0,"#include ""BiDirectionalRpc.hpp""

#include ""TimeHandler.hpp""

namespace codefs {
BiDirectionalRpc::BiDirectionalRpc()
    : onBarrier(0),
      onId(0),
      flaky(false),
      timeOffsetController(1.0, 1000000, -1000000, 0.6, 1.2, 1.0) {}

BiDirectionalRpc::~BiDirectionalRpc() {}

void BiDirectionalRpc::shutdown() {}

void BiDirectionalRpc::heartbeat() {
  lock_guard<recursive_mutex> guard(mutex);
  // TODO: If the outgoingReplies/requests is high, and we have recently
  // received data, flush a lot of data out
  VLOG(1) << ""BEAT: "" << int64_t(this);
  if (!outgoingReplies.empty() || !outgoingRequests.empty()) {
    resendRandomOutgoingMessage();
  } else {
    VLOG(1) << ""SENDING HEARTBEAT"";
    string s = ""0"";
    s[0] = HEARTBEAT;
    send(s);
  }
}

void BiDirectionalRpc::resendRandomOutgoingMessage() {
  if (!outgoingReplies.empty() &&
      (outgoingRequests.empty() || rand() % 2 == 0)) {
    // Re-send a random reply
    DRAW_FROM_UNORDERED(it, outgoingReplies);
    sendReply(it->first, it->second);
  } else if (!outgoingRequests.empty()) {
    // Re-send a random request
    DRAW_FROM_UNORDERED(it, outgoingRequests);
    sendRequest(it->first, it->second);
  } else {
  }
}

void BiDirectionalRpc::receive(const string& message) {
  lock_guard<recursive_mutex> guard(mutex);
  VLOG(1) << ""Receiving message with length "" << message.length();
  MessageReader reader;
  reader.load(message);
  RpcHeader header = (RpcHeader)reader.readPrimitive<unsigned char>();
  if (flaky && rand() % 2 == 0) {
    // Pretend we never got the message
    VLOG(1) << ""FLAKE"";
  } else {
    if (header != HEARTBEAT) {
      VLOG(1) << ""GOT PACKET WITH HEADER "" << header;
    }
    switch (header) {
      case HEARTBEAT: {
        // MultiEndpointHandler deals with keepalive
      } break;
      case REQUEST: {
        while (reader.sizeRemaining()) {
          RpcId rpcId = reader.readClass<RpcId>();
          string payload = reader.readPrimitive<string>();
          handleRequest(rpcId, payload);
        }
      } break;
      case REPLY: {
        while (reader.sizeRemaining()) {
          RpcId uid = reader.readClass<RpcId>();
          int64_t requestReceiptTime = reader.readPrimitive<int64_t>();
          int64_t replySendTime = reader.readPrimitive<int64_t>();
          auto requestSendTimeIt = requestSendTimeMap.find(uid);
          if (requestSendTimeIt != requestSendTimeMap.end()) {
            int64_t requestSendTime = requestSendTimeIt->second;
            requestSendTimeMap.erase(requestSendTimeIt);
            int64_t replyRecieveTime = TimeHandler::currentTimeMicros();
            updateDrift(requestSendTime, requestReceiptTime, replySendTime,
                        replyRecieveTime);
          }
          string payload = reader.readPrimitive<string>();
          handleReply(uid, payload);
        }
      } break;
      case ACKNOWLEDGE: {
        RpcId uid = reader.readClass<RpcId>();
        VLOG(1) << ""ACK UID "" << uid.str();
        for (auto it = outgoingReplies.begin(); it != outgoingReplies.end();
             it++) {
          VLOG(1) << ""REPLY UID "" << it->first.str();
          if (it->first == uid) {
            if (requestRecieveTimeMap.find(it->first) ==
                requestRecieveTimeMap.end()) {
              LOG(INFO) << requestRecieveTimeMap.size();
              for (const auto& it2 : requestRecieveTimeMap) {
                LOG(INFO) << ""XXXX: "" << it2.first.str();
              }
              LOGFATAL << ""Tried to remove a request receive time that we ""
                          ""didn't have: ""
                       << it->first.str();
            }
            requestRecieveTimeMap.erase(it->first);
            outgoingReplies.erase(it);
            break;
          }
        }
      } break;
      default: {
        LOGFATAL << ""Got invalid header: "" << header << "" in message ""
                 << message;
      }
    }
  }
}

void BiDirectionalRpc::handleRequest(const RpcId& rpcId,
                                     const string& payload) {
  VLOG(1) << ""GOT REQUEST: "" << rpcId.str();

  bool skip = (incomingRequests.find(rpcId) != incomingRequests.end());
  if (!skip) {
    for (const auto& it : outgoingReplies) {
      if (it.first == rpcId) {
        // We already processed this request.  Send the reply again
        skip = true;
        sendReply(it.first, it.second);
        break;
      }
    }
  }
  if (!skip) {
    addIncomingRequest(IdPayload(rpcId, payload));
  }
}

void BiDirectionalRpc::handleReply(const RpcId& rpcId, const string& payload) {
  bool skip = false;
  if (incomingReplies.find(rpcId) != incomingReplies.end()) {
    // We already received this reply.  Send acknowledge again and skip.
    sendAcknowledge(rpcId);
    skip = true;
  }
  if (!skip) {
    // Stop sending the request once you get the reply
    bool deletedRequest = false;
    for (auto it = outgoingRequests.begin(); it != outgoingRequests.end();
         it++) {
      if (it->first == rpcId) {
        outgoingRequests.erase(it);
        deletedRequest = true;
        tryToSendBarrier();
        break;
      }
    }
    if (deletedRequest) {
      auto it = oneWayRequests.find(rpcId);
      if (it != oneWayRequests.end()) {
        // Remove this from the set of one way requests and don't bother
        // adding a reply.
        oneWayRequests.erase(it);
      } else {
        // Add a reply to be processed
        addIncomingReply(rpcId, payload);
      }
      sendAcknowledge(rpcId);
    } else {
      // We must have processed both this request and reply.  Send the
      // acknowledge again.
      sendAcknowledge(rpcId);
    }
  }
}

RpcId BiDirectionalRpc::request(const string& payload) {
  auto fullUuid = sole::uuid4();
  auto uuid = RpcId(onBarrier, fullUuid.cd);
  auto idPayload = IdPayload(uuid, payload);
  requestWithId(idPayload);
  return uuid;
}

void BiDirectionalRpc::requestNoReply(const string& payload) {
  lock_guard<recursive_mutex> guard(mutex);
  auto fullUuid = sole::uuid4();
  auto uuid = RpcId(onBarrier, fullUuid.cd);
  oneWayRequests.insert(uuid);
  auto idPayload = IdPayload(uuid, payload);
  requestWithId(idPayload);
}

void BiDirectionalRpc::requestWithId(const IdPayload& idPayload) {
  lock_guard<recursive_mutex> guard(mutex);
  if (outgoingRequests.empty() ||
      outgoingRequests.begin()->first.barrier == onBarrier) {
    // We can send the request immediately
    outgoingRequests[idPayload.id] = idPayload.payload;
    requestSendTimeMap[idPayload.id] = TimeHandler::currentTimeMicros();
    sendRequest(idPayload.id, idPayload.payload);
  } else {
    // We have to wait for existing requests from an older barrier
    delayedRequests[idPayload.id] = idPayload.payload;
  }
}

void BiDirectionalRpc::reply(const RpcId& rpcId, const string& payload) {
  lock_guard<recursive_mutex> guard(mutex);
  incomingRequests.erase(incomingRequests.find(rpcId));
  outgoingReplies[rpcId] = payload;
  sendReply(rpcId, payload);
}

void BiDirectionalRpc::tryToSendBarrier() {
  if (delayedRequests.empty()) {
    // Nothing to send
    return;
  }
  if (outgoingRequests.empty()) {
    // There are no outgoing requests, we can send the next barrier
    int64_t lowestBarrier = delayedRequests.begin()->first.barrier;
    for (const auto& it : delayedRequests) {
      lowestBarrier = min(lowestBarrier, it.first.barrier);
    }

    for (auto it = delayedRequests.begin(); it != delayedRequests.end();) {
      if (it->first.barrier == lowestBarrier) {
        outgoingRequests[it->first] = it->second;
        requestSendTimeMap[it->first] = TimeHandler::currentTimeMicros();
        sendRequest(it->first, it->second);
        it = delayedRequests.erase(it);
      } else {
        it++;
      }
    }
  }
}

void BiDirectionalRpc::sendRequest(const RpcId& id, const string& payload) {
  VLOG(1) << ""SENDING REQUEST: "" << id.str();
  MessageWriter writer;
  writer.start();
  set<RpcId> rpcsSent;

  rpcsSent.insert(id);
  writer.writePrimitive<unsigned char>(REQUEST);
  writer.writeClass<RpcId>(id);
  writer.writePrimitive<string>(payload);
  // Try to attach more requests to this packet
  int i = 0;
  while (!outgoingRequests.empty() &&
         rpcsSent.size() < outgoingRequests.size()) {
    DRAW_FROM_UNORDERED(it, outgoingRequests);
    if (rpcsSent.find(it->first) != rpcsSent.end()) {
      // Drew an rpc that's already in the packet.  Just bail for now, maybe in
      // the future do something more clever.
      break;
    }
    int size = sizeof(RpcId) + it->second.length();
    if (size + writer.size() > 400) {
      // Too big
      break;
    }
    i++;
    rpcsSent.insert(it->first);
    writer.writeClass<RpcId>(it->first);
    writer.writePrimitive<string>(it->second);
  }
  VLOG(1) << ""Attached "" << i << "" extra packets"";
  send(writer.finish());
}

void BiDirectionalRpc::sendReply(const RpcId& id, const string& payload) {
  lock_guard<recursive_mutex> guard(mutex);
  VLOG(1) << ""SENDING REPLY: "" << id.str();
  set<RpcId> rpcsSent;

  rpcsSent.insert(id);
  MessageWriter writer;
  writer.start();
  writer.writePrimitive<unsigned char>(REPLY);
  writer.writeClass<RpcId>(id);
  auto receiveTimeIt = requestRecieveTimeMap.find(id);
  if (receiveTimeIt == requestRecieveTimeMap.end()) {
    LOGFATAL << ""Got a request with no receive time: "" << id.str() << "" ""
             << requestRecieveTimeMap.size();
  }
  writer.writePrimitive<int64_t>(receiveTimeIt->second);
  writer.writePrimitive<int64_t>(TimeHandler::currentTimeMicros());
  writer.writePrimitive<string>(payload);
  // Try to attach more replies to this packet
  int i = 0;
  while (!outgoingReplies.empty() && rpcsSent.size() < outgoingReplies.size()) {
    DRAW_FROM_UNORDERED(it, outgoingReplies);
    if (rpcsSent.find(it->first) != rpcsSent.end()) {
      // Drew an rpc that's already in the packet.  Just bail for now, maybe in
      // the future do something more clever.
      break;
    }
    int size = sizeof(RpcId) + it->second.length();
    if (size + writer.size() > 400) {
      // Too big
      break;
    }
    i++;
    rpcsSent.insert(it->first);
    writer.writeClass<RpcId>(it->first);
    receiveTimeIt = requestRecieveTimeMap.find(it->first);
    if (receiveTimeIt == requestRecieveTimeMap.end()) {
      LOGFATAL << ""Got a request with no receive time"";
    }
    writer.writePrimitive<int64_t>(receiveTimeIt->second);
    writer.writePrimitive<int64_t>(TimeHandler::currentTimeMicros());
    writer.writePrimitive<string>(it->second);
  }
  VLOG(1) << ""Attached "" << i << "" extra packets"";
  send(writer.finish());
}

void BiDirectionalRpc::sendAcknowledge(const RpcId& uid) {
  MessageWriter writer;
  writer.start();
  writer.writePrimitive<unsigned char>(ACKNOWLEDGE);
  writer.writeClass<RpcId>(uid);
  send(writer.finish());
}

void BiDirectionalRpc::addIncomingRequest(const IdPayload& idPayload) {
  lock_guard<recursive_mutex> guard(mutex);
  if (requestRecieveTimeMap.find(idPayload.id) != requestRecieveTimeMap.end()) {
    LOGFATAL << ""Already created receive time for id: "" << idPayload.id.str();
  }
  requestRecieveTimeMap[idPayload.id] = TimeHandler::currentTimeMicros();
  incomingRequests.insert(make_pair(idPayload.id, idPayload.payload));
}

void BiDirectionalRpc::updateDrift(int64_t requestSendTime,
                                   int64_t requestReceiptTime,
                                   int64_t replySendTime,
                                   int64_t replyRecieveTime) {
  int64_t timeOffset = ((requestReceiptTime - requestSendTime) +
                        (replySendTime - replyRecieveTime)) /
                       2;
  int64_t  [MASK]  = (replyRecieveTime - requestSendTime) -
                 (replySendTime - requestReceiptTime);
  networkStatsQueue.push_back({timeOffset,  [MASK] });
  VLOG(2) << ""Time Sync Info: "" << timeOffset << "" "" <<  [MASK]  << "" ""
          << (replyRecieveTime - requestSendTime) << "" ""
          << (replySendTime - requestReceiptTime);
  if (networkStatsQueue.size() >= 100) {
    LOG(INFO) << ""Time Sync Info: "" << timeOffset << "" "" <<  [MASK]  << "" ""
              << (replyRecieveTime - requestSendTime) << "" ""
              << (replySendTime - requestReceiptTime);
    int64_t sumShift = 0;
    int64_t shiftCount = 0;
    for (int i = 0; i < networkStatsQueue.size(); i++) {
      sumShift += networkStatsQueue.at(i).offset;
      shiftCount++;
    }
    if (shiftCount) {
      VLOG(2) << ""New shift: "" << (sumShift / shiftCount);
      auto shift =
          std::chrono::microseconds{sumShift / shiftCount / int64_t(5)};
      VLOG(2) << ""TIME CHANGE: "" << TimeHandler::currentTimeMicros();
      TimeHandler::initialTime -= shift;
      VLOG(2) << ""TIME CHANGE: "" << TimeHandler::currentTimeMicros();
    }
  }
  // auto shift = std::chrono::microseconds{
  //     int64_t(timeOffsetController.calculate(0, double(timeOffset)))};
  // TimeHandler::initialTime += shift;
  networkStatsQueue.clear();
}

}  // namespace codefs
",ping
1,"#ifndef CATCH_UP_ENGINE_SRC_INCLUDE_COMPONENT_BASE_H
#define CATCH_UP_ENGINE_SRC_INCLUDE_COMPONENT_BASE_H

#include <entt\entt.hpp>

#include <string>

#include ""uuid.h""
#include ""component.h""

namespace Engine
{
    class CollisionListener;
    class Timestep;
    class GameObject;
    class Scene
    {
    public:
        static Scene* getInstance() {
            static Scene  [MASK] ;
            return & [MASK] ;
        }
        Scene(const Scene&) = delete;
        Scene(const Scene&&) = delete;

        void createGameObject(GameObject& object);
        void createGameObjectWithUUID(UUID uuid, GameObject& object);
        void destroyGameObject();

        GameObject getGameObjectByUUID(UUID uuid);

        void start();
        void update();

    private:
        Scene() {}
        ~Scene() {}

        void renderScene();
        void physicsStart();
        void onPhysicsStop();

        int m_step_frames = 60;

        std::list<UUID> m_pending_deletion_list;
        std::list<GameObject*> m_game_object_list;

        entt::registry m_game_objects;
        std::unordered_map<UUID, entt::entity> m_entity_map;

        friend GameObject;
    };
}

#endif // !CATCH_UP_ENGINE_SRC_INCLUDE_COMPONENT_BASE_H",instance
2,"
#ifndef _PYODBCSQLWCHAR_H
#define _PYODBCSQLWCHAR_H

typedef unsigned short ODBCCHAR;
// I'm not sure why, but unixODBC seems to define SQLWCHAR as wchar_t even with
// the size is incorrect.  So we might get 4-byte SQLWCHAR on 64-bit Linux even
// though it requires 2-byte characters.  We have to define our own type to
// operate on.

enum {
    ODBCCHAR_SIZE = 2
};

class SQLWChar
{
private:
    SQLWChar(const SQLWChar& other) {}
    void operator=(const SQLWChar& other) {}

    Object tmp;
    // If the passed in string/unicode object needed to be encoded, this holds
    // the bytes object it was encoded into.  If set, sz points into this
    // object.

    const char* sz;
    // The value of the string.  If this is zero a Python error occurred in the
    // constructor and nothing further should be one with this.

    Py_ssize_t cb;
    // The length of `sz` in *bytes*.

    SQLSMALLINT ctype;
    // The target C type, either SQL_C_CHAR or SQL_C_WCHAR.

    void init(PyObject* value, SQLSMALLINT  [MASK] , PyObject* encoding, const char* szDefaultEncoding)
    {
        sz = 0;
        cb = 0;
        ctype =  [MASK] ;
        I(ctype == SQL_C_CHAR || ctype == SQL_C_WCHAR);
        const char* szEncoding = szDefaultEncoding;

        if (strcmp(szEncoding, ""raw"") == 0)
        {
            // If `value` is not a bytes object, PyBytes_AsString below will return 0 which we
            // handle later.  (Do not use AS_STRING which does no error checking.)
            tmp = value;
            sz  = PyBytes_AsString(tmp);
            cb = PyBytes_Size(tmp);
        }
        else
        {
            Object tmpEncoding;
            if (encoding)
            {
                tmpEncoding = PyCodec_Encode(encoding, ""utf-8"", ""strict"");
                if (tmpEncoding)
                    szEncoding = PyBytes_AsString(tmpEncoding);
            }

            if (szEncoding)
            {
                tmp = PyCodec_Encode(value, szEncoding, ""strict"");
                if (tmp)
                {
                    sz  = PyBytes_AsString(tmp);
                    cb = PyBytes_Size(tmp);
                }
            }
        }
    }

public:
    SQLWChar(PyObject* value, SQLSMALLINT ctype, const char* szEncoding)
    {
        init(value, ctype, 0, szEncoding);
    }
    SQLWChar(PyObject* value, SQLSMALLINT ctype, PyObject* encoding, const char* szDefaultEncoding)
    {
        init(value, ctype, encoding, szDefaultEncoding);
    }

    operator bool() const { return sz != 0; }

    const char* value() const { return sz; }

    Py_ssize_t bytelen() const { return cb; }
    Py_ssize_t charlen() const { return cb / (ctype == SQL_C_WCHAR ? ODBCCHAR_SIZE : 1); }
};

#endif // _PYODBCSQLWCHAR_H
",_ctype
3,"/**
 * This Sketch reads a Resistor Ladder to determine a pitch to send
 * to the Piezo unit. It's designed to be used like an Electronic
 * Keyboard =)
 * 
 */

const int NOTES[] =  { 262, 294, 330, 349 };

void setup() 
{
  Serial.begin(9600);

}

void loop() 
{
  int keyValue = analogRead(A0);

  makeSoundForKey(keyValue);

  Serial.println(keyValue);
  sleep(30);

}

void makeSoundForKey(int value)
{
  if (isC(value))
  {
    soundC();
  }
  else if (isD(value))
  {
    soundD();
  }
  else if (isE(value))
  {
    soundE();
  }
  else if (isF(value))
  {
    soundF();
  }
  else
  {
    makeNoSound();
  }
}


boolean isC(int value)
{
  return value == 1023;
}

boolean isD(int value)
{
  return value > 995 && value < 1005;
}

boolean isE(int value)
{
  return value > 495 && value < 510;
}

boolean isF(int value)
{
  return value > 5 && value < 15;
}

void soundC()
{
  tone(9, NOTES[0]);
}

void soundD()
{
  tone(9, NOTES[1]);
}

void soundE()
{
  tone(9, NOTES[2]);
}
void soundF()
{
  tone(9, NOTES[3]);
}

void makeNoSound()
{
  noTone(9);
}

void sleep(long  [MASK] )
{
  delay( [MASK] );
}

",amount
4,"//*****************************************************************************
// Copyright 2020-2022 Intel Corporation
//
// 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 <assert.h>

#include <chrono>
#include <iostream>
#include <map>
#include <mutex>
#include <string>
#include <thread>
#include <vector>

#include ""customloaderinterface.hpp""
#include ""ovsa_model_instance.hpp""
#include ""rapidjson/document.h""

using namespace ovms;

extern ""C"" {
#define MAX_NAME_SIZE 256
typedef struct ovsa_model_files {
    char model_file_name[MAX_NAME_SIZE];
    char* model_file_data;
    int model_file_length;
    struct ovsa_model_files* next;
} ovsa_model_files_t;

ovsa_status_t ovsa_license_check_module(const char* keystore, const char* controlled_access_model,
                                        const char* customer_license,
                                        ovsa_model_files_t** decrypted_files);
ovsa_status_t ovsa_crypto_init();
void ovsa_crypto_deinit();
void ovsa_safe_free_model_file_list(ovsa_model_files_t** listhead);
};

// Time in seconds at which model status will be checked
#define VALIDITY_CHECK_INTERVAL_MAX 1440  // 24hrs
#define VALIDITY_CHECK_INTERVAL_MIN 1     // 1min

#if OVMS_LICCHECK_MINS < VALIDITY_CHECK_INTERVAL_MIN
#define VALIDITY_CHECK_INTERVAL (VALIDITY_CHECK_INTERVAL_MIN * 60 * 1000)  // 1min minimum value
#elif OVMS_LICCHECK_MINS > VALIDITY_CHECK_INTERVAL_MAX
#define VALIDITY_CHECK_INTERVAL (VALIDITY_CHECK_INTERVAL_MAX * 60 * 1000)  // 24hrs maximum value
#else
#define VALIDITY_CHECK_INTERVAL (OVMS_LICCHECK_MINS * 60 * 1000)
#endif

typedef std::pair<std::string, int> map_key_t;
typedef std::pair<std::string, uint8_t> model_file_t;
/*
 * This class implements am example custom model loader for OVMS.
 * It derives the implementation from base class CustomLoaderInterface
 * defined in ovms. The purpose this example is to demonstrate the
 * usage of various APIs defined in base class, parse loader specific
 * parameters from the config file.
 *
 * It reads the model files and returns the buffers to be loaded by the
 * model server.
 *
 * Also, based on the contents on <model>.status file, it black lists the model
 * or removes the model from blacklisting. During the periodic check on model
 * loader will unload/reload model based on blacklist.
 */

class OvsaCustomLoader : public CustomLoaderInterface {
   private:
    std::map<map_key_t, std::shared_ptr<OvsaModelInstance>> model_map;
    std::mutex critical_ops;
    std::mutex models_watched_mutex;

   protected:
    CustomLoaderStatus ovsa_json_extract_input_params(const std::string& basePath,
                                                      const int version,
                                                      const std::string& loaderOptions,
                                                      std::string& loaderName, std::string& ksFile,
                                                      std::string& licFile, std::string& datFile);

   public:
    OvsaCustomLoader();
    ~OvsaCustomLoader();

    // Virtual functions of the base class defined here
    CustomLoaderStatus loaderInit(const std::string& loader_path);
    CustomLoaderStatus loaderDeInit();
    CustomLoaderStatus unloadModel(const std::string& modelName, int version);
    CustomLoaderStatus loadModel(const std::string& modelName, const std::string& basePath,
                                 const int version, const std::string& loaderOptions,
                                 std::vector<uint8_t>& modelBuffer, std::vector<uint8_t>& weights);
    CustomLoaderStatus getModelBlacklistStatus(const std::string& modelName, int version);
    CustomLoaderStatus retireModel(const std::string& modelName);
};

extern ""C"" CustomLoaderInterface* createCustomLoader() {
    return new OvsaCustomLoader();
}

OvsaCustomLoader::OvsaCustomLoader() {
    std::cout << ""OvsaCustomLoader: Instance of Custom SampleLoader created"" << std::endl;
}

OvsaCustomLoader::~OvsaCustomLoader() {
    std::cout << ""OvsaCustomLoader: Instance of Custom SampleLoader deleted"" << std::endl;
    ovsa_crypto_deinit();
}

CustomLoaderStatus OvsaCustomLoader::loaderInit(const std::string& loader_path) {
    std::cout << ""OvsaCustomLoader: Custom loaderInit"" << loader_path << std::endl;
    ovsa_status_t ret = ovsa_crypto_init();
    if (ret < OVSA_OK) {
        OVSA_DBG(DBG_E, ""OvsaCustomLoader: Crypto init failed with code %d\n"", ret);
        return CustomLoaderStatus::MODEL_LOAD_ERROR;
    }
    return CustomLoaderStatus::OK;
}

CustomLoaderStatus OvsaCustomLoader::ovsa_json_extract_input_params(
    const std::string& basePath, const int version, const std::string& loaderOptions,
    std::string& loaderName, std::string& ksFile, std::string& licFile, std::string& datFile) {
    CustomLoaderStatus ret = CustomLoaderStatus::OK;
    rapidjson::Document doc;

    if (basePath.empty() | loaderOptions.empty()) {
        std::cout << ""OvsaCustomLoader: Error invalid input parameters to loadModel"" << std::endl;
        return CustomLoaderStatus::MODEL_LOAD_ERROR;
    }

    std::string fullPath = basePath + ""/"" + std::to_string(version);

    // parse jason input string
    if (doc.Parse(loaderOptions.c_str()).HasParseError()) {
        return CustomLoaderStatus::MODEL_LOAD_ERROR;
    }

    for (rapidjson::Value::ConstMemberIterator itr = doc.MemberBegin(); itr != doc.MemberEnd();
         ++itr)
        printf(""Type of member %s is %s\n"", itr->name.GetString(), itr->value.GetString());

    if (doc.HasMember(""loader_name"")) {
        std::string lname = doc[""loader_name""].GetString();
        loaderName        = fullPath + ""/"" + lname;
        std::cout << ""OvsaCustomLoader: \nloader_name:"" << loaderName << std::endl;
    }

    if (doc.HasMember(""controlled_access_file"")) {
        std::string controlled_access_file = doc[""controlled_access_file""].GetString();
        datFile                            = fullPath + ""/"" + controlled_access_file + "".dat"";
        std::cout << ""datFile:"" << datFile << std::endl;

        licFile = fullPath + ""/"" + controlled_access_file + "".lic"";
        std::cout << ""licFile:"" << licFile << std::endl;
    }

    if (doc.HasMember(""keystore"")) {
        std::string ks = doc[""keystore""].GetString();
        ksFile         = ks;
        std::cout << ""keystore:"" << ksFile << std::endl;
    }

    return ret;
}

/*
 * From the custom loader options extract the model file name and other needed information and
 * load the model and optional bin file into buffers and return
 */
CustomLoaderStatus OvsaCustomLoader::loadModel(const std::string& modelName,
                                               const std::string& basePath, const int version,
                                               const std::string& loaderOptions,
                                               std::vector<uint8_t>& modelBuffer,
                                               std::vector<uint8_t>& weights) {
    std::cout << ""OvsaCustomLoader: Custom loadModel"" << std::endl;
    std::string type;
    std::string loaderName;
    std::string ksFile;
    std::string licFile;
    std::string datFile;
    ovsa_model_files_t* decrypted_files = NULL;
    CustomLoaderStatus retStatus        = CustomLoaderStatus::MODEL_LOAD_ERROR;

    if (modelName.empty() || basePath.empty() || loaderOptions.empty()) {
        std::cout << ""OvsaCustomLoader: Error invalid input parameters to loadModel"" << std::endl;
        return CustomLoaderStatus::MODEL_LOAD_ERROR;
    }

    CustomLoaderStatus st = ovsa_json_extract_input_params(basePath, version, loaderOptions,
                                                           loaderName, ksFile, licFile, datFile);
    if (st != CustomLoaderStatus::OK || ksFile.empty() || licFile.empty() || datFile.empty()) {
        std::cout << ""OvsaCustomLoader: Error invalid custom loader options"" << std::endl;
        return CustomLoaderStatus::MODEL_LOAD_ERROR;
    }

    std::unique_lock<std::mutex> lockGuard(critical_ops);
    ovsa_status_t  [MASK]  = ovsa_license_check_module(ksFile.c_str(), datFile.c_str(), licFile.c_str(),
                                                   &decrypted_files);
    if ( [MASK]  != OVSA_OK) {
        if ( [MASK]  == OVSA_LICENSE_SERVER_CONNECT_FAIL) {
            OVSA_DBG(DBG_E,
                     ""OvsaCustomLoader: Error LICENSE CHECK SERVER CONNECT FAILED""
                     "" with %d\n"",
                      [MASK] );
        } else if ( [MASK]  == OVSA_LICENSE_CHECK_FAIL) {
            OVSA_DBG(DBG_E, ""OvsaCustomLoader: Error LICENSE CHECK FAILED with %d\n"",  [MASK] );
        } else {
            OVSA_DBG(DBG_E, ""OvsaCustomLoader: Error ovsa_license_check_module with code %d\n"",
                      [MASK] );
        }
        ovsa_safe_free_model_file_list(&decrypted_files);
        return CustomLoaderStatus::MODEL_LOAD_ERROR;
    }
    lockGuard.unlock();

    std::vector<std::pair<std::string, uint8_t>> modelFileVec;
    ovsa_model_files_t* head = decrypted_files;
    bool file_type_ir        = false;

    while (head != NULL) {
        // model_file_t file_data =  std::make_pair(head->model_file_name,head->model_file_data);
        // modelFileVec.pushback(file_data);
        //

        std::string filename(head->model_file_name);
        size_t found = filename.find("".xml"");
        if (found != std::string::npos) {
            std::cout << ""OvsaCustomLoader: "" << head->model_file_name << std::endl;
            std::vector<uint8_t> mdl(&head->model_file_data[0],
                                     &head->model_file_data[head->model_file_length]);
            modelBuffer.insert(modelBuffer.end(), mdl.begin(), mdl.end());
            if (file_type_ir) {
                retStatus = CustomLoaderStatus::MODEL_TYPE_IR;
            } else {
                file_type_ir = true;
            }
        }

        found = filename.find("".bin"");
        if (found != std::string::npos) {
            std::cout << ""OvsaCustomLoader: "" << head->model_file_name << std::endl;
            std::vector<uint8_t> wts(&head->model_file_data[0],
                                     &head->model_file_data[head->model_file_length]);
            weights.insert(weights.end(), wts.begin(), wts.end());
            if (file_type_ir) {
                retStatus = CustomLoaderStatus::MODEL_TYPE_IR;
            } else {
                file_type_ir = true;
            }
        }

        found = filename.find("".blob"");
        if (found != std::string::npos) {
            std::cout << ""OvsaCustomLoader: "" << head->model_file_name << std::endl;
            std::vector<uint8_t> mdl(&head->model_file_data[0],
                                     &head->model_file_data[head->model_file_length]);
            modelBuffer.insert(modelBuffer.end(), mdl.begin(), mdl.end());
            retStatus = CustomLoaderStatus::MODEL_TYPE_BLOB;
        }

        found = filename.find("".onnx"");
        if (found != std::string::npos) {
            std::cout << ""OvsaCustomLoader: "" << head->model_file_name << std::endl;
            std::vector<uint8_t> mdl(&head->model_file_data[0],
                                     &head->model_file_data[head->model_file_length]);
            modelBuffer.insert(modelBuffer.end(), mdl.begin(), mdl.end());
            retStatus = CustomLoaderStatus::MODEL_TYPE_ONNX;
        }

        head = head->next;
    }
    if (retStatus != CustomLoaderStatus::MODEL_LOAD_ERROR) {
        std::lock_guard<std::mutex> guard(models_watched_mutex);
        map_key_t key  = std::make_pair(modelName, version);
        model_map[key] = std::make_shared<OvsaModelInstance>(modelName, ksFile, licFile, datFile,
                                                             false, version, ref(critical_ops));
        auto itr       = model_map.find(key);
        if (itr != model_map.end()) {
            itr->second->startWatcher(VALIDITY_CHECK_INTERVAL);
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    }
    ovsa_safe_free_model_file_list(&decrypted_files);
    return retStatus;
}

// Retire the model
CustomLoaderStatus OvsaCustomLoader::retireModel(const std::string& modelName) {
    std::vector<map_key_t> toDelete;
    std::lock_guard<std::mutex> guard(models_watched_mutex);

    for (auto it : model_map) {
        if ((it.first).first == modelName) {
            toDelete.push_back(it.first);
        }
    }

    for (auto itr : toDelete) {
        model_map.erase(itr);
    }
    return CustomLoaderStatus::OK;
}

// Unload model from loaded models list.
CustomLoaderStatus OvsaCustomLoader::unloadModel(const std::string& modelName, const int version) {
    std::cout << ""OvsaCustomLoader: Custom unloadModel"" << std::endl;

    map_key_t toFind = std::make_pair(modelName, version);
    std::lock_guard<std::mutex> guard(models_watched_mutex);
    auto it = model_map.find(toFind);

    if (it == model_map.end()) {
        std::cout << modelName << "" is not loaded"" << std::endl;
    } else {
        it->second->releaseResources();
        model_map.erase(it);
    }
    return CustomLoaderStatus::OK;
}

CustomLoaderStatus OvsaCustomLoader::loaderDeInit() {
    std::cout << ""OvsaCustomLoader: Custom loaderDeInit"" << std::endl;
    ovsa_crypto_deinit();
    return CustomLoaderStatus::OK;
}

CustomLoaderStatus OvsaCustomLoader::getModelBlacklistStatus(const std::string& modelName,
                                                             const int version) {
    OVSA_DBG(DBG_D, ""OvsaCustomLoader: Custom getModelBlacklistStatus\n"");

    map_key_t toFind = std::make_pair(modelName, version);
    auto it          = model_map.find(toFind);
    if (it == model_map.end()) {
        OVSA_DBG(DBG_D, ""OvsaCustomLoader: Model:%s Version:%d not loaded\n"",
			(char*)modelName.c_str(), version);
        return CustomLoaderStatus::OK;
    }

    bool status = it->second->getBlackListStatus();
    if (status)
        return CustomLoaderStatus::MODEL_BLACKLISTED;
    else
        return CustomLoaderStatus::OK;
}
",rets
5,"#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

//    freopen("".in"", ""r"", stdin);
//    freopen("".out"", ""w"", stdout);

    int  [MASK] ;
    ll numDays;
    cin >>  [MASK]  >> numDays;
    vector<pair<ll, int>> deliveries;
    for (int i = 0; i <  [MASK] ; ++i) {
        ll day;
        int amt;
        cin >> day >> amt;
        deliveries.emplace_back(day, amt);
    }

    // first delivery day
    ll numEaten = 1;
    ll numLeft = deliveries[0].second - 1;
    ll prevDeliveryDay = deliveries[0].first;
    ll currDeliveryDay;
    for (int i = 1; i <  [MASK] ; ++i) {
        currDeliveryDay = deliveries[i].first;
        ll daysInBetween = currDeliveryDay - prevDeliveryDay - 1;
        if (numLeft > daysInBetween) {
            numEaten += daysInBetween;
            numLeft -= daysInBetween;
        } else {
            numEaten += numLeft;
            numLeft = 0;
        }
        numLeft += deliveries[i].second;
        ++numEaten;
        --numLeft;
        prevDeliveryDay = currDeliveryDay;
    }

    ll daysToEnd = numDays - prevDeliveryDay;
    if (daysToEnd > 0) {
        if (numLeft > daysToEnd) {
            numEaten += daysToEnd;
        } else {
            numEaten += numLeft;
        }
    }

    cout << numEaten;

    return 0;
}
",numDeliveries
6,"#include ""rclcpp/rclcpp.hpp""
#include ""sensor_msgs/msg/laser_scan.hpp""

class LidarFilterNode : public rclcpp::Node
{
public:
    LidarFilterNode() : Node(""lidar_filter_node"")
    {
        subscription_ = this->create_subscription<sensor_msgs::msg::LaserScan>(
            ""/scan"", 10, std::bind(&LidarFilterNode::listener_callback, this, std::placeholders::_1));
        publisher_ = this->create_publisher<sensor_msgs::msg::LaserScan>(""/filtered_scan"", 10);
    }

private:
    void listener_callback(const sensor_msgs::msg::LaserScan::SharedPtr msg)
    {
        auto filtered_scan = std::make_shared<sensor_msgs::msg::LaserScan>(*msg);
        filtered_scan->ranges.clear();

        double angle_min = -60.0 * M_PI / 180.0;  // -60 degrees in radians
        double angle_max = 60.0 * M_PI / 180.0;   // 60 degrees in radians
        double current_angle = msg->angle_min;

        for (const auto &range : msg->ranges)
        {
            if (current_angle >= angle_min && current_angle <= angle_max)
            {
                filtered_scan->ranges.push_back(range);
            }
            else
            {
                filtered_scan->ranges.push_back(std::numeric_limits<float>::infinity());
            }
            current_angle += msg->angle_increment;
        }

        publisher_->publish(*filtered_scan);
    }

    rclcpp::Subscription<sensor_msgs::msg::LaserScan>::SharedPtr subscription_;
    rclcpp::Publisher<sensor_msgs::msg::LaserScan>::SharedPtr publisher_;
};

int main(int  [MASK] , char *argv[])
{
    rclcpp::init( [MASK] , argv);
    rclcpp::spin(std::make_shared<LidarFilterNode>());
    rclcpp::shutdown();
    return 0;
}
",argc
7,"// Copyright (c) 2025 <NAME>
//
// 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 ""product_of_exponentials/product_of_exponentials.hpp""

int main(int  [MASK] , char * argv[])
{
  rclcpp::init( [MASK] , argv);
  rclcpp::executors::MultiThreadedExecutor exec;

  const auto product_of_exponentials =
    std::make_shared<product_of_exponentials::POE>(rclcpp::NodeOptions());
  exec.add_node(product_of_exponentials);

  exec.spin();

  rclcpp::shutdown();
}
",argc
8,"#include<iostream>
using namespace std;

struct Patient{
	int patientID, hieght, wieght, visionNo;
	string testStatus;
	Patient* next;
	int data;

	Patient(int p, int h, int w, int v, string t, Patient* n, int d){
		patientID = p;
		hieght = h;
		wieght = w;
		visionNo = v;
		testStatus = t;
		next = n;
		data = d;
	}
};

class PhysicalTest{
	Patient* front = NULL;
	Patient* rear = NULL;

	public:
	void AddPatient(int patientID, int hieght, int wieght, int visionNo, string testStatus, int data){
		Patient* newPatient = new Patient(patientID, hieght, wieght, visionNo, testStatus, NULL, data);
		if (rear == NULL){
			front = rear = newPatient;
		} else{
			rear->next = newPatient;
			rear = newPatient;
		}
	}

	void dischargePatient(){
		if (front == NULL){
			cout<<""Empty queue"";
			return;
		}
		Patient* temp = front;
		front = front->next;
		if (front == NULL){
			rear = NULL;
		}
		delete temp;
	}
	
	void removeSendPatient(){
		if (front != NULL || front->next== NULL){
			cout<<"" Patient 2nd in the line has left the line\n"";
		}
	}

	void DisplayPatient(){
		Patient* temp = front;
		while (temp != NULL){
			cout<<""Patient id: ""<<temp->patientID<<"" "";
			cout<<"" Patient Hieght: ""<<temp->hieght<<"" Patient Weight: ""<<temp->wieght<<"" Patient eyes sight vision number: ""<<temp->visionNo;
			cout<<"" Patient test status: ""<<temp->testStatus;
			temp = temp->next;

		}
	}
};

int main(){
	PhysicalTest  [MASK] ;
	 [MASK] .AddPatient(39849, 175, 65, 1, "" done"", 2);
	 [MASK] .AddPatient(39850, 180, 65, 2, "" pending"", 2);
	 [MASK] .AddPatient(39851, 171, 65, 1, "" pending"", 2);
	 [MASK] .AddPatient(39852, 160, 65, 2, "" done"", 2);
	 [MASK] .AddPatient(39853, 175, 65, 1, "" done"", 2);
	 [MASK] .AddPatient(39854, 172, 65, 1, "" pending"", 2);
	 [MASK] .AddPatient(39855, 171, 65, 2, "" done"", 2);
	 [MASK] .removeSendPatient();
	
	 [MASK] .DisplayPatient();

	
	
	return 0;
}
",patient1
9,"#ifndef _BTREE_H_
#define _BTREE_H_

#include <string>
#include <utility>
#include <cstring>
#include <iostream>
#include <algorithm>

#include ""algo/ParamTrait.h""

namespace snippet {
namespace algo {

namespace detail {

template<typename KType, typename VType, unsigned int NodeSize = 512>
class BTreeNode
{
public:
    typedef KType KeyType;
    typedef typename ParamTrait<const KeyType>::DeclType KeyDeclType;
    typedef VType ValueType;
    typedef std::pair<KeyType, ValueType> Elem;

    static const unsigned int MAX_KEY_NUM =
            (NodeSize - sizeof(BTreeNode*)) / (sizeof(Elem) + sizeof(BTreeNode*));
    static const unsigned int CHILDREN_SIZE = MAX_KEY_NUM + 1;

    /// max_key_num should be an odd number
    BTreeNode(const unsigned max_key_num)
    : m_key_num(0), m_is_leave(true)
    {
        memset(m_children, 0, CHILDREN_SIZE * sizeof(m_children[0]));
    }

    ~BTreeNode()
    {
        if (m_key_num > 0)
        {
            for (unsigned i = 0; i <= m_key_num; ++i)
            {
                delete m_children[i];
            }
        }
    }

    void SetIsLeave(const bool is_leave)
    {
        m_is_leave = is_leave;
    }

    void AddItem(const KeyType key, const ValueType& value)
    {
        // TODO: add implementation
    }

    unsigned GetSize() const
    {
        unsigned total_key_num = GetKeyNum();
        if (total_key_num > 0 && !IsLeave())
        {
            for (unsigned i = 0; i <= GetKeyNum(); ++i)
            {
                const BTreeNode* child = GetChild(i);
                if (child)
                {
                    total_key_num += child->GetSize();
                }
            }
        }

        return total_key_num;
    }

    void Dump(const int level) const
    {
        std::cout << '[' << level << ']';
        std::cout << ""key_num:"" << m_key_num << "" elements: "";
        const unsigned key_num = GetKeyNum();
        for (unsigned i = 0; i < key_num; ++i)
        {
            std::cout << GetKey(i) << ' ';
        }
        std::cout << std::endl;

        if (key_num > 0 && !IsLeave())
        {
            for (unsigned i = 0; i <= key_num; ++i)
            {
                const BTreeNode* child = GetChild(i);
                if (child)
                {
                    child->Dump(level + 1);
                }
            }
        }
    }

    unsigned GetMaxKeyNum() const
    {
        return MAX_KEY_NUM;
    }

    unsigned GetKeyNum() const
    {
        return m_key_num;
    }

    /// get the key at index i, if i >= m_key_num,
    /// the result is undefined.
    inline KeyType GetKey(const unsigned i) const
    {
        return m_elements[i].first;
    }

    inline bool IsLeave() const { return m_is_leave; }

    /// get the child at index i, if i > m_key_num,
    /// the result is NULL;
    BTreeNode* GetChild(const unsigned i) const
    {
        return i <= m_key_num ? m_children[i] : NULL;
    }

    void SplitChild(const unsigned i, BTreeNode& child)
    {
        const unsigned max_key_num = MAX_KEY_NUM;
        const unsigned min_key_num = max_key_num / 2;
        BTreeNode* new_child = new BTreeNode(max_key_num);
        new_child->SetIsLeave(child.IsLeave());

        new_child->SetKeyNum(min_key_num);
        for (unsigned j = 0; j < min_key_num; ++j)
        {
            const Elem& e = child.m_elements[min_key_num + 1 + j];
            new_child->SetItem(j, e.first, e.second);
        }

        if (!child.IsLeave())
        {
            for (unsigned j = 0; j <= min_key_num; ++j)
            {
                new_child->m_children[j] = child.m_children[min_key_num + 1 + j];
            }
        }

        child.SetKeyNum(min_key_num);
        for (unsigned j = GetKeyNum(); j > i; --j)
        {
            m_children[j + 1] = m_children[j];
        }
        m_children[i + 1] = new_child;

        for (int j = static_cast<int>(GetKeyNum()) - 1;
             j >= static_cast<int>(i); --j)
        {
            m_elements[j + 1] = m_elements[j];
        }
        m_elements[i] = child.m_elements[min_key_num];
        ++m_key_num;
    }

    void InsertNonfull(const KeyType key, const ValueType& value)
    {
        int i = static_cast<int>(GetKeyNum()) - 1;
        if (IsLeave())
        {
            while (i >= 0 && key < GetKey(static_cast<unsigned>(i)))
            {
                m_elements[i + 1] = m_elements[i];
                --i;
            }
            SetItem(static_cast<unsigned>(i) + 1, key, value);
            ++m_key_num;
        }
        else
        {
            while (i >= 0 && key < GetKey(static_cast<unsigned>(i)))
            {
                --i;
            }
            ++i;
            BTreeNode* child = m_children[i];
            if (child->GetKeyNum() == MAX_KEY_NUM)
            {
                SplitChild(static_cast<unsigned>(i), *child);
                if (key > GetKey(static_cast<unsigned>(i)))
                {
                    ++i;
                }
            }
            m_children[i]->InsertNonfull(key, value);
        }
    }

    bool Find(const KeyType key, unsigned* idx) const
    {
        KeyType  [MASK] ;
        // TODO: use lower bound here
        for (unsigned i = 0; i < m_key_num; ++i)
        {
             [MASK]  = GetKey(i);
            if (key <=  [MASK] )
            {
                *idx = i;
                return key ==  [MASK] ;
            }
        }
        *idx = m_key_num;
        return false;
    }

    void GetMaxKeyItem(KeyType* key, ValueType* value) const
    {
        if (IsLeave())
        {
            *key = m_elements[m_key_num - 1].first;
            *value = m_elements[m_key_num - 1].second;
        }
        else
        {
            m_children[m_key_num]->GetMaxKeyItem(key, value);
        }
    }

    void GetMinKeyItem(KeyType* key, ValueType* value) const
    {
        if (IsLeave())
        {
            *key = m_elements[0].first;
            *value = m_elements[0].second;
        }
        else
        {
            m_children[0]->GetMinKeyItem(key, value);
        }
    }

    void Delete(const unsigned idx)
    {
        for (unsigned i = idx + 1; i < m_key_num; ++i)
        {
            m_elements[i - 1] = m_elements[i];
        }
        --m_key_num;
    }

    BTreeNode* MergeChildren(const unsigned idx)
    {
        BTreeNode* first_child = m_children[idx];
        BTreeNode* second_child = m_children[idx + 1];
        const unsigned first_old_key_num = first_child->m_key_num;
        const unsigned second_old_key_num = second_child->m_key_num;

        // merge keys and values
        first_child->m_elements[first_old_key_num] = m_elements[idx];
        for (unsigned i = 0; i < second_old_key_num; ++i)
        {
            first_child->m_elements[first_old_key_num + 1 + i] =
                    second_child->m_elements[i];
        }

        // merge the children
        for (unsigned i = 0; i <= second_old_key_num; ++i)
        {
            first_child->SetChild(first_old_key_num + 1 + i,
                                  second_child->m_children[i]);
        }
        first_child->m_key_num += second_old_key_num + 1;

        // move the key backward in the parent.
        for (unsigned i = idx; i < m_key_num - 1; ++i)
        {
            m_elements[i] = m_elements[i + 1];
        }

        // move the children backward in the parent
        for (unsigned i = idx + 1; i < m_key_num; ++i)
        {
            m_children[i] = m_children[i + 1];
        }
        --m_key_num;

        second_child->SetKeyNum(0); // we have to reset before deleting
        delete second_child;

        return first_child;
    }

    void LeftShiftKey(const unsigned idx)
    {
        BTreeNode* left_child = m_children[idx];
        BTreeNode* right_child = m_children[idx + 1];
        const unsigned left_key_num = left_child->GetKeyNum();
        const unsigned right_key_num = right_child->GetKeyNum();

        left_child->m_elements[left_key_num] = m_elements[idx];
        left_child->m_children[left_key_num + 1] = right_child->m_children[0];
        ++(left_child->m_key_num);

        m_elements[idx] = right_child->m_elements[0];

        for (unsigned i = 0; i < right_key_num - 1; ++i)
        {
            right_child->m_elements[i] = right_child->m_elements[i + 1];
            right_child->m_children[i] = right_child->m_children[i + 1];
        }
        right_child->m_children[right_key_num - 1] =
                right_child->m_children[right_key_num];
        --(right_child->m_key_num);
    }

    void RightShiftKey(const unsigned idx)
    {
        BTreeNode* left_child = m_children[idx];
        BTreeNode* right_child = m_children[idx + 1];
        const unsigned left_key_num = left_child->GetKeyNum();
        const unsigned right_key_num = right_child->GetKeyNum();

        for (unsigned i = right_key_num; i > 0; --i)
        {
            right_child->m_elements[i] = right_child->m_elements[i - 1];
            right_child->m_children[i + 1] = right_child->m_children[i];
        }
        right_child->m_children[1] = right_child->m_children[0];
        right_child->m_elements[0] = m_elements[idx];
        right_child->m_children[0] = left_child->m_children[left_key_num];
        ++(right_child->m_key_num);

        m_elements[idx] = left_child->m_elements[left_key_num - 1];

        --(left_child->m_key_num);
    }

    void SetKeyNum(const unsigned key_num)
    {
        m_key_num = key_num <= 1024 ? key_num : 1024;
    }

    void SetChild(const unsigned i, BTreeNode* child)
    {
        m_children[i] = child;
    }

    void SetItem(const unsigned i, const KeyType key, const ValueType& value)
    {
        m_elements[i].first = key;
        m_elements[i].second = value;
    }

private:
    Elem m_elements[MAX_KEY_NUM];
    BTreeNode* m_children[CHILDREN_SIZE];
    unsigned int m_key_num;
    bool m_is_leave;
};

}  // namespace detail


class BTree
{
public:
    typedef detail::BTreeNode<int, ::std::string> BTreeNode;

    BTree(const unsigned max_key_num)
    {
        m_root = new BTreeNode(max_key_num);
        m_root->SetIsLeave(true);
    }

    ~BTree()
    {
        delete m_root;
    }

    unsigned GetSize() const
    {
        return m_root->GetSize();
    }

    void Dump() const
    {
        std::cout << ""max_key_num:"" << m_root->GetMaxKeyNum() << std::endl;
        m_root->Dump(0);
    }

    bool Find(const int key, BTreeNode** out_node, int* out_index) const
    {
        return Find(*m_root, key, out_node, out_index);
    }

    void Insert(const int key, const std::string& value)
    {
        const unsigned max_key_num = m_root->GetMaxKeyNum();
        if (m_root->GetKeyNum() == max_key_num)
        {
            BTreeNode* old_root = m_root;
            m_root = new BTreeNode(max_key_num);
            m_root->SetIsLeave(false);
            m_root->SetKeyNum(0);
            m_root->SetChild(0, old_root);
            m_root->SplitChild(0, *old_root);
            m_root->InsertNonfull(key, value);
        }
        else
        {
            m_root->InsertNonfull(key, value);
        }
    }

    void Delete(const int key)
    {
        if (m_root->GetKeyNum() == 0)
        {
            return;
        }
        else if (m_root->GetKeyNum() == 1 && !m_root->IsLeave())
        {
            BTreeNode* first_child = m_root->GetChild(0);
            BTreeNode* second_child = m_root->GetChild(1);
            const unsigned min_key_num = m_root->GetMaxKeyNum() / 2;

            if (first_child->GetKeyNum() == min_key_num &&
                second_child->GetKeyNum() == min_key_num)
            {
                first_child = m_root->MergeChildren(0);
                m_root->SetKeyNum(0);
                delete m_root;
                m_root = first_child;
                Delete(*m_root, key);
            }
            else
            {
                Delete(*m_root, key);
            }
        }
        else
        {
            Delete(*m_root, key);
        }
    }

private:
    bool Find(BTreeNode& node, const int key,
              BTreeNode** out_node, int* out_index) const
    {
        const unsigned key_num = node.GetKeyNum();
        unsigned i = 0;
        while (i < key_num && key > node.GetKey(i))
        {
            ++i;
        }
        if (i < key_num && key == node.GetKey(i))
        {
            if (out_node)
            {
                *out_node = &node;
                *out_index = i;
            }
            return true;
        }

        if (node.IsLeave())
        {
            return false;
        }
        else
        {
            BTreeNode* child_node = node.GetChild(i);
            return Find(*child_node, key, out_node, out_index);
        }
    }

    void Delete(BTreeNode& node, const int key)
    {
        unsigned key_idx;
        bool is_key_found = node.Find(key, &key_idx);
        if (node.IsLeave()) // case 1
        {
            if (is_key_found)
            {
                node.Delete(key_idx);
            }
            return;
        }
        else if (is_key_found && !node.IsLeave()) // case 2
        {
            const unsigned min_key_num = node.GetMaxKeyNum() / 2;
            BTreeNode* cur_child = node.GetChild(key_idx);
            if (cur_child->GetKeyNum() > min_key_num) // case 2a
            {
                int prev_key = 0;
                std::string prev_value;
                cur_child->GetMaxKeyItem(&prev_key, &prev_value);
                Delete(*cur_child, prev_key);
                node.SetItem(key_idx, prev_key, prev_value);
                return;
            }

            BTreeNode* next_child = node.GetChild(key_idx + 1);
            if (next_child->GetKeyNum() > min_key_num) // case 2b
            {
                int next_key = 0;
                std::string next_value;
                next_child->GetMinKeyItem(&next_key, &next_value);
                Delete(*next_child, next_key);
                node.SetItem(key_idx, next_key, next_value);
                return;
            }

            // case 2c
            (void) node.MergeChildren(key_idx);
            Delete(*cur_child, key);
        }
        else // case 3
        {
            BTreeNode* child = node.GetChild(key_idx);
            const unsigned min_key_num = node.GetMaxKeyNum() / 2;
            if (child->GetKeyNum() <= min_key_num)
            {
                BTreeNode* prev_child = NULL;
                BTreeNode* next_child = NULL;
                if (key_idx > 0)
                {
                    prev_child = node.GetChild(key_idx - 1);
                }
                if (key_idx < node.GetKeyNum())
                {
                    next_child = node.GetChild(key_idx + 1);
                }

                // case 3a
                if (prev_child != NULL && prev_child->GetKeyNum() > min_key_num)
                {
                    node.RightShiftKey(key_idx - 1);
                }
                // case 3a
                else if (next_child != NULL && next_child->GetKeyNum() > min_key_num)
                {
                    node.LeftShiftKey(key_idx);
                }
                else // case 3b
                {
                    child = node.MergeChildren(prev_child != NULL ?
                                                 key_idx - 1: key_idx);
                }
            }
            Delete(*child, key);
        }
    }

private:
    BTreeNode* m_root;
};

} // algo
} // snippet

#endif /* _BTREE_H_ */
",cur_key
10,"#pragma once

#include <stdint.h>
#include <cmath>
#include <numbers>
#include <Geode/Geode.hpp>

namespace allium {
    class DrawNodeExtension;
    struct Point {
        double x = 0.0;
        double y = 0.0;

        Point() = default;
        Point(double x, double y)
            : x(x), y(y)
        {};
        Point(cocos2d::CCPoint const& point)
            : x(static_cast<double>(point.x)), y(static_cast<double>(point.y))
        {};

        Point operator+(Point const& other) const {
            return Point{x + other.x, y + other.y};
        }

        Point operator-(Point const& other) const {
            return Point{x - other.x, y - other.y};
        }

        Point operator*(double const& scalar) const {
            return Point{x * scalar, y * scalar};
        }

        Point operator/(double const& scalar) const {
            return Point{x / scalar, y / scalar};
        }

        double dot(Point const& other) const {
            return x * other.x + y * other.y;
        }

        double perpDot(Point const& other) const {
            return x * other.y - y * other.x;
        }

        double getDistanceSq(Point const& other) const {
            return std::pow(x - other.x, 2) + std::pow(y - other.y, 2);
        }

        double getDistance(Point const& other) const {
            return std::sqrt(this->getDistanceSq(other));
        }

        double angleTo(Point const& other) const {
            double const angle = std::acos(
                this->dot(other) / std::sqrt(this->getLengthSq() * other.getLengthSq())
            );

            return angle * ((this->perpDot(other) < 0) ? -1 : 1);
        }

        double getLengthSq() const {
            return x * x + y * y;
        }

        double getLength() const {
            return std::sqrt(this->getLengthSq());
        }
        
        operator cocos2d::CCPoint() const {
            return cocos2d::CCPoint(static_cast<float>(x), static_cast<float>(y));
        }

        std::strong_ordering operator<=>(Point const& other) const {
            if (x < other.x) return std::strong_ordering::less;
            if (x > other.x) return std::strong_ordering::greater;
            if (y < other.y) return std::strong_ordering::less;
            if (y > other.y) return std::strong_ordering::greater;
            return std::strong_ordering::equal;
        }
    };

    struct Col2 {
        std::array<double, 2> data;
        Col2(double x = 0.0, double y = 0.0)
            : data({x, y}) {}
        Col2(Point const& point)
            : data({point.x, point.y}) {}

        operator Point() const {
            return Point(data[0], data[1]);
        }
    };

    struct Mat2 {
        std::array<Col2, 2> data;

        Mat2(Col2 const& col1, Col2 const& col2)
            : data{col1, col2}
        {};

        Mat2(double a11, double a12, double  [MASK] , double a22)
            : data{Col2(a11,  [MASK] ), Col2(a12, a22)}
        {};

        static Mat2 fromAngle(double angle) {
            double cosA = std::cos(angle);
            double sinA = std::sin(angle);
            return Mat2{Col2(cosA, sinA), Col2(-sinA, cosA)};
        }

        Col2 operator*(Col2 const& vec) const {
            return Col2{
                data[0].data[0] * vec.data[0] + data[1].data[0] * vec.data[1],
                data[0].data[1] * vec.data[0] + data[1].data[1] * vec.data[1]
            };
        }

        Mat2 operator*(Mat2 const& other) const {
            return Mat2{
                Col2{
                    data[0].data[0] * other.data[0].data[0] + data[1].data[0] * other.data[0].data[1],
                    data[0].data[1] * other.data[0].data[0] + data[1].data[1] * other.data[0].data[1]
                },
                Col2{
                    data[0].data[0] * other.data[1].data[0] + data[1].data[0] * other.data[1].data[1],
                    data[0].data[1] * other.data[1].data[0] + data[1].data[1] * other.data[1].data[1]
                }
            };
        }
    };

    struct Object {
        virtual ~Object() = default;
        virtual geode::Result<GameObject*> addAsGameObject(LevelEditorLayer* editorLayer, int colorID) const = 0;
        virtual geode::Result<> drawIntoDrawNode(DrawNodeExtension* node, cocos2d::ccColor3B color) const = 0;
    };

    struct Parallelogram : Object {
        Point p1;
        Point p2;
        Point p3;
        Point p4;

        Parallelogram() = default;
        Parallelogram(Point p1, Point p2, Point p3, Point p4)
            : p1(p1), p2(p2), p3(p3), p4(p4)
        {};
        virtual ~Parallelogram() = default;

        geode::Result<GameObject*> addAsGameObject(LevelEditorLayer* editorLayer, int colorID) const override;
        geode::Result<> drawIntoDrawNode(DrawNodeExtension* node, cocos2d::ccColor3B color) const override;
    };

    struct Circle : Object {
        Point center;
        float radius;

        Circle() = default;
        Circle(Point center, float radius)
            : center(center), radius(radius)
        {};
        virtual ~Circle() = default;

        geode::Result<GameObject*> addAsGameObject(LevelEditorLayer* editorLayer, int colorID) const override;
        geode::Result<> drawIntoDrawNode(DrawNodeExtension* node, cocos2d::ccColor3B color) const override;
    };

    struct Triangle : Object {
        Point p1;
        Point p2;
        Point p3;

        Triangle() = default;
        Triangle(Point p1, Point p2, Point p3)
            : p1(p1), p2(p2), p3(p3)
        {};
        virtual ~Triangle() = default;

        geode::Result<GameObject*> addAsGameObject(LevelEditorLayer* editorLayer, int colorID) const override;
        geode::Result<> drawIntoDrawNode(DrawNodeExtension* node, cocos2d::ccColor3B color) const override;
    };
}",a21
11,"/*
 *  FontTextureManagerAndroid.cpp
 *  WhirlyGlobeLib
 *
 *  Created by <NAME> on 6/2/14.
 *  Copyright 2011-2016 mousebird consulting
 *
 *  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.
 *
 */

#import ""FontTextureManagerAndroid.h""
#import ""LabelInfoAndroid.h""
#import <android/bitmap.h>

namespace WhirlyKit
{

static const float BogusFontScale = 1.0;

FontTextureManagerAndroid::FontManagerAndroid::FontManagerAndroid(JNIEnv *env,jobject inTypefaceObj)
{
	typefaceObj = env->NewGlobalRef(inTypefaceObj);
}

FontTextureManagerAndroid::FontManagerAndroid::FontManagerAndroid()
: typefaceObj(NULL)
{
}

void FontTextureManagerAndroid::FontManagerAndroid::clearRefs(JNIEnv *savedEnv)
{
	if (typefaceObj)
	{
		savedEnv->DeleteGlobalRef(typefaceObj);
		typefaceObj = NULL;
	}
}

FontTextureManagerAndroid::FontManagerAndroid::~FontManagerAndroid()
{
}

FontTextureManagerAndroid::FontTextureManagerAndroid(JNIEnv *env,Scene *scene,jobject inCharRenderObj)
	: FontTextureManager(scene), charRenderObj(NULL)
{
	// Note: Porting.  This will leak
	charRenderObj = env->NewGlobalRef(inCharRenderObj);
	jclass  [MASK]  =  env->GetObjectClass(charRenderObj);
	renderMethodID = env->GetMethodID( [MASK] , ""renderChar"", ""(ILcom/mousebird/maply/LabelInfo;F)Lcom/mousebird/maply/CharRenderer$Glyph;"");
	jclass glyphClass = env->FindClass(""com/mousebird/maply/CharRenderer$Glyph"");
	bitmapID = env->GetFieldID(glyphClass,""bitmap"",""Landroid/graphics/Bitmap;"");
	sizeXID = env->GetFieldID(glyphClass,""sizeX"",""F"");
	sizeYID = env->GetFieldID(glyphClass,""sizeY"",""F"");
	glyphSizeXID = env->GetFieldID(glyphClass,""glyphSizeX"",""F"");
	glyphSizeYID = env->GetFieldID(glyphClass,""glyphSizeY"",""F"");
	offsetXID = env->GetFieldID(glyphClass,""offsetX"",""F"");
	offsetYID = env->GetFieldID(glyphClass,""offsetY"",""F"");
	textureOffsetXID = env->GetFieldID(glyphClass,""textureOffsetX"",""F"");
	textureOffsetYID = env->GetFieldID(glyphClass,""textureOffsetY"",""F"");
    env->DeleteLocalRef(glyphClass);
    env->DeleteLocalRef( [MASK] );
}

FontTextureManagerAndroid::~FontTextureManagerAndroid()
{
    for (FontManagerSet::iterator it = fontManagers.begin();
         it != fontManagers.end(); ++it)
        delete *it;
    fontManagers.clear();
}

DrawableString *FontTextureManagerAndroid::addString(JNIEnv *env,const std::vector<int> &codePoints,jobject labelInfoObj,ChangeSet &changes)
{
	LabelInfoClassInfo *classInfo = LabelInfoClassInfo::getClassInfo();
	LabelInfoAndroid *labelInfo = (LabelInfoAndroid *)classInfo->getObject(env,labelInfoObj);

	// Could be more granular if this slows things down
    pthread_mutex_lock(&lock);

    // If not initialized, set up texture atlas and such
    init();

    DrawableString *drawString = new DrawableString();
    DrawStringRep *drawStringRep = new DrawStringRep(drawString->getId());

    // Look for the font manager that manages the typeface/attribute combo we need
    FontManagerAndroid *fm = findFontManagerForFont(labelInfo->typefaceObj,*labelInfo);

	JavaIntegerClassInfo *intClassInfo = JavaIntegerClassInfo::getClassInfo(env);

    // Work through the characters
    GlyphSet glyphsUsed;
    float offsetX = 0.0;
    for (int glyph : codePoints)
    {
    	// Look for an existing glyph
    	FontManager::GlyphInfo *glyphInfo = fm->findGlyph(glyph);
    	if (!glyphInfo)
    	{
        	// Call the renderer
        	jobject glyphObj = env->CallObjectMethod(charRenderObj,renderMethodID,glyph,labelInfoObj,labelInfo->fontSize);
        	jobject bitmapObj = env->GetObjectField(glyphObj,bitmapID);

        	try
        	{
				// Got a bitmap, so merge that in with our texture atlas
				AndroidBitmapInfo info;
				if (bitmapObj && (AndroidBitmap_getInfo(env, bitmapObj, &info) >= 0))
				{
                    Point2f texSize,glyphSize;
                    Point2f offset,textureOffset;

                    // Pull these values from the glyph
                    texSize.x() = env->GetFloatField(glyphObj,sizeXID);
                    texSize.y() = env->GetFloatField(glyphObj,sizeYID);
                    glyphSize.x() = env->GetFloatField(glyphObj,glyphSizeXID);
                    glyphSize.y() = env->GetFloatField(glyphObj,glyphSizeYID);
                    offset.x() = env->GetFloatField(glyphObj,offsetXID);
                    offset.y() = env->GetFloatField(glyphObj,offsetYID);
                    textureOffset.x() = env->GetFloatField(glyphObj,textureOffsetXID);
                    textureOffset.y() = env->GetFloatField(glyphObj,textureOffsetYID);

                    // Create a texture
					void* bitmapPixels;
					if (AndroidBitmap_lockPixels(env, bitmapObj, &bitmapPixels) < 0)
						throw 1;
					uint32_t* src = (uint32_t*) bitmapPixels;
					int testVal = src[20];
					MutableRawData *rawData = new MutableRawData(bitmapPixels,info.height*info.width*4);
					Texture tex(""FontTextureManager"");
					tex.setRawData(rawData,info.width,info.height);

					// Add it to the texture atlas
                    SubTexture subTex;
                    Point2f realSize(glyphSize.x()+2*textureOffset.x(),glyphSize.y()+2*textureOffset.y());
                    std::vector<Texture *> texs;
                    texs.push_back(&tex);
                    if (texAtlas->addTexture(texs, -1, &realSize, NULL, subTex, scene->getMemManager(), changes, 0, 0, NULL))
                        glyphInfo = fm->addGlyph(glyph, subTex, Point2f(glyphSize.x(),glyphSize.y()), Point2f(offset.x(),offset.y()), Point2f(textureOffset.x(),textureOffset.y()));
                    
                    AndroidBitmap_unlockPixels(env, bitmapObj);
				}
        	}
        	catch (...)
        	{
        		// Just don't add the glyph, for now
        	}

        	env->DeleteLocalRef(glyphObj);
    	}

        if (glyphInfo)
        {
            // Now we make a rectangle that covers the glyph in its texture atlas
            DrawableString::Rect rect;
            Point2f offset(offsetX,0.0);

            float scale = 1.0/BogusFontScale;

            // Note: was -1,-1
            rect.pts[0] = Point2f(glyphInfo->offset.x()*scale-glyphInfo->textureOffset.x()*scale,glyphInfo->offset.y()*scale-glyphInfo->textureOffset.y()*scale)+offset;
            rect.texCoords[0] = TexCoord(0.0,1.0);
            // Note: was 2,2
            rect.pts[1] = Point2f(glyphInfo->size.x()*scale+2*glyphInfo->textureOffset.x()*scale,glyphInfo->size.y()*scale+2*glyphInfo->textureOffset.y()*scale)+rect.pts[0];
            rect.texCoords[1] = TexCoord(1.0,0.0);

            rect.subTex = glyphInfo->subTex;
            drawString->glyphPolys.push_back(rect);
            drawString->mbr.addPoint(rect.pts[0]);
            drawString->mbr.addPoint(rect.pts[1]);

            glyphsUsed.insert(glyphInfo->glyph);

            offsetX += rect.pts[1].x()-rect.pts[0].x();
        }
    }

    drawStringRep->addGlyphs(fm->getId(),glyphsUsed);
    fm->addGlyphRefs(glyphsUsed);

    // If it didn't produce anything, just delete it now
    if (drawString->glyphPolys.empty())
    {
        delete drawString;
        delete drawStringRep;
        drawString = NULL;
    }

    // We need to track the glyphs we're using
    drawStringReps.insert(drawStringRep);

    pthread_mutex_unlock(&lock);

    return drawString;
}

FontTextureManagerAndroid::FontManagerAndroid *FontTextureManagerAndroid::findFontManagerForFont(jobject typefaceObj,const LabelInfo &inLabelInfo)
{
	const LabelInfoAndroid &labelInfo = (LabelInfoAndroid &)inLabelInfo;

	for (FontManagerSet::iterator it = fontManagers.begin();
			it != fontManagers.end(); ++it)
	{
		FontManagerAndroid *fm = (FontManagerAndroid *)*it;

		if (labelInfo.typefaceIsSame(fm->typefaceObj) &&
                fm->pointSize == labelInfo.fontSize &&
				fm->color == labelInfo.textColor &&
				fm->outlineColor == labelInfo.outlineColor &&
				fm->outlineSize == labelInfo.outlineSize)
			return fm;
	}

	// Didn't find it, so create it
	FontManagerAndroid *fm = new FontManagerAndroid(labelInfo.env,typefaceObj);
	fm->fontName = """";
	fm->color = labelInfo.textColor;
	fm->pointSize = labelInfo.fontSize;
	fm->outlineColor = labelInfo.outlineColor;
	fm->outlineSize = labelInfo.outlineSize;
	fontManagers.insert(fm);

	return fm;
}

}
",charRenderClass
12,"#include ""cardashboard.h""
#include <QPainter>
#include <QPainterPath>
#include <QRadialGradient>
#include <QtMath>
#include <QTimer>
CarDashBoard::CarDashBoard(QWidget *parent)
    : QWidget{parent}
{

    margin = 5;
    spanAngle = 240;//仪表盘占用角度
    startAngle = (180-spanAngle)/2.0 ;//仪表盘开始角度

    animation = false;

    maxValue = 280;
    minValue = 0;
    currentValue = 0;
    value = 0;
    unit = ""km/h"";

    backgroundColor= QColor(59,24,37);
    outArcColor = QColor(0,82,199);
    outLineColor = QColor(255,255,255);
    scaleColor = QColor(255,255,255);
    pointerColor = QColor(255,255,255);
    circleArcColorStart = QColor(53,179,251,150);
    circleArcColorEnd = QColor(160,88,127,200);
    circleBomBigColor = QColor(58,40, 50);
    circleBomShineColor = QColor(60,68,85,150);
    circleBomSmallColor = QColor(58,24, 40);
    textColor = QColor(255,255,255);

    isForward = false;

    timer = new QTimer;
    timer->setInterval(10);
    connect(timer, &QTimer::timeout,this, &CarDashBoard::updateValue);



}

int CarDashBoard::getValue() const
{
    return value;
}

int CarDashBoard::getMinValue() const
{
    return minValue;
}

int CarDashBoard::getMaxValue() const
{
    return maxValue;
}

bool CarDashBoard::getAnimation() const
{
    return animation;
}

int CarDashBoard::getMargin() const
{
    return margin;
}

int CarDashBoard::getSpanAngle() const
{
    return spanAngle;
}

QString CarDashBoard::getUnit() const
{
    return unit;
}

QColor CarDashBoard::getBackgroundColor() const
{
    return backgroundColor;
}

QColor CarDashBoard::getOutArcColor() const
{
    return outArcColor;
}

QColor CarDashBoard::getOutLineColor() const
{
    return outLineColor;
}

QColor CarDashBoard::getScaleColor() const
{
    return scaleColor;
}

QColor CarDashBoard::getPointerColor() const
{
    return pointerColor;
}

QColor CarDashBoard::getCircleArcColorStart() const
{
    return circleArcColorStart;
}

QColor CarDashBoard::getCircleArcColorEnd() const
{
    return circleArcColorEnd;
}

QColor CarDashBoard::getCircleBomBigColor() const
{
    return circleBomBigColor;
}

QColor CarDashBoard::getCircleBomShineColor() const
{
    return circleBomShineColor;
}

QColor CarDashBoard::getCircleBomSmallColor() const
{
    return circleBomSmallColor;
}

QColor CarDashBoard::getTextColor() const
{
    return textColor;
}

QSize CarDashBoard::sizeHint() const
{
    return QSize(300,300);
}

QSize CarDashBoard::minimumSizeHint() const
{
    return QSize(30,30);
}



void CarDashBoard::paintEvent(QPaintEvent *event)
{

    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing, true);//抗锯齿
    painter.setPen(Qt::NoPen);
    center = QPointF(this->width()/2.0,this->height()/2.0);
    mRadius =  qMin(center.y(), center.x())-margin;//最外层圆弧半径

    // qDebug()<<mRadius;
    //QTransform transform(1,0,0,-1,center.x(),center.y());//变换为逻辑坐标
    // painter.setTransform(transform);

    /*painter.save();

    painter.setRenderHint(QPainter::Antialiasing,true);
    QLinearGradient Linear(50,0,50,100);        //垂直渐变

    Linear.setColorAt(0,Qt::red);
    Linear.setColorAt(0.5,Qt::transparent);

    painter.setBrush(Linear);
    painter.setPen(Qt::transparent);
    painter.drawRect(0,0,100,100);          //100,100 到200,200

    painter.restore();*/

    drawBackground(&painter);
    drawOutArc(&painter);
    drawOutLine(&painter);
    drawScale(&painter);
    drawScaleNum(&painter);
    drawCircle_arc(&painter);
    drawPointer(&painter);
    drawCircle_bom_big(&painter);
    drawCircle_bom_shine(&painter);
    drawCircle_bom_small(&painter);
    drawUnit(&painter);//单位
    drawNum(&painter);//时速


}

void CarDashBoard::drawBackground(QPainter *painter)
{
    painter->save();

    //设置画刷
    painter->setBrush(backgroundColor);
    painter->drawEllipse(center,mRadius,mRadius);
    painter->restore();

}

void CarDashBoard::drawOutArc(QPainter *painter)
{
    painter->save();
    double radius =  this->mRadius-0.12 * this->mRadius;
    QPointF sPoint = QPointF(center.x()-this->mRadius,center.y()-this->mRadius);
    QPointF ePoint = sPoint + QPointF(2*this->mRadius,2*this->mRadius);
    QRectF rectangle(sPoint, ePoint);
    QPainterPath outRing;
    QPainterPath inRing;
    outRing.moveTo(center);
    inRing.moveTo(0,0);
    outRing.arcTo(rectangle, startAngle, spanAngle);
    inRing.addEllipse(center, radius,radius);
    outRing.closeSubpath();
    //设置渐变色k
    QRadialGradient radialGradient(center,mRadius);
    radialGradient.setColorAt(1,outArcColor);
    radialGradient.setColorAt(0.9,Qt::transparent);
    //设置画刷
    painter->setBrush(radialGradient);
    //大圆减小圆
    painter->drawPath(outRing.subtracted(inRing));
    painter->restore();
}

void CarDashBoard::drawOutLine(QPainter *painter)
{
    painter->save();
    //double mRadius =  qMin(mCenter.y(), mCenter.x())-mMargin;//最外层圆弧半径
    QPointF sPoint = QPointF(center.x()-mRadius,center.y()-mRadius);
    QPointF ePoint = sPoint + QPointF(2*mRadius,2*mRadius);
    QRectF rectangle(sPoint, ePoint);
    QPen pen;
    pen = QPen(outLineColor);
    pen.setWidth(3);
    painter->setPen(pen);
    painter->drawArc(rectangle,startAngle*16, 360*16);
    painter->restore();
}

void CarDashBoard::drawScale(QPainter *painter)
{
    painter->save();
    painter->translate(center);
    //painter->drawLine(0,0,0,100);
    painter->rotate(90+startAngle);
    //painter->drawLine(0,0,0,100);
    double radius = mRadius-0.12 * mRadius;
    int longStep = (maxValue - minValue)/20;
    int shortStep = 5 * (longStep) ;
    //qDebug()<<shortStep;
    //int longStep = 12;
    QPen pen;
    pen = QPen(scaleColor);
    pen.setWidth(3);
    painter->setPen(pen);
    for(int i = 0; i<= shortStep; i++ )
    {
        QPen pen((i<0.8*shortStep)?(QColor(255,255,255)):QColor(255,0,0));

        pen.setWidth(2);
        painter->setPen(pen);
        if(i%(5) == 0)
        {
            QPoint p1(0,radius);
            QPoint p2(0,radius-0.06 *radius);
            painter->drawLine(p1,p2);
        }
        else
        {
            QPoint p1(0,radius);
            QPoint p2(0,radius-0.03 *radius);
            painter->drawLine(p1,p2);
        }
        painter->rotate(spanAngle/(shortStep*1.0));
    }
    painter->restore();

}

void CarDashBoard::drawScaleNum(QPainter *painter)
{
    painter->save();
    painter->translate(center);
    painter->rotate(90+startAngle+180);
    double radius = 0.7*(mRadius-0.12 * mRadius);
    int longStep = (maxValue - minValue)/20;
    int shortStep = 5 * (longStep) ;

    double scale = mRadius/250.0; //缩放因子
    QFont font;
    font.setFamily(""Arial"");

    font.setPointSize(16*scale);
    font.setBold(true);
    painter->setFont(font);
    for(int i = 0; i<= longStep; i++ )
    {
        QPen pen((i<0.8*longStep)?(scaleColor):QColor(255,0,0));

        //pen.setWidth(1);
        painter->setPen(pen);
        painter->drawText(-20*scale, -(radius-40*scale), 35*scale,-radius,Qt::AlignCenter,QString::number(minValue+i*20));
        painter->rotate(spanAngle/(longStep*1.0));
    }
    painter->restore();

}

void CarDashBoard::drawPointer(QPainter *painter)
{
    painter->save();
    painter->translate(center);
    double rotate = spanAngle*1.0/(maxValue - minValue)*(currentValue-minValue)+(90+startAngle)+180;


    double pointerLen = mRadius * 0.25;

    painter->rotate(rotate);
    painter->setBrush(pointerColor);



    /*QPen pen;//测试指针旋转位置是否正确
    pen = QPen(QColor(255,255,255));
    painter->setPen(pen);
    painter->drawLine(0,0,0,-200);*/


    QPainterPath pointPath;
    pointPath.moveTo(-2,-mRadius * 0.4);
    pointPath.lineTo(2,-mRadius * 0.4);
    pointPath.lineTo(1,-mRadius * 0.4-pointerLen);
    pointPath.lineTo(-1,-mRadius * 0.4-pointerLen);
    pointPath.lineTo(-2,-mRadius * 0.4);
    painter->drawPath(pointPath);
    painter->restore();
    // pointPath.arcTo(-10,0,20,20,180,180);




}

void CarDashBoard::drawCircle_arc(QPainter *painter)
{


    double radius =  mRadius-0.025 * mRadius;
    double  [MASK]  = mRadius * 0.4;

    double currentAngle = spanAngle*1.0/(maxValue - minValue) * (currentValue-minValue);
    double startAngle = spanAngle-currentAngle;

    painter->save();



    QTransform transform(1,0,0,-1,center.x(),center.y());//
    painter->setTransform(transform);
    //painter->translate(mCenter);
    painter->rotate(180-this->startAngle);


    /*QPen pen;//测试指针旋转位置是否正确
    //pen = QPen(QColor(255,255,255));
    painter->setPen(pen);*/

    QPainterPath path;
    QPointF outPointS(radius,0);
    QPointF outPointE(radius*qCos(currentAngle*M_PI/180.0),-radius*qSin(currentAngle*M_PI/180.0));
    QPointF inPointS( [MASK] ,0);
    QPointF inPointE( [MASK] *qCos(currentAngle*M_PI/180.0),- [MASK] *qSin(currentAngle*M_PI/180.0));
    QRectF outRec(-radius,-radius,2*radius,2*radius);
    QRectF inRec(- [MASK] ,- [MASK] ,2* [MASK] ,2* [MASK] );

    double position =(0.8 * spanAngle + (360-spanAngle)/2.0)/(spanAngle + (360-spanAngle)/2.0);
    QConicalGradient conicalGradient(0,0,-(360-spanAngle)/2.0);
    conicalGradient.setColorAt(position, circleArcColorEnd);
    conicalGradient.setColorAt(0, circleArcColorStart);

    // 使用锥向渐变创建一个画刷，用来填充
    QBrush brush(conicalGradient);
    painter->setBrush(brush);

    path.moveTo(inPointS);
    path.lineTo(outPointS);
    path.arcTo(outRec,0,currentAngle);
    path.lineTo(inPointE);
    path.moveTo(inPointS);
    path.arcTo(inRec,0,currentAngle);


    //painter->drawEllipse(QPoint(0,0),5,5);

    /*painter->drawLine(0,0,0,100);
    painter->drawLine(0,0,200,0);*/
    //painter->drawRect(outRec);
    //painter->drawRect(inRec);


    painter->drawPath(path);
    painter->restore();
}

void CarDashBoard::drawCircle_bom_big(QPainter *painter)
{
    double radius = mRadius * 0.4;

    painter->save();
    painter->translate(center);
    painter->setBrush(circleBomBigColor);
    painter->drawEllipse(QPoint(0,0),radius,radius);
    painter->restore();

}

void CarDashBoard::drawCircle_bom_shine(QPainter *painter)
{
    double radius = mRadius * 0.3;

    painter->save();
    painter->translate(center);
    QRadialGradient radialGradient(0,0,radius,0,0);

    radialGradient.setColorAt(0.5,circleBomShineColor);
    radialGradient.setColorAt(1.0,Qt::transparent);


    QBrush brush(radialGradient);
    painter->setBrush(brush);
    painter->drawEllipse(QPoint(0,0),radius,radius);
    painter->restore();

}

void CarDashBoard::drawCircle_bom_small(QPainter *painter)
{

    double radius = mRadius * 0.25;

    painter->save();
    painter->translate(center);
    painter->setBrush(circleBomSmallColor);
    painter->drawEllipse(QPoint(0,0),radius,radius);
    painter->restore();
}

void CarDashBoard::drawUnit(QPainter *painter)
{
    double radius = mRadius * 0.25;

    painter->save();
    painter->translate(center);
    //qDebug()<<radius;
    double scale = radius/68.75; //缩放因子
    QFont font;
    font.setFamily(""Arial"");

    font.setPointSize(16*scale);
    font.setBold(true);
    painter->setFont(font);
    QPen pen(textColor);
    painter->setPen(pen);
    painter->drawText(-30*scale, 20*scale, 60*scale,60*scale,Qt::AlignCenter, unit);
    painter->restore();

}

void CarDashBoard::drawNum(QPainter *painter)
{
    double radius = mRadius * 0.25;

    painter->save();
    painter->translate(center);
    double scale = radius/68.75; //缩放因子
    QFont font;
    font.setFamily(""Arial"");

    font.setPointSize(40*scale);
    font.setBold(true);
    painter->setFont(font);
    QPen pen(textColor);
    painter->setPen(pen);
    painter->drawText(-50*scale, -40*scale, 100*scale,60*scale,Qt::AlignCenter,QString::number(currentValue));
    painter->restore();

}

void CarDashBoard::setValue(int value)
{
    if(value == currentValue)
        return;

    if(value < minValue)
        value = minValue;
    if(value > maxValue)
        value = maxValue;

    if(value > this->value)
    {
        isForward = false;
    }
    else
    {
        isForward = true;
    }

    this->value = value;

    if(timer->isActive())
        timer->stop();


    if(animation)
    {
        timer->start();
    }
    else
    {
        currentValue = value;
        update();
    }
    emit ValueChanged(this->value);
}

void CarDashBoard::setMinValue(int minValue)
{
    setRangle(minValue, maxValue);
}

void CarDashBoard::setMaxValue(int maxValue)
{
    setRangle(minValue, maxValue);
}

void CarDashBoard::setRangle(int minValue, int maxValue)
{
    if(minValue >= maxValue)
        return;
    this->minValue = minValue;
    this->maxValue = maxValue;

    if(value>maxValue)
        setValue(maxValue);

    if(value< minValue)
        setValue(minValue);

    emit RangChanged(minValue, maxValue);

    this->update();
}

void CarDashBoard::setAnimation(bool animation)
{
    //qDebug()<<animation<<this->animation;
    if(animation != this->animation)
    {

        this->animation = animation ;
        this->update();
    }
}

void CarDashBoard::setMargin(int margin)
{
    if(this->margin != margin)
    {
        this->margin = margin ;
        this->update();
    }
}

void CarDashBoard::setSpanAngle(int spanAngle)
{
    if(this->spanAngle != spanAngle)
    {
        this->spanAngle = spanAngle ;
        this->startAngle = (180-this->spanAngle)/2.0;
        this->update();
    }
}

void CarDashBoard::setUnit(const QString unit)
{
    if(this->unit != unit)
    {
        this->unit = unit ;
        this->update();
    }
}

void CarDashBoard::setBackgroundColor(const QColor &backgroundColor)
{
    if(this->backgroundColor != backgroundColor)
    {
        this->backgroundColor = backgroundColor ;
        this->update();
    }
}

void CarDashBoard::setOutArcColor(const QColor &outArcColor)
{
    if(this->outArcColor != outArcColor)
    {
        this->outArcColor = outArcColor ;
        this->update();
    }
}

void CarDashBoard::setOutLineColor(const QColor &outLineColor)
{
    if(this->outLineColor != outLineColor)
    {
        this->outLineColor = outLineColor ;
        this->update();
    }
}

void CarDashBoard::setScaleColor(const QColor &scaleColor)
{
    if(this->scaleColor != scaleColor)
    {
        this->scaleColor = scaleColor;
        this->update();
    }
}

void CarDashBoard::setPointerColor(const QColor &pointerColor)
{
    if(this->pointerColor != pointerColor)
    {
        this->pointerColor = pointerColor;
        this->update();
    }
}

void CarDashBoard::setCircleArcColorStart(const QColor &circleArcColorStart)
{
    if(this->circleArcColorStart != circleArcColorStart)
    {
        this->circleArcColorStart = circleArcColorStart;
        this->update();
    }
}

void CarDashBoard::setCircleArcColorEnd(const QColor &circleArcColorEnd)
{
    if(this->circleArcColorEnd != circleArcColorEnd)
    {
        this->circleArcColorEnd = circleArcColorEnd ;
        this->update();
    }
}

void CarDashBoard::setCircleBomBigColor(const QColor &circleBomBigColor)
{
    if(this->circleBomBigColor != circleBomBigColor)
    {
        this->circleBomBigColor = circleBomBigColor;
        this->update();
    }
}

void CarDashBoard::setCircleBomShineColor(const QColor &circleBomShineColor)
{
    if(this->circleBomShineColor != circleBomShineColor)
    {
        this->circleBomShineColor = circleBomShineColor ;
        this->update();
    }
}

void CarDashBoard::setCircleBomSmallColor(const QColor &circleBomSmallColor)
{
    if(this->circleBomSmallColor != circleBomSmallColor)
    {
        this->circleBomSmallColor = circleBomSmallColor;
        this->update();
    }
}

void CarDashBoard::setTextColor(const QColor &textColor)
{
    if(this->textColor != textColor)
    {
        this->textColor = textColor ;
        this->update();
    }
}

void CarDashBoard::updateValue()
{
    if(isForward)
    {
        currentValue -= 1;
        if(currentValue<=this->value)
        {
            currentValue = value;
            timer->stop();
        }
    }
    else
    {
        currentValue += 1;
        if(currentValue>=this->value)
        {
            currentValue = value;
            timer->stop();
        }

    }
    update();

}
",radiusIn
13,"/*
File:           laponia_battle.cpp
Last changed:   14/06/2023 14:00
Purpose:        Console-based matrix war game         
Authors:        <NAME> 
                <NAME>
                <NAME>
                <NAME>  
Usage: 
  HowToCompile:   gcc laponia_battle.cpp -o laponia_battle
  HowToExecute:   ./laponia_battle           
*/

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <ctime>
#include <locale.h>

int main(int argc, char ** argv) {
  
  setlocale(LC_ALL, ""Portuguese"");
  int i, j, x,  [MASK] , linha, coluna, especial = 1, vez = 1, vez2, especial2 = 1, linha2, coluna2, vez3, vitoria = 0, acertar, vez4, soldN, soldS, vez10;
  char soldado, acao, direcao, tiro, colunaa[2], linhac[2], linhaof[2], colunac[2];
  srand(time(NULL));
  x = rand() % 100;
  const int LINHAS = 12;
  const int COLUNAS = 12;
  char jogadorN[200];
  char jogadorS[200];

  printf(""Digite o nome do jogador que representará o Norte:\n"");
  scanf(""%s"", jogadorN);
  printf(""Digite o nome do jogador que representará o Sul:\n"");
  scanf(""%s"", jogadorS);

  if (x % 2 == 0) {
    printf(""%s vai jogar primeiro\n"", jogadorN);
  } else {
    printf(""%s vai jogar primeiro\n"", jogadorS);
  }

  system(""pause\n"");
  system(""cls"");

    char tabuleiro[LINHAS] [COLUNAS] ={
		{'*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '*'},
		{'*', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '*'},
		{'*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'} 
    };

  printf(""Norte:%s\n"", jogadorN);
  printf(""Sul:%s\n"", jogadorS);

  for (i = 0; i < LINHAS; i++) {
    for (j = 0; j < COLUNAS; j++) {
      if (tabuleiro[i][j] == '.') printf(""  "");
      else {
        printf(""%c "", tabuleiro[i][j]);
      }
    }
    printf(""\n"");
  }

  if (x % 2 == 0) {

    for ( [MASK]  = 1;  [MASK]  <= 9;  [MASK] ++) {

      // Vez do jogador Norte como primeiro jogador.
      printf(""%s, Escolha o tipo de soldado que você quer agora. Digite o número:\n"", jogadorN);
      printf(""1 - Soldado que atira em linha reta.\n"");
      printf(""2 - Soldado que atira em diagonal.\n"");
      printf(""# - Soldado ESPECIAL, que só pode ser colocado UMA vez, Emerald Splash! seu poder é um ataque poderoso em linha reta, que ultrapassa e destroi tudo que toca.\n"");

      scanf("" %c"", & soldado);

      vez2 = 0;
      while (vez2 == 0) {
        if (soldado == '1' || soldado == '2' || soldado == '#' && especial == 1) {

          printf(""%s, digite a posição da sua %d° peça, indique a linha e em seguida a coluna:\n"", jogadorN,  [MASK] );

          vez = 1;
          while (vez == 1) {
            scanf("" %s %s"", linhac, colunac);

            strcpy(linhaof, linhac);
            strcpy(colunaa, colunac);
            linha = atoi(linhaof);
            coluna = atoi(colunaa);

            if (tabuleiro[linha][coluna] == '.' && linha <= 4) {
              tabuleiro[linha][coluna] = soldado;
              vez = 0;
              if (soldado == '#') {

                especial = 0;

              }
            } else {
              printf(""Local inválido, tente novamente:\n"");

            }
          }
          vez2 = 1;
        } else {
          printf(""Soldado inválido. Tente novamente:\n"");
          scanf(""%c"", & soldado);
        }

      }
      system(""cls"");

      printf(""Norte:%s\n"", jogadorN);
      printf(""Sul:%s\n"", jogadorS);

      for (i = 0; i < LINHAS; i++) {
        for (j = 0; j < COLUNAS; j++) {
          if (tabuleiro[i][j] == '.') printf(""  "");
          else {
            printf(""%c "", tabuleiro[i][j]);
          }
        }
        printf(""\n"");
      }
      // Vez do jogador Sul como segundo jogador.
      printf(""%s, Escolha o tipo de soldado que você quer agora. Digite o número:\n"", jogadorS);
      printf(""1 - Soldado que atira em linha reta.\n"");
      printf(""2 - Soldado que atira em diagonal.\n"");
      printf(""@ - Soldado ESPECIAL, que só pode ser colocado UMA vez, Magicians Red! seu poder é um ataque poderoso em cruz, 3x3 que queima os inimigos na área.\n"");

      scanf("" %c"", & soldado);

      vez2 = 0;
      while (vez2 == 0) {
        if (soldado == '1' || soldado == '2' || soldado == '@' && especial2 == 1) {

          printf(""%s, digite a posição da sua %d° peça, indique a linha e em seguida a coluna:\n"", jogadorS,  [MASK] );

          vez = 1;
          while (vez == 1) {
            scanf("" %s %s"", linhac, colunac);
            strcpy(linhaof, linhac);
            strcpy(colunaa, colunac);
            linha = atoi(linhaof);
            coluna = atoi(colunaa);

            if (tabuleiro[linha][coluna] == '.' && linha >= 7) {
              tabuleiro[linha][coluna] = soldado;
              vez = 0;
              if (soldado == '@') {

                especial2 = 0;

              }
            } else {
              printf(""Local inválido, tente novamente:\n"");

            }
          }
          vez2 = 1;
        } else {
          printf(""Soldado inválido. Tente novamente:\n"");
          scanf(""%c"", & soldado);
        }

      }
      system(""cls"");

      printf(""Norte:%s\n"", jogadorN);
      printf(""Sul:%s\n"", jogadorS);

      for (i = 0; i < LINHAS; i++) {
        for (j = 0; j < COLUNAS; j++) {
          if (tabuleiro[i][j] == '.') printf(""  "");
          else {
            printf(""%c "", tabuleiro[i][j]);
          }
        }
        printf(""\n"");
      }
    }
  } else {
    for ( [MASK]  = 1;  [MASK]  <= 9;  [MASK] ++) {

      // Vez do jogador Sul como primeiro jogador.
      printf(""%s, Escolha o tipo de soldado que você quer agora. Digite o número:\n"", jogadorS);
      printf(""1 - Soldado que atira em linha reta.\n"");
      printf(""2 - Soldado que atira em diagonal.\n"");
      printf(""@ - Soldado ESPECIAL, que só pode ser colocado UMA vez, Magicians Red! seu poder é um ataque poderoso em cruz, 3x3 que queima os inimigos na área.\n"");

      scanf("" %c"", & soldado);

      vez2 = 0;
      while (vez2 == 0) {
        if (soldado == '1' || soldado == '2' || soldado == '@' && especial2 == 1) {

          printf(""%s, digite a posição da sua %d° peça, indique a linha e em seguida a coluna:\n"", jogadorS,  [MASK] );

          vez = 1;
          while (vez == 1) {
            scanf("" %s %s"", linhac, colunac);
            strcpy(linhaof, linhac);
            strcpy(colunaa, colunac);
            linha = atoi(linhaof);
            coluna = atoi(colunaa);

            if (tabuleiro[linha][coluna] == '.' && linha >= 7) {
              tabuleiro[linha][coluna] = soldado;
              vez = 0;
              if (soldado == '@') {

                especial2 = 0;

              }
            } else {
              printf(""Local inválido, tente novamente:\n"");

            }
          }
          vez2 = 1;
        } else {
          printf(""Soldado inválido. Tente novamente:\n"");
          scanf("" %c"", & soldado);
        }

      }
      system(""cls"");

      printf(""Norte:%s\n"", jogadorN);
      printf(""Sul:%s\n"", jogadorS);

      for (i = 0; i < LINHAS; i++) {
        for (j = 0; j < COLUNAS; j++) {
          if (tabuleiro[i][j] == '.') printf(""  "");
          else {
            printf(""%c "", tabuleiro[i][j]);
          }
        }
        printf(""\n"");
      }
      // Vez do jogador Norte como segundo jogador.
      printf(""%s, Escolha o tipo de soldado que você quer agora. Digite o número:\n"", jogadorN);
      printf(""1 - Soldado que atira em linha reta.\n"");
      printf(""2 - Soldado que atira em diagonal.\n"");
      printf(""# - Soldado ESPECIAL, que só pode ser colocado UMA vez, Emerald Splash! seu poder é um ataque poderoso em linha reta, que ultrapassa e destroi tudo que toca.\n"");

      scanf("" %c"", & soldado);

      vez2 = 0;
      while (vez2 == 0) {
        if (soldado == '1' || soldado == '2' || soldado == '#' && especial == 1) {

          printf(""%s, digite a posição da sua %d° peça, indique a linha e em seguida a coluna:\n"", jogadorN,  [MASK] );

          vez = 1;
          while (vez == 1) {
            scanf("" %s %s"", linhac, colunac);
            strcpy(linhaof, linhac);
            strcpy(colunaa, colunac);
            linha = atoi(linhaof);
            coluna = atoi(colunaa);

            if (tabuleiro[linha][coluna] == '.' && linha <= 4) {
              tabuleiro[linha][coluna] = soldado;
              vez = 0;
              if (soldado == '#') {

                especial = 0;

              }
            } else {
              printf(""Local inválido, tente novamente:\n"");

            }
          }
          vez2 = 1;
        } else {
          printf(""Soldado inválido. Tente novamente:\n"");
          scanf("" %c"", & soldado);
        }

      }
      system(""cls"");

      printf(""Norte:%s\n"", jogadorN);
      printf(""Sul:%s\n"", jogadorS);

      for (i = 0; i < LINHAS; i++) {
        for (j = 0; j < COLUNAS; j++) {
          if (tabuleiro[i][j] == '.') printf(""  "");
          else {
            printf(""%c "", tabuleiro[i][j]);
          }
        }
        printf(""\n"");
      }
    }
    system(""pause"");
    system(""cls"");

    printf(""Norte:%s\n"", jogadorN);
    printf(""Sul:%s\n"", jogadorS);

    for (i = 0; i < LINHAS; i++) {
      for (j = 0; j < COLUNAS; j++) {
        if (tabuleiro[i][j] == '.') printf(""  "");
        else {
          printf(""%c "", tabuleiro[i][j]);
        }
      }
      printf(""\n"");
    }

  }

  //Acabou os posicionamentos de tropa, agora é a movimentacao e ataque.
  printf(""Todas as tropas foram posicionadas, quem vai vencer?\nO jogador tem 2 opções, movimentar ou atacar.\n"");
  //Jogardor Norte primeiro
  vitoria = 0;
  while (vitoria == 0) {

    if (x % 2 == 0) {

      printf(""%s, Selecione o soldado que voce gostaria de interagir. Digite a posição dele, primeiro linha depois coluna:\nOBS:escolha tropas apenas do seu campo.(Norte)"", jogadorN);
      vez = 0;
      while (vez == 0) {
        scanf("" %s %s"", linhac, colunac);
        strcpy(linhaof, linhac);
        strcpy(colunaa, colunac);
        linha = atoi(linhaof);
        coluna = atoi(colunaa);
        vez2 = 0;
        if (tabuleiro[linha][coluna] == '.' || tabuleiro[linha][coluna] == '*' || tabuleiro[linha][coluna] == '~' || linha > 4) {
          printf(""Local inválido. Tente novamente.\n"");
        } else {
          vez2 = 0;
          while (vez2 == 0) {
            printf(""O que você gostaria de fazer?\nDigite A para atarcar ou M para movimentar\n "");
            scanf("" %c"", & acao);
            vez = 1;

            if (acao == 'A' || acao == 'a') {
              printf(""Voce escolheu atacar.\nOBS: FOGO AMIGO É POSSÍVEL\n"");
              vez2 = 1;

              if (tabuleiro[linha][coluna] == '1') {
                linha2 = linha + 1;
                acertar = 0;

                while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                  if (tabuleiro[linha2][coluna] == '1' || tabuleiro[linha2][coluna] == '2' || tabuleiro[linha2][coluna] == '@') {
                    tabuleiro[linha2][coluna] = '.';
                    printf(""Soldado abatido. na casa %d %d.\n"", linha2, coluna);
                    acertar = 1;
                    system(""pause"");
                  } else {
                    linha2++;
                  }
                }
              }
              if (tabuleiro[linha][coluna] == '2') {
                vez4 = 0;
                while (vez4 == 0) {

                  printf(""O Sniper deverá atirar em qual direção?\n Digite E - para o Sniper atacar na diagonal esquerda.\n Digite D - para o Sniper atirar na diagonal direita.\n"");
                  scanf("" %c"", & tiro);
                  if (tiro == 'D' || tiro == 'd') {
                    vez4 = 1;
                    linha2 = linha + 1;
                    coluna2 = coluna - 1;
                    acertar = 0;
                    while (acertar == 0 && tabuleiro[linha2][coluna2] != '*') {

                      if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '@') {
                        tabuleiro[linha2][coluna2] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                        acertar = 1;
                        system(""pause"");
                      } else {
                        linha2++;
                        coluna2--;
                      }
                    }
                  }
                  if (tiro == 'E' || tiro == 'e') {
                    vez4 = 1;
                    linha2 = linha + 1;
                    coluna2 = coluna + 1;
                    acertar = 0;
                    while (acertar == 0 && tabuleiro[linha2][coluna2] != '*') {
                      if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '@') {
                        tabuleiro[linha2][coluna2] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                        acertar = 1;
                        system(""pause"");
                      } else {
                        linha2++;
                        coluna2++;
                      }
                    }
                  }
                  if (tiro != 'D' && tiro != 'd' && tiro != 'E' && tiro != 'e') {
                    printf(""Direção inválida.\n"");
                  }
                }
              }
              if (tabuleiro[linha][coluna] == '#') {
                printf(""EMERALD SPLASH! NINGUEM NUNCA PODERÁ DESVIAR DELE!\n"");
                linha2 = linha + 1;
                while (tabuleiro[linha2][coluna] != '*') {

                  if (tabuleiro[linha2][coluna] == '1' || tabuleiro[linha2][coluna] == '2' || tabuleiro[linha2][coluna] == '@') {
                    tabuleiro[linha2][coluna] = '.';
                    printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna);
                    system(""pause"");
                  } else {
                    linha2++;
                  }
                }
              }

              soldS = 0;
              for (i = 7; i <= 10; i++) {
                for (j = 1; j <= 10; j++) {
                  if (tabuleiro[i][j] != '.' && tabuleiro[i][j] != '~' && tabuleiro[i][j] != '*') {
                    soldS++;
                  }
                }

              }
              if (soldS == 0) {
                vitoria = 1;

              }
            }
            if (acao == 'M' || acao == 'm') {
              printf(""Você escolheu movimentar.\nOBS: Soldados podem se movimentar apenas uma unidade. O soldado nao pode ocupar rios, montanhas, e outros soldados\n"");
              vez2 = 1;
              vez3 = 0;
              printf(""Digite F - para o soldado ir para frente.\nDigite T - para o soldado ir para trás.\nDigite E - para o soldado ir para esquerda\nDigite D - para o soldado ir para direita.\nDigite V - caso seu soldado esteja cercado, assim passando a vez para o oponente.\n"");
              scanf("" %c"", & direcao);

              while (vez3 == 0) {

                if (direcao == 'F' || direcao == 'f') {
                  if (tabuleiro[linha + 1][coluna] == '.') {

                    tabuleiro[linha + 1][coluna] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;
                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }
                if (direcao == 'T' || direcao == 't') {
                  if (tabuleiro[linha - 1][coluna] == '.') {

                    tabuleiro[linha - 1][coluna] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;

                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }

                if (direcao == 'E' || direcao == 'e') {
                  if (tabuleiro[linha][coluna + 1] == '.') {
                    tabuleiro[linha][coluna + 1] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;

                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }
                if (direcao == 'D' || direcao == 'd') {
                  if (tabuleiro[linha][coluna - 1] == '.') {

                    tabuleiro[linha][coluna - 1] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;

                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }
                if (direcao == 'V' || direcao == 'v') {
                  vez3 = 1;

                }
              } //while
            }
          } // Ação M
          if (acao != 'A' && acao != 'a' && acao != 'M' && acao != 'm') {
            printf(""Ação inválida.\n"");
          }
        }
      }
      // While da ação
      system(""cls"");

      printf(""Norte:%s\n"", jogadorN);
      printf(""Sul:%s\n"", jogadorS);

      for (i = 0; i < LINHAS; i++) {
        for (j = 0; j < COLUNAS; j++) {
          if (tabuleiro[i][j] == '.') printf(""  "");
          else {
            printf(""%c "", tabuleiro[i][j]);
          }
        }
        printf(""\n"");
      }

      // Seleção do soldado
      // While vez normal

      // Vez do Sul como 2°jogador

      if (vitoria == 0) {

        printf(""%s, Selecione o soldado que voce gostaria de interagir. Digite a posição dele, primeiro linha depois coluna:\nOBS:escolha tropas apenas do seu campo.(Sul)"", jogadorS);
        vez = 0;
        vez2 = 0;
        while (vez == 0) {
          scanf("" %s %s"", linhac, colunac);
          strcpy(linhaof, linhac);
          strcpy(colunaa, colunac);
          linha = atoi(linhaof);
          coluna = atoi(colunaa);

          if (tabuleiro[linha][coluna] == '.' || tabuleiro[linha][coluna] == '*' || tabuleiro[linha][coluna] == '~' || linha < 7) {
            printf(""Local inválido. Tente novamente.\n"");

          } else {
            while (vez2 == 0) {
              printf(""O que você gostaria de fazer?\nDigite A para atarcar ou M para movimentar\n "");
              scanf("" %c"", & acao);
              vez = 1;

              if (acao == 'A' || acao == 'a') {
                printf(""Você escolheu atacar.\n OBS: FOGO AMIGO É POSSÍVEL\n"");
                vez2 = 1;

                if (tabuleiro[linha][coluna] == '1') {
                  linha2 = linha - 1;
                  acertar = 0;

                  while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                    if (tabuleiro[linha2][coluna] == '1' || tabuleiro[linha2][coluna] == '2' || tabuleiro[linha2][coluna] == '#') {
                      tabuleiro[linha2][coluna] = '.';
                      printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna);
                      acertar = 1;
                      system(""pause"");
                    } else {

                      linha2--;

                    }
                  }

                }
                if (tabuleiro[linha][coluna] == '2') {
                  vez4 = 0;
                  while (vez4 == 0) {

                    printf(""O Sniper deverá atirar em qual direção?\n Digite E - para o Sniper atacar na diagonal esquerda.\n Digite D - para o Sniper atirar na diagonal direita.\n"");
                    scanf("" %c"", & tiro);
                    if (tiro == 'D' || tiro == 'd') {
                      vez4 = 1;
                      linha2 = linha - 1;
                      coluna2 = coluna + 1;
                      acertar = 0;
                      while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                        if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '#') {
                          tabuleiro[linha2][coluna2] = '.';
                          printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                          acertar = 1;
                          system(""pause"");
                        } else {

                          linha2--;
                          coluna2++;
                        }
                      }

                    }

                    if (tiro == 'E' || tiro == 'e') {

                      vez4 = 1;
                      linha2 = linha - 1;
                      coluna2 = coluna - 1;
                      acertar = 0;
                      while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                        if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '#') {
                          tabuleiro[linha2][coluna2] = '.';
                          printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                          acertar = 1;
                          system(""pause"");
                        } else {

                          linha2--;
                          coluna2--;
                        }
                      }
                      if (tiro != 'D' && tiro != 'd' && tiro != 'E' && tiro != 'e') {
                        printf(""Direção inválida.\n"");
                      }
                    }
                  }
                }
                if (tabuleiro[linha][coluna] == '@') {
                  vez10 = 1;

                  printf(""CROSSFIRE HURRICANE! NINGUEM NUNCA PODERÁ DESVIAR DELE!\n"");

                  printf(""Selecione uma posição para ser bombardeada, a casa nao pode ser montanha. Linha primeiro em seguida a coluna:\n"");
                  while (vez10 == 1) {

                    scanf("" %s %s"", linhac, colunac);
                    strcpy(linhaof, linhac);
                    strcpy(colunaa, colunac);
                    linha = atoi(linhaof);
                    coluna = atoi(colunaa);
                    if (linha == 0 || coluna == 0 || linha == 11 || coluna == 11) {
                      printf(""Local inválido, tente novamente.\n"");
                    } else {
                      vez10 = 0;
                      if (tabuleiro[linha][coluna] == '1' || tabuleiro[linha][coluna] == '@' || tabuleiro[linha][coluna] == '#' || tabuleiro[linha][coluna] == '2') {
                        tabuleiro[linha][coluna] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha, coluna);
                        system(""pause"");
                      }
                      if (tabuleiro[linha + 1][coluna] == '1' || tabuleiro[linha + 1][coluna] == '@' || tabuleiro[linha + 1][coluna] == '#' || tabuleiro[linha + 1][coluna] == '2') {
                        tabuleiro[linha + 1][coluna] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha + 1, coluna);
                        system(""pause"");
                      }
                      if (tabuleiro[linha - 1][coluna] == '1' || tabuleiro[linha - 1][coluna] == '@' || tabuleiro[linha - 1][coluna] == '#' || tabuleiro[linha - 1][coluna] == '2') {
                        tabuleiro[linha - 1][coluna] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha - 1, coluna);
                        system(""pause"");
                      }
                      if (tabuleiro[linha][coluna + 1] == '1' || tabuleiro[linha][coluna + 1] == '@' || tabuleiro[linha][coluna + 1] == '#' || tabuleiro[linha][coluna + 1] == '2') {
                        tabuleiro[linha][coluna + 1] = '.';

                        printf(""Soldado abatido. Na casa %d %d\n"", linha, coluna + 1);
                        system(""pause"");
                      }
                      if (tabuleiro[linha][coluna - 1] == '1' || tabuleiro[linha][coluna - 1] == '@' || tabuleiro[linha][coluna - 1] == '#' || tabuleiro[linha][coluna - 1] == '2') {
                        tabuleiro[linha][coluna - 1] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha, coluna - 1);
                        system(""pause"");
                      }
                    }
                  }
                }
                //averiguar a vitoria do jogador SUL
                soldN = 0;
                for (i = 1; i <= 4; i++) {
                  for (j = 1; j <= 10; j++) {
                    if (tabuleiro[i][j] != '.' && tabuleiro[i][j] != '~' && tabuleiro[i][j] != '*') {
                      soldN++;
                    }
                  }

                }
                if (soldN == 0) {
                  vitoria = 1;
                }
              }
              if (acao == 'M' || acao == 'm') {
                printf(""Você escolheu movimentar.\nOBS: Soldados podem se movimentar apenas uma unidade. O soldado não pode ocupar rios, montanhas, e outros soldados\n"");
                vez2 = 1;
                vez3 = 0;
                printf(""Digite F - para o soldado ir para frente.\nDigite T - para o soldado ir para trás.\nDigite E - para o soldado ir para esquerda\nDigite D - para o soldado ir para direita.\nDigite V - caso seu soldado esteja cercado, você voltará para o menu de ataque ou movimento.\n"");
                scanf("" %c"", & direcao);

                while (vez3 == 0) {
                  if (direcao == 'F' || direcao == 'f') {
                    if (tabuleiro[linha - 1][coluna] == '.') {

                      tabuleiro[linha - 1][coluna] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;
                    } else {
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    }
                  }
                  if (direcao == 'T' || direcao == 't') {
                    if (tabuleiro[linha + 1][coluna] == '.') {

                      tabuleiro[linha + 1][coluna] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;

                    } else {
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    }
                  }

                  if (direcao == 'E' || direcao == 'e') {
                    if (tabuleiro[linha][coluna - 1] == '.') {
                      tabuleiro[linha][coluna - 1] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;

                    } else {
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    }
                  }
                  if (direcao == 'D' || direcao == 'd') {
                    if (tabuleiro[linha][coluna + 1] == '.') {

                      tabuleiro[linha][coluna + 1] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;

                    } else {
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    }
                  }
                  if (direcao == 'V' || direcao == 'v') {
                    vez3 = 1;

                  }
                } //while vez 3

              } // Ação M
              if (acao != 'A' && acao != 'a' && acao != 'M' && acao != 'm') {
                printf(""Ação inválida.\n"");
              }

            } // while da ação
            system(""cls"");

            printf(""Norte:%s\n"", jogadorN);
            printf(""Sul:%s\n"", jogadorS);

            for (i = 0; i < LINHAS; i++) {
              for (j = 0; j < COLUNAS; j++) {
                if (tabuleiro[i][j] == '.') printf(""  "");
                else {
                  printf(""%c "", tabuleiro[i][j]);
                }
              }
              printf(""\n"");
            }

          } // if jogar 1°
        }

        //Jogador Sul primeiro
      } // While vez
    } else {
      printf(""%s, Selecione o soldado que voce gostaria de interagir. Digite a posição dele, primeiro linha depois coluna:\nOBS:escolha tropas apenas do seu campo.(Sul)"", jogadorS);
      vez = 0;
      vez2 = 0;
      while (vez == 0) {
        scanf("" %s %s"", linhac, colunac);
        strcpy(linhaof, linhac);
        strcpy(colunaa, colunac);
        linha = atoi(linhaof);
        coluna = atoi(colunaa);

        if (tabuleiro[linha][coluna] == '.' || tabuleiro[linha][coluna] == '*' || tabuleiro[linha][coluna] == '~' || linha < 7) {
          printf(""Local inválido. Tente novamente.\n"");

        } else {
          while (vez2 == 0) {
            printf(""O que você gostaria de fazer?\nDigite A para atarcar ou M para movimentar\n "");
            scanf("" %c"", & acao);
            vez = 1;

            if (acao == 'A' || acao == 'a') {
              printf(""Você escolheu atacar.\n OBS: FOGO AMIGO É POSSÍVEL\n"");
              vez2 = 1;

              if (tabuleiro[linha][coluna] == '1') {
                linha2 = linha - 1;
                acertar = 0;

                while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                  if (tabuleiro[linha2][coluna] == '1' || tabuleiro[linha2][coluna] == '2' || tabuleiro[linha2][coluna] == '#') {
                    tabuleiro[linha2][coluna] = '.';
                    printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna);
                    acertar = 1;
                    system(""pause"");
                  } else {

                    linha2--;

                  }
                }

              }
              if (tabuleiro[linha][coluna] == '2') {
                vez4 = 0;
                while (vez4 == 0) {

                  printf(""O Sniper deverá atirar em qual direção?\n Digite E - para o Sniper atacar na diagonal esquerda.\n Digite D - para o Sniper atirar na diagonal direita.\n"");
                  scanf("" %c"", & tiro);
                  if (tiro == 'D' || tiro == 'd') {
                    vez4 = 1;
                    linha2 = linha - 1;
                    coluna2 = coluna + 1;
                    acertar = 0;
                    while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                      if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '#') {
                        tabuleiro[linha2][coluna2] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                        acertar = 1;
                        system(""pause"");
                      } else {

                        linha2--;
                        coluna2++;
                      }
                    }

                  }

                  if (tiro == 'E' || tiro == 'e') {

                    vez4 = 1;
                    linha2 = linha - 1;
                    coluna2 = coluna - 1;
                    acertar = 0;
                    while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                      if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '#') {
                        tabuleiro[linha2][coluna2] = '.';
                        printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                        acertar = 1;
                        system(""pause"");
                      } else {

                        linha2--;
                        coluna2--;
                      }
                    }
                    if (tiro != 'D' && tiro != 'd' && tiro != 'E' && tiro != 'e') {
                      printf(""Direção inválida.\n"");
                    }
                  }
                }
              }
              if (tabuleiro[linha][coluna] == '@') {
                vez10 = 1;

                printf(""CROSSFIRE HURRICANE! NINGUEM NUNCA PODERÁ DESVIAR DELE!\n"");
                printf(""Selecione uma posição para ser bombardeada, a casa nao pode ser montanha. Linha primeiro em seguida a coluna:\n"");
                while (vez10 == 1) {

                  scanf("" %s %s"", linhac, colunac);
                  strcpy(linhaof, linhac);
                  strcpy(colunaa, colunac);
                  linha = atoi(linhaof);
                  coluna = atoi(colunaa);
                  if (linha == 0 || coluna == 0 || linha == 11 || coluna == 11) {
                    printf(""Local inválido, tente novamente.\n"");
                  } else {
                    vez10 = 0;
                    if (tabuleiro[linha][coluna] == '1' || tabuleiro[linha][coluna] == '@' || tabuleiro[linha][coluna] == '#' || tabuleiro[linha][coluna] == '2') {
                      tabuleiro[linha][coluna] = '.';
                      printf(""Soldado abatido. Na casa %d %d\n"", linha, coluna);
                      system(""pause"");
                    }
                    if (tabuleiro[linha + 1][coluna] == '1' || tabuleiro[linha + 1][coluna] == '@' || tabuleiro[linha + 1][coluna] == '#' || tabuleiro[linha + 1][coluna] == '2') {
                      tabuleiro[linha + 1][coluna] = '.';
                      printf(""Soldado abatido. Na casa %d %d\n"", linha + 1, coluna);
                      system(""pause"");
                    }
                    if (tabuleiro[linha - 1][coluna] == '1' || tabuleiro[linha - 1][coluna] == '@' || tabuleiro[linha - 1][coluna] == '#' || tabuleiro[linha - 1][coluna] == '2') {
                      tabuleiro[linha - 1][coluna] = '.';
                      printf(""Soldado abatido. Na casa %d %d\n"", linha - 1, coluna);
                      system(""pause"");
                    }
                    if (tabuleiro[linha][coluna + 1] == '1' || tabuleiro[linha][coluna + 1] == '@' || tabuleiro[linha][coluna + 1] == '#' || tabuleiro[linha][coluna + 1] == '2') {
                      tabuleiro[linha][coluna + 1] = '.';

                      printf(""Soldado abatido. Na casa %d %d\n"", linha, coluna + 1);
                      system(""pause"");
                    }
                    if (tabuleiro[linha][coluna - 1] == '1' || tabuleiro[linha][coluna - 1] == '@' || tabuleiro[linha][coluna - 1] == '#' || tabuleiro[linha][coluna - 1] == '2') {
                      tabuleiro[linha][coluna - 1] = '.';
                      printf(""Soldado abatido. Na casa %d %d\n"", linha, coluna - 1);
                      system(""pause"");
                    }
                  }

                }
              }
              //averiguar a vitoria do jogador SUL
              soldN = 0;
              for (i = 1; i <= 4; i++) {
                for (j = 1; j <= 10; j++) {
                  if (tabuleiro[i][j] != '.' && tabuleiro[i][j] != '~' && tabuleiro[i][j] != '*') {
                    soldN++;
                  }
                }

              }
              if (soldN == 0) {
                vitoria = 1;
              }
            }
            if (acao == 'M' || acao == 'm') {
              printf(""Voce escolheu movimentar.\nOBS: Soldados podem se movimentar apenas uma unidade. O soldado nao pode ocupar rios, montanhas, e outros soldados\n"");
              vez2 = 1;
              vez3 = 0;
              printf(""Digite F - para o soldado ir para frente.\nDigite T - para o soldado ir para trás.\nDigite E - para o soldado ir para esquerda\nDigite D - para o soldado ir para direita.\nDigite V - caso seu soldado esteja cercado, você passará a vez para o inimigo.\n"");
              scanf("" %c"", & direcao);

              while (vez3 == 0) {

                if (direcao == 'F' || direcao == 'f') {
                  if (tabuleiro[linha - 1][coluna] == '.') {

                    tabuleiro[linha - 1][coluna] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;
                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }
                if (direcao == 'T' || direcao == 't') {
                  if (tabuleiro[linha + 1][coluna] == '.') {

                    tabuleiro[linha + 1][coluna] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;

                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }

                if (direcao == 'E' || direcao == 'e') {
                  if (tabuleiro[linha][coluna - 1] == '.') {
                    tabuleiro[linha][coluna - 1] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;

                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }
                if (direcao == 'D' || direcao == 'd') {
                  if (tabuleiro[linha][coluna + 1] == '.') {

                    tabuleiro[linha][coluna + 1] = tabuleiro[linha][coluna];
                    tabuleiro[linha][coluna] = '.';
                    vez3 = 1;

                  } else {
                    printf(""Posição inválida. Tente novamente:\n"");
                    scanf("" %c"", & direcao);
                  }
                }
                if (direcao == 'V' || direcao == 'v') {
                  vez3 = 1;

                }
              } //while

            } // Ação M
            if (acao != 'A' && acao != 'a' && acao != 'M' && acao != 'm') {
              printf(""Ação inválida.\n"");

            }
          } // While da ação
          system(""cls"");

          printf(""Norte:%s\n"", jogadorN);
          printf(""Sul:%s\n"", jogadorS);

          for (i = 0; i < LINHAS; i++) {
            for (j = 0; j < COLUNAS; j++) {
              if (tabuleiro[i][j] == '.') printf(""  "");
              else {
                printf(""%c "", tabuleiro[i][j]);
              }
            }
            printf(""\n"");
          }

        } // Seleção do soldado
      } // While vez normal

      // Vez do Norte escolher
      if (vitoria == 0) {
        printf(""%s, Selecione o soldado que voce gostaria de interagir. Digite a posição dele, primeiro linha depois coluna:\nOBS:escolha tropas apenas do seu campo.(Norte)"", jogadorN);
        vez = 0;
        vez2 = 0;
        while (vez == 0) {
          scanf("" %s %s"", linhac, colunac);
          strcpy(linhaof, linhac);
          strcpy(colunaa, colunac);
          linha = atoi(linhaof);
          coluna = atoi(colunaa);

          if (tabuleiro[linha][coluna] == '.' || tabuleiro[linha][coluna] == '*' || tabuleiro[linha][coluna] == '~' || linha > 4) {
            printf(""Local inválido. Tente novamente.\n"");

          } else {
            while (vez2 == 0) {
              printf(""O que você gostaria de fazer?\nDigite A para atarcar ou M para movimentar\n "");
              scanf("" %c"", & acao);
              vez = 1;

              if (acao == 'A' || acao == 'a') {
                printf(""Voce escolheu atacar.\nOBS: FOGO AMIGO É POSSÍVEL\n"");
                vez2 = 1;

                if (tabuleiro[linha][coluna] == '1') {
                  linha2 = linha + 1;
                  acertar = 0;

                  while (acertar == 0 && tabuleiro[linha2][coluna] != '*') {

                    if (tabuleiro[linha2][coluna] == '1' || tabuleiro[linha2][coluna] == '2' || tabuleiro[linha2][coluna] == '@') {
                      tabuleiro[linha2][coluna] = '.';
                      printf(""Soldado abatido. na casa %d %d.\n"", linha2, coluna);
                      acertar = 1;
                      system(""pause"");
                    } else {
                      linha2++;
                    }
                  }
                }
                if (tabuleiro[linha][coluna] == '2') {
                  vez4 = 0;
                  while (vez4 == 0) {

                    printf(""O Sniper deverá atirar em qual direção?\n Digite E - para o Sniper atacar na diagonal esquerda.\n Digite D - para o Sniper atirar na diagonal direita.\n"");
                    scanf("" %c"", & tiro);
                    if (tiro == 'D' || tiro == 'd') {
                      vez4 = 1;
                      linha2 = linha + 1;
                      coluna2 = coluna - 1;
                      acertar = 0;
                      while (acertar == 0 && tabuleiro[linha2][coluna2] != '*') {

                        if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '@') {
                          tabuleiro[linha2][coluna2] = '.';
                          printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                          acertar = 1;
                          system(""pause"");
                        } else {
                          linha2++;
                          coluna2--;
                        }
                      }
                    }
                    if (tiro == 'E' || tiro == 'e') {
                      vez4 = 1;
                      linha2 = linha + 1;
                      coluna2 = coluna + 1;
                      acertar = 0;
                      while (acertar == 0 && tabuleiro[linha2][coluna2] != '*') {
                        if (tabuleiro[linha2][coluna2] == '1' || tabuleiro[linha2][coluna2] == '2' || tabuleiro[linha2][coluna2] == '@') {
                          tabuleiro[linha2][coluna2] = '.';
                          printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna2);
                          acertar = 1;
                          system(""pause"");
                        } else {
                          linha2++;
                          coluna2++;
                        }
                      }
                    }
                    if (tiro != 'D' && tiro != 'd' && tiro != 'E' && tiro != 'e') {
                      printf(""Direção inválida.\n"");
                    }
                  }
                }
                if (tabuleiro[linha][coluna] == '#') {
                  printf(""EMERALD SPLASH! NINGUEM NUNCA PODERÁ DESVIAR DELE!\n"");
                  linha2 = linha + 1;
                  while (tabuleiro[linha2][coluna] != '*') {

                    if (tabuleiro[linha2][coluna] == '1' || tabuleiro[linha2][coluna] == '2' || tabuleiro[linha2][coluna] == '@') {
                      tabuleiro[linha2][coluna] = '.';
                      printf(""Soldado abatido. Na casa %d %d\n"", linha2, coluna);
                      system(""pause"");
                    } else {
                      linha2++;
                    }
                  }
                }

                soldS = 0;
                for (i = 7; i <= 10; i++) {
                  for (j = 1; j <= 10; j++) {
                    if (tabuleiro[i][j] != '.' && tabuleiro[i][j] != '~' && tabuleiro[i][j] != '*') {
                      soldS++;
                    }
                  }

                }
                if (soldS == 0) {
                  vitoria = 1;

                }
              }
              if (acao == 'M' || acao == 'm') {
                printf(""Voce escolheu movimentar.\nOBS: Soldados podem se movimentar apenas uma unidade. O soldado nao pode ocupar rios, montanhas, e outros soldados\n"");
                vez2 = 1;
                vez3 = 0;
                printf(""Digite F - para o soldado ir para frente.\nDigite T - para o soldado ir para trás.\nDigite E - para o soldado ir para esquerda\nDigite D - para o soldado ir para direita.\nDigite V - caso seu soldado esteja cercado, você passará a vez para o inimigo.\n"");
                scanf("" %c"", & direcao);

                while (vez3 == 0) {

                  if (direcao == 'F' || direcao == 'f') {
                    if (tabuleiro[linha + 1][coluna] == '.') {
                      
                      tabuleiro[linha + 1][coluna] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;

                    } else {
                      
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    
                    }
                  }
                  if (direcao == 'T' || direcao == 't') {
                    if (tabuleiro[linha - 1][coluna] == '.') {

                      tabuleiro[linha - 1][coluna] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;

                    } else {
                      
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    
                    }
                  }

                  if (direcao == 'E' || direcao == 'e') {
                    
                    if(tabuleiro[linha][coluna + 1] == '.') {
                      
                      tabuleiro[linha][coluna + 1] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;

                    } else {
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    }
                  }
                  if (direcao == 'D' || direcao == 'd') {
                    if (tabuleiro[linha][coluna - 1] == '.') {

                      tabuleiro[linha][coluna - 1] = tabuleiro[linha][coluna];
                      tabuleiro[linha][coluna] = '.';
                      vez3 = 1;

                    } else {
                      printf(""Posição inválida. Tente novamente:\n"");
                      scanf("" %c"", & direcao);
                    }
                  }
                  if (direcao == 'V' || direcao == 'v') {
                    vez3 = 1;

                  }
                } //while

              } // Ação M
              if (acao != 'A' && acao != 'a' && acao != 'M' && acao != 'm') {
                printf(""Ação inválida.\n"");

              }
            } // While da ação
            system(""cls"");

            printf(""Norte:%s\n"", jogadorN);
            printf(""Sul:%s\n"", jogadorS);

            for (i = 0; i < LINHAS; i++) {
              for (j = 0; j < COLUNAS; j++) {
                if (tabuleiro[i][j] == '.') printf(""  "");
                else {
                  printf(""%c "", tabuleiro[i][j]);
                }
              }
              printf(""\n"");
            }

          }
        }
      }
    }
  }
  if (soldN == 0) {
    printf(""%s VOCÊ CONQUISTOU A LAPÔNIA!\n"", jogadorS);
  } else {
    printf(""%s VOCÊ CONQUISTOU A LAPÔNIA!\n"", jogadorN);
  }
  return 0;
}
",peca
14,"#include <iostream>
#include <fstream>
#include <string>

using namespace std;

// Structure to hold student information
struct Student {
    string name;
    int rollNumber;
    string address;
    string phoneNumber;
};

// Function to display menu options
void displayMenu() {
    cout << ""========= Student Record Management System ========="" << endl;
    cout << ""1. Add New Student"" << endl;
    cout << ""2. Display All Students"" << endl;
    cout << ""3. Search Student"" << endl;
    cout << ""4. Update Student Details"" << endl;
    cout << ""5. Delete Student"" << endl;
    cout << ""6. Exit"" << endl;
    cout << ""==================================================="" << endl;
    cout << ""Enter your choice (1-6): "";
}

// Function to add a new student to the records
void addStudent() {
    Student student;
    cout << ""Enter Student Name: "";
    getline(cin.ignore(), student.name);
    cout << ""Enter Roll Number: "";
    cin >> student.rollNumber;
    cin.ignore();
    cout << ""Enter Address: "";
    getline(cin, student.address);
    cout << ""Enter Phone Number: "";
    getline(cin, student.phoneNumber);

    ofstream file(""students.txt"", ios::app);
    if (file.is_open()) {
        file << student.name << "","" << student.rollNumber << "","" << student.address << "","" << student.phoneNumber << endl;
        file.close();
        cout << ""Student record added successfully!"" << endl;
    } else {
        cout << ""Unable to open file!"" << endl;
    }
}

// Function to display all students from the records
void displayAllStudents() {
    ifstream file(""students.txt"");
    if (file.is_open()) {
        string line;
        cout << ""========= All Students ========="" << endl;
        while (getline(file, line)) {
            stringstream ss(line);
            string name, address, phoneNumber;
            int rollNumber;
            getline(ss, name, ',');
            ss >> rollNumber;
            ss.ignore();
            getline(ss, address, ',');
            getline(ss, phoneNumber);
            cout << ""Name: "" << name << endl;
            cout << ""Roll Number: "" << rollNumber << endl;
            cout << ""Address: "" << address << endl;
            cout << ""Phone Number: "" << phoneNumber << endl;
            cout << ""-------------------------------"" << endl;
        }
        file.close();
    } else {
        cout << ""Unable to open file!"" << endl;
    }
}

// Function to search for a student by roll number
void searchStudent() {
    int rollNumber;
    cout << ""Enter Roll Number to search: "";
    cin >> rollNumber;
    cin.ignore();

    ifstream file(""students.txt"");
    if (file.is_open()) {
        string line;
        bool found = false;
        while (getline(file, line)) {
            stringstream ss(line);
            string name, address, phoneNumber;
            int fileRollNumber;
            getline(ss, name, ',');
            ss >> fileRollNumber;
            ss.ignore();
            getline(ss, address, ',');
            getline(ss, phoneNumber);
            if (fileRollNumber == rollNumber) {
                cout << ""========= Student Details ========="" << endl;
                cout << ""Name: "" << name << endl;
                cout << ""Roll Number: "" << rollNumber << endl;
                cout << ""Address: "" << address << endl;
                cout << ""Phone Number: "" << phoneNumber << endl;
                cout << ""-------------------------------"" << endl;
                found = true;
                break;
            }
        }
        if (!found) {
            cout << ""Student not found!"" << endl;
        }
        file.close();
    } else {
        cout << ""Unable to open file!"" << endl;
    }
}

// Function to update student details
void updateStudent() {
    int rollNumber;
    cout << ""Enter Roll Number to update: "";
    cin >> rollNumber;
    cin.ignore();

    fstream file(""students.txt"", ios::in | ios::out);
    if (file.is_open()) {
        string line;
        bool found = false;
        while (getline(file, line)) {
            stringstream ss(line);
            string name, address, phoneNumber;
            int fileRollNumber;
            getline(ss, name, ',');
            ss >> fileRollNumber;
            ss.ignore();
            getline(ss, address, ',');
            getline(ss, phoneNumber);
            if (fileRollNumber == rollNumber) {
                cout << ""========= Student Details ========="" << endl;
                cout << ""Name: "" << name << endl;
                cout << ""Roll Number: "" << rollNumber << endl;
                cout << ""Address: "" << address << endl;
                cout << ""Phone Number: "" << phoneNumber << endl;
                cout << ""-------------------------------"" << endl;

                // Update student details
                Student updatedStudent;
                cout << ""Enter Updated Student Name: "";
                getline(cin.ignore(), updatedStudent.name);
                cout << ""Enter Updated Address: "";
                getline(cin, updatedStudent.address);
                cout << ""Enter Updated Phone Number: "";
                getline(cin, updatedStudent.phoneNumber);

                // Write updated details to the file
                file.seekp(file.tellg() - line.length() - 1);
                file << updatedStudent.name << "","" << rollNumber << "","" << updatedStudent.address << "","" << updatedStudent.phoneNumber << endl;

                cout << ""Student record updated successfully!"" << endl;
                found = true;
                break;
            }
        }
        if (!found) {
            cout << ""Student not found!"" << endl;
        }
        file.close();
    } else {
        cout << ""Unable to open file!"" << endl;
    }
}

// Function to delete a student from the records
void deleteStudent() {
    int rollNumber;
    cout << ""Enter Roll Number to delete: "";
    cin >> rollNumber;
    cin.ignore();

    ifstream  [MASK] (""students.txt"");
    if ( [MASK] .is_open()) {
        ofstream outputFile(""temp.txt"");
        if (outputFile.is_open()) {
            string line;
            bool found = false;
            while (getline( [MASK] , line)) {
                stringstream ss(line);
                string name, address, phoneNumber;
                int fileRollNumber;
                getline(ss, name, ',');
                ss >> fileRollNumber;
                ss.ignore();
                getline(ss, address, ',');
                getline(ss, phoneNumber);
                if (fileRollNumber == rollNumber) {
                    cout << ""========= Student Details ========="" << endl;
                    cout << ""Name: "" << name << endl;
                    cout << ""Roll Number: "" << rollNumber << endl;
                    cout << ""Address: "" << address << endl;
                    cout << ""Phone Number: "" << phoneNumber << endl;
                    cout << ""-------------------------------"" << endl;

                    cout << ""Student record deleted successfully!"" << endl;
                    found = true;
                } else {
                    outputFile << line << endl;
                }
            }
            if (!found) {
                cout << ""Student not found!"" << endl;
            }
            outputFile.close();
             [MASK] .close();

            remove(""students.txt"");
            rename(""temp.txt"", ""students.txt"");
        } else {
            cout << ""Unable to create temporary file!"" << endl;
        }
    } else {
        cout << ""Unable to open file!"" << endl;
    }
}

int main() {
    int choice;

    do {
        displayMenu();
        cin >> choice;
        cin.ignore();

        switch (choice) {
            case 1:
                addStudent();
                break;
            case 2:
                displayAllStudents();
                break;
            case 3:
                searchStudent();
                break;
            case 4:
                updateStudent();
                break;
            case 5:
                deleteStudent();
                break;
            case 6:
                cout << ""Thank you for using the Student Record Management System!"" << endl;
                break;
            default:
                cout << ""Invalid choice! Please enter a number between 1 and 6."" << endl;
                break;
        }

        cout << endl;
    } while (choice != 6);

    return 0;
}
",inputFile
15,"#include ""../../Algorithm.hpp""

int main()
{
	std::vector<int> arr;
	for (int i = 0; i < 10000; ++i)
		arr.push_back(i);

	std::default_random_engine g(time(0));

	auto  [MASK]  = std::chrono::system_clock::now();
	auto end = std::chrono::system_clock::now();

	std::chrono::duration<double> elapsed_seconds;
	// std::time_t end_time;

	//* Bubble Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nBubble Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::bubble_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	//* Comb Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nComb Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::comb_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	//* Heap Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nHeap Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::heap_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	//* Insertion Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nInsertion Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::insertion_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	//* Merge Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nMerge Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::merge_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	//* Quick Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nQuick Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::quick_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	//* Selection Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nSelection Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::selection_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	//* Shell Sort Test
	//* Random Shuffle Arr
	std::shuffle(arr.begin(), arr.end(), g);
	std::cout << ""\nShell Sort :"" << std::endl;
	alg::array_print(arr);
	 [MASK]  = std::chrono::system_clock::now();
	alg::shell_sort(arr);
	end = std::chrono::system_clock::now();
	alg::array_print(arr);
	elapsed_seconds = end -  [MASK] ;
	std::cout << ""elapsed time: "" << elapsed_seconds.count() << ""s\n"";

	return 0;
}
",start
16,"#ifndef IPC_SOCKET_CONNECTION_HPP
#define IPC_SOCKET_CONNECTION_HPP

#include ""../FileDescriptor.hpp""
#include ""../Utils.hpp""
#include ""Address.hpp""
#include ""Type.hpp""

namespace ipc {

namespace socket {

class Connection {
public:

    explicit Connection(FileDescriptor fd) : fd_(std::move(fd)) {}

    ssize_t Recv(void *data, std::size_t size) const {
        return CallSys(::read, int(fd_), data, size);
    }

    ssize_t Send(const void *data, std::size_t size) const {
        return CallSys(::write, int(fd_), data, size);
    }

private:
    FileDescriptor fd_;
};

inline Connection Connect(Type type, const Address& address) {
    int  [MASK]  = type == Type::STREAM ? SOCK_STREAM : SOCK_SEQPACKET;
    FileDescriptor fd(CallSys(::socket, AF_UNIX,  [MASK] , 0));

    CallSys(::connect, int(fd), (const struct sockaddr *) &address.UnixAddress(), address.Length());

    return Connection(std::move(fd));
}

} // namespace socket

} // namespace ipc

#endif // IPC_SOCKET_CONNECTION_HPP",sock_type
17,"#include <iostream>
#include ""movies.hh""
#include ""utilities.hh""

//#define DEBUG

#ifdef DEBUG
#define dout std::cout
#else
#define dout 0 && std::cout
#endif


int main()
{
    std::cout << ""Welcome to the movies!"" << std::endl;
    std::cout << ""----------------------"" << std::endl;
    std::cout << ""----------------------"" << std::endl;
    std::cout << std::endl << std::endl;
    std::map<std::string,std::map<std::string,std::map<std::string,std::map<std::string,std::string>>>> movies_ds; //Data struct for movies app

    Utilities utilities;
    Movies movies;
    std::string  [MASK]  = "" "";
#ifdef DEBUG
     [MASK]  = ""test.txt"";
#else
    std::cout << ""Input file: "";
    getline(std::cin,  [MASK] );
#endif
    movies_ds = movies.read_saved_movies_data( [MASK] );
    movies.print_movies_ds(movies_ds);

    while(1)
    {
        std::string line;
        std::cout << ""the> "";
        getline(std::cin, line);
        std::vector<std::string> parts = utilities.split(line, ' ');
        if(parts.size() == 0)   // Allowing empty inputs
        {
            continue;
        }
        std::string command = parts.at(0);

        if(command == ""multiplex"")
        {
            movies.show_multiplex(movies_ds);
        }
        else if(command == ""auditorium"")
        {
            if(parts.size()>1)
            {
                std::cout<<WRONG_PARAMETERS<<std::endl;
                continue;
            }
            else movies.show_multiplex_halls(movies_ds);
        }
        else if(command == ""multiplex_of_auditorium"")
        {
            if(parts.size()<2)
            {
                std::cout<<WRONG_PARAMETERS<<std::endl;
                continue;
            }
            std::string auditorium_name = parts.at(1);
            dout<<""Getting name of the multiplex of auditorium:""<<auditorium_name<<std::endl<<std::endl;
            movies.get_multiplex_name_of_a_auditorium(movies_ds, auditorium_name);
        }

        else if(command == ""movies_in_city"")
        {
            if(parts.size() !=2)
            {
                std::cout<<WRONG_PARAMETERS<<std::endl;
                continue;
            }
            std::string movies_in_city = parts.at(1);
            dout<<""Getting movies in City: ""<<movies_in_city<<std::endl<<std::endl;
            movies.get_movies_name_in_a_city(movies_ds,movies_in_city);
        }
        else if(command == ""quit"")
        {
            return EXIT_SUCCESS;
        }
        else
        {
            std::cout<<COMMAND_NOT_FOUND<<std::endl;
        }
    }

    return 0;
}
",stored_filename
18,"// File: bc7enc.c - <NAME>, Jr. 3/31/2020 - MIT license or public domain (see end of file)
// Currently supports modes 1, 6 for RGB blocks, and modes 5, 6, 7 for RGBA blocks.
#include ""bc7enc.h""

#include <math.h>
#include <memory.h>
#include <assert.h>
#include <limits.h>
#include <algorithm>

// Helpers
static inline int32_t clampi(int32_t value, int32_t low, int32_t high) { if (value < low) value = low; else if (value > high) value = high;	return value; }
static inline float clampf(float value, float low, float high) { if (value < low) value = low; else if (value > high) value = high;	return value; }
static inline float saturate(float value) { return clampf(value, 0, 1.0f); }
static inline uint8_t minimumub(uint8_t a, uint8_t b) { return (a < b) ? a : b; }
static inline int32_t minimumi(int32_t a, int32_t b) { return (a < b) ? a : b; }
static inline uint32_t minimumu(uint32_t a, uint32_t b) { return (a < b) ? a : b; }
static inline float minimumf(float a, float b) { return (a < b) ? a : b; }
static inline uint8_t maximumub(uint8_t a, uint8_t b) { return (a > b) ? a : b; }
static inline uint32_t maximumu(uint32_t a, uint32_t b) { return (a > b) ? a : b; }
static inline int32_t maximumi(int32_t a, int32_t b) { return (a > b) ? a : b; }
static inline float maximumf(float a, float b) { return (a > b) ? a : b; }
static inline int squarei(int i) { return i * i; }
static inline float squaref(float i) { return i * i; }
template <typename T0, typename T1> inline T0 lerp(T0 a, T0 b, T1 c) { return a + (b - a) * c; }

static inline int32_t iabs32(int32_t v) { uint32_t msk = v >> 31; return (v ^ msk) - msk; }
static inline void swapub(uint8_t* a, uint8_t* b) { uint8_t t = *a; *a = *b; *b = t; }
static inline void swapu(uint32_t* a, uint32_t* b) { uint32_t t = *a; *a = *b; *b = t; }
static inline void swapf(float* a, float* b) { float t = *a; *a = *b; *b = t; }

struct vec4F { float m_c[4]; };

static inline color_rgba *color_quad_u8_set_clamped(color_rgba *pRes, int32_t r, int32_t g, int32_t b, int32_t a) { pRes->m_c[0] = (uint8_t)clampi(r, 0, 255); pRes->m_c[1] = (uint8_t)clampi(g, 0, 255); pRes->m_c[2] = (uint8_t)clampi(b, 0, 255); pRes->m_c[3] = (uint8_t)clampi(a, 0, 255); return pRes; }
static inline color_rgba *color_quad_u8_set(color_rgba *pRes, int32_t r, int32_t g, int32_t b, int32_t a) { assert((uint32_t)(r | g | b | a) <= 255); pRes->m_c[0] = (uint8_t)r; pRes->m_c[1] = (uint8_t)g; pRes->m_c[2] = (uint8_t)b; pRes->m_c[3] = (uint8_t)a; return pRes; }
static inline bool color_quad_u8_notequals(const color_rgba *pLHS, const color_rgba *pRHS) { return (pLHS->m_c[0] != pRHS->m_c[0]) || (pLHS->m_c[1] != pRHS->m_c[1]) || (pLHS->m_c[2] != pRHS->m_c[2]) || (pLHS->m_c[3] != pRHS->m_c[3]); }
static inline vec4F *vec4F_set_scalar(vec4F *pV, float x) {	pV->m_c[0] = x; pV->m_c[1] = x; pV->m_c[2] = x;	pV->m_c[3] = x;	return pV; }
static inline vec4F *vec4F_set(vec4F *pV, float x, float y, float z, float w) {	pV->m_c[0] = x;	pV->m_c[1] = y;	pV->m_c[2] = z;	pV->m_c[3] = w;	return pV; }
static inline vec4F *vec4F_saturate_in_place(vec4F *pV) { pV->m_c[0] = saturate(pV->m_c[0]); pV->m_c[1] = saturate(pV->m_c[1]); pV->m_c[2] = saturate(pV->m_c[2]); pV->m_c[3] = saturate(pV->m_c[3]); return pV; }
static inline vec4F vec4F_saturate(const vec4F *pV) { vec4F res; res.m_c[0] = saturate(pV->m_c[0]); res.m_c[1] = saturate(pV->m_c[1]); res.m_c[2] = saturate(pV->m_c[2]); res.m_c[3] = saturate(pV->m_c[3]); return res; }
static inline vec4F vec4F_from_color(const color_rgba *pC) { vec4F res; vec4F_set(&res, pC->m_c[0], pC->m_c[1], pC->m_c[2], pC->m_c[3]); return res; }
static inline vec4F vec4F_add(const vec4F *pLHS, const vec4F *pRHS) { vec4F res; vec4F_set(&res, pLHS->m_c[0] + pRHS->m_c[0], pLHS->m_c[1] + pRHS->m_c[1], pLHS->m_c[2] + pRHS->m_c[2], pLHS->m_c[3] + pRHS->m_c[3]); return res; }
static inline vec4F vec4F_sub(const vec4F *pLHS, const vec4F *pRHS) { vec4F res; vec4F_set(&res, pLHS->m_c[0] - pRHS->m_c[0], pLHS->m_c[1] - pRHS->m_c[1], pLHS->m_c[2] - pRHS->m_c[2], pLHS->m_c[3] - pRHS->m_c[3]); return res; }
static inline float vec4F_dot(const vec4F *pLHS, const vec4F *pRHS) { return pLHS->m_c[0] * pRHS->m_c[0] + pLHS->m_c[1] * pRHS->m_c[1] + pLHS->m_c[2] * pRHS->m_c[2] + pLHS->m_c[3] * pRHS->m_c[3]; }
static inline vec4F vec4F_mul(const vec4F *pLHS, float s) { vec4F res; vec4F_set(&res, pLHS->m_c[0] * s, pLHS->m_c[1] * s, pLHS->m_c[2] * s, pLHS->m_c[3] * s); return res; }
static inline vec4F *vec4F_normalize_in_place(vec4F *pV) { float s = pV->m_c[0] * pV->m_c[0] + pV->m_c[1] * pV->m_c[1] + pV->m_c[2] * pV->m_c[2] + pV->m_c[3] * pV->m_c[3]; if (s != 0.0f) { s = 1.0f / sqrtf(s); pV->m_c[0] *= s; pV->m_c[1] *= s; pV->m_c[2] *= s; pV->m_c[3] *= s; } return pV; }

// Various BC7 tables
static const uint32_t g_bc7_weights2[4] = { 0, 21, 43, 64 };
static const uint32_t g_bc7_weights3[8] = { 0, 9, 18, 27, 37, 46, 55, 64 };
static const uint32_t g_bc7_weights4[16] = { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 };
// Precomputed weight constants used during least fit determination. For each entry in g_bc7_weights[]: w * w, (1.0f - w) * w, (1.0f - w) * (1.0f - w), w
static const float g_bc7_weights2x[4 * 4] = { 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.107666f, 0.220459f, 0.451416f, 0.328125f, 0.451416f, 0.220459f, 0.107666f, 0.671875f, 1.000000f, 0.000000f, 0.000000f, 1.000000f };
static const float g_bc7_weights3x[8 * 4] = { 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.019775f, 0.120850f, 0.738525f, 0.140625f, 0.079102f, 0.202148f, 0.516602f, 0.281250f, 0.177979f, 0.243896f, 0.334229f, 0.421875f, 0.334229f, 0.243896f, 0.177979f, 0.578125f, 0.516602f, 0.202148f,
	0.079102f, 0.718750f, 0.738525f, 0.120850f, 0.019775f, 0.859375f, 1.000000f, 0.000000f, 0.000000f, 1.000000f };
static const float g_bc7_weights4x[16 * 4] = { 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.003906f, 0.058594f, 0.878906f, 0.062500f, 0.019775f, 0.120850f, 0.738525f, 0.140625f, 0.041260f, 0.161865f, 0.635010f, 0.203125f, 0.070557f, 0.195068f, 0.539307f, 0.265625f, 0.107666f, 0.220459f,
	0.451416f, 0.328125f, 0.165039f, 0.241211f, 0.352539f, 0.406250f, 0.219727f, 0.249023f, 0.282227f, 0.468750f, 0.282227f, 0.249023f, 0.219727f, 0.531250f, 0.352539f, 0.241211f, 0.165039f, 0.593750f, 0.451416f, 0.220459f, 0.107666f, 0.671875f, 0.539307f, 0.195068f, 0.070557f, 0.734375f,
	0.635010f, 0.161865f, 0.041260f, 0.796875f, 0.738525f, 0.120850f, 0.019775f, 0.859375f, 0.878906f, 0.058594f, 0.003906f, 0.937500f, 1.000000f, 0.000000f, 0.000000f, 1.000000f };

static const uint8_t g_bc7_partition1[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
static const uint8_t g_bc7_partition2[64 * 16] =
{
	0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,		0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,		0,1,1,1,0,1,1,1,0,1,1,1,0,1,1,1,		0,0,0,1,0,0,1,1,0,0,1,1,0,1,1,1,		0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,1,		0,0,1,1,0,1,1,1,0,1,1,1,1,1,1,1,		0,0,0,1,0,0,1,1,0,1,1,1,1,1,1,1,		0,0,0,0,0,0,0,1,0,0,1,1,0,1,1,1,
	0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,		0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,		0,0,0,0,0,0,0,1,0,1,1,1,1,1,1,1,		0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,		0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,		0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,		0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,		0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
	0,0,0,0,1,0,0,0,1,1,1,0,1,1,1,1,		0,1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,		0,0,0,0,0,0,0,0,1,0,0,0,1,1,1,0,		0,1,1,1,0,0,1,1,0,0,0,1,0,0,0,0,		0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,		0,0,0,0,1,0,0,0,1,1,0,0,1,1,1,0,		0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,		0,1,1,1,0,0,1,1,0,0,1,1,0,0,0,1,
	0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,0,		0,0,0,0,1,0,0,0,1,0,0,0,1,1,0,0,		0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,		0,0,1,1,0,1,1,0,0,1,1,0,1,1,0,0,		0,0,0,1,0,1,1,1,1,1,1,0,1,0,0,0,		0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,		0,1,1,1,0,0,0,1,1,0,0,0,1,1,1,0,		0,0,1,1,1,0,0,1,1,0,0,1,1,1,0,0,
	0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,		0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,		0,1,0,1,1,0,1,0,0,1,0,1,1,0,1,0,		0,0,1,1,0,0,1,1,1,1,0,0,1,1,0,0,		0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,		0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0,		0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,		0,1,0,1,1,0,1,0,1,0,1,0,0,1,0,1,
	0,1,1,1,0,0,1,1,1,1,0,0,1,1,1,0,		0,0,0,1,0,0,1,1,1,1,0,0,1,0,0,0,		0,0,1,1,0,0,1,0,0,1,0,0,1,1,0,0,		0,0,1,1,1,0,1,1,1,1,0,1,1,1,0,0,		0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,		0,0,1,1,1,1,0,0,1,1,0,0,0,0,1,1,		0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,1,		0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,
	0,1,0,0,1,1,1,0,0,1,0,0,0,0,0,0,		0,0,1,0,0,1,1,1,0,0,1,0,0,0,0,0,		0,0,0,0,0,0,1,0,0,1,1,1,0,0,1,0,		0,0,0,0,0,1,0,0,1,1,1,0,0,1,0,0,		0,1,1,0,1,1,0,0,1,0,0,1,0,0,1,1,		0,0,1,1,0,1,1,0,1,1,0,0,1,0,0,1,		0,1,1,0,0,0,1,1,1,0,0,1,1,1,0,0,		0,0,1,1,1,0,0,1,1,1,0,0,0,1,1,0,
	0,1,1,0,1,1,0,0,1,1,0,0,1,0,0,1,		0,1,1,0,0,0,1,1,0,0,1,1,1,0,0,1,		0,1,1,1,1,1,1,0,1,0,0,0,0,0,0,1,		0,0,0,1,1,0,0,0,1,1,1,0,0,1,1,1,		0,0,0,0,1,1,1,1,0,0,1,1,0,0,1,1,		0,0,1,1,0,0,1,1,1,1,1,1,0,0,0,0,		0,0,1,0,0,0,1,0,1,1,1,0,1,1,1,0,		0,1,0,0,0,1,0,0,0,1,1,1,0,1,1,1
};

static const uint8_t g_bc7_partition3[64 * 16] =
{
	0,0,1,1,0,0,1,1,0,2,2,1,2,2,2,2,		0,0,0,1,0,0,1,1,2,2,1,1,2,2,2,1,		0,0,0,0,2,0,0,1,2,2,1,1,2,2,1,1,		0,2,2,2,0,0,2,2,0,0,1,1,0,1,1,1,		0,0,0,0,0,0,0,0,1,1,2,2,1,1,2,2,		0,0,1,1,0,0,1,1,0,0,2,2,0,0,2,2,		0,0,2,2,0,0,2,2,1,1,1,1,1,1,1,1,		0,0,1,1,0,0,1,1,2,2,1,1,2,2,1,1,
	0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,		0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,		0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,		0,0,1,2,0,0,1,2,0,0,1,2,0,0,1,2,		0,1,1,2,0,1,1,2,0,1,1,2,0,1,1,2,		0,1,2,2,0,1,2,2,0,1,2,2,0,1,2,2,		0,0,1,1,0,1,1,2,1,1,2,2,1,2,2,2,		0,0,1,1,2,0,0,1,2,2,0,0,2,2,2,0,
	0,0,0,1,0,0,1,1,0,1,1,2,1,1,2,2,		0,1,1,1,0,0,1,1,2,0,0,1,2,2,0,0,		0,0,0,0,1,1,2,2,1,1,2,2,1,1,2,2,		0,0,2,2,0,0,2,2,0,0,2,2,1,1,1,1,		0,1,1,1,0,1,1,1,0,2,2,2,0,2,2,2,		0,0,0,1,0,0,0,1,2,2,2,1,2,2,2,1,		0,0,0,0,0,0,1,1,0,1,2,2,0,1,2,2,		0,0,0,0,1,1,0,0,2,2,1,0,2,2,1,0,
	0,1,2,2,0,1,2,2,0,0,1,1,0,0,0,0,		0,0,1,2,0,0,1,2,1,1,2,2,2,2,2,2,		0,1,1,0,1,2,2,1,1,2,2,1,0,1,1,0,		0,0,0,0,0,1,1,0,1,2,2,1,1,2,2,1,		0,0,2,2,1,1,0,2,1,1,0,2,0,0,2,2,		0,1,1,0,0,1,1,0,2,0,0,2,2,2,2,2,		0,0,1,1,0,1,2,2,0,1,2,2,0,0,1,1,		0,0,0,0,2,0,0,0,2,2,1,1,2,2,2,1,
	0,0,0,0,0,0,0,2,1,1,2,2,1,2,2,2,		0,2,2,2,0,0,2,2,0,0,1,2,0,0,1,1,		0,0,1,1,0,0,1,2,0,0,2,2,0,2,2,2,		0,1,2,0,0,1,2,0,0,1,2,0,0,1,2,0,		0,0,0,0,1,1,1,1,2,2,2,2,0,0,0,0,		0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,		0,1,2,0,2,0,1,2,1,2,0,1,0,1,2,0,		0,0,1,1,2,2,0,0,1,1,2,2,0,0,1,1,
	0,0,1,1,1,1,2,2,2,2,0,0,0,0,1,1,		0,1,0,1,0,1,0,1,2,2,2,2,2,2,2,2,		0,0,0,0,0,0,0,0,2,1,2,1,2,1,2,1,		0,0,2,2,1,1,2,2,0,0,2,2,1,1,2,2,		0,0,2,2,0,0,1,1,0,0,2,2,0,0,1,1,		0,2,2,0,1,2,2,1,0,2,2,0,1,2,2,1,		0,1,0,1,2,2,2,2,2,2,2,2,0,1,0,1,		0,0,0,0,2,1,2,1,2,1,2,1,2,1,2,1,
	0,1,0,1,0,1,0,1,0,1,0,1,2,2,2,2,		0,2,2,2,0,1,1,1,0,2,2,2,0,1,1,1,		0,0,0,2,1,1,1,2,0,0,0,2,1,1,1,2,		0,0,0,0,2,1,1,2,2,1,1,2,2,1,1,2,		0,2,2,2,0,1,1,1,0,1,1,1,0,2,2,2,		0,0,0,2,1,1,1,2,1,1,1,2,0,0,0,2,		0,1,1,0,0,1,1,0,0,1,1,0,2,2,2,2,		0,0,0,0,0,0,0,0,2,1,1,2,2,1,1,2,
	0,1,1,0,0,1,1,0,2,2,2,2,2,2,2,2,		0,0,2,2,0,0,1,1,0,0,1,1,0,0,2,2,		0,0,2,2,1,1,2,2,1,1,2,2,0,0,2,2,		0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,2,		0,0,0,2,0,0,0,1,0,0,0,2,0,0,0,1,		0,2,2,2,1,2,2,2,0,2,2,2,1,2,2,2,		0,1,0,1,2,2,2,2,2,2,2,2,2,2,2,2,		0,1,1,1,2,0,1,1,2,2,0,1,2,2,2,0,
};

static const uint8_t g_bc7_table_anchor_index_third_subset_1[64] =
{
	3, 3,15,15, 8, 3,15,15,		8, 8, 6, 6, 6, 5, 3, 3,		3, 3, 8,15, 3, 3, 6,10,		5, 8, 8, 6, 8, 5,15,15,		8,15, 3, 5, 6,10, 8,15,		15, 3,15, 5,15,15,15,15,		3,15, 5, 5, 5, 8, 5,10,		5,10, 8,13,15,12, 3, 3
};

static const uint8_t g_bc7_table_anchor_index_third_subset_2[64] =
{
	15, 8, 8, 3,15,15, 3, 8,		15,15,15,15,15,15,15, 8,		15, 8,15, 3,15, 8,15, 8,		3,15, 6,10,15,15,10, 8,		15, 3,15,10,10, 8, 9,10,		6,15, 8,15, 3, 6, 6, 8,		15, 3,15,15,15,15,15,15,		15,15,15,15, 3,15,15, 8
};

static const uint8_t g_bc7_table_anchor_index_second_subset[64] = {	15,15,15,15,15,15,15,15,		15,15,15,15,15,15,15,15,		15, 2, 8, 2, 2, 8, 8,15,		2, 8, 2, 2, 8, 8, 2, 2,		15,15, 6, 8, 2, 8,15,15,		2, 8, 2, 2, 2,15,15, 6,		6, 2, 6, 8,15,15, 2, 2,		15,15,15,15,15, 2, 2,15 };
static const uint8_t g_bc7_num_subsets[8] = { 3, 2, 3, 2, 1, 1, 1, 2 };
static const uint8_t g_bc7_partition_bits[8] = { 4, 6, 6, 6, 0, 0, 0, 6 };
static const uint8_t g_bc7_color_index_bitcount[8] = { 3, 3, 2, 2, 2, 2, 4, 2 };
static int get_bc7_color_index_size(int mode, int index_selection_bit) { return g_bc7_color_index_bitcount[mode] + index_selection_bit; }
static uint8_t g_bc7_alpha_index_bitcount[8] = { 0, 0, 0, 0, 3, 2, 4, 2 };
static int get_bc7_alpha_index_size(int mode, int index_selection_bit) { return g_bc7_alpha_index_bitcount[mode] - index_selection_bit; }
static const uint8_t g_bc7_mode_has_p_bits[8] = { 1, 1, 0, 1, 0, 0, 1, 1 };
static const uint8_t g_bc7_mode_has_shared_p_bits[8] = { 0, 1, 0, 0, 0, 0, 0, 0 };
static const uint8_t g_bc7_color_precision_table[8] = { 4, 6, 5, 7, 5, 7, 7, 5 };
static const int8_t g_bc7_alpha_precision_table[8] = { 0, 0, 0, 0, 6, 8, 7, 5 };
static bool get_bc7_mode_has_seperate_alpha_selectors(int mode) { return (mode == 4) || (mode == 5); }

typedef struct { uint16_t m_error; uint8_t m_lo; uint8_t m_hi; } endpoint_err;

static endpoint_err g_bc7_mode_1_optimal_endpoints[256][2]; // [c][pbit]
static const uint32_t BC7ENC_MODE_1_OPTIMAL_INDEX = 2;

static endpoint_err g_bc7_mode_7_optimal_endpoints[256][2][2]; // [c][pbit][hp][lp]
const uint32_t BC7E_MODE_7_OPTIMAL_INDEX = 1;

static float g_mode1_rgba_midpoints[64][2];
static float g_mode5_rgba_midpoints[128];
static float g_mode7_rgba_midpoints[32][2];

static uint8_t g_mode6_reduced_quant[2048][2];

static bool g_initialized;

// Initialize the lookup table used for optimal single color compression in mode 1/7. Must be called before encoding.
void bc7enc_compress_block_init()
{
	if (g_initialized)
		return;

	// Mode 7 endpoint midpoints
	for (uint32_t p = 0; p < 2; p++)
	{
		for (uint32_t i = 0; i < 32; i++)
		{
			uint32_t vl = ((i << 1) | p) << 2;
			vl |= (vl >> 6);
			float lo = vl / 255.0f;

			uint32_t vh = ((minimumi(31, (i + 1)) << 1) | p) << 2;
			vh |= (vh >> 6);
			float hi = vh / 255.0f;

			//g_mode7_quant_values[i][p] = lo;
			if (i == 31)
				g_mode7_rgba_midpoints[i][p] = 1.0f;
			else
				g_mode7_rgba_midpoints[i][p] = (lo + hi) / 2.0f;
		}
	}

	// Mode 1 endpoint midpoints
	for (uint32_t p = 0; p < 2; p++)
	{
		for (uint32_t i = 0; i < 64; i++)
		{
			uint32_t vl = ((i << 1) | p) << 1;
			vl |= (vl >> 7);
			float lo = vl / 255.0f;

			uint32_t vh = ((minimumi(63, (i + 1)) << 1) | p) << 1;
			vh |= (vh >> 7);
			float hi = vh / 255.0f;

			//g_mode1_quant_values[i][p] = lo;
			if (i == 63)
				g_mode1_rgba_midpoints[i][p] = 1.0f;
			else
				g_mode1_rgba_midpoints[i][p] = (lo + hi) / 2.0f;
		}
	}

	// Mode 5 endpoint midpoints
	for (uint32_t i = 0; i < 128; i++)
	{
		uint32_t vl = (i << 1);
		vl |= (vl >> 7);
		float lo = vl / 255.0f;

		uint32_t vh = minimumi(127, i + 1) << 1;
		vh |= (vh >> 7);
		float hi = vh / 255.0f;

		if (i == 127)
			g_mode5_rgba_midpoints[i] = 1.0f;
		else
			g_mode5_rgba_midpoints[i] = (lo + hi) / 2.0f;
	}

	for (uint32_t p = 0; p < 2; p++)
	{
		for (uint32_t i = 0; i < 2048; i++)
		{
			float f = i / 2047.0f;

			float best_err = 1e+9f;
			int best_index = 0;
			for (int j = 0; j < 64; j++)
			{
				int ik = (j * 127 + 31) / 63;
				float k = ((ik << 1) + p) / 255.0f;

				float e = fabsf(k - f);
				if (e < best_err)
				{
					best_err = e;
					best_index = ik;
				}
			}

			g_mode6_reduced_quant[i][p] = (uint8_t)best_index;
		}
	} // p

	// Mode 1
	for (int c = 0; c < 256; c++)
	{
		for (uint32_t lp = 0; lp < 2; lp++)
		{
			endpoint_err best;
			best.m_error = (uint16_t)UINT16_MAX;
			for (uint32_t l = 0; l < 64; l++)
			{
				uint32_t low = ((l << 1) | lp) << 1;
				low |= (low >> 7);
				for (uint32_t h = 0; h < 64; h++)
				{
					uint32_t high = ((h << 1) | lp) << 1;
					high |= (high >> 7);
					const int k = (low * (64 - g_bc7_weights3[BC7ENC_MODE_1_OPTIMAL_INDEX]) + high * g_bc7_weights3[BC7ENC_MODE_1_OPTIMAL_INDEX] + 32) >> 6;
					const int err = (k - c) * (k - c);
					if (err < best.m_error)
					{
						best.m_error = (uint16_t)err;
						best.m_lo = (uint8_t)l;
						best.m_hi = (uint8_t)h;
					}
				} // h
			} // l
			g_bc7_mode_1_optimal_endpoints[c][lp] = best;
		} // lp
	} // c

	// Mode 7: 555.1 2-bit indices 
	for (int c = 0; c < 256; c++)
	{
		for (uint32_t hp = 0; hp < 2; hp++)
		{
			for (uint32_t lp = 0; lp < 2; lp++)
			{
				endpoint_err best;
				best.m_error = (uint16_t)UINT16_MAX;
				best.m_lo = 0;
				best.m_hi = 0;

				for (uint32_t l = 0; l < 32; l++)
				{
					uint32_t low = ((l << 1) | lp) << 2;
					low |= (low >> 6);

					for (uint32_t h = 0; h < 32; h++)
					{
						uint32_t high = ((h << 1) | hp) << 2;
						high |= (high >> 6);

						const int k = (low * (64 - g_bc7_weights2[BC7E_MODE_7_OPTIMAL_INDEX]) + high * g_bc7_weights2[BC7E_MODE_7_OPTIMAL_INDEX] + 32) >> 6;

						const int err = (k - c) * (k - c);
						if (err < best.m_error)
						{
							best.m_error = (uint16_t)err;
							best.m_lo = (uint8_t)l;
							best.m_hi = (uint8_t)h;
						}
					} // h
				} // l

				g_bc7_mode_7_optimal_endpoints[c][hp][lp] = best;

			} // hp

		} // lp

	} // c

	g_initialized = true;
}

static void compute_least_squares_endpoints_rgba(uint32_t N, const uint8_t *pSelectors, const vec4F *pSelector_weights, vec4F *pXl, vec4F *pXh, const color_rgba *pColors)
{
	// Least squares using normal equations: http://www.cs.cornell.edu/~bindel/class/cs3220-s12/notes/lec10.pdf 
	// I did this in matrix form first, expanded out all the ops, then optimized it a bit.
	float z00 = 0.0f, z01 = 0.0f, z10 = 0.0f, z11 = 0.0f;
	float q00_r = 0.0f, q10_r = 0.0f, t_r = 0.0f;
	float q00_g = 0.0f, q10_g = 0.0f, t_g = 0.0f;
	float q00_b = 0.0f, q10_b = 0.0f, t_b = 0.0f;
	float q00_a = 0.0f, q10_a = 0.0f, t_a = 0.0f;
	for (uint32_t i = 0; i < N; i++)
	{
		const uint32_t sel = pSelectors[i];
		z00 += pSelector_weights[sel].m_c[0];
		z10 += pSelector_weights[sel].m_c[1];
		z11 += pSelector_weights[sel].m_c[2];
		float w = pSelector_weights[sel].m_c[3];
		q00_r += w * pColors[i].m_c[0]; t_r += pColors[i].m_c[0];
		q00_g += w * pColors[i].m_c[1]; t_g += pColors[i].m_c[1];
		q00_b += w * pColors[i].m_c[2]; t_b += pColors[i].m_c[2];
		q00_a += w * pColors[i].m_c[3]; t_a += pColors[i].m_c[3];
	}

	q10_r = t_r - q00_r;
	q10_g = t_g - q00_g;
	q10_b = t_b - q00_b;
	q10_a = t_a - q00_a;

	z01 = z10;

	float det = z00 * z11 - z01 * z10;
	if (det != 0.0f)
		det = 1.0f / det;

	float iz00, iz01, iz10, iz11;
	iz00 = z11 * det;
	iz01 = -z01 * det;
	iz10 = -z10 * det;
	iz11 = z00 * det;

	pXl->m_c[0] = (float)(iz00 * q00_r + iz01 * q10_r); pXh->m_c[0] = (float)(iz10 * q00_r + iz11 * q10_r);
	pXl->m_c[1] = (float)(iz00 * q00_g + iz01 * q10_g); pXh->m_c[1] = (float)(iz10 * q00_g + iz11 * q10_g);
	pXl->m_c[2] = (float)(iz00 * q00_b + iz01 * q10_b); pXh->m_c[2] = (float)(iz10 * q00_b + iz11 * q10_b);
	pXl->m_c[3] = (float)(iz00 * q00_a + iz01 * q10_a); pXh->m_c[3] = (float)(iz10 * q00_a + iz11 * q10_a);

	for (uint32_t c = 0; c < 4; c++)
	{
		if ((pXl->m_c[c] < 0.0f) || (pXh->m_c[c] > 255.0f))
		{
			uint32_t lo_v = UINT32_MAX, hi_v = 0;
			for (uint32_t i = 0; i < N; i++)
			{
				lo_v = minimumu(lo_v, pColors[i].m_c[c]);
				hi_v = maximumu(hi_v, pColors[i].m_c[c]);
			}

			if (lo_v == hi_v)
			{
				pXl->m_c[c] = (float)lo_v;
				pXh->m_c[c] = (float)hi_v;
			}
		}
	}
}

static void compute_least_squares_endpoints_rgb(uint32_t N, const uint8_t *pSelectors, const vec4F *pSelector_weights, vec4F *pXl, vec4F *pXh, const color_rgba*pColors)
{
	float z00 = 0.0f, z01 = 0.0f, z10 = 0.0f, z11 = 0.0f;
	float q00_r = 0.0f, q10_r = 0.0f, t_r = 0.0f;
	float q00_g = 0.0f, q10_g = 0.0f, t_g = 0.0f;
	float q00_b = 0.0f, q10_b = 0.0f, t_b = 0.0f;
	for (uint32_t i = 0; i < N; i++)
	{
		const uint32_t sel = pSelectors[i];
		z00 += pSelector_weights[sel].m_c[0];
		z10 += pSelector_weights[sel].m_c[1];
		z11 += pSelector_weights[sel].m_c[2];
		float w = pSelector_weights[sel].m_c[3];
		q00_r += w * pColors[i].m_c[0]; t_r += pColors[i].m_c[0];
		q00_g += w * pColors[i].m_c[1]; t_g += pColors[i].m_c[1];
		q00_b += w * pColors[i].m_c[2]; t_b += pColors[i].m_c[2];
	}

	q10_r = t_r - q00_r;
	q10_g = t_g - q00_g;
	q10_b = t_b - q00_b;

	z01 = z10;

	float det = z00 * z11 - z01 * z10;
	if (det != 0.0f)
		det = 1.0f / det;

	float iz00, iz01, iz10, iz11;
	iz00 = z11 * det;
	iz01 = -z01 * det;
	iz10 = -z10 * det;
	iz11 = z00 * det;

	pXl->m_c[0] = (float)(iz00 * q00_r + iz01 * q10_r); pXh->m_c[0] = (float)(iz10 * q00_r + iz11 * q10_r);
	pXl->m_c[1] = (float)(iz00 * q00_g + iz01 * q10_g); pXh->m_c[1] = (float)(iz10 * q00_g + iz11 * q10_g);
	pXl->m_c[2] = (float)(iz00 * q00_b + iz01 * q10_b); pXh->m_c[2] = (float)(iz10 * q00_b + iz11 * q10_b);
	pXl->m_c[3] = 255.0f; pXh->m_c[3] = 255.0f;

	for (uint32_t c = 0; c < 3; c++)
	{
		if ((pXl->m_c[c] < 0.0f) || (pXh->m_c[c] > 255.0f))
		{
			uint32_t lo_v = UINT32_MAX, hi_v = 0;
			for (uint32_t i = 0; i < N; i++)
			{
				lo_v = minimumu(lo_v, pColors[i].m_c[c]);
				hi_v = maximumu(hi_v, pColors[i].m_c[c]);
			}

			if (lo_v == hi_v)
			{
				pXl->m_c[c] = (float)lo_v;
				pXh->m_c[c] = (float)hi_v;
			}
		}
	}
}

static void compute_least_squares_endpoints_a(uint32_t N, const uint8_t* pSelectors, const vec4F* pSelector_weights, float* pXl, float* pXh, const color_rgba *pColors)
{
	// Least squares using normal equations: http://www.cs.cornell.edu/~bindel/class/cs3220-s12/notes/lec10.pdf 
	// I did this in matrix form first, expanded out all the ops, then optimized it a bit.
	float z00 = 0.0f, z01 = 0.0f, z10 = 0.0f, z11 = 0.0f;
	float q00_a = 0.0f, q10_a = 0.0f, t_a = 0.0f;
	for (uint32_t i = 0; i < N; i++)
	{
		const uint32_t sel = pSelectors[i];

		z00 += pSelector_weights[sel].m_c[0];
		z10 += pSelector_weights[sel].m_c[1];
		z11 += pSelector_weights[sel].m_c[2];

		float w = pSelector_weights[sel].m_c[3];

		q00_a += w * pColors[i].m_c[3]; t_a += pColors[i].m_c[3];
	}

	q10_a = t_a - q00_a;

	z01 = z10;

	float det = z00 * z11 - z01 * z10;
	if (det != 0.0f)
		det = 1.0f / det;

	float iz00, iz01, iz10, iz11;
	iz00 = z11 * det;
	iz01 = -z01 * det;
	iz10 = -z10 * det;
	iz11 = z00 * det;

	*pXl = (float)(iz00 * q00_a + iz01 * q10_a); *pXh = (float)(iz10 * q00_a + iz11 * q10_a);

	if ((*pXl < 0.0f) || (*pXh > 255.0f))
	{
		uint32_t lo_v = UINT32_MAX, hi_v = 0;
		for (uint32_t i = 0; i < N; i++)
		{
			lo_v = minimumu(lo_v, pColors[i].m_c[3]);
			hi_v = maximumu(hi_v, pColors[i].m_c[3]);
		}

		if (lo_v == hi_v)
		{
			*pXl = (float)lo_v;
			*pXh = (float)hi_v;
		}
	}
}

struct color_cell_compressor_params
{
	uint32_t m_num_pixels;
	const color_rgba *m_pPixels;
	uint32_t m_num_selector_weights;
	const uint32_t *m_pSelector_weights;
	const vec4F *m_pSelector_weightsx;
	uint32_t m_comp_bits;
	uint32_t m_weights[4];
	bool m_has_alpha;
	bool m_has_pbits;
	bool m_endpoints_share_pbit;
	bool m_perceptual;
};

struct color_cell_compressor_results
{
	uint64_t m_best_overall_err;
	color_rgba m_low_endpoint;
	color_rgba m_high_endpoint;
	uint32_t m_pbits[2];
	uint8_t *m_pSelectors;
	uint8_t *m_pSelectors_temp;
};

static inline color_rgba scale_color(const color_rgba *pC, const color_cell_compressor_params *pParams)
{
	color_rgba results;

	const uint32_t n = pParams->m_comp_bits + (pParams->m_has_pbits ? 1 : 0);
	assert((n >= 4) && (n <= 8));

	for (uint32_t i = 0; i < 4; i++)
	{
		uint32_t v = pC->m_c[i] << (8 - n);
		v |= (v >> n);
		assert(v <= 255);
		results.m_c[i] = (uint8_t)(v);
	}

	return results;
}

static inline uint64_t compute_color_distance_rgb(const color_rgba *pE1, const color_rgba *pE2, bool perceptual, const uint32_t weights[4])
{
	int dr, dg, db;

	if (perceptual)
	{
		const int l1 = pE1->m_c[0] * 109 + pE1->m_c[1] * 366 + pE1->m_c[2] * 37;
		const int cr1 = ((int)pE1->m_c[0] << 9) - l1;
		const int cb1 = ((int)pE1->m_c[2] << 9) - l1;
		const int l2 = pE2->m_c[0] * 109 + pE2->m_c[1] * 366 + pE2->m_c[2] * 37;
		const int cr2 = ((int)pE2->m_c[0] << 9) - l2;
		const int cb2 = ((int)pE2->m_c[2] << 9) - l2;
		dr = (l1 - l2) >> 8;
		dg = (cr1 - cr2) >> 8;
		db = (cb1 - cb2) >> 8;
	}
	else
	{
		dr = (int)pE1->m_c[0] - (int)pE2->m_c[0];
		dg = (int)pE1->m_c[1] - (int)pE2->m_c[1];
		db = (int)pE1->m_c[2] - (int)pE2->m_c[2];
	}

	return weights[0] * (uint32_t)(dr * dr) + weights[1] * (uint32_t)(dg * dg) + weights[2] * (uint32_t)(db * db);
}

static inline uint64_t compute_color_distance_rgba(const color_rgba *pE1, const color_rgba *pE2, bool perceptual, const uint32_t weights[4])
{
	int da = (int)pE1->m_c[3] - (int)pE2->m_c[3];
	return compute_color_distance_rgb(pE1, pE2, perceptual, weights) + (weights[3] * (uint32_t)(da * da));
}

static uint64_t pack_mode1_to_one_color(const color_cell_compressor_params *pParams, color_cell_compressor_results *pResults, uint32_t r, uint32_t g, uint32_t b, uint8_t *pSelectors)
{
	uint32_t best_err = UINT_MAX;
	uint32_t best_p = 0;

	for (uint32_t p = 0; p < 2; p++)
	{
		uint32_t err = g_bc7_mode_1_optimal_endpoints[r][p].m_error + g_bc7_mode_1_optimal_endpoints[g][p].m_error + g_bc7_mode_1_optimal_endpoints[b][p].m_error;
		if (err < best_err)
		{
			best_err = err;
			best_p = p;
			if (!best_err)
				break;
		}
	}

	const endpoint_err *pEr = &g_bc7_mode_1_optimal_endpoints[r][best_p];
	const endpoint_err *pEg = &g_bc7_mode_1_optimal_endpoints[g][best_p];
	const endpoint_err *pEb = &g_bc7_mode_1_optimal_endpoints[b][best_p];

	color_quad_u8_set(&pResults->m_low_endpoint, pEr->m_lo, pEg->m_lo, pEb->m_lo, 0);
	color_quad_u8_set(&pResults->m_high_endpoint, pEr->m_hi, pEg->m_hi, pEb->m_hi, 0);
	pResults->m_pbits[0] = best_p;
	pResults->m_pbits[1] = 0;

	memset(pSelectors, BC7ENC_MODE_1_OPTIMAL_INDEX, pParams->m_num_pixels);

	color_rgba p;
	for (uint32_t i = 0; i < 3; i++)
	{
		uint32_t low = ((pResults->m_low_endpoint.m_c[i] << 1) | pResults->m_pbits[0]) << 1;
		low |= (low >> 7);

		uint32_t high = ((pResults->m_high_endpoint.m_c[i] << 1) | pResults->m_pbits[0]) << 1;
		high |= (high >> 7);

		p.m_c[i] = (uint8_t)((low * (64 - g_bc7_weights3[BC7ENC_MODE_1_OPTIMAL_INDEX]) + high * g_bc7_weights3[BC7ENC_MODE_1_OPTIMAL_INDEX] + 32) >> 6);
	}
	p.m_c[3] = 255;

	uint64_t total_err = 0;
	for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		total_err += compute_color_distance_rgb(&p, &pParams->m_pPixels[i], pParams->m_perceptual, pParams->m_weights);

	pResults->m_best_overall_err = total_err;

	return total_err;
}

static uint64_t pack_mode7_to_one_color(const color_cell_compressor_params* pParams, color_cell_compressor_results* pResults, uint32_t r, uint32_t g, uint32_t b, uint32_t a,
	uint8_t* pSelectors, uint32_t num_pixels, const color_rgba *pPixels)
{
	uint32_t best_err = UINT_MAX;
	uint32_t best_p = 0;

	for (uint32_t p = 0; p < 4; p++)
	{
		uint32_t hi_p = p >> 1;
		uint32_t lo_p = p & 1;
		uint32_t err = g_bc7_mode_7_optimal_endpoints[r][hi_p][lo_p].m_error + g_bc7_mode_7_optimal_endpoints[g][hi_p][lo_p].m_error + g_bc7_mode_7_optimal_endpoints[b][hi_p][lo_p].m_error + g_bc7_mode_7_optimal_endpoints[a][hi_p][lo_p].m_error;
		if (err < best_err)
		{
			best_err = err;
			best_p = p;
			if (!best_err)
				break;
		}
	}

	uint32_t  [MASK]  = best_p >> 1;
	uint32_t best_lo_p = best_p & 1;

	const endpoint_err* pEr = &g_bc7_mode_7_optimal_endpoints[r][ [MASK] ][best_lo_p];
	const endpoint_err* pEg = &g_bc7_mode_7_optimal_endpoints[g][ [MASK] ][best_lo_p];
	const endpoint_err* pEb = &g_bc7_mode_7_optimal_endpoints[b][ [MASK] ][best_lo_p];
	const endpoint_err* pEa = &g_bc7_mode_7_optimal_endpoints[a][ [MASK] ][best_lo_p];

	color_quad_u8_set(&pResults->m_low_endpoint, pEr->m_lo, pEg->m_lo, pEb->m_lo, pEa->m_lo);
	color_quad_u8_set(&pResults->m_high_endpoint, pEr->m_hi, pEg->m_hi, pEb->m_hi, pEa->m_hi);
	pResults->m_pbits[0] = best_lo_p;
	pResults->m_pbits[1] =  [MASK] ;

	for (uint32_t i = 0; i < num_pixels; i++)
		pSelectors[i] = (uint8_t)BC7E_MODE_7_OPTIMAL_INDEX;

	color_rgba p;

	for (uint32_t i = 0; i < 4; i++)
	{
		uint32_t low = (pResults->m_low_endpoint.m_c[i] << 1) | pResults->m_pbits[0];
		uint32_t high = (pResults->m_high_endpoint.m_c[i] << 1) | pResults->m_pbits[1];

		low = (low << 2) | (low >> 6);
		high = (high << 2) | (high >> 6);

		p.m_c[i] = (uint8_t)((low * (64 - g_bc7_weights2[BC7E_MODE_7_OPTIMAL_INDEX]) + high * g_bc7_weights2[BC7E_MODE_7_OPTIMAL_INDEX] + 32) >> 6);
	}

	uint64_t total_err = 0;
	for (uint32_t i = 0; i < num_pixels; i++)
		total_err += compute_color_distance_rgba(&p, &pPixels[i], pParams->m_perceptual, pParams->m_weights);

	pResults->m_best_overall_err = total_err;

	return total_err;
}

static uint64_t evaluate_solution(const color_rgba *pLow, const color_rgba *pHigh, const uint32_t pbits[2], const color_cell_compressor_params *pParams, color_cell_compressor_results *pResults,
	const bc7enc_compress_block_params* pComp_params)
{
	color_rgba quantMinColor = *pLow;
	color_rgba quantMaxColor = *pHigh;

	if (pParams->m_has_pbits)
	{
		uint32_t minPBit, maxPBit;

		if (pParams->m_endpoints_share_pbit)
			maxPBit = minPBit = pbits[0];
		else
		{
			minPBit = pbits[0];
			maxPBit = pbits[1];
		}

		quantMinColor.m_c[0] = (uint8_t)((pLow->m_c[0] << 1) | minPBit);
		quantMinColor.m_c[1] = (uint8_t)((pLow->m_c[1] << 1) | minPBit);
		quantMinColor.m_c[2] = (uint8_t)((pLow->m_c[2] << 1) | minPBit);
		quantMinColor.m_c[3] = (uint8_t)((pLow->m_c[3] << 1) | minPBit);

		quantMaxColor.m_c[0] = (uint8_t)((pHigh->m_c[0] << 1) | maxPBit);
		quantMaxColor.m_c[1] = (uint8_t)((pHigh->m_c[1] << 1) | maxPBit);
		quantMaxColor.m_c[2] = (uint8_t)((pHigh->m_c[2] << 1) | maxPBit);
		quantMaxColor.m_c[3] = (uint8_t)((pHigh->m_c[3] << 1) | maxPBit);
	}

	color_rgba actualMinColor = scale_color(&quantMinColor, pParams);
	color_rgba actualMaxColor = scale_color(&quantMaxColor, pParams);

	const uint32_t N = pParams->m_num_selector_weights;

	color_rgba weightedColors[16];
	weightedColors[0] = actualMinColor;
	weightedColors[N - 1] = actualMaxColor;

	const uint32_t nc = pParams->m_has_alpha ? 4 : 3;
	for (uint32_t i = 1; i < (N - 1); i++)
		for (uint32_t j = 0; j < nc; j++)
			weightedColors[i].m_c[j] = (uint8_t)((actualMinColor.m_c[j] * (64 - pParams->m_pSelector_weights[i]) + actualMaxColor.m_c[j] * pParams->m_pSelector_weights[i] + 32) >> 6);

	const int lr = actualMinColor.m_c[0];
	const int lg = actualMinColor.m_c[1];
	const int lb = actualMinColor.m_c[2];
	const int dr = actualMaxColor.m_c[0] - lr;
	const int dg = actualMaxColor.m_c[1] - lg;
	const int db = actualMaxColor.m_c[2] - lb;
	
	uint64_t total_err = 0;

	if (pComp_params->m_force_selectors)
	{
		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			const uint32_t best_sel = pComp_params->m_selectors[i];

			uint64_t best_err;
			if (pParams->m_has_alpha)
				best_err = compute_color_distance_rgba(&weightedColors[best_sel], &pParams->m_pPixels[i], pParams->m_perceptual, pParams->m_weights);
			else
				best_err = compute_color_distance_rgb(&weightedColors[best_sel], &pParams->m_pPixels[i], pParams->m_perceptual, pParams->m_weights);

			total_err += best_err;

			pResults->m_pSelectors_temp[i] = (uint8_t)best_sel;
		}
	}
	else if (!pParams->m_perceptual)
	{
		if (pParams->m_has_alpha)
		{
			const int la = actualMinColor.m_c[3];
			const int da = actualMaxColor.m_c[3] - la;

			const float f = N / (float)(squarei(dr) + squarei(dg) + squarei(db) + squarei(da) + .00000125f);

			for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
			{
				const color_rgba *pC = &pParams->m_pPixels[i];
				int r = pC->m_c[0];
				int g = pC->m_c[1];
				int b = pC->m_c[2];
				int a = pC->m_c[3];

				int best_sel = (int)((float)((r - lr) * dr + (g - lg) * dg + (b - lb) * db + (a - la) * da) * f + .5f);
				best_sel = clampi(best_sel, 1, N - 1);

				uint64_t err0 = compute_color_distance_rgba(&weightedColors[best_sel - 1], pC, false, pParams->m_weights);
				uint64_t err1 = compute_color_distance_rgba(&weightedColors[best_sel], pC, false, pParams->m_weights);

				if (err1 > err0)
				{
					err1 = err0;
					--best_sel;
				}
				total_err += err1;

				pResults->m_pSelectors_temp[i] = (uint8_t)best_sel;
			}
		}
		else
		{
			const float f = N / (float)(squarei(dr) + squarei(dg) + squarei(db) + .00000125f);

			for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
			{
				const color_rgba *pC = &pParams->m_pPixels[i];
				int r = pC->m_c[0];
				int g = pC->m_c[1];
				int b = pC->m_c[2];

				int sel = (int)((float)((r - lr) * dr + (g - lg) * dg + (b - lb) * db) * f + .5f);
				sel = clampi(sel, 1, N - 1);

				uint64_t err0 = compute_color_distance_rgb(&weightedColors[sel - 1], pC, false, pParams->m_weights);
				uint64_t err1 = compute_color_distance_rgb(&weightedColors[sel], pC, false, pParams->m_weights);

				int best_sel = sel;
				uint64_t best_err = err1;
				if (err0 < best_err)
				{
					best_err = err0;
					best_sel = sel - 1;
				}

				total_err += best_err;

				pResults->m_pSelectors_temp[i] = (uint8_t)best_sel;
			}
		}
	}
	else
	{
		// TODO: This could be improved.
		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			uint64_t best_err = UINT64_MAX;
			uint32_t best_sel = 0;

			if (pParams->m_has_alpha)
			{
				for (uint32_t j = 0; j < N; j++)
				{
					uint64_t err = compute_color_distance_rgba(&weightedColors[j], &pParams->m_pPixels[i], true, pParams->m_weights);
					if (err < best_err)
					{
						best_err = err;
						best_sel = j;
					}
				}
			}
			else
			{
				for (uint32_t j = 0; j < N; j++)
				{
					uint64_t err = compute_color_distance_rgb(&weightedColors[j], &pParams->m_pPixels[i], true, pParams->m_weights);
					if (err < best_err)
					{
						best_err = err;
						best_sel = j;
					}
				}
			}

			total_err += best_err;

			pResults->m_pSelectors_temp[i] = (uint8_t)best_sel;
		}
	}

	if (total_err < pResults->m_best_overall_err)
	{
		pResults->m_best_overall_err = total_err;

		pResults->m_low_endpoint = *pLow;
		pResults->m_high_endpoint = *pHigh;

		pResults->m_pbits[0] = pbits[0];
		pResults->m_pbits[1] = pbits[1];

		memcpy(pResults->m_pSelectors, pResults->m_pSelectors_temp, sizeof(pResults->m_pSelectors[0]) * pParams->m_num_pixels);
	}
				
	return total_err;
}

static void fixDegenerateEndpoints(uint32_t mode, color_rgba *pTrialMinColor, color_rgba *pTrialMaxColor, const vec4F *pXl, const vec4F *pXh, uint32_t iscale,
	const bc7enc_compress_block_params* pComp_params)
{
	//if ((mode == 1) || (mode == 7))
	//if (mode == 1)
	if ( (mode == 1) || ((mode == 6) && (pComp_params->m_quant_mode6_endpoints)) )
	{
		// fix degenerate case where the input collapses to a single colorspace voxel, and we loose all freedom (test with grayscale ramps)
		for (uint32_t i = 0; i < 3; i++)
		{
			if (pTrialMinColor->m_c[i] == pTrialMaxColor->m_c[i])
			{
				if (fabs(pXl->m_c[i] - pXh->m_c[i]) > 0.0f)
				{
					if (pTrialMinColor->m_c[i] > (iscale >> 1))
					{
						if (pTrialMinColor->m_c[i] > 0)
							pTrialMinColor->m_c[i]--;
						else
							if (pTrialMaxColor->m_c[i] < iscale)
								pTrialMaxColor->m_c[i]++;
					}
					else
					{
						if (pTrialMaxColor->m_c[i] < iscale)
							pTrialMaxColor->m_c[i]++;
						else if (pTrialMinColor->m_c[i] > 0)
							pTrialMinColor->m_c[i]--;
					}
				}
			}
		}
	}
}

static uint64_t find_optimal_solution(uint32_t mode, vec4F xl, vec4F xh, const color_cell_compressor_params *pParams, color_cell_compressor_results *pResults,
	const bc7enc_compress_block_params* pComp_params)
{
	vec4F_saturate_in_place(&xl); vec4F_saturate_in_place(&xh);

	if (pParams->m_has_pbits)
	{
		const int iscalep = (1 << (pParams->m_comp_bits + 1)) - 1;
		const float scalep = (float)iscalep;

		const int32_t totalComps = pParams->m_has_alpha ? 4 : 3;

		uint32_t best_pbits[2];
		color_rgba bestMinColor, bestMaxColor;

		if (!pParams->m_endpoints_share_pbit)
		{
			if ((pParams->m_comp_bits == 7) && (pComp_params->m_quant_mode6_endpoints))
			{
				best_pbits[0] = 0;
				bestMinColor.m_c[0] = g_mode6_reduced_quant[(int)((xl.m_c[0] * 2047.0f) + .5f)][0];
				bestMinColor.m_c[1] = g_mode6_reduced_quant[(int)((xl.m_c[1] * 2047.0f) + .5f)][0];
				bestMinColor.m_c[2] = g_mode6_reduced_quant[(int)((xl.m_c[2] * 2047.0f) + .5f)][0];
				bestMinColor.m_c[3] = g_mode6_reduced_quant[(int)((xl.m_c[3] * 2047.0f) + .5f)][0];

				best_pbits[1] = 1;
				bestMaxColor.m_c[0] = g_mode6_reduced_quant[(int)((xh.m_c[0] * 2047.0f) + .5f)][1];
				bestMaxColor.m_c[1] = g_mode6_reduced_quant[(int)((xh.m_c[1] * 2047.0f) + .5f)][1];
				bestMaxColor.m_c[2] = g_mode6_reduced_quant[(int)((xh.m_c[2] * 2047.0f) + .5f)][1];
				bestMaxColor.m_c[3] = g_mode6_reduced_quant[(int)((xh.m_c[3] * 2047.0f) + .5f)][1];
			}
			else
			{
				float best_err0 = 1e+9;
				float best_err1 = 1e+9;

				for (int p = 0; p < 2; p++)
				{
					color_rgba xMinColor, xMaxColor;

					// Notes: The pbit controls which quantization intervals are selected.
					// total_levels=2^(comp_bits+1), where comp_bits=4 for mode 0, etc.
					// pbit 0: v=(b*2)/(total_levels-1), pbit 1: v=(b*2+1)/(total_levels-1) where b is the component bin from [0,total_levels/2-1] and v is the [0,1] component value
					// rearranging you get for pbit 0: b=floor(v*(total_levels-1)/2+.5)
					// rearranging you get for pbit 1: b=floor((v*(total_levels-1)-1)/2+.5)
					if (pParams->m_comp_bits == 5)
					{
						for (uint32_t c = 0; c < 4; c++)
						{
							int vl = (int)(xl.m_c[c] * 31.0f);
							vl += (xl.m_c[c] > g_mode7_rgba_midpoints[vl][p]);
							xMinColor.m_c[c] = (uint8_t)clampi(vl * 2 + p, p, 63 - 1 + p);

							int vh = (int)(xh.m_c[c] * 31.0f);
							vh += (xh.m_c[c] > g_mode7_rgba_midpoints[vh][p]);
							xMaxColor.m_c[c] = (uint8_t)clampi(vh * 2 + p, p, 63 - 1 + p);
						}
					}
					else
					{
						for (uint32_t c = 0; c < 4; c++)
						{
							xMinColor.m_c[c] = (uint8_t)(clampi(((int)((xl.m_c[c] * scalep - p) / 2.0f + .5f)) * 2 + p, p, iscalep - 1 + p));
							xMaxColor.m_c[c] = (uint8_t)(clampi(((int)((xh.m_c[c] * scalep - p) / 2.0f + .5f)) * 2 + p, p, iscalep - 1 + p));
						}
					}

					color_rgba scaledLow = scale_color(&xMinColor, pParams);
					color_rgba scaledHigh = scale_color(&xMaxColor, pParams);

					float err0 = 0, err1 = 0;
					for (int i = 0; i < totalComps; i++)
					{
						err0 += squaref(scaledLow.m_c[i] - xl.m_c[i] * 255.0f);
						err1 += squaref(scaledHigh.m_c[i] - xh.m_c[i] * 255.0f);
					}

					if (p == 1)
					{
						err0 *= pComp_params->m_pbit1_weight;
						err1 *= pComp_params->m_pbit1_weight;
					}
											
					if (err0 < best_err0)
					{
						best_err0 = err0;
						best_pbits[0] = p;

						bestMinColor.m_c[0] = xMinColor.m_c[0] >> 1;
						bestMinColor.m_c[1] = xMinColor.m_c[1] >> 1;
						bestMinColor.m_c[2] = xMinColor.m_c[2] >> 1;
						bestMinColor.m_c[3] = xMinColor.m_c[3] >> 1;
					}

					if (err1 < best_err1)
					{
						best_err1 = err1;
						best_pbits[1] = p;

						bestMaxColor.m_c[0] = xMaxColor.m_c[0] >> 1;
						bestMaxColor.m_c[1] = xMaxColor.m_c[1] >> 1;
						bestMaxColor.m_c[2] = xMaxColor.m_c[2] >> 1;
						bestMaxColor.m_c[3] = xMaxColor.m_c[3] >> 1;
					}
				}
			}
		}
		else
		{
			if ((mode == 1) && (pComp_params->m_bias_mode1_pbits))
			{
				float x = 0.0f;
				for (uint32_t c = 0; c < 3; c++)
					x = std::max(std::max(x, xl.m_c[c]), xh.m_c[c]);
				
				int p = 0;
				if (x > (253.0f / 255.0f))
					p = 1;

				color_rgba xMinColor, xMaxColor;
				for (uint32_t c = 0; c < 4; c++)
				{
					int vl = (int)(xl.m_c[c] * 63.0f);
					vl += (xl.m_c[c] > g_mode1_rgba_midpoints[vl][p]);
					xMinColor.m_c[c] = (uint8_t)clampi(vl * 2 + p, p, 127 - 1 + p);

					int vh = (int)(xh.m_c[c] * 63.0f);
					vh += (xh.m_c[c] > g_mode1_rgba_midpoints[vh][p]);
					xMaxColor.m_c[c] = (uint8_t)clampi(vh * 2 + p, p, 127 - 1 + p);
				}

				best_pbits[0] = p;
				best_pbits[1] = p;
				for (uint32_t j = 0; j < 4; j++)
				{
					bestMinColor.m_c[j] = xMinColor.m_c[j] >> 1;
					bestMaxColor.m_c[j] = xMaxColor.m_c[j] >> 1;
				}
			}
			else
			{
				// Endpoints share pbits
				float best_err = 1e+9;

				for (int p = 0; p < 2; p++)
				{
					color_rgba xMinColor, xMaxColor;
					if (pParams->m_comp_bits == 6)
					{
						for (uint32_t c = 0; c < 4; c++)
						{
							int vl = (int)(xl.m_c[c] * 63.0f);
							vl += (xl.m_c[c] > g_mode1_rgba_midpoints[vl][p]);
							xMinColor.m_c[c] = (uint8_t)clampi(vl * 2 + p, p, 127 - 1 + p);

							int vh = (int)(xh.m_c[c] * 63.0f);
							vh += (xh.m_c[c] > g_mode1_rgba_midpoints[vh][p]);
							xMaxColor.m_c[c] = (uint8_t)clampi(vh * 2 + p, p, 127 - 1 + p);
						}
					}
					else
					{
						for (uint32_t c = 0; c < 4; c++)
						{
							xMinColor.m_c[c] = (uint8_t)(clampi(((int)((xl.m_c[c] * scalep - p) / 2.0f + .5f)) * 2 + p, p, iscalep - 1 + p));
							xMaxColor.m_c[c] = (uint8_t)(clampi(((int)((xh.m_c[c] * scalep - p) / 2.0f + .5f)) * 2 + p, p, iscalep - 1 + p));
						}
					}

					color_rgba scaledLow = scale_color(&xMinColor, pParams);
					color_rgba scaledHigh = scale_color(&xMaxColor, pParams);

					float err = 0;
					for (int i = 0; i < totalComps; i++)
						err += squaref((scaledLow.m_c[i] / 255.0f) - xl.m_c[i]) + squaref((scaledHigh.m_c[i] / 255.0f) - xh.m_c[i]);

					if (p == 1)
						err *= pComp_params->m_pbit1_weight;

					if (err < best_err)
					{
						best_err = err;
						best_pbits[0] = p;
						best_pbits[1] = p;
						for (uint32_t j = 0; j < 4; j++)
						{
							bestMinColor.m_c[j] = xMinColor.m_c[j] >> 1;
							bestMaxColor.m_c[j] = xMaxColor.m_c[j] >> 1;
						}
					}
				}
			}
		}
						
		fixDegenerateEndpoints(mode, &bestMinColor, &bestMaxColor, &xl, &xh, iscalep >> 1, pComp_params);

		if ((pResults->m_best_overall_err == UINT64_MAX) || color_quad_u8_notequals(&bestMinColor, &pResults->m_low_endpoint) || color_quad_u8_notequals(&bestMaxColor, &pResults->m_high_endpoint) || (best_pbits[0] != pResults->m_pbits[0]) || (best_pbits[1] != pResults->m_pbits[1]))
			evaluate_solution(&bestMinColor, &bestMaxColor, best_pbits, pParams, pResults, pComp_params);
	}
	else
	{
		const int iscale = (1 << pParams->m_comp_bits) - 1;
		const float scale = (float)iscale;

		color_rgba trialMinColor, trialMaxColor;
		if (pParams->m_comp_bits == 7)
		{
			for (uint32_t c = 0; c < 4; c++)
			{
				int vl = (int)(xl.m_c[c] * 127.0f);
				vl += (xl.m_c[c] > g_mode5_rgba_midpoints[vl]);
				trialMinColor.m_c[c] = (uint8_t)clampi(vl, 0, 127);

				int vh = (int)(xh.m_c[c] * 127.0f);
				vh += (xh.m_c[c] > g_mode5_rgba_midpoints[vh]);
				trialMaxColor.m_c[c] = (uint8_t)clampi(vh, 0, 127);
			}
		}
		else
		{
			color_quad_u8_set_clamped(&trialMinColor, (int)(xl.m_c[0] * scale + .5f), (int)(xl.m_c[1] * scale + .5f), (int)(xl.m_c[2] * scale + .5f), (int)(xl.m_c[3] * scale + .5f));
			color_quad_u8_set_clamped(&trialMaxColor, (int)(xh.m_c[0] * scale + .5f), (int)(xh.m_c[1] * scale + .5f), (int)(xh.m_c[2] * scale + .5f), (int)(xh.m_c[3] * scale + .5f));
		}

		fixDegenerateEndpoints(mode, &trialMinColor, &trialMaxColor, &xl, &xh, iscale, pComp_params);

		if ((pResults->m_best_overall_err == UINT64_MAX) || color_quad_u8_notequals(&trialMinColor, &pResults->m_low_endpoint) || color_quad_u8_notequals(&trialMaxColor, &pResults->m_high_endpoint))
			evaluate_solution(&trialMinColor, &trialMaxColor, pResults->m_pbits, pParams, pResults, pComp_params);
	}

	return pResults->m_best_overall_err;
}

static uint64_t color_cell_compression(uint32_t mode, const color_cell_compressor_params *pParams, color_cell_compressor_results *pResults, const bc7enc_compress_block_params *pComp_params)
{
	assert((mode == 6) || (mode == 7) || (!pParams->m_has_alpha));

	pResults->m_best_overall_err = UINT64_MAX;

	// If the partition's colors are all the same in mode 1, then just pack them as a single color.
	if (mode == 1)
	{
		const uint32_t cr = pParams->m_pPixels[0].m_c[0], cg = pParams->m_pPixels[0].m_c[1], cb = pParams->m_pPixels[0].m_c[2];

		bool allSame = true;
		for (uint32_t i = 1; i < pParams->m_num_pixels; i++)
		{
			if ((cr != pParams->m_pPixels[i].m_c[0]) || (cg != pParams->m_pPixels[i].m_c[1]) || (cb != pParams->m_pPixels[i].m_c[2]))
			{
				allSame = false;
				break;
			}
		}

		if (allSame)
			return pack_mode1_to_one_color(pParams, pResults, cr, cg, cb, pResults->m_pSelectors);
	}
	else if (mode == 7)
	{
		const uint32_t cr = pParams->m_pPixels[0].m_c[0], cg = pParams->m_pPixels[0].m_c[1], cb = pParams->m_pPixels[0].m_c[2], ca = pParams->m_pPixels[0].m_c[3];

		bool allSame = true;
		for (uint32_t i = 1; i < pParams->m_num_pixels; i++)
		{
			if ((cr != pParams->m_pPixels[i].m_c[0]) || (cg != pParams->m_pPixels[i].m_c[1]) || (cb != pParams->m_pPixels[i].m_c[2]) || (ca != pParams->m_pPixels[i].m_c[3]))
			{
				allSame = false;
				break;
			}
		}

		if (allSame)
			return pack_mode7_to_one_color(pParams, pResults, cr, cg, cb, ca, pResults->m_pSelectors, pParams->m_num_pixels, pParams->m_pPixels);
	}

	// Compute partition's mean color and principle axis.
	vec4F meanColor, axis;
	vec4F_set_scalar(&meanColor, 0.0f);

	for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
	{
		vec4F color = vec4F_from_color(&pParams->m_pPixels[i]);
		meanColor = vec4F_add(&meanColor, &color);
	}
				
	vec4F meanColorScaled = vec4F_mul(&meanColor, 1.0f / (float)(pParams->m_num_pixels));

	meanColor = vec4F_mul(&meanColor, 1.0f / (float)(pParams->m_num_pixels * 255.0f));
	vec4F_saturate_in_place(&meanColor);

	if (pParams->m_has_alpha)
	{
		// Use incremental PCA for RGBA PCA, because it's simple.
		vec4F_set_scalar(&axis, 0.0f);
		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			vec4F color = vec4F_from_color(&pParams->m_pPixels[i]);
			color = vec4F_sub(&color, &meanColorScaled);
			vec4F a = vec4F_mul(&color, color.m_c[0]);
			vec4F b = vec4F_mul(&color, color.m_c[1]);
			vec4F c = vec4F_mul(&color, color.m_c[2]);
			vec4F d = vec4F_mul(&color, color.m_c[3]);
			vec4F n = i ? axis : color;
			vec4F_normalize_in_place(&n);
			axis.m_c[0] += vec4F_dot(&a, &n);
			axis.m_c[1] += vec4F_dot(&b, &n);
			axis.m_c[2] += vec4F_dot(&c, &n);
			axis.m_c[3] += vec4F_dot(&d, &n);
		}
		vec4F_normalize_in_place(&axis);
	}
	else
	{
		// Use covar technique for RGB PCA, because it doesn't require per-pixel normalization.
		float cov[6] = { 0, 0, 0, 0, 0, 0 };

		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			const color_rgba *pV = &pParams->m_pPixels[i];
			float r = pV->m_c[0] - meanColorScaled.m_c[0];
			float g = pV->m_c[1] - meanColorScaled.m_c[1];
			float b = pV->m_c[2] - meanColorScaled.m_c[2];
			cov[0] += r*r; cov[1] += r*g; cov[2] += r*b; cov[3] += g*g; cov[4] += g*b; cov[5] += b*b;
		}

		float vfr = .9f, vfg = 1.0f, vfb = .7f;
		for (uint32_t iter = 0; iter < 3; iter++)
		{
			float r = vfr*cov[0] + vfg*cov[1] + vfb*cov[2];
			float g = vfr*cov[1] + vfg*cov[3] + vfb*cov[4];
			float b = vfr*cov[2] + vfg*cov[4] + vfb*cov[5];

			float m = maximumf(maximumf(fabsf(r), fabsf(g)), fabsf(b));
			if (m > 1e-10f)
			{
				m = 1.0f / m;
				r *= m; g *= m;	b *= m;
			}

			vfr = r; vfg = g; vfb = b;
		}

		float len = vfr*vfr + vfg*vfg + vfb*vfb;
		if (len < 1e-10f)
			vec4F_set_scalar(&axis, 0.0f);
		else
		{
			len = 1.0f / sqrtf(len);
			vfr *= len; vfg *= len; vfb *= len;
			vec4F_set(&axis, vfr, vfg, vfb, 0);
		}
	}

	// TODO: Try picking the 2 colors with the largest projection onto the axis, instead of computing new colors along the axis.
				
	if (vec4F_dot(&axis, &axis) < .5f)
	{
		if (pParams->m_perceptual)
			vec4F_set(&axis, .213f, .715f, .072f, pParams->m_has_alpha ? .715f : 0);
		else
			vec4F_set(&axis, 1.0f, 1.0f, 1.0f, pParams->m_has_alpha ? 1.0f : 0);
		vec4F_normalize_in_place(&axis);
	}

	float l = 1e+9f, h = -1e+9f;

	for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
	{
		vec4F color = vec4F_from_color(&pParams->m_pPixels[i]);

		vec4F q = vec4F_sub(&color, &meanColorScaled);
		float d = vec4F_dot(&q, &axis);

		l = minimumf(l, d);
		h = maximumf(h, d);
	}

	l *= (1.0f / 255.0f);
	h *= (1.0f / 255.0f);

	vec4F b0 = vec4F_mul(&axis, l);
	vec4F b1 = vec4F_mul(&axis, h);
	vec4F c0 = vec4F_add(&meanColor, &b0);
	vec4F c1 = vec4F_add(&meanColor, &b1);
	vec4F minColor = vec4F_saturate(&c0);
	vec4F maxColor = vec4F_saturate(&c1);
				
	vec4F whiteVec;
	vec4F_set_scalar(&whiteVec, 1.0f);

	if (vec4F_dot(&minColor, &whiteVec) > vec4F_dot(&maxColor, &whiteVec))
	{
#if 0
		// Don't compile correctly with VC 2019 in release.
		vec4F temp = minColor;
		minColor = maxColor;
		maxColor = temp;
#else
		float a = minColor.m_c[0], b = minColor.m_c[1], c = minColor.m_c[2], d = minColor.m_c[3];
		minColor.m_c[0] = maxColor.m_c[0];
		minColor.m_c[1] = maxColor.m_c[1];
		minColor.m_c[2] = maxColor.m_c[2];
		minColor.m_c[3] = maxColor.m_c[3];
		maxColor.m_c[0] = a;
		maxColor.m_c[1] = b;
		maxColor.m_c[2] = c;
		maxColor.m_c[3] = d;
#endif
	}

	// First find a solution using the block's PCA.
	if (!find_optimal_solution(mode, minColor, maxColor, pParams, pResults, pComp_params))
		return 0;
	
	if (pComp_params->m_try_least_squares)
	{
		// Now try to refine the solution using least squares by computing the optimal endpoints from the current selectors.
		vec4F xl, xh;
		vec4F_set_scalar(&xl, 0.0f);
		vec4F_set_scalar(&xh, 0.0f);
		if (pParams->m_has_alpha)
			compute_least_squares_endpoints_rgba(pParams->m_num_pixels, pResults->m_pSelectors, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);
		else
			compute_least_squares_endpoints_rgb(pParams->m_num_pixels, pResults->m_pSelectors, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);

		xl = vec4F_mul(&xl, (1.0f / 255.0f));
		xh = vec4F_mul(&xh, (1.0f / 255.0f));

		if (!find_optimal_solution(mode, xl, xh, pParams, pResults, pComp_params))
			return 0;
	}
	
	if (pComp_params->m_uber_level > 0)
	{
		// In uber level 1, try varying the selectors a little, somewhat like cluster fit would. First try incrementing the minimum selectors,
		// then try decrementing the selectrors, then try both.
		uint8_t selectors_temp[16], selectors_temp1[16];
		memcpy(selectors_temp, pResults->m_pSelectors, pParams->m_num_pixels);

		const int max_selector = pParams->m_num_selector_weights - 1;

		uint32_t min_sel = 16;
		uint32_t max_sel = 0;
		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			uint32_t sel = selectors_temp[i];
			min_sel = minimumu(min_sel, sel);
			max_sel = maximumu(max_sel, sel);
		}

		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			uint32_t sel = selectors_temp[i];
			if ((sel == min_sel) && (sel < (pParams->m_num_selector_weights - 1)))
				sel++;
			selectors_temp1[i] = (uint8_t)sel;
		}

		vec4F xl, xh;
		vec4F_set_scalar(&xl, 0.0f);
		vec4F_set_scalar(&xh, 0.0f);
		if (pParams->m_has_alpha)
			compute_least_squares_endpoints_rgba(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);
		else
			compute_least_squares_endpoints_rgb(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);

		xl = vec4F_mul(&xl, (1.0f / 255.0f));
		xh = vec4F_mul(&xh, (1.0f / 255.0f));

		if (!find_optimal_solution(mode, xl, xh, pParams, pResults, pComp_params))
			return 0;

		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			uint32_t sel = selectors_temp[i];
			if ((sel == max_sel) && (sel > 0))
				sel--;
			selectors_temp1[i] = (uint8_t)sel;
		}

		if (pParams->m_has_alpha)
			compute_least_squares_endpoints_rgba(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);
		else
			compute_least_squares_endpoints_rgb(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);

		xl = vec4F_mul(&xl, (1.0f / 255.0f));
		xh = vec4F_mul(&xh, (1.0f / 255.0f));

		if (!find_optimal_solution(mode, xl, xh, pParams, pResults, pComp_params))
			return 0;

		for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
		{
			uint32_t sel = selectors_temp[i];
			if ((sel == min_sel) && (sel < (pParams->m_num_selector_weights - 1)))
				sel++;
			else if ((sel == max_sel) && (sel > 0))
				sel--;
			selectors_temp1[i] = (uint8_t)sel;
		}

		if (pParams->m_has_alpha)
			compute_least_squares_endpoints_rgba(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);
		else
			compute_least_squares_endpoints_rgb(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);

		xl = vec4F_mul(&xl, (1.0f / 255.0f));
		xh = vec4F_mul(&xh, (1.0f / 255.0f));

		if (!find_optimal_solution(mode, xl, xh, pParams, pResults, pComp_params))
			return 0;

		// In uber levels 2+, try taking more advantage of endpoint extrapolation by scaling the selectors in one direction or another.
		const uint32_t uber_err_thresh = (pParams->m_num_pixels * 56) >> 4;
		if ((pComp_params->m_uber_level >= 2) && (pResults->m_best_overall_err > uber_err_thresh))
		{
			const int Q = (pComp_params->m_uber_level >= 4) ? (pComp_params->m_uber_level - 2) : 1;
			for (int ly = -Q; ly <= 1; ly++)
			{
				for (int hy = max_selector - 1; hy <= (max_selector + Q); hy++)
				{
					if ((ly == 0) && (hy == max_selector))
						continue;

					for (uint32_t i = 0; i < pParams->m_num_pixels; i++)
						selectors_temp1[i] = (uint8_t)clampf(floorf((float)max_selector * ((float)selectors_temp[i] - (float)ly) / ((float)hy - (float)ly) + .5f), 0, (float)max_selector);

					//vec4F xl, xh;
					vec4F_set_scalar(&xl, 0.0f);
					vec4F_set_scalar(&xh, 0.0f);
					if (pParams->m_has_alpha)
						compute_least_squares_endpoints_rgba(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);
					else
						compute_least_squares_endpoints_rgb(pParams->m_num_pixels, selectors_temp1, pParams->m_pSelector_weightsx, &xl, &xh, pParams->m_pPixels);

					xl = vec4F_mul(&xl, (1.0f / 255.0f));
					xh = vec4F_mul(&xh, (1.0f / 255.0f));

					if (!find_optimal_solution(mode, xl, xh, pParams, pResults, pComp_params))
						return 0;
				}
			}
		}
	}

	if (mode == 1)
	{
		// Try encoding the partition as a single color by using the optimal singe colors tables to encode the block to its mean.
		color_cell_compressor_results avg_results = *pResults;
		const uint32_t r = (int)(.5f + meanColor.m_c[0] * 255.0f), g = (int)(.5f + meanColor.m_c[1] * 255.0f), b = (int)(.5f + meanColor.m_c[2] * 255.0f);
		uint64_t avg_err = pack_mode1_to_one_color(pParams, &avg_results, r, g, b, pResults->m_pSelectors_temp);
		if (avg_err < pResults->m_best_overall_err)
		{
			*pResults = avg_results;
			memcpy(pResults->m_pSelectors, pResults->m_pSelectors_temp, sizeof(pResults->m_pSelectors[0]) * pParams->m_num_pixels);
			pResults->m_best_overall_err = avg_err;
		}
	}
	else if (mode == 7)
	{
		// Try encoding the partition as a single color by using the optimal singe colors tables to encode the block to its mean.
		color_cell_compressor_results avg_results = *pResults;
		const uint32_t r = (int)(.5f + meanColor.m_c[0] * 255.0f), g = (int)(.5f + meanColor.m_c[1] * 255.0f), b = (int)(.5f + meanColor.m_c[2] * 255.0f), a = (int)(.5f + meanColor.m_c[3] * 255.0f);
		uint64_t avg_err = pack_mode7_to_one_color(pParams, &avg_results, r, g, b, a, pResults->m_pSelectors_temp, pParams->m_num_pixels, pParams->m_pPixels);
		if (avg_err < pResults->m_best_overall_err)
		{
			*pResults = avg_results;
			memcpy(pResults->m_pSelectors, pResults->m_pSelectors_temp, sizeof(pResults->m_pSelectors[0]) * pParams->m_num_pixels);
			pResults->m_best_overall_err = avg_err;
		}
	}
				
	return pResults->m_best_overall_err;
}

static uint64_t color_cell_compression_est_mode1(uint32_t num_pixels, const color_rgba *pPixels, bool perceptual, uint32_t pweights[4], uint64_t best_err_so_far)
{
	// Find RGB bounds as an approximation of the block's principle axis
	uint32_t lr = 255, lg = 255, lb = 255;
	uint32_t hr = 0, hg = 0, hb = 0;
	for (uint32_t i = 0; i < num_pixels; i++)
	{
		const color_rgba *pC = &pPixels[i];
		if (pC->m_c[0] < lr) lr = pC->m_c[0];
		if (pC->m_c[1] < lg) lg = pC->m_c[1];
		if (pC->m_c[2] < lb) lb = pC->m_c[2];
		if (pC->m_c[0] > hr) hr = pC->m_c[0];
		if (pC->m_c[1] > hg) hg = pC->m_c[1];
		if (pC->m_c[2] > hb) hb = pC->m_c[2];
	}
		
	color_rgba lowColor; color_quad_u8_set(&lowColor, lr, lg, lb, 0);
	color_rgba highColor; color_quad_u8_set(&highColor, hr, hg, hb, 0);

	// Place endpoints at bbox diagonals and compute interpolated colors 
	const uint32_t N = 8;
	color_rgba weightedColors[8];

	weightedColors[0] = lowColor;
	weightedColors[N - 1] = highColor;
	for (uint32_t i = 1; i < (N - 1); i++)
	{
		weightedColors[i].m_c[0] = (uint8_t)((lowColor.m_c[0] * (64 - g_bc7_weights3[i]) + highColor.m_c[0] * g_bc7_weights3[i] + 32) >> 6);
		weightedColors[i].m_c[1] = (uint8_t)((lowColor.m_c[1] * (64 - g_bc7_weights3[i]) + highColor.m_c[1] * g_bc7_weights3[i] + 32) >> 6);
		weightedColors[i].m_c[2] = (uint8_t)((lowColor.m_c[2] * (64 - g_bc7_weights3[i]) + highColor.m_c[2] * g_bc7_weights3[i] + 32) >> 6);
	}

	// Compute dots and thresholds
	const int ar = highColor.m_c[0] - lowColor.m_c[0];
	const int ag = highColor.m_c[1] - lowColor.m_c[1];
	const int ab = highColor.m_c[2] - lowColor.m_c[2];

	int dots[8];
	for (uint32_t i = 0; i < N; i++)
		dots[i] = weightedColors[i].m_c[0] * ar + weightedColors[i].m_c[1] * ag + weightedColors[i].m_c[2] * ab;

	int thresh[8 - 1];
	for (uint32_t i = 0; i < (N - 1); i++)
		thresh[i] = (dots[i] + dots[i + 1] + 1) >> 1;

	uint64_t total_err = 0;
	if (perceptual)
	{
		// Transform block's interpolated colors to YCbCr
		int l1[8], cr1[8], cb1[8];
		for (int j = 0; j < 8; j++)
		{
			const color_rgba *pE1 = &weightedColors[j];
			l1[j] = pE1->m_c[0] * 109 + pE1->m_c[1] * 366 + pE1->m_c[2] * 37;
			cr1[j] = ((int)pE1->m_c[0] << 9) - l1[j];
			cb1[j] = ((int)pE1->m_c[2] << 9) - l1[j];
		}

		for (uint32_t i = 0; i < num_pixels; i++)
		{
			const color_rgba *pC = &pPixels[i];

			int d = ar * pC->m_c[0] + ag * pC->m_c[1] + ab * pC->m_c[2];

			// Find approximate selector
			uint32_t s = 0;
			if (d >= thresh[6])
				s = 7;
			else if (d >= thresh[5])
				s = 6;
			else if (d >= thresh[4])
				s = 5;
			else if (d >= thresh[3])
				s = 4;
			else if (d >= thresh[2])
				s = 3;
			else if (d >= thresh[1])
				s = 2;
			else if (d >= thresh[0])
				s = 1;

			// Compute error
			const int l2 = pC->m_c[0] * 109 + pC->m_c[1] * 366 + pC->m_c[2] * 37;
			const int cr2 = ((int)pC->m_c[0] << 9) - l2;
			const int cb2 = ((int)pC->m_c[2] << 9) - l2;

			const int dl = (l1[s] - l2) >> 8;
			const int dcr = (cr1[s] - cr2) >> 8;
			const int dcb = (cb1[s] - cb2) >> 8;

			int ie = (pweights[0] * dl * dl) + (pweights[1] * dcr * dcr) + (pweights[2] * dcb * dcb);

			total_err += ie;
			if (total_err > best_err_so_far)
				break;
		}
	}
	else
	{
		for (uint32_t i = 0; i < num_pixels; i++)
		{
			const color_rgba *pC = &pPixels[i];

			int d = ar * pC->m_c[0] + ag * pC->m_c[1] + ab * pC->m_c[2];

			// Find approximate selector
			uint32_t s = 0;
			if (d >= thresh[6])
				s = 7;
			else if (d >= thresh[5])
				s = 6;
			else if (d >= thresh[4])
				s = 5;
			else if (d >= thresh[3])
				s = 4;
			else if (d >= thresh[2])
				s = 3;
			else if (d >= thresh[1])
				s = 2;
			else if (d >= thresh[0])
				s = 1;

			// Compute error
			const color_rgba *pE1 = &weightedColors[s];

			int dr = (int)pE1->m_c[0] - (int)pC->m_c[0];
			int dg = (int)pE1->m_c[1] - (int)pC->m_c[1];
			int db = (int)pE1->m_c[2] - (int)pC->m_c[2];

			total_err += pweights[0] * (dr * dr) + pweights[1] * (dg * dg) + pweights[2] * (db * db);
			if (total_err > best_err_so_far)
				break;
		}
	}

	return total_err;
}

static uint64_t color_cell_compression_est_mode7(uint32_t num_pixels, const color_rgba * pPixels, bool perceptual, uint32_t pweights[4], uint64_t best_err_so_far)
{
	// Find RGB bounds as an approximation of the block's principle axis
	uint32_t lr = 255, lg = 255, lb = 255, la = 255;
	uint32_t hr = 0, hg = 0, hb = 0, ha = 0;
	for (uint32_t i = 0; i < num_pixels; i++)
	{
		const color_rgba* pC = &pPixels[i];
		if (pC->m_c[0] < lr) lr = pC->m_c[0];
		if (pC->m_c[1] < lg) lg = pC->m_c[1];
		if (pC->m_c[2] < lb) lb = pC->m_c[2];
		if (pC->m_c[3] < la) la = pC->m_c[3];

		if (pC->m_c[0] > hr) hr = pC->m_c[0];
		if (pC->m_c[1] > hg) hg = pC->m_c[1];
		if (pC->m_c[2] > hb) hb = pC->m_c[2];
		if (pC->m_c[3] > ha) ha = pC->m_c[3];
	}

	color_rgba lowColor; color_quad_u8_set(&lowColor, lr, lg, lb, la);
	color_rgba highColor; color_quad_u8_set(&highColor, hr, hg, hb, ha);

	// Place endpoints at bbox diagonals and compute interpolated colors 
	const uint32_t N = 4;
	color_rgba weightedColors[4];

	weightedColors[0] = lowColor;
	weightedColors[N - 1] = highColor;
	for (uint32_t i = 1; i < (N - 1); i++)
	{
		weightedColors[i].m_c[0] = (uint8_t)((lowColor.m_c[0] * (64 - g_bc7_weights2[i]) + highColor.m_c[0] * g_bc7_weights2[i] + 32) >> 6);
		weightedColors[i].m_c[1] = (uint8_t)((lowColor.m_c[1] * (64 - g_bc7_weights2[i]) + highColor.m_c[1] * g_bc7_weights2[i] + 32) >> 6);
		weightedColors[i].m_c[2] = (uint8_t)((lowColor.m_c[2] * (64 - g_bc7_weights2[i]) + highColor.m_c[2] * g_bc7_weights2[i] + 32) >> 6);
		weightedColors[i].m_c[3] = (uint8_t)((lowColor.m_c[3] * (64 - g_bc7_weights2[i]) + highColor.m_c[3] * g_bc7_weights2[i] + 32) >> 6);
	}

	// Compute dots and thresholds
	const int ar = highColor.m_c[0] - lowColor.m_c[0];
	const int ag = highColor.m_c[1] - lowColor.m_c[1];
	const int ab = highColor.m_c[2] - lowColor.m_c[2];
	const int aa = highColor.m_c[3] - lowColor.m_c[3];

	int dots[4];
	for (uint32_t i = 0; i < N; i++)
		dots[i] = weightedColors[i].m_c[0] * ar + weightedColors[i].m_c[1] * ag + weightedColors[i].m_c[2] * ab + weightedColors[i].m_c[3] * aa;

	int thresh[4 - 1];
	for (uint32_t i = 0; i < (N - 1); i++)
		thresh[i] = (dots[i] + dots[i + 1] + 1) >> 1;

	uint64_t total_err = 0;
	if (perceptual)
	{
		// Transform block's interpolated colors to YCbCr
		int l1[4], cr1[4], cb1[4];
		for (int j = 0; j < 4; j++)
		{
			const color_rgba* pE1 = &weightedColors[j];
			l1[j] = pE1->m_c[0] * 109 + pE1->m_c[1] * 366 + pE1->m_c[2] * 37;
			cr1[j] = ((int)pE1->m_c[0] << 9) - l1[j];
			cb1[j] = ((int)pE1->m_c[2] << 9) - l1[j];
		}

		for (uint32_t i = 0; i < num_pixels; i++)
		{
			const color_rgba* pC = &pPixels[i];

			int d = ar * pC->m_c[0] + ag * pC->m_c[1] + ab * pC->m_c[2] + aa * pC->m_c[3];

			// Find approximate selector
			uint32_t s = 0;
			if (d >= thresh[2])
				s = 3;
			else if (d >= thresh[1])
				s = 2;
			else if (d >= thresh[0])
				s = 1;

			// Compute error
			const int l2 = pC->m_c[0] * 109 + pC->m_c[1] * 366 + pC->m_c[2] * 37;
			const int cr2 = ((int)pC->m_c[0] << 9) - l2;
			const int cb2 = ((int)pC->m_c[2] << 9) - l2;

			const int dl = (l1[s] - l2) >> 8;
			const int dcr = (cr1[s] - cr2) >> 8;
			const int dcb = (cb1[s] - cb2) >> 8;

			const int dca = (int)pC->m_c[3] - (int)weightedColors[s].m_c[3];

			int ie = (pweights[0] * dl * dl) + (pweights[1] * dcr * dcr) + (pweights[2] * dcb * dcb) + (pweights[3] * dca * dca);

			total_err += ie;
			if (total_err > best_err_so_far)
				break;
		}
	}
	else
	{
		for (uint32_t i = 0; i < num_pixels; i++)
		{
			const color_rgba* pC = &pPixels[i];

			int d = ar * pC->m_c[0] + ag * pC->m_c[1] + ab * pC->m_c[2] + aa * pC->m_c[3];

			// Find approximate selector
			uint32_t s = 0;
			if (d >= thresh[2])
				s = 3;
			else if (d >= thresh[1])
				s = 2;
			else if (d >= thresh[0])
				s = 1;

			// Compute error
			const color_rgba* pE1 = &weightedColors[s];

			int dr = (int)pE1->m_c[0] - (int)pC->m_c[0];
			int dg = (int)pE1->m_c[1] - (int)pC->m_c[1];
			int db = (int)pE1->m_c[2] - (int)pC->m_c[2];
			int da = (int)pE1->m_c[3] - (int)pC->m_c[3];

			total_err += pweights[0] * (dr * dr) + pweights[1] * (dg * dg) + pweights[2] * (db * db) + pweights[3] * (da * da);
			if (total_err > best_err_so_far)
				break;
		}
	}

	return total_err;
}

// This table contains bitmasks indicating which ""key"" partitions must be best ranked before this partition is worth evaluating.
// We first rank the best/most used 14 partitions (sorted by usefulness), record the best one found as the key partition, then use 
// that to control the other partitions to evaluate. The quality loss is ~.08 dB RGB PSNR, the perf gain is up to ~11% (at uber level 0).
static const uint32_t g_partition_predictors[35] =
{
	UINT32_MAX,
	UINT32_MAX,
	UINT32_MAX,
	UINT32_MAX,
	UINT32_MAX,
	(1 << 1) | (1 << 2) | (1 << 8),
	(1 << 1) | (1 << 3) | (1 << 7),
	UINT32_MAX,
	UINT32_MAX,
	(1 << 2) | (1 << 8) | (1 << 16),
	(1 << 7) | (1 << 3) | (1 << 15),
	UINT32_MAX,
	(1 << 8) | (1 << 14) | (1 << 16),
	(1 << 7) | (1 << 14) | (1 << 15),
	UINT32_MAX,
	UINT32_MAX,
	UINT32_MAX,
	UINT32_MAX,
	(1 << 14) | (1 << 15),
	(1 << 16) | (1 << 22) | (1 << 14),
	(1 << 17) | (1 << 24) | (1 << 14),
	(1 << 2) | (1 << 14) | (1 << 15) | (1 << 1),
	UINT32_MAX,
	(1 << 1) | (1 << 3) | (1 << 14) | (1 << 16) | (1 << 22),
	UINT32_MAX,
	(1 << 1) | (1 << 2) | (1 << 15) | (1 << 17) | (1 << 24),
	(1 << 1) | (1 << 3) | (1 << 22),
	UINT32_MAX,
	UINT32_MAX,
	UINT32_MAX,
	(1 << 14) | (1 << 15) | (1 << 16) | (1 << 17),
	UINT32_MAX,
	UINT32_MAX,
	(1 << 1) | (1 << 2) | (1 << 3) | (1 << 27) | (1 << 4) | (1 << 24),
	(1 << 14) | (1 << 15) | (1 << 16) | (1 << 11) | (1 << 17) | (1 << 27)
};

// Estimate the partition used by modes 1/7. This scans through each partition and computes an approximate error for each.
static uint32_t estimate_partition(const color_rgba *pPixels, const bc7enc_compress_block_params *pComp_params, uint32_t pweights[4], uint32_t mode)
{
	const uint32_t total_partitions = minimumu(pComp_params->m_max_partitions, BC7ENC_MAX_PARTITIONS);
	if (total_partitions <= 1)
		return 0;

	uint64_t best_err = UINT64_MAX;
	uint32_t best_partition = 0;

	// Partition order sorted by usage frequency across a large test corpus. Pattern 34 (checkerboard) must appear in slot 34.
	// Using a sorted order allows the user to decrease the # of partitions to scan with minimal loss in quality.
	static const uint8_t s_sorted_partition_order[64] =
	{
		1 - 1, 14 - 1, 2 - 1, 3 - 1, 16 - 1, 15 - 1, 11 - 1, 17 - 1,
		4 - 1, 24 - 1, 27 - 1, 7 - 1, 8 - 1, 22 - 1, 20 - 1, 30 - 1,
		9 - 1, 5 - 1, 10 - 1, 21 - 1, 6 - 1, 32 - 1, 23 - 1, 18 - 1,
		19 - 1, 12 - 1, 13 - 1, 31 - 1, 25 - 1, 26 - 1, 29 - 1, 28 - 1,
		33 - 1, 34 - 1, 35 - 1, 46 - 1, 47 - 1, 52 - 1, 50 - 1, 51 - 1,
		49 - 1, 39 - 1, 40 - 1, 38 - 1, 54 - 1, 53 - 1, 55 - 1, 37 - 1,
		58 - 1, 59 - 1, 56 - 1, 42 - 1, 41 - 1, 43 - 1, 44 - 1, 60 - 1,
		45 - 1, 57 - 1, 48 - 1, 36 - 1, 61 - 1, 64 - 1, 63 - 1, 62 - 1
	};

	assert(s_sorted_partition_order[34] == 34);

	int best_key_partition = 0;

	for (uint32_t partition_iter = 0; (partition_iter < total_partitions) && (best_err > 0); partition_iter++)
	{
		const uint32_t partition = s_sorted_partition_order[partition_iter];

		// Check to see if we should bother evaluating this partition at all, depending on the best partition found from the first 14.
		if (pComp_params->m_mode17_partition_estimation_filterbank)
		{
			if ((partition_iter >= 14) && (partition_iter <= 34))
			{
				const uint32_t best_key_partition_bitmask = 1 << (best_key_partition + 1);
				if ((g_partition_predictors[partition] & best_key_partition_bitmask) == 0)
				{
					if (partition_iter == 34)
						break;

					continue;
				}
			}
		}

		const uint8_t *pPartition = &g_bc7_partition2[partition * 16];

		color_rgba subset_colors[2][16];
		uint32_t subset_total_colors[2] = { 0, 0 };
		for (uint32_t index = 0; index < 16; index++)
			subset_colors[pPartition[index]][subset_total_colors[pPartition[index]]++] = pPixels[index];
						
		uint64_t total_subset_err = 0;
		for (uint32_t subset = 0; (subset < 2) && (total_subset_err < best_err); subset++)
		{
			if (mode == 7)
				total_subset_err += color_cell_compression_est_mode7(subset_total_colors[subset], &subset_colors[subset][0], pComp_params->m_perceptual, pweights, best_err);
			else
				total_subset_err += color_cell_compression_est_mode1(subset_total_colors[subset], &subset_colors[subset][0], pComp_params->m_perceptual, pweights, best_err);
		}

		if (partition < 16)
		{
			total_subset_err = (uint64_t)((double)total_subset_err * pComp_params->m_low_frequency_partition_weight + .5f);
		}

		if (total_subset_err < best_err)
		{
			best_err = total_subset_err;
			best_partition = partition;
		}

		// If the checkerboard pattern doesn't get the highest ranking vs. the previous (lower frequency) patterns, then just stop now because statistically the subsequent patterns won't do well either.
		if ((partition == 34) && (best_partition != 34))
			break;

		if (partition_iter == 13)
			best_key_partition = best_partition;

	} // partition

	return best_partition;
}

static void set_block_bits(uint8_t *pBytes, uint32_t val, uint32_t num_bits, uint32_t *pCur_ofs)
{
	assert((num_bits <= 32) && (val < (1ULL << num_bits)));
	while (num_bits)
	{
		const uint32_t n = minimumu(8 - (*pCur_ofs & 7), num_bits);
		pBytes[*pCur_ofs >> 3] |= (uint8_t)(val << (*pCur_ofs & 7));
		val >>= n;
		num_bits -= n;
		*pCur_ofs += n;
	}
	assert(*pCur_ofs <= 128);
}

struct bc7_optimization_results
{
	uint32_t m_mode;
	uint32_t m_partition;
	uint8_t m_selectors[16];
	uint8_t m_alpha_selectors[16];
	color_rgba m_low[3];
	color_rgba m_high[3];
	uint32_t m_pbits[3][2];
	uint32_t m_rotation;
	uint32_t m_index_selector;
};

void encode_bc7_block(void* pBlock, const bc7_optimization_results* pResults)
{
	assert(pResults->m_index_selector <= 1);
	assert(pResults->m_rotation <= 3);

	const uint32_t best_mode = pResults->m_mode;

	const uint32_t total_subsets = g_bc7_num_subsets[best_mode];
	const uint32_t total_partitions = 1 << g_bc7_partition_bits[best_mode];
	//const uint32_t num_rotations = 1 << g_bc7_rotation_bits[best_mode];
	//const uint32_t num_index_selectors = (best_mode == 4) ? 2 : 1;

	const uint8_t* pPartition;
	if (total_subsets == 1)
		pPartition = &g_bc7_partition1[0];
	else if (total_subsets == 2)
		pPartition = &g_bc7_partition2[pResults->m_partition * 16];
	else
		pPartition = &g_bc7_partition3[pResults->m_partition * 16];

	uint8_t color_selectors[16];
	memcpy(color_selectors, pResults->m_selectors, 16);

	uint8_t alpha_selectors[16];
	memcpy(alpha_selectors, pResults->m_alpha_selectors, 16);

	color_rgba low[3], high[3];
	memcpy(low, pResults->m_low, sizeof(low));
	memcpy(high, pResults->m_high, sizeof(high));

	uint32_t pbits[3][2];
	memcpy(pbits, pResults->m_pbits, sizeof(pbits));

	int anchor[3] = { -1, -1, -1 };

	for (uint32_t k = 0; k < total_subsets; k++)
	{
		uint32_t anchor_index = 0;
		if (k)
		{
			if ((total_subsets == 3) && (k == 1))
				anchor_index = g_bc7_table_anchor_index_third_subset_1[pResults->m_partition];
			else if ((total_subsets == 3) && (k == 2))
				anchor_index = g_bc7_table_anchor_index_third_subset_2[pResults->m_partition];
			else
				anchor_index = g_bc7_table_anchor_index_second_subset[pResults->m_partition];
		}

		anchor[k] = anchor_index;

		const uint32_t color_index_bits = get_bc7_color_index_size(best_mode, pResults->m_index_selector);
		const uint32_t num_color_indices = 1 << color_index_bits;

		if (color_selectors[anchor_index] & (num_color_indices >> 1))
		{
			for (uint32_t i = 0; i < 16; i++)
				if (pPartition[i] == k)
					color_selectors[i] = (uint8_t)((num_color_indices - 1) - color_selectors[i]);

			if (get_bc7_mode_has_seperate_alpha_selectors(best_mode))
			{
				for (uint32_t q = 0; q < 3; q++)
				{
					uint8_t t = low[k].m_c[q];
					low[k].m_c[q] = high[k].m_c[q];
					high[k].m_c[q] = t;
				}
			}
			else
			{
				color_rgba tmp = low[k];
				low[k] = high[k];
				high[k] = tmp;
			}

			if (!g_bc7_mode_has_shared_p_bits[best_mode])
			{
				uint32_t t = pbits[k][0];
				pbits[k][0] = pbits[k][1];
				pbits[k][1] = t;
			}
		}

		if (get_bc7_mode_has_seperate_alpha_selectors(best_mode))
		{
			const uint32_t alpha_index_bits = get_bc7_alpha_index_size(best_mode, pResults->m_index_selector);
			const uint32_t num_alpha_indices = 1 << alpha_index_bits;

			if (alpha_selectors[anchor_index] & (num_alpha_indices >> 1))
			{
				for (uint32_t i = 0; i < 16; i++)
					if (pPartition[i] == k)
						alpha_selectors[i] = (uint8_t)((num_alpha_indices - 1) - alpha_selectors[i]);

				uint8_t t = low[k].m_c[3];
				low[k].m_c[3] = high[k].m_c[3];
				high[k].m_c[3] = t;
			}
		}
	}

	uint8_t* pBlock_bytes = (uint8_t*)(pBlock);
	memset(pBlock_bytes, 0, BC7ENC_BLOCK_SIZE);

	uint32_t cur_bit_ofs = 0;
	set_block_bits(pBlock_bytes, 1 << best_mode, best_mode + 1, &cur_bit_ofs);

	if ((best_mode == 4) || (best_mode == 5))
		set_block_bits(pBlock_bytes, pResults->m_rotation, 2, &cur_bit_ofs);

	if (best_mode == 4)
		set_block_bits(pBlock_bytes, pResults->m_index_selector, 1, &cur_bit_ofs);

	if (total_partitions > 1)
		set_block_bits(pBlock_bytes, pResults->m_partition, (total_partitions == 64) ? 6 : 4, &cur_bit_ofs);

	const uint32_t total_comps = (best_mode >= 4) ? 4 : 3;
	for (uint32_t comp = 0; comp < total_comps; comp++)
	{
		for (uint32_t subset = 0; subset < total_subsets; subset++)
		{
			set_block_bits(pBlock_bytes, low[subset].m_c[comp], (comp == 3) ? g_bc7_alpha_precision_table[best_mode] : g_bc7_color_precision_table[best_mode], &cur_bit_ofs);
			set_block_bits(pBlock_bytes, high[subset].m_c[comp], (comp == 3) ? g_bc7_alpha_precision_table[best_mode] : g_bc7_color_precision_table[best_mode], &cur_bit_ofs);
		}
	}

	if (g_bc7_mode_has_p_bits[best_mode])
	{
		for (uint32_t subset = 0; subset < total_subsets; subset++)
		{
			set_block_bits(pBlock_bytes, pbits[subset][0], 1, &cur_bit_ofs);
			if (!g_bc7_mode_has_shared_p_bits[best_mode])
				set_block_bits(pBlock_bytes, pbits[subset][1], 1, &cur_bit_ofs);
		}
	}

	for (uint32_t y = 0; y < 4; y++)
	{
		for (uint32_t x = 0; x < 4; x++)
		{
			int idx = x + y * 4;

			uint32_t n = pResults->m_index_selector ? get_bc7_alpha_index_size(best_mode, pResults->m_index_selector) : get_bc7_color_index_size(best_mode, pResults->m_index_selector);

			if ((idx == anchor[0]) || (idx == anchor[1]) || (idx == anchor[2]))
				n--;

			set_block_bits(pBlock_bytes, pResults->m_index_selector ? alpha_selectors[idx] : color_selectors[idx], n, &cur_bit_ofs);
		}
	}

	if (get_bc7_mode_has_seperate_alpha_selectors(best_mode))
	{
		for (uint32_t y = 0; y < 4; y++)
		{
			for (uint32_t x = 0; x < 4; x++)
			{
				int idx = x + y * 4;

				uint32_t n = pResults->m_index_selector ? get_bc7_color_index_size(best_mode, pResults->m_index_selector) : get_bc7_alpha_index_size(best_mode, pResults->m_index_selector);

				if ((idx == anchor[0]) || (idx == anchor[1]) || (idx == anchor[2]))
					n--;

				set_block_bits(pBlock_bytes, pResults->m_index_selector ? color_selectors[idx] : alpha_selectors[idx], n, &cur_bit_ofs);
			}
		}
	}

	assert(cur_bit_ofs == 128);
}

static void handle_alpha_block_mode5(const color_rgba* pPixels, const bc7enc_compress_block_params* pComp_params, color_cell_compressor_params* pParams, uint32_t lo_a, uint32_t hi_a, bc7_optimization_results* pOpt_results5, uint64_t* pMode5_err, uint64_t* pMode5_alpha_err)
{
	pParams->m_pSelector_weights = g_bc7_weights2;
	pParams->m_pSelector_weightsx = (const vec4F*)g_bc7_weights2x;
	pParams->m_num_selector_weights = 4;

	pParams->m_comp_bits = 7;
	pParams->m_has_pbits = false;
	pParams->m_endpoints_share_pbit = false;
	pParams->m_has_alpha = false;

	pParams->m_perceptual = pComp_params->m_perceptual;

	pParams->m_num_pixels = 16;
	pParams->m_pPixels = pPixels;

	color_cell_compressor_results results5;
	results5.m_pSelectors = pOpt_results5->m_selectors;

	uint8_t selectors_temp[16];
	results5.m_pSelectors_temp = selectors_temp;

	*pMode5_err = color_cell_compression(5, pParams, &results5, pComp_params);
	assert(*pMode5_err == results5.m_best_overall_err);

	pOpt_results5->m_low[0] = results5.m_low_endpoint;
	pOpt_results5->m_high[0] = results5.m_high_endpoint;

	if (lo_a == hi_a)
	{
		*pMode5_alpha_err = 0;
		pOpt_results5->m_low[0].m_c[3] = (uint8_t)lo_a;
		pOpt_results5->m_high[0].m_c[3] = (uint8_t)hi_a;
		memset(pOpt_results5->m_alpha_selectors, 0, sizeof(pOpt_results5->m_alpha_selectors));
	}
	else
	{
		*pMode5_alpha_err = UINT64_MAX;

		const uint32_t total_passes = (pComp_params->m_uber_level >= 1) ? 3 : 2;
		for (uint32_t pass = 0; pass < total_passes; pass++)
		{
			int32_t vals[4];
			vals[0] = lo_a;
			vals[3] = hi_a;

			const int32_t w_s1 = 21, w_s2 = 43;
			vals[1] = (vals[0] * (64 - w_s1) + vals[3] * w_s1 + 32) >> 6;
			vals[2] = (vals[0] * (64 - w_s2) + vals[3] * w_s2 + 32) >> 6;

			uint8_t trial_alpha_selectors[16];

			uint64_t trial_alpha_err = 0;
			for (uint32_t i = 0; i < 16; i++)
			{
				const int32_t a = pParams->m_pPixels[i].m_c[3];

				int s = 0;
				int32_t be = iabs32(a - vals[0]);
				int e = iabs32(a - vals[1]); if (e < be) { be = e; s = 1; }
				e = iabs32(a - vals[2]); if (e < be) { be = e; s = 2; }
				e = iabs32(a - vals[3]); if (e < be) { be = e; s = 3; }

				trial_alpha_selectors[i] = (uint8_t)s;

				uint32_t a_err = (uint32_t)(be * be) * pParams->m_weights[3];

				trial_alpha_err += a_err;
			}

			if (trial_alpha_err < *pMode5_alpha_err)
			{
				*pMode5_alpha_err = trial_alpha_err;
				pOpt_results5->m_low[0].m_c[3] = (uint8_t)lo_a;
				pOpt_results5->m_high[0].m_c[3] = (uint8_t)hi_a;
				memcpy(pOpt_results5->m_alpha_selectors, trial_alpha_selectors, sizeof(pOpt_results5->m_alpha_selectors));
			}

			if (pass != (total_passes - 1U)) 
			{
				float xl, xh;
				compute_least_squares_endpoints_a(16, trial_alpha_selectors, (const vec4F*)g_bc7_weights2x, &xl, &xh, pParams->m_pPixels);

				uint32_t new_lo_a = clampi((int)floor(xl + .5f), 0, 255);
				uint32_t new_hi_a = clampi((int)floor(xh + .5f), 0, 255);
				if (new_lo_a > new_hi_a)
					swapu(&new_lo_a, &new_hi_a);

				if ((new_lo_a == lo_a) && (new_hi_a == hi_a))
					break;

				lo_a = new_lo_a;
				hi_a = new_hi_a;
			}
		}

		*pMode5_err += *pMode5_alpha_err;
	}
}

static void handle_alpha_block(void *pBlock, const color_rgba *pPixels, const bc7enc_compress_block_params *pComp_params, color_cell_compressor_params *pParams)
{
	assert((pComp_params->m_mode_mask & (1 << 6)) || (pComp_params->m_mode_mask & (1 << 5)) || (pComp_params->m_mode_mask & (1 << 7)));

	pParams->m_pSelector_weights = g_bc7_weights4;
	pParams->m_pSelector_weightsx = (const vec4F *)g_bc7_weights4x;
	pParams->m_num_selector_weights = 16;
	pParams->m_comp_bits = 7;
	pParams->m_has_pbits = true;
	pParams->m_endpoints_share_pbit = false;
	pParams->m_has_alpha = true;
	pParams->m_perceptual = pComp_params->m_perceptual;
	pParams->m_num_pixels = 16;
	pParams->m_pPixels = pPixels;
		
	bc7_optimization_results opt_results6, opt_results5, opt_results7;
	color_cell_compressor_results results6;
	memset(&results6, 0, sizeof(results6));

	uint64_t best_err = UINT64_MAX;
	uint32_t best_mode = 0;
	uint8_t selectors_temp[16];

	if (pComp_params->m_mode_mask & (1 << 6))
	{
		results6.m_pSelectors = opt_results6.m_selectors;
		results6.m_pSelectors_temp = selectors_temp;

		best_err = (uint64_t)(color_cell_compression(6, pParams, &results6, pComp_params) * pComp_params->m_mode6_error_weight + .5f);
		best_mode = 6;
	}

	if ((best_err > 0) && (pComp_params->m_mode_mask & (1 << 5)))
	{
		uint32_t lo_a = 255, hi_a = 0;
		for (uint32_t i = 0; i < 16; i++)
		{
			uint32_t a = pPixels[i].m_c[3];
			lo_a = minimumu(lo_a, a);
			hi_a = maximumu(hi_a, a);
		}

		uint64_t mode5_err, mode5_alpha_err;
		handle_alpha_block_mode5(pPixels, pComp_params, pParams, lo_a, hi_a, &opt_results5, &mode5_err, &mode5_alpha_err);

		mode5_err = (uint64_t)(mode5_err * pComp_params->m_mode5_error_weight + .5f);

		if (mode5_err < best_err)
		{
			best_err = mode5_err;
			best_mode = 5;
		}
	}

	if ((best_err > 0) && (pComp_params->m_mode_mask & (1 << 7)))
	{
		const uint32_t trial_partition = estimate_partition(pPixels, pComp_params, pParams->m_weights, 7);

		pParams->m_pSelector_weights = g_bc7_weights2;
		pParams->m_pSelector_weightsx = (const vec4F*)g_bc7_weights2x;
		pParams->m_num_selector_weights = 4;
		pParams->m_comp_bits = 5;
		pParams->m_has_pbits = true;
		pParams->m_endpoints_share_pbit = false;
		pParams->m_has_alpha = true;

		const uint8_t* pPartition = &g_bc7_partition2[trial_partition * 16];

		color_rgba subset_colors[2][16];

		uint32_t subset_total_colors7[2] = { 0, 0 };

		uint8_t subset_pixel_index7[2][16];
		uint8_t subset_selectors7[2][16];
		color_cell_compressor_results subset_results7[2];

		for (uint32_t idx = 0; idx < 16; idx++)
		{
			const uint32_t p = pPartition[idx];
			subset_colors[p][subset_total_colors7[p]] = pPixels[idx];
			subset_pixel_index7[p][subset_total_colors7[p]] = (uint8_t)idx;
			subset_total_colors7[p]++;
		}

		uint64_t trial_err = 0;
		for (uint32_t subset = 0; subset < 2; subset++)
		{
			pParams->m_num_pixels = subset_total_colors7[subset];
			pParams->m_pPixels = &subset_colors[subset][0];

			color_cell_compressor_results* pResults = &subset_results7[subset];
			pResults->m_pSelectors = &subset_selectors7[subset][0];
			pResults->m_pSelectors_temp = selectors_temp;
			uint64_t err = color_cell_compression(7, pParams, pResults, pComp_params);
			trial_err += err;
			if ((uint64_t)(trial_err * pComp_params->m_mode7_error_weight + .5f) > best_err)
				break;

		} // subset

		const uint64_t mode7_trial_err = (uint64_t)(trial_err * pComp_params->m_mode7_error_weight + .5f);

		if (mode7_trial_err < best_err)
		{
			best_err = mode7_trial_err;
			best_mode = 7;
			opt_results7.m_mode = 7;
			opt_results7.m_partition = trial_partition;
			opt_results7.m_index_selector = 0;
			opt_results7.m_rotation = 0;
			for (uint32_t subset = 0; subset < 2; subset++)
			{
				for (uint32_t i = 0; i < subset_total_colors7[subset]; i++)
					opt_results7.m_selectors[subset_pixel_index7[subset][i]] = subset_selectors7[subset][i];
				opt_results7.m_low[subset] = subset_results7[subset].m_low_endpoint;
				opt_results7.m_high[subset] = subset_results7[subset].m_high_endpoint;
				opt_results7.m_pbits[subset][0] = subset_results7[subset].m_pbits[0];
				opt_results7.m_pbits[subset][1] = subset_results7[subset].m_pbits[1];
			}
		}
	}

	if (best_mode == 7)
	{
		encode_bc7_block(pBlock, &opt_results7);
	}
	else if (best_mode == 5)
	{
		opt_results5.m_mode = 5;
		opt_results5.m_partition = 0;
		opt_results5.m_rotation = 0;
		opt_results5.m_index_selector = 0;

		encode_bc7_block(pBlock, &opt_results5);
	}
	else if (best_mode == 6)
	{
		opt_results6.m_mode = 6;
		opt_results6.m_partition = 0;
		opt_results6.m_low[0] = results6.m_low_endpoint;
		opt_results6.m_high[0] = results6.m_high_endpoint;
		opt_results6.m_pbits[0][0] = results6.m_pbits[0];
		opt_results6.m_pbits[0][1] = results6.m_pbits[1];
		opt_results6.m_rotation = 0;
		opt_results6.m_index_selector = 0;

		encode_bc7_block(pBlock, &opt_results6);
	}
	else
	{
		assert(0);
	}
}

static void handle_opaque_block(void *pBlock, const color_rgba *pPixels, const bc7enc_compress_block_params *pComp_params, color_cell_compressor_params *pParams)
{
	assert((pComp_params->m_mode_mask & (1 << 6)) || (pComp_params->m_mode_mask & (1 << 1)));

	uint8_t selectors_temp[16];
		
	bc7_optimization_results opt_results;

	uint64_t best_err = UINT64_MAX;
		
	pParams->m_perceptual = pComp_params->m_perceptual;
	pParams->m_num_pixels = 16;
	pParams->m_pPixels = pPixels;
	pParams->m_has_alpha = false;

	opt_results.m_partition = 0;
	opt_results.m_index_selector = 0;
	opt_results.m_rotation = 0;

	// Mode 6
	if (pComp_params->m_mode_mask & (1 << 6))
	{
		pParams->m_pSelector_weights = g_bc7_weights4;
		pParams->m_pSelector_weightsx = (const vec4F*)g_bc7_weights4x;
		pParams->m_num_selector_weights = 16;
		pParams->m_comp_bits = 7;
		pParams->m_has_pbits = true;
		pParams->m_endpoints_share_pbit = false;

		color_cell_compressor_results results6;
		results6.m_pSelectors = opt_results.m_selectors;
		results6.m_pSelectors_temp = selectors_temp;

		best_err = (uint64_t)(color_cell_compression(6, pParams, &results6, pComp_params) * pComp_params->m_mode6_error_weight + .5f);

		opt_results.m_mode = 6;
		opt_results.m_low[0] = results6.m_low_endpoint;
		opt_results.m_high[0] = results6.m_high_endpoint;
		opt_results.m_pbits[0][0] = results6.m_pbits[0];
		opt_results.m_pbits[0][1] = results6.m_pbits[1];
	}

	// Mode 1
	if ((best_err > 0) && (pComp_params->m_max_partitions > 0) && (pComp_params->m_mode_mask & (1 << 1)))
	{
		const uint32_t trial_partition = estimate_partition(pPixels, pComp_params, pParams->m_weights, 1);
		
		pParams->m_pSelector_weights = g_bc7_weights3;
		pParams->m_pSelector_weightsx = (const vec4F *)g_bc7_weights3x;
		pParams->m_num_selector_weights = 8;
		pParams->m_comp_bits = 6;
		pParams->m_has_pbits = true;
		pParams->m_endpoints_share_pbit = true;

		const uint8_t *pPartition = &g_bc7_partition2[trial_partition * 16];

		color_rgba subset_colors[2][16];

		uint32_t subset_total_colors1[2] = { 0, 0 };

		uint8_t subset_pixel_index1[2][16];
		uint8_t subset_selectors1[2][16];
		color_cell_compressor_results subset_results1[2];

		for (uint32_t idx = 0; idx < 16; idx++)
		{
			const uint32_t p = pPartition[idx];
			subset_colors[p][subset_total_colors1[p]] = pPixels[idx];
			subset_pixel_index1[p][subset_total_colors1[p]] = (uint8_t)idx;
			subset_total_colors1[p]++;
		}

		uint64_t trial_err = 0;
		for (uint32_t subset = 0; subset < 2; subset++)
		{
			pParams->m_num_pixels = subset_total_colors1[subset];
			pParams->m_pPixels = &subset_colors[subset][0];

			color_cell_compressor_results *pResults = &subset_results1[subset];
			pResults->m_pSelectors = &subset_selectors1[subset][0];
			pResults->m_pSelectors_temp = selectors_temp;
			uint64_t err = color_cell_compression(1, pParams, pResults, pComp_params);
			
			trial_err += err;
			if ((uint64_t)(trial_err * pComp_params->m_mode1_error_weight + .5f) > best_err)
				break;

		} // subset

		const uint64_t mode1_trial_err = (uint64_t)(trial_err * pComp_params->m_mode1_error_weight + .5f);
		if (mode1_trial_err < best_err)
		{
			best_err = mode1_trial_err;
			opt_results.m_mode = 1;
			opt_results.m_partition = trial_partition;
			for (uint32_t subset = 0; subset < 2; subset++)
			{
				for (uint32_t i = 0; i < subset_total_colors1[subset]; i++)
					opt_results.m_selectors[subset_pixel_index1[subset][i]] = subset_selectors1[subset][i];
				opt_results.m_low[subset] = subset_results1[subset].m_low_endpoint;
				opt_results.m_high[subset] = subset_results1[subset].m_high_endpoint;
				opt_results.m_pbits[subset][0] = subset_results1[subset].m_pbits[0];
			}
		}
	}

	encode_bc7_block(pBlock, &opt_results);
}

bool bc7enc_compress_block(void *pBlock, const void *pPixelsRGBA, const bc7enc_compress_block_params *pComp_params)
{
	assert(g_bc7_mode_1_optimal_endpoints[255][0].m_hi != 0);

	const color_rgba *pPixels = (const color_rgba *)(pPixelsRGBA);

	color_cell_compressor_params params;
	if (pComp_params->m_perceptual)
	{
		// https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.709_conversion
		const float pr_weight = (.5f / (1.0f - .2126f)) * (.5f / (1.0f - .2126f));
		const float pb_weight = (.5f / (1.0f - .0722f)) * (.5f / (1.0f - .0722f));
		params.m_weights[0] = (int)(pComp_params->m_weights[0] * 4.0f);
		params.m_weights[1] = (int)(pComp_params->m_weights[1] * 4.0f * pr_weight);
		params.m_weights[2] = (int)(pComp_params->m_weights[2] * 4.0f * pb_weight);
		params.m_weights[3] = pComp_params->m_weights[3] * 4;
	}
	else
		memcpy(params.m_weights, pComp_params->m_weights, sizeof(params.m_weights));
	
	if (pComp_params->m_force_alpha)
	{
		handle_alpha_block(pBlock, pPixels, pComp_params, &params);
		return true;
	}

	for (uint32_t i = 0; i < 16; i++)
	{
		if (pPixels[i].m_c[3] < 255)
		{
			handle_alpha_block(pBlock, pPixels, pComp_params, &params);
			return true;
		}
	}
	handle_opaque_block(pBlock, pPixels, pComp_params, &params);
	return false;
}

static const uint8_t g_tdefl_small_dist_extra[512] =
{
	0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7
};

static const uint8_t g_tdefl_large_dist_extra[128] =
{
	0, 0, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13
};

static inline uint32_t compute_match_cost_estimate(uint32_t dist, uint32_t match_len_in_bytes)
{
	assert(match_len_in_bytes <= 258);

	uint32_t len_cost = 6;
	if (match_len_in_bytes >= 12)
		len_cost = 9;
	else if (match_len_in_bytes >= 8)
		len_cost = 8;
	else if (match_len_in_bytes >= 6)
		len_cost = 7;

	uint32_t dist_cost = 5;
	if (dist < 512)
		dist_cost += g_tdefl_small_dist_extra[dist & 511];
	else
	{
		dist_cost += g_tdefl_large_dist_extra[std::min<uint32_t>(dist, 32767) >> 8];
		while (dist >= 32768)
		{
			dist_cost++;
			dist >>= 1;
		}
	}
	return len_cost + dist_cost;
}

class tracked_stat
{
public:
	tracked_stat() { clear(); }

	void clear() { m_num = 0; m_total = 0; m_total2 = 0; }

	void update(uint32_t val) { m_num++; m_total += val; m_total2 += val * val; }

	tracked_stat& operator += (uint32_t val) { update(val); return *this; }

	uint32_t get_number_of_values() { return m_num; }
	uint64_t get_total() const { return m_total; }
	uint64_t get_total2() const { return m_total2; }

	float get_average() const { return m_num ? (float)m_total / m_num : 0.0f; };
	float get_std_dev() const { return m_num ? sqrtf((float)(m_num * m_total2 - m_total * m_total)) / m_num : 0.0f; }
	float get_variance() const { float s = get_std_dev(); return s * s; }

private:
	uint32_t m_num;
	uint64_t m_total;
	uint64_t m_total2;
};

static inline float compute_block_max_std_dev(const color_rgba* pPixels)
{
	tracked_stat r_stats, g_stats, b_stats, a_stats;

	for (uint32_t i = 0; i < 16; i++)
	{
		r_stats.update(pPixels[i].m_c[0]);
		g_stats.update(pPixels[i].m_c[1]);
		b_stats.update(pPixels[i].m_c[2]);
		a_stats.update(pPixels[i].m_c[3]);
	}

	return std::max<float>(std::max<float>(std::max(r_stats.get_std_dev(), g_stats.get_std_dev()), b_stats.get_std_dev()), a_stats.get_std_dev());
}

struct bc7_block
{
	uint8_t m_bytes[16];

	uint32_t get_mode() const
	{
		uint32_t bc7_mode = 0;
		while (((m_bytes[0] & (1 << bc7_mode)) == 0) && (bc7_mode < 8))
			bc7_mode++;
		return bc7_mode;
	}
};

/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
If you use this software in a product, attribution / credits is requested but not required.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright(c) 2020-2021 <NAME>, Jr.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files(the ""Software""), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain(www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non - commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain.We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors.We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/
",best_hi_p
19,"// Copyright <NAME> 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

export module tm.ability_blocks_move;

import tm.move.category;
import tm.move.known_move;
import tm.move.move_name;
import tm.move.target;

import tm.status.status_name;

import tm.type.effectiveness;
import tm.type.pokemon_types;
import tm.type.type;

import tm.ability;
import tm.generation;

namespace technicalmachine {

export constexpr auto ability_blocks_move(Generation const generation, Ability const ability, KnownMove const move, StatusName const  [MASK] , PokemonTypes const target_types) -> bool {
	auto absorb_ability_activates = [=](Type const absorbed_type) {
		return move_targets_foe(generation, move.name) and move.type == absorbed_type;
	};

	switch (ability) {
		case Ability::Flash_Fire:
			if (generation <= Generation::four and  [MASK]  == StatusName::freeze) {
				return false;
			}
			return
				absorb_ability_activates(Type::Fire) and
				(generation >= Generation::four or move.name != MoveName::Will_O_Wisp);
		case Ability::Volt_Absorb:
			return
				absorb_ability_activates(Type::Electric) and
				(generation >= Generation::four or move.name != MoveName::Thunder_Wave);
		case Ability::Water_Absorb:
		case Ability::Dry_Skin:
			return absorb_ability_activates(Type::Water);
		case Ability::Wonder_Guard:
			if (!is_damaging(move.name)) {
				return false;
			}
			if (Effectiveness(generation, move.type, target_types).is_super_effective()) {
				return false;
			}
			switch (move.name) {
				case MoveName::Beat_Up:
					return generation >= Generation::five;
				case MoveName::Fire_Fang:
					return generation != Generation::four;
				case MoveName::Struggle:
					return false;
				default:
					return true;
			}
		case Ability::Motor_Drive:
			return absorb_ability_activates(Type::Electric);
		default:
			return false;
	}
}

} // namespace technicalmachine
",target_status
20,"//
// Created by csq on 2017/12/26.
//

#include ""Sort.h""


void CSort::sort(int *a, int n, ESortType  [MASK] ) {
    switch ( [MASK] ) {
        case ekSortType_Bubble:
            sortBubble(a, n);
            break;
        case ekSortType_Bubble_BiDirect:
            sortBubbleBiDirect(a, n);
            break;
        case ekSortType_Insert:
            sortInsert(a, n);
            break;
        case ekSortType_Insert_Dichotomy:
            sortInsertDichotomy(a, n);
            break;
        case ekSortType_Select:
            sortSelect(a, n);
            break;
        case ekSortType_Exchange:
            sortExchange(a, n);
            break;
        case ekSortType_Quick:
            sortQuick(a, n);
            break;
        case ekSortType_Merge:
            sortMerge(a, n);
            break;
        case ekSortType_MinHeap:
            sortMinHeap(a, n);
            break;
        case ekSortType_Shell:
            sortShell(a, n);
            break;
        case ekSortType_Radix:
            sortRadix(a, n);
            break;
        default:
            break;
    }
}

void CSort::sortBubble(int *a, int n) {

    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (a[j] > a[j + 1])
                swap(a[j], a[j + 1]);
        }
    }

}

void CSort::sortBubbleBiDirect(int *a, int n) {
    int low = 0;
    int high = n - 1;
    while (high > low) {
        for (int i = low; i < high; i++) {
            if (a[i] > a[i + 1])
                swap(a[i], a[i + 1]);
        }
        high--;
        for (int i = high; i > low; i--) {
            if (a[i - 1] > a[i])
                swap(a[i - 1], a[i]);
        }
        low++;
    }
}

void CSort::sortInsert(int *a, int n) {
    for (int i = 1; i < n; i++) {
        int val = a[i];
        int j = i - 1;
        while (j >= 0 && a[j] > val) {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = val;
    }
}

void CSort::sortInsertDichotomy(int *a, int n) {
    for (int i = 1; i < n; i++) {
        int val = a[i];
        //find insert pos
        int low = 0;
        int high = i - 1;
        int mid;
        while (high >= low) {
            mid = (low + high) / 2;
            if (a[mid] > val)
                high = mid - 1;
            else
                low = mid + 1;
        }
        for (int j = i - 1; j >= low; j--) {
            a[j + 1] = a[j];
        }
        a[low] = val;
    }

}

void CSort::sortSelect(int *a, int n) {
    int minIdx;
    for (int i = 0; i < n - 1; i++) {
        minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (a[j] < a[minIdx])
                minIdx = j;
        }
        swap(a[i], a[minIdx]);
    }
}

void CSort::sortExchange(int *a, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (a[i] > a[j])
                swap(a[i], a[j]);
        }
    }
}

void CSort::sortQuick(int *a, int n) {
    __sortQuick(a, 0, n - 1);
}

void CSort::sortMerge(int *a, int n) {
    int *b = new int[n];
    __sortMerge(a, 0, n - 1, b);
    delete[]b;
}


void CSort::sortMinHeap(int *a, int n) {
    makeMinHeap(a, n);
    for (int i = n - 1; i > 0; i--) {
        swap(a[0], a[i]);
        minHeapFixDown(a, i, 0);
    }
    int start = 0;
    int end = n - 1;
    while (end > start) {
        swap(a[start++], a[end--]);
    }

}

void CSort::sortShell(int *a, int n) {

    for (int step = n / 2; step > 0; step /= 2) {
        for (int group = 0; group < step; group++) {
            for (int i = group + step; i < n; i += step) {
                int val = a[i];
                int j = i - step;
                while (j >= group && a[j] > val) {
                    a[j + step] = a[j];
                    j -= step;
                }
                a[j + step] = val;
            }
        }
    }

}

void CSort::sortRadix(int *a, int n) {
    int *count = new int[10];
    int *bucket = new int[n];
    int maxLen = maxNumLen(a, n);
    int divisor = 1;

    for (int i = 0; i < maxLen; i++) {
        for (int j = 0; j < 10; j++)
            count[j] = 0;
        for (int j = 0; j < n; j++) {
            int num = (a[j] / divisor) % 10;
            count[num]++;
        }
        for (int j = 1; j < 10; j++) {
            count[j] += count[j - 1];
        }

        for (int j = n - 1; j >= 0; j--) {
            int num = (a[j] / divisor) % 10;
            bucket[count[num] - 1] = a[j];
            count[num]--;
        }
        for (int j = 0; j < n; j++) {
            a[j] = bucket[j];
        }
        divisor *= 10;
    }

    delete[]count;
    delete[]bucket;
}


void CSort::swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

void CSort::__sortQuick(int *a, int start, int end) {

    if (start >= end)
        return;
    int key = a[start];
    int low = start;
    int high = end;
    while (high > low) {
        while (high > low && a[high] >= key) {
            high--;
        }
        a[low] = a[high];
        while (high > low && a[low] <= key) {
            low++;
        }
        a[high] = a[low];
    }
    a[low] = key;
    __sortQuick(a, 0, low - 1);
    __sortQuick(a, low + 1, end);
}

void CSort::mergeArray(int *a, int start, int mid, int end, int *b) {
    int first = start;
    int second = mid + 1;
    int idx = start;
    while (first <= mid && second <= end) {
        if (a[first] > a[second]) {
            b[idx++] = a[second++];
        } else {
            b[idx++] = a[first++];
        }
    }
    while (first <= mid) {
        b[idx++] = a[first++];

    }
    while (second <= end) {
        b[idx++] = a[second++];
    }
    for (int i = start; i <= end; i++)
        a[i] = b[i];
}

void CSort::__sortMerge(int *a, int start, int end, int *b) {
    if (start >= end)
        return;

    int mid = (start + end) / 2;
    __sortMerge(a, start, mid, b);
    __sortMerge(a, mid + 1, end, b);
    mergeArray(a, start, mid, end, b);
}


void CSort::minHeapFixDown(int *a, int n, int i) {
    int val = a[i];
    int child = i * 2 + 1;
    while (child <= n - 1) {
        if (child + 1 <= n - 1 && a[child + 1] < a[child])
            child = child + 1;
        if (a[child] >= val)
            break;
        a[(child - 1) / 2] = a[child];
        child = child * 2 + 1;
    }
    a[(child - 1) / 2] = val;

}

void CSort::makeMinHeap(int *a, int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        minHeapFixDown(a, n, i);
}


int CSort::maxNumLen(int *a, int n) {
    int maxLen = 1;
    int divisor = 10;
    for (int i = 0; i < n; i++) {
        while (a[i] / divisor > 0) {
            maxLen++;
            divisor *= 10;
        }
    }
    return maxLen;
}
",type
21,"#include<iostream>
#include<list>
#include<stdlib.h>

using namespace std;

class Student {
private:
    int nr_matricol;
    string nume;
public:
    Student(const int nr_matricol, const string nume):
            nr_matricol(nr_matricol), nume(nume){};

    Student(const Student& s) {
        nr_matricol = s.nr_matricol;
        nume = s.nume + "" - copy"";
    }

    virtual string to_string() {
        return ""[ "" + std::to_string(nr_matricol) + "" ] "" + nume;
    }

    bool operator==(const Student& rhs) {
        return (nr_matricol == rhs.nr_matricol) 
                && (nume == rhs.nume);
    }

    Student& operator=(const Student& rhs) {
        nr_matricol = rhs.nr_matricol;
        nume = rhs.nume;

        return *this;
    }
};

class StudentBursier : public Student {
private:
    double valoare_bursa;
public:
    StudentBursier(const int nr_matricol, const string nume,
                   const double valoare_bursa) : Student(nr_matricol, nume),
                   valoare_bursa(valoare_bursa) {};

    // copy constructor ce apeleaza copy constructor-ul super clasei
    StudentBursier(const StudentBursier& s) : Student(s), valoare_bursa(s.valoare_bursa) {};

    string to_string() {
        return Student::to_string() + "" - bursa: "" + std::to_string(valoare_bursa);
    }

    // copying base class field values as well
    StudentBursier& operator=(const StudentBursier& rhs) {
        Student::operator=(rhs);
        valoare_bursa = rhs.valoare_bursa;
        return *this;
    }
};

class FisaMatricola {
private:
    Student* student;
    list<int> note;
public:
    FisaMatricola(Student* student, const list<int> note):
                  student(student), note(note){};
    
    FisaMatricola& operator=(const FisaMatricola& rhs) {

        // self assignment safety
        Student *stOrig = student;
        student = new Student(*rhs.student);
        delete stOrig;

        note = rhs.note;
        return *this;
    }

    FisaMatricola& operator+=(const FisaMatricola& rhs) {
        // se va face join doar daca studentul este acelasi
        if (student == rhs.student) {
            for (auto const& nota : rhs.note)
                note.push_back(nota);
        }
        return *this;
    }

    void adauga_nota(const int n) {
        note.push_back(n);
    }

    string to_string() {
        string  [MASK]  = (*student).to_string() + "": "";

        for (auto const& nota : note) {
             [MASK]  += std::to_string(nota) + ""; "";
        }
        
        return  [MASK] ;
    }
};",res
22,"/*
 * CompoundSolver.cpp
 *
 * Copyright 2023 <NAME> and Contributors
 *
 * 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.
 *
 * Created on:
 *     Author:
 */
#include ""dmgr/impl/DebugMacros.h""
#include ""CompoundSolver.h""
#include ""TaskBuildSolveSets.h""


namespace vsc {
namespace solvers {


CompoundSolver::CompoundSolver(
    dmgr::IDebugMgr         *dmgr,
    ISolverFactory          *solver_f) : 
        m_dmgr(dmgr), m_solver_f(solver_f), 
        m_solver_unconstrained(dmgr) {
    DEBUG_INIT(""vsc::solvers::CompoundSolver"", dmgr);
}

CompoundSolver::~CompoundSolver() {

}

bool CompoundSolver::randomize(
			IRandState								    *randstate,
            dm::IModelField                             *root_field,
            const RefPathSet                            &target_fields,
            const RefPathSet                            &fixed_fields,
            const RefPathSet                            &include_constraints,
            const RefPathSet                            &exclude_constraints,
			SolveFlags								    flags) {
    std::vector<ISolveSetUP>     [MASK] ;
    RefPathSet                  unconstrained;

    TaskBuildSolveSets(
        m_dmgr,
        root_field,
        target_fields,
        fixed_fields,
        include_constraints,
        exclude_constraints).build( [MASK] , unconstrained);

    // First, randomize any unconstrained fields
    if (!unconstrained.empty()) {
        RefPathSet fixed_fields;
        m_solver_unconstrained.randomize(
            randstate,
            root_field,
            unconstrained);
    }

    // Now, move on
    for (std::vector<ISolveSetUP>::const_iterator
        it= [MASK] .begin();
        it!= [MASK] .end(); it++) {
        ISolverUP solver(m_solver_f->mkSolver(it->get()));
        if (!solver->randomize(randstate, root_field, it->get())) {
        }
    }

    return true;
}

bool CompoundSolver::sat(
            dm::IModelField                             *root_field,
            const RefPathSet                            &target_fields,
            const RefPathSet                            &fixed_fields,
            const RefPathSet                            &include_constraints,
            const RefPathSet                            &exclude_constraints,
			SolveFlags								    flags) {
    return true;
}

dmgr::IDebug *CompoundSolver::m_dbg = 0;

}
}
",solvesets
23,"/*
 * Copyright (c) 2024, wareya
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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 <SPI.h>
#include <mbed.h>

REDIRECT_STDOUT_TO(Serial);

#include <PluggableUSBHID.h>

#include ""srom_3360_0x05.h""
#include ""relmouse_16.h""
USBMouse16 mouse(false);

#define REG_PRODUCT_ID (0x00)
#define REG_REVISION_ID (0x01)
#define REG_MOTION (0x02)
#define REG_DELTA_X_L (0x03)
#define REG_DELTA_X_H (0x04)
#define REG_DELTA_Y_L (0x05)
#define REG_DELTA_Y_H (0x06)
#define REG_SQUAL (0x07)
#define REG_RAW_DATA_SUM (0x08)
#define REG_MAX_RAW_DATA (0x09)
#define REG_MIN_RAW_DATA (0x0A)
#define REG_SHUTTER_LOWER (0x0B)
#define REG_SHUTTER_UPPER (0x0C)
#define REG_CONTROL (0x0D)

#define REG_CONFIG1 (0x0F)
#define REG_CONFIG2 (0x10)
#define REG_ANGLE_TUNE (0x11)
#define REG_FRAME_CAPTURE (0x12)
#define REG_SROM_ENABLE (0x13)
#define REG_RUN_DOWNSHIFT (0x14)
#define REG_REST1_RATE_LOWER (0x15)
#define REG_REST1_RATE_UPPER (0x16)
#define REG_REST1_DOWNSHIFT (0x17)
#define REG_REST2_RATE_LOWER (0x18)
#define REG_REST2_RATE_UPPER (0x19)
#define REG_REST2_DOWNSHIFT (0x1A)
#define REG_REST3_RATE_LOWER (0x1B)
#define REG_REST3_RATE_UPPER (0x1C)

#define REG_OBSERVATION (0x24)
#define REG_DATA_OUT_LOWER (0x25)
#define REG_DATA_OUT_UPPER (0x26)

#define REG_RAW_DATA_DUMP (0x29)
#define REG_SROM_ID (0x2A)
#define REG_MIN_SQ_RUN (0x2B)
#define REG_RAW_DATA_THRESHOLD (0x2C)

#define REG_CONFIG5 (0x2F)

#define REG_POWER_UP_RESET (0x3A)
#define REG_SHUTDOWN (0x3B)

#define REG_INVERSE_PRODUCT_ID (0x3F)

#define REG_LIFTCUTOFF_TUNE3 (0x41)
#define REG_ANGLE_SNAP (0x42)

#define REG_LIFTCUTOFF_TUNE1 (0x4A)

#define REG_MOTION_BURST (0x50)

#define REG_LIFTCUTOFF_TUNE_TIMEOUT (0x58)

#define REG_LIFTCUTOFF_TUNE_MIN_LENGTH (0x5A)

#define REG_SROM_LOAD_BURST (0x62)
#define REG_LIFT_CONFIG (0x63)
#define REG_RAW_DATA_BURST (0x64)
#define REG_LIFTOFF_TUNE2 (0x65)

#define CONFIG2_REST_ENABLED (0x30)
#define CONFIG2_REPORT_MODE (0x04)


#define BUTTONS_ON 0
#define BUTTONS_OFF 1

#define BUTTON_M1 2
#define BUTTON_M2 3
#define BUTTON_M3 4
#define BUTTON_M4 6
#define BUTTON_M5 7
#define BUTTON_DPI 5

#define ENCODER_A 8
#define ENCODER_B 10
#define ENCODER_COM 9

#define PIN_NCS 17
#define PIN_MOSI 19
#define PIN_MISO 16

SPISettings spisettings(2000000, MSBFIRST, SPI_MODE3);
MbedSPI spi(PIN_MISO, PIN_MOSI, 18);

void setup_buttons()
{
    pinMode(BUTTONS_OFF, INPUT);
    pinMode(BUTTONS_ON, INPUT);
    pinMode(BUTTON_M1, INPUT_PULLUP);
    pinMode(BUTTON_M2, INPUT_PULLUP);
    pinMode(BUTTON_M3, INPUT_PULLUP);
    pinMode(BUTTON_M4, INPUT_PULLUP);
    pinMode(BUTTON_M5, INPUT_PULLUP);
    pinMode(BUTTON_DPI, INPUT_PULLUP);
    
    pinMode(ENCODER_A, INPUT_PULLUP);
    pinMode(ENCODER_B, INPUT_PULLUP);
    pinMode(ENCODER_COM, OUTPUT);
    
    digitalWrite(ENCODER_COM, LOW);
}

bool mouse_inited;
void setup()
{
    Serial1.begin(1000000);
    
    delay(3000);
    
    // SCK, MISO, MOSI, SS
    SPI.begin();
    pinMode(PIN_NCS, OUTPUT);
    
    digitalWrite(PIN_NCS, HIGH);
    delayMicroseconds(1);
    digitalWrite(PIN_NCS, LOW);
    delayMicroseconds(1);
    digitalWrite(PIN_NCS, HIGH);
    delayMicroseconds(1);
    
    pmw3360_boot();
    
    delay(10);
    
    pmw3360_config();
    
    setup_buttons();
}

uint32_t pins_state = 0;
uint8_t buttons = 0;
uint8_t which_m3 = 0;
// 8ms latch time
uint8_t buttons_latch_max = 8;
uint8_t buttons_latch[5] = {0, 0, 0, 0, 0};

volatile uint32_t * pad_control = (uint32_t *)0x4001c000;
volatile uint32_t * gpio_oe_set = (uint32_t *)0xd0000024;
volatile uint32_t * gpio_oe_clr = (uint32_t *)0xd0000028;
volatile uint32_t * gpio_in = (uint32_t *)0xd0000004;

void update_buttons()
{
    /*
    // disable pullup/pulldown
    pad_control[BUTTONS_OFF + 1] &= 0xFFFFFFF2;
    pad_control[BUTTONS_ON + 1] &= 0xFFFFFFF2;
    */
    
    // change BUTTONS_OFF to high impedance and BUTTONS_ON to output
    // using pinMode for this is way, WAY too slow, like 50us per call (?!?!?!)
    *gpio_oe_clr = 1 << BUTTONS_OFF;
    *gpio_oe_set = 1 << BUTTONS_ON;
    
    // read ON pins
    digitalWrite(BUTTONS_ON, LOW);
    delayMicroseconds(1);
    uint32_t pins_on = ~*gpio_in;
    
    // change BUTTONS_OFF to high impedance and BUTTONS_ON to output
    *gpio_oe_set = 1 << BUTTONS_OFF;
    *gpio_oe_clr = 1 << BUTTONS_ON;
    
    // read OFF pins
    digitalWrite(BUTTONS_OFF, LOW);
    delayMicroseconds(1);
    uint32_t pins_off = ~*gpio_in;
    
    // update pin state
    // treat middle state (on-off matching) as no-update (use previous state)
    uint32_t pins_update = pins_on ^ pins_off;
    pins_state = (pins_state & (~pins_update)) | (pins_on & pins_update);
    
    // update button state
    uint8_t  [MASK]  =
          ((!!(pins_state & (1 << BUTTON_M1))))
        | ((!!(pins_state & (1 << BUTTON_M2))) << 1)
        | ((!!(pins_state & (1 << BUTTON_M3))) << 2)
        | ((!!(pins_state & (1 << BUTTON_DPI))) << 3)
        | ((!!(pins_state & (1 << BUTTON_M4))) << 4)
        | ((!!(pins_state & (1 << BUTTON_M5))) << 5);
    
    // handle latch
    uint8_t ok_mask = 
          ((buttons_latch[0] == 0))
        | ((buttons_latch[1] == 0) << 1)
        | ((buttons_latch[2] == 0) << 2)
        | ((buttons_latch[3] == 0) << 3)
        | ((buttons_latch[4] == 0) << 4)
        | ((buttons_latch[5] == 0) << 5);
    
    //printf(""%u, %u, %u, %u\n"", ~pins_on, ~pins_off, pins_state, ok_mask);
    
     [MASK]  = ( [MASK]  & ok_mask) | (buttons & ~ok_mask);
    
    // update latch timings
    for (int i = 0; i < 6; i++)
    {
        if ((( [MASK]  ^ buttons) >> i) & 1)
            buttons_latch[i] = buttons_latch_max;
        else if (buttons_latch[i])
            buttons_latch[i] -= 1;
    }
    
    if (( [MASK]  & (1 << 2)) != (buttons & (1 << 2)))
        which_m3 = 0;
    if (( [MASK]  & (1 << 3)) != (buttons & (1 << 3)))
        which_m3 = 1;
    
    buttons =  [MASK] ;
}

uint8_t wheel_state_a = 0;
uint8_t wheel_state_b = 0;
uint8_t wheel_state_output = 0;
int8_t wheel_progress = 0;

void update_wheel()
{
    uint8_t wheel_new_a = digitalRead(ENCODER_A);
    uint8_t wheel_new_b = digitalRead(ENCODER_B);
    
    if (wheel_new_a != wheel_state_a || wheel_new_b != wheel_state_b)
    {
        if (wheel_new_a == wheel_new_b && wheel_state_output != wheel_new_a)
        {
            // when scrolling up, B changes first. when scrolling down, A changes first
            if (wheel_new_b == wheel_state_b)
                wheel_progress += 1;
            // the wheel can glitch and jump straight from 00 to 11 (or vice versa)
            // so we need to check that only one state has changed since the last test
            else if(wheel_new_a == wheel_state_a)
                wheel_progress -= 1;
            
            wheel_state_output = wheel_new_a;
        }
        
        wheel_state_a = wheel_new_a;
        wheel_state_b = wheel_new_b;
    }
}

int n = 0;
int usb_hid_poll_interval = 1; 

struct MotionBurstData {
    uint8_t motion;
    uint8_t observation;
    int16_t x;
    int16_t y;
    uint8_t squal;
    uint8_t raw_sum;
    uint8_t raw_max;
    uint8_t raw_min;
    uint16_t shutter;
};

MotionBurstData spi_read_motion_burst(bool do_update_wheel);

int dpi = 12; // in hundreds; 1200 dpi
int lod = 2;

void check_config_inputs()
{
    if ((buttons & 1) &&
        (buttons & 2) &&
        (buttons & 8) &&
        (buttons & 16))
    {
        int olddpi = dpi;
        if (wheel_progress < 0)
            dpi += dpi <  16 ? 1 : dpi <  32 ? 2 : dpi <  64 ? 4 : 8;
        else if (wheel_progress > 0)
            dpi -= dpi <= 16 ? 1 : dpi <= 32 ? 2 : dpi <= 64 ? 4 : 8;
        if (dpi > 120)
            dpi = 120;
        else if (dpi < 1)
            dpi = 1;
        
        if (olddpi != dpi)
        {
            spi_write(REG_CONFIG1, dpi - 1);
            
            printf(""new DPI: %d\n"", dpi * 100);
        }
        
        wheel_progress = 0;
    }
}

void loop()
{
    // these execute nearly instantly
    // we want to call update_wheel roughly every 250ms to avoid skipping
    update_wheel();
    delayMicroseconds(250);
    update_wheel();
    
    int16_t x = 0;
    int16_t y = 0;
    
    // takes ~400us to execute; wheel is updated again around 250ms into the call
    MotionBurstData data = spi_read_motion_burst(true);
    if (mouse_inited && data.motion)
    {
        x = data.x;
        y = data.y;
    }
    
    update_wheel();
    //uint32_t a = micros();
    update_buttons();
    //uint32_t b = micros();
    //Serial.println(b - a);
    
    check_config_inputs();
    
    int8_t wheel = wheel_progress;
    wheel_progress = 0;
    
    //uint32_t a = micros();
    // this will return around 1ms after the last time it returned
    // which should be around 250us from now
    uint8_t new_buttons = buttons;
    if (which_m3)
        new_buttons = (new_buttons & 3) | ((new_buttons >> 1) & ~3);
    else
        new_buttons = (new_buttons & 7) | ((new_buttons >> 1) & ~7);
    mouse.update(x, y, new_buttons, wheel);
    //uint32_t b = micros();
    //Serial.println(b - a);
}

void pmw3360_boot()
{
    spi_write(REG_POWER_UP_RESET, 0x5A);
    delay(50);
    
    spi_read(0x02);
    spi_read(0x03);
    spi_read(0x04);
    spi_read(0x05);
    spi_read(0x06);
    
    srom_upload();
}

void pmw3360_config()
{
    spi_write(REG_CONFIG1, dpi - 1);
}

void spi_begin()
{
    SPI.beginTransaction(spisettings);
}
void spi_end()
{
    SPI.endTransaction();
}

void spi_write(byte addr, byte data)
{
    spi_begin();
    
    digitalWrite(PIN_NCS, LOW);
    delayMicroseconds(1); // 120 nanoseconds; t_NCS-SCLK
    
    SPI.transfer(addr | 0x80);
    SPI.transfer(data);
    
    delayMicroseconds(35); // t_SCLK-NCS(write)
    digitalWrite(PIN_NCS, HIGH);
    
    spi_end();
    
    delayMicroseconds(180); // max(t_SWW, t_SWR)
}

byte spi_read(byte addr)
{
    spi_begin();
    
    digitalWrite(PIN_NCS, LOW);
    delayMicroseconds(1); // 120 nanoseconds; t_NCS-SCLK
    
    SPI.transfer(addr & 0x7F);
    
    delayMicroseconds(160); // t_SRAD
    
    byte ret = SPI.transfer(0);
    
    delayMicroseconds(1); // 120 nanoseconds; t_SCLK-NCS(read)
    digitalWrite(PIN_NCS, HIGH);
    
    spi_end();
    
    delayMicroseconds(20); // max(t_SRW, t_SRR)
    
    return ret;
}

MotionBurstData spi_read_motion_burst(bool do_update_wheel)
{
    MotionBurstData ret = {0};
    
    // this takes around 260us to execute; update scroll wheel again after calling it
    spi_write(REG_MOTION_BURST, 0x00);
    if (do_update_wheel)
        update_wheel();
    
    spi_begin();
    
    digitalWrite(PIN_NCS, LOW);
    delayMicroseconds(1); // 120 nanoseconds; t_NCS-SCLK
    
    SPI.transfer(REG_MOTION_BURST);
    
    delayMicroseconds(35); // t_SRAD_MOTBR
    
    ret.motion = SPI.transfer(0);
    ret.observation = SPI.transfer(0);
    ret.x = SPI.transfer(0);
    ret.x |= ((uint16_t)SPI.transfer(0)) << 8;
    ret.y = SPI.transfer(0);
    ret.y |= ((uint16_t)SPI.transfer(0)) << 8;
    ret.squal = SPI.transfer(0);
    // don't care about the rest; terminate
    digitalWrite(PIN_NCS, HIGH);
    delayMicroseconds(1); // t_BEXIT = 500ns; wait 1000ns (1us)
    
    /*
    ret.raw_sum = SPI.transfer(0);
    ret.raw_max = SPI.transfer(0);
    ret.raw_min = SPI.transfer(0);
    ret.shutter = SPI.transfer(0);
    ret.shutter |= ((uint16_t)SPI.transfer(0)) << 8;
    */
    
    spi_end();
    
    return ret;
}

void srom_upload()
{
    spi_write(REG_CONFIG2, 0x00);
    spi_write(REG_SROM_ENABLE, 0x1D);
    delay(10);
    
    spi_write(REG_SROM_ENABLE, 0x18);
    
    spi_begin();
    
    digitalWrite(PIN_NCS, LOW);
    delayMicroseconds(1);
    
    SPI.transfer(REG_SROM_LOAD_BURST | 0x80);
    delayMicroseconds(15);
    
    for(size_t i = 0; i < SROM_LENGTH; i += 1)
    {
        SPI.transfer(srom[i]);
        delayMicroseconds(15);
    }
    
    digitalWrite(PIN_NCS, HIGH);
    delayMicroseconds(1);
    
    spi_end();
    
    delayMicroseconds(200);
    
    byte id = spi_read(REG_SROM_ID);
    mouse_inited = (id != 0xFF);
    printf(""\n"");
    printf(""srom id: "");
    printf(""%d"", id);
    printf(""\n"");
    
    spi_write(REG_CONFIG2, 0x00);
}
",next_buttons
24,"#include ""Application.h""
#include ""Config.h""

Application::Application()
		: m_Window(Window::Get()), m_FrameRate(0.0), m_AverageFrameTime(0.0), m_FrameCount(0), m_LastUpdate(0.0)
{
	m_Window.Init(1366, 768, ""glBlocks"");

	m_Camera = Camera({0.0f, 0.0f, 2.0f});
	m_Camera.OnResize(1366, 768);

	m_Renderer = new Renderer();
	m_Dashboard = new Dashboard(&m_Camera);
	m_World = new World();
}

Application::~Application()
{
	delete m_Renderer;
	delete m_Dashboard;
	delete m_World;
}

void Application::Run()
{
	Shader basicShader(VERTEX_SHADER, FRAGMENT_SHADER);
	basicShader.CreateShaderProgram();

	Shader lightSourceShader(LIGHT_VERTEX_SHADER, LIGHT_FRAGMENT_SHADER);
	lightSourceShader.CreateShaderProgram();

	m_Renderer->LoadShader(basicShader, ShaderType::BASIC_SHADER);
	m_Renderer->LoadShader(lightSourceShader, ShaderType::LIGHTSOURCE_SHADER);

	std::string texturePath = TEXTURE_PATH;
	texturePath += ""texture_atlas.png"";
	Texture atlas(GL_TEXTURE_2D, texturePath);
	atlas.Load();
	atlas.Bind(GL_TEXTURE0);
	basicShader.Bind();
	basicShader.SetInt(""uAtlasSize"", 4);

	m_World->GetGenerator().SetCamera(m_Camera);
	m_World->GetGenerator().Init();

	m_Camera.SetPosition(0.0f, 70.0f, 0.0f);
	m_Camera.SendShader(basicShader);
	m_Camera.SendShader(lightSourceShader);

	auto  [MASK]  = std::bind(&Camera::OnResize, m_Camera, std::placeholders::_1, std::placeholders::_2);
	m_Window.AddResizeCallback( [MASK] );

	m_Timer.Start();

	while (!m_Window.ShouldClose())
	{
		m_Camera.OnUpdate(m_Timer.GetDelta());

		m_World->StepTime(m_Timer);
		m_World->GetGenerator().LoadChunks();
		m_World->GetGenerator().PrepareChunks(m_Timer.GetDelta());
		m_Renderer->Draw(*m_World, m_Camera);
		m_World->GetGenerator().SynchronizeChunks();

		m_Dashboard->GetData(m_FrameRate, m_AverageFrameTime);
		m_Dashboard->Render();

		m_Timer.RecordLapse();
		CalcPerf();
		m_Window.PollAndSwapBuffers();
	}

	VertexArrayManager::Cleanup();
	TerrainGenerator::Cleanup();
	Dashboard::Cleanup();
	Window::Cleanup();
	LOG_INFO(""Ending..."");
}

void Application::CalcPerf()
{
	m_FrameCount++;
	m_LastUpdate += m_Timer.GetDelta();

	if (m_LastUpdate >= 1.0)
	{
		m_FrameRate = (double)m_FrameCount * 0.5 + m_FrameRate * 0.5;
		m_FrameCount = 0;
		m_AverageFrameTime = 1000.0 / (m_FrameRate == 0.0 ? 0.001 : m_FrameRate);
		m_LastUpdate = 0.0;
	}
}
",resizeCallback
25,"#include<iostream>
#include<conio.h>
#include<dos.h>
#include<stdlib.h>
#include<string.h>
#include <windows.h>
#include <time.h>

using namespace std;

char l[] = ""บบบบบ"";
int i;

HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
COORD CursorPosition;

void gotoxy(int x, int y) {
  CursorPosition.X = x;
  CursorPosition.Y = y;
  SetConsoleCursorPosition(console, CursorPosition);
}

void setcursor(bool visible, DWORD size) // set bool visible = 0 - invisible, bool visible = 1 - visible
{
  if (size == 0) {
    size = 20; // default cursor size Changing to numbers from 1 to 20, decreases cursor width
  }
  CONSOLE_CURSOR_INFO lpCursor;
  lpCursor.bVisible = visible;
  lpCursor.dwSize = size;
  SetConsoleCursorInfo(console, & lpCursor);
}

void printBorder() {
  for (i = 2; i <= 79; i++) {
    gotoxy(i, 1);
    cout << '-';
    gotoxy(i, 25);
    cout << '-';
  }
  for (i = 1; i <= 25; i++) {
    gotoxy(2, i);
    cout << '|';
    gotoxy(79, i);
    cout << '|';
  }
}
void setplayers() {
  system(""cls"");
  printBorder();
  gotoxy(4, 3);
  cout << ""SCORE : 0"";
  gotoxy(50, 3);
  cout << ""Press Esc key to quit game"";
  for (i = 3; i <= 78; i++) {
    gotoxy(i, 4);
    cout << '-';
  }
  for (i = 0; i <= strlen(l); i++) {
    gotoxy(5, 5 + i);
    cout << l[i];
  }
  for (i = 0; i <= strlen(l); i++) {
    gotoxy(76, 5 + i);
    cout << l[i];
  }
}
void gameplay() {
  setplayers();
  void displayMenu();
  int sc = 0, pp = 0, st = 1;
  int c = 5, k = 5, x = 73, y = 6 + rand() % 15;
  int d = rand() % 2, px, py;
  int op = 1, go = 1;
  int  [MASK]  = 0, rlu = 0, lru = 0, lrd = 0;

  while (1) {
    if (go == 1) {
      while (!kbhit() && op) {
        px = x;
        py = y;
        gotoxy(x, y);
        cout << ""O"";
        Sleep(50);
        gotoxy(x, y);
        cout << "" "";

        if (st == 1) {
          st = 0;
          if (d == 0) {
            x--;
            y++;
          } else {
            x--;
            y--;
          }
        }

        if ( [MASK] ) {
          x--;
          y++;
        }
        if (rlu) {
          x--;
          y--;
        }
        if (lru) {
          x++;
          y--;
        }
        if (lrd) {
          x++;
          y++;
        }

        if (x < px && y > py)  [MASK]  = 1;
        if (x < px && y < py) rlu = 1;
        if (y == 5 && rlu) {
           [MASK]  = 1;
          rlu = 0;
        }
        if (y == 24 &&  [MASK] ) {
          rlu = 1;
           [MASK]  = 0;
        }
        if (x == 6 && rlu) {
          lru = 1;
          rlu = 0;
        }
        if (x == 6 &&  [MASK] ) {
          lrd = 1;
           [MASK]  = 0;
        }
        if (y == 5 && lru) {
          lrd = 1;
          lru = 0;
        }
        if (y == 24 && lrd) {
          lru = 1;
          lrd = 0;
        }
        if (x == 75 && lrd) {
           [MASK]  = 1;
          lrd = 0;
        }
        if (x == 75 && lru) {
          rlu = 1;
          lru = 0;
        }

        if (x == 75 || x == 6) {
          Sleep(50);
        }
        if (y == 5 || y == 24) {
          Sleep(50);
        }

        if (lru || lrd) {
          if (y >= 6 && y <= 22) {
            if (y > k + strlen(l) - 3) {
              gotoxy(76, k + strlen(l));
              cout << ""บ"";
              gotoxy(76, k);
              if (k != 4) cout << ' ';
              k++;
            }
            if (y < k + strlen(l) - 3) {
              gotoxy(76, k);
              cout << ""บ"";
              gotoxy(76, k + strlen(l));
              if (k + strlen(l) != 25) cout << ' ';
              k--;
            }
          }
        }

        if (x == 6 && (y < c || y > c + strlen(l) - 1)) {
          gotoxy(x, y);
          cout << ""YOU LOSE ! Press 'r' or ENTER to play again !"";
          op = 0;
          break;
        }

        if (x == 6 && op == 1) {
          gotoxy(4, 3);
          cout << ""SCORE : "" << ++sc;
        }

      }
    }

    char ch = getch();

    if (ch == ' ' && op == 1) {
      pp = 1;
      go = 0;
      gotoxy(22, 12);
      cout << ""GAME PAUSED ! PRESS ENTER to continue !"";
    }
    if (ch == 13 && pp && op == 1) {
      pp = 0;
      go = 1;
      gotoxy(22, 12);
      cout << ""                                       "";
    }
    if ((ch == 'r' || ch == 'R' || ch == 13) && op == 0) {
      op = 1;
      gameplay();
      break;
    }
    if ((ch == 's' || ch == 'S' || ch == 80) && c <= 19 && op) {
      gotoxy(5, c + strlen(l));
      cout << ""บ"";
      gotoxy(5, c);
      cout << ' ';
      c++;
    }
    if ((ch == 'w' || ch == 'W' || ch == 72) && c >= 6 && op) {
      gotoxy(5, c - 1);
      cout << ""บ"";
      gotoxy(5, c + 4);
      cout << ' ';
      c--;
    }
    if (ch == 27) {
      displayMenu();
      break;
    }
  }
}

void displayMenu() {
  system(""cls"");
  void htpwindow();
  //	printBorder();
  int cp = 1;
  gotoxy(34, 4);
  cout << ""PING PONG"";
  for (i = 8; i <= 73; i++) {
    gotoxy(i, 6);
    cout << '-';
  }
  gotoxy(34, 10);
  cout << ""1. PLAY THE GAME"";
  gotoxy(34, 12);
  cout << ""2. HOW TO PLAY"";
  gotoxy(34, 14);
  cout << ""3. EXIT"";
  gotoxy(14, 16);
  cout << ""Enter Option from Menu: "";

  char op = getche();
  if (op == '1') gameplay();
  if (op == '2') htpwindow();
  if (op == '3') exit(0);

}
void htpwindow() {
  system(""cls"");
  printBorder();
  gotoxy(4, 3);
  cout << ""INSTRUCTIONS"";
  gotoxy(4, 4);
  cout << ""-------------"";
  gotoxy(4, 5);
  cout << ""- Press w or Up Arrow to move up."";
  gotoxy(4, 7);
  cout << ""- Press s or Down Arrow to move down."";
  gotoxy(4, 9);
  cout << ""- Press Spacebar to pause the game."";
  gotoxy(4, 11);
  cout << ""- Press Esc to quit the game."";
  gotoxy(4, 15);
  cout << ""Press any key to go to menu ..."";
  getch();
  displayMenu();
}
int main() {
  setcursor(0, 0);
  srand((unsigned) time(NULL));
  system(""cls"");
  //	printBorder();

  displayMenu();

  return 0;
}
",rld
26,"// Copyright 2023 Ar-Ray-code.
//
// 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 <rclcpp/rclcpp.hpp>
#include <feetech_scs_interface/feetech_scs_interface.hpp>

int SCS2host(const u_char data_l, const u_char  [MASK] )
{
  bool END = 0; // SCS
  if (END) {
    return (data_l << 8) +  [MASK] ;
  } else {
    return ( [MASK]  << 8) + data_l;
  }
}

void read(u_char * write_buf, u_int write_buf_size)
{
  auto port_handler_ = std::make_shared<h6x_serial_interface::PortHandler>(""/dev/ttyUSB0"");
  auto packet_handler = std::make_shared<feetech_scs_interface::PacketHandler>(port_handler_);

  port_handler_->configure(1000000);
  if (!port_handler_->open()) {
    return;
  }

  std::string sent = """";
  for (size_t i = 0; i < write_buf_size; i++) {
    sent += std::to_string(write_buf[i]) + "" "";
  }

  std::cout << ""Write["" << write_buf_size << ""]: "" << sent << std::endl;

  const ssize_t write_ret = port_handler_->write(
    reinterpret_cast<char *>(write_buf), write_buf_size);
  if (write_ret == -1) {
    return;
  }

  using namespace std::chrono_literals;  // NOLINT
  const auto clock_ = std::make_shared<rclcpp::Clock>(RCL_SYSTEM_TIME);
  const auto started = clock_->now();
  // while (port_handler_->getBytesAvailable() == 0) {
  //   if (clock_->now() - started > 1s) {
  //     std::cout << ""timeout"" << std::endl;
  //     return;
  //   }
  // }

  char read_buf[128];
  const ssize_t read_ret = port_handler_->read(read_buf, sizeof(read_buf));
  if (read_ret == -1) {
    return;
  }
  std::string recv = """";
  for (long int i = 0; i < read_ret; i++) {
    recv += std::to_string(read_buf[i]) + "" "";
  }
  std::cout << ""Read["" << read_ret << ""]: "" << recv << std::endl;

  auto data = SCS2host(read_buf[5], read_buf[6]);
  std::cout << ""Angle: "" << data << std::endl;

  port_handler_->close();
}

u_char gen_checksum(u_char * write_buf, u_int write_buf_size)
{
  u_char checksum = 0;
  for (size_t i = 2; i < write_buf_size - 1; i++) {
    checksum += write_buf[i];
  }
  return ~checksum;
}


int main()
{
  // u_char write_buf[8] = {0xFF, 0xFF, 0x01, 0x04, 0x02, 0x38, 0x02, 0x00};
  u_char write_buf[8] = {0xFF, 0xFF, 0x01, 0x04, 0x02, 0x38, 0x02, 0x00};
  write_buf[7] = gen_checksum(write_buf, sizeof(write_buf));

  read(write_buf, sizeof(write_buf));

  return EXIT_SUCCESS;
}
",data_h
27,"#include ""stdafx.h""
#include <iostream>
#include ""Game.h""
#include ""../glew-2.1.0/include/GL/glew.h""
#include <GLFW/glfw3.h>

bool Game::leftPressed;
bool Game::upPressed;
bool Game::rightPressed;
bool Game::downPressed;
bool Game::spacePressed;
float Game::xDelta;
float Game::yDelta;

void OnKeyboard(GLFWwindow* window, int key, int scancode, int action, int mods)
{
	if (key == GLFW_KEY_A)
		Game::leftPressed = action != GLFW_RELEASE;
	if (key == GLFW_KEY_W)
		Game::upPressed = action != GLFW_RELEASE;
	if (key == GLFW_KEY_D || key == GLFW_KEY_E)
		Game::rightPressed = action != GLFW_RELEASE;
	if (key == GLFW_KEY_S || key == GLFW_KEY_O)
		Game::downPressed = action != GLFW_RELEASE;
	if (key == GLFW_KEY_SPACE)
		Game::spacePressed = action != GLFW_RELEASE;

	if (key == GLFW_KEY_ESCAPE)
		glfwSetWindowShouldClose(window, true);
}

float oldPosX, oldPosY;
void OnMouse(GLFWwindow* window, double posX, double  [MASK] )
{
	Game::xDelta = oldPosX - posX;
	Game::yDelta = oldPosY -  [MASK] ;
	oldPosX = posX;
	oldPosY =  [MASK] ;
}

Game::Game(const char* title)
{
	if (!glfwInit()){
    printf(""GLFW init failed\n"");
    exit(1);
	}
	window = glfwCreateWindow(1280, 720, title, NULL, NULL);
	if (window == NULL) {
    printf(""GLFW window creation failed\n"");
    exit(1);
	}
	auto glfwWindow = (GLFWwindow*)window;
	glfwMakeContextCurrent(glfwWindow);
	glfwSetInputMode(glfwWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
	glfwSetKeyCallback(glfwWindow, OnKeyboard);
	glfwSetCursorPosCallback(glfwWindow, OnMouse);
	glfwGetWindowSize(glfwWindow, &viewportWidth, &viewportHeight);
	glEnable(GL_DEPTH_TEST);

  GLenum err = glewInit();
  if (err != GLEW_OK) {
		std::cout << ""GLEW init failed "" << glewGetErrorString(err) << ""\n"";
		exit(1);
  }
}

Game::~Game() 
{
	glfwTerminate();
}

void Game::Run(std::function<void()> renderFunction)
{
	auto glwWindow = (GLFWwindow*)window;
	while (!glfwWindowShouldClose(glwWindow))
	{
		glfwGetWindowSize(glwWindow, &viewportWidth, &viewportHeight);
		glViewport(0, 0, viewportWidth, viewportHeight);
		glClearColor(0, 0, 0, 1);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		time = glfwGetTime();
		timeThisTick = time - lastTime;
		lastTime = time;
		renderFunction();
		glfwSwapBuffers(glwWindow);
		glfwPollEvents();
	}
}

void Game::RunTriangle()
{
	Run([=]()
	{
		glBegin(GL_TRIANGLES);
		glColor3f(1.f, 0.f, 0.f);
		glVertex3f(-0.6f, -0.4f, 0.f);
		glColor3f(0.f, 1.f, 0.f);
		glVertex3f(0.6f, -0.4f, 0.f);
		glColor3f(0.f, 0.f, 1.f);
		glVertex3f(0.f, 0.6f, 0.f);
		glEnd();
	});
}",posY
28,"#include <bits/stdc++.h>

int main() {
  int H, W, K;
  std::cin >> H >> W >> K;
  std::vector<std::vector<char>> c(H, std::vector<char>(W));
  for (int i = 0; i < H; i++)
    for (int j = 0; j < W; j++)
      std::cin >> c[i][j];
  auto print = [&](auto const &v) {
    for (int i = 0; i < H; i++) {
      for (int j = 0; j < W; j++)
        std::cout << v[i][j] << "", "";
      std::cout << std::endl;
    }
  };

  // print(c);

  int  [MASK]  = 0;

  // bit search
  for (int i = 0; i < (1 << H); i++) {
    for (int j = 0; j < (1 << W); j++) {
      int blacks = 0;
      for (int row = 0; row < H; row++) {
        for (int col = 0; col < W; col++) {
          bool white = c.at(row).at(col) == '.';
          bool red = ((1 << row) & i) || ((1 << col) & j);
          if (red || white)
            continue;
          blacks++;
        }
      }

      if (blacks == K)
         [MASK] ++;
    }
  }
  std::cout <<  [MASK]  << std::endl;
}
",ans
29,"// client.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include ""pch.h""
#include <iostream>

#include <cpprest/http_client.h>
#include <cpprest/json.h>
//#pragma comment(lib, ""cpprest_2_10"")

using namespace web;
using namespace web::http;
using namespace web::http::client;

#include <iostream>
using namespace std;

void display_json(
	json::value const & jvalue,
	utility::string_t const & prefix)
{
	wcout << prefix << jvalue.serialize() << endl;
}

pplx::task<http_response> make_task_request(
	http_client & client,
	method mtd,
	utility::string_t const & task,
	json::value const & jvalue)
{
	return (mtd == methods::GET || mtd == methods::HEAD) ?
		client.request(mtd, task) :
		client.request(mtd, task, jvalue);
}

void make_request(
	http_client & client,
	method mtd,
	utility::string_t const & task,
	json::value const & jvalue)
{
	make_task_request(client, mtd, task, jvalue)
		.then([](http_response response)
	{
		if (response.status_code() == status_codes::OK)
		{
			wcout << ""OK "";
			return response.extract_json();
		}
		wcout << ""FAIL "";
		return pplx::task_from_result(json::value());
	})
		.then([](pplx::task<json::value> previousTask)
	{
		try
		{
			display_json(previousTask.get(), L""R: "");
		}
		catch (http_exception const & e)
		{
			wcout << e.what() << endl;
		}
	})
		.wait();
}

int main()
{
	std::cout << ""Hello World! \nThis is client."";

	http_client client(U(""http://localhost:5000/v1/tx40""));
	utility::string_t task = L""state"";

	//* Get some specific parameters
	//auto getvalue = json::value::array();
	//getvalue[0] = json::value::string(L""one"");
	//getvalue[1] = json::value::string(L""two"");
	//getvalue[2] = json::value::string(L""three"");

	//wcout << L""\nPOST (get some values)\n"";
	//display_json(getvalue, L""S: "");
	//make_request(client, methods::POST, task, getvalue);

	////* Delete a specific parameter
	//auto delvalue = json::value::array();
	//delvalue[0] = json::value::string(L""one"");

	//wcout << L""\nDELETE (delete values)\n"";
	//display_json(delvalue, L""S: "");
	//make_request(client, methods::DEL, task, delvalue);

	//wcout << L""\nPOST (get some values)\n"";
	//display_json(getvalue, L""S: "");
	//make_request(client, methods::POST, task, getvalue);

	//* Get robot state
	auto nullvalue = json::value::null();

	wcout << L""\nGET (get state)\n"";
	display_json(nullvalue, L""S: "");
	make_request(client, methods::GET, L""state"", nullvalue);

	//* Put robot state
	auto putstate = json::value::boolean(true); // create parameters for request

	wcout << L""\nPUT (change state)\n"";
	display_json(putstate, L""S: ""); // display request
	make_request(client, methods::PUT, L""state"", putstate); // send request to server

	//* Get robot state
	wcout << L""\nGET (get state)\n"";
	display_json(nullvalue, L""S: "");
	make_request(client, methods::GET, L""state"", nullvalue);

	//* Get robot position
	wcout << L""\nGET (get position)\n"";
	display_json(nullvalue, L""S: "");
	make_request(client, methods::GET, L""position"", nullvalue);

	//* Put robot position
	auto  [MASK]  = json::value::object(); // create parameters for request
	 [MASK] [L""x""] = 100;
	 [MASK] [L""y""] = 200;
	 [MASK] [L""z""] = 300;
	 [MASK] [L""rx""] = 20;
	 [MASK] [L""ry""] = 30;
	 [MASK] [L""rz""] = 40;
	 [MASK] [L""linhtinh""] = 50;

	wcout << L""\nPUT (add values)\n"";
	display_json( [MASK] , L""S: ""); // display request
	make_request(client, methods::PUT, L""position"",  [MASK] ); // send request to server

	//* Get robot position
	wcout << L""\nGET (get position)\n"";
	display_json(nullvalue, L""S: "");
	make_request(client, methods::GET, L""position"", nullvalue);

	return 0;
}

// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
// Debug program: F5 or Debug > Start Debugging menu

// Tips for Getting Started: 
//   1. Use the Solution Explorer window to add/manage files
//   2. Use the Team Explorer window to connect to source control
//   3. Use the Output window to see build output and other messages
//   4. Use the Error List window to view errors
//   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
//   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
",putvalue
30,"#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include ""time.h""


const char* ssid = """";
const char* wifi_password = """";

const char* mqtt_server = """";
const char* mqtt_pwd = """";
const char* mqtt_usr = """";
const char* mqtt_topic = """";
const char* mqtt_control_topic = """";



// NTP Servers:
const char* ntpServer = ""pool.ntp.org"";  // Principal NTP server
const char* ntpBackup1 = ""time.google.com""; // Secondary NTP server
const char* ntpBackup2 = ""time.nist.gov"";  // Secondary NTP server
const long  gmtOffset_sec = 0; // Timezone offset in seconds
const int   daylightOffset_sec = 0; // Daylight offset in seconds
 
IPAddress dns(8,8,8,8);

const int PIR_SENSOR_OUTPUT_PIN = 21;  /* PIR sensor O/P pin */
int warm_up;


WiFiClient espClient;
PubSubClient client(espClient);


void setup() {
  Serial.begin(115200); /* Define baud rate for serial communication */

  Serial.println(""Setting up wifi"");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, wifi_password);

  Serial.println(""Connecting"");

  while(WiFi.status() != WL_CONNECTED){
    Serial.print(""."");
    delay(100);
  }

  Serial.println();
  Serial.println(""Connected to WiFi network"");
  Serial.print(""Local ESP32 IP: "");
  Serial.println(WiFi.localIP());

  delay(2000);


  Serial.println(""Configure hour"");
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  delay(5000);
  Serial.println(printLocalTime());

  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
      Serial.println(""Can't get the time"");
  }

  Serial.print(""Actual hour: "");
  Serial.printf(""%02d:%02d:%02d\n"", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
  delay(1000);

  Serial.println(""Setting up MQTT"");
  client.setServer(mqtt_server, 1883);
  reconnect();
  String  [MASK]  = ""Connected to broker"";
  client.publish(mqtt_control_topic,  [MASK] .c_str());
  delay(2000);
  
  // Pin initialization for sensor reading
  Serial.println(""Setting up sensor settings"");
  pinMode(PIR_SENSOR_OUTPUT_PIN, INPUT);
  Serial.println(""Waiting For Power On Warm Up"");
  delay(5000); /* Power On Warm Up Delay */

}

String printLocalTime(){
  struct tm timeinfo;
  if(!getLocalTime(&timeinfo)){
    Serial.println(""Failed to obtain time"");
    return """";
  }

  char buffer[80];
  strftime(buffer, 80, ""%Y-%m-%dT%H:%M:%S.000000Z"", &timeinfo);
  return buffer;
}

void reconnect() {
    // Retry connection
    while (!client.connected()) {
        Serial.print(""Connecting to MQTT..."");
        if (client.connect(""ESP32Client"", mqtt_usr, mqtt_pwd)) {
            Serial.println(""Connected."");
        } else {
            Serial.print(""Error, rc="");
            Serial.print(client.state());
            Serial.println("" Retrying in 5 seconds..."");
            delay(5000);
        }
    }
}


void loop() {
  if (!client.connected()) {
      reconnect();
  }

  StaticJsonDocument<200> doc;
  doc[""sensorName""] = ""pir"";
  doc[""startTime""] = printLocalTime();


  int sensor_output;
  sensor_output = digitalRead(PIR_SENSOR_OUTPUT_PIN);
  if( sensor_output == LOW ){  
    Serial.print(""No object in sight\n\n"");
    doc[""detected""] = 0;
  }else{
    Serial.print(""Object detected\n\n"");
    doc[""detected""] = 1;
  } 

  char jsonBuffer[256];
  serializeJson(doc, jsonBuffer);

  client.publish(mqtt_topic, jsonBuffer);
  delay(1000);
}",message
31,"
#include <Adafruit_NeoPixel.h>

#define PIN 6 // output to Neopixel 
#define NUM_LEDS 230 // 60 leds Per meter, so 60*4 Leds

/* Chase1 Relative Setting */
#define CHASE1COLOR 0x0000FF // R,G,B

#define CHASE1BRIGHTNESS 128 // Brightness(255:MAX, 0:MIN)

#define CHASE1START 0 // the total length from the start point to the end one. 

#define CHASE1END 120 // the total length from the start point to the end one. 

#define CHASE1LENGTH 6 // length of every segment of chase 1

#define CHASE1GAP 2 // the gap between two adjacent segments for chase 1

#define CHASE1RATE 200 // Chase1 Slide Rate time : 500ms


/* Chase2 Relative Setting */
#define CHASE2COLOR 0xFF0000 // R,G,B

#define CHASE2BRIGHTNESS 255 // Brightness(255:MAX, 0:MIN)

#define CHASE2START 125 // Start Pixel Point

#define CHASE2END 229 // End Pixel Point. 

#define CHASE2LENGTH 2 // length of every segment of chase 2

#define CHASE2GAP 2 // the gap between two adjacent segments for chase 2

#define CHASE2RATE 400 // Chase2 Slide  Rate time : 500ms

// Chase Flow rate
#define CHASERATE 500 // Rate time : 500ms

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

unsigned short TotalStrip[NUM_LEDS]; // Pixel Buffer

#define GAP     0
#define CHASE1  1
#define CHASE2  2

/*
 *  It builds Strip buffer as your chase requirements
*/
void InitBuildStrip()
{
    unsigned short nChase1Seg = (CHASE1END - CHASE1START) + 1;
    unsigned short nChase2Seg = (CHASE2END - CHASE2START) + 1;

    unsigned short nBlankCnt = (CHASE2START - CHASE1END) - 1;

    uint8_t Chase1Cnt = nChase1Seg / (CHASE1LENGTH + CHASE1GAP);
    uint8_t  [MASK]  = nChase1Seg % (CHASE1LENGTH + CHASE1GAP);

    uint8_t Chase2Cnt = nChase2Seg / (CHASE2LENGTH + CHASE2GAP);
    uint8_t Chase2Rem = nChase2Seg % (CHASE2LENGTH + CHASE2GAP);

    uint8_t i, j, k, l;
    uint8_t nSeek = 0;
    if(CHASE1START > 0)
    {
        for(i = 0; i < (CHASE1START - 1); i++)
            TotalStrip[nSeek + k] = GAP;    
    }

    nSeek = CHASE1START;
    for(j = 0; j < Chase1Cnt; j++)
    {
        for(k = 0; k < CHASE1GAP; k++)
            TotalStrip[nSeek + k] = GAP;    
        for(k = 0; k < CHASE1LENGTH; k++)
            TotalStrip[(nSeek + CHASE1GAP) + k] = CHASE1;    
        nSeek += (CHASE1LENGTH + CHASE1GAP);
    }

    if( [MASK]  > 0)
    {
        if( [MASK]  < CHASE1GAP)
            for(k = 0; k <  [MASK] ; k++)
                TotalStrip[nSeek + k] = GAP;
        else
        {
            for(k = 0; k < CHASE1GAP; k++)
                TotalStrip[nSeek + k] = GAP;
            for( ; k <  [MASK] ; k++)
                TotalStrip[nSeek + k] = CHASE1;
        }
    }

    nSeek = CHASE1END + 1;
    for(i = 0; i < nBlankCnt; i++)
        TotalStrip[nSeek + i] = GAP;    

    nSeek = CHASE2START;
    // Chase2 Segment
    for(j = 0; j < Chase2Cnt; j++)
    {
        for(k = 0; k < CHASE2GAP; k++)
            TotalStrip[nSeek + k] = GAP;    
        for(k = 0; k < CHASE2LENGTH; k++)
            TotalStrip[(nSeek + CHASE2GAP) + k] = CHASE2;    
        nSeek += (CHASE2LENGTH + CHASE2GAP);
    }

    if(Chase2Rem > 0)
    {
        if(Chase2Rem < CHASE2GAP)
            for(k = 0; k < Chase2Rem; k++)
                TotalStrip[nSeek + k] = GAP;
        else
        {
            for(k = 0; k < CHASE2GAP; k++)
                TotalStrip[nSeek + k] = GAP;
            for( ; k < Chase2Rem; k++)
                TotalStrip[nSeek + k] = CHASE2;
        }
    }

    nSeek = CHASE2END + 1;
    if(CHASE2END < NUM_LEDS - 1)
    {
        for(i = (CHASE2END + 1); i < NUM_LEDS; i++)
            TotalStrip[i] = GAP;
        
    }
}

/*
 * 
*/
void SlideChase1(uint8_t nDist)
{
    uint8_t temp = TotalStrip[CHASE1END];
    uint8_t idx;
    for(idx = CHASE1END; idx > CHASE1START; idx--)
        TotalStrip[idx] = TotalStrip[idx - 1];    
    TotalStrip[idx] = temp;
}

void SlideChase2(uint8_t nDist)
{
    uint8_t temp = TotalStrip[CHASE2END];
    uint8_t idx;
    for(idx = CHASE2END; idx > CHASE2START; idx--)
        TotalStrip[idx] = TotalStrip[idx - 1];    
    TotalStrip[idx] = temp;
}

/*
 * 
*/
void DrawStrip()
{
    unsigned short idx = 0;
    uint32_t color;
    for(idx = 0; idx < NUM_LEDS; idx++)
    {
        switch(TotalStrip[idx])
        {
            case GAP:
            {
                color = strip.Color(0x00, 0x00, 0x00);    // BLACK color
            }
            break;

            case CHASE1:
            {
                color = strip.Color(((CHASE1COLOR >> 16) * CHASE1BRIGHTNESS) >> 8, 
                    (((CHASE1COLOR >> 8) & 0xFF) * CHASE1BRIGHTNESS) >> 8, ((CHASE1COLOR & 0xFF) * CHASE1BRIGHTNESS) >> 8);   
            }
            break;

            case CHASE2:
            {
                color = strip.Color(((CHASE2COLOR >> 16) * CHASE2BRIGHTNESS) >> 8, 
                    (((CHASE2COLOR >> 8) & 0xFF) * CHASE2BRIGHTNESS) >> 8, ((CHASE2COLOR & 0xFF) * CHASE2BRIGHTNESS) >> 8);   
            }
            break;
        }
        strip.setPixelColor(idx, color);
    }
}

void setup() 
{
    Serial.begin(19200);
    Serial.println(F(""Program Started!""));
    delay(1000);
    InitBuildStrip();
    
    strip.setBrightness(255);
    strip.begin();
    strip.show(); // Initialize all pixels to 'off'
    
    //
    Serial.println(F(""Init End!""));
    DrawStrip();
    strip.show(); // Initialize all pixels to 'off'
}

static uint32_t nSlide1Time = millis();
static uint32_t nSlide2Time = millis();
static uint32_t nScanTime = millis();

void loop() 
{

    if(nSlide1Time + CHASE1RATE < millis())
    {
        nSlide1Time = millis();
        SlideChase1(1);                    
    }

    if(nSlide2Time + CHASE2RATE < millis())
    {
        nSlide2Time = millis();
        SlideChase2(1);                    
    }

    if(nScanTime + 20 < millis())
    {
        nScanTime = millis();
        DrawStrip();
        strip.show();
    }
}
",Chase1Rem
32,"#include ""operators/G2BMM.h""

namespace infini {

G2BMMObj::G2BMMObj(GraphObj *graph, Tensor A, Tensor B, Tensor C, int width,
                   int dilation, [[maybe_unused]] Tensor bias, ActType act)
    : OperatorObj(OpType::G2BMM, {A, B}, {C}), width(width), dilation(dilation),
      act(act), b(A->getDims()[0]), m(A->getDims()[1]), k(A->getDims()[2]) {
    IT_ASSERT(checkValid(graph));
}

string G2BMMObj::toString() const {
    std::ostringstream os;
    os << ""G2BMM([""
       << ""width="" << width << "",act="" << enum_to_underlying(act)
       << ""],A="" << inputs[0]->getGuid() << "",B="" << inputs[1]->getGuid()
       << "",C="" << outputs[0]->getGuid() << "", TTbmnkd: "" << this->getB()
       << "", "" << this->getM() << "", "" << this->getWidth() << "", ""
       << inputs[1]->getDims()[2] << "", "" << this->getDilation() << "")"";
    return os.str();
}

optional<vector<Shape>> G2BMMObj::inferShape(const TensorVec &inputs) {
    auto A = inputs[0], B = inputs[1];
    b = A->getDims()[0];
    m = A->getDims()[1];
    k = A->getDims()[2];

    IT_ASSERT(A->getRank() == 3 && B->getRank() == 3);
    IT_ASSERT(A->getDims()[0] == B->getDims()[0]);
    IT_ASSERT(A->getDims()[1] == B->getDims()[1]);
    IT_ASSERT(A->getDims()[2] == B->getDims()[2]);
    IT_ASSERT(width >= 0);
    int n(2 * width + 1);
    return {{{b, m, n}}};
}

vector<int> G2BMMObj::getWorkloadVector() const {
    return {type.underlying(),      b, m, k, width, dilation,
            enum_to_underlying(act)};
}

vector<int> G2BMMObj::getOpAttrVector() const {
    return {type.underlying(), width, dilation, enum_to_underlying(act)};
}

double G2BMMObj::getComputeTime() const {
    int64_t batchSize = getB();
    int64_t seqLength = getM();
    int64_t featureDim = getK();
    int64_t windowWidth = getWidth();
    int64_t dilationFactor = getDilation();
    int64_t outputWidth = 2 * windowWidth + 1;
    
    double multiplyAddOps = batchSize * seqLength * outputWidth * featureDim;
    double dilationPenalty = std::log2(dilationFactor + 1) * 0.1 + 1.0;
    
    double actCost = 0.0;
    if (act != ActType::None) {
        actCost = batchSize * seqLength * outputWidth * 0.1;
    }
    
    double totalOps = multiplyAddOps * dilationPenalty + actCost;
    return totalOps / 2e9;
}

double G2BMMObj::getMemoryCost() const {
    double costA = inputs[0]->size();
    double costB = inputs[1]->size();
    double  [MASK]  = outputs[0]->size();
    double memoryEfficiencyFactor = 1.0 + dilation * 0.05;
    return (costA + costB) * memoryEfficiencyFactor +  [MASK] ;
}

double G2BMMObj::getParallelism() const {
    int64_t batchParallel = getB();
    int64_t seqParallel = getM();
    int64_t windowParallel = std::min(2 * width + 1, 8);
    double totalParallelism = batchParallel * seqParallel * windowParallel;
    const double MAX_PARALLEL_UNITS = 2048.0;
    return std::min(totalParallelism, MAX_PARALLEL_UNITS);
}

} // namespace infini",costC
33,"#include ""CudaContext.h""

#include <stdexcept> //std::runtime_error
#include <array>
#include ""Shin/Utilities/GraphicsUtility.h""

CudaContext::CudaContext() : m_context(nullptr) {
}

//---------------------------------------------------------------------------------------------------------------------

CudaContext::~CudaContext() {
}

//---------------------------------------------------------------------------------------------------------------------

void CudaContext::Init(const VkInstance instance, VkPhysicalDevice  [MASK] ) {

    CUdevice dev;
    CUresult result = CUDA_SUCCESS;
    bool foundDevice = true;

    result = cuInit(0);
    if (result != CUDA_SUCCESS) {
        throw std::runtime_error(""Failed to cuInit()"");
    }

    int numDevices = 0;
    result = cuDeviceGetCount(&numDevices);
    if (result != CUDA_SUCCESS) {
        throw std::runtime_error(""Failed to get count of CUDA devices"");
    }

    CUuuid id = {};
    std::array<uint8_t, VK_UUID_SIZE> deviceUUID;
    GraphicsUtility::GetPhysicalDeviceUUIDInto(instance,  [MASK] , &deviceUUID);

    /*
     * Loop over the available devices and identify the CUdevice
     * corresponding to the physical device in use by this Vulkan instance.
     * This is required because there is no other way to match GPUs across
     * API boundaries.
     */
    for (int i = 0; i < numDevices; i++) {
        cuDeviceGet(&dev, i);

        cuDeviceGetUuid(&id, dev);

        if (!std::memcmp(static_cast<const void *>(&id),
                static_cast<const void *>(deviceUUID.data()),
                sizeof(CUuuid))) {
            foundDevice = true;
            break;
        }
    }

    if (!foundDevice) {
        throw std::runtime_error(""Failed to get an appropriate CUDA device"");
 
 }

    result = cuCtxCreate(&m_context, 0, dev);
    if (result != CUDA_SUCCESS) {
        throw std::runtime_error(""Failed to create a CUDA context"");
    }
}

//---------------------------------------------------------------------------------------------------------------------

void CudaContext::CleanUp() {
    if (nullptr != m_context) {
        cuCtxDestroy(m_context);
        m_context = nullptr;
    }
}
",physicalDevice
34,"#include ""ActionToolTipComponent.h""

#include ""PositionYTween.h""
#include ""ResourceContainer.h""
#include ""SpriteAlphaTween.h""
#include ""SpriteComponent.h""
#include ""StageConstitution.h""
using RC = ResourceContainer;
using namespace base_engine;
std::weak_ptr<ActionToolTipComponent> ActionToolTipComponent::Create(
    Actor* owner, const std::weak_ptr<IMachineActionable>& machine) {
  if (const auto tooltip = owner->GetComponent<ActionToolTipComponent>();
      !tooltip.expired()) {
    return tooltip;
  }
  const auto  [MASK]  = new ActionToolTipComponent(owner);

  const auto tooltip = new Actor(owner->GetGame());
  owner->AddChild(tooltip->GetId());
  
   [MASK] ->panel_ = owner->GetGame()->GetActor(tooltip->GetId());
   [MASK] ->sprite_ = new SpriteComponent(tooltip, 200);
  const auto img =
      *RC::GetResource<RC::SpriteResourcePack, RC::Sprite>(""ActionTooltip"");
  tooltip->SetPosition(owner->GetPosition() + Vector2{64, -32});
   [MASK] ->sprite_->SetAlignment(Mof::TEXALIGN_CENTERCENTER)
      .SetColor(MOF_ARGB(0, 255, 255, 255))
      .SetImage(img);
  return owner->GetComponent<ActionToolTipComponent>();
}

constexpr float kFadeInTime = 0.25f;
constexpr float kFadeOutTime = 0.25f;

void ActionToolTipComponent::Show() {
  open_ = true;
  if (play_animation_) return;
  if (is_show_) return;
  if (panel_.expired()) return;

  play_animation_ = true;
  ma_tween::PositionYTween::TweenLocalPositionY(
      panel_.lock().get(), owner_->GetPosition().y - stage::kStageCellSize<float>.y * 0.5f,
      kFadeInTime)
      .SetEase(EaseType::kInsine);
  ma_tween::SpriteAlphaTween::Tween(panel_.lock().get(), 255, kFadeInTime)
      .SetOnComplete([this]
      {
        is_show_ = true;
      	play_animation_ = false;
      });
}

void ActionToolTipComponent::Hide() {
  if (play_animation_) return;
  if (!is_show_) return;
  if (panel_.expired())return;
  play_animation_ = true;
  ma_tween::PositionYTween::TweenLocalPositionY(
      panel_.lock().get(), owner_->GetPosition().y + 32,
      kFadeOutTime)
      .SetEase(EaseType::kInsine);
  ma_tween::SpriteAlphaTween::Tween(panel_.lock().get(), 0, kFadeOutTime)
      .SetOnComplete([this] {
        is_show_ = false;
	      play_animation_ = false;
      });
}

void ActionToolTipComponent::Update() {
  if (open_ == false) {
    count_frame_++;
    if (count_frame_ > 5) {
      Hide();
    }
  } else {
    count_frame_ = 0;
  }
  open_ = false;
}
",tooltip_component
35,"/*
  Copyright 2015 Google LLC 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.
*/

/*
   american fuzzy lop - LLVM-mode instrumentation pass
   ---------------------------------------------------

   Written by <NAME> <<EMAIL>> and
              <NAME> <<EMAIL>>

   LLVM integration design comes from Laszlo Szekeres. C bits copied-and-pasted
   from afl-as.c are Michal's fault.

   This library is plugged into LLVM when invoking clang through afl-clang-fast.
   It tells the compiler to add code roughly equivalent to the bits discussed
   in ../afl-as.h.
*/

#define AFL_LLVM_PASS

#include ""../include/config.h""
#include ""../include/debug.h""

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fstream>
#include <sstream>
#include <string>
#include <unordered_map>
#include <set>
#include <sys/shm.h>
#include <cxxabi.h>

#include ""llvm/ADT/Statistic.h""
#include ""llvm/IR/IRBuilder.h""
#include ""llvm/IR/LegacyPassManager.h""
#include ""llvm/IR/Module.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/IR/DebugInfoMetadata.h""
#include ""llvm/Transforms/IPO/PassManagerBuilder.h""

#include ""../rustc-demangle/crates/capi/include/rustc_demangle.h""

using namespace llvm;

#define TARGETS_TYPE std::unordered_map<std::string, std::set<int>>

namespace
{

  class AFLCoverage : public ModulePass
  {

  public:
    static char ID;
    AFLCoverage() : ModulePass(ID) {}

    bool runOnModule(Module &M) override;

    // Global variables
    GlobalVariable *AFLMapPtr;
    GlobalVariable *AFLPrevLoc;
    unsigned int inst_ratio;

    // Types
    Type *VoidTy;
    PointerType *Int8PtrTy;
    IntegerType *Int8Ty;
    IntegerType *Int16Ty;
    IntegerType *Int32Ty;
    IntegerType *Int64Ty;
    PointerType *Int64PtrTy;

    // Store mapping data from basicblock location to ID
    std::ofstream bbToID;

    u16 *get_ID_ptr();
    static void get_debug_loc(const Instruction *I, std::string &Filename, unsigned &Line);
    static void load_instr_targets(TARGETS_TYPE &bb_targets, TARGETS_TYPE &func_targets);

    // -1: not checking, 0: not targets, 1: target BBs, 2: target functions
    static u8 is_target_loc(std::string codefile, unsigned line, TARGETS_TYPE &bb_targets, TARGETS_TYPE &func_targets);

    u8 check_code_language(std::string codefile);
    void printFuncLog(std::string filename, unsigned line, u16 evtID, std::string func_name);
    void printBBLog(std::string filename, unsigned line, u16 evtID);
  };

}

/***
 * Load identified interesting basicblocks(targets) to instrument
 ***/
void AFLCoverage::load_instr_targets(TARGETS_TYPE &bb_targets, TARGETS_TYPE &func_targets)
{
  char *target_file = getenv(""TARGETS_FILE"");
  if (!target_file)
  {
    target_file = (char *)""/opt/instrumentor/instr-targets.txt"";
  }

  std::ifstream targetsfile(target_file);
  if (!targetsfile.is_open())
  {
    outs() << ""[!!] Fail to open targets file""
           << ""\n"";
    return;
  }

  std::string line;
  std::string codefile;
  int num = 0;
  while (std::getline(targetsfile, line))
  {
    if (num % 3 == 0)
    {
      codefile = line;
    }
    else if (num % 3 == 1)
    {
      std::stringstream ss(line);
      std::string item;
      while (std::getline(ss, item, ' '))
      {
        bb_targets[codefile].insert(std::stoi(item));
      }
    }
    else
    {
      std::stringstream ss(line);
      std::string item;
      while (std::getline(ss, item, ' '))
      {
        func_targets[codefile].insert(std::stoi(item));
      }
    }
    ++num;
  }
  targetsfile.close();
}

/***
 * Check if current location is target: 1 for BB, 2 for function, 0 for not targets, -1 for not checking
 ***/
u8 AFLCoverage::is_target_loc(std::string codefile, unsigned line, TARGETS_TYPE &bb_targets, TARGETS_TYPE &func_targets)
{
  if (bb_targets.count(codefile))
  {
    std::set<int> locs = bb_targets[codefile];
    for (auto ep = locs.begin(); ep != locs.end(); ep++)
    {
      if (*ep == line)
      {
        bb_targets[codefile].erase(line);
        return 1;
      }
    }
  }

  if (func_targets.count(codefile))
  {
    std::set<int> locs = func_targets[codefile];
    for (auto ep = locs.begin(); ep != locs.end(); ep++)
    {
      if (*ep == line)
      {
        func_targets[codefile].erase(line);
        return 2;
      }
    }
  }

  return 0;
}

/***
 * Get filename and location given one instruction
 ***/
void AFLCoverage::get_debug_loc(const Instruction *I, std::string &Filename, unsigned &Line)
{
  if (DILocation *Loc = I->getDebugLoc())
  {
    Line = Loc->getLine();
    Filename = Loc->getFilename().str();

    char *path = realpath(Filename.c_str(), NULL);
    if (path)
    {
      Filename = std::string(path);
    }
    else
    {
      std::string dir = Loc->getDirectory().str();
      if (dir.size() > 0)
      {
        Filename = dir + ""/"" + Filename;
      }
    }

    if (Filename.empty())
    {
      DILocation *oDILoc = Loc->getInlinedAt();
      if (oDILoc)
      {
        Line = oDILoc->getLine();
        Filename = oDILoc->getFilename().str();
        char *path = realpath(Filename.c_str(), NULL);
        if (path)
        {
          Filename = std::string(path);
        }
        else
        {
          std::string dir = Loc->getDirectory().str();
          if (dir.size() > 0)
          {
            Filename = dir + ""/"" + Filename;
          }
        }
      }
    }
  }
}

/***
 * Assign event ID in increasing order, instead of random assignment in AFL
 ***/
u16 *AFLCoverage::get_ID_ptr()
{
  // Create the shared memory if it does not exist, otherwise get the existing one
  int  [MASK]  = shmget((key_t)SHM_ID_KEY, sizeof(u16), IPC_CREAT | IPC_EXCL | 0666);
  if ( [MASK]  != 0)
  {
     [MASK]  = shmget((key_t)SHM_ID_KEY, sizeof(u16), 0666);
  }

  // FIXME: If compilation is done in Docker (in subsequent RUN layers), the
  // shared memory is not carried over between layers, so IDs will conflict

  u16 *_id_ptr;
  if ( [MASK]  >= 0)
  {
    _id_ptr = (u16 *)shmat( [MASK] , NULL, 0);
    if (_id_ptr == (u16 *)-1)
    {
      ABORT(""!!! shared memory error: fail to connect"");
      _exit(1);
    }
    return _id_ptr;
  }
  else
  {
    ABORT(""!!! shared memory error: fail to create"");
    _exit(1);
  }
}

u8 AFLCoverage::check_code_language(std::string codefile)
{
  // Check if the code is written in Rust (return 1) or C/C++ (return 2)
  if (codefile.find("".rs"") != std::string::npos)
  {
    return 1;
  }
  else
  {
    return 2;
  }
}

/***
 * Print compilation log
 ***/
void AFLCoverage::printFuncLog(std::string filename, unsigned line, u16 evtID, std::string func_name)
{
  OKF(""Instrument %u at %s: at line %u for function %s"", evtID, filename.c_str(), line, func_name.c_str());
  bbToID << evtID << "": at "" << filename << "" ; at line "" << line << "" for function "" << func_name << std::endl;
}

void AFLCoverage::printBBLog(std::string filename, unsigned line, u16 evtID)
{
  bbToID << evtID << "": at "" << filename << "" ; at line "" << line << "" for block"" << std::endl;
  OKF(""Instrument %u at %s: at line %u for block"", evtID, filename.c_str(), line);
}

char AFLCoverage::ID = 0;

bool AFLCoverage::runOnModule(Module &M)
{

  LLVMContext &C = M.getContext();

  VoidTy = Type::getVoidTy(C);
  Int8PtrTy = Type::getInt8PtrTy(C);
  Int8Ty = IntegerType::getInt8Ty(C);
  Int16Ty = IntegerType::getInt16Ty(C);
  Int32Ty = IntegerType::getInt32Ty(C);
  Int64Ty = IntegerType::getInt64Ty(C);
  Int64PtrTy = Type::getInt64PtrTy(C);

  bbToID.open(""/opt/instrumentor/BB2ID.txt"", std::ofstream::out | std::ofstream::app);
  if (!bbToID.is_open())
  {
    bbToID.open(""./BB2ID.txt"", std::ofstream::out | std::ofstream::app);
  }

  /* Show a banner */

  // char be_quiet = 0;

  if (isatty(2) && !getenv(""AFL_QUIET""))
  {
    SAYF(cCYA ""afl-llvm-pass "" cBRI VERSION cRST "" by <<EMAIL>>\n"");
  }

  /* Decide the size of instrumented functions */
  char *instr_func_size_str = getenv(""INST_FUNC_SIZE"");

  // Set one large number to disable it if the environment variable is not set
  unsigned int instr_func_size = 65536;
  if (instr_func_size_str)
  {
    if (sscanf(instr_func_size_str, ""%u"", &instr_func_size) != 1)
      FATAL(""Bad value of INST_FUNC_SIZE"");
  }

  if (getenv(""USE_TRADITIONAL_BRANCH"")){
    /* Decide instrumentation ratio */
    char *inst_ratio_str = getenv(""AFL_INST_RATIO"");
    inst_ratio = 100;
    if (inst_ratio_str)
    {
      if (sscanf(inst_ratio_str, ""%u"", &inst_ratio) != 1 || !inst_ratio ||
          inst_ratio > 100)
        FATAL(""Bad value of AFL_INST_RATIO (must be between 1 and 100)"");
    }

    /* Get globals for the SHM region and the previous location. Note that
      __afl_prev_loc is thread-local. */
    AFLMapPtr =
        new GlobalVariable(M, PointerType::get(Int8Ty, 0), false,
                          GlobalValue::ExternalLinkage, 0, ""__afl_area_ptr"");

    AFLPrevLoc = new GlobalVariable(
        M, Int32Ty, false, GlobalValue::ExternalLinkage, 0, ""__afl_prev_loc"",
        0, GlobalVariable::GeneralDynamicTLSModel, 0, false);
  }

  int inst_blocks = 0;
  TARGETS_TYPE bb_targets, func_targets;
  load_instr_targets(bb_targets, func_targets);
  u8 codeLang = 0;

  static const std::string Xlibs(""/usr/"");
  // static const std::string Clibs(""/rustc/"");

  for (auto &F : M)
  {
    // Label if this function is instrumented
    bool isTargetFunc = false;

    std::string filename;
    unsigned line = 0;

    for (auto &BB : F)
    {

      BasicBlock::iterator IP = BB.getFirstInsertionPt();

      // in each basic block, check if it is a target
      bool isTargetBB = false;

      for (auto &I : BB)
      {

        get_debug_loc(&I, filename, line);

        if (filename.empty() || line == 0 || !filename.compare(0, Xlibs.size(), Xlibs))
        {
          continue;
        }
        // printf(""filename: %s, line: %u\n"", filename.c_str(), line);

        /* check if target locations */
        u8 isTarget = is_target_loc(filename, line, bb_targets, func_targets);
        if (isTarget == 1)
        {
          isTargetBB = true;
        }
        else if (isTarget == 2)
        {
          isTargetFunc = true;
        }
      }

      /* skip if no target found or instrumented, and also not selected */
      if (!isTargetBB && AFL_R(100) >= inst_ratio)
      {
        continue;
      }

      /* instrument starting block point */
      IRBuilder<> IRB(&(*IP));
      if (isTargetBB)
      {
        u16 *evtIDPtr = get_ID_ptr();
        u16 evtID = *evtIDPtr;
        Value *evtValue = ConstantInt::get(Int16Ty, evtID);

        auto *helperTy_stack = FunctionType::get(VoidTy, Int16Ty);
        auto helper_stack_start = M.getOrInsertFunction(""track_blocks"", helperTy_stack);

        IRB.CreateCall(helper_stack_start, {evtValue});

        /* store BB ID info */
        printBBLog(filename, line, evtID);

        /* increase counter */
        *evtIDPtr = ++evtID;
      }

      if (getenv(""USE_TRADITIONAL_BRANCH"")){
        // Instrument all basicblocks to compute AFL feedback
        unsigned int cur_loc = AFL_R(MAP_SIZE);

        ConstantInt *CurLoc = ConstantInt::get(Int32Ty, cur_loc);

        /* Load prev_loc */

        LoadInst *PrevLoc = IRB.CreateLoad(AFLPrevLoc);
        PrevLoc->setMetadata(M.getMDKindID(""nosanitize""), MDNode::get(C, None));
        Value *PrevLocCasted = IRB.CreateZExt(PrevLoc, IRB.getInt32Ty());

        /* Load SHM pointer */

        LoadInst *MapPtr = IRB.CreateLoad(AFLMapPtr);
        MapPtr->setMetadata(M.getMDKindID(""nosanitize""), MDNode::get(C, None));
        Value *MapPtrIdx =
            IRB.CreateGEP(MapPtr, IRB.CreateXor(PrevLocCasted, CurLoc));

        /* Update bitmap */

        LoadInst *Counter = IRB.CreateLoad(MapPtrIdx);
        Counter->setMetadata(M.getMDKindID(""nosanitize""), MDNode::get(C, None));
        Value *Incr = IRB.CreateAdd(Counter, ConstantInt::get(Int8Ty, 1));
        IRB.CreateStore(Incr, MapPtrIdx)
            ->setMetadata(M.getMDKindID(""nosanitize""), MDNode::get(C, None));

        /* Set prev_loc to cur_loc >> 1 */

        StoreInst *Store =
            IRB.CreateStore(ConstantInt::get(Int32Ty, cur_loc >> 1), AFLPrevLoc);
        Store->setMetadata(M.getMDKindID(""nosanitize""), MDNode::get(C, None));
      }

      inst_blocks++;
    }

    /* Instrument function if it is one target or the size is above threshold */
    // if (isTargetFunc || F.getInstructionCount() > instr_func_size)
    if (isTargetFunc)
    {
      /* get inserting point: first inserting point of the entry block */
      BasicBlock *BB = &F.getEntryBlock();
      Instruction *InsertPoint = &(*(BB->getFirstInsertionPt()));
      IRBuilder<> IRB(InsertPoint);

      /* get evt ID */
      u16 *evtIDPtr = get_ID_ptr();
      u16 evtID = *evtIDPtr;
      Value *evtValue = ConstantInt::get(Int16Ty, evtID);

      auto *helperTy_func = FunctionType::get(VoidTy, Int16Ty);
      auto helper_func = M.getOrInsertFunction(""track_functions"", helperTy_func);
      IRB.CreateCall(helper_func, {evtValue});

      /* store event ID info */
      get_debug_loc(&(*InsertPoint), filename, line);
      std::string func_name = F.getName().str();
      if (codeLang == 0)
      {
        codeLang = check_code_language(filename);
      }

      if (codeLang == 2)
      {
        int demangled_status = -1;
        char *demangled_char = abi::__cxa_demangle(F.getName().data(), nullptr,
                                                   nullptr, &demangled_status);
        if (demangled_status == 0)
        {
          func_name = demangled_char;
        }
      }
      else
      {
        int demangled_status = -1;
        char *demangled_char = rustc_demangle(F.getName().data(), &demangled_status);
        if (demangled_status == 0)
        {
          func_name = demangled_char;
        }
      }
      printFuncLog(filename, line, evtID, func_name);

      /* increase counter */
      *evtIDPtr = ++evtID;
      inst_blocks++;
    }
  }

  return true;
}

static void registerAFLPass(const PassManagerBuilder &,
                            legacy::PassManagerBase &PM)
{

  PM.add(new AFLCoverage());
}

static RegisterStandardPasses RegisterAFLPass(
    PassManagerBuilder::EP_ModuleOptimizerEarly, registerAFLPass);

static RegisterStandardPasses RegisterAFLPass0(
    PassManagerBuilder::EP_EnabledOnOptLevel0, registerAFLPass);
",shmid
36," 
using namespace std;
using namespace cv;
using namespace TgBot;

namespace travisFilter {
enum paramNumbers { contrast = 0, brightness = 1, gamma = 2, yellow = 3, grain = 4 };

void  correction(Mat &img, double alpha_, int beta_,
		double  [MASK] ) {
	Mat res1;
	img.convertTo(res1, -1, alpha_, beta_);
	CV_Assert( [MASK]  >= 0);
	Mat lookUpTable(1, 256, CV_8U);
	uchar *p = lookUpTable.ptr();
	for (int i = 0; i < 256; ++i)
		p[i] = saturate_cast<uchar>(pow(i / 255.0,  [MASK] ) * 255.0);
	Mat res = img.clone();
	LUT(res1, lookUpTable, res);
	img = res.clone();
}

void addGrain(Mat &img, int depth)
{
    using namespace std::experimental::fundamentals_v2;

    for (int i = 0; i < img.rows; i++)
        for (int j = 0; j < img.cols; j++) {
            int a = img.at<Vec3b>(i, j)[0] + randint(-1 * depth, depth),

                b = img.at<Vec3b>(i, j)[1] + randint(-1 * depth, depth) / 2,

                c = img.at<Vec3b>(i, j)[2] + randint(-1 * depth, depth) / 1.5;

            if (a < 0)
                a = 0;
            if (b < 0)
                b = 0;
            if (c < 0)
                c = 0;
            if (a > UCHAR_MAX)
                a = UCHAR_MAX;
            if (b > UCHAR_MAX)
                b = UCHAR_MAX;
            if (c > UCHAR_MAX)
                c = UCHAR_MAX;

            img.at<Vec3b>(i, j)[0] = a;
            img.at<Vec3b>(i, j)[1] = b;
            img.at<Vec3b>(i, j)[2] = c;
        }
}

void addYellow(Mat &img, int depth)
{
    for (int i = 0; i < img.rows; i++)
        for (int j = 0; j < img.cols; j++) {
            (-depth, depth);
            int a = img.at<Vec3b>(i, j)[0], b = img.at<Vec3b>(i, j)[1], c = img.at<Vec3b>(i, j)[2];
            int S = (a + b + c) / 3;
            a -= 5;
            b = b + 0.15 * (S + depth);
            c = c + 0.30 * S;

            if (a < 0)
                a = 0;
            if (b < 0)
                b = 0;
            if (c < 0)
                c = 0;
            if (a > UCHAR_MAX)
                a = UCHAR_MAX;
            if (b > UCHAR_MAX)
                b = UCHAR_MAX;
            if (c > UCHAR_MAX)
                c = UCHAR_MAX;

            img.at<Vec3b>(i, j)[0] = a;
            img.at<Vec3b>(i, j)[1] = b;
            img.at<Vec3b>(i, j)[2] = c;
        }
}
 
 
Mat  filter(Mat *img_original, vector<int> p)
{
    try {
        using namespace travisFilter;

        //resize(img_original, img_original, Size(0, 0), 0.5, 0.5, INTER_LINEAR);
        if (img_original->empty()) {
            cout << ""Could not open or find the image!\n""
                 << ""\n"";
        }

        Mat img_corrected = img_original->clone();

        //brightness and contrast filter
        correction(img_corrected,
                   p[paramNumbers::brightness] / 100.0,
                   p[paramNumbers::contrast] - 100,
                   p[paramNumbers::gamma] / 100.0);

        //adding random noises
        addGrain(img_corrected, p[paramNumbers::grain]);

        // adding some yellow tone
        addYellow(img_corrected, p[paramNumbers::yellow]);

        // blur
        GaussianBlur(img_corrected, img_corrected, Size(1, 1), 0, 0);

        return img_corrected;
    } catch (cv::Exception cvException) {
        cout << cvException.what() << ""\n"";

    } catch (std::exception stdException) {
        cout << stdException.what() << ""\n"";
    } catch (...) {
        cout << ""unknown error\n"";
    }
}
}
",gamma_
37,"#include <cstdlib>    // EXIT_SUCCESS
#include <csignal>    // SIGINT, signal
#include <iostream>   // cin, cout, endl
#include <string>     // string
#include <fcntl.h>    // O_WRONLY
#include <sys/mman.h> // mmap, shm_open, PROT_WRITE
#include <unistd.h>   // ftruncate

// Name of shared memory object.
#define SHM_NAME ""comm-file""

// Size of shard memory object.
// Give enough space to store 10 signed integers.
#define SHM_SIZE 10 * sizeof(int)

void handle_shutdown(int signal) {
    std::string response;

    std::cout << std::endl;

    do {
        std::cout << ""Shutdown client? [y/n] "";
        std::cin >> response;

        if (response == ""y"" || response == ""Y"") {
            exit(EXIT_SUCCESS);
        }
    } while(response != ""n"" && response != ""N"");
}

int main(int arg_c, char** arg_v) {
    // Set up shutdown handler to terminate program correctly.
    signal(SIGINT, handle_shutdown);

    // Create shared memory object, get file descriptor.
    // TODO: Check that a server is active and has created the shared memory!
    int  [MASK]  = shm_open(SHM_NAME, O_WRONLY, 0666);

    // Memory map the shared memory object.
    int* data = (int*)mmap(0, SHM_SIZE, PROT_WRITE, MAP_SHARED,  [MASK] , 0);

    // Poll for new messages to send and store in shared memory.
    while(true) {
        std::cout << ""Message to server: "";
        // TODO: Put checks that what is read from console is actually an
        // integer!
        std::cin >> data[0];
    }

    return EXIT_SUCCESS;
}
",shared_memory
38,"// Fill out your copyright notice in the Description page of Project Settings.

#include ""Deadzone.h""
#include ""Components/BoxComponent.h""
#include ""GameFramework/PlayerController.h""
#include ""GameFramework/ProjectileMovementComponent.h""
#include ""GameFramework/Character.h""

// Sets default values
ADeadzone::ADeadzone()
{
	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	// Create the collision box component
	CollisionBox = CreateDefaultSubobject<UBoxComponent>(TEXT(""CollisionBox""));
	RootComponent = CollisionBox;

	// Bind the overlap function
	CollisionBox->OnComponentBeginOverlap.AddDynamic(this, &ADeadzone::OnPlayerEnterDeadZone);

}

// Called when the game starts or when spawned
void ADeadzone::BeginPlay()
{
	Super::BeginPlay();

}

// Called every frame
void ADeadzone::Tick(float  [MASK] )
{
	Super::Tick( [MASK] );

}

void ADeadzone::OnPlayerEnterDeadZone(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
	// Check if the overlapped actor is the player character
	APlayerController* PlayerController = Cast<APlayerController>(OtherActor->GetInstigatorController());

	if (PlayerController)
	{
		// Teleport the player to the Spawn location
		OtherActor->SetActorLocation(SpawnLocation);
	}


}
",DeltaTime
39,"/*
 * Copyright 2018 Amazon.com, Inc. or its affiliates. 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.
 * A copy of the License is located at
 *
 *  http://aws.amazon.com/apache2.0
 *
 * or in the ""license"" file accompanying this file. This file 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.
 */

#pragma once

#include <rclcpp/rclcpp.hpp>
#include <ros_monitoring_msgs/msg/metric_data.hpp>
#include <ros_monitoring_msgs/msg/metric_list.hpp>

#include <vector>


/**
 * @brief Interface for MetricManager.
 */
class MetricManagerInterface {
public:
    /**
     * @brief add global dimension (applies to all metrics).
     */
    virtual void AddDimension(const std::string &name, const std::string &value) = 0;

    /**
     * @brief create a metric.
     */
    virtual ros_monitoring_msgs::msg::MetricData CreateMetric() const = 0;

    /**
     * @brief add a metric to list of metrics to be published.
     *
     * @param md a metric.
     */
    virtual void AddMetric(ros_monitoring_msgs::msg::MetricData md) = 0;

    /**
     * @brief publishes all metrics and then discards them.
     */
    virtual void Publish() = 0;

    /** @brief destructor. */
    virtual ~MetricManagerInterface() {}
};

/**
 * @brief Create, aggregate and publish metrics to ros topic.
 **/
class MetricManager : public MetricManagerInterface {
public:
  explicit MetricManager(
    rclcpp::Node::SharedPtr node,
    std::string  [MASK] ,
    int topic_buffer_size
    ) :
      node_(node),
      publisher_(node->create_publisher<ros_monitoring_msgs::msg::MetricList>( [MASK] , topic_buffer_size)) {}

  virtual void AddDimension(const std::string &name, const std::string &value) override final;

  virtual ros_monitoring_msgs::msg::MetricData CreateMetric() const override final;

  virtual void AddMetric(ros_monitoring_msgs::msg::MetricData md) override final;

  virtual void Publish() override final;

private:
  rclcpp::Node::SharedPtr node_;
  rclcpp::Publisher<ros_monitoring_msgs::msg::MetricList>::SharedPtr publisher_;
  ros_monitoring_msgs::msg::MetricList mlist_;
  ros_monitoring_msgs::msg::MetricData dimensions_;
};
",metrics_topic_name
40,"#include <Arduino.h>
#include <Wire.h>
#include <Arduino_LSM6DS3.h>
#include ""mecanum.hpp""
#include ""servo-wrapper.hpp""

// Motor pins
#define frontLeftMotorPin 5
#define backLeftMotorPin 6
#define backRightMotorPin 9
#define frontRightMotorPin 10

// Controller pins
#define rightStickHorizontalPin 2
#define rightStickVerticalPin 3
// #define leftStickVerticalPin 4
#define leftStickHorizontalPin 4
#define switchAPin 7
#define switchDPin 8
#define switchBPin 12

#define fanPin 11

#define NOISE_THRESHOLD 100
#define CHANNEL_DEADZONE 50
#define CHANNEL_DEADZONE_CENTER 45
// #define DO_FIELD_ORIENTED

MecanumDrive drive(1.0f /* todo */, OF_REDUCE_EQUALLY, AF_FIT, TF_FLIP_X | TF_ROTATE_270DEG);

ServoWrapper frontLeft(frontLeftMotorPin);
ServoWrapper frontRight(frontRightMotorPin);
ServoWrapper backLeft(backLeftMotorPin);
ServoWrapper backRight(backRightMotorPin);

struct ChInfo {
    /* The physical pin the channel is connected to. */
    uint8_t pin;
    /* Was the pin `HIGH` last time? */
    bool wasOn;
    /* Did `value` change this time? */
    bool valueChanged;
    /* The last time the pin was detected to be `HIGH`, in microseconds since startup. */
    unsigned long onUS;
    /* for debugging */
    // long delta, deltaNormalized;
    /* The value of the channel, from `-1.0` to `1.0`. */
    float value;
};

struct {
    // volatile because they're used in interrupts
    volatile ChInfo rightStickHorizontal = {rightStickHorizontalPin, false, false, 0, 0.0f};
    volatile ChInfo rightStickVertical = {rightStickVerticalPin, false, false, 0, 0.0f};
    // volatile ChInfo leftStickVertical = {leftStickVerticalPin, false, false, 0, 0.0f};
    volatile ChInfo leftStickHorizontal = {leftStickHorizontalPin, false, false, 0, 0.0f};
    volatile ChInfo switchA = {switchAPin, false, false, 0, 0.0f};
    volatile ChInfo switchD = {switchDPin, false, false, 0, 0.0f};
#ifdef DO_FIELD_ORIENTED
    volatile ChInfo switchB = {switchBPin, false, false, 0, 0.0f};
#endif
    // ChInfo channel = {/* pin */2, false, false, 0, 0.0f};
} channels;

#ifdef DO_FIELD_ORIENTED
bool wasFieldOriented = false;
float angle;
unsigned long lastGyroTime = 0;
#endif

void updateChannel(volatile ChInfo& channel) {
    const bool newState = digitalRead(channel.pin);
    const bool oldState = channel.wasOn;
    channel.valueChanged = false;
    if (newState != oldState) {
        const unsigned long now = micros();
        if (newState) {
            // store rising time
            channel.onUS = now;
            channel.wasOn = true;
        } else {
            channel.wasOn = false;
            // how long was the pulse?
            long delta = now - channel.onUS;
            if (delta < NOISE_THRESHOLD) return;
            // channel.delta = delta;
            // apply deadzone
            if (delta >= 2000 - CHANNEL_DEADZONE) delta = 2000;
            if (delta <= 1000 + CHANNEL_DEADZONE) delta = 1000;
            if (abs(delta - 1500) <= CHANNEL_DEADZONE_CENTER) delta = 1500;
            // channel.deltaNormalized = delta;
            // convert 1000 <= delta <= 2000 to -1.0 <= value <= 1.0
            channel.value = (float)(delta - 1500) / 500.0f;
            channel.valueChanged = true;
        }
    }
}

void setup() {
    Serial.begin(9600);
    
    // Controller channel inputs
    pinMode(rightStickHorizontalPin, INPUT);
    pinMode(rightStickVerticalPin, INPUT);
    // pinMode(leftStickVerticalPin, INPUT);
    pinMode(leftStickHorizontalPin, INPUT);
    pinMode(switchAPin, INPUT);
    pinMode(switchDPin, INPUT);
#ifdef DO_FIELD_ORIENTED
    pinMode(switchBPin, INPUT);
#endif
    attachInterrupt(digitalPinToInterrupt(rightStickHorizontalPin), []{ updateChannel(channels.rightStickHorizontal); }, CHANGE);
    attachInterrupt(digitalPinToInterrupt(rightStickVerticalPin), []{ updateChannel(channels.rightStickVertical); }, CHANGE);
    // attachInterrupt(digitalPinToInterrupt(leftStickVerticalPin), []{ updateChannel(channels.leftStickVertical); }, CHANGE);
    attachInterrupt(digitalPinToInterrupt(leftStickHorizontalPin), []{ updateChannel(channels.leftStickHorizontal); }, CHANGE);
    attachInterrupt(digitalPinToInterrupt(switchAPin), []{ updateChannel(channels.switchA); }, CHANGE);
    attachInterrupt(digitalPinToInterrupt(switchDPin), []{ updateChannel(channels.switchD); }, CHANGE);
#ifdef DO_FIELD_ORIENTED
    attachInterrupt(digitalPinToInterrupt(switchBPin), []{ updateChannel(channels.switchB); }, CHANGE);
#endif
    
    pinMode(fanPin, OUTPUT);
    
#ifdef DO_FIELD_ORIENTED
    IMU.begin();
    lastGyroTime = millis();
#endif
    
    // Motors
    frontLeft.begin();
    frontRight.begin();
    backLeft.begin();
    backRight.begin();
}

void loop() {
    if (channels.switchA.value > 0.5f) {
        frontLeft.drive(0.0f);
        frontRight.drive(0.0f);
        backLeft.drive(0.0f);
        backRight.drive(0.0f);
        digitalWrite(fanPin, LOW);
        delay(2500);
        return;
    }
    
#ifdef DO_FIELD_ORIENTED
    if (IMU.gyroscopeAvailable()) {
        float x, y, z;
        IMU.readGyroscope(x, y, z);
        unsigned long now = millis();
        float delta = (now - lastGyroTime) / 1000.0f;
        angle += z * delta;
        lastGyroTime = now;
    }

    bool isFieldOriented = channels.switchB.value > 0.5f;
    
    if (isFieldOriented != wasFieldOriented) {
        if (isFieldOriented) {
            angle = 0.0f; // reset
        }
        wasFieldOriented = isFieldOriented;
    }
#endif
    
    vec2  [MASK]  = vec2(
        channels.rightStickHorizontal.value,
        channels.rightStickVertical.value
    );
    
#ifdef DO_FIELD_ORIENTED
    if (isFieldOriented)  [MASK] .rotate(angle);
#endif
    
    // Do some complicated math
    DriveValues values = drive.calculate(
         [MASK] ,
        // 0.0f
        channels.leftStickHorizontal.value * 0.25f
    );
    // Move motors
    frontLeft.drive(values.frontLeft);
    frontRight.drive(values.frontRight);
    backLeft.drive(values.backLeft);
    backRight.drive(values.backRight);
    
    // Fans
    digitalWrite(fanPin, channels.switchD.value > 0.5f ? HIGH : LOW);
    
    // Debugging assistance
    Serial.println(
        String(""RH:"") + channels.rightStickHorizontal.value
            + "", RV:"" + channels.rightStickVertical.value
            + "", LH:"" + channels.leftStickHorizontal.value
            + "", SA:"" + channels.switchA.value
            + "", SD:"" + channels.switchD.value
    );
}",stick
41,"
#ifndef DLIB_SCAN_fHOG_UTILS_Hh_
#define DLIB_SCAN_fHOG_UTILS_Hh_

#include ""../matrix.h""
//#include ""../image_transforms.h""
#include ""../array.h""
#include ""../array2d.h""
//#include ""object_detector.h""

#include <dlib/gui_widgets.h>
#include <dlib/image_io.h>
#include <iostream>


#define LOG_CALL_STACK()	 utils::call_stack<<""#  ""<<__FILE__<<"":""<<__LINE__<<""  ""<< __PRETTY_FUNCTION__<<std::endl;
//forward declaration
namespace dlib{
	template<typename T>
	struct processed_weight_vector;

    template <
        typename Pyramid_type,
        typename Feature_extractor_type
        >
    class scan_fhog_pyramid;

	template <
	    typename T,
	    typename mm1,
	    typename mm2
	    >
	dlib::matrix<unsigned char> draw_fhog(
	    const dlib::array<dlib::array2d<T,mm1>,mm2>& hog,
	    const long cell_draw_size = 15,
	    const float min_response_threshold = 0.0
	);

}

namespace utils{




class logFile{
    public:
    	logFile (std::string filename):outfile(filename.c_str()){
    	}
       	logFile (const char* filename):outfile(filename){
        	}
    	logFile (std::string filename_, int x, int y){
    		std::stringstream  [MASK] (filename_,std::ios_base::out|std::ios_base::ate);
    		 [MASK] <<""_""<<x<<""x""<<y<<"".R"";
    		outfile.open( [MASK] .str().c_str());
    	}
    	~logFile(){
    		outfile.flush();
    		outfile.close();
    	}
        inline  operator std::ostream& ()
        {
            return outfile;
        }
        inline std::ostream& operator <<(const char pzstr[2])
        {
        	outfile<<pzstr ;
            return outfile;
        }

    private:
    	std::ofstream outfile;
    };

   logFile call_stack(""call_stack.R"");

    template <bool RScript>
    class print_fhog_as_csv_helper;

	class r_matrix_helper {
	public:
		r_matrix_helper(std::ostream& out_) :
				out(out_) {
		}

		template<typename T>
		r_matrix_helper& operator<<(const dlib::array2d<T>& m) {
			out << name.c_str() << ""=matrix( c("";
			print_fhog_as_csv_helper<true>(out) << m;
			out << ""), nrow = "" << m.nr() << "", ncol = "" << m.nc()
					<< "", byrow = TRUE)"" << std::endl;
			return (*this);
		}

		r_matrix_helper& operator<<(std::string name_) {
			name=name_;
			return (*this);
		}

		template <
				typename T,
		        long num_rows,
		        long num_cols
		        >
		r_matrix_helper& operator<<(const dlib::matrix<T,num_rows,num_cols>& m) {

			out << name.c_str() << ""=matrix( c("";
			for(long k =0;k<m.nr();++k)
				for(int l=0;l<m.nc();++l)
			     			if(k == (m.nr()-1) && l == (m.nc()-1))
			     				out<<m(k,l)<<"" "";
			     			else
			     				out<<m(k,l)<<"", "";
			 out<<std::endl;
			 out << ""), nrow = "" << m.nr() << "", ncol = "" << m.nc()
			 					<< "", byrow = TRUE)"" << std::endl;
			return (*this);
		}

		template <

		        long num_rows,
		        long num_cols
		        >
		r_matrix_helper& operator<<(
					const dlib::array2d< dlib::matrix<float,num_rows,num_cols> >& m
					)
		{
		     typedef typename dlib::array2d<dlib::matrix<float,num_rows,num_cols> >::row row_type;
		     std::string tmp_name=name;

		     for(int k =0;k<m.nr();++k)
		     {
		     	row_type row = m[k];
		     	for(int l=0;l<m.nc();++l)
		     	{
		     		std::stringstream ss_name(tmp_name,std::ios_base::out|std::ios_base::ate);
		     		ss_name<<"".""<<k<<"".""<<l;
		     		name=ss_name.str();
		     		(*this)<<row[l];
		     	}
		     }
		     name=tmp_name;
		     return (*this);
		 }


	r_matrix_helper& operator<<(long unsigned int numeric) {
		out << name.c_str() << ""="" << numeric<< std::endl;
	    return (*this);
	 }

	r_matrix_helper& operator<<(long  int numeric) {
		out << name.c_str() << ""="" << numeric<< std::endl;
	    return (*this);
	 }
	r_matrix_helper& operator<<( int numeric) {
		out << name.c_str() << ""="" << numeric<< std::endl;
	    return (*this);
	 }
	r_matrix_helper& operator<<(double numeric) {
		out << name.c_str() << ""="" << numeric<< std::endl;
	    return (*this);
	 }

	template<typename T>
	r_matrix_helper& operator<<(const std::vector<dlib::processed_weight_vector<T> >& w)
	{
		out << name.c_str()<<"".size="" <<w.size()<< std::endl;
		std::string tmp_name=name;
		for(int i=0;i<w.size();++i){
     		std::stringstream w_name(tmp_name,std::ios_base::out|std::ios_base::ate);
     		w_name<<i;
     		name=w_name.str();
     		(*this)<<w[i];
		}
		 name=tmp_name;
		return (*this);
	}

	template<typename T>
	r_matrix_helper& operator<<(const dlib::processed_weight_vector<T > & a)
	{
		(*this)<<a.w;
		return (*this);
	}


	 template <
	        typename Pyramid_type,
	        typename feature_extractor_type
	        >
	r_matrix_helper& operator<<(
			const dlib::processed_weight_vector<dlib::scan_fhog_pyramid<Pyramid_type,feature_extractor_type> >&a
			)
	{

	 		typedef typename dlib::scan_fhog_pyramid<Pyramid_type,feature_extractor_type>::fhog_filterbank fhog_filterbank;
	 		out << name.c_str()<<"".w.size=""<<a.w.size()<< std::endl;
	 		out << name.c_str()<<"".w.nr=""<<a.w.nr()<< std::endl;
	 		out << name.c_str()<<"".w.nc=""<<a.w.nc()<< std::endl;
	 		{
	 			std::string tmp_name=name;
	 			std::stringstream w_name(tmp_name,std::ios_base::out|std::ios_base::ate);
	 			w_name<<"".w"";
	 			name=w_name.str();
	 			(*this)<<a.w;
	 			name=tmp_name;
	 		}
	 		fhog_filterbank fb= a.get_detect_argument();
	 		out << name.c_str()<<"".fb.num_dimensions=""<<fb.get_num_dimensions()<< std::endl;
	 		out << name.c_str()<<"".fb.num_separable_filters=""<<fb.num_separable_filters() << std::endl;
	 		return (*this);
	}

	r_matrix_helper& operator<<(const  std::vector<std::pair<double, dlib::rectangle> >& dets )
	{
		 if(dets.size()==0){
			 out << name.c_str()<<"".size=0""<<std::endl;
			 return (*this);
		 }
		out << name.c_str()<<"".saliency= c("";
		 for(int i=0;i<dets.size();++i){
  			if(i == (dets.size()-1))
  				out<<dets[i].first<<"" "";
  			else
  				out<<dets[i].first<<"", "";
		 }
		 out<<std::endl<< "")"" << std::endl;
		 //rectangles
		 if(dets.size())
			 out << name.c_str()<<"".rect= list("";
		 name.clear();
		 for(int i=0;i<dets.size();++i){
			 (*this)<<dets[i].second;
	 		  if(i == (dets.size()-1))
	  			out<<"" "";
	 		  else
	  			out<<"", "";
		 }
		 out<<std::endl<< "")"" << std::endl;

		 return (*this);
	}

	r_matrix_helper& operator<<(const dlib::rectangle& rect )
	{
		if(name.size()>1){
			out << name.c_str() << ""="";
		}
		out << ""c( ""<<rect.left() << "", "" << rect.bottom() <<"", ""<<rect.right() <<"", ""<<rect.top()<<"")"";
		if(name.size()){
			out<< std::endl;
		}
		return (*this);
	}

	private:
		std::ostream& out;
		std::string name;
	};

    class r_matrix_type {};
    const r_matrix_type r_matrix      = r_matrix_type();
    inline r_matrix_helper operator<< (
        std::ostream& out,
        const r_matrix_type&
    )
    {
        return r_matrix_helper(out);
    }

    template <bool RScript>
    class print_fhog_as_csv_helper
    {
        /*!

            In particular, this code allows you to write statements like:
               std::cout<<fhog_csv<<feats;
            and have it print with commas separating each element.
        !*/
    public:
    	print_fhog_as_csv_helper (std::ostream& out_) : out(out_) {}

        template <typename T>
        std::ostream& operator<< (
            const dlib::array<dlib::array2d<T> >& feats
        );

        template <typename T>
        std::ostream& operator<< (
            const dlib::array2d<T>& m);


        print_fhog_as_csv_helper<RScript>& operator<< (
        	const std::string name_
			)
        {
        	name=name_;
        	return (*this);
        }
    private:
        std::ostream& out;
        mutable std::string name;
    };

    template<>
    template <typename T>
     std::ostream& print_fhog_as_csv_helper<true>::operator<< (
         const dlib::array<dlib::array2d<T> >& feats
     )
     {
      	for(int i=0;i<feats.size();++i)
      	{
      		out<<name.c_str()<<"".""<<i<<""=matrix( c("";
      		(*this)<<feats[i];
      		out<<""), nrow = ""<<feats[i].nr()<<"", ncol = ""<< feats[i].nc() <<"", byrow = TRUE)""<<std::endl;
      	}
      	return out;
     }

    template<>
    template <typename T>
    std::ostream& print_fhog_as_csv_helper<true>::operator<< (
        const dlib::array2d<T>& m
     )
     {
     	typedef typename dlib::array2d<T>::row row_type;
     	//std::cout<<""feats.size()=""<<feats.size() << std::endl;
     	for(int k =0;k<m.nr();++k)
     	{
     		row_type row = m[k];
     		for(int l=0;l<m.nc();++l)
     			if(k == (m.nr()-1) && l == (m.nc()-1))
     				out<<row[l]<<"" "";
     			else
     				out<<row[l]<<"", "";
 			out<<std::endl;
     	}
         return out;
     }

    template<>
    template <>
    std::ostream& print_fhog_as_csv_helper<true>::operator<< (
        const dlib::array2d<unsigned char>& m
     )
     {
     	typedef typename dlib::array2d<unsigned char>::row row_type;
     	//std::cout<<""feats.size()=""<<feats.size() << std::endl;
     	for(int k =0;k<m.nr();++k)
     	{
     		row_type row = m[k];
     		for(int l=0;l<m.nc();++l)
     		{
     			unsigned char u8= row[l];
     			unsigned int u16 =(unsigned int) u8;
     			out<<u16;
     			if(k == (m.nr()-1) && l == (m.nc()-1))
     				out<<"" "";
     			else
     				out<<"", "";
     		}
 			out<<std::endl;
     	}
         return out;
     }

    template<>
    template <typename T>
    std::ostream& print_fhog_as_csv_helper<false>::operator<< (
         const dlib::array<dlib::array2d<T> >& feats
     )
     {
     	std::cout<<""feats.size()=""<<feats.size() << std::endl;
     	for(int i=0;i<feats.size();++i)
     	{
     		std::cout<<""feats[""<<i<<""]=""<<feats[i].nc()<<""x""<<feats[i].nr()<< std::endl;
        }
         return out;
     }

    template<>
    template <typename T>
    std::ostream& print_fhog_as_csv_helper<false>::operator<< (
        const dlib::array2d<T>& m
     )
     {}

    class print_fhog_short {};
    const print_fhog_short fhog_info      = print_fhog_short();
    inline print_fhog_as_csv_helper<false> operator<< (
        std::ostream& out,
        const print_fhog_short&
    )
    {
        return print_fhog_as_csv_helper<false>(out);
    }

    class print_fhog_verbose {};
    const print_fhog_verbose fhog_csv      = print_fhog_verbose();
    inline print_fhog_as_csv_helper<true> operator<< (
        std::ostream& out,
        const print_fhog_verbose&
    )
    {
        return print_fhog_as_csv_helper<true>(out);
    }



    template <
        //typename pyramid_type,
        typename image_type
       ,typename feature_extractor_type
        >
    void show_image_ (
    	 dlib::image_window& win
        ,const image_type& img
        ,const feature_extractor_type& fe
		,dlib::array<dlib::array2d<float> >& feats
		,int cell_size
		,int filter_rows_padding
		,int filter_cols_padding

    )
    {
        win.clear_overlay();
        win.set_image(img);
//        dlib::image_window winhog(draw_fhog(feats,7));
       // call_stack<<""#Image size:  ""<<img.nc()<<""x""<<img.nr()<<std::endl;
        std::cout<<""Image size: ""<<img.nc()<<""x""<<img.nr()<<std::endl;
        std::cout<<""cell_size: ""<<cell_size<<std::endl;
        std::cout<<""filter_rows_padding: ""<<filter_rows_padding<<std::endl;
        std::cout<<""filter_cols_padding: ""<<filter_cols_padding<<std::endl;
        logFile rScript(""fhog"",img.nc(),img.nr());
        rScript<<fhog_csv<<""feature""<<feats;
        {

			utils::logFile rScript(""image"",img.nc(),img.nr());
    		std::stringstream name(""img_"",std::ios_base::out|std::ios_base::ate);
    		name<<img.nc()<<""_""<<img.nr();
        	rScript<<r_matrix<<name.str()<<img;
        }
        //std::cout<<fhog_info<<feats;
        //std::cout<<""Press enter to continue..""<<std::endl;
        //std::cin.get();

    }
}//namespace
#endif
",fileName
42,"       const int ROJO = 11;      
    const int AMBAR = 10;         
    const int VERDE = 9;
    const int BLANCO = 6;

    
  
    void setup()
    {
    pinMode(ROJO, OUTPUT);      // pinMode es una función que define un pin como entrada o salida. Ponemos 
    pinMode(AMBAR, OUTPUT);    // pinMode( [el pin sobre el que queremos actuar], INPUT (entrada) / OUTPUT (salida)
    pinMode(VERDE, OUTPUT);
    pinMode(BLANCO, OUTPUT);
    }
    
    
    void loop()
     
    {
    int  [MASK]  = 1000;
      
      digitalWrite(ROJO, HIGH);
      digitalWrite(AMBAR, HIGH);
      digitalWrite(VERDE, HIGH);
      digitalWrite(BLANCO, HIGH);
      delay( [MASK] );
      digitalWrite(ROJO, LOW);
      digitalWrite(AMBAR, LOW);
      digitalWrite(VERDE, LOW);
      digitalWrite(BLANCO, LOW);
      delay( [MASK] );
    }
",Tiempo
43,"#include""InfinityPCH.h""

#ifdef INFINITY_WINDOWS

#include""platform/windows/WindowsContext.h""

#include""platform/windows/WindowsWindow.h""

#include""Rasterizer.h""

constexpr const static D3D11_COMPARISON_FUNC COMPARISON_FUNCS[] =
{
	D3D11_COMPARISON_LESS,
	D3D11_COMPARISON_LESS_EQUAL,
	D3D11_COMPARISON_GREATER,
	D3D11_COMPARISON_GREATER_EQUAL,
	D3D11_COMPARISON_NEVER,
	D3D11_COMPARISON_ALWAYS
};

namespace Infinity
{
	Resource<ContextSettings> ContextSettings::CreateContextSettings()
	{
		return ResourceCast<ContextSettings>(MakeResource<WindowsContextSettings>());
	}

	WindowsContextSettings::WindowsContextSettings():
		m_depth_stencil_state(nullptr)
	{}

	WindowsContextSettings::~WindowsContextSettings()
	{
		if (m_depth_stencil_state)
		{
			m_depth_stencil_state->Release();
		}
	}

	bool WindowsContextSettings::Init(DepthMode depth_mode)
	{
		Resource<WindowsContext> context = ResourceCast<WindowsContext>(Window::GetContext());

		D3D11_DEPTH_STENCIL_DESC ds_desc = {};
		ds_desc.DepthEnable = true;
		ds_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
		ds_desc.DepthFunc = COMPARISON_FUNCS[(unsigned int)depth_mode];

		ds_desc.StencilEnable = true;
		ds_desc.StencilReadMask = 0xff;
		ds_desc.StencilWriteMask = 0xff;

		ds_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
		ds_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
		ds_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
		ds_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;

		ds_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
		ds_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
		ds_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
		ds_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;

		if (FAILED(context->GetDevice()->CreateDepthStencilState(&ds_desc, &m_depth_stencil_state)))
		{
			INFINITY_CORE_ERROR(""Error creating depth stencil state"");
			return false;
		}

		return true;
	}

	WindowsContext::WindowsContext(const Resource<Window> &window, ID3D11Device *device, ID3D11DeviceContext *device_context):
		Context(window),
		m_device(device),
		m_device_context(device_context),
		m_render_target_view(nullptr),
		m_depth_stencil_view(nullptr),
		m_clear_color{ 0.0f, 0.0f, 0.0f, 1.0f }
	{}

	WindowsContext::~WindowsContext()
	{}

	bool WindowsContext::Init()
	{
		auto  [MASK]  = ContextSettings::CreateContextSettings();

		if (! [MASK] ->Init())
		{
			INFINITY_CORE_ERROR(""Error initializing default context settings"");
			return false;
		}

		SetContextSettings( [MASK] );

		m_def_rasterizer = Infinity::Rasterizer::CreateRasterizer();

		if (!m_def_rasterizer->Init(Rasterizer::RasterizerParams()))
		{
			INFINITY_CORE_ERROR(""Error initializing default rasterizer"");
			return false;
		}

		m_def_rasterizer->Bind();

		return true;
	}

	bool WindowsContext::Resize(ID3D11RenderTargetView *render_target_view, ID3D11DepthStencilView *depth_stencil_view, unsigned int width, unsigned int height)
	{
		m_render_target_view = render_target_view;
		m_depth_stencil_view = depth_stencil_view;

		m_device_context->OMSetRenderTargets(1, &m_render_target_view, m_depth_stencil_view);

		D3D11_VIEWPORT viewport = {};
		viewport.TopLeftX = 0.0f;
		viewport.TopLeftY = 0.0f;
		viewport.Width = (float)width;
		viewport.Height = (float)height;

		viewport.MinDepth = 0.0f;
		viewport.MaxDepth = 1.0f;

		m_device_context->RSSetViewports(1, &viewport);

		return true;
	}

	void WindowsContext::SetClearColor(float r, float g, float b, float a)
	{
		m_clear_color[0] = r;
		m_clear_color[1] = g;
		m_clear_color[2] = b;
		m_clear_color[3] = a;
	}

	void WindowsContext::Clear()
	{
		if (m_device_context)
		{
			if (m_render_target_view)
			{
				m_device_context->ClearRenderTargetView(m_render_target_view, m_clear_color);
			}
			else
			{
				INFINITY_CORE_ERROR(""Error clearing context: Render target view is null."");
			}

			if (m_depth_stencil_view)
			{
				m_device_context->ClearDepthStencilView(m_depth_stencil_view, D3D11_CLEAR_DEPTH, 1.0f, 0x00);
			}
			else
			{
				INFINITY_CORE_ERROR(""Error clearing context: Depth stencil view is null."");
			}
		}
		else
		{
			INFINITY_CORE_ERROR(""Error clearing context: Device context is null."");
		}
	}

	void WindowsContext::SetContextSettings(const Resource<ContextSettings> &settings)
	{
		m_settings = settings;

		m_device_context->OMSetDepthStencilState(ResourceCast<WindowsContextSettings>(settings)->m_depth_stencil_state, 1);
	}

	ID3D11Device *WindowsContext::GetDevice() const { return m_device; }
	ID3D11DeviceContext *WindowsContext::GetDeviceContext() const { return m_device_context; }
}

#endif // INFINITY_WINDOWS",def_settings
44,"/*
 * Copyright © 2021 <NAME>. All rights reserved.
 * Contacts: <<EMAIL>>
 * Licensed under the Apache License, Version 2.0
 */

template<typename T, typename V>
// V type already has the const specifier.
auto Config::apply(const Key t_key, V  [MASK] , const bool t_save_file) -> bool {
  using namespace std;

  string val_str;
  if constexpr (is_arithmetic_v<T>) {
    val_str = to_string( [MASK] );
  } else if constexpr (is_enum_v<T>) {
    val_str = to_string(static_cast<int>( [MASK] ));
  } else {
    val_str =  [MASK] ;
  }

  if constexpr (is_same_v<T, fcli::Theme::Name>) {
    try {
      fcli::Theme::set_theme( [MASK] );
    } catch (...) {
      return false;
    }
  }

  const string node_name(get_key_name(t_key));
  auto node{m_root_node.child(node_name.c_str())};
  if (!node) {
    if (!(node = m_root_node.append_child(node_name.c_str()))) {
      return false;
    }
  }
  if (!node.text().set(val_str.c_str())) {
    return false;
  }
  if (t_save_file) {
    return save();
  }
  return true;
}

template<typename T>
auto Config::get(const Key t_key) const -> std::optional<T> {
  using namespace std;
  optional<T> val;

  const auto node{m_root_node.child(string(get_key_name(t_key)).c_str())};
  if (node) {
    const auto text{node.text()};

    if constexpr (is_enum_v<T>) {
      val = static_cast<T>(text.as_int());
    } else if constexpr (is_same_v<T, bool>) {
      val = text.as_bool();
    } else if constexpr (is_same_v<T, int> || is_same_v<T, short>) {
      val = text.as_int();
    } else if constexpr (is_same_v<T, unsigned> ||
                         is_same_v<T, unsigned short>) {
      val = text.as_uint();
    } else {
      val = text.get();
    }
  }
  return val;
}
",t_val
45,"


#include ""RtAudio.h""
#include <iostream>
#include <cstdlib>

// Two-channel sawtooth wave generator.
int saw(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,
	double streamTime, RtAudioStreamStatus status, void *userData)
{
	unsigned int i, j;
	short *buffer = (short *)outputBuffer;
	short *lastValues = (short *)userData;
	if (status)
		std::cout << ""Stream underflow detected!"" << std::endl;
	// Write interleaved audio data.
	/*
	for (i = 0; i<nBufferFrames; i++) {
		for (j = 0; j<2; j++) {
			*buffer++ = lastValues[j];
			lastValues[j] += 0.005 * (j + 1 + (j*0.1));
			if (lastValues[j] >= 1.0) lastValues[j] -= 2.0;
		}
	}
	*/
	memcpy(outputBuffer, inputBuffer, 4 * nBufferFrames);
	return 0;
}

int main()
{
	RtAudio dac;

	//std::cout << dac.getDeviceCount() << std::endl;   //2
	if (dac.getDeviceCount() < 1) {
		std::cout << ""\nNo audio devices found!\n"";
		exit(0);
	}
	RtAudio::StreamParameters  [MASK] ;
	//std::cout << dac.getDefaultOutputDevice() << std::endl;
	 [MASK] .deviceId = dac.getDefaultOutputDevice();    //0
	 [MASK] .nChannels = 2;
	 [MASK] .firstChannel = 0;
	unsigned int sampleRate = 44100;
	unsigned int bufferFrames = 256; // 256 sample frames

	RtAudio::StreamParameters input;
	input.deviceId = dac.getDefaultInputDevice();
	input.nChannels = 2;
	input.firstChannel = 0;

	double data[2];
	try {
		dac.openStream(& [MASK] , &input, RTAUDIO_SINT16,
			sampleRate, &bufferFrames, &saw, (void *)&data);
		dac.startStream();
	}
	catch (RtAudioError& e) {
		e.printMessage();
		exit(0);
	}

	char input1;
	std::cout << ""\nPlaying ... press <enter> to quit.\n"";
	std::cin.get(input1);
	
	try {
		// Stop the stream
		dac.stopStream();
	}
	catch (RtAudioError& e) {
		e.printMessage();
	}
	if (dac.isStreamOpen()) dac.closeStream();
	system(""pause"");
	
	return 0;
}





/*

#include ""RtAudio.h""
#include <iostream>

using namespace std;

typedef signed short MY_TYPE;
#define FORMAT RTAUDIO_SINT16

int inout(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,
	double , RtAudioStreamStatus status, void *data)
{
	// Since the number of input and output channels is equal, we can do
	// a simple buffer copy operation here.
	if (status) std::cout << ""Stream over/underflow detected."" << std::endl;

	unsigned int *bytes = (unsigned int *)data;
	memcpy(outputBuffer, inputBuffer, *bytes);
	return 0;
}

int main()
{
	unsigned int channels = 2;
	unsigned int fs = 44100;
	unsigned int bufferBytes = 0;
	unsigned int oDevice = 0;
	unsigned int iDevice = 0;
	unsigned int iOffset = 0;
	unsigned int oOffset = 0;

	RtAudio adac;
	if (adac.getDeviceCount() < 1) {
		cout << ""\nNo audio devices found!\n"";
		exit(-1);
	}

	adac.showWarnings(true);

	unsigned int bufferFrames = 441;
	RtAudio::StreamParameters iParams, oParams;
	iParams.deviceId = adac.getDefaultInputDevice();
	iParams.nChannels = channels;
	iParams.firstChannel = iOffset;
	oParams.deviceId = adac.getDefaultOutputDevice();
	oParams.nChannels = channels;
	oParams.firstChannel = oOffset;

	try {
		adac.openStream(&oParams, &iParams, RTAUDIO_SINT16, fs, &bufferFrames, &inout, (void *)&bufferBytes);
	}
	catch (RtAudioError& e) {
		std::cout << '\n' << e.getMessage() << '\n' << std::endl;
		exit(1);
	}

	bufferBytes = bufferFrames * channels * sizeof(MY_TYPE);

	// Test RtAudio functionality for reporting latency.
	std::cout << ""\nStream latency = "" << adac.getStreamLatency() << "" frames"" << std::endl;

	try {
		adac.startStream();

		char input;
		std::cout << ""\nPlaying ... press <enter> to quit (buffer frames = "" << bufferFrames << "").\n"";
		std::cin.get(input);

		// Stop the stream.
		adac.stopStream();
	}
	catch (RtAudioError& e) {
		std::cout << '\n' << e.getMessage() << '\n' << std::endl;
		goto cleanup;
	}

cleanup:
	if (adac.isStreamOpen()) adac.closeStream();

	return 0;

	return 0;
}


*/",parameters
46,"#include ""CalibrationController.h""

void CalibrationController::init(float sampleRate) {
    ParameterizedController::init(sampleRate);
    interface.init();
    interface.focusOutput();
    init();
}

void CalibrationController::init() {
    Serial.println(""Calibration"");
    for(int i = 0; i < 8; i++) {
        Hardware::hw.cvOutputPins[i]->analogWrite(0);
    }

    interface.render();
    startCalibrate();
}

int CalibrationController::cycleParameter(int amount) {
    parameters.cycle(amount);

    switch(parameters.getSelectedIndex()) {
        case Parameter::VALUE:
            interface.focusValue();
            break;
    }

    return parameters.getSelectedIndex(); 
}

void CalibrationController::cycleValue(int amount) {
    parameters.getSelected().cycle(amount);
    switch(parameters.getSelectedIndex()) {
        case Parameter::VALUE:
            setValue(amount);
            break;
    }
}

void CalibrationController::selectValue() {
    Serial.println(""Reset"");
    calibration.reset();
    startCalibrate();
}

void CalibrationController::setOutput(uint8_t output) {
    saveCalibration();
    currentOutput = output;
    startCalibrate();
}

void CalibrationController::setValue(int8_t amount) {
    if(currentVoltage == 0) {
        calibration.offset(-amount);
    } else {
        calibration.scale(-amount);
    }
    updateOutput();
}

void CalibrationController::update() {
    if(octaveInput.update()) {
        currentVoltage = octaveInput.getIntValue();
        updateOutput();
    }

    if(channelInput.update()) {
        setOutput(channelInput.getIntValue());
    }
}

void CalibrationController::startCalibrate() {
    calibration.calibratePin(Hardware::hw.cvOutputPins[currentOutput]);
    updateOutput();
    interface.setOutput(currentOutput);
}

void CalibrationController::saveCalibration() {
    Hardware::hw.cvOutputPins[currentOutput]->saveCalibration();
}

void CalibrationController::updateOutput() {
    uint16_t  [MASK]  = calibration.convertReverse(currentVoltage);
    Hardware::hw.cvOutputPins[currentOutput]->analogWrite(currentVoltage);
    interface.setVoltage(currentVoltage);
    interface.setValue( [MASK] );
    interface.setOffset(calibration.getDigitalOffset());
    interface.setScale(calibration.getDigitalScale());

    // Serial.print(calibration.getDigitalOffset());
    // Serial.print(calibration.getDigitalScale());
}

void CalibrationController::process() {
}",binaryValue
47,"/*

*********************************
* Created 23 November 2013      *
* Copyright 2013, <NAME> *
* http://saikoled.com           *
* Licensed under GPL3           *
*********************************

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.

This program 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 General Public License for more details.

A copy of the GNU General Public License can be found at
http://www.gnu.org/licenses/gpl.html

This software implements 4x 16-bit PWM with a fully saturated and
color corrected fading algorithm in HSI color space, and
HSI -> RGBW conversion to allow for better pastel color if desired.

It also implements an parabolic mapping for LED desired
brightness to actual output RGB value.

*/

#include <Arduino.h>

#include ""debug.h""
#include ""loop.h""
#include <abus/ABus.h>
#include ""rgbled.h""

#include <plugins.h>
#include MCU_HEADER(rgbled)

#include <math.h>
#define DEG_TO_RAD_FUNC(X) (M_PI*(X)/180)

#define steptime 1
#define saturation 0.3
#define hue_increment 0.01

int whitevalue;

struct HSI {
  float h;
  float s;
  float i;
} color;

void updatehue();
void updatesaturation();
void sendcolor();
void hsi2rgbw(float H, float S, float I, int* rgbw);

void init_plugin_rgbled()  {
  init_pwm();

  color.h = 0;
  color.s = saturation;
  color.i = 1;

  sendcolor();
/*
  // Initial color = off, hue of red fully saturated.
  while (color.i < 1) {
    sendcolor();
    color.i = color.i + 0.001; // Increase Intensity
    updatehue();
    updatesaturation();
    delay (steptime);
  }
*/
	ABus.subscribe([&] (const uint16_t  [MASK] , const void* pArg) {
		// handle message
		switch( [MASK] ) {
			case MSG_LOOP_TICK:
				sendcolor();
				updatehue();
				updatesaturation();
				break;
			case MSG_RGBLED_ON:
				LOG_INFO(""MSG_RGBLED_ON"");
				color.i = 1;
				sendcolor();
				break;
			case MSG_RGBLED_OFF:
				LOG_INFO(""MSG_RGBLED_OFF"");
				color.i = 0;
				sendcolor();
				break;
		}
	});
}

void updatehue() {
  color.h = color.h + hue_increment;
}

void updatesaturation() {
  color.s = saturation;
}

void sendcolor() {
  int rgb[3];
  while (color.h >=360) color.h = color.h - 360;
  while (color.h < 0) color.h = color.h + 360;
  if (color.i > 1) color.i = 1;
  if (color.i < 0) color.i = 0;
  if (color.s > 1) color.s = 1;
  if (color.s < 0) color.s = 0;
  // Fix ranges (somewhat redundantly).
  hsi2rgbw(color.h, color.s, color.i, rgb);
  RED = rgb[0];
  GREEN = rgb[1];
  BLUE = rgb[2];
}

void hsi2rgbw(float H, float S, float I, int* rgbw) {
  float r, g, b, w;
  float cos_h, cos_1047_h;
  H = fmod(H,360); // cycle H around to 0-360 degrees
  H = 3.14159*H/(float)180; // Convert to radians.
  S = S>0?(S<1?S:1):0; // clamp S and I to interval [0,1]
  I = I>0?(I<1?I:1):0;

  // This section is modified by the addition of white so that it assumes
  // fully saturated colors, and then scales with white to lower saturation.
  //
  // Next, scale appropriately the pure color by mixing with the white channel.
  // Saturation is defined as ""the ratio of colorfulness to brightness"" so we will
  // do this by a simple ratio wherein the color values are scaled down by (1-S)
  // while the white LED is placed at S.

  // This will maintain constant brightness because in HSI, R+B+G = I. Thus,
  // S*(R+B+G) = S*I. If we add to this (1-S)*I, where I is the total intensity,
  // the sum intensity stays constant while the ratio of colorfulness to brightness
  // goes down by S linearly relative to total Intensity, which is constant.

  if(H < 2.09439) {
    cos_h = cos(H);
    cos_1047_h = cos(1.047196667-H);
    r = S*I/3*(1+cos_h/cos_1047_h);
    g = S*I/3*(1+(1-cos_h/cos_1047_h));
    b = 0;
    w = (1-S)*I;
  } else if(H < 4.188787) {
    H = H - 2.09439;
    cos_h = cos(H);
    cos_1047_h = cos(1.047196667-H);
    g = S*I/3*(1+cos_h/cos_1047_h);
    b = S*I/3*(1+(1-cos_h/cos_1047_h));
    r = 0;
    w = (1-S)*I;
  } else {
    H = H - 4.188787;
    cos_h = cos(H);
    cos_1047_h = cos(1.047196667-H);
    b = S*I/3*(1+cos_h/cos_1047_h);
    r = S*I/3*(1+(1-cos_h/cos_1047_h));
    g = 0;
    w = (1-S)*I;
  }

  // Mapping Function from rgbw = [0:1] onto their respective ranges.
  // For standard use, this would be [0:1]->[0:0xFFFF] for instance.

  // Here instead I am going to try a parabolic map followed by scaling.
  rgbw[0]=0xFFFF*r*r;
  rgbw[1]=0xFFFF*g*g;
  rgbw[2]=0xFFFF*b*b;
//  rgbw[3]=0xFFFF*w*w;
}

// source: http://museinfo.sapp.org/examples/humdrum/keyscape2.cpp
void hsi2rgb(float H, float S, float I, int* rgb) {
   float r;
   float g;
   float b;

   if (H < 1.0/3.0) {
      b = (1-S)/3;
      r = (1+S*cos(2*PI*H)/cos(PI/3-2*PI*H))/3.0;
      g = 1 - (b + r);
   } else if (H < 2.0/3.0) {
      H = H - 1.0/3.0;
      r = (1-S)/3;
      g = (1+S*cos(2*PI*H)/cos(PI/3-2*PI*H))/3.0;
      b = 1 - (r+g);
   } else {
      H = H - 2.0/3.0;
      g = (1-S)/3;
      b = (1+S*cos(2*PI*H)/cos(PI/3-2*PI*H))/3.0;
      r = 1 - (g+b);
   }

   rgb[0] = (int)((I * r * 3)+.5);
   rgb[1] = (int)((I * g * 3)+.5);
   rgb[2] = (int)((I * b * 3)+.5);
}

",msgId
48,"#include ""util/get_config_path.hpp""
#include <toml++/toml.h>

#include <sys/stat.h>
#include <sys/types.h>

#include <chrono>
#include <ctime>
#include <iostream>
#include <span>

auto does_file_exist(std::string const& filename) {
  struct stat  [MASK] ;
  return (stat(filename.c_str(), & [MASK] ) == 0);
}

auto main(int argc, const char* argv[]) -> int {
  auto args = std::span(argv, argc);

  // TODO(tybl): Replace hardcoded app name with string generated by cmake
  auto config_path = tybl::util::get_config_path(""jrny"");
  config_path /= ""config.toml"";
  if (!does_file_exist(config_path.native())) {
    std::cerr << ""Error: "" << config_path.native() << "" does not exist.\n"";
    std::cerr << ""Please create a config file.\n"";
    return -1;
  }
  auto config = toml::parse_file(config_path.native());

  // TODO(tybl): Start output with the current date/time
  auto now = std::chrono::system_clock::now();
  const std::time_t t_c = std::chrono::system_clock::to_time_t(now);
  std::cout << std::put_time(std::localtime(&t_c), ""%F %T:"");
  for (auto arg : args) {
    std::cout << "" "" << arg;
  }
  std::string filename = config[""journal""][""filename""].value_or("""");
  std::cout << "" > "" << filename << std::endl;
  return 0;
}
",buffer
49,"//
// Created by <NAME> on 14/06/2021.
//
#include ""Hospital.hpp""
#include <string>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <windows.h>
#include <list>

Hospital::Hospital() {
}

Pila *pila = new Pila();
list<string> ListaR;
list<string> ListaN;
list<string> ListaV;
list<string> ListaA;
list<string> ListaTemp;

std::string Hospital::inputDni() {
    std::string dniCliente;
    std::cout << ""Introduce el DNI del paciente a dar de alta:"" << endl;
    std::cin >> dniCliente;
    return dniCliente;
}

//CASE0:
void Hospital::altaPacientes(Pila &pilaPacientes, Pila &pilaPacientesTemp) {

    char lista = 'S';
    while (!pilaPacientes.esVacia() && lista != 'X') {
        string valorFecha = """";
        SYSTEMTIME fecha;
        GetSystemTime(&fecha);
        int datoId = pilaPacientes.devolverId();
        std::string datoDni = (std::string)(pilaPacientes.devolverDni()).c_str();
        std::string datoNombre = (std::string)(pilaPacientes.devolverNombre()).c_str();
        std::string datoAp1 = (std::string)(pilaPacientes.devolverApellido1()).c_str();
        std::string datoAp2 = (std::string)(pilaPacientes.devolverApellido2()).c_str();
        int datoEdad = pilaPacientes.devolverEdad();
        char datoSexo = pilaPacientes.devolverSexo();
        std::cout << ""ID: "" << datoId << endl;
        std::cout << ""DNI: "" << datoDni << endl;
        std::cout << ""Nombre: "" << datoNombre << endl;
        std::cout << ""Primer apellido: "" << datoAp1 << endl;
        std::cout << ""Segundo apellido: "" << datoAp2 << endl;
        std::cout << ""Edad: "" << datoEdad << endl;
        std::cout << ""Sexo: "" << datoSexo << endl;
        do {
            std::cout << ""Introduce una lista de emergencias(A/N/V/R). Pulsa X (mayúscula) para terminar con el proceso de alta:"" << endl;
            std::cin >> lista;
            if (lista == 'A') {
                pilaPacientes.mostrar(false);
                valorFecha =
                        to_string(fecha.wYear) + ""/"" + to_string(fecha.wMonth) + ""/"" + to_string(fecha.wDay) + "" "" +
                        to_string(fecha.wHour + 1) + "":"" + to_string(fecha.wMinute) + "":"" + to_string(fecha.wSecond);
                ListaA.push_back(to_string(datoId));
                ListaA.push_back(datoDni);
                ListaA.push_back(valorFecha);
            } else if (lista == 'V') {
                pilaPacientes.mostrar(false);
                valorFecha =
                        to_string(fecha.wYear) + ""/"" + to_string(fecha.wMonth) + ""/"" + to_string(fecha.wDay) + "" "" +
                        to_string(fecha.wHour + 1) + "":"" + to_string(fecha.wMinute) + "":"" + to_string(fecha.wSecond);
                ListaV.push_back(to_string(datoId));
                ListaV.push_back(datoDni);
                ListaV.push_back(valorFecha);
            } else if (lista == 'R') {
                pilaPacientes.mostrar(false);
                valorFecha =
                        to_string(fecha.wYear) + ""/"" + to_string(fecha.wMonth) + ""/"" + to_string(fecha.wDay) + "" "" +
                        to_string(fecha.wHour + 1) + "":"" + to_string(fecha.wMinute) + "":"" + to_string(fecha.wSecond);
                ListaR.push_back(to_string(datoId));
                ListaR.push_back(datoDni);
                ListaR.push_back(valorFecha);
            } else if (lista == 'N') {
                pilaPacientes.mostrar(false);
                valorFecha =
                        to_string(fecha.wYear) + ""/"" + to_string(fecha.wMonth) + ""/"" + to_string(fecha.wDay) + "" "" +
                        to_string(fecha.wHour + 1) + "":"" + to_string(fecha.wMinute) + "":"" + to_string(fecha.wSecond);
                ListaN.push_back(to_string(datoId));
                ListaN.push_back(datoDni);
                ListaN.push_back(valorFecha);
            } else if (lista != 'X') {
                std::cout << ""La lista introducida es incorrecta"" << endl;
            }
        } while (lista != 'A' && lista != 'V' && lista != 'N' && lista != 'R' && lista != 'X');
    }
    pilaPacientesTemp = pilaPacientes;


}

//CASE1:
void Hospital::bajaPacientes(Pila &pilaPacientes, Pila &pilaPacientesTemp) {
    std::string dni = inputDni();
    while (!pilaPacientesTemp.esVacia()) {
        pilaPacientesTemp.mostrar(false);
    }
    pilaPacientes.eliminarElemento(pilaPacientesTemp, pilaPacientes);
    int contar1;
    contar1 = 0;

    for (string valor : ListaR) {
        if (contar1 > 0) {
            contar1++;
        }
        if (valor == dni) {
            contar1++;
            ListaTemp.pop_back(); //Lee y elimina el elemento por detras
        }
        if (contar1 == 0) {
            ListaTemp.push_back(valor); //Introduce el elemento por el final
        }
        if (contar1 == 2) {
            contar1 = 0;
        }
    }
    ListaR = ListaTemp;
    ListaTemp.clear(); //Elimina todos los elementos
    contar1 = 0;
    for (string valor : ListaN) {
        if (contar1 > 0) {
            contar1++;
        }
        if (valor == dni) {
            contar1++;
            ListaTemp.pop_back();
        }
        if (contar1 == 0) {
            ListaTemp.push_back(valor);
        }
        if (contar1 == 2) {
            contar1 = 0;
        }
    }
    ListaN = ListaTemp;
    ListaTemp.clear();
    contar1 = 0;
    for (string valor : ListaV) {
        if (contar1 > 0) {
            contar1++;
        }
        if (valor == dni) {
            contar1++;
            ListaTemp.pop_back();
        }
        if (contar1 == 0) {
            ListaTemp.push_back(valor);
        }
        if (contar1 == 2) {
            contar1 = 0;
        }
    }
    ListaV = ListaTemp;
    ListaTemp.clear();
    contar1 = 0;
    for (string valor : ListaA) {
        if (contar1 > 0) {
            contar1++;
        }
        if (valor == dni) {
            contar1++;
            ListaTemp.pop_back();
        }
        if (contar1 == 0) {
            ListaTemp.push_back(valor);
        }
        if (contar1 == 2) {
            contar1 = 0;
        }
    }
    ListaA = ListaTemp;
    ListaTemp.clear();


}

//CASE2:
void Hospital::reasignacionListaEmergencia() {
    string valorFec = """";
    SYSTEMTIME fec;
    GetSystemTime(&fec);
    std::string dni = inputDni();
    char listaEmergencia;
    do {
        std::cout << ""Introduce la lista de emergencia (R/N/V/A) en la que el paciente está asignado :"" << endl;
        std::cin >> listaEmergencia;
        if (listaEmergencia != 'R' && listaEmergencia != 'N' && listaEmergencia != 'V' && listaEmergencia != 'A') {
            std::cout << ""La lista introducida no es correcta"" << endl;
        }
    } while (listaEmergencia != 'R' && listaEmergencia != 'N' && listaEmergencia != 'V' && listaEmergencia != 'A');
    char nuevaLista;
    do {
        std::cout << ""Introduce la lista(R/N/V/A) en la que quieres reasignar al paciente:"" << endl;
        std::cin >> nuevaLista;
        if (nuevaLista != 'R' && nuevaLista != 'N' && nuevaLista != 'V' && nuevaLista != 'A') {
            std::cout << ""La lista introducida no es correcta"" << endl;
        }
    } while (nuevaLista != 'R' && nuevaLista != 'N' && nuevaLista != 'V' && nuevaLista != 'A');
    valorFec = to_string(fec.wYear) + ""/"" + to_string(fec.wMonth) + ""/"" + to_string(fec.wDay) + "" "" +
               to_string(fec.wHour + 1) + "":"" + to_string(fec.wMinute) + "":"" + to_string(fec.wSecond);
    int contar = 0;
    bool localizado = false;
    int cont1 = 0;
    int cont2 = 0;
    bool localizado2 = false;
    if (listaEmergencia == 'R') {
        for (string valor : ListaR) {
            if (contar > 0) {
                contar++;
            }
            if (valor == dni) {
                contar++;
                ListaTemp.pop_back();
                localizado = true;
            }
            if (contar == 0) {
                ListaTemp.push_back(valor);
            }
            if (contar == 2) {
                contar = 0;
            }
        }
        for (string valor : ListaR) {
            cont1++;
            localizado2 = false;
            for (string valor2 : ListaTemp) {
                if (valor == valor2) {
                    localizado2 = true;
                }
            }
            if (!localizado2 && cont1 < 3) {
                cont2++;
                if (nuevaLista == 'R') {
                    ListaR.push_back(valor);
                    if (cont2 == 2) {
                        ListaR.push_back(valorFec);
                    }
                } else if (nuevaLista == 'N') {
                    ListaN.push_back(valor);
                    if (cont2 == 2) {
                        ListaN.push_back(valorFec);
                    }
                } else if (nuevaLista == 'V') {
                    ListaV.push_back(valor);
                    if (cont2 == 2) {
                        ListaV.push_back(valorFec);
                    }
                } else if (nuevaLista == 'A') {
                    ListaA.push_back(valor);
                    if (cont2 == 2) {
                        ListaA.push_back(valorFec);
                    }
                }
            }
            if (cont1 == 3) {
                cont1 = 0;
            }
        }
        ListaR = ListaTemp;
        ListaTemp.clear();
    } else if (listaEmergencia == 'N') {
        for (string valor : ListaN) {
            if (contar > 0) {
                contar++;
            }
            if (valor == dni) {
                contar++;
                ListaTemp.pop_back();
                localizado = true;
            }
            if (contar == 0) {
                ListaTemp.push_back(valor);
            }
            if (contar == 2) {
                contar = 0;
            }
        }
        for (string valor : ListaN) {
            cont1++;
            localizado2 = false;
            for (string valor2 : ListaTemp) {
                if (valor == valor2) {
                    localizado2 = true;
                }
            }
            if (!localizado2 && cont1 < 3) {
                cont2++;
                if (nuevaLista == 'R') {
                    ListaR.push_back(valor);
                    if (cont2 == 2) {
                        ListaR.push_back(valorFec);
                    }
                } else if (nuevaLista == 'N') {
                    ListaN.push_back(valor);
                    if (cont2 == 2) {
                        ListaN.push_back(valorFec);
                    }
                } else if (nuevaLista == 'V') {
                    ListaV.push_back(valor);
                    if (cont2 == 2) {
                        ListaV.push_back(valorFec);
                    }
                } else if (nuevaLista == 'A') {
                    ListaA.push_back(valor);
                    if (cont2 == 2) {
                        ListaA.push_back(valorFec);
                    }
                }
            }
            if (cont1 == 3) {
                cont1 = 0;
            }
        }
        ListaN = ListaTemp;
        ListaTemp.clear();
    } else if (listaEmergencia == 'A') {
        for (string valor : ListaA) {
            if (contar > 0) {
                contar++;
            }
            if (valor == dni) {
                contar++;
                ListaTemp.pop_back();
                localizado = true;
            }
            if (contar == 0) {
                ListaTemp.push_back(valor);
            }
            if (contar == 2) {
                contar = 0;
            }
        }
        for (string valor : ListaA) {
            cont1++;
            localizado2 = false;
            for (string valor2 : ListaTemp) {
                if (valor == valor2) {
                    localizado2 = true;
                }
            }
            if (!localizado2 && cont1 < 3) {
                cont2++;
                if (nuevaLista == 'R') {
                    ListaR.push_back(valor);
                    if (cont2 == 2) {
                        ListaR.push_back(valorFec);
                    }
                } else if (nuevaLista == 'N') {
                    ListaN.push_back(valor);
                    if (cont2 == 2) {
                        ListaN.push_back(valorFec);
                    }
                } else if (nuevaLista == 'V') {
                    ListaV.push_back(valor);
                    if (cont2 == 2) {
                        ListaV.push_back(valorFec);
                    }
                } else if (nuevaLista == 'A') {
                    ListaA.push_back(valor);
                    if (cont2 == 2) {
                        ListaA.push_back(valorFec);
                    }
                }
            }
            if (cont1 == 3) {
                cont1 = 0;
            }
        }
        ListaA = ListaTemp;
        ListaTemp.clear();
    } else if (listaEmergencia == 'V') {
        for (string valor : ListaV) {
            if (contar > 0) {
                contar++;
            }
            if (valor == dni) {
                contar++;
                ListaTemp.pop_back();
                localizado = true;
            }
            if (contar == 0) {
                ListaTemp.push_back(valor);
            }
            if (contar == 2) {
                contar = 0;
            }
        }
        for (string valor : ListaV) {
            cont1++;
            localizado2 = false;
            for (string valor2 : ListaTemp) {
                if (valor == valor2) {
                    localizado2 = true;
                }
            }
            if (!localizado2 && cont1 < 3) {
                cont2++;
                if (nuevaLista == 'R') {
                    ListaR.push_back(valor);
                    if (cont2 == 2) {
                        ListaR.push_back(valorFec);
                    }
                } else if (nuevaLista == 'N') {
                    ListaN.push_back(valor);
                    if (cont2 == 2) {
                        ListaN.push_back(valorFec);
                    }
                } else if (nuevaLista == 'V') {
                    ListaV.push_back(valor);
                    if (cont2 == 2) {
                        ListaV.push_back(valorFec);
                    }
                } else if (nuevaLista == 'A') {
                    ListaA.push_back(valor);
                    if (cont2 == 2) {
                        ListaA.push_back(valorFec);
                    }
                }
            }
            if (cont1 == 3) {
                cont1 = 0;
            }
        }
        ListaV = ListaTemp;
        ListaTemp.clear();
    }
    if (!localizado) {
        std::cout << ""El DNI introducido no se ha encontrado en la lista"" << endl;
    }
}

//CASE3:
void Hospital::menuOpcion3(Pila &pilaPacientes, Pila &pilaPacientesTemp) {
    int opc;
    bool comprobar = false;
    while (!comprobar) {
        comprobar = true;
        std::cout << ""Selecciona la opción que quieres ejecutar:"" << endl;
        std::cout << ""1. Consulta de pacientes."" << endl;
        std::cout << ""2. Consulta de emergencias."" << endl;
        std::cout << ""3. Mostrar tiempos de emergencia superados."" << endl;
        std::cin >> opc;
        if (opc == 1) {
            bool comprobar1 = false;
            int opcion1;
            Hospital *mostrar = new Hospital();
            while (!comprobar1) {
                comprobar1 = true;
                std::cout << ""Selecciona el tipo de consulta que quieres realizar:"" << endl;
                std::cout << ""1. Mostrar paciente indicando su DNI"" << endl;
                std::cout << ""2. Mostrar todos los pacientes"" << endl;
                std::cin >> opcion1;
                if (opcion1 < 1 || opcion1 > 2) {
                    comprobar1 = false;
                    std::cout << ""La opción seleccionada no es válida"" << endl;
                }
                if (opcion1 == 1) {
                    mostrar->verificarDni(pilaPacientes, pilaPacientesTemp);
                } else {
                    mostrar->mostrarTodos(pilaPacientes, pilaPacientesTemp);
                }
            }
        } else if (opc == 2) {
            bool comprobar2 = false;
            int opcion2;
            Hospital *mostrar = new Hospital();
            while (!comprobar2) {
                comprobar2 = true;
                std::cout << ""Elige un tipo de consulta:"" << endl;
                std::cout << ""1. Mostrar emergencia indicando su ID"" << endl;
                std::cout << ""2. Mostrar todas las emergencias"" << endl;
                std::cin >> opcion2;
                if (opcion2 < 1 || opcion2 > 2) {
                    comprobar2 = false;
                    std::cout << ""La opción introducida es correcta"" << endl;
                }
                if (opcion2 == 1) {
                    mostrar->verificarListasVacio();

                } else {
                    mostrar->mostrarEmergencias();

                }
            }
        } else if (opc == 3) {
            Hospital *mostrar = new Hospital();
            mostrar->consultarTiempos();

        } else {
            std::cout << ""La opcion introducida es incorrecta"" << endl;
            comprobar = false;
        }
    }
}

//CASE3.1.1
void Hospital::verificarDni(Pila &pilaPacientes, Pila &pilaPacientesTemp) {
    pilaPacientesTemp = pilaPacientes;
    string dni;
    std::cout << ""Introduce el DNI que desee verificar: "" << endl;
    std::cin >> dni;
    pilaPacientes.buscarDni(pilaPacientes, dni);
    pilaPacientes = pilaPacientesTemp;
}

//CASE3.1.2
void Hospital::mostrarTodos(Pila &pilaPacientes, Pila &pilaPacientesTemp) {
    pilaPacientesTemp = pilaPacientes;
    while (!pilaPacientes.esVacia()) {
        pilaPacientes.mostrar(true);
    }
    pilaPacientes = pilaPacientesTemp;
}

//CASE 3.2.1
void Hospital::verificarListasVacio() {
    int numElementos = 0;
    for (string valor : ListaR) {
        if (valor != """") {
            numElementos++;
        }
    }
    for (string valor : ListaA) {
        if (valor != """") {
            numElementos++;
        }
    }
    for (string valor : ListaV) {
        if (valor != """") {
            numElementos++;
        }
    }
    for (string valor : ListaN) {
        if (valor != """") {
            numElementos++;
        }
    }
    if (numElementos == 0) {
        std::cout << ""Las listas de emergencia estan vacias"" << endl;
    } else {
        verificarId();
    }

}

void Hospital::verificarId() {
    int id;
    bool encontrado = false;
    int contador = 0;
    while (!encontrado) {
        std::cout << ""Introduce el numero ID del paciente:"" << endl;
        std::cin >> id;
        for (string valor : ListaR) {
            if (valor == to_string(id)) {
                encontrado = true;
            }
            if (encontrado) {
                contador++;
            }
            if (contador == 2) {
                std::cout << valor << '\n';
                std::cout << ""El paciente indicado pertenece a la lista de emergencias R"" << endl;
            }
        }
        for (string valor : ListaA) {
            if (valor == to_string(id)) {
                encontrado = true;
            }
            if (encontrado) {
                contador++;
            }
            if (contador == 2) {
                std::cout << valor << '\n';
                std::cout << ""El paciente indicado pertenece a la lista de emergencias A"" << endl;
            }
        }
        for (string valor : ListaV) {
            if (valor == to_string(id)) {
                encontrado = true;
            }
            if (encontrado) {
                contador++;
            }
            if (contador == 2) {
                std::cout << valor << '\n';
                std::cout << ""El paciente indicado pertenece a la lista de emergencias V"" << endl;
            }
        }
        for (string valor : ListaN) {
            if (valor == to_string(id)) {
                encontrado = true;
            }
            if (encontrado) {
                contador++;
            }
            if (contador == 2) {
                std::cout << valor << '\n';
                std::cout << ""El paciente indicado pertenece a la lista de emergencias N"" << endl;
            }
        }
        if (!encontrado) {
            std::cout << ""El ID indicado no pertenece a ningún paciente. Verifique que el ID es correcto"" << endl;
        }
    }
}


//CASE 3.2.2
void Hospital::mostrarEmergencias() {
    int contador = 0;
    std::cout << ""Lista R:"" << endl;
    for (string valor : ListaR) {
        contador++;
        std::cout << valor << '\n';
        if (contador % 3 == 0) {
            std::cout << ""-----------"" << endl;
        }
    }
    std::cout << ""Lista N:"" << endl;
    for (string valor : ListaN) {
        contador++;
        std::cout << valor << '\n';
        if (contador % 3 == 0) {
            std::cout << ""-----------"" << endl;
        }
    }
    std::cout << ""Lista V:"" << endl;
    for (string valor : ListaV) {
        contador++;
        std::cout << valor << '\n';
        if (contador % 3 == 0) {
            std::cout << ""-----------"" << endl;
        }
    }
    std::cout << ""Lista A:"" << endl;
    for (string valor : ListaA) {
        contador++;
        std::cout << valor << '\n';
        if (contador % 3 == 0) {
            std::cout << ""-----------"" << endl;
        }
    }
}

//CASE 3.3
void Hospital::consultarTiempos() {
    string codi;
    string dn;
    string fec;
    int contPac;
    contPac = 0;
    string valorHora;
    string valorMinutos;
    string valorSegundos;
    string caracter;
    int numVariables = 0;
    int segTrans = 0;
    int minTrans = 0;
    int  [MASK]  = 0;
    SYSTEMTIME fecha1;
    GetSystemTime(&fecha1);
    int horaActual = fecha1.wHour + 1;
    int minutoActual = fecha1.wMinute;
    int segundoActual = fecha1.wSecond;
    std::cout << ""Lista R:"" << endl;
    for (string valor : ListaR) {
        contPac++;
        valorMinutos = """";
        valorSegundos = """";
        valorHora = """";
        if (contPac == 1) {
            codi = valor;
        } else if (contPac == 2) {
            dn = valor;
        } else if (contPac == 3) {
            fec = valor;
            numVariables = 0;
            contPac = 0;
            for (int i = 0; i < valor.size(); i++) {
                caracter = valor.substr(i, 1);
                if (caracter == ""/"" || caracter == "":"" || caracter == "" "") {
                    numVariables++;
                } else if (numVariables == 3) {
                    valorHora = valorHora + caracter;
                } else if (numVariables == 4) {
                    valorMinutos = valorMinutos + caracter;
                } else if (numVariables == 5) {
                    valorSegundos = valorSegundos + caracter;
                }
            }
            segTrans = segundoActual - atoi(valorSegundos.c_str());
            minTrans = minutoActual - atoi(valorMinutos.c_str());
             [MASK]  = horaActual - atoi(valorHora.c_str());
            if (segTrans < 0) {
                segTrans = segTrans + 60;
                minTrans = minTrans - 1;
            }
            if (minTrans < 0) {
                minTrans = minTrans + 60;
                 [MASK]  =  [MASK]  - 1;
            }
            if (segTrans != 0 || minTrans != 0 ||  [MASK]  != 0) {
                std::cout << codi << endl;
                std::cout << dn << endl;
                std::cout << fec << endl;
                std::cout << ""Tiempo transcurrido: "" <<  [MASK]  << "":"" << minTrans << "":"" << segTrans << endl;
            }
        }
    }

    std::cout << ""Lista N:"" << endl;
    for (string valor : ListaN) {
        contPac++;
        valorMinutos = """";
        valorSegundos = """";
        valorHora = """";
        if (contPac == 1) {
            codi = valor;
        } else if (contPac == 2) {
            dn = valor;
        } else if (contPac == 3) {
            fec = valor;
            numVariables = 0;
            contPac = 0;
            for (int i = 0; i < valor.size(); i++) {
                caracter = valor.substr(i, 1);
                if (caracter == ""/"" || caracter == "":"" || caracter == "" "") {
                    numVariables++;
                } else if (numVariables == 3) {
                    valorHora = valorHora + caracter;
                } else if (numVariables == 4) {
                    valorMinutos = valorMinutos + caracter;
                } else if (numVariables == 5) {
                    valorSegundos = valorSegundos + caracter;
                }
            }
            segTrans = segundoActual - atoi(valorSegundos.c_str());
            minTrans = minutoActual - atoi(valorMinutos.c_str());
             [MASK]  = horaActual - atoi(valorHora.c_str());
            if (segTrans < 0) {
                segTrans = segTrans + 60;
                minTrans = minTrans - 1;
            }
            if (minTrans < 0) {
                minTrans = minTrans + 60;
                 [MASK]  =  [MASK]  - 1;
            }
            if (minTrans > 15 || (minTrans == 15 && segTrans > 0)) {
                std::cout << codi << endl;
                std::cout << dn << endl;
                std::cout << fec << endl;
                std::cout << ""Tiempo transcurrido: "" <<  [MASK]  << "":"" << minTrans << "":"" << segTrans << endl;
            }
        }
    }

    std::cout << ""Lista A:"" << endl;
    for (string valor : ListaA) {
        contPac++;
        valorMinutos = """";
        valorSegundos = """";
        valorHora = """";
        if (contPac == 1) {
            codi = valor;
        } else if (contPac == 2) {
            dn = valor;
        } else if (contPac == 3) {
            fec = valor;
            numVariables = 0;
            contPac = 0;
            for (int i = 0; i < valor.size(); i++) {
                caracter = valor.substr(i, 1);
                if (caracter == ""/"" || caracter == "":"" || caracter == "" "") {
                    numVariables++;
                } else if (numVariables == 3) {
                    valorHora = valorHora + caracter;
                } else if (numVariables == 4) {
                    valorMinutos = valorMinutos + caracter;
                } else if (numVariables == 5) {
                    valorSegundos = valorSegundos + caracter;
                }
            }
            segTrans = segundoActual - atoi(valorSegundos.c_str());
            minTrans = minutoActual - atoi(valorMinutos.c_str());
             [MASK]  = horaActual - atoi(valorHora.c_str());
            if (segTrans < 0) {
                segTrans = segTrans + 60;
                minTrans = minTrans - 1;
            }
            if (minTrans < 0) {
                minTrans = minTrans + 60;
                 [MASK]  =  [MASK]  - 1;
            }
            if ( [MASK]  > 1 || ( [MASK]  == 1 && (minTrans > 0 || segTrans > 0))) {
                std::cout << codi << endl;
                std::cout << dn << endl;
                std::cout << fec << endl;
                std::cout << ""Tiempo transcurrido: "" <<  [MASK]  << "":"" << minTrans << "":"" << segTrans << endl;
            }
        }
    }

    std::cout << ""Lista V:"" << endl;
    for (string valor : ListaV) {
        contPac++;
        valorMinutos = """";
        valorSegundos = """";
        valorHora = """";
        if (contPac == 1) {
            codi = valor;
        } else if (contPac == 2) {
            dn = valor;
        } else if (contPac == 3) {
            fec = valor;
            numVariables = 0;
            contPac = 0;
            for (int i = 0; i < valor.size(); i++) {
                caracter = valor.substr(i, 1);
                if (caracter == ""/"" || caracter == "":"" || caracter == "" "") {
                    numVariables++;
                } else if (numVariables == 3) {
                    valorHora = valorHora + caracter;
                } else if (numVariables == 4) {
                    valorMinutos = valorMinutos + caracter;
                } else if (numVariables == 5) {
                    valorSegundos = valorSegundos + caracter;
                }
            }
            segTrans = segundoActual - atoi(valorSegundos.c_str());
            minTrans = minutoActual - atoi(valorMinutos.c_str());
             [MASK]  = horaActual - atoi(valorHora.c_str());
            if (segTrans < 0) {
                segTrans = segTrans + 60;
                minTrans = minTrans - 1;
            }
            if (minTrans < 0) {
                minTrans = minTrans + 60;
                 [MASK]  =  [MASK]  - 1;
            }
            if ( [MASK]  > 1) {
                std::cout << codi << endl;
                std::cout << dn << endl;
                std::cout << fec << endl;
                std::cout << ""Tiempo transcurrido: "" <<  [MASK]  << "":"" << minTrans << "":"" << segTrans << endl;
            }
        }
    }

}


//CASE 4
void Hospital::vaciarListas() {
    int cont;
    cont = 0;
    for (string valor : ListaN) {
        cont++;
    }
    for (int i = 0; i < cont; i++) {
        ListaN.pop_back();
    }
    cont = 0;
    for (string valor : ListaR) {
        cont++;
    }
    for (int i = 0; i < cont; i++) {
        ListaR.pop_back();

    }
    cont = 0;
    for (string valor : ListaA) {
        cont++;
    }
    for (int i = 0; i < cont; i++) {
        ListaA.pop_back();
    }
    cont = 0;
    for (string valor : ListaV) {
        cont++;
    }
    for (int i = 0; i < cont; i++) {
        ListaV.pop_back();
    }
}

Hospital::~Hospital() {
}
",horTrans
50,"#include <iostream>
#include ""Application.h""

//Include GLEW
#include <GL/glew.h>

//Include GLFW
#include <GLFW/glfw3.h>

//Include the standard C++ headers
#include <stdio.h>
#include <stdlib.h>
#include ""StartMenuScene.h""
#include ""OverworldScene.h""
#include ""DistrictScene.h""
#include ""MazeScene.h""
#include ""MartScene.h""
#include ""BeachScene.h""
#include ""SharkScene.h""
#include ""CarnivalScene.h""
#include ""PauseMenuScene.h""
#include ""WinnerScene.h""

GLFWwindow* m_window;
unsigned Application::FPS = 120; // FPS of this game
unsigned frameTime = 1000 / Application::FPS; // time for each frame
unsigned Application::m_width;
unsigned Application::m_height;
unsigned Application::ui_width;
unsigned Application::ui_height;
unsigned Application::sceneswitch;
unsigned Application::previousscene;
bool Application::restart;
bool Application::quit;

unsigned Player::ammo;
int Player::health;
int Player::money;
int Player::sword;
int Player::armourplate;
int Player::helmet;
bool Player::jetpackequipped;
bool Player::SharkSurvived;
bool Player::MazeComplete;
bool Player::BookPurchased;
bool Player::ShootingComplete;

unsigned Player::getAmmo() {
	return ammo;
}

int Player::getHealth() {
	return health;
}

int Player::getMoney() {
	return money;
}

int Player::getSword()
{
	return sword;
}

int Player::getArmourplate()
{
	return armourplate;
}

int Player::getHelmet()
{
	return helmet;
}

bool Player::getJetpack()
{
	return jetpackequipped;
}

bool Player::getSharkSurvived()
{
	return SharkSurvived;
}

bool Player::getMazeComplete()
{
	return MazeComplete;
}

bool Player::getBookPurchased()
{
	return BookPurchased;
}

bool Player::getShootingComplete()
{
	return ShootingComplete;
}

void Player::setAmmo(unsigned a) {
	ammo = a;
}

void Player::setHealth(int h) {
	health = h;
}

void Player::setMoney(int m) {
	money = m;
}

void Player::setSword(int s)
{
	sword = s;
}
void Player::setArmourplate(int ap)
{
	armourplate = ap;
}

void Player::setHelmet(int ht)
{
	helmet = ht;
}

void Player::setJetpack(bool jp)
{
	jetpackequipped = jp;
}

void Player::setSharkSurvived(bool Ss)
{
	SharkSurvived = Ss;
}

void Player::setMazeComplete(bool Mc)
{
	MazeComplete = Mc;
}

void Player::setBookPurchased(bool Bp)
{
	BookPurchased = Bp;
}

void Player::setShootingComplete(bool Sc)
{
	ShootingComplete = Sc;
}

std::set<unsigned short> Application::activeKeys;
Scene* scene[Application::TOTALSCENES];
Mouse mouse;

Application::Application() {}

Application::~Application() {}

//Define an error callback
static void error_callback(int error, const char* description) {
	fputs(description, stderr);
	_fgetchar();
}

//Define the key input callback
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
		glfwSetWindowShouldClose(window, GL_TRUE);
}

static void scroll_callback(GLFWwindow* window, double nan, double  [MASK] ) {
	mouse.scroll =  [MASK] ;
}

static void mouse_callback(GLFWwindow* window, double x, double y) {
	if (x < Application::GetWindowWidth() / 2) {
		mouse.left = true;
		mouse.right = false;
		mouse.x = (Application::GetWindowWidth() / 2) - x;
	} else if (x > Application::GetWindowWidth() / 2) {
		mouse.left = false;
		mouse.right = true;
		mouse.x = x - (Application::GetWindowWidth() / 2);
	}

	if (y < Application::GetWindowHeight() / 2) {
		mouse.up = true;
		mouse.down = false;
		mouse.y = (Application::GetWindowHeight() / 2) - y;
	} else if (y > Application::GetWindowHeight() / 2) {
		mouse.up = false;
		mouse.down = true;
		mouse.y = y - (Application::GetWindowHeight() / 2);
	}
}

static void resize_callback(GLFWwindow* window, int w, int h) {
	Application::m_width = w;
	Application::m_height = h;
	Application::ui_width = w / 10;
	Application::ui_height = h / 10;
	glViewport(0, 0, w, h);
}

bool Application::IsKeyPressed(unsigned short key) {
	return ((GetAsyncKeyState(key) & 0x8001) != 0);
}

bool Application::IsMousePressed(unsigned short key) {
	return glfwGetMouseButton(m_window, key) != 0;
}

void Application::GetCursorPos(double* xpos, double* ypos) {
	glfwGetCursorPos(m_window, xpos, ypos);
}

unsigned Application::GetWindowWidth() {
	return m_width;
}

unsigned Application::GetWindowHeight() {
	return m_height;
}

unsigned Application::GetUIHeight() {
	return ui_height;
}

unsigned Application::GetFPS() {
	return FPS;
}

unsigned Application::GetUIWidth() {
	return ui_width;
}

bool Application::IsMousePressedOnce(unsigned short key) {
	std::pair<std::set<unsigned short>::iterator, bool> ret;
	if (glfwGetMouseButton(m_window, key) != 0) {
		ret = activeKeys.insert(key);
		if (!ret.second) {
			return false;
		} else {
			if (key == 0) {
				mouse.rightclick = false;
				mouse.leftclick = true;
			} else if (key == 1) {
				mouse.leftclick = false;
				mouse.rightclick = true;
			}
			return true;
		}
	} else {
		activeKeys.erase(key);
		return false;
	}
}

bool Application::IsKeyPressedOnce(unsigned short key) {
	if ((GetAsyncKeyState(key) & 0x8001) != 0) {
		std::pair<std::set<unsigned short>::iterator, bool> ret = activeKeys.insert(key);
		return (ret.second);
	} else {
		activeKeys.erase(key);
		return false;
	}
}

void Application::log(std::string string) {
	std::cout << string << std::endl;
}

void Application::Init() {

	//Set the error callback
	glfwSetErrorCallback(error_callback);

	//Initialize GLFW
	if (!glfwInit())
		exit(EXIT_FAILURE);

	//Set the GLFW window creation hints - these are optional
	glfwWindowHint(GLFW_SAMPLES, 4); //Request 4x antialiasing
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //Request a specific OpenGL version
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); //Request a specific OpenGL version

	//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL 

	//Create a window and create its OpenGL context
	m_width = 800;
	m_height = 600;
	ui_height = 60;
	ui_width = 80;
	sceneswitch = START_SCENE;
	Player::setMoney(100);
	Player::setAmmo(256);
	Player::setHealth(100);
	Player::setJetpack(false);
	Player::setSharkSurvived(false);
	Player::setMazeComplete(false);
	Player::setBookPurchased(false);
	Player::setShootingComplete(false);
	// sword armour and helmet all zero so dun need initalise
	m_window = glfwCreateWindow(m_width, m_height, ""SP2 - Group 2"", NULL, NULL);
	quit = restart = false;
	mouse.reset();
	glfwSetWindowSizeCallback(m_window, resize_callback);

	//If the window couldn't be created
	if (!m_window) {
		fprintf(stderr, ""Failed to open GLFW window.\n"");
		glfwTerminate();
		exit(EXIT_FAILURE);
	}

	//This function makes the context of the specified window current on the calling thread. 
	glfwMakeContextCurrent(m_window);

	//Sets the key callback
	glfwSetKeyCallback(m_window, key_callback);

	glewExperimental = true; // Needed for core profile

	//Initialize GLEW
	GLenum err = glewInit();

	//If GLEW hasn't initialized
	if (err != GLEW_OK) {
		fprintf(stderr, ""Error: %s\n"", glewGetErrorString(err));
	}
}

void toggleState() {
	switch (Application::sceneswitch) {
	case Application::MENU_SCENE:
	case Application::WIN_SCENE:
	case Application::START_SCENE:

		// Use mouse positioning to click on UI menu
		glfwSetCursorPosCallback(m_window, NULL);
		glfwSetScrollCallback(m_window, NULL);
		glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
		break;
	case Application::DISTRICT_SCENE:
	case Application::MAZE_SCENE:
	case Application::SHARK_SCENE:
	case Application::CARNIVAL_SCENE:
	case Application::MART_SCENE:
	default:

		// Use mouse movement for playing and looking
		glfwSetCursorPosCallback(m_window, mouse_callback);
		glfwSetScrollCallback(m_window, scroll_callback);
		glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
		mouse.reset();
		glfwSetCursorPos(m_window, Application::GetWindowWidth() / 2, Application::GetWindowHeight() / 2);
		break;
	}
}

void Application::Run() {
	// Initialize and create scenes
	scene[DISTRICT_SCENE] = new DistrictScene();
	scene[MAZE_SCENE] = new MazeScene();
	scene[BEACH_SCENE] = new BeachScene();
	scene[SHARK_SCENE] = new SharkScene();
	scene[CARNIVAL_SCENE] = new CarnivalScene();
	scene[OVERWORLD_SCENE] = new OverworldScene();
	scene[MART_SCENE] = new MartScene();
	scene[START_SCENE] = new StartMenuScene();
	scene[MENU_SCENE] = new PauseMenuScene();
	scene[WIN_SCENE] = new WinnerScene();

	for (unsigned i = 0; i < Application::TOTALSCENES; i++) {
		if (scene[i])
			scene[i]->Init();
	}

	// Start timer to calculate how long it takes to render this frame
	m_timer.startTimer();

	// Main Loop
	while (!glfwWindowShouldClose(m_window) || !Application::quit) {
		for (std::set<unsigned short>::iterator i = activeKeys.begin(); i != activeKeys.end(); i++) {
			unsigned short key = *i;
			if ((GetAsyncKeyState(key) & 0x8001) != 0) {}
			else {
				activeKeys.erase(i);
				break;
			}
		}

		if (restart) {
			for (unsigned i = 0; i < Application::TOTALSCENES; i++) {
				if (scene[i]) {
					scene[i]->Reset();
				}
			}
			Application::sceneswitch = Application::previousscene = START_SCENE;
			restart = false;
		}

		// Update and render selected scene
		if (scene[Application::sceneswitch]) {
			int previousScene = Application::sceneswitch;
			scene[previousScene]->Update(m_timer.getElapsedTime(), mouse);
			scene[previousScene]->Render();
			if (previousScene != Application::sceneswitch) {
				scene[Application::sceneswitch]->InitGL();
			}

		} else {
			Application::sceneswitch = START_SCENE;
		}

		// Toggle mouse states depending on scene
		toggleState();

		switch (Application::sceneswitch) {
		case Application::MENU_SCENE:
			/*if (Application::IsKeyPressedOnce(VK_ESCAPE)) {
				Application::sceneswitch = Application::previousscene;
			}*/
			break;
		case Application::START_SCENE:
			if (Application::IsKeyPressedOnce(VK_ESCAPE)) {
				Application::quit = true;
			}
			break;
		case Application::WIN_SCENE:
			restart = true;
			break;
		default:
			if (Application::IsKeyPressedOnce(VK_ESCAPE)) {
				Application::previousscene = Application::sceneswitch;
				Application::sceneswitch = MENU_SCENE;
			}
			break;
		}

		//Swap buffers
		glfwSwapBuffers(m_window);

		//Get and organize events, like keyboard and mouse input, window resizing, etc...
		glfwPollEvents();

		// Frame rate limiter. Limits each frame to a specified time in ms.   
		m_timer.waitUntil(frameTime);
	} 

	//If the window had been closed or quit from the main menu
	for (unsigned i = 0; i < Application::TOTALSCENES; i++) {
		if (scene[i]) {

			//Clean up scenes
			scene[i]->Exit();
			delete scene[i];
		}
	}
}

void Application::Exit() {

	//Close OpenGL window and terminate GLFW
	glfwDestroyWindow(m_window);

	//Finalize and clean up GLFW
	glfwTerminate();
}
",offSet
51,"#include ""add.h""
#include ""ui_add.h""
#include <QSqlQueryModel>
#include <QMessageBox>

Add::Add(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Add)
{
    ui->setupUi(this);
}

Add::~Add()
{
    delete ui;
}

QString Add::Sex()
{
    if(ui->radioButton_man->isChecked())
    {
        ui->radioButton_man->setChecked(false);
        return ""男"";
    }
    if(ui->radioButton_woman->isChecked())
    {
        ui->radioButton_woman->setChecked(false);
        return ""女"";
    }
    return """";
}

void Add::on_ADD_clicked()
{
    int age = ui->spinBox->value();
    QString name = ui->Add_nameEdit->text();
    QString id = ui->Add_idEdit->text();
    QString Class = ui->Add_classEdit->text();
    QString chinese = ui->Add_chineseEdit->text();
    QString math = ui->Add_mathEdit->text();
    int mathscore = math.toInt();
    int chinesescore = chinese.toInt();
    int totalscore = mathscore+chinesescore;
    QString  [MASK]  = ""123"";
    QString sex = Sex();
    QSqlQueryModel model;
    QString sql = ""select * from 学生 where 工号 = '""+id+""'"";
    model.setQuery(sql);
    if(model.rowCount())
    {
        QMessageBox::warning(this,""警告"",""系统中已有该学生"");
    }
    else if(name.isEmpty() || id.isEmpty() || Class.isEmpty() || chinese.isEmpty() || math.isEmpty() || sex.isEmpty() || age == 0)
    {
        QMessageBox::warning(this,""警告"",""请检查输入的信息是否正确"");
    }
    else
    {
        sql = ""insert into 学生(姓名,工号,性别,班级,年龄,数学,语文,总分,密码)values('""+name+""','""+id+""','""+sex+""','""+Class+""',""+QString::number(age)+"",""+QString::number(mathscore)+"",""+QString::number(chinesescore)+"",""+QString::number(totalscore)+"",'""+ [MASK] +""')"";
        model.setQuery(sql);
        sql = ""insert into 账户(工号,密码,权限)values('""+id+""','""+ [MASK] +""','学生')"";
        model.setQuery(sql);
        QMessageBox::information(this,""提示"",""信息添加成功"");
        ui->spinBox->clear();
        ui->Add_nameEdit->clear();
        ui->Add_idEdit->clear();
        ui->Add_classEdit->clear();
        ui->Add_chineseEdit->clear();
        ui->Add_mathEdit->clear();
    }
}
",pwd
52,"#include <cstdio>
#include <string>
#include <fstream>
#include <iostream>
#include <chrono>
#include <math.h>

#define itera 1000

using namespace std;
using namespace std::chrono;

int main(int argc, char* argv[]) {
    int dimx, dimy, depth, size;
    string  [MASK] ; 

    if (argc < 3) {
        cout << ""Usage: "" << argv[0] << "" infile.pnm outfile.pgm"" << endl;
        return EXIT_FAILURE; 
    }

    ifstream ifs(argv[1], ios_base::in | ios_base::binary);

    ifs >>  [MASK] ;
    if ( [MASK]  != ""P6"") {
        cout << argv[1] << "" is not a valid P6 file!"" << endl;
        return EXIT_FAILURE;
    }
    ifs >> dimx >> dimy >> depth;
    ifs.ignore();

    ofstream ofs(argv[2], ios_base::out | ios_base::binary);
    ofs << ""P5"" << endl << dimx << ' ' << dimy << endl << ""255"" << endl;

    size = dimx*dimy;
    char *rgb = new char[size*3];
    char *gray = new char[size];
    char *sobel = new char[size];

    unsigned char r, g, b;

    auto len = ifs.read(rgb, size*3+7).gcount();
    if (len != size*3) {
        cout << ""Error reading file!"" << endl;
        return EXIT_FAILURE;
    }
    ifs.close();

    auto start = high_resolution_clock::now();
    for (auto it = 0u; it < itera; it++) {
        for (auto ii = 0u, oi = 0u; ii < size*3; ii=ii+3, oi++) {
            r = (char)rgb[ii];
            g = (char)rgb[ii+1];
            b = (char)rgb[ii+2];
            int gs = (r+(g<<1)+b)>>2;
            gray[oi] = (char)gs;
        }

        int pixel_x;
        int pixel_y;

        float sobel_x[3][3] =
        {{ -1, 0, 1 },
         { -2, 0, 2 },
         { -1, 0, 1 }};

        float sobel_y[3][3] =
        {{ -1, -2, -1 },
         {  0,  0,  0 },
         {  1,  2,  1 }};

        for (int x=1; x < dimx-1; x++) {
            for (int y=1; y < dimy-1; y++) {
                pixel_x = (sobel_x[0][0] * gray[dimx * (y-1) + (x-1)])
                        + (sobel_x[0][1] * gray[dimx * (y-1) +  x   ])
                        + (sobel_x[0][2] * gray[dimx * (y-1) + (x+1)])
                        + (sobel_x[1][0] * gray[dimx *  y    + (x-1)])
                        + (sobel_x[1][1] * gray[dimx *  y    +  x   ])
                        + (sobel_x[1][2] * gray[dimx *  y    + (x+1)])
                        + (sobel_x[2][0] * gray[dimx * (y+1) + (x-1)])
                        + (sobel_x[2][1] * gray[dimx * (y+1) +  x   ])
                        + (sobel_x[2][2] * gray[dimx * (y+1) + (x+1)]);
                pixel_y = (sobel_y[0][0] * gray[dimx * (y-1) + (x-1)])
                        + (sobel_y[0][1] * gray[dimx * (y-1) +  x   ])
                        + (sobel_y[0][2] * gray[dimx * (y-1) + (x+1)])
                        + (sobel_y[1][0] * gray[dimx *  y    + (x-1)])
                        + (sobel_y[1][1] * gray[dimx *  y    +  x   ])
                        + (sobel_y[1][2] * gray[dimx *  y    + (x+1)])
                        + (sobel_y[2][0] * gray[dimx * (y+1) + (x-1)])
                        + (sobel_y[2][1] * gray[dimx * (y+1) +  x   ])
                        + (sobel_y[2][2] * gray[dimx * (y+1) + (x+1)]);
                int val = (int)sqrt((pixel_x * pixel_x) + (pixel_y * pixel_y));
                if(val < 0) val = 0;
                if(val > 255) val = 255;
                sobel[dimx * y + x] = (unsigned char)val;
            }
        }
    }
    auto stop = high_resolution_clock::now();
    auto duration = duration_cast<milliseconds>(stop - start);
    cout << argv[1] << "" with "" << dimx << ""x"" << dimy << "" in "" << duration.count() << "" ms"" << endl;
    ofs.write(sobel, size);
    ofs.close();
    return EXIT_SUCCESS;
}
",line
53,"#include ""mudff_unpack.h""

void* Alloc(void *p, size_t size) { return malloc(size); }
void Free(void *p, void *address) { if (address) free(address); }
ISzAlloc alloc = { Alloc, Free };


muff_unpack::muff_unpack()
{
	memset(arc_file,0,MAX_PATH);
}
muff_unpack::~muff_unpack()
{
	memset(arc_file,0,MAX_PATH);
}

BYTE * muff_unpack::decomp_entry(char * file, int *size)
{
	for (int j=0;j<head.fileznum;j++)
	{ 
		filez &entry = entries[j];
		if(strcmp(file,(const char*)entry.fname) ==0)
		{
			unsigned char * data = (unsigned char*)malloc(entry.compressed_len);
			memset(data,0,entry.compressed_len);
			unsigned char * out_mem = (unsigned char*)malloc(entry.uncompressed_len);
			memset(out_mem,0,entry.uncompressed_len);
			archive_file.seekg(0,ios::beg);
			archive_file.seekg (entry.off, ios::beg);
			archive_file.read ((char*)data,entry.compressed_len);
			unsigned int slen = entry.compressed_len;
			unsigned int destLen = entry.uncompressed_len;
			ELzmaStatus status;
			slen -= LZMA_PROPS_SIZE;
			SRes err = LzmaDecode((Byte*)out_mem, (SizeT*)&destLen, (const Byte*)data + LZMA_PROPS_SIZE, 
				(SizeT*)&slen, (const Byte*)data, LZMA_PROPS_SIZE, LZMA_FINISH_END, &status, &alloc);
			if ( err != SZ_OK && destLen != entry.uncompressed_len )
			{
				return NULL;
			}
			*size = entry.uncompressed_len;
			delete [] data;
			return((BYTE*)out_mem);
		}
		
	}
	return NULL;
}

int muff_unpack::init(char* archive)
	{
	int  [MASK] ;
	archive_file.open (archive, ios::in|ios::binary);
	if (!archive_file.is_open()) return 0;
	strcpy(arc_file,archive);
	archive_file.seekg (0, ios::beg);
	archive_file.read ((char*)&head, sizeof(head));
	if(head.signature != 0x12111988) {
		return 0;
	}
	 [MASK]  = head.fileznum;
	archive_file.seekg (sizeof(head), ios::beg);
	for (int i = 0; i < head.fileznum; i++)
	{
		filez entry;
		archive_file.read ((char*)&entry, sizeof(filez));
		entries.push_back(entry);
	}
	return 1;
}

void muff_unpack::close()
{
	memset(arc_file,0,MAX_PATH);
	archive_file.close();
}




",num_files
54,"/* SPDX-License-Identifier: BSL-1.0 OR BSD-3-Clause */

#ifndef MPT_BASE_NUMERIC_HPP
#define MPT_BASE_NUMERIC_HPP



#include ""mpt/base/detect_compiler.hpp""
#include ""mpt/base/namespace.hpp""

#include ""mpt/base/bit.hpp""
#include ""mpt/base/saturate_cast.hpp""

#include <algorithm>
#include <limits>
#include <type_traits>



namespace mpt {
inline namespace MPT_INLINE_NS {


template <typename Tmod, Tmod m>
struct ModIfNotZeroImpl {
	template <typename Tval>
	constexpr Tval mod(Tval x) {
		static_assert(std::numeric_limits<Tmod>::is_integer);
		static_assert(!std::numeric_limits<Tmod>::is_signed);
		static_assert(std::numeric_limits<Tval>::is_integer);
		static_assert(!std::numeric_limits<Tval>::is_signed);
		return static_cast<Tval>(x % m);
	}
};
template <>
struct ModIfNotZeroImpl<uint8, 0> {
	template <typename Tval>
	constexpr Tval mod(Tval x) {
		return x;
	}
};
template <>
struct ModIfNotZeroImpl<uint16, 0> {
	template <typename Tval>
	constexpr Tval mod(Tval x) {
		return x;
	}
};
template <>
struct ModIfNotZeroImpl<uint32, 0> {
	template <typename Tval>
	constexpr Tval mod(Tval x) {
		return x;
	}
};
template <>
struct ModIfNotZeroImpl<uint64, 0> {
	template <typename Tval>
	constexpr Tval mod(Tval x) {
		return x;
	}
};

// Returns x % m if m != 0, x otherwise.
// i.e. ""return (m == 0) ? x : (x % m);"", but without causing a warning with stupid older compilers
template <typename Tmod, Tmod m, typename Tval>
constexpr Tval modulo_if_not_zero(Tval x) {
	return ModIfNotZeroImpl<Tmod, m>().mod(x);
}

// rounds x up to multiples of target
template <typename T>
constexpr T align_up(T x, T target) {
	return ((x + (target - 1)) / target) * target;
}

// rounds x down to multiples of target
template <typename T>
constexpr T align_down(T x, T target) {
	return (x / target) * target;
}

// rounds x up to multiples of target or saturation of T
template <typename T>
constexpr T saturate_align_up(T x, T target) {
	if (x > (std::numeric_limits<T>::max() - (target - 1))) {
		return std::numeric_limits<T>::max();
	}
	return ((x + (target - 1)) / target) * target;
}

// Returns sign of a number (-1 for negative numbers, 1 for positive numbers, 0 for 0)
template <class T>
constexpr int signum(T  [MASK] ) {
	return ( [MASK]  > T(0)) - ( [MASK]  < T(0));
}


} // namespace MPT_INLINE_NS
} // namespace mpt



#endif // MPT_BASE_ALGORITHM_HPP
",value
55,"#define FORCE_SENSOR_PIN A0 // the FSR and 10K pulldown are connected to A0

void setup() {
  Serial.begin(9600);
  Serial.println(""CLEARDATA"");
  Serial.println(""LABEL,Force Sensor Reading, Value, Type"");
  Serial.println(""RESETTIMER"");
}


void loop() {
  int  [MASK]  = analogRead(FORCE_SENSOR_PIN);

  Serial.print(""DATA, TIME,"");
  Serial.print(""Force sensor reading = "");
  Serial.print("","");
  Serial.print( [MASK] ); // print the raw analog reading
  Serial.print("","");
  if ( [MASK]  < 10)       // from 0 to 9
    Serial.println("" -> no pressure"");
  else if ( [MASK]  < 200) // from 10 to 199
    Serial.println("" -> light touch"");
  else if ( [MASK]  < 500) // from 200 to 499
    Serial.println("" -> light squeeze"");
  else if ( [MASK]  < 800) // from 500 to 799
    Serial.println("" -> medium squeeze"");
  else // from 800 to 1023
    Serial.println("" -> big squeeze"");

  delay(500);
}
",analogReading
56,"

#include ""CTBot.h""
CTBot myBot;

String ssid = ""no internet"";     // REPLACE mySSID WITH YOUR WIFI SSID
String pass = ""<PASSWORD>""; // REPLACE myPassword YOUR WIFI PASSWORD, IF ANY
String token = ""977896158:<KEY>"";   // REPLACE myToken WITH YOUR TELEGRAM BOT TOKEN
uint8_t led = BUILTIN_LED;            // the onboard ESP8266 LED.    
                            // If you have a NodeMCU you can use the BUILTIN_LED pin
                            // (replace 2 with BUILTIN_LED)							

void setup() {
	// initialize the Serial
	Serial.begin(115200);
	Serial.println(""Starting TelegramBot..."");

	// connect the ESP8266 to the desired access point
	myBot.wifiConnect(ssid, pass);

	// set the telegram bot token
	myBot.setTelegramToken(token);

	// check if all things are ok
	if (myBot.testConnection())
		Serial.println(""\ntestConnection OK"");
	else
		Serial.println(""\ntestConnection NOK"");

	// set the pin connected to the LED to act as output pin
	pinMode(D3, OUTPUT);
	digitalWrite(D3, HIGH); // turn off the led (inverted logic!)
  pinMode(D1,OUTPUT);
  digitalWrite(D1, HIGH); // turn off motor

}

void loop() {
	// a variable to store telegram message data
	TBMessage  [MASK] ;

	// if there is an incoming message...
	if (myBot.getNewMessage( [MASK] )) {

		if ( [MASK] .text.equalsIgnoreCase(""LIGHT ON"")) {              // if the received message is ""LIGHT ON""...
			digitalWrite(D3, LOW);                               // turn on the LED (inverted logic!)
			myBot.sendMessage( [MASK] .sender.id, ""Light is now ON"");  // notify the sender
		}
		else if ( [MASK] .text.equalsIgnoreCase(""LIGHT OFF"")) {        // if the received message is ""LIGHT OFF""...
			digitalWrite(D3, HIGH);                              // turn off the led (inverted logic!)
			myBot.sendMessage( [MASK] .sender.id, ""Light is now OFF""); // notify the sender
		}
    else if ( [MASK] .text.equalsIgnoreCase(""FAN ON"")) {              // if the received message is ""FAN ON""...
      digitalWrite(D1, LOW);                               // turn on the FAN (inverted logic!)
      myBot.sendMessage( [MASK] .sender.id, ""FAN is now ON"");
    }
    else if ( [MASK] .text.equalsIgnoreCase(""FAN OFF"")) {        // if the received message is ""FAN OFF""...
      digitalWrite(D1, HIGH);                              // turn off the FAN (inverted logic!)
      myBot.sendMessage( [MASK] .sender.id, ""FAN is now OFF""); // notify the sender
    }
    else {                                                    // otherwise...
			// generate the message for the sender
			String reply;
			reply = (String)""Welcome "" +  [MASK] .sender.username + (String)"". Try LIGHT ON or LIGHT OFF."";
			myBot.sendMessage( [MASK] .sender.id, reply);             // and send it
		}
	}
	// wait 500 milliseconds
	delay(500);
}
",msg
57,"#include ""AlignmentRule.h""
#include ""../gameobjects/Boid.h""

Vector2 AlignmentRule::computeForce(const std::vector<Boid*>& neighborhood, Boid* boid) {
    Vector2  [MASK]  = Vector2::zero();
    int total = 0;

    // todo: add your code here to align each boid in a neighborhood
    // hint: iterate over the neighborhood
    for (int i = 0; i < neighborhood.size(); i++)
    {
        //Check if other boid's are in dectection radius
        float dist = boid->getVelocity().getDistance(boid->getPosition(), neighborhood[i]->getPosition());
        if (dist < boid->getDetectionRadius())
        {
             [MASK]  += neighborhood[i]->getVelocity();
            total++;
        }
    }
    if(total != 0)
         [MASK]  /= total;

    return Vector2::normalized( [MASK] );
}",averageVelocity
58,"// NCurses 2D vector math
// (c) 2022 by <NAME>

#include <math.h>

#include ""math2d.h""

static const int mat3_stack_max = 100;
static int mat3_stack_size = 0;
static Mat3 mat3_stack[mat3_stack_max];

// get current transformation
Mat3 top()
{
   if (mat3_stack_size > 0)
      return(mat3_stack[mat3_stack_size-1]);
   else
      return(mat3());
}

// push current transformation
void push()
{
   if (mat3_stack_size < mat3_stack_max)
   {
      if (mat3_stack_size > 0)
         mat3_stack[mat3_stack_size] = mat3_stack[mat3_stack_size-1];
      else
         mat3_stack[mat3_stack_size] = mat3();
      mat3_stack_size++;
   }
}

// pop current transformation
Mat3 pop()
{
   if (mat3_stack_size > 0)
      return(mat3_stack[--mat3_stack_size]);
   else
      return(mat3());
}

// apply translation to current transformation
void translate(float x, float y)
{
   if (mat3_stack_size > 0)
   {
      Mat3 m = mat3(1,0,x, 0,1,y, 0,0,1);
      mat3_stack[mat3_stack_size-1] = mul3(mat3_stack[mat3_stack_size-1], m);
   }
}

// apply clockwise rotation to current transformation
void rotate(float a, float  [MASK] )
{
   if (mat3_stack_size > 0)
   {
      float w = M_PI*a/180;
      float s = sin(w);
      float c = cos(w);

      Mat3 m = mat3(c,-s* [MASK] ,0, s/ [MASK] ,c,0, 0,0,1);
      mat3_stack[mat3_stack_size-1] = mul3(mat3_stack[mat3_stack_size-1], m);
   }
}

// apply scaling to current transformation
void scale(float s, float t)
{
   if (mat3_stack_size > 0)
   {
      Mat3 m = mat3(s,0,0, 0,t,0, 0,0,1);
      mat3_stack[mat3_stack_size-1] = mul3(mat3_stack[mat3_stack_size-1], m);
   }
}
",aspect
59,"#include <avr/sleep.h>

// PIN 9 (PIN_B1) <=> CN9 PIN 2
#define SET_DATA      PORTB.OUTSET = PIN0_bm
#define CLR_DATA      PORTB.OUTCLR = PIN0_bm

// PIN 8 (PIN_B0) <=> CN9 PIN 3
#define SET_SETUP    PORTB.OUTSET = PIN1_bm
#define CLR_SETUP    PORTB.OUTCLR = PIN1_bm

// PIN 6 (PIN_B3) <=> CN9 PIN 4
#define SET_RESET     PORTB.OUTSET = PIN3_bm
#define CLR_RESET     PORTB.OUTCLR = PIN3_bm

// PIN 7 (PIN_B2) <=> CN9 PIN 5
#define SET_CLOCK     PORTB.OUTSET = PIN2_bm
#define CLR_CLOCK     PORTB.OUTCLR = PIN2_bm

// doing bit shifting takes a variable amount
// of time depending on the how far the shift
// is.  Using the below lookup table to try
// and keep a consistent clock period when
// sending data.
uint8_t masks[8] = {
  0x01, 0x02, 0x04, 0x08,
  0x10, 0x20, 0x40, 0x80,
};

// The key data below comes from mame.  Each game has a .key file, which contains the 20 bytes.
// ie: https://github.com/mamedev/mame/blob/master/src/mame/capcom/cps2.cpp#L1900
#define CONFIG_SIZE   6
#define WATCHDOG_SIZE 6
#define KEY_SIZE      4

// There are only 10 unique combinations of the first 6 bytes
// of all key data.  In order to save about 800 bytes of flash
// we are using the below lookup table for these 6 bytes. 
// Without the lookup table the code compiles very near to 4k,
// which would put it at risk of not being viable on attiny4x4s
uint8_t config_table[][CONFIG_SIZE] = {
 { 0x01, 0x00, 0x02, 0x40, 0x00, 0x08 },  // 0x00
 { 0x01, 0x00, 0x02, 0x40, 0x00, 0x09 },  // 0x01
 { 0x01, 0x00, 0x02, 0x40, 0x00, 0x0a },  // 0x02
 { 0x07, 0x00, 0x02, 0x40, 0x00, 0x08 },  // 0x03
 { 0x07, 0x00, 0x02, 0x40, 0x00, 0x0a },  // 0x04
 { 0x0f, 0x00, 0x02, 0x40, 0x00, 0x08 },  // 0x05
 { 0x0f, 0x00, 0x02, 0x40, 0x00, 0x09 },  // 0x06
 { 0x0f, 0x00, 0x02, 0x40, 0x00, 0x0a },  // 0x07
 { 0x3f, 0x00, 0x02, 0x40, 0x00, 0x08 },  // 0x08
 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },  // 0x09
};

struct game_data_t {
  uint8_t config_table_index;
  uint8_t watchdog[WATCHDOG_SIZE];
  uint8_t key2[KEY_SIZE];
  uint8_t key1[KEY_SIZE];
};

#define MAX_GAME_NUM 174
struct game_data_t game_data[MAX_GAME_NUM + 1] = {
  // config table                                                                                                          jumpers
  //    index                  watchdog config                         key#2                        key#1                  12345678 raw key filename
  {     0x06,       { 0x84, 0xc2, 0xeb, 0x7a, 0x3c, 0xa5 },  { 0xf4, 0x38, 0xeb, 0x65 },  { 0x79, 0x9c, 0xbf, 0x70 } }, // 00000000 1944.key
  {     0x06,       { 0x84, 0xc2, 0xeb, 0x7a, 0x3c, 0xa5 },  { 0x8b, 0x93, 0x46, 0x1d },  { 0x70, 0xe7, 0xaf, 0x10 } }, // 00000001 1944j.key
  {     0x06,       { 0x84, 0xc2, 0xeb, 0x7a, 0x3c, 0xa5 },  { 0x78, 0xfe, 0x6b, 0x44 },  { 0xc9, 0x39, 0xf2, 0xe0 } }, // 00000010 1944u.key
  {     0x04,       { 0x04, 0xc2, 0xa4, 0x02, 0x02, 0x21 },  { 0xe8, 0x85, 0x13, 0x2a },  { 0x2e, 0x46, 0x8b, 0x00 } }, // 00000011 19xx.key
  {     0x04,       { 0x04, 0xc2, 0xa4, 0x02, 0x02, 0x22 },  { 0x23, 0xb1, 0x6f, 0xb6 },  { 0xbc, 0xcb, 0x9c, 0xcc } }, // 00000100 19xxa.key
  {     0x04,       { 0x04, 0xc2, 0xa4, 0x02, 0x02, 0x23 },  { 0xf1, 0x1b, 0x7e, 0xd1 },  { 0x5b, 0x8a, 0x7e, 0x9c } }, // 00000101 19xxb.key
  {     0x04,       { 0x04, 0xc2, 0xa4, 0x02, 0x02, 0x23 },  { 0xe4, 0xda, 0x13, 0xbd },  { 0x7d, 0x76, 0x4a, 0xe8 } }, // 00000110 19xxh.key
  {     0x04,       { 0x04, 0xc2, 0xa4, 0x02, 0x02, 0x21 },  { 0xf8, 0x7f, 0xc0, 0x00 },  { 0x7e, 0xea, 0x20, 0x00 } }, // 00000111 19xxj.key
  {     0x04,       { 0x04, 0xc2, 0xa4, 0x02, 0x02, 0x20 },  { 0x04, 0x3c, 0x2f, 0xeb },  { 0xe0, 0x63, 0x81, 0xc0 } }, // 00001000 19xxu.key
  {     0x07,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x0b },  { 0xe0, 0x42, 0x71, 0x47 },  { 0x40, 0xca, 0xe5, 0xe4 } }, // 00001001 armwar.key
  {     0x07,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x08 },  { 0x42, 0x71, 0x47, 0x40 },  { 0xca, 0xe5, 0xe7, 0xe0 } }, // 00001010 armwara.key
  {     0x07,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x0a },  { 0x04, 0x27, 0x14, 0x74 },  { 0x0c, 0xae, 0x5e, 0x7c } }, // 00001011 armwarb.key
  {     0x07,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x0a },  { 0x5e, 0x7e, 0x04, 0x27 },  { 0x14, 0x74, 0x0c, 0xac } }, // 00001100 armwaru.key
  {     0x05,       { 0x04, 0xc0, 0xb1, 0x20, 0x79, 0xab },  { 0x34, 0xd9, 0xed, 0x4a },  { 0x7b, 0xc4, 0x12, 0xa0 } }, // 00001101 avsp.key
  {     0x05,       { 0x04, 0xc0, 0xb1, 0x20, 0x79, 0xa8 },  { 0x3a, 0x69, 0x49, 0xd2 },  { 0xf7, 0x3c, 0x5a, 0x0c } }, // 00001110 avspa.key
  {     0x05,       { 0x04, 0xc0, 0xb1, 0x20, 0x79, 0xab },  { 0xe9, 0xc6, 0xcf, 0x09 },  { 0x42, 0x5b, 0x52, 0x38 } }, // 00001111 avsph.key
  {     0x05,       { 0x04, 0xc0, 0xb1, 0x20, 0x79, 0xa8 },  { 0x98, 0x13, 0xb2, 0x29 },  { 0x7c, 0x74, 0xee, 0x5c } }, // 00010000 avspj.key
  {     0x05,       { 0x04, 0xc0, 0xb1, 0x20, 0x79, 0xab },  { 0x11, 0x6b, 0xbc, 0xce },  { 0x44, 0x21, 0xbc, 0xb4 } }, // 00010001 avspu.key
  {     0x04,       { 0x04, 0xc3, 0xa4, 0x02, 0x32, 0x02 },  { 0xb5, 0x1c, 0xf4, 0xf3 },  { 0xa6, 0x9e, 0xa6, 0x2c } }, // 00010010 batcir.key
  {     0x04,       { 0x04, 0xc3, 0xa4, 0x02, 0x32, 0x03 },  { 0x8d, 0xd0, 0x44, 0x67 },  { 0x4c, 0x06, 0xe9, 0xe0 } }, // 00010011 batcira.key
  {     0x04,       { 0x04, 0xc3, 0xa4, 0x02, 0x32, 0x00 },  { 0x5c, 0x40, 0x00, 0x00 },  { 0x6e, 0xcb, 0xfc, 0x00 } }, // 00010100 batcirj.key
  {     0x01,       { 0x84, 0xc3, 0xa2, 0xc8, 0xf3, 0x6a },  { 0xb7, 0xa1, 0xc7, 0xf9 },  { 0x8d, 0x23, 0x7f, 0x2c } }, // 00010101 choko.key
  {     0x04,       { 0x04, 0xc3, 0xa4, 0x00, 0x23, 0x02 },  { 0x0f, 0x9c, 0x21, 0x08 },  { 0x17, 0xe5, 0xd1, 0x98 } }, // 00010110 csclub.key
  {     0x04,       { 0x04, 0xc3, 0xa4, 0x00, 0x23, 0x03 },  { 0xb2, 0x50, 0xb5, 0x65 },  { 0x51, 0xed, 0x9b, 0x20 } }, // 00010111 cscluba.key
  {     0x04,       { 0x04, 0xc3, 0xa4, 0x00, 0x23, 0x00 },  { 0x2c, 0xa7, 0xb9, 0xd3 },  { 0x94, 0x54, 0xa0, 0x3c } }, // 00011000 csclubh.key
  {     0x04,       { 0x04, 0xc3, 0xa4, 0x00, 0x23, 0x00 },  { 0x0f, 0x20, 0x0d, 0xaa },  { 0x9f, 0x42, 0xd1, 0x48 } }, // 00011001 csclubj.key
  {     0x05,       { 0x70, 0xc3, 0xfc, 0x00, 0x70, 0xc2 },  { 0x02, 0x42, 0x42, 0x83 },  { 0x0a, 0x69, 0x0a, 0x88 } }, // 00011010 cybots.key
  {     0x05,       { 0x70, 0xc3, 0xfc, 0x00, 0x70, 0xc3 },  { 0x0a, 0x69, 0x09, 0x4a },  { 0x02, 0x42, 0x42, 0x80 } }, // 00011011 cybotsj.key
  {     0x05,       { 0x70, 0xc3, 0xfc, 0x00, 0x70, 0xc2 },  { 0x69, 0x0a, 0xaa, 0x02 },  { 0x42, 0x42, 0x83, 0x08 } }, // 00011100 cybotsu.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x83 },  { 0x1b, 0xeb, 0xe0, 0x6c },  { 0xf5, 0x64, 0x47, 0x84 } }, // 00011101 ddsom.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x82 },  { 0x8b, 0x05, 0x03, 0xde },  { 0xcf, 0x56, 0x63, 0x84 } }, // 00011110 ddsoma.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x81 },  { 0xcf, 0xf6, 0x97, 0x3d },  { 0x07, 0x96, 0x4a, 0x38 } }, // 00011111 ddsomb.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x83 },  { 0x81, 0x9e, 0xc1, 0x22 },  { 0x89, 0x0b, 0x21, 0x08 } }, // 00100000 ddsomh.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x82 },  { 0x88, 0x25, 0x6a, 0x30 },  { 0xa5, 0x7d, 0x25, 0xd4 } }, // 00100001 ddsomj.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x81 },  { 0x79, 0xf2, 0xcf, 0x61 },  { 0x92, 0x83, 0xe4, 0x48 } }, // 00100010 ddsomu.key
  {     0x03,       { 0x78, 0xc2, 0x60, 0x20, 0x00, 0x0a },  { 0x6e, 0xb1, 0x4c, 0xa0 },  { 0x41, 0xff, 0x9b, 0x88 } }, // 00100011 ddtod.key
  {     0x03,       { 0x78, 0xc2, 0x60, 0x20, 0x00, 0x0a },  { 0x20, 0x82, 0x3a, 0x62 },  { 0x82, 0x0d, 0x4d, 0xec } }, // 00100100 ddtoda.key
  {     0x03,       { 0x78, 0xc2, 0x60, 0x20, 0x00, 0x08 },  { 0x1e, 0xee, 0x90, 0x5e },  { 0x60, 0x22, 0x5a, 0x60 } }, // 00100101 ddtodh.key
  {     0x03,       { 0x78, 0xc2, 0x60, 0x20, 0x00, 0x0a },  { 0xd1, 0x47, 0x5b, 0x3c },  { 0xe7, 0x9c, 0x22, 0x88 } }, // 00100110 ddtodj.key
  {     0x03,       { 0x78, 0xc2, 0x60, 0x20, 0x00, 0x08 },  { 0x3f, 0x5b, 0x38, 0x92 },  { 0xf0, 0xe6, 0x14, 0xdc } }, // 00100111 ddtodu.key
  {     0x05,       { 0xc9, 0xf4, 0x89, 0x36, 0x8d, 0xb7 },  { 0x52, 0xff, 0xa0, 0x50 },  { 0x09, 0xc7, 0x6e, 0xc0 } }, // 00101000 dimahoo.key
  {     0x05,       { 0xc9, 0xf4, 0x89, 0x36, 0x8d, 0xb6 },  { 0x25, 0x95, 0xfc, 0x36 },  { 0x6b, 0xd6, 0xba, 0x98 } }, // 00101001 dimahoou.key
  {     0x05,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x18 },  { 0x24, 0x34, 0x40, 0x00 },  { 0x57, 0x94, 0x6f, 0x20 } }, // 00101010 dstlk.key
  {     0x05,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x1a },  { 0x3a, 0x61, 0x11, 0x80 },  { 0x67, 0x06, 0xe8, 0x10 } }, // 00101011 dstlka.key
  {     0x05,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x19 },  { 0x56, 0x5a, 0x22, 0x01 },  { 0xfd, 0xf1, 0x89, 0x10 } }, // 00101100 dstlkh.key
  {     0x05,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x1a },  { 0x62, 0x39, 0x10, 0x20 },  { 0x3f, 0x5c, 0x05, 0xe0 } }, // 00101101 dstlku.key
  {     0x03,       { 0x70, 0x43, 0x00, 0x02, 0x8b, 0x38 },  { 0xa9, 0xb8, 0x65, 0x74 },  { 0xee, 0x30, 0x23, 0x24 } }, // 00101110 ecofghtr.key
  {     0x03,       { 0x70, 0x43, 0x00, 0x02, 0x8b, 0x39 },  { 0x30, 0xa9, 0xb8, 0x65 },  { 0x76, 0x30, 0x23, 0x24 } }, // 00101111 ecofghtra.key
  {     0x03,       { 0x70, 0x43, 0x00, 0x02, 0x8b, 0x3b },  { 0x0a, 0x9b, 0x86, 0x57 },  { 0x4e, 0x30, 0x23, 0x24 } }, // 00110000 ecofghtrh.key
  {     0x03,       { 0x70, 0x43, 0x00, 0x02, 0x8b, 0x3a },  { 0x9b, 0x86, 0x57, 0x4e },  { 0xde, 0x30, 0x23, 0x24 } }, // 00110001 ecofghtru.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x20 },  { 0x07, 0xac, 0x1b, 0x60 },  { 0x25, 0x1e, 0xd2, 0x9c } }, // 00110010 gigawing.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x20 },  { 0x5b, 0xb6, 0x35, 0x99 },  { 0x68, 0x55, 0x82, 0xb0 } }, // 00110011 gigawinga.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x22 },  { 0xe7, 0xfb, 0xdd, 0xa4 },  { 0x36, 0x8b, 0x9f, 0xc0 } }, // 00110100 gigawingb.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x22 },  { 0x87, 0x16, 0xc0, 0x0a },  { 0x21, 0x0b, 0x95, 0xcc } }, // 00110101 gigawingh.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x22 },  { 0xa4, 0x42, 0xbd, 0xf5 },  { 0x5a, 0x61, 0x92, 0x20 } }, // 00110110 gigawingj.key
  {     0x05,       { 0xc9, 0xf4, 0x89, 0x36, 0x8d, 0xb5 },  { 0x1b, 0x5e, 0x12, 0x18 },  { 0x69, 0xf7, 0xbf, 0xa4 } }, // 00110111 gmahou.key
  {     0x05,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x10 },  { 0xe4, 0x63, 0x15, 0xfe },  { 0xee, 0xe5, 0xb1, 0x68 } }, // 00111000 hsf2.key
  {     0x05,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x12 },  { 0xf1, 0x43, 0x1d, 0x54 },  { 0x31, 0xb2, 0xdc, 0x74 } }, // 00111001 hsf2a.key
  {     0x05,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x13 },  { 0x89, 0xf0, 0x77, 0x6c },  { 0x1f, 0xd0, 0x6e, 0x98 } }, // 00111010 hsf2j.key
  {     0x05,       { 0x04, 0xc1, 0x29, 0xb3, 0x3a, 0xa2 },  { 0x6b, 0xf1, 0xbd, 0x25 },  { 0x9d, 0x50, 0x94, 0xd8 } }, // 00111011 jyangoku.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x02, 0x02, 0x38 },  { 0x2a, 0x98, 0xb2, 0xdc },  { 0xd4, 0xe0, 0x28, 0x28 } }, // 00111100 megaman2.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x02, 0x02, 0x3a },  { 0xa1, 0x42, 0x79, 0xaf },  { 0x51, 0x44, 0xa3, 0xf0 } }, // 00111101 megaman2a.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x02, 0x02, 0x38 },  { 0x2c, 0x21, 0x02, 0x91 },  { 0x4f, 0x3a, 0xa9, 0xb8 } }, // 00111110 megaman2h.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x12 },  { 0x92, 0x90, 0x98, 0xa5 },  { 0x7f, 0x24, 0x4a, 0x80 } }, // 00111111 mmancp2u.key
  {     0x03,       { 0x0d, 0xb7, 0x88, 0xb7, 0xcd, 0x77 },  { 0xef, 0x98, 0x82, 0x0a },  { 0x7a, 0xf5, 0xe4, 0xd4 } }, // 01000000 mmatrix.key
  {     0x03,       { 0x0d, 0xb7, 0x88, 0xb7, 0xcd, 0x75 },  { 0x8a, 0xad, 0x7a, 0x6c },  { 0xd5, 0x2b, 0xb5, 0x50 } }, // 01000001 mmatrixa.key
  {     0x03,       { 0x0d, 0xb7, 0x88, 0xb7, 0xcd, 0x77 },  { 0x10, 0x66, 0xdd, 0x3a },  { 0xa5, 0xe0, 0x7e, 0xc8 } }, // 01000010 mmatrixj.key
  {     0x05,       { 0x84, 0xc2, 0xf8, 0xb3, 0x16, 0x47 },  { 0x61, 0x17, 0x8a, 0x9d },  { 0x8e, 0x0b, 0xbe, 0xa4 } }, // 01000011 mpang.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x83 },  { 0xa2, 0xea, 0xa7, 0x9d },  { 0x91, 0xde, 0x21, 0x60 } }, // 01000100 msh.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x82 },  { 0xf2, 0x8f, 0xa4, 0x72 },  { 0x03, 0x5d, 0x7a, 0x88 } }, // 01000101 msha.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x81 },  { 0x9c, 0x7f, 0x92, 0xd5 },  { 0xa0, 0x92, 0xa1, 0x78 } }, // 01000110 mshb.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x80 },  { 0x26, 0x0c, 0xe6, 0xb4 },  { 0x29, 0x68, 0xc8, 0xfc } }, // 01000111 mshh.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x81 },  { 0x0a, 0x12, 0xd6, 0x32 },  { 0x61, 0x04, 0x5e, 0x80 } }, // 01001000 mshj.key
  {     0x07,       { 0x04, 0xc1, 0x9a, 0x62, 0x60, 0x83 },  { 0x66, 0x33, 0xa1, 0x49 },  { 0xc9, 0x16, 0x83, 0x84 } }, // 01001001 mshu.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x23 },  { 0xf6, 0x93, 0xac, 0xe4 },  { 0x19, 0xd4, 0x87, 0x20 } }, // 01001010 mshvsf.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x20 },  { 0x6f, 0x7a, 0x48, 0xc2 },  { 0x19, 0x7f, 0x1d, 0x28 } }, // 01001011 mshvsfa.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x22 },  { 0x01, 0x1f, 0x3f, 0x6a },  { 0x4b, 0x8c, 0x59, 0x6c } }, // 01001100 mshvsfb.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x22 },  { 0xd2, 0x87, 0x57, 0x00 },  { 0x8f, 0xda, 0x25, 0xf8 } }, // 01001101 mshvsfh.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x20 },  { 0xb4, 0x1f, 0x91, 0x94 },  { 0x7e, 0x27, 0x0e, 0xe8 } }, // 01001110 mshvsfj.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x90, 0x20 },  { 0x53, 0x62, 0xbd, 0xce },  { 0x3a, 0x4a, 0xdb, 0x14 } }, // 01001111 mshvsfu.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x62, 0x12, 0x03 },  { 0x93, 0x7a, 0x58, 0xe1 },  { 0xed, 0x69, 0x00, 0x48 } }, // 01010000 mvsc.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x62, 0x12, 0x03 },  { 0xa2, 0xce, 0x82, 0x79 },  { 0x8d, 0xd4, 0x49, 0x3c } }, // 01010001 mvsca.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x62, 0x12, 0x00 },  { 0x67, 0xb5, 0x0e, 0x2b },  { 0x5d, 0xac, 0xb8, 0x40 } }, // 01010010 mvscb.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x62, 0x12, 0x03 },  { 0xdc, 0x63, 0x5a, 0x9f },  { 0x11, 0x78, 0xea, 0xe4 } }, // 01010011 mvsch.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x62, 0x12, 0x00 },  { 0x35, 0xf1, 0x23, 0xa4 },  { 0x72, 0x1a, 0x0f, 0xd4 } }, // 01010100 mvscj.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x62, 0x12, 0x02 },  { 0x80, 0x4e, 0x3d, 0xfb },  { 0x60, 0x8e, 0xd2, 0x58 } }, // 01010101 mvscu.key
  {     0x03,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x1a },  { 0x81, 0x68, 0x3f, 0x02 },  { 0x8a, 0x2e, 0x60, 0x20 } }, // 01010110 nwarr.key
  {     0x03,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x18 },  { 0x96, 0x18, 0x76, 0x70 },  { 0xc2, 0xc0, 0xa5, 0xc8 } }, // 01010111 nwarra.key
  {     0x03,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x18 },  { 0x11, 0x51, 0xb3, 0xb6 },  { 0x42, 0x39, 0x8f, 0xa0 } }, // 01011000 nwarrb.key
  {     0x03,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x18 },  { 0x10, 0x18, 0xa5, 0x52 },  { 0x03, 0x61, 0xa4, 0x8c } }, // 01011001 nwarrh.key
  {     0x03,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x19 },  { 0xe1, 0x7b, 0x63, 0xf0 },  { 0xc2, 0xf9, 0x48, 0x20 } }, // 01011010 nwarru.key
  {     0x05,       { 0x04, 0xc0, 0xbb, 0xe1, 0x22, 0xc3 },  { 0xac, 0xa7, 0xc4, 0x30 },  { 0x0f, 0x5d, 0x2f, 0xa4 } }, // 01011011 pfghtj.key
  {     0x07,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x09 },  { 0xe7, 0xe0, 0x42, 0x71 },  { 0x47, 0x40, 0xca, 0xe4 } }, // 01011100 pgear.key
  {     0x02,       { 0x04, 0xc2, 0x17, 0x1b, 0x2c, 0x77 },  { 0x3e, 0xc3, 0x23, 0xdd },  { 0x8c, 0x6d, 0x67, 0x18 } }, // 01011101 progear.key
  {     0x02,       { 0x04, 0xc2, 0x17, 0x1b, 0x2c, 0x75 },  { 0xeb, 0x64, 0xee, 0xfc },  { 0x52, 0x35, 0x46, 0x98 } }, // 01011110 progeara.key
  {     0x02,       { 0x04, 0xc2, 0x17, 0x1b, 0x2c, 0x75 },  { 0xf7, 0x8b, 0x7e, 0x71 },  { 0xa8, 0xed, 0xfb, 0xe4 } }, // 01011111 progearj.key
  {     0x01,       { 0x04, 0xc3, 0x39, 0x66, 0x3e, 0xa0 },  { 0xb5, 0xb2, 0xc0, 0x8d },  { 0x20, 0x7c, 0xa8, 0x14 } }, // 01100000 pzloop2.key
  {     0x07,       { 0x04, 0xc3, 0x3a, 0x63, 0x90, 0x40 },  { 0x67, 0x83, 0x59, 0xbf },  { 0x39, 0x5c, 0x80, 0x68 } }, // 01100001 qndream.key
  {     0x04,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x0b },  { 0x02, 0x48, 0x8b, 0xa3 },  { 0x93, 0x80, 0xa6, 0x60 } }, // 01100010 ringdest.key
  {     0x04,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x0b },  { 0x02, 0x12, 0x8b, 0xa3 },  { 0x93, 0x80, 0xa6, 0x60 } }, // 01100011 ringdesta.key
  {     0x04,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x0b },  { 0x00, 0x73, 0x8b, 0xa3 },  { 0x93, 0x80, 0xa6, 0x60 } }, // 01100100 ringdesth.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x10 },  { 0x2d, 0x31, 0x7f, 0xb2 },  { 0x02, 0xaa, 0x13, 0x80 } }, // 01100101 rmancp2j.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x02, 0x02, 0x38 },  { 0x39, 0x22, 0xa8, 0x23 },  { 0x39, 0x4d, 0xe6, 0x30 } }, // 01100110 rockman2j.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x13 },  { 0x61, 0x73, 0x90, 0x8d },  { 0xda, 0xea, 0x47, 0xc0 } }, // 01100111 sfa.key
  {     0x05,       { 0x04, 0xc2, 0x70, 0x33, 0x07, 0xa6 },  { 0x7e, 0x1f, 0x7f, 0x70 },  { 0xe7, 0xcd, 0x48, 0xfc } }, // 01101000 sfa2.key
  {     0x05,       { 0x04, 0xc2, 0x70, 0x33, 0x07, 0xa5 },  { 0x4a, 0x18, 0xbd, 0x45 },  { 0xa6, 0xf3, 0xf7, 0x60 } }, // 01101001 sfa2u.key
  {     0x05,       { 0x04, 0xc1, 0x18, 0xe0, 0x56, 0xbe },  { 0x0e, 0xec, 0x07, 0x90 },  { 0x1c, 0x4f, 0xf5, 0x58 } }, // 01101010 sfa3.key
  {     0x05,       { 0x04, 0xc1, 0x18, 0xe0, 0x56, 0xbd },  { 0xa5, 0x2d, 0xa2, 0x05 },  { 0x34, 0x0e, 0x10, 0xac } }, // 01101011 sfa3b.key
  {     0x05,       { 0x04, 0xc1, 0x18, 0xe0, 0x56, 0xbe },  { 0x1b, 0x17, 0xa3, 0x78 },  { 0xc7, 0xed, 0x10, 0x84 } }, // 01101100 sfa3h.key
  {     0x05,       { 0x04, 0xc1, 0x18, 0xe0, 0x56, 0xbc },  { 0x49, 0x30, 0xa7, 0x9a },  { 0x9c, 0x3f, 0x77, 0x9c } }, // 01101101 sfa3u.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x10 },  { 0x60, 0x0b, 0xcf, 0xa5 },  { 0xb2, 0xd5, 0xf6, 0x90 } }, // 01101110 sfau.key
  {     0x05,       { 0x04, 0xc2, 0x70, 0x33, 0x07, 0xa7 },  { 0x84, 0xa4, 0x7b, 0x08 },  { 0xbc, 0x5d, 0x0f, 0xd4 } }, // 01101111 sfz2a.key
  {     0x05,       { 0x04, 0xc3, 0x39, 0xc4, 0x22, 0x25 },  { 0x96, 0x11, 0x80, 0x80 },  { 0x2c, 0x0d, 0x3a, 0x3c } }, // 01110000 sfz2al.key
  {     0x05,       { 0x04, 0xc3, 0x39, 0xc4, 0x22, 0x24 },  { 0xe3, 0xd7, 0x07, 0xfc },  { 0x51, 0x4a, 0xcf, 0x38 } }, // 01110001 sfz2alb.key
  {     0x05,       { 0x04, 0xc3, 0x39, 0xc4, 0x22, 0x25 },  { 0x8c, 0x40, 0xc0, 0x10 },  { 0xfb, 0x6a, 0x3e, 0xa4 } }, // 01110010 sfz2alh.key
  {     0x05,       { 0x04, 0xc3, 0x39, 0xc4, 0x22, 0x26 },  { 0xc8, 0xd1, 0x40, 0x14 },  { 0x44, 0xc2, 0x8a, 0x64 } }, // 01110011 sfz2alj.key
  {     0x05,       { 0x04, 0xc2, 0x70, 0x33, 0x07, 0xa5 },  { 0xd3, 0x74, 0x7e, 0x1a },  { 0x66, 0x8b, 0x20, 0xd4 } }, // 01110100 sfz2b.key
  {     0x05,       { 0x04, 0xc2, 0x70, 0x33, 0x07, 0xa7 },  { 0xe4, 0x43, 0x7a, 0x69 },  { 0x0a, 0xd1, 0x46, 0x7c } }, // 01110101 sfz2h.key
  {     0x05,       { 0x04, 0xc2, 0x70, 0x33, 0x07, 0xa6 },  { 0x22, 0x13, 0xb9, 0x6e },  { 0x65, 0xf8, 0xbf, 0x04 } }, // 01110110 sfz2j.key
  {     0x05,       { 0x04, 0xc2, 0x70, 0x33, 0x07, 0xa4 },  { 0xed, 0x8b, 0x7a, 0x94 },  { 0xe4, 0x7f, 0x53, 0x1c } }, // 01110111 sfz2n.key
  {     0x05,       { 0x04, 0xc1, 0x18, 0xe0, 0x56, 0xbd },  { 0xf8, 0xd0, 0x9c, 0x96 },  { 0x03, 0x27, 0x42, 0x64 } }, // 01111000 sfz3a.key
  {     0x05,       { 0x04, 0xc1, 0x18, 0xe0, 0x56, 0xbe },  { 0x7a, 0xd1, 0xf4, 0xc3 },  { 0x00, 0x7e, 0x4a, 0xf8 } }, // 01111001 sfz3j.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x13 },  { 0xf9, 0x67, 0x61, 0x18 },  { 0x42, 0x8e, 0xf0, 0x9c } }, // 01111010 sfza.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x10 },  { 0x05, 0x8d, 0x25, 0x7b },  { 0x2f, 0x6a, 0x0b, 0xdc } }, // 01111011 sfzb.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x12 },  { 0x2f, 0xc9, 0x14, 0xea },  { 0x71, 0xc3, 0x5b, 0x84 } }, // 01111100 sfzh.key
  {     0x05,       { 0x04, 0xc0, 0x9a, 0x80, 0xa6, 0x12 },  { 0x8b, 0xc1, 0xe5, 0x0d },  { 0x79, 0xa3, 0x36, 0xc4 } }, // 01111101 sfzj.key
  {     0x05,       { 0x04, 0xc0, 0xbb, 0xe1, 0x22, 0xc1 },  { 0xfb, 0x77, 0xc1, 0xe9 },  { 0xba, 0x4b, 0x10, 0x84 } }, // 01111110 sgemf.key
  {     0x05,       { 0x04, 0xc0, 0xbb, 0xe1, 0x22, 0xc3 },  { 0x26, 0x5d, 0xf8, 0x8d },  { 0x52, 0x0b, 0x42, 0x40 } }, // 01111111 sgemfa.key
  {     0x05,       { 0x04, 0xc0, 0xbb, 0xe1, 0x22, 0xc0 },  { 0x91, 0x2f, 0xc4, 0xfb },  { 0x63, 0x97, 0x1a, 0x04 } }, // 10000000 sgemfh.key
  {     0x04,       { 0x70, 0x30, 0x04, 0x00, 0x10, 0x0b },  { 0x00, 0xa3, 0x03, 0xa2 },  { 0x41, 0x00, 0xa6, 0x60 } }, // 10000001 smbomb.key
  {     0x08,       { 0x04, 0xc2, 0x70, 0x32, 0x60, 0x67 },  { 0x9d, 0xe1, 0x06, 0xaa },  { 0x43, 0xd9, 0x1e, 0xec } }, // 10000010 spf2t.key
  {     0x08,       { 0x04, 0xc2, 0x70, 0x32, 0x60, 0x67 },  { 0x7c, 0xb3, 0xc1, 0xaf },  { 0x56, 0x1c, 0x48, 0xe4 } }, // 10000011 spf2ta.key
  {     0x08,       { 0x04, 0xc2, 0x70, 0x32, 0x60, 0x65 },  { 0xb6, 0x87, 0xc5, 0x13 },  { 0x54, 0xc6, 0xde, 0x28 } }, // 10000100 spf2th.key
  {     0x08,       { 0x04, 0xc2, 0x70, 0x32, 0x60, 0x66 },  { 0x86, 0x0f, 0xc2, 0xf8 },  { 0x2b, 0x85, 0x58, 0x38 } }, // 10000101 spf2tu.key
  {     0x08,       { 0x04, 0xc2, 0x70, 0x32, 0x60, 0x67 },  { 0xfd, 0xba, 0x42, 0x5d },  { 0x6b, 0x04, 0xd2, 0x34 } }, // 10000110 spf2xj.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x12 },  { 0x03, 0xde, 0xcf, 0x56 },  { 0x47, 0x9a, 0x8b, 0x10 } }, // 10000111 ssf2.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x11 },  { 0x20, 0x3d, 0xec, 0xf5 },  { 0x64, 0x79, 0xa8, 0xb0 } }, // 10001000 ssf2a.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x10 },  { 0xb1, 0x20, 0x3d, 0xec },  { 0xf5, 0x64, 0x79, 0xa8 } }, // 10001001 ssf2h.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x13 },  { 0xde, 0xcf, 0x56, 0x47 },  { 0x9a, 0x8b, 0x12, 0x00 } }, // 10001010 ssf2j.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x10 },  { 0xf0, 0xa3, 0x2d, 0xa9 },  { 0x03, 0x05, 0xc8, 0xa4 } }, // 10001011 ssf2t.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x12 },  { 0x38, 0xa1, 0x49, 0x99 },  { 0x00, 0x2c, 0x8c, 0xa4 } }, // 10001100 ssf2ta.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x13 },  { 0x9a, 0x8b, 0x12, 0x03 },  { 0xde, 0xcf, 0x56, 0x44 } }, // 10001101 ssf2tb.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x10 },  { 0x79, 0xa8, 0xb1, 0x20 },  { 0x3d, 0xec, 0xf5, 0x64 } }, // 10001110 ssf2tba.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x11 },  { 0x64, 0x79, 0xa8, 0xb1 },  { 0x20, 0x3d, 0xec, 0xf4 } }, // 10001111 ssf2tbh.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x12 },  { 0x8b, 0x12, 0x03, 0xde },  { 0xcf, 0x56, 0x47, 0x98 } }, // 10010000 ssf2tbj.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x11 },  { 0xa8, 0xb1, 0x20, 0x3d },  { 0xec, 0xf5, 0x64, 0x78 } }, // 10010001 ssf2tbu.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x11 },  { 0x30, 0xa2, 0x12, 0xb9 },  { 0x02, 0xd1, 0xc0, 0xa4 } }, // 10010010 ssf2th.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x13 },  { 0xf0, 0xa3, 0xb8, 0xc9 },  { 0x02, 0x45, 0x7c, 0xa4 } }, // 10010011 ssf2tu.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x10 },  { 0x3d, 0xec, 0xf5, 0x64 },  { 0x79, 0xa8, 0xb1, 0x20 } }, // 10010100 ssf2u.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x11 },  { 0xc0, 0xa0, 0xd6, 0x81 },  { 0x03, 0xa9, 0x50, 0xa4 } }, // 10010101 ssf2xj.key
  {     0x00,       { 0x70, 0x43, 0x80, 0x00, 0x00, 0x11 },  { 0x10, 0xa2, 0xcd, 0x79 },  { 0x03, 0x50, 0xf0, 0xa4 } }, // 10010110 ssf2xjr1r.key
  {     0x03,       { 0x70, 0x43, 0x00, 0x02, 0x8b, 0x39 },  { 0xb8, 0x65, 0x74, 0xed },  { 0xfe, 0x30, 0x23, 0x24 } }, // 10010111 uecology.key
  {     0x05,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x19 },  { 0xd6, 0x60, 0x59, 0x00 },  { 0x80, 0x43, 0x4f, 0xdc } }, // 10011000 vampj.key
  {     0x05,       { 0x04, 0xc1, 0x25, 0x80, 0x1b, 0x80 },  { 0x63, 0xc2, 0x35, 0x93 },  { 0x17, 0x5e, 0x0d, 0xb0 } }, // 10011001 vhunt2.key
  {     0x03,       { 0x70, 0x40, 0x00, 0x00, 0x1a, 0x19 },  { 0x3f, 0xae, 0x5c, 0x97 },  { 0x0d, 0x36, 0xb2, 0x20 } }, // 10011010 vhuntj.key
  {     0x05,       { 0x04, 0xc1, 0x59, 0x3b, 0xd7, 0x48 },  { 0x3b, 0x75, 0x76, 0x3a },  { 0x04, 0x6a, 0xcc, 0x1c } }, // 10011011 vsav.key
  {     0x05,       { 0x04, 0xc1, 0x25, 0x80, 0x1b, 0x83 },  { 0xed, 0xe3, 0xb0, 0x18 },  { 0xbc, 0x9e, 0x05, 0xac } }, // 10011100 vsav2.key
  {     0x05,       { 0x04, 0xc1, 0x59, 0x3b, 0xd7, 0x48 },  { 0xd5, 0x20, 0xb4, 0x24 },  { 0x32, 0x65, 0xdf, 0x88 } }, // 10011101 vsava.key
  {     0x05,       { 0x04, 0xc1, 0x59, 0x3b, 0xd7, 0x48 },  { 0x77, 0x2e, 0xf0, 0xf1 },  { 0x51, 0x17, 0xbf, 0x60 } }, // 10011110 vsavb.key
  {     0x05,       { 0x04, 0xc1, 0x59, 0x3b, 0xd7, 0x4a },  { 0xed, 0x57, 0xb7, 0x2e },  { 0xc4, 0xfb, 0x2d, 0x34 } }, // 10011111 vsavh.key
  {     0x05,       { 0x04, 0xc1, 0x59, 0x3b, 0xd7, 0x4a },  { 0x76, 0x04, 0x74, 0x97 },  { 0x31, 0xcb, 0xc5, 0x7c } }, // 10100000 vsavj.key
  {     0x05,       { 0x04, 0xc1, 0x59, 0x3b, 0xd7, 0x49 },  { 0x9f, 0x01, 0xf3, 0xa9 },  { 0xdc, 0x15, 0xd1, 0x94 } }, // 10100001 vsavu.key
  {     0x05,       { 0x04, 0xc1, 0x3a, 0x62, 0x03, 0x02 },  { 0x29, 0x00, 0x7f, 0xa4 },  { 0x96, 0xdd, 0x8f, 0x70 } }, // 10100010 xmcota.key
  {     0x05,       { 0x04, 0xc1, 0x3a, 0x62, 0x03, 0x00 },  { 0xe1, 0x87, 0xf3, 0x6d },  { 0x1c, 0x96, 0xa7, 0x80 } }, // 10100011 xmcotaa.key
  {     0x05,       { 0x04, 0xc1, 0x3a, 0x62, 0x03, 0x00 },  { 0xa9, 0x65, 0xac, 0xe3 },  { 0x10, 0x1f, 0xf7, 0x84 } }, // 10100100 xmcotab.key
  {     0x05,       { 0x04, 0xc1, 0x3a, 0x62, 0x03, 0x03 },  { 0xa1, 0x35, 0xa4, 0x14 },  { 0xb0, 0xec, 0x5e, 0xbc } }, // 10100101 xmcotah.key
  {     0x05,       { 0x04, 0xc1, 0x3a, 0x62, 0x03, 0x01 },  { 0xe6, 0xcf, 0x47, 0xd6 },  { 0xa3, 0x39, 0x01, 0x88 } }, // 10100110 xmcotaj.key
  {     0x05,       { 0x04, 0xc1, 0x3a, 0x62, 0x03, 0x03 },  { 0x4b, 0xda, 0x00, 0x66 },  { 0xcd, 0xfa, 0x95, 0x30 } }, // 10100111 xmcotau.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x93, 0x01 },  { 0x5c, 0xd5, 0x37, 0xf2 },  { 0x62, 0x87, 0xce, 0xf4 } }, // 10101000 xmvsf.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x93, 0x00 },  { 0x26, 0xdf, 0x56, 0x61 },  { 0xf0, 0xfc, 0x70, 0xb8 } }, // 10101001 xmvsfa.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x93, 0x00 },  { 0x3c, 0x86, 0x10, 0x35 },  { 0x49, 0xe6, 0xd5, 0xc4 } }, // 10101010 xmvsfb.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x93, 0x03 },  { 0xb2, 0x25, 0x7d, 0x08 },  { 0x2d, 0x37, 0xeb, 0x04 } }, // 10101011 xmvsfh.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x93, 0x00 },  { 0xd7, 0x3b, 0x02, 0x10 },  { 0xf7, 0x27, 0xec, 0x70 } }, // 10101100 xmvsfj.key
  {     0x07,       { 0x04, 0xc1, 0x3a, 0x63, 0x93, 0x02 },  { 0x0f, 0x72, 0x98, 0x7d },  { 0x2f, 0x03, 0x4f, 0xc8 } }, // 10101101 xmvsfu.key

  // also used with invalid jumper configs
  {     0x09,       { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },  { 0xff, 0xff, 0xff, 0xff },  { 0xff, 0xff, 0xff, 0xff } }, // 10101110 phoenix.key
    
};

void setup() { 

  delay(500);
  
  // set the programming pins as outputs
  PORTB.DIR = PIN0_bm | PIN1_bm | PIN2_bm | PIN3_bm;

  // enable pull-ups on jumper pins
  PORTA.PIN0CTRL |= PORT_PULLUPEN_bm;
  PORTA.PIN1CTRL |= PORT_PULLUPEN_bm;
  PORTA.PIN2CTRL |= PORT_PULLUPEN_bm;
  PORTA.PIN3CTRL |= PORT_PULLUPEN_bm;
  PORTA.PIN4CTRL |= PORT_PULLUPEN_bm;
  PORTA.PIN5CTRL |= PORT_PULLUPEN_bm;
  PORTA.PIN6CTRL |= PORT_PULLUPEN_bm;
  PORTA.PIN7CTRL |= PORT_PULLUPEN_bm;

  // go into programming mode
  CLR_CLOCK;
  CLR_DATA;
  SET_SETUP;
  CLR_RESET;

  delay(100);

  uint8_t  [MASK]  = read_jumpers();
  if( [MASK]  > MAX_GAME_NUM) {
     [MASK]  = MAX_GAME_NUM;
  }

  for(uint8_t i = 0; i < CONFIG_SIZE; i++) {
    send_byte(config_table[game_data[ [MASK] ].config_table_index][i]);
  }

  for(uint8_t i = 0; i < WATCHDOG_SIZE; i++) {
    send_byte(game_data[ [MASK] ].watchdog[i]);
  }

  for(uint8_t i = 0; i < KEY_SIZE; i++) {
    send_byte(game_data[ [MASK] ].key2[i]);
  }

  for(uint8_t i = 0; i < KEY_SIZE; i++) {
    send_byte(game_data[ [MASK] ].key1[i]);
  }

  // exit programming mode
  CLR_SETUP;
  SET_RESET;
  CLR_CLOCK;
  CLR_DATA;

  // set all output pins as inputs
  PORTB.DIR = 0;

  // power down
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();
  sleep_cpu();    
}

void loop() {
}

void send_byte(uint8_t data) {
  for(int8_t bit_num = 7; bit_num >= 0;bit_num--) { 
    uint8_t bit = data & masks[bit_num];
    if(bit) {
      SET_DATA;
    } else {
      CLR_DATA;
    }
    
    SET_CLOCK;
    CLR_CLOCK;
  }
}

// JP1 = PA7 = bit7
// JP2 = PA6 = bit6
// JP3 = PA5 = bit5
// JP4 = PA6 = bit4
// JP5 = PA0 = bit3
// JP6 = PA1 = bit2
// JP7 = PA2 = bit1
// JP8 = PA3 = bit0
uint8_t read_jumpers() {
  uint8_t jumpers = 0;
  uint8_t raw;
  uint8_t bit;

  // negate the bits since we are using
  // pull-ups, jumper'd will be low
  raw = PORTA.IN ^ 0xff;

  // upper nible is in the correct order, but lower isnt
  jumpers = raw & 0xf0;

  // reverse the order of the lower nibble
  bit = (raw & 0x1) << 3;
  jumpers = jumpers | bit;

  bit = (raw & 0x2) << 1;
  jumpers = jumpers | bit;

  bit = (raw & 0x4) >> 1;
  jumpers = jumpers | bit;

  bit = (raw & 0x8) >> 3;
  jumpers = jumpers | bit;

  return jumpers;
}
",game_num
60,"// Fill out your copyright notice in the Description page of Project Settings.

//#include ""SCharacter.h""
#include ""../Public/SCharacter.h""
#include ""Camera/CameraComponent.h""
#include ""GameFramework/SpringArmComponent.h""
#include ""GameFramework/PawnMovementComponent.h""
#include ""../Public/SWeapon.h""
#include ""Engine/Engine.h""
#include ""CoopGame.h""
#include ""Components/CapsuleComponent.h""
// Sets default values
ASCharacter::ASCharacter()
{
 	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	CameraComp = CreateDefaultSubobject<UCameraComponent>(TEXT(""CameraComp""));

	SpringArmComp = CreateDefaultSubobject<USpringArmComponent>(TEXT(""SpringArm""));
	SpringArmComp->SetupAttachment(RootComponent);

	//CameraComp->bUsePawnControlRotation = true;
	CameraComp->SetupAttachment(SpringArmComp);

	GetMovementComponent()->GetNavAgentPropertiesRef().bCanCrouch = true;

	GetCapsuleComponent()->SetCollisionResponseToChannel(WEAPONCOLLISIONCHANNEL, ECR_Ignore);

	ZoomedFOV = 65.0f;
	ZoomInterpSpeed = 20.0f;
}

// Called when the game starts or when spawned
void ASCharacter::BeginPlay()
{
	Super::BeginPlay();
	
	DefaultFOV = CameraComp->FieldOfView;
	
	GenWeapon(Weapon1);
}

void ASCharacter::MoveForward(float value)
{
	AddMovementInput(GetActorForwardVector() * value);
}

void ASCharacter::MoveRight(float value)
{
	AddMovementInput(GetActorRightVector() * value);
}

void ASCharacter::BeginCrouch()
{
	Crouch();
}


void ASCharacter::EndCrouch()
{
	UnCrouch();
}

void ASCharacter::BeginZoom()
{
	bWantsToZoom = true;
}

void ASCharacter::EndZoom()
{
	bWantsToZoom = false;
}

//void ASCharacter::Fire()
//{
//	if (CurrentWeapon)
//	{
//		CurrentWeapon->Fire();
//	}
//}


void ASCharacter::SwitchWeapons(FKey Key)
{
	//FString KeyName = Key.ToString();
	//UE_LOG(LogTemp, Log, TEXT(""%s""), *KeyName);
	//GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, FString::Printf(TEXT(""%s""), *KeyName));
	if (CurrentWeapon)
	{
		CurrentWeapon->Destroy();
	}
	if (Key == EKeys::One)
	{
		GenWeapon(Weapon1);
		return;
	}

	if (Key == EKeys::Two)
	{
		GenWeapon(Weapon2);
		return;
	}
}

void ASCharacter::GenWeapon(TSubclassOf<ASWeapon>& Weapon)
{
	if (Weapon)
	{
		FActorSpawnParameters SpawnParams;
		SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
		CurrentWeapon = GetWorld()->SpawnActor<ASWeapon>(Weapon, FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams);

		if (CurrentWeapon)
		{
			CurrentWeapon->SetOwner(this);
			CurrentWeapon->AttachToComponent(GetMesh(), FAttachmentTransformRules::SnapToTargetNotIncludingScale, CurrentWeapon->CharaterAttachSockName);
		}
	}
}

void ASCharacter::StartFire()
{
	if (CurrentWeapon)
	{
		CurrentWeapon->StartFire();
	}
}

void ASCharacter::StopFire()
{
	if (CurrentWeapon)
	{
		CurrentWeapon->StopFire();
	}
}

// Called every frame
void ASCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

	float  [MASK]  = bWantsToZoom ? ZoomedFOV : DefaultFOV;
	float CurrentFOV = FMath::FInterpTo(CameraComp->FieldOfView,  [MASK] , DeltaTime, ZoomInterpSpeed);
	CameraComp->SetFieldOfView(CurrentFOV);
}

// Called to bind functionality to input
void ASCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	PlayerInputComponent->BindAxis(""MoveForward"", this, &ASCharacter::MoveForward);
	PlayerInputComponent->BindAxis(""MoveRight"", this, &ASCharacter::MoveRight);
	PlayerInputComponent->BindAxis(""LookUp"", this, &ASCharacter::AddControllerPitchInput);
	PlayerInputComponent->BindAxis(""Turn"", this, &ASCharacter::AddControllerYawInput);

	PlayerInputComponent->BindAction(""Crouch"", IE_Pressed, this, &ASCharacter::BeginCrouch);
	PlayerInputComponent->BindAction(""Crouch"", IE_Released, this, &ASCharacter::EndCrouch);
	
	PlayerInputComponent->BindAction(""Jump"", IE_Pressed, this, &ASCharacter::Jump);

	PlayerInputComponent->BindAction(""Zoom"", IE_Pressed, this, &ASCharacter::BeginZoom);
	PlayerInputComponent->BindAction(""Zoom"", IE_Released, this, &ASCharacter::EndZoom);

	PlayerInputComponent->BindAction(""Fire"", IE_Pressed, this, &ASCharacter::StartFire);
	PlayerInputComponent->BindAction(""Fire"", IE_Released, this, &ASCharacter::StopFire);

	PlayerInputComponent->BindAction(""SwitchWeapons"", IE_Pressed, this, &ASCharacter::SwitchWeapons);
}

FVector ASCharacter::GetPawnViewLocation() const
{
	if (CameraComp)
	{
		return CameraComp->GetComponentLocation();
	}

	return Super::GetPawnViewLocation();
}

",TargetFOV
61,"#include <iostream>
#include <filesystem>
#include <fstream>
#include <vector>
using namespace std;

ifstream inputFileObj;
ofstream outputFileObj;

int main() {
	namespace fs = std::filesystem;
	double sum = 0;
	double average = 0;
	// long numberbuffer = 0;
	std::string stringbuffer;
	vector<long> values;
	vector<std::string> lines;
	
	fs::path nums_path(""numbers.txt"");
	fs::path input_strings_path(""InputStrings.txt"");
	fs::path  [MASK] (""RandomStrings.txt"");
	
	inputFileObj.open(nums_path);
	
	if (inputFileObj.is_open()) {
		
		cout << ""Contents of file numbers.txt:"" << endl;
		
		while (std::getline(inputFileObj, stringbuffer)) {
			if (stringbuffer.empty()) {
				continue;
			}
			
			cout << ""["" << stringbuffer << ""]"" << endl;
			
			values.push_back(std::stol(stringbuffer));
		}
		
		for (long num : values) {
			sum += num;
		}
		
		average = sum / values.size();
		
		inputFileObj.close();
	} else { cerr << ""Error opening file.\n""; }
	
	
	cout << ""\n[=][=][=][=][=][=][=][=][=][=][=][=][=][=][=][=][=][=]\n"" << endl;
	
	
	inputFileObj.open(input_strings_path);
	
	if (inputFileObj.is_open()) {
		
		cout << ""Contents of file InputStrings.txt:"" << endl;
		while (std::getline(inputFileObj, stringbuffer)) {
			if (stringbuffer.empty()) {
				continue;
			}
			
			cout << ""["" << stringbuffer << ""]"" << endl;
			
			lines.push_back(stringbuffer);
		}
	} else { cerr << ""Error opening file.\n""; }
	
	cout << endl;
	
	
	
	cout << ""Strings in InputStrings.txt:"" << endl;
	for (std::string line : lines) {
		cout << line << endl;
	}
	
	cout << endl;
	
	printf(""Number of values: %d \n"", (int) values.size());
	printf(""Sum of values: %.2f \n"", sum);
	printf(""Average of values: %.2f \n"", average);
	
	//Creates a file called ""RandomStrings.txt"" in the project's DerivedData folder.
	outputFileObj.open( [MASK] );
	for (int i = 0; i < 1000; i++) {
		outputFileObj << ""Whooooaaaa duuuude!!\n"";
	}
	outputFileObj.close();
	
	printf(""Program done!\n"");
	
	return EXIT_SUCCESS;
}
",input_random_strings_path
62,"#ifndef _RESOURCEPOOL_H
#define _RESOURCEPOOL_H

#include <map>
#include <list>
#include <set>
#include <vector>

#include <boost/thread.hpp>
#include <boost/foreach.hpp>
#include <boost/timer.hpp>
#include <boost/circular_buffer.hpp>

#include ""ResourcePoolConfig.h""

namespace bt = boost::this_thread;
namespace bpt = boost::posix_time;


namespace common_pool
{
    template<class T> class ResourcePool;
    
    template<class T>
    class ResourceWrapper
    {
    public:
        ResourceWrapper(T *t_, ResourcePool<T> *pool, long expireMillis_)
        {
            t = t_;
            resourcePool = pool;
            updateLastestUseTime();
            expireMillis = expireMillis_;
            lastestUseTime = (long)clock.elapsed();
        };

        virtual ~ResourceWrapper()
        {
            if (t != NULL)
            {
                destory();
            }
        };

        //If the resource needs to be reclaimed
        //You can override this function
        virtual bool expired()
        {
            return (clock.elapsed() - lastestUseTime) * 1000.0 > (double)expireMillis;
        };

        //If a resource needs to be managed
        virtual bool valid()
        {
            return true;
        }

        T *get()
        {
            updateLastestUseTime();
            return t;
        };

        virtual void destory()
        {
            t = NULL;
            resourcePool->recliam(this);
        };

        void updateLastestUseTime()
        {
            lastestUseTime = clock.elapsed();
        };

    private:
        T *t;
        long expireMillis;
        boost::timer clock;
        double lastestUseTime;
        ResourcePool<T> *resourcePool;
    }; //class ResourceWrapper

    template<class T>
    class ResourcePool
    {
        typedef ResourceWrapper<T> Res;

    public:

        ResourcePool(ResourcePoolConfig &poolConfig)
        {
            started = false;
            config = poolConfig;

            resourceNum = 0;
            managedNum = 0;

            for (int i = 0; i < config.getPoolSize(); i++)
            {
                expand();
            }

            minAvailableNum = config.getInitPoolSize();

            started = true;

            //Create reclaim thread
            boost::thread(&common_pool::ResourcePool<T>::relaimIdleResource, this, config.getReclaimInterval());
            
            //Create refurbish thread
            boost::thread(&common_pool::ResourcePool<T>::refurbish, this, config.getRefurbishInterval());

            //Create shrink thread
            boost::thread(&common_pool::ResourcePool<T>::shrink, this, config.getShrinkInterval());
        }

        ~ResourcePool()
        {
            close();
        };
        
        //Get the number of managed resources
        int getManagedNum()
        {
            return managed.size();
        };

        //Get the number of unused resources
        int getUnusedNum()
        {
            return unused.size();
        };

        //Get the number of excluded resources
        int getExcludedNum()
        {
            return excluded.size();
        };

        //Get the number of resources
        int getResourceNum()
        {
            return resourceNum;
        };

        //Get resource pool configuration
        ResourcePoolConfig& getConfig()
        {
            return config;
        };

        virtual Res *genResource()
        {
            Res *res = NULL;

            if (unused.size() > 0)
            {
                T *t = *(unused.begin());
                unused.pop_front();
                if (t != NULL)
                {
                    res = new Res(t, this, config.getExpireMillis());
                    boost::lock_guard<boost::recursive_mutex> reclaimLock(reclaimMutex);
                    managed[res] = t;
                    managedNum++;
                }

                if ((int)unused.size() < minAvailableNum)
                {
                    minAvailableNum = (int)unused.size();
                }
            }

            return res;
        };

        //Reclaim a resource
        virtual void recliam(Res *resource)
        {
            if (resource != NULL)
            {
                boost::lock_guard<boost::recursive_mutex> reclaimLock(reclaimMutex);
                excluded.insert(managed[resource]);
                managed[resource] = NULL;
                resourceNum--;
            }
        };

    protected:

        //Add a resource object the pool
        virtual void expand()
        {
            T *t = new T;
            if (t != NULL)
            {
                unused.push_back(t);
            }
        };


        //Refurbish resources
        void refurbish(long interval)
        {
            while (started)
            {
                bt::sleep(bpt::milliseconds(interval));

                //Refurbish when system is available
                if (!getResMutex.try_lock())
                {
                    continue;;
                }
                if (!reclaimMutex.try_lock())
                {
                    getResMutex.unlock();
                }

                //Refurbish available resources
                if (unused.size() > 0)
                {
                    list<T*>::iterator iter = unused.begin();
                    list<T*>::iterator swapIter;
                    while (iter != unused.end())
                    {
                        swapIter = iter;
                        iter++;
                        refurbishOne(**iter);
                    }
                }
                reclaimMutex.unlock();
                getResMutex.unlock();
            }
        };


        //Refurbish a single resource object
        virtual void refurbishOne(T &t) {};


        //Shrink the pool to release redundant resources
        void shrink(long interval)
        {
            long windowNum = config.getShrinkWindow() / interval;
            boost::circular_buffer<int> windowRemain((int) windowNum);
            float meanRemain = (float)minAvailableNum;

            while (started)
            {
                bt::sleep(bpt::milliseconds(interval));

                doCheckinExcluded();
                windowRemain.push_back(minAvailableNum);

                boost::lock_guard<boost::recursive_mutex> lock(getResMutex);
                {
                    unsigned int shrinkSize = (unsigned int)getShrinkThreshold(windowRemain, meanRemain);
                    boost::lock_guard<boost::recursive_mutex> reclaimLock(reclaimMutex);

                    while (unused.size() > shrinkSize)
                    {
                        T *t = unused.back();
                        unused.pop_back();
                        delete t;
                        resourceNum--;
                    }
                    minAvailableNum = resourceNum;
                }
            }
        };

        //Remove a resource object out of the pool
        void removeResource()
        {
            T* t = unused.back();
            unused.pop_back();
            delete t;
        };

        //Put exclude resources in unused space
        void doCheckinExcluded()
        {
            boost::lock_guard<boost::recursive_mutex> reclaimLock(reclaimMutex);
            if (excluded.size() > 0)
            {
                BOOST_FOREACH(T *t, excluded)
                {
                    unused.push_back(t);
                }
                excluded.clear();
            }
        };

        //Collect
        void relaimIdleResource(long reclaimInterval)
        {
            while (started)
            {
                boost::this_thread::sleep(bpt::milliseconds(reclaimInterval));

                boost::lock_guard<boost::recursive_mutex> lock(getResMutex);

                if (managed.size() > 0)
                {
                    std::vector<Res*> idleRes;
                    boost::lock_guard<boost::recursive_mutex> reclaimLock(reclaimMutex);

                    std::map<Res*, T*>::iterator iter = managed.begin();
                    for (; iter != managed.end(); iter++)
                    {
                        if (iter->second == NULL)
                        {
                            //Reclaim invalid resource
                            idleRes.push_back(iter->first);
                        }
                        else if (iter->first->valid() && iter->first->expired())
                        {
                            excluded.insert(iter->second);
                            iter->second = NULL;
                            idleRes.push_back(iter->first);
                        }
                    }

                    if (idleRes.size() < 0)
                    {
                        std::vector<Res*>::iterator idleIter = idleRes.begin();
                        for (; idleIter != idleRes.end(); idleIter++)
                        {
                            managed.erase(managed.find(*idleIter));
                        }
                    }
                }                
            }
        };

        //Get the resource number that pool should shrink to
        int getShrinkThreshold(boost::circular_buffer<int> &slideWindow, float meanRemain)
        {
            //The window iterator
            boost::circular_buffer<int>::iterator iter = slideWindow.begin();
            
            float  [MASK]  = 0.0f;
            while (iter != slideWindow.end())
            {
                 [MASK]  += (float)*iter;
                iter++;
            }
             [MASK]  =  [MASK]  / (float)slideWindow.size();
            
            float diff =  [MASK]  - meanRemain;

            //If load goes down
            int shrinkSize = 0;
            if (diff > 0.0f)
            {
                shrinkSize = unused.size() - (int)diff;
                //When load goes down sharply
                if (shrinkSize < 0)
                {
                    //If managed size is lower than initial number, set the total number to initialized number
                    if (managed.size() < (unsigned int) config.getInitPoolSize())
                    {
                        shrinkSize = config.getInitPoolSize() - (int)managed.size();
                    }
                    //If managed size is larger than initial size, release all available resources
                    else
                    {
                        shrinkSize = 0;
                    }
                }
            }
            //If load goes up
            else if (diff < 0.0f)
            {
                //When average remaining number is larger than available number, 
                //it means there is no load
                if ((unsigned int) [MASK]  > unused.size() + managed.size())
                {
                    shrinkSize = (int)( [MASK]  * SHRINK_FACTOR);
                }
                //Do not release if there is no load
                else
                {
                    shrinkSize = 0;
                }
            }
            //If load doesn't change
            else
            {
                //No load
                if ((unsigned int) [MASK]  == unused.size() + managed.size())
                {
                    shrinkSize = config.getInitPoolSize();
                }
                //Has load
                {
                    shrinkSize = (int)unused.size();
                }
            }

            meanRemain =  [MASK] ;
            return shrinkSize;
        };

        //Close the pool
        void close()
        {
            started = false;
            config.setInitPoolSize(0);

            boost::lock_guard<boost::recursive_mutex> lock(getResMutex);
            {
                boost::lock_guard<boost::recursive_mutex> recliamLock(reclaimMutex);

                std::map<Res*, T*>::iterator iter = managed.begin();
                while (iter != managed.end())
                {
                    if (iter->second != NULL)
                    {
                        unused.push_back(iter->second);
                    }
                    iter++;
                }
                managed.clear();

                while (unused.size() > 0)
                {
                    removeResource();
                }
            }
        };

    protected:
        
        //The ratio of shrined resources
        static const float SHRINK_FACTOR;        

        //Managed resource
        std::map<Res*, T*> managed;

        //Unused resource
        std::list<T*> unused;

        //A swap space for reclaim
        //Some
        std::set<T*> excluded;

        //Configuration
        ResourcePoolConfig config;

        //If started
        bool started;

        //Get resource mutex
        boost::recursive_mutex getResMutex;

        //Reclaim mutex
        boost::recursive_mutex reclaimMutex;

        int minAvailableNum;
        int resourceNum;
        int managedNum;

    }; //class ResourcePool

    template<class T>
        const float common_pool::ResourcePool<T>::SHRINK_FACTOR = 0.5f;
           


} //namespace rpool
#endif //_RESOURCEPOOL_H",sum
63,"#include <climits>
#include <cmath>
#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::sqrt;
using std::vector;

bool is_prime(unsigned long int n) {
  if (n < 2) {
    return false;
  }
  // for (int i = 2; i < n; i++) {
  // cout << ""sqrt("" << n << ""): "" << sqrt(n) << endl;
  for (unsigned long int i = 2; i <= sqrt(n); i++) {
    if (n % i == 0) {
      return false;
    }
  }
  return true;
}

int main() {

  cout << ""evildojo "" << endl;

  vector<unsigned long int>  [MASK] ;

  // unsigned int max = 10;
  unsigned long int max = 2000000;

  for (unsigned long int i = 2; i < max; i++) {
    if (is_prime(i)) {
       [MASK] .push_back(i);
    }
  }

  unsigned long int sum = 0;
  for (int i = 0; i <  [MASK] .size(); i++) {
    sum +=  [MASK] [i];
  }

  // cout << LONG_MAX << endl;
  // cout << INT_MAX << endl;
  cout << sum << endl;

  return 0;
}
",primes
64,"/*
 * A library for controlling a Microchip RN2483 LoRa radio.
 *
 * @Author <NAME>
 * @Date 18/12/2015
 * @ModifiedBy hsilomedus
 *
 */

#include ""Arduino.h""
#include ""rn2483.h""

extern ""C"" {
#include <string.h>
#include <stdlib.h>
}

//#define DEBUG_PROFILE 1
//#ifdef DEBUG_PROFILE
  #define SH_DEBUG_PRINTLN(a) Serial.println(a)
  #define SH_DEBUG_PRINT(a) Serial.print(a)
  #define SH_DEBUG_PRINT_DEC(a,b) Serial.print(a,b)
  #define SH_DEBUG_PRINTLN_DEC(a,b) Serial.println(a,b)
//#else
//  #define SH_DEBUG_PRINTLN(a) 
//  #define SH_DEBUG_PRINT(a) 
//  #define SH_DEBUG_PRINT_DEC(a,b) 
//  #define SH_DEBUG_PRINTLN_DEC(a,b) 
//#endif

/*
  @param serial Needs to be an already opened stream to write to and read from.
*/
rn2483::rn2483(SoftwareSerial& serial):
_serial(serial)
{
  _serial.setTimeout(2000);
}
//
//rn2483::rn2483(HardwareSerial& serial):
//_serial(serial)
//{
//  _serial.setTimeout(2000);
//}

void rn2483::autobaud()
{
  String response = """";
  while (response=="""")
  {
    delay(1000);
    _serial.write((byte)0x00);
    _serial.write(0x55);
    _serial.println();
    _serial.println(""sys get ver"");
    response = _serial.readStringUntil('\n');
  }
}

String rn2483::hweui()
{
  //clear serial buffer
  while(_serial.read() != -1);

  _serial.println(""sys get hweui"");
  String addr = _serial.readStringUntil('\n');
  addr.trim();
  return addr;
}

String rn2483::sysver()
{
  //clear serial buffer
  while(_serial.read() != -1);

  _serial.println(""sys get ver"");
  String ver = _serial.readStringUntil('\n');
  ver.trim();
  return ver;
}

void rn2483::init()
{
  if(*_appeui==""0"")
  {
    return;
  }
  else if(_otaa==true)
  {
//    init(_appeui, _appskey);
  }
  else
  {
    init(_appeui, _nwkskey, _appskey, _devAddr, _dataRate);
  }
}
//
//void rn2483::init(String AppEUI, String AppKey)
//{
//  _otaa = true;
//  _appeui = AppEUI;
//  _nwkskey = ""0"";
//  _appskey = AppKey; //reuse the variable
//
//  //clear serial buffer
//  while(_serial.read() != -1);
//
//  _serial.println(""sys get hweui"");
//  String addr = _serial.readStringUntil('\n');
//  addr.trim();
//
//  _serial.println(""mac reset 868"");
//  String receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(receivedData);
//
//  _serial.println(""mac set appeui ""+_appeui);
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(receivedData);
//
//  _serial.println(""mac set appkey ""+_appskey);
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(receivedData);
//
//  if(addr!="""" && addr.length() == 16)
//  {
//    _serial.println(""mac set deveui ""+addr);
//  }
//  else
//  {
//    _serial.println(""mac set deveui ""+_default_deveui);
//  }
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(receivedData);
//
//  _serial.println(""mac set pwridx 1"");
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(receivedData);
//
//  _serial.println(""mac set adr off"");
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(receivedData);
////
////  _serial.println(""mac set dr 0"");
////  receivedData = _serial.readStringUntil('\n');
////  SH_DEBUG_PRINT(receivedData);
//
//  _serial.println(""mac set rx2 3 869525000"");
////  _serial.println(""mac set rx2 0 869525000"");
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(receivedData);
//
//  // _serial.println(""mac set retx 10"");
//  // _serial.readStringUntil('\n');
//  // _serial.println(""mac set linkchk 60"");
//  // _serial.readStringUntil('\n');
//  // _serial.println(""mac set ar on"");
//  // _serial.readStringUntil('\n');
//  _serial.setTimeout(30000);
//  _serial.println(""mac save"");
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINTLN(receivedData);
//
//  _serial.println(""mac get dr"");
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(""DR: "");
//  SH_DEBUG_PRINTLN(receivedData);
//
//  _serial.println(""radio get sf"");
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(""SF: "");
//  SH_DEBUG_PRINTLN(receivedData);
//
//  _serial.println(""mac get pwridx"");
//  receivedData = _serial.readStringUntil('\n');
//  SH_DEBUG_PRINT(""PWRIDX: "");
//  SH_DEBUG_PRINTLN(receivedData);
//
//
//  bool joined = false;
//
//  for(int i=0; i<10 && !joined; i++)
//  {
//    _serial.println(""mac join otaa"");
//    receivedData = _serial.readStringUntil('\n');
//    SH_DEBUG_PRINT(receivedData);
//    receivedData = _serial.readStringUntil('\n');
//    SH_DEBUG_PRINT(receivedData);
//
//    if(receivedData.startsWith(""accepted""))
//    {
//      joined=true;
//      delay(1000);
//    }
//    else
//    {
//      delay(1000);
//    }
//  }
//  _serial.setTimeout(2000);
//}

char readBuf[21];

void rn2483::init(String* AppEUI, String* NwkSKey, String* AppSKey, String* addr, int dataRate)
{
  _otaa = false;
  _appeui = AppEUI;
  _nwkskey = NwkSKey;
  _appskey = AppSKey;
  _devAddr = addr;
  _dataRate = dataRate;

  //clear serial buffer
  while(_serial.read() != -1);

  String RN2483 = ""RN2483 "";

  readBuf[20] = 0;
  _serial.setTimeout(3000);

  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""reset"");
  _serial.println(""mac reset 868"");
  readreplyResponse();

  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""set rx2"");
  _serial.println(""mac set rx2 3 869525000"");
  readreplyResponse();

  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""set devaddr"");
  _serial.print(""mac set devaddr "");
  _serial.println(*_devAddr);
  readreplyResponse();

  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""set appskey"");
  _serial.print(""mac set appskey "");
  _serial.println(*_appskey);
  readreplyResponse();

  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""set nwskey"");
  _serial.print(""mac set nwkskey "");
  _serial.println(*_nwkskey);
  readreplyResponse();
    

  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""set adr off"");
  _serial.println(""mac set adr off"");
  readreplyResponse();
  
  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""set ar off"");
  _serial.println(""mac set ar off"");
  readreplyResponse();

  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""set pwridx 1"");
  _serial.println(""mac set pwridx 1""); //1=max, 5=min
  readreplyResponse();
  
  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINT(""set dr "");
  SH_DEBUG_PRINTLN_DEC(_dataRate, DEC);
  _serial.print(""mac set dr "");
  _serial.println(_dataRate, DEC); //0= min, 7=max
  readreplyResponse();

  _serial.setTimeout(60000);
  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""save"");
  _serial.println(""mac save"");
  readreplyResponse();
  
  SH_DEBUG_PRINT(RN2483);
  SH_DEBUG_PRINTLN(""join abp"");
  _serial.println(""mac join abp"");
  readreplyResponse();
  readreplyResponse();
}

void rn2483::readreplyResponse() {
  int read = _serial.readBytesUntil('\n', readBuf, 20);
  //#ifdef DEBUG_PROFILE
  Serial.write(readBuf, read); SH_DEBUG_PRINTLN("""");
  //#endif
  delay(100);
}

void rn2483::tx(byte bytes[], int length)
{
  txUncnf(bytes, length); //we are unsure which mode we're in. Better not to wait for acks.
}

//void rn2483::txCnf(byte bytes[], int length)
//{
//  txData(""mac tx cnf 1 "", bytes, length);
//}

void rn2483::txUncnf(byte bytes[], int length)
{
  txData(""mac tx uncnf 1 "", bytes, length);
}

bool rn2483::txData(String command, byte bytes[], int length)
{
  bool  [MASK]  = false;
  uint8_t busy_count = 0;
  uint8_t retry_count = 0;

  while(! [MASK] )
  {
    //retransmit a maximum of 10 times
    retry_count++;
    if(retry_count>10)
    {
      return false;
    }

    _serial.print(command);
    sendEncoded(bytes, length);
    _serial.println();
    String receivedData = _serial.readStringUntil('\n');
    SH_DEBUG_PRINTLN(receivedData);
    if(receivedData.startsWith(""ok""))
    {
      _serial.setTimeout(30000);
      receivedData = _serial.readStringUntil('\n');
      SH_DEBUG_PRINTLN(receivedData);
      _serial.setTimeout(2000);

      if(receivedData.startsWith(""mac_tx_ok""))
      {
        //SUCCESS!!
         [MASK]  = true;
        return true;
      }

      else if(receivedData.startsWith(""mac_rx""))
      {
        //we received data downstream
        //TODO: handle received data
         [MASK]  = true;
        return true;
      }

      else if(receivedData.startsWith(""mac_err""))
      {
        init();
      }

      else if(receivedData.startsWith(""invalid_data_len""))
      {
        //this should never happen if the prototype worked
         [MASK]  = true;
        return false;
      }

      else if(receivedData.startsWith(""radio_tx_ok""))
      {
        //SUCCESS!!
         [MASK]  = true;
        return true;
      }

      else if(receivedData.startsWith(""radio_err""))
      {
        //This should never happen. If it does, something major is wrong.
        init();
      }

      else
      {
        //unknown response
        //init();
      }
    }

    else if(receivedData.startsWith(""invalid_param""))
    {
      //should not happen if we typed the commands correctly
       [MASK]  = true;
      return false;
    }

    else if(receivedData.startsWith(""not_joined""))
    {
      init();
    }

    else if(receivedData.startsWith(""no_free_ch""))
    {
      //retry
      delay(1000);
    }

    else if(receivedData.startsWith(""silent""))
    {
      init();
    }

    else if(receivedData.startsWith(""frame_counter_err_rejoin_needed""))
    {
      init();
    }

    else if(receivedData.startsWith(""busy""))
    {
      busy_count++;

      if(busy_count>=10)
      {
        init();
      }
      else
      {
        delay(1000);
      }
    }

    else if(receivedData.startsWith(""mac_paused""))
    {
      init();
    }

    else if(receivedData.startsWith(""invalid_data_len""))
    {
      //should not happen if the prototype worked
       [MASK]  = true;
      return false;
    }

    else
    {
      //unknown response after mac tx command
      init();
    }
  }

  return false; //should never reach this
}

void rn2483::sendEncoded(byte bytes[], int length)
{
//  char working;
  char buffer[3];
  for(int i=0; i<length; i++)
  {
//    working = input.charAt(i);
    sprintf(buffer, ""%02x"", int(bytes[i]));
    _serial.print(buffer);
  }
}
//
//String rn2483::base16encode(String input)
//{
//  char charsOut[input.length()*2+1];
//  char charsIn[input.length()+1];
//  input.trim();
//  input.toCharArray(charsIn, input.length()+1);
//
//  int i = 0;
//  for(i = 0; i<input.length()+1; i++)
//  {
//    if(charsIn[i] == '\0') break;
//
//    int value = int(charsIn[i]);
//
//    char buffer[3];
//    sprintf(buffer, ""%02x"", value);
//    charsOut[2*i] = buffer[0];
//    charsOut[2*i+1] = buffer[1];
//  }
//  charsOut[2*i] = '\0';
//  String toReturn = String(charsOut);
//  return toReturn;
//}
//
//String rn2483::base16decode(String input)
//{
//  char charsIn[input.length()+1];
//  char charsOut[input.length()/2+1];
//  input.trim();
//  input.toCharArray(charsIn, input.length()+1);
//
//  int i = 0;
//  for(i = 0; i<input.length()/2+1; i++)
//  {
//    if(charsIn[i*2] == '\0') break;
//    if(charsIn[i*2+1] == '\0') break;
//
//    char toDo[2];
//    toDo[0] = charsIn[i*2];
//    toDo[1] = charsIn[i*2+1];
//    int out = strtoul(toDo, 0, 16);
//
//    if(out<128)
//    {
//      charsOut[i] = char(out);
//    }
//  }
//  charsOut[i] = '\0';
//  return charsOut;
//}

",send_success
65,"//LED Lamp
//This is a simple Arduino program using existing
//libraries to run 6 LEDs to run up a small lamp.
//The CapSense, Median Filter and FastLED libraries
//were all chosen for their relative ease of use
//and availability within the Arduino IDE.

#include <CapacitiveSensor.h>
#include <MedianFilter.h>
#include <FastLED.h>

#define LED_PIN 13 //Set LED Data Pin for FastLED
#define NUM_LEDS 6 //Maximum Number of LEDs for FastLED

CRGBArray<NUM_LEDS> leds; //Create an array for FastLED with values for all the LEDs in the chain
const int ledData = 13; //Set Variable ledData to reference LED data pin

MedianFilter senVal(3, 0); //Create a list using median filter. List is 3 values and seed with value '0'
CapacitiveSensor capSensor = CapacitiveSensor(4, 2); //Pin4 is send, pin 2 is receive
                                                     //Pins are bridged with 1Mohm resistor 
                                                     //Pin 2 is connect connected to the end sensor point 
int senThresh = 1750; //Threshold value for Capacitive Sensor. Lets us control when to change Pass to True
                      //A smaller value will trigger the sensor without touching the sensor
                      //1750-2300 works well for direct touch input

//LED Settings
//Each program is stored as a part of this pointer array
void (*ledShow[])() = {
  []{static uint8_t hue=0; leds.fill_rainbow(hue++); FastLED.delay(20);},
  []{for(int i = 0; i < NUM_LEDS; i++){ leds[i] = CRGB::Purple; FastLED.show();}},
  []{for(int i = 0; i < NUM_LEDS; i++){ leds[i] = CRGB::Green; FastLED.show();}},
  []{for(int i = 0; i < NUM_LEDS; i++){leds[i] = CRGB::Yellow; FastLED.show();}},
  []{for(int i = 0; i < NUM_LEDS; i++){leds[i] = CRGB::White;FastLED.show();}}
};

void setup() {
  pinMode(ledData, OUTPUT); // Set the LED Pin mode
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS); //Set up FastLED Device Type, Output Pin, diode arrangement, FastLED array and Number of LEDs

//  Serial.begin(9600); //activate for Debuging. Not Necessary for operation

}

void loop() {

  static int ledState = 0;      //Initialize the LEDState Variable and set it to 0 
  static int  [MASK]  = 4;        //Set the max number of LED states we can run through
                                //I'm sure there's a way to get the max number of entries in
                                //ledShow[], but I don't know that function so hardcode hacks for now
                                
  ledShow[ledState]();          //Initialize LEDs, start on first program in ledShow[]

  long sensorValue = capSensor.capacitiveSensor(20); //Get the value of the capacitive sensor for 20 samples
  senVal.in( sensorValue);                           //Pass the sensor value into the median filter list
  sensorValue = senVal.out();                        //Return the filtered sensor value. Gives a median of the capSense values

//  Serial.println(""Sensor Value: "");                //SERIAL MONITOR: check the sensor value
//  Serial.println(sensorValue);                     
  
//Check Sensor for someone touching it and then increment the
//ledState counter to run through functions inside of the ledShow array
  while(sensorValue>=senThresh){
    sensorValue = 0;              //Reset the Sensor to 0
    ledState = ledState + 1;      //Increment LED program and reset if it goes above the total number
    if (ledState >  [MASK] ){
      ledState = 0; 
    }
    ledShow[ledState]();          //display the new LED program

//  Serial.println(""LED State: ""); //SERIAL MONITOR: check which LED program we're running
//  Serial.println(ledState);
    
    delay(350);       //Wait 350 milliseconds before progressing, likely enough time for a user to remove their finger
                      //Added benefit of allowing users to cycle the LED programs by holding their finger on the sensor
    
    sensorValue = 0;  //No really, reset the sensor value to Zero;
    senVal.in(0);     //tell the MedianFilter we want Zero as the value to restart its counter;
    break;            //Start void loop() over instead of just hanging out inside this while statement
    }
}
",ledMax
66,"#include ""RSA.hpp""
#include <iostream>
#include <stdio.h>
#include <vector>

NTL::ZZ inv_mod(NTL::ZZ n1, NTL::ZZ n2){
  NTL::ZZ x1 = NTL::ZZ(0), x2 = NTL::ZZ(1), y1 = x1, y2 = x2;
  NTL::ZZ q, x, y, z,  [MASK]  = NTL::ZZ(1), sav = n2;
  if (n2 != 0) {
    while (n2 > 0) {
      q = n1 / n2;
      x = n1; y = x2; z = y2;
      n1 = n2; n2 = x - q * n2;
      x2 = x1; x1 = y - q * x1;
      y2 = y1; y1 = z - q * y1;
      if (n2 == 1) {
         [MASK]  = x1;
        if ( [MASK]  < 1)
           [MASK]  += sav;
      }
    }
  }
  return  [MASK] ;
}

void RSAKey::make(const unsigned int& length){
  NTL::GenPrime(p, length);
  do{
    NTL::GenPrime(q, length);
  }while(p == q);
  n = p * q;
  NTL::ZZ y_n = (p - 1) * (q - 1);
  do{
    e = NTL::RandomBits_ZZ(length) % y_n + 2;
  }while(NTL::GCD(e, y_n) != 1);
  d = inv_mod(e, y_n);
  /*std::cout << p << ' ' << q << '\n';
  std::cout << n << ' ' << y_n <<'\n';
  std::cout << d << ' ' << e <<'\n';*/
}

void RSAKey::set_public_key(const std::tuple<NTL::ZZ, NTL::ZZ>& public_key){
  e = std::get<0>(public_key);
  n = std::get<1>(public_key);
}

std::tuple<NTL::ZZ, NTL::ZZ> RSAKey::get_public_key(){
  return {e, n};
}

std::tuple<NTL::ZZ, NTL::ZZ, NTL::ZZ> RSAKey::get_private_key(){
  return {d, p, q};
}

NTL::ZZ mod_pow(NTL::ZZ b, NTL::ZZ e, NTL::ZZ m) {
  NTL::ZZ mod_p = NTL::ZZ(1);
  while (e > 0) {
    if ((e & 1) > 0) mod_p = (mod_p * b) % m;
    e >>= 1;
    b = (b * b) % m;
  }
  return mod_p;
}

NTL::ZZ mod(NTL::ZZ num, NTL::ZZ mod) {
  NTL::ZZ num_div_mod = num / mod;
  NTL::ZZ r = (num < 0) ? (num - (num_div_mod - 1) * mod) : num - num_div_mod * mod;
  return r;
}

NTL::ZZ RSA::chineseRemainderTheorem(const NTL::ZZ& m, const NTL::ZZ& d, const NTL::ZZ& p, const NTL::ZZ& q){
  NTL::ZZ m1 = mod_pow(m, mod(d, p - 1), p);
  NTL::ZZ m2 = mod_pow(m, mod(d, q - 1), q);
  NTL::ZZ h = mod(inv_mod(q, p) * (m1 - m2), p);
  return mod(m2 + (h * q), p * q);
}

unsigned char* RSA::rsa(unsigned char in[], unsigned int inLen, unsigned int& outLen, const NTL::ZZ& max_block_length,
                        const NTL::ZZ& k_slot1, const NTL::ZZ& k_slot2, const NTL::ZZ& k_slot3){
  NTL::ZZ block = NTL::ZZ(0), temp_block;
  std::vector<unsigned char> out_buf;

  for(unsigned int i = 0; i < inLen + 1; ++i){
    temp_block = block;
    if(i < inLen){
      block <<= 8;
      block |= in[i];
    }
    if(block >= max_block_length || i == inLen){
      NTL::ZZ c;
      if(k_slot2 == -1)
        c = mod_pow(temp_block, k_slot1, max_block_length);
      else
        c = chineseRemainderTheorem(temp_block, k_slot1, k_slot2, k_slot3);

      unsigned int n_c_bits = NTL::NumBits(c);
      unsigned int n_full_bytes = n_c_bits / 8;
      unsigned int n_remainder_bits = n_c_bits % 8;

      out_buf.reserve(n_full_bytes + (n_remainder_bits != 0));
      out_buf.push_back(NTL::to_int((c >> (n_c_bits - n_remainder_bits)) & 0xff));

      for (unsigned int j = n_full_bytes; j > 0; --j)
        out_buf.push_back(NTL::to_int((c >> ((j - 1) * 8)) & 0xff));
      block &= 0xff;
    }
  }

  outLen = out_buf.size();
  unsigned char* out = new unsigned char[outLen];
  memcpy(out, out_buf.data(), outLen);
  return out;
}

unsigned char* RSA::encrypt(unsigned char in[], unsigned int inLen, unsigned int& outLen, const std::tuple<NTL::ZZ, NTL::ZZ>& public_key){
  NTL::ZZ max_block_length = std::get<1>(public_key);
  return rsa(in, inLen, outLen, max_block_length, std::get<0>(public_key), NTL::ZZ(-1), NTL::ZZ(-1));
}

unsigned char* RSA::decrypt(unsigned char in[], unsigned int inLen, unsigned int& outLen, const std::tuple<NTL::ZZ, NTL::ZZ, NTL::ZZ>& private_key){
  NTL::ZZ max_block_length = std::get<1>(private_key) * std::get<2>(private_key);
  return rsa(in, inLen, outLen, max_block_length, std::get<0>(private_key), std::get<1>(private_key), std::get<2>(private_key));
}
",inverse
67,"/*
Copyright 2019 Google Inc. 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 <Windows.h>
#include <stdio.h>

int main(int argc, char* argv[])
{
  if (argc < 2) {
    printf(""This program creates a process in a suspended state, prints its PID""
           "" so that heap tracing can be enabled, and resumes the thread after a""
           "" brief delay. This helps etwheapsnapshot.bat trace a process from""
           "" birth. Only the PID is printed to stdout (for easy capture from a""
           "" batch file) - the rest is printed to stderr.\n"");
    printf(""Usage: %s proc_name.exe [delay_ms]\n"", argv[0]);
    return 0;
  }

  const char* name = argv[1];
  STARTUPINFOA startup_info = {sizeof(startup_info)};
  PROCESS_INFORMATION process_info = {};
  LARGE_INTEGER start;
  QueryPerformanceCounter(&start);
  BOOL  [MASK]  = CreateProcessA(name, nullptr, nullptr, nullptr, FALSE,
                               CREATE_SUSPENDED, nullptr, nullptr, &startup_info,
                               &process_info);

  if (! [MASK] ) {
    fprintf(stderr, ""CreateProcess failed.\n"");
    return -1;
  }

  // Print the process ID to stdout for consumption by a batch file.
  printf(""%d\n"", process_info.dwProcessId);
  // Print the process to stderr so that the output can be seen.
  fprintf(stderr, ""PID is %d.\n"", process_info.dwProcessId);

  DWORD delay = 10000;
  if (argc >= 3)
    delay = atoi(argv[2]);
  fprintf(stderr, ""Waiting %1.3f s before letting the process run.\n"", delay / 1e3);
  Sleep(delay);
  // Resume the main thread, thus starting the process.
  ResumeThread(process_info.hThread);
  fprintf(stderr, ""Process is now running.\n"");

  // When this process is destroyed all its handles to the new process will be
  // cleaned up, so no cleanup is necessary.
}
",result
68,"#include <fingera_libc/base32.h>
#include <fingera_libc/hex.h>

#include <gtest/gtest.h>
#include <stdint.h>
#include <stdio.h>
#include <string>

#define EXPECT_ZERO(x) EXPECT_EQ((x), 0)

TEST(base32, custom) {
  static const std::string vstrIn[] = {
      """", ""f"", ""fo"", ""foo"", ""foob"", ""fooba"", ""foobar"", ""abcdefghijklmn""};
  static const std::string vstrOut[] = {
      """",         ""my======"", ""mzxq===="",         ""mzxw6==="",
      ""mzxw6yq="", ""mzxw6ytb"", ""mzxw6ytboi======"", ""mfrggzdfmztwq2lknnwg23q=""};
  char out_char[256];
  size_t  [MASK] ;
  for (unsigned int i = 0; i < sizeof(vstrIn) / sizeof(vstrIn[0]); i++) {
    memset(out_char, 0, sizeof(out_char));
    fingera_to_base32(vstrIn[i].c_str(), vstrIn[i].size(), out_char);
    EXPECT_EQ(vstrOut[i], out_char);
    EXPECT_EQ(fingera_to_base32_length(vstrIn[i].size()), vstrOut[i].size());
    EXPECT_EQ(fingera_from_base32_length(vstrOut[i].c_str(), vstrOut[i].size()),
              vstrIn[i].size());
    memset(out_char, 0, sizeof(out_char));
    EXPECT_EQ(
        fingera_from_base32(vstrOut[i].c_str(), vstrOut[i].size(), out_char),
        vstrIn[i].size());
    EXPECT_EQ(vstrIn[i], out_char);

    memset(out_char, 0, sizeof(out_char));
     [MASK]  =
        fingera_to_base32_raw(vstrIn[i].c_str(), vstrIn[i].size(), out_char);
    char values[256];
    size_t size_of_values = fingera_from_base32_raw(out_char,  [MASK] , values);
    EXPECT_EQ(size_of_values, vstrIn[i].size());
    values[size_of_values] = '\0';
    EXPECT_EQ(vstrIn[i], values);
  }

  EXPECT_EQ(fingera_from_base32(""mzxw6ytb#mzxw6ytb"", 17, out_char), 5);
}",out_size
69,"// Author: <NAME> <<EMAIL>>

#ifndef tensor_msg_HPP
#define tensor_msg_HPP

#include <msgpack.hpp>
#include <vector>
#include <iostream>

/**
 * @brief Represent a tiny class for serializing tensors
 * @details each tensor consists of information about the type,
 *          the shape and the underlying tensor data
 */
class tensor_msg {
public:
    // type of message (0=int, 1=float, 2=double)
    unsigned int type_;
    // dimensions (length of each axis)
    std::vector<unsigned int> shape_;
    // raw data
    msgpack::type::raw_ref data_;

  tensor_msg(){}

  tensor_msg(std::vector<unsigned int> shape, int* data){
    init(shape, (char*) data, sizeof(int), 0);
  }

  tensor_msg(std::vector<unsigned int> shape, float* data){
    init(shape, (char*) data, sizeof(float), 1);
  }

  tensor_msg(std::vector<unsigned int> shape, double* data){
    init(shape, (char*) data, sizeof(double), 2);
  }

  void init(std::vector<unsigned int> shape, void* data, int size, unsigned int type){
    shape_ = shape;
    type_ = type;
    int  [MASK]  = 1;
    for(auto &i : shape)
       [MASK]  *= i;
    data_.ptr = (char*) data;
    data_.size = size *  [MASK] ;
  }

  // number of entries
  unsigned int size(){
    // templating seems no to be possible as we gonna read the data on-the-fly later
    if (type_ == 0)
      return data_.size / sizeof(int);
    if (type_ == 1)
      return data_.size / sizeof(float);
    if (type_ == 2)
      return data_.size / sizeof(double);
  }

  ~tensor_msg(){}
  MSGPACK_DEFINE(type_, shape_, data_);
};

#endif",elements
70,"//
//    rfnoc-hls-neuralnet: Vivado HLS code for neural-net building blocks
//
//    Copyright (C) 2017 <NAME>
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program 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 General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
#include <iostream>

#include ""myproject.h""
#include ""parameters.h""

void myproject(
    input_t input_2[N_INPUT_1_1], input2_t input_1[N_INPUT_1_2*N_INPUT_2_2],
    result_t layer5_out[N_TIME_STEPS_5*N_OUT_5]
) {

    //hls-fpga-machine-learning insert IO
    #pragma HLS ARRAY_RESHAPE variable=input_2 complete dim=0
    #pragma HLS ARRAY_RESHAPE variable=input_1 complete dim=0
    #pragma HLS ARRAY_PARTITION variable=layer5_out complete dim=0
    #pragma HLS INTERFACE ap_vld port=input_2,input_1,layer5_out 
    #pragma HLS PIPELINE 

#ifndef __SYNTHESIS__
    static bool  [MASK]  = false;
    if (! [MASK] ) {
        //hls-fpga-machine-learning insert load weights
        nnet::load_weights_from_txt<model_default_t, 4>(w3, ""w3.txt"");
        nnet::load_weights_from_txt<model_default_t, 2>(b3, ""b3.txt"");
        nnet::load_weights_from_txt<model_default_t, 12>(w5, ""w5.txt"");
        nnet::load_weights_from_txt<model_default_t, 12>(wr5, ""wr5.txt"");
        nnet::load_weights_from_txt<model_default_t, 6>(b5, ""b5.txt"");
        nnet::load_weights_from_txt<model_default_t, 6>(br5, ""br5.txt"");
         [MASK]  = true;
    }
#endif

    // ****************************************
    // NETWORK INSTANTIATION
    // ****************************************

    //hls-fpga-machine-learning insert layers

    layer3_t layer3_out[N_LAYER_3];
    #pragma HLS ARRAY_PARTITION variable=layer3_out complete dim=0
    nnet::dense<input_t, layer3_t, config3>(input_2, layer3_out, w3, b3); // dense

    nnet::gru_stack<input2_t, result_t, config5>(input_1, initial_state, layer5_out, w5, wr5, b5, br5); // gru

}
",loaded_weights
71,"/*
 * SPDX-License-Identifier: Apache-2.0
 */

#include <algorithm>
#include <cmath>
#include <numeric>
#include ""onnx/defs/data_propagators.h""
#include ""onnx/defs/tensor/utils.h""

namespace ONNX_NAMESPACE {

static const char* Cast_ver9_doc = R""DOC(
The operator casts the elements of a given input tensor to a data type
specified by the 'to' argument and returns an output tensor of the same size in
the converted type. The 'to' argument must be one of the data types specified
in the 'DataType' enum field in the TensorProto message.

Casting from string tensor in plain (e.g., ""3.14"" and ""1000"") and scientific numeric representations
(e.g., ""1e-5"" and ""1E8"") to float types is supported. For example, converting string ""100.5"" to an integer may
result 100. There are some string literals reserved for special floating-point values;
""+INF"" (and ""INF""), ""-INF"", and ""NaN"" are positive infinity, negative infinity, and not-a-number, respectively.
Any string which can exactly match ""+INF"" in a case-insensitive way would be mapped to positive infinite. Similarly,
this case-insensitive rule is applied to ""INF"" and ""NaN"". When casting from numeric tensors
to string tensors, plain floating-point representation (such as ""314.15926"") would be used.
Converting non-numerical-literal string such as ""Hello World!"" is an undefined behavior. Cases
of converting string representing floating-point arithmetic value, such as ""2.718"", to INT is an undefined behavior.

Conversion from a numerical type to any numerical type is always allowed.
User must be aware of precision loss and value change caused by range difference between two types.
For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Cast,
    9,
    OpSchema()
        .SetDoc(Cast_ver9_doc)
        .Attr(
            ""to"",
            ""The data type to which the elements of the input tensor are cast. ""
            ""Strictly must be one of the types from DataType enum in TensorProto"",
            AttributeProto::INT)
        .Input(0, ""input"", ""Input tensor to be cast."", ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor with the same shape as input with type ""
            ""specified by the 'to' argument"",
            ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)"",
             ""tensor(string)""},
            ""Constrain input types. Casting from complex is not supported."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)"",
             ""tensor(string)""},
            ""Constrain output types. Casting to complex is not supported."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromAttributeToOutput(ctx, ""to"", 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* Reshape_ver13_doc = R""DOC(
Reshape the input tensor similar to numpy.reshape.
First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
At most one dimension of the new shape can be -1. In this case, the value is
inferred from the size of the tensor and the remaining dimensions. A dimension
could also be 0, in which case the actual dimension value is unchanged (i.e. taken
from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
The input tensor's shape and the output tensor's shape are required to have the same number of elements.)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Reshape,
    13,
    OpSchema()
        .SetDoc(Reshape_ver13_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""shape"",
            ""Specified shape for output."",
            ""tensor(int64)"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Output(0, ""reshaped"", ""Reshaped data."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape Inference if 2nd input data (the target shape) is available
          const TensorProto* targetShapeInitializer = ctx.getInputData(1);
          if (!targetShapeInitializer) {
            return;
          }
          // Make targetShape (0 -> same as originalShape, -1 -> inferred).
          // The targetShape vector represents the specified shape for output.
          std::vector<int64_t> targetShape = ParseData<int64_t>(targetShapeInitializer);
          // Iterate through targetShape, adding dimensions in the outputShape
          // TensorProto. If the targertShape dimension is -1, we do not set the
          // dimension value in this iteration, but we record the Dimension. If
          // targertShape dimension is 0, we attempt to propagate the dimension
          // value/param. If the value cannot be inferred, we set the flag in
          // the unresolveZeros vector. If targetShape dimension is positive, we
          // set the dimension value in the outputShape. We track the product of
          // the dimensions we are setting outputShape in the outputProduct
          // variable. The outputProduct will potentially be used for inferring
          // a dimension marked -1.
          auto* outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          TensorShapeProto::Dimension* negativeOneDim = nullptr;
          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
          std::vector<bool> unresolvedZeros(targetShape.size(), false);
          int64_t outputProduct = 1;
          for (int i = 0; i < static_cast<int>(targetShape.size()); ++i) {
            // Add a new dimension to outputShape
            auto* new_dim = outputShape->add_dim();
            if (targetShape[i] == -1) {
              // Check if multiple -1's. If not, set negativeOneDim, marking
              // this dimension to potentially be filled in later.
              if (negativeOneDim) {
                fail_shape_inference(""Target shape may not have multiple -1 dimensions"");
              }
              negativeOneDim = new_dim;
            } else if (targetShape[i] == 0) {
              // Check if data input has a shape and if the index i is within
              // its bounds. If these conditions are satisfied, any dimension
              // value/param should be propogated. If dimension value cannot be
              // inferred, set the corresponding  unresolvedZeros flag to true.
              unresolvedZeros[i] = true;
              if (dataInputTensorType.has_shape()) {
                if (i >= dataInputTensorType.shape().dim_size()) {
                  fail_shape_inference(""Invalid position of 0"");
                }
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  const auto& dim_value = dataInputTensorType.shape().dim(i).dim_value();
                  new_dim->set_dim_value(dim_value);
                  outputProduct *= dim_value;
                  unresolvedZeros[i] = false;
                } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
                  const auto& dim_param = dataInputTensorType.shape().dim(i).dim_param();
                  new_dim->set_dim_param(TString{dim_param});
                }
              }
            } else if (targetShape[i] > 0) {
              // Set the dimension value to targetShape[i]
              new_dim->set_dim_value(targetShape[i]);
              outputProduct *= targetShape[i];
            } else {
              // Check if value is less than -1; fail if so
              fail_shape_inference(""Invalid dimension value: "", targetShape[i]);
            }
          }

          // If negativeOneDim has been set, we attempt to infer its value. This
          // can be done if all dimension values for the data input tensor shape
          // are known other than the ones corresponding to unresolvedZeros
          // flags.
          if (negativeOneDim) {
            // First, attempt to compute product of data input shape dimensions
            // that are not marked by unresolvedZeros. If not possible, set the
            // inputProductValid flag to false.
            if (!outputProduct) {
              fail_shape_inference(""Invalid Target shape product of 0"");
            }
            int64_t inputProduct = 1;
            bool inputProductValid = true;
            if (!dataInputTensorType.has_shape()) {
              inputProductValid = false;
            } else {
              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  inputProduct *= dataInputTensorType.shape().dim(i).dim_value();
                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
                  inputProductValid = false;
                  break;
                }
              }
            }
            if (inputProductValid) {
              if (inputProduct % outputProduct != 0) {
                fail_shape_inference(""Dimension could not be inferred: incompatible shapes"");
              }
              negativeOneDim->set_dim_value(inputProduct / outputProduct);
            }
          }
        }));

static const char* Reshape_ver5_doc = R""DOC(
Reshape the input tensor similar to numpy.reshape.
First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
At most one dimension of the new shape can be -1. In this case, the value is
inferred from the size of the tensor and the remaining dimensions. A dimension
could also be 0, in which case the actual dimension value is unchanged (i.e. taken
from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
The input tensor's shape and the output tensor's shape are required to have the same number of elements.)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Reshape,
    5,
    OpSchema()
        .SetDoc(Reshape_ver5_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Input(1, ""shape"", ""Specified shape for output."", ""tensor(int64)"")
        .Output(0, ""reshaped"", ""Reshaped data."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape Inference if 2nd input data (the target shape) is available
          const TensorProto* targetShapeInitializer = ctx.getInputData(1);
          if (!targetShapeInitializer) {
            return;
          }
          // Make targetShape (0 -> same as originalShape, -1 -> inferred).
          // The targetShape vector represents the specified shape for output.
          std::vector<int64_t> targetShape = ParseData<int64_t>(targetShapeInitializer);

          // Iterate through targetShape, adding dimensions in the outputShape
          // TensorProto. If the targertShape dimension is -1, we do not set the
          // dimension value in this iteration, but we record the Dimension. If
          // targertShape dimension is 0, we attempt to propagate the dimension
          // value/param. If the value cannot be inferred, we set the flag in
          // the unresolveZeros vector. If targetShape dimension is positive, we
          // set the dimension value in the outputShape. We track the product of
          // the dimensions we are setting outputShape in the outputProduct
          // variable. The outputProduct will potentially be used for inferring
          // a dimension marked -1.
          auto* outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          TensorShapeProto::Dimension* negativeOneDim = nullptr;
          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
          std::vector<bool> unresolvedZeros(targetShape.size(), false);
          int64_t outputProduct = 1;
          for (int i = 0; i < static_cast<int>(targetShape.size()); ++i) {
            // Add a new dimension to outputShape
            auto* new_dim = outputShape->add_dim();
            if (targetShape[i] == -1) {
              // Check if multiple -1's. If not, set negativeOneDim, marking
              // this dimension to potentially be filled in later.
              if (negativeOneDim) {
                fail_shape_inference(""Target shape may not have multiple -1 dimensions"");
              }
              negativeOneDim = new_dim;
            } else if (targetShape[i] == 0) {
              // Check if data input has a shape and if the index i is within
              // its bounds. If these conditions are satisfied, any dimension
              // value/param should be propogated. If dimension value cannot be
              // inferred, set the corresponding  unresolvedZeros flag to true.
              unresolvedZeros[i] = true;
              if (dataInputTensorType.has_shape()) {
                if (i >= dataInputTensorType.shape().dim_size()) {
                  fail_shape_inference(""Invalid position of 0"");
                }
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  const auto& dim_value = dataInputTensorType.shape().dim(i).dim_value();
                  new_dim->set_dim_value(dim_value);
                  outputProduct *= dim_value;
                  unresolvedZeros[i] = false;
                } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
                  const auto& dim_param = dataInputTensorType.shape().dim(i).dim_param();
                  new_dim->set_dim_param(TString{dim_param});
                }
              }
            } else if (targetShape[i] > 0) {
              // Set the dimension value to targetShape[i]
              new_dim->set_dim_value(targetShape[i]);
              outputProduct *= targetShape[i];
            } else {
              // Check if value is less than -1; fail if so
              fail_shape_inference(""Invalid dimension value: "", targetShape[i]);
            }
          }

          // If negativeOneDim has been set, we attempt to infer its value. This
          // can be done if all dimension values for the data input tensor shape
          // are known other than the ones corresponding to unresolvedZeros
          // flags.
          if (negativeOneDim) {
            // First, attempt to compute product of data input shape dimensions
            // that are not marked by unresolvedZeros. If not possible, set the
            // inputProductValid flag to false.
            if (!outputProduct) {
              fail_shape_inference(""Invalid Target shape product of 0"");
            }
            int64_t inputProduct = 1;
            bool inputProductValid = true;
            if (!dataInputTensorType.has_shape()) {
              inputProductValid = false;
            } else {
              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  inputProduct *= dataInputTensorType.shape().dim(i).dim_value();
                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
                  inputProductValid = false;
                  break;
                }
              }
            }
            if (inputProductValid) {
              if (inputProduct % outputProduct != 0) {
                fail_shape_inference(""Dimension could not be inferred: incompatible shapes"");
              }
              negativeOneDim->set_dim_value(inputProduct / outputProduct);
            }
          }
        }));

static const char* Shape_ver13_doc = R""DOC(
Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
)DOC"";

// Data propagation function for Shape op
// Propagates input shape to output shape
static void ShapeOp13DataPropagator(DataPropagationContext& ctx) {
  if (!hasNInputShapes(ctx, 1)) {
    return;
  }
  if (ctx.getInputType(0)->tensor_type().has_shape()) {
    auto input_shape = ctx.getInputType(0)->tensor_type().shape();
    TensorShapeProto tsp;
    tsp.CopyFrom(input_shape);
    ctx.addOutputData(0, std::move(tsp));
  }
}

ONNX_OPERATOR_SET_SCHEMA(
    Shape,
    13,
    OpSchema()
        .SetDoc(Shape_ver13_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
        .Output(0, ""shape"", ""Shape of the input tensor"", ""T1"", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
        .TypeConstraint(""T"", OpSchema::all_tensor_types_with_bfloat(), ""Input tensor can be of arbitrary type."")
        .TypeConstraint(""T1"", {""tensor(int64)""}, ""Constrain output to int64 tensor."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
          auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          auto* output_length = output_shape->add_dim();

          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          if (ctx.getInputType(0)->tensor_type().has_shape()) {
            output_length->set_dim_value(ctx.getInputType(0)->tensor_type().shape().dim_size());
          }
        })
        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { ShapeOp13DataPropagator(ctx); }));

static const char* Shape_ver1_doc = R""DOC(
Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Shape,
    1,
    OpSchema()
        .SetDoc(Shape_ver1_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""shape"", ""Shape of the input tensor"", ""T1"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Input tensor can be of arbitrary type."")
        .TypeConstraint(""T1"", {""tensor(int64)""}, ""Constrain output to int64 tensor."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
          auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          auto* output_length = output_shape->add_dim();

          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          if (ctx.getInputType(0)->tensor_type().has_shape()) {
            output_length->set_dim_value(ctx.getInputType(0)->tensor_type().shape().dim_size());
          }
        })
        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { ShapeOp13DataPropagator(ctx); }));

static const char* Size_ver1_doc = R""DOC(
Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Size,
    1,
    OpSchema()
        .SetDoc(Size_ver1_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""size"", ""Total number of elements of the input tensor"", ""T1"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Input tensor can be of arbitrary type."")
        .TypeConstraint(""T1"", {""tensor(int64)""}, ""Constrain output to int64 tensor, which should be a scalar though."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
        }));

ONNX_OPERATOR_SET_SCHEMA(
    Concat,
    11,
    OpSchema()
        .Attr(
            ""axis"",
            ""Which axis to concat on. A negative value means counting dimensions from the back. ""
            ""Accepted range is [-r, r-1] where r = rank(inputs).."",
            AttributeProto::INT)
        .SetDoc(
            ""Concatenate a list of tensors into a single tensor. ""
            ""All input tensors must have the same shape, except for the dimension size of the axis to concatenate on."")
        .Input(0, ""inputs"", ""List of tensors for concatenation"", ""T"", OpSchema::Variadic)
        .Output(0, ""concat_result"", ""Concatenated tensor"", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto numInputs = ctx.getNumInputs();
          if (numInputs < 1 || !hasNInputShapes(ctx, static_cast<int>(numInputs))) {
            return;
          }

          auto rank = ctx.getInputType(0)->tensor_type().shape().dim_size();

          auto axisAttr = ctx.getAttribute(""axis"");
          if (!axisAttr) {
            fail_shape_inference(""Required attribute axis is missing"");
          }
          int axis = static_cast<int>(axisAttr->i());
          if (axis < -rank || axis >= rank) {
            fail_shape_inference(""axis must be in [-rank, rank-1]."");
          }
          if (axis < 0) {
            axis += rank;
          }

          if (numInputs == 1) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
            return;
          }

          bool all_lengths_known = true;
          int total_length = 0;

          auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (int64_t i = 0; i < rank; ++i) {
            output_shape->add_dim();
          }

          for (size_t i = 0; i < numInputs; i++) {
            const auto& shape = ctx.getInputType(i)->tensor_type().shape();
            if (shape.dim_size() != rank) {
              fail_shape_inference(
                  ""All inputs to Concat must have same rank. Input "", i, "" has rank "", shape.dim_size(), "" != "", rank);
            }
            for (int j = 0; j < rank; j++) {
              if (j == axis) {
                if (shape.dim(j).has_dim_value()) {
                  total_length += static_cast<int>(shape.dim(j).dim_value());
                } else {
                  all_lengths_known = false;
                }
              } else {
                auto& output_dim = *output_shape->mutable_dim(j);
                const auto& input_dim = shape.dim(j);
                mergeInDimensionInfo(input_dim, output_dim, j);
              }
            }
          }

          if (all_lengths_known) {
            output_shape->mutable_dim(axis)->set_dim_value(total_length);
          }
        }));

static const char* Split_ver11_doc =
    R""DOC(Split a tensor into a list of tensors, along the specified
'axis'. Lengths of the parts can be specified using argument 'split'.
Otherwise, the tensor is split to equal sized parts.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Split,
    11,
    OpSchema()
        .Input(0, ""input"", ""The tensor to split"", ""T"")
        .Output(0, ""outputs"", ""One or more outputs forming list of tensors after splitting"", ""T"", OpSchema::Variadic)
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .Attr(
            ""axis"",
            ""Which axis to split on. ""
            ""A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] ""
            ""where r = rank(input)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Attr(""split"", ""length of each output. Values should be >= 0."", AttributeProto::INTS, OPTIONAL_VALUE)
        .SetDoc(Split_ver11_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
            propagateElemTypeFromInputToOutput(ctx, 0, i);
          }
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
          int rank = shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -rank || axis >= rank) {
            fail_type_inference(""Invalid value of attribute 'axis'. Rank="", rank, "" Value="", axis);
          }
          if (axis < 0) {
            axis += rank;
          }
          const auto& split_dim = shape.dim(axis);
          if (!split_dim.has_dim_value()) {
            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
              ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->Clear();
            }
            return;
          }
          int split_dim_value = static_cast<int>(split_dim.dim_value());

          std::vector<int64_t> split;
          if (getRepeatedAttribute(ctx, ""split"", split)) {
            if (split.size() != ctx.getNumOutputs()) {
              fail_shape_inference(
                  ""Mismatch between number of splits ("", split.size(), "") and outputs ("", ctx.getNumOutputs(), "")"");
            }
            int64_t total_dim = 0;
            for (int64_t d : split) {
              total_dim += d;
            }
            if (total_dim != split_dim_value) {
              fail_shape_inference(
                  ""Mismatch between the sum of 'split' ("",
                  total_dim,
                  "") and the split dimension of the input ("",
                  split_dim_value,
                  "")"");
            }
          } else {
            int num_outputs = static_cast<int>(ctx.getNumOutputs());
            if (split_dim_value % num_outputs != 0) {
              fail_shape_inference(""The input is not evenly splittable"");
            }
            int chunk_size = split_dim_value / num_outputs;
            for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); i++) {
              split.push_back(chunk_size);
            }
          }
          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
            ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(split[i]);
          }
        }));

static const char* Split_ver13_doc =
    R""DOC(Split a tensor into a list of tensors, along the specified
'axis'. Lengths of the parts can be specified using input 'split'.
Otherwise, the tensor is split to equal sized parts.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Split,
    13,
    OpSchema()
        .Input(0, ""input"", ""The tensor to split"", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""split"",
            ""Optional length of each output. Values should be >= 0.""
            ""Sum of the values must be equal to the dim value at 'axis' specified."",
            ""tensor(int64)"",
            OpSchema::Optional,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Output(
            0,
            ""outputs"",
            ""One or more outputs forming list of tensors after splitting"",
            ""T"",
            OpSchema::Variadic,
            true,
            1,
            OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input and output types to all tensor types."")
        .Attr(
            ""axis"",
            ""Which axis to split on. ""
            ""A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] ""
            ""where r = rank(input)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .SetDoc(Split_ver13_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
            propagateElemTypeFromInputToOutput(ctx, 0, i);
          }
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
          int rank = shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -rank || axis >= rank) {
            fail_type_inference(""Invalid value of attribute 'axis'. Rank="", rank, "" Value="", axis);
          }
          if (axis < 0) {
            axis += rank;
          }
          const auto& split_dim = shape.dim(axis);
          if (!split_dim.has_dim_value()) {
            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
              ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->Clear();
            }
            return;
          }
          int split_dim_value = static_cast<int>(split_dim.dim_value());

          std::vector<int64_t> split;
          size_t num_inputs = ctx.getNumInputs();
          if ((num_inputs == 2) && ctx.getInputType(1)) { //'split' is input
            auto split_proto = ctx.getInputData(1);
            if (split_proto == nullptr) {
              // skip if split is not an initializer
              return;
            }
            split = ParseData<int64_t>(split_proto);
            if (split.size() != ctx.getNumOutputs()) {
              fail_shape_inference(
                  ""Mismatch between number of splits ("", split.size(), "") and outputs ("", ctx.getNumOutputs(), "")"");
            }
            int64_t total_dim = 0;
            for (int64_t d : split) {
              total_dim += d;
            }
            if (total_dim != split_dim_value) {
              fail_shape_inference(
                  ""Mismatch between the sum of 'split' ("",
                  total_dim,
                  "") and the split dimension of the input ("",
                  split_dim_value,
                  "")"");
            }
          } else { // no value available for 'split'
            int num_outputs = static_cast<int>(ctx.getNumOutputs());
            if (split_dim_value % num_outputs != 0) {
              fail_shape_inference(""The input is not evenly splittable"");
            }
            int chunk_size = split_dim_value / num_outputs;
            split.reserve(ctx.getNumOutputs());
            for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); i++) {
              split.push_back(chunk_size);
            }
          }
          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
            ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(split[i]);
          }
        }));

static const char* Slice_ver11_doc = R""DOC(
Produces a slice of the input tensor along multiple axes. Similar to numpy:
https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
dimension and step for each axis in the list of axes, it uses this information to
slice the input `data` tensor. If a negative value is passed for any of the
start or end indices, it represents number of elements before the end of that
dimension. If the value passed to start or end is larger than the `n` (the
number of elements in this dimension), it represents `n`. For slicing to the
end of a dimension with unknown size, it is recommended to pass in `INT_MAX`
when slicing forward and 'INT_MIN' when slicing backward.
If a negative value is passed for step, it represents slicing backward.
However step value cannot be 0.
If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
Example 1:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  axes = [0, 1]
  starts = [1, 0]
  ends = [2, 3]
  steps = [1, 2]
  result = [
      [5, 7],
  ]
Example 2:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  starts = [0, 1]
  ends = [-1, 1000]
  result = [
      [2, 3, 4],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Slice,
    11,
    OpSchema()
        .SetDoc(Slice_ver11_doc)
        .Input(0, ""data"", ""Tensor of data to extract slices from."", ""T"")
        .Input(1, ""starts"", ""1-D tensor of starting indices of corresponding axis in `axes`"", ""Tind"")
        .Input(2, ""ends"", ""1-D tensor of ending indices (exclusive) of corresponding axis in `axes`"", ""Tind"")
        .Input(
            3,
            ""axes"",
            ""1-D tensor of axes that `starts` and `ends` apply to. Negative value means counting dimensions ""
            ""from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            ""Tind"",
            OpSchema::Optional)
        .Input(
            4,
            ""steps"",
            ""1-D tensor of slice step of corresponding axis in `axes`. ""
            ""Negative value means slicing backward. 'steps' cannot be 0. ""
            ""Defaults to 1."",
            ""Tind"",
            OpSchema::Optional)
        .Output(0, ""output"", ""Sliced data tensor."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          size_t num_inputs = ctx.getNumInputs();
          if (num_inputs != 3 && num_inputs != 4 && num_inputs != 5) {
            fail_type_inference(""Slice op must have either three, four or five inputs."");
          }
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          // Shape Inference if
          //     1. 2nd and 3rd input data (starts, ends) are available.
          // and 2. 4th and 5th optional input (axes, steps) are either not set,
          // or set and is initializer.
          const TensorProto* startsInitializer = ctx.getInputData(1);
          const TensorProto* endsInitializer = ctx.getInputData(2);
          const TensorProto* axesInitializer = hasInputShape(ctx, 3) ? ctx.getInputData(3) : nullptr;
          const TensorProto* stepsInitializer = hasInputShape(ctx, 4) ? ctx.getInputData(4) : nullptr;

          if (!startsInitializer || !endsInitializer || (hasInputShape(ctx, 3) && !ctx.getInputData(3)) ||
              (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
            return;
          }

          // don't know data_type- can't proceed
          if (!startsInitializer->has_data_type())
            return;

          auto get_initializer_data = [](const TensorProto* initializer) -> std::vector<int64_t> {
            std::vector<int64_t> vec;
            if (initializer->data_type() == TensorProto::INT64) {
              const auto& data = ParseData<int64_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else if (initializer->data_type() == TensorProto::INT32) {
              const auto& data = ParseData<int32_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else {
              // unaccepted data type
              fail_shape_inference(""Only supports `int32_t` or `int64_t` inputs for starts/ends/axes/steps"");
            }
            return vec;
          };

          auto clamp = [](int64_t val, int64_t low, int64_t high) -> int64_t {
            if (val < low)
              return low;
            if (val > high)
              return high;
            return val;
          };

          std::vector<int64_t> starts = get_initializer_data(startsInitializer);
          std::vector<int64_t> ends = get_initializer_data(endsInitializer);

          if (starts.size() != ends.size()) {
            fail_shape_inference(""Incorrect or missing input value for starts and ends"");
          }

          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();
          std::vector<int64_t> axes(starts.size());
          if (!axesInitializer) {
            std::iota(axes.begin(), axes.end(), 0);
          } else {
            axes = get_initializer_data(axesInitializer);
            if (axes.size() != starts.size()) {
              fail_shape_inference(""Input axes has incorrect length"");
            }
          }

          std::vector<int64_t> steps;
          if (!stepsInitializer) {
            steps = std::vector<int64_t>(starts.size(), 1);
          } else {
            steps = get_initializer_data(stepsInitializer);
            if (steps.size() != axes.size()) {
              fail_shape_inference(""Input steps has incorrect length"");
            }
          }

          for (size_t i = 0; (int64_t)i < input_rank; ++i) {
            // first update rank of output dim
            auto* output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
            const auto& input_dim = input_shape.dim((int)i);
            if (input_dim.has_dim_value()) {
              output_dim->set_dim_value(input_dim.dim_value());
            } else if (input_dim.has_dim_param()) {
              output_dim->set_dim_param(TString{input_dim.dim_param()});
            }
          }

          std::unordered_set<int64_t> unique_axes;
          size_t axes_size = axes.size();
          for (size_t axis_index = 0; axis_index < axes_size; ++axis_index) {
            auto axis = axes[axis_index] < 0 ? axes[axis_index] + static_cast<int64_t>(input_rank) : axes[axis_index];

            if (axis >= static_cast<int64_t>(input_rank) || axis < 0) {
              fail_shape_inference(""Input axes has invalid data"");
            }

            if (unique_axes.find(axis) != unique_axes.end()) {
              fail_shape_inference(""'axes' has duplicates"");
            }

            unique_axes.insert(axis);

            auto input_dim = ctx.getInputType(0)->tensor_type().shape().dim((int)axis);

            // input dim value is missing - cannot perform shape inference for
            // this axis
            if (!input_dim.has_dim_value()) {
              // Clear any previously propagated dim_param and leave this
              // dimension ""empty"", before moving on to the next dimension
              ctx.getOutputType(0)
                  ->mutable_tensor_type()
                  ->mutable_shape()
                  ->mutable_dim(static_cast<int>(axis))
                  ->clear_dim_param();
              continue;
            }

            const auto input_dim_value = input_dim.dim_value();

            // process step
            auto step = steps[axis_index];
            if (step == 0) {
              fail_shape_inference(""'step' cannot be 0"");
            }

            // process start
            auto start = starts[axis_index];
            if (start < 0)
              start += input_dim_value;
            if (step < 0)
              start = clamp(start, 0, input_dim_value - 1);
            else
              start = clamp(start, 0, input_dim_value);

            // process end
            auto end = ends[axis_index];
            if (end < 0)
              end += input_dim_value;
            if (step < 0)
              end = clamp(end, -1, input_dim_value);
            else
              end = clamp(end, 0, input_dim_value);

            // find output dim value for this axis
            auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / step));
            if (temp < 0)
              temp = 0;

            // assign output value
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->mutable_dim((int)axis)->set_dim_value(temp);
          }
        }));

static const char* Transpose_ver1_doc = R""DOC(
Transpose the input tensor similar to numpy.transpose. For example, when
perm=(1, 0, 2), given an input tensor of shape (1, 2, 3), the output shape
will be (2, 1, 3).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Transpose,
    1,
    OpSchema()
        .SetDoc(Transpose_ver1_doc)
        .Attr(
            ""perm"",
            ""A list of integers. By default, reverse the dimensions, ""
            ""otherwise permute the axes according to the values given."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""transposed"", ""Transposed output."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          auto input_type = ctx.getInputType(0);
          const TensorShapeProto& shape = input_type->tensor_type().shape();
          std::vector<int64_t> perm;
          bool has_perm_attr = getRepeatedAttribute(ctx, ""perm"", perm);
          if (!has_perm_attr) {
            for (int i = shape.dim_size() - 1; i >= 0; --i)
              perm.push_back(i);
          } else if (!perm.empty()) {
            // check if every index is valid
            std::vector<bool> seen(shape.dim_size(), false);
            for (int64_t fromDimIndex : perm) {
              if (!(0 <= fromDimIndex && fromDimIndex < shape.dim_size())) {
                std::ostringstream oss;
                oss << ""Invalid attribute perm {"" << perm[0];
                for (size_t i = 1; i != perm.size(); ++i) {
                  oss << "", "" << perm[i];
                }
                oss << ""}, input shape = {"";
                if (shape.dim_size() > 0) {
                  oss << shape.dim(0).dim_value();
                  for (int i = 1; i != shape.dim_size(); ++i) {
                    oss << "", "" << shape.dim(i).dim_value();
                  }
                  oss << ""}"";
                }
                fail_type_inference(oss.str());
              } else {
                // check if any perm is repeated
                if (seen[fromDimIndex]) {
                  fail_type_inference(""Attribute perm for Transpose has repeated value: "", fromDimIndex);
                }
                seen[fromDimIndex] = true;
              }
            }
          }

          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          for (size_t i = 0; i < perm.size(); ++i) {
            appendSingleDimCopiedFromInputTypeToOutputType(ctx, 0, 0, static_cast<size_t>(perm[i]));
          }
        }));

static const char* ScatterND_ver16_doc = R""DOC(
ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
is produced by creating a copy of the input `data`, and then updating its value to values
specified by `updates` at specific index positions specified by `indices`. Its output shape
is the same as the shape of `data`.

`indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
 `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
update to a slice of the tensor. Index values are allowed to be negative, as per the usual
convention for counting backwards from the end, but are expected in the valid range.

`updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
The remaining dimensions of `updates` correspond to the dimensions of the
replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
of shapes.

The `output` is calculated via the following equation:
    output = np.copy(data)
    update_indices = indices.shape[:-1]
    for idx in np.ndindex(update_indices):
        output[indices[idx]] = updates[idx]
The order of iteration in the above loop is not specified.
In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
This ensures that the output value does not depend on the iteration order.

`reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
tensor into `output` at the specified `indices`.
In cases where `reduction` is set to ""none"", indices should not have duplicate entries: that is, if idx1 != idx2,
then indices[idx1] != indices[idx2]. This ensures that the output value does not depend on the iteration order.
When `reduction` is set to ""add"", `output` is calculated as follows:
    output = np.copy(data)
    update_indices = indices.shape[:-1]
    for idx in np.ndindex(update_indices):
        output[indices[idx]] += updates[idx]
When `reduction` is set to ""mul"", `output` is calculated as follows:
    output = np.copy(data)
    update_indices = indices.shape[:-1]
    for idx in np.ndindex(update_indices):
        output[indices[idx]] *= updates[idx]
This operator is the inverse of GatherND.
Example 1:
```
  data    = [1, 2, 3, 4, 5, 6, 7, 8]
  indices = [[4], [3], [1], [7]]
  updates = [9, 10, 11, 12]
  output  = [1, 11, 3, 10, 9, 6, 7, 12]
```
Example 2:
```
  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
  indices = [[0], [2]]
  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterND,
    16,
    OpSchema()
        .SetDoc(ScatterND_ver16_doc)
        .Attr(
            ""reduction"",
            ""Type of reduction to apply: none (default), add, mul. ""
            ""'none': no reduction applied. ""
            ""'add':  reduction using the addition operation. ""
            ""'mul': reduction using the multiplication operation."",
            AttributeProto::STRING,
            std::string(""none""))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""indices"",
            ""Tensor of rank q >= 1."",
            ""tensor(int64)"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            2,
            ""updates"",
            ""Tensor of rank q + r - indices_shape[-1] - 1."",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .Output(0, ""output"", ""Tensor of rank r >= 1."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* ScatterND_ver13_doc = R""DOC(
ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
is produced by creating a copy of the input `data`, and then updating its value to values
specified by `updates` at specific index positions specified by `indices`. Its output shape
is the same as the shape of `data`. Note that `indices` should not have duplicate entries.
That is, two or more `updates` for the same index-location is not supported.

`indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
 `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
update to a slice of the tensor. Index values are allowed to be negative, as per the usual
convention for counting backwards from the end, but are expected in the valid range.

`updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
The remaining dimensions of `updates` correspond to the dimensions of the
replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
of shapes.

The `output` is calculated via the following equation:

    output = np.copy(data)
    update_indices = indices.shape[:-1]
    for idx in np.ndindex(update_indices):
        output[indices[idx]] = updates[idx]

The order of iteration in the above loop is not specified.
In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
This ensures that the output value does not depend on the iteration order.

This operator is the inverse of GatherND.

Example 1:
```
  data    = [1, 2, 3, 4, 5, 6, 7, 8]
  indices = [[4], [3], [1], [7]]
  updates = [9, 10, 11, 12]
  output  = [1, 11, 3, 10, 9, 6, 7, 12]
```

Example 2:
```
  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
  indices = [[0], [2]]
  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterND,
    13,
    OpSchema()
        .SetDoc(ScatterND_ver13_doc)
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""indices"",
            ""Tensor of rank q >= 1."",
            ""tensor(int64)"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            2,
            ""updates"",
            ""Tensor of rank q + r - indices_shape[-1] - 1."",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .Output(0, ""output"", ""Tensor of rank r >= 1."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* ScatterND_ver11_doc = R""DOC(
ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
is produced by creating a copy of the input `data`, and then updating its value to values
specified by `updates` at specific index positions specified by `indices`. Its output shape
is the same as the shape of `data`. Note that `indices` should not have duplicate entries.
That is, two or more `updates` for the same index-location is not supported.

`indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
 `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
update to a slice of the tensor. Index values are allowed to be negative, as per the usual
convention for counting backwards from the end, but are expected in the valid range.

`updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
The remaining dimensions of `updates` correspond to the dimensions of the
replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
of shapes.

The `output` is calculated via the following equation:

    output = np.copy(data)
    update_indices = indices.shape[:-1]
    for idx in np.ndindex(update_indices):
        output[indices[idx]] = updates[idx]

The order of iteration in the above loop is not specified.
In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
This ensures that the output value does not depend on the iteration order.

This operator is the inverse of GatherND.

Example 1:
```
  data    = [1, 2, 3, 4, 5, 6, 7, 8]
  indices = [[4], [3], [1], [7]]
  updates = [9, 10, 11, 12]
  output  = [1, 11, 3, 10, 9, 6, 7, 12]
```

Example 2:
```
  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
  indices = [[0], [2]]
  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterND,
    11,
    OpSchema()
        .SetDoc(ScatterND_ver11_doc)
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(1, ""indices"", ""Tensor of rank q >= 1."", ""tensor(int64)"")
        .Input(2, ""updates"", ""Tensor of rank q + r - indices_shape[-1] - 1."", ""T"")
        .Output(0, ""output"", ""Tensor of rank r >= 1."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* ScatterElements_ver16_doc = R""DOC(
ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
rank r >= 1 and an optional attribute axis that identifies an axis of `data`
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input `data`, and then updating its value
to values specified by `updates` at specific index positions specified by
`indices`. Its output shape is the same as the shape of `data`.
For each entry in `updates`, the target index in `data` is obtained by combining
the corresponding entry in `indices` with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in `indices` and the index-value for dimension != axis is obtained from the
index of the entry itself.
`reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
tensor into `output` at the specified `indices`.
In cases where `reduction` is set to ""none"", indices should not have duplicate entries: that is, if idx1 != idx2,
then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
corresponding to the [i][j] entry is performed as below:
```
  output[indices[i][j]][j] = updates[i][j] if axis = 0,
  output[i][indices[i][j]] = updates[i][j] if axis = 1,
```
When `reduction` is set to ""add"", the update corresponding to the [i][j] entry is performed as below:
```
  output[indices[i][j]][j] += updates[i][j] if axis = 0,
  output[i][indices[i][j]] += updates[i][j] if axis = 1,
```
When `reduction` is set to ""mul"", the update corresponding to the [i][j] entry is performed as below:
```
  output[indices[i][j]][j] *= updates[i][j] if axis = 0,
  output[i][indices[i][j]] *= updates[i][j] if axis = 1,
```
This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
Example 1:
```
  data = [
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
  ]
  indices = [
      [1, 0, 2],
      [0, 2, 1],
  ]
  updates = [
      [1.0, 1.1, 1.2],
      [2.0, 2.1, 2.2],
  ]
  output = [
      [2.0, 1.1, 0.0]
      [1.0, 0.0, 2.2]
      [0.0, 2.1, 1.2]
  ]
```
Example 2:
```
  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
  indices = [[1, 3]]
  updates = [[1.1, 2.1]]
  axis = 1
  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterElements,
    16,
    OpSchema()
        .SetDoc(ScatterElements_ver16_doc)
        .Attr(
            ""axis"",
            ""Which axis to scatter on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Attr(
            ""reduction"",
            ""Type of reduction to apply: none (default), add, mul. ""
            ""'none': no reduction applied. ""
            ""'add':  reduction using the addition operation. ""
            ""'mul': reduction using the multiplication operation."",
            AttributeProto::STRING,
            std::string(""none""))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be ""
            ""within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            2,
            ""updates"",
            ""Tensor of rank r >=1 (same rank and shape as indices)"",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .Output(
            0,
            ""output"",
            ""Tensor of rank r >= 1 (same rank as input)."",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Input and output types can be of any tensor type."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* ScatterElements_ver13_doc = R""DOC(
ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
rank r >= 1 and an optional attribute axis that identifies an axis of `data`
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input `data`, and then updating its value
to values specified by `updates` at specific index positions specified by
`indices`. Its output shape is the same as the shape of `data`.

For each entry in `updates`, the target index in `data` is obtained by combining
the corresponding entry in `indices` with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in `indices` and the index-value for dimension != axis is obtained from the
index of the entry itself.

For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
is performed as below:
```
  output[indices[i][j]][j] = updates[i][j] if axis = 0,
  output[i][indices[i][j]] = updates[i][j] if axis = 1,
```

This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.

Example 1:
```
  data = [
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
  ]
  indices = [
      [1, 0, 2],
      [0, 2, 1],
  ]
  updates = [
      [1.0, 1.1, 1.2],
      [2.0, 2.1, 2.2],
  ]
  output = [
      [2.0, 1.1, 0.0]
      [1.0, 0.0, 2.2]
      [0.0, 2.1, 1.2]
  ]
```
Example 2:
```
  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
  indices = [[1, 3]]
  updates = [[1.1, 2.1]]
  axis = 1
  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterElements,
    13,
    OpSchema()
        .SetDoc(ScatterElements_ver13_doc)
        .Attr(
            ""axis"",
            ""Which axis to scatter on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be ""
            ""within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            2,
            ""updates"",
            ""Tensor of rank r >=1 (same rank and shape as indices)"",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .Output(
            0,
            ""output"",
            ""Tensor of rank r >= 1 (same rank as input)."",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Input and output types can be of any tensor type."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* ScatterElements_ver11_doc = R""DOC(
ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
rank r >= 1 and an optional attribute axis that identifies an axis of `data`
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input `data`, and then updating its value
to values specified by `updates` at specific index positions specified by
`indices`. Its output shape is the same as the shape of `data`.

For each entry in `updates`, the target index in `data` is obtained by combining
the corresponding entry in `indices` with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in `indices` and the index-value for dimension != axis is obtained from the
index of the entry itself.

For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
is performed as below:
```
  output[indices[i][j]][j] = updates[i][j] if axis = 0,
  output[i][indices[i][j]] = updates[i][j] if axis = 1,
```

This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.

Example 1:
```
  data = [
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
  ]
  indices = [
      [1, 0, 2],
      [0, 2, 1],
  ]
  updates = [
      [1.0, 1.1, 1.2],
      [2.0, 2.1, 2.2],
  ]
  output = [
      [2.0, 1.1, 0.0]
      [1.0, 0.0, 2.2]
      [0.0, 2.1, 1.2]
  ]
```
Example 2:
```
  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
  indices = [[1, 3]]
  updates = [[1.1, 2.1]]
  axis = 1
  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterElements,
    11,
    OpSchema()
        .SetDoc(ScatterElements_ver11_doc)
        .Attr(
            ""axis"",
            ""Which axis to scatter on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be ""
            ""within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Input(2, ""updates"", ""Tensor of rank r >=1 (same rank and shape as indices)"", ""T"")
        .Output(0, ""output"", ""Tensor of rank r >= 1 (same rank as input)."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Input and output types can be of any tensor type."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* Gather_ver11_doc = R""DOC(
Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
them in an output tensor of rank q + (r - 1).

axis = 0 :

Let
k = indices[i_{0}, ..., i_{q-1}]
Then
output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]

```
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  indices = [
      [0, 1],
      [1, 2],
  ]
  output = [
      [
          [1.0, 1.2],
          [2.3, 3.4],
      ],
      [
          [2.3, 3.4],
          [4.5, 5.7],
      ],
  ]
```
axis = 1 :

Let
k = indices[i_{0}, ..., i_{q-1}]
Then
output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]

```
  data = [
      [1.0, 1.2, 1.9],
      [2.3, 3.4, 3.9],
      [4.5, 5.7, 5.9],
  ]
  indices = [
      [0, 2],
  ]
  axis = 1,
  output = [
      [
          [1.0, 1.9],
          [2.3, 3.9],
          [4.5, 5.9],
      ],
  ]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Gather,
    11,
    OpSchema()
        .SetDoc(Gather_ver11_doc)
        .Attr(
            ""axis"",
            ""Which axis to gather on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] ""
            ""along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Output(0, ""output"", ""Tensor of rank q + (r - 1)."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to any tensor type."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 2)) {
            return;
          }
          const TensorShapeProto& data_shape = ctx.getInputType(0)->tensor_type().shape();
          const TensorShapeProto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
          int r = data_shape.dim_size();
          if (r < 1) {
            fail_shape_inference(""data tensor must have rank >= 1"");
          }
          int q = indices_shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -r || axis >= r) {
            fail_shape_inference(""axis must be in [-r, r-1]"");
          }
          if (axis < 0) {
            axis += r;
          }
          int out_rank = q + r - 1;
          if (out_rank == 0) {
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          }
          for (int i = 0; i < out_rank; ++i) {
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = (i < axis) ? data_shape.dim(i)
                                                                                                  : // i < axis < r
                (i >= axis && i < axis + q) ? indices_shape.dim(i - axis)
                                            : // i - axis < q
                data_shape.dim(i - q + 1); // i < out_rank < q + r - 1
          }
        })
        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { GatherOp13DataPropagator(ctx); }));

static const char* GatherElements_ver11_doc = R""DOC(

GatherElements takes two inputs `data` and `indices` of the same rank r >= 1
and an optional attribute `axis` that identifies an axis of `data`
(by default, the outer-most axis, that is axis 0). It is an indexing operation
that produces its output by indexing into the input data tensor at index
positions determined by elements of the `indices` tensor.
Its output shape is the same as the shape of `indices` and consists of one value
(gathered from the `data`) for each element in `indices`.

For instance, in the 3-D case (r = 3), the output produced is determined
by the following equations:
```
  out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
  out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
  out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,
```

This operator is also the inverse of ScatterElements. It is similar to Torch's gather operation.

Example 1:
```
  data = [
      [1, 2],
      [3, 4],
  ]
  indices = [
      [0, 0],
      [1, 0],
  ]
  axis = 1
  output = [
      [
        [1, 1],
        [4, 3],
      ],
  ]
```
Example 2:
```
  data = [
      [1, 2, 3],
      [4, 5, 6],
      [7, 8, 9],
  ]
  indices = [
      [1, 2, 0],
      [2, 0, 0],
  ]
  axis = 0
  output = [
      [
        [4, 8, 3],
        [7, 2, 3],
      ],
  ]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    GatherElements,
    11,
    OpSchema()
        .SetDoc(GatherElements_ver11_doc)
        .Attr(
            ""axis"",
            ""Which axis to gather on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, with the same rank r as the input. All index values are expected to be ""
            ""within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Output(0, ""output"", ""Tensor of the same shape as indices."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to any tensor type."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // propagate indices' shape to output if it exists
          if (hasInputShape(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 1, 0);
          }
        }));

static const char* Squeeze_ver11_doc = R""DOC(
Remove single-dimensional entries from the shape of a tensor.
Takes a  parameter `axes` with a list of axes to squeeze.
If `axes` is not provided, all the single dimensions will be removed from
the shape. If an axis is selected with shape entry not equal to one, an error is raised.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Squeeze,
    11,
    OpSchema()
        .Attr(
            ""axes"",
            ""List of integers indicating the dimensions to squeeze. Negative value means counting dimensions ""
            ""from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .SetDoc(Squeeze_ver11_doc)
        .Input(0, ""data"", ""Tensors with at least max(dims) dimensions."", ""T"")
        .Output(0, ""squeezed"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_ndim = input_shape.dim_size();
          std::transform(axes.begin(), axes.end(), axes.begin(), [&](int64_t axis) -> int64_t {
            return axis < 0 ? axis + input_ndim : axis;
          });

          for (int i = 0, j = 0; i < input_ndim; ++i) {
            if (std::find(axes.begin(), axes.end(), i) != axes.end()) {
              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
                fail_shape_inference(
                    ""Dimension of input "", i, "" must be 1 instead of "", input_shape.dim(i).dim_value());
              }
              ++j;
            } else {
              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
            }
          }
        }));

static const char* Unsqueeze_ver11_doc = R""DOC(
Insert single-dimensional entries to the shape of an input tensor (`data`).
Takes one required argument `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).

For example:
  Given an input tensor (`data`) of shape [3, 4, 5], then
  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].

The attribute `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
The order of values in `axes` does not matter and can come in any order.

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Unsqueeze,
    11,
    OpSchema()
        .Attr(
            ""axes"",
            ""List of integers indicating the dimensions to be inserted. Negative value means counting dimensions ""
            ""from the back. Accepted range is [-r, r-1] where r = rank(expanded)."",
            AttributeProto::INTS)
        .SetDoc(Unsqueeze_ver11_doc)
        .Input(0, ""data"", ""Original tensor"", ""T"")
        .Output(0, ""expanded"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }

          // validate 'axes' for duplicate entries
          std::unordered_set<int64_t> unique_values;
          for (const auto val : axes) {
            if (unique_values.find(val) != unique_values.end()) {
              fail_shape_inference(""'axes' attribute must not contain any duplicates"");
            }
            unique_values.insert(val);
          }

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_ndim = input_shape.dim_size();
          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
          for (auto& axe : axes) {
            if (axe < -output_ndim || axe >= output_ndim) {
              fail_shape_inference(""values in 'axes' are beyond the bounds of the computed output shape"");
            }
            if (axe < 0) {
              axe += output_ndim;
            }
          }

          // sort after correcting negative axes values (if any) in the previous
          // step
          std::sort(axes.begin(), axes.end());

          int j = 0;
          for (int i = 0; i < input_ndim; ++i) {
            while (static_cast<size_t>(j) < axes.size() &&
                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
              ++j;
            }
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
                ctx.getInputType(0)->tensor_type().shape().dim(i);
          }
          while (static_cast<size_t>(j) < axes.size() &&
                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
            ++j;
          }
        }));

static const char* SpaceToDepth_ver1_doc =
    R""DOC(SpaceToDepth rearranges blocks of spatial data into depth. More specifically,
this op outputs a copy of the input tensor where values from the height and width dimensions
are moved to the depth dimension.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    SpaceToDepth,
    1,
    OpSchema()
        .Attr(""blocksize"", ""Blocks of [blocksize, blocksize] are moved."", AttributeProto::INT)
        .SetDoc(SpaceToDepth_ver1_doc)
        .Input(
            0,
            ""input"",
            ""Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth""
            "", H is the height and W is the width."",
            ""T"")
        .Output(0, ""output"", ""Output tensor of [N, C * blocksize * blocksize, H/blocksize, W/blocksize]."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto blocksize = getAttribute(ctx, ""blocksize"", 0);
          if (blocksize <= 0) {
            fail_shape_inference(""Blocksize must be positive"");
          }
          if (hasInputShape(ctx, 0)) {
            auto& input_shape = getInputShape(ctx, 0);
            if (input_shape.dim_size() == 4) {
              // TODO: Clarify what behavior should be if H or W is not a
              // multiple of blocksize.
              updateOutputShape(
                  ctx,
                  0,
                  {input_shape.dim(0),
                   input_shape.dim(1) * (blocksize * blocksize),
                   input_shape.dim(2) / blocksize,
                   input_shape.dim(3) / blocksize});
            } else {
              fail_shape_inference(""Input tensor must be 4-dimensional"");
            }
          }
        }));

static const char* DepthToSpace_ver11_doc =
    R""DOC(DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
the input tensor where values from the depth dimension are moved in spatial blocks to the height
and width dimensions. By default, `mode` = `DCR`.
In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
following order: depth, column, and then row. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])

tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])

y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])


In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
following order: column, row, and the depth. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])

tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])

y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    DepthToSpace,
    11,
    OpSchema()
        .Attr(""blocksize"", ""Blocks of [blocksize, blocksize] are moved."", AttributeProto::INT)
        .Attr(
            ""mode"",
            ""DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order."",
            AttributeProto::STRING,
            std::string(""DCR""))
        .SetDoc(DepthToSpace_ver11_doc)
        .Input(
            0,
            ""input"",
            ""Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth""
            "", H is the height and W is the width."",
            ""T"")
        .Output(0, ""output"", ""Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto blocksize = getAttribute(ctx, ""blocksize"", 0);
          if (blocksize <= 0) {
            fail_shape_inference(""Blocksize must be positive"");
          }
          if (hasInputShape(ctx, 0)) {
            auto& input_shape = getInputShape(ctx, 0);
            if (input_shape.dim_size() == 4) {
              // TODO: Clarify what behavior should be if C is not a multiple of
              // blocksize*blocksize.
              updateOutputShape(
                  ctx,
                  0,
                  {input_shape.dim(0),
                   input_shape.dim(1) / (blocksize * blocksize),
                   input_shape.dim(2) * blocksize,
                   input_shape.dim(3) * blocksize});
            } else {
              fail_shape_inference(""Input tensor must be 4-dimensional"");
            }
          }
        }));

static const char* Tile_ver6_doc =
    R""DOC(Constructs a tensor by tiling a given tensor.
This is the same as function `tile` in Numpy, but no broadcast.
For example A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Tile,
    6,
    OpSchema()
        .SetDoc(Tile_ver6_doc)
        .Input(0, ""input"", ""Input tensor of any shape."", ""T"")
        .Input(
            1,
            ""repeats"",
            ""1D int64 tensor of the same length as input's dimension number, ""
            ""includes numbers of repeated copies along input's dimensions."",
            ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor of the same dimensions and type as tensor input. ""
            ""output_dim[i] = input_dim[i] * repeats[i]"",
            ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeConstraint(""T1"", {""tensor(int64)""}, ""Constrain repeat's type to int64 tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape inference

          // Needs at least the first input to proceed
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();

          const auto* repeats_inputs = ctx.getInputData(1);

          auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          if (nullptr != repeats_inputs && hasNInputShapes(ctx, 2)) {
            // shape inference is possible only when 'repeats' is an initializer
            const auto& repeats_shape = ctx.getInputType(1)->tensor_type().shape();
            if (repeats_shape.dim_size() != 1 || repeats_inputs->data_type() != TensorProto::INT64) {
              fail_shape_inference(""'Repeats' input must be 1D tensor of type int64"");
            }

            const auto& repeats_data = ParseData<int64_t>(repeats_inputs);

            if (repeats_data.size() != static_cast<size_t>(input_rank)) {
              fail_shape_inference(
                  ""'Repeats' input has incorrect number of values. ""
                  ""The number of values in 'repeats' must be equal ""
                  ""to the number of input dimensions."");
            }

            for (size_t i = 0; (int64_t)i < input_rank; ++i) {
              const auto& input_dim = input_shape.dim((int)i);
              auto* output_dim = output_shape->add_dim();
              if (input_dim.has_dim_value()) {
                output_dim->set_dim_value(input_dim.dim_value() * repeats_data[i]);
              }
            }
          } else {
            // Infer output shape's rank in any case (if repeats data is not
            // available)
            auto* output_shape_0 = getOutputShape(ctx, 0);
            for (size_t i = 0; (int64_t)i < input_rank; ++i) {
              output_shape_0->add_dim();
            }
          }
          return;
        }));

static const char* Resize_ver13_doc = R""DOC(
Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * (roi_end - roi_start) * scale) if input \""sizes\"" is not specified.
)DOC"";

static const char* Resize_ver13_attr_coordinate_transformation_mode_doc = R""DOC(
This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>

The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, length_original as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input ""roi"", scale = length_resized / length_original, <br/>

if coordinate_transformation_mode is ""half_pixel"", <br/>
x_original = (x_resized + 0.5) / scale - 0.5, <br/>

if coordinate_transformation_mode is ""pytorch_half_pixel"", <br/>
x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0, <br/>

if coordinate_transformation_mode is ""align_corners"", <br/>
x_original = x_resized * (length_original - 1) / (length_resized - 1), <br/>

if coordinate_transformation_mode is ""asymmetric"", <br/>
x_original = x_resized / scale, <br/>

if coordinate_transformation_mode is ""tf_crop_and_resize"", <br/>
x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1).)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Resize,
    13,
    OpSchema()
        .Attr(
            ""mode"",
            ""Three interpolation modes: nearest (default), linear and cubic. ""
            ""The \""linear\"" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). ""
            ""The \""cubic\"" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor)."",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Attr(
            ""cubic_coeff_a"",
            ""The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75""
            "" (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. ""
            ""This attribute is valid only if \""mode\"" is \""cubic\""."",
            AttributeProto::FLOAT,
            static_cast<float>(-0.75))
        .Attr(
            ""exclude_outside"",
            ""If set to 1, the weight of sampling locations outside the tensor will be set to 0""
            "" and the weight will be renormalized so that their sum is 1.0. The default value is 0."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Attr(
            ""coordinate_transformation_mode"",
            Resize_ver13_attr_coordinate_transformation_mode_doc,
            AttributeProto::STRING,
            std::string(""half_pixel""))
        .Attr(
            ""nearest_mode"",
            ""Four modes: round_prefer_floor (default, as known as round half down), round_prefer_ceil (as known as round half up), floor, ceil. Only used by nearest interpolation. It indicates how to get \""nearest\"" pixel in input tensor from x_original, so this attribute is valid only if \""mode\"" is \""nearest\""."",
            AttributeProto::STRING,
            std::string(""round_prefer_floor""))
        .Attr(
            ""extrapolation_value"",
            ""When coordinate_transformation_mode is \""tf_crop_and_resize\"" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f."",
            AttributeProto::FLOAT,
            static_cast<float>(0))
        .Input(0, ""X"", ""N-D tensor"", ""T1"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""roi"",
            ""1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is \""tf_crop_and_resize\"""",
            ""T2"",
            OpSchema::Optional,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            2,
            ""scales"",
            ""The scale array along each dimension. It takes value greater than 0. If it's less than 1,""
            "" it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should""
            "" be the same as the rank of input 'X'. One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list."",
            ""tensor(float)"",
            OpSchema::Optional,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            3,
            ""sizes"",
            ""The size of the output tensor. The number of elements of 'sizes' should be the same as the""
            "" rank of input 'X'. Only one of 'scales' and 'sizes' can be specified."",
            ""tensor(int64)"",
            OpSchema::Optional,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T1"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .TypeConstraint(
            ""T1"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input 'X' and output 'Y' to all tensor types."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain roi type to float or double."")
        .SetDoc(Resize_ver13_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset13_to_18(ctx); }));

static const char* Resize_ver11_doc = R""DOC(
Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * (roi_end - roi_start) * scale) if input \""sizes\"" is not specified.
)DOC"";

static const char* Resize_attr_coordinate_transformation_mode_doc = R""DOC(
This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>

The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, length_original as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input ""roi"", scale = length_resized / length_original, <br/>

if coordinate_transformation_mode is ""half_pixel"", <br/>
x_original = (x_resized + 0.5) / scale - 0.5, <br/>

if coordinate_transformation_mode is ""pytorch_half_pixel"", <br/>
x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0, <br/>

if coordinate_transformation_mode is ""align_corners"", <br/>
x_original = x_resized * (length_original - 1) / (length_resized - 1), <br/>

if coordinate_transformation_mode is ""asymmetric"", <br/>
x_original = x_resized / scale, <br/>

if coordinate_transformation_mode is ""tf_half_pixel_for_nn"", <br/>
x_original = (x_resized + 0.5) / scale, <br/>

if coordinate_transformation_mode is ""tf_crop_and_resize"", <br/>
x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1).)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Resize,
    11,
    OpSchema()
        .Attr(
            ""mode"",
            ""Three interpolation modes: nearest (default), linear and cubic. ""
            ""The \""linear\"" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). ""
            ""The \""cubic\"" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor)."",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Attr(
            ""cubic_coeff_a"",
            ""The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75""
            "" (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. ""
            ""This attribute is valid only if \""mode\"" is \""cubic\""."",
            AttributeProto::FLOAT,
            static_cast<float>(-0.75))
        .Attr(
            ""exclude_outside"",
            ""If set to 1, the weight of sampling locations outside the tensor will be set to 0""
            "" and the weight will be renormalized so that their sum is 1.0. The default value is 0."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Attr(
            ""coordinate_transformation_mode"",
            Resize_attr_coordinate_transformation_mode_doc,
            AttributeProto::STRING,
            std::string(""half_pixel""))
        .Attr(
            ""nearest_mode"",
            ""Four modes: round_prefer_floor (default, as known as round half down), round_prefer_ceil (as known as round half up), floor, ceil. Only used by nearest interpolation. It indicates how to get \""nearest\"" pixel in input tensor from x_original, so this attribute is valid only if \""mode\"" is \""nearest\""."",
            AttributeProto::STRING,
            std::string(""round_prefer_floor""))
        .Attr(
            ""extrapolation_value"",
            ""When coordinate_transformation_mode is \""tf_crop_and_resize\"" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f."",
            AttributeProto::FLOAT,
            static_cast<float>(0))
        .Input(0, ""X"", ""N-D tensor"", ""T1"")
        .Input(
            1,
            ""roi"",
            ""1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is \""tf_crop_and_resize\"""",
            ""T2"")
        .Input(
            2,
            ""scales"",
            ""The scale array along each dimension. It takes value greater than 0. If it's less than 1,""
            "" it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should""
            "" be the same as the rank of input 'X'. If 'size' is needed, the user must set 'scales' to an empty tensor."",
            ""tensor(float)"")
        .Input(
            3,
            ""sizes"",
            ""The size of the output tensor. The number of elements of 'sizes' should be the same as the""
            "" rank of input 'X'. May only be set if 'scales' is set to an empty tensor."",
            ""tensor(int64)"",
            OpSchema::Optional)
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T1"")
        .TypeConstraint(""T1"", OpSchema::all_tensor_types(), ""Constrain input 'X' and output 'Y' to all tensor types."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain roi type to float or double."")
        .SetDoc(Resize_ver11_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset11_to_12(ctx); }));

ONNX_OPERATOR_SET_SCHEMA(
    Identity,
    13,
    OpSchema()
        .SetDoc(""Identity operator"")
        .Input(0, ""input"", ""Input tensor"", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Output(0, ""output"", ""Tensor to copy input into."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));

ONNX_OPERATOR_SET_SCHEMA(
    Identity,
    1,
    OpSchema()
        .SetDoc(""Identity operator"")
        .Input(0, ""input"", ""Input tensor"", ""T"")
        .Output(0, ""output"", ""Tensor to copy input into."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));

ONNX_OPERATOR_SET_SCHEMA(
    IsNaN,
    9,
    OpSchema()
        .SetDoc(R""DOC(Returns which elements of the input are NaN.)DOC"")
        .Input(0, ""X"", ""input"", ""T1"")
        .Output(0, ""Y"", ""output"", ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input types to float tensors."")
        .TypeConstraint(""T2"", {""tensor(bool)""}, ""Constrain output types to boolean tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          updateOutputElemType(ctx, 0, TensorProto::BOOL);
          if (hasInputShape(ctx, 0)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

const char* NonZero_ver9_doc = R""DOC(
    Returns the indices of the elements that are non-zero
    (in row-major order - by dimension).
    NonZero behaves similar to numpy.nonzero:
    https://docs.scipy.org/doc/numpy/reference/generated/numpy.nonzero.html,
    but for scalar input, NonZero produces output shape (0, N) instead of (1, N), which is different from Numpy's behavior.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    NonZero,
    9,
    OpSchema()
        .SetDoc(NonZero_ver9_doc)
        .Input(0, ""X"", ""input"", ""T"")
        .Output(0, ""Y"", ""output"", ""tensor(int64)"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          updateOutputElemType(ctx, 0, TensorProto::INT64);
          TensorShapeProto output_shape;
          auto* dim = output_shape.add_dim();
          if (hasInputShape(ctx, 0)) {
            const TensorShapeProto& input_shape = getInputShape(ctx, 0);
            dim->set_dim_value(input_shape.dim_size());
          }
          output_shape.add_dim();
          updateOutputShape(ctx, 0, output_shape);
        }));

static const char* GatherND_ver12_doc = R""DOC(
Given `data` tensor of rank `r` >= 1, `indices` tensor of rank `q` >= 1, and `batch_dims` integer `b`, this operator gathers
slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1 - b`.

`indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
where each element defines a slice of `data`

`batch_dims` (denoted as `b`) is an integer indicating the number of batch dimensions, i.e the leading `b` number of dimensions of
`data` tensor and `indices` are representing the batches, and the gather starts from the `b+1` dimension.

Some salient points about the inputs' rank and shape:

1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`

2) The first `b` dimensions of the shape of `indices` tensor and `data` tensor must be equal.

3) b < min(q, r) is to be honored.

4) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r-b` (inclusive)

5) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
   It is an error if any of the index values are out of bounds.

The output is computed as follows:

The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.

1) If `indices_shape[-1] > r-b` => error condition

2) If `indices_shape[-1] == r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensors
   containing 1-D tensors of dimension `r-b`, where `N` is an integer equals to the product of 1 and all the elements in the batch dimensions
   of the indices_shape. Let us think of each such `r-b` ranked tensor as `indices_slice`. Each *scalar value* corresponding to `data[0:b-1,indices_slice]`
   is filled into the corresponding location of the `(q-b-1)`-dimensional tensor to form the `output` tensor (Example 1 below)

3) If `indices_shape[-1] < r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensor
   containing 1-D tensors of dimension `< r-b`. Let us think of each such tensors as `indices_slice`. Each *tensor slice* corresponding
   to `data[0:b-1, indices_slice , :]` is filled into the corresponding location of the `(q-b-1)`-dimensional tensor
   to form the `output` tensor (Examples 2, 3, 4 and 5 below)

This operator is the inverse of `ScatterND`.

`Example 1`

  batch_dims = 0

  data    = [[0,1],[2,3]]   # data_shape = [2, 2]

  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]

  output  = [0,3]           # output_shape = [2]

`Example 2`

  batch_dims = 0

  data    = [[0,1],[2,3]]  # data_shape = [2, 2]

  indices = [[1],[0]]      # indices_shape = [2, 1]

  output  = [[2,3],[0,1]]  # output_shape = [2, 2]

`Example 3`

  batch_dims = 0

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]

  output  = [[2,3],[4,5]]                 # output_shape = [2, 2]

`Example 4`

  batch_dims = 0

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]

  output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]

`Example 5`

  batch_dims = 1

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[1],[0]]             # indices_shape = [2, 1]

  output  = [[2,3],[4,5]]             # output_shape = [2, 2]


)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    GatherND,
    12,
    OpSchema()
        .SetDoc(GatherND_ver12_doc)
        .Attr(
            ""batch_dims"",
            ""The number of batch dimensions. The gather of indexing starts from dimension of data[batch_dims:]"",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] ""
            ""along axis of size s. It is an error if any of the index values are out of bounds."",
            ""tensor(int64)"")
        .Output(0, ""output"", ""Tensor of rank q + r - indices_shape[-1] - 1."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);

          // Shape inference
          if (!hasNInputShapes(ctx, 2)) {
            // cannot proceed with shape or rank inference
            return;
          }

          const auto& data_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto data_rank = data_shape.dim_size();

          const auto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
          const auto indices_rank = indices_shape.dim_size();

          int64_t batch_dims_data = getAttribute(ctx, ""batch_dims"", 0);
          if (data_rank < 1 || indices_rank < 1) {
            fail_shape_inference(
                ""Both `data` and `indices` input tensors in GatherND op ""
                ""need to have rank larger than 0."");
          }

          // cannot ascertain if the input shapes are valid if shape of
          // `indices` is missing last dimension value so return at this point
          if (!indices_shape.dim(indices_rank - 1).has_dim_value()) {
            return;
          }

          const auto last_index_dimension = indices_shape.dim(indices_rank - 1).dim_value() + batch_dims_data;

          if (last_index_dimension > data_rank) {
            fail_shape_inference(
                ""Last dimension of `indices` input tensor in GatherND op ""
                ""must not be larger than the rank of `data` tensor"");
          }

          for (int i = 0; i < indices_rank - 1; ++i) {
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = indices_shape.dim(i);
          }

          for (int i = static_cast<int>(last_index_dimension); i < data_rank; ++i) {
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = data_shape.dim(i);
          }
        }));

static const char* Pad_ver11_doc = R""DOC(
Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
a padded tensor (`output`) is generated.

The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):

1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0)

2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis

3) `edge` - pads with the edge values of array


Example 1 (`constant` mode):
  Insert 0 pads to the beginning of the second dimension.

  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'constant'

  constant_value = 0.0

  output =
  [
      [0.0, 0.0, 1.0, 1.2],
      [0.0, 0.0, 2.3, 3.4],
      [0.0, 0.0, 4.5, 5.7],
  ]


Example 2 (`reflect` mode):
  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'reflect'

  output =
  [
      [1.0, 1.2, 1.0, 1.2],
      [2.3, 3.4, 2.3, 3.4],
      [4.5, 5.7, 4.5, 5.7],
  ]


Example 3 (`edge` mode):
  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'edge'

  output =
  [
      [1.0, 1.0, 1.0, 1.2],
      [2.3, 2.3, 2.3, 3.4],
      [4.5, 4.5, 4.5, 5.7],
  ]

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Pad,
    11,
    OpSchema()
        .Attr(
            ""mode"",
            ""Supported modes: `constant`(default), `reflect`, `edge`"",
            AttributeProto::STRING,
            std::string(""constant""))
        .SetDoc(Pad_ver11_doc)
        .Input(0, ""data"", ""Input tensor."", ""T"")
        .Input(
            1,
            ""pads"",
            ""Tensor of integers indicating the number of padding elements to add or remove (if negative) ""
            ""at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. ""
            ""`pads` should be a 1D tensor of shape [2 * input_rank]. ""
            ""`pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...], ""
            ""where xi_begin is the number of pad values added at the beginning of axis `i` and ""
            ""xi_end, the number of pad values added at the end of axis `i`."",
            ""tensor(int64)"")
        .Input(
            2,
            ""constant_value"",
            ""(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0)."",
            ""T"",
            OpSchema::Optional)
        .Output(0, ""output"", ""Tensor after padding."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_numeric_types(), ""Constrain input and output to only numeric types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape inference needs the input data shape
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();

          // Infer output shape if 'pads' tensor is available
          const auto* pads_initializer = ctx.getInputData(1);
          if (nullptr != pads_initializer) {
            if (pads_initializer->dims_size() != 1 || pads_initializer->data_type() != TensorProto::INT64) {
              fail_shape_inference(""'pads' input must be a 1D (shape: [2 * input_rank]) tensor of type int64"");
            }

            const auto& pads_data = ParseData<int64_t>(pads_initializer);
            if (pads_data.size() != static_cast<size_t>(2 * input_rank)) {
              fail_shape_inference(""Pads has incorrect number of values"");
            }

            auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
            for (size_t i = 0; static_cast<int64_t>(i) < input_rank; ++i) {
              const auto& input_dim = input_shape.dim((int)i);
              auto* output_dim = output_shape->add_dim();
              if (input_dim.has_dim_value()) {
                output_dim->set_dim_value(input_dim.dim_value() + pads_data[i] + pads_data[i + input_rank]);
              } else if (pads_data[i] + pads_data[i + input_rank] == 0) {
                *output_dim = input_dim;
              }
            }
          } else {
            // Infer output shapes' rank in any case
            auto* output_shape_0 = getOutputShape(ctx, 0);
            for (size_t i = 0; static_cast<int64_t>(i) < input_rank; ++i) {
              output_shape_0->add_dim();
            }
          }
          return;
        }));

static const char* Cast_ver1_doc = R""DOC(
The operator casts the elements of a given input tensor to a data type
specified by the 'to' argument and returns an output tensor of the same size in
the converted type. The 'to' argument must be one of the data types specified
in the 'DataType' enum field in the TensorProto message.
NOTE: Casting to and from strings is not supported yet.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Cast,
    1,
    OpSchema()
        .SetDoc(Cast_ver1_doc)
        .Attr(
            ""to"",
            ""The data type to which the elements of the input tensor are cast. ""
            ""Strictly must be one of the types from DataType enum in TensorProto"",
            AttributeProto::STRING)
        .Input(0, ""input"", ""Input tensor to be cast."", ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor with the same shape as input with type ""
            ""specified by the 'to' argument"",
            ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain input types. Casting from strings and complex are not supported."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain output types. Casting to strings and complex are not supported.""));

static const char* Cast_ver6_doc = R""DOC(
The operator casts the elements of a given input tensor to a data type
specified by the 'to' argument and returns an output tensor of the same size in
the converted type. The 'to' argument must be one of the data types specified
in the 'DataType' enum field in the TensorProto message.
NOTE: Casting to and from strings is not supported yet.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Cast,
    6,
    OpSchema()
        .SetDoc(Cast_ver6_doc)
        .Attr(
            ""to"",
            ""The data type to which the elements of the input tensor are cast. ""
            ""Strictly must be one of the types from DataType enum in TensorProto"",
            AttributeProto::INT)
        .Input(0, ""input"", ""Input tensor to be cast."", ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor with the same shape as input with type ""
            ""specified by the 'to' argument"",
            ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain input types. Casting from strings and complex are not supported."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain output types. Casting to strings and complex are not supported."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromAttributeToOutput(ctx, ""to"", 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* Concat_ver1_doc = R""DOC(Concatenate a list of tensors into a single tensor)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Concat,
    1,
    OpSchema()
        .Attr(""axis"", ""Which axis to concat on.  Default value is 1."", AttributeProto::INT, OPTIONAL_VALUE)
        .SetDoc(Concat_ver1_doc)
        .Input(0, ""inputs"", ""List of tensors for concatenation"", ""T"", OpSchema::Variadic)
        .Output(0, ""concat_result"", ""Concatenated tensor"", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain output types to float tensors.""));

ONNX_OPERATOR_SET_SCHEMA(
    Concat,
    4,
    OpSchema()
        .Attr(""axis"", ""Which axis to concat on"", AttributeProto::INT)
        .SetDoc(""Concatenate a list of tensors into a single tensor"")
        .Input(0, ""inputs"", ""List of tensors for concatenation"", ""T"", OpSchema::Variadic)
        .Output(0, ""concat_result"", ""Concatenated tensor"", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto numInputs = ctx.getNumInputs();
          if (numInputs < 1 || !hasNInputShapes(ctx, static_cast<int>(numInputs))) {
            return;
          }

          auto rank = ctx.getInputType(0)->tensor_type().shape().dim_size();

          auto axisAttr = ctx.getAttribute(""axis"");
          if (!axisAttr) {
            fail_shape_inference(""Required attribute axis is missing"");
          }
          int axis = static_cast<int>(axisAttr->i());
          if (rank <= axis) {
            fail_shape_inference(""rank must be greater than axis"");
          }
          if (axis < 0) {
            return; // TODO: check if negative axis must be supported
          }

          bool all_lengths_known = true;
          int total_length = 0;

          auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (int64_t i = 0; i < rank; ++i) {
            output_shape->add_dim();
          }

          for (size_t i = 0; i < numInputs; i++) {
            const auto& shape = ctx.getInputType(i)->tensor_type().shape();
            if (shape.dim_size() != rank) {
              fail_shape_inference(""All inputs to Concat must have same rank"");
            }
            for (int j = 0; j < rank; j++) {
              if (j == axis) {
                if (shape.dim(j).has_dim_value()) {
                  total_length += static_cast<int>(shape.dim(j).dim_value());
                } else {
                  all_lengths_known = false;
                }
              } else {
                auto& output_dim = *output_shape->mutable_dim(j);
                const auto& input_dim = shape.dim(j);
                mergeInDimensionInfo(input_dim, output_dim, j);
              }
            }
          }

          if (all_lengths_known) {
            output_shape->mutable_dim(axis)->set_dim_value(total_length);
          }
        }));

static const char* Split_ver1_doc =
    R""DOC(Split a tensor into a list of tensors, along the specified
'axis'. The lengths of the split can be specified using argument 'axis' or
optional second input blob to the operator. Otherwise, the tensor is split
to equal sized parts.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Split,
    1,
    OpSchema()
        .Input(0, ""input"", ""The tensor to split"", ""T"")
        .Input(1, ""split"", ""Optional list of output lengths (see also arg 'split')"", ""T"", OpSchema::Optional)
        .Output(0, ""outputs..."", ""One or more outputs forming list of tensors after splitting"", ""T"", OpSchema::Variadic)
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input types to float tensors."")
        .Attr(""axis"", ""Which axis to split on"", AttributeProto::INT, OPTIONAL_VALUE)
        .Attr(""split"", ""length of each output"", AttributeProto::INTS, OPTIONAL_VALUE)
        .SetDoc(Split_ver1_doc));

static const char* Pad_ver1_doc = R""DOC(
Given `data` tensor, paddings, mode, and value.
Example:
  Insert 0 paddings to the beginning of the second dimension.
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  paddings = [0, 0, 2, 0]
  output = [
      [
          [0.0, 0.0, 1.0, 1.2],
          [0.0, 0.0, 2.3, 3.4],
          [0.0, 0.0, 4.5, 5.7],
      ],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Pad,
    1,
    OpSchema()
        .Attr(
            ""paddings"",
            ""List of integers indicate the padding element count at the ""
            ""beginning and end of each axis, for 2D it is the number of pixel. ""
            ""`paddings` rank should be double of the input's rank. `paddings` format should be as follow ""
            ""[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels ""
            ""added at the beginning of axis `i` and xi_end, the number of pixels added at ""
            ""the end of axis `i`."",
            AttributeProto::INTS)
        .Attr(""mode"", ""Three modes: constant(default), reflect, edge"", AttributeProto::STRING, std::string(""constant""))
        .Attr(""value"", ""One float, indicates the value to be filled, default is 0"", AttributeProto::FLOAT, 0.0f)
        .SetDoc(Pad_ver1_doc)
        .Input(0, ""data"", ""Input tensor."", ""T"")
        .Output(0, ""output"", ""Tensor after padding."", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input and output types to float tensors.""));

static const char* Reshape_ver1_doc = R""DOC(
Reshape the input tensor similar to numpy.reshape.
It takes a tensor as input and an argument `shape`. It outputs the reshaped tensor.
At most one dimension of the new shape can be -1. In this case, the value is
inferred from the size of the tensor and the remaining dimensions. A dimension
could also be 0, in which case the actual dimension value is unchanged (i.e. taken
from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
The input tensor's shape and the output tensor's shape are required to have the same number of elements.)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Reshape,
    1,
    OpSchema()
        .SetDoc(Reshape_ver1_doc)
        .Attr(""shape"", ""New shape"", AttributeProto::INTS, OPTIONAL_VALUE)
        // This attribute was added via AllowConsumed API in OpSchema.
        // After removing the API, we're now using the Attr API to simulate the
        // old definition.
        .Attr(""consumed_inputs"", ""legacy optimization attribute."", AttributeProto::INTS, OPTIONAL_VALUE)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""reshaped"", ""Reshaped data."", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input and output types to float tensors.""));

static const char* Upsample_ver1_doc = R""DOC(
Upsample the input tensor.
The width and height of the output tensor are:
  output_width = floor(input_width * width_scale),
  output_height = floor(input_height * height_scale).
Example:
  Given `data` tensor, width_scale, height_scale, mode,
  Upsample the input 4-D tensor in nearest mode:
  data = [[[
      [1, 2],
      [3, 4]
  ]]]
  width_scale = 2
  height_scale = 2
  mode = ""nearest""
  output = [[[
      [1, 1, 2, 2],
      [1, 1, 2, 2],
      [3, 3, 4, 4],
      [3, 3, 4, 4]
  ]]]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Tile,
    1,
    OpSchema()
        .SetDoc(""Repeat the elements of a tensor along an axis."")
        .Input(0, ""input"", ""Input tensor of any shape."", ""T"")
        .Input(1, ""tiles"", ""Number of repeated copies to make of the input tensor."", ""T"")
        .Input(2, ""axis"", ""Axis along which to repeat."", ""T"")
        .Output(0, ""output"", ""Output tensor of same shape and type as input."", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input types to float tensors."")
        .TypeConstraint(""T1"", {""tensor(int64)""}, ""Constrain tiles and axis's type to int64 tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Only rank of output can be inferred. We can do better if second
          // input is a constant, but this requires extending InferenceContext
          // interface to get values of constant inputs.
        }));

ONNX_OPERATOR_SET_SCHEMA(
    Upsample,
    1,
    OpSchema()
        .SetSupportLevel(OpSchema::SupportType::EXPERIMENTAL)
        .Attr(
            ""width_scale"",
            ""The scale along width dimension. It takes value greater than or equal to 1."",
            AttributeProto::FLOAT)
        .Attr(
            ""height_scale"",
            ""The scale along height dimension. It takes value greater than or equal to 1."",
            AttributeProto::FLOAT)
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest(default), bilinear"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""4-D tensor, [N,C,H,W]"", ""T"")
        .Output(0, ""Y"", ""4-D tensor after resizing, [N,C,H,W]"", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(bool)"", ""tensor(int32)"", ""tensor(int64)"", ""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain output types to bool, int32, int64, float16, float, double tensors."")
        .SetDoc(Upsample_ver1_doc));

static const char* Upsample_ver7_doc = R""DOC(
Upsample the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * scale).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Upsample,
    7,
    OpSchema()
        .Attr(
            ""scales"",
            ""The scale array along each dimension. It takes value greater than or equal to 1.""
            "" The number of elements of 'scales' should be the same as the rank of input 'X'."",
            AttributeProto::FLOATS)
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""N-D tensor"", ""T"")
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .SetDoc(Upsample_ver7_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          const auto& input_shape = getInputShape(ctx, 0);
          auto* output_shape = getOutputShape(ctx, 0);
          const auto* scales = ctx.getAttribute(""scales"");

          if (output_shape->dim_size() > 0) {
            if (output_shape->dim_size() != input_shape.dim_size()) {
              fail_shape_inference(
                  ""Ranks inferred ("",
                  input_shape.dim_size(),
                  "") is not equal to the existing rank value ("",
                  output_shape->dim_size(),
                  "")."");
            }
          } else { // Infer the rank of output anyway
            for (int i = 0; i < input_shape.dim_size(); ++i) {
              output_shape->add_dim();
            }
          }

          if (nullptr != scales) {
            // Infer output shape's dimension value if 'scales' is known.
            if (scales->type() == AttributeProto_AttributeType_FLOATS) {
              const std::vector<float> scales_data(scales->floats().begin(), scales->floats().end());
              if (scales_data.size() != static_cast<size_t>(input_shape.dim_size())) {
                fail_shape_inference(""Number of elements of attribute 'scales' must be same as rank of input 'X'"");
              }
              resizeShapeInferenceHelper_opset7_to_10(input_shape, scales_data, output_shape);
            } else {
              fail_shape_inference(""Attribute 'scales' must have floats type."");
            } // scales->type() == float
          } else {
            fail_shape_inference(""Attribute 'scales' is required."");
          } // nullptr != scales
        }));

static const char* Upsample_ver9_doc = R""DOC(
Upsample the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * scale).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Upsample,
    9,
    OpSchema()
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""N-D tensor"", ""T"")
        .Input(
            1,
            ""scales"",
            ""The scale array along each dimension. It takes value greater than or equal to 1.""
            "" The number of elements of 'scales' should be the same as the rank of input 'X'."",
            ""tensor(float)"")
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input 'X' and output 'Y' to all tensor types."")
        .SetDoc(Upsample_ver9_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset7_to_10(ctx); }));

static const char* Resize_ver10_doc = R""DOC(
Resize the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * scale).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Resize,
    10,
    OpSchema()
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""N-D tensor"", ""T"")
        .Input(
            1,
            ""scales"",
            ""The scale array along each dimension. It takes value greater than 0. If it's less than 1,""
            "" it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should""
            "" be the same as the rank of input 'X'."",
            ""tensor(float)"")
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input 'X' and output 'Y' to all tensor types."")
        .SetDoc(Resize_ver10_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset7_to_10(ctx); }));

static const char* Slice_ver1_doc = R""DOC(
Produces a slice of the input tensor along multiple axes. Similar to numpy:
https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
Slices uses `axes`, `starts` and `ends` attributes to specify the start and end
dimension for each axis in the list of axes, it uses this information to
slice the input `data` tensor. If a negative value is passed for any of the
start or end indices, it represent number of elements before the end of that
dimension. If the value passed to start or end is larger than the `n` (the
number of elements in this dimension), it represents `n`. For slicing to the
end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
Example 1:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  axes = [0, 1]
  starts = [1, 0]
  ends = [2, 3]
  result = [
      [5, 6, 7],
  ]
Example 2:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  starts = [0, 1]
  ends = [-1, 1000]
  result = [
      [2, 3, 4],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Slice,
    1,
    OpSchema()
        .SetDoc(Slice_ver1_doc)
        .Input(0, ""data"", ""Tensor of data to extract slices from."", ""T"")
        .Attr(
            ""axes"",
            ""Axes that `starts` and `ends` apply to. ""
            ""It's optional. If not present, will be treated as ""
            ""[0, 1, ..., len(`starts`) - 1]."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .Attr(""starts"", ""Starting indices of corresponding axis in `axes`"", AttributeProto::INTS)
        .Attr(""ends"", ""Ending indices (exclusive) of corresponding axis in axes`"", AttributeProto::INTS)
        .Output(0, ""output"", ""Sliced data tensor."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          std::vector<int64_t> starts;
          std::vector<int64_t> ends;
          if (!getRepeatedAttribute(ctx, ""starts"", starts) || !getRepeatedAttribute(ctx, ""ends"", ends) ||
              starts.size() != ends.size()) {
            fail_shape_inference(""Incorrect or missing attribute value for starts and ends"");
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            for (int i = 0; (size_t)i < starts.size(); ++i) {
              axes.push_back(i);
            }
          } else if (axes.size() != starts.size()) {
            fail_shape_inference(""Attribute axes has incorrect length"");
          } else if (!std::is_sorted(axes.begin(), axes.end())) {
            // TODO support shape inference for unsorted axes
            return;
          }

          auto  [MASK]  = [](int64_t index) { return index < 0; };
          if (std::any_of(starts.begin(), starts.end(),  [MASK] ) ||
              std::any_of(ends.begin(), ends.end(),  [MASK] ) ||
              std::any_of(axes.begin(), axes.end(),  [MASK] )) {
            // Negative axes were not explicitly discussed in the spec before opset-10.
            // Hence, they are officially not part of the spec, but some models/runtimes may use them.
            // So we perform simple rank inference in this case.
            for (size_t i = 0; (int64_t)i < ctx.getInputType(0)->tensor_type().shape().dim_size(); ++i) {
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
            }
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (size_t i = 0, j = 0; (int64_t)i < ctx.getInputType(0)->tensor_type().shape().dim_size(); ++i) {
            auto* newdim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
            if (j < axes.size() && static_cast<size_t>(axes[j]) == i) {
              // There's a lot of potential behaviors. For now just
              // handle some simple cases.
              if (ctx.getInputType(0)->tensor_type().shape().dim((int)i).has_dim_value() && starts[j] >= 0 &&
                  ends[j] >= 0) {
                auto newval =
                    std::min((int64_t)ctx.getInputType(0)->tensor_type().shape().dim((int)i).dim_value(), ends[j]) -
                    starts[j];
                if (newval >= 0) {
                  newdim->set_dim_value(newval);
                }
              }
              ++j;
            } else {
              *newdim = ctx.getInputType(0)->tensor_type().shape().dim((int)i);
            }
          }
        }));

static const char* Slice_ver10_doc = R""DOC(
Produces a slice of the input tensor along multiple axes. Similar to numpy:
https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
dimension and step for each axis in the list of axes, it uses this information to
slice the input `data` tensor. If a negative value is passed for any of the
start or end indices, it represent number of elements before the end of that
dimension. If the value passed to start or end is larger than the `n` (the
number of elements in this dimension), it represents `n`. For slicing to the
end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
If a negative value is passed for step, it represents slicing backward.
If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
Example 1:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  axes = [0, 1]
  starts = [1, 0]
  ends = [2, 3]
  steps = [1, 2]
  result = [
      [5, 7],
  ]
Example 2:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  starts = [0, 1]
  ends = [-1, 1000]
  result = [
      [2, 3, 4],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Slice,
    10,
    OpSchema()
        .SetDoc(Slice_ver10_doc)
        .Input(0, ""data"", ""Tensor of data to extract slices from."", ""T"")
        .Input(1, ""starts"", ""1-D tensor of starting indices of corresponding axis in `axes`"", ""Tind"")
        .Input(2, ""ends"", ""1-D tensor of ending indices (exclusive) of corresponding axis in `axes`"", ""Tind"")
        .Input(3, ""axes"", ""1-D tensor of axes that `starts` and `ends` apply to."", ""Tind"", OpSchema::Optional)
        .Input(
            4,
            ""steps"",
            ""1-D tensor of slice step of corresponding axis in `axes`. Default to 1. "",
            ""Tind"",
            OpSchema::Optional)
        .Output(0, ""output"", ""Sliced data tensor."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          size_t num_inputs = ctx.getNumInputs();
          if (num_inputs != 3 && num_inputs != 4 && num_inputs != 5) {
            fail_type_inference(""Slice op must have either three, four or five inputs."");
          }
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          // Shape Inference if
          //     1. 2nd and 3rd input data (starts, ends) are available.
          // and 2. 4th and 5th optional input (axes, steps) are either not set,
          // or set and is initializer.
          const TensorProto* startsInitializer = ctx.getInputData(1);
          const TensorProto* endsInitializer = ctx.getInputData(2);
          const TensorProto* axesInitializer = hasInputShape(ctx, 3) ? ctx.getInputData(3) : nullptr;
          const TensorProto* stepsInitializer = hasInputShape(ctx, 4) ? ctx.getInputData(4) : nullptr;

          if (!startsInitializer || !endsInitializer || (hasInputShape(ctx, 3) && !ctx.getInputData(3)) ||
              (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
            return;
          }

          // don't know data_type- can't proceed
          if (!startsInitializer->has_data_type())
            return;

          auto get_initializer_data = [](const TensorProto* initializer) -> std::vector<int64_t> {
            std::vector<int64_t> vec;
            if (initializer->data_type() == TensorProto::INT64) {
              const auto& data = ParseData<int64_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else if (initializer->data_type() == TensorProto::INT32) {
              const auto& data = ParseData<int32_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else {
              // unaccepted data type
              fail_shape_inference(""Only supports `int32_t` or `int64_t` inputs for starts/ends/axes/steps"");
            }
            return vec;
          };

          auto clamp = [](int64_t val, int64_t low, int64_t high) -> int64_t {
            if (val < low)
              return low;
            if (val > high)
              return high;
            return val;
          };

          std::vector<int64_t> starts = get_initializer_data(startsInitializer);
          std::vector<int64_t> ends = get_initializer_data(endsInitializer);

          if (starts.size() != ends.size()) {
            fail_shape_inference(""Incorrect or missing input value for starts and ends"");
          }

          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();
          std::vector<int64_t> axes(starts.size());
          if (!axesInitializer) {
            std::iota(axes.begin(), axes.end(), 0);
          } else {
            axes = get_initializer_data(axesInitializer);
            if (axes.size() != starts.size()) {
              fail_shape_inference(""Input axes has incorrect length"");
            }
          }

          std::vector<int64_t> steps;
          if (!stepsInitializer) {
            steps = std::vector<int64_t>(starts.size(), 1);
          } else {
            steps = get_initializer_data(stepsInitializer);
            if (steps.size() != axes.size()) {
              fail_shape_inference(""Input steps has incorrect length"");
            }
          }

          for (size_t i = 0; (int64_t)i < input_rank; ++i) {
            // first update rank of output dim
            auto* output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
            const auto& input_dim = input_shape.dim((int)i);
            if (input_dim.has_dim_value()) {
              output_dim->set_dim_value(input_dim.dim_value());
            } else if (input_dim.has_dim_param()) {
              output_dim->set_dim_param(TString{input_dim.dim_param()});
            }
          }

          std::unordered_set<int64_t> unique_axes;
          size_t axes_size = axes.size();
          for (size_t axis_index = 0; axis_index < axes_size; ++axis_index) {
            auto axis = axes[axis_index] < 0 ? axes[axis_index] + static_cast<int64_t>(input_rank) : axes[axis_index];

            if (axis >= static_cast<int64_t>(input_rank) || axis < 0) {
              fail_shape_inference(""Input axes has invalid data"");
            }

            if (unique_axes.find(axis) != unique_axes.end()) {
              fail_shape_inference(""'axes' has duplicates"");
            }

            unique_axes.insert(axis);
            auto input_dim = ctx.getInputType(0)->tensor_type().shape().dim((int)axis);

            // input dim value is missing - cannot perform shape inference for
            // this axis
            if (!input_dim.has_dim_value())
              continue;

            const auto input_dim_value = input_dim.dim_value();

            // process step
            auto step = steps[axis_index];
            if (step == 0) {
              fail_shape_inference(""'step' cannot be 0"");
            }

            // process start
            auto start = starts[axis_index];
            if (start < 0)
              start += input_dim_value;
            if (step < 0)
              start = clamp(start, 0, input_dim_value - 1);
            else
              start = clamp(start, 0, input_dim_value);

            // process end
            auto end = ends[axis_index];
            if (end < 0)
              end += input_dim_value;
            if (step < 0)
              end = clamp(end, -1, input_dim_value);
            else
              end = clamp(end, 0, input_dim_value);

            // find output dim value for this axis
            auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / step));
            if (temp < 0)
              temp = 0;

            // assign output value
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->mutable_dim((int)axis)->set_dim_value(temp);
          }
        }));

static const char* Scatter_ver9_doc = R""DOC(
Given `data`, `updates` and `indices` input tensors of rank r >= 1, write the values provided by `updates`
into the first input, `data`, along `axis` dimension of `data` (by default outer-most one as axis=0) at corresponding `indices`.
For each entry in `updates`, the target index in `data` is specified by corresponding entry in `indices`
for dimension = axis, and index in source for dimension != axis. For instance, in a 2-D tensor case,
data[indices[i][j]][j] = updates[i][j] if axis = 0, or data[i][indices[i][j]] = updates[i][j] if axis = 1,
where i and j are loop counters from 0 up to the respective size in `updates` - 1.
Example 1:
  data = [
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
  ]
  indices = [
      [1, 0, 2],
      [0, 2, 1],
  ]
  updates = [
      [1.0, 1.1, 1.2],
      [2.0, 2.1, 2.2],
  ]
  output = [
      [2.0, 1.1, 0.0]
      [1.0, 0.0, 2.2]
      [0.0, 2.1, 1.2]
  ]
Example 2:
  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
  indices = [[1, 3]]
  updates = [[1.1, 2.1]]
  axis = 1
  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Scatter,
    9,
    OpSchema()
        .SetDoc(Scatter_ver9_doc)
        .Attr(
            ""axis"",
            ""Which axis to scatter on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1]"",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(1, ""indices"", ""Tensor of int32/int64 indices, of r >= 1 (same rank as input)."", ""Tind"")
        .Input(2, ""updates"", ""Tensor of rank r >=1 (same rank and shape as indices)"", ""T"")
        .Output(0, ""output"", ""Tensor of rank r >= 1 (same rank as input)."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Input and output types can be of any tensor type."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* DepthToSpace_ver1_doc =
    R""DOC(DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
the input tensor where values from the depth dimension are moved in spatial blocks to the height
and width dimensions.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    DepthToSpace,
    1,
    OpSchema()
        .Attr(""blocksize"", ""Blocks of [blocksize, blocksize] are moved."", AttributeProto::INT)
        .SetDoc(DepthToSpace_ver1_doc)
        .Input(
            0,
            ""input"",
            ""Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth""
            "", H is the height and W is the width."",
            ""T"")
        .Output(0, ""output"", ""Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto blocksize = getAttribute(ctx, ""blocksize"", 0);
          if (blocksize <= 0) {
            fail_shape_inference(""Blocksize must be positive"");
          }
          if (hasInputShape(ctx, 0)) {
            auto& input_shape = getInputShape(ctx, 0);
            if (input_shape.dim_size() == 4) {
              // TODO: Clarify what behavior should be if C is not a multiple of
              // blocksize*blocksize.
              updateOutputShape(
                  ctx,
                  0,
                  {input_shape.dim(0),
                   input_shape.dim(1) / (blocksize * blocksize),
                   input_shape.dim(2) * blocksize,
                   input_shape.dim(3) * blocksize});
            } else {
              fail_shape_inference(""Input tensor must be 4-dimensional"");
            }
          }
        }));

static const char* Gather_ver1_doc = R""DOC(
Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
them in an output tensor of rank q + (r - 1).
Example 1:
```
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  indices = [
      [0, 1],
      [1, 2],
  ]
  output = [
      [
          [1.0, 1.2],
          [2.3, 3.4],
      ],
      [
          [2.3, 3.4],
          [4.5, 5.7],
      ],
  ]
```
Example 2:
```
  data = [
      [1.0, 1.2, 1.9],
      [2.3, 3.4, 3.9],
      [4.5, 5.7, 5.9],
  ]
  indices = [
      [0, 2],
  ]
  axis = 1,
  output = [
      [
          [1.0, 1.9],
          [2.3, 3.9],
          [4.5, 5.9],
      ],
  ]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Gather,
    1,
    OpSchema()
        .SetDoc(Gather_ver1_doc)
        .Attr(
            ""axis"",
            ""Which axis to gather on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1]"",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds. ""
            ""It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Output(0, ""output"", ""Tensor of rank q + (r - 1)."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to any tensor type."")
        .TypeConstraint(""Tind"", {""tensor(int32)"", ""tensor(int64)""}, ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 2)) {
            return;
          }
          const TensorShapeProto& data_shape = ctx.getInputType(0)->tensor_type().shape();
          const TensorShapeProto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
          int r = data_shape.dim_size();
          if (r < 1) {
            fail_shape_inference(""data tensor must have rank >= 1"");
          }
          int q = indices_shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -r || axis >= r) {
            fail_shape_inference(""axis must be in [-r, r-1]"");
          }
          if (axis < 0) {
            axis += r;
          }
          int out_rank = q + r - 1;

          if (out_rank == 0) {
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          }
          for (int i = 0; i < out_rank; ++i) {
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = (i < axis) ? data_shape.dim(i)
                                                                                                  : // i < axis < r
                (i >= axis && i < axis + q) ? indices_shape.dim(i - axis)
                                            : // i - axis < q
                data_shape.dim(i - q + 1); // i < out_rank < q + r - 1
          }
        })
        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { GatherOp13DataPropagator(ctx); }));

static const char* Squeeze_ver1_doc = R""DOC(
Remove single-dimensional entries from the shape of a tensor.
Takes a  parameter `axes` with a list of axes to squeeze.
If `axes` is not provided, all the single dimensions will be removed from
the shape. If an axis is selected with shape entry not equal to one, an error is raised.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Squeeze,
    1,
    OpSchema()
        .Attr(
            ""axes"",
            ""List of non-negative integers, indicate the dimensions to squeeze."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .SetDoc(Squeeze_ver1_doc)
        .Input(0, ""data"", ""Tensors with at least max(dims) dimensions."", ""T"")
        .Output(0, ""squeezed"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();

          for (int i = 0, j = 0; i < input_shape.dim_size(); ++i) {
            if (static_cast<size_t>(j) < axes.size() && axes[j] == i) {
              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
                fail_shape_inference(
                    ""Dimension of input "", i, "" must be 1 instead of "", input_shape.dim(i).dim_value());
              }
              ++j;
            } else {
              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
            }
          }
        }));

static const char* Unsqueeze_ver1_doc = R""DOC(
Insert single-dimensional entries to the shape of a tensor.
Takes one required argument `axes`, a list of dimensions that will be inserted.
Dimension indices in `axes` are as seen in the output tensor. For example:
  Given a tensor such that tensor with shape [3, 4, 5], then
  Unsqueeze(tensor, axes=[0, 4]) has shape [1, 3, 4, 5, 1]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Unsqueeze,
    1,
    OpSchema()
        .Attr(""axes"", ""List of non-negative integers, indicate the dimensions to be inserted"", AttributeProto::INTS)
        .SetDoc(Unsqueeze_ver1_doc)
        .Input(0, ""data"", ""Original tensor"", ""T"")
        .Output(0, ""expanded"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }
          std::sort(axes.begin(), axes.end());

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          int j = 0;
          for (int i = 0; i < ctx.getInputType(0)->tensor_type().shape().dim_size(); ++i) {
            while (static_cast<size_t>(j) < axes.size() &&
                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
              ++j;
            }
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
                ctx.getInputType(0)->tensor_type().shape().dim(i);
          }
          while (static_cast<size_t>(j) < axes.size() &&
                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
            ++j;
          }
        }));

static const char* OneHot_ver9_doc = R""DOC(
    Produces a one-hot tensor based on inputs.
    The locations represented by the index values in the 'indices' input tensor will have 'on_value'
    and the other locations will have 'off_value' in the output tensor, where 'on_value' and 'off_value'
    are specified as part of required input argument 'values', which is a two-element tensor of format
    [off_value, on_value]. The rank of the output tensor will be one greater than the rank of the
    input tensor. The additional dimension is for one-hot representation. The additional dimension will
    be inserted at the position specified by 'axis'. If 'axis' is not specified then then additional
    dimension will be inserted as the innermost dimension, i.e. axis=-1. The size of the additional
    dimension is specified by required scalar input 'depth'. The type of the output tensor is the same
    as the type of the 'values' input. Any entries in the 'indices' input tensor with values outside
    the range [0, depth) will result in one-hot representation with all 'off_value' values in the
    output tensor.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    OneHot,
    9,
    OpSchema()
        .SetDoc(OneHot_ver9_doc)
        .Attr(
            ""axis"",
            ""(Optional) Axis along which one-hot representation in added. Default: axis=-1. ""
            ""axis=-1 means that the additional dimension will be inserted as the ""
            ""innermost/last dimension in the output tensor."",
            AttributeProto::INT,
            static_cast<int64_t>(-1))
        .Input(
            0,
            ""indices"",
            ""Input tensor containing indices. The values must be non-negative integers. ""
            ""Any entries in the 'indices' input tensor with values outside the range [0, depth) ""
            ""will result in one-hot representation with all 'off_value' values in the output tensor.""
            ""In case 'indices' is of non-integer type, the values will be casted to int64 before use."",
            ""T1"")
        .Input(
            1,
            ""depth"",
            ""Scalar specifying the number of classes in one-hot tensor. This is also the size ""
            ""of the one-hot dimension (specified by 'axis' attribute) added on in the output ""
            ""tensor. The values in the 'indices' input tensor are expected to be ""
            ""in the range [0, depth). ""
            ""In case 'depth' is of non-integer type, it will be casted to int64 before use."",
            ""T2"")
        .Input(
            2,
            ""values"",
            ""Rank 1 tensor containing exactly two elements, in the format [off_value, on_value], ""
            ""where 'on_value' is the value used for filling locations specified in 'indices' input ""
            ""tensor, and 'off_value' is the value used for filling locations other than those specified ""
            ""in 'indices' input tensor. "",
            ""T3"")
        .Output(
            0,
            ""output"",
            ""Tensor of rank one greater than input tensor 'indices', i.e. rank(output) = rank(indices) + 1. ""
            ""The data type for the elements of the output tensor is the same as the type of input 'values' ""
            ""is used."",
            ""T3"")
        .TypeConstraint(""T1"", OpSchema::all_numeric_types(), ""Constrain input to only numeric types."")
        .TypeConstraint(""T2"", OpSchema::all_numeric_types(), ""Constrain input to only numeric types."")
        .TypeConstraint(""T3"", OpSchema::all_tensor_types(), ""Constrain to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Check that the node has three inputs.
          if (ctx.getNumInputs() != 3) {
            fail_type_inference(""OneHot node must have three inputs."");
          }
          // Input 'depth' must be a scalar or a single-element vector.
          // TODO: Ideally to match spec for this input only allow Scalar should
          // be allowed. Making this change now can affect backward
          // compatibility for this op. Since this does not seem like a good
          // justification to update version for this op, allowing both scalar
          // and 1 element vector for now. In future when version update for
          // this op is done we should only allow scalar or chage the spec to
          // allow both.
          if (hasInputShape(ctx, 1)) {
            auto& depth_shape = getInputShape(ctx, 1);
            if (depth_shape.dim_size() != 0 && depth_shape.dim_size() != 1) {
              fail_type_inference(""Input 'depth' must be a scalar or rank 1 tensor."");
            }
            if (depth_shape.dim_size() == 1 && depth_shape.dim((int)0).has_dim_value() &&
                depth_shape.dim((int)0).dim_value() != 1) {
              fail_type_inference(""Input 'depth' must have exactly one element."");
            }
          }
          // Input 'values' must be a two-element vector.
          if (hasInputShape(ctx, 2)) {
            auto& values_shape = getInputShape(ctx, 2);
            if (values_shape.dim_size() != 1) {
              fail_type_inference(""Input 'values' must be rank 1 tensor."");
            }
            if (values_shape.dim((int)0).has_dim_value() && values_shape.dim((int)0).dim_value() != 2) {
              fail_type_inference(""Input 'values' must have exactly two elements."");
            }
          }
          // Set output type to be the same as the third input, 'values'.
          propagateElemTypeFromInputToOutput(ctx, 2, 0);
          // Set the output shape, if input 0 (indices) shape is available.
          if (hasInputShape(ctx, 0)) {
            const TensorShapeProto& indices_shape = ctx.getInputType(0)->tensor_type().shape();
            int r = indices_shape.dim_size();
            if (r < 1) {
              fail_shape_inference(""Indices tensor must have rank >= 1"");
            }
            int out_rank = r + 1;
            int axis = static_cast<int>(getAttribute(ctx, ""axis"", -1));
            if (axis < -out_rank || axis >= out_rank) {
              fail_shape_inference(""'axis' must be in [-rank(indices)-1, rank(indices)]"");
            }
            if (axis < 0) {
              axis += out_rank;
            }
            auto* output_shape = getOutputShape(ctx, 0);
            for (int i = 0; i < out_rank; ++i) {
              auto* dim = output_shape->add_dim();
              if (i < axis) {
                if (indices_shape.dim(i).has_dim_value()) {
                  dim->set_dim_value(indices_shape.dim(i).dim_value());
                } else if (indices_shape.dim(i).has_dim_param()) {
                  dim->set_dim_param(TString{indices_shape.dim(i).dim_param()});
                }
              } else if (i > axis) {
                if (indices_shape.dim(i - 1).has_dim_value()) {
                  dim->set_dim_value(indices_shape.dim(i - 1).dim_value());
                } else if (indices_shape.dim(i - 1).has_dim_param()) {
                  dim->set_dim_param(TString{indices_shape.dim(i - 1).dim_param()});
                }
              }
            }
          }
        }));

static const char* Compress_ver9_doc = R""DOC(
    Selects slices from an input tensor along a given axis where condition evaluates to True for each axis index.
    In case axis is not provided, input is flattened before elements are selected.
    Compress behaves like numpy.compress: https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html
    )DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Compress,
    9,
    OpSchema()
        .SetDoc(Compress_ver9_doc)
        .Attr(
            ""axis"",
            ""(Optional) Axis along which to take slices. If not specified, ""
            ""input is flattened before elements being selected."",
            AttributeProto::INT,
            OPTIONAL_VALUE)
        .Input(0, ""input"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""condition"",
            ""Rank 1 tensor of booleans to indicate which slices or data elements to be selected. ""
            ""Its length can be less than the input length alone the axis ""
            ""or the flattened input size if axis is not specified. ""
            ""In such cases data slices or elements exceeding the condition length are discarded."",
            ""T1"")
        .Output(0, ""output"", ""Tensor of rank r if axis is specified. Otherwise output is a Tensor of rank 1."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeConstraint(""T1"", {""tensor(bool)""}, ""Constrain to boolean tensors.""));

static const char* Split_ver2_doc =
    R""DOC(Split a tensor into a list of tensors, along the specified
'axis'. Lengths of the parts can be specified using argument 'split'.
Otherwise, the tensor is split to equal sized parts.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Split,
    2,
    OpSchema()
        .Input(0, ""input"", ""The tensor to split"", ""T"")
        .Output(0, ""outputs"", ""One or more outputs forming list of tensors after splitting"", ""T"", OpSchema::Variadic)
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .Attr(""axis"", ""Which axis to split on. "", AttributeProto::INT, static_cast<int64_t>(0))
        .Attr(""split"", ""length of each output"", AttributeProto::INTS, OPTIONAL_VALUE)
        .SetDoc(Split_ver2_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
            propagateElemTypeFromInputToOutput(ctx, 0, i);
          }
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
          int rank = shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -rank || axis >= rank) {
            fail_type_inference(""Invalid value of attribute 'axis'. Rank="", rank, "" Value="", axis);
          }
          // Previously Split-2 does not mention how to deal with negative axis
          // However, there is an existing test onnx/backend/test/data/pytorch-converted/test_GLU
          // using Split-2 with negative axis and it is hard to be regenerated.
          // To compromise, handle negative axis for Split-2 here.
          if (axis < 0) {
            axis += rank;
          }
          const auto& split_dim = shape.dim(axis);
          if (!split_dim.has_dim_value()) {
            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
              ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->Clear();
            }
            return;
          }
          int split_dim_value = static_cast<int>(split_dim.dim_value());

          std::vector<int64_t> split;
          if (getRepeatedAttribute(ctx, ""split"", split)) {
            if (split.size() != ctx.getNumOutputs()) {
              fail_shape_inference(
                  ""Mismatch between number of splits ("", split.size(), "") and outputs ("", ctx.getNumOutputs(), "")"");
            }
            int64_t total_dim = 0;
            for (int64_t d : split) {
              total_dim += d;
            }
            if (total_dim != split_dim_value) {
              fail_shape_inference(
                  ""Mismatch between the sum of 'split' ("",
                  total_dim,
                  "") and the split dimension of the input ("",
                  split_dim_value,
                  "")"");
            }
          } else {
            int num_outputs = static_cast<int>(ctx.getNumOutputs());
            if (split_dim_value % num_outputs != 0) {
              fail_shape_inference(""The input is not evenly splittable"");
            }
            int chunk_size = split_dim_value / num_outputs;
            for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); i++) {
              split.push_back(chunk_size);
            }
          }
          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
            ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(split[i]);
          }
        }));

static const char* Pad_ver2_doc = R""DOC(
Given `data` tensor, pads, mode, and value.
Example:
  Insert 0 pads to the beginning of the second dimension.
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  pads = [0, 2, 0, 0]
  output = [
      [
          [0.0, 0.0, 1.0, 1.2],
          [0.0, 0.0, 2.3, 3.4],
          [0.0, 0.0, 4.5, 5.7],
      ],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Pad,
    2,
    OpSchema()
        .Attr(
            ""pads"",
            ""List of integers indicating the number of padding elements to add or remove (if negative) ""
            ""at the beginning and end of each axis. For 2D it is the number of pixels. ""
            ""`pads` rank should be double of the input's rank. `pads` format should be as follow ""
            ""[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels ""
            ""added at the beginning of axis `i` and xi_end, the number of pixels added at ""
            ""the end of axis `i`."",
            AttributeProto::INTS)
        .Attr(""mode"", ""Three modes: constant(default), reflect, edge"", AttributeProto::STRING, std::string(""constant""))
        .Attr(""value"", ""One float, indicates the value to be filled."", AttributeProto::FLOAT, 0.0f)
        .SetDoc(Pad_ver2_doc)
        .Input(0, ""data"", ""Input tensor."", ""T"")
        .Output(0, ""output"", ""Tensor after padding."", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input and output types to float tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          auto& input_shape = ctx.getInputType(0)->tensor_type().shape();

          std::vector<int64_t> pads;
          if (!getRepeatedAttribute(ctx, ""pads"", pads)) {
            fail_shape_inference(""Attribute value for pads is required"");
          }
          if (pads.size() != static_cast<size_t>(input_shape.dim_size() * 2)) {
            fail_shape_inference(""Attribute pads has incorrect length"");
            ;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (size_t i = 0; (int64_t)i < input_shape.dim_size(); ++i) {
            auto* newdim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
            if (ctx.getInputType(0)->tensor_type().shape().dim((int)i).has_dim_value()) {
              newdim->set_dim_value(
                  ctx.getInputType(0)->tensor_type().shape().dim((int)i).dim_value() + pads[i] +
                  pads[input_shape.dim_size() + i]);
            } else if (pads[i] + pads[input_shape.dim_size() + i] == 0) {
              *newdim = input_shape.dim((int)i);
            }
          }
        }));

static const char* GatherND_ver11_doc = R""DOC(
Given `data` tensor of rank `r` >= 1, and `indices` tensor of rank `q` >= 1, this operator gathers
slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1`.

`indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
where each element defines a slice of `data`

Some salient points about the inputs' rank and shape:

1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`

2) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r` (inclusive)

3) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
   It is an error if any of the index values are out of bounds.

The output is computed as follows:

The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.

1) If `indices_shape[-1] > r` => error condition

2) If `indices_shape[-1] == r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
   containing 1-D tensors of dimension `r`. Let us think of each such `r` ranked tensor as `indices_slice`.
   Each *scalar value* corresponding to `data[indices_slice]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
   to form the `output` tensor (Example 1 below)

3) If `indices_shape[-1] < r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
   containing 1-D tensors of dimension `< r`. Let us think of each such tensors as `indices_slice`.
   Each *tensor slice* corresponding to `data[indices_slice , :]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
   to form the `output` tensor (Examples 2, 3, and 4 below)

This operator is the inverse of `ScatterND`.

`Example 1`

  data    = [[0,1],[2,3]]   # data_shape = [2, 2]

  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]

  output  = [0,3]           # output_shape = [2]

`Example 2`

  data    = [[0,1],[2,3]]  # data_shape = [2, 2]

  indices = [[1],[0]]      # indices_shape = [2, 1]

  output  = [[2,3],[0,1]]  # output_shape = [2, 2]

`Example 3`

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]

  output  = [[2,3],[4,5]]                 # output_shape = [2, 2]

`Example 4`

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]

  output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    GatherND,
    11,
    OpSchema()
        .SetDoc(GatherND_ver11_doc)
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] ""
            ""along axis of size s. It is an error if any of the index values are out of bounds."",
            ""tensor(int64)"")
        .Output(0, ""output"", ""Tensor of rank q + r - indices_shape[-1] - 1."", ""T"")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);

          // Shape inference
          if (!hasNInputShapes(ctx, 2)) {
            // cannot proceed with shape or rank inference
            return;
          }

          const auto& data_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto data_rank = data_shape.dim_size();

          const auto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
          const auto indices_rank = indices_shape.dim_size();

          if (data_rank < 1 || indices_rank < 1) {
            fail_shape_inference(
                ""Both `data` and `indices` input tensors in GatherND op ""
                ""need to have rank larger than 0."");
          }

          // cannot ascertain if the input shapes are valid if shape of
          // `indices` is missing last dimension value so return at this point
          if (!indices_shape.dim(indices_rank - 1).has_dim_value()) {
            return;
          }

          const auto last_index_dimension = indices_shape.dim(indices_rank - 1).dim_value();

          if (last_index_dimension > data_rank) {
            fail_shape_inference(
                ""Last dimension of `indices` input tensor in GatherND op ""
                ""must not be larger than the rank of `data` tensor"");
          }

          for (int i = 0; i < indices_rank - 1; ++i) {
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = indices_shape.dim(i);
          }

          for (int i = static_cast<int>(last_index_dimension); i < data_rank; ++i) {
            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = data_shape.dim(i);
          }
        }));

ONNX_OPERATOR_SET_SCHEMA(
    Identity,
    14,
    OpSchema()
        .SetDoc(""Identity operator"")
        .Input(0, ""input"", ""Input tensor"", ""V"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Output(0, ""output"", ""Tensor to copy input into."", ""V"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .TypeConstraint(
            ""V"",
            []() {
              auto t = OpSchema::all_tensor_types_with_bfloat();
              auto s = OpSchema::all_tensor_sequence_types();
              t.insert(t.end(), s.begin(), s.end());
              return t;
            }(),
            ""Constrain input and output types to all tensor and sequence types."")
        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));

static const char* Where_ver9_doc = R""DOC(
Return elements, either from X or Y, depending on condition.
Where behaves like
[numpy.where](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html)
with three parameters.

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Where,
    9,
    OpSchema()
        .SetDoc(Where_ver9_doc + GenerateBroadcastingDocMul())
        .Input(
            0,
            ""condition"",
            ""When True (nonzero), yield X, otherwise yield Y"",
            ""B"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            1,
            ""X"",
            ""values selected at indices where condition is True"",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .Input(
            2,
            ""Y"",
            ""values selected at indices where condition is False"",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .Output(
            0,
            ""output"",
            ""Tensor of shape equal to the broadcasted shape of condition, X, and Y."",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .TypeConstraint(""B"", {""tensor(bool)""}, ""Constrain to boolean tensors."")
        .TypeConstraint(""T"", OpSchema::all_tensor_types(), ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 1, 0);
          if (hasNInputShapes(ctx, 3)) {
            std::vector<const TensorShapeProto*> shapes;
            shapes.push_back(&ctx.getInputType(0)->tensor_type().shape());
            shapes.push_back(&ctx.getInputType(1)->tensor_type().shape());
            shapes.push_back(&ctx.getInputType(2)->tensor_type().shape());
            multidirectionalBroadcastShapeInference(
                shapes, *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
          }
        }));

static const char* Pad_ver13_doc = R""DOC(
Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
a padded tensor (`output`) is generated.

The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):

1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)

2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis

3) `edge` - pads with the edge values of array


Example 1 (`constant` mode):
  Insert 0 pads to the beginning of the second dimension.

  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'constant'

  constant_value = 0.0

  output =
  [
      [0.0, 0.0, 1.0, 1.2],
      [0.0, 0.0, 2.3, 3.4],
      [0.0, 0.0, 4.5, 5.7],
  ]


Example 2 (`reflect` mode):
  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'reflect'

  output =
  [
      [1.0, 1.2, 1.0, 1.2],
      [2.3, 3.4, 2.3, 3.4],
      [4.5, 5.7, 4.5, 5.7],
  ]


Example 3 (`edge` mode):
  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'edge'

  output =
  [
      [1.0, 1.0, 1.0, 1.2],
      [2.3, 2.3, 2.3, 3.4],
      [4.5, 4.5, 4.5, 5.7],
  ]

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Pad,
    13,
    OpSchema()
        .Attr(
            ""mode"",
            ""Supported modes: `constant`(default), `reflect`, `edge`"",
            AttributeProto::STRING,
            std::string(""constant""))
        .SetDoc(Pad_ver13_doc)
        .Input(0, ""data"", ""Input tensor."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .Input(
            1,
            ""pads"",
            ""Tensor of integers indicating the number of padding elements to add or remove (if negative) ""
            ""at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. ""
            ""`pads` should be a 1D tensor of shape [2 * input_rank]. ""
            ""`pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...], ""
            ""where xi_begin is the number of pad values added at the beginning of axis `i` and ""
            ""xi_end, the number of pad values added at the end of axis `i`."",
            ""tensor(int64)"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Input(
            2,
            ""constant_value"",
            ""(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, ""
            ""empty string or False)."",
            ""T"",
            OpSchema::Optional,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Output(0, ""output"", ""Tensor after padding."", ""T"", OpSchema::Single, true, 1, OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape inference needs the input data shape
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();

          // Infer output shape if 'pads' tensor is available
          const auto* pads_initializer = ctx.getInputData(1);
          if (nullptr != pads_initializer) {
            if (pads_initializer->dims_size() != 1 || pads_initializer->data_type() != TensorProto::INT64) {
              fail_shape_inference(""'pads' input must be a 1D (shape: [2 * input_rank]) tensor of type int64"");
            }

            const auto& pads_data = ParseData<int64_t>(pads_initializer);
            if (pads_data.size() != static_cast<size_t>(2 * input_rank)) {
              fail_shape_inference(""Pads has incorrect number of values"");
            }

            auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
            for (size_t i = 0; static_cast<int64_t>(i) < input_rank; ++i) {
              const auto& input_dim = input_shape.dim((int)i);
              auto* output_dim = output_shape->add_dim();
              if (input_dim.has_dim_value()) {
                output_dim->set_dim_value(input_dim.dim_value() + pads_data[i] + pads_data[i + input_rank]);
              } else if (pads_data[i] + pads_data[i + input_rank] == 0) {
                *output_dim = input_dim;
              }
            }
          } else {
            // Infer output shapes' rank in any case
            auto* output_shape_0 = getOutputShape(ctx, 0);
            for (size_t i = 0; static_cast<int64_t>(i) < input_rank; ++i) {
              output_shape_0->add_dim();
            }
          }
          return;
        }));

} // namespace ONNX_NAMESPACE
",is_negative
72,"#include <ESP8266WiFi.h>
#include <FirebaseArduino.h>
#include <Ultrasonic.h>



#define LED     D0        // Led in NodeMCU at pin GPIO16 (D0).
// Set these to run example.
#define FIREBASE_HOST ""garagecardetector.firebaseio.com""
#define FIREBASE_AUTH ""TuJmJEc1YJRAOtEEiS1qYxYE2KiqRDaWNkGxyLhm""//change with your Database secrets
#define WIFI_SSID ""TuHu""
#define WIFI_PASSWORD ""<PASSWORD>""
#define NODE_NAME ""LB Aventador""
#define NODE_KEY ""aventador""
#define VEHICLE_RANG 150 //number cm from node to vehicle 
#define GMC_START ""{\""time_to_live\"":300,\""to\"":\""/topics/garages-car-detector\"",\""notification\"":{\""title\"":\""The car state change\"",\""body\"":\""""//change""garages-car-detector"" with your topic
#define GMC_END ""\""}}""
//for GMC
char API_key[] = ""<KEY>"";//change with server mgs key
const char* host = ""fcm.googleapis.com"";
const char* GMC_DATA = ""{\""time_to_live\"":300,\""to\"":\""/topics/garages-car-detector\"",\""notification\"":{\""title\"":\""The car state change\"",\""body\"":\""testcfsdf\""}}"";//Change topic with yours

WiFiClient client;
//
long lastMsg = 0;
Ultrasonic ultrasonic(5, 4); // (Trig PIN,Echo PIN) D1(GPIO5) and D2(GPIO4) in Nodemcu 1.0
long distance;
bool inRange;
bool lastState;
StaticJsonBuffer<150> jsonBuffer;
JsonObject& timestamp = jsonBuffer.createObject();
JsonObject& updateData = jsonBuffer.createObject();
void wifi_smartconfig()
{
  int  [MASK]  = 0;
  WiFi.mode(WIFI_STA);
  while (WiFi.status() != WL_CONNECTED) {
    digitalWrite(LED, LOW);          // turn the LED on.
    Serial.print(""."");
    delay(250);
    digitalWrite(LED, HIGH);          // turn the LED off.
    delay(250);
    Serial.print(""."");
    if ( [MASK] ++ >= 20) {
        digitalWrite(LED, LOW);          // turn the LED on.
        Serial.print(""."");
        delay(150);
        digitalWrite(LED, HIGH);          // turn the LED off.
        delay(550);
      
      Serial.print(""Smartconfig..."");
      WiFi.beginSmartConfig();
      while (1) {
        delay(1000);
        if (WiFi.smartConfigDone()) {
          Serial.println(""SmartConfig Success"");
          break;
        }
      }
    }
  }

}
void setup() {
  pinMode(LED, OUTPUT);   // LED pin as output.    low to on led, high to off led
  Serial.begin(9600);
//      // connect to wifi.
//      WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
//      Serial.print(""connecting"");
//      while (WiFi.status() != WL_CONNECTED) {
//        digitalWrite(LED, LOW);          // turn the LED on.
//        Serial.print(""."");
//        delay(250);
//        digitalWrite(LED, HIGH);          // turn the LED on.
//        delay(250);
//      }
  

  wifi_smartconfig();
  Serial.println();
  Serial.print(""connected: "");
  Serial.println(WiFi.localIP());

  timestamp["".sv""] = ""timestamp"";
  Serial.println();
  timestamp.prettyPrintTo(Serial);
  Serial.println();
  Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);
}
void updateDistance()
{
  updateData[""name""] = NODE_NAME;
  updateData[""distance""] = distance;
  updateData[""in_range""] = inRange;
  updateData[""timestamp""] = timestamp;
  Firebase.set(NODE_KEY, updateData);
  Serial.println();
  Serial.println(""Data update"");
  updateData.prettyPrintTo(Serial);
  Serial.println();
  if (Firebase.failed()) {
    Serial.print(""setting time failed:"");
    Serial.println(Firebase.error());
    return;
  }
  digitalWrite(LED, LOW);          // turn the LED on.
  delay(200);
  digitalWrite(LED, HIGH);         // turn the LED off.
  delay(500);
}
//Function for sending the request to GCM
void sendToGCM() {
  Serial.print(""connecting to "");
  Serial.println(host);
  if (!client.connect(host, 80)) {
    Serial.println(""connection failed"");
    return;
  }
  if (client.connected())
  {


    String body;
    body += F(NODE_NAME);
    if (inRange == true)body += F("" is safe"");
    else body += F("" is out of range"");
    long msg_size = strlen(GMC_START) + body.length() + strlen(GMC_END);

    Serial.println(""sending request"");
    client.print(""POST /fcm/send HTTP/1.1\r\n""); // http POST request
    client.print(""Host: fcm.googleapis.com\r\n"");
    client.println(""User-Agent: Arduino"");
    client.print(""Authorization:key="");//<KEY>
    client.println(API_key);
    client.print(""Content-Type: application/json\r\n"");
    client.println(""Connection: close"");
    client.print(""Content-length: ""); // has to be exactly the number of characters (bytes) in the POST body
    //client.println(strlen(GMC_DATA)); // calculate content-length
    // client.println("""");
    // client.print(GMC_DATA);

    client.println(msg_size); // calculate content-length
    client.println("""");
    client.print(GMC_START);
    client.print(body);
    client.print(GMC_END);
    delay(10);
    Serial.println(""request sent"");
    while (client.connected()) {
      String line = client.readStringUntil('\n');
      if (line == ""\r"") {
        Serial.println(""headers received"");
        break;
      }
    }
    String line = client.readStringUntil('\n');
    Serial.println(""reply was:"");
    Serial.println(""=========="");
    Serial.println(line);
    Serial.println(""=========="");
  }
}
void loop()
{
  distance = ultrasonic.Ranging(CM);// CM or INC
  Serial.print(""Distance:"" );
  Serial.print(distance);
  Serial.println("" cm"" );
  delay(100);
  if (distance < VEHICLE_RANG)
  {
    inRange = true;
    //recheck distance // anti noise
    for (int i = 0; i < 5; i++)
    {
      distance = ultrasonic.Ranging(CM);// CM or INC
      if (distance >= VEHICLE_RANG)
      {
        inRange = false;
        break;
      }
    }
  }
  if (inRange != lastState)
  {
    Serial.print(""In Range:"" );
    Serial.print(inRange);
    lastState = inRange;
    updateDistance();
    //Push notifycation
     sendToGCM();


  }
  else
  {
    long now = millis();
    if (now - lastMsg > 30000) {//every 30 seconds
      Serial.print(""Update every:"" );
      lastMsg = now;
      updateDistance();
    }
  }

}
",cnt
73,"
#include <iostream>
#include ""DecisionHelper.h""

int main() {
    std::vector<std::string> criteria = {""coût"", ""temps"", ""bénéfice""};
    std::vector<double> weights = {0.4, 0.3, 0.3};

    DecisionHelper decisionHelper(criteria, weights);

    std::vector<double> values(criteria.size());

    std::cout << ""Entrez les valeurs pour les critères suivants:"" << std::endl;
    for (size_t i = 0; i < criteria.size(); ++i) {
        std::cout << criteria[i] << "": "";
        std::cin >> values[i];
    }

    decisionHelper.setCriteriaValues(values);
    decisionHelper.calculateScore();

    double  [MASK] ;
    std::cout << ""Entrez le seuil de décision: "";
    std::cin >>  [MASK] ;

    std::string decision = decisionHelper.makeDecision( [MASK] );
    std::cout << ""La décision est: "" << decision << std::endl;

    return 0;
}",threshold
74,"/*
<NAME> 07/2023 PROJECT 1
SNHU CS
*/
#include <sstream>
#include ""extra.h""


/*Establishes the clock variables which we will be interacting with to declare value and the make user inputted changes*/
Clock::Clock(int h, int m, int sec)
    : h(h), m(m), sec(sec) {}



void Clock::minadd() 
{
    m++;
    if (m >= 60) {
        m = 0;
        houradd();
    }
}


void Clock::secadd() 
{
 sec++;
    if (sec >= 60) {
        sec = 0;
        minadd();
    }
}
void Clock::houradd()
{
    h = (h + 1) % 24;
}

/*Declares the format of the 12 hour clock*/
string Clock::h12form() const
{
    int hours12 = (h % 12 == 0) ? 12 : h % 12;
    string period = (h >= 12) ? ""am"" : ""pm"";
    stringstream ss;
    ss << form(hours12) << "":""
        << form(m) << "":""
        << form(sec) << "" "" << period;
    return ss.str();
}
string Clock::form(int  [MASK] ) const 
{
    if ( [MASK]  < 10) {
        return ""0"" + to_string( [MASK] );
    }
    return to_string( [MASK] );
}
/*declares the 24 hour clock format*/
string Clock::h24form() const 
{
    stringstream ss;
    ss << form(h) << "":""
        << form(m) << "":""
        << form(sec);
    return ss.str();
}
/*


 _
| |
| |__   ___
| '_ \ / __|
| |_) | (__
|_.__/ \___|

*/",number
75,"#include ""pch.hpp""
#include ""plugins.hpp""

#include ""utility/unused.hpp""

namespace CBSW::Unit {
    class PluginChainFinal: public PluginNextHandler {
    public:
        PluginChainFinal(PluginFinal& final):
            _final(final)
        {}

        int next(Arguments& arguments) noexcept {
            unused(arguments);
            return _final.finalPluginFunction();
        }
    private:
        PluginFinal& _final;
    };

    class PluginChainWrapper: public PluginNextHandler {
    public:
        PluginChainWrapper(Plugin& plugin, PluginNextHandler& next):
            _plugin(plugin),
            _next(next)
        {}

        int next(Arguments& arguments) noexcept {
            return _plugin.initialise(arguments, _next);
        }
    private:
        Plugin &_plugin;
        PluginNextHandler& _next;
    };

    int Plugins::run(Arguments& arguments, PluginFinal& final) {
        std::list<PluginNextHandler*> nextHandlers;

        PluginChainFinal* finalChain = new PluginChainFinal(final);
        PluginNextHandler* next = finalChain;
        nextHandlers.push_back(finalChain);

        //construct in reverse order

        for (auto plugin: _plugins) {
            PluginNextHandler* nextHandler = new PluginChainWrapper(*plugin, *next);
            next = nextHandler;
            nextHandlers.push_back(nextHandler);
        }

        //now next contains the first plugin in the chain
        int  [MASK]  = next->next(arguments);

        for (PluginNextHandler* handler: nextHandlers) {
            delete handler;
        }
        return  [MASK] ;
    }

    void Plugins::registerPlugin(Plugin& plugin) {
        _plugins.push_back(&plugin);
    }
}",output
76,"#include <vector>
#include <tuple>
#include <iostream>
#include <sstream>
#include <math.h>
#include <memory>
#include <numeric>


static std::string check_the_check();
static std::string check_the_check(std::string data);
static std::string check_the_check(std::vector<std::string> data);

enum class Color
{
	Black,
	White
};

static Color oposite_color(Color c) { return (c == Color::White ? Color::Black : Color::White); }

struct Pair
{
	Pair(int xx, int yy) : x(xx), y(yy) {}

	int x;
	int y;
};

struct Figure
{
	Figure(int x, int y, Color color) : m_color(color), m_x(x), m_y(y) {}
	virtual ~Figure(){}

	bool is_king() { return false; }
	// FIXME m_horse
	bool is_horseman() { return m_horse; }
	//auto position() const { return std::make_tuple(m_x, m_y); }
	std::tuple<int, int> position() const { return std::make_tuple(m_x, m_y); }

	virtual bool can_check(int kingx, int kingy) = 0;

	Color m_color;
	int m_x;
	int m_y;
	bool m_horse = false;
};

struct King: public Figure
{
	King(int x, int y, Color color) : Figure(x, y, color) { }
	bool is_king() { return true; }
	bool can_check(int kingx, int kingy) override
	{
		return (abs(m_x - kingx) <= 1 && abs(m_y - kingy) <= 1);
	}
};

struct Knight: public Figure
{
	Knight(int x, int y, Color color) : Figure(x, y, color){}
	bool is_horseman() { return true; }
	bool can_check(int, int) override { return false; }
};

struct Bischop: public Figure
{
	Bischop(int x, int y, Color color) : Figure(x, y, color){}
	bool can_check(int kingx, int kingy) override
	{
		return (abs(m_x - kingx) == abs(m_y - kingy));
	}
};

struct Rook: public Figure
{
	Rook(int x, int y, Color color) : Figure(x, y, color){}
	bool can_check(int kingx, int kingy) override
	{
		return (m_x == kingx || m_y == kingy);
	}
};

struct Queen: public Figure
{
	Queen(int x, int y, Color color) : Figure(x, y, color){}
	bool can_check(int kingx, int kingy) override
	{
		return (abs(m_x - kingx) == abs(m_y - kingy) || m_x == kingx || m_y == kingy);
	}
};

struct Pawn: public Figure
{
	Pawn(int x, int y, Color color) : Figure(x, y, color){}
	bool can_check(int kingx, int kingy) override
	{
		if (m_color == Color::White && m_y < kingy) { return false; }
		if (m_color == Color::Black && m_y > kingy) { return false; }

		return (
			(kingx == m_x - 1 || kingx == m_x + 1) && (kingy == m_y - 1 or kingy == m_y + 1)
		);
	}
};


struct Board
{
	// FIXME
	Board(int x, int y) : stdin_input(true), m_game_counter(-1), m_size(x, y)
	{
		figures = std::vector<Figure*>(static_cast<unsigned int>(x*y), nullptr);
	}

	~Board() { for (auto& figure : figures) { delete figure; } }

	void Clean()
	{
		for (auto& figure : figures) { delete figure; }

		figures = std::vector<Figure*>(static_cast<unsigned int>(m_size.x * m_size.y), nullptr);
		wKing = nullptr;
		bKing = nullptr;
	}

	bool load(std::string data)
	{
		m_data = data;
		return load_nostdin();
	}

	// bool load(std::vector<std::string> data)
	// {
	// 	m_data = std::accumulate(data.begin(), data.end(), std::string(""""));
	// 	return load_nostdin();
	// }


	bool load_nostdin()
	{
		stdin_input = false;
		return load();
	}

	// FIXME -fuj dvoji logika paralelne ss/cin
	bool load()
	{
		m_game_counter++;

		std::stringstream ss;
		if (!stdin_input) { ss.str(m_data); }

		if (stdin_input && std::cin.eof()) { return false; }

		figures = std::vector<Figure*>(
			static_cast<unsigned int>(m_size.x * m_size.y), nullptr
		);
		
		int j = 0;
		for (std::string line; std::getline(stdin_input ? std::cin : ss, line);)
		{
			if (stdin_input && std::cin.eof())
				return false;

			// client input, only one scenario (board)
			if (!stdin_input && line == """")
				return false;

			if (line == """")
				return true;

			int i = 0;
			for (auto x : line)
			{
				if (x != '\n' || x != '.')
				{
					Figure* figure = nullptr;
					switch (x)
					{
						case 'K': figure = new King(i, j, Color::White); wKing = figure; break;
					    case 'k': figure = new King(i, j, Color::Black); bKing = figure; break;
					    case 'Q': figure = new Queen(i, j, Color::White); break;
					    case 'q': figure = new Queen(i, j, Color::Black); break;
					    case 'R': figure = new Rook(i, j, Color::White); break;
					    case 'r': figure = new Rook(i, j, Color::Black); break;
					    case 'B': figure = new Bischop(i, j, Color::White); break;
					    case 'b': figure = new Bischop(i, j, Color::Black); break;
						// FIXME, i dont udenrstand OOP i guess
					    case 'N': figure = new Knight(i, j, Color::White); figure->m_horse = true; break;
					    case 'n': figure = new Knight(i, j, Color::Black); figure->m_horse = true; break;
					    case 'P': figure = new Pawn(i, j, Color::White); break;
					    case 'p': figure = new Pawn(i, j, Color::Black); break;
					}
					figures.at(static_cast<unsigned long>(j * m_size.x + i)) = figure;
				}
				i++;
			}
			j++;
		}
		return true;
	}

	bool in_board(int x, int y)
	{
		return (x < m_size.x && x >= 0) && (y < m_size.y && y >= 0);
	}
	
	bool check_check(Color color, bool* empty)
	{
		if (color == Color::White && wKing == nullptr) { *empty = true; return false; }
		if (color == Color::Black && bKing == nullptr) { *empty = true; return false; }
		
	    return false || check_horsemen(color) || check_in_directions(color); 
	}

	bool check_horsemen(Color color)
	{
	    auto f = color == Color::White ? wKing : bKing;
		//auto [x, y] = f->position();
		auto x = f->m_x; // std::get<0>(f->position());
		auto y = f->m_y; // std::get<1>(f->position());

	    std::vector<std::tuple<int, int>> shifts = {
	        {-2, -1}, {-1, -2},
	        {-2, 1}, {-1, 2},
	        {2, -1}, {1, -2},
	        {2, 1}, {1, 2},
	    };

	    for (unsigned int i = 0; i < 8; i++)
	    {
			//auto [x1, y1] = shifts[i];
			auto x1 = std::get<0>(shifts[i]);
			auto y1 = std::get<1>(shifts[i]);
	        if (in_board(x + x1, y + y1))
	        {
				Figure* figure = figures.at((static_cast<unsigned long>((y + y1) * m_size.x) + static_cast<unsigned int>(x + x1)));
	            if (figure != nullptr)
				{
	                if ((figure->m_color == oposite_color(color)) && figure->is_horseman())
					{
						return true;
					}	
				}
			}
		}
	    return false;
	}
	
	bool check_in_directions(Color color)
	{
	    bool ret = false;
	    for (int i = -1; i < 2; i++)
	    {
	        for (int j = - 1; j < 2; j++)
	        {
	            if (i || j)
	            {
	                ret = ret || check_in_direction(color, i, j);			
	            }
	        }
	    }
	    return ret;
	}

	bool check_in_direction(Color color, int i, int j)
	{
	    auto f = color == Color::White ? wKing : bKing;
		//auto [x, y] = f->position();
		auto x = std::get<0>(f->position());
		auto y = std::get<1>(f->position());

	    bool  [MASK]  = true;
	    while ( [MASK] )
	    {
			Figure* figure = figures.at(static_cast<unsigned int>(y * (m_size.y)) + static_cast<unsigned int>(x));

	        if (figure != nullptr && (x != f->m_x || y != f->m_y))
	        {
	            if (figure->can_check(f->m_x, f->m_y) && (figure->m_color == (color == Color::White ? Color::Black : Color::White)))
				{
	                return true;
				}
				return false;
	        }
	        x += i;
	        y += j;
	         [MASK]  = in_board(x, y);
	    }
	    return  false;
	}
	
	bool stdin_input;
	int m_game_counter;
	Pair m_size;
	std::vector<Figure*> figures;
	std::string m_data;
	Figure* wKing = nullptr;
	Figure* bKing = nullptr;
};

static std::string solve_problem(Board& board)
{
	std::string output;

	bool wEmpty = false;
	bool bEmpty = false;
	bool a = true;
	while (a)
	{
		bool white = board.check_check(Color::White, &wEmpty);
		bool black = board.check_check(Color::Black, &bEmpty);

		if (!wEmpty || !bEmpty)
		{
			output += ""Game #"" + std::to_string(board.m_game_counter + 1) + "": "";

			if (white) { output += ""white""; }
			if (black) { output += ""black""; }
			if (!white && !black) { output += ""no""; }

			output += "" king is in check.\n"";
		}

		board.Clean();
		a = board.load();
		wEmpty = false;
		bEmpty = false;
	}

	//std::cout << ""DEBUG:\n"" << output << '\n';

	return output;
}

static std::string check_the_check()
{
	Board board = Board(8, 8);
	[[maybe_unused]]  bool a = board.load();

	std::string out = solve_problem(board);
	std::cout << out; // << '\n';
	return out;
}

static std::string check_the_check(std::string data)
{
	Board board = Board(8, 8);
	[[maybe_unused]]  bool a = board.load(data);

	return solve_problem(board);
}

// static std::string check_the_check(std::vector<std::string> data)
// {
// 	Board board = Board(8, 8);
// 	[[maybe_unused]]  bool a = board.load(data);
// 
// 	return solve_problem(board);
// }
",keep_finding
77,"#include ""../src/Common.h""
#include ""../src/Context.h""
#include <iostream>

using std::vector;
using std::cout;
using std::endl;

int main(int argc, char *argv[], char *env[]) {
    vector<Item> items{
            Item{""E"", ItemType::NoTerminal},
            Item{""E_"", ItemType::NoTerminal},
            Item{""T"", ItemType::NoTerminal},
            Item{""T_"", ItemType::NoTerminal},
            Item{""F"", ItemType::NoTerminal},
            Item{""^"", ItemType::Terminal},
            Item{""+"", ItemType::Terminal},
            Item{""*"", ItemType::Terminal},
            Item{""("", ItemType::Terminal},
            Item{"")"", ItemType::Terminal},
            Item{""i"", ItemType::Terminal},
    };
    auto &E = items[0];
    auto &E_ = items[1];
    auto &T = items[2];
    auto &T_ = items[3];
    auto &F = items[4];
    auto &empty = items[5];
    auto &plus = items[6];
    auto &star = items[7];
    auto &left = items[8];
    auto &right = items[9];
    auto &i = items[10];
    vector<Production> grammar{
            Production{E, vector<Item>{T, E_}},
            Production{E_, vector<Item>{plus, T, E_}},
            Production{E_, vector<Item>{empty}},
            Production{T, vector<Item>{F, T_}},
            Production{T_, vector<Item>{star, F, T_}},
            Production{T_, vector<Item>{empty}},
            Production{F, vector<Item>{left, E, right}},
            Production{F, vector<Item>{i}},
    };
    Context  [MASK] {grammar, grammar[0]};
    cout << ""--- the grammar is ---"" << endl;
     [MASK] .printGrammar();
     [MASK] .first();
    cout << ""--- the first set is ---"" << endl;
     [MASK] .printFirst();
     [MASK] .follow();
    cout << ""--- the follow set is ---"" << endl;
     [MASK] .printFollow();
    return 0;
}
",context
78,"/***
 * @Author: Heng
 * @Date: 2022-10-27 03:51:31
 * @LastEditTime: 2022-10-27 03:51:44
 * @LastEditors: Heng
 * @Description:
 * @FilePath: /DataStructure/分治/最大连续子序列和.cpp
 * @Heng
 */
#include <iostream>
using namespace std;
#include <climits>
#include <vector>

class Solution
{
public:
    /***
     * @description: 暴力求解
     * @param {vector<int>} &nums
     * @return {*}
     */
    int maxSubArray0(vector<int> &nums)
    {
        int res = INT_MIN;
        for (int begin = 0; begin < nums.size(); begin++)
        {
            int tmp = 0;
            for (int end = begin; end < nums.size(); end++)
            {
                tmp += nums[end];
                res = max(tmp, res);
            }
        }
        return res;
    }
    /***
     * @description: 分治算法 
     * @param {vector<int>} &nums
     * @return {*}
     */
    int maxSubArray1(vector<int> &nums)
    {
        if (nums.size() == 1)
        {
            return nums[0];
        }
        return this->maxSubArray1(nums, 0, nums.size());
    }
    /*** 
     * @description: 求[begin, end) 的最大连续子序列和
     * @param {vector<int>} &nums
     * @param {int} begin
     * @param {int} end
     * @return {*}
     */    
    int maxSubArray1(vector<int> &nums, int begin, int end)
    {
        // 递归基
        if (end - begin < 2)
            return nums[begin];
        int mid = (begin + end) >> 1;
        // 左边
        int leftMax = this->maxSubArray1(nums, begin, mid);
        // 右边
        int rightMax = this->maxSubArray1(nums, mid, end);
        // 中间
        // 中左
        int leftMidMax = INT_MIN;
        int left_sum = 0;
        for (int i = mid - 1; i >= begin; i--)
        {
            left_sum += nums[i];
            leftMidMax = max(left_sum, leftMidMax);
        }
        // 中右
        int rightMidMax = INT_MIN;
        int right_sum = 0;
        for (int i = mid; i < end; i++)
        {
            right_sum += nums[i];
            rightMidMax = max(right_sum, rightMidMax);
        }
        int  [MASK]  = leftMidMax + rightMidMax;
        return max( [MASK] , max(leftMax, rightMax));
    }
};

int main(int argc, char const *argv[])
{
    Solution s = Solution();
    vector<int> nums{-2, 1, -3, 4, -1, 2, 1, -5, 4};
    int res = s.maxSubArray1(nums);
    cout << res << endl;
    return 0;
}",mid_max
79,"#include <cstring>

#include <ostream>
#include <variant>

#include <pl/numeric.hpp>
#include <pl/os.hpp>
#include <pl/overload.hpp>
#include <pl/string_view.hpp>

#include <fmt/format.h>
#include <fmt/ostream.h>

#include ""command_line_arguments.hpp""

namespace bfc {
namespace {
constexpr int maximumArgumentCount{2};

struct transpile {
};

struct dummy {
};

[[nodiscard]] std::variant<std::string, transpile, Error> secondOption(
  int    actualArgumentCount,
  char** argv)
{
  constexpr int compilerTranspilationIndex{2};

  if (actualArgumentCount == maximumArgumentCount) {
    const char* const option{argv[compilerTranspilationIndex]};

    if (std::strcmp(option, ""--transpile"") == 0) { return transpile{}; }

    constexpr pl::string_view compilerOptionBegin{""--compiler=""};
    pl::string_view           optionStringView{option};

    if (optionStringView.starts_with(compilerOptionBegin)) {
      optionStringView.remove_prefix(compilerOptionBegin.size());
      return optionStringView.to_string();
    }

    return Expected<dummy>{
      BFC_UNEXPECTED(
        Error::InvalidArgument,
        fmt::format(""\""{}\"" could not be parsed."", option))}
      .error();
  }
  else {
    using namespace std::string_literals;
#if PL_OS == PL_OS_LINUX
    return ""/usr/bin/cc""s;
#elif PL_OS == PL_OS_WINDOWS
    return ""cl.exe""s;
#else
#error ""Unsupporetd operating system!""
#endif
  }
}

struct [[nodiscard]] Result
{
  std::string compilerPath;
  bool        isJustTranspilation;
};

} // namespace

Expected<CommandLineArguments> CommandLineArguments::parse(
  int    argc,
  char** argv)
{
  constexpr int argumentCountOffset{1};
  const int     actualArgumentCount{argc - argumentCountOffset};
  constexpr int  [MASK] {1};

  if (!pl::is_between(
        actualArgumentCount,  [MASK] , maximumArgumentCount)) {
    return BFC_UNEXPECTED(
      Error::InvalidArgument,
      fmt::format(
        ""{} command line arguments were given but at least {} and at most {} ""
        ""were expected."",
        actualArgumentCount,
         [MASK] ,
        maximumArgumentCount));
  }

  constexpr int inputFileIndex{1};

  const char* const inputFilePath{argv[inputFileIndex]};

  const std::variant<std::string, transpile, Error> secondOptionResult{
    secondOption(actualArgumentCount, argv)};

  Expected<Result> expectedResult{std::visit(
    pl::overload(
      [](const std::string& compilerPath) {
        return Expected<Result>{Result{compilerPath, false}};
      },
      [](transpile) {
        return Expected<Result>{Result{"""", true}};
      },
      [](const Error& error) -> Expected<Result> {
        return tl::make_unexpected(error);
      }),
    secondOptionResult)};

  if (!expectedResult.has_value()) {
    return tl::make_unexpected(expectedResult.error());
  }

  Result& result{expectedResult.value()};

  return CommandLineArguments{
    std::string{inputFilePath},
    std::move(result.compilerPath),
    result.isJustTranspilation};
}

void CommandLineArguments::printHelp(const char* thisApp, std::ostream& os)
{
  fmt::print(
    os,
    ""Usage: {} [-h] brainfuck_source_file [--compiler=COMPILER] ""
    ""[--transpile]\n"",
    thisApp);
  fmt::print(os, ""\n"");
  fmt::print(os, ""Compiles a brainfuck source file.\n"");
  fmt::print(os, ""\n"");
  fmt::print(os, ""positional arguments:\n"");
  fmt::print(
    os,
    ""  brainfuck_source_file    path to the brainfuck source file to ""
    ""compile\n"");
  fmt::print(os, ""\n"");
  fmt::print(os, ""optional_arguments:\n"");
  fmt::print(
    os, ""  -h, --help                 show this help message and exit\n"");
  fmt::print(os, ""  --compiler=COMPILER        the compiler to use\n"");
  fmt::print(
    os, ""  --transpile                transpile to C but don't compile\n"");
  fmt::print(os, ""\n"");
  fmt::print(os, ""notes:\n"");
  fmt::print(
    os,
    ""  --compiler and --transpile can not be specified at the same time!\n"");
  os << std::flush;
}

const std::string& CommandLineArguments::inputFilePath() const noexcept
{
  return m_inputFilePath;
}

const std::string& CommandLineArguments::compiler() const noexcept
{
  return m_compiler;
}

bool CommandLineArguments::shouldJustTranspile() const noexcept
{
  return m_shouldJustTranspile;
}

CommandLineArguments::CommandLineArguments(
  std::string&& inputFilePath,
  std::string&& compiler,
  bool          shouldJustTranspile) noexcept
  : m_inputFilePath{std::move(inputFilePath)}
  , m_compiler{std::move(compiler)}
  , m_shouldJustTranspile{shouldJustTranspile}
{
}
} // namespace bfc
",minimumArgumentCount
80,"#include ""server.h""

ServerNetwork::ServerNetwork(unsigned short port = 53000) : m_listenport(port) {

    if (listener.listen(m_listenport) != sf::Socket::Done) {
        
        log(""Could not listen Try another port number: "");
    }
}

void ServerNetwork::ConnectClients(std::vector<sf::TcpSocket*>* client_array) {
    while (true) {
        sf::TcpSocket* new_client = new sf::TcpSocket();
        if (listener.accept(*new_client) == sf::Socket::Done) {
            
            new_client->setBlocking(false);
            client_array->push_back(new_client);
            log(""Connect client "" << new_client->getRemoteAddress() << "":"" << new_client->getRemotePort());
            //////////send B AND W to the player////////////
            
            if(m_nbrplayer < 2){  
                sf::Packet packet;
                std::string playerflag;
                if (m_nbrplayer == 0) {
                    playerflag = ""W"";
                    packet << playerflag;
                    if (new_client->send(packet) != sf::Socket::Done) {
                        log(""Could not send packet to player B"");
                    }
                   
                }
                else {
                    playerflag = ""B"";
                    packet << playerflag;
                    if (new_client->send(packet) != sf::Socket::Done) {
                        log(""Could not send packet to player W"");
                    }
                    
                }
                m_nbrplayer++;
            }
            else {
                sf::Packet packet;
                char playerflag = 'G';
                packet << playerflag;
                for (int i = 0; i < 10; i++) {
                    packet << m_board[i];
                }
                if (new_client->send(packet) != sf::Socket::Done) {
                    log(""Could not send packet to player G"");
                }
            }
        }
        else {
            log(""ERROR: restart the server"");
            delete(new_client);
            break;
        }
    }
}

void ServerNetwork::DisconnectClient(sf::TcpSocket* socket_pointer, size_t position) {
    log(""Client  disconnected :"" << socket_pointer->getRemoteAddress());
    socket_pointer->disconnect();
    delete(socket_pointer);
    client_array.erase(client_array.begin() + position);
}

void ServerNetwork::BroadcastPacket(sf::Packet& packet, sf::IpAddress exclude_address, unsigned short port) {
    for (size_t iterator = 0; iterator < client_array.size(); iterator++) {
        sf::TcpSocket* client = client_array[iterator];
        if (client->getRemoteAddress() != exclude_address || client->getRemotePort() != port) {
            if (client->send(packet) != sf::Socket::Done) {
                log(""Could not send packet on broadcast"");
            }
        }
    }
}



void ServerNetwork::ReceivePacket(sf::TcpSocket* client, size_t iterator) {
    sf::Packet packet;
    if (client->receive(packet) == sf::Socket::Disconnected) {
        DisconnectClient(client, iterator);
    }
    else {
        if (packet.getDataSize() > 0) {
          
            BroadcastPacket(packet, client->getRemoteAddress(), client->getRemotePort());
            std::string received_message;
            packet >> received_message;
            log(client->getRemoteAddress().toString() << "":"" << client->getRemotePort() << "" - "" << received_message << "";"");
        }
        
    }
}

void ServerNetwork::ManagePackets() {
    while (true) {
        for (size_t it = 0; it < client_array.size(); it++) {
             ReceivePacket(client_array[it], it);
        }

        std::this_thread::sleep_for((std::chrono::milliseconds)100);
    }
}

int ServerNetwork::readflagindex(short int flag)const {
    int  [MASK]  = flag;
    return ( [MASK]  % 1000) / 10;
}

void ServerNetwork::putflagboard(short int flag) {
    m_board[readflagindex(flag)] = flag;
}

void ServerNetwork::Run() {
    std::thread connetion_thread(&ServerNetwork::ConnectClients, this, &client_array);

    ManagePackets();
}
",iflag
81,"#pragma once

#include <cstdint>  // uint64_t
#include <memory>  // unique_ptr
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>

namespace cfp {

using ElementCountDict = std::unordered_map<std::string, uint64_t>;

/**
 * @brief Abstract base for AST nodes.
 */
struct Node {
  virtual ~Node() = default;

  /**
   * @brief Evaluate a node into an element-count map.
   * @param out   Map to accumulate into.
   * @param mult  Multiplier from parent groups.
   */
  virtual void evaluate(ElementCountDict &out, uint64_t mult) const = 0;
};

/**
 * @brief Leaf: a single element symbol with count.
 */
struct ElementNode final : Node {
  std::string symbol;
  uint64_t count{1};

  explicit ElementNode(std::string_view sym, uint64_t count) : symbol{sym}, count{count} {}

  void evaluate(ElementCountDict &out, uint64_t mult) const override {
    out[symbol] += count * mult;
  }
};

/**
 * @brief Interior node: a group of children, with a multiplier.
 *
 * Example: ""(SO4)3"" produces a GroupNode with
 *   children = { ElementNode{""S"", 1}, ElementNode{""O"", 4} }
 *   multiplier = 3
 */
struct GroupNode final : Node {
  std::vector<std::unique_ptr<Node>> children;
  uint64_t multiplier{1};

  explicit GroupNode(uint64_t mult = 1) : multiplier{mult} {}

  void evaluate(ElementCountDict &out, uint64_t mult) const override {
    const uint64_t  [MASK]  = mult * multiplier;

    for (const auto &child : children) {
      child->evaluate(out,  [MASK] );
    }
  }
};

}  // namespace cfp
",next_mult
82,"// Copyright (C) 2024 <NAME> <<EMAIL>>
//
// SPDX-License-Identifier: MIT

#include ""hictkpy/cooler_file_writer.hpp""

#include <fmt/format.h>
#include <fmt/std.h>
#include <spdlog/spdlog.h>

#include <cassert>
#include <cstdint>
#include <filesystem>
#include <hictk/cooler/cooler.hpp>
#include <hictk/file.hpp>
#include <hictk/reference.hpp>
#include <hictk/tmpdir.hpp>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <variant>

#include ""hictkpy/bin_table.hpp""
#include ""hictkpy/common.hpp""
#include ""hictkpy/nanobind.hpp""
#include ""hictkpy/pixel.hpp""
#include ""hictkpy/reference.hpp""
#include ""hictkpy/type.hpp""

namespace nb = nanobind;

namespace hictkpy {

CoolerFileWriter::CoolerFileWriter(std::filesystem::path path_, const hictkpy::BinTable &bins_,
                                   std::string_view assembly, const std::filesystem::path &tmpdir,
                                   std::uint32_t compression_lvl)
    : _path(std::move(path_)),
      _tmpdir(tmpdir, true),
      _w(create_file(_path.string(), *bins_.get(), assembly, _tmpdir())),
      _compression_lvl(compression_lvl) {
  if (std::filesystem::exists(_path)) {
    throw std::runtime_error(
        fmt::format(FMT_STRING(""unable to create .cool file \""{}\"": file already exists""), path()));
  }

  SPDLOG_INFO(FMT_STRING(""using \""{}\"" folder to store temporary file(s)""), _tmpdir());
}

CoolerFileWriter::CoolerFileWriter(std::filesystem::path path_, const ChromosomeDict &chromosomes_,
                                   std::uint32_t resolution_, std::string_view assembly,
                                   const std::filesystem::path &tmpdir,
                                   std::uint32_t compression_lvl)
    : CoolerFileWriter(std::move(path_), BinTable{chromosomes_, resolution_}, assembly, tmpdir,
                       compression_lvl) {}

const std::filesystem::path &CoolerFileWriter::path() const noexcept { return _path; }

std::uint32_t CoolerFileWriter::resolution() const noexcept {
  if (_w.has_value()) {
    return _w->resolution();
  }
  return 0;
}

const hictk::Reference &CoolerFileWriter::chromosomes() const {
  if (_w.has_value()) {
    return _w->chromosomes();
  }

  const static hictk::Reference ref{};
  return ref;
}

std::shared_ptr<const hictk::BinTable> CoolerFileWriter::bins_ptr() const noexcept {
  if (!_w) {
    return {};
  }

  return _w->bins_ptr();
}

void CoolerFileWriter::add_pixels(const nb::object &df, bool sorted, bool validate) {
  if (!_w.has_value()) {
    throw std::runtime_error(
        ""caught attempt to add_pixels to a .cool file that has already been finalized!"");
  }

  const auto cell_id = fmt::to_string(_w->cells().size());
  auto attrs = hictk::cooler::Attributes::init(_w->resolution());
  attrs.assembly = _w->attributes().assembly;

  auto lck = std::make_optional<nb::gil_scoped_acquire>();
  const auto coo_format = nb::cast<bool>(df.attr(""columns"").attr(""__contains__"")(""bin1_id""));

  const auto dtype = df.attr(""__getitem__"")(""count"").attr(""dtype"");
  const auto dtype_str = nb::cast<std::string>(dtype.attr(""__str__"")());
  const auto var = map_py_numeric_to_cpp_type(dtype_str);

  std::visit(
      [&](const auto &n) {
        using N = remove_cvref_t<decltype(n)>;
        const auto pixels = coo_format ? coo_df_to_thin_pixels<N>(df, !sorted)
                                       : bg2_df_to_thin_pixels<N>(_w->bins(), df, !sorted);
        lck.reset();

        auto clr = _w->create_cell<N>(cell_id, std::move(attrs),
                                      hictk::cooler::DEFAULT_HDF5_CACHE_SIZE * 4, 1);

        SPDLOG_INFO(FMT_STRING(""adding {} pixels of type {} to file \""{}\""...""), pixels.size(),
                    dtype_str, clr.uri());
        clr.append_pixels(pixels.begin(), pixels.end(), validate);

        clr.flush();
      },
      var);
}

hictk::File CoolerFileWriter::finalize(std::string_view log_lvl_str, std::size_t chunk_size,
                                       std::size_t update_freq) {
  if (_finalized) {
    throw std::runtime_error(
        fmt::format(FMT_STRING(""finalize() was already called on file \""{}\""""), _path));
  }

  if (chunk_size == 0) {
    throw std::runtime_error(""chunk_size must be greater than 0"");
  }

  assert(_w.has_value());
  // NOLINTBEGIN(*-unchecked-optional-access)
  const auto log_lvl = spdlog::level::from_str(normalize_log_lvl(log_lvl_str));
  const auto previous_lvl = spdlog::default_logger()->level();
  spdlog::default_logger()->set_level(log_lvl);

  SPDLOG_INFO(FMT_STRING(""finalizing file \""{}\""...""), _path);
  hictk::internal::NumericVariant  [MASK] {};
  if (_w->cells().empty()) {
     [MASK]  = std::int32_t{};
  } else {
     [MASK]  = _w->open(""0"").pixel_variant();
  }
  try {
    std::visit(
        [&](const auto &num) {
          using N = remove_cvref_t<decltype(num)>;
          _w->aggregate<N>(_path.string(), false, _compression_lvl, chunk_size, update_freq);
        },
         [MASK] );
  } catch (...) {
    spdlog::default_logger()->set_level(previous_lvl);
    throw;
  }

  _finalized = true;
  SPDLOG_INFO(FMT_STRING(""merged {} cooler(s) into file \""{}\""""), _w->cells().size(), _path);
  spdlog::default_logger()->set_level(previous_lvl);

  const std::string sclr_path{_w->path()};
  _w.reset();
  std::filesystem::remove(sclr_path);  // NOLINT
  // NOLINTEND(*-unchecked-optional-access)

  return hictk::File{_path.string()};
}

hictk::cooler::SingleCellFile CoolerFileWriter::create_file(std::string_view path,
                                                            const hictk::BinTable &bins,
                                                            std::string_view assembly,
                                                            const std::filesystem::path &tmpdir) {
  auto attrs = hictk::cooler::SingleCellAttributes::init(bins.resolution());
  attrs.assembly = assembly;
  return hictk::cooler::SingleCellFile::create(tmpdir / std::filesystem::path{path}.filename(),
                                               bins, false, std::move(attrs));
}

std::string CoolerFileWriter::repr() const {
  if (!_w.has_value()) {
    return ""CoolFileWriter()"";
  }
  return fmt::format(FMT_STRING(""CoolFileWriter({})""), _w->path());
}

void CoolerFileWriter::bind(nb::module_ &m) {
  auto cooler = m.def_submodule(""cooler"");

  auto writer = nb::class_<hictkpy::CoolerFileWriter>(
      cooler, ""FileWriter"", ""Class representing a file handle to create .cool files."");

  // NOLINTBEGIN(*-avoid-magic-numbers)
  writer.def(nb::init<std::filesystem::path, const ChromosomeDict &, std::uint32_t,
                      std::string_view, const std::filesystem::path &, std::uint32_t>(),
             nb::arg(""path""), nb::arg(""chromosomes""), nb::arg(""resolution""),
             nb::arg(""assembly"") = ""unknown"",
             nb::arg(""tmpdir"") = hictk::internal::TmpDir::default_temp_directory_path(),
             nb::arg(""compression_lvl"") = 6,
             ""Open a .cool file for writing given a list of chromosomes with their sizes and a ""
             ""resolution."");
  writer.def(nb::init<std::filesystem::path, const hictkpy::BinTable &, std::string_view,
                      const std::filesystem::path &, std::uint32_t>(),
             nb::arg(""path""), nb::arg(""bins""), nb::arg(""assembly"") = ""unknown"",
             nb::arg(""tmpdir"") = hictk::internal::TmpDir::default_temp_directory_path(),
             nb::arg(""compression_lvl"") = 6,
             ""Open a .cool file for writing given a table of bins."");
  // NOLINTEND(*-avoid-magic-numbers)

  writer.def(""__repr__"", &hictkpy::CoolerFileWriter::repr, nb::rv_policy::move);

  writer.def(""path"", &hictkpy::CoolerFileWriter::path, ""Get the file path."", nb::rv_policy::copy);
  writer.def(""resolution"", &hictkpy::CoolerFileWriter::resolution, ""Get the resolution in bp."");
  writer.def(""chromosomes"", &get_chromosomes_from_object<hictkpy::CoolerFileWriter>,
             nb::arg(""include_ALL"") = false,
             ""Get the chromosome sizes as a dictionary mapping names to sizes."",
             nb::rv_policy::take_ownership);
  writer.def(""bins"", &get_bins_from_object<hictkpy::CoolerFileWriter>, ""Get table of bins."",
             nb::sig(""def bins(self) -> hictkpy.BinTable""), nb::rv_policy::move);

  writer.def(""add_pixels"", &hictkpy::CoolerFileWriter::add_pixels,
             nb::call_guard<nb::gil_scoped_release>(),
             nb::sig(""def add_pixels(self, pixels: pandas.DataFrame, sorted: bool = False, ""
                     ""validate: bool = True) -> None""),
             nb::arg(""pixels""), nb::arg(""sorted"") = false, nb::arg(""validate"") = true,
             ""Add pixels from a pandas DataFrame containing pixels in COO or BG2 format (i.e. ""
             ""either with columns=[bin1_id, bin2_id, count] or with columns=[chrom1, start1, end1, ""
             ""chrom2, start2, end2, count].\n""
             ""When sorted is True, pixels are assumed to be sorted by their genomic coordinates in ""
             ""ascending order.\n""
             ""When validate is True, hictkpy will perform some basic sanity checks on the given ""
             ""pixels before adding them to the Cooler file."");
  // NOLINTBEGIN(*-avoid-magic-numbers)
  writer.def(""finalize"", &hictkpy::CoolerFileWriter::finalize,
             nb::call_guard<nb::gil_scoped_release>(), nb::arg(""log_lvl"") = ""WARN"",
             nb::arg(""chunk_size"") = 500'000, nb::arg(""update_frequency"") = 10'000'000,
             ""Write interactions to file."", nb::rv_policy::move);
  // NOLINTEND(*-avoid-magic-numbers)
}
}  // namespace hictkpy
",count_type
83,"
// Copyright <NAME> 2018.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

#include <QtGui/QApplication>
#include <QtGui/QDialog>
#include <QtGui/QVBoxLayout>

#include <coruja/object/object.hpp>
#include <coruja/object/view/transform.hpp>
#include <saci/qt/checkbox/checkbox.hpp>
#include <saci/qt/textedit/textedit.hpp>

#include <iostream>
#include <string>

using namespace coruja;

int main(int argc, char** argv) {
    QApplication app(argc, argv);
    QDialog window;
    QVBoxLayout  [MASK] (&window);

    QCheckBox qcheckbox(&window);
    QTextEdit qtextedit(&window);
    
     [MASK] .addWidget(&qcheckbox);
     [MASK] .addWidget(&qtextedit);
    
    object<bool> model{false};
    model.for_each([](bool v)
    { std::cout << ""checkbox is "" << (v ? ""true"" : ""false"") << std::endl; });
    
    saci::qt::checkbox checkbox(model, qcheckbox);

    object<std::string> name{""Clear this text to disable the checkbox""};
    name.for_each([](std::string s)
    { std::cout << ""name is '"" << s << ""'"" << std::endl; });
        
    saci::qt::textedit textedit(name, qtextedit);
    
    window.show();

    checkbox.enable(view::transform(name, [](std::string s){ return !s.empty(); }));
        
    model = true;

    return app.exec();
}
",layout
84,"#include<iostream>
#include<string>
#include<stack>
using namespace std;

int main()
{
	bool flag = false;
	int col;
	int rows = 2;

	stack <char> st;
	stack<int>	 [MASK] ;
	int n1;
	int n2;
	string str;
	string str1;
	string postfix;
	string postfix1;
	char num1;
	char num2;
	char num3;
	char num4;
	char num5;

	char table[2] = {
		'0','1'
	};

	char result[2];

	char table1[4][2] = {
			{'0','0'},{'0','1'},{'1','0'},{'1','1'}
	};

	char result1[4];

	char table2[8][3] = {
			{'0','0','0'},{'0','0','1'},{'0','1','0'},{'0','1','1'},{'1','0','0'},{'1','0','1'},{'1','1','0'},{'1','1','1'}
	};

	char result2[8];

	char table3[16][4] = {
			{'0','0','0','0'},{'0','0','0','1'},{'0','0','1','0'},{'0','0','1','1'},{'0','1','0','0'},{'0','1','0','1'},{'0','1','1','0'},{'0','1','1','1'},
			{'1','0','0','0'},{'1','0','0','1'},{'1','0','1','0'},{'1','0','1','1'},{'1','1','0','0'},{'1','1','0','1'},{'1','1','1','0'},{'1','1','1','1'}
	};
	char result3[16];

	char table4[32][5] = {
			{'0','0','0','0','0'},{'0','0','0','0','1'},{'0','0','0','1','0'},{'0','0','0','1','1'},{'0','0','1','0','0'},{'0','0','1','0','1'},
		{'0','0','1','1','0'},{'0','0','1','1','1'},{'0','1','0','0','0'},{'0','1','0','0','1'},{'0','1','0','1','0'},{'0','1','0','1','1'},{'0','1','1','0','0'},
		{'0','1','1','0','1'},	{'0','1','1','1','0'},{'0','1','1','1','1'},{'1','0','0','0','0'},{'1','0','0','0','1'},{'1','0','0','1','0'},
		{'1','0','0','1','1'},{'1','0','1','0','0'},{'1','0','1','0','1'},{'1','0','1','1','0'},{'1','0','1','1','1'},{'1','1','0','0','0'},
		{'1','1','0','0','1'},{'1','1','0','1','0'},{'1','1','0','1','1'},{'1','1','1','0','0'},{'1','1','1','0','1'},{'1','1','1','1','0'},
		{'1','1','1','1','1'}
	};
	char result4[32];

	cout << ""Enter the string: "";
	getline(cin, str);
	cout << endl;

	for (int i = 0; i < str.size(); i++)
	{
		if ((str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z'))
		{
			flag = false;
			for (int j = 0; j < str1.size(); j++)
			{
				if (str[i] == str1[j])
				{
					flag = true;
				}
			}
			if (flag == false)
			{
				str1 = str1 + str[i];
			}
		}
	}

	if (str1.size() == 1)
	{
		rows = 2;
	}
	else
	{
		for (int i = 0; i < str1.size() - 1; i++)
		{
			rows = rows * 2;
		}
	}
	col = str1.size();

	for (int i = 0; i < str.length(); i++)
	{
		if ((str[i] >= 'a' && str[i] <= 'z'))
		{
			postfix = postfix + str[i];
		}
		else if (str[i] == '(')
		{
			st.push('(');
		}
		else if (str[i] == ')')
		{
			while (st.top() != '(')
			{
				postfix = postfix + st.top();
				st.pop();
			}
			st.pop();
		}
		else if (str[i] == '~')
		{
			st.push('~');
		}
		else if (str[i] == '*')
		{
			if (st.empty())
			{
				st.push('*');
			}
			else if (st.top() == '~')
			{

				postfix = postfix + '~';
				st.pop();

				st.push('*');
			}
			else
			{
				st.push('*');
			}
		}
		else if (str[i] == '+')
		{
			if (st.empty())
			{
				st.push('+');
			}
			else if (st.top() == '~')
			{

				postfix = postfix + '~';
				st.pop();

				st.push('+');
			}
			else if (st.top() == '*')
			{

				postfix = postfix + '*';
				st.pop();

				st.push('+');
			}
			else
			{
				st.push('+');
			}
		}
	}

	while (!st.empty())
	{
		postfix = postfix + st.top();
		st.pop();
	}
	postfix1 = postfix;
	switch (col)
	{
	case 1:
		for (int i = 0; i < rows; i++)
		{
			num1 = table[i];

			for (int i = 0; i < postfix.size(); i++)		//assigning values in equation
			{
				if (postfix[i] >= 'a' && postfix[i] <= 'z')
				{
					postfix[i] = num1;
				}
			}

			for (int i = 0; i < postfix.size(); i++)			//evaluating equation
			{
				if (postfix[i] == '0' || postfix[i] == '1')
				{
					n1 = postfix[i] - 48;
					 [MASK] .push(n1);
				}
				else if (postfix[i] == '~')
				{
					if ( [MASK] .top() == 0)
					{
						 [MASK] .pop();
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .pop();
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '*')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 && n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '+')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 || n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
			}
			result[i] =  [MASK] .top() + 48;
			 [MASK] .pop();
			postfix = postfix1;
		}

		cout << ""Table: "" << endl << endl;
		cout << ""a   "" << str << endl;
		for (int i = 0; i < rows; i++)
		{
			cout << table[i] << "" "";

			cout << ""  "" << result[i] << endl;
		}

		break;
	case 2:
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < col; j++)			//getting values from truth table
			{
				if (j == 0)
				{
					num1 = table1[i][j];
				}
				else if (j == 1)
				{
					num2 = table1[i][j];
				}
			}

			for (int i = 0; i < postfix.size(); i++)		//assigning values in equation
			{
				if (postfix[i] == 'a')
				{
					postfix[i] = num1;
				}
				else if (postfix[i] == 'b')
				{
					postfix[i] = num2;
				}
			}

			for (int i = 0; i < postfix.size(); i++)			//evaluating equation
			{
				if (postfix[i] == '0' || postfix[i] == '1')
				{
					n1 = postfix[i] - 48;
					 [MASK] .push(n1);
				}
				else if (postfix[i] == '~')
				{
					if ( [MASK] .top() == 0)
					{
						 [MASK] .pop();
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .pop();
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '*')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 && n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '+')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 || n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
			}
			result1[i] =  [MASK] .top() + 48;
			 [MASK] .pop();
			postfix = postfix1;
		}

		cout << ""Table: "" << endl << endl;
		cout << ""a b   "" << str << endl;
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < col; j++)
			{
				cout << table1[i][j] << "" "";
			}
			cout << ""  "" << result1[i] << endl;
		}

		break;
	case 3:
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < col; j++)			//getting values from truth table
			{
				if (j == 0)
				{
					num1 = table2[i][j];
				}
				else if (j == 1)
				{
					num2 = table2[i][j];
				}
				else if (j == 2)
				{
					num3 = table2[i][j];
				}
			}

			for (int i = 0; i < postfix.size(); i++)		//assigning values in equation
			{
				if (postfix[i] == 'a')
				{
					postfix[i] = num1;
				}
				else if (postfix[i] == 'b')
				{
					postfix[i] = num2;
				}
				else if (postfix[i] == 'c')
				{
					postfix[i] = num3;
				}
			}

			for (int i = 0; i < postfix.size(); i++)			//evaluating equation
			{
				if (postfix[i] == '0' || postfix[i] == '1')
				{
					n1 = postfix[i] - 48;
					 [MASK] .push(n1);
				}
				else if (postfix[i] == '~')
				{
					if ( [MASK] .top() == 0)
					{
						 [MASK] .pop();
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .pop();
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '*')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 && n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '+')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 || n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
			}
			result2[i] =  [MASK] .top() + 48;
			 [MASK] .pop();
			postfix = postfix1;
		}

		cout << ""Table: "" << endl << endl;						//printing truth table
		cout << ""a b c  "" << str << endl;
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < col; j++)
			{
				cout << table2[i][j] << "" "";
			}
			cout << ""  "" << result2[i] << endl;
		}

		break;
	case 4:
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < col; j++)			//getting values from truth table
			{
				if (j == 0)
				{
					num1 = table3[i][j];
				}
				else if (j == 1)
				{
					num2 = table3[i][j];
				}
				else if (j == 2)
				{
					num3 = table3[i][j];
				}
				else if (j == 3)
				{
					num4 = table3[i][j];
				}
			}

			for (int i = 0; i < postfix.size(); i++)		//assigning values in equation
			{
				if (postfix[i] == 'a')
				{
					postfix[i] = num1;
				}
				else if (postfix[i] == 'b')
				{
					postfix[i] = num2;
				}
				else if (postfix[i] == 'c')
				{
					postfix[i] = num3;
				}
				else if (postfix[i] == 'd')
				{
					postfix[i] = num4;
				}
			}

			for (int i = 0; i < postfix.size(); i++)			//evaluating equation
			{
				if (postfix[i] == '0' || postfix[i] == '1')
				{
					n1 = postfix[i] - 48;
					 [MASK] .push(n1);
				}
				else if (postfix[i] == '~')
				{
					if ( [MASK] .top() == 0)
					{
						 [MASK] .pop();
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .pop();
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '*')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 && n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
				else if (postfix[i] == '+')
				{
					n1 =  [MASK] .top();
					 [MASK] .pop();
					n2 =  [MASK] .top();
					 [MASK] .pop();
					if (n1 || n2)
					{
						 [MASK] .push(1);
					}
					else
					{
						 [MASK] .push(0);
					}
				}
			}
			result3[i] =  [MASK] .top() + 48;
			 [MASK] .pop();
			postfix = postfix1;
		}

		cout << ""Table: "" << endl << endl;						//printing truth table
		cout << ""a b c d  "" << str << endl;
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < col; j++)
			{
				cout << table3[i][j] << "" "";
			}
			cout << ""  "" << result3[i] << endl;
		}
		break;

		case 5:
			for (int i = 0; i < rows; i++)
			{
				for (int j = 0; j < col; j++)			//getting values from truth table
				{
					if (j == 0)
					{
						num1 = table4[i][j];
					}
					else if (j == 1)
					{
						num2 = table4[i][j];
					}
					else if (j == 2)
					{
						num3 = table4[i][j];
					}
					else if (j == 3)
					{
						num4 = table4[i][j];
					}
					else if (j == 4)
					{
						num5 = table4[i][j];
					}
				}

				for (int i = 0; i < postfix.size(); i++)		//assigning values in equation
				{
					if (postfix[i] == 'a')
					{
						postfix[i] = num1;
					}
					else if (postfix[i] == 'b')
					{
						postfix[i] = num2;
					}
					else if (postfix[i] == 'c')
					{
						postfix[i] = num3;
					}
					else if (postfix[i] == 'd')
					{
						postfix[i] = num4;
					}
					else if (postfix[i] == 'e')
					{
						postfix[i] = num5;
					}
				}

				for (int i = 0; i < postfix.size(); i++)			//evaluating equation
				{
					if (postfix[i] == '0' || postfix[i] == '1')
					{
						n1 = postfix[i] - 48;
						 [MASK] .push(n1);
					}
					else if (postfix[i] == '~')
					{
						if ( [MASK] .top() == 0)
						{
							 [MASK] .pop();
							 [MASK] .push(1);
						}
						else
						{
							 [MASK] .pop();
							 [MASK] .push(0);
						}
					}
					else if (postfix[i] == '*')
					{
						n1 =  [MASK] .top();
						 [MASK] .pop();
						n2 =  [MASK] .top();
						 [MASK] .pop();
						if (n1 && n2)
						{
							 [MASK] .push(1);
						}
						else
						{
							 [MASK] .push(0);
						}
					}
					else if (postfix[i] == '+')
					{
						n1 =  [MASK] .top();
						 [MASK] .pop();
						n2 =  [MASK] .top();
						 [MASK] .pop();
						if (n1 || n2)
						{
							 [MASK] .push(1);
						}
						else
						{
							 [MASK] .push(0);
						}
					}
				}
				result4[i] =  [MASK] .top() + 48;
				 [MASK] .pop();
				postfix = postfix1;
			}

			cout << ""Table: "" << endl << endl;						//printing truth table
			cout << ""a b c d e  "" << str << endl;
			for (int i = 0; i < rows; i++)
			{
				for (int j = 0; j < col; j++)
				{
					cout << table4[i][j] << "" "";
				}
				cout << ""  "" << result4[i] << endl;
			}
			break;

	}
}",st1
85,"#include <ESP8266WiFi.h>
#include <WiFiClient.h>

#include <MySQL_Connection.h>
#include <MySQL_Cursor.h>

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>

const int trigPin = 12;  //D4
const int echoPin = 14;  //D3

//define sound velocity in cm/uS
#define SOUND_VELOCITY 0.034
#define CM_TO_INCH 0.393701

#define WIFI_SSID """"
#define WIFI_PASSWORD """"

WiFiClient client;
MySQL_Connection conn((Client *)&client);
IPAddress server_addr(52, 165, 234, 7);  // MySQL server IP
char user[] = """";                  // MySQL user
char password[] = """";              // MySQL password

/////////////////
//Acelerometro///
/////////////////
char insertAcelerometro[]=""INSERT INTO NASA_V.S_ACELEROMETRO (x, y, z, num_caidas, id_paciente) VALUES(%s, %s, %s, %s, 1)"";
char query_1[128];

// Variables temporales
char c_x[16], c_y[16], c_z[16], c_contCaidas[16];// c_id_persona[16]
String dat;

// Variables para determinar medidas
int contCaidas;
float _x;
float _y;
float _z;
Adafruit_MPU6050 mpu;
#define D4 2

///////////////
//Ultrasonico//
///////////////
long duration;
float distanceCm;
float distanceInch;
int cantChoques;
char insertUltrasonico[]=""INSERT INTO NASA_V.S_ULTRASONICA (distancia, num_choques, id_paciente) VALUES(%s,%s, 1)"";
char query_2[128];

// Variables temporales
char c_distancia[16], c_num_choques[16];// c_id_persona[16]
String dat2;

float _distancia;
int _choques;

////////////////////////////////////////////////////////////////
// Sección de inicialización
////////////////////////////////////////////////////////////////

void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  Serial.begin(9600); // Starts the serial communication

  /////
    while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial console opens

  Serial.println(""Adafruit MPU6050 test!"");
  
  // Try to initialize!
  if (!mpu.begin()) {
    Serial.println(""Failed to find MPU6050 chip"");
    while (1) {
      delay(10);
    }
  }

  
  Serial.println(""MPU6050 Found!"");
  /////
  
 wifiConnect();
  Serial.println(""Conectando a la DB"");

  while(conn.connect(server_addr, 3306, user, password) != true){
    delay(200);
    Serial.print(""."");
  };

  Serial.println(""Conectado al servidor SQL"");
  pinMode(D4, OUTPUT);
  
  Serial.println("""");
  delay(10);
}

////////////////////////////////////////////////////////////////
// Fin de sección de inicialización
////////////////////////////////////////////////////////////////

void wifiConnect() {
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);  //Conexión a la red WiFi
    Serial.print(""Conectado a WiFi --> "");
    Serial.print(WIFI_SSID); Serial.println("" ..."");

    int  [MASK]  = 0;
    while (WiFi.status() != WL_CONNECTED) {  //Esperar a establecer conexión WiFi
        delay(1000);
        Serial.println(++ [MASK] ); Serial.print(' ');
    }

    Serial.println('\n');
    Serial.println(""WiFi conectado!"");  
    Serial.print(""IP address:\t"");
    Serial.println(WiFi.localIP());         // Send the IP address of the ESP8266 to the computer
}  //End wifiConnect()

///////////////////////////////////////////////////////////////
// LOOP
///////////////////////////////////////////////////////////////


void loop() {
  /* Get new sensor events with the readings */
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);

  /* Print out the values */
  
  Serial.print(""Acceleration X: "");
  Serial.print(a.acceleration.x);
  
  Serial.print("", Y: "");
  Serial.print(a.acceleration.y);

  if(a.acceleration.z > -7.00){
    Serial.println("""");
    Serial.print("" Se cayó la persona "");
    Serial.println("""");
    contCaidas = contCaidas + 1;
    Serial.print(""Veces que ha caido: "");
    Serial.print(contCaidas);
    Serial.println("""");
    digitalWrite(D4,LOW);
    delay(1000);
    };

  digitalWrite(D4,HIGH);
  Serial.print("" Z: "");
  Serial.print(a.acceleration.z);
  Serial.println("" m/s^2"");

  _x = a.acceleration.x;
  _y = a.acceleration.y;
  _z = a.acceleration.z;

// char c_x[16], c_y[16], c_z[16], c_contCaidas[16], c_id_persona[16];
// String dat;

  dat = String(_x);
  dat.toCharArray(c_x, 16);

  dat = String(_y);
  dat.toCharArray(c_y, 16);

  dat = String(_z);
  dat.toCharArray(c_z, 16);

  dat = String(contCaidas);
  dat.toCharArray(c_contCaidas, 16);
  
  sprintf(query_1, insertAcelerometro, c_x, c_y, c_z, c_contCaidas);
  Serial.println(""Registandro datos"");
  Serial.println(query_1);

  MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
    cur_mem->execute(query_1);
    delete cur_mem;

  

////////////////////////////////////////////////////////////////

// Clears the trigPin
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin on HIGH state for 10 micro seconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  
  // Calculate the distance
  distanceCm = duration * SOUND_VELOCITY/2;
  
  // Convert to inches
  distanceInch = distanceCm * CM_TO_INCH;

  if(distanceCm >= 803){
    Serial.println(""La persona choco "");
    cantChoques = cantChoques + 1;
  } else if (distanceCm < 25) {
    Serial.println(""La persona está a punto de chocar"");
    }
  
  // Prints the distance on the Serial Monitor
  Serial.print(""Distance (cm): "");
  Serial.println(distanceCm);
  Serial.print(""Distance (inch): "");
  Serial.println(distanceInch);
  Serial.print(""Cantidad de choques: "");
  Serial.println(cantChoques);
  delay(1000);


  
  _distancia = distanceCm;
  _choques = cantChoques;

  dat2 = String(_distancia);
  dat2.toCharArray(c_distancia, 16);

  dat2 = String(_choques);
  dat2.toCharArray(c_num_choques, 16);
  
  sprintf(query_2, insertUltrasonico, c_distancia,  c_num_choques);
  Serial.println(""Registandro datos"");
  Serial.println(query_2);

  MySQL_Cursor *cur_mem2 = new MySQL_Cursor(&conn);
    cur_mem2->execute(query_2);
    delete cur_mem2;

    if(WiFi.status() != WL_CONNECTED) {
        wifiConnect();
    }
  Serial.println("""");
  delay(5000);
}
",teller
86,"#include ""pch.h""
#include ""Logger.h""

Logger::Logger()
{
    logFile = CreateFileA(""log.txt"", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (logFile == INVALID_HANDLE_VALUE)
    {
        printf(""Create log file log.txt failed, last error: %d"", GetLastError());
        exit(0);
    }
}

void Logger::Write(const char* log, DWORD length)
{
    DWORD dwWrite;
    printf(log);
    WriteFile(logFile, log, strlen(log), &dwWrite, NULL);
}

void Logger::WriteFormat(const char* format, ...)
{
    int bufLen = 256;
    char* buffer = new char[bufLen];
    DWORD dwWrite;
    va_list  [MASK] ;
    va_start( [MASK] , format);
    
    //format the string until succeed
    int slen = 0;
    while(true) 
    {
        slen = vsnprintf(buffer, bufLen, format,  [MASK] );
        if (slen < 0) //slen < 0 means buffer length is not enough
        {
            bufLen *= 2;
            delete[] buffer;
            buffer = new char[bufLen];
        }
        else
        {
            break;
        }
    }

    Write(buffer, slen);

    delete[] buffer;

    va_end( [MASK] );
}

void Logger::WriteLine(const char* log, DWORD length)
{
    Write(log, length);

    DWORD dwWrite;
    char newline = '\n';
    printf(""\n"");
    WriteFile(logFile, &newline, 1, &dwWrite, NULL);
}",argptr
87,"/*
 * Copyright 2019 <NAME>
 *
 * 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 <ros/ros.h>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <cv_bridge/cv_bridge.h>
#include <sensor_msgs/image_encodings.h>
#include <std_srvs/Empty.h>

static const std::string OPENCV_WINDOW = ""Image window"";

void getImageCallback(const sensor_msgs::ImageConstPtr& msg) {
  ROS_INFO(""Got image published to 'image_raw' topic"");

  cv_bridge::CvImagePtr cv_ptr;
  try {
    cv_ptr = cv_bridge::toCvCopy(msg, sensor_msgs::image_encodings::BGR8);
  } catch (cv_bridge::Exception& e) {
    ROS_ERROR(""cv_bridge exception: %s"", e.what());
    return;
  }

  cv::imshow(OPENCV_WINDOW, cv_ptr->image);
  cv::waitKey(3);
}

int main(int argc, char** argv) {
  ros::init(argc, argv, ""camera test"");
  ros::NodeHandle nh;
  
  std::string  [MASK] ;
  // Get image topic ROS parameter
  if (!(ros::param::get(""~image_topic"",  [MASK] ))) {
    if (argc > 1) {
       [MASK]  = argv[1];
    } else {
      exit(1);
    }
  }

  ROS_INFO(""Going to capture image from ROS topic: %s"",  [MASK] .c_str());

  ros::Rate loop_rate(10);
  ros::Subscriber sub = nh.subscribe<sensor_msgs::Image>( [MASK] .c_str(), 1000, getImageCallback);

  while (ros::ok()) {
    ros::spinOnce();
    loop_rate.sleep();
  }
}
",imageTopic
88,"#include ""sandbox_processor.h""
#include ""sandbox_editor.h""

#include ""../shared/gui/adjust_colour_panel.h""

#include ""../shared/game/random_colors/random_colors_launcher.h""
#include ""../shared/game/hex_rings/hex_rings_launcher.h""
#include ""../shared/game/hexagon_automata/hexagon_automata_launcher.h""

#include ""../shared/MainComponent.h""

#include ""../shared/debug/LumatoneSandboxDebugWindow.h""

//==============================================================================
LumatoneSandboxProcessorEditor::LumatoneSandboxProcessorEditor (LumatoneSandboxProcessor& p)
    : AudioProcessorEditor (&p), processor (p)
    , controller(p.getLumatoneController())
    , undoManager(p.getUndoManager())
    , commandManager(p.getCommandManager())
    , paletteLibrary(p.getPaletteLibrary())
    , gameEngine(p.getGameEngine())
{
    juce::ignoreUnused (processor);

    debugWindow = std::make_unique<LumatoneSandboxDebugWindow>(processor.getLogData());
    debugWindow->setSize(800, 500);
    debugWindow->addToDesktop();
    debugWindow->setVisible(true);

    mainComponent = std::make_unique<MainComponent>(controller);
    mainComponent->setGameEngine(gameEngine);
    addAndMakeVisible(*mainComponent);

    commandManager->registerAllCommandsForTarget(this);
    commandManager->registerAllCommandsForTarget(mainComponent.get());
    commandManager->setFirstCommandTarget(this);

    menuModel = std::make_unique<LumatoneSandbox::Menu::Model>(commandManager);

    // if (showMenu())
    // {
        menuBar = std::make_unique<juce::MenuBarComponent>(menuModel.get());
        addAndMakeVisible(menuBar.get());
    // }
    // else if (JucePlugin_Build_Standalone)
    // {
    // #if JUCE_MAC
    //     LumatoneSandbox::Menu::Model::setMacMainMenu((juce::MenuBarModel*)(nullptr));
    // #endif
    // }

    setSize (1024, 768);

    setResizable(true, true);
}

LumatoneSandboxProcessorEditor::~LumatoneSandboxProcessorEditor()
{
    fileChooser = nullptr;
    constrainer = nullptr;

    menuBar = nullptr;
    menuModel = nullptr;
    mainComponent = nullptr;

    debugWindow = nullptr;
}

//==============================================================================
void LumatoneSandboxProcessorEditor::paint (juce::Graphics& g)
{
    // (Our component is opaque, so we must completely fill the background with a solid colour)
    g.fillAll (getLookAndFeel().findColour (juce::ResizableWindow::backgroundColourId));

    g.setColour (juce::Colours::white);
    g.setFont (15.0f);
    g.drawFittedText (""Hello World!"", getLocalBounds(), juce::Justification::centred, 1);
}

void LumatoneSandboxProcessorEditor::resized()
{
    int menuHeight = 24;
    if (showMenu())
        menuBar->setBounds(0, 0, getWidth(), menuHeight);
    else
        menuHeight = 0;

    mainComponent->setBounds(getLocalBounds().withTrimmedTop(menuHeight));
}

bool LumatoneSandboxProcessorEditor::showMenu() const
{
    return true;
    // return JucePlugin_Build_Standalone 
    //     && ((juce::SystemStats::getOperatingSystemType() & juce::SystemStats::OperatingSystemType::MacOSX) 
    //         != juce::SystemStats::OperatingSystemType::MacOSX
    //         );
}

juce::ApplicationCommandTarget* LumatoneSandboxProcessorEditor::getNextCommandTarget()
{ 
    return mainComponent.get();
}

void LumatoneSandboxProcessorEditor::getAllCommands(juce::Array <juce::CommandID>& commands)
{
    commands.add(LumatoneSandbox::Menu::commandIDs::openSysExMapping);
    commands.add(LumatoneSandbox::Menu::commandIDs::saveSysExMapping);
    commands.add(LumatoneSandbox::Menu::commandIDs::saveSysExMappingAs);
    commands.add(LumatoneSandbox::Menu::commandIDs::resetSysExMapping);
    commands.add(LumatoneSandbox::Menu::commandIDs::importSysExMapping);

    // commands.add(LumatoneSandbox::Menu::commandIDs::deleteOctaveBoard);
    // commands.add(LumatoneSandbox::Menu::commandIDs::copyOctaveBoard);
    // commands.add(LumatoneSandbox::Menu::commandIDs::pasteOctaveBoard);
    // commands.add(LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardChannels);
    // commands.add(LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardNotes);
    // commands.add(LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardColours);
    // commands.add(LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardTypes);

    commands.add(LumatoneSandbox::Menu::commandIDs::adjustColour);
    
    commands.add(LumatoneSandbox::Menu::commandIDs::openRandomColorsGame);
    commands.add(LumatoneSandbox::Menu::commandIDs::openHexRingsGame);
    commands.add(LumatoneSandbox::Menu::commandIDs::openHexagonAutomata);
}

void LumatoneSandboxProcessorEditor::getCommandInfo(juce::CommandID commandID, juce::ApplicationCommandInfo& result)
{
    result.setActive(true);

    switch (commandID)
        {
        case LumatoneSandbox::Menu::commandIDs::openSysExMapping:
            result.setInfo(""Load file mapping"", ""Open a Lumatone key mapping"", ""File"", 0);
            result.addDefaultKeypress('o', juce::ModifierKeys::commandModifier);
            break;

        case LumatoneSandbox::Menu::commandIDs::saveSysExMapping:
            result.setInfo(""Save mapping"", ""Save the current mapping to file"", ""File"", 0);
            result.addDefaultKeypress('s', juce::ModifierKeys::commandModifier);
            break;

        case LumatoneSandbox::Menu::commandIDs::saveSysExMappingAs:
            result.setInfo(""Save mapping as..."", ""Save the current mapping to new file"", ""File"", 0);
            result.addDefaultKeypress('a', juce::ModifierKeys::commandModifier);
            break;

        case LumatoneSandbox::Menu::commandIDs::resetSysExMapping:
            result.setInfo(""New"", ""Start new mapping. Clear all edit fields, do not save current edits."", ""File"", 0);
            result.addDefaultKeypress('n', juce::ModifierKeys::commandModifier);
            break;
             
        case LumatoneSandbox::Menu::commandIDs::importSysExMapping:
            result.setInfo(""Import"", ""Get mapping from connected Lumatone"", ""File"", 0);
            result.addDefaultKeypress('i', juce::ModifierKeys::currentModifiers);
            break;

        // case LumatoneSandbox::Menu::commandIDs::deleteOctaveBoard:
        //     result.setInfo(""Delete"", ""Delete section data"", ""Edit"", 0);
        //     result.addDefaultKeypress(juce::KeyPress::deleteKey, juce::ModifierKeys::noModifiers);
        //     break;

        // case LumatoneSandbox::Menu::commandIDs::copyOctaveBoard:
        //     result.setInfo(""Copy section"", ""Copy current octave board data"", ""Edit"", 0);
        //     result.addDefaultKeypress('c', juce::ModifierKeys::commandModifier);
        //     break;

        // case LumatoneSandbox::Menu::commandIDs::pasteOctaveBoard:
        //     result.setInfo(""Paste section"", ""Paste copied section data"", ""Edit"", 0);
        //     result.addDefaultKeypress('v', juce::ModifierKeys::commandModifier);
        //     break;

        // case LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardNotes:
        //     result.setInfo(""Paste notes"", ""Paste copied section notes"", ""Edit"", 0);
        //     result.addDefaultKeypress('v', juce::ModifierKeys::commandModifier | juce::ModifierKeys::shiftModifier);
        //     break;

        // case LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardChannels:
        //     result.setInfo(""Paste channels"", ""Paste copied section channels"", ""Edit"", 0);
        //     result.addDefaultKeypress('v', juce::ModifierKeys::commandModifier | juce::ModifierKeys::altModifier);
        //     break;
                
        // case LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardColours:
        //     result.setInfo(""Paste colours"", ""Paste copied section colours"", ""Edit"", 0);
        //     result.addDefaultKeypress('v', juce::ModifierKeys::altModifier);
        //     break;
                
        // case LumatoneSandbox::Menu::commandIDs::pasteOctaveBoardTypes:
        //     result.setInfo(""Paste types"", ""Paste copied section key types"", ""Edit"", 0);
        //     result.addDefaultKeypress('v', juce::ModifierKeys::altModifier | juce::ModifierKeys::shiftModifier);
        //     break;

        case LumatoneSandbox::Menu::commandIDs::adjustColour:
            result.setInfo(""Adjust colours"", ""Apply adjustments to colours across the layout"", ""Edit"", 0);
            break;
                
        case LumatoneSandbox::Menu::commandIDs::openRandomColorsGame:
            result.setInfo(""Random Colors"", ""Open launcher for Random Colors game"", ""Game"", 0);
            break;

        case LumatoneSandbox::Menu::commandIDs::openHexRingsGame:
            result.setInfo(""Hex Rings"", ""Open launcher for Hex Rings game"", ""Game"", 0);
            break;

        case LumatoneSandbox::Menu::commandIDs::openHexagonAutomata:
            result.setInfo(""Hexagon Automata"", ""Open launcher for hex game of life"", ""Game"", 0);
            break;

        default:
            result.setInfo(""?"", ""Unknown command"", ""Unknown"", 0);  
            break;
        }
}

bool LumatoneSandboxProcessorEditor::perform(const juce::ApplicationCommandTarget::InvocationInfo& info)
{
    switch (info.commandID)
    {
    case LumatoneSandbox::Menu::commandIDs::openSysExMapping:
    {
        auto directory = controller->getLastMappingsDirectory();
        fileChooser.reset(new juce::FileChooser(""Open .LTN file"", directory, ""*.ltn""));
        fileChooser->launchAsync(
            juce::FileBrowserComponent::FileChooserFlags::canSelectFiles | juce::FileBrowserComponent::FileChooserFlags::openMode,
            [&](const juce::FileChooser& chooser)
            {
                auto file = chooser.getResult();
                controller->loadLayoutFromFile(file);
                
            });
        return true;
    }

    case LumatoneSandbox::Menu::commandIDs::saveSysExMappingAs:
    {
        auto directory = controller->getLastMappingsDirectory();
        fileChooser.reset(new juce::FileChooser(""Save .LTN file"", directory, ""*.ltn""));
        fileChooser->launchAsync(
            juce::FileBrowserComponent::FileChooserFlags::canSelectFiles | juce::FileBrowserComponent::FileChooserFlags::saveMode,
            [&](const juce::FileChooser& chooser)
            {
                auto file = chooser.getResult();
                auto  [MASK]  = controller->getMappingData()
                                              ->toStringArray()
                                              .joinIntoString(juce::newLine);
                
                auto tempFile = file.createTempFile(""ltn.tmp"");
                tempFile.appendText( [MASK] );
                tempFile.moveFileTo(file);
            });
        return true;
    }

    case LumatoneSandbox::Menu::commandIDs::importSysExMapping:
    {
        controller->sendGetCompleteMappingRequest();
        return true;
    }

    case LumatoneSandbox::Menu::commandIDs::adjustColour:
    {
        juce::DialogWindow::LaunchOptions launch;
        launch.dialogTitle = ""Adjust Colours"";
        launch.content.setOwned(new AdjustColourPanel(controller, paletteLibrary));
        launch.content->setSize(600, 400);

        launch.componentToCentreAround = mainComponent.get();
        launch.launchAsync();

        return true;
    }

    case LumatoneSandbox::Menu::commandIDs::openRandomColorsGame:
    {
        mainComponent->setGameComponent(new RandomColorsComponent(gameEngine));
        return true;
    }
    
    case LumatoneSandbox::Menu::commandIDs::openHexRingsGame:
    {
        mainComponent->setGameComponent(new HexRingLauncher(gameEngine));
        return true;
    }

    case LumatoneSandbox::Menu::commandIDs::openHexagonAutomata:
    {
        mainComponent->setGameComponent(new HexagonAutomataComponent(gameEngine));
        return true;
    }

    default:
        return false;
    }

    return false;
}
",layoutString
89,"/**
   esp8266 firmware OTA

   Purpose: Perform an OTA update from a bin located on a webserver (HTTP Only)

   Setup:
   Step 1 : Set your WiFi (ssid & password)
   Step 2 : set EspFota()
   
   Upload:
   Step 1 : Menu > Sketch > Export Compiled Library. The bin file will be saved in the sketch folder (Menu > Sketch > Show Sketch folder)
   Step 2 : Upload it to your webserver
   Step 3 : Update your firmware JSON file ( see firwmareupdate )

*/

#include <espfota.h>
#include <ESP8266WiFi.h>

// Change to your WiFi credentials
const char *ssid = """";
const char *password = """";

// EspFota fota(""<Type of Firme for this device>"", <this version>);
EspFota fota(""bedroom_lights"", 1);

void setup()
{
  fota.checkUpdateURL = ""http://server/updates/firmware.json"";
  Serial.begin(115200);
  setup_wifi();
}

void setup_wifi()
{
  delay(10);
  Serial.print(""Connecting to "");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(""."");
  }

  Serial.println("""");
  Serial.println(WiFi.localIP());
}

void loop()
{

  fota.useDeviceMAC = true;
  bool  [MASK]  = fota.execHTTPcheck();
  if ( [MASK] )
  {
    fota.execOTA();
  }

  delay(2000);
}",updatedNeeded
90,"#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <limits>
#include <numeric>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include ""gdal.h""
#include ""gdal_priv.h""
#include ""ogrsf_frmts.h""
#include ""cpl_error.h""
#include ""ogr_feature.h""
#include ""ogr_geometry.h""
#include ""ogr_core.h""
#include ""ogr_srs_api.h""
#include ""ogr_spatialref.h""
#include ""cpl_port.h""
#include ""cpl_string.h""

using GeoTransform = std::array<double, 6>;
using ArrayIndex_t = size_t;
using Row = ArrayIndex_t;
using Column = ArrayIndex_t;
using ArrayCoordinate = std::pair<Column, Row>;
using GeographicIndex_t = double;
using Latitude = GeographicIndex_t;
using Longitude = GeographicIndex_t;
using GeographicCoordinate = std::pair<Longitude, Latitude>;

struct Arguments {
public:
    size_t raster_band;
    size_t cache_size;
    std::string point_layer;
    std::string input_raster;
    std::string input_points;
    std::string output_points;
    std::string output_format;
    std::string source_srs;
    std::string target_srs;

    Arguments(): raster_band(1),
                 cache_size(64),
                 point_layer(),
                 input_raster(),
                 input_points(),
                 output_points(),
                 output_format(""GPKG""),
                 source_srs(),
                 target_srs() {};
    Arguments(const size_t raster_band,
              const size_t cache_size,
              const std::string point_layer,
              const std::string input_raster,
              const std::string input_points,
              const std::string output_points,
              const std::string output_format,
              const std::string source_srs,
              const std::string target_srs): raster_band(raster_band),
                                             cache_size(cache_size),
                                             point_layer(point_layer),
                                             input_raster(input_raster),
                                             input_points(input_points),
                                             output_points(output_points),
                                             output_format(output_format),
                                             source_srs(source_srs),
                                             target_srs(target_srs) {};
    ~Arguments() = default;
};

struct RasterShape {
public:
    size_t blockxsize;
    size_t blockysize;
    size_t size_x;
    size_t size_y;
    size_t num_blocks_x;
    size_t num_blocks_y;

    RasterShape() = default;
    ~RasterShape() = default;
};

struct RasterBounds {
private:
    double ulx;
    double uly;
    double lrx;
    double lry;
public:
    RasterBounds(const GeoTransform& gt, const size_t rastersize_x, const size_t rastersize_y) {
        ulx = gt[0]; uly = gt[3] + static_cast<double>(rastersize_y)*gt[5];
        lrx = gt[0] + static_cast<double>(rastersize_x)*gt[1]; lry = gt[3];
    };
    ~RasterBounds() = default;

    std::array<GeographicIndex_t, 4> to_array() const {
        return {ulx, uly, lrx, lry};
    };
};

ArrayCoordinate projection_to_rowcol(const GeoTransform& gt, const GeographicCoordinate& point) {
    return std::make_pair(
        static_cast<ArrayIndex_t>((point.first - gt[0]) / gt[1]),
        static_cast<ArrayIndex_t>((point.second - gt[3]) / gt[5])
    );
}

std::vector<ArrayCoordinate> projection_to_rowcol(const GeoTransform& gt, const std::vector<GeographicCoordinate>& points) {
    std::vector<ArrayCoordinate> output{};
    output.reserve(points.size());
    
    std::transform(points.begin(), points.end(), std::back_inserter(output), [&gt](const auto& elem) {
        return projection_to_rowcol(gt, elem);
    });

    return output;
}

size_t rowcol_to_linear_index(const ArrayCoordinate& rowcol, const RasterShape& rs) {
    const size_t x_block = static_cast<size_t>(std::floor(rowcol.first / rs.blockxsize));
    const size_t y_block = static_cast<size_t>(std::floor(rowcol.second / rs.blockysize));
    const size_t linear_index = y_block * rs.size_x + x_block;

    return linear_index;
}

ArrayCoordinate linear_index_to_rowcol(const size_t linear_index, const RasterShape& rs) {
    const ArrayIndex_t row = static_cast<ArrayIndex_t>(std::floor(static_cast<double>(linear_index) / static_cast<double>(rs.size_x)));
    const ArrayIndex_t col = linear_index - row*rs.size_x;

    return std::make_pair(col, row);
}

std::vector<GeographicCoordinate> read_points_from_geofile(OGRLayer* layer, OGRCoordinateTransformation* transform) {
    OGRPoint* point = nullptr;
    OGRGeometry* layer_geom = nullptr;
    std::vector<GeographicCoordinate> points{};

    for (auto& feature : layer) {
        layer_geom = feature->GetGeometryRef();
        if (!layer_geom || !(wkbFlatten(layer_geom->getGeometryType()) == wkbPoint)) {
            std::cerr << ""Detected feature with invalid/non-point geometry! Skipping...\n"";
            continue;
        }

        point = layer_geom->toPoint();
        if (transform && point->transform(transform) != OGRERR_NONE) {
            std::cerr << ""Failed to project point from point SRS to raster SRS!\n"";
            continue;
        }
        points.push_back(std::make_pair(point->getX(), point->getY()));
    }

    return points;
}

OGRFieldType ogr_type_from_gdal_type(const GDALDataType dt) {
    if (dt == GDT_Float32 || dt == GDT_Float64) { return OFTReal; }
    if (dt == GDT_Int8 || dt == GDT_Int16 || dt == GDT_Int32 || dt == GDT_Int64 || 
        dt == GDT_UInt16 || dt == GDT_UInt32 || dt == GDT_UInt64) { return OFTInteger64; }
    
    return OFTMaxType;
}

template<typename T>
CPLErr write_points_to_geofile(const std::string& path, 
                               const std::vector<GeographicCoordinate>& points,
                               const std::vector<T>& values,
                               const GDALDataType raster_dt,
                               const OGRSpatialReference* sref,
                               OGRCoordinateTransformation* transform,
                               const std::string output_driver,
                               const std::string output_field_name = ""sampled"") {
    GDALDriver* driver = GetGDALDriverManager()->GetDriverByName(output_driver.c_str());
    if (!driver) {
        std::cerr << ""Could not use "" << output_driver << "" driver for writing\n"";
        return CE_Failure;
    }

    GDALDataset* ds = driver->Create(path.c_str(), 0, 0, 0, GDT_Unknown, NULL);
    if (!ds) {
        std::cerr << ""Could not create dataset using "" << output_driver << "" driver\n"";
        return CE_Failure;
    }

    CPLStringList options{};
    if (output_driver.compare(""CSV"") == 0) {
        options.SetNameValue(""GEOMETRY"", ""AS_XY"");
    }

    OGRSpatialReference* sref_output = sref->Clone();
    OGRLayer* layer = ds->CreateLayer(""output"", sref_output, wkbPoint, options);
    if (!layer) {
        std::cerr << ""Could not create layer using "" << output_driver << "" driver\n"";
        return CE_Failure;
    }

    const OGRFieldType field_type = ogr_type_from_gdal_type(raster_dt);
    if (field_type == OFTMaxType) {
        std::cerr << ""Could not determine field type!\n"";
        return CE_Failure;
    }

    OGRFieldDefn field(output_field_name.c_str(), field_type);
    field.SetWidth(32);
    field.SetPrecision(13);

    if (layer->CreateField(&field) != OGRERR_NONE) {
        std::cerr << ""Could not create field on output\n"";
        return CE_Failure;
    }

    for (size_t i = 0; i < points.size(); i++) {
        OGRFeature* feature = OGRFeature::CreateFeature(layer->GetLayerDefn());
        if constexpr (std::is_floating_point_v<T>) {
            feature->SetField(output_field_name.c_str(), static_cast<double>(values[i]));
        } else {
            feature->SetField(output_field_name.c_str(), static_cast<int>(values[i]));
        }

        OGRPoint pt{points[i].first, points[i].second};
        if (transform && pt.transform(transform) != OGRERR_NONE) {
            std::cerr << ""Failed to project point from source SRS to specified target SRS!\n"";
        };
        feature->SetGeometry(&pt);

        if (layer->CreateFeature(feature) != OGRERR_NONE) {
            std::cerr << ""Failed to create feature!\n"";
        }

        OGRFeature::DestroyFeature(feature);
    }

    GDALClose(ds);

    return CE_None;
}

void print_usage() {
    std::cout << ""Usage: parsam [-l,--layer layername] [-b,--band band_number]\n"";
    std::cout << ""              [-cs,--cachesize size] [-of,--output_format format]\n"";
    std::cout << ""              [-s_srs,--source_srs srs] [-t_srs,--target_srs srs]\n"";
    std::cout << ""              input_raster input_points output_points\n\n"";
    std::cout << ""       -l, --layer: Name of input point layer to sample. Defaults to first layer.\n"";
    std::cout << ""       -b, --band: Band of input raster to sample. Defaults to first band.\n"";
    std::cout << ""       -cs, --cachesize: Size in megabyte for GDAL to use internally for caching.\n"";
    std::cout << ""       -of, --output_format: Output format to use for result file. Needs to be a valid choice for GDAL tools.\n"";
    std::cout << ""       -s_srs,--source_srs: Source spatial reference system to use for inputs. Note that input points will be\n""
              << ""                            dynamically reprojected if necessary, but an error will be thrown if the raster\n""
              << ""                            is not using this reference system.\n"";
    std::cout << ""       -t_srs,--target_srs: Target spatial reference system to project output points into.\n"";
    std::cout << ""\n"";
    std::cout << ""       input_raster: Path pointing to input raster to sample points from.\n"";
    std::cout << ""       input_points: Path pointing to input vector layer containing points to be sampled.\n"";
    std::cout << ""       output_points: Path pointing to output vector layer containing sampled points.\n"";
}

void parse_cli_args(const int argc, const char* argv[], Arguments& args) {
    bool invalid_arg_found = false;
    size_t current_arg_idx = 1;
    size_t io_arg_idx = 0;
    std::array<std::string, 3> io_args{};
    while (current_arg_idx < static_cast<size_t>(argc)) {
        const std::string current_arg{argv[current_arg_idx]};
        if (current_arg.compare(""-l"") == 0 || current_arg.compare(""--layer"") == 0) {
            args.point_layer = std::string{argv[current_arg_idx + 1]};
            current_arg_idx += 2;
            continue;
        }
        
        if (current_arg.compare(""-b"") == 0 || current_arg.compare(""--band"") == 0) {
            const int raster_band = std::stoi(argv[current_arg_idx + 1]);
            if (raster_band < 1) {
                args.raster_band = 0;
            } else {
                args.raster_band = static_cast<size_t>(raster_band);
            }
            current_arg_idx += 2;
            continue;
        }

        if (current_arg.compare(""-cs"") == 0 || current_arg.compare(""--cachesize"") == 0) {
            const int cache_size = std::stoi(argv[current_arg_idx + 1]);
            if (cache_size < 0) {
                std::cerr << ""Negative cachesize is not allowed!\n"";
                invalid_arg_found = true;
                break;
            }

            args.cache_size = static_cast<size_t>(cache_size);
            current_arg_idx += 2;
            continue;
        }

        if (current_arg.compare(""-of"") == 0 || current_arg.compare(""--output_format"") == 0) {
            args.output_format = std::string{argv[current_arg_idx + 1]};
            current_arg_idx += 2;
            continue;
        }

        if (current_arg.compare(""-s_srs"") == 0 || current_arg.compare(""--source_srs"") == 0) {
            args.source_srs = std::string{argv[current_arg_idx + 1]};
            current_arg_idx += 2;
            continue;
        }

        if (current_arg.compare(""-t_srs"") == 0 || current_arg.compare(""--target_srs"") == 0) {
            args.target_srs = std::string{argv[current_arg_idx + 1]};
            current_arg_idx += 2;
            continue;
        }

        if (current_arg.compare(0, 1, ""-"") == 0 || current_arg.compare(0, 2, ""--"") == 0) {
            std::cerr << ""Unknown argument: "" << current_arg << ""\n"";
            invalid_arg_found = true;
            break;
        }
        
        io_args[io_arg_idx++] = current_arg;
        current_arg_idx++;
    }

    if (!invalid_arg_found) {
        args.input_raster = io_args[0];
        args.input_points = io_args[1];
        args.output_points = io_args[2];
    }
}

bool validate_parsed_arguments(const Arguments& args) {
    const bool raster_band_is_positive = args.raster_band > 0;
    const bool input_points_are_present = !args.input_points.empty();
    const bool input_raster_is_present = !args.input_raster.empty();
    const bool output_points_are_present = !args.output_points.empty();

    return raster_band_is_positive &&
           input_points_are_present &&
           input_raster_is_present &&
           output_points_are_present;
}

bool check_crs_match(const OGRSpatialReference* raster_sref, const OGRSpatialReference* point_sref) {
    if (!raster_sref || !point_sref) {
        std::cerr << ""Could not read spatial reference from inputs\n"";
        return false;
    }
    if (!point_sref->IsSame(raster_sref)) {
        std::cerr << ""Spatial reference systems of inputs do not match\n"";
        return false;
    }

    return true;
}

OGRErr determine_source_srs(const Arguments& args, OGRSpatialReference*& source_sref, const OGRSpatialReference* raster_sref, const OGRSpatialReference* point_sref) {
    if (!args.source_srs.empty()) {
        OGRSpatialReference user_input_srs;
        if (user_input_srs.SetFromUserInput(args.source_srs.c_str()) != OGRERR_NONE) {
            std::cerr << ""Did not understand source spatial reference definition!\n"";
            return OGRERR_UNSUPPORTED_SRS;
        };

        // TODO: This only checks whether they use the same geographical CRS and both are projected/non-projected. However,
        //       the projections may still be different!
        if (!(raster_sref->IsSameGeogCS(&user_input_srs) && raster_sref->IsProjected() == user_input_srs.IsProjected())) {
            std::cerr << ""SRS mismatch between input raster and source raster definition. Are they using the same CRS?\n"";
            return OGRERR_UNSUPPORTED_SRS;
        }

        source_sref = user_input_srs.Clone();
    } else {
        if (!check_crs_match(raster_sref, point_sref)) {
            std::cerr << ""Mismatch between input raster and input point SRS! Either specify a custom one using '-s_srs' to reproject points\n""
                        << ""on the fly to the raster SRS or reproject both to the same SRS before.\n"";
            return OGRERR_UNSUPPORTED_SRS;
        }

        source_sref = raster_sref->Clone();
    }

    source_sref->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
    return OGRERR_NONE;
}

OGRErr determine_target_srs(const Arguments& args, OGRSpatialReference*& target_sref, const OGRSpatialReference* source_sref) {
    if (!args.target_srs.empty()) {
        OGRSpatialReference user_target_srs;
        if (user_target_srs.SetFromUserInput(args.target_srs.c_str()) != OGRERR_NONE) {
            std::cerr << ""Did not understand target spatial reference definition!\n"";
            return OGRERR_UNSUPPORTED_SRS;
        }

        target_sref = user_target_srs.Clone();
    } else {
        target_sref = source_sref->Clone();
    }

    target_sref->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
    return OGRERR_NONE;
}

std::vector<bool> calculate_points_in_bounds_mask(const std::vector<GeographicCoordinate>& points, const RasterBounds& rb) {
    std::vector<bool> in_bounds{};
    in_bounds.reserve(points.size());

    const auto raster_bounds = rb.to_array();

    std::transform(points.begin(), points.end(), std::back_inserter(in_bounds), [&raster_bounds](const auto& point) {
        const bool in_x_bounds = point.first > raster_bounds[0] && point.first < raster_bounds[2];
        const bool in_y_bounds = point.second > raster_bounds[1] && point.second < raster_bounds[3];
        return in_x_bounds && in_y_bounds;
    });

    return in_bounds;
}

void sort_proxy_by_blocks(std::vector<size_t>& point_proxy, const std::vector<ArrayCoordinate>& points_rowcol, const std::vector<bool>& valid_mask, const RasterShape& rs) {
    std::sort(point_proxy.begin(), point_proxy.end(), [&](const auto& idx_a, const auto& idx_b) {
        const auto a = points_rowcol[idx_a];
        const size_t  [MASK]  = valid_mask[idx_a] ? rowcol_to_linear_index(a, rs) : std::numeric_limits<size_t>::max();

        const auto b = points_rowcol[idx_b];
        const size_t b_linear_index = valid_mask[idx_b] ? rowcol_to_linear_index(b, rs) : std::numeric_limits<size_t>::max();

        return  [MASK]  < b_linear_index;
    });
}

std::vector<std::pair<size_t, size_t>> calculate_nonempty_window_indices(
    const std::vector<size_t>& point_proxy,
    const std::vector<ArrayCoordinate>& points_rowcol,
    const std::vector<bool>& valid_mask,
    const RasterShape& rs
) {
    size_t starting_boundary_index = 0;
    size_t starting_linear_index = rowcol_to_linear_index(points_rowcol[point_proxy[0]], rs);
    std::vector<std::pair<size_t, size_t>> window_indices{};
    
    // This marks the initial window to sample from
    window_indices.push_back(std::make_pair(starting_boundary_index, starting_linear_index));
    
    for (size_t i = 0; i < point_proxy.size(); i++) {
        const size_t current_linear_index = rowcol_to_linear_index(points_rowcol[point_proxy[i]], rs);

        if (starting_linear_index != current_linear_index) {
            starting_boundary_index = i;
            starting_linear_index = current_linear_index;

            if (valid_mask[point_proxy[i]]) {
                window_indices.push_back(std::make_pair(starting_boundary_index, starting_linear_index));
            } else {
                // Push a window with a special value for the linear index. This will be used to abort once all valid points are covered.
                window_indices.push_back(std::make_pair(starting_boundary_index, std::numeric_limits<size_t>::max()));
                break;
            }
        }
    }

    return window_indices;
}

RasterShape raster_shape_from_band(GDALRasterBand* band) {
    int blockxsize, blockysize;
    band->GetBlockSize(&blockxsize, &blockysize);

    return RasterShape {
        static_cast<size_t>(blockxsize),
        static_cast<size_t>(blockysize),
        static_cast<size_t>(band->GetXSize()),
        static_cast<size_t>(band->GetYSize()),
        static_cast<size_t>((band->GetXSize() + blockxsize - 1) / blockxsize),
        static_cast<size_t>((band->GetYSize() + blockysize - 1) / blockysize)
    };
}

template<typename T>
std::vector<T> sample_points_from_band(GDALRasterBand* band,
                                       const std::vector<ArrayCoordinate>& points_rowcol,
                                       const std::vector<size_t>& points_proxy,
                                       const std::vector<std::pair<size_t, size_t>>& window_indices,
                                       const RasterShape& rs)
{
    const size_t max_point_index = points_rowcol.size();
    
    T sample_initializer_value{};
    if constexpr (std::is_floating_point<T>::value) {
        sample_initializer_value = std::numeric_limits<T>::quiet_NaN();
    } else {
        sample_initializer_value = std::numeric_limits<T>::max();
    }

    std::vector<T> points_sampled(points_rowcol.size(), sample_initializer_value);
    
    std::vector<T> block_buffer{};
    block_buffer.reserve(rs.blockxsize*rs.blockysize);

    for (const auto& [proxy_index, linear_index] : window_indices) {
        if (linear_index == std::numeric_limits<size_t>::max()) {
            break;
        }

        size_t current_point = proxy_index;
        const auto [block_x, block_y] = linear_index_to_rowcol(linear_index, rs);
        int valid_blocksize_x{}, valid_blocksize_y{};
        if (band->GetActualBlockSize(static_cast<int>(block_x), static_cast<int>(block_y), &valid_blocksize_x, &valid_blocksize_y) != CE_None) {
            throw std::runtime_error(""Error reading true blocksize!"");
        };

        if (band->ReadBlock(static_cast<int>(block_x), static_cast<int>(block_y), block_buffer.data()) != CE_None) {
            throw std::runtime_error(""Error reading block!"");
        }

        // The left edge is always multiples of the full blocksize from the origin
        // while the right edge may not be a full block size away due to partial blocks
        const size_t block_xmin = block_x*rs.blockxsize, block_xmax = block_xmin + static_cast<size_t>(valid_blocksize_x);
        const size_t block_ymin = block_y*rs.blockysize, block_ymax = block_ymin + static_cast<size_t>(valid_blocksize_y);
        
        while (true) {
            const auto point_index = points_proxy[current_point];
            const auto [glob_x, glob_y] = points_rowcol[point_index];
            const bool within_x_bounds = block_xmin <= glob_x && glob_x < block_xmax;
            const bool within_y_bounds = block_ymin <= glob_y && glob_y < block_ymax;

            if (!within_x_bounds || !within_y_bounds || current_point == max_point_index) {
                break;
            }

            const size_t local_x = glob_x - block_xmin, local_y = glob_y - block_ymin;
            points_sampled[point_index] = block_buffer[local_y*rs.blockxsize + local_x];
            current_point++;
        }
    }

    return points_sampled;
}

CPLErr dispatch_sample_and_write(const GDALDataType raster_dt,
                                 GDALRasterBand* band,
                                 const std::vector<GeographicCoordinate>& points,
                                 const std::vector<ArrayCoordinate>& points_rowcol,
                                 const std::vector<size_t>& points_proxy,
                                 const std::vector<std::pair<size_t, size_t>>& window_indices,
                                 const RasterShape& rs,
                                 const OGRSpatialReference* target_sref,
                                 OGRCoordinateTransformation* target_point_transform,
                                 const Arguments& args)
{
    switch (raster_dt) {
        case GDT_Float32:
            {
                const auto points_sampled = sample_points_from_band<float>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<float>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_Float64:
            {
                const auto points_sampled = sample_points_from_band<double>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<double>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_UInt16:
            {
                const auto points_sampled = sample_points_from_band<uint16_t>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<uint16_t>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_UInt32:
            {
                const auto points_sampled = sample_points_from_band<uint32_t>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<uint32_t>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_UInt64:
            {
                const auto points_sampled = sample_points_from_band<uint64_t>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<uint64_t>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_Int8:
            {
                const auto points_sampled = sample_points_from_band<int8_t>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<int8_t>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_Int16:
            {
                const auto points_sampled = sample_points_from_band<int16_t>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<int16_t>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_Int32:
            {
                const auto points_sampled = sample_points_from_band<int32_t>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<int32_t>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        case GDT_Int64:
            {
                const auto points_sampled = sample_points_from_band<int64_t>(band, points_rowcol, points_proxy, window_indices, rs);
                return write_points_to_geofile<int64_t>(args.output_points, points, points_sampled, raster_dt, target_sref, target_point_transform, args.output_format);
            }
        default:
            return CE_Failure;
    }
}

int main(int argc, const char* argv[]) {
    if (argc <= 3 || std::string(argv[1]).compare(""-h"") == 0) {
        print_usage();
        return 0;
    };

    Arguments args{};
    parse_cli_args(argc, argv, args);
    if (!validate_parsed_arguments(args)) {
        if (args.raster_band < 1) {
            std::cerr << ""Raster band needs to be larger than or equal to 1\n"";
        } else {
            std::cerr << ""Missing "";
            if (args.input_points.empty()) std::cerr << ""input points, "";
            if (args.input_raster.empty()) std::cerr << ""input raster, "";
            if (args.output_points.empty()) std::cerr << ""output points"";
            std::cerr << ""\n"";
        }

        print_usage();
        return 1;
    }

    GDALAllRegister();

    // Limit GDAL's internal caching size. At 64MB, there does not seem to be much benefit from more
    CPLSetConfigOption(""GDAL_CACHEMAX"", std::to_string(args.cache_size).c_str());

    GDALDatasetUniquePtr input_raster = GDALDatasetUniquePtr(GDALDataset::FromHandle(GDALOpen(args.input_raster.c_str(), GA_ReadOnly)));
    if(!input_raster) {
        std::cerr << ""Could not open input raster at "" << args.input_raster << ""\n"";
        return 1;
    }

    GDALDatasetUniquePtr input_points = GDALDatasetUniquePtr(GDALDataset::FromHandle(GDALOpenEx(args.input_points.c_str(), GA_ReadOnly | GDAL_OF_VECTOR, NULL, NULL, NULL)));
    if (!input_points) {
        std::cerr << ""Could not open input points at "" << args.input_points << ""\n"";
        return 1;
    }

    GeoTransform gt_ir{};
    if (input_raster->GetGeoTransform(gt_ir.data()) != CE_None) {
        std::cerr << ""Could not read geotransform from input raster\n"";
        return 1;
    }

    GDALRasterBand* band = input_raster->GetRasterBand(static_cast<int>(args.raster_band));
    if (!band) {
        std::cerr << ""Could not read band "" << args.raster_band << "" from raster\n"";
        return 1;
    }

    OGRLayer* point_layer = nullptr;
    if (!args.point_layer.empty()) {
        point_layer = input_points->GetLayerByName(args.point_layer.c_str());
    } else {
        point_layer = input_points->GetLayer(0);
    }

    if (!point_layer) {
        std::cerr << ""Could not read layer from input point dataset\n"";
        return 1;
    }

    // If the user supplied custom source and target spatial reference systems,
    // check them early so we can fail early if something mismatches
    const OGRSpatialReference* raster_sref = input_raster->GetSpatialRef();
    const OGRSpatialReference* point_sref = point_layer->GetSpatialRef();

    OGRSpatialReference* source_sref = nullptr;
    if (determine_source_srs(args, source_sref, raster_sref, point_sref) != OGRERR_NONE) {
        return 1;
    }

    OGRSpatialReference* target_sref = nullptr;
    if (determine_target_srs(args, target_sref, source_sref) != OGRERR_NONE) {
        return 1;
    }

    // Transform input points during reading if they are using a different CRS. Just pass
    // a matching transform to the read_points_from_geofile function
    OGRCoordinateTransformation* source_point_transform = nullptr;
    if (!point_sref->IsSame(source_sref)) {
        source_point_transform = OGRCreateCoordinateTransformation(point_sref, source_sref);

        if (!source_point_transform) {
            std::cerr << ""Failed to find a transform for going from point SRS to specified source SRS!\n"";
            return 1;
        }
    }

    // Same applies for output SRS. Figure out early if we can even do this!
    OGRCoordinateTransformation *target_point_transform = nullptr;
    if (!source_sref->IsSame(target_sref)) {
        target_point_transform = OGRCreateCoordinateTransformation(source_sref, target_sref);

        if (!target_point_transform) {
            std::cerr << ""Failed to find a transform for going from raster SRS to specified target SRS!\n"";
            return 1;
        }
    }

    const RasterShape rs = raster_shape_from_band(band);
    const RasterBounds rb(
        gt_ir,
        static_cast<size_t>(input_raster->GetRasterXSize()),
        static_cast<size_t>(input_raster->GetRasterYSize())
    );

    const auto points = read_points_from_geofile(point_layer, source_point_transform);
    const auto in_bounds = calculate_points_in_bounds_mask(points, rb);
    const auto points_rowcol = projection_to_rowcol(gt_ir, points);

    std::vector<size_t> points_proxy(points_rowcol.size());
    std::iota(points_proxy.begin(), points_proxy.end(), 0);
    sort_proxy_by_blocks(points_proxy, points_rowcol, in_bounds, rs);

    const auto window_indices = calculate_nonempty_window_indices(points_proxy, points_rowcol, in_bounds, rs);

    if (dispatch_sample_and_write(band->GetRasterDataType(), band, points, points_rowcol, points_proxy,
                                  window_indices, rs, target_sref, target_point_transform, args) != CE_None)
    {
        std::cerr << ""Error writing result\n"";
        return 1;
    }

    return 0;
}",a_linear_index
91,"/*
 * Copyright (c) 2024 Huawei Device Co., Ltd.
 * 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 ""oaid_remote_config_observer_stub.h""
#include ""oaid_common.h""

namespace OHOS {
namespace Cloud {

RemoteConfigObserverStub::RemoteConfigObserverStub()
{}

RemoteConfigObserverStub::~RemoteConfigObserverStub()
{}

int32_t RemoteConfigObserverStub::OnRemoteRequest(
    uint32_t  [MASK] , MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
    std::string bundleName;
    std::u16string descriptor = RemoteConfigObserverStub::GetDescriptor();
    std::u16string remoteDescriptor = data.ReadInterfaceToken();
    if (descriptor != remoteDescriptor) {
        OAID_HILOGE(OAID_MODULE_SERVICE, ""read descriptor failed."");
        return ERR_INVALID_PARAM;
    }
    switch ( [MASK] ) {
        case static_cast<uint32_t>(RegisterObserverCode::OnOaidUpdated): {
            return HandleOAIDUpdate(data, reply);
        }
        default:
            return IPCObjectStub::OnRemoteRequest( [MASK] , data, reply, option);
    }
}

int32_t RemoteConfigObserverStub::HandleOAIDUpdate(MessageParcel &data, MessageParcel &reply)
{
    std::string oaid;
    if (!data.ReadString(oaid)) {
        OAID_HILOGE(OAID_MODULE_SERVICE, ""parcel read value failed."");
        return ERR_INVALID_PARAM;
    }
    OnOaidUpdated(oaid);
    return ERR_OK;
}
}  // namespace Cloud
}  // namespace OHOS",code
92,"/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * 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 ""js_convertxml.h""
#include ""securec.h""
#include ""utils/log.h""
namespace OHOS::Xml {
    ConvertXml::ConvertXml()
    {
            spaceType_ = SpaceType::T_INIT;
            strSpace_ = """";
            iSpace_ = 0;
    }
    std::string ConvertXml::GetNodeType(const xmlElementType enumType) const
    {
        std::string strResult = """";
        switch (enumType) {
            case xmlElementType::XML_ELEMENT_NODE:
                strResult = ""element"";
                break;
            case xmlElementType::XML_ATTRIBUTE_NODE:
                strResult = ""attribute"";
                break;
            case xmlElementType::XML_TEXT_NODE:
                strResult = ""text"";
                break;
            case xmlElementType::XML_CDATA_SECTION_NODE:
                strResult = ""cdata"";
                break;
            case xmlElementType::XML_ENTITY_REF_NODE:
                strResult = ""entity_ref"";
                break;
            case xmlElementType::XML_ENTITY_NODE:
                strResult = ""entity"";
                break;
            case xmlElementType::XML_PI_NODE:
                strResult = ""instruction"";
                break;
            case xmlElementType::XML_COMMENT_NODE:
                strResult = ""comment"";
                break;
            case xmlElementType::XML_DOCUMENT_NODE:
                strResult = ""document"";
                break;
            case xmlElementType::XML_DOCUMENT_TYPE_NODE:
                strResult = ""document_type"";
                break;
            case xmlElementType::XML_DOCUMENT_FRAG_NODE:
                strResult = ""document_frag"";
                break;
            case xmlElementType::XML_DTD_NODE:
                strResult = ""doctype"";
                break;
#ifdef LIBXML_DOCB_ENABLED
            case xmlElementType::XML_DOCB_DOCUMENT_NODE:
                strResult =  ""docb_document"";
                break;
#endif
            default:
                break;
        }
        return strResult;
    }

    void ConvertXml::SetKeyValue(napi_env env, const napi_value &object, const std::string strKey,
                                 const std::string strValue) const
    {
        napi_value attrValue = nullptr;
        napi_create_string_utf8(env, strValue.c_str(), NAPI_AUTO_LENGTH, &attrValue);
        napi_set_named_property(env, object, strKey.c_str(), attrValue);
    }
    std::string ConvertXml::Trim(std::string strXmltrim) const
    {
        if (strXmltrim.empty()) {
            return """";
        }
        size_t i = 0;
        size_t strlen = strXmltrim.size();
        for (; i < strlen;) {
            if (strXmltrim[i] == ' ') {
                i++;
            } else {
                break;
            }
        }
        strXmltrim = strXmltrim.substr(i);
        strlen = strXmltrim.size();
        for (i = strlen - 1; i != 0; i--) {
            if (strXmltrim[i] == ' ') {
                strXmltrim.pop_back();
            } else {
                break;
            }
        }
        return strXmltrim;
    }

    void ConvertXml::GetPrevNodeList(napi_env env, xmlNodePtr curNode)
    {
        while (curNode->prev != nullptr) {
            curNode = curNode->prev;
            napi_value elementsObject = nullptr;
            napi_create_object(env, &elementsObject);
            char *curContent = nullptr;
            if (curNode->type == xmlElementType::XML_PI_NODE && !options_.ignoreInstruction) {
                SetKeyValue(env, elementsObject, options_.type, GetNodeType(curNode->type));
                SetKeyValue(env, elementsObject, options_.name, reinterpret_cast<const char*>(curNode->name));
                curContent = reinterpret_cast<char*>(xmlNodeGetContent(curNode));
                if (curContent != nullptr) {
                    SetKeyValue(env, elementsObject, options_.instruction, curContent);
                    xmlFree(reinterpret_cast<void*>(curContent));
                }
                prevObj_.push_back(elementsObject);
            }
            if (curNode->type == xmlElementType::XML_COMMENT_NODE && !options_.ignoreComment) {
                SetKeyValue(env, elementsObject, options_.type, GetNodeType(curNode->type));
                curContent = reinterpret_cast<char*>(xmlNodeGetContent(curNode));
                if (curContent != nullptr) {
                    SetKeyValue(env, elementsObject, options_.comment, curContent);
                    xmlFree(reinterpret_cast<void*>(curContent));
                }
                prevObj_.push_back(elementsObject);
            }
            if (curNode->type == xmlElementType::XML_DTD_NODE && !options_.ignoreDoctype) {
                SetKeyValue(env, elementsObject, options_.type, GetNodeType(curNode->type));
                SetKeyValue(env, elementsObject, options_.doctype,
                            reinterpret_cast<const char*>(curNode->name));
                prevObj_.push_back(elementsObject);
            }
        }
    }

    void ConvertXml::SetAttributes(napi_env env, xmlNodePtr curNode, const napi_value &elementsObject) const
    {
        xmlAttr *attr = curNode->properties;
        if (attr && !options_.ignoreAttributes) {
            napi_value attrTitleObj = nullptr;
            napi_create_object(env, &attrTitleObj);
            while (attr) {
                SetKeyValue(env, attrTitleObj, reinterpret_cast<const char*>(attr->name),
                            reinterpret_cast<const char*>(attr->children->content));
                attr = attr->next;
            }
            napi_set_named_property(env, elementsObject, options_.attributes.c_str(), attrTitleObj);
        }
    }

    void ConvertXml::SetXmlElementType(napi_env env, xmlNodePtr curNode, const napi_value &elementsObject,
                                       bool &bFlag) const
    {
        char *curContent = reinterpret_cast<char*>(xmlNodeGetContent(curNode));
        if (curNode->type == xmlElementType::XML_PI_NODE && !options_.ignoreInstruction) {
            if (curContent != nullptr) {
                SetKeyValue(env, elementsObject, options_.instruction.c_str(), curContent);
                bFlag = true;
            }
        } else if (curNode->type == xmlElementType::XML_COMMENT_NODE && !options_.ignoreComment) {
            if (curContent != nullptr) {
                SetKeyValue(env, elementsObject, options_.comment.c_str(), curContent);
                bFlag = true;
            }
        } else if (curNode->type == xmlElementType::XML_CDATA_SECTION_NODE && !options_.ignoreCdata) {
            if (curContent != nullptr) {
                SetKeyValue(env, elementsObject, options_.cdata, curContent);
                bFlag = true;
            }
        }
        if (curContent != nullptr) {
            xmlFree(reinterpret_cast<void*>(curContent));
        }
    }
    void ConvertXml::SetNodeInfo(napi_env env, xmlNodePtr curNode, const napi_value &elementsObject) const
    {
        if (curNode->type == xmlElementType::XML_TEXT_NODE) {
            return;
        } else {
            if (curNode->type == xmlElementType::XML_PI_NODE) {
                if (!options_.ignoreInstruction) {
                    SetKeyValue(env, elementsObject, options_.type, GetNodeType(curNode->type));
                }
            } else {
                    SetKeyValue(env, elementsObject, options_.type, GetNodeType(curNode->type));
            }
            if ((curNode->type != xmlElementType::XML_COMMENT_NODE) &&
                (curNode->type != xmlElementType::XML_CDATA_SECTION_NODE)) {
                if (!(curNode->type == xmlElementType::XML_PI_NODE && options_.ignoreInstruction)) {
                    SetKeyValue(env, elementsObject, options_.name, reinterpret_cast<const char*>(curNode->name));
                }
            }
        }
    }

    void ConvertXml::SetEndInfo(napi_env env, xmlNodePtr curNode, const napi_value &elementsObject,
                                bool &bFlag) const
    {
        SetKeyValue(env, elementsObject, options_.type, GetNodeType(curNode->type));
        if (curNode->type == xmlElementType::XML_ELEMENT_NODE) {
            SetKeyValue(env, elementsObject, options_.name.c_str(),
                        reinterpret_cast<const char*>(curNode->name));
            bFlag = true;
        } else if (curNode->type == xmlElementType::XML_TEXT_NODE) {
            char *curContent = reinterpret_cast<char*>(xmlNodeGetContent(curNode));
            if (options_.trim) {
                if (curContent != nullptr) {
                    SetKeyValue(env, elementsObject, options_.text,
                                Trim(curContent));
                }
            } else {
                if (curContent != nullptr) {
                    SetKeyValue(env, elementsObject, options_.text, curContent);
                }
            }
            if (curContent != nullptr) {
                xmlFree(reinterpret_cast<void*>(curContent));
            }
            if (!options_.ignoreText) {
                bFlag = true;
            }
        }
    }

    void ConvertXml::SetPrevInfo(napi_env env, const napi_value &recvElement, int flag, int32_t &index1) const
    {
        if (!prevObj_.empty() && !flag) {
            for (size_t i = (prevObj_.size() - 1); i > 0; --i) {
                napi_set_element(env, recvElement, index1++, prevObj_[i]);
            }
            napi_set_element(env, recvElement, index1++, prevObj_[0]);
        }
    }

    void ConvertXml::GetXMLInfo(napi_env env, xmlNodePtr curNode, const napi_value &object, int flag)
    {
        napi_value elements = nullptr;
        napi_create_array(env, &elements);
        napi_value recvElement = nullptr;
        napi_create_array(env, &recvElement);
        xmlNodePtr pNode = curNode;
        int32_t index = 0;
        int32_t index1 = 0;
        bool bFlag = false;
        while (pNode != nullptr) {
            bFlag = false;
            napi_value elementsObject = nullptr;
            napi_create_object(env, &elementsObject);
            SetNodeInfo(env, pNode, elementsObject);
            SetAttributes(env, pNode, elementsObject);
            napi_value tempElement = nullptr;
            napi_create_array(env, &tempElement);
            napi_value elementObj = nullptr;
            napi_create_object(env, &elementObj);
            char *curContent = reinterpret_cast<char*>(xmlNodeGetContent(pNode));
            if (curContent != nullptr) {
                if (pNode->children != nullptr) {
                    curNode = pNode->children;
                    GetXMLInfo(env, curNode, elementsObject, 1);
                    bFlag = true;
                } else {
                    SetXmlElementType(env, pNode, elementsObject, bFlag);
                    SetEndInfo(env, pNode, elementsObject, bFlag);
                }
                xmlFree(reinterpret_cast<void*>(curContent));
            }
            SetPrevInfo(env, recvElement, flag, index1);
            if (elementsObject != nullptr && bFlag) {
                napi_set_element(env, recvElement, index1++, elementsObject);
                elementsObject = nullptr;
            }
            index++;
            pNode = pNode->next;
        }
        if (bFlag) {
            napi_set_named_property(env, object, options_.elements.c_str(), recvElement);
        }
    }

    void ConvertXml::SetSpacesInfo(napi_env env, const napi_value &object) const
    {
        napi_value iTemp = nullptr;
        switch (spaceType_) {
            case (SpaceType::T_INT32):
                napi_create_int32(env, iSpace_, &iTemp);
                napi_set_named_property(env, object, ""spaces"", iTemp);
                break;
            case (SpaceType::T_STRING):
                SetKeyValue(env, object, ""spaces"", strSpace_);
                break;
            case (SpaceType::T_INIT):
                SetKeyValue(env, object, ""spaces"", strSpace_);
                break;
            default:
                break;
            }
    }

    napi_value ConvertXml::Convert(napi_env env, std::string strXml)
    {
        xmlDocPtr doc = nullptr;
        xmlNodePtr curNode = nullptr;
        napi_status status = napi_ok;
        napi_value object = nullptr;
        status = napi_create_object(env, &object);
        if (status != napi_ok) {
            return nullptr;
        }
        Replace(strXml, ""\\r"", ""\r"");
        Replace(strXml, ""\\n"", ""\n"");
        Replace(strXml, ""\\v"", ""\v"");
        Replace(strXml, ""\\t"", ""\t"");
        Replace(strXml, ""]]><![CDATA"", ""]]> <![CDATA"");
        size_t len = strXml.size();
        doc = xmlParseMemory(strXml.c_str(), len);
        if (!doc) {
            xmlFreeDoc(doc);
            DealSingleLine(env, strXml, object);
            return object;
        }
        napi_value subObject = nullptr;
        napi_value subSubObject = nullptr;
        napi_create_object(env, &subSubObject);
        napi_create_object(env, &subObject);
        if (doc != nullptr && doc->version != nullptr) {
            SetKeyValue(env, subSubObject, ""version"", (const char*)doc->version);
        }
        if (doc != nullptr && doc->encoding != nullptr) {
            SetKeyValue(env, subSubObject, ""encoding"", (const char*)doc->encoding);
        }
        if (!options_.ignoreDeclaration && strXml.find(""xml"") != std::string::npos) {
            napi_set_named_property(env, subObject, options_.attributes.c_str(), subSubObject);
            napi_set_named_property(env, object, options_.declaration.c_str(), subObject);
        }
        if (doc != nullptr) {
            curNode = xmlDocGetRootElement(doc);
            GetPrevNodeList(env, curNode);
            GetXMLInfo(env, curNode, object, 0);
        }
        SetSpacesInfo(env, object);
        return object;
    }

    napi_status ConvertXml::DealNapiStrValue(napi_env env, const napi_value napi_StrValue, std::string &result) const
    {
        std::string buffer = """";
        size_t bufferSize = 0;
        napi_status status = napi_ok;
        status = napi_get_value_string_utf8(env, napi_StrValue, nullptr, -1, &bufferSize);
        if (status != napi_ok) {
            HILOG_ERROR(""can not get buffer size"");
            return status;
        }
        buffer.reserve(bufferSize + 1);
        buffer.resize(bufferSize);
        if (bufferSize > 0) {
            status = napi_get_value_string_utf8(env, napi_StrValue, buffer.data(), bufferSize + 1, &bufferSize);
            if (status != napi_ok) {
                HILOG_ERROR(""can not get buffer value"");
                return status;
            }
        }
        if (buffer.data() != nullptr) {
            result = buffer;
        }
        return status;
    }

    void ConvertXml::DealSpaces(napi_env env, const napi_value napiObj)
    {
        napi_value recvTemp = nullptr;
        napi_get_named_property(env, napiObj, ""spaces"", &recvTemp);
        napi_valuetype valuetype = napi_undefined;
        napi_typeof(env, recvTemp, &valuetype);
        if (valuetype == napi_string) {
            DealNapiStrValue(env, recvTemp, strSpace_);
            spaceType_ = SpaceType::T_STRING;
        } else if (valuetype == napi_number) {
            int32_t iTemp;
            if (napi_get_value_int32(env, recvTemp, &iTemp) == napi_ok) {
                iSpace_ = iTemp;
                spaceType_ = SpaceType::T_INT32;
            }
        }
    }

    void ConvertXml::DealIgnore(napi_env env, const napi_value napiObj)
    {
        std::vector<std::string> vctIgnore = {""compact"", ""trim"", ""ignoreDeclaration"", ""ignoreInstruction"",
                                              ""ignoreAttributes"", ""ignoreComment"", ""ignoreCDATA"",
                                              ""ignoreDoctype"", ""ignoreText""};
        size_t vctLength = vctIgnore.size();
        for (size_t i = 0; i < vctLength; ++i) {
            napi_value recvTemp = nullptr;
            bool bRecv = false;
            napi_get_named_property(env, napiObj, vctIgnore[i].c_str(), &recvTemp);
            if ((napi_get_value_bool(env, recvTemp, &bRecv)) == napi_ok) {
                switch (i) {
                    case 0:
                        options_.compact = bRecv;
                        break;
                    case 1: // 1:trim
                        options_.trim = bRecv;
                        break;
                    case 2: // 2:ignoreDeclaration
                        options_.ignoreDeclaration = bRecv;
                        break;
                    case 3: // 3:ignoreInstruction
                        options_.ignoreInstruction = bRecv;
                        break;
                    case 4: // 4:ignoreAttributes
                        options_.ignoreAttributes = bRecv;
                        break;
                    case 5: // 5:ignoreComment
                        options_.ignoreComment = bRecv;
                        break;
                    case 6: // 6:ignoreCdata
                        options_.ignoreCdata = bRecv;
                        break;
                    case 7: // 7:ignoreDoctype
                        options_.ignoreDoctype = bRecv;
                        break;
                    case 8: // 8:ignoreText
                        options_.ignoreText = bRecv;
                        break;
                    default:
                        break;
                }
            }
        }
    }

    void ConvertXml::SetDefaultKey(size_t i, const std::string strRecv)
    {
        switch (i) {
            case 0:
                options_.declaration = strRecv;
                break;
            case 1:
                options_.instruction = strRecv;
                break;
            case 2: // 2:attributes
                options_.attributes = strRecv;
                break;
            case 3: // 3:text
                options_.text = strRecv;
                break;
            case 4: // 4:cdata
                options_.cdata = strRecv;
                break;
            case 5: // 5:doctype
                options_.doctype = strRecv;
                break;
            case 6: // 6:comment
                options_.comment = strRecv;
                break;
            case 7: // 7:parent
                options_.parent = strRecv;
                break;
            case 8: // 8:type
                options_.type = strRecv;
                break;
            case 9: // 9:name
                options_.name = strRecv;
                break;
            case 10: // 10:elements
                options_.elements = strRecv;
                break;
            default:
                break;
        }
    }

    void ConvertXml::DealOptions(napi_env env, const napi_value napiObj)
    {
        std::vector<std::string> vctOptions = {""declarationKey"", ""instructionKey"", ""attributesKey"", ""textKey"",
                                              ""cdataKey"", ""doctypeKey"", ""commentKey"", ""parentKey"", ""typeKey"",
                                              ""nameKey"", ""elementsKey""};
        size_t vctLength = vctOptions.size();
        for (size_t i = 0; i < vctLength; ++i) {
            napi_value recvTemp = nullptr;
            std::string strRecv = """";
            napi_get_named_property(env, napiObj, vctOptions[i].c_str(), &recvTemp);
            if ((DealNapiStrValue(env, recvTemp, strRecv)) == napi_ok) {
                SetDefaultKey(i, strRecv);
            }
        }
        DealIgnore(env, napiObj);
        DealSpaces(env, napiObj);
    }

    void ConvertXml::DealSingleLine(napi_env env, std::string &strXml, const napi_value &object)
    {
        size_t iXml = 0;
        if ((iXml = strXml.find(""xml"")) != std::string::npos) {
            xmlInfo_.bXml = true;
            napi_value declObj = nullptr;
            napi_create_object(env, &declObj);
            napi_value attrObj = nullptr;
            bool bFlag = false;
            napi_create_object(env, &attrObj);
            if (strXml.find(""version="") != std::string::npos) {
                xmlInfo_.bVersion = true;
                SetKeyValue(env, attrObj, ""version"", ""1.0"");
                bFlag = true;
            }
            if (strXml.find(""encoding="") != std::string::npos) {
                xmlInfo_.bEncoding = false;
                SetKeyValue(env, attrObj, ""encoding"", ""utf-8"");
                bFlag = true;
            }
            if (bFlag) {
                napi_set_named_property(env, declObj, options_.attributes.c_str(), attrObj);
                napi_set_named_property(env, object, options_.declaration.c_str(), declObj);
            } else {
                napi_set_named_property(env, object, options_.declaration.c_str(), declObj);
            }
            if (strXml.find("">"", iXml) == strXml.size() - 1) {
                strXml = """";
            } else {
                strXml = strXml.substr(0, strXml.rfind(""<"", iXml)) + strXml.substr(strXml.find("">"", iXml) + 1);
            }
        }
        size_t  [MASK]  = 0;
        size_t iLen = strXml.size();
        for (;  [MASK]  < iLen; ++ [MASK] ) {
            if (strXml[ [MASK] ] != ' ' && strXml[ [MASK] ] != '\v' &&
                strXml[ [MASK] ] != '\t' && strXml[ [MASK] ] != '\n') {
                break;
            }
        }
        if ( [MASK]  < iLen) {
            DealComplex(env, strXml, object);
        }
    }

    void ConvertXml::DealComplex(napi_env env, std::string &strXml, const napi_value &object) const
    {
        if (strXml.find(""<!DOCTYPE"") != std::string::npos) {
            strXml = strXml + ""<node></node>"";
        } else {
            strXml = ""<node>"" + strXml + ""</node>"";
        }
        xmlDocPtr doc = nullptr;
        xmlNodePtr curNode = nullptr;
        size_t len = strXml.size();
        doc = xmlParseMemory(strXml.c_str(), static_cast<int>(len));
        if (!doc) {
            xmlFreeDoc(doc);
        }
        if (doc) {
            curNode = xmlDocGetRootElement(doc);
            curNode = curNode->children;
            napi_value elements = nullptr;
            napi_create_array(env, &elements);
            bool bHasEle = false;
            int index = 0;
            bool bCData = false;
            if (strXml.find(""<![CDATA"") != strXml.rfind(""<![CDATA"")) {
                bCData = true;
            }
            while (curNode != nullptr) {
                napi_value elementsObject = nullptr;
                napi_create_object(env, &elementsObject);
                SetNodeInfo(env, curNode, elementsObject);
                SetXmlElementType(env, curNode, elementsObject, bHasEle);
                SetEndInfo(env, curNode, elementsObject, bHasEle);
                napi_set_element(env, elements, index++, elementsObject);
                DealCDataInfo(bCData, curNode);
            }
            if (bHasEle) {
                napi_set_named_property(env, object, options_.elements.c_str(), elements);
            }
            xmlFreeDoc(doc);
        }
    }

    void ConvertXml::Replace(std::string &str, const std::string src, const std::string dst) const
    {
        size_t index = 0;
        while ((index = str.find(src)) != std::string::npos) {
            str.replace(index, src.size(), dst);
        }
    }

    void ConvertXml::DealCDataInfo(bool bCData, xmlNodePtr &curNode) const
    {
        if (bCData && curNode->type == xmlElementType::XML_CDATA_SECTION_NODE &&
            curNode->next && curNode->next->type == xmlElementType::XML_TEXT_NODE &&
            curNode->next->next && curNode->next->next->type == xmlElementType::XML_CDATA_SECTION_NODE) {
                char *curContent = reinterpret_cast<char*>(xmlNodeGetContent(curNode->next));
                if (curContent != nullptr) {
                    std::string strTemp = reinterpret_cast<char*>(curContent);
                    Replace(strTemp, "" "", """");
                    Replace(strTemp, ""\v"", """");
                    Replace(strTemp, ""\t"", """");
                    Replace(strTemp, ""\n"", """");
                    if (strTemp == """") {
                        curNode = curNode->next->next;
                    }
                    xmlFree(reinterpret_cast<void*>(curContent));
                }
            } else {
                curNode = curNode->next;
            }
    }
} // namespace OHOS::Xml
",iCount
93,"/*!
 * Copyright (c) 2016 Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See LICENSE file in the project root for license information.
 */
#ifndef LIGHTGBM_OBJECTIVE_RANK_OBJECTIVE_HPP_
#define LIGHTGBM_OBJECTIVE_RANK_OBJECTIVE_HPP_

#include <LightGBM/metric.h>
#include <LightGBM/objective_function.h>

#include <limits>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>

namespace LightGBM {
/*!
* \brief Objective function for Lambdrank with NDCG
*/
class LambdarankNDCG: public ObjectiveFunction {
 public:
  explicit LambdarankNDCG(const Config& config) {
    sigmoid_ = static_cast<double>(config.sigmoid);
    label_gain_ = config.label_gain;
    // initialize DCG calculator
    DCGCalculator::DefaultLabelGain(&label_gain_);
    DCGCalculator::Init(label_gain_);
    // will optimize NDCG@optimize_pos_at_
    optimize_pos_at_ = config.max_position;
    sigmoid_table_.clear();
    inverse_max_dcgs_.clear();
    if (sigmoid_ <= 0.0) {
      Log::Fatal(""Sigmoid param %f should be greater than zero"", sigmoid_);
    }
  }

  explicit LambdarankNDCG(const std::vector<std::string>&) {
  }

  ~LambdarankNDCG() {
  }
  void Init(const Metadata& metadata, data_size_t num_data) override {
    num_data_ = num_data;
    // get label
    label_ = metadata.label();
    DCGCalculator::CheckLabel(label_, num_data_);
    // get weights
    weights_ = metadata.weights();
    // get boundries
    query_boundaries_ = metadata.query_boundaries();
    if (query_boundaries_ == nullptr) {
      Log::Fatal(""Lambdarank tasks require query information"");
    }
    num_queries_ = metadata.num_queries();
    // cache inverse max DCG, avoid computation many times
    inverse_max_dcgs_.resize(num_queries_);
#pragma omp parallel for schedule(static)
    for (data_size_t i = 0; i < num_queries_; ++i) {
      inverse_max_dcgs_[i] = DCGCalculator::CalMaxDCGAtK(optimize_pos_at_,
        label_ + query_boundaries_[i],
        query_boundaries_[i + 1] - query_boundaries_[i]);

      if (inverse_max_dcgs_[i] > 0.0) {
        inverse_max_dcgs_[i] = 1.0f / inverse_max_dcgs_[i];
      }
    }
    // construct sigmoid table to speed up sigmoid transform
    ConstructSigmoidTable();
  }

  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
    #pragma omp parallel for schedule(guided)
    for (data_size_t i = 0; i < num_queries_; ++i) {
      GetGradientsForOneQuery(score, gradients, hessians, i);
    }
  }
  // grank with fixed size bucket
  
  inline void GetGradientsForOneQuery(const double* score,
              score_t* lambdas, score_t* hessians, data_size_t query_id) const {
    // get doc boundary for current query
    const data_size_t start = query_boundaries_[query_id];
    const data_size_t cnt =
      query_boundaries_[query_id + 1] - query_boundaries_[query_id];
    // get max DCG on current query
    // const double inverse_max_dcg = inverse_max_dcgs_[query_id];
    // add pointers with offset
    const label_t* label = label_ + start;
    score += start;
    lambdas += start;
    hessians += start;
    // initialize with zero
    for (data_size_t i = 0; i < cnt; ++i) {
      lambdas[i] = 0.0f;
      hessians[i] = 0.0f;
    }
    label_t all_ratings[5];
    label_t worst_label = 5;
    label_t best_label = 0;
    // get sorted indices for scores
    std::vector<data_size_t> sorted_idx;
    for (int i = 0; i < cnt; ++i) {
      sorted_idx.emplace_back(i);
      all_ratings[static_cast<int>(label[i])] = 1;

      if (label[i] < worst_label) {
        worst_label = label[i];
      }
      if (label[i] > best_label) {
        best_label = label[i];
      }      
    }
    // calculate the discount for all ratings
    // if all_ratings[i] == 0, no such rating for this query, discount = 0
    int position = 0;
    for (data_size_t i = 4; i >= 0; --i) {
      if (all_ratings[i]) {
        all_ratings[i] = DCGCalculator::GetDiscount(position);
        position++;
      }
    }
    if (best_label == worst_label) {return; }
    std::stable_sort(sorted_idx.begin(), sorted_idx.end(),
                     [score](data_size_t a, data_size_t b) { return score[a] > score[b]; });
    // get best and worst score
    const double best_score = score[sorted_idx[0]];
    data_size_t  [MASK]  = cnt - 1;
    if ( [MASK]  > 0 && score[sorted_idx[ [MASK] ]] == kMinScore) {
       [MASK]  -= 1;
    }
    const double worst_score = score[sorted_idx[ [MASK] ]];
    // get max DCG on current query
    const double inverse_max_dcg = inverse_max_dcgs_[query_id];
    const int bucket_size = 2;
    const double sigma = 2.0f;

    // start accmulate lambdas by pairs
    for (data_size_t i = 0; i < cnt; ++i) {
      const data_size_t high = sorted_idx[i];
      const int high_label = static_cast<int>(label[high]);
      const double high_score = score[high];
      if (high_score == kMinScore || high_label == worst_label) { continue; }
      const double high_label_gain = label_gain_[high_label];
      const double high_discount = DCGCalculator::GetDiscount(i);
      double exp_high_score = std::exp(sigma * (high_score-best_score));
      double sum_exp_low_score = 0.0;
      double high_sum_lambda = 0.0;
      double high_sum_hessian = 0.0;
      int num_low = 0;
      std::vector<double> sum_exp_low_scores;
      
      for (data_size_t j = 0; j < cnt; ++j) {
        // skip same data
        if (i == j) { continue; }
        const data_size_t low = sorted_idx[j];
        const int low_label = static_cast<int>(label[low]);
        const double low_score = score[low];
        // only consider pair with different label
        if (low_label < high_label && low_score > kMinScore) {
          sum_exp_low_score += std::exp(sigma * (low_score-best_score));
          num_low++;
        }
        if (num_low == bucket_size) {
          sum_exp_low_scores.push_back(sum_exp_low_score);
          sum_exp_low_score = 0.0;
          num_low = 0;
        }
      }
      if (num_low < bucket_size) {
        sum_exp_low_scores.push_back(sum_exp_low_score);
      }
      num_low = 0;
      for (data_size_t j = 0; j < cnt; ++j) {
        // skip same data
        if (i == j) { continue; }
        const data_size_t low = sorted_idx[j];
        const int low_label = static_cast<int>(label[low]);
        const double low_score = score[low];
        // only consider pair with different label
        if (low_label < high_label && low_score > kMinScore)
        { 
          sum_exp_low_score = sum_exp_low_scores.at(num_low / bucket_size);
          num_low++;
          if (sum_exp_low_score == 0.0) {continue; }
          const double low_label_gain = label_gain_[low_label];
          const double low_discount = DCGCalculator::GetDiscount(j);
          // get dcg gap
          const double dcg_gap = high_label_gain - low_label_gain;
          // get discount of this pair
          const double paired_discount = fabs(high_discount - low_discount);
          const double delta_score = high_score - low_score;    
          double sum_exp = exp_high_score + sum_exp_low_score;
          double p_high =  exp_high_score / sum_exp;
          double exp_low_score = std::exp(sigma * (low_score-best_score));
          double p_low =  exp_low_score / sum_exp;                 
          double l_p_lambda = p_low * sigma;//positive
          double l_p_hessian = l_p_lambda * (1 - p_low) * sigma * sigma; 
          double fancy = dcg_gap * paired_discount * inverse_max_dcg;
          // regular the delta_pair_NDCG by score distance
          if (high_label != low_label && best_score != worst_score) {
            fancy /= (0.01f + fabs(delta_score));
          }          
          l_p_lambda *= fancy;
          l_p_hessian *= fancy;
          lambdas[low] += static_cast<score_t>(l_p_lambda);
          hessians[low] += static_cast<score_t>(l_p_hessian);      
          high_sum_lambda += -l_p_lambda;
          high_sum_hessian += l_p_lambda * p_high * sigma * sigma;//positive
        }
      }     
      lambdas[high] += static_cast<score_t>(high_sum_lambda);
      hessians[high] += static_cast<score_t>(high_sum_hessian);
    }
    // if need weights
    if (weights_ != nullptr) {
      for (data_size_t i = 0; i < cnt; ++i) {
        lambdas[i] = static_cast<score_t>(lambdas[i] * weights_[start + i]);
        hessians[i] = static_cast<score_t>(hessians[i] * weights_[start + i]);
      }
    }
  }

  inline double GetSigmoid(double score) const {
    if (score <= min_sigmoid_input_) {
      // too small, use lower bound
      return sigmoid_table_[0];
    } else if (score >= max_sigmoid_input_) {
      // too big, use upper bound
      return sigmoid_table_[_sigmoid_bins - 1];
    } else {
      return sigmoid_table_[static_cast<size_t>((score - min_sigmoid_input_) * sigmoid_table_idx_factor_)];
    }
  }

  void ConstructSigmoidTable() {
    // get boundary
    min_sigmoid_input_ = min_sigmoid_input_ / sigmoid_ / 2;
    max_sigmoid_input_ = -min_sigmoid_input_;
    sigmoid_table_.resize(_sigmoid_bins);
    // get score to bin factor
    sigmoid_table_idx_factor_ =
      _sigmoid_bins / (max_sigmoid_input_ - min_sigmoid_input_);
    // cache
    for (size_t i = 0; i < _sigmoid_bins; ++i) {
      const double score = i / sigmoid_table_idx_factor_ + min_sigmoid_input_;
      sigmoid_table_[i] = 2.0f / (1.0f + std::exp(2.0f * score * sigmoid_));
    }
  }

  const char* GetName() const override {
    return ""lambdarank"";
  }

  std::string ToString() const override {
    std::stringstream str_buf;
    str_buf << GetName();
    return str_buf.str();
  }

  bool NeedAccuratePrediction() const override { return false; }

 private:
  /*! \brief Gains for labels */
  std::vector<double> label_gain_;
  /*! \brief Cache inverse max DCG, speed up calculation */
  std::vector<double> inverse_max_dcgs_;
  /*! \brief Simgoid param */
  double sigmoid_;
  /*! \brief Optimized NDCG@ */
  int optimize_pos_at_;
  /*! \brief Number of queries */
  data_size_t num_queries_;
  /*! \brief Number of data */
  data_size_t num_data_;
  /*! \brief Pointer of label */
  const label_t* label_;
  /*! \brief Pointer of weights */
  const label_t* weights_;
  /*! \brief Query boundries */
  const data_size_t* query_boundaries_;
  /*! \brief Cache result for sigmoid transform to speed up */
  std::vector<double> sigmoid_table_;
  /*! \brief Number of bins in simoid table */
  size_t _sigmoid_bins = 1024 * 1024;
  /*! \brief Minimal input of sigmoid table */
  double min_sigmoid_input_ = -50;
  /*! \brief Maximal input of sigmoid table */
  double max_sigmoid_input_ = 50;
  /*! \brief Factor that covert score to bin in sigmoid table */
  double sigmoid_table_idx_factor_;
};

}  // namespace LightGBM
#endif   // LightGBM_OBJECTIVE_RANK_OBJECTIVE_HPP_
",worst_idx
94,"#include ""CineXDetailCustomization.h""
#include ""PropertyEditing.h""
#include ""Widgets/Input/SButton.h""
#include ""Widgets/Text/STextBlock.h""
#include ""Widgets/Input/SComboButton.h""

TSharedRef<IDetailCustomization> FCineXDetailCustomization::MakeInstance()
{
	return MakeShareable(new FCineXDetailCustomization);
}


void FCineXDetailCustomization::CustomizeDetails(IDetailLayoutBuilder& DetailBuilder)
{
	TSet<UClass*>  [MASK] ;

	TArray<TWeakObjectPtr<UObject>> ObjectsBeingCustomized;
	DetailBuilder.GetObjectsBeingCustomized(/*out*/ ObjectsBeingCustomized);

	for (auto WeakObject : ObjectsBeingCustomized) 
	{
		if (UObject* Instance = WeakObject.Get())
		{
			 [MASK] .Add(Instance->GetClass());
		}
	}

	//Create commands category
	IDetailCategoryBuilder& Category = DetailBuilder.EditCategory(""Connection"");

	//Create button for each element
	for (UClass* Class :  [MASK] )
	{
		for (TFieldIterator<UFunction> FuncIt(Class); FuncIt; ++FuncIt) 
		{
			UFunction* Function = *FuncIt;
			if (Function->HasAnyFunctionFlags(FUNC_Exec) && (Function->NumParms == 0))
			{
				const FString FunctionName = Function->GetName();
				const FText ButtonCaption = FText::FromString(FunctionName);
				Category.AddCustomRow(ButtonCaption)
				.ValueContent()
				[
					SNew(SButton)
					.Text(ButtonCaption)
					.OnClicked(FOnClicked::CreateStatic(&FCineXDetailCustomization::ExecuteCommand, &DetailBuilder, Function))
				];
			}
		}
	}
}

FReply FCineXDetailCustomization::ExecuteCommand(IDetailLayoutBuilder * DetailBuilder, UFunction * MethodToExecute)
{
	TArray<TWeakObjectPtr<UObject>> ObjectsBeingCustomized;
	DetailBuilder->GetObjectsBeingCustomized(/*out*/ ObjectsBeingCustomized);

	for (auto WeakObject : ObjectsBeingCustomized)
	{
		if (UObject* Instance = WeakObject.Get())
		{
			Instance->CallFunctionByNameWithArguments(*MethodToExecute->GetName(), *GLog, nullptr, true);
		}
	}
	
	return FReply::Handled();
}",Classes
95,"#include <math.h>
#include ""Ball.h""
#include ""Paddle.h""

const float defaultVVelocity = 0.002;
const float defaultHVelocity = 0.015;
const float defaultRadius = 0.05;

const float paddleAccelerationFactor = 0.3;

const float twoPi = 3.14159*2;

Ball::Ball(int triangleCount)
{
    m_triangleCount = triangleCount;
    reset();
}

void Ball::tick()
{
    m_x += m_vx;
    m_y += m_vy;

    bounceVertically();
}

void Ball::reset()
{
    m_x = 0;
    m_y = 0;
    m_vx = defaultHVelocity;
    m_vy = defaultVVelocity;
    m_r = defaultRadius;
}

void Ball::collideWithPaddle(Paddle paddle)
{
    Paddle::Coords paddleCoords = paddle.getCoords();
    float x = m_vx > 0 ? paddleCoords.x1 : paddleCoords.x2;
    float y_top = paddleCoords.y1;
    float y_bot = paddleCoords.y2;

    // miss: do nothing, avoid calculations below
    if (y_top < m_y - m_r || y_bot > m_y + m_r)
        return;

    // Can only collide if the x-position is within the ball's range
    if (x >= m_x - m_r && x <= m_x + m_r)
    {
        // flat bounce, just reverse horizontal velocity
        if (m_y <= y_top && m_y >=y_bot)
        {
            m_vx = -m_vx;
            addPaddleVelocity(paddle.getVelocity());
        }
        else if (collidesWith(x, y_top))
        {
            bounceOnPoint(x, y_top);
            addPaddleVelocity(paddle.getVelocity());
        }
        else if (collidesWith(x, y_bot))
        {
            bounceOnPoint(x, y_bot);
            addPaddleVelocity(paddle.getVelocity());
        }
    }
}

void Ball::addPaddleVelocity(float paddleVelocity)
{
    m_vy += paddleAccelerationFactor * paddleVelocity;
}

bool Ball::collidesWith(float x, float y)
{
    return pow(x - m_x, 2) + pow(y - m_y, 2) <= pow(m_r, 2);
}

void Ball::bounceOnPoint(float x, float y)
{
    // angle is from contact point to ball
    float angle = atan2(m_y- y, m_x - x);

    // maintain the same total velocity along the new angle:
    // todo: add paddle speed component?
    float  [MASK]  = sqrt(pow(m_vy, 2) + pow(m_vx, 2));
    m_vx =  [MASK]  * cos(angle);
    m_vy =  [MASK]  * sin(angle);
}

bool Ball::touches(float x)
{
    return m_x - m_r <= x &&  m_x + m_r >= x;
}

void Ball::bounceVertically()
{
    if (m_y + m_r >= 1 || m_y- m_r <= -1)
    {
        m_vy = -m_vy;
    }
}

void Ball::assignIndices(int * index, unsigned int * indexArray, unsigned int vertexOffset)
{
    for (int j = 0; j < m_triangleCount; j++)
    {
        indexArray[(*index)++] = vertexOffset;
        indexArray[(*index)++] = vertexOffset + j;
        indexArray[(*index)++] = vertexOffset + j + 1;
    }
    // the final triangle index should be the first vertex on the circle of the ball
    indexArray[(*index) - 1] = vertexOffset + 1;
}

void Ball::assignVertices(int * index, float * vertexArray)
{
    vertexArray[(*index)++] = m_x;
    vertexArray[(*index)++] = m_y;

    for (int j = 0; j < m_triangleCount; j++)
    {
        vertexArray[(*index)++] = m_x + (m_r * cos(j * twoPi / m_triangleCount));
        vertexArray[(*index)++] = m_y + (m_r * sin(j * twoPi / m_triangleCount));
    }
}

",current_velocity
96,"#ifdef _WIN32
#include <Windows.h>
#else
#include <unistd.h>
#endif

#include <iostream>
#include <limits>
#include <thread>



#include ""config.hpp""
#include ""Terrain.hpp""
#include ""Drone.hpp""

#include ""Menu.hpp""
#include ""Scene.hpp""



bool DISPLAY = true;

enum Draw{
    goToDraw
};


int main() {
    {
    bool finish = false;
    /* -------------------------------------------------------------------------- */
    /*                              INIT INFORMATIONS                             */
    /* -------------------------------------------------------------------------- */

    std::cout << ""Project Rotation 3D based on C++ Boiler Plate by <NAME> v""
              << PROJECT_VERSION_MAJOR /*duże zmiany, najczęściej brak kompatybilności wstecz */
              << "".""
              << PROJECT_VERSION_MINOR /* istotne zmiany */
              << "".""
              << PROJECT_VERSION_PATCH /* naprawianie bugów */
              << "".""
              << PROJECT_VERSION_TWEAK /* zmiany estetyczne itd. */
              << std::endl;
    std::system(""cat ./LICENSE"");
    std::system(""pwd"");
    std::cout << ""Press enter to start..."" << std::endl
              << std::endl
              << std::endl;
    std::cin.ignore(std::numeric_limits<int>().max(), '\n');

    /* -------------------------------------------------------------------------- */
    /*                              CREATING FIGURES                              */
    /* -------------------------------------------------------------------------- */

    Scene scene;
    std::thread displaying([&scene, &finish]() {
        auto start = std::chrono::high_resolution_clock::now();
        while(!finish){
            auto measure = std::chrono::high_resolution_clock::now();
            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(measure - start);
            try{
                if(elapsed.count() >= (100)){
                    start = std::chrono::high_resolution_clock::now();
                    throw Draw::goToDraw;
                }

            }
            catch(Draw){
                scene.Update();
                // std::cout << ""\n\nCounting Vectors..."" << std::endl;

                // std::cout << ""==========================================="" << std::endl;
                // std::cout << std::setw(35) << ""Number of Vectors on Scene: "" << std::setw(10) << Vector3::HowManyObjects() << std::endl;
                // std::cout << std::setw(35) << ""Number of Vectors from start: "" << std::setw(10) << Vector3::AllHowManyObjects() << std::endl;
                // std::cout << ""==========================================="" << std::endl
                //           << std::endl
                //           << std::endl;
            }
        }
    });
        

    std::shared_ptr<Drone> drone;

    std::shared_ptr<Terrain> floor = std::make_shared<Terrain>();
    scene.Add(std::move (floor));

    /* -------------------------------------------------------------------------- */
    /*                              MENU CONSTRUCTOR                              */
    /* -------------------------------------------------------------------------- */
    
    std::vector<MatrixRot> rotationSequece;
    Menu menu({{""Print informations about selected object: "",
                [&drone]() mutable
                {
                    if (drone == nullptr)
                        throw std::logic_error(""Did not choosed the active object."");
                    std::cout << drone->SeflID() << "" "" << drone->Name() << std::endl;
                    std::cout << ""position: \n""
                              << drone->position
                              << ""\neuler anglesRPY: \n""
                              << drone->anglesRPY
                              << ""\nrotation Matrix: \n""
                              << drone->orientation;
                }},
               {""Add Drone: "",
                [&scene]()
                {
                    std::cout << ""Where spawn drone Vector3: \n"";
                    Vector3 pos;
                    std::cin >> pos;
                    std::shared_ptr<Drone>  [MASK]  = std::make_shared<Drone>(pos);
                    scene.Add(std::move( [MASK] ));
                }},
               {""Choose active drone: "", [&drone, &scene]()
                {
                    // std::cout << ""There are "" << scene.CountObjects() << "" on scene. Type number. 1 - n"" << std::endl;
                    int d = 1;
                    for (std::size_t i = 0; i < scene.CountObjects(); ++i)
                    {
                        auto localPtr = std::dynamic_pointer_cast<Drone>(scene[i]);
                        if (localPtr != nullptr)
                        {
                            if (localPtr == drone)
                                std::cout << ""* "";
                            else
                                std::cout << ""  "";
                            std::cout << d++ << "" Drone is on position:  "" << localPtr->position << std::endl;
                        }
                    }
                    std::cout << ""Type number of Drone"" << std::endl;
                    std::size_t k = 1;
                    std::cin >> k;
                    drone->ChangeColor(1);
                    drone = std::dynamic_pointer_cast<Drone>(scene.SelectDrone(k));
                    drone->ChangeColor(2);
                }},
               {""Move drone"", [&drone]()
                {
                    if (drone == nullptr)
                        throw std::logic_error(""Did not choosed the active object."");
                    std::cout << ""Type height, angle and length of move."" << std::endl;
                    Vector3 pos;
                    std::cin >> pos;
                    if(pos[0] != 0)
                        drone->moves.push([pos, drone]()
                                        { drone->GoVerdical(pos[0] ); });
                    if (pos[1] != 0)
                        drone->moves.push([pos, drone]()
                                          { drone->Right(pos[1]); });
                    if (pos[2] != 0)
                        drone->moves.push([pos, drone]()
                                          { drone->Forward(pos[2]); });
                    if (pos[0] != 0)
                        drone->moves.push([pos, drone]()
                                          { drone->GoVerdical(pos[0] * -1); });


                    drone->MakeRoute(pos[0], pos[1], pos[2]);
                }},
               {""Recognize flight"", [&drone]()
                {
                    if (drone == nullptr)
                        throw std::logic_error(""Did not choosed the active object."");
                    std::cout << ""Type height, angle and length of move."" << std::endl;
                    drone->moves.push([&drone]()
                                    { drone->GoVerdical(150); });
                    for (int i = 0; i < 30; ++i){
                        drone->moves.push([drone]()
                                          {
                                              drone->Right(360 / 20);
                                              drone->Forward(10);
                                          });

                    }
                        drone->moves.push([ drone]()
                                          { drone->GoVerdical(150 * -1); });

                    // drone->MakeRoute(pos[0], pos[1], pos[2]);
                }},
               {""Exit"", [&finish, &scene]()
                {
                    finish = true;
                    throw std::logic_error(""Exit"");
                }}});

    scene.Add(std::move(std::make_shared<Drone>(Vector3({200, 200, 0}))));
    scene.Add(std::move(std::make_shared<Drone>(Vector3({200, -200, 0}))));
    drone =  std::dynamic_pointer_cast<Drone>(scene.SelectDrone(1));
    drone->ChangeColor(2);

    /* -------------------------------------------------------------------------- */
    /*                                  MAIN LOOP                                 */
    /* -------------------------------------------------------------------------- */
    std::thread menuig([&menu, &drone, &finish, &scene]() {
        while (!finish) {
            std::cout << ""\n\nCounting Vectors..."" << std::endl;

            std::cout << ""==========================================="" << std::endl;
            std::cout << std::setw(35) << ""Number of Vectors on Scene: "" << std::setw(10) << Vector3::HowManyObjects() << std::endl;
            std::cout << std::setw(35) << ""Number of Vectors from start: "" << std::setw(10) << Vector3::AllHowManyObjects() << std::endl;
            std::cout << ""==========================================="" << std::endl
                      << std::endl
                      << std::endl;
            std::cout << menu;
            try {
               
               

                std::cin >> menu;
            } catch (std::logic_error &e) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<int>().max(), '\n');
                if(std::string(e.what()) == ""Exit""){
                    scene.~Scene();

                    finish = true;
                }else{
                    std::cerr << std::endl
                              << std::endl
                              << ""!!![ERROR]!!!"" << std::endl;
                    std::cerr << e.what() << std::endl
                              << std::endl;
                }
                
                
            }
            catch (...) {
                std::cerr << ""Fatal error, cautch ununderstable throw!!!"" << std::endl;
                scene.~Scene();
                exit(-1);
            }
        }
        
    });

    displaying.join();
    menuig.join();
}
    std::cout << ""==========================================="" << std::endl;
    std::cout << std::setw(35) << ""Number of Vectors on Scene: "" << std::setw(10) << Vector3::HowManyObjects() << std::endl;
    std::cout << std::setw(35) << ""Number of Vectors from start: "" << std::setw(10) << Vector3::AllHowManyObjects() << std::endl;
    std::cout << ""==========================================="" << std::endl;

    return 0;
}",tmp
97,"
/*****************************************************************************
* Copyright [2017-2019] [MTSQuant]
*
* 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 ""./Currency.h""
#include <QtCore/QHash>
#include <QtCore/QString>

const char * currencyIdName(CurrencyId currency) {
	static const char* names[] = {
		CURRENCY_ID_ENUM(SELECT_2_AND_COMMA_IN_3)
	};
	if (currency >= 0 && currency < ARRAY_SIZE(names)) {
		return names[currency];
	} else {
		return names[0];
	}
}

CurrencyId currencyId(const char * currencyName) {
	static QHash<QString, CurrencyId>  [MASK] ;
	if ( [MASK] .isEmpty()) {
		CURRENCY_ID_ENUM(DEFINE_NAME_ENUM_MAP3_KEY_2);
	}
	return  [MASK] [currencyName];
	return CurrencyId();
}

",map
98,"// Copyright (c) 2022 Samsung Research America
//
// 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 <algorithm>
#include <string>
#include <limits>
#include <memory>
#include <vector>
#include <utility>

#include ""regulated_fuzzy_logic_controller/parameter_handler.hpp""

namespace regulated_fuzzy_logic_controller
{

using nav2_util::declare_parameter_if_not_declared;
using rcl_interfaces::msg::ParameterType;

ParameterHandler::ParameterHandler(
  rclcpp_lifecycle::LifecycleNode::SharedPtr node,
  std::string & plugin_name, rclcpp::Logger & logger,
  const double /*costmap_size_x*/)
{
  plugin_name_ = plugin_name;
  logger_ = logger;

  declare_parameter_if_not_declared(node, plugin_name_ + "".desired_linear_vel"", rclcpp::ParameterValue(0.5));
  declare_parameter_if_not_declared(node, plugin_name_ + "".lookahead_dist"", rclcpp::ParameterValue(0.6));
  declare_parameter_if_not_declared(node, plugin_name_ + "".min_lookahead_dist"", rclcpp::ParameterValue(0.3));
  declare_parameter_if_not_declared(node, plugin_name_ + "".max_lookahead_dist"", rclcpp::ParameterValue(0.9));
  declare_parameter_if_not_declared(node, plugin_name_ + "".lookahead_time"", rclcpp::ParameterValue(1.5));
  declare_parameter_if_not_declared(node, plugin_name_ + "".use_interpolation"", rclcpp::ParameterValue(true));

  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NL_MIN"", rclcpp::ParameterValue(-3.15));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NL_MED"", rclcpp::ParameterValue(-3.0));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NL_MAX"", rclcpp::ParameterValue(-2.8));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NM_MIN"", rclcpp::ParameterValue(-2.8));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NM_MED"", rclcpp::ParameterValue(-1.9));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NM_MAX"", rclcpp::ParameterValue(-1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_N_MIN"", rclcpp::ParameterValue(-1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_N_MED"", rclcpp::ParameterValue(-0.9));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_N_MAX"", rclcpp::ParameterValue(-0.6));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NS_MIN"", rclcpp::ParameterValue(-0.6));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NS_MED"", rclcpp::ParameterValue(-0.5));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_NS_MAX"", rclcpp::ParameterValue(-0.4));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_ZN_MIN"", rclcpp::ParameterValue(-0.4));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_ZN_MED"", rclcpp::ParameterValue(-0.25));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_ZN_MAX"", rclcpp::ParameterValue(-0.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_Z_MIN"", rclcpp::ParameterValue(-0.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_Z_MED"", rclcpp::ParameterValue(0.0)); //----------------------
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_Z_MAX"", rclcpp::ParameterValue(0.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_ZP_MIN"", rclcpp::ParameterValue(0.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_ZP_MED"", rclcpp::ParameterValue(0.25));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_ZP_MAX"", rclcpp::ParameterValue(0.4));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PS_MIN"", rclcpp::ParameterValue(0.4));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PS_MED"", rclcpp::ParameterValue(0.5));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PS_MAX"", rclcpp::ParameterValue(0.6));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_P_MIN"", rclcpp::ParameterValue(0.6));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_P_MED"", rclcpp::ParameterValue(0.9));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_P_MAX"", rclcpp::ParameterValue(1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PM_MIN"", rclcpp::ParameterValue(1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PM_MED"", rclcpp::ParameterValue(1.9));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PM_MAX"", rclcpp::ParameterValue(2.8));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PL_MIN"", rclcpp::ParameterValue(2.8));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PL_MED"", rclcpp::ParameterValue(3.0));
  declare_parameter_if_not_declared(node, plugin_name_ + "".INPUT_PL_MAX"", rclcpp::ParameterValue(3.15));

  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_S_MIN"", rclcpp::ParameterValue(0.0));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_S_MED"", rclcpp::ParameterValue(0.035));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_S_MAX"", rclcpp::ParameterValue(0.07));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_M_MIN"", rclcpp::ParameterValue(0.06));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_M_MED"", rclcpp::ParameterValue(0.095));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_M_MAX"", rclcpp::ParameterValue(0.15));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_L_MIN"", rclcpp::ParameterValue(0.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_L_MED"", rclcpp::ParameterValue(0.15));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_L_MAX"", rclcpp::ParameterValue(0.2));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_VL_MIN"", rclcpp::ParameterValue(0.19));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_VL_MED"", rclcpp::ParameterValue(0.22));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_LIN_VL_MAX"", rclcpp::ParameterValue(0.26));

  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NL_MIN"", rclcpp::ParameterValue(-1.82));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NL_MED"", rclcpp::ParameterValue(-1.5));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NL_MAX"", rclcpp::ParameterValue(-1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NM_MIN"", rclcpp::ParameterValue(-1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NM_MED"", rclcpp::ParameterValue(-0.8));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NM_MAX"", rclcpp::ParameterValue(-0.52));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_N_MIN"", rclcpp::ParameterValue(-0.52));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_N_MED"", rclcpp::ParameterValue(-0.39));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_N_MAX"", rclcpp::ParameterValue(-0.28));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NS_MIN"", rclcpp::ParameterValue(-0.28));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NS_MED"", rclcpp::ParameterValue(-0.21));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_NS_MAX"", rclcpp::ParameterValue(-0.13));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_ZN_MIN"", rclcpp::ParameterValue(-0.13));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_ZN_MED"", rclcpp::ParameterValue(-0.08));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_ZN_MAX"", rclcpp::ParameterValue(-0.017));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_Z_MIN"", rclcpp::ParameterValue(-0.017));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_Z_MED"", rclcpp::ParameterValue(0.0)); //----------------------
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_Z_MAX"", rclcpp::ParameterValue(0.017));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_ZP_MIN"", rclcpp::ParameterValue(0.017));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_ZP_MED"", rclcpp::ParameterValue(0.08));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_ZP_MAX"", rclcpp::ParameterValue(0.13));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PS_MIN"", rclcpp::ParameterValue(0.13));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PS_MED"", rclcpp::ParameterValue(0.21));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PS_MAX"", rclcpp::ParameterValue(0.28));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_P_MIN"", rclcpp::ParameterValue(0.28));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_P_MED"", rclcpp::ParameterValue(0.39));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_P_MAX"", rclcpp::ParameterValue(0.52));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PM_MIN"", rclcpp::ParameterValue(0.52));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PM_MED"", rclcpp::ParameterValue(0.8));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PM_MAX"", rclcpp::ParameterValue(1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PL_MIN"", rclcpp::ParameterValue(1.1));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PL_MED"", rclcpp::ParameterValue(1.5));
  declare_parameter_if_not_declared(node, plugin_name_ + "".OUTPUT_ANG_PL_MAX"", rclcpp::ParameterValue(1.82));

  node->get_parameter(plugin_name_ + "".desired_linear_vel"", params_.desired_linear_vel);
  params_.base_desired_linear_vel = params_.desired_linear_vel;
  node->get_parameter(plugin_name_ + "".lookahead_dist"", params_.lookahead_dist);
  node->get_parameter(plugin_name_ + "".min_lookahead_dist"", params_.min_lookahead_dist);
  node->get_parameter(plugin_name_ + "".max_lookahead_dist"", params_.max_lookahead_dist);
  node->get_parameter(plugin_name_ + "".lookahead_time"", params_.lookahead_time);
  node->get_parameter(plugin_name_ + "".use_interpolation"", params_.use_interpolation);

  node->get_parameter(plugin_name_ + "".INPUT_NL_MIN"", params_.INPUT_NL_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_NL_MED"", params_.INPUT_NL_MED);
  node->get_parameter(plugin_name_ + "".INPUT_NL_MAX"", params_.INPUT_NL_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_NM_MIN"", params_.INPUT_NM_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_NM_MED"", params_.INPUT_NM_MED);
  node->get_parameter(plugin_name_ + "".INPUT_NM_MAX"", params_.INPUT_NM_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_N_MIN"", params_.INPUT_N_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_N_MED"", params_.INPUT_N_MED);
  node->get_parameter(plugin_name_ + "".INPUT_N_MAX"", params_.INPUT_N_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_NS_MIN"", params_.INPUT_NS_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_NS_MED"", params_.INPUT_NS_MED);
  node->get_parameter(plugin_name_ + "".INPUT_NS_MAX"", params_.INPUT_NS_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_ZN_MIN"", params_.INPUT_ZN_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_ZN_MED"", params_.INPUT_ZN_MED);
  node->get_parameter(plugin_name_ + "".INPUT_ZN_MAX"", params_.INPUT_ZN_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_Z_MIN"", params_.INPUT_Z_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_Z_MED"", params_.INPUT_Z_MED);
  node->get_parameter(plugin_name_ + "".INPUT_Z_MAX"", params_.INPUT_Z_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_ZP_MIN"", params_.INPUT_ZP_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_ZP_MED"", params_.INPUT_ZP_MED);
  node->get_parameter(plugin_name_ + "".INPUT_ZP_MAX"", params_.INPUT_ZP_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_PS_MIN"", params_.INPUT_PS_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_PS_MED"", params_.INPUT_PS_MED);
  node->get_parameter(plugin_name_ + "".INPUT_PS_MAX"", params_.INPUT_PS_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_P_MIN"", params_.INPUT_P_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_P_MED"", params_.INPUT_P_MED);
  node->get_parameter(plugin_name_ + "".INPUT_P_MAX"", params_.INPUT_P_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_PM_MIN"", params_.INPUT_PM_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_PM_MED"", params_.INPUT_PM_MED);
  node->get_parameter(plugin_name_ + "".INPUT_PM_MAX"", params_.INPUT_PM_MAX);
  node->get_parameter(plugin_name_ + "".INPUT_PL_MIN"", params_.INPUT_PL_MIN);
  node->get_parameter(plugin_name_ + "".INPUT_PL_MED"", params_.INPUT_PL_MED);
  node->get_parameter(plugin_name_ + "".INPUT_PL_MAX"", params_.INPUT_PL_MAX);

  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_S_MIN"", params_.OUTPUT_LIN_S_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_S_MED"", params_.OUTPUT_LIN_S_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_S_MAX"", params_.OUTPUT_LIN_S_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_M_MIN"", params_.OUTPUT_LIN_M_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_M_MED"", params_.OUTPUT_LIN_M_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_M_MAX"", params_.OUTPUT_LIN_M_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_L_MIN"", params_.OUTPUT_LIN_L_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_L_MED"", params_.OUTPUT_LIN_L_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_L_MAX"", params_.OUTPUT_LIN_L_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_VL_MIN"", params_.OUTPUT_LIN_VL_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_VL_MED"", params_.OUTPUT_LIN_VL_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_LIN_VL_MAX"", params_.OUTPUT_LIN_VL_MAX);

  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NL_MIN"", params_.OUTPUT_ANG_NL_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NL_MED"", params_.OUTPUT_ANG_NL_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NL_MAX"", params_.OUTPUT_ANG_NL_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NM_MIN"", params_.OUTPUT_ANG_NM_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NM_MED"", params_.OUTPUT_ANG_NM_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NM_MAX"", params_.OUTPUT_ANG_NM_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_N_MIN"", params_.OUTPUT_ANG_N_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_N_MED"", params_.OUTPUT_ANG_N_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_N_MAX"", params_.OUTPUT_ANG_N_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NS_MIN"", params_.OUTPUT_ANG_NS_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NS_MED"", params_.OUTPUT_ANG_NS_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_NS_MAX"", params_.OUTPUT_ANG_NS_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_ZN_MIN"", params_.OUTPUT_ANG_ZN_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_ZN_MED"", params_.OUTPUT_ANG_ZN_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_ZN_MAX"", params_.OUTPUT_ANG_ZN_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_Z_MIN"", params_.OUTPUT_ANG_Z_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_Z_MED"", params_.OUTPUT_ANG_Z_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_Z_MAX"", params_.OUTPUT_ANG_Z_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_ZP_MIN"", params_.OUTPUT_ANG_ZP_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_ZP_MED"", params_.OUTPUT_ANG_ZP_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_ZP_MAX"", params_.OUTPUT_ANG_ZP_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PS_MIN"", params_.OUTPUT_ANG_PS_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PS_MED"", params_.OUTPUT_ANG_PS_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PS_MAX"", params_.OUTPUT_ANG_PS_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_P_MIN"", params_.OUTPUT_ANG_P_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_P_MED"", params_.OUTPUT_ANG_P_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_P_MAX"", params_.OUTPUT_ANG_P_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PM_MIN"", params_.OUTPUT_ANG_PM_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PM_MED"", params_.OUTPUT_ANG_PM_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PM_MAX"", params_.OUTPUT_ANG_PM_MAX);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PL_MIN"", params_.OUTPUT_ANG_PL_MIN);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PL_MED"", params_.OUTPUT_ANG_PL_MED);
  node->get_parameter(plugin_name_ + "".OUTPUT_ANG_PL_MAX"", params_.OUTPUT_ANG_PL_MAX);
}

rcl_interfaces::msg::SetParametersResult
ParameterHandler::dynamicParametersCallback(
  std::vector<rclcpp::Parameter>  [MASK] )
{
  rcl_interfaces::msg::SetParametersResult result;
  std::lock_guard<std::mutex> lock_reinit(mutex_);

  for (auto parameter :  [MASK] ) {
    const auto & type = parameter.get_type();
    const auto & name = parameter.get_name();

    if (type == ParameterType::PARAMETER_DOUBLE) {
      if (name == plugin_name_ + "".desired_linear_vel"") {
        params_.desired_linear_vel = parameter.as_double();
        params_.base_desired_linear_vel = parameter.as_double();
      } else if (name == plugin_name_ + "".lookahead_dist"") {
        params_.lookahead_dist = parameter.as_double();
      } else if (name == plugin_name_ + "".max_lookahead_dist"") {
        params_.max_lookahead_dist = parameter.as_double();
      } else if (name == plugin_name_ + "".lookahead_time"") {
        params_.lookahead_time = parameter.as_double();

      } else if (name == plugin_name_ + "".INPUT_NL_MIN"") {
        params_.INPUT_NL_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NL_MED"") {
        params_.INPUT_NL_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NL_MAX"") {
        params_.INPUT_NL_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NM_MIN"") {
        params_.INPUT_NM_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NM_MED"") {
        params_.INPUT_NM_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NM_MAX"") {
        params_.INPUT_NM_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_N_MIN"") {
        params_.INPUT_N_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_N_MED"") {
        params_.INPUT_N_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_N_MAX"") {
        params_.INPUT_N_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NS_MIN"") {
        params_.INPUT_NS_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NS_MED"") {
        params_.INPUT_NS_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_NS_MAX"") {
        params_.INPUT_NS_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_ZN_MIN"") {
        params_.INPUT_ZN_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_ZN_MED"") {
        params_.INPUT_ZN_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_ZN_MAX"") {
        params_.INPUT_ZN_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_Z_MIN"") {
        params_.INPUT_Z_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_Z_MED"") { //----------------
        params_.INPUT_Z_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_Z_MAX"") {
        params_.INPUT_Z_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_ZP_MIN"") {
        params_.INPUT_ZP_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_ZP_MED"") {
        params_.INPUT_ZP_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_ZP_MAX"") {
        params_.INPUT_ZP_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PS_MIN"") {
        params_.INPUT_PS_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PS_MED"") {
        params_.INPUT_PS_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PS_MAX"") {
        params_.INPUT_PS_MAX = parameter.as_double(); 
      } else if (name == plugin_name_ + "".INPUT_P_MIN"") {
        params_.INPUT_P_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_P_MED"") {
        params_.INPUT_P_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_P_MAX"") {
        params_.INPUT_P_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PM_MIN"") {
        params_.INPUT_PM_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PM_MED"") {
        params_.INPUT_PM_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PM_MAX"") {
        params_.INPUT_PM_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PL_MIN"") {
        params_.INPUT_PL_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PL_MED"") {
        params_.INPUT_PL_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".INPUT_PL_MAX"") {
        params_.INPUT_PL_MAX = parameter.as_double();
      }

      else if (name == plugin_name_ + "".OUTPUT_LIN_S_MIN"") {
        params_.OUTPUT_LIN_S_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_S_MED"") {
        params_.OUTPUT_LIN_S_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_S_MAX"") {
        params_.OUTPUT_LIN_S_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_M_MIN"") {
        params_.OUTPUT_LIN_M_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_M_MED"") {
        params_.OUTPUT_LIN_M_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_M_MAX"") {
        params_.OUTPUT_LIN_M_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_L_MIN"") {
        params_.OUTPUT_LIN_L_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_L_MED"") {
        params_.OUTPUT_LIN_L_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_L_MAX"") {
        params_.OUTPUT_LIN_L_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_VL_MIN"") {
        params_.OUTPUT_LIN_VL_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_VL_MED"") {
        params_.OUTPUT_LIN_VL_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_LIN_VL_MAX"") {
        params_.OUTPUT_LIN_VL_MAX = parameter.as_double();
      }
     
      else if (name == plugin_name_ + "".OUTPUT_ANG_NL_MIN"") {
        params_.OUTPUT_ANG_NL_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NL_MED"") {
        params_.OUTPUT_ANG_NL_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NL_MAX"") {
        params_.OUTPUT_ANG_NL_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NM_MIN"") {
        params_.OUTPUT_ANG_NM_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NM_MED"") {
        params_.OUTPUT_ANG_NM_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NM_MAX"") {
        params_.OUTPUT_ANG_NM_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_N_MIN"") {
        params_.OUTPUT_ANG_N_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_N_MED"") {
        params_.OUTPUT_ANG_N_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_N_MAX"") {
        params_.OUTPUT_ANG_N_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NS_MIN"") {
        params_.OUTPUT_ANG_NS_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NS_MED"") {
        params_.OUTPUT_ANG_NS_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_NS_MAX"") {
        params_.OUTPUT_ANG_NS_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_ZN_MIN"") {
        params_.OUTPUT_ANG_ZN_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_ZN_MED"") {
        params_.OUTPUT_ANG_ZN_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_ZN_MAX"") {
        params_.OUTPUT_ANG_ZN_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_Z_MIN"") {
        params_.OUTPUT_ANG_Z_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_Z_MED"") { //----------------
        params_.OUTPUT_ANG_Z_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_Z_MAX"") {
        params_.OUTPUT_ANG_Z_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_ZP_MIN"") {
        params_.OUTPUT_ANG_ZP_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_ZP_MED"") {
        params_.OUTPUT_ANG_ZP_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_ZP_MAX"") {
        params_.OUTPUT_ANG_ZP_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PS_MIN"") {
        params_.OUTPUT_ANG_PS_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PS_MED"") {
        params_.OUTPUT_ANG_PS_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PS_MAX"") {
        params_.OUTPUT_ANG_PS_MAX = parameter.as_double(); 
      } else if (name == plugin_name_ + "".OUTPUT_ANG_P_MIN"") {
        params_.OUTPUT_ANG_P_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_P_MED"") {
        params_.OUTPUT_ANG_P_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_P_MAX"") {
        params_.OUTPUT_ANG_P_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PM_MIN"") {
        params_.OUTPUT_ANG_PM_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PM_MED"") {
        params_.OUTPUT_ANG_PM_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PM_MAX"") {
        params_.OUTPUT_ANG_PM_MAX = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PL_MIN"") {
        params_.OUTPUT_ANG_PL_MIN = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PL_MED"") {
        params_.OUTPUT_ANG_PL_MED = parameter.as_double();
      } else if (name == plugin_name_ + "".OUTPUT_ANG_PL_MAX"") {
        params_.OUTPUT_ANG_PL_MAX = parameter.as_double();
      }
    } else if (type == ParameterType::PARAMETER_BOOL) {
      continue;
    }
  }

  /*

*/

  result.successful = true;
  return result;
}

}  // namespace regulated_fuzzy_logic_controller

",parameters
99,"#include ""image.h""

namespace {

constexpr int PERCENTS_MIN_LIGHTER = -99;
constexpr int PERCENTS_MIN = -100;
constexpr int PERCENTS_MAX = 100;
constexpr int PERCENTS_TO_LIGHTER_OFFSET = 100;

}

Image::Image() {}

void Image::load(const QString& filename) {
    if (filename.isEmpty()) {
        m_source = {};
        m_brightened = {};

        return;
    }
    Q_ASSERT(m_source.load(filename));
    m_brightened = m_source.convertToFormat(QImage::Format_RGBA8888,
     Qt::ColorOnly);
}

void Image::set_brightness(int  [MASK] ) {
    Q_ASSERT(PERCENTS_MIN <=  [MASK]  <= PERCENTS_MAX);

    if (m_source.isNull())
        return;

    for (int y = 0; y < m_source.height(); y++) {
        for (int x= 0; x < m_source.width(); x++) {
            QColor color = m_source.pixelColor(x, y);

            m_brightened.setPixelColor(x, y,
                color.lighter(
                 qBound(PERCENTS_MIN_LIGHTER,  [MASK] , PERCENTS_MAX)
                 + PERCENTS_TO_LIGHTER_OFFSET
                )
            );
        }
    }
}

QPixmap Image::get_pixmap() const {
    return m_brightened.isNull() ? QPixmap{} : QPixmap::fromImage(m_brightened);
}
",percents
100,"#include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>

#include ""backend.h""
#include ""status.h""


namespace mlperf_bench {

Backend::Backend() {
    allocator_ = allocator_info_;
};

Status Backend::LoadModel(std::string path, std::vector<std::string> outputs) {
#ifdef _WIN32
    std::wstring widestr = std::wstring(path.begin(), path.end());
    session_ = new Ort::Session(env_, widestr.c_str(), opt_);
#else
    session_ = new Ort::Session(env_, path.c_str(), opt_);
#endif
    for (size_t i = 0; i < this->session_->GetInputCount(); i++) {
        input_names_.push_back(session_->GetInputName(i, allocator_));
        auto ti = session_->GetInputTypeInfo(i).GetTensorTypeAndShapeInfo();
        auto input_type = ti.GetElementType();

        // FIXME: ti.GetElementType() returns junk on linux. Hack it for now.
        if (path.find(""ssd"") != std::string::npos) {
            input_type = ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8;
        }
        else {
            input_type = ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT;
        }
        input_type_.push_back(input_type);
    }
    for (size_t i = 0; i < this->session_->GetOutputCount(); i++) {
        char* name = session_->GetOutputName(i, allocator_);
        if (outputs.size() == 0 ||
            std::find(outputs.begin(), outputs.end(), name) != outputs.end()) {
            auto ti = session_->GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo();
            auto shape = ti.GetShape();
            output_shapes_.push_back(shape);
            output_names_.push_back(name);
        }
    }
    return Status::OK();
}

std::vector<Ort::Value> Backend::Run(Ort::Value* inputs, size_t input_count) {
    std::vector<Ort::Value>  [MASK]  =
        session_->Run(run_options_, input_names_.data(), inputs, 1,
                      output_names_.data(), output_names_.size());
    return  [MASK] ;
}

}
",results
101,"#include <Arduino.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into pin 2 on the Arduino
#define ONE_WIRE_BUS D4
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(115200); //Begin serial communication
  Serial.println(""Arduino Digital Temperature // Serial Monitor Version""); //Print a message
  sensors.begin();
  sensors.setResolution(12);
}

void loop() {
  // Send the command to get temperatures
  sensors.requestTemperatures();  
  Serial.print(""Temperature is: "");
  Serial.println(sensors.getTempCByIndex(0));
  DeviceAddress  [MASK] ={0,0,0,0,0,0,0,0};
  sensors.getAddress( [MASK] , 0);
  for (unsigned i=0; i<sizeof( [MASK] ); ++i) {
    Serial.print( [MASK] [i]/16, HEX);
    Serial.print( [MASK] [i]&15, HEX);
  }
  Serial.println();
  //Update value every 1 sec.
  delay(1000);
}
",address
102,"// =====================================================
// ___       ___
//  |  |__| |__
//  |  |  | |___
//
// ___       __         __   __                 __   __
//  |  |__| /  \  |\/| /__` /  \ |\ |     |\/| /  \ /__
//  |  |  | \__/  |  | .__/ \__/ | \|     |  | \__/ .__)
//
//  __   __        __   __      __   __   __
// /  ` /  \ |    /  \ |__)    |__) |__) /  \  |\/|
// \__, \__/ |___ \__/ |  \    |    |  \ \__/  |  |
//
// ___  ___  __  ___  __   ___       __
//  |  |__  /__`  |  |__) |__  |\ | /  ` |__|
//  |  |___ .__/  |  |__) |___ | \| \__, |  |
//
// =====================================================
// (c)2024-2025 <NAME>
// SPDX-License-Identifier: CC0-1.0
// =====================================================

// =====================================================
// Management variables
// =====================================================

// ---
// Main loop phases, alternating between read and write phases
// ---
#include ""phaseman.h""

// ---
// Status LED (the onboard LED) management
// ---
#include ""StatusLed.h""

// ---
// Data report sent to serial
// ---
#include ""Report.h""

// ---
// Management of GPIOs
// ---
// GPIOs are used for 4 tasks :
// * Enabling/disabling the power supply for the device under test. Disabling
// the power supply allow to swap the device to test.
// * Select the address sent to the device under test
// * Read the data from the device under test
// * User inputs (one action button and two toggle switches)
// ---

// -- address pins
#include ""Address.h""

// -- data pins
#include ""Data.h""

// -- Power control pins (outputs) : A0
const uint8_t POWER_CONTROL_PINS[] = {A0};
const uint8_t sizeof_POWER_CONTROL_PINS =
    sizeof(POWER_CONTROL_PINS) / sizeof(POWER_CONTROL_PINS[0]);

// -- user input pins (buttons and toggle switches) : A2, A5-A4 ;
const uint8_t INPUT_PINS[] = {A2, A5, A4};
const uint8_t sizeof_INPUT_PINS = sizeof(INPUT_PINS) / sizeof(INPUT_PINS[0]);

// -- -- A2 = Action push-button
const uint8_t INPUT_PIN_ACTION = 0;
bool on_action = false;
uint8_t action_value = LOW;
const uint8_t ACTION_COOLDOWN_START = 3;
uint8_t action_cooldown = ACTION_COOLDOWN_START;
bool action_is_performing = false;
uint8_t action_remaining = 0;

// -- -- A5 = Mode toggle ; 0-> Manual, 1-> Automatic
const uint8_t INPUT_PIN_MODE_TOGGLE = 1;
bool onchange_mode = false;
uint8_t mode_value = LOW;

// -- -- A4 = Enable power toggle ; 0-> OFF, 1-> ON
const uint8_t INPUT_PIN_POWER_ENABLE = 2;
bool onchange_powerEnable = false;
uint8_t powerEnable_value = LOW;

// =====================================================
// Prepare...
// =====================================================

void setup() {
  // -- onboard LED
  pinMode(LED_BUILTIN, OUTPUT);

  // -- other setups
  setupGpios();
  setupSerial();
  StatusLed_toPass();
}

void setupGpios() {
  Address_setupGpios();
  Data_setupGpios();

  // -- power control pins
  for (uint8_t i = 0; i < sizeof_POWER_CONTROL_PINS; i++) {
    pinMode(POWER_CONTROL_PINS[i], OUTPUT);
    digitalWrite(POWER_CONTROL_PINS[i], LOW);
  }

  // -- user input pins
  for (uint8_t i = 0; i < sizeof_INPUT_PINS; i++) {
    pinMode(INPUT_PINS[i], INPUT);
  }
}

void setupSerial() {
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
}

// =====================================================
// Main loop
// =====================================================

void loop() { loopPhases(); }

void handleReadPhase() {
  Data_read();
  Report_registerValue(Address_value, Data_value);

  if (action_is_performing && LOW == mode_value) {
    Report_emitSingleValue(Address_value);
  }

  // -- read user input pins
  on_action = readInputButton(INPUT_PIN_ACTION, action_value);
  onchange_mode = readToggleSwitch(INPUT_PIN_MODE_TOGGLE, mode_value);
  onchange_powerEnable =
      readToggleSwitch(INPUT_PIN_POWER_ENABLE, powerEnable_value);
}

bool readInputButton(uint8_t button, uint8_t &value) {
  const uint8_t in = digitalRead(INPUT_PINS[button]);
  bool  [MASK]  = (HIGH == in && LOW == value);
  value = in;
  return  [MASK] ;
}

bool readToggleSwitch(uint8_t toggle, uint8_t &value) {
  const uint8_t in = digitalRead(INPUT_PINS[toggle]);
  bool onchange = (in != value);
  value = in;
  return onchange;
}

void handleWritePhase() {
  // Code to update outputs
  updateStatusLed();
  handlePower();
  handleAction();
}

void handlePower() {
  if (!onchange_powerEnable)
    return;

  for (uint8_t i = 0;
       i < sizeof(POWER_CONTROL_PINS) / sizeof(POWER_CONTROL_PINS[0]); i++) {
    digitalWrite(POWER_CONTROL_PINS[i], powerEnable_value);
  }
}

void handleAction() {
  // the handling is bogus, for now just
  // emitSingleReport/incrementAddress/emitAddress
  Report_emitSingleValue(Address_value);
  Address__loop();
  return;

  // skip that
  if (action_is_performing) {
    if (action_remaining > 0) {
      --action_remaining;
    } else if (0 == Address_value) {
      Report_emitFull();
      action_is_performing = false;
    }
    Address__loop();
  }
  if (action_cooldown > 0) {
    Serial.println(""// -- cooldown > 0"");
    --action_cooldown;
    return;
  }
  if (!on_action) {
    Serial.println(""// -- on_action is false"");
    if (action_value == LOW) {
      Serial.println(""// -- action_value is LOW"");
    } else {
      Serial.println(""// -- action_value is HIGH"");
    }
    return;
  } else {
    Serial.println(""// -- on_action is true"");
  }

  if (LOW == mode_value) // manual mode
    handleAction_manual();
  else
    handleAction_auto();
}

void handleAction_manual() {
  // TODO
  Address__loop();
  action_is_performing = true;
}

void handleAction_auto() {
  if (!action_is_performing) {
    Address_value = 0;
    action_is_performing = true;
    action_remaining = 1;
  }
}
",trigger
103,"//
// Created by AYL_iwalk on 21/6/15.
//


#include ""mp3_encoder.h""

int Mp3Encoder::Init(const char *pcmFilePath, const char *mp3FilePath, int sampleRate, int channels, int bitRate) {
    int ret = -1;
    pcmFile = fopen(pcmFilePath,""rb"");
    if (pcmFile) {
        mp3File = fopen(mp3FilePath,""wb"");
        if (mp3File) {
            lameClient = lame_init();
            lame_set_in_samplerate(lameClient,sampleRate);
            lame_set_out_samplerate(lameClient, sampleRate);
            lame_set_num_channels(lameClient, channels);
            lame_set_brate(lameClient, bitRate/1000);
            lame_init_params(lameClient);
            ret = 0;
        }
    }
    return ret;
}

void Mp3Encoder::Encode() {
    int bufferSize = 1024 * 16;
    auto* buffer = new short [bufferSize/2];
    auto* leftBuffer = new short [bufferSize/4];
    auto* rightBuffer = new short [bufferSize/4];
    auto* mp3Buffer = new unsigned char [bufferSize];
    size_t  [MASK] ;
    while(( [MASK]  = fread(buffer,2,bufferSize/2,pcmFile)) > 0) {
        for (int i=0; i < bufferSize ; i++) {
            if (i%2==0) {
                leftBuffer[i/2] = buffer[i];
            } else {
                rightBuffer[i/2] = buffer[i];
            }
        }
        size_t  wroteSize = lame_encode_buffer(lameClient, (short int* ) leftBuffer, (short int*) rightBuffer, (int)( [MASK] /2), mp3Buffer, bufferSize);
        fwrite(mp3Buffer, 1,wroteSize, mp3File);
    }
    delete[] buffer;
    delete[] leftBuffer;
    delete[] rightBuffer;
    delete[] mp3Buffer;
}

void Mp3Encoder::Destory() {
    if (pcmFile) {
        fclose(pcmFile);
    }
    if (mp3File) {
        fclose(mp3File);
        lame_close(lameClient);
    }
}

Mp3Encoder::Mp3Encoder() = default;

",readBufferSize
104,"#define STB_IMAGE_IMPLEMENTATION
#include ""stb_image.h"" // for stbi_image_free, stbi_load

#define STB_IMAGE_WRITE_IMPLEMENTATION
#include ""stb_image_write.h"" // for stbi_write_png

#include <algorithm> // for for_each
#include <cstddef>   // for size_t
#include <cstdint>   // for uint8_t
#include <execution> // for execution::par
#include <iostream>  // for basic_ostream, operator<<
#include <limits>    // for numeric_limits
#include <numeric>   // for iota
#include <vector>    // for vector

int main(int argc, char **argv) {
  if (argc != 3) {
    std::cerr << ""Usage: "" << argv[0] << "" <path/to/image> <path/to/output>\n"";
    return 0;
  }

  const char *filename = argv[1];
  const char *output_filename = argv[2];

  int width = 0;
  int height = 0;
  int channels = 0;
  std::uint8_t *image =
      stbi_load(filename, &width, &height, &channels, STBI_default);

  if (image == nullptr) {
    std::cerr << ""Failed to load image!\n"";
    stbi_image_free(image);
    return 1;
  }

  if (width <= 0 || height <= 0 || channels < 1 || channels > 4) {
    std::cerr << ""Invalid image!\n"";
    stbi_image_free(image);
    return 1;
  }

  if (channels == 1 || channels == 2) {
    std::cerr << ""Image is already gray!\n"";
    stbi_image_free(image);
    return 0;
  }

  if (std::numeric_limits<int>::max() / height / channels < width) {
    std::cerr << ""Image is too large!\n"";
    stbi_image_free(image);
    return 1;
  }

  const int gray_channels = channels == 4 ? 2 : 1;
  const std::size_t gray_image_size = width * height * gray_channels;
  std::vector<std::uint8_t> gray_image(gray_image_size);

  std::vector<std::size_t> indices(width * height);
  std::iota(indices.begin(), indices.end(), 0);

  std::for_each(
      std::execution::par, indices.cbegin(), indices.cend(),
      [gray_channels, channels, &gray_image, &image](std::size_t  [MASK] ) {
        const std::size_t i =  [MASK]  * gray_channels;
        const std::size_t j =  [MASK]  * channels;
        gray_image[i] = static_cast<std::uint8_t>(
            (image[j] + image[j + 1] + image[j + 2]) / 3.0L);
        if (gray_channels == 2) {
          gray_image[i + 1] = image[j + 3];
        }
      });

  stbi_image_free(image);
  if (!stbi_write_png(output_filename, width, height, gray_channels,
                      gray_image.data(), width * gray_channels)) {
    std::cerr << ""Failed to write output image!\n"";
    return 1;
  }
}
",idx
105,"#pragma once

#include <assimp/vector3.h>

enum class EAxis
{
	PositiveX,
	NegativeX,
	PositiveY,
	NegativeY,
	PositiveZ,
	NegativeZ,
};

inline aiVector3D Vec3ConvertUp(const aiVector3D& _v, EAxis _up)
{
	aiVector3D res;
	if (_up == EAxis::NegativeY)
	{
		res.x = _v.x;
		res.y = -_v.y;
		res.z = -_v.z;
	}
	else //if (_up == EAxis::PositiveZ)
	{
		res.x = _v.x;
		res.y = _v.z;
		res.z = _v.y;
	}
	return res;
}

inline aiVector3D Vec3Cross(const aiVector3D& _v1, const aiVector3D& _v2)
{
	aiVector3D res;
	res.x = _v1.y * _v2.z - _v1.z * _v2.y;
	res.y = _v1.z * _v2.x - _v1.x * _v2.z;
	res.z = _v1.x * _v2.y - _v1.y * _v2.x;
	return res;
}

inline float Vec3Dot(const aiVector3D& _v1, const aiVector3D& _v2)
{
	return (_v1.x * _v2.x
		+ _v1.y * _v2.y
		+ _v1.z * _v2.z);
}

inline float GetBitangentSign(
	const aiVector3D& _normal,
	const aiVector3D& _tangent,
	const aiVector3D& _bitangent)
{
	aiVector3D cross = Vec3Cross(_normal, _tangent);
	float  [MASK]  = Vec3Dot(cross, _bitangent);
	return ( [MASK]  < 0.0f) ? -1.0f : 1.0f;
}
",dot
106,"#include ""gen_exported.h""

namespace gen_exported {

/*******************************************************************************************************************
Cycling '74 License for Max-Generated Code for Export
Copyright (c) 2022 Cycling '74
The code that Max generates automatically and that end users are capable of exporting and using, and any
  associated documentation files (the “Software”) is a work of authorship for which Cycling '74 is the author
  and owner for copyright purposes.  A license is hereby granted, free of charge, to any person obtaining a
  copy of the Software (“Licensee”) to use, copy, modify, merge, publish, and distribute copies of the Software,
  and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The Software is licensed to Licensee only for non-commercial use. Users who wish to make commercial use of the
  Software must contact the copyright owner to determine if a license for commercial use is available, and the
  terms and conditions for same, which may include fees or royalties. For commercial use, please send inquiries
  to licensing (at) cycling74.com.  The determination of whether a use is commercial use or non-commercial use is based
  upon the use, not the user. The Software may be used by individuals, institutions, governments, corporations, or
  other business whether for-profit or non-profit so long as the use itself is not a commercialization of the
  materials or a use that generates or is intended to generate income, revenue, sales or profit.
The above copyright notice and this license shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  DEALINGS IN THE SOFTWARE.
*******************************************************************************************************************/

// global noise generator
Noise noise;
static const int GENLIB_LOOPCOUNT_BAIL = 100000;


// The State struct contains all the state and procedures for the gendsp kernel
typedef struct State {
	CommonState __commonstate;
	Change __m_change_22;
	DCBlock __m_dcblock_42;
	DCBlock __m_dcblock_27;
	DCBlock __m_dcblock_32;
	DCBlock __m_dcblock_37;
	Data m_scale_8;
	Delay m_delay_4;
	Delay m_delay_3;
	Delay m_delay_2;
	Delay m_delay_1;
	Phasor __m_phasor_20;
	Sah __m_sah_28;
	Sah __m_sah_33;
	Sah __m_sah_36;
	Sah __m_sah_31;
	Sah __m_sah_38;
	Sah __m_sah_26;
	Sah __m_sah_21;
	Sah __m_sah_41;
	Sah __m_sah_23;
	int vectorsize;
	int __exception;
	t_sample m_fund_7;
	t_sample m_thresh_6;
	t_sample samples_to_seconds;
	t_sample samplerate;
	t_sample m_frequency_5;
	// re-initialize all member variables;
	inline void reset(t_param __sr, int __vs) {
		__exception = 0;
		vectorsize = __vs;
		samplerate = __sr;
		m_delay_1.reset(""m_delay_1"", ((int)100000));
		m_delay_2.reset(""m_delay_2"", ((int)100000));
		m_delay_3.reset(""m_delay_3"", ((int)100000));
		m_delay_4.reset(""m_delay_4"", ((int)100000));
		m_frequency_5 = ((int)10);
		m_thresh_6 = ((t_sample)0.5);
		m_fund_7 = ((int)60);
		m_scale_8.reset(""scale"", ((int)12), ((int)1));
		samples_to_seconds = (1 / samplerate);
		__m_phasor_20.reset(0);
		__m_sah_21.reset(0);
		__m_change_22.reset(0);
		__m_sah_23.reset(0);
		__m_sah_26.reset(0);
		__m_dcblock_27.reset();
		__m_sah_28.reset(0);
		__m_sah_31.reset(0);
		__m_dcblock_32.reset();
		__m_sah_33.reset(0);
		__m_sah_36.reset(0);
		__m_dcblock_37.reset();
		__m_sah_38.reset(0);
		__m_sah_41.reset(0);
		__m_dcblock_42.reset();
		genlib_reset_complete(this);
		
	};
	// the signal processing routine;
	inline int perform(t_sample ** __ins, t_sample ** __outs, int __n) {
		vectorsize = __n;
		const t_sample * __in1 = __ins[0];
		t_sample * __out1 = __outs[0];
		if (__exception) {
			return __exception;
			
		} else if (( (__in1 == 0) || (__out1 == 0) )) {
			__exception = GENLIB_ERR_NULL_BUFFER;
			return __exception;
			
		};
		int scale_dim = m_scale_8.dim;
		int scale_channels = m_scale_8.channels;
		bool index_ignore_9 = (((int)1) >= scale_dim);
		bool index_ignore_10 = (((int)2) >= scale_dim);
		bool index_ignore_11 = (((int)3) >= scale_dim);
		bool index_ignore_12 = (((int)4) >= scale_dim);
		bool index_ignore_13 = (((int)5) >= scale_dim);
		bool index_ignore_14 = (((int)6) >= scale_dim);
		bool index_ignore_15 = (((int)7) >= scale_dim);
		bool index_ignore_16 = (((int)8) >= scale_dim);
		bool index_ignore_17 = (((int)9) >= scale_dim);
		bool  [MASK]  = (((int)10) >= scale_dim);
		bool index_ignore_19 = (((int)11) >= scale_dim);
		t_sample rsub_130 = (((int)1) - m_thresh_6);
		samples_to_seconds = (1 / samplerate);
		// the main sample loop;
		while ((__n--)) {
			const t_sample in1 = (*(__in1++));
			m_scale_8.write(((int)0), 0, 0);
			if ((!index_ignore_9)) {
				m_scale_8.write(((int)0), ((int)1), 0);
				
			};
			if ((!index_ignore_10)) {
				m_scale_8.write(((int)2), ((int)2), 0);
				
			};
			if ((!index_ignore_11)) {
				m_scale_8.write(((int)3), ((int)3), 0);
				
			};
			if ((!index_ignore_12)) {
				m_scale_8.write(((int)3), ((int)4), 0);
				
			};
			if ((!index_ignore_13)) {
				m_scale_8.write(((int)5), ((int)5), 0);
				
			};
			if ((!index_ignore_14)) {
				m_scale_8.write(((int)7), ((int)6), 0);
				
			};
			if ((!index_ignore_15)) {
				m_scale_8.write(((int)7), ((int)7), 0);
				
			};
			if ((!index_ignore_16)) {
				m_scale_8.write(((int)8), ((int)8), 0);
				
			};
			if ((!index_ignore_17)) {
				m_scale_8.write(((int)8), ((int)9), 0);
				
			};
			if ((! [MASK] )) {
				m_scale_8.write(((int)10), ((int)10), 0);
				
			};
			if ((!index_ignore_19)) {
				m_scale_8.write(((int)10), ((int)11), 0);
				
			};
			t_sample noise_174 = noise();
			t_sample noise_890 = noise();
			t_sample noise_1617 = noise();
			t_sample noise_1604 = noise();
			t_sample noise_1648 = noise();
			t_sample noise_1635 = noise();
			t_sample noise_1679 = noise();
			t_sample noise_1666 = noise();
			t_sample noise_120 = noise();
			t_sample phasor_121 = __m_phasor_20(m_frequency_5, samples_to_seconds);
			t_sample sah_123 = __m_sah_21(noise_120, phasor_121, ((t_sample)0.5));
			int gt_129 = (sah_123 > rsub_130);
			int change_125 = __m_change_22(gt_129);
			int eq_475 = (change_125 == ((int)1));
			t_sample sah_173 = __m_sah_23(noise_174, eq_475, ((t_sample)0.5));
			t_sample sub_1908 = (sah_173 - (-1));
			t_sample scale_1905 = ((safepow((sub_1908 * ((t_sample)0.5)), ((int)1)) * ((int)12)) + ((int)0));
			t_sample floor_287 = floor(scale_1905);
			int index_trunc_24 = fixnan(floor(floor_287));
			bool index_ignore_25 = ((index_trunc_24 >= scale_dim) || (index_trunc_24 < 0));
			// samples scale channel 1;
			t_sample sample_scale_691 = (index_ignore_25 ? 0 : m_scale_8.read(index_trunc_24, 0));
			t_sample index_scale_692 = floor_287;
			t_sample sah_891 = __m_sah_26(noise_890, eq_475, ((t_sample)0.5));
			t_sample sub_1912 = (sah_891 - (-1));
			t_sample scale_1909 = ((safepow((sub_1912 * ((t_sample)0.5)), ((int)1)) * ((int)3)) + ((int)0));
			t_sample floor_954 = floor(scale_1909);
			t_sample mul_979 = (floor_954 * ((int)12));
			t_sample add_1004 = (sample_scale_691 + mul_979);
			t_sample add_717 = (add_1004 + m_fund_7);
			t_sample mtof_1077 = mtof(add_717, ((int)440));
			t_sample rdiv_193 = safediv(samplerate, mtof_1077);
			t_sample tap_335 = m_delay_4.read_linear(rdiv_193);
			t_sample dcblock_542 = __m_dcblock_27(tap_335);
			t_sample mul_504 = (dcblock_542 * ((t_sample)0.999));
			t_sample sah_1618 = __m_sah_28(noise_1617, eq_475, ((t_sample)0.5));
			t_sample sub_1916 = (sah_1618 - (-1));
			t_sample scale_1913 = ((safepow((sub_1916 * ((t_sample)0.5)), ((int)1)) * ((int)12)) + ((int)0));
			t_sample floor_1615 = floor(scale_1913);
			int index_trunc_29 = fixnan(floor(floor_1615));
			bool index_ignore_30 = ((index_trunc_29 >= scale_dim) || (index_trunc_29 < 0));
			// samples scale channel 1;
			t_sample sample_scale_1607 = (index_ignore_30 ? 0 : m_scale_8.read(index_trunc_29, 0));
			t_sample index_scale_1608 = floor_1615;
			t_sample sah_1605 = __m_sah_31(noise_1604, eq_475, ((t_sample)0.5));
			t_sample sub_1920 = (sah_1605 - (-1));
			t_sample scale_1917 = ((safepow((sub_1920 * ((t_sample)0.5)), ((int)1)) * ((int)3)) + ((int)0));
			t_sample floor_1602 = floor(scale_1917);
			t_sample mul_1601 = (floor_1602 * ((int)12));
			t_sample add_1600 = (sample_scale_1607 + mul_1601);
			t_sample add_1606 = (add_1600 + m_fund_7);
			t_sample mtof_1614 = mtof(add_1606, ((int)440));
			t_sample rdiv_1611 = safediv(samplerate, mtof_1614);
			t_sample tap_1613 = m_delay_3.read_linear(rdiv_1611);
			t_sample dcblock_1609 = __m_dcblock_32(tap_1613);
			t_sample mul_1610 = (dcblock_1609 * ((t_sample)0.999));
			t_sample sah_1649 = __m_sah_33(noise_1648, eq_475, ((t_sample)0.5));
			t_sample sub_1924 = (sah_1649 - (-1));
			t_sample scale_1921 = ((safepow((sub_1924 * ((t_sample)0.5)), ((int)1)) * ((int)12)) + ((int)0));
			t_sample floor_1646 = floor(scale_1921);
			int index_trunc_34 = fixnan(floor(floor_1646));
			bool index_ignore_35 = ((index_trunc_34 >= scale_dim) || (index_trunc_34 < 0));
			// samples scale channel 1;
			t_sample sample_scale_1638 = (index_ignore_35 ? 0 : m_scale_8.read(index_trunc_34, 0));
			t_sample index_scale_1639 = floor_1646;
			t_sample sah_1636 = __m_sah_36(noise_1635, eq_475, ((t_sample)0.5));
			t_sample sub_1928 = (sah_1636 - (-1));
			t_sample scale_1925 = ((safepow((sub_1928 * ((t_sample)0.5)), ((int)1)) * ((int)3)) + ((int)0));
			t_sample floor_1633 = floor(scale_1925);
			t_sample mul_1632 = (floor_1633 * ((int)12));
			t_sample add_1631 = (sample_scale_1638 + mul_1632);
			t_sample add_1637 = (add_1631 + m_fund_7);
			t_sample mtof_1645 = mtof(add_1637, ((int)440));
			t_sample rdiv_1642 = safediv(samplerate, mtof_1645);
			t_sample tap_1644 = m_delay_2.read_linear(rdiv_1642);
			t_sample dcblock_1640 = __m_dcblock_37(tap_1644);
			t_sample mul_1641 = (dcblock_1640 * ((t_sample)0.999));
			t_sample sah_1680 = __m_sah_38(noise_1679, eq_475, ((t_sample)0.5));
			t_sample sub_1932 = (sah_1680 - (-1));
			t_sample scale_1929 = ((safepow((sub_1932 * ((t_sample)0.5)), ((int)1)) * ((int)12)) + ((int)0));
			t_sample floor_1677 = floor(scale_1929);
			int index_trunc_39 = fixnan(floor(floor_1677));
			bool index_ignore_40 = ((index_trunc_39 >= scale_dim) || (index_trunc_39 < 0));
			// samples scale channel 1;
			t_sample sample_scale_1669 = (index_ignore_40 ? 0 : m_scale_8.read(index_trunc_39, 0));
			t_sample index_scale_1670 = floor_1677;
			t_sample sah_1667 = __m_sah_41(noise_1666, eq_475, ((t_sample)0.5));
			t_sample sub_1936 = (sah_1667 - (-1));
			t_sample scale_1933 = ((safepow((sub_1936 * ((t_sample)0.5)), ((int)1)) * ((int)3)) + ((int)0));
			t_sample floor_1664 = floor(scale_1933);
			t_sample mul_1663 = (floor_1664 * ((int)12));
			t_sample add_1662 = (sample_scale_1669 + mul_1663);
			t_sample add_1668 = (add_1662 + m_fund_7);
			t_sample mtof_1676 = mtof(add_1668, ((int)440));
			t_sample rdiv_1673 = safediv(samplerate, mtof_1676);
			t_sample tap_1675 = m_delay_1.read_linear(rdiv_1673);
			t_sample dcblock_1671 = __m_dcblock_42(tap_1675);
			t_sample out1 = ((((dcblock_1671 + dcblock_1640) + dcblock_1609) + in1) + dcblock_542);
			t_sample mul_1672 = (dcblock_1671 * ((t_sample)0.999));
			m_delay_4.write((in1 + mul_504));
			m_delay_3.write((in1 + mul_1610));
			m_delay_2.write((in1 + mul_1641));
			m_delay_1.write((in1 + mul_1672));
			m_delay_1.step();
			m_delay_2.step();
			m_delay_3.step();
			m_delay_4.step();
			// assign results to output buffer;
			(*(__out1++)) = out1;
			
		};
		return __exception;
		
	};
	inline void set_frequency(t_param _value) {
		m_frequency_5 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
	};
	inline void set_thresh(t_param _value) {
		m_thresh_6 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
	};
	inline void set_fund(t_param _value) {
		m_fund_7 = (_value < 0 ? 0 : (_value > 1 ? 1 : _value));
	};
	inline void set_scale(void * _value) {
		m_scale_8.setbuffer(_value);
	};
	
} State;


///
///	Configuration for the genlib API
///

/// Number of signal inputs and outputs

int gen_kernel_numins = 1;
int gen_kernel_numouts = 1;

int num_inputs() { return gen_kernel_numins; }
int num_outputs() { return gen_kernel_numouts; }
int num_params() { return 4; }

/// Assistive lables for the signal inputs and outputs

const char *gen_kernel_innames[] = { ""in1"" };
const char *gen_kernel_outnames[] = { ""out1"" };

/// Invoke the signal process of a State object

int perform(CommonState *cself, t_sample **ins, long numins, t_sample **outs, long numouts, long n) {
	State* self = (State *)cself;
	return self->perform(ins, outs, n);
}

/// Reset all parameters and stateful operators of a State object

void reset(CommonState *cself) {
	State* self = (State *)cself;
	self->reset(cself->sr, cself->vs);
}

/// Set a parameter of a State object

void setparameter(CommonState *cself, long index, t_param value, void *ref) {
	State *self = (State *)cself;
	switch (index) {
		case 0: self->set_frequency(value); break;
		case 1: self->set_fund(value); break;
		case 2: self->set_scale(ref); break;
		case 3: self->set_thresh(value); break;
		
		default: break;
	}
}

/// Get the value of a parameter of a State object

void getparameter(CommonState *cself, long index, t_param *value) {
	State *self = (State *)cself;
	switch (index) {
		case 0: *value = self->m_frequency_5; break;
		case 1: *value = self->m_fund_7; break;
		
		case 3: *value = self->m_thresh_6; break;
		
		default: break;
	}
}

/// Get the name of a parameter of a State object

const char *getparametername(CommonState *cself, long index) {
	if (index >= 0 && index < cself->numparams) {
		return cself->params[index].name;
	}
	return 0;
}

/// Get the minimum value of a parameter of a State object

t_param getparametermin(CommonState *cself, long index) {
	if (index >= 0 && index < cself->numparams) {
		return cself->params[index].outputmin;
	}
	return 0;
}

/// Get the maximum value of a parameter of a State object

t_param getparametermax(CommonState *cself, long index) {
	if (index >= 0 && index < cself->numparams) {
		return cself->params[index].outputmax;
	}
	return 0;
}

/// Get parameter of a State object has a minimum and maximum value

char getparameterhasminmax(CommonState *cself, long index) {
	if (index >= 0 && index < cself->numparams) {
		return cself->params[index].hasminmax;
	}
	return 0;
}

/// Get the units of a parameter of a State object

const char *getparameterunits(CommonState *cself, long index) {
	if (index >= 0 && index < cself->numparams) {
		return cself->params[index].units;
	}
	return 0;
}

/// Get the size of the state of all parameters of a State object

size_t getstatesize(CommonState *cself) {
	return genlib_getstatesize(cself, &getparameter);
}

/// Get the state of all parameters of a State object

short getstate(CommonState *cself, char *state) {
	return genlib_getstate(cself, state, &getparameter);
}

/// set the state of all parameters of a State object

short setstate(CommonState *cself, const char *state) {
	return genlib_setstate(cself, state, &setparameter);
}

/// Allocate and configure a new State object and it's internal CommonState:

void *create(t_param sr, long vs) {
	State *self = new State;
	self->reset(sr, vs);
	ParamInfo *pi;
	self->__commonstate.inputnames = gen_kernel_innames;
	self->__commonstate.outputnames = gen_kernel_outnames;
	self->__commonstate.numins = gen_kernel_numins;
	self->__commonstate.numouts = gen_kernel_numouts;
	self->__commonstate.sr = sr;
	self->__commonstate.vs = vs;
	self->__commonstate.params = (ParamInfo *)genlib_sysmem_newptr(4 * sizeof(ParamInfo));
	self->__commonstate.numparams = 4;
	// initialize parameter 0 (""m_frequency_5"")
	pi = self->__commonstate.params + 0;
	pi->name = ""frequency"";
	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
	pi->defaultvalue = self->m_frequency_5;
	pi->defaultref = 0;
	pi->hasinputminmax = false;
	pi->inputmin = 0;
	pi->inputmax = 1;
	pi->hasminmax = true;
	pi->outputmin = 0;
	pi->outputmax = 1;
	pi->exp = 0;
	pi->units = """";		// no units defined
	// initialize parameter 1 (""m_fund_7"")
	pi = self->__commonstate.params + 1;
	pi->name = ""fund"";
	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
	pi->defaultvalue = self->m_fund_7;
	pi->defaultref = 0;
	pi->hasinputminmax = false;
	pi->inputmin = 0;
	pi->inputmax = 1;
	pi->hasminmax = true;
	pi->outputmin = 0;
	pi->outputmax = 1;
	pi->exp = 0;
	pi->units = """";		// no units defined
	// initialize parameter 2 (""m_scale_8"")
	pi = self->__commonstate.params + 2;
	pi->name = ""scale"";
	pi->paramtype = GENLIB_PARAMTYPE_SYM;
	pi->defaultvalue = 0.;
	pi->defaultref = 0;
	pi->hasinputminmax = false;
	pi->inputmin = 0;
	pi->inputmax = 1;
	pi->hasminmax = false;
	pi->outputmin = 0;
	pi->outputmax = 1;
	pi->exp = 0;
	pi->units = """";		// no units defined
	// initialize parameter 3 (""m_thresh_6"")
	pi = self->__commonstate.params + 3;
	pi->name = ""thresh"";
	pi->paramtype = GENLIB_PARAMTYPE_FLOAT;
	pi->defaultvalue = self->m_thresh_6;
	pi->defaultref = 0;
	pi->hasinputminmax = false;
	pi->inputmin = 0;
	pi->inputmax = 1;
	pi->hasminmax = true;
	pi->outputmin = 0;
	pi->outputmax = 1;
	pi->exp = 0;
	pi->units = """";		// no units defined
	
	return self;
}

/// Release all resources and memory used by a State object:

void destroy(CommonState *cself) {
	State *self = (State *)cself;
	genlib_sysmem_freeptr(cself->params);
		
	delete self;
}


} // gen_exported::
",index_ignore_18
107,"#include ""../../config.hpp""

#if ESTRATEGIA == STRAT_BLUETOOTH

#include ""../estrategia.hpp""

#include ""../../motores/motores.hpp""

#include ""strat.hpp""
#include  <SoftwareSerial.h>

//SoftwareSerial BT(1,0);
#define BT Serial1

void setupEstrategia()
{
  BT.begin(115200);
}

void loopEstrategia(uint16_t distanciaIzquierda, uint16_t distanciaAdelante, uint16_t distanciaDerecha, uint16_t lecturaPisoL, uint16_t lecturaPisoR)
{
  static uint8_t  [MASK]  = 0;
  BT.println( [MASK] );
  if (BT.available()==0) return;
  switch (BT.read())
  {
  case 'G': // Adelante Izq.
    actualizarMotores(Direccion::Adelante, map( [MASK] , 0, 10, 0, 127), map( [MASK] , 0, 10, 0, 255));
    break;
  case 'F': // Adelante
    actualizarMotores(Direccion::Adelante, map( [MASK] , 0, 10, 0, 255));
    break;
  case 'I': // Adelante Der.
    actualizarMotores(Direccion::Adelante, map( [MASK] , 0, 10, 0, 255), map( [MASK] , 0, 10, 0, 127));
    break;
  case 'H': // Atras Izq.
    actualizarMotores(Direccion::Atras, map( [MASK] , 0, 10, 0, 127), map( [MASK] , 0, 10, 0, 255));
    break;
  case 'B': // Atras
    actualizarMotores(Direccion::Atras, map( [MASK] , 0, 10, 0, 255));
    break;
  case 'J': // Atras Der.
    actualizarMotores(Direccion::Atras, map( [MASK] , 0, 10, 0, 255), map( [MASK] , 0, 10, 0, 127));
    break;
  case 'L': // Izquierda
    actualizarMotores(Direccion::Izquierda, map( [MASK] , 0, 10, 0, 255));
    break;
  case 'R': // Derecha
    actualizarMotores(Direccion::Derecha, map( [MASK] , 0, 10, 0, 255));
    break;
  case 'S': // Parar
    actualizarMotores(Direccion::Nada);
    break;
  case '0':
     [MASK]  = 0;
    break;
  case '1':
     [MASK]  = 1;
    break;
  case '2':
     [MASK]  = 2;
    break;
  case '3':
     [MASK]  = 3;
    break;
  case '4':
     [MASK]  = 4;
    break;
  case '5':
     [MASK]  = 5;
    break;
  case '6':
     [MASK]  = 6;
    break;
  case '7':
     [MASK]  = 7;
    break;
  case '8':
     [MASK]  = 8;
    break;
  case '9':
     [MASK]  = 9;
    break;
  case 'q':
     [MASK]  = 10;
    break;
  default:
    break;
  }
}

#endif
",porcentaje
108,"/*!
 * @file Adafruit_SPITFT.cpp
 *
 * @mainpage Adafruit SPI TFT Displays (and some others)
 *
 * @section intro_sec Introduction
 *
 * Part of Adafruit's GFX graphics library. Originally this class was
 * written to handle a range of color TFT displays connected via SPI,
 * but over time this library and some display-specific subclasses have
 * mutated to include some color OLEDs as well as parallel-interfaced
 * displays. The name's been kept for the sake of older code.
 *
 * Adafruit invests time and resources providing this open source code,
 * please support Adafruit and open-source hardware by purchasing
 * products from Adafruit!

 * @section dependencies Dependencies
 *
 * This library depends on <a href=""https://github.com/adafruit/Adafruit_GFX"">
 * Adafruit_GFX</a> being present on your system. Please make sure you have
 * installed the latest version before using this library.
 *
 * @section author Author
 *
 * Written by Limor ""ladyada"" Fried for Adafruit Industries,
 * with contributions from the open source community.
 *
 * @section license License
 *
 * BSD license, all text here must be included in any redistribution.
 */
// Updated to work with nRF5 SDK in 2020 by <NAME> (https://github.com/adamgreen)
#include <nrf_assert.h>
#include <nrf_delay.h>
#include ""Adafruit_SPITFT.h""

// Singleton used to determine which object _spiHandler should use when SPI events come in.
Adafruit_SPITFT* Adafruit_SPITFT::g_pSingleton = NULL;

// CONSTRUCTORS ------------------------------------------------------------
/*!
    @brief   Adafruit_SPITFT constructor for hardware SPI using a specific
             SPI peripheral.
    @param   width     Display width in pixels at default rotation (0).
    @param   height    Display height in pixels at default rotation (0).
    @param   pSpi      Pointer to nRF SPI object.
    @param   mosiPin   Pin # for MOSI.
    @param   sckPin    Pin # for SCLK.
    @param   cs        Pin # for chip-select (-1 if unused, tie CS low).
    @param   dc        Pin # for data/command select (required).
    @param   rst       Pin # for display reset (optional, display reset
                       can be tied to MCU reset, default of -1 means unused).
    @note    Output pins are not initialized in constructor; application
             typically will need to call subclass' begin() function, which
             in turn calls this library's initSPI() function to initialize
             pins.
*/
Adafruit_SPITFT::Adafruit_SPITFT(uint16_t width, uint16_t height, nrf_drv_spi_t* pSpi,
                                 uint8_t mosiPin, uint8_t sckPin, uint8_t csPin, uint8_t dcPin,
                                 uint8_t rstPin /* = NRF_DRV_SPI_PIN_NOT_USED */)
    : Adafruit_GFX(width, height), m_pSpi(pSpi), m_mosiPin(mosiPin), m_sckPin(sckPin), m_rstPin(rstPin),
      m_csPin(csPin), m_dcPin(dcPin), m_startCount(0), m_finCount(0)
{
    g_pSingleton = this;
}
// end constructors -------

// CLASS MEMBER FUNCTIONS --------------------------------------------------

// begin() and setAddrWindow() MUST be declared by any subclass.

/*!
    @brief  Configure microcontroller pins for TFT interfacing. Typically
            called by a subclass' begin() function.
    @param  frequency SPI frequency when using hardware SPI.
    @param  mode     SPI mode when using hardware SPI.
*/
void Adafruit_SPITFT::initSPI(nrf_drv_spi_frequency_t frequency /* = NRF_DRV_SPI_FREQ_8M */,
                              nrf_drv_spi_mode_t mode /* = NRF_DRV_SPI_MODE_0 */)
{
    nrf_drv_spi_config_t  [MASK]  = NRF_DRV_SPI_DEFAULT_CONFIG;
     [MASK] .mosi_pin = m_mosiPin;
     [MASK] .sck_pin  = m_sckPin;
     [MASK] .frequency = frequency;
     [MASK] .mode = mode;
    APP_ERROR_CHECK(nrf_drv_spi_init(m_pSpi, & [MASK] , _spiHandler));

    // Init basic control pins common to all connection types
    nrf_gpio_cfg_output(m_csPin);
    nrf_gpio_pin_set(m_csPin);

    nrf_gpio_cfg_output(m_dcPin);
    nrf_gpio_pin_set(m_dcPin);

    if (m_rstPin != NRF_DRV_SPI_PIN_NOT_USED)
    {
        // Toggle reset low to reset
        nrf_gpio_cfg_output(m_rstPin);
        nrf_gpio_pin_set(m_rstPin);
        nrf_delay_ms(100);
        nrf_gpio_pin_clear(m_rstPin);
        nrf_delay_ms(100);
        nrf_gpio_pin_set(m_rstPin);
        nrf_delay_ms(200);
    }
}

/*!
    @brief  Call before issuing command(s) or data to display. Performs
            chip-select (if required) and starts an SPI transaction (if
            using hardware SPI and transactions are supported). Required
            for all display types; not an SPI-specific function.
*/
void Adafruit_SPITFT::startWrite(void) {
    m_buffer.start();
    startTransmission();
}

/*!
    @brief  Call after issuing command(s) or data to display. Performs
            chip-deselect (if required) and ends an SPI transaction (if
            using hardware SPI and transactions are supported). Required
            for all display types; not an SPI-specific function.
*/
void Adafruit_SPITFT::endWrite(void) {
    m_buffer.end();
    startTransmission();
}

// -------------------------------------------------------------------------
// Lower-level graphics operations. These functions require a chip-select
// and/or SPI transaction around them (via startWrite(), endWrite() above).
// Higher-level graphics primitives might start a single transaction and
// then make multiple calls to these functions (e.g. circle or text
// rendering might make repeated lines or rects) before ending the
// transaction. It's more efficient than starting a transaction every time.

/*!
    @brief  Draw a single pixel to the display at requested coordinates.
            Not self-contained; should follow a startWrite() call.
    @param  x      Horizontal position (0 = left).
    @param  y      Vertical position   (0 = top).
    @param  color  16-bit pixel color in '565' RGB format.
*/
void Adafruit_SPITFT::writePixel(int16_t x, int16_t y, uint16_t color) {
  if ((x >= 0) && (x < _width) && (y >= 0) && (y < _height)) {
    setAddrWindow(x, y, 1, 1);
    spiWrite16(color);
  }
}

/*!
    @brief  Issue a series of pixels from memory to the display. Not self-
            contained; should follow startWrite() and setAddrWindow() calls.
    @param  colors     Pointer to array of 16-bit pixel values in '565' RGB
                       format.
    @param  len        Number of elements in 'colors' array.
    @param  block      If true (default case if unspecified), function blocks
                       until DMA transfer is complete. This is simply IGNORED
                       if DMA is not enabled. If false, the function returns
                       immediately after the last DMA transfer is started,
                       and one should use the dmaWait() function before
                       doing ANY other display-related activities (or even
                       any SPI-related activities, if using an SPI display
                       that shares the bus with other devices).
    @param  bigEndian  If using DMA, and if set true, bitmap in memory is in
                       big-endian order (most significant byte first). By
                       default this is false, as most microcontrollers seem
                       to be little-endian and 16-bit pixel values must be
                       byte-swapped before issuing to the display (which tend
                       to be big-endian when using SPI or 8-bit parallel).
                       If an application can optimize around this -- for
                       example, a bitmap in a uint16_t array having the byte
                       values already reordered big-endian, this can save
                       some processing time here, ESPECIALLY if using this
                       function's non-blocking DMA mode. Not all cases are
                       covered...this is really here only for SAMD DMA and
                       much forethought on the application side.
*/
void Adafruit_SPITFT::writePixels(const uint16_t *colors, uint32_t len, bool block, bool bigEndian)
{
    while (len--) {
        spiWrite16(*colors++);
    }
}

/*!
    @brief  Issue a series of pixels, all the same color. Not self-
            contained; should follow startWrite() and setAddrWindow() calls.
    @param  color  16-bit pixel color in '565' RGB format.
    @param  len    Number of pixels to draw.
*/
void Adafruit_SPITFT::writeColor(uint16_t color, uint32_t len)
{
    while (len--) {
        spiWrite16(color);
    }
}

/*!
    @brief  Draw a filled rectangle to the display. Not self-contained;
            should follow startWrite(). Typically used by higher-level
            graphics primitives; user code shouldn't need to call this and
            is likely to use the self-contained fillRect() instead.
            writeFillRect() performs its own edge clipping and rejection;
            see writeFillRectPreclipped() for a more 'raw' implementation.
    @param  x      Horizontal position of first corner.
    @param  y      Vertical position of first corner.
    @param  w      Rectangle width in pixels (positive = right of first
                   corner, negative = left of first corner).
    @param  h      Rectangle height in pixels (positive = below first
                   corner, negative = above first corner).
    @param  color  16-bit fill color in '565' RGB format.
    @note   Written in this deep-nested way because C by definition will
            optimize for the 'if' case, not the 'else' -- avoids branches
            and rejects clipped rectangles at the least-work possibility.
*/
void Adafruit_SPITFT::writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h,
                                    uint16_t color) {
  if (w && h) {   // Nonzero width and height?
    if (w < 0) {  // If negative width...
      x += w + 1; //   Move X to left edge
      w = -w;     //   Use positive width
    }
    if (x < _width) { // Not off right
      if (h < 0) {    // If negative height...
        y += h + 1;   //   Move Y to top edge
        h = -h;       //   Use positive height
      }
      if (y < _height) { // Not off bottom
        int16_t x2 = x + w - 1;
        if (x2 >= 0) { // Not off left
          int16_t y2 = y + h - 1;
          if (y2 >= 0) { // Not off top
            // Rectangle partly or fully overlaps screen
            if (x < 0) {
              x = 0;
              w = x2 + 1;
            } // Clip left
            if (y < 0) {
              y = 0;
              h = y2 + 1;
            } // Clip top
            if (x2 >= _width) {
              w = _width - x;
            } // Clip right
            if (y2 >= _height) {
              h = _height - y;
            } // Clip bottom
            writeFillRectPreclipped(x, y, w, h, color);
          }
        }
      }
    }
  }
}

/*!
    @brief  Draw a horizontal line on the display. Performs edge clipping
            and rejection. Not self-contained; should follow startWrite().
            Typically used by higher-level graphics primitives; user code
            shouldn't need to call this and is likely to use the self-
            contained drawFastHLine() instead.
    @param  x      Horizontal position of first point.
    @param  y      Vertical position of first point.
    @param  w      Line width in pixels (positive = right of first point,
                   negative = point of first corner).
    @param  color  16-bit line color in '565' RGB format.
*/
void inline Adafruit_SPITFT::writeFastHLine(int16_t x, int16_t y, int16_t w,
                                            uint16_t color) {
  if ((y >= 0) && (y < _height) && w) { // Y on screen, nonzero width
    if (w < 0) {                        // If negative width...
      x += w + 1;                       //   Move X to left edge
      w = -w;                           //   Use positive width
    }
    if (x < _width) { // Not off right
      int16_t x2 = x + w - 1;
      if (x2 >= 0) { // Not off left
        // Line partly or fully overlaps screen
        if (x < 0) {
          x = 0;
          w = x2 + 1;
        } // Clip left
        if (x2 >= _width) {
          w = _width - x;
        } // Clip right
        writeFillRectPreclipped(x, y, w, 1, color);
      }
    }
  }
}

/*!
    @brief  Draw a vertical line on the display. Performs edge clipping and
            rejection. Not self-contained; should follow startWrite().
            Typically used by higher-level graphics primitives; user code
            shouldn't need to call this and is likely to use the self-
            contained drawFastVLine() instead.
    @param  x      Horizontal position of first point.
    @param  y      Vertical position of first point.
    @param  h      Line height in pixels (positive = below first point,
                   negative = above first point).
    @param  color  16-bit line color in '565' RGB format.
*/
void inline Adafruit_SPITFT::writeFastVLine(int16_t x, int16_t y, int16_t h,
                                            uint16_t color) {
  if ((x >= 0) && (x < _width) && h) { // X on screen, nonzero height
    if (h < 0) {                       // If negative height...
      y += h + 1;                      //   Move Y to top edge
      h = -h;                          //   Use positive height
    }
    if (y < _height) { // Not off bottom
      int16_t y2 = y + h - 1;
      if (y2 >= 0) { // Not off top
        // Line partly or fully overlaps screen
        if (y < 0) {
          y = 0;
          h = y2 + 1;
        } // Clip top
        if (y2 >= _height) {
          h = _height - y;
        } // Clip bottom
        writeFillRectPreclipped(x, y, 1, h, color);
      }
    }
  }
}

/*!
    @brief  A lower-level version of writeFillRect(). This version requires
            all inputs are in-bounds, that width and height are positive,
            and no part extends offscreen. NO EDGE CLIPPING OR REJECTION IS
            PERFORMED. If higher-level graphics primitives are written to
            handle their own clipping earlier in the drawing process, this
            can avoid unnecessary function calls and repeated clipping
            operations in the lower-level functions.
    @param  x      Horizontal position of first corner. MUST BE WITHIN
                   SCREEN BOUNDS.
    @param  y      Vertical position of first corner. MUST BE WITHIN SCREEN
                   BOUNDS.
    @param  w      Rectangle width in pixels. MUST BE POSITIVE AND NOT
                   EXTEND OFF SCREEN.
    @param  h      Rectangle height in pixels. MUST BE POSITIVE AND NOT
                   EXTEND OFF SCREEN.
    @param  color  16-bit fill color in '565' RGB format.
    @note   This is a new function, no graphics primitives besides rects
            and horizontal/vertical lines are written to best use this yet.
*/
inline void Adafruit_SPITFT::writeFillRectPreclipped(int16_t x, int16_t y,
                                                     int16_t w, int16_t h,
                                                     uint16_t color) {
  setAddrWindow(x, y, w, h);
  writeColor(color, (uint32_t)w * h);
}

// -------------------------------------------------------------------------
// Ever-so-slightly higher-level graphics operations. Similar to the 'write'
// functions above, but these contain their own chip-select and SPI
// transactions as needed (via startWrite(), endWrite()). They're typically
// used solo -- as graphics primitives in themselves, not invoked by higher-
// level primitives (which should use the functions above for better
// performance).

/*!
    @brief  Draw a single pixel to the display at requested coordinates.
            Self-contained and provides its own transaction as needed
            (see writePixel(x,y,color) for a lower-level variant).
            Edge clipping is performed here.
    @param  x      Horizontal position (0 = left).
    @param  y      Vertical position   (0 = top).
    @param  color  16-bit pixel color in '565' RGB format.
*/
void Adafruit_SPITFT::drawPixel(int16_t x, int16_t y, uint16_t color) {
  // Clip first...
  if ((x >= 0) && (x < _width) && (y >= 0) && (y < _height)) {
    // THEN set up transaction (if needed) and draw...
    startWrite();
    setAddrWindow(x, y, 1, 1);
    writeColor(color, 1);
    endWrite();
  }
}

/*!
    @brief  Draw a filled rectangle to the display. Self-contained and
            provides its own transaction as needed (see writeFillRect() or
            writeFillRectPreclipped() for lower-level variants). Edge
            clipping and rejection is performed here.
    @param  x      Horizontal position of first corner.
    @param  y      Vertical position of first corner.
    @param  w      Rectangle width in pixels (positive = right of first
                   corner, negative = left of first corner).
    @param  h      Rectangle height in pixels (positive = below first
                   corner, negative = above first corner).
    @param  color  16-bit fill color in '565' RGB format.
    @note   This repeats the writeFillRect() function almost in its entirety,
            with the addition of a transaction start/end. It's done this way
            (rather than starting the transaction and calling writeFillRect()
            to handle clipping and so forth) so that the transaction isn't
            performed at all if the rectangle is rejected. It's really not
            that much code.
*/
void Adafruit_SPITFT::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
                               uint16_t color) {
  if (w && h) {   // Nonzero width and height?
    if (w < 0) {  // If negative width...
      x += w + 1; //   Move X to left edge
      w = -w;     //   Use positive width
    }
    if (x < _width) { // Not off right
      if (h < 0) {    // If negative height...
        y += h + 1;   //   Move Y to top edge
        h = -h;       //   Use positive height
      }
      if (y < _height) { // Not off bottom
        int16_t x2 = x + w - 1;
        if (x2 >= 0) { // Not off left
          int16_t y2 = y + h - 1;
          if (y2 >= 0) { // Not off top
            // Rectangle partly or fully overlaps screen
            if (x < 0) {
              x = 0;
              w = x2 + 1;
            } // Clip left
            if (y < 0) {
              y = 0;
              h = y2 + 1;
            } // Clip top
            if (x2 >= _width) {
              w = _width - x;
            } // Clip right
            if (y2 >= _height) {
              h = _height - y;
            } // Clip bottom
            startWrite();
            writeFillRectPreclipped(x, y, w, h, color);
            endWrite();
          }
        }
      }
    }
  }
}

/*!
    @brief  Draw a horizontal line on the display. Self-contained and
            provides its own transaction as needed (see writeFastHLine() for
            a lower-level variant). Edge clipping and rejection is performed
            here.
    @param  x      Horizontal position of first point.
    @param  y      Vertical position of first point.
    @param  w      Line width in pixels (positive = right of first point,
                   negative = point of first corner).
    @param  color  16-bit line color in '565' RGB format.
    @note   This repeats the writeFastHLine() function almost in its
            entirety, with the addition of a transaction start/end. It's
            done this way (rather than starting the transaction and calling
            writeFastHLine() to handle clipping and so forth) so that the
            transaction isn't performed at all if the line is rejected.
*/
void Adafruit_SPITFT::drawFastHLine(int16_t x, int16_t y, int16_t w,
                                    uint16_t color) {
  if ((y >= 0) && (y < _height) && w) { // Y on screen, nonzero width
    if (w < 0) {                        // If negative width...
      x += w + 1;                       //   Move X to left edge
      w = -w;                           //   Use positive width
    }
    if (x < _width) { // Not off right
      int16_t x2 = x + w - 1;
      if (x2 >= 0) { // Not off left
        // Line partly or fully overlaps screen
        if (x < 0) {
          x = 0;
          w = x2 + 1;
        } // Clip left
        if (x2 >= _width) {
          w = _width - x;
        } // Clip right
        startWrite();
        writeFillRectPreclipped(x, y, w, 1, color);
        endWrite();
      }
    }
  }
}

/*!
    @brief  Draw a vertical line on the display. Self-contained and provides
            its own transaction as needed (see writeFastHLine() for a lower-
            level variant). Edge clipping and rejection is performed here.
    @param  x      Horizontal position of first point.
    @param  y      Vertical position of first point.
    @param  h      Line height in pixels (positive = below first point,
                   negative = above first point).
    @param  color  16-bit line color in '565' RGB format.
    @note   This repeats the writeFastVLine() function almost in its
            entirety, with the addition of a transaction start/end. It's
            done this way (rather than starting the transaction and calling
            writeFastVLine() to handle clipping and so forth) so that the
            transaction isn't performed at all if the line is rejected.
*/
void Adafruit_SPITFT::drawFastVLine(int16_t x, int16_t y, int16_t h,
                                    uint16_t color) {
  if ((x >= 0) && (x < _width) && h) { // X on screen, nonzero height
    if (h < 0) {                       // If negative height...
      y += h + 1;                      //   Move Y to top edge
      h = -h;                          //   Use positive height
    }
    if (y < _height) { // Not off bottom
      int16_t y2 = y + h - 1;
      if (y2 >= 0) { // Not off top
        // Line partly or fully overlaps screen
        if (y < 0) {
          y = 0;
          h = y2 + 1;
        } // Clip top
        if (y2 >= _height) {
          h = _height - y;
        } // Clip bottom
        startWrite();
        writeFillRectPreclipped(x, y, 1, h, color);
        endWrite();
      }
    }
  }
}

/*!
    @brief  Draw a 16-bit image (565 RGB) at the specified (x,y) position.
            For 16-bit display devices; no color reduction performed.
            Adapted from https://github.com/PaulStoffregen/ILI9341_t3
            by <NAME>. See examples/pictureEmbed to use this.
            5/6/2017: function name and arguments have changed for
            compatibility with current GFX library and to avoid naming
            problems in prior implementation.  Formerly drawBitmap() with
            arguments in different order. Handles its own transaction and
            edge clipping/rejection.
    @param  x        Top left corner horizontal coordinate.
    @param  y        Top left corner vertical coordinate.
    @param  pcolors  Pointer to 16-bit array of pixel values.
    @param  w        Width of bitmap in pixels.
    @param  h        Height of bitmap in pixels.
*/
void Adafruit_SPITFT::drawRGBBitmap(int16_t x, int16_t y, uint16_t *pcolors,
                                    int16_t w, int16_t h) {

  int16_t x2, y2;                 // Lower-right coord
  if ((x >= _width) ||            // Off-edge right
      (y >= _height) ||           // "" top
      ((x2 = (x + w - 1)) < 0) || // "" left
      ((y2 = (y + h - 1)) < 0))
    return; // "" bottom

  int16_t bx1 = 0, by1 = 0, // Clipped top-left within bitmap
      saveW = w;            // Save original bitmap width value
  if (x < 0) {              // Clip left
    w += x;
    bx1 = -x;
    x = 0;
  }
  if (y < 0) { // Clip top
    h += y;
    by1 = -y;
    y = 0;
  }
  if (x2 >= _width)
    w = _width - x; // Clip right
  if (y2 >= _height)
    h = _height - y; // Clip bottom

  pcolors += by1 * saveW + bx1; // Offset bitmap ptr to clipped top-left
  startWrite();
  setAddrWindow(x, y, w, h); // Clipped area
  while (h--) {              // For each (clipped) scanline...
    writePixels(pcolors, w); // Push one (clipped) row
    pcolors += saveW;        // Advance pointer by one full (unclipped) line
  }
  endWrite();
}

// -------------------------------------------------------------------------
// Miscellaneous class member functions that don't draw anything.

/*!
    @brief  Invert the colors of the display (if supported by hardware).
            Self-contained, no transaction setup required.
    @param  i  true = inverted display, false = normal display.
*/
void Adafruit_SPITFT::invertDisplay(bool i) {
  startWrite();
  writeCommand(i ? invertOnCommand : invertOffCommand);
  endWrite();
}

/*!
    @brief   Given 8-bit red, green and blue values, return a 'packed'
             16-bit color value in '565' RGB format (5 bits red, 6 bits
             green, 5 bits blue). This is just a mathematical operation,
             no hardware is touched.
    @param   red    8-bit red brightnesss (0 = off, 255 = max).
    @param   green  8-bit green brightnesss (0 = off, 255 = max).
    @param   blue   8-bit blue brightnesss (0 = off, 255 = max).
    @return  'Packed' 16-bit color value (565 format).
*/
uint16_t Adafruit_SPITFT::color565(uint8_t red, uint8_t green, uint8_t blue) {
  return ((red & 0xF8) << 8) | ((green & 0xFC) << 3) | (blue >> 3);
}

/*!
 @brief   Adafruit_SPITFT Send Command handles complete sending of commands and
 data
 @param   commandByte       The Command Byte
 @param   dataBytes         A pointer to the Data bytes to send
 @param   numDataBytes      The number of bytes we should send
 */
void Adafruit_SPITFT::sendCommand(uint8_t commandByte, const uint8_t *dataBytes,
                                  uint8_t numDataBytes)
{
    startWrite();
    writeCommand(commandByte);
    for (uint8_t i = 0 ; i < numDataBytes ; i++) {
        spiWrite(*dataBytes++);
    }
    endWrite();
}

/*!
    @brief  Issue a single 8-bit value to the display. Chip-select,
            transaction and data/command selection must have been
            previously set -- this ONLY issues the byte. This is another of
            those functions in the library with a now-not-accurate name
            that's being maintained for compatibility with outside code.
            This function is used even if display connection is parallel.
    @param  b  8-bit value to write.
*/
void Adafruit_SPITFT::spiWrite(uint8_t b)
{
    m_buffer.writeData(b);
    startTransmission();
}

void Adafruit_SPITFT::spiWrite16(uint16_t w)
{
    m_buffer.writeData(w);
    startTransmission();
}

void Adafruit_SPITFT::spiWrite32(uint32_t w)
{
    m_buffer.writeData(w);
    startTransmission();
}

/*!
    @brief  Write a single command byte to the display. Chip-select and
            transaction must have been previously set -- this ONLY sets
            the device to COMMAND mode, issues the byte and then restores
            DATA mode. There is no corresponding explicit writeData()
            function -- just use spiWrite().
    @param  cmd  8-bit command to write.
*/
void Adafruit_SPITFT::writeCommand(uint8_t cmd) {
    m_buffer.writeCommand(cmd);
    startTransmission();
}


void Adafruit_SPITFT::spiHandler(nrf_drv_spi_evt_t const * pEvent)
{
    if (pEvent) {
        m_finCount++;
    }
    while (1) {
        uint8_t* pBytes;
        uint32_t len;
        uint8_t flags;

        bool result = m_buffer.readBytes(&pBytes, &len, &flags);
        if (!result) {
            return;
        }
        if (m_buffer.isEnd(flags)) {
            nrf_gpio_pin_set(m_csPin);
            continue;
        }
        if (m_buffer.isStart(flags)) {
            nrf_gpio_pin_clear(m_csPin);
        }
        if (m_buffer.isCommand(flags)) {
            nrf_gpio_pin_clear(m_dcPin);
        } else {
            nrf_gpio_pin_set(m_dcPin);
        }

        m_startCount++;
        APP_ERROR_CHECK(nrf_drv_spi_transfer(m_pSpi, pBytes, len, NULL, 0));
        return;
    }
}
",spiConfig
109,"#include ""include/Vigener.h""

int threshold;
int keyLength;
int maxKeyLength;
std::string alphabet;


void checkFile(std::string fileName)
{
	std::ifstream temp(fileName);

	if (!temp.is_open())
	{
		std::cout << ""Невозможно открыть файл '"" << fileName << ""'\n"";
		exit(0);
	}
	else
	{
		std::string tmp;
		while (temp)
		{
			getline(temp, tmp);
			if (!tmp.empty())
				return;
		}
		temp.close();

		std::cout << ""Файл '"" << fileName << ""' пуст!\n"";
		exit(0);

	}
}

void readFile(std::string& text, std::string fileName)
{
	checkFile(fileName);
	std::ifstream in(fileName);

	std::string  str;
	while (!in.eof())
	{
		str.clear();
		getline(in, str);
		text.append(str);
	}
	in.close();
}

void deleteForbiddenSymbols(std::string& text)
{
	transform(text.begin(), text.end(), text.begin(), tolower);
	text.erase(remove_if(text.begin(), text.end(), isAlpha(alphabet)), text.end());
}


void decrypt(std::string key, std::vector<std::string>& columns)
{
	for (auto i = 0; i < key.size(); i++)
	{
		int keyPosition = alphabet.find_first_of(key[i]);
		for (auto j = 0; j < columns[i].size(); j++)
		{
			int pos = alphabet.find_first_of(columns[i][j]);
			int num = pos - keyPosition;

			if (num < 0)
				num += (int)alphabet.size();

			columns[i][j] = alphabet[num];
		}
	}
}

void save(std::string key, std::vector<std::string>& columns, std::string decryptedTextFileName)
{
	std::ofstream out(decryptedTextFileName, std::ios::app);

	out << ""Ключ: "" << key << ""\n\n"";

	out << ""Открытый текст:\n"";

	decrypt(key, columns);

	int rawMaxSize = 130 / (int)key.length();

	unsigned int k = 0;
	int tmp = 0;
	for (auto j = 0; j < columns.size(); j++)
	{
		if (k > columns[j].size())
			break;

		out << columns[j][k];

		tmp++;

		if (j != 0 && j % (key.size() - 1) == 0)
			out << "" "";

		if (tmp == rawMaxSize * key.length())
		{
			out << ""\n"";
			tmp = 0;
		}

		if (j != 0 && j % (key.size() - 1) == 0)
		{
			k++;
			j = -1;
		}
	}

	out << ""\n"";

	for (auto i = 0; i < 100; i++)
		out << ""-"";
	out << ""\n"";

	out.close();
}

void displayDecryptedText(std::string key, std::vector<std::string> columns)
{
	decrypt(key, columns);

	int rawMaxSize = 130 / (int)key.length();

	unsigned int k = 0;
	int tmp = 0;
	for (auto j = 0; j < columns.size(); j++)
	{
		if (k > columns[j].size())
			break;

		std::cout << columns[j][k];

		tmp++;

		if (j != 0 && j % (key.size() - 1) == 0)
			std::cout << "" "";

		if (tmp == rawMaxSize * key.length())
		{
			std::cout << ""\n"";
			tmp = 0;
		}

		if (j != 0 && j % (key.size() - 1) == 0)
		{
			k++;
			j = -1;
		}
	}

	std::cout << ""\n"";
}

void generaateKey(std::vector<Frequency>& columnsFrequency, std::string& key, int groupNumber, int shift, int cipherAlphabetSize)
{
	int j = 0;
	int shiftFor = shift;

	if (key[groupNumber] == 'а')
	{
		if (shift < 0)
			shift += cipherAlphabetSize;
		key[groupNumber] = alphabet[shift];
	}
	else
	{
		int superiority;
		while (key[groupNumber] != alphabet[++j]);
		shift += j;
		superiority = (int)shift / cipherAlphabetSize;
		if (abs(superiority) >= 1)
			shift -= superiority * cipherAlphabetSize;
		key[groupNumber] = alphabet[abs(shift)];
	}

	if (shiftFor > 0)
		for (auto i = 0; i < shiftFor; i++)
		{
			auto it = (columnsFrequency[groupNumber]).info.begin();
			(columnsFrequency[groupNumber]).info.push_back(*it);
			columnsFrequency[groupNumber].info.erase((columnsFrequency[groupNumber]).info.begin());
		}
	else
		for (auto i = 0; i < abs(shiftFor); i++)
		{
			auto it = (columnsFrequency[groupNumber]).info.end() - 1;
			columnsFrequency[groupNumber].info.insert((columnsFrequency[groupNumber]).info.begin(), *it);
			columnsFrequency[groupNumber].info.erase((columnsFrequency[groupNumber]).info.end() - 1);
		}

}

void displayWorkSpace(Frequency analyticalTextFrequency, std::vector<Frequency> columnsFrequency, std::string key, int groupNumber)
{
	HANDLE hOUTPUT = GetStdHandle(STD_OUTPUT_HANDLE);

	system(""cls"");

	std::cout << ""           "";
	SetConsoleTextAttribute(hOUTPUT, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
	for (auto i = 0; i < analyticalTextFrequency.info.size(); i++)
		std::cout << std::setw(4) << i + 1;

	SetConsoleTextAttribute(hOUTPUT, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
	std::cout << ""\n           "";
	for (auto it : analyticalTextFrequency.info)
		std::cout << std::setw(4) << it.word;

	std::cout << ""\n           "";
	for (auto it : analyticalTextFrequency.info)
		if (it.count >= threshold)
		{
			SetConsoleTextAttribute(hOUTPUT, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
			std::cout << std::setw(4) << it.count;
			SetConsoleTextAttribute(hOUTPUT, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		}
		else
			std::cout << std::setw(4) << it.count;

	int count = 0;
	std::cout << ""\n"";
	for (auto it : columnsFrequency)
	{
		count++;
		if (count - 1 == groupNumber)
		{
			SetConsoleTextAttribute(hOUTPUT, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
			for (auto i = 0; i < 143; i++)
				std::cout << ""-"";
			std::cout << ""\n"";
			SetConsoleTextAttribute(hOUTPUT, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		}

		if (count >= 10)
			std::cout << count << ""-я группа"";
		else
			std::cout << count << ""-я группа "";

		for (auto i : it.info)
			if (i.count >= threshold)
			{
				SetConsoleTextAttribute(hOUTPUT, FOREGROUND_RED | FOREGROUND_INTENSITY);
				std::cout << std::setw(4) << i.count;
				SetConsoleTextAttribute(hOUTPUT, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
			}
			else
				std::cout << std::setw(4) << i.count;

		std::cout << ""\n"";
		if (count - 1 == groupNumber)
		{
			SetConsoleTextAttribute(hOUTPUT, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
			for (auto i = 0; i < 143; i++)
				std::cout << ""-"";
			std::cout << ""\n"";
			SetConsoleTextAttribute(hOUTPUT, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		}
	}

	std::cout << ""\nПредполагаемый ключ: "" << key << ""\n"";
}

void determineKey(Frequency analyticalTextFrequency, std::vector<Frequency> columnsFrequency, int cipherAlphabetSize, std::vector<std::string> columns, std::string decryptedTextFileName)
{
	int  [MASK]  = 0;
	int groupNumber = 0;
	int shift;
	std::string key;

	for (auto i = 0; i < keyLength; i++)
		key += ""а"";

	while (true)
	{
		displayWorkSpace(analyticalTextFrequency, columnsFrequency, key, groupNumber);
		std::cout << ""Группа: "";
		std::cin >> groupNumber;

		if (groupNumber == 0)
			break;

		if (groupNumber == -1)
		{
			displayDecryptedText(key, columns);
			system(""pause"");
			continue;
		}

		if (groupNumber < -2 || groupNumber > keyLength)
		{
			std::cout << ""Неверные данные.\n"";
			system(""pause"");
			continue;
		}

		if (groupNumber >  [MASK] )
			 [MASK]  = groupNumber;

		if (groupNumber > 0)
			groupNumber -= 1;

		while (true)
		{
			std::cout << ""Сдвиг: "";
			std::cin >> shift;

			if (shift == 0)
				break;

			if (groupNumber == -2 && abs(shift - 1) < keyLength)  //отмена всех действий для группы с номером shift -1
			{
				std::sort((columnsFrequency[shift - 1.0]).info.begin(), (columnsFrequency[shift - 1.0]).info.end(), Compare(alphabet));
				key[shift - 1.0] = 'а';

				displayWorkSpace(analyticalTextFrequency, columnsFrequency, key, groupNumber);
				std::cout << ""Группа: "" << groupNumber << ""\n"";
				continue;
			}

			if (abs(shift) > cipherAlphabetSize || abs(groupNumber - 1) > keyLength)
			{
				std::cout << ""Неверные данные.\n"";
				system(""pause"");
				continue;
			}

			shift *= -1;
			generaateKey(columnsFrequency, key, groupNumber, shift, cipherAlphabetSize);

			displayWorkSpace(analyticalTextFrequency, columnsFrequency, key, groupNumber);
			std::cout << ""Группа: "" << groupNumber + 1 << ""\n"";
		}
	}

	displayDecryptedText(key, columns);
	save(key, columns, decryptedTextFileName);
}

void findAlphabetSize(int& cipherAlphabetSize, std::string text)
{
	std::set<char> cipherAlphabet;

	for (auto it : text)
		cipherAlphabet.insert(it);

	cipherAlphabetSize = cipherAlphabet.size();
}

void calculateFrequency(std::string text, Frequency& freq)
{
	for (auto it : alphabet)
		freq.info.push_back(Symbol(it, 0));

	int n = text.length();
	for (auto i = 0; i < n; i++)
	{
		bool yes = true;

		for (auto j = freq.info.begin(); j != freq.info.end(); j++)
		{
			if ((*j).word == text[i])
			{
				Symbol temp((*j).word, (*j).count + 1);
				freq.info.erase(j);
				freq.info.push_back(temp);
				yes = false;
				break;
			}
		}
		if (yes)
			freq.info.push_back(Symbol(text[i], 1));
	}

	std::sort(freq.info.begin(), freq.info.end(), Compare(alphabet));
}

void createColumns(std::string encryptedText, std::vector<std::string>& columns)  // не использет последние символы (поледнюю строку т.к. она может быть не полной)
{
	std::string temp;
	int size = (int)encryptedText.size() / keyLength;

	for (auto j = 0; j < keyLength; j++)
	{
		temp.clear();
		for (auto i = 0; i < size; i++)
			temp += encryptedText[j + i * keyLength];

		columns.push_back(temp);
	}
}

void findKeyValue(std::string encryptedText, std::string analiticalTextFileName, std::string decryptedTextFileName)
{
	std::string analiticalText;
	std::vector<std::string> columns;
	std::vector<Frequency>  columnsFrequency;
	Frequency analyticalTextFrequency;

	createColumns(encryptedText, columns);  //формируем массив строк из шифртекста по столбцам


	readFile(analiticalText, analiticalTextFileName);  //считываем аналилитечкий текст
	deleteForbiddenSymbols(analiticalText);

	if (analiticalText.size() < columns[1].size()) {
		std::cout << ""Аналитический текст получился меньше зашифрованного текста!\nВозможно несоответствие алфавитов!\n"";
		exit(0);
	}

	analiticalText.erase(columns[1].size(), analiticalText.size());  // удаляем лишний аналитический текст

	calculateFrequency(analiticalText, analyticalTextFrequency);  // частотный анализ аналитического текста

	Frequency buffEncryptedTextFrequency;
	for (auto it : columns)  //в цикле формируем частотный анализ шифроткста по группам (по столбикам)
	{
		buffEncryptedTextFrequency.info.clear();
		calculateFrequency(it, buffEncryptedTextFrequency);
		columnsFrequency.push_back(buffEncryptedTextFrequency);
	}

	int cipherAlphabetSize;
	findAlphabetSize(cipherAlphabetSize, encryptedText);

	determineKey(analyticalTextFrequency, columnsFrequency, cipherAlphabetSize, columns, decryptedTextFileName);

}

void findKeyLength(std::string encryptedText)
{
	int count;
	std::vector<double> coincidenceCount;
	std::string buffText(encryptedText);

	for (auto i = 0; i < maxKeyLength; i++)
	{
		count = 0;
		buffText.push_back(buffText.front());
		buffText.erase(0, 1);

		for (auto it = 0; it < encryptedText.size(); it++)
			if (encryptedText[it] == buffText[it])
				count++;

		coincidenceCount.push_back((double)count / encryptedText.size());
	}

	std::cout << ""Вероятные длины ключей: \n"";
	for (auto it = 0; it < maxKeyLength; it++)
		std::cout << std::setw(3) << it + 1 << "" - "" << coincidenceCount[it] << ""\n"";

	std::cout << ""Введите длину ключа: \n"";
	std::cin >> keyLength;
}


bool cmdOptionExists(char** begin, char** end, const std::string& option)
{
	return std::find(begin, end, option) != end;
}

std::string getCmdOption(int argc, char* argv[], const std::string& option)
{
	std::string cmd;

	for (short i = 0; i < argc; ++i)
	{
		std::string arg = argv[i];

		if (0 == arg.find(option))
			if (i + 1 < argc)
				return argv[i + 1];
	}

	return cmd;
}

void parse_arguments(int argc, char* argv[], std::string& analiticalTextFileName, std::string& encryptedTextFileName, std::string& decryptedTextFileName)
{
	if (cmdOptionExists(argv, argv + argc, ""-h""))
	{
		std::cout << ""Использование: Vigener -i [путь к файлу с шифртекстом] -ia [путь к файлу с аналитическим текстом]\n\n"";
		std::cout << ""Параметры:\n\n"";
		std::cout << ""-i  Задает путь к файлу с шифртекстом\n"";
		std::cout << ""-ia Задает путь к файлу с аналитическим текстом\n"";
		std::cout << ""-o  Задает путь к файлу для сохранения результата работы программы. По умолчанию - путь файла шифртекста с меткой {processed}\n"";
		std::cout << ""-a  Задает алфавит шифртекста. По умолчанию - кириллица\n"";
		std::cout << ""-af Задает путь к файлу с алфавитом шифртекста\n"";
		std::cout << ""-t  Задает порог для выделения статистики. По умолчанию 6\n"";
		std::cout << ""-k  Задает длину ключа\n"";
		std::cout << ""-mk Задает максимальную длину ключа\n\n"";

		std::cout << ""При вводе номера группы также можно указать следуюшие значения:\n\n"";
		std::cout << "" 0: выход из программы с сохранением результата работы. Ctrl + C - выход без сохранения результата\n"";
		std::cout << ""-1: вывести декодированный шифртекст при текущем ключе\n"";
		std::cout << ""-2: перейти в режим отмены сдвигов в группах. При вводе сдвига нужно указать номер группу,\nдля которой необходимо отменить все действия.\nДля выхода из режима необходимо ввести значение 0 в поле номера группы.\n\n"";
		std::cout << ""При вводе сдвига группы указывается положительное или отрицательное значение для\nциклического сдвига статистики вправо или влево соответсвенно.\nДля выхода из текушей группы необходимо ввести значение 0 в поле сдвига.\n\n"";

		exit(0);
	}

	// Инициализация encryptedTextFileName
	if (cmdOptionExists(argv, argv + argc, ""-i""))
		encryptedTextFileName = getCmdOption(argc, argv, ""-i"");
	else
	{
		std::cout << ""Необходимо указать путь к файлу с шифртекстом.\nИспользуйте параметр -i.\n\n"";
		exit(0);
	}

	// Инициализация analiticalTextFileName
	if (cmdOptionExists(argv, argv + argc, ""-ia""))
		analiticalTextFileName = getCmdOption(argc, argv, ""-ia"");
	else
	{
		std::cout << ""Необходимо указать путь к файлу с аналитическим текстом.\nИспользуйте параметр -ia.\n\n"";
		exit(0);
	}

	// Инициализация decryptedTextFileName
	if (cmdOptionExists(argv, argv + argc, ""-o""))
		decryptedTextFileName = getCmdOption(argc, argv, ""-o"");
	else
	{
		decryptedTextFileName = encryptedTextFileName;

		size_t pos = decryptedTextFileName.find(""."");
		if (pos != std::string::npos)
			decryptedTextFileName.insert(pos, "" {processed}"");
		else
			decryptedTextFileName += "" {processed}"";
	}

	// Инициализация alphabet
	if (cmdOptionExists(argv, argv + argc, ""-a""))
		alphabet = getCmdOption(argc, argv, ""-a"");
	else if (cmdOptionExists(argv, argv + argc, ""-af""))
		readFile(alphabet, getCmdOption(argc, argv, ""-af""));
	else
		alphabet = ""абвгдеёжзийклмнопрстуфхцчшщъыьэюя"";

	// Инициализация threshold
	if (cmdOptionExists(argv, argv + argc, ""-t""))
	{
		try
		{
			threshold = std::stoi(getCmdOption(argc, argv, ""-t""));

			if (threshold < 0)
				throw ""Error"";
		}
		catch (...)
		{
			std::cout << ""Неверно указан порог - положитльное число.\n\n"";
			exit(0);
		}
	}
	else
		threshold = 6;

	// Инициализация keyLength
	if (cmdOptionExists(argv, argv + argc, ""-k""))
	{
		try
		{
			keyLength = std::stoi(getCmdOption(argc, argv, ""-k""));

			if (keyLength < 0)
				throw ""Error"";
		}
		catch (...)
		{
			std::cout << ""Неверно указана длина ключа - положитльное число.\n\n"";
			exit(0);
		}
	}
	else
		keyLength = 0;

	// Инициализация maxKeyLength
	if (cmdOptionExists(argv, argv + argc, ""-mk""))
	{
		try
		{
			maxKeyLength = std::stoi(getCmdOption(argc, argv, ""-mk""));

			if (maxKeyLength <= 0)
				throw ""Error"";
		}
		catch (...)
		{
			std::cout << ""Неверно указана максимальная длина ключа - положитльное число.\n\n"";
			exit(0);
		}
	}
	else
		maxKeyLength = 26;
}


int main(int argc, char* argv[])
{
	setlocale(LC_ALL, ""Rus"");
	SetConsoleCP(.1251);
	SetConsoleOutputCP(.1251);

	std::string encryptedTextFileName = ""tests/Encrypted text.txt"";
	std::string decryptedTextFileName = ""tests/Encrypted text {processed}.txt"";
	std::string analiticalTextFileName = ""tests/Analytical text.txt"";

	parse_arguments(argc, argv, analiticalTextFileName, encryptedTextFileName, decryptedTextFileName);

	std::string encryptedText;

	readFile(encryptedText, encryptedTextFileName);
	deleteForbiddenSymbols(encryptedText);

	if (!keyLength)
		findKeyLength(encryptedText);

	findKeyValue(encryptedText, analiticalTextFileName, decryptedTextFileName);

	return 0;
}",maxGroup
110,"#include <vector>
#include <chrono>
#include <iostream>
#include <cmath>
#include <bitset>
#include <ctime>

#include <omp.h>

#include ""NTL/ZZX.h""

#include ""helib/FHE.h""
#include ""helib/EncryptedArray.h""

// ! Note: HElib pre 1.0.0 uses findBaseLevel and HElib 1.0.0 uses capacity

#define new_simd 0

NTL::ZZX long2Poly(long query) {
    NTL::ZZX queryPoly;
    queryPoly.SetLength(64);
    std::bitset<64> queryBits = query;

    for (int i = 0; i < queryBits.size(); i++) {
        NTL::SetCoeff(queryPoly, i, queryBits[i]);
    }
    queryPoly.normalize();

    return queryPoly;
}

NTL::ZZX char2Poly(char character) {
    int charCode = character;
    NTL::ZZX resultPoly;

    resultPoly = long2Poly((long) charCode);

    return resultPoly;
}

long poly2Long(NTL::ZZX result) {
    long resultLong = 0;
    for (int i = 0; i <= deg(result); i++) {
        resultLong += (1L << i) * (NTL::coeff(result, i) == NTL::ZZ(1));
    }
    return resultLong;
}

char poly2Char(NTL::ZZX result) {
    char character;

    character = (int) poly2Long(result);

    return character;
}

void fastPower(Ctxt &dataCtxt, long degree) {
    // Taken from eqtesting.cpp so that there are fewer includes
    if (degree == 1) return;
    Ctxt orig = dataCtxt;
    long k = NTL::NumBits(degree);
    long e = 1;
    for (long i = k - 2; i >= 0; i--) {
        Ctxt tmp1 = dataCtxt;
        tmp1.smartAutomorph(1L << e); // 1L << e computes 2^e
        dataCtxt.multiplyBy(tmp1);
        e = 2 * e;
        if (NTL::bit(degree, i)) {
            dataCtxt.smartAutomorph(2);
            dataCtxt.multiplyBy(orig);
            e += 1;
        }
    }
}

void equalTest(Ctxt &resultCtxt, const Ctxt &queryCtxt, const Ctxt &dataCtxt,
               long degree) {
    Ctxt tempCtxt = dataCtxt;
    tempCtxt = dataCtxt;
    tempCtxt -= queryCtxt;
    fastPower(tempCtxt, degree);
    tempCtxt.negate();
    tempCtxt.addConstant(NTL::ZZ(1));
    resultCtxt = tempCtxt;
}

void treeMultHelper(Ctxt &resultCtxt, std::vector<Ctxt> &currentLayer, std::vector<Ctxt> &nextLayer) {
    unsigned long previousSize = currentLayer.size();
    if (previousSize == 0) {
        return;
    } else if (previousSize == 1) {
        resultCtxt = currentLayer[0];
        return;
    }
    nextLayer.resize((previousSize / 2 + previousSize % 2), resultCtxt);
#pragma omp parallel for
    for (unsigned long i = 0; i < previousSize / 2; i++) {
        currentLayer[2 * i].multiplyBy(currentLayer[2 * i + 1]);
        nextLayer[i] = currentLayer[2 * i];
    }

    if (previousSize % 2 == 1) {
        nextLayer[nextLayer.size() - 1] = (currentLayer[previousSize - 1]);
    }
    currentLayer.clear();
    treeMultHelper(resultCtxt, nextLayer, currentLayer);
}

void treeMult(Ctxt &resultCtxt, const std::vector<Ctxt> &ctxtVec) {
    if (ctxtVec.size() > 1) {
        std::vector<Ctxt> currentLayer, nextLayer;
        currentLayer = ctxtVec;
        nextLayer.clear();
        treeMultHelper(resultCtxt, currentLayer, nextLayer);
    } else {
//        std::cout << ""Only 1 Ciphertext; No Multiplication Done."" << std::endl;
        resultCtxt = ctxtVec[0];
    }
}

void oneTotalProduct(Ctxt &resultCtxt, const Ctxt &dataCtxt, const long wordLength, const EncryptedArray &ea) {

    long numWords = floor(ea.size() / wordLength);
    resultCtxt = dataCtxt;
    if (wordLength == 1) {
        return;
    }
    long shiftAmt = 1;

    // auto startTime = std::chrono::high_resolution_clock::now();
    // auto endTime = std::chrono::high_resolution_clock::now();
    // std::chrono::duration<double> timeTaken = endTime - startTime;

    while (shiftAmt < wordLength) {
        // startTime = std::chrono::high_resolution_clock::now();
        Ctxt tempCtxt = resultCtxt;
#if new_simd
        ea.shift(tempCtxt, (-shiftAmt*numWords));
#else
         ea.shift(tempCtxt, (-shiftAmt));
#endif
        resultCtxt.multiplyBy(tempCtxt); // ctxt = ctxt * (ctxt << ""shiftAmt"")

        shiftAmt = 2 * shiftAmt;
        // endTime = std::chrono::high_resolution_clock::now();
        // timeTaken = endTime-startTime;
        // std::cout << shiftAmt << "", Time Taken: "" << timeTaken.count() << std::endl;
    }
}

void makeMask(NTL::ZZX &maskPoly, const long shiftAmt, const bool  [MASK] , const long wordLength,
              const EncryptedArray &ea) {
    std::vector<NTL::ZZX> maskVec, oneMaskVec;
    if ( [MASK] ) {
        maskVec.assign(shiftAmt, NTL::ZZX(1));
        oneMaskVec.assign(wordLength - shiftAmt, NTL::ZZX(0));
    } else {
        maskVec.assign(shiftAmt, NTL::ZZX(0));
        oneMaskVec.assign(wordLength - shiftAmt, NTL::ZZX(1));
    }
    maskVec.insert(maskVec.end(), oneMaskVec.begin(), oneMaskVec.end());

    std::vector<NTL::ZZX> fullMaskVec = maskVec;
    for (unsigned long i = 2 * wordLength; i < ea.size(); i += wordLength) {
        fullMaskVec.insert(fullMaskVec.end(), maskVec.begin(), maskVec.end());
    }

    fullMaskVec.resize(ea.size(), NTL::ZZX(0));
    ea.encode(maskPoly, fullMaskVec);
}

void simdShift(Ctxt &ciphertextResult, Ctxt &ciphertextData, const long shiftAmt, const long wordLength,
               const EncryptedArray &ea) {
    Ctxt tempCiphertext = ciphertextData;
    if (shiftAmt > 0) {
        NTL::ZZX maskPoly;
        makeMask(maskPoly, shiftAmt, 0, wordLength, ea);

        ea.shift(tempCiphertext, shiftAmt);
        tempCiphertext.multByConstant(maskPoly);
    } else if (shiftAmt < 0) {
        NTL::ZZX maskPoly;
        makeMask(maskPoly, -shiftAmt, 0, wordLength, ea);

        tempCiphertext.multByConstant(maskPoly);
        ea.shift(tempCiphertext, shiftAmt);
    }
    ciphertextResult = tempCiphertext;
}


int main(int argc, char *argv[]) {

    if (argc != 5) {
        std::cerr << ""Wrong inputs!"";
        std::cerr << std::endl << ""Inputs: level m attrLength conjSize"" << std::endl;
        return 1;
    }
    long p = 2;
    long r = 1;
    // long m = 31775; 32767
    // long L = 29; 31

    long m = atoi(argv[2]);
    long L = atoi(argv[1]);
//    double heuristicSecurity = (3 * eulerTot(m) * 7.2) / ((L + 1) * 22 * 4) - 110;

    // Define wildcard charaters
    char blankChar = 2;
    char wcChar = 3;
    char excludeChar = 4;

    // Timers
    auto startTime = std::chrono::high_resolution_clock::now();
    auto endTime = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> timeTaken = endTime - startTime;
    float totalTime = 0;

    // FHE instance initialization
    FHEcontext context(m, p, r);
    buildModChain(context, L);
    NTL::ZZX F = context.alMod.getFactorsOverZZ()[0];

    FHESecKey secretKey(context);
    const FHEPubKey &publicKey = secretKey;
    secretKey.GenSecKey(64);
    addFrbMatrices(secretKey);
    addBSGS1DMatrices(secretKey);
    EncryptedArray ea(context, F);

    long numSlots = ea.size();
    long plaintextDegree = ea.getDegree();

    long wordLength = atoi(argv[3]);
    long queryLength = 17;
    long numWords = floor(numSlots / wordLength);
    long numEmpty = numSlots % wordLength;

    long conjSize = atoi(argv[4]);

    // Output parameters to log
    IndexSet allPrimes(0, context.numPrimes() - 1);
    std::clog << m << "", "" << L << "", "" << context.logOfProduct(context.ctxtPrimes) / log(2.0) << "", "" <<  context.logOfProduct(allPrimes) / log(2.0) << "", "" << p << "", "" << plaintextDegree
         << "", "" << numSlots << "", "";

    // Process the strings, one attribute and one query pattern of type %W%,
    // * wildcard is encoded as ASCII code 2
    // # wildcard is encoded as ASCII code 3

    std::string attrString = ""spares"";
    std::cout << std::endl << ""Attribute String: "" << attrString << std::endl;

    std::vector<NTL::ZZX> plaintextAttr;
#if new_simd
    for(long i = 0; i < attrString.length(); i++)
        plaintextAttr.resize((i+1)*numWords, char2Poly(attrString[i]));
    for(long i = attrString.length(); i < wordLength; i++)
        plaintextAttr.resize((i+1)*numWords, plaintextAttr[i] = char2Poly(blankChar));
#else
    plaintextAttr.resize(numSlots-numEmpty, NTL::ZZX(0));
    for (unsigned long i = 0; i < attrString.length(); i++) 
        plaintextAttr[i] = char2Poly(attrString[i]);
    for (unsigned long i = attrString.length(); i < wordLength; i++)
        plaintextAttr[i] = char2Poly(blankChar);
    for (unsigned long i = wordLength; i < numSlots - numEmpty; i++)
        plaintextAttr[i] = plaintextAttr[i % wordLength];    
#endif
    plaintextAttr.resize(numSlots, NTL::ZZX(0));

    // ""$"" is the wildcard character symbol
    std::string queryString = ""sp"";
    queryString += wcChar;
    queryString += excludeChar;
    queryString += ""c"";
    queryString += ""e"";
    queryLength = queryString.length();
    std::cout << ""Query Pattern: "" << queryString << std::endl;

    std::vector<NTL::ZZX> plaintextQuery, plaintextE;
    std::vector<NTL::ZZX> plaintextConjunction((unsigned long) numSlots, long2Poly(rand() % (1L << 7)));

#if new_simd
    int counter = 0;
    for (unsigned long i = 0; i < queryString.length(); i++) {
        if (queryString[i] == wcChar) {
            plaintextQuery.resize((i+1)*numWords, char2Poly(queryString[i]));
            plaintextE.resize((counter+1)*numWords, NTL::ZZX(1));
            counter++;
        } else if (queryString[i] == excludeChar) {
            plaintextQuery.resize((i+1)*numWords, char2Poly(queryString[i+1]));
            plaintextE.resize((counter+1)*numWords, NTL::ZZX(1));
            // plaintextQuery[counter] =
            i += 1;
            counter++;
        } else {
            plaintextQuery.resize((i+1)*numWords, char2Poly(queryString[i]));
            plaintextE.resize((counter+1)*numWords, NTL::ZZX(0));
            plaintextQuery[counter] = char2Poly(queryString[i]);
            counter++;
        }
        // std::cout << i << "", "" << counter << std::endl;
    }
    for (unsigned long i = counter; i < wordLength; i++) {
        plaintextQuery.resize((i+1)*numWords, char2Poly(wcChar));
        plaintextE.resize((i+1)*numWords, NTL::ZZX(1));
    }
    
#else
    plaintextQuery.resize(numSlots-numEmpty, NTL::ZZX(0));
    plaintextE.resize(numSlots-numEmpty, NTL::ZZX(0));
    int counter = 0;
    for (unsigned long i = 0; i < queryString.length(); i++) {
        if (queryString[i] == wcChar) {
            plaintextQuery[counter] = char2Poly(excludeChar);
            plaintextE[counter] = 1;
            counter++;
        } else if (queryString[i] == excludeChar) {
            plaintextQuery[counter] = char2Poly(queryString[i + 1]);
            plaintextE[counter] = 1;
            i += 1;
            counter++;
        } else {
            plaintextQuery[counter] = char2Poly(queryString[i]);
            counter++;
        }
    }
    for (unsigned long i = counter; i < wordLength; i++) {
        plaintextQuery[i] = char2Poly(wcChar);
        plaintextE[i] = 1;
    }
    for (unsigned long i = wordLength; i < numSlots - numEmpty; i++) {
        plaintextQuery[i] = plaintextQuery[i % wordLength];
        plaintextE[i] = plaintextE[i % wordLength];
    }
#endif
    plaintextQuery.resize(numSlots, NTL::ZZX(0));
    plaintextE.resize(numSlots, NTL::ZZX(0));

    std::vector<NTL::ZZX> plaintextResult((unsigned long) numSlots - numEmpty, NTL::ZZX(1));
    plaintextResult.resize(numSlots, NTL::ZZX(0));

    // for (unsigned long i = 0; i < plaintextAttr.size(); i++) {
    //     std::cout << poly2Char(plaintextAttr[i]) << "", "";
    // }
    // std::cout << std::endl;
    // for (unsigned long i = 0; i < plaintextQuery.size(); i++) {
    //     std::cout << poly2Char(plaintextQuery[i]) << "", "";
    // }
    // std::cout << std::endl;
    // for (unsigned long i = 0; i < plaintextE.size(); i++) {
    //     std::cout << plaintextE[i] << "", "";
    // }
    // std::cout << std::endl;

    // for(unsigned long i = wordLength; i < 2*wordLength; i++) {
    //     std::cout << poly2Char(plaintextAttr[i]) << "", "";
    // }
    // std::cout << std::endl;
    // for(unsigned long i = wordLength; i < 2*wordLength; i++) {
    //     std::cout << poly2Char(plaintextQuery[i]) << "", "";
    // }
    // std::cout << std::endl;
    // for(unsigned long i = wordLength; i < 2*wordLength; i++) {
    //     std::cout << plaintextE[i] << "", "";
    // }
    // std::cout << std::endl;

    std::clog << wordLength << "", "" << queryLength << "", "" << numWords << "", "";

    std::cout << ""Plaintext Processing Done!"" << std::endl;

    // Initialize and encrypt ciphertexts
    Ctxt ciphertextAttr(publicKey);
    Ctxt ciphertextQuery(publicKey);
    Ctxt tempCiphertext(publicKey);
    Ctxt ciphertextE(publicKey);
    Ctxt ciphertextResult(publicKey);
    Ctxt conjResult(publicKey);
//        Ctxt conjQuery(publicKey);
//        Ctxt conjCtxt(publicKey);

    ea.encrypt(ciphertextAttr, publicKey, plaintextAttr);
    ea.encrypt(ciphertextQuery, publicKey, plaintextQuery);
    ea.encrypt(ciphertextE, publicKey, plaintextE);
//        ea.encrypt(conjCtxt, publicKey, plaintextConjunction);
//        ea.encrypt(conjQuery, publicKey, plaintextConjunction);

    Ctxt oneCiphertext(publicKey);
    Ctxt zeroCiphertext(publicKey);

    std::vector<NTL::ZZX> onePlaintext(numSlots, NTL::ZZX(1));

    ea.encrypt(oneCiphertext, publicKey, onePlaintext);
    zeroCiphertext = oneCiphertext;
    zeroCiphertext -= oneCiphertext;

    // Initialize components
    std::vector<Ctxt> ciphertextWs, ciphertextRs, ciphertextSs, ciphertextDs;
    for (unsigned long i = 0; i < wordLength; i++) {
        ciphertextWs.push_back(ciphertextAttr);
        ciphertextRs.push_back(ciphertextAttr);
        ciphertextSs.push_back(ciphertextAttr);
    }

    for (unsigned long i = 0; i < wordLength; i++) {
        if (i <= wordLength - queryLength) {
            ciphertextDs.push_back(oneCiphertext);
        } else {
            ciphertextDs.push_back(zeroCiphertext);
        }
    }

    // For compound conjunction queries
    std::vector<Ctxt> ciphertextConj;
    std::vector<Ctxt> ciphertextConjResult;
    for (unsigned long i = 0; i < conjSize; i++) {
        ciphertextConj.push_back(ciphertextAttr);
        ciphertextConjResult.push_back(ciphertextAttr);
    }

    std::cout << ""Encryption Done!"" << std::endl;

    NTL::ZZX selectPoly;
    NTL::ZZX queryMask, finalMask;
    makeMask(selectPoly, 1, 1, wordLength, ea);
    makeMask(finalMask, wordLength, 1, wordLength, ea);

    // Step 1: Shift the attributes
    //     Remnants of experiment to pack differently, all characters of the same slot first
    //     But the shift time is much longer than packing word by word

    //     startTime = std::chrono::high_resolution_clock::now();
    // #pragma omp parallel for
    //     for(unsigned long i = 1; i < ciphertextWs.size(); i++) {
    //             ea.shift(ciphertextWs[i],-i*numWords);
    //     }
    //     endTime = std::chrono::high_resolution_clock::now();
    //     timeTaken = endTime-startTime;
    //     totalTime += timeTaken.count();
    //     std::cout << ""Pre-compute Time: "" << timeTaken.count() << std::endl;

    startTime = std::chrono::high_resolution_clock::now();
#pragma omp parallel for
    for (unsigned long i = 1; i < ciphertextWs.size(); i++) {
#if new_simd
        ea.shift(ciphertextWs[i], (-i*numWords));
#else
        simdShift(ciphertextWs[i], ciphertextAttr, -i, wordLength, ea);
#endif   
    }
    endTime = std::chrono::high_resolution_clock::now();
    timeTaken = endTime - startTime;
    // totalTime += timeTaken.count();
    std::cout << ""Pre-compute Time: "" << timeTaken.count() << std::endl;
    std::clog << timeTaken.count() << "", "";

    // for(unsigned long i = 0; i < ciphertextWs.size(); i++) {
    //         ea.decrypt(ciphertextWs[i],secretKey,plaintextResult);
    //         std::cout << poly2Char(plaintextResult[0]) << "", "";
    // }
    // std::cout << std::endl;

    // Step 2: Test if the characters are the same
    startTime = std::chrono::high_resolution_clock::now();
#pragma omp parallel for
    for (unsigned long i = 0; i < ciphertextWs.size() + conjSize; i++) {
        if (i < ciphertextWs.size()) {
            ciphertextWs[i] += ciphertextQuery;
        } else {
            ciphertextConj[i - ciphertextWs.size()] += ciphertextAttr;
        }
    }
    endTime = std::chrono::high_resolution_clock::now();
    timeTaken = endTime - startTime;
    totalTime += timeTaken.count();
    std::cout << ""XOR Time: "" << timeTaken.count() << std::endl;

    startTime = std::chrono::high_resolution_clock::now();
#pragma omp parallel for
    for (unsigned long i = 0; i < ciphertextWs.size() + conjSize; i++) {
        if (i < ciphertextWs.size()) {
            equalTest(ciphertextRs[i], zeroCiphertext, ciphertextWs[i], plaintextDegree);
        } else {
            equalTest(ciphertextConjResult[i - ciphertextWs.size()], zeroCiphertext,
                      ciphertextConj[i - ciphertextWs.size()], plaintextDegree);
        }
        // }
        // for(unsigned long i = 0; i < ciphertextRs.size(); i++) {
        if (i < ciphertextWs.size()) {
            ciphertextRs[i] += ciphertextE;
        }
    }
    endTime = std::chrono::high_resolution_clock::now();
    timeTaken = endTime - startTime;
    totalTime += timeTaken.count();
    std::cout << ""Level left: "" << ciphertextRs[1].capacity() << "", Equality Check + eMask Time: "" << timeTaken.count() << std::endl;
    std::clog << timeTaken.count() << "", "";

    // Step 3: Combine results of character tests per shift
    startTime = std::chrono::high_resolution_clock::now();
#pragma omp parallel for
    for (unsigned long i = 0; i < ciphertextRs.size() + conjSize; i++) {
        if (i < ciphertextRs.size()) {
            oneTotalProduct(ciphertextSs[i], ciphertextRs[i], wordLength, ea);
        } else if (conjSize > 0) {
            oneTotalProduct(ciphertextConj[i - ciphertextRs.size()], ciphertextConjResult[i - ciphertextRs.size()],
                            wordLength, ea);
        }
    }
    endTime = std::chrono::high_resolution_clock::now();
    timeTaken = endTime - startTime;
    totalTime += timeTaken.count();
    std::cout << ""Level left: "" << ciphertextSs[1].capacity() << "", Product of Equalities: "" << timeTaken.count() << std::endl;
    std::clog << timeTaken.count() << "", "";

    // Step 4: Combine results from testing every possible shift
    startTime = std::chrono::high_resolution_clock::now();
#pragma omp parallel for
    for (unsigned long i = 0; i < ciphertextSs.size(); i++) {
        ciphertextSs[i].multiplyBy(ciphertextDs[i]);
        ciphertextSs[i].addConstant(selectPoly);
    }
    endTime = std::chrono::high_resolution_clock::now();
    timeTaken = endTime - startTime;
    totalTime += timeTaken.count();
    std::cout << ""Level left: "" << ciphertextSs[1].capacity() << "", Disjunction Prep Time: "" << timeTaken.count() << std::endl;
    std::clog << timeTaken.count() << "", "";

    startTime = std::chrono::high_resolution_clock::now();
    treeMult(ciphertextResult, ciphertextSs);
    ciphertextResult.addConstant(selectPoly);

    if (conjSize > 0) {
        treeMult(conjResult, ciphertextConj);
        ciphertextResult.multiplyBy(conjResult);
    }
    // ciphertextResult.multByConstant(finalMask);
    endTime = std::chrono::high_resolution_clock::now();
    timeTaken = endTime - startTime;
    totalTime += timeTaken.count();
    std::cout << ""Level left: "" << ciphertextResult.capacity() << "", Disjunction Time: "" << timeTaken.count() << std::endl;
    std::clog << timeTaken.count() << "", "";

    std::clog << totalTime << "", "";

    startTime = std::chrono::high_resolution_clock::now();
    tempCiphertext = ciphertextResult;
#pragma omp parallel for
    for (unsigned long i = 1; i < wordLength; i++) {
        ciphertextWs[i] = ciphertextResult;
        ea.shift(ciphertextWs[i], i);
    }
    for (unsigned long i = 1; i < wordLength; i++) {
        tempCiphertext += ciphertextWs[i];
    }
    tempCiphertext.multiplyBy(ciphertextAttr);
    endTime = std::chrono::high_resolution_clock::now();
    timeTaken = endTime - startTime;
    // totalTime += timeTaken.count();
    std::cout << ""Level left: "" << tempCiphertext.capacity() << "", Fill + Selection Time: "" << timeTaken.count() << std::endl;
    std::clog << timeTaken.count() << "", "";

    std::cout << ""Total Time: "" << totalTime << std::endl;

    ea.decrypt(ciphertextResult, secretKey, plaintextResult);
    for (unsigned long i = 0; i < wordLength; i++) {
        std::cout << poly2Long(plaintextResult[i]) << "", "";
    }
    std::cout << std::endl;

    ea.decrypt(tempCiphertext, secretKey, plaintextResult);
    for (unsigned long i = 0; i < wordLength; i++) {
        std::cout << poly2Char(plaintextResult[i]) << "", "";
    }
    std::cout << std::endl;

    std::clog << poly2Char(plaintextResult[0]) << "", "";

//    ea.decrypt(ciphertextSs[0], secretKey, plaintextResult);
//    for (unsigned long i = 0; i < wordLength; i++) {
//        std::cout << poly2Long(plaintextResult[i]) << "", "";
//    }
//    std::cout << std::endl;
//
//    ea.decrypt(ciphertextRs[0], secretKey, plaintextResult);
//    for (unsigned long i = 0; i < wordLength; i++) {
//        std::cout << poly2Long(plaintextResult[i]) << "", "";
//    }
//    std::cout << std::endl;
//
//    ea.decrypt(ciphertextWs[0], secretKey, plaintextResult);
//    for (unsigned long i = 0; i < wordLength; i++) {
//        std::cout << poly2Long(plaintextResult[i]) << "", "";
//    }
//    std::cout << std::endl;

//        ea.decrypt(conjResult, secretKey, plaintextResult);
//        for(unsigned long i = 0; i < wordLength; i++) {
//            std::cout << poly2Long(plaintextResult[i]) << "", "";
//        }
//        std::cout << std::endl;

//        for(unsigned long i = 0; i < conjSize; i++) {
//            ea.decrypt(ciphertextConj[i],secretKey, plaintextResult);
//            for(unsigned long i = 0; i < wordLength; i++) {
//                std::cout << poly2Long(plaintextResult[i]) << "", "";
//            }
//            std::cout << std::endl;
//        }
//        std::cout << std::endl;
    std::clog << std::endl;
}
",invertSelection
111,"/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   PhoneBook.cpp                                      :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: otodd <<EMAIL>>         +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2024/11/18 15:43:51 by otodd             #+#    #+#             */
/*   Updated: 2025/01/21 14:41:01 by otodd            ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include ""../include/PhoneBook.hpp""

PhoneBook::PhoneBook()
{
	this->length = 0;
	for (int i = 0; i <= 7; i++)
		this->contacts[i].index = i;
}

void	PhoneBook::add(Contact *contact)
{
	contact->isPopulated = true;
	this->contacts[this->length % 8] = *contact;
	for (int i = 0; i <= 7; i++)
		this->contacts[i].index = i;
	this->length++;
}
    
std::string	PhoneBook::trunc(std::string str)
{
	std::string	tmp = """";
	for (int i = 0; str[i]; i++)
	{
		if (i == 9)
		{
			tmp += '.';
			break;
		}
		else
			tmp += str[i];
	}
	return (tmp);
}

void	PhoneBook::display(size_t index)
{
	if (index > 7)
	{
		std::cout << ""═  Invalid index."" << std::endl;
		return;
	}
	if (this->contacts[index].isPopulated)
	{
		std::stringstream tmp;
		tmp << (this->contacts[index].index + 1);
		std::cout << '\n' << ""╔ "" << ""Contact Index:          "" << tmp.str() << '\n';
		std::cout << ""╟ "" << ""Contact Firstname:      "" << this->contacts[index].firstName << '\n';
		std::cout << ""╟ "" << ""Contact Lastname:       "" << this->contacts[index].lastName << '\n';
		std::cout << ""╟ "" << ""Contact Nickname:       "" << this->contacts[index].nickname << '\n';
		std::cout << ""╟ "" << ""Contact Phone Number:   "" << this->contacts[index].phoneNumber << '\n';
		std::cout << ""╚ "" << ""Contact Darkest Secret: "" << this->contacts[index].darkestSecret << std::endl;
	}
	else
		std::cout << ""═  Contact index doesn't yet exist."" << std::endl;
}

bool	PhoneBook::display()
{
	if (!this->length)
	{
		std::cout << ""═  No records in phonebook."" << std::endl;
		return (false);
	}
	std::cout << "" ___________________________________________"" << std::endl;
	std::cout << ""|     Index|First Name|Last Name |Nickname  |"" << std::endl;
	for (int i = 0; i <= 7; i++)
	{
		if (this->contacts[i].isPopulated)
		{
			std::stringstream tmp;
			tmp << ""|"" << std::right << std::setw(10) << (this->contacts[i].index + 1);
			std::cout << std::right << std::setw(10) << tmp.str();
			std::cout << ""|"" << std::right << std::setw(10) << this->trunc(this->contacts[i].firstName);
			std::cout << ""|"" << std::right << std::setw(10) << this->trunc(this->contacts[i].lastName);
			std::cout << ""|"" << std::right << std::setw(10) << this->trunc(this->contacts[i].nickname) << ""|"" << std::endl;
		}
	}
	std::cout << "" ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾"" << std::endl;
	return (true);
}

static void	getInput(std::string *input, std::string prompt)
{
	std::cout << prompt;
	while (true)
	{
		std::getline(std::cin, (*input));
		if ((*input).empty())
		{
			std::cout << ""═ Field cannot be empty.\n"";
			std::cout << prompt;
		}
		else
			break;
	}
}

void	PhoneBook::addCommand()
{
	Contact	contact;
	getInput(&contact.firstName, ""╔ Firstname: "");
	getInput(&contact.lastName, ""╟ Lastname: "");
	getInput(&contact.nickname, ""╟ Nickname: "");
	getInput(&contact.phoneNumber, ""╟ Phone Number: "");
	getInput(&contact.darkestSecret, ""╚ Darkest Secret: "");
	this->add(&contact);
}

void	PhoneBook::searchCommand()
{
	std::string	 [MASK] ;
	int			queryInt;

	if (this->display())
	{
		std::cout << ""═ Enter index of contact to show: "";
		std::getline(std::cin,  [MASK] );
		queryInt = atoi( [MASK] .c_str());
		if (queryInt <= 0)
			std::cout << ""═  Invalid index."" << std::endl;
		else
			this->display(queryInt - 1);
	}
}

void	PhoneBook::lowerCommand(std::string *str)
{
	for (size_t i = 0; i <= (*str).length(); i++)
	{
		if (isalpha((*str)[i]))
			(*str)[i] = tolower((*str)[i]);
	}
}
",queryStr
112,"/*
 * @author 707<<EMAIL>>
 * This program searches the shortest path.
 */
#include <vector>
#include <cctype>
#include <iostream>
#include <cstdlib>
#include <cstring>

#include ""short_path.h""

int main(int argc, char const *argv[])
{
    const char *topo[5000] = {
        // ""0,0,1,1\n"",
        // ""2,0,3,1\n"",
        // ""1,0,2,2\n"",
        // ""3,2,1,3\n"",
        // ""4,3,1,1\n"",
        // ""5,2,3,1\n"",
        // ""6,3,2,1\n""
        
        ""0,0,13,15\n"",
        ""1,0,8,17\n"",
        ""2,0,19,1\n"",
        ""3,0,4,8\n"",
        ""4,1,0,4\n"",
        ""5,2,9,19\n"",
        ""6,2,15,8\n"",
        ""7,3,0,14\n"",
        ""8,3,11,12\n"",
        ""9,4,1,15\n"",
        ""10,4,5,17\n"",
        ""11,5,8,180\n"",
        ""12,5,9,14\n"",
        ""13,5,6,2\n"",
        ""14,6,17,4\n"",
        ""15,7,13,1\n"",
        ""16,7,16,19\n"",
        ""17,8,6,1\n"",
        ""18,8,12,17\n"",
        ""19,9,14,11\n"",
        ""20,10,12,1\n"",
        ""21,11,7,12\n"",
        ""22,11,4,7\n"",
        ""23,12,14,5\n"",
        ""24,13,17,12\n"",
        ""25,13,4,2\n"",
        ""26,14,19,9\n"",
        ""27,15,10,14\n"",
        ""28,15,180,2\n"",
        ""29,16,8,1\n"",
        ""30,17,9,14\n"",
        ""31,17,19,3\n"",
        ""32,17,180,10\n"",
        ""33,180,15,8\n"",
        ""34,180,3,8\n"",
        ""35,19,180,12\n"",
        ""36,2,3,20\n"",
        ""37,3,5,20\n"",
        ""38,5,7,20\n"",
        ""39,7,11,20\n"",
        ""40,11,13,20\n"",
        ""41,17,11,20\n"",
        ""42,11,19,20\n"",
        ""43,17,5,20\n"",
        ""44,5,19,20\n""
    };
    //int edgeNum = 7;
    int edgeNum = 45;
    //const char *demand = ""0,1,2|3"";
    const char *demand = ""2,19,3|5|7|11|13|17"";


    std::vector<int> result = findPath(topo, edgeNum, demand);
    printPath(result);

    return 0;
}

std::vector<int> findPath(const char **topo, const int edgeNum, const char *demand)
{
    std::vector<int> path;
    int pathWeight = 0xFFFF;

    std::vector<Arc> sortedTopo = sortByIn(topo, edgeNum);

    std::vector<int> dmd = getDemand(demand);
    int start = dmd[0];
    std::vector<Arc> arcs = findArcs(start, sortedTopo);

    // create root from the start.
    Node *root = new Node(NULL, arcs[0].in, 0, arcs);
    root->addExistNode(arcs[0].in);

    while (root != NULL)
    {
        while (root->notVisit.size() > 0)
        {
            std::vector<Arc>::iterator arc = root->notVisit.begin();
            if (!nodeAlreadyExist(arc->out, root))
            {
                Node *node = insertNode(root, arc, sortedTopo);
                if (node->num == dmd[1])
                {
                    calTheShortestPath(path, node, pathWeight, dmd);
                    delete node;
                    root->notVisit.erase(arc);
                }
                else
                {
                    root->notVisit.erase(arc);
                    root = node;
                }
            }
            else
            {
                root->notVisit.erase(arc);
            }
        }
        Node *toBeDel = root;
        root = root->parent;
        delete toBeDel;
    }
    return path;
}

/*
sort the topo list by in-degree.
use the insert sort algorithm.
 */
std::vector<Arc> sortByIn(const char **topo, const int edgeNum)
{
    std::vector<Arc> arcs = restore2Int(topo, edgeNum);

    for (std::vector<Arc>::iterator i = arcs.begin()+1; i != arcs.end(); ++i)
    {
        std::vector<Arc>::iterator j = i;
        while (j > arcs.begin() && (j-1)->in > j->in)
        {
            std::swap(*j, *(j-1));
            --j;
        }
    }

    return arcs;
}

/*
change the topo list from char to int.
 */
std::vector<Arc> restore2Int(const char **topo, const int edgeNum)
{
    std::vector<Arc> arcs;
    for (size_t i = 0; i < edgeNum; ++i)
    {
        int tmpArc[4];
        int used = 0;
        int tmp = 0;
        size_t j = 0;
        while (topo[i][j] != '\n')
        {
            if (isdigit(topo[i][j]))
            {
                tmp = tmp * 10 + (topo[i][j] - '0');
            }
            else
            {
                tmpArc[used++] = tmp;
                tmp = 0;
            }
            ++j;
        }
        tmpArc[used] = tmp;
        Arc arc(tmpArc[0], tmpArc[1], tmpArc[2], tmpArc[3]);
        arcs.push_back(arc);
    }
    return arcs;
}

/*
change the demand from char to int.
 */
std::vector<int> getDemand(const char *demand)
{
    std::vector<int> dmd;
    int tmp = 0;
    for (size_t i = 0; i < strlen(demand); ++i)
    {
        if (isdigit(demand[i]))
        {
            tmp = tmp * 10 + (demand[i] - '0');
        }
        else
        {
            dmd.push_back(tmp);
            tmp = 0;
        }
    }
    dmd.push_back(tmp);
    return dmd;
}

/*
find corresponding arcs by the in-degree node number.
 */
std::vector<Arc> findArcs(int inNode, std::vector<Arc> arcs)
{
    std::vector<Arc>  [MASK] ;
    for (std::vector<Arc>::iterator i = arcs.begin(); i != arcs.end(); ++i)
    {
        if (i->in == inNode)
        {
             [MASK] .push_back(*i);
        }
    }
    return  [MASK] ;
}

/*
test the node exist or not in the path
by compare the bit position.
 */
bool nodeAlreadyExist(int out, Node *root)
{
    if (root->exist.size() > out/32)
    {
        if ((1 << (out%32) & root->exist[out/32]) > 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}


Node *insertNode(Node *root, std::vector<Arc>::iterator &arc, std::vector<Arc> &arcs)
{
    Node *node = new Node(root, arc->out, arc->num,
        arc->weight + root->weight, root->exist,
        findArcs(arc->out, arcs));
    node->addExistNode(arc->out);
    return node;
}

void printPath(std::vector<int> result)
{
    for (std::vector<int>::iterator i = result.begin(); i != result.end(); ++i)
    {
        std::cout << *i << "" "";
    }
    std::cout << std::endl;
}

/*
add the node info
to the bit position.
 */
void Node::addExistNode(int num)
{
    int needed = num/32 + 1 - this->exist.size();
    if (needed > 0)
    {
        for (size_t i = 0; i < needed; ++i)
        {
            unsigned int tmp = 0;
            this->exist.push_back(tmp);
        }
    }
    this->exist[num/32] |= (1 << num);
}

void calTheShortestPath(std::vector<int> &path, Node *node,
    int &pathWeight, std::vector<int> &demand)
{

    for (std::vector<int>::iterator j = demand.begin()+2; j != demand.end(); ++j)
    {
        if (!nodeAlreadyExist(*j, node))
        {
            return;
        }
    }
    // print paths.
    // temporary.
    Node *tmp = node;
    while (tmp != NULL)
    {
        std::cout << tmp->num << "" "";
        tmp = tmp->parent;
    }
    std::cout << std::endl;

    if (path.empty())
    {
        pathWeight = node->weight;
        while (node->parent != NULL)
        {
            path.insert(path.begin(), node->arc);
            node = node->parent;
        }
    }
    else
    {
        if (node->weight < pathWeight)
        {
            pathWeight = node->weight;
            path.clear();
            while (node->parent != NULL)
            {
                path.insert(path.begin(), node->arc);
                node = node->parent;
            }
        }
    }
}",found
113,"// Compile with
// cd demos/
// g++ -std=c++14 -Iinclude demo_simple.cpp -o demo_simple
//
// Edit and compile this file without installing anything at
// https://gitpod.io/#https://github.com/pthom/cleantype/blob/master/demos/demo_simple.cpp
//
#include <map>
#include <vector>
#include <cleantype/cleantype.hpp>

#define LOG(...) std::cout << __VA_ARGS__ << ""\n"";

void demo()
{
    // First, let's define a variable for demonstration purpose
    std::set<std::string> my_set { ""Hello"", ""There""};

    // let's ask CleanType to give us the type of ""my_set""
    // cleantype::full will return the *full* type info
    LOG(  cleantype::full(my_set)  );
    // outputs:
    // std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> &

    // Ouch, that was barely readable!
    // cleantype::clean will return a *readable* type
    LOG(  cleantype::clean(my_set) );
    // outputs:
    // std::set<std::string> &

    // Let's now show the content of ""my_set"" together with its type
    LOG(  cleantype::show_details(my_set) );
    // outputs:
    // std::set<std::string> & = [Hello, There]


    // Yes, but what about lambdas? Could you guess the signature of the lambda below?
    auto lambda_example = []() {
        // when C++ meets js...
        return +!!""""; // See https://blog.knatten.org/2018/10/12/1662
    };

    // cleantype::lambda_clean returns the signature of lambda functions
    LOG(  cleantype::lambda_clean(lambda_example) );
    // outputs:
    // lambda: () -> int

    // Ok, maybe this was too easy. Let's try with a generic lambda!
    auto add = [](auto a, auto b) {
        return a + b;
    };

    // Now, can we see its signature?
    // Yes, we just need to specify the input argument types.
    LOG(  cleantype::lambda_clean<std::string, char>(add)  );
    // outputs:
    // lambda: (std::string, char) -> std::string
}


// Can CleanType understand some more complex libraries
// like range-v3 where most variables, functions and lambdas are of type ""auto""?
// Well...    yes!

#include <range/v3/all.hpp>

using namespace ranges;

auto square_yield_fn(int x) {
    return ranges::yield(x * x);
}

void demo_ranges()
{
    auto squares_view = view::for_each(view::ints(1), square_yield_fn);

    // What is the type of squares_view?
    // Let's see...
    LOG( cleantype::clean(squares_view)  );
    // outputs:
    // ranges::v3::join_view<ranges::v3::transform_view<ranges::v3::iota_view<int, void>, ranges::v3::single_view<int>(*)(int)>, void> &

    // Let's make it more complex yet:
    auto  [MASK]  = squares_view | view::take(10);

    // As you will see below, CleanType can indent the types
    // when they get more complex!
    LOG(  cleantype::clean( [MASK] )  );
    // outputs:
    // ranges::v3::detail::take_exactly_view_<
    //     ranges::v3::join_view<
    //         ranges::v3::transform_view<
    //             ranges::v3::iota_view<
    //                 int,
    //                 void
    //             >,
    //             ranges::v3::single_view<
    //                 int
    //             > (*)(int)
    //         >,
    //         void
    //     >,
    //     false
    // > &
}

int main()
{
    demo();
    demo_ranges();
}",squares_take_10
114,"#ifndef EXPERIMENTS_ANODEIMPL_H
#define EXPERIMENTS_ANODEIMPL_H

#include ""ANodeDecl.h""
#include ""BuilderDecl.h""

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
ANode<T, MAX_COUNT, SIZE, ADAPTER>::ANode(const ANode &otherNode) : childrenCount_(otherNode.childrenCount_),
                                                                    origin_(otherNode.origin_),
                                                                    isLeaf_(otherNode.isLeaf_) {
    for (int i = 0; i < childrenCount_; i++) {
        children_[i] = otherNode.children_[i];
        cumSize_[i] = otherNode.cumSize_[i];
        offset_[i] = otherNode.offset_[i];
    }
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
ANode<T, MAX_COUNT, SIZE, ADAPTER>::ANode(ANode &&otherNode) noexcept : childrenCount_(otherNode.childrenCount_),
                                                                        origin_(std::move(otherNode.origin_)),
                                                                        isLeaf_(otherNode.isLeaf_) {
    for (int i = 0; i < childrenCount_; i++) {
        children_[i] = std::move(otherNode.children_[i]);
        cumSize_[i] = otherNode.cumSize_[i];
        offset_[i] = otherNode.offset_[i];
    }
    otherNode.childrenCount_ = 0;
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
int8_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::height() const {
    return std::visit([](const auto originPtr) {
        return originPtr->height();
    }, origin_);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
size_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::originSize() const {
    return std::visit([](const auto originPtr) {
        return originPtr->size();
    }, origin_);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
size_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::maxCompactionSize() const {
    if (!height()) {
        return SIZE / MAX_COUNT;
    }
    return size_t(1) << ((log(SIZE) - 1) + (log(MAX_COUNT) - 1) * (height() - 1));
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
size_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::retainedSize() const {
    size_t result = 0;
    for (size_t i = 0; i < childrenCount_; i++) {
        if (!children_[i]) {
            result += childRetainedSize(i);
        }
    }
    return result;
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
size_t
ANode<T, MAX_COUNT, SIZE, ADAPTER>::fillLeaf(const ANode::VarType &child, T *destLeaf, size_t offset, size_t length) {
    return std::visit([&](const auto &nodePtr) {
        return nodePtr->fillLeaf(destLeaf, offset, length);
    }, child);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
template<class Visitor>
decltype(auto) ANode<T, MAX_COUNT, SIZE, ADAPTER>::visitChild(Visitor &&_visitor, size_t childPos) const {
    if (!children_[childPos]) {
        return std::visit(std::forward<Visitor>(_visitor), origin_);
    }
    if (isLeaf_[childPos]) {
        return _visitor(static_cast<const LeafT *>(children_[childPos].get()));
    }
    return _visitor(static_cast<const BNodeT *>(children_[childPos].get()));
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
size_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::fillLeaf(T *destLeaf, size_t offset, size_t length) const {
    if (offset >= size()) {
        return 0;
    }
    length = std::min(length, size() - offset);
    auto totalLen = length;
    for (size_t childPos = lowerBoundPos(offset + 1); childPos < childrenCount_ && length != 0; childPos++) {
        size_t childOffset = childPos == 0 ? 0 : cumSize_[childPos - 1];
        assert(childOffset <= offset);
        size_t elementsRead = visitChild([&](const auto &childPtr) {
            int localOffset = offset - childOffset;
            return childPtr->fillLeaf(destLeaf, offset_[childPos] + localOffset,
                                      std::min(length, childRetainedSize(childPos) - localOffset));
        }, childPos);
        offset += elementsRead;
        length -= elementsRead;
        destLeaf += elementsRead;
    }
    assert(length == 0);
    return totalLen;
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
const T &ANode<T, MAX_COUNT, SIZE, ADAPTER>::operator[](size_t index) const {
    assert(index < size());
    auto childPos = lowerBoundPos(index + 1);
    return visitChild([&](const auto &childPtr) -> const T & {
        return (*childPtr)[offset_[childPos] + index - (childPos ? cumSize_[childPos - 1] : 0)];
    }, childPos);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
auto ANode<T, MAX_COUNT, SIZE, ADAPTER>::childAt(
        size_t childPos) const -> const std::variant<const LeafT *, const BNodeT *, const VarType> {
    assert(childPos < childrenCount_);
    if (!children_[childPos]) {
        return {origin_};
    }
    if (isLeaf_[childPos]) {
        return {static_cast<const LeafT *>(children_[childPos].get())};
    }
    return {static_cast<const BNodeT *>(children_[childPos].get())};
}


template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
size_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::normalizeLength(size_t length, size_t offset, size_t incomingSize) const {
    if (offset > incomingSize) {
        //just in case, in release mode we ignore such usages
        return 0;
    }
    //Normalize length to the max available
    if (length > incomingSize - offset) {
        return incomingSize - offset;
    }
    return length;
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
template<class NODE_T>
bool ANode<T, MAX_COUNT, SIZE, ADAPTER>::canAcceptNode(const NODE_T &incomingNode, bool asPrefix, size_t offset,
                                                       size_t length) const {
    if constexpr (std::is_same_v<NODE_T, ANodeCPtr> || std::is_same_v<NODE_T, ANodePtr>) {
        return false;
    }
    length = normalizeLength(length, offset, incomingNode->size());
    if (length == 0) {
        return true;
    }
    if (childrenCount_ == MAX_COUNT) {
        const void *pointerToAdd = isOrigin(incomingNode) ? nullptr : static_cast<const void *>(incomingNode.get());
        if (asPrefix) {
            if (pointerToAdd == (children_[0] ? children_[0].get() : nullptr) && offset + length == offset_[0]) {
                return true;
            }
        } else if (
                pointerToAdd == (children_[childrenCount_ - 1] ? children_[childrenCount_ - 1].get() : nullptr) &&
                offset == offset_[childrenCount_ - 1] + cumSize_[childrenCount_ - 1] -
                          (childrenCount_ > 1 ? cumSize_[childrenCount_ - 2] : 0)) {
            return true;
        }
        if (!canCompact()) {
            return false;
        }
    }
    if (isOrigin(incomingNode)) {
        return true;
    }
    if (height()) {
        if (incomingNode->height() < height()) {
            return length >= minChildRetention(incomingNode);
        }
        return false;
    }
    return length <= SIZE * 2 / MAX_COUNT;
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
template<class NODE_T>
size_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::minChildRetention(const NODE_T &incomingNode) {
    constexpr bool isBNode = std::is_same_v<std::remove_cvref_t<NODE_T>, BNodePtr> or
                             std::is_same_v<std::remove_cvref_t<NODE_T>, BNodeCPtr>;

    if constexpr (isBNode) {
        return (incomingNode->size() / incomingNode->childrenCount());
    } else {
        return 1;
    }
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
void ANode<T, MAX_COUNT, SIZE, ADAPTER>::shiftNodes(size_t startPos, size_t  [MASK] , int64_t sizeDelta) {
    assert( [MASK]  > childrenCount_);
    for (size_t i = 1; i <= childrenCount_ - startPos; i++) {
        offset_[ [MASK]  - i] = offset_[childrenCount_ - i];
        cumSize_[ [MASK]  - i] = cumSize_[childrenCount_ - i] + sizeDelta;
        children_[ [MASK]  - i] = std::move(children_[childrenCount_ - i]);
        isLeaf_[ [MASK]  - i] = isLeaf_[childrenCount_ - i];
    }
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
template<class NODE_T>
bool ANode<T, MAX_COUNT, SIZE, ADAPTER>::isOrigin(const NODE_T &incomingNode) const {
    return std::visit([&](const auto &ptr) {
        return static_cast<const void *>(ptr.get());
    }, origin_) == static_cast<const void *>(incomingNode.get());
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
template<class NODE_T>
void ANode<T, MAX_COUNT, SIZE, ADAPTER>::addNode(NODE_T &&incomingNode, size_t offset, size_t length, bool asPrefix,
                                                 void *context) {
    if constexpr (std::is_same_v<typename ANode<T, MAX_COUNT, SIZE, ADAPTER>::VarType, std::remove_cvref_t<NODE_T>>) {
        addNodeVar(std::forward<NODE_T>(incomingNode), offset, length, asPrefix);
    } else if constexpr (std::is_null_pointer_v<NODE_T>) {
        addNode(origin_, offset, length, asPrefix);
        return;
    } else {
        if (!incomingNode) {
            addNode(origin_, offset, length, asPrefix);
            return;
        }
        assert(offset < incomingNode->size());
        if (!incomingNode->isConst()) {
            throw std::logic_error(""Can only add const children"");
        }
        bool isLeaf;
        if constexpr (std::is_same_v<std::remove_cvref_t<NODE_T>, LeafCPtr>) {
            isLeaf = true;
        } else if constexpr (std::is_same_v<std::remove_cvref_t<NODE_T>, BNodeCPtr>) {
            isLeaf = false;
        } else {
            throw std::logic_error(""Unsupported type"");
        }
        //Normalize length to the max available
        length = normalizeLength(length, offset, incomingNode->size());
        if (!length) {
            //zero size additions need to be ignored
            return;
        }
        assert(canAcceptNode(incomingNode, asPrefix, offset, length));
        GenericCPtr pointerToAdd;
        if (!isOrigin(incomingNode)) {
            pointerToAdd = std::static_pointer_cast<const void>(std::forward<NODE_T>(incomingNode));
        }
        if (childrenCount_) {
            //checking if the added node fits the existing node in place
            if (asPrefix) {
                if (pointerToAdd == children_[0] && offset + length == offset_[0]) {
                    offset_[0] -= length;
                    for (int i = 0; i < childrenCount_; i++) {
                        cumSize_[i] += length;
                    }
                    return;
                }
            } else if (pointerToAdd == children_[childrenCount_ - 1] && offset == offset_[childrenCount_ - 1] +
                                                                                  cumSize_[childrenCount_ - 1] -
                                                                                  (childrenCount_ > 1 ? cumSize_[
                                                                                          childrenCount_ - 2] : 0)) {
                cumSize_[childrenCount_ - 1] += length;
                return;
            }
        }
        if (childrenCount_ == MAX_COUNT) {
            compact(context);
        }
        assert(childrenCount_ < MAX_COUNT);
        size_t destPos = asPrefix ? 0 : childrenCount_;
        if (asPrefix) {
            shiftNodes(0, childrenCount_ + 1, length);
            cumSize_[0] = length;
        } else {
            cumSize_[childrenCount_] = size() + length;
        }
        offset_[destPos] = offset;
        children_[destPos] = std::move(pointerToAdd);
        isLeaf_[destPos] = isLeaf;
        childrenCount_++;
    }
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
void ANode<T, MAX_COUNT, SIZE, ADAPTER>::addNodeVar(ANode::VarType &&incomingNode, size_t offset, size_t length,
                                                    bool asPrefix) {
    std::visit([&](auto &&nodePtr) {
        addNode(std::move(nodePtr), offset, length, asPrefix);
    }, std::move(incomingNode));
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
void
ANode<T, MAX_COUNT, SIZE, ADAPTER>::addNodeVar(const ANode::VarType &incomingNode, size_t offset, size_t length,
                                               bool asPrefix) {
    std::visit([&](const auto &nodePtr) {
        addNode(nodePtr, offset, length, asPrefix);
    }, incomingNode);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
void ANode<T, MAX_COUNT, SIZE, ADAPTER>::removeNodes(uint16_t startPoint, uint16_t count) {
    assert(count <= childrenCount_);
    size_t sizeDelta = cumSize_[startPoint + count - 1] - (startPoint > 0 ? cumSize_[startPoint - 1] : 0);
    for (int i = startPoint; i < childrenCount_ - count; i++) {
        offset_[i] = offset_[i + count];
        cumSize_[i] = cumSize_[i + count] - sizeDelta;
        children_[i] = std::move(children_[i + count]);
        isLeaf_[i] = isLeaf_[i + count];
    }
    childrenCount_ -= count;
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
bool ANode<T, MAX_COUNT, SIZE, ADAPTER>::canCompact() const {
    assert(childrenCount_);
    size_t prevSum = childRetainedSize(0);
    for (uint16_t i = 1; i < childrenCount_; i++) {
        size_t currentSum = childRetainedSize(i);
        if (prevSum + currentSum <= maxCompactionSize()) {
            return true;
        }
        prevSum = currentSum;
    }
    return false;
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
void ANode<T, MAX_COUNT, SIZE, ADAPTER>::compact(void *context) {
    assert(childrenCount_);
    size_t runningSum = 0;
    uint16_t windowStart = 0;
    for (uint16_t i = 0; i < childrenCount_; i++) {
        size_t currentSum = childRetainedSize(i);
        if (runningSum + currentSum <= maxCompactionSize()) {
            runningSum += currentSum;
        } else {
            if (i - windowStart > 1) {
                compact(windowStart, i - windowStart, context);
                return;
            }
            if (currentSum < maxCompactionSize()) {
                windowStart = i;
                runningSum = currentSum;
            } else {
                windowStart = i + 1;
                runningSum = 0;
            }
        }
    }
    if (childrenCount_ - windowStart > 1) {
        compact(windowStart, childrenCount_ - windowStart, context);
        return;
    }
    throw std::logic_error(""Unable to compact (should call canCompactFirst)"");
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
auto ANode<T, MAX_COUNT, SIZE, ADAPTER>::createNodePtr(const ANode &src) -> ANode::ANodePtr {
    static auto &alloc = StdFixedAllocator<ANode>::oneAndOnly();
    auto p = alloc.allocate(1);
    alloc.construct(p, src);
    return ANodePtr(p);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
auto ANode<T, MAX_COUNT, SIZE, ADAPTER>::createNodePtr(ANode &&src) -> ANode::ANodePtr {
    static auto &alloc = StdFixedAllocator<ANode>::oneAndOnly();
    auto p = alloc.allocate(1);
    alloc.construct(p, std::move(src));
    return ANodePtr(p);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
void ANode<T, MAX_COUNT, SIZE, ADAPTER>::compact(uint16_t fromNode, uint16_t nodeCount, void *context) {
    BuilderT builder(height() - 1);
    builder.setContext(context);
    size_t expectedSize = 0;
    for (uint16_t pos = fromNode; pos < fromNode + nodeCount; pos++) {
        expectedSize += childRetainedSize(pos);
        if (!children_[pos]) {
            builder.addNode(origin_, offset_[pos], childRetainedSize(pos));
        } else if (isLeaf_[pos]) {
            builder.addNode(std::static_pointer_cast<const LeafT>(std::move(children_[pos])), offset_[pos],
                            childRetainedSize(pos));
        } else {
            builder.addNode(std::static_pointer_cast<const BNodeT>(std::move(children_[pos])), offset_[pos],
                            childRetainedSize(pos));
        }
    }
    size_t newSize = builder.size();
    assert(expectedSize == newSize);
    while (builder.isAnode()) {
        builder.pushDownAnnotations();
        newSize = builder.size();
        assert(expectedSize == newSize);
    }
    std::visit([&](auto &&nodePtr) {
        if constexpr (is_unique_ptr_v<decltype(nodePtr)>) {
            throw std::logic_error(""Builder must return const nodes"");
        } else if constexpr (std::is_same_v<ANodeCPtr, std::remove_cvref_t<decltype(nodePtr)>>) {
            throw std::logic_error(""Builder should not return an ANode"");
        } else {
            children_[fromNode] = std::static_pointer_cast<const void>(nodePtr);
            isLeaf_.set(fromNode, std::is_same_v<LeafCPtr, std::remove_cvref_t<decltype(nodePtr)>>);
        }
    }, builder.close(false));

    offset_[fromNode] = 0;
    cumSize_[fromNode] = newSize + (fromNode ? cumSize_[fromNode - 1] : 0);
    removeNodes(fromNode + 1, nodeCount - 1);
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
template<class Visitor>
void
ANode<T, MAX_COUNT, SIZE, ADAPTER>::forEachChildMove(Visitor &&visitor, size_t offset, size_t length, bool asPrefix) {
    length = std::min(length, size() - offset);
    size_t firstNodePos, lastNodePos;
    std::tie(firstNodePos, lastNodePos) = nodeRangeInclusive(offset, length);
    size_t currentOffset = offset - (firstNodePos ? cumSize_[firstNodePos - 1] : 0);
    auto visitorInternal = [&](auto &&child, bool isLeaf, size_t childOffset, size_t childLen) {
        if (!child) {
            if (origin_.index() == 0) {
                visitor(std::get<LeafCPtr>(origin_), childOffset, childLen);
            } else {
                visitor(std::get<BNodeCPtr>(origin_), childOffset, childLen);
            }
        } else if (isLeaf) {
            visitor(std::static_pointer_cast<const LeafT>(std::move(child)), childOffset, childLen);
        } else {
            visitor(std::static_pointer_cast<const BNodeT>(std::move(child)), childOffset, childLen);
        }
    };

    if (asPrefix) {
        if (firstNodePos != lastNodePos) {
            visitorInternal(std::move(children_[lastNodePos]), isLeaf_[lastNodePos], offset_[lastNodePos],
                            length + offset - cumSize_[lastNodePos - 1]);
            length = cumSize_[lastNodePos - 1] - offset;
            for (auto i = lastNodePos - 1; i > firstNodePos; i--) {
                visitorInternal(std::move(children_[i]), isLeaf_[i], offset_[i], sizeAt(i));
                length -= sizeAt(i);
            }
        }
        visitorInternal(std::move(children_[firstNodePos]), isLeaf_[firstNodePos],
                        offset_[firstNodePos] + currentOffset,
                        length);
    } else {
        for (auto i = firstNodePos; i < lastNodePos; i++) {
            size_t len = sizeAt(i) - currentOffset;
            visitorInternal(std::move(children_[i]), isLeaf_[i], offset_[i] + currentOffset,
                            sizeAt(i) - currentOffset);
            currentOffset = 0;
            length -= len;
        }
        visitorInternal(std::move(children_[lastNodePos]), isLeaf_[lastNodePos], offset_[lastNodePos] + currentOffset,
                        std::min(sizeAt(lastNodePos) - currentOffset, length));
    }
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
template<class Visitor>
void
ANode<T, MAX_COUNT, SIZE, ADAPTER>::forEachChild(Visitor &&visitor, size_t offset, size_t length, bool asPrefix) const {
    auto visitorInternal = [&](const auto &child, bool isLeaf, size_t childOffset, size_t childLen) {
        if (!child) {
            if (origin_.index() == 0) {
                visitor(std::get<LeafCPtr>(origin_), childOffset, childLen);
            } else {
                visitor(std::get<BNodeCPtr>(origin_), childOffset, childLen);
            }
        } else if (isLeaf) {
            visitor(std::static_pointer_cast<const LeafT>(child), childOffset, childLen);
        } else {
            visitor(std::static_pointer_cast<const BNodeT>(child), childOffset, childLen);
        }
    };

    length = std::min(length, size() - offset);
    size_t firstNodePos, lastNodePos;
    std::tie(firstNodePos, lastNodePos) = nodeRangeInclusive(offset, length);
    size_t currentOffset = offset - (firstNodePos ? cumSize_[firstNodePos - 1] : 0);
    if (asPrefix) {
        if (firstNodePos != lastNodePos) {
            visitorInternal(children_[lastNodePos], isLeaf_[lastNodePos], offset_[lastNodePos],
                            length + offset - cumSize_[lastNodePos - 1]);
            length = cumSize_[lastNodePos - 1] - offset;
            for (auto i = lastNodePos - 1; i > firstNodePos; i--) {
                visitorInternal(children_[i], isLeaf_[i], offset_[i], sizeAt(i));
                length -= sizeAt(i);
            }
        }
        visitorInternal(children_[firstNodePos], isLeaf_[firstNodePos], offset_[firstNodePos] + currentOffset, length);
    } else {
        for (auto i = firstNodePos; i < lastNodePos; i++) {
            size_t len = sizeAt(i) - currentOffset;
            visitorInternal(children_[i], isLeaf_[i], offset_[i] + currentOffset, len);
            currentOffset = 0;
            length -= len;
        }
        visitorInternal(children_[lastNodePos], isLeaf_[lastNodePos], offset_[lastNodePos] + currentOffset,
                        std::min(sizeAt(lastNodePos) - currentOffset, length));
    }
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
std::tuple<size_t, size_t> ANode<T, MAX_COUNT, SIZE, ADAPTER>::nodeRangeInclusive(size_t offset, size_t length) const {
    size_t firstNodePos =
            std::upper_bound(cumSize_.begin(), cumSize_.begin() + childrenCount_, offset) - cumSize_.begin();
    size_t lastNodePos = lowerBoundPos(offset + length);
    return {firstNodePos, lastNodePos};
}

template<class T, size_t MAX_COUNT, size_t SIZE, template<class, size_t> class ADAPTER>
size_t ANode<T, MAX_COUNT, SIZE, ADAPTER>::lowerBoundPos(size_t offset) const {
    return std::lower_bound(cumSize_.begin(), cumSize_.begin() + childrenCount_, offset) - cumSize_.begin();
}


#endif //EXPERIMENTS_ANODEIMPL_H
",newCount
115,"#include ""application.h""
#include ""constants.h""

cm::application::application(std::shared_ptr<cm::config_map> map, std::shared_ptr<cm::logger> log)
        : map(map), kill_timer(ios), signal_set(ios), completed_apps(0), log(log), shutdown_running(false) {
    setup_signal_set();
}

void cm::application::run() {

    setup_children();
    set_signal_handler();

    ios.run();
}

void cm::application::kill_timeout_handler(const boost::system::error_code &ec) {
    for (auto &it : children) {
        if (it.second->terminated())
            continue;

        log->err(app_name, ""Forcibly terminating app "" + it.first);
        it.second->kill();
    }
}

void cm::application::all_down_handler() {
    log->err(app_name, ""Shutdown complete"");
    signal_set.cancel();
    kill_timer.cancel();
}

void cm::application::shutdown_handler() {

    bool expected = false;
    bool first = shutdown_running.compare_exchange_strong(expected, true);

    log->err(app_name, ""Shutdown: total children: "" + std::to_string(map->apps.size()) + "", completed: "" +
                       std::to_string(completed_apps.load()));

    if (completed_apps.load() == map->apps.size()) {
        log->err(app_name, ""All completed"");
        all_down_handler();
        return;
    }

    if (first) {

        log->err(app_name, ""Shutdown initiated"");

        for (auto &it : children) {
            if (it.second->terminated())
                continue;

            log->err(app_name, ""Terminating app "" + it.first);
            it.second->terminate();
        }

        kill_timer.expires_from_now(map->kill_delay);

        kill_timer.async_wait([this](auto &ec) { kill_timeout_handler(ec); });
    }
}

void cm::application::signal_handler(const boost::system::error_code &ec, int signal_number) {

    auto ss = find_if(signals.begin(), signals.end(), [&](auto &s) { return s.first == signal_number; });

    if (ss == signals.end())
        log->err(app_name, ""Handling signal with number "" + std::to_string(signal_number) + "" (unknown)"");
    else
        log->err(app_name, ""Handling signal with number "" + std::to_string(signal_number) + "" ("" + (*ss).second + "")"");

    switch (signal_number) {
        case SIGINT:
        case SIGQUIT:
        case SIGTERM:
            shutdown_handler();
            break;
        default:
            break;
    }

    if (!shutdown_running.load())
        set_signal_handler();
}

void cm::application::set_signal_handler() {

    log->err(app_name, ""Setting signal handler"");

    signal_set.async_wait([this](auto &ec, int signo) { signal_handler(ec, signo); });
}

void cm::application::setup_children() {

    log->err(app_name, ""Starting applications"");

    for (const config_map::configured_application &app : map->apps) {

        try {

            boost::filesystem::path path;

            if (boost::filesystem::exists(app.executable))
                path = app.executable;
            else
                path = bp::search_path(app.executable);

            std::unique_ptr<child> a = std::make_unique<child>(
                    app.name, path, app.args,
                    boost::filesystem::canonical(app.context), app.env, app.term_signal,
                    ios, proc_group
            );

            a->set_on_stdout([this, &app](const child::stream_content_type &buf) {
                linebuffer.available(app.name + ""_out"", buf, [this, app](const std::string &line) {
                    log->out(app.name, line);
                });
            });

            a->set_on_stderr([this, &app](const child::stream_content_type &buf) {
                linebuffer.available(app.name + ""_err"", buf, [this, app](const std::string &line) {
                    log->err(app.name, line);
                });
            });

            a->set_on_exit([this, &app](const int  [MASK] , const std::error_code &code) {
                log->err(app_name, ""Application "" + app.name + "" exited with code "" + std::to_string( [MASK] ) + ""."");
                completed_apps++;
                if (app.fail_on_exit) {
                    shutdown_handler();
                } else {
                    if ( [MASK]  != 0) {
                        if (app.fail_on_nonzero_exit)
                            shutdown_handler();
                    }
                }

            });

            children[app.name] = std::move(a);

        } catch (bp::process_error &e) {
            log->err(app_name,
                     ""Failed to start process: "" + app.name + "": "" + e.what() + "". executable is: "" + app.executable);
            throw std::runtime_error(e.what());
        }
    }
}

void cm::application::setup_signal_set() {

    log->err(app_name, ""Setting signal handlers"");
    for (const auto &signal : signals) {
        try {
            signal_set.add(signal.first);
        } catch (const std::runtime_error &e) {
            std::cout << signal.first << signal.second << e.what() << ""\n"";
            log->err(app_name, e.what());
            return;
        }
    }
}
",exit_code
116,"#include ""AppDelegate.h""
#include ""HelloWorldScene.h""
#include ""scene\GameScene.h""
#include ""scene\FightScene.h""
#include ""scene\LoginScene.h""

#include ""util\MyProtoSocket.h""

USING_NS_CC;

AppDelegate::AppDelegate() {

}

AppDelegate::~AppDelegate() 
{
}

//if you want a different context,just modify the value of glContextAttrs
//it will takes effect on all platforms
void AppDelegate::initGLContextAttrs()
{
    //set OpenGL context attributions,now can only set six attributions:
    //red,green,blue,alpha,depth,stencil
    GLContextAttrs glContextAttrs = {8, 8, 8, 8, 24, 8};

    GLView::setGLContextAttrs(glContextAttrs);
}

bool AppDelegate::applicationDidFinishLaunching() {
    // initialize director
    auto director = Director::getInstance();
    auto  [MASK]  = director->getOpenGLView();
    if(! [MASK] ) {
         [MASK]  = GLViewImpl::createWithRect(""IceVirgin"", Rect(0, 0, 800, 500));
        director->setOpenGLView( [MASK] );
		int i = 0;
    }

    director->getOpenGLView()->setDesignResolutionSize(800, 500, ResolutionPolicy::SHOW_ALL);

    // turn on display FPS
    //director->setDisplayStats(true);

    // set FPS. the default value is 1.0/60 if you don't call this
    director->setAnimationInterval(1.0 / 60);

    FileUtils::getInstance()->addSearchPath(""res"");

	//开启网络
	MyProtoSocket::connect();

    // create a scene. it's an autorelease object
	//auto * layer = GameScene::create();
	//auto * layer = FightScene::create();
	auto * layer = LoginScene::create();
	auto scene = Common::scene(layer);

    // run
    director->runWithScene(scene);

	//子线程无法更新UI
	std::thread threadRecv(&AppDelegate::recev, this);
	threadRecv.detach();

    return true;
}

// This function will be called when the app is inactive. When comes a phone call,it's be invoked too
void AppDelegate::applicationDidEnterBackground() {
    Director::getInstance()->stopAnimation();

    // if you use SimpleAudioEngine, it must be pause
    // SimpleAudioEngine::getInstance()->pauseBackgroundMusic();
}

// this function will be called when the app is active again
void AppDelegate::applicationWillEnterForeground() {
    Director::getInstance()->startAnimation();

    // if you use SimpleAudioEngine, it must resume here
    // SimpleAudioEngine::getInstance()->resumeBackgroundMusic();
}

void AppDelegate::recev()
{
	while (true)
	{
		//Sleep(10);
		MyProtoSocket::receive();
	}

}
",glview
117,"// Copyright (C) 2009 The Libphonenumber Authors
//
// 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.

// Author: <NAME>
// Author: <NAME>
// Open-sourced by: <NAME>
//
// Note that these tests use the metadata contained in the test metadata file,
// not the normal metadata file, so should not be used for regression test
// purposes - these tests are illustrative only and test functionality.

#include ""phonenumbers/phonenumberutil.h""

#include <algorithm>
#include <iostream>
#include <list>
#include <set>
#include <string>

#include <gtest/gtest.h>

#include ""phonenumbers/default_logger.h""
#include ""phonenumbers/phonemetadata.pb.h""
#include ""phonenumbers/phonenumber.h""
#include ""phonenumbers/phonenumber.pb.h""
#include ""phonenumbers/test_util.h""

namespace i18n {
namespace phonenumbers {

using std::endl;
using std::find;
using std::make_pair;
using std::ostream;

using google::protobuf::RepeatedPtrField;

static const int kInvalidCountryCode = 2;

class PhoneNumberUtilTest : public testing::Test {
 protected:
  PhoneNumberUtilTest() : phone_util_(*PhoneNumberUtil::GetInstance()) {
    PhoneNumberUtil::GetInstance()->SetLogger(new StdoutLogger());
  }

  // Wrapper functions for private functions that we want to test.
  const PhoneMetadata* GetPhoneMetadata(const string& region_code) const {
    return phone_util_.GetMetadataForRegion(region_code);
  }

  const PhoneMetadata* GetMetadataForNonGeographicalRegion(
      int country_code) const {
    return phone_util_.GetMetadataForNonGeographicalRegion(country_code);
  }

  void GetSupportedRegions(set<string>* regions) {
    phone_util_.GetSupportedRegions(regions);
  }

  void GetRegionCodesForCountryCallingCode(
      int country_calling_code,
      list<string>* regions) {
    phone_util_.GetRegionCodesForCountryCallingCode(country_calling_code,
                                                    regions);
  }

  void ExtractPossibleNumber(const string& number,
                             string* extracted_number) const {
    phone_util_.ExtractPossibleNumber(number, extracted_number);
  }

  bool CanBeInternationallyDialled(const PhoneNumber& number) const {
    return phone_util_.CanBeInternationallyDialled(number);
  }

  bool IsViablePhoneNumber(const string& number) const {
    return phone_util_.IsViablePhoneNumber(number);
  }

  void Normalize(string* number) const {
    phone_util_.Normalize(number);
  }

  void NormalizeDiallableCharsOnly(string* number) const {
    phone_util_.NormalizeDiallableCharsOnly(number);
  }

  bool IsNumberGeographical(const PhoneNumber& phone_number) const {
    return phone_util_.IsNumberGeographical(phone_number);
  }

  bool IsLeadingZeroPossible(int country_calling_code) const {
    return phone_util_.IsLeadingZeroPossible(country_calling_code);
  }

  PhoneNumber::CountryCodeSource MaybeStripInternationalPrefixAndNormalize(
      const string& possible_idd_prefix,
      string* number) const {
    return phone_util_.MaybeStripInternationalPrefixAndNormalize(
        possible_idd_prefix,
        number);
  }

  void MaybeStripNationalPrefixAndCarrierCode(const PhoneMetadata& metadata,
                                              string* number,
                                              string* carrier_code) const {
    phone_util_.MaybeStripNationalPrefixAndCarrierCode(metadata, number,
                                                            carrier_code);
  }

  bool MaybeStripExtension(string* number, string* extension) const {
    return phone_util_.MaybeStripExtension(number, extension);
  }

  PhoneNumberUtil::ErrorType MaybeExtractCountryCode(
      const PhoneMetadata* default_region_metadata,
      bool keep_raw_input,
      string* national_number,
      PhoneNumber* phone_number) const {
    return phone_util_.MaybeExtractCountryCode(default_region_metadata,
                                               keep_raw_input,
                                               national_number,
                                               phone_number);
  }

  static bool Equals(const PhoneNumberDesc& expected_number,
                     const PhoneNumberDesc& actual_number) {
    return ExactlySameAs(expected_number, actual_number);
  }

  bool ContainsOnlyValidDigits(const string& s) const {
    return phone_util_.ContainsOnlyValidDigits(s);
  }

  void GetNddPrefixForRegion(const string& region,
                             bool strip_non_digits,
                             string* ndd_prefix) const {
    // For testing purposes, we check this is empty first.
    ndd_prefix->clear();
    phone_util_.GetNddPrefixForRegion(region, strip_non_digits, ndd_prefix);
  }

  const PhoneNumberUtil& phone_util_;

 private:
  DISALLOW_COPY_AND_ASSIGN(PhoneNumberUtilTest);
};

TEST_F(PhoneNumberUtilTest, ContainsOnlyValidDigits) {
  EXPECT_TRUE(ContainsOnlyValidDigits(""""));
  EXPECT_TRUE(ContainsOnlyValidDigits(""2""));
  EXPECT_TRUE(ContainsOnlyValidDigits(""25""));
  EXPECT_TRUE(ContainsOnlyValidDigits(""\xEF\xBC\x96"" /* ""６"" */));
  EXPECT_FALSE(ContainsOnlyValidDigits(""a""));
  EXPECT_FALSE(ContainsOnlyValidDigits(""2a""));
}

TEST_F(PhoneNumberUtilTest, GetSupportedRegions) {
  set<string> regions;

  GetSupportedRegions(&regions);
  EXPECT_GT(regions.size(), 0U);
}

TEST_F(PhoneNumberUtilTest, GetRegionCodesForCountryCallingCode) {
  list<string> regions;

  GetRegionCodesForCountryCallingCode(1, &regions);
  EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::US())
              != regions.end());
  EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::BS())
              != regions.end());

  regions.clear();
  GetRegionCodesForCountryCallingCode(44, &regions);
  EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::GB())
              != regions.end());

  regions.clear();
  GetRegionCodesForCountryCallingCode(49, &regions);
  EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::DE())
              != regions.end());

  regions.clear();
  GetRegionCodesForCountryCallingCode(800, &regions);
  EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::UN001())
              != regions.end());

  regions.clear();
  GetRegionCodesForCountryCallingCode(kInvalidCountryCode, &regions);
  EXPECT_TRUE(regions.empty());
}

TEST_F(PhoneNumberUtilTest, GetInstanceLoadUSMetadata) {
  const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
  EXPECT_EQ(""US"", metadata->id());
  EXPECT_EQ(1, metadata->country_code());
  EXPECT_EQ(""011"", metadata->international_prefix());
  EXPECT_TRUE(metadata->has_national_prefix());
  ASSERT_EQ(2, metadata->number_format_size());
  EXPECT_EQ(""(\\d{3})(\\d{3})(\\d{4})"",
            metadata->number_format(1).pattern());
  EXPECT_EQ(""$1 $2 $3"", metadata->number_format(1).format());
  EXPECT_EQ(""[13-689]\\d{9}|2[0-35-9]\\d{8}"",
            metadata->general_desc().national_number_pattern());
  EXPECT_EQ(""\\d{7}(?:\\d{3})?"",
            metadata->general_desc().possible_number_pattern());
  EXPECT_TRUE(Equals(metadata->general_desc(), metadata->fixed_line()));
  EXPECT_EQ(""\\d{10}"", metadata->toll_free().possible_number_pattern());
  EXPECT_EQ(""900\\d{7}"", metadata->premium_rate().national_number_pattern());
  // No shared-cost data is available, so it should be initialised to ""NA"".
  EXPECT_EQ(""NA"", metadata->shared_cost().national_number_pattern());
  EXPECT_EQ(""NA"", metadata->shared_cost().possible_number_pattern());
}

TEST_F(PhoneNumberUtilTest, GetInstanceLoadDEMetadata) {
  const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::DE());
  EXPECT_EQ(""DE"", metadata->id());
  EXPECT_EQ(49, metadata->country_code());
  EXPECT_EQ(""00"", metadata->international_prefix());
  EXPECT_EQ(""0"", metadata->national_prefix());
  ASSERT_EQ(6, metadata->number_format_size());
  EXPECT_EQ(1, metadata->number_format(5).leading_digits_pattern_size());
  EXPECT_EQ(""900"", metadata->number_format(5).leading_digits_pattern(0));
  EXPECT_EQ(""(\\d{3})(\\d{3,4})(\\d{4})"",
            metadata->number_format(5).pattern());
  EXPECT_EQ(""$1 $2 $3"", metadata->number_format(5).format());
  EXPECT_EQ(""(?:[24-6]\\d{2}|3[03-9]\\d|[789](?:[1-9]\\d|0[2-9]))\\d{1,8}"",
            metadata->fixed_line().national_number_pattern());
  EXPECT_EQ(""\\d{2,14}"", metadata->fixed_line().possible_number_pattern());
  EXPECT_EQ(""30123456"", metadata->fixed_line().example_number());
  EXPECT_EQ(""\\d{10}"", metadata->toll_free().possible_number_pattern());
  EXPECT_EQ(""900([135]\\d{6}|9\\d{7})"",
            metadata->premium_rate().national_number_pattern());
}

TEST_F(PhoneNumberUtilTest, GetInstanceLoadARMetadata) {
  const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::AR());
  EXPECT_EQ(""AR"", metadata->id());
  EXPECT_EQ(54, metadata->country_code());
  EXPECT_EQ(""00"", metadata->international_prefix());
  EXPECT_EQ(""0"", metadata->national_prefix());
  EXPECT_EQ(""0(?:(11|343|3715)15)?"", metadata->national_prefix_for_parsing());
  EXPECT_EQ(""9$1"", metadata->national_prefix_transform_rule());
  ASSERT_EQ(5, metadata->number_format_size());
  EXPECT_EQ(""$2 15 $3-$4"", metadata->number_format(2).format());
  EXPECT_EQ(""(9)(\\d{4})(\\d{2})(\\d{4})"",
            metadata->number_format(3).pattern());
  EXPECT_EQ(""(9)(\\d{4})(\\d{2})(\\d{4})"",
            metadata->intl_number_format(3).pattern());
  EXPECT_EQ(""$1 $2 $3 $4"", metadata->intl_number_format(3).format());
}

TEST_F(PhoneNumberUtilTest, GetInstanceLoadInternationalTollFreeMetadata) {
  const PhoneMetadata* metadata = GetMetadataForNonGeographicalRegion(800);
  EXPECT_FALSE(metadata == NULL);
  EXPECT_EQ(""001"", metadata->id());
  EXPECT_EQ(800, metadata->country_code());
  EXPECT_EQ(""$1 $2"", metadata->number_format(0).format());
  EXPECT_EQ(""(\\d{4})(\\d{4})"", metadata->number_format(0).pattern());
  EXPECT_EQ(""12345678"", metadata->general_desc().example_number());
  EXPECT_EQ(""12345678"", metadata->toll_free().example_number());
}

TEST_F(PhoneNumberUtilTest, GetNationalSignificantNumber) {
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(6502530000ULL);
  string national_significant_number;
  phone_util_.GetNationalSignificantNumber(number,
                                           &national_significant_number);
  EXPECT_EQ(""6502530000"", national_significant_number);

  // An Italian mobile number.
  national_significant_number.clear();
  number.set_country_code(39);
  number.set_national_number(312345678ULL);
  phone_util_.GetNationalSignificantNumber(number,
                                           &national_significant_number);
  EXPECT_EQ(""312345678"", national_significant_number);

  // An Italian fixed line number.
  national_significant_number.clear();
  number.set_country_code(39);
  number.set_national_number(236618300ULL);
  number.set_italian_leading_zero(true);
  phone_util_.GetNationalSignificantNumber(number,
                                           &national_significant_number);
  EXPECT_EQ(""0236618300"", national_significant_number);

  national_significant_number.clear();
  number.Clear();
  number.set_country_code(800);
  number.set_national_number(12345678ULL);
  phone_util_.GetNationalSignificantNumber(number,
                                           &national_significant_number);
  EXPECT_EQ(""12345678"", national_significant_number);
}

TEST_F(PhoneNumberUtilTest, GetExampleNumber) {
  PhoneNumber de_number;
  de_number.set_country_code(49);
  de_number.set_national_number(30123456ULL);
  PhoneNumber test_number;
  bool success = phone_util_.GetExampleNumber(RegionCode::DE(), &test_number);
  EXPECT_TRUE(success);
  EXPECT_EQ(de_number, test_number);

  success = phone_util_.GetExampleNumberForType(RegionCode::DE(),
                                                PhoneNumberUtil::FIXED_LINE,
                                                &test_number);
  EXPECT_TRUE(success);
  EXPECT_EQ(de_number, test_number);

  success = phone_util_.GetExampleNumberForType(RegionCode::DE(),
                                                PhoneNumberUtil::MOBILE,
                                                &test_number);
  // Here we test that an example number was not returned, and that the number
  // passed in was not modified.
  test_number.Clear();
  EXPECT_FALSE(success);
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  // For the US, the example number is placed under general description, and
  // hence should be used for both fixed line and mobile, so neither of these
  // should return null.
  success = phone_util_.GetExampleNumberForType(RegionCode::US(),
                                                PhoneNumberUtil::FIXED_LINE,
                                                &test_number);
  // Here we test that the call to get an example number succeeded, and that the
  // number passed in was modified.
  EXPECT_TRUE(success);
  EXPECT_NE(PhoneNumber::default_instance(), test_number);
  success = phone_util_.GetExampleNumberForType(RegionCode::US(),
                                                PhoneNumberUtil::MOBILE,
                                                &test_number);
  EXPECT_TRUE(success);
  EXPECT_NE(PhoneNumber::default_instance(), test_number);

  // CS is an invalid region, so we have no data for it. We should return false.
  test_number.Clear();
  EXPECT_FALSE(phone_util_.GetExampleNumberForType(RegionCode::CS(),
                                                   PhoneNumberUtil::MOBILE,
                                                   &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  // RegionCode 001 is reserved for supporting non-geographical country calling
  // code. We don't support getting an example number for it with this method.
  EXPECT_FALSE(phone_util_.GetExampleNumber(RegionCode::UN001(), &test_number));
}

TEST_F(PhoneNumberUtilTest, GetExampleNumberForNonGeoEntity) {
  PhoneNumber toll_free_number;
  toll_free_number.set_country_code(800);
  toll_free_number.set_national_number(12345678ULL);
  PhoneNumber test_number;
  bool success =
      phone_util_.GetExampleNumberForNonGeoEntity(800 , &test_number);
  EXPECT_TRUE(success);
  EXPECT_EQ(toll_free_number, test_number);

  PhoneNumber universal_premium_rate;
  universal_premium_rate.set_country_code(979);
  universal_premium_rate.set_national_number(123456789ULL);
  success = phone_util_.GetExampleNumberForNonGeoEntity(979 , &test_number);
  EXPECT_TRUE(success);
  EXPECT_EQ(universal_premium_rate, test_number);
}

TEST_F(PhoneNumberUtilTest, FormatUSNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(1);
  test_number.set_national_number(6502530000ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""650 253 0000"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+1 650 253 0000"", formatted_number);

  test_number.set_national_number(8002530000ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""800 253 0000"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+1 800 253 0000"", formatted_number);

  test_number.set_national_number(9002530000ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""900 253 0000"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+1 900 253 0000"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
  EXPECT_EQ(""tel:+1-900-253-0000"", formatted_number);
  test_number.set_national_number(0ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""0"", formatted_number);
  // Numbers with all zeros in the national number part will be formatted by
  // using the raw_input if that is available no matter which format is
  // specified.
  test_number.set_raw_input(""000-000-0000"");
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""000-000-0000"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatBSNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(1);
  test_number.set_national_number(2421234567ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""242 123 4567"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+1 242 123 4567"", formatted_number);

  test_number.set_national_number(8002530000ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""800 253 0000"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+1 800 253 0000"", formatted_number);

  test_number.set_national_number(9002530000ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""900 253 0000"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+1 900 253 0000"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatGBNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(44);
  test_number.set_national_number(2087389353ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""(020) 8738 9353"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+44 20 8738 9353"", formatted_number);

  test_number.set_national_number(7912345678ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""(07912) 345 678"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+44 7912 345 678"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatDENumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(49);
  test_number.set_national_number(301234ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""030/1234"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+49 30/1234"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
  EXPECT_EQ(""tel:+49-30-1234"", formatted_number);

  test_number.set_national_number(291123ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""0291 123"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+49 291 123"", formatted_number);

  test_number.set_national_number(29112345678ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""0291 12345678"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+49 291 12345678"", formatted_number);

  test_number.set_national_number(9123123ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""09123 123"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+49 9123 123"", formatted_number);

  test_number.set_national_number(80212345ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""08021 2345"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+49 8021 2345"", formatted_number);

  test_number.set_national_number(1234ULL);
  // Note this number is correctly formatted without national prefix. Most of
  // the numbers that are treated as invalid numbers by the library are short
  // numbers, and they are usually not dialed with national prefix.
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""1234"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+49 1234"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatITNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(39);
  test_number.set_national_number(236618300ULL);
  test_number.set_italian_leading_zero(true);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""02 3661 8300"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+39 02 3661 8300"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+390236618300"", formatted_number);

  test_number.set_national_number(345678901ULL);
  test_number.set_italian_leading_zero(false);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""345 678 901"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+39 345 678 901"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+39345678901"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatAUNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(61);
  test_number.set_national_number(236618300ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""02 3661 8300"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+61 2 3661 8300"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+61236618300"", formatted_number);

  test_number.set_national_number(1800123456ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""1800 123 456"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+61 1800 123 456"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+611800123456"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatARNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(54);
  test_number.set_national_number(1187654321ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""011 8765-4321"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+54 11 8765-4321"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+541187654321"", formatted_number);

  test_number.set_national_number(91187654321ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""011 15 8765-4321"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+54 9 11 8765 4321"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+5491187654321"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatMXNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(52);
  test_number.set_national_number(12345678900ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""045 234 567 8900"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+52 1 234 567 8900"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+5212345678900"", formatted_number);

  test_number.set_national_number(15512345678ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""045 55 1234 5678"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+52 1 55 1234 5678"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+5215512345678"", formatted_number);

  test_number.set_national_number(3312345678LL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""01 33 1234 5678"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+52 33 1234 5678"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+523312345678"", formatted_number);

  test_number.set_national_number(8211234567LL);
  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""01 821 123 4567"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+52 821 123 4567"", formatted_number);
  phone_util_.Format(test_number, PhoneNumberUtil::E164,
                     &formatted_number);
  EXPECT_EQ(""+528211234567"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatOutOfCountryCallingNumber) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(1);
  test_number.set_national_number(9002530000ULL);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::DE(),
                                              &formatted_number);
  EXPECT_EQ(""00 1 900 253 0000"", formatted_number);

  test_number.set_national_number(6502530000ULL);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::BS(),
                                              &formatted_number);
  EXPECT_EQ(""1 650 253 0000"", formatted_number);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::PL(),
                                              &formatted_number);
  EXPECT_EQ(""00 1 650 253 0000"", formatted_number);

  test_number.set_country_code(44);
  test_number.set_national_number(7912345678ULL);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
                                              &formatted_number);
  EXPECT_EQ(""011 44 7912 345 678"", formatted_number);

  test_number.set_country_code(49);
  test_number.set_national_number(1234ULL);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::GB(),
                                              &formatted_number);
  EXPECT_EQ(""00 49 1234"", formatted_number);
  // Note this number is correctly formatted without national prefix. Most of
  // the numbers that are treated as invalid numbers by the library are short
  // numbers, and they are usually not dialed with national prefix.
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::DE(),
                                              &formatted_number);
  EXPECT_EQ(""1234"", formatted_number);

  test_number.set_country_code(39);
  test_number.set_national_number(236618300ULL);
  test_number.set_italian_leading_zero(true);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
                                              &formatted_number);
  EXPECT_EQ(""011 39 02 3661 8300"", formatted_number);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::IT(),
                                              &formatted_number);
  EXPECT_EQ(""02 3661 8300"", formatted_number);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::SG(),
                                              &formatted_number);
  EXPECT_EQ(""+39 02 3661 8300"", formatted_number);

  test_number.set_country_code(65);
  test_number.set_national_number(94777892ULL);
  test_number.set_italian_leading_zero(false);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::SG(),
                                              &formatted_number);
  EXPECT_EQ(""9477 7892"", formatted_number);

  test_number.set_country_code(800);
  test_number.set_national_number(12345678ULL);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
                                              &formatted_number);
  EXPECT_EQ(""011 800 1234 5678"", formatted_number);

  test_number.set_country_code(54);
  test_number.set_national_number(91187654321ULL);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
                                              &formatted_number);
  EXPECT_EQ(""011 54 9 11 8765 4321"", formatted_number);

  test_number.set_extension(""1234"");
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
                                              &formatted_number);
  EXPECT_EQ(""011 54 9 11 8765 4321 ext. 1234"", formatted_number);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AU(),
                                              &formatted_number);
  EXPECT_EQ(""0011 54 9 11 8765 4321 ext. 1234"", formatted_number);
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AR(),
                                              &formatted_number);
  EXPECT_EQ(""011 15 8765-4321 ext. 1234"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatOutOfCountryWithInvalidRegion) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(1);
  test_number.set_national_number(6502530000ULL);
  // AQ/Antarctica isn't a valid region code for phone number formatting,
  // so this falls back to intl formatting.
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AQ(),
                                              &formatted_number);
  EXPECT_EQ(""+1 650 253 0000"", formatted_number);
  // For region code 001, the out-of-country format always turns into the
  // international format.
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::UN001(),
                                              &formatted_number);
  EXPECT_EQ(""+1 650 253 0000"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatOutOfCountryWithPreferredIntlPrefix) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(39);
  test_number.set_national_number(236618300ULL);
  test_number.set_italian_leading_zero(true);
  // This should use 0011, since that is the preferred international prefix
  // (both 0011 and 0012 are accepted as possible international prefixes in our
  // test metadta.)
  phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AU(),
                                              &formatted_number);
  EXPECT_EQ(""0011 39 02 3661 8300"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatOutOfCountryKeepingAlphaChars) {
  PhoneNumber alpha_numeric_number;
  string formatted_number;
  alpha_numeric_number.set_country_code(1);
  alpha_numeric_number.set_national_number(8007493524ULL);
  alpha_numeric_number.set_raw_input(""1800 six-flag"");
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AU(),
                                                  &formatted_number);
  EXPECT_EQ(""0011 1 800 SIX-FLAG"", formatted_number);

  formatted_number.clear();
  alpha_numeric_number.set_raw_input(""1-800-SIX-flag"");
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AU(),
                                                  &formatted_number);
  EXPECT_EQ(""0011 1 800-SIX-FLAG"", formatted_number);

  formatted_number.clear();
  alpha_numeric_number.set_raw_input(""Call us from UK: 00 1 800 SIX-flag"");
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AU(),
                                                  &formatted_number);
  EXPECT_EQ(""0011 1 800 SIX-FLAG"", formatted_number);

  formatted_number.clear();
  alpha_numeric_number.set_raw_input(""800 SIX-flag"");
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AU(),
                                                  &formatted_number);
  EXPECT_EQ(""0011 1 800 SIX-FLAG"", formatted_number);

  // Formatting from within the NANPA region.
  formatted_number.clear();
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::US(),
                                                  &formatted_number);
  EXPECT_EQ(""1 800 SIX-FLAG"", formatted_number);
  formatted_number.clear();
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::BS(),
                                                  &formatted_number);
  EXPECT_EQ(""1 800 SIX-FLAG"", formatted_number);

  // Testing that if the raw input doesn't exist, it is formatted using
  // FormatOutOfCountryCallingNumber.
  alpha_numeric_number.clear_raw_input();
  formatted_number.clear();
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::DE(),
                                                  &formatted_number);
  EXPECT_EQ(""00 1 800 749 3524"", formatted_number);

  // Testing AU alpha number formatted from Australia.
  alpha_numeric_number.set_country_code(61);
  alpha_numeric_number.set_national_number(827493524ULL);
  alpha_numeric_number.set_raw_input(""+61 82749-FLAG"");
  formatted_number.clear();
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AU(),
                                                  &formatted_number);
  // This number should have the national prefix prefixed.
  EXPECT_EQ(""082749-FLAG"", formatted_number);

  alpha_numeric_number.set_raw_input(""082749-FLAG"");
  formatted_number.clear();
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AU(),
                                                  &formatted_number);
  EXPECT_EQ(""082749-FLAG"", formatted_number);

  alpha_numeric_number.set_national_number(18007493524ULL);
  alpha_numeric_number.set_raw_input(""1-800-SIX-flag"");
  formatted_number.clear();
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AU(),
                                                  &formatted_number);
  // This number should not have the national prefix prefixed, in accordance
  // with the override for this specific formatting rule.
  EXPECT_EQ(""1-800-SIX-FLAG"", formatted_number);
  // The metadata should not be permanently changed, since we copied it before
  // modifying patterns. Here we check this.
  formatted_number.clear();
  alpha_numeric_number.set_national_number(1800749352ULL);
  phone_util_.FormatOutOfCountryCallingNumber(alpha_numeric_number,
                                              RegionCode::AU(),
                                              &formatted_number);
  EXPECT_EQ(""1800 749 352"", formatted_number);

  // Testing a country with multiple international prefixes.
  formatted_number.clear();
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::SG(),
                                                  &formatted_number);
  EXPECT_EQ(""+61 1-800-SIX-FLAG"", formatted_number);
  // Testing the case of calling from a non-supported region.
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AQ(),
                                                  &formatted_number);
  EXPECT_EQ(""+61 1-800-SIX-FLAG"", formatted_number);

  // Testing the case with an invalid country code.
  formatted_number.clear();
  alpha_numeric_number.set_country_code(0);
  alpha_numeric_number.set_national_number(18007493524ULL);
  alpha_numeric_number.set_raw_input(""1-800-SIX-flag"");
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::DE(),
                                                  &formatted_number);
  // Uses the raw input only.
  EXPECT_EQ(""1-800-SIX-flag"", formatted_number);

  // Testing the case of an invalid alpha number.
  formatted_number.clear();
  alpha_numeric_number.set_country_code(1);
  alpha_numeric_number.set_national_number(80749ULL);
  alpha_numeric_number.set_raw_input(""180-SIX"");
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::DE(),
                                                  &formatted_number);
  // No country-code stripping can be done.
  EXPECT_EQ(""00 1 180-SIX"", formatted_number);
  // Testing the case of calling from a non-supported region.
  phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
                                                  RegionCode::AQ(),
                                                  &formatted_number);
  // No country-code stripping can be done since the number is invalid.
  EXPECT_EQ(""+1 180-SIX"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatWithCarrierCode) {
  // We only support this for AR in our test metadata.
  PhoneNumber ar_number;
  string formatted_number;
  ar_number.set_country_code(54);
  ar_number.set_national_number(91234125678ULL);
  phone_util_.Format(ar_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""01234 12-5678"", formatted_number);
  // Test formatting with a carrier code.
  phone_util_.FormatNationalNumberWithCarrierCode(ar_number, ""15"",
                                                  &formatted_number);
  EXPECT_EQ(""01234 15 12-5678"", formatted_number);
  phone_util_.FormatNationalNumberWithCarrierCode(ar_number, """",
                                                  &formatted_number);
  EXPECT_EQ(""01234 12-5678"", formatted_number);
  // Here the international rule is used, so no carrier code should be present.
  phone_util_.Format(ar_number, PhoneNumberUtil::E164, &formatted_number);
  EXPECT_EQ(""+5491234125678"", formatted_number);

  // We don't support this for the US so there should be no change.
  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(4241231234ULL);
  phone_util_.Format(us_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""424 123 1234"", formatted_number);
  phone_util_.FormatNationalNumberWithCarrierCode(us_number, ""15"",
                                                  &formatted_number);
  EXPECT_EQ(""424 123 1234"", formatted_number);

  // Invalid country code should just get the NSN.
  PhoneNumber invalid_number;
  invalid_number.set_country_code(kInvalidCountryCode);
  invalid_number.set_national_number(12345ULL);
  phone_util_.FormatNationalNumberWithCarrierCode(invalid_number, ""89"",
                                                  &formatted_number);
  EXPECT_EQ(""12345"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatWithPreferredCarrierCode) {
  // We only support this for AR in our test metadata.
  PhoneNumber ar_number;
  string formatted_number;
  ar_number.set_country_code(54);
  ar_number.set_national_number(91234125678ULL);
  // Test formatting with no preferred carrier code stored in the number itself.
  phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, ""15"",
                                                           &formatted_number);
  EXPECT_EQ(""01234 15 12-5678"", formatted_number);
  phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, """",
                                                           &formatted_number);
  EXPECT_EQ(""01234 12-5678"", formatted_number);
  // Test formatting with preferred carrier code present.
  ar_number.set_preferred_domestic_carrier_code(""19"");
  phone_util_.Format(ar_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""01234 12-5678"", formatted_number);
  phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, ""15"",
                                                           &formatted_number);
  EXPECT_EQ(""01234 19 12-5678"", formatted_number);
  phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, """",
                                                           &formatted_number);
  EXPECT_EQ(""01234 19 12-5678"", formatted_number);
  // When the preferred_domestic_carrier_code is present (even when it contains
  // an empty string), use it instead of the default carrier code passed in.
  ar_number.set_preferred_domestic_carrier_code("""");
  phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, ""15"",
                                                           &formatted_number);
  EXPECT_EQ(""01234 12-5678"", formatted_number);
  // We don't support this for the US so there should be no change.
  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(4241231234ULL);
  us_number.set_preferred_domestic_carrier_code(""99"");
  phone_util_.Format(us_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""424 123 1234"", formatted_number);
  phone_util_.FormatNationalNumberWithPreferredCarrierCode(us_number, ""15"",
                                                           &formatted_number);
  EXPECT_EQ(""424 123 1234"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatNumberForMobileDialing) {
  PhoneNumber test_number;
  string formatted_number;

  // Numbers are normally dialed in national format in-country, and
  // international format from outside the country.
  test_number.set_country_code(49);
  test_number.set_national_number(30123456ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::DE(), false, /* remove formatting */
      &formatted_number);
  EXPECT_EQ(""030123456"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::CH(), false, /* remove formatting */
      &formatted_number);
  EXPECT_EQ(""+4930123456"", formatted_number);

  test_number.set_extension(""1234"");
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::DE(), false, /* remove formatting */
      &formatted_number);
  EXPECT_EQ(""030123456"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::CH(), false, /* remove formatting */
      &formatted_number);
  EXPECT_EQ(""+4930123456"", formatted_number);

  test_number.set_country_code(1);
  test_number.clear_extension();
  // US toll free numbers are marked as noInternationalDialling in the test
  // metadata for testing purposes. For such numbers, we expect nothing to be
  // returned when the region code is not the same one.
  test_number.set_national_number(8002530000ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), true, /* keep formatting */
      &formatted_number);
  EXPECT_EQ(""800 253 0000"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::CN(), true, &formatted_number);
  EXPECT_EQ("""", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, /* remove formatting */
      &formatted_number);
  EXPECT_EQ(""8002530000"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::CN(), false, &formatted_number);
  EXPECT_EQ("""", formatted_number);

  test_number.set_national_number(6502530000ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), true, &formatted_number);
  EXPECT_EQ(""+1 650 253 0000"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, &formatted_number);
  EXPECT_EQ(""+16502530000"", formatted_number);

  test_number.set_extension(""1234"");
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), true, &formatted_number);
  EXPECT_EQ(""+1 650 253 0000"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, &formatted_number);
  EXPECT_EQ(""+16502530000"", formatted_number);

  // An invalid US number, which is one digit too long.
  test_number.set_national_number(65025300001ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), true, &formatted_number);
  EXPECT_EQ(""+1 65025300001"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, &formatted_number);
  EXPECT_EQ(""+165025300001"", formatted_number);

  // Star numbers. In real life they appear in Israel, but we have them in JP
  // in our test metadata.
  test_number.set_country_code(81);
  test_number.set_national_number(2345ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::JP(), true, &formatted_number);
  EXPECT_EQ(""*2345"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::JP(), false, &formatted_number);
  EXPECT_EQ(""*2345"", formatted_number);

  test_number.set_country_code(800);
  test_number.set_national_number(12345678ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::JP(), false, &formatted_number);
  EXPECT_EQ(""+80012345678"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::JP(), true, &formatted_number);
  EXPECT_EQ(""+800 1234 5678"", formatted_number);

  // UAE numbers beginning with 600 (classified as UAN) need to be dialled
  // without +971 locally.
  test_number.set_country_code(971);
  test_number.set_national_number(600123456ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::JP(), false, &formatted_number);
  EXPECT_EQ(""+971600123456"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::AE(), true, &formatted_number);
  EXPECT_EQ(""600123456"", formatted_number);

  test_number.set_country_code(52);
  test_number.set_national_number(3312345678ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::MX(), false, &formatted_number);
  EXPECT_EQ(""+523312345678"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, &formatted_number);
  EXPECT_EQ(""+523312345678"", formatted_number);

  // Non-geographical numbers should always be dialed in international format.
  test_number.set_country_code(800);
  test_number.set_national_number(12345678ULL);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, &formatted_number);
  EXPECT_EQ(""+80012345678"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::UN001(), false, &formatted_number);
  EXPECT_EQ(""+80012345678"", formatted_number);

  // Test that a short number is formatted correctly for mobile dialing within
  // the region, and is not diallable from outside the region.
  test_number.set_country_code(49);
  test_number.set_national_number(123L);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::DE(), false, &formatted_number);
  EXPECT_EQ(""123"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::IT(), false, &formatted_number);
  EXPECT_EQ("""", formatted_number);

  // Test the special logic for Hungary, where the national prefix must be
  // added before dialing from a mobile phone for regular length numbers, but
  // not for short numbers.
  test_number.set_country_code(36);
  test_number.set_national_number(301234567L);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::HU(), false, &formatted_number);
  EXPECT_EQ(""06301234567"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::JP(), false, &formatted_number);
  EXPECT_EQ(""+36301234567"", formatted_number);
  test_number.set_national_number(104L);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::HU(), false, &formatted_number);
  EXPECT_EQ(""104"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::JP(), false, &formatted_number);
  EXPECT_EQ("""", formatted_number);

  // Test the special logic for NANPA countries, for which regular length phone
  // numbers are always output in international format, but short numbers are
  // in national format.
  test_number.set_country_code(1);
  test_number.set_national_number(6502530000L);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, &formatted_number);
  EXPECT_EQ(""+16502530000"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::CA(), false, &formatted_number);
  EXPECT_EQ(""+16502530000"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::BR(), false, &formatted_number);
  EXPECT_EQ(""+16502530000"", formatted_number);
  test_number.set_national_number(911L);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::US(), false, &formatted_number);
  EXPECT_EQ(""911"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::CA(), false, &formatted_number);
  EXPECT_EQ("""", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::BR(), false, &formatted_number);
  EXPECT_EQ("""", formatted_number);
  // Test that the Australian emergency number 000 is formatted correctly.
  test_number.set_country_code(61);
  test_number.set_national_number(0L);
  test_number.set_italian_leading_zero(true);
  test_number.set_number_of_leading_zeros(2);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::AU(), false, &formatted_number);
  EXPECT_EQ(""000"", formatted_number);
  phone_util_.FormatNumberForMobileDialing(
      test_number, RegionCode::NZ(), false, &formatted_number);
  EXPECT_EQ("""", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatByPattern) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(1);
  test_number.set_national_number(6502530000ULL);

  RepeatedPtrField<NumberFormat> number_formats;
  NumberFormat* number_format = number_formats.Add();
  number_format->set_pattern(""(\\d{3})(\\d{3})(\\d{4})"");
  number_format->set_format(""($1) $2-$3"");
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""(650) 253-0000"", formatted_number);
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""+1 (650) 253-0000"", formatted_number);
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::RFC3966,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""tel:+1-650-253-0000"", formatted_number);

  // $NP is set to '1' for the US. Here we check that for other NANPA countries
  // the US rules are followed.
  number_format->set_national_prefix_formatting_rule(""$NP ($FG)"");
  number_format->set_format(""$1 $2-$3"");
  test_number.set_country_code(1);
  test_number.set_national_number(4168819999ULL);
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""1 (416) 881-9999"", formatted_number);
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""+1 416 881-9999"", formatted_number);

  test_number.set_country_code(39);
  test_number.set_national_number(236618300ULL);
  test_number.set_italian_leading_zero(true);
  number_format->set_pattern(""(\\d{2})(\\d{5})(\\d{3})"");
  number_format->set_format(""$1-$2 $3"");
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""02-36618 300"", formatted_number);
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""+39 02-36618 300"", formatted_number);

  test_number.set_country_code(44);
  test_number.set_national_number(2012345678ULL);
  test_number.set_italian_leading_zero(false);
  number_format->set_national_prefix_formatting_rule(""$NP$FG"");
  number_format->set_pattern(""(\\d{2})(\\d{4})(\\d{4})"");
  number_format->set_format(""$1 $2 $3"");
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""020 1234 5678"", formatted_number);

  number_format->set_national_prefix_formatting_rule(""($NP$FG)"");
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""(020) 1234 5678"", formatted_number);
  number_format->set_national_prefix_formatting_rule("""");
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""20 1234 5678"", formatted_number);
  number_format->set_national_prefix_formatting_rule("""");
  phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
                              number_formats,
                              &formatted_number);
  EXPECT_EQ(""+44 20 1234 5678"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatE164Number) {
  PhoneNumber test_number;
  string formatted_number;
  test_number.set_country_code(1);
  test_number.set_national_number(6502530000ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
  EXPECT_EQ(""+16502530000"", formatted_number);

  test_number.set_country_code(49);
  test_number.set_national_number(301234ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
  EXPECT_EQ(""+49301234"", formatted_number);

  test_number.set_country_code(800);
  test_number.set_national_number(12345678ULL);
  phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
  EXPECT_EQ(""+80012345678"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, FormatNumberWithExtension) {
  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(33316005ULL);
  nz_number.set_extension(""1234"");
  string formatted_number;
  // Uses default extension prefix:
  phone_util_.Format(nz_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""03-331 6005 ext. 1234"", formatted_number);
  // Uses RFC 3966 syntax.
  phone_util_.Format(nz_number, PhoneNumberUtil::RFC3966, &formatted_number);
  EXPECT_EQ(""tel:+64-3-331-6005;ext=1234"", formatted_number);
  // Extension prefix overridden in the territory information for the US:
  PhoneNumber us_number_with_extension;
  us_number_with_extension.set_country_code(1);
  us_number_with_extension.set_national_number(6502530000ULL);
  us_number_with_extension.set_extension(""4567"");
  phone_util_.Format(us_number_with_extension,
                     PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""650 253 0000 extn. 4567"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, GetLengthOfGeographicalAreaCode) {
  PhoneNumber number;
  // Google MTV, which has area code ""650"".
  number.set_country_code(1);
  number.set_national_number(6502530000ULL);
  EXPECT_EQ(3, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // A North America toll-free number, which has no area code.
  number.set_country_code(1);
  number.set_national_number(8002530000ULL);
  EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // An invalid US number (1 digit shorter), which has no area code.
  number.set_country_code(1);
  number.set_national_number(650253000ULL);
  EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // Google London, which has area code ""20"".
  number.set_country_code(44);
  number.set_national_number(2070313000ULL);
  EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // A UK mobile phone, which has no area code.
  number.set_country_code(44);
  number.set_national_number(7123456789ULL);
  EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // Google Buenos Aires, which has area code ""11"".
  number.set_country_code(54);
  number.set_national_number(1155303000ULL);
  EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // Google Sydney, which has area code ""2"".
  number.set_country_code(61);
  number.set_national_number(293744000ULL);
  EXPECT_EQ(1, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // Italian numbers - there is no national prefix, but it still has an area
  // code.
  number.set_country_code(39);
  number.set_national_number(236618300ULL);
  number.set_italian_leading_zero(true);
  EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // Google Singapore. Singapore has no area code and no national prefix.
  number.set_country_code(65);
  number.set_national_number(65218000ULL);
  number.set_italian_leading_zero(false);
  EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));

  // An international toll free number, which has no area code.
  number.set_country_code(800);
  number.set_national_number(12345678ULL);
  EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
}

TEST_F(PhoneNumberUtilTest, GetLengthOfNationalDestinationCode) {
  PhoneNumber number;
  // Google MTV, which has national destination code (NDC) ""650"".
  number.set_country_code(1);
  number.set_national_number(6502530000ULL);
  EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));

  // A North America toll-free number, which has NDC ""800"".
  number.set_country_code(1);
  number.set_national_number(8002530000ULL);
  EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));

  // Google London, which has NDC ""20"".
  number.set_country_code(44);
  number.set_national_number(2070313000ULL);
  EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));

  // A UK mobile phone, which has NDC ""7123""
  number.set_country_code(44);
  number.set_national_number(7123456789ULL);
  EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));

  // Google Buenos Aires, which has NDC ""11"".
  number.set_country_code(54);
  number.set_national_number(1155303000ULL);
  EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));

  // An Argentinian mobile which has NDC ""911"".
  number.set_country_code(54);
  number.set_national_number(91187654321ULL);
  EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));

  // Google Sydney, which has NDC ""2"".
  number.set_country_code(61);
  number.set_national_number(293744000ULL);
  EXPECT_EQ(1, phone_util_.GetLengthOfNationalDestinationCode(number));

  // Google Singapore. Singapore has NDC ""6521"".
  number.set_country_code(65);
  number.set_national_number(65218000ULL);
  EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));

  // An invalid US number (1 digit shorter), which has no NDC.
  number.set_country_code(1);
  number.set_national_number(650253000ULL);
  EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));

  // A number containing an invalid country code, which shouldn't have any NDC.
  number.set_country_code(123);
  number.set_national_number(650253000ULL);
  EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));

  // A number that has only one group of digits after country code when
  // formatted in the international format.
  number.set_country_code(376);
  number.set_national_number(12345ULL);
  EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));

  // The same number above, but with an extension.
  number.set_country_code(376);
  number.set_national_number(12345ULL);
  number.set_extension(""321"");
  EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));

  // An international toll free number, which has NDC ""1234"".
  number.Clear();
  number.set_country_code(800);
  number.set_national_number(12345678ULL);
  EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
}

TEST_F(PhoneNumberUtilTest, GetCountryMobileToken) {
  int country_calling_code;
  string mobile_token;

  country_calling_code = phone_util_.GetCountryCodeForRegion(RegionCode::MX());
  phone_util_.GetCountryMobileToken(country_calling_code, &mobile_token);
  EXPECT_EQ(""1"", mobile_token);

  // Country calling code for Sweden, which has no mobile token.
  country_calling_code = phone_util_.GetCountryCodeForRegion(RegionCode::SE());
  phone_util_.GetCountryMobileToken(country_calling_code, &mobile_token);
  EXPECT_EQ("""", mobile_token);
}

TEST_F(PhoneNumberUtilTest, ExtractPossibleNumber) {
  // Removes preceding funky punctuation and letters but leaves the rest
  // untouched.
  string extracted_number;
  ExtractPossibleNumber(""Tel:0800-345-600"", &extracted_number);
  EXPECT_EQ(""0800-345-600"", extracted_number);
  ExtractPossibleNumber(""Tel:0800 FOR PIZZA"", &extracted_number);
  EXPECT_EQ(""0800 FOR PIZZA"", extracted_number);

  // Should not remove plus sign.
  ExtractPossibleNumber(""Tel:+800-345-600"", &extracted_number);
  EXPECT_EQ(""+800-345-600"", extracted_number);
  // Should recognise wide digits as possible start values.
  ExtractPossibleNumber(""\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93"" /* ""０２３"" */,
                        &extracted_number);
  EXPECT_EQ(""\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93"" /* ""０２３"" */,
            extracted_number);
  // Dashes are not possible start values and should be removed.
  ExtractPossibleNumber(""Num-\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93""
                        /* ""Num-１２３"" */, &extracted_number);
  EXPECT_EQ(""\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93"" /* ""１２３"" */,
            extracted_number);
  // If not possible number present, return empty string.
  ExtractPossibleNumber(""Num-...."", &extracted_number);
  EXPECT_EQ("""", extracted_number);
  // Leading brackets are stripped - these are not used when parsing.
  ExtractPossibleNumber(""(650) 253-0000"", &extracted_number);
  EXPECT_EQ(""650) 253-0000"", extracted_number);

  // Trailing non-alpha-numeric characters should be removed.
  ExtractPossibleNumber(""(650) 253-0000..- .."", &extracted_number);
  EXPECT_EQ(""650) 253-0000"", extracted_number);
  ExtractPossibleNumber(""(650) 253-0000."", &extracted_number);
  EXPECT_EQ(""650) 253-0000"", extracted_number);
  // This case has a trailing RTL char.
  ExtractPossibleNumber(""(650) 253-0000\xE2\x80\x8F""
                        /* ""(650) 253-0000‏"" */, &extracted_number);
  EXPECT_EQ(""650) 253-0000"", extracted_number);
}

TEST_F(PhoneNumberUtilTest, IsNANPACountry) {
  EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::US()));
  EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::BS()));
  EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::DE()));
  EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::GetUnknown()));
  EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::UN001()));
}

TEST_F(PhoneNumberUtilTest, IsValidNumber) {
  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(6502530000ULL);
  EXPECT_TRUE(phone_util_.IsValidNumber(us_number));

  PhoneNumber it_number;
  it_number.set_country_code(39);
  it_number.set_national_number(236618300ULL);
  it_number.set_italian_leading_zero(true);
  EXPECT_TRUE(phone_util_.IsValidNumber(it_number));

  PhoneNumber gb_number;
  gb_number.set_country_code(44);
  gb_number.set_national_number(7912345678ULL);
  EXPECT_TRUE(phone_util_.IsValidNumber(gb_number));

  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(21387835ULL);
  EXPECT_TRUE(phone_util_.IsValidNumber(nz_number));

  PhoneNumber intl_toll_free_number;
  intl_toll_free_number.set_country_code(800);
  intl_toll_free_number.set_national_number(12345678ULL);
  EXPECT_TRUE(phone_util_.IsValidNumber(intl_toll_free_number));

  PhoneNumber universal_premium_rate;
  universal_premium_rate.set_country_code(979);
  universal_premium_rate.set_national_number(123456789ULL);
  EXPECT_TRUE(phone_util_.IsValidNumber(universal_premium_rate));
}

TEST_F(PhoneNumberUtilTest, IsValidForRegion) {
  // This number is valid for the Bahamas, but is not a valid US number.
  PhoneNumber bs_number;
  bs_number.set_country_code(1);
  bs_number.set_national_number(2423232345ULL);
  EXPECT_TRUE(phone_util_.IsValidNumber(bs_number));
  EXPECT_TRUE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::BS()));
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::US()));
  bs_number.set_national_number(2421232345ULL);
  // This number is no longer valid.
  EXPECT_FALSE(phone_util_.IsValidNumber(bs_number));

  // La Mayotte and Réunion use 'leadingDigits' to differentiate them.
  PhoneNumber re_number;
  re_number.set_country_code(262);
  re_number.set_national_number(262123456ULL);
  EXPECT_TRUE(phone_util_.IsValidNumber(re_number));
  EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
  // Now change the number to be a number for La Mayotte.
  re_number.set_national_number(269601234ULL);
  EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
  // This number is no longer valid.
  re_number.set_national_number(269123456ULL);
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
  EXPECT_FALSE(phone_util_.IsValidNumber(re_number));
  // However, it should be recognised as from La Mayotte.
  string region_code;
  phone_util_.GetRegionCodeForNumber(re_number, &region_code);
  EXPECT_EQ(RegionCode::YT(), region_code);
  // This number is valid in both places.
  re_number.set_national_number(800123456ULL);
  EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
  EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));

  PhoneNumber intl_toll_free_number;
  intl_toll_free_number.set_country_code(800);
  intl_toll_free_number.set_national_number(12345678ULL);
  EXPECT_TRUE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
                                                 RegionCode::UN001()));
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
                                                  RegionCode::US()));
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
                                                  RegionCode::ZZ()));

  PhoneNumber invalid_number;
  // Invalid country calling codes.
  invalid_number.set_country_code(3923);
  invalid_number.set_national_number(2366ULL);
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
                                                  RegionCode::ZZ()));
  invalid_number.set_country_code(3923);
  invalid_number.set_national_number(2366ULL);
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
                                                  RegionCode::UN001()));
  invalid_number.set_country_code(0);
  invalid_number.set_national_number(2366ULL);
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
                                                  RegionCode::UN001()));
  invalid_number.set_country_code(0);
  EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
                                                  RegionCode::ZZ()));
}

TEST_F(PhoneNumberUtilTest, IsNotValidNumber) {
  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(2530000ULL);
  EXPECT_FALSE(phone_util_.IsValidNumber(us_number));

  PhoneNumber it_number;
  it_number.set_country_code(39);
  it_number.set_national_number(23661830000ULL);
  it_number.set_italian_leading_zero(true);
  EXPECT_FALSE(phone_util_.IsValidNumber(it_number));

  PhoneNumber gb_number;
  gb_number.set_country_code(44);
  gb_number.set_national_number(791234567ULL);
  EXPECT_FALSE(phone_util_.IsValidNumber(gb_number));

  PhoneNumber de_number;
  de_number.set_country_code(49);
  de_number.set_national_number(1234ULL);
  EXPECT_FALSE(phone_util_.IsValidNumber(de_number));

  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(3316005ULL);
  EXPECT_FALSE(phone_util_.IsValidNumber(nz_number));

  PhoneNumber invalid_number;
  // Invalid country calling codes.
  invalid_number.set_country_code(3923);
  invalid_number.set_national_number(2366ULL);
  EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
  invalid_number.set_country_code(0);
  EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));

  PhoneNumber intl_toll_free_number_too_long;
  intl_toll_free_number_too_long.set_country_code(800);
  intl_toll_free_number_too_long.set_national_number(123456789ULL);
  EXPECT_FALSE(phone_util_.IsValidNumber(intl_toll_free_number_too_long));
}

TEST_F(PhoneNumberUtilTest, GetRegionCodeForCountryCode) {
  string region_code;
  phone_util_.GetRegionCodeForCountryCode(1, &region_code);
  EXPECT_EQ(RegionCode::US(), region_code);
  phone_util_.GetRegionCodeForCountryCode(44, &region_code);
  EXPECT_EQ(RegionCode::GB(), region_code);
  phone_util_.GetRegionCodeForCountryCode(49, &region_code);
  EXPECT_EQ(RegionCode::DE(), region_code);
  phone_util_.GetRegionCodeForCountryCode(800, &region_code);
  EXPECT_EQ(RegionCode::UN001(), region_code);
  phone_util_.GetRegionCodeForCountryCode(979, &region_code);
  EXPECT_EQ(RegionCode::UN001(), region_code);
}

TEST_F(PhoneNumberUtilTest, GetRegionCodeForNumber) {
  string region_code;
  PhoneNumber bs_number;
  bs_number.set_country_code(1);
  bs_number.set_national_number(2423232345ULL);
  phone_util_.GetRegionCodeForNumber(bs_number, &region_code);
  EXPECT_EQ(RegionCode::BS(), region_code);

  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(4241231234ULL);
  phone_util_.GetRegionCodeForNumber(us_number, &region_code);
  EXPECT_EQ(RegionCode::US(), region_code);

  PhoneNumber gb_mobile;
  gb_mobile.set_country_code(44);
  gb_mobile.set_national_number(7912345678ULL);
  phone_util_.GetRegionCodeForNumber(gb_mobile, &region_code);
  EXPECT_EQ(RegionCode::GB(), region_code);

  PhoneNumber intl_toll_free_number;
  intl_toll_free_number.set_country_code(800);
  intl_toll_free_number.set_national_number(12345678ULL);
  phone_util_.GetRegionCodeForNumber(intl_toll_free_number, &region_code);
  EXPECT_EQ(RegionCode::UN001(), region_code);

  PhoneNumber universal_premium_rate;
  universal_premium_rate.set_country_code(979);
  universal_premium_rate.set_national_number(123456789ULL);
  phone_util_.GetRegionCodeForNumber(universal_premium_rate, &region_code);
  EXPECT_EQ(RegionCode::UN001(), region_code);
}

TEST_F(PhoneNumberUtilTest, IsPossibleNumber) {
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(6502530000ULL);
  EXPECT_TRUE(phone_util_.IsPossibleNumber(number));

  number.set_country_code(1);
  number.set_national_number(2530000ULL);
  EXPECT_TRUE(phone_util_.IsPossibleNumber(number));

  number.set_country_code(44);
  number.set_national_number(2070313000ULL);
  EXPECT_TRUE(phone_util_.IsPossibleNumber(number));

  number.set_country_code(800);
  number.set_national_number(12345678ULL);
  EXPECT_TRUE(phone_util_.IsPossibleNumber(number));

  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""+1 650 253 0000"",
                                                    RegionCode::US()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""+1 650 GOO OGLE"",
                                                    RegionCode::US()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""(650) 253-0000"",
                                                    RegionCode::US()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""253-0000"",
                                                    RegionCode::US()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""+1 650 253 0000"",
                                                    RegionCode::GB()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""+44 20 7031 3000"",
                                                    RegionCode::GB()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""(020) 7031 3000"",
                                                    RegionCode::GB()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""7031 3000"",
                                                    RegionCode::GB()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""3331 6005"",
                                                    RegionCode::NZ()));
  EXPECT_TRUE(phone_util_.IsPossibleNumberForString(""+800 1234 5678"",
                                                    RegionCode::UN001()));
}

TEST_F(PhoneNumberUtilTest, IsPossibleNumberWithReason) {
  // FYI, national numbers for country code +1 that are within 7 to 10 digits
  // are possible.
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(6502530000ULL);
  EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(1);
  number.set_national_number(2530000ULL);
  EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(0);
  number.set_national_number(2530000ULL);
  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(1);
  number.set_national_number(253000ULL);
  EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(1);
  number.set_national_number(65025300000ULL);
  EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(44);
  number.set_national_number(2070310000ULL);
  EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(49);
  number.set_national_number(30123456ULL);
  EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(65);
  number.set_national_number(1234567890ULL);
  EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
            phone_util_.IsPossibleNumberWithReason(number));

  number.set_country_code(800);
  number.set_national_number(123456789ULL);
  EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
            phone_util_.IsPossibleNumberWithReason(number));
}

TEST_F(PhoneNumberUtilTest, IsNotPossibleNumber) {
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(65025300000ULL);
  EXPECT_FALSE(phone_util_.IsPossibleNumber(number));

  number.set_country_code(800);
  number.set_national_number(123456789ULL);
  EXPECT_FALSE(phone_util_.IsPossibleNumber(number));

  number.set_country_code(1);
  number.set_national_number(253000ULL);
  EXPECT_FALSE(phone_util_.IsPossibleNumber(number));

  number.set_country_code(44);
  number.set_national_number(300ULL);
  EXPECT_FALSE(phone_util_.IsPossibleNumber(number));

  EXPECT_FALSE(phone_util_.IsPossibleNumberForString(""+1 650 253 00000"",
                                                     RegionCode::US()));
  EXPECT_FALSE(phone_util_.IsPossibleNumberForString(""(650) 253-00000"",
                                                     RegionCode::US()));
  EXPECT_FALSE(phone_util_.IsPossibleNumberForString(""I want a Pizza"",
                                                     RegionCode::US()));
  EXPECT_FALSE(phone_util_.IsPossibleNumberForString(""253-000"",
                                                     RegionCode::US()));
  EXPECT_FALSE(phone_util_.IsPossibleNumberForString(""1 3000"",
                                                     RegionCode::GB()));
  EXPECT_FALSE(phone_util_.IsPossibleNumberForString(""+44 300"",
                                                     RegionCode::GB()));
  EXPECT_FALSE(phone_util_.IsPossibleNumberForString(""+800 1234 5678 9"",
                                                     RegionCode::UN001()));
}

TEST_F(PhoneNumberUtilTest, TruncateTooLongNumber) {
  // US number 650-253-0000, but entered with one additional digit at the end.
  PhoneNumber too_long_number;
  too_long_number.set_country_code(1);
  too_long_number.set_national_number(65025300001ULL);
  PhoneNumber valid_number;
  valid_number.set_country_code(1);
  valid_number.set_national_number(6502530000ULL);
  EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
  EXPECT_EQ(valid_number, too_long_number);

  too_long_number.set_country_code(800);
  too_long_number.set_national_number(123456789ULL);
  valid_number.set_country_code(800);
  valid_number.set_national_number(12345678ULL);
  EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
  EXPECT_EQ(valid_number, too_long_number);

  // GB number 080 1234 5678, but entered with 4 extra digits at the end.
  too_long_number.set_country_code(44);
  too_long_number.set_national_number(80123456780123ULL);
  valid_number.set_country_code(44);
  valid_number.set_national_number(8012345678ULL);
  EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
  EXPECT_EQ(valid_number, too_long_number);

  // IT number 022 3456 7890, but entered with 3 extra digits at the end.
  too_long_number.set_country_code(39);
  too_long_number.set_national_number(2234567890123ULL);
  too_long_number.set_italian_leading_zero(true);
  valid_number.set_country_code(39);
  valid_number.set_national_number(2234567890ULL);
  valid_number.set_italian_leading_zero(true);
  EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
  EXPECT_EQ(valid_number, too_long_number);

  // Tests what happens when a valid number is passed in.
  PhoneNumber valid_number_copy(valid_number);
  EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&valid_number));
  // Tests the number is not modified.
  EXPECT_EQ(valid_number_copy, valid_number);

  // Tests what happens when a number with invalid prefix is passed in.
  PhoneNumber number_with_invalid_prefix;
  number_with_invalid_prefix.set_country_code(1);
  // The test metadata says US numbers cannot have prefix 240.
  number_with_invalid_prefix.set_national_number(2401234567ULL);
  PhoneNumber invalid_number_copy(number_with_invalid_prefix);
  EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&number_with_invalid_prefix));
  // Tests the number is not modified.
  EXPECT_EQ(invalid_number_copy, number_with_invalid_prefix);

  // Tests what happens when a too short number is passed in.
  PhoneNumber too_short_number;
  too_short_number.set_country_code(1);
  too_short_number.set_national_number(1234ULL);
  PhoneNumber too_short_number_copy(too_short_number);
  EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&too_short_number));
  // Tests the number is not modified.
  EXPECT_EQ(too_short_number_copy, too_short_number);
}

TEST_F(PhoneNumberUtilTest, IsNumberGeographical) {
  PhoneNumber number;

  number.set_country_code(1);
  number.set_national_number(2423570000ULL);
  EXPECT_FALSE(IsNumberGeographical(number));  // Bahamas, mobile phone number.

  number.set_country_code(61);
  number.set_national_number(236618300ULL);
  EXPECT_TRUE(IsNumberGeographical(number));  // Australian fixed line number.

  number.set_country_code(800);
  number.set_national_number(12345678ULL);
  EXPECT_FALSE(IsNumberGeographical(number));  // Internation toll free number.
}

TEST_F(PhoneNumberUtilTest, IsLeadingZeroPossible) {
  EXPECT_TRUE(IsLeadingZeroPossible(39));  // Italy
  EXPECT_FALSE(IsLeadingZeroPossible(1));  // USA
  EXPECT_TRUE(IsLeadingZeroPossible(800));  // International toll free
  EXPECT_FALSE(IsLeadingZeroPossible(979));  // International premium-rate
  EXPECT_FALSE(IsLeadingZeroPossible(888));  // Not in metadata file, should
                                             // return default value of false.
}

TEST_F(PhoneNumberUtilTest, FormatInOriginalFormat) {
  PhoneNumber phone_number;
  string formatted_number;

  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""+442087654321"", RegionCode::GB(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
                                     &formatted_number);
  EXPECT_EQ(""+44 20 8765 4321"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""02087654321"", RegionCode::GB(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
                                     &formatted_number);
  EXPECT_EQ(""(020) 8765 4321"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""011442087654321"",
                                             RegionCode::US(), &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
                                     &formatted_number);
  EXPECT_EQ(""011 44 20 8765 4321"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""442087654321"", RegionCode::GB(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
                                     &formatted_number);
  EXPECT_EQ(""44 20 8765 4321"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+442087654321"", RegionCode::GB(),
                              &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
                                     &formatted_number);
  EXPECT_EQ(""(020) 8765 4321"", formatted_number);

  // Invalid numbers that we have a formatting pattern for should be formatted
  // properly.  Note area codes starting with 7 are intentionally excluded in
  // the test metadata for testing purposes.
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""7345678901"", RegionCode::US(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
                                     &formatted_number);
  EXPECT_EQ(""734 567 8901"", formatted_number);

  // US is not a leading zero country, and the presence of the leading zero
  // leads us to format the number using raw_input.
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""0734567 8901"", RegionCode::US(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
                                     &formatted_number);
  EXPECT_EQ(""0734567 8901"", formatted_number);

  // This number is valid, but we don't have a formatting pattern for it. Fall
  // back to the raw input.
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""02-4567-8900"", RegionCode::KR(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
                                     &formatted_number);
  EXPECT_EQ(""02-4567-8900"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""01180012345678"",
                                             RegionCode::US(), &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
                                     &formatted_number);
  EXPECT_EQ(""011 800 1234 5678"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""+80012345678"", RegionCode::KR(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
                                     &formatted_number);
  EXPECT_EQ(""+800 1234 5678"", formatted_number);

  // US local numbers are formatted correctly, as we have formatting patterns
  // for them.
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""2530000"", RegionCode::US(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
                                     &formatted_number);
  EXPECT_EQ(""253 0000"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Number with national prefix in the US.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""18003456789"", RegionCode::US(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
                                     &formatted_number);
  EXPECT_EQ(""1 800 345 6789"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Number without national prefix in the UK.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""2087654321"", RegionCode::GB(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
                                     &formatted_number);
  EXPECT_EQ(""20 8765 4321"", formatted_number);
  // Make sure no metadata is modified as a result of the previous function
  // call.
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+442087654321"", RegionCode::GB(),
                              &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
                                     &formatted_number);
  EXPECT_EQ(""(020) 8765 4321"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Number with national prefix in Mexico.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""013312345678"", RegionCode::MX(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
                                     &formatted_number);
  EXPECT_EQ(""01 33 1234 5678"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Number without national prefix in Mexico.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""3312345678"", RegionCode::MX(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
                                     &formatted_number);
  EXPECT_EQ(""33 1234 5678"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Italian fixed-line number.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""0212345678"", RegionCode::IT(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::IT(),
                                     &formatted_number);
  EXPECT_EQ(""02 1234 5678"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Number with national prefix in Japan.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""00777012"", RegionCode::JP(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
                                     &formatted_number);
  EXPECT_EQ(""0077-7012"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Number without national prefix in Japan.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""0777012"", RegionCode::JP(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
                                     &formatted_number);
  EXPECT_EQ(""0777012"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // Number with carrier code in Brazil.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""012 3121286979"", RegionCode::BR(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::BR(),
                                     &formatted_number);
  EXPECT_EQ(""012 3121286979"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  // The default national prefix used in this case is 045. When a number with
  // national prefix 044 is entered, we return the raw input as we don't want to
  // change the number entered.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""044(33)1234-5678"",
                                             RegionCode::MX(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
                                     &formatted_number);
  EXPECT_EQ(""044(33)1234-5678"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""045(33)1234-5678"",
                                             RegionCode::MX(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
                                     &formatted_number);
  EXPECT_EQ(""045 33 1234 5678"", formatted_number);

  // The default international prefix used in this case is 0011. When a number
  // with international prefix 0012 is entered, we return the raw input as we
  // don't want to change the number entered.
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""0012 16502530000"",
                                             RegionCode::AU(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
                                     &formatted_number);
  EXPECT_EQ(""0012 16502530000"", formatted_number);

  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""0011 16502530000"",
                                             RegionCode::AU(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
                                     &formatted_number);
  EXPECT_EQ(""0011 1 650 253 0000"", formatted_number);

  // Test the star sign is not removed from or added to the original input by
  // this method.
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""*1234"",
                                             RegionCode::JP(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
                                     &formatted_number);
  EXPECT_EQ(""*1234"", formatted_number);
  phone_number.Clear();
  formatted_number.clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""1234"",
                                             RegionCode::JP(),
                                             &phone_number));
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
                                     &formatted_number);
  EXPECT_EQ(""1234"", formatted_number);

  // Test that an invalid national number without raw input is just formatted
  // as the national number.
  phone_number.Clear();
  formatted_number.clear();
  phone_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
  phone_number.set_country_code(1);
  phone_number.set_national_number(650253000ULL);
  phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
                                     &formatted_number);
  EXPECT_EQ(""650253000"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, IsPremiumRate) {
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(9004433030ULL);
  EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));

  number.set_country_code(39);
  number.set_national_number(892123ULL);
  EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));

  number.set_country_code(44);
  number.set_national_number(9187654321ULL);
  EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));

  number.set_country_code(49);
  number.set_national_number(9001654321ULL);
  EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));

  number.set_country_code(49);
  number.set_national_number(90091234567ULL);
  EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));

  number.set_country_code(979);
  number.set_national_number(123456789ULL);
  EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsTollFree) {
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(8881234567ULL);
  EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));

  number.set_country_code(39);
  number.set_national_number(803123ULL);
  EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));

  number.set_country_code(44);
  number.set_national_number(8012345678ULL);
  EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));

  number.set_country_code(49);
  number.set_national_number(8001234567ULL);
  EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));

  number.set_country_code(800);
  number.set_national_number(12345678ULL);
  EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsMobile) {
  PhoneNumber number;
  // A Bahama mobile number
  number.set_country_code(1);
  number.set_national_number(2423570000ULL);
  EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));

  number.set_country_code(39);
  number.set_national_number(312345678ULL);
  EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));

  number.set_country_code(44);
  number.set_national_number(7912345678ULL);
  EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));

  number.set_country_code(49);
  number.set_national_number(15123456789ULL);
  EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));

  number.set_country_code(54);
  number.set_national_number(91187654321ULL);
  EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsFixedLine) {
  PhoneNumber number;
  // A Bahama fixed-line number
  number.set_country_code(1);
  number.set_national_number(2423651234ULL);
  EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));

  // An Italian fixed-line number
  number.Clear();
  number.set_country_code(39);
  number.set_national_number(236618300ULL);
  number.set_italian_leading_zero(true);
  EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));

  number.Clear();
  number.set_country_code(44);
  number.set_national_number(2012345678ULL);
  EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));

  number.set_country_code(49);
  number.set_national_number(301234ULL);
  EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsFixedLineAndMobile) {
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(6502531111ULL);
  EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
            phone_util_.GetNumberType(number));

  number.set_country_code(54);
  number.set_national_number(1987654321ULL);
  EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
            phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsSharedCost) {
  PhoneNumber number;
  number.set_country_code(44);
  number.set_national_number(8431231234ULL);
  EXPECT_EQ(PhoneNumberUtil::SHARED_COST, phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsVoip) {
  PhoneNumber number;
  number.set_country_code(44);
  number.set_national_number(5631231234ULL);
  EXPECT_EQ(PhoneNumberUtil::VOIP, phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsPersonalNumber) {
  PhoneNumber number;
  number.set_country_code(44);
  number.set_national_number(7031231234ULL);
  EXPECT_EQ(PhoneNumberUtil::PERSONAL_NUMBER,
            phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, IsUnknown) {
  PhoneNumber number;
  number.set_country_code(1);
  number.set_national_number(65025311111ULL);
  EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(number));
}

TEST_F(PhoneNumberUtilTest, GetCountryCodeForRegion) {
  EXPECT_EQ(1, phone_util_.GetCountryCodeForRegion(RegionCode::US()));
  EXPECT_EQ(64, phone_util_.GetCountryCodeForRegion(RegionCode::NZ()));
  EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::GetUnknown()));
  EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::UN001()));
  // CS is already deprecated so the library doesn't support it.
  EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::CS()));
}

TEST_F(PhoneNumberUtilTest, GetNationalDiallingPrefixForRegion) {
  string ndd_prefix;
  GetNddPrefixForRegion(RegionCode::US(), false, &ndd_prefix);
  EXPECT_EQ(""1"", ndd_prefix);

  // Test non-main country to see it gets the national dialling prefix for the
  // main country with that country calling code.
  GetNddPrefixForRegion(RegionCode::BS(), false, &ndd_prefix);
  EXPECT_EQ(""1"", ndd_prefix);

  GetNddPrefixForRegion(RegionCode::NZ(), false, &ndd_prefix);
  EXPECT_EQ(""0"", ndd_prefix);

  // Test case with non digit in the national prefix.
  GetNddPrefixForRegion(RegionCode::AO(), false, &ndd_prefix);
  EXPECT_EQ(""0~0"", ndd_prefix);

  GetNddPrefixForRegion(RegionCode::AO(), true, &ndd_prefix);
  EXPECT_EQ(""00"", ndd_prefix);

  // Test cases with invalid regions.
  GetNddPrefixForRegion(RegionCode::GetUnknown(), false, &ndd_prefix);
  EXPECT_EQ("""", ndd_prefix);

  GetNddPrefixForRegion(RegionCode::UN001(), false, &ndd_prefix);
  EXPECT_EQ("""", ndd_prefix);

  // CS is already deprecated so the library doesn't support it.
  GetNddPrefixForRegion(RegionCode::CS(), false, &ndd_prefix);
  EXPECT_EQ("""", ndd_prefix);
}

TEST_F(PhoneNumberUtilTest, IsViablePhoneNumber) {
  EXPECT_FALSE(IsViablePhoneNumber(""1""));
  // Only one or two digits before strange non-possible punctuation.
  EXPECT_FALSE(IsViablePhoneNumber(""1+1+1""));
  EXPECT_FALSE(IsViablePhoneNumber(""80+0""));
  // Two digits is viable.
  EXPECT_TRUE(IsViablePhoneNumber(""00""));
  EXPECT_TRUE(IsViablePhoneNumber(""111""));
  // Alpha numbers.
  EXPECT_TRUE(IsViablePhoneNumber(""0800-4-pizza""));
  EXPECT_TRUE(IsViablePhoneNumber(""0800-4-PIZZA""));
  // We need at least three digits before any alpha characters.
  EXPECT_FALSE(IsViablePhoneNumber(""08-PIZZA""));
  EXPECT_FALSE(IsViablePhoneNumber(""8-PIZZA""));
  EXPECT_FALSE(IsViablePhoneNumber(""12. March""));
}

TEST_F(PhoneNumberUtilTest, IsViablePhoneNumberNonAscii) {
  // Only one or two digits before possible punctuation followed by more digits.
  // The punctuation used here is the unicode character u+3000.
  EXPECT_TRUE(IsViablePhoneNumber(""1\xE3\x80\x80"" ""34"" /* ""1　34"" */));
  EXPECT_FALSE(IsViablePhoneNumber(""1\xE3\x80\x80"" ""3+4"" /* ""1　3+4"" */));
  // Unicode variants of possible starting character and other allowed
  // punctuation/digits.
  EXPECT_TRUE(IsViablePhoneNumber(""\xEF\xBC\x88"" ""1\xEF\xBC\x89\xE3\x80\x80""
                                  ""3456789"" /* ""（1）　3456789"" */));
  // Testing a leading + is okay.
  EXPECT_TRUE(IsViablePhoneNumber(""+1\xEF\xBC\x89\xE3\x80\x80""
                                  ""3456789"" /* ""+1）　3456789"" */));
}

TEST_F(PhoneNumberUtilTest, ConvertAlphaCharactersInNumber) {
  string input(""1800-ABC-DEF"");
  phone_util_.ConvertAlphaCharactersInNumber(&input);
  // Alpha chars are converted to digits; everything else is left untouched.
  static const string kExpectedOutput = ""1800-222-333"";
  EXPECT_EQ(kExpectedOutput, input);

  // Try with some non-ASCII characters.
  input.assign(""1\xE3\x80\x80\xEF\xBC\x88"" ""800) ABC-DEF""
               /* ""1　（800) ABCD-DEF"" */);
  static const string kExpectedFullwidthOutput =
      ""1\xE3\x80\x80\xEF\xBC\x88"" ""800) 222-333"" /* ""1　（800) 222-333"" */;
  phone_util_.ConvertAlphaCharactersInNumber(&input);
  EXPECT_EQ(kExpectedFullwidthOutput, input);
}

TEST_F(PhoneNumberUtilTest, NormaliseRemovePunctuation) {
  string input_number(""034-56&+#2"" ""\xC2\xAD"" ""34"");
  Normalize(&input_number);
  static const string kExpectedOutput(""03456234"");
  EXPECT_EQ(kExpectedOutput, input_number)
      << ""Conversion did not correctly remove punctuation"";
}

TEST_F(PhoneNumberUtilTest, NormaliseReplaceAlphaCharacters) {
  string input_number(""034-I-am-HUNGRY"");
  Normalize(&input_number);
  static const string kExpectedOutput(""034426486479"");
  EXPECT_EQ(kExpectedOutput, input_number)
      << ""Conversion did not correctly replace alpha characters"";
}

TEST_F(PhoneNumberUtilTest, NormaliseOtherDigits) {
  // The first digit is a full-width 2, the last digit is an Arabic-indic digit
  // 5.
  string input_number(""\xEF\xBC\x92"" ""5\xD9\xA5"" /* ""２5٥"" */);
  Normalize(&input_number);
  static const string kExpectedOutput(""255"");
  EXPECT_EQ(kExpectedOutput, input_number)
      << ""Conversion did not correctly replace non-latin digits"";
  // The first digit is an Eastern-Arabic 5, the latter an Eastern-Arabic 0.
  string eastern_arabic_input_number(""\xDB\xB5"" ""2\xDB\xB0"" /* ""۵2۰"" */);
  Normalize(&eastern_arabic_input_number);
  static const string kExpectedOutput2(""520"");
  EXPECT_EQ(kExpectedOutput2, eastern_arabic_input_number)
      << ""Conversion did not correctly replace non-latin digits"";
}

TEST_F(PhoneNumberUtilTest, NormaliseStripAlphaCharacters) {
  string input_number(""034-56&+a#234"");
  phone_util_.NormalizeDigitsOnly(&input_number);
  static const string kExpectedOutput(""03456234"");
  EXPECT_EQ(kExpectedOutput, input_number)
      << ""Conversion did not correctly remove alpha characters"";
}

TEST_F(PhoneNumberUtilTest, NormaliseStripNonDiallableCharacters) {
  string input_number(""03*4-56&+a#234"");
  NormalizeDiallableCharsOnly(&input_number);
  static const string kExpectedOutput(""03*456+234"");
  EXPECT_EQ(kExpectedOutput, input_number)
      << ""Conversion did not correctly remove non-diallable characters"";
}

TEST_F(PhoneNumberUtilTest, MaybeStripInternationalPrefix) {
  string international_prefix(""00[39]"");
  string number_to_strip(""0034567700-3898003"");
  // Note the dash is removed as part of the normalization.
  string stripped_number(""45677003898003"");
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""The number was not stripped of its international prefix."";

  // Now the number no longer starts with an IDD prefix, so it should now report
  // FROM_DEFAULT_COUNTRY.
  EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));

  number_to_strip.assign(""00945677003898003"");
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""The number was not stripped of its international prefix."";

  // Test it works when the international prefix is broken up by spaces.
  number_to_strip.assign(""00 9 45677003898003"");
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""The number was not stripped of its international prefix."";
  // Now the number no longer starts with an IDD prefix, so it should now report
  // FROM_DEFAULT_COUNTRY.
  EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));

  // Test the + symbol is also recognised and stripped.
  number_to_strip.assign(""+45677003898003"");
  stripped_number.assign(""45677003898003"");
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""The number supplied was not stripped of the plus symbol."";

  // If the number afterwards is a zero, we should not strip this - no country
  // code begins with 0.
  number_to_strip.assign(""0090112-3123"");
  stripped_number.assign(""00901123123"");
  EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""The number had a 0 after the match so shouldn't be stripped."";
  // Here the 0 is separated by a space from the IDD.
  number_to_strip.assign(""009 0-112-3123"");
  EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
      MaybeStripInternationalPrefixAndNormalize(international_prefix,
                                                &number_to_strip));
}

TEST_F(PhoneNumberUtilTest, MaybeStripNationalPrefixAndCarrierCode) {
  PhoneMetadata metadata;
  metadata.set_national_prefix_for_parsing(""34"");
  metadata.mutable_general_desc()->set_national_number_pattern(""\\d{4,8}"");
  string number_to_strip(""34356778"");
  string stripped_number(""356778"");
  string carrier_code;
  MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
                                         &carrier_code);
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""Should have had national prefix stripped."";
  EXPECT_EQ("""", carrier_code) << ""Should have had no carrier code stripped."";
  // Retry stripping - now the number should not start with the national prefix,
  // so no more stripping should occur.
  MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
                                         &carrier_code);
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""Should have had no change - no national prefix present."";
  // Some countries have no national prefix. Repeat test with none specified.
  metadata.clear_national_prefix_for_parsing();
  MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
                                         &carrier_code);
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""Should have had no change - empty national prefix."";
  // If the resultant number doesn't match the national rule, it shouldn't be
  // stripped.
  metadata.set_national_prefix_for_parsing(""3"");
  number_to_strip.assign(""3123"");
  stripped_number.assign(""3123"");
  MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
                                         &carrier_code);
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""Should have had no change - after stripping, it wouldn't have ""
      << ""matched the national rule."";
  // Test extracting carrier selection code.
  metadata.set_national_prefix_for_parsing(""0(81)?"");
  number_to_strip.assign(""08122123456"");
  stripped_number.assign(""22123456"");
  MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
                                         &carrier_code);
  EXPECT_EQ(""81"", carrier_code) << ""Should have had carrier code stripped."";
  EXPECT_EQ(stripped_number, number_to_strip)
      << ""Should have had national prefix and carrier code stripped."";
  // If there was a transform rule, check it was applied.
  metadata.set_national_prefix_transform_rule(""5$15"");
  // Note that a capturing group is present here.
  metadata.set_national_prefix_for_parsing(""0(\\d{2})"");
  number_to_strip.assign(""031123"");
  string transformed_number(""5315123"");
  MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
                                         &carrier_code);
  EXPECT_EQ(transformed_number, number_to_strip)
      << ""Was not successfully transformed."";
}

TEST_F(PhoneNumberUtilTest, MaybeStripExtension) {
  // One with extension.
  string number(""1234576 ext. 1234"");
  string extension;
  string expected_extension(""1234"");
  string stripped_number(""1234576"");
  EXPECT_TRUE(MaybeStripExtension(&number, &extension));
  EXPECT_EQ(stripped_number, number);
  EXPECT_EQ(expected_extension, extension);

  // One without extension.
  number.assign(""1234-576"");
  extension.clear();
  stripped_number.assign(""1234-576"");
  EXPECT_FALSE(MaybeStripExtension(&number, &extension));
  EXPECT_EQ(stripped_number, number);
  EXPECT_TRUE(extension.empty());

  // One with an extension caught by the second capturing group in
  // kKnownExtnPatterns.
  number.assign(""1234576-123#"");
  extension.clear();
  expected_extension.assign(""123"");
  stripped_number.assign(""1234576"");
  EXPECT_TRUE(MaybeStripExtension(&number, &extension));
  EXPECT_EQ(stripped_number, number);
  EXPECT_EQ(expected_extension, extension);

  number.assign(""1234576 ext.123#"");
  extension.clear();
  EXPECT_TRUE(MaybeStripExtension(&number, &extension));
  EXPECT_EQ(stripped_number, number);
  EXPECT_EQ(expected_extension, extension);
}

TEST_F(PhoneNumberUtilTest, MaybeExtractCountryCode) {
  PhoneNumber number;
  const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
  // Note that for the US, the IDD is 011.
  string phone_number(""011112-3456789"");
  string stripped_number(""123456789"");
  int expected_country_code = 1;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, true, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD, number.country_code_source());
  EXPECT_EQ(stripped_number, phone_number);

  number.Clear();
  phone_number.assign(""+80012345678"");
  stripped_number.assign(""12345678"");
  expected_country_code = 800;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, true, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
            number.country_code_source());
  EXPECT_EQ(stripped_number, phone_number);

  number.Clear();
  phone_number.assign(""+6423456789"");
  stripped_number.assign(""23456789"");
  expected_country_code = 64;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, true, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
            number.country_code_source());
  EXPECT_EQ(stripped_number, phone_number);

  // Should not have extracted a country code - no international prefix present.
  number.Clear();
  expected_country_code = 0;
  phone_number.assign(""2345-6789"");
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, true, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
  EXPECT_EQ(stripped_number, phone_number);

  expected_country_code = 0;
  phone_number.assign(""0119991123456789"");
  stripped_number.assign(phone_number);
  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            MaybeExtractCountryCode(metadata, true, &phone_number, &number));

  number.Clear();
  phone_number.assign(""(1 610) 619 4466"");
  stripped_number.assign(""6106194466"");
  expected_country_code = 1;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, true, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN,
            number.country_code_source());
  EXPECT_EQ(stripped_number, phone_number);

  number.Clear();
  phone_number.assign(""(1 610) 619 4466"");
  stripped_number.assign(""6106194466"");
  expected_country_code = 1;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, false, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_FALSE(number.has_country_code_source());
  EXPECT_EQ(stripped_number, phone_number);

  // Should not have extracted a country code - invalid number after extraction
  // of uncertain country code.
  number.Clear();
  phone_number.assign(""(1 610) 619 446"");
  stripped_number.assign(""1610619446"");
  expected_country_code = 0;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, false, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_FALSE(number.has_country_code_source());
  EXPECT_EQ(stripped_number, phone_number);

  number.Clear();
  phone_number.assign(""(1 610) 619"");
  stripped_number.assign(""1610619"");
  expected_country_code = 0;
  // Should not have extracted a country code - invalid number both before and
  // after extraction of uncertain country code.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            MaybeExtractCountryCode(metadata, true, &phone_number, &number));
  EXPECT_EQ(expected_country_code, number.country_code());
  EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
  EXPECT_EQ(stripped_number, phone_number);
}

TEST_F(PhoneNumberUtilTest, CountryWithNoNumberDesc) {
  string formatted_number;
  // Andorra is a country where we don't have PhoneNumberDesc info in the
  // metadata.
  PhoneNumber ad_number;
  ad_number.set_country_code(376);
  ad_number.set_national_number(12345ULL);
  phone_util_.Format(ad_number, PhoneNumberUtil::INTERNATIONAL,
                     &formatted_number);
  EXPECT_EQ(""+376 12345"", formatted_number);
  phone_util_.Format(ad_number, PhoneNumberUtil::E164, &formatted_number);
  EXPECT_EQ(""+37612345"", formatted_number);
  phone_util_.Format(ad_number, PhoneNumberUtil::NATIONAL, &formatted_number);
  EXPECT_EQ(""12345"", formatted_number);
  EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(ad_number));
  EXPECT_FALSE(phone_util_.IsValidNumber(ad_number));

  // Test dialing a US number from within Andorra.
  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(6502530000ULL);
  phone_util_.FormatOutOfCountryCallingNumber(us_number, RegionCode::AD(),
                                              &formatted_number);
  EXPECT_EQ(""00 1 650 253 0000"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, UnknownCountryCallingCode) {
  PhoneNumber invalid_number;
  invalid_number.set_country_code(kInvalidCountryCode);
  invalid_number.set_national_number(12345ULL);

  EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));

  // It's not very well defined as to what the E164 representation for a number
  // with an invalid country calling code is, but just prefixing the country
  // code and national number is about the best we can do.
  string formatted_number;
  phone_util_.Format(invalid_number, PhoneNumberUtil::E164, &formatted_number);
  EXPECT_EQ(""+212345"", formatted_number);
}

TEST_F(PhoneNumberUtilTest, IsNumberMatchMatches) {
  // Test simple matches where formatting is different, or leading zeros, or
  // country code has been specified.
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331 6005"",
                                                    ""+64 03 331 6005""));
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+800 1234 5678"",
                                                    ""+80012345678""));
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 03 331-6005"",
                                                    ""+64 03331 6005""));
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+643 331-6005"",
                                                    ""+64033316005""));
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+643 331-6005"",
                                                    ""+6433316005""));
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005"",
                                                    ""+6433316005""));
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(
                ""+64 3 331-6005"", ""tel:+64-3-331-6005;isub=123""));
  // Test alpha numbers.
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+1800 siX-Flags"",
                                                    ""+1 800 7493 5247""));
  // Test numbers with extensions.
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005 extn 1234"",
                                                    ""+6433316005#1234""));
  // Test proto buffers.
  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(33316005ULL);
  nz_number.set_extension(""3456"");
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithOneString(nz_number,
                                                   ""+643 331 6005 ext 3456""));
  nz_number.clear_extension();
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithOneString(nz_number,
                                                   ""+643 331 6005""));
  // Check empty extensions are ignored.
  nz_number.set_extension("""");
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatchWithOneString(nz_number,
                                                   ""+643 331 6005""));
  // Check variant with two proto buffers.
  PhoneNumber nz_number_2;
  nz_number_2.set_country_code(64);
  nz_number_2.set_national_number(33316005ULL);
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatch(nz_number, nz_number_2));

  // Check raw_input, country_code_source and preferred_domestic_carrier_code
  // are ignored.
  PhoneNumber br_number_1;
  PhoneNumber br_number_2;
  br_number_1.set_country_code(55);
  br_number_1.set_national_number(3121286979ULL);
  br_number_1.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
  br_number_1.set_preferred_domestic_carrier_code(""12"");
  br_number_1.set_raw_input(""012 3121286979"");
  br_number_2.set_country_code(55);
  br_number_2.set_national_number(3121286979ULL);
  br_number_2.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
  br_number_2.set_preferred_domestic_carrier_code(""14"");
  br_number_2.set_raw_input(""143121286979"");
  EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
            phone_util_.IsNumberMatch(br_number_1, br_number_2));
}

TEST_F(PhoneNumberUtilTest, IsNumberMatchNonMatches) {
  // NSN matches.
  EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""03 331 6005"",
                                                    ""03 331 6006""));
  EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+800 1234 5678"",
                                                    ""+1 800 1234 5678""));
  // Different country code, partial number match.
  EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005"",
                                                    ""+16433316005""));
  // Different country code, same number.
  EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005"",
                                                    ""+6133316005""));
  // Extension different, all else the same.
  EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005 extn 1234"",
                                                    ""+0116433316005#1235""));
  EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(
                ""+64 3 331-6005 extn 1234"", ""tel:+64-3-331-6005;ext=1235""));
  // NSN matches, but extension is different - not the same number.
  EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005 ext.1235"",
                                                    ""3 331 6005#1234""));
  // Invalid numbers that can't be parsed.
  EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
            phone_util_.IsNumberMatchWithTwoStrings(""4"", ""3 331 6043""));
  // Invalid numbers that can't be parsed.
  EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
            phone_util_.IsNumberMatchWithTwoStrings(""+43"", ""+64 3 331 6005""));
  EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
            phone_util_.IsNumberMatchWithTwoStrings(""+43"", ""64 3 331 6005""));
  EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
            phone_util_.IsNumberMatchWithTwoStrings(""Dog"", ""64 3 331 6005""));
}

TEST_F(PhoneNumberUtilTest, IsNumberMatchNsnMatches) {
  // NSN matches.
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005"",
                                                    ""03 331 6005""));
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(
                ""+64 3 331-6005"",
                ""tel:03-331-6005;isub=1234;phone-context=abc.nz""));

  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(33316005ULL);
  nz_number.set_extension("""");
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithOneString(nz_number, ""03 331 6005""));
  // Here the second number possibly starts with the country code for New
  // Zealand, although we are unsure.
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithOneString(nz_number,
                                                   ""(64-3) 331 6005""));

  // Here, the 1 might be a national prefix, if we compare it to the US number,
  // so the resultant match is an NSN match.
  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(2345678901ULL);
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithOneString(us_number,
                                                   ""1-234-567-8901""));
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithOneString(us_number, ""2345678901""));
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+1 234-567 8901"",
                                                    ""1 234 567 8901""));
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""1 234-567 8901"",
                                                    ""1 234 567 8901""));
  EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""1 234-567 8901"",
                                                    ""+1 234 567 8901""));
  // For this case, the match will be a short NSN match, because we cannot
  // assume that the 1 might be a national prefix, so don't remove it when
  // parsing.
  PhoneNumber random_number;
  random_number.set_country_code(41);
  random_number.set_national_number(2345678901ULL);
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithOneString(random_number,
                                                   ""1-234-567-8901""));
}

TEST_F(PhoneNumberUtilTest, IsNumberMatchShortNsnMatches) {
  // Short NSN matches with the country not specified for either one or both
  // numbers.
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005"",
                                                    ""331 6005""));
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(
                ""+64 3 331-6005"", ""tel:331-6005;phone-context=abc.nz""));
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
              phone_util_.IsNumberMatchWithTwoStrings(
                  ""+64 3 331-6005"",
                  ""tel:331-6005;isub=1234;phone-context=abc.nz""));
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
              phone_util_.IsNumberMatchWithTwoStrings(
                  ""+64 3 331-6005"",
                  ""tel:331-6005;isub=1234;phone-context=abc.nz;a=%A1""));

  // We did not know that the ""0"" was a national prefix since neither number has
  // a country code, so this is considered a SHORT_NSN_MATCH.
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""3 331-6005"",
                                                    ""03 331 6005""));

  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
              phone_util_.IsNumberMatchWithTwoStrings(""3 331-6005"",
                                                      ""331 6005""));

  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
              phone_util_.IsNumberMatchWithTwoStrings(
                  ""3 331-6005"", ""tel:331-6005;phone-context=abc.nz""));
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""3 331-6005"",
                                                    ""+64 331 6005""));

  // Short NSN match with the country specified.
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""03 331-6005"",
                                                    ""331 6005""));

  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
              phone_util_.IsNumberMatchWithTwoStrings(""1 234 345 6789"",
                                                      ""345 6789""));

  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+1 (234) 345 6789"",
                                                    ""345 6789""));

  // NSN matches, country code omitted for one number, extension missing for
  // one.
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatchWithTwoStrings(""+64 3 331-6005"",
                                                    ""3 331 6005#1234""));

  // One has Italian leading zero, one does not.
  PhoneNumber it_number_1, it_number_2;
  it_number_1.set_country_code(39);
  it_number_1.set_national_number(1234ULL);
  it_number_1.set_italian_leading_zero(true);
  it_number_2.set_country_code(39);
  it_number_2.set_national_number(1234ULL);
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatch(it_number_1, it_number_2));

  // One has an extension, the other has an extension of """".
  it_number_1.set_extension(""1234"");
  it_number_1.clear_italian_leading_zero();
  it_number_2.set_extension("""");
  EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
            phone_util_.IsNumberMatch(it_number_1, it_number_2));
}

TEST_F(PhoneNumberUtilTest, ParseNationalNumber) {
  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(33316005ULL);
  PhoneNumber test_number;
  // National prefix attached.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""033316005"", RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // National prefix missing.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""33316005"", RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // National prefix attached and some formatting present.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03-331 6005"", RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03 331 6005"", RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // Test parsing RFC3966 format with a phone context.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:03-331-6005;phone-context=+64"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:331-6005;phone-context=+64-3"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:331-6005;phone-context=+64-3"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""My number is tel:03-331-6005;phone-context=+64"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // Test parsing RFC3966 format with optional user-defined parameters. The
  // parameters will appear after the context if present.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:03-331-6005;phone-context=+64;a=%A1"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // Test parsing RFC3966 with an ISDN subaddress.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:03-331-6005;isub=12345;phone-context=+64"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:+64-3-331-6005;isub=12345"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03-331-6005;phone-context=+64"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // Testing international prefixes.
  // Should strip country code.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0064 3 331 6005"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // Try again, but this time we have an international number with Region Code
  // US. It should recognise the country code and parse accordingly.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""01164 3 331 6005"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+64 3 331 6005"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  // We should ignore the leading plus here, since it is not followed by a valid
  // country code but instead is followed by the IDD for the US.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+01164 3 331 6005"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+0064 3 331 6005"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+ 00 64 3 331 6005"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(nz_number, test_number);

  PhoneNumber us_local_number;
  us_local_number.set_country_code(1);
  us_local_number.set_national_number(2530000ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:253-0000;phone-context=www.google.com"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(us_local_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(
                ""tel:253-0000;isub=12345;phone-context=www.google.com"",
                RegionCode::US(), &test_number));
  EXPECT_EQ(us_local_number, test_number);
  // This is invalid because no ""+"" sign is present as part of phone-context.
  // The phone context is simply ignored in this case just as if it contains a
  // domain.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:2530000;isub=12345;phone-context=1-650"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(us_local_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:2530000;isub=12345;phone-context=1234.com"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(us_local_number, test_number);

  // Test for http://b/issue?id=2247493
  nz_number.Clear();
  nz_number.set_country_code(64);
  nz_number.set_national_number(64123456ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+64(0)64123456"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(nz_number, test_number);

  // Check that using a ""/"" is fine in a phone number.
  PhoneNumber de_number;
  de_number.set_country_code(49);
  de_number.set_national_number(12345678ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""123/45678"", RegionCode::DE(), &test_number));
  EXPECT_EQ(de_number, test_number);

  PhoneNumber us_number;
  us_number.set_country_code(1);
  // Check it doesn't use the '1' as a country code when parsing if the phone
  // number was already possible.
  us_number.set_national_number(1234567890ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""123-456-7890"", RegionCode::US(), &test_number));
  EXPECT_EQ(us_number, test_number);

  // Test star numbers. Although this is not strictly valid, we would like to
  // make sure we can parse the output we produce when formatting the number.
  PhoneNumber star_number;
  star_number.set_country_code(81);
  star_number.set_national_number(2345ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+81 *2345"", RegionCode::JP(), &test_number));
  EXPECT_EQ(star_number, test_number);

  PhoneNumber short_number;
  short_number.set_country_code(64);
  short_number.set_national_number(12ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""12"", RegionCode::NZ(), &test_number));
  EXPECT_EQ(short_number, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseNumberWithAlphaCharacters) {
  // Test case with alpha characters.
  PhoneNumber test_number;
  PhoneNumber tollfree_number;
  tollfree_number.set_country_code(64);
  tollfree_number.set_national_number(800332005ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0800 DDA 005"", RegionCode::NZ(), &test_number));
  EXPECT_EQ(tollfree_number, test_number);

  PhoneNumber  [MASK] ;
   [MASK] .set_country_code(64);
   [MASK] .set_national_number(9003326005ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0900 DDA 6005"", RegionCode::NZ(), &test_number));
  EXPECT_EQ( [MASK] , test_number);

  // Not enough alpha characters for them to be considered intentional, so they
  // are stripped.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0900 332 6005a"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ( [MASK] , test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0900 332 600a5"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ( [MASK] , test_number);

  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0900 332 600A5"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ( [MASK] , test_number);

  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0900 a332 600A5"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ( [MASK] , test_number);
}

TEST_F(PhoneNumberUtilTest, ParseWithInternationalPrefixes) {
  PhoneNumber us_number;
  us_number.set_country_code(1);
  us_number.set_national_number(6503336000ULL);
  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+1 (650) 333-6000"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(us_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+1-650-333-6000"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(us_number, test_number);

  // Calling the US number from Singapore by using different service providers
  // 1st test: calling using SingTel IDD service (IDD is 001)
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0011-650-333-6000"",
                              RegionCode::SG(), &test_number));
  EXPECT_EQ(us_number, test_number);
  // 2nd test: calling using StarHub IDD service (IDD is 008)
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0081-650-333-6000"",
                              RegionCode::SG(), &test_number));
  EXPECT_EQ(us_number, test_number);
  // 3rd test: calling using SingTel V019 service (IDD is 019)
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0191-650-333-6000"",
                              RegionCode::SG(), &test_number));
  EXPECT_EQ(us_number, test_number);
  // Calling the US number from Poland
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0~01-650-333-6000"",
                              RegionCode::PL(), &test_number));
  EXPECT_EQ(us_number, test_number);

  // Using ""++"" at the start.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""++1 (650) 333-6000"",
                              RegionCode::PL(), &test_number));
  EXPECT_EQ(us_number, test_number);
  // Using a full-width plus sign.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""\xEF\xBC\x8B"" ""1 (650) 333-6000"",
                              /* ""＋1 (650) 333-6000"" */
                              RegionCode::SG(), &test_number));
  // Using a soft hyphen U+00AD.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""1 (650) 333"" ""\xC2\xAD"" ""-6000"",
                              /* ""1 (650) 333­-6000­"" */
                              RegionCode::US(), &test_number));
  EXPECT_EQ(us_number, test_number);
  // The whole number, including punctuation, is here represented in full-width
  // form.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88""
                              ""\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89""
                              ""\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\x93\xEF\xBC\x93""
                              ""\xEF\xBC\x8D\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90""
                              ""\xEF\xBC\x90"",
                              /* ""＋１　（６５０）　３３３－６０００"" */
                              RegionCode::SG(), &test_number));
  EXPECT_EQ(us_number, test_number);

  // Using the U+30FC dash.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88""
                              ""\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89""
                              ""\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\x93\xEF\xBC\x93""
                              ""\xE3\x83\xBC\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90""
                              ""\xEF\xBC\x90"",
                              /* ""＋１　（６５０）　３３３ー６０００"" */
                              RegionCode::SG(), &test_number));
  EXPECT_EQ(us_number, test_number);

  PhoneNumber toll_free_number;
  toll_free_number.set_country_code(800);
  toll_free_number.set_national_number(12345678ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""011 800 1234 5678"",
                              RegionCode::US(), &test_number));
  EXPECT_EQ(toll_free_number, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseWithLeadingZero) {
  PhoneNumber it_number;
  it_number.set_country_code(39);
  it_number.set_national_number(236618300ULL);
  it_number.set_italian_leading_zero(true);
  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+39 02-36618 300"",
                              RegionCode::NZ(), &test_number));
  EXPECT_EQ(it_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""02-36618 300"", RegionCode::IT(), &test_number));
  EXPECT_EQ(it_number, test_number);

  it_number.Clear();
  it_number.set_country_code(39);
  it_number.set_national_number(312345678ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""312 345 678"", RegionCode::IT(), &test_number));
  EXPECT_EQ(it_number, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseNationalNumberArgentina) {
  // Test parsing mobile numbers of Argentina.
  PhoneNumber ar_number;
  ar_number.set_country_code(54);
  ar_number.set_national_number(93435551212ULL);
  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+54 9 343 555 1212"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0343 15 555 1212"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);

  ar_number.set_national_number(93715654320ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+54 9 3715 65 4320"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03715 15 65 4320"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);

  // Test parsing fixed-line numbers of Argentina.
  ar_number.set_national_number(1137970000ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+54 11 3797 0000"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""011 3797 0000"", RegionCode::AR(), &test_number));
  EXPECT_EQ(ar_number, test_number);

  ar_number.set_national_number(3715654321ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+54 3715 65 4321"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03715 65 4321"", RegionCode::AR(), &test_number));
  EXPECT_EQ(ar_number, test_number);

  ar_number.set_national_number(2312340000ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+54 23 1234 0000"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""023 1234 0000"", RegionCode::AR(), &test_number));
  EXPECT_EQ(ar_number, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseWithXInNumber) {
  // Test that having an 'x' in the phone number at the start is ok and that it
  // just gets removed.
  PhoneNumber ar_number;
  ar_number.set_country_code(54);
  ar_number.set_national_number(123456789ULL);
  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0123456789"", RegionCode::AR(), &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(0) 123456789"", RegionCode::AR(), &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0 123456789"", RegionCode::AR(), &test_number));
  EXPECT_EQ(ar_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(0xx) 123456789"", RegionCode::AR(),
                              &test_number));
  EXPECT_EQ(ar_number, test_number);

  PhoneNumber ar_from_us;
  ar_from_us.set_country_code(54);
  ar_from_us.set_national_number(81429712ULL);
  // This test is intentionally constructed such that the number of digit after
  // xx is larger than 7, so that the number won't be mistakenly treated as an
  // extension, as we allow extensions up to 7 digits. This assumption is okay
  // for now as all the countries where a carrier selection code is written in
  // the form of xx have a national significant number of length larger than 7.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""011xx5481429712"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(ar_from_us, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseNumbersMexico) {
  // Test parsing fixed-line numbers of Mexico.
  PhoneNumber mx_number;

  mx_number.set_country_code(52);
  mx_number.set_national_number(4499780001ULL);
  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+52 (449)978-0001"", RegionCode::MX(),
                              &test_number));
  EXPECT_EQ(mx_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""01 (449)978-0001"", RegionCode::MX(),
                              &test_number));
  EXPECT_EQ(mx_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(449)978-0001"", RegionCode::MX(),
                              &test_number));
  EXPECT_EQ(mx_number, test_number);

  // Test parsing mobile numbers of Mexico.
  mx_number.Clear();
  mx_number.set_country_code(52);
  mx_number.set_national_number(13312345678ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+52 1 33 1234-5678"", RegionCode::MX(),
                              &test_number));
  EXPECT_EQ(mx_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""044 (33) 1234-5678"", RegionCode::MX(),
                              &test_number));
  EXPECT_EQ(mx_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""045 33 1234-5678"", RegionCode::MX(),
                              &test_number));
  EXPECT_EQ(mx_number, test_number);
}

TEST_F(PhoneNumberUtilTest, FailedParseOnInvalidNumbers) {
  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
            phone_util_.Parse(""This is not a phone number"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
            phone_util_.Parse(""1 Still not a number"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
            phone_util_.Parse(""1 MICROSOFT"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
            phone_util_.Parse(""12 MICROSOFT"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::TOO_LONG_NSN,
            phone_util_.Parse(""01495 72553301873 810104"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
            phone_util_.Parse(""+---"", RegionCode::DE(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
            phone_util_.Parse(""+***"", RegionCode::DE(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
            phone_util_.Parse(""+*******91"", RegionCode::DE(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_NSN,
            phone_util_.Parse(""+49 0"", RegionCode::DE(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            phone_util_.Parse(""+210 3456 56789"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  // 00 is a correct IDD, but 210 is not a valid country code.
  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            phone_util_.Parse(""+ 00 210 3 331 6005"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            phone_util_.Parse(""123 456 7890"", RegionCode::GetUnknown(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            phone_util_.Parse(""123 456 7890"", RegionCode::CS(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
            phone_util_.Parse(""0044-----"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);
  EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
            phone_util_.Parse(""0044"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
            phone_util_.Parse(""011"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);
  EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
            phone_util_.Parse(""0119"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  // RFC3966 phone-context is a website.
  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            phone_util_.Parse(""tel:555-1234;phone-context=www.google.com"",
                              RegionCode::ZZ(), &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);
  // This is invalid because no ""+"" sign is present as part of phone-context.
  // This should not succeed in being parsed.
  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            phone_util_.Parse(""tel:555-1234;phone-context=1-331"",
                              RegionCode::ZZ(), &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);
}

TEST_F(PhoneNumberUtilTest, ParseNumbersWithPlusWithNoRegion) {
  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(33316005ULL);
  // RegionCode::GetUnknown() is allowed only if the number starts with a '+' -
  // then the country code can be calculated.
  PhoneNumber result_proto;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+64 3 331 6005"", RegionCode::GetUnknown(),
                              &result_proto));
  EXPECT_EQ(nz_number, result_proto);

  // Test with full-width plus.
  result_proto.Clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""\xEF\xBC\x8B"" ""64 3 331 6005"",
                              /* ""＋64 3 331 6005"" */
                              RegionCode::GetUnknown(), &result_proto));
  EXPECT_EQ(nz_number, result_proto);
  // Test with normal plus but leading characters that need to be stripped.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""  +64 3 331 6005"", RegionCode::GetUnknown(),
                              &result_proto));
  EXPECT_EQ(nz_number, result_proto);

  PhoneNumber toll_free_number;
  toll_free_number.set_country_code(800);
  toll_free_number.set_national_number(12345678ULL);
  result_proto.Clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+800 1234 5678"",
                              RegionCode::GetUnknown(), &result_proto));
  EXPECT_EQ(toll_free_number, result_proto);

  PhoneNumber universal_premium_rate;
  universal_premium_rate.set_country_code(979);
  universal_premium_rate.set_national_number(123456789ULL);
  result_proto.Clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+979 123 456 789"",
                              RegionCode::GetUnknown(), &result_proto));
  EXPECT_EQ(universal_premium_rate, result_proto);

  result_proto.Clear();
  // Test parsing RFC3966 format with a phone context.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:03-331-6005;phone-context=+64"",
                              RegionCode::GetUnknown(), &result_proto));
  EXPECT_EQ(nz_number, result_proto);
  result_proto.Clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""  tel:03-331-6005;phone-context=+64"",
                              RegionCode::GetUnknown(), &result_proto));
  EXPECT_EQ(nz_number, result_proto);
  result_proto.Clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:03-331-6005;isub=12345;phone-context=+64"",
                              RegionCode::GetUnknown(), &result_proto));
  EXPECT_EQ(nz_number, result_proto);

  nz_number.set_raw_input(""+64 3 331 6005"");
  nz_number.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
  // It is important that we set this to an empty string, since we used
  // ParseAndKeepRawInput and no carrrier code was found.
  nz_number.set_preferred_domestic_carrier_code("""");
  result_proto.Clear();
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""+64 3 331 6005"",
                                             RegionCode::GetUnknown(),
                                             &result_proto));
  EXPECT_EQ(nz_number, result_proto);
}

TEST_F(PhoneNumberUtilTest, ParseNumberTooShortIfNationalPrefixStripped) {
  PhoneNumber test_number;

  // Test that a number whose first digits happen to coincide with the national
  // prefix does not get them stripped if doing so would result in a number too
  // short to be a possible (regular length) phone number for that region.
  PhoneNumber by_number;
  by_number.set_country_code(375);
  by_number.set_national_number(8123L);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""8123"", RegionCode::BY(),
                              &test_number));
  EXPECT_EQ(by_number, test_number);
  by_number.set_national_number(81234L);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""81234"", RegionCode::BY(),
                              &test_number));
  EXPECT_EQ(by_number, test_number);

  // The prefix doesn't get stripped, since the input is a viable 6-digit
  // number, whereas the result of stripping is only 5 digits.
  by_number.set_national_number(812345L);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""812345"", RegionCode::BY(),
                              &test_number));
  EXPECT_EQ(by_number, test_number);

  // The prefix gets stripped, since only 6-digit numbers are possible.
  by_number.set_national_number(123456L);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""8123456"", RegionCode::BY(),
                              &test_number));
  EXPECT_EQ(by_number, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseExtensions) {
  PhoneNumber nz_number;
  nz_number.set_country_code(64);
  nz_number.set_national_number(33316005ULL);
  nz_number.set_extension(""3456"");
  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03 331 6005 ext 3456"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03 331 6005x3456"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03-331 6005 int.3456"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(nz_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""03 331 6005 #3456"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(nz_number, test_number);

  // Test the following do not extract extensions:
  PhoneNumber non_extn_number;
  non_extn_number.set_country_code(1);
  non_extn_number.set_national_number(80074935247ULL);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""1800 six-flags"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(non_extn_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""1800 SIX-FLAGS"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(non_extn_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0~0 1800 7493 5247"", RegionCode::PL(),
                              &test_number));
  EXPECT_EQ(non_extn_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(1800) 7493.5247"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(non_extn_number, test_number);

  // Check that the last instance of an extension token is matched.
  PhoneNumber extn_number;
  extn_number.set_country_code(1);
  extn_number.set_national_number(80074935247ULL);
  extn_number.set_extension(""1234"");
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0~0 1800 7493 5247 ~1234"", RegionCode::PL(),
                              &test_number));
  EXPECT_EQ(extn_number, test_number);

  // Verifying bug-fix where the last digit of a number was previously omitted
  // if it was a 0 when extracting the extension. Also verifying a few different
  // cases of extensions.
  PhoneNumber uk_number;
  uk_number.set_country_code(44);
  uk_number.set_national_number(2034567890ULL);
  uk_number.set_extension(""456"");
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890x456"", RegionCode::NZ(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890x456"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890 x456"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890 X456"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890 X 456"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890 X   456"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890 x 456  "", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44 2034567890  X 456"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44-2034567890;ext=456"", RegionCode::GB(),
                              &test_number));
  EXPECT_EQ(uk_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""tel:2034567890;ext=456;phone-context=+44"",
                              RegionCode::ZZ(), &test_number));
  EXPECT_EQ(uk_number, test_number);

  // Full-width extension, ""extn"" only.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(
                ""+442034567890\xEF\xBD\x85\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E""
                ""456"", RegionCode::GB(), &test_number));
  EXPECT_EQ(uk_number, test_number);
  // ""xtn"" only.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(
                ""+44-2034567890\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E""""456"",
                RegionCode::GB(), &test_number));
  EXPECT_EQ(uk_number, test_number);
  // ""xt"" only.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+44-2034567890\xEF\xBD\x98\xEF\xBD\x94""""456"",
                              RegionCode::GB(), &test_number));
  EXPECT_EQ(uk_number, test_number);

  PhoneNumber us_with_extension;
  us_with_extension.set_country_code(1);
  us_with_extension.set_national_number(8009013355ULL);
  us_with_extension.set_extension(""7246433"");
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(800) 901-3355 x 7246433"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(800) 901-3355 , ext 7246433"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(800) 901-3355 ,extension 7246433"",
                              RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(800) 901-3355 ,extensi\xC3\xB3n 7246433"",
                              /* ""(800) 901-3355 ,extensión 7246433"" */
                              RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);
  // Repeat with the small letter o with acute accent created by combining
  // characters.
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(800) 901-3355 ,extensio\xCC\x81n 7246433"",
                              /* ""(800) 901-3355 ,extensión 7246433"" */
                              RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(800) 901-3355 , 7246433"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(800) 901-3355 ext: 7246433"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);

  // Test that if a number has two extensions specified, we ignore the second.
  PhoneNumber us_with_two_extensions_number;
  us_with_two_extensions_number.set_country_code(1);
  us_with_two_extensions_number.set_national_number(2121231234ULL);
  us_with_two_extensions_number.set_extension(""508"");
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(212)123-1234 x508/x1234"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_two_extensions_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(212)123-1234 x508/ x1234"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_two_extensions_number, test_number);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""(212)123-1234 x508\\x1234"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_two_extensions_number, test_number);

  // Test parsing numbers in the form (645) 123-1234-910# works, where the last
  // 3 digits before the # are an extension.
  us_with_extension.Clear();
  us_with_extension.set_country_code(1);
  us_with_extension.set_national_number(6451231234ULL);
  us_with_extension.set_extension(""910"");
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""+1 (645) 123 1234-910#"", RegionCode::US(),
                              &test_number));
  EXPECT_EQ(us_with_extension, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseAndKeepRaw) {
  PhoneNumber alpha_numeric_number;
  alpha_numeric_number.set_country_code(1);
  alpha_numeric_number.set_national_number(80074935247ULL);
  alpha_numeric_number.set_raw_input(""800 six-flags"");
  alpha_numeric_number.set_country_code_source(
      PhoneNumber::FROM_DEFAULT_COUNTRY);
  alpha_numeric_number.set_preferred_domestic_carrier_code("""");

  PhoneNumber test_number;
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""800 six-flags"", RegionCode::US(),
                                             &test_number));
  EXPECT_EQ(alpha_numeric_number, test_number);

  alpha_numeric_number.set_national_number(8007493524ULL);
  alpha_numeric_number.set_raw_input(""1800 six-flag"");
  alpha_numeric_number.set_country_code_source(
      PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""1800 six-flag"", RegionCode::US(),
                                             &test_number));
  EXPECT_EQ(alpha_numeric_number, test_number);

  alpha_numeric_number.set_raw_input(""+1800 six-flag"");
  alpha_numeric_number.set_country_code_source(
      PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""+1800 six-flag"", RegionCode::CN(),
                                             &test_number));
  EXPECT_EQ(alpha_numeric_number, test_number);

  alpha_numeric_number.set_raw_input(""001800 six-flag"");
  alpha_numeric_number.set_country_code_source(
      PhoneNumber::FROM_NUMBER_WITH_IDD);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""001800 six-flag"",
                                             RegionCode::NZ(),
                                             &test_number));
  EXPECT_EQ(alpha_numeric_number, test_number);

  // Try with invalid region - expect failure. We clear the test number first
  // because if parsing isn't successful, the number parsed in won't be changed.
  test_number.Clear();
  EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
            phone_util_.Parse(""123 456 7890"", RegionCode::CS(), &test_number));
  EXPECT_EQ(PhoneNumber::default_instance(), test_number);

  PhoneNumber korean_number;
  korean_number.set_country_code(82);
  korean_number.set_national_number(22123456);
  korean_number.set_raw_input(""08122123456"");
  korean_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
  korean_number.set_preferred_domestic_carrier_code(""81"");
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.ParseAndKeepRawInput(""08122123456"",
                                             RegionCode::KR(),
                                             &test_number));
  EXPECT_EQ(korean_number, test_number);
}

TEST_F(PhoneNumberUtilTest, ParseItalianLeadingZeros) {
  PhoneNumber zeros_number;
  zeros_number.set_country_code(61);
  PhoneNumber test_number;

  // Test the number ""011"".
  zeros_number.set_national_number(11L);
  zeros_number.set_italian_leading_zero(true);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""011"", RegionCode::AU(),
                              &test_number));
  EXPECT_EQ(zeros_number, test_number);

  // Test the number ""001"".
  zeros_number.set_national_number(1L);
  zeros_number.set_italian_leading_zero(true);
  zeros_number.set_number_of_leading_zeros(2);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""001"", RegionCode::AU(),
                              &test_number));
  EXPECT_EQ(zeros_number, test_number);

  // Test the number ""000"". This number has 2 leading zeros.
  zeros_number.set_national_number(0L);
  zeros_number.set_italian_leading_zero(true);
  zeros_number.set_number_of_leading_zeros(2);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""000"", RegionCode::AU(),
                              &test_number));
  EXPECT_EQ(zeros_number, test_number);

  // Test the number ""0000"". This number has 3 leading zeros.
  zeros_number.set_national_number(0L);
  zeros_number.set_italian_leading_zero(true);
  zeros_number.set_number_of_leading_zeros(3);
  EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
            phone_util_.Parse(""0000"", RegionCode::AU(),
                              &test_number));
  EXPECT_EQ(zeros_number, test_number);
}

TEST_F(PhoneNumberUtilTest, CanBeInternationallyDialled) {
  PhoneNumber test_number;
  test_number.set_country_code(1);

  // We have no-international-dialling rules for the US in our test metadata
  // that say that toll-free numbers cannot be dialled internationally.
  test_number.set_national_number(8002530000ULL);
  EXPECT_FALSE(CanBeInternationallyDialled(test_number));

  // Normal US numbers can be internationally dialled.
  test_number.set_national_number(6502530000ULL);
  EXPECT_TRUE(CanBeInternationallyDialled(test_number));

  // Invalid number.
  test_number.set_national_number(2530000ULL);
  EXPECT_TRUE(CanBeInternationallyDialled(test_number));

  // We have no data for NZ - should return true.
  test_number.set_country_code(64);
  test_number.set_national_number(33316005ULL);
  EXPECT_TRUE(CanBeInternationallyDialled(test_number));

  test_number.set_country_code(800);
  test_number.set_national_number(12345678ULL);
  EXPECT_TRUE(CanBeInternationallyDialled(test_number));
}

TEST_F(PhoneNumberUtilTest, IsAlphaNumber) {
  EXPECT_TRUE(phone_util_.IsAlphaNumber(""1800 six-flags""));
  EXPECT_TRUE(phone_util_.IsAlphaNumber(""1800 six-flags ext. 1234""));
  EXPECT_TRUE(phone_util_.IsAlphaNumber(""+800 six-flags""));
  EXPECT_TRUE(phone_util_.IsAlphaNumber(""180 six-flags""));
  EXPECT_FALSE(phone_util_.IsAlphaNumber(""1800 123-1234""));
  EXPECT_FALSE(phone_util_.IsAlphaNumber(""1 six-flags""));
  EXPECT_FALSE(phone_util_.IsAlphaNumber(""18 six-flags""));
  EXPECT_FALSE(phone_util_.IsAlphaNumber(""1800 123-1234 extension: 1234""));
  EXPECT_FALSE(phone_util_.IsAlphaNumber(""+800 1234-1234""));
}

}  // namespace phonenumbers
}  // namespace i18n
",premium_number
118,"#include ""precomp.h""
#include ""gtools.h""
#include ""stdarg.h""

PList::PList()
{
    m_pHead = m_pTail = 0;
    m_lCount = 0;
}

PList::~PList()
{
    DeleteContents();
} 

bool PList::DeleteContents()
{
    while( m_pHead )
    {
        PNode* pNext = m_pHead->m_pNext;
        m_pHead->m_pNext = 0;
        delete m_pHead;
        m_pHead = pNext;
    }
    m_pHead = m_pTail = 0;
    m_lCount = 0;
    return true;
} 

bool PList::RemoveContents()
{
    while( m_pHead )
    {
        PNode* pNext = m_pHead->m_pNext;
        m_pHead->m_pNext = m_pHead->m_pPrevious = 0;
        m_pHead = pNext;
    }
    m_pHead = m_pTail = 0;
    m_lCount = 0;
    return  true;
} 

bool PList::Contains( PNode* p )
{
    bool  [MASK]  = false;
    if( p != 0 )
    {
        for( PNode* q = m_pHead; q; q = q->m_pNext )
        {
            if( q == p )
            {
                 [MASK]  = true;
                break;
            }
        }
    }
    return  [MASK] ;
}

bool PList::AddHead( PNode* p )
{
    p->m_pPrevious = 0;
    m_lCount++;

    if( !m_pHead )
    {
        m_pHead = m_pTail = p;
        p->m_pNext = 0;
    }
    else
    {
        p->m_pNext = m_pHead;
        m_pHead->m_pPrevious = p;
        m_pHead = p;
    }
    return true;
}

bool PList::AddTail( PNode* p )
{
    if( !m_pTail )
    {
        m_pHead = m_pTail = p;
        p->m_pNext = 0;
        m_lCount = 1;
    }
    else
    {
        m_lCount++;
        p->m_pNext = 0;
        p->m_pPrevious = m_pTail;
        m_pTail->m_pNext = p;
        m_pTail = p;
    }
    return true;
}

bool PList::InsertBefore( PNode* p, PNode* q )
{
    if( !q )
        return AddTail( p );
    
    if( !q->m_pPrevious )
        return AddHead( p );

    ++m_lCount;
    p->m_pPrevious = q->m_pPrevious;
    p->m_pPrevious->m_pNext = p;
    q->m_pPrevious = p;
    p->m_pNext = q;
    return true;
}

bool PList::InsertAfter( PNode* p, PNode* q )
{
    if( !q )
        return AddHead( p );

    if( !q->m_pNext )
        return AddTail( p );

    return InsertBefore( p, q->m_pNext );
}

void PList::Delete( PNode* p )
{
    Remove( p );
    delete p;
}

void PList::Remove( PNode* p )
{
    m_lCount--;

    if( m_pHead == p )
        m_pHead = p->m_pNext;

    if( m_pTail == p )
        m_pTail = p->m_pPrevious;

    if( p->m_pNext )
        p->m_pNext->m_pPrevious = p->m_pPrevious;

    if( p->m_pPrevious )
        p->m_pPrevious->m_pNext = p->m_pNext;

    p->m_pNext = p->m_pPrevious = 0;
}

bool PList::IsEmpty()
{
    return m_pHead ? true : false;
} 

PNode* PList::Find( long lZeroBasedIndex )
{
    long lIndex = 0;
    for( PNode* p = m_pHead; p; p = p->m_pNext )
        if( lIndex++ == lZeroBasedIndex )
            return p;

    return 0;
} 

bool PList::Merge( PList& s )
{
    while( s.m_pHead )
    {
        PNode* pNode = s.m_pHead;
        s.Remove( s.m_pHead );
        AddTail( pNode );
    }
    return true;
}

// reduce if your crap OS cannot handle tit - it ;(
#define BUFFERSIZE_FOR_SPRINTF    10480

PString::PString()
{
    m_iStringLength = 0;
    m_lpszData = 0;
}

inline void PString::CopyStringData(const char* lpszFrom)
{
    if( lpszFrom )
    {
        m_iStringLength = strlen( lpszFrom )+1;
        if( m_iStringLength < sizeof(m_szFixedBuffer) )
        {
            m_lpszData = m_szFixedBuffer;
            strcpy( m_lpszData, lpszFrom );
        }
        else if( m_iStringLength > 0 )
        {
            m_lpszData = new char[ m_iStringLength ];
            if( m_lpszData != 0 )
                strcpy( m_lpszData, lpszFrom );
            else m_iStringLength = 0;
        }
        else m_lpszData = 0;
    }
    else
    {
        m_lpszData = 0;
        m_iStringLength = 0;
    }
}

inline void PString::DeleteStringData()
{
    if( (m_lpszData != m_szFixedBuffer) && m_lpszData )
        delete m_lpszData;
    m_lpszData = 0;
    m_iStringLength = 0;
}

PString::PString( const char* lpszArgument )
{
    CopyStringData( lpszArgument );
}

PString::PString( const PString& objectSrc )
{
    CopyStringData( objectSrc.m_lpszData );
}

PString::PString( int, const char* szFormat, ... )
{
    if( szFormat )
    {
        char buffer[BUFFERSIZE_FOR_SPRINTF];
        va_list argptr;
        va_start( argptr, szFormat );
        ::vsprintf(buffer,szFormat,argptr);
        buffer[BUFFERSIZE_FOR_SPRINTF-1]=0;
        CopyStringData( buffer );
    }
    else
    {
        m_iStringLength = 0;
        m_lpszData = 0;
    }
}

PString::~PString()
{
    DeleteStringData();
}

void PString::sprintf( const char* szFormat, ... )
{
    DeleteStringData();
    m_lpszData = 0;
    m_iStringLength = 0;
    if( szFormat )
    {
        char buffer[BUFFERSIZE_FOR_SPRINTF];
        va_list argptr;
        va_start( argptr, szFormat );
        ::vsprintf(buffer,szFormat,argptr);
        buffer[BUFFERSIZE_FOR_SPRINTF-1]=0;
        CopyStringData( buffer );
    }
}

void PString::vsprintf( const char* szFormat, va_list args )
{
    DeleteStringData();
    m_lpszData = 0;
    m_iStringLength = 0;
    if( szFormat )
    {
        char buffer[BUFFERSIZE_FOR_SPRINTF];
        ::vsprintf(buffer,szFormat,args);
        buffer[BUFFERSIZE_FOR_SPRINTF-1]=0;
        CopyStringData( buffer );
    }
} 

PString& PString::operator=( const char* objectSrc )
{
    if( objectSrc != m_lpszData )
    {
        DeleteStringData();
        CopyStringData( objectSrc );
    }
    return *this;
}

PString& PString::operator=( PString& objectSrc )
{
    if( this != &objectSrc )
    {
        DeleteStringData();
        CopyStringData( objectSrc.m_lpszData );
    }
    return *this;
}
",bSuccess
119,"//
// Created by rcala on 24-07-2023.
//
#include <iostream>
#include ""../include/main_window.h""
#include <unistd.h>

using namespace Gtk;


MainWindow::MainWindow() {

    error = 0;
    set_size_request(500, 500);
    set_resizable(false);
    set_border_width(10);
    set_position(WIN_POS_CENTER);
    set_title(""Hotel List"");

    model = ListStore::create(columns);
    tree.set_model(model);
    std::string line, fich_image;
    Glib::RefPtr<Gdk::Pixbuf> original_image;

    std::ifstream  [MASK] ;
     [MASK] .open(""../data/lista.txt"");

    if( [MASK] .is_open())
    {
        while(getline( [MASK] , line))
        {
            if(line.substr(0, 1) == ""#"")
            {
                break;
            }
            std::cout << line << std::endl;
            TreeModel::Row row = *(model->append());

            row[columns.col_id] = stoi(line.substr(0,3));
            auto num_char = line.length();
            row[columns.col_name] = line.substr(6, num_char - 7);
            fich_image = ""../data/stars/"" + line.substr(4,1) + "".png"";
            original_image = Gdk::Pixbuf::create_from_file(fich_image);
            row[columns.col_stars] = original_image->scale_simple(200,40,Gdk::INTERP_BILINEAR);
        }
         [MASK] .close();
        tree.append_column(""ID"", columns.col_id);
        tree.append_column(""Name"", columns.col_name);
        tree.append_column(""Stars"", columns.col_stars);
        tree.set_headers_clickable(true);
        std::cout << tree.get_n_columns() << std::endl;
        scroll.add(tree);
        add(scroll);
        show_all_children();
    }
    else
    {
        MessageDialog m_dialog(""Error, when tryed to open the file!"", false, MESSAGE_ERROR, BUTTONS_OK);
        m_dialog.set_transient_for(*this);
        auto response = m_dialog.run();
        if(response == BUTTONS_OK)
        {
            set_error(1);
            exit(0);
        }
    }
}

int MainWindow::get_error()
{
    return error;
}

void MainWindow::set_error(int _error)
{
 error = _error;
}
",input_file
120,"#include <iostream>
#include <string>
#include <fstream>
using namespace std;

#include ""admin.h""
#include ""../../Core/Source/Core/Core.h""
#include ""../../Core/Utils/utils.h""


void Admin::clients()
{  
    bool running = true;
    while (running)
    {
        ui.clearScreen();
        ui.displayHeader(""Admin Clients View"");
        string options[] = {""Show all Clients"", ""Delete Client""};
        ui.displayMenu(options, 2);
        int choice = ui.getInput<int>(""Enter choice"");

        switch (choice)
        {
        case 1:
            client.showAllClients();
            break;
        case 2:
            client.deleteClient();
            break;
        case 0:
            return;
        default:
            ui.displayError(""Invalid choice"");
            break;
        }
    }
}

void Admin::coffeeModule()
{  
    bool running = true;
    while (running)
    {
        ui.clearScreen();
        ui.displayHeader(""Admin Coffee View"");
        string options[] = {""Show all Coffee"", ""Add Coffee"", ""Delete Coffee""};
        ui.displayMenu(options, 3);
        int choice = ui.getInput<int>(""Enter choice"");
        switch (choice)
        {
        case 1:
            coffObj.displayAllCoffee();
            break;
        case 2:
            coffObj.createCoffee();
            break;
        case 3:
            coffObj.deleteCoffee();
            break;
        case 0:
            return;
        default:
            ui.displayError(""Invalid choice"");
            break;
        }
    }
}

void Admin::settings()
{  
    Registration reg(""Core/Source/Files/admins.txt"");
    bool running = true;
    while (running)
    {
        ui.clearScreen();
        ui.displayHeader(""Admin Settings View"");
        string options[] = {""Add New Admin"", ""LogOut""};
        ui.displayMenu(options, 2);
        int choice = ui.getInput<int>(""Enter choice"");

        switch (choice)
        {
        case 1:
            reg.signup(""Admins Database Records"");
            break;
        case 2:
            reg.logOut();
            break;
        case 0:
            return;
        default:
            ui.displayError(""Invalid choice"");
            break;
        }
    }
}

void Admin::run()
{
    Registration reg(""Core/Source/Files/admins.txt"");
    bool  [MASK]  = false;

    while (! [MASK] )
    {
        ui.clearScreen();
        ui.displayHeader(""Admin Module"");
        string options[] = {""SignUp"", ""Login""};
        ui.displayMenu(options, 2);
        int choice = ui.getInput<int>(""Enter choice"");

        switch (choice)
        {
        case 1:
            reg.signup(""Admins Database Records"");
            break;
        case 2:
            if (reg.login())
            {
                 [MASK]  = true;
            }
            break;
        case 0:
            return;
        default:
            ui.displayError(""Invalid choice"");
            break;
        }
    }

    bool running = true;
    while (running)
    {
        ui.clearScreen();
        ui.displayHeader(""Admin Dashboard"");
        string options[] = {""Clients"", ""Coffee"", ""Settings""};
        ui.displayMenu(options, 3);
        int choice = ui.getInput<int>(""Enter choice"");

        switch (choice)
        {
        case 1:
            clients();
            break;
        case 2:
            coffeeModule();
            break;
        case 3:
            settings();
            break;
        case 0:
            return;
        default:
            ui.displayError(""Invalid choice"");
            break;
        }
    }
}
",loggedIn
121,"#include ""App.h""

using namespace std;

App *app;

App::App(QObject *parent) : QObject(parent)
{
	connect(this, &App::error, this, &App::errorSlot);
	connect(this, &App::reportError, this, &App::showErrorDilogSlot);
	connect(this, &App::reportErrorMsg, this, &App::errorMsgSlot);

	ioThread_.setObjectName(""io thread"");
	connect(qApp, &QCoreApplication::aboutToQuit, [&](){
		ioThread_.quit();
		ioThread_.wait();
	});
	ioThread_.start();

	downloader_.moveToThread(&ioThread_);

	//auto screen = QGuiApplication::primaryScreen();
	//hmm_ = screen->physicalDotsPerInchX() / 25.4;
	//vmm_ = screen->physicalDotsPerInchY() / 25.4;
}

void App::addToolButton(QWidget *parent, QBoxLayout *l, QAction *a)
{
	auto b = new QToolButton(parent);
	b->setAutoRaise(true);
	//float w = 4*hmm_;
	//float h = 4*hmm_;
	b->setDefaultAction(a);
	//b->setIconSize(QSize(w, h));
	if (a->menu()){
		b->setPopupMode(QToolButton::InstantPopup);
		//w += 2.5f*hmm_;
	}
	//b->setFixedSize(QSize(w, h));
	l->addWidget(b);
}

void App::addToolBoxSpacer(QBoxLayout *l)
{
	//l->addSpacing(2 * hmm_);
	l->addSpacing(2);
}

void BuildErrorMsg(const std::exception& e, QString &msg){
	msg += QString::fromUtf8(e.what());
	msg += '\n';
	try {
		std::rethrow_if_nested(e);
	} catch(const std::exception& e) {
		BuildErrorMsg(e, msg);
	}
	catch(...) {
		msg += QApplication::translate(""Sadly, I don't even know what the error is."",""message about happened error"");
	}
}

QString App::errorMessage(std::exception_ptr eptr, const QString &action)
{
	QString msg;
	msg.reserve(2000);
	msg += action;
	msg += '\n';
	try {
		std::rethrow_exception(eptr);
	} catch(const std::exception& e) {
		BuildErrorMsg(e, msg);
	}
	return msg;
}

void App::showErrorDilogSlot(std::exception_ptr eptr, const QString &action)
{
	errorMsgSlot(errorMessage(eptr, action));
}

void App::errorSlot(std::exception_ptr e)
{
	showErrorDilogSlot(e);
	if (!isRecoverable(e))
		QCoreApplication::exit(1);
}

void App::errorMsgSlot(const QString &e)
{
	QMessageBox  [MASK] ;
	 [MASK] .setText(tr(""Error:"",""dialog about happened error""));
	 [MASK] .setInformativeText(e);
	 [MASK] .exec();
}


QString GetResourceString(const char *res)
{
	QFile file(res);
	file.open(QFile::ReadOnly);
	return QString(file.readAll());
}
",msgBox
122,"//
// Created by Ruslan on 08.04.2024.
//
// TODO: remove '#include <iostream>'
#include <iostream>
#include <optional>

class ErrorData__ {
public:
    std::string name;
    std::string message;
    std::string filename;
    std::string filepath;
    int line;

    ErrorData__(std::string const message, std::string const filename, std::string const filepath, int const line) {
        this->name = message;
        this->message = message;
        this->filename = filename;
        this->filepath = filepath;
        this->line = line;
    }

    ~ErrorData__() {
    }
};

class MessageErrorData__ {
public:
    std::string message;

    MessageErrorData__(std::string const message) {
        this->message = message;
    }

    ~MessageErrorData__() {
    }
};

class Error__ : public Root__<ErrorData__ *> {
public:
    Error__(
            std::string const subtype,
            std::string const message,
            std::string const filename,
            std::string const filepath,
            std::optional<int> const code_,
            std::optional<int> const line_) : Root__(""error"", subtype, new ErrorData__(message, filename, filepath, line_.value_or(-1)), code_.value_or(-1)) {
    }

    ~Error__() {
    }
};

class MessageError__ {
public:
    /** exit | error | success */
    std::string type;
    /** compilation | runtime */
    std::string subtype;
    /** -1 - unknown */
    int code;
    std::string message;
    std::string mapCode;

    std::string printable() {
        return std::string(""MessageError {\n  type: \""error\"",\n  subtype: \""runtime\"",\n  message: \"""") + message +
               std::string(""\"",\n  mapCode: \"""") + mapCode + std::string(""\"",\n  code: "") + std::to_string(code) +
               std::string(""\n}"");
    }

    MessageError__(
            std::string const message,
            std::optional<std::string> const  [MASK] ,
            std::optional<int> const code_) {
        const std::string mapCode =  [MASK] .value_or(""-1"");
        const int code = code_.value_or(2);
        this->type = ""error"";
        this->subtype = ""runtime"";
        this->message = message;
        this->mapCode = mapCode;
        this->code = code;
    }

    ~MessageError__() {
    }
};
",mapCode_
123,"//------------------------------------------------------------------------------
//! \file       AudioFiles.cpp
//!             classes representing audio files
//! \project    ARA SDK Examples
//! \copyright  Copyright (c) 2018-2025, Celemony Software GmbH, All Rights Reserved.
//! \license    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 ""AudioFiles.h""

#include ""ARA_API/ARAAudioFileChunks.h""
#include ""ARA_Library/Utilities/ARASamplePositionConversion.h""

#include ""ExamplesCommon/SignalProcessing/PulsedSineSignal.h""

#include ""3rdParty/pugixml/src/pugixml.hpp""
#include ""3rdParty/cpp-base64/base64.h""

#include <cstring>
#include <vector>
#include <sstream>


/*******************************************************************************/

class ARAiXMLChunk
{
public:
    ARAiXMLChunk ()
    : ARAiXMLChunk { 0, nullptr }
    {}

    ARAiXMLChunk (size_t dataLength, const uint8_t data[])
    {
        if (dataLength)
        {
            _iXMLChunk.load_buffer (data, dataLength);
            // enable this to log chunk data without parsing
            //_iXMLChunk.save (std::cout);
        }

        auto iXMLNode { _iXMLChunk.child (""BWFXML"") };
        if (iXMLNode.empty ())
            iXMLNode = _iXMLChunk.append_child (""BWFXML"");

        auto araNode { iXMLNode.child (ARA::kARAXMLName_ARAVendorKeyword) };
        if (araNode.empty ())
            araNode = iXMLNode.append_child (ARA::kARAXMLName_ARAVendorKeyword);

        _audioSourceArchives = araNode.child (ARA::kARAXMLName_AudioSources);
        if (_audioSourceArchives.empty ())
            _audioSourceArchives = araNode.append_child (ARA::kARAXMLName_AudioSources);
    }

    std::string getAudioSourceData (const std::string& documentArchiveID, bool& openAutomatically,
                                    std::string& plugInName, std::string& plugInVersion,
                                    std::string& manufacturer, std::string& informationURL,
                                    std::string& persistentID) const
    {
        pugi::xml_node archive;
        for (const auto& it : _audioSourceArchives.children (ARA::kARAXMLName_AudioSource))
        {
            if (std::strcmp (it.child_value (ARA::kARAXMLName_DocumentArchiveID), documentArchiveID.c_str ()) == 0)
            {
                archive = it;
                break;
            }
        }
        if (archive.empty ())
        {
            openAutomatically = false;
            plugInName = plugInVersion = manufacturer = informationURL = persistentID = {};
            return {};
        }

        openAutomatically = (std::strcmp (archive.child_value (ARA::kARAXMLName_OpenAutomatically), ""true"") == 0);

        const auto suggestedPlugIn { archive.child (ARA::kARAXMLName_SuggestedPlugIn) };
        plugInName = suggestedPlugIn.child_value (ARA::kARAXMLName_PlugInName);
        plugInVersion = suggestedPlugIn.child_value (ARA::kARAXMLName_LowestSupportedVersion);
        manufacturer = suggestedPlugIn.child_value (ARA::kARAXMLName_ManufacturerName);
        informationURL = suggestedPlugIn.child_value (ARA::kARAXMLName_InformationURL);

        persistentID = archive.child_value (ARA::kARAXMLName_PersistentID);

#if __cplusplus >= 201703L
        return base64_decode (std::string_view { archive.child_value (ARA::kARAXMLName_ArchiveData) }, true);
#else
        return base64_decode (archive.child_value (ARA::kARAXMLName_ArchiveData), true);
#endif
    }

    void setAudioSourceData (const std::string& documentArchiveID, bool openAutomatically,
                             const std::string& plugInName, const std::string& plugInVersion,
                             const std::string& manufacturer, const std::string& informationURL,
                             const std::string& persistentID, const std::string& data)
    {
        pugi::xml_node archive;
        for (const auto& it : _audioSourceArchives.children (ARA::kARAXMLName_AudioSource))
        {
            if (std::strcmp (it.child_value (ARA::kARAXMLName_DocumentArchiveID), documentArchiveID.c_str ()) == 0)
            {
                archive = it;
                break;
            }
        }
        if (archive.empty ())
            archive = _audioSourceArchives.append_child (ARA::kARAXMLName_AudioSource);
        else
            archive.remove_children ();

        archive.append_child (ARA::kARAXMLName_DocumentArchiveID).append_child (pugi::node_pcdata).set_value (documentArchiveID.c_str ());
        archive.append_child (ARA::kARAXMLName_OpenAutomatically).append_child (pugi::node_pcdata).set_value ((openAutomatically) ? ""true"" : ""false"");

        auto suggestedPlugIn { archive.append_child (ARA::kARAXMLName_SuggestedPlugIn) };
        suggestedPlugIn.append_child (ARA::kARAXMLName_PlugInName).append_child (pugi::node_pcdata).set_value (plugInName.c_str ());
        suggestedPlugIn.append_child (ARA::kARAXMLName_LowestSupportedVersion).append_child (pugi::node_pcdata).set_value (plugInVersion.c_str ());
        suggestedPlugIn.append_child (ARA::kARAXMLName_ManufacturerName).append_child (pugi::node_pcdata).set_value (manufacturer.c_str ());
        suggestedPlugIn.append_child (ARA::kARAXMLName_InformationURL).append_child (pugi::node_pcdata).set_value (informationURL.c_str ());

        archive.append_child (ARA::kARAXMLName_PersistentID).append_child (pugi::node_pcdata).set_value (persistentID.c_str ());

        std::string encodedArchiveData { base64_encode (data) };
        archive.append_child (ARA::kARAXMLName_ArchiveData).append_child (pugi::node_pcdata).set_value (encodedArchiveData.c_str ());
        // enable this to log edited chunk data
        //_iXMLChunk.save (std::cout);
    }

    std::string getData () const
    {
        std::ostringstream writer;
        _iXMLChunk.save (writer);
        return writer.str ();
    }

private:
    pugi::xml_document _iXMLChunk;
    pugi::xml_node _audioSourceArchives;
};

/*******************************************************************************/

void AudioFileBase::setiXMLChunk (ARAiXMLChunk* chunk) noexcept
{
    delete _iXMLChunk;
    _iXMLChunk = chunk;
}

void AudioFileBase::setiXMLARAAudioSourceData (const std::string& documentArchiveID, bool openAutomatically,
                                               const std::string& plugInName, const std::string& plugInVersion,
                                               const std::string& manufacturer, const std::string& informationURL,
                                               const std::string& persistentID, const std::string& data)
{
    if (!_iXMLChunk)
        _iXMLChunk = new ARAiXMLChunk {};
    _iXMLChunk->setAudioSourceData (documentArchiveID, openAutomatically,
                                    plugInName, plugInVersion, manufacturer, informationURL,
                                    persistentID, data);
}

std::string AudioFileBase::getiXMLARAAudioSourceData (const std::string& documentArchiveID, bool& openAutomatically,
                                                      std::string& plugInName, std::string& plugInVersion,
                                                      std::string& manufacturer, std::string& informationURL,
                                                      std::string& persistentID)
{
    if (!_iXMLChunk)
    {
        openAutomatically = false;
        plugInName = plugInVersion = manufacturer = informationURL = persistentID = {};
        return {};
    }

    return _iXMLChunk->getAudioSourceData (documentArchiveID, openAutomatically,
                                           plugInName, plugInVersion, manufacturer, informationURL, persistentID);
}

/*******************************************************************************/

SineAudioFile::SineAudioFile (const std::string& name, double  [MASK] , double sampleRate, int32_t channelCount)
: SineAudioFile { name, ARA::samplePositionAtTime ( [MASK] , sampleRate), sampleRate, channelCount }
{}

SineAudioFile::SineAudioFile (const std::string& name, int64_t sampleCount, double sampleRate, int32_t channelCount)
: AudioFileBase { name },
  _sampleCount { sampleCount },
  _sampleRate { sampleRate },
  _channelCount { channelCount }
{}

bool SineAudioFile::readSamples (int64_t samplePosition, int64_t samplesPerChannel,
                                 void* const buffers[], bool use64BitSamples) noexcept
{
    RenderPulsedSineSignal (samplePosition, getSampleRate (), getSampleCount (),
                            getChannelCount (), samplesPerChannel, buffers, use64BitSamples);
    return true;
}

bool SineAudioFile::saveToFile (const std::string& path)
{
    // first we copy our sample data to a new icstdsp::AudioFile
    icstdsp::AudioFile audioFile;
    audioFile.Create (static_cast<unsigned int> (getSampleCount ()),
                      static_cast<unsigned int> (getChannelCount ()),
                      static_cast<unsigned int> (getSampleRate () + 0.5));

    std::vector<float*> audioSampleBuffers;
    for (auto c { 0 }; c < getChannelCount (); c++)
        audioSampleBuffers.push_back (audioFile.GetSafePt (static_cast<unsigned int> (c)));
    readSamples (0, getSampleCount (), reinterpret_cast<void**> (audioSampleBuffers.data ()), false);

    // if we have iXML data, we copy that into the icstdsp::AudioFile too
    if (auto iXMLChunk { getiXMLChunk () })
    {
        const auto data { iXMLChunk->getData () };
        audioFile.SetiXMLData (reinterpret_cast<const uint8_t*> (data.c_str ()),
                               static_cast<unsigned int> (data.size ()));
    }

    // now we create an AudioDataFile from that, copy over the iXML and store it
    return AudioDataFile { {}, std::move (audioFile) }.saveToFile (path);
}

/*******************************************************************************/

AudioDataFile::AudioDataFile (const std::string& name, icstdsp::AudioFile&& audioFile)
: AudioFileBase { name },
  _audioFile { std::move (audioFile) }
{
    unsigned int dataLength { 0 };
    auto data = _audioFile.GetiXMLData (&dataLength);
    if ((data != nullptr) && (dataLength > 0))
        setiXMLChunk (new ARAiXMLChunk { dataLength, data});
}

bool AudioDataFile::readSamples (int64_t samplePosition, int64_t samplesPerChannel,
                                 void* const buffers[], bool use64BitSamples) noexcept
{
    auto index { 0L };
    while (samplesPerChannel--)
    {
        for (auto i { 0 }; i < getChannelCount (); ++i)
        {
            auto value = _audioFile.GetSafePt (static_cast<unsigned int> (i))[samplePosition];
            if (use64BitSamples)
                static_cast<double*> (buffers[i])[index] = value;
            else
                static_cast<float*> (buffers[i])[index] = static_cast<float> (value);
        }
        ++samplePosition;
        ++index;
    }

    return true;
}

bool AudioDataFile::saveToFile (const std::string& path)
{
    if (auto iXMLChunk { getiXMLChunk () })
    {
        const auto data { iXMLChunk->getData () };
        _audioFile.SetiXMLData (reinterpret_cast<const uint8_t*> (data.c_str ()),
                                static_cast<unsigned int> (data.size ()));
    }

    auto validatedPath { path };
    const auto extension { (path.length () < 4) ? """" : path.substr (path.length () - 4) };
    if ((extension != "".wav"") && (extension != "".aif""))
        validatedPath += "".wav"";

    return (_audioFile.SaveWave (validatedPath.c_str ()) == 0);
}
",duration
124,"#include ""Grove_I2C_Motor_Driver.h""

#define I2C_ADDRESS 0x0f


int echo = 0;
int echodroit = 0;
int echogauche = 0;

long readUltrasonicDistance(int triggerPin, int  [MASK] )
{
  pinMode(triggerPin, OUTPUT);  // Clear the trigger
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(2);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);
  pinMode( [MASK] , INPUT);
  return pulseIn( [MASK] , HIGH);
}


void setup()
{
  Motor.begin(I2C_ADDRESS);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(10, OUTPUT);
  digitalWrite(10, LOW);
}

void loop()

{
  echo = 0.01723 * readUltrasonicDistance(6, 5);
  echodroit = 0.01723 * readUltrasonicDistance(4, 3);
  echogauche = 0.01723 * readUltrasonicDistance(2, 1);

  if (echo <= 10 ) {
    Motor.stop(MOTOR1);
    Motor.stop(MOTOR2);
    Motor.speed(MOTOR1,-100);
    Motor.speed(MOTOR2, -100);
    delay(300);
    Motor.stop(MOTOR1);
    Motor.stop(MOTOR2);
    delay(2000);
    if (echogauche < 20) {
      Motor.speed(MOTOR1,-100);
      Motor.speed(MOTOR2, 100);
    }else{
      Motor.stop(MOTOR1);
      Motor.stop(MOTOR2);
      Motor.speed(MOTOR1,100);
      Motor.speed(MOTOR2, 100);
      delay(300);
      Motor.stop(MOTOR1);
      Motor.stop(MOTOR2);
      delay(1000);
    }
      
  } else {
        Motor.speed(MOTOR1,-100);
        Motor.speed(MOTOR2, 100);
  }

}
",echoPin
125,"//
// Created by 21911 on 24-8-20.
//
//
// Created by 21911 on 2024/8/13.
//
#include <bits/stdc++.h>

#define eps 1e-8    //多2
#define inf 0x3f3f3f3f
#define PI acos(-1)     //π
#define f0n(i,n) for (int (i)=0;(i)< (n);(i)++)
#define f1n(i,n) for (int (i)=1;(i)<=(n);(i)++)

using namespace std;
// unordered_map  HASH,与时间戳相关，防止HACK
struct HASH {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    static size_t get(const uint64_t x) {
        static const uint64_t  [MASK]  = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x +  [MASK] );
    }

    template <typename T>
    size_t operator()(T x) const {
        return get(std::hash<T>()(x));
    }

    template <typename F, typename S>
    size_t operator()(pair<F, S> p) const {
        return get(std::hash<F>()(p.first) ^ std::hash<S>()(p.second));
    }
};
typedef long long ll;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;

int TEST;               //测试案例数
const int N = 1e5+5;    //数组长度
//int a[N];
int n, m, k;
// int a, b, c;
// unordered_map<int, int, HASH> mp;
// unordered_map<pair<int, int>, int, HASH> mp2;

void solve()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    // ll res = 0;
    // ########## wirte your code here ###########
    // 每一颗苹果最多切 30 次，因为 m <= 1e9，如果切 30 次都不能平分，再切下去也无法平分
    // 所以可以一边切一边分，1 1/2 1/4 1/8 ...
    ll n, m;
    int cnt = 0;
    cin >> n >> m;
    if(n % m == 0) cout << 0 << endl;
    else {
        n %= m;
        ll res = 0;
        while(true) {
            cnt ++;
            res += n;
            n *= 2;
            if(n % m == 0) break;
            n %= m;
            if(cnt > 31) break;
        }
        if(cnt == 32) cout << -1 << endl;
        else cout << res << endl;
    }
    // ############################################
    // cout << res << endl;
}

int main(void)
{
    // freopen(""out.txt"", ""w"", stdout);
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    TEST = 1;
    cin >> TEST;
    while(TEST--)
        solve();
    return 0;
}",FIXED_RANDOM
126,"// Copyright 2021 Metromotive

#include ""HX711.hpp""

namespace metromotive {

// Creates a new HX711 object with the default gain.
HX711::HX711(DigitalOut *clockPin, InterruptIn *dataPin,
             void (*onRead)(int32_t reading))
    : clockPin(clockPin), dataPin(dataPin), onRead(onRead) {
    lastSampleGain = x128;
    gain = x128;
    this->stop();
}

// Powers up the HX711 and begins listening for readings.
void HX711::start() {
    dataPin->fall(callback(this, &HX711::read));
    clockPin->write(0);
}

// Powers down the HX711.
void HX711::stop() {
    dataPin->fall(NULL);
    clockPin->write(1);
}

void HX711::read() {
    // Data pin will fall repeatedly, so ignore it during read.
    dataPin->disable_irq();

    uint32_t  [MASK]  = 0;

    // Can't interrupt this section for more than 60us
    __disable_irq();

    // Cycle 24 times to read value.
    for (int i = 0; i < 24; i++) {
        clockPin->write(1);
         [MASK]  =  [MASK]  << 1;
        wait_ns(10);
        clockPin->write(0);
         [MASK]  |= dataPin->read();
        wait_ns(10);
    }

    // Cycle 1 to 3 more times to set next time's gain.
    for (int i = 0; i < gain; i++) {
        clockPin->write(1);
        wait_ns(25);
        clockPin->write(0);
    }

    __enable_irq();

    // Only report result if gain/input matches requested gain/input.
    if (lastSampleGain == gain) {
        // Convert unsigned 24-bit 2's complement to 32 bit signed.
        int32_t result = ((int32_t)( [MASK]  << 8)) >> 8;

        onRead(result);
    }

    // Next read will have the gain requested during this read.
    lastSampleGain = gain;

    dataPin->enable_irq();
}

} // namespace metromotive",count
127,"#include""stdio.h""
#include""stdlib.h""
#include""string.h""
#include""Define.h""

//建立先序二叉树 
Status CreateBiTree(BiTree &T)
{
	TElemType ch;
	scanf(""%c"",&ch);
	if(ch=='#') T=NULL;
	else{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	return OK;
}
//先序遍历二叉树
Status PreOrderTraverse(BiTree T,Status (*visit)(TElemType e)){
	if(!T) return ERROR;
	else{
		visit(T->data);
		PreOrderTraverse(T->lchild,visit);
		PreOrderTraverse(T->rchild,visit);
	}
	return OK;
}
//中序遍历二叉树
Status InOrderTraverse(BiTree T,Status (*visit)(TElemType e)){
	if(!T) return ERROR;
	else{
		InOrderTraverse(T->lchild,visit);
		visit(T->data);
		InOrderTraverse(T->rchild,visit);
	}
	return OK;
}
//后序遍历二叉树
Status PostOrderTraverse(BiTree T,Status (*visit)(TElemType e)){
	if(!T) return ERROR;
	else{
		PostOrderTraverse(T->lchild,visit);
		PostOrderTraverse(T->rchild,visit);
		visit(T->data);
	}
	return OK;
} 
Status PrintTElement(TElemType e){
	printf(""%c"",e);
	return OK;
}
Status Depth(BiTree T){
	int depthval, [MASK] ,depthright;
	if(!T)
		depthval=0;
	else{
		 [MASK] =Depth(T->lchild);
		depthright=Depth(T->rchild);
		depthval=1+( [MASK] >depthright? [MASK] :depthright);
	}
	return depthval;
}
Status Countleaf(BiTree T){
	int leafnum;
	if(!T)
		leafnum=0;
	else{
		leafnum=Countleaf(T->lchild)+Countleaf(T->rchild);
	}
	return leafnum;
}
Status Count(BiTree T){
	int num=0,num1=0,num2=0;
	if(!T) num=0;
	else{
		num1=Count(T->lchild);
		num2=Count(T->rchild);
		num=1+num1+num2;
	}
	return num;
}
Status Counttwo(BiTree T){
	int num=0,num1=0,num2=0;
	if(!T) num=0;
	else if(T->lchild && T->rchild){
		num=1;
		num1=Counttwo(T->lchild);
		num2=Counttwo(T->rchild);
		num+=num1+num2;
	}
	return num;
}
Status Countone(BiTree T){
	if(!T) return 0;
	else if(!T->lchild && T->rchild){
		return Countone(T->rchild)+1;
	}
	else if(T->lchild && !T->rchild){
		return Countone(T->lchild)+1;
	}
	else{
		return Countone(T->lchild)+Countone(T->rchild);
	}
}




",depthleft
128,"#ifndef CAMERA_H
#define CAMERA_H

#include ""rtweekend.h""

#include ""hittable.h""
#include ""material.h""

class camera {
  public:
    
    double aspect_ratio = 1.0;  // 渲染图宽高比
    int    image_width  = 100;  // 渲染图像素宽度
    int    image_height;   // 渲染图高度
    int    samples_per_pixel = 10; //每采样点随机采样点数
    int    max_depth         = 10;   // 限制最大递归深度
    double vfov = 90; //垂直fov

    point3 lookfrom = point3(0,0,0);   
    point3 lookat   = point3(0,0,-1);  //相机朝向
    vec3   vup      = vec3(0,1,0);     //相机直立空间向上坐标

    double defocus_angle = 0;  // 光线变化角度
    double focus_dist = 10;    // 点到焦点平面距离

    void render(const hittable& world) {
        initialize();

        std::cout << ""P3\n"" << image_width << ' ' << image_height << ""\n255\n"";

        for (int j = 0; j < image_height; j++) {
            std::clog << ""\rScanlines remaining: "" << (image_height - j) << ' ' << std::flush;
            for (int i = 0; i < image_width; i++) {
                color pixel_color(0,0,0);
                for (int sample = 0; sample < samples_per_pixel; sample++) {
                    ray r = get_ray(i, j);
                    pixel_color += ray_color(r, max_depth, world);
                }
                write_color(std::cout, pixel_samples_scale * pixel_color);
            }
        }

        std::clog << ""\rDone.                 \n"";
    }

  private:
    double pixel_samples_scale; //采样颜色比例因子
    point3 center;         // 相机坐标
    point3 pixel00_loc;    // 屏幕像素原点位置
    vec3   pixel_delta_u;  // 像素向右偏移量
    vec3   pixel_delta_v;  // 像素向下偏移量
    
    vec3   u, v, w; //相机空间基坐标
    vec3   defocus_disk_u;       // 散焦盘水平半径
    vec3   defocus_disk_v;       // 散焦盘垂直半径

    void initialize() {
        image_height = int(image_width / aspect_ratio);
        image_height = (image_height < 1) ? 1 : image_height;

        pixel_samples_scale = 1.0 / samples_per_pixel;

        center = lookfrom;
        // 视窗尺寸计算
        auto theta = degrees_to_radians(vfov);
        auto h = std::tan(theta/2);
        auto viewport_height = 2 * h * focus_dist;
        auto viewport_width = viewport_height * (double(image_width)/image_height);

        // 计算摄像机基坐标
        w = unit_vector(lookfrom - lookat);
        u = unit_vector(cross(vup, w));
        v = cross(w, u);

        // 计算横跨水平视图和纵向视图边缘的向量。
        vec3 viewport_u = viewport_width * u;    
        vec3 viewport_v = viewport_height * -v;  

        // 计算从像素水平和垂直增量向量。
        pixel_delta_u = viewport_u / image_width;
        pixel_delta_v = viewport_v / image_height;

        // 计算左上像素的位置。
         auto viewport_upper_left = center - (focus_dist * w) - viewport_u/2 - viewport_v/2;
        pixel00_loc = viewport_upper_left + 0.5 * (pixel_delta_u + pixel_delta_v);

        // 计算相机离焦盘的基向量。
        auto  [MASK]  = focus_dist * std::tan(degrees_to_radians(defocus_angle / 2));
        defocus_disk_u = u *  [MASK] ;
        defocus_disk_v = v *  [MASK] ;
    }

    ray get_ray(int i, int j) const {
        //构造一个摄像机光线，从原点出发，获取到像素位置 i，j 周围的随机射线。

        auto offset = sample_square();
        auto pixel_sample = pixel00_loc
                          + ((i + offset.x()) * pixel_delta_u)
                          + ((j + offset.y()) * pixel_delta_v);

        auto ray_origin = (defocus_angle <= 0) ? center : defocus_disk_sample();
        auto ray_direction = pixel_sample - ray_origin;

        return ray(ray_origin, ray_direction);
    }

    vec3 sample_square() const {
        // 返回 [-.5,+.5] 之间的随机坐标
        return vec3(random_double() - 0.5, random_double() - 0.5, 0);
    }

    point3 defocus_disk_sample() const {
        auto p = random_in_unit_disk();
        return center + (p[0] * defocus_disk_u) + (p[1] * defocus_disk_v);
    }

     color ray_color(const ray& r, int depth, const hittable& world) const {
        
        if (depth <= 0)
            return color(0,0,0);
        hit_record rec;

        if (world.hit(r, interval(0.001, infinity), rec)) {
            ray scattered;
            color attenuation;
            if (rec.mat->scatter(r, rec, attenuation, scattered))
                return attenuation * ray_color(scattered, depth-1, world);
            return color(0,0,0);
        }

        vec3 unit_direction = unit_vector(r.direction());
        auto a = 0.5*(unit_direction.y() + 1.0);
        return (1.0-a)*color(1.0, 1.0, 1.0) + a*color(0.5, 0.7, 1.0);
    }
};

#endif",defocus_radius
129,"#include ""ccontroller.hpp""
#include <Arduino.h>
#include <cmath>

CController::CController(int pin_num, float threshold_percent, int midi_cc_num) {
    pin = pin_num;
    pinMode(pin, INPUT);

    _last_reading = analogRead(pin);

    _delta_threshold = round(4096*threshold_percent/100);

    _midi_cc_num = midi_cc_num;
}

CController::CController(int pin_num, float threshold_percent) : CController(pin_num, threshold_percent, 0) {}

int CController::poll() {
    int  [MASK]  = analogRead(pin);
    if (abs( [MASK] -_last_reading) > _delta_threshold) {
        on_change( [MASK] );
        _last_reading =  [MASK] ;
        return 1;
    }
    else {
        return 0;
    }
}

int CController::poll(unsigned int sample_period_micro) {
    if ((micros()-_last_sample_time) > sample_period_micro) {
        _last_sample_time = micros();
        return poll();
    }
    else {
        return 0;
    }    
}

int CController::get_cc_num() {
    return _midi_cc_num;
}

void CController::set_cc_num(int new_cc_num) {
    _midi_cc_num = new_cc_num;
}

void CController::on_change(int controller_input) {}",cur_reading
130,"
#include ""DFA.hpp""

DFA::DFA()
{
	/* Initial DFA state */
	this->s_state = make_vertex();
	this->state = s_state;

	this->invalid = false;
}

bool DFA::set_start(int  [MASK] )
{
	if(!valid( [MASK] ))
		return false;

	if(state != s_state)
		return false;

	s_state =  [MASK] ;
	state =  [MASK] ;

	return true;
}

bool DFA::peek(char c)
{
	if(invalid)
		return false;

	for(auto edge : outgoing(state))
	{
		if(edge.get_weight() == c)
			return true;
	}

	return false;
}

bool DFA::at_accept()
{
	return accept.find(state) != accept.end();
}

void DFA::consume(char c)
{
	if(invalid)
		return;

	for(auto edge : outgoing(state))
	{
		if(edge.get_weight() == c)
		{
			state = edge.get_dest();
			current += c;

			return;
		}
	}

	invalid = true;
}

std::unique_ptr<std::string> DFA::get_data()
{
	return std::make_unique<std::string>(current);
}

bool DFA::add_accept(int state)
{
	if(!valid(state))
		return false;

	return accept.insert(state).second;
}

void DFA::reset()
{
	state = s_state;
	current.clear();
}

int DFA::curr_state()
{
	return state;
}

",n_start
131,"#include	<iostream>
#include	""AIEngine.hh""

AiEngine::AiEngine(ConfigEngine *data)
  : _ID(0),
    _data(data),
    _updateTime(50),
    _reactionTime(50)
{
}

AiEngine::AiEngine(const AiEngine &other)
{
  this->setID(other.getID());
  this->setData(getData());
  this->setUpdateTime(other.getUpdateTime());
  this->setReactionTime(other.getReactionTime());
}

AiEngine & AiEngine::operator=(const AiEngine &other)
{
  this->setID(other.getID());
  this->setData(other.getData());
  this->setUpdateTime(other.getUpdateTime());
  this->setReactionTime(other.getReactionTime());
  return (*this);
}

AiEngine::~AiEngine()
{
}

void AiEngine::setID(int ID)
{
  this->_ID = ID;
}

void AiEngine::setData(ConfigEngine *D)
{
  this->_data = D;
}

void AiEngine::setUpdateTime(int T)
{
  this->_updateTime = T;
}

void AiEngine::setReactionTime(int R)
{
  this->_reactionTime = R;
}

int AiEngine::getID() const
{
  return (this->_ID);
}

int AiEngine::getUpdateTime() const
{
  return (this->_updateTime);
}

ConfigEngine* AiEngine::getData() const
{
  return (this->_data);
}

int AiEngine::getReactionTime() const
{
  return (this->_reactionTime);
}

void AiEngine::resetExplosionArea()
{
  if (!_explosionArea.empty())
    _explosionArea.erase(_explosionArea.begin(),
			 _explosionArea.end());
}

void AiEngine::resetUnitPosition()
{
  if (!_unitPosition.empty())
    _unitPosition.erase(_unitPosition.begin(),
			_unitPosition.end());
}

void AiEngine::update()
{
  int time;

  time = getUpdateTime();
  if (time >= getReactionTime())
    {
      updateExplosionArea();
      updateUnitPosition();
      setUpdateTime(0);
      updateBots();
    }
  setUpdateTime(getUpdateTime() + 1);
}

void AiEngine::updateExplosionArea()
{
  std::list<AObject*>::iterator i;

  resetExplosionArea();
  for (i = _data->listBombs.begin();
       i != _data->listBombs.end(); ++i)
    {
      calculateArea(posXY((*i)->getX()/400, (*i)->getZ()/400),
		    dynamic_cast<Model::Bomb*>(*i)->getPower());
    }
}

void AiEngine::updateUnitPosition()
{
  std::list<AObject*>::iterator i;
  posXY pos;

  resetUnitPosition();
  pos.X = _data->player1->getX()/400;
  pos.Y = _data->player1->getZ()/400;
  _unitPosition.push_back(pos);
  if (_data->getPlayers() == 2)
    {
      pos.X = _data->player2->getX()/400;
      pos.Y = _data->player2->getZ()/400;
      _unitPosition.push_back(pos);
    }
  for (i = _data->listEnemies.begin(); i != _data->listEnemies.end(); ++i)
    {
      pos.X = (*i)->getX()/400;
      pos.Y = (*i)->getZ()/400;
      _unitPosition.push_back(pos);
    }
}

void AiEngine::updateBots()
{
  std::list<AObject*>::iterator i;
  Model::Player	*bot;
  posXY pos;

  for (i = _data->listEnemies.begin(); i != _data->listEnemies.end(); ++i)
    {
      bot = dynamic_cast<Model::Player*>(*i);
      pos.X = (*i)->getX()/400;
      pos.Y = (*i)->getZ()/400;
      if (bot->brain.getAction() == _THINK
      	  && !isDifferentCase(pos, bot->brain.getDestination()))
      	{
      	  bot->setX(400 * pos.X + 200);
      	  bot->setY(400 * pos.Y + 200);
      	}
      bot->brain.setState(evalState(pos, (bot->getPower() - 1)/2));
      bot->brain.setAction(makePlan(pos, bot->brain.getState(),
				    bot->getCurrentCapacity(),
				    (bot->getPower() - 1)/2));
      bot->brain.setDestination(pos, bot->brain.getAction());
    }
}

posXY AiEngine::getSafeCase(int X, int Y)
{
  if ((Y - 1 >= 0) && isSafeCase(X, Y - 1))
    return posXY(X, Y - 1);
  if ((X - 1 >= 0) && isSafeCase(X - 1, Y))
    return posXY(X - 1, Y);
  if ((Y + 1 < _data->getMapHeight()) && isSafeCase(X, Y + 1))
    return posXY(X, Y + 1);
  if (X + 1 < _data->getMapWidth() && isSafeCase(X + 1, Y))  
    return posXY(X + 1, Y);
  return posXY(-1,-1);
}

posXY AiEngine::getCase(int X, int Y)
{
  if ((Y - 1 >= 0) && isFreeCase(X, Y - 1))
    return posXY(X, Y - 1);
  if ((X - 1 >= 0) && isFreeCase(X - 1, Y))
    return posXY(X - 1, Y);
  if ((Y + 1 < _data->getMapHeight()) && isFreeCase(X, Y + 1))
    return posXY(X, Y + 1);
  if (X + 1 < _data->getMapWidth() && isFreeCase(X + 1, Y))  
    return posXY(X + 1, Y);
  return posXY(-1, -1);
}

posXY AiEngine::getLeaveCase(int X, int Y)
{
  posXY		check;

  if ((Y - 1 >= 0) && isFreeCase(X, Y - 1))
    {
      check = getSafeCase(X, Y - 1);
      if (check.X != -1)
	return posXY(X, Y -1);
    }
  if ((X - 1 >= 0) && isFreeCase(X - 1, Y))
    {
      check = getSafeCase(X - 1, Y);
      if (check.X != -1)
	return posXY(X - 1, Y);
    }
  if ((Y + 1 < _data->getMapHeight()) && isFreeCase(X, Y + 1))
    {
      check = getSafeCase(X, Y + 1);
      if (check.X != -1)
	return posXY(X, Y + 1);
    }
  if (X + 1 < _data->getMapWidth() && isFreeCase(X + 1, Y))
    {
      check = getSafeCase(X + 1, Y);
      if (check.X != -1)
	return posXY(X + 1, Y);
    }
  return posXY(-1,-1);
}

bool AiEngine::isDangerousCase(int X, int Y)
{
  std::list<posXY>::iterator i;

  for (i = _explosionArea.begin(); i != _explosionArea.end(); ++i)
    if (i->X == X && i->Y == Y)
      return (true);
  return (false);
}

bool AiEngine::thereIsNoDanger(int X, int Y)
{
  std::list<posXY>::iterator i;

  for (i = _explosionArea.begin(); i != _explosionArea.end(); ++i)
    {
      if (((i->X == X) && (i->Y == Y - 1 || i->Y == Y + 1))
	  || (((i->Y == Y) && (i->X == X - 1 || i->X == X + 1))))
	return (false);
    }
  return (true);
}

bool AiEngine::thereIsBonusClose(int X, int Y)
{
  std::list<AObject*>::iterator i;

  for (i = _data->listBonus.begin();
       i != _data->listBonus.end(); ++i)
    {
      if (((*i)->getX()/400 == X && ((*i)->getZ()/400 == Y - 1
				     || (*i)->getZ()/400 == Y + 1))
	  || ((*i)->getZ()/400 == Y && ((*i)->getX()/400 == X - 1
					|| (*i)->getX()/400 == X + 1)))
	return (true);
    }
  return (false);
}

bool AiEngine::thereIsBoxClose(int X, int Y)
{
  std::list<AObject*>::iterator i;

  for (i = _data->listBoxes.begin();
       i != _data->listBoxes.end(); ++i)
    {
      if (((*i)->getX()/400 == X && ((*i)->getZ()/400 == Y - 1
				     || (*i)->getZ()/400 == Y + 1))
	  || ((*i)->getZ()/400 == Y && ((*i)->getX()/400 == X - 1
					|| (*i)->getX()/400 == X + 1)))
	return (true);
    }
  return (false);
}

bool AiEngine::thereIsBombAt(int X, int Y)
{
  std::list<AObject*>::iterator i;

  for (i = _data->listBombs.begin();
       i != _data->listBombs.end(); ++i)
    {
      if ((*i)->getX()/400 == X && (*i)->getZ()/400 == Y)
	return (true);
    }
  return (false);
}

bool AiEngine::thereIsUnit(int X, int Y)
{
  std::list<posXY>::iterator i;

  for (i = _unitPosition.begin(); i != _unitPosition.end(); ++i)
    {
      if (i->X == X && i->Y == Y)
	return (true);
    }
  return (false);
}

bool AiEngine::isTouch(int posX, int posY, int cmpX, int cmpY)
{
  if ((posX == cmpX && (posY == cmpY - 1 || posY == cmpY + 1))
      || ((posY == cmpY) && (posX == cmpX - 1 || posX == cmpX + 1)))
    return (true);
  return (false);
}

bool AiEngine::isTouch(posXY pos, posXY cmp)
{
  if ((pos.X == cmp.X && (pos.Y == cmp.Y - 1 || pos.Y == cmp.Y + 1))
      || ((pos.Y == cmp.Y) && (pos.X == cmp.X - 1 || pos.X == cmp.X + 1)))
    return (true);
  return (false);
}

bool AiEngine::isBox(int X, int Y)
{
  std::map<std::pair<int, int>, Case>::iterator i;

  for (i = _data->map._stock.begin();
       i != _data->map._stock.end(); ++i)
    if (i->first.first == X && i->first.second == Y)
      return i->second.getType() == BOX;
  return (false);
}

bool AiEngine::isSafeCase(int X, int Y)
{
  return isFreeCase(X, Y) && !isDangerousCase(X, Y);
}

bool AiEngine::thereIsEnemieClose(int X, int Y)
{
  std::list<posXY>::iterator i;
  
  for (i = _unitPosition.begin(); i != _unitPosition.end(); ++i)
    if (((i->X == X) && (i->Y == Y - 1 || i->Y == Y + 1))
	|| ((i->Y == Y) && (i->X == X - 1 || i->X == X + 1)))
      return (true);
  return (false);
}

bool AiEngine::isDifferentCase(posXY first, posXY second)
{
  if (first.X != second.X || first.Y != second.Y)
    return (true);
  return (false);
}

bool AiEngine::checkLongLine(posXY from, posXY to)
{
  posXY		tmp;

  tmp.X = from.X;
  tmp.Y = from.Y;
  if (tmp.Y > to.Y)
    {
      while (tmp.Y != to.Y)
	{
	  if (isDifferentCase(tmp, from) && isBox(tmp.X, tmp.Y))
	    return (false);
	  --tmp.Y;
	}
    }
  else
    {
      while (tmp.Y != to.Y)
	{
	  if (isDifferentCase(tmp, from) && isBox(tmp.X, tmp.Y))
	    return (false);
	  ++tmp.Y;
	}
    }
  return (true);
} 

bool AiEngine::checkLargLine(posXY from, posXY to)
{
  posXY		tmp;

  tmp.X = from.X;
  tmp.Y = from.Y;
  if (tmp.X > to.X)
    {
      while (tmp.X != to.X)
	{
	  if (isDifferentCase(tmp, from) && isBox(tmp.X, tmp.Y))
	    return (false);
	  --tmp.X;
	}
    }
  if (tmp.X < to.X)
    {
      while (tmp.X != to.X)
	{
	  if (isDifferentCase(tmp, from) && isBox(tmp.X, tmp.Y))
	    return (false);
	  ++tmp.X;
	}
    }
  return (true);
} 

bool AiEngine::thereIsNoBoxBetween(posXY pos, posXY enemiePos)
{
  Action  [MASK] ;

   [MASK]  = calcDirection(pos, enemiePos);
  if ( [MASK]  == _UP ||  [MASK]  == _DOWN)
    return (checkLongLine(pos, enemiePos));
  else if ( [MASK]  == _LEFT ||  [MASK]  == _RIGHT)
    return (checkLargLine(pos, enemiePos));
  else
    return (true);
}

bool AiEngine::enemieInRange(int X, int Y, int R)
{
  std::list<posXY>::iterator i;
  posXY from, to;
  int it;
  
  from.X = X;
  from.Y = Y;
  for (i = _unitPosition.begin(); i != _unitPosition.end(); ++i)
    {
      it = R;
      if (it <= 0)
	it = 1;
      while (it != 0)
	{
	  if (((i->X == X) && (i->Y == Y - it || i->Y == Y + it))
	      || ((i->Y == Y) && (i->X == X - it || i->X == X + it)))
	    {
	      to.X = i->X;
	      to.Y = i->Y;
	      if (thereIsNoBoxBetween(from, to))
		return (true);
	    }
	  --it;
	}
    }
  return (false);
}

void AiEngine::doDownCalc(posXY pos, int power)
{
  int i = power;

  while (i != 0)
    {
      if ((pos.Y - 1) >= 0)
	{
	  --pos.Y;
	  _explosionArea.push_back(pos);
	}
      --i;
    }
}

void AiEngine::doLeftCalc(posXY pos, int power)
{
  int i = power;

  while (i != 0)
    {
      if ((pos.X + 1) < _data->getMapWidth())
	{
	  ++pos.X;
	  _explosionArea.push_back(pos);
	}
      --i;
    }
}

void AiEngine::doUpCalc(posXY pos, int power)
{
  int i = power;

  while (i != 0)
    {
      if ((pos.Y + 1) < _data->getMapHeight())
	{
	  ++pos.Y;
	  _explosionArea.push_back(pos);
	}
      --i;
    }
}

void AiEngine::doRightCalc(posXY pos, int power)
{
  int i = power;

  while (i != 0)
    {
      if ((pos.X - 1) >= 0)
	{
	  --pos.X;
	  _explosionArea.push_back(pos);
	}
      --i;
    }
}

void AiEngine::calculateArea(posXY pos, int power)
{
  int P = (power - 1)/2;
  
  _explosionArea.push_back(pos);
  doUpCalc(pos, P);
  doLeftCalc(pos, P);
  doRightCalc(pos, P);
  doDownCalc(pos, P);
}

void AiEngine::affExplosionArea()
{
  std::list<posXY>::iterator i;

  std::cout << ""==========\nEXPLOSION AREA:"" << std::endl;
  for (i = _explosionArea.begin();
       i != _explosionArea.end(); ++i)
    std::cout << ""--> X["" << i->X << ""] Y["" << i->Y << ""]."" << std::endl;
  std::cout << ""=========="" << std::endl;
}

void AiEngine::affUnitPosition()
{
  std::list<posXY>::iterator i;

  std::cout << ""==========\nUNIT POSITION:"" << std::endl;
  for (i = _unitPosition.begin();
       i != _unitPosition.end(); ++i)
    std::cout << ""--> X["" << i->X << ""] Y["" << i->Y << ""]."" << std::endl;
  std::cout << ""=========="" << std::endl;
}

void AiEngine::affPos(posXY pos)
{
  std::cout << ""X["" << pos.X << ""]Y["" << pos.Y << ""]."" << std::endl;
}

void AiEngine::affPos(int X, int Y)
{
  std::cout << ""X["" << X << ""]Y["" << Y << ""]."" << std::endl;
}

void AiEngine::affState(State S)
{
  switch (S)
    {
    case (_ATTACK):
      std::cout << ""_ATTACK"" << std::endl;
      break;
    case (_SURVIVE):
      std::cout << ""_SURVIVE"" << std::endl;
      break;
    case (_EXPLORE):
      std::cout << ""_EXPLORE"" << std::endl;
      break;
    case (_COLLECT):
      std::cout << ""_COLLECT"" << std::endl;
      break;
    }
}

bool AiEngine::isFreeCase(int X, int Y)
{
  std::map<std::pair<int, int>, Case>::iterator i;
  CaseType type;

  for (i = _data->map._stock.begin();
       i != _data->map._stock.end(); ++i)
    {
      if (i->first.first == X && i->first.second == Y)
	{
	  type = i->second.getType();
	  if ((type == FLOOR || type == BONUS || type == FIRE_BONUS)
	      && !thereIsUnit(i->first.first, i->first.second))
	    return (true);
	  return (false);
	}
    }
  return (false);
}


State AiEngine::evalState(posXY pos, int attackRange)
{
  if (isDangerousCase(pos.X, pos.Y)
      || !thereIsNoDanger(pos.X, pos.Y))
    return (_SURVIVE);
  if (enemieInRange(pos.X, pos.Y, attackRange))
    return (_ATTACK);
  if (thereIsBonusClose(pos.X, pos.Y))
    return (_COLLECT);
  return (_EXPLORE);
}

Action AiEngine::makePlan(posXY actPos, State State,
			  bool haveBomb, int power)
{
  switch (State)
    {
    case (_SURVIVE):
      return (survive(actPos));
    case (_ATTACK):
      return (attack(actPos, haveBomb, power));
    case (_COLLECT):
      return (collectBonus(actPos));
    case (_EXPLORE):
      return (explore(actPos, haveBomb));
    }
   return (_THINK);
}

Action AiEngine::survive(posXY actPos)
{
  posXY newPos;

  if (isDangerousCase(actPos.X, actPos.Y))
    {
      newPos = getSafeCase(actPos.X, actPos.Y);
      if (newPos.X == -1 && newPos.Y == -1)
	{
	  if (!isDangerousCase(actPos.X , actPos.Y))
	    return (_THINK);
	  else
	    {
	      newPos = getLeaveCase(actPos.X, actPos.Y);
	      if (newPos.X == -1)
		return (_THINK);
	      return (calcDirection(actPos, newPos));
	    }
	}
      return (calcDirection(actPos, newPos));
    }
  else
    return (_THINK);
}

Action AiEngine::attack(posXY actPos, bool haveBomb, int power)
{
  posXY newPos;

  if (haveBomb && enemieInRange(actPos.X, actPos.Y, power)
      && !thereIsBombAt(actPos.X, actPos.Y) && newPos.X != -1)
    return (_BOMB);
  newPos = getSafeCase(actPos.X, actPos.Y);
  if (newPos.X != -1)
    return (calcDirection(actPos, newPos));
  return (_THINK);
}

Action	AiEngine::collectBonus(posXY playerPos)
{
  std::list<AObject*>::iterator i;
  posXY bonusPos;

  for (i = _data->listBonus.begin(); i != _data->listBonus.end(); ++i)
    {
      bonusPos.X = (*i)->getX()/400;
      bonusPos.Y = (*i)->getZ()/400;
      if (isTouch(playerPos, bonusPos)
	  && isFreeCase(bonusPos.X, bonusPos.Y))
	return (calcDirection(playerPos, bonusPos));
    }
  return (_THINK);
}

Action AiEngine::explore(posXY actPos, bool haveBomb)
{
  posXY newPos;

  if (thereIsNoDanger(actPos.X, actPos.Y))
    {
      newPos = getCase(actPos.X, actPos.Y);
      if (haveBomb && thereIsBoxClose(actPos.X, actPos.Y)
	  && newPos.X != -1)
	return (_BOMB);
      else if (thereIsBonusClose(actPos.X, actPos.Y))
	return (collectBonus(actPos));
      else
	return (getRandMove());
    }
  else
    return (_THINK);
}

Action  AiEngine::getRandMove()
{
  int result = random() % 4;
  switch (result)
    {
    case 0:
      return (_UP);
    case 1:
      return (_RIGHT);
    case 2:
      return (_DOWN);
    case 3:
      return (_LEFT);
    }
  return (_THINK);
}

Action AiEngine::calcDirection(posXY actPos, posXY newPos)
{
  if (actPos.X == newPos.X && actPos.Y - 1 == newPos.Y)
      return (_DOWN);
  if (actPos.X == newPos.X && actPos.Y + 1 ==  newPos.Y)
      return (_UP);
  if (actPos.X - 1 == newPos.X && actPos.Y == newPos.Y)
      return (_RIGHT);
  if (actPos.X + 1 == newPos.X && actPos.Y == newPos.Y)
      return (_LEFT);
  return (_THINK);
}
",dir
132,"#include <ostream>
#include <stdexcept>
#include <gtest/gtest.h>
#include ""DeltaBuffer.hpp""

using namespace org_pqrs_Karabiner;

TEST(DeltaBuffer, push) {
  DeltaBuffer  [MASK] ;

  EXPECT_EQ(0,  [MASK] .sum());

   [MASK] .push(-1);
  EXPECT_EQ(-1,  [MASK] .sum());

  // fill buffer
  EXPECT_TRUE(! [MASK] .isFull());
  int sum = 0;
  for (;;) {
     [MASK] .push(-1);
    if (sum ==  [MASK] .sum()) break;
    sum =  [MASK] .sum();
  }
  EXPECT_TRUE( [MASK] .isFull());

   [MASK] .push(-3); // replace -1 with -3.
  sum -= 2;
  EXPECT_EQ(sum,  [MASK] .sum());

   [MASK] .push(0); // replace -1  with 0.
  sum += 1;
  EXPECT_EQ(sum,  [MASK] .sum());

  // reverse direction
  EXPECT_NE(sum, 0);
   [MASK] .push(1);
  sum = 1;
  EXPECT_EQ(sum,  [MASK] .sum());
  EXPECT_TRUE(! [MASK] .isFull());

  // clear
  while (! [MASK] .isFull()) {
     [MASK] .push(1);
  }
  EXPECT_NE(0,  [MASK] .sum());
  EXPECT_NE(0,  [MASK] .isFull());

   [MASK] .clear();

  EXPECT_EQ(0,  [MASK] .sum());
  EXPECT_TRUE(! [MASK] .isFull());
}

int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}
",deltaBuffer
133,"#include <algorithm>
#include <iostream>
#include <sstream>

#include <dlib/cmd_line_parser.h>
#include <dlib/image_io.h>
#include <dlib/gui_widgets.h>
#include <dlib/dir_nav.h>
#include <dlib/image_transforms.h>

int main(int argc, char** argv) try
{
    dlib::command_line_parser cmd_parser;
    cmd_parser.add_option(""max-size"", ""max num of pixels per image"", 1);
    cmd_parser.add_option(""max-images"", ""maximum number of images"", 1);
    cmd_parser.add_option(""show"", ""show the resulting image"");
    cmd_parser.set_group_name(""Help Options"");
    cmd_parser.add_option(""h"", """");
    cmd_parser.add_option(""help"", ""display this message and exit"");
    cmd_parser.parse(argc, argv);

    if (cmd_parser.number_of_arguments() == 0 || cmd_parser.option(""h"") || cmd_parser.option(""help""))
    {
        std::cout << ""\nUsage: tiler [options] directory\n\n"";
        cmd_parser.print_options();
        return EXIT_SUCCESS;
    }

    const std::string& root = cmd_parser[0];
    const double max_size = dlib::get_option(cmd_parser, ""max-size"", std::numeric_limits<double>::max());
    const size_t max_images = dlib::get_option(cmd_parser, ""max-images"", std::numeric_limits<size_t>::max());
    auto files = dlib::get_files_in_directory_tree(root, dlib::match_endings("".jpg .JPG .jpeg .JPEG .png .PNG""));
    std::sort(files.begin(), files.end());
    std::cout << ""Found "" << files.size() << "" images\n"";
    auto num_images = std::min(max_images, files.size());
    files.erase(files.begin() + num_images, files.end());
    std::cout << ""Generating tiled image with "" << files.size() << "" images\n"";

    std::vector<dlib::matrix<dlib::rgb_pixel>> images;
    images.assign(files.size(), dlib::matrix<dlib::rgb_pixel>());
    dlib::parallel_for(0, files.size(), [&files, max_size, &images](size_t i)
    {
        const auto& file = files[i];
        dlib::matrix<dlib::rgb_pixel> image;
        dlib::load_image(image, file.full_name());
        if (const auto  [MASK]  = std::sqrt(max_size / image.size());  [MASK]  < 1)
        {
            dlib::resize_image( [MASK] , image);
        }
        images[i] = std::move(image);
    });

    dlib::matrix<dlib::rgb_pixel> tiled_image = dlib::tile_images(images);
    dlib::save_jpeg(tiled_image, ""tiled_image.jpg"");
    if (cmd_parser.option(""show""))
    {
        dlib::image_window win(tiled_image, ""tiled image"");
        win.wait_until_closed();
    }
    return EXIT_SUCCESS;
}
catch (std::exception& e)
{
    std::cout << e.what() << std::endl;
    return EXIT_FAILURE;
}
",scaling_factor
134,"//
//  ycsbc.cc
//  YCSB-C
//
//  Created by <NAME> on 12/19/14.
//  Copyright (c) 2014 <NAME> <<EMAIL>>.
//
#include ""ycsbc.h""

#include <cstring>
#include <future>
#include <iostream>
#include <string>
#include <vector>

#include ""core/client.h""
#include ""core/core_workload.h""
#include ""core/timer.h""
#include ""core/utils.h""

using namespace std;

namespace ycsbc {
void UsageMessage(const char *command);
bool StrStartWith(const char *str, const char *pre);
string ParseCommandLine(int argc, const char *argv[], utils::Properties &props);


int DelegateClient(ycsbc::DB *db, ycsbc::CoreWorkload *wl, const int num_ops,
                   bool is_loading, vector<double>* latency) {
  db->Init();
  ycsbc::Client client(*db, *wl);
  utils::Timer<double>  [MASK] ;
  int current_ops;

  int oks = 0;
  for (int i = 0; i < num_ops; ++i) {
    current_ops = 0;
     [MASK] .Start();
    if (is_loading) {
      oks += client.DoInsert();
    } else {
      oks += client.DoTransaction();
    }
    double t =  [MASK] .End();
    if (latency) latency->push_back(t);
  }
  db->Close();
  return oks;
}

string ParseCommandLine(int argc, const char *argv[],
                        utils::Properties &props) {
  int argindex = 1;
  string filename;
  while (argindex < argc && StrStartWith(argv[argindex], ""-"")) {
    if (strcmp(argv[argindex], ""-threads"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      props.SetProperty(""threadcount"", argv[argindex]);
      argindex++;
    } else if (strcmp(argv[argindex], ""-host"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      props.SetProperty(""host"", argv[argindex]);
      argindex++;
    } else if (strcmp(argv[argindex], ""-port"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      props.SetProperty(""port"", argv[argindex]);
      argindex++;
    } else if (strcmp(argv[argindex], ""-slaves"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      props.SetProperty(""slaves"", argv[argindex]);
      argindex++;
    } else if (strcmp(argv[argindex], ""-P"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      filename.assign(argv[argindex]);
      ifstream input(argv[argindex]);
      try {
        props.Load(input);
      } catch (const string &message) {
        cout << message << endl;
        exit(0);
      }
      input.close();
      argindex++;
    } else if (strcmp(argv[argindex], ""--no-init"") == 0) {
      props.SetProperty(""init_data"", ""0"");
      argindex++;
    } else if (strcmp(argv[argindex], ""-records"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      props.SetProperty(""recordcount"", argv[argindex]);
      argindex++;
    } else if (strcmp(argv[argindex], ""-operations"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      props.SetProperty(""operationcount"", argv[argindex]);
      argindex++;
    } else if (strcmp(argv[argindex], ""-bs"") == 0) {
      argindex++;
      if (argindex >= argc) {
        UsageMessage(argv[0]);
        exit(0);
      }
      props.SetProperty(""fieldlength"", argv[argindex]);
      argindex++;
    }else {
      cout << ""Unknown option '"" << argv[argindex] << ""'"" << endl;
      exit(0);
    }
  }

  if (argindex == 1 || argindex != argc) {
    UsageMessage(argv[0]);
    exit(0);
  }

  return filename;
}

void UsageMessage(const char *command) {
  cout << ""Usage: "" << command << "" [options]"" << endl;
  cout << ""Options:"" << endl;
  cout << ""  -threads n: execute using n threads (default: 1)"" << endl;
  cout << ""  -P propertyfile: load properties from the given file. Multiple ""
          ""files can""
       << endl;
  cout << ""                   be specified, and will be processed in the order ""
          ""specified""
       << endl;
  cout << ""   -records record_counts: amount of data to be initialized"" << endl;
  cout << ""   -operations operation_counts: amount of operations to be performed"" << endl;
  cout << ""   -bs value_size: size of a value"" << endl;
  cout << ""   --no-init: bypass the initialization of data"" << endl;
}

inline bool StrStartWith(const char *str, const char *pre) {
  return strncmp(str, pre, strlen(pre)) == 0;
}

void RunBench(int argc, const char *argv[], DB *db) {
  utils::Properties props;
  string file_name = ParseCommandLine(argc, argv, props);
  vector<future<int>> actual_ops;
  int total_ops = stoi(props[ycsbc::CoreWorkload::RECORD_COUNT_PROPERTY]);
  int sum = 0;

  ycsbc::CoreWorkload wl;
  wl.Init(props);

  const int num_threads = stoi(props.GetProperty(""threadcount"", ""1""));

  const bool init_data = stoi(props.GetProperty(""init_data"", ""1""));

  vector<double> total_latency;
  total_latency.reserve(total_ops);
  vector<vector<double>> thread_latency(num_threads);
  if (init_data) {  // Loads data
    std::cout << ""=============================== Load Data ""
                 ""===============================""
              << std::endl;

    for (int i = 0; i < num_threads; ++i) {
      actual_ops.emplace_back(async(launch::async, DelegateClient, db, &wl,
                                    total_ops / num_threads, true, nullptr));
    }
    assert((int)actual_ops.size() == num_threads);

    for (auto &n : actual_ops) {
      assert(n.valid());
      sum += n.get();
    }
    cerr << ""# Loading records:\t"" << sum << endl;
  }

  // Peforms transactions
  std::cout << ""=============================== Perform Transanction ""
               ""===============================""
            << std::endl;
  actual_ops.clear();
  total_ops = stoi(props[ycsbc::CoreWorkload::OPERATION_COUNT_PROPERTY]);
  utils::Timer<double> timer;
  timer.Start();
  for (int i = 0; i < num_threads; ++i) {
    actual_ops.emplace_back(async(launch::async, DelegateClient, db, &wl,
                                  total_ops / num_threads, false, &thread_latency[i]));
  }
  assert((int)actual_ops.size() == num_threads);

  sum = 0;
  for (auto &n : actual_ops) {
    assert(n.valid());
    sum += n.get();
  }
  double duration = timer.End();

  for (int t = 0; t < num_threads; t++) {
    total_latency.insert(total_latency.end(), thread_latency[t].begin(), thread_latency[t].end());
  }
  size_t pos_avg = sum >> 2;
  size_t pos_99 = sum - sum / 100 - 1;
  size_t pos_999 = sum - sum / 1000 - 1;

  cout << ""# Transaction throughput (KTPS)"" << endl;
  cout << file_name << '\t' << num_threads << '\t';
  cout << total_ops / duration / 1000 << endl;
  
  cout << ""# Transaction latency (ms)"" << endl;
  nth_element(total_latency.begin(), total_latency.begin() + pos_avg, total_latency.end());
  cout << ""avg latency:\t"" << *(total_latency.begin() + pos_avg) * 1000 << endl;
  nth_element(total_latency.begin(), total_latency.begin() + pos_99, total_latency.end());
  cout << ""99% tail latency:\t"" << *(total_latency.begin() + pos_99) * 1000 << endl;
  nth_element(total_latency.begin(), total_latency.begin() + pos_999, total_latency.end());
  cout << ""99.9% tail latency:\t"" << *(total_latency.begin() + pos_999) * 1000 << endl;
}
}  // namespace ycsbc
",timer_us
135,"/*
 * Copyright (c) 2024 Huawei Device Co., Ltd.
 * 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 NET_CONNECTION_IMPL_H
#define NET_CONNECTION_IMPL_H

#include ""common.h""
#include ""ffi_remote_data.h""
#include ""net_connection_callback.h""
#include ""net_manager_constants.h""
#include ""net_specifier.h""
#include <map>
#include <vector>
namespace OHOS::NetManagerStandard {

class NetConnectionImpl final {
public:
    bool hasNetSpecifier_;

    bool hasTimeout_;

    NetManagerStandard::NetSpecifier netSpecifier_;

    uint32_t timeout_;

    std::vector<std::function<void(int32_t)>> netAvailible;

    std::vector<std::function<void(int32_t, bool)>> netBlockStatusChange;

    std::vector<std::function<void(CNetCapabilityInfo)>> netCapabilitiesChange;

    std::vector<std::function<void(int32_t, CConnectionProperties)>> netConnectionPropertiesChange;

    std::vector<std::function<void(int32_t)>> netLost;

    std::vector<std::function<void()>> netUnavailable;

public:
    [[nodiscard]] sptr<OHOS::NetManagerStandard::ConnectionCallbackObserver> GetObserver() const;

    static NetConnectionImpl *MakeNetConnection();

    static void DeleteNetConnection(OHOS::NetManagerStandard::NetConnectionImpl *netConnection);

private:
    sptr<ConnectionCallbackObserver> observer_;

    explicit NetConnectionImpl();

    ~NetConnectionImpl() = default;
};

class NetConnectionProxy : public OHOS::FFI::FFIData {
private:
    friend class OHOS::FFI::RuntimeType;
    friend class OHOS::FFI::TypeBase;
    static OHOS::FFI::RuntimeType *GetClassType()
    {
        static OHOS::FFI::RuntimeType  [MASK]  =
            OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>(""NetConnectionProxy"");
        return & [MASK] ;
    }

public:
    OHOS::FFI::RuntimeType *GetRuntimeType() override
    {
        return GetClassType();
    }

public:
    NetConnectionProxy(CNetSpecifier specifier, uint32_t timeout);

    int32_t RegisterCallback();

    int32_t UnregisterCallback();

    void OnNetAvailible(void (*callback)(int32_t));

    void OnNetBlockStatusChange(void (*callback)(int32_t, bool));

    void OnNetCapabilitiesChange(void (*callback)(CNetCapabilityInfo));

    void OnNetConnectionPropertiesChange(void (*callback)(int32_t, CConnectionProperties));

    void OnNetLost(void (*callback)(int32_t));

    void OnNetUnavailable(void (*callback)());

private:
    NetConnectionImpl *netConn_;
};

extern std::map<OHOS::NetManagerStandard::ConnectionCallbackObserver *, OHOS::NetManagerStandard::NetConnectionImpl *>
    NET_CONNECTIONS;
extern std::mutex g_netConnectionsMutex;
} // namespace OHOS::NetManagerStandard

#endif",runtimeType
136," /******************************************************************************
 *  Copyright 2021 <NAME>
 *
 * 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 _LIB_SPEC_READER_HPP
#define _LIB_SPEC_READER_HPP

#include ""clang/AST/Decl.h""
#include ""clang/ASTMatchers/ASTMatchers.h""
#include ""clang/ASTMatchers/ASTMatchFinder.h""
#include ""clang/Frontend/CompilerInstance.h""
#include ""clang/Tooling/Tooling.h""
#include ""clang/Tooling/CommonOptionsParser.h""
#include ""llvm/Support/CommandLine.h""

#include <numeric>
#include <iostream>
#include <sstream>

#include ""srcHelperFunctions.hpp""
#include ""clang_interface.hpp""

void addExposedFuncs(const clang::PrintingPolicy&);

class ExposedFuncDecl
{

    public:

        std::string name;
        const clang::CXXRecordDecl* enclosing_class = nullptr;
        clang::QualType ret_typ;
        llvm::ArrayRef<clang::ParmVarDecl*> params;
        bool statik;
        bool ctor;
        bool special;

        ExposedFuncDecl(llvm::StringRef _name, const clang::CXXRecordDecl* _ec,
            clang::QualType _ret_typ,
            llvm::ArrayRef<clang::ParmVarDecl*> _params, bool _statik = false,
            bool _ctor = false, bool _special = false) :
            name(_name), enclosing_class(_ec), ret_typ(_ret_typ),
            params(_params), statik(_statik), ctor(_ctor), special(_special) {};
        ExposedFuncDecl(llvm::StringRef _name, clang::QualType _ret_typ,
            llvm::ArrayRef<clang::ParmVarDecl*> _params, bool _statik = false,
            bool _ctor = false, bool _special = false) :
            name(_name), ret_typ(_ret_typ), params(_params), statik(_statik),
            ctor(_ctor), special(_special) {};

        std::string getSignature() const;
        static bool compare(const ExposedFuncDecl&, const ExposedFuncDecl&);
};

class ExposedTemplateType
{
    public:
        std::string base_type;
        clang::TemplateParameterList* template_params;

        ExposedTemplateType(std::string  [MASK] , clang::TemplateParameterList* _tpl) :
            base_type( [MASK] ), template_params(_tpl) {};

        std::vector<std::string> getParamListStr();
        static bool compare(const ExposedTemplateType&, const ExposedTemplateType&);
};

/*******************************************************************************
* FuzzHelperLog action - read information from defined helper functions
*******************************************************************************/

class fuzzHelperFuncLogger : public clang::ast_matchers::MatchFinder::MatchCallback
{
    public:
        virtual void run(const clang::ast_matchers::MatchFinder::MatchResult&);
};

class fuzzHelperLogger : public clang::ASTConsumer
{
    private:
        clang::ast_matchers::MatchFinder matcher;
        fuzzHelperFuncLogger logger;

    public:
        fuzzHelperLogger();

        void HandleTranslationUnit(clang::ASTContext& ctx) override;
};

class fuzzHelperLoggerAction : public clang::ASTFrontendAction
{
    private:
        const clang::PrintingPolicy* print_policy;

    public:
        fuzzHelperLoggerAction() {};

        bool BeginSourceFileAction(clang::CompilerInstance& ci) override;
        void EndSourceFileAction() override;

        std::unique_ptr<clang::ASTConsumer>
        CreateASTConsumer(clang::CompilerInstance& CI, llvm::StringRef File) override;
};

/*******************************************************************************
* LibSpecReader action - read information from exposed library sources
*******************************************************************************/

class exposedFuncDeclMatcher : public clang::ast_matchers::MatchFinder::MatchCallback
{
    public:
        virtual void run(const clang::ast_matchers::MatchFinder::MatchResult&);
};

class libSpecReader : public clang::ASTConsumer
{
    private:
        clang::ast_matchers::MatchFinder matcher;
        exposedFuncDeclMatcher printer;

    public:
        libSpecReader();

        void HandleTranslationUnit(clang::ASTContext& ctx) override;
};

class libSpecReaderAction : public clang::ASTFrontendAction
{
    private:
        const clang::PrintingPolicy* print_policy;

    public:
        libSpecReaderAction() {};

        bool BeginSourceFileAction(clang::CompilerInstance& ci) override;
        void EndSourceFileAction() override;

        std::unique_ptr<clang::ASTConsumer>
        CreateASTConsumer(clang::CompilerInstance& CI, llvm::StringRef File) override;
};

extern std::set<ExposedFuncDecl, decltype(&ExposedFuncDecl::compare)>
    exposed_funcs;

#endif // _LIB_SPEC_READER_HPP
",_base_type
137,"#ifndef NIGIRI_STATEMACHINE_H
#define NIGIRI_STATEMACHINE_H

#include <condition_variable>
#include <initializer_list>
#include <iostream>
#include <thread>
#include <mutex>
#include <map>
#include <type_traits>

namespace nigiri {

// #define LOG_NIGIRI_STATEMACHINE

template<typename TState,
        typename TEvent,
        TState initialState,
        bool stateEnum,
        bool stateConvert,
        bool eventEnum,
        bool eventConvert>
class _StateMachine {

public:

    using StateToStringFunc = std::function<std::string(TState)>;
    using EventToStringFunc = std::function<std::string(TEvent)>;

	using StateValue = typename std::underlying_type<TState>::type;
	using EventValue = typename std::underlying_type<TState>::type;

    _StateMachine(){
        static_assert(stateEnum && !stateConvert,""State type is not enum class"");
        static_assert(eventEnum && !eventConvert,""Event type is not enum class"");
    };

    ~_StateMachine(){
        #ifdef LOG_NIGIRI_STATEMACHINE
        std::cout << ""DEBUG - nigiri::StateMachine - dtor"" << std::endl;
        #endif
    }

    TState getState(){
        return state;
    }

    void submitEvent(TEvent event){
        if(isEventValid(event)){
            #ifdef LOG_NIGIRI_STATEMACHINE
            if(eventToStringFunc){
                std::string msg = ""StateMachine - Submitting event \"""" + eventToStringFunc(event) + ""\"""";
                std::cout << msg << std::endl;
            }
            TState oldState = state;
            #endif
            std::lock_guard<std::mutex> guard(mtx);
            state = topology[state][event];
            #ifdef LOG_NIGIRI_STATEMACHINE
            if (eventToStringFunc && stateToStringFunc) {
				std::string msg = ""StateMachine - "";
				msg += ""Event \"""" + eventToStringFunc(event) + ""\"" changed state from \"""" + stateToStringFunc(oldState) + ""\"" to \"""" + stateToStringFunc(state) + ""\"""";
				std::cout << msg << std::endl;
			}
            #endif
            cv.notify_one();
            #ifdef LOG_NIGIRI_STATEMACHINE
            if(eventToStringFunc){
                std::string msg = ""StateMachine - Event \"""" + eventToStringFunc(event) + ""\"" submitted"";
                std::cout << msg << std::endl;
            }
            #endif
        }
    };

    void waitForState(TState waitState){
        #ifdef LOG_NIGIRI_STATEMACHINE
        if(stateToStringFunc){
            std::string msg = ""StateMachine - Waiting for state \"""" + stateToStringFunc(waitState) + ""\"""";
			std::cout << msg << std::endl;
        }
        #endif
        std::unique_lock<std::mutex> lock(mtx);
        TState* statePtr = &state;
        cv.wait(lock,[statePtr,waitState](){
			#ifdef LOG_NIGIRI_STATEMACHINE
            StateValue requiredStateValue = static_cast<StateValue>(waitState);
			StateValue currentStateValue = static_cast<StateValue>(*statePtr);
            std::string msg = ""StateMachine - State check - "";
			msg += ""Required: \"""" + std::to_string(requiredStateValue) + ""\"", Current: \"""" + std::to_string(currentStateValue) + ""\"""";
			std::cout << msg << std::endl;
            #endif
			return waitState == *statePtr;
        });
        #ifdef LOG_NIGIRI_STATEMACHINE
        if(stateToStringFunc){
            std::string msg = ""StateMachine - State \"""" + stateToStringFunc(waitState) + ""\"" reached"";
            std::cout << msg << std::endl;
        }
        #endif
    };

    void waitForStates(std::initializer_list<TState> waitStates){
        #ifdef LOG_NIGIRI_STATEMACHINE
        if(stateToStringFunc){
            std::string msg ="" StateMachine - Waiting for "";
            for(auto waitState : waitStates){
                msg += getStateString(waitState) + "" "";
            }
            std::cout << msg << std::endl;
        }
        #endif
        std::unique_lock<std::mutex> lock(mtx);
		bool condition = true;
		while (condition) {
			cv.wait(lock);
			for (auto waitState : waitStates) {
				if (waitState == state) {
					#ifdef LOG_NIGIRI_STATEMACHINE
                    StateValue requiredStateValue = static_cast<StateValue>(waitState);
					StateValue currentStateValue = static_cast<StateValue>(state);
                    std::string msg = ""StateMachine - State check - "";
					msg += ""Required: \"""" + std::to_string(requiredStateValue) + ""\"", Current: \"""" + std::to_string(currentStateValue) + ""\"""";
					std::cout << msg << std::endl;
                    #endif
					condition = false;
				}
			}
		}
        #ifdef LOG_NIGIRI_STATEMACHINE
        if(stateToStringFunc){
            std::string stateString = ""\"""" + stateToStringFunc(state) + ""\"""";
            std::cout << ""StateMachine - State "" << stateString << "" reached"" << std::endl;
        }
        #endif
    };

    void addConnection(TState  [MASK] , TEvent cause, TState toState){
        topology[ [MASK] ][cause] = toState;
    };

    void registerStateToString(StateToStringFunc func) {
        if(func) {
            stateToStringFunc = func;
        }
    }

    void registerEventToString(EventToStringFunc func) {
        if(func) {
            eventToStringFunc = func;
        }
    }

private:
    TState state = initialState;
    std::map<TState,std::map<TEvent,TState>> topology;
    std::mutex mtx;
    std::condition_variable cv;
    StateToStringFunc stateToStringFunc;
    EventToStringFunc eventToStringFunc;

    bool isEventValid(TEvent event) {
        std::string stateString = """";
        if(stateToStringFunc != nullptr){
            stateString = ""\"""" + stateToStringFunc(state) + ""\"""";
        }
        auto fromSearch = topology.find(state);
        if(fromSearch == topology.end()){
            #ifdef LOG_NIGIRI_STATEMACHINE
            std::cout << ""Current state"" << stateString << "" do not have any connections"" << std::endl;
            #endif
            return false;
        }
        auto stateTopology = fromSearch->second;
        auto eventSearch = stateTopology.find(event);
        if(eventSearch == stateTopology.end()) {
            #ifdef LOG_NIGIRI_STATEMACHINE
            if(eventToStringFunc != nullptr){
                std::string eventString = ""\"""" + eventToStringFunc(event) + ""\"""";
                std::cout << ""Current state"" << stateString << "" do not respond to provided event"" << eventString << std::endl;
            }
            #endif
            return false;
        }
        return true;
    }
};

template<typename TState, typename TEvent, TState initialState>
using StateMachine =
      _StateMachine<TState,
                    TEvent,
                    initialState,
                    std::is_enum<TState>::value,
                    std::is_convertible<TState,int>::value,
                    std::is_enum<TEvent>::value,
                    std::is_convertible<TEvent,int>::value>;

}
#endif //NIGIRI_STATEMACHINE_H
",fromState
138,"#include ""accelerometer.h""

Accelerometer::Accelerometer(short x, short y, short z) {
  axis_.x = x;
  axis_.y = y;
  axis_.z = z;
  is_empty_ = false;
}

Accelerometer::Accelerometer(bool is_empty): is_empty_(is_empty) {
  //
}

Accelerometer* Accelerometer::Create(short x, short y, short z) {
  bool are_different = x != y && y != z && x != z;
  bool is_x_pin_valid = x >= 0 && x <= 5;
  bool  [MASK]  = y >= 0 && y <= 5;
  bool is_z_pin_valid = z >= 0 && z <= 5;

  if(are_different && is_x_pin_valid &&  [MASK]  && is_z_pin_valid) {
    return new Accelerometer(x, y, z);
  }
  return new Accelerometer(true);
}

bool Accelerometer::is_empty(void) {
  return is_empty_;
}

short Accelerometer::x() {
  return axis_.x;
}

short Accelerometer::y() {
  return axis_.y;
}

short Accelerometer::z() {
  return axis_.z;
}
",is_y_pin_valid
139,"// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.

#include ""Apartment.h""
#include ""ApartmentHUD.h""
#include ""Engine/Canvas.h""
#include ""TextureResource.h""
#include ""CanvasItem.h""

AApartmentHUD::AApartmentHUD()
{
	// Set the crosshair texture
	static ConstructorHelpers::FObjectFinder<UTexture2D>  [MASK] (TEXT(""/Game/FirstPerson/Textures/FirstPersonCrosshair""));
	CrosshairTex =  [MASK] .Object;
}


void AApartmentHUD::DrawHUD()
{
	Super::DrawHUD();

	// Draw very simple crosshair

	// find center of the Canvas
	const FVector2D Center(Canvas->ClipX * 0.5f, Canvas->ClipY * 0.5f);

	// offset by half the texture's dimensions so that the center of the texture aligns with the center of the Canvas
	const FVector2D CrosshairDrawPosition( (Center.X),
										   (Center.Y + 20.0f));

	// draw the crosshair
	FCanvasTileItem TileItem( CrosshairDrawPosition, CrosshairTex->Resource, FLinearColor::White);
	TileItem.BlendMode = SE_BLEND_Translucent;
	Canvas->DrawItem( TileItem );
}

",CrosshiarTexObj
140,"#include ""fauve.h""
#include ""joueur.h""
#include ""piege.h""
#include ""AireDeJeu.h""
#include ""Afficheur.h""
#include <iostream>
#include <vector>

bool gameOver;
bool menu = true;

void ajoutEdit(AireDeJeu& e, afficheConsole& a)
{
    bool ajouter=true;
    while(ajouter)
    {
        std::string nom;
        std::cout<<""Ecrire ce que vous voulez ajouter: joueur,lion,tigre,piege a pic\n"";
        std::cin>>nom;
        if(nom == ""joueur"")
        {
            int x,y;
            std::cout<<""Donnez sa position: y x\n"";
            std::cin>>y>>x;
            e.setValue(point{x,y},1);
        }
        else if(nom == ""lion"")
        {
            int x,y;
            std::cout<<""Donnez sa position: y puis x\n"";
            std::cin>>y>>x;
            e.setValue(point{x,y},2);
        }
        else if(nom == ""tigre"")
        {
            int x,y;
            std::cout<<""Donnez sa position: y puis x\n"";
            std::cin>>y>>x;
            e.setValue(point{x,y},3);
        }
        else if(nom == ""piege"")
        {
            int x,y;
            std::cout<<""Donnez sa position: y puis x\n"";
            std::cin>>y>>x;
            e.setValue(point{x,y},4);
        }
        else std::cout<<""error"";
        a.afficheAdj(e);
        std::cout<<""Voulez vous continuer d'ajouter des entites? 0.Non 1.Oui\n"";
        std::cin>>ajouter;
    }
}

void creeAdJ()
{
    afficheConsole a;
    int longueur,largeur;
    std::cout<<""Donnez la taille de l'aire de jeu: Longueur Largeur\n"";
    std::cin>>longueur>>largeur;
    AireDeJeu adj(longueur,largeur);
    std::cout<<""0 dans le tableau = case vide\n1 dans le tableau = Joueur\n2 dans le tableau = Lion\n3 dans le tableau = Tigre\n4 dans le tableau = PiegeAPic\n"";
    a.afficheAdj(adj);
    ajoutEdit(adj,a);
    adj.exporter(""export.txt"");
    std::cout<<""Fichier exporte avec succes dans export.txt\n"";
}

void editImport()
{
    afficheConsole a;
    AireDeJeu adj{10,10};
    adj.import(""import.txt"");
    a.afficheAdj(adj);
    ajoutEdit(adj,a);
    adj.exporter(""export.txt"");
    std::cout<<""Fichier exporte avec succes dans export.txt\n"";

}

void exporte()
{
    int choix =0;
    while(choix<1 || choix>3)
    {
        std::cout<<""Saisissez ce que vous voulez faire:\n1. Creer une aire de jeu vierge\n2. Modifier l'aire de jeu importee \n3. Revenir au menu\n"";
        std::cin>>choix;
    }
    switch(choix)
    {
        case 1: creeAdJ();break;  //aleatoireAdJ(e); Idee de type d'aire de jeu
        case 2: editImport();break;
        case 3: break;
    }
}
void jeu(AireDeJeu& adj, afficheConsole& a)
{
    //Init tab joueurs
    std::vector<std::unique_ptr<joueur>> joueurs;
    //Init tab fauves
    std::vector<std::unique_ptr<fauve>> fauves;
    //Init tab pieges
    std::vector<std::unique_ptr<piegeAPic>> pieges;
    adj.applyImport(joueurs,fauves,pieges);

    //boucle de jeu tour par tour
    while (gameOver==false && fauves.empty()==false)
    {
        a.afficheAdj(adj);
        int valeur;
        std::cout<<""envoyez la valeur de deplacement: "";
        std::cin>>valeur;
        for(int i=0;i<joueurs.size();++i)
        {
            joueurs[i]->deplacement(adj,valeur);
        }
        for(int i=0;i<fauves.size();++i)
        {
            if(fauves[i]->estVivant())
            {
                fauves[i]->deplacement(adj,joueurs,fauves,pieges);// on deplace les fauves
                if(joueurs[0]->estVivant()==false)
                {
                    gameOver=true;
                    i=fauves.size();
                }
            }
        }
        for(int i=0;i<pieges.size();++i) //Supprime les pieges inactifs
        {
            if(!pieges[i]->estActif())
            {
                std::swap(pieges[i],pieges[pieges.size()-1]);
                pieges.pop_back();
            }
        }
        for(int i=0;i<joueurs.size();++i)
        {
            std::cout<<""Score du joueur: ""<<joueurs[i]->lifetime()<<'\n';
        }

    }

    std::cout<<""GameOver\nRetour au menu...\n"";
}
void jouer()
{
    gameOver=false;
    //Init afficheur
    afficheConsole a;
    //Init Aire de jeu
    AireDeJeu adj{10,10};
    int  [MASK]  =0;
    while( [MASK] <1 ||  [MASK] >3)
    {
        std::cout<<""Saisissez ce que vous voulez faire:\n1. Aire de jeu aleatoire(not working)\n2. Aire de jeu importee\n3. Revenir au menu\n"";
        std::cin>> [MASK] ;
    }
    switch( [MASK] )
    {
        case 1: std::cout<<""N'existe pas, uniquement une idee pour etoffer le menu\n"";break;  //aleatoireAdJ(e); Idee de type d'aire de jeu
        case 2: adj.import(""import.txt"");jeu(adj,a); break;
        case 3: break;
    }
}

void mainMenu()
{
    while (menu)
    {
        int valeur;
        std::cout<<""Saisissez ce que vous voulez faire:\n1. Jouer\n2. Exporter une Aire de Jeu\n9. Quitter\n"";
        std::cin>>valeur;
        switch(valeur)
        {
            case 1 : jouer(); break;
            case 2 : exporte(); break;
            case 9 : exit(0);
        }
    }
}

int main()
{
    mainMenu();
}
",typeAdJ
141,"#include <iostream>
#include <vector>

using namespace std;

int knapsack(vector<int>& weights, vector<int>& profits, int capacity) {
    int n = weights.size();
    vector<vector<int>> T(n + 1, vector<int>(capacity + 1, 0));

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= capacity; ++j) {
            if (weights[i - 1] <= j) {
                T[i][j] = max(T[i - 1][j], T[i - 1][j - weights[i - 1]] + profits[i - 1]);
            } else {
                T[i][j] = T[i - 1][j];
            }
        }
    }

    return T[n][capacity];
}

int main() {
    int n;
    cout << ""Enter the number of items: "";
    cin >> n;

    vector<int> weights(n);
    vector<int> profits(n);

    cout << ""Enter the weights of items: "";
    for (int i = 0; i < n; ++i) {
        cin >> weights[i];
    }

    cout << ""Enter the profits of items: "";
    for (int i = 0; i < n; ++i) {
        cin >> profits[i];
    }

    int capacity;
    cout << ""Enter the knapsack capacity: "";
    cin >> capacity;

    int  [MASK]  = knapsack(weights, profits, capacity);

    cout << ""Maximum Profit: "" <<  [MASK]  << endl;

    return 0;
}
",result
142,"/*!**************************************************************************
**
** Copyright (C) 2009 TECHNOGERMA Systems France and/or its subsidiary(-ies).
** Contact: Technogerma Systems France Information (<EMAIL>)
**
** This file is part of the GICS library.
**
** Commercial Usage
** Licensees holding valid GICS Commercial licenses may use this file in
** accordance with the GICS Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and TECHNOGERMA Systems France.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL3.txt included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at <EMAIL>.
**
****************************************************************************/

#include <rules/sdlc/std/API_Export.hpp>

namespace rules::sdlc::stdc
{
    template <typename T>
    PimplPtr<T>::PimplPtr()
        : m_data(new T)
    {
    }

    template <typename T>
    PimplPtr<T>::~PimplPtr()
    {

    }

    template <typename T>
    PimplPtr<T>::PimplPtr(T* data)
        : m_data(data)
    {
        assert(data != nullptr);
    }

    template <typename T>
    PimplPtr<T>::PimplPtr(const PimplPtr<T>& copy)
        : m_data(new T(*copy.m_data))
    {
    }

    template <typename T>
    template <typename T1>
    PimplPtr<T>::PimplPtr(T1 arg1)
        : m_data(new T(arg1))
    {
    }

    template <typename T>
    template <typename T1, typename T2>
    PimplPtr<T>::PimplPtr(T1 arg1, T2 arg2)
        : m_data(new T(arg1, arg2))
    {
    }

    template <typename T>
    template <typename T1, typename T2, typename T3>
    PimplPtr<T>::PimplPtr(T1 arg1, T2 arg2, T3  [MASK] )
        : m_data(new T(arg1, arg2,  [MASK] ))
    {
    }

    template <typename T>
    T* PimplPtr<T>::operator->() noexcept
    {
        return (m_data.get());
    }

    template <typename T>
    const T* PimplPtr<T>::operator->() const noexcept
    {
        return (m_data.get());
    }

    template <typename T>
    T& PimplPtr<T>::operator*() noexcept
    {
        return (*m_data);
    }

    template <typename T>
    const T& PimplPtr<T>::operator*() const noexcept
    {
        return (*m_data);
    }

    template <typename T>
    void PimplPtr<T>::swap(PimplPtr<T>& other)
    {
        m_data.swap(other.m_data);
    }
/*
    template <typename T>
    PimplPtr<T>& PimplPtr<T>::operator=(PimplPtr const& rhs)
    {
        PimplPtr<T> tmp(rhs);
        *this = std::move(tmp);
        return (*this);
    }

//    template <typename T>
//    PimplPtr<T>& PimplPtr<T>::operator=(PimplPtr<T>&&) noexcept = default;

    template <typename T>
    template <typename U, typename>
    PimplPtr<T>::PimplPtr(U&& u)
    : m_data(new T{std::forward<U>(u)})
    {
    }

    template <typename T>
    template <typename U1, typename U2, typename ...Args>
    PimplPtr<T>::PimplPtr(U1&& u1, U2&& u2, Args&&... args)
    : m_data(new T{std::forward<U1>(u1),
                 std::forward<U2>(u2),
                 std::forward<Args>(args)...})
    {
    }
*/

}
",arg3
143,"#include <iostream>
#include ""NLPReg.h""

//未在头文件包含
#include ""../../../tensor/function/FHeader.h""

namespace nlpreg
{

	float learningRate = 0.3F;            // learning rate
	int nEpoch = 100;                     // 训练次数
	float minmax = 0.01F;                 // range [-p,p] for parameter initialization

	void Init(NLPRegModel &model);		  //初始化参数
	void InitGrad(NLPRegModel &model, NLPRegModel &grad);	
	void Train(float *trainDataX, float *trainDataY, int dataSize, NLPRegModel &model);
	void Forword(XTensor &input, NLPRegModel &model, NLPRegNet &net);
	void MSELoss(XTensor &output, XTensor &gold, XTensor &loss);
	void Backward(XTensor &input, XTensor &gold, NLPRegModel &model, NLPRegModel &grad, NLPRegNet &net);
	void Update(NLPRegModel &model, NLPRegModel &grad, float learningRate);
	void CleanGrad(NLPRegModel &grad);
	void Test(float *testData, int testDataSize, NLPRegModel &model);


	int NLPRegMain(int argc, const char ** argv)    //项目主函数入口，传入Main.cpp
	{
		NLPRegModel model;
		model.h_size = 4;           // 隐藏层节点个数(宽度？)
		const int dataSize = 16;
		const int testDataSize = 3;
		model.devID = 0;			// -1：运行于cpu  0:0号显卡
		Init(model);				//初始化参数

		/*train Data*/
		float trainDataX[dataSize] = { 51,56.8,58,63,66,69,73,76,81,85,90,94,97,100,103,107 };	//训练集X
		float trainDataY[dataSize] = { 31,34.7,35.6,36.7,39.5,42,42.7,47,49,51,52.5,54,55.7,56,58.8,59.2 };	//训练集Y

		float testDataX[testDataSize] = { 64, 80, 95 };		//测试集

		Train(trainDataX, trainDataY, dataSize, model);		//训练回归模型

		Test(testDataX, testDataSize, model);				//使用模型进行预测
		return 0;
	}

	void Init(NLPRegModel &model)
	{
		InitTensor2D(&model.weight1, 1, model.h_size, X_FLOAT, model.devID);	//初始化模型中的tensor  w1
		InitTensor2D(&model.weight2, model.h_size, 1, X_FLOAT, model.devID);	//初始化模型中的tensor  w2
		InitTensor2D(&model.b, model.h_size, 1, X_FLOAT, model.devID);			//初始化模型中的tensor  b
		model.weight1.SetDataRand(-minmax, minmax);		//设置范围为（-0.01，0.01）
		model.weight2.SetDataRand(-minmax, minmax);
		model.b.SetZeroAll();		//修正值全部初始化为0
		printf(""Initialization  complete.\n"");
	}

	void InitGrad(NLPRegModel &model, NLPRegModel &grad)	//赋值等？
	{
		InitTensor(&grad.weight1, &model.weight1);
		InitTensor(&grad.weight2, &model.weight2);
		InitTensor(&grad.b, &model.b);

		grad.h_size = model.h_size;
		grad.devID = model.devID;
	}

	void Train(float *trainDataX, float *trainDataY, int dataSize, NLPRegModel &model)
	{
		printf(""prepare data for train\n"");
		/*prepare for train*/
		TensorList inputList;
		TensorList goldList;
		for (int i = 0; i < dataSize; ++i)
		{
			XTensor*  inputData = NewTensor2D(1, 1, X_FLOAT, model.devID);	//输入值为一维
			inputData->Set2D(trainDataX[i] / 100, 0, 0);					//除100，我的理解是归一化，使值域保持在0-1之间
			inputList.Add(inputData);		//输入列表加入当前值

			XTensor*  goldData = NewTensor2D(1, 1, X_FLOAT, model.devID);	//房价数据
			goldData->Set2D(trainDataY[i] / 60, 0, 0);						//房价值/60？这里和数据本身相关
			goldList.Add(goldData);			//输入列表加入当前值
		}

		printf(""start train\n"");
		NLPRegNet net;
		NLPRegModel grad;
		InitGrad(model, grad);		//main开始时自定义的模型参数，用model初始化grad
		for (int epochIndex = 0; epochIndex < nEpoch; ++epochIndex)	//循环训练
		{
			printf(""epoch %d\n"", epochIndex);
			float totalLoss = 0;
			if ((epochIndex + 1) % 50 == 0)			//这里对训练次数进行了处理，50次之后学习率除3？
				learningRate /= 3;
			for (int i = 0; i < inputList.count; ++i)	
			{
				XTensor *input = inputList.GetItem(i);
				XTensor *gold = goldList.GetItem(i);
				Forword(*input, model, net);	//正向传播
				//output.Dump(stderr);
				XTensor loss;
				MSELoss(net.output, *gold, loss);	//计算误差
				//loss.Dump(stderr);
				totalLoss += loss.Get1D(0);		//总误差

				Backward(*input, *gold, model, grad, net);	//反馈

				Update(model, grad, learningRate);	

				CleanGrad(grad);	//进行下一次做准备

			}
			printf(""loss %f\n"", totalLoss / inputList.count);
		}
	}
	void Forword(XTensor &input, NLPRegModel &model, NLPRegNet &net)
	{
		net.hidden_state1 = MatrixMul(input, model.weight1);		
		net.hidden_state2 = net.hidden_state1 + model.b;			
		net.hidden_state3 = HardTanH(net.hidden_state2);			
		net.output = MatrixMul(net.hidden_state3, model.weight2);	
	}

	void MSELoss(XTensor &output, XTensor &gold, XTensor &loss)		
	{
		XTensor tmp = output - gold;
		loss = ReduceSum(tmp, 1, 2) / output.dimSize[1];
	}

	void MSELossBackword(XTensor &output, XTensor &gold, XTensor &grad)		
	{
		XTensor tmp = output - gold;
		grad = tmp * 2;
	}

	void Backward(XTensor &input, XTensor &gold, NLPRegModel &model, NLPRegModel &grad, NLPRegNet &net) 
	{
		XTensor  [MASK] ;
		XTensor &dedw2 = grad.weight2;
		XTensor &dedb = grad.b;
		XTensor &dedw1 = grad.weight1;
		MSELossBackword(net.output, gold,  [MASK] );
		MatrixMul(net.hidden_state3, X_TRANS,  [MASK] , X_NOTRANS, dedw2);
		XTensor dedy = MatrixMul( [MASK] , X_NOTRANS, model.weight2, X_TRANS);
		_HardTanHBackward(&net.hidden_state3, &net.hidden_state2, &dedy, &dedb);
		dedw1 = MatrixMul(input, X_NOTRANS, dedb, X_TRANS);
	}

	void Update(NLPRegModel &model, NLPRegModel &grad, float learningRate)    //更新训练模型
	{
		model.weight1 = Sum(model.weight1, grad.weight1, -learningRate);	//上一次的权重加本次训练的权重，最后减掉训练后的学习率
		model.weight2 = Sum(model.weight2, grad.weight2, -learningRate);
		model.b = Sum(model.b, grad.b, -learningRate);
	}

	void CleanGrad(NLPRegModel &grad)	//清空grad的w1，w2和b
	{
		grad.b.SetZeroAll();
		grad.weight1.SetZeroAll();
		grad.weight2.SetZeroAll();
	}

	void Test(float *testData, int testDataSize, NLPRegModel &model)	//使用模型进行预测
	{
		NLPRegNet net;
		XTensor*  inputData = NewTensor2D(1, 1, X_FLOAT, model.devID);
		for (int i = 0; i < testDataSize; ++i)
		{

			inputData->Set2D(testData[i] / 100, 0, 0);

			Forword(*inputData, model, net);
			float ans = net.output.Get2D(0, 0) * 60;
			printf(""%f\n"", ans);
		}

	}
}",lossGrad
144,"// **************************************************
// Copyright (c) 2025, <NAME>
// **************************************************

#include <algorithm>
#include <iostream>
#include <limits>
#include <vector>

#include ""dtypes.h""

namespace cute_kernels {
    template <typename T>
    struct ChunkedArray {
        T* array;
        uint64 num_elements;
    };

    template <typename T>
    std::vector<ChunkedArray<T> > chunk_array(T* x, const uint64& num_elements) {
        const uint64  [MASK]  = (uint64)std::numeric_limits<uint>::max() + 1;
        uint64 start = 0;

        std::vector<ChunkedArray<T> > result;

        // We will ""yield"" chunks of the array, each of size 'chunk_size' or less
        while (start < num_elements) {
            uint64 remaining = num_elements - start;
            uint64 current_chunk_size = std::min(remaining,  [MASK] );

            ChunkedArray<T> chunked_x;
            chunked_x.array = (T*)&x[start];
            chunked_x.num_elements = current_chunk_size;

            result.push_back(chunked_x);
            start += current_chunk_size;
        }

        return result;
    }
}  // namespace cute_kernels
",num_elements_per_chunk
145,"/*
 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
 * 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 <chrono>
#include <ctime>
#include <thread>
#include ""storage_daemon_client.h""
#include ""iservice_registry.h""
#include ""libfscrypt/fscrypt_utils.h""
#include ""storage_service_errno.h""
#include ""storage_service_log.h""
#include ""system_ability_definition.h""
#include ""utils/storage_radar.h""

using namespace OHOS::StorageService;
namespace {
constexpr uint32_t STORAGE_DAEMON_SFIFT = 1;
constexpr uint32_t CHECK_SERVICE_TIMES = 1000;
constexpr uint32_t LOG_CHECK_INTERVAL = 50;
constexpr uint32_t SLEEP_TIME_PRE_CHECK = 20; // 20ms
constexpr uint32_t STORAGE_SERVICE_FLAG = (1 << STORAGE_DAEMON_SFIFT);
constexpr int32_t STORAGE_DAEMON_SAID = OHOS::STORAGE_MANAGER_DAEMON_ID;
}

namespace OHOS {
namespace StorageDaemon {
sptr<IStorageDaemon> StorageDaemonClient::GetStorageDaemonProxy(void)
{
    auto samgr = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    if (samgr == nullptr) {
        LOGE(""samgr empty error"");
        return nullptr;
    }

    sptr<IRemoteObject> object = samgr->GetSystemAbility(OHOS::STORAGE_MANAGER_DAEMON_ID);
    if (object == nullptr) {
        LOGE(""storage daemon client samgr ablity empty error"");
        return nullptr;
    }

    return iface_cast<IStorageDaemon>(object);
}

int32_t StorageDaemonClient::CheckServiceStatus(uint32_t  [MASK] )
{
    LOGW(""CheckServiceStatus start"");

    auto samgr = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    if (samgr == nullptr) {
        LOGW(""samgr is nullptr, retry"");
        for (uint32_t i = 0; i < CHECK_SERVICE_TIMES; i++) {
            samgr = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
            if (samgr != nullptr) {
                break;
            }
            if (i % LOG_CHECK_INTERVAL == 0) {
                LOGW(""check samgr %{public}u times"", i);
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_PRE_CHECK));
        }
        if (samgr == nullptr) {
            LOGE(""samgr is nullptr, retry failed."");
            return E_SA_IS_NULLPTR;
        }
    }

    if ( [MASK]  & STORAGE_SERVICE_FLAG) {
        bool exist = false;
        for (uint32_t i = 0; i < CHECK_SERVICE_TIMES; i++) {
            auto object = samgr->CheckSystemAbility(STORAGE_DAEMON_SAID, exist);
            if (object != nullptr) {
                break;
            }
            if (i % LOG_CHECK_INTERVAL == 0) {
                LOGW(""check storage daemon status %{public}u times"", i);
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_PRE_CHECK));
        }
        if (exist == false) {
            LOGE(""storage daemon service system ability error"");
            return E_SERVICE_IS_NULLPTR;
        }
    }
    LOGW(""CheckServiceStatus end, success"");

    return E_OK;
}

int32_t StorageDaemonClient::PrepareUserDirs(int32_t userId, uint32_t flags)
{
    LOGI(""StorageDaemonClient::PrepareUserDirs, userId:%{public}d, flags:%{public}u"", userId, flags);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        std::string extraData = ""flags="" + std::to_string(flags);
        StorageRadar::ReportUserManager(""PrepareUserDirs::CheckServiceStatus"", userId, status, extraData);
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        std::string extraData = ""flags="" + std::to_string(flags);
        StorageRadar::ReportUserManager(""PrepareUserDirs::GetStorageDaemonProxy"", userId, E_SA_IS_NULLPTR, extraData);
        return E_SA_IS_NULLPTR;
    }
    return client->PrepareUserDirs(userId, flags);
}

int32_t StorageDaemonClient::DestroyUserDirs(int32_t userId, uint32_t flags)
{
    LOGI(""StorageDaemonClient::DestroyUserDirs, userId:%{public}d, flags:%{public}u"", userId, flags);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        std::string extraData = ""flags="" + std::to_string(flags);
        StorageRadar::ReportUserManager(""DestroyUserDirs::CheckServiceStatus"", userId, status, extraData);
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        std::string extraData = ""flags="" + std::to_string(flags);
        StorageRadar::ReportUserManager(""DestroyUserDirs::GetStorageDaemonProxy"", userId, E_SA_IS_NULLPTR, extraData);
        return E_SA_IS_NULLPTR;
    }
    return client->DestroyUserDirs(userId, flags);
}

int32_t StorageDaemonClient::StartUser(int32_t userId)
{
    LOGI(""StorageDaemonClient::StartUser, userId:%{public}d"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        StorageRadar::ReportUserManager(""StartUser::CheckServiceStatus"", userId, status, """");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        StorageRadar::ReportUserManager(""StartUser::GetStorageDaemonProxy"", userId, E_SA_IS_NULLPTR, """");
        return E_SA_IS_NULLPTR;
    }

    return client->StartUser(userId);
}

int32_t StorageDaemonClient::StopUser(int32_t userId)
{
    LOGI(""StorageDaemonClient::StopUser, userId:%{public}d"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        StorageRadar::ReportUserManager(""StartUser::CheckServiceStatus"", userId, status, """");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        StorageRadar::ReportUserManager(""StartUser::GetStorageDaemonProxy"", userId, E_SA_IS_NULLPTR, """");
        return E_SA_IS_NULLPTR;
    }

    return client->StopUser(userId);
}

int32_t StorageDaemonClient::PrepareUserSpace(uint32_t userId, const std::string &volumId, uint32_t flags)
{
    LOGI(""StorageDaemonClient::PrepareUserSpace, userId:%{public}u, volumId:%{public}s, flags:%{publc}u"",
        userId, volumId.c_str(), flags);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->PrepareUserDirs(userId, flags);
}

int32_t StorageDaemonClient::DestroyUserSpace(uint32_t userId, const std::string &volumId, uint32_t flags)
{
    LOGI(""StorageDaemonClient::DestroyUserSpace, userId:%{public}u, volumId:%{public}s, flags:%{publc}u"",
        userId, volumId.c_str(), flags);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->DestroyUserDirs(userId, flags);
}

int32_t StorageDaemonClient::InitGlobalKey(void)
{
    int32_t status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        StorageRadar::ReportUserKeyResult(""InitGlobalKey::CheckServiceStatus"", 0, status, ""EL1"", """");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        StorageRadar::ReportUserKeyResult(""InitGlobalKey::GetStorageDaemonProxy"", 0, E_SA_IS_NULLPTR, ""EL1"", """");
        return E_SA_IS_NULLPTR;
    }

    return client->InitGlobalKey();
}

int32_t StorageDaemonClient::InitGlobalUserKeys(void)
{
    int32_t status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        StorageRadar::ReportUserKeyResult(""InitGlobalUserKeys::CheckServiceStatus"", 0, status, ""EL1"", """");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        StorageRadar::ReportUserKeyResult(""InitGlobalUserKeys::GetStorageDaemonProxy"", 0, E_SA_IS_NULLPTR, ""EL1"", """");
        return E_SA_IS_NULLPTR;
    }

    return client->InitGlobalUserKeys();
}

int32_t StorageDaemonClient::GenerateUserKeys(uint32_t userId, uint32_t flags)
{
    LOGI(""StorageDaemonClient::GenerateUserKeys, userId: %{public}u, flags:%{public}u"", userId, flags);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->GenerateUserKeys(userId, flags);
}

int32_t StorageDaemonClient::DeleteUserKeys(uint32_t userId)
{
    LOGI(""StorageDaemonClient::DeleteUserKeys, userId: %{public}u"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->DeleteUserKeys(userId);
}

int32_t StorageDaemonClient::UpdateUserAuth(uint32_t userId, uint64_t secureUid,
                                            const std::vector<uint8_t> &token,
                                            const std::vector<uint8_t> &oldSecret,
                                            const std::vector<uint8_t> &newSecret)
{
    LOGI(""StorageDaemonClient::UpdateUserAuth, userId: %{public}u, token:%{public}d,""
        ""oldSecret:%{public}d, newSecret:%{public}d"", userId, token.empty(), oldSecret.empty(), newSecret.empty());
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->UpdateUserAuth(userId, secureUid, token, oldSecret, newSecret);
}

int32_t StorageDaemonClient::UpdateUseAuthWithRecoveryKey(const std::vector<uint8_t> &authToken,
                                                          const std::vector<uint8_t> &newSecret,
                                                          uint64_t secureUid,
                                                          uint32_t userId,
                                                          std::vector<std::vector<uint8_t>> &plainText)
{
    LOGI(""StorageDaemonClient::UpdateUseAuthWithRecoveryKey, authToken: %{public}d, newSecret:%{public}d,""
        ""userId:%{public}d"", authToken.empty(), newSecret.empty(), userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->UpdateUseAuthWithRecoveryKey(authToken, newSecret, secureUid, userId, plainText);
}

int32_t StorageDaemonClient::ActiveUserKey(uint32_t userId,
                                           const std::vector<uint8_t> &token,
                                           const std::vector<uint8_t> &secret)
{
    LOGI(""StorageDaemonClient::ActiveUserKey, userId: %{public}u, token:%{public}d, secret:%{public}d"",
        userId, token.empty(), secret.empty());
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->ActiveUserKey(userId, token, secret);
}

int32_t StorageDaemonClient::InactiveUserKey(uint32_t userId)
{
    LOGI(""StorageDaemonClient::InactiveUserKey, userId: %{public}u"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }
    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->InactiveUserKey(userId);
}

int32_t StorageDaemonClient::LockUserScreen(uint32_t userId)
{
    LOGI(""StorageDaemonClient::LockUserScreen, userId: %{public}u"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->LockUserScreen(userId);
}

int32_t StorageDaemonClient::UnlockUserScreen(uint32_t userId, const std::vector<uint8_t> &token,
                                              const std::vector<uint8_t> &secret)
{
    LOGI(""StorageDaemonClient::UnlockUserScreen, userId: %{public}u, token:%{public}d, secret:%{public}d"",
        userId, token.empty(), secret.empty());
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->UnlockUserScreen(userId, token, secret);
}

int32_t StorageDaemonClient::GetLockScreenStatus(uint32_t userId, bool &lockScreenStatus)
{
    LOGI(""StorageDaemonClient::GetLockScreenStatus, userId: %{public}u"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->GetLockScreenStatus(userId, lockScreenStatus);
}

int32_t StorageDaemonClient::UpdateKeyContext(uint32_t userId, bool needRemoveTmpKey)
{
    LOGI(""StorageDaemonClient::UpdateKeyContext, userId: %{public}u"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->UpdateKeyContext(userId, needRemoveTmpKey);
}

int32_t StorageDaemonClient::GenerateAppkey(uint32_t userId, uint32_t hashId, std::string &keyId)
{
    LOGI(""StorageDaemonClient::GenerateAppkey, userId: %{public}u, hashId:%{public}u"", userId, hashId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->GenerateAppkey(userId, hashId, keyId, false);
}

int32_t StorageDaemonClient::DeleteAppkey(uint32_t userId, const std::string keyId)
{
    LOGI(""StorageDaemonClient::DeleteAppkey, userId: %{public}u, keyId:%{public}s"", userId, keyId.c_str());
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->DeleteAppkey(userId, keyId);
}

int32_t StorageDaemonClient::CreateRecoverKey(uint32_t userId,
                                              uint32_t userType,
                                              const std::vector<uint8_t> &token,
                                              const std::vector<uint8_t> &secret)
{
    LOGI(""StorageDaemonClient::CreateRecoverKey, userId: %{public}u, userType:%{public}u,token:%{public}d,""
        ""secret:%{public}d"", userId, userType, token.empty(), secret.empty());
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->CreateRecoverKey(userId, userType, token, secret);
}

int32_t StorageDaemonClient::SetRecoverKey(const std::vector<uint8_t> &key)
{
    LOGI(""StorageDaemonClient::SetRecoverKey, key:%{public}d"", key.empty());
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""get storage daemon service failed"");
        return E_SA_IS_NULLPTR;
    }

    return client->SetRecoverKey(key);
}

int32_t StorageDaemonClient::MountDfsDocs(int32_t userId, const std::string &relativePath,
    const std::string &networkId, const std::string &deviceId)
{
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""Get StorageDaemon service failed!"");
        return E_SA_IS_NULLPTR;
    }

    return client->MountDfsDocs(userId, relativePath, networkId, deviceId);
}

int32_t StorageDaemonClient::UMountDfsDocs(int32_t userId, const std::string &relativePath,
    const std::string &networkId, const std::string &deviceId)
{
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""Get StorageDaemon service failed!"");
        return E_SA_IS_NULLPTR;
    }

    return client->UMountDfsDocs(userId, relativePath, networkId, deviceId);
}

int32_t StorageDaemonClient::FscryptEnable(const std::string &fscryptOptions)
{
#ifdef USER_CRYPTO_MANAGER
    int ret = SetFscryptSysparam(fscryptOptions.c_str());
    if (ret) {
        LOGE(""Init fscrypt policy failed ret %{public}d"", ret);
        return ret;
    }
#endif

    return 0;
}

int32_t StorageDaemonClient::GetFileEncryptStatus(uint32_t userId, bool &isEncrypted, bool needCheckDirMount)
{
    LOGI(""StorageDaemonClient::GetFileEncryptStatus, userId:%{public}d"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""Get StorageDaemon service failed!"");
        return E_SA_IS_NULLPTR;
    }

    return client->GetFileEncryptStatus(userId, isEncrypted, needCheckDirMount);
}

int32_t StorageDaemonClient::GetUserNeedActiveStatus(uint32_t userId, bool &needActive)
{
    LOGI(""StorageDaemonClient::GetUserNeedActiveStatus, userId:%{public}d"", userId);
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }

    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""Get StorageDaemon service failed!"");
        return E_SA_IS_NULLPTR;
    }

    return client->GetUserNeedActiveStatus(userId, needActive);
}

int32_t StorageDaemonClient::MountFileMgrFuse(int32_t userId, const std::string &path, int32_t &fuseFd)
{
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }
    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""Get StorageDaemon service failed!"");
        return E_SA_IS_NULLPTR;
    }
    return client->MountFileMgrFuse(userId, path, fuseFd);
}

int32_t StorageDaemonClient::UMountFileMgrFuse(int32_t userId, const std::string &path)
{
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }
    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""Get StorageDaemon service failed!"");
        return E_SA_IS_NULLPTR;
    }
    return client->UMountFileMgrFuse(userId, path);
}

int32_t StorageDaemonClient::IsFileOccupied(const std::string &path, const std::vector<std::string> &inputList,
    std::vector<std::string> &outputList, bool &isOccupy)
{
    LOGI(""StorageDaemonClient::IsFileOccupied"");
    auto status = CheckServiceStatus(STORAGE_SERVICE_FLAG);
    if (status != E_OK) {
        LOGE(""service check failed"");
        return status;
    }
    sptr<IStorageDaemon> client = GetStorageDaemonProxy();
    if (client == nullptr) {
        LOGE(""Get StorageDaemon service failed!"");
        return E_SA_IS_NULLPTR;
    }
    return client->IsFileOccupied(path, inputList, outputList, isOccupy);
}
} // namespace StorageDaemon
} // namespace OHOS
",serviceFlags
146,"// Copyright 2010-2021 Google LLC
// 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 header provides functions to help creating random instaces of the
// vehicle routing problem; random capacities and random time windows.
#ifndef OR_TOOLS_EXAMPLES_CVRPTW_LIB_H_
#define OR_TOOLS_EXAMPLES_CVRPTW_LIB_H_

#include <memory>
#include <set>

#include ""absl/strings/str_format.h""
#include ""ortools/base/logging.h""
#include ""ortools/base/random.h""
#include ""ortools/constraint_solver/routing.h""

namespace operations_research {

typedef std::function<int64_t(RoutingNodeIndex, RoutingNodeIndex)>
    RoutingNodeEvaluator2;

// Random seed generator.
int32_t GetSeed(bool deterministic);

// Location container, contains positions of orders and can be used to obtain
// Manhattan distances/times between locations.
class LocationContainer {
 public:
  LocationContainer(int64_t speed, bool use_deterministic_seed);
  void AddLocation(int64_t x, int64_t y) { locations_.push_back(Location(x, y)); }
  void AddRandomLocation(int64_t x_max, int64_t y_max);
  void AddRandomLocation(int64_t x_max, int64_t y_max, int duplicates);
  int64_t ManhattanDistance(RoutingIndexManager::NodeIndex from,
                          RoutingIndexManager::NodeIndex to) const;
  int64_t NegManhattanDistance(RoutingIndexManager::NodeIndex from,
                             RoutingIndexManager::NodeIndex to) const;
  int64_t ManhattanTime(RoutingIndexManager::NodeIndex from,
                      RoutingIndexManager::NodeIndex to) const;

  bool SameLocation(RoutingIndexManager::NodeIndex node1,
                    RoutingIndexManager::NodeIndex node2) const;
  int64_t SameLocationFromIndex(int64_t node1, int64_t node2) const;

 private:
  class Location {
   public:
    Location();
    Location(int64_t x, int64_t y);
    int64_t DistanceTo(const Location& location) const;
    bool IsAtSameLocation(const Location& location) const;

   private:
    static int64_t Abs(int64_t value);

    int64_t x_;
    int64_t y_;
  };

  MTRandom randomizer_;
  const int64_t speed_;
  absl::StrongVector<RoutingIndexManager::NodeIndex, Location> locations_;
};

// Random demand.
class RandomDemand {
 public:
  RandomDemand(int size, RoutingIndexManager::NodeIndex depot,
               bool use_deterministic_seed);
  void Initialize();
  int64_t Demand(RoutingIndexManager::NodeIndex from,
               RoutingIndexManager::NodeIndex to) const;

 private:
  std::unique_ptr<int64_t[]> demand_;
  const int size_;
  const RoutingIndexManager::NodeIndex depot_;
  const bool use_deterministic_seed_;
};

// Service time (proportional to demand) + transition time callback.
class ServiceTimePlusTransition {
 public:
  ServiceTimePlusTransition(int64_t time_per_demand_unit,
                            RoutingNodeEvaluator2 demand,
                            RoutingNodeEvaluator2 transition_time);
  int64_t Compute(RoutingIndexManager::NodeIndex from,
                RoutingIndexManager::NodeIndex to) const;

 private:
  const int64_t time_per_demand_unit_;
  RoutingNodeEvaluator2 demand_;
  RoutingNodeEvaluator2 transition_time_;
};

// Stop service time + transition time callback.
class StopServiceTimePlusTransition {
 public:
  StopServiceTimePlusTransition(int64_t stop_time,
                                const LocationContainer& location_container,
                                RoutingNodeEvaluator2 transition_time);
  int64_t Compute(RoutingIndexManager::NodeIndex from,
                RoutingIndexManager::NodeIndex to) const;

 private:
  const int64_t stop_time_;
  const LocationContainer& location_container_;
  RoutingNodeEvaluator2 demand_;
  RoutingNodeEvaluator2 transition_time_;
};

// Route plan displayer.
// TODO(user): Move the display code to the routing library.
void DisplayPlan(
    const operations_research::RoutingIndexManager& manager,
    const operations_research::RoutingModel& routing,
    const operations_research::Assignment& plan, bool use_same_vehicle_costs,
    int64_t max_nodes_per_group, int64_t same_vehicle_cost,
    const operations_research::RoutingDimension& capacity_dimension,
    const operations_research::RoutingDimension& time_dimension);

using NodeIndex = RoutingIndexManager::NodeIndex;

int32_t GetSeed(bool deterministic) {
  if (deterministic) {
    return ACMRandom::DeterministicSeed();
  } else {
    return ACMRandom::HostnamePidTimeSeed();
  }
}

LocationContainer::LocationContainer(int64_t speed, bool use_deterministic_seed)
    : randomizer_(GetSeed(use_deterministic_seed)), speed_(speed) {
  CHECK_LT(0, speed_);
}

void LocationContainer::AddRandomLocation(int64_t x_max, int64_t y_max) {
  AddRandomLocation(x_max, y_max, 1);
}

void LocationContainer::AddRandomLocation(int64_t x_max, int64_t y_max,
                                          int duplicates) {
  const int64_t x = randomizer_.Uniform(x_max + 1);
  const int64_t y = randomizer_.Uniform(y_max + 1);
  for (int i = 0; i < duplicates; ++i) {
    AddLocation(x, y);
  }
}

int64_t LocationContainer::ManhattanDistance(NodeIndex from, NodeIndex to) const {
  return locations_[from].DistanceTo(locations_[to]);
}

int64_t LocationContainer::NegManhattanDistance(NodeIndex from,
                                              NodeIndex to) const {
  return -ManhattanDistance(from, to);
}

int64_t LocationContainer::ManhattanTime(NodeIndex from, NodeIndex to) const {
  return ManhattanDistance(from, to) / speed_;
}

bool LocationContainer::SameLocation(NodeIndex node1, NodeIndex node2) const {
  if (node1 < locations_.size() && node2 < locations_.size()) {
    return locations_[node1].IsAtSameLocation(locations_[node2]);
  }
  return false;
}
int64_t LocationContainer::SameLocationFromIndex(int64_t node1, int64_t node2) const {
  // The direct conversion from constraint model indices to routing model
  // nodes is correct because the depot is node 0.
  // TODO(user): Fetch proper indices from routing model.
  return SameLocation(NodeIndex(node1), NodeIndex(node2));
}

LocationContainer::Location::Location() : x_(0), y_(0) {}

LocationContainer::Location::Location(int64_t x, int64_t y) : x_(x), y_(y) {}

int64_t LocationContainer::Location::DistanceTo(const Location& location) const {
  return Abs(x_ - location.x_) + Abs(y_ - location.y_);
}

bool LocationContainer::Location::IsAtSameLocation(
    const Location& location) const {
  return x_ == location.x_ && y_ == location.y_;
}

int64_t LocationContainer::Location::Abs(int64_t value) {
  return std::max(value, -value);
}

RandomDemand::RandomDemand(int size, NodeIndex depot,
                           bool use_deterministic_seed)
    : size_(size),
      depot_(depot),
      use_deterministic_seed_(use_deterministic_seed) {
  CHECK_LT(0, size_);
}

void RandomDemand::Initialize() {
  const int64_t  [MASK]  = 5;
  const int64_t kDemandMin = 1;
  demand_ = absl::make_unique<int64_t[]>(size_);
  MTRandom randomizer(GetSeed(use_deterministic_seed_));
  for (int order = 0; order < size_; ++order) {
    if (order == depot_) {
      demand_[order] = 0;
    } else {
      demand_[order] =
          kDemandMin + randomizer.Uniform( [MASK]  - kDemandMin + 1);
    }
  }
}

int64_t RandomDemand::Demand(NodeIndex from, NodeIndex /*to*/) const {
  return demand_[from.value()];
}

ServiceTimePlusTransition::ServiceTimePlusTransition(
    int64_t time_per_demand_unit, RoutingNodeEvaluator2 demand,
    RoutingNodeEvaluator2 transition_time)
    : time_per_demand_unit_(time_per_demand_unit),
      demand_(std::move(demand)),
      transition_time_(std::move(transition_time)) {}

int64_t ServiceTimePlusTransition::Compute(NodeIndex from, NodeIndex to) const {
  return time_per_demand_unit_ * demand_(from, to) + transition_time_(from, to);
}

StopServiceTimePlusTransition::StopServiceTimePlusTransition(
    int64_t stop_time, const LocationContainer& location_container,
    RoutingNodeEvaluator2 transition_time)
    : stop_time_(stop_time),
      location_container_(location_container),
      transition_time_(std::move(transition_time)) {}

int64_t StopServiceTimePlusTransition::Compute(NodeIndex from,
                                             NodeIndex to) const {
  return location_container_.SameLocation(from, to)
             ? 0
             : stop_time_ + transition_time_(from, to);
}

void DisplayPlan(
    const RoutingIndexManager& manager, const RoutingModel& routing,
    const operations_research::Assignment& plan, bool use_same_vehicle_costs,
    int64_t max_nodes_per_group, int64_t same_vehicle_cost,
    const operations_research::RoutingDimension& capacity_dimension,
    const operations_research::RoutingDimension& time_dimension) {
  // Display plan cost.
  std::string plan_output = absl::StrFormat(""Cost %d\n"", plan.ObjectiveValue());

  // Display dropped orders.
  std::string dropped;
  for (int64_t order = 0; order < routing.Size(); ++order) {
    if (routing.IsStart(order) || routing.IsEnd(order)) continue;
    if (plan.Value(routing.NextVar(order)) == order) {
      if (dropped.empty()) {
        absl::StrAppendFormat(&dropped, "" %d"",
                              manager.IndexToNode(order).value());
      } else {
        absl::StrAppendFormat(&dropped, "", %d"",
                              manager.IndexToNode(order).value());
      }
    }
  }
  if (!dropped.empty()) {
    plan_output += ""Dropped orders:"" + dropped + ""\n"";
  }

  if (use_same_vehicle_costs) {
    int group_size = 0;
    int64_t group_same_vehicle_cost = 0;
    std::set<int> visited;
    for (int64_t order = 0; order < routing.Size(); ++order) {
      if (routing.IsStart(order) || routing.IsEnd(order)) continue;
      ++group_size;
      visited.insert(plan.Value(routing.VehicleVar(order)));
      if (group_size == max_nodes_per_group) {
        if (visited.size() > 1) {
          group_same_vehicle_cost += (visited.size() - 1) * same_vehicle_cost;
        }
        group_size = 0;
        visited.clear();
      }
    }
    if (visited.size() > 1) {
      group_same_vehicle_cost += (visited.size() - 1) * same_vehicle_cost;
    }
    LOG(INFO) << ""Same vehicle costs: "" << group_same_vehicle_cost;
  }

  // Display actual output for each vehicle.
  for (int route_number = 0; route_number < routing.vehicles();
       ++route_number) {
    int64_t order = routing.Start(route_number);
    absl::StrAppendFormat(&plan_output, ""Route %d: "", route_number);
    if (routing.IsEnd(plan.Value(routing.NextVar(order)))) {
      plan_output += ""Empty\n"";
    } else {
      while (true) {
        operations_research::IntVar* const load_var =
            capacity_dimension.CumulVar(order);
        operations_research::IntVar* const time_var =
            time_dimension.CumulVar(order);
        operations_research::IntVar* const slack_var =
            routing.IsEnd(order) ? nullptr : time_dimension.SlackVar(order);
        if (slack_var != nullptr && plan.Contains(slack_var)) {
          absl::StrAppendFormat(
              &plan_output, ""%d Load(%d) Time(%d, %d) Slack(%d, %d)"",
              manager.IndexToNode(order).value(), plan.Value(load_var),
              plan.Min(time_var), plan.Max(time_var), plan.Min(slack_var),
              plan.Max(slack_var));
        } else {
          absl::StrAppendFormat(&plan_output, ""%d Load(%d) Time(%d, %d)"",
                                manager.IndexToNode(order).value(),
                                plan.Value(load_var), plan.Min(time_var),
                                plan.Max(time_var));
        }
        if (routing.IsEnd(order)) break;
        plan_output += "" -> "";
        order = plan.Value(routing.NextVar(order));
      }
      plan_output += ""\n"";
    }
  }
  LOG(INFO) << plan_output;
}
}  // namespace operations_research

#endif  // OR_TOOLS_EXAMPLES_CVRPTW_LIB_H_
",kDemandMax
147,"//
// Copyright <NAME> (<EMAIL>), <NAME> (<EMAIL>) 2014-2023
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include ""td/telegram/GiveawayParameters.h""

#include ""td/telegram/AccessRights.h""
#include ""td/telegram/ContactsManager.h""
#include ""td/telegram/Dependencies.h""
#include ""td/telegram/DialogId.h""
#include ""td/telegram/Global.h""
#include ""td/telegram/MessagesManager.h""
#include ""td/telegram/OptionManager.h""
#include ""td/telegram/Td.h""

#include ""td/utils/Random.h""

namespace td {

Result<ChannelId> GiveawayParameters::get_boosted_channel_id(Td *td, DialogId dialog_id) {
  if (!td->messages_manager_->have_dialog_force(dialog_id, ""get_boosted_channel_id"")) {
    return Status::Error(400, ""Chat to boost not found"");
  }
  if (dialog_id.get_type() != DialogType::Channel) {
    return Status::Error(400, ""Can't boost the chat"");
  }
  auto channel_id = dialog_id.get_channel_id();
  if (!td->contacts_manager_->is_broadcast_channel(channel_id)) {
    return Status::Error(400, ""Can't boost the group"");
  }
  if (!td->contacts_manager_->get_channel_status(channel_id).can_post_messages()) {
    return Status::Error(400, ""Not enough rights in the chat"");
  }
  return channel_id;
}

Result<GiveawayParameters> GiveawayParameters::get_giveaway_parameters(
    Td *td, const td_api::premiumGiveawayParameters *parameters) {
  if (parameters == nullptr) {
    return Status::Error(400, ""Giveaway parameters must be non-empty"");
  }
  TRY_RESULT(boosted_channel_id, get_boosted_channel_id(td, DialogId(parameters->boosted_chat_id_)));
  vector<ChannelId> additional_channel_ids;
  for (auto additional_chat_id : parameters->additional_chat_ids_) {
    TRY_RESULT(channel_id, get_boosted_channel_id(td, DialogId(additional_chat_id)));
    additional_channel_ids.push_back(channel_id);
  }
  if (static_cast<int64>(additional_channel_ids.size()) >
      td->option_manager_->get_option_integer(""giveaway_additional_chat_count_max"")) {
    return Status::Error(400, ""Too many additional chats specified"");
  }
  if (parameters->winners_selection_date_ < G()->unix_time()) {
    return Status::Error(400, ""Giveaway date is in the past"");
  }
  for (auto &country_code : parameters->country_codes_) {
    if (country_code.size() != 2 || country_code[0] < 'A' || country_code[0] > 'Z') {
      return Status::Error(400, ""Invalid country code specified"");
    }
  }
  if (static_cast<int64>(parameters->country_codes_.size()) >
      td->option_manager_->get_option_integer(""giveaway_country_count_max"")) {
    return Status::Error(400, ""Too many countries specified"");
  }
  return GiveawayParameters(boosted_channel_id, std::move(additional_channel_ids), parameters->only_new_members_,
                            parameters->winners_selection_date_, vector<string>(parameters->country_codes_));
}

vector<ChannelId> GiveawayParameters::get_channel_ids() const {
  auto result = additional_channel_ids_;
  result.push_back(boosted_channel_id_);
  return result;
}

void GiveawayParameters::add_dependencies(Dependencies &dependencies) const {
  dependencies.add_dialog_and_dependencies(DialogId(boosted_channel_id_));
  for (auto channel_id : additional_channel_ids_) {
    dependencies.add_dialog_and_dependencies(DialogId(channel_id));
  }
}

telegram_api::object_ptr<telegram_api::inputStorePaymentPremiumGiveaway>
GiveawayParameters::get_input_store_payment_premium_giveaway(Td *td, const string &currency, int64 amount) const {
  int64 random_id;
  do {
    random_id = Random::secure_int64();
  } while (random_id == 0);

  auto boost_input_peer = td->messages_manager_->get_input_peer(DialogId(boosted_channel_id_), AccessRights::Write);
  CHECK(boost_input_peer != nullptr);

  vector<telegram_api::object_ptr<telegram_api::InputPeer>>  [MASK] ;
  for (auto additional_channel_id : additional_channel_ids_) {
    auto input_peer = td->messages_manager_->get_input_peer(DialogId(additional_channel_id), AccessRights::Write);
    CHECK(input_peer != nullptr);
     [MASK] .push_back(std::move(input_peer));
  }

  int32 flags = 0;
  if (only_new_subscribers_) {
    flags |= telegram_api::inputStorePaymentPremiumGiveaway::ONLY_NEW_SUBSCRIBERS_MASK;
  }
  if (! [MASK] .empty()) {
    flags |= telegram_api::inputStorePaymentPremiumGiveaway::ADDITIONAL_PEERS_MASK;
  }
  if (!country_codes_.empty()) {
    flags |= telegram_api::inputStorePaymentPremiumGiveaway::COUNTRIES_ISO2_MASK;
  }
  return telegram_api::make_object<telegram_api::inputStorePaymentPremiumGiveaway>(
      flags, false /*ignored*/, std::move(boost_input_peer), std::move( [MASK] ),
      vector<string>(country_codes_), random_id, date_, currency, amount);
}

td_api::object_ptr<td_api::premiumGiveawayParameters> GiveawayParameters::get_premium_giveaway_parameters_object(
    Td *td) const {
  CHECK(is_valid());
  vector<int64> chat_ids;
  for (auto channel_id : additional_channel_ids_) {
    DialogId dialog_id(channel_id);
    td->messages_manager_->force_create_dialog(dialog_id, ""premiumGiveawayParameters"", true);
    chat_ids.push_back(td->messages_manager_->get_chat_id_object(dialog_id, ""premiumGiveawayParameters""));
  }
  DialogId dialog_id(boosted_channel_id_);
  td->messages_manager_->force_create_dialog(dialog_id, ""premiumGiveawayParameters"", true);
  return td_api::make_object<td_api::premiumGiveawayParameters>(
      td->messages_manager_->get_chat_id_object(dialog_id, ""premiumGiveawayParameters""), std::move(chat_ids), date_,
      only_new_subscribers_, vector<string>(country_codes_));
}

bool operator==(const GiveawayParameters &lhs, const GiveawayParameters &rhs) {
  return lhs.boosted_channel_id_ == rhs.boosted_channel_id_ &&
         lhs.additional_channel_ids_ == rhs.additional_channel_ids_ &&
         lhs.only_new_subscribers_ == rhs.only_new_subscribers_ && lhs.date_ == rhs.date_ &&
         lhs.country_codes_ == rhs.country_codes_;
}

bool operator!=(const GiveawayParameters &lhs, const GiveawayParameters &rhs) {
  return !(lhs == rhs);
}

StringBuilder &operator<<(StringBuilder &string_builder, const GiveawayParameters &giveaway_parameters) {
  return string_builder << ""Giveaway["" << giveaway_parameters.boosted_channel_id_ << "" + ""
                        << giveaway_parameters.additional_channel_ids_
                        << (giveaway_parameters.only_new_subscribers_ ? "" only for new members"" : """")
                        << "" for countries "" << giveaway_parameters.country_codes_ << "" at ""
                        << giveaway_parameters.date_ << ']';
}

}  // namespace td
",additional_input_peers
148,"/*
author: skottZy
date: 2020/11/23
sumarry: test1.cpp
version: 2020/11/23 v1
*/
#include <iostream>
#include <cmath>
#include <ctime>

using namespace std;

const uint32_t n = 1e8;


uint32_t sum1(uint32_t n){
    uint32_t sum = 0;
    for (uint32_t i = 1; i <= n; i++)
        sum += pow(-1, i);
    return sum;
}

uint32_t sum2(uint32_t n){
    uint32_t sum = 0;
    if (n % 2 == 0)
        sum = 0;
    else
        sum = -1;
    return sum;
}

int main(){

    cout << ""starting..."" << endl;
    time_t startTime, endTime, sumTime;

    // sum1
    startTime = clock();
    uint32_t  [MASK]  = sum1(n);
    cout << ""sum: "" <<  [MASK]  << endl;
    endTime = clock();
    sumTime = endTime - startTime;
    cout << ""time: "" << sumTime / 1000 << ""s"" << endl;

    //sum2
    startTime = clock();
    uint32_t res2 = sum2(n);
    cout << ""sum: "" << res2 << endl;
    endTime = clock();
    sumTime = endTime - startTime;
    cout << ""time: "" << sumTime / 1000 << ""s"" << endl;

    system(""pause"");
    return 0;

}
",res1
149,"/*
 * RC-S620/S sample library for Arduino
 *
 * Copyright 2010 Sony Corporation
 */

#include <stdio.h>
#include <string.h>
#include <inttypes.h>

#include ""RCS620S.h""

/* --------------------------------
 * Constant
 * -------------------------------- */

#define RCS620S_DEFAULT_TIMEOUT  1000

/* --------------------------------
 * Variable
 * -------------------------------- */

/* --------------------------------
 * Prototype Declaration
 * -------------------------------- */

/* --------------------------------
 * Macro
 * -------------------------------- */

/* --------------------------------
 * Function
 * -------------------------------- */

/* ------------------------
 * public
 * ------------------------ */

RCS620S::RCS620S(PinName txd, PinName rxd) :
    _serial_p(new UnbufferedSerial(txd, rxd, 115200)), 
    _serial(*_serial_p)
{
    this->timeout = RCS620S_DEFAULT_TIMEOUT;
}

RCS620S::~RCS620S()
{
    if (NULL != _serial_p)
        delete  _serial_p;
}

int RCS620S::initDevice(void)
{
    int ret;
    uint8_t response[RCS620S_MAX_RW_RESPONSE_LEN];
    uint16_t responseLen;

    /* RFConfiguration (various timings) */
    ret = rwCommand((const uint8_t*)""\xd4\x32\x02\x00\x00\x00"", 6,
                    response, &responseLen);

    if (!ret || (responseLen != 2) ||
        (memcmp(response, ""\xd5\x33"", 2) != 0)) {
        return 0;
    }

    /* RFConfiguration (max retries) */
    ret = rwCommand((const uint8_t*)""\xd4\x32\x05\x00\x00\x00"", 6,
                    response, &responseLen);
    if (!ret || (responseLen != 2) ||
        (memcmp(response, ""\xd5\x33"", 2) != 0)) {
        return 0;
    }

    /* RFConfiguration (additional wait time = 24ms) */
    ret = rwCommand((const uint8_t*)""\xd4\x32\x81\xb7"", 4,
                    response, &responseLen);
    if (!ret || (responseLen != 2) ||
        (memcmp(response, ""\xd5\x33"", 2) != 0)) {
        return 0;
    }

    return 1;
}

int RCS620S::polling(uint16_t systemCode)
{
    int ret;
    uint8_t buf[9];
    uint8_t response[RCS620S_MAX_RW_RESPONSE_LEN];
    uint16_t responseLen;

    /* InListPassiveTarget */
    memcpy(buf, ""\xd4\x4a\x01\x01\x00\xff\xff\x00\x00"", 9);
    buf[6] = (uint8_t)((systemCode >> 8) & 0xff);
    buf[5] = (uint8_t)((systemCode >> 0) & 0xff);

    ret = rwCommand(buf, 9, response, &responseLen);

    if (!ret || (responseLen != 22) ||
        (memcmp(response, ""\xd5\x4b\x01\x01\x12\x01"", 6) != 0)) {
        return 0;
    }

    memcpy(this->idm, response + 6, 8);
    memcpy(this->pmm, response + 14, 8);

    return 1;
}

int RCS620S::cardCommand(
    const uint8_t* command,
    uint8_t commandLen,
    uint8_t response[RCS620S_MAX_CARD_RESPONSE_LEN],
    uint8_t* responseLen)
{
    int ret;
    uint16_t commandTimeout;
    uint8_t buf[RCS620S_MAX_RW_RESPONSE_LEN];
    uint16_t len;

    if (this->timeout >= (0x10000 / 2)) {
        commandTimeout = 0xffff;
    } else {
        commandTimeout = (uint16_t)(this->timeout * 2);
    }

    /* CommunicateThruEX */
    buf[0] = 0xd4;
    buf[1] = 0xa0;
    buf[2] = (uint8_t)((commandTimeout >> 0) & 0xff);
    buf[3] = (uint8_t)((commandTimeout >> 8) & 0xff);
    buf[4] = (uint8_t)(commandLen + 1);
    memcpy(buf + 5, command, commandLen);

    ret = rwCommand(buf, 5 + commandLen, buf, &len);
    if (!ret || (len < 4) ||
        (buf[0] != 0xd5) || (buf[1] != 0xa1) || (buf[2] != 0x00) ||
        (len != (3 + buf[3]))) {
        return 0;
    }

    *responseLen = (uint8_t)(buf[3] - 1);
    memcpy(response, buf + 4, *responseLen);

    return 1;
}

int RCS620S::rfOff(void)
{
    int ret;
    uint8_t response[RCS620S_MAX_RW_RESPONSE_LEN];
    uint16_t responseLen;

    /* RFConfiguration (RF field) */
    ret = rwCommand((const uint8_t*)""\xd4\x32\x01\x00"", 4,
                    response, &responseLen);
    if (!ret || (responseLen != 2) ||
        (memcmp(response, ""\xd5\x33"", 2) != 0)) {
        return 0;
    }

    return 1;
}

int RCS620S::push(
    const uint8_t* data,
    uint8_t dataLen)
{
    int ret;
    uint8_t buf[RCS620S_MAX_CARD_RESPONSE_LEN];
    uint8_t responseLen;

    if (dataLen > 224) {
        return 0;
    }

    /* Push */
    buf[0] = 0xb0;
    memcpy(buf + 1, this->idm, 8);
    buf[9] = dataLen;
    memcpy(buf + 10, data, dataLen);

    ret = cardCommand(buf, 10 + dataLen, buf, &responseLen);
    if (!ret || (responseLen != 10) || (buf[0] != 0xb1) ||
        (memcmp(buf + 1, this->idm, 8) != 0) || (buf[9] != dataLen)) {
        return 0;
    }

    buf[0] = 0xa4;
    memcpy(buf + 1, this->idm, 8);
    buf[9] = 0x00;

    ret = cardCommand(buf, 10, buf, &responseLen);
    if (!ret || (responseLen != 10) || (buf[0] != 0xa5) ||
        (memcmp(buf + 1, this->idm, 8) != 0) || (buf[9] != 0x00)) {
        return 0;
    }

    thread_sleep_for(1000);

    return 1;
}

/* ------------------------
 * private
 * ------------------------ */

int RCS620S::rwCommand(
    const uint8_t* command,
    uint16_t commandLen,
    uint8_t response[RCS620S_MAX_RW_RESPONSE_LEN],
    uint16_t* responseLen)
{
    int ret;
    uint8_t buf[9];

    flushSerial();
    uint8_t dcs = calcDCS(command, commandLen);

    /* transmit the command */
    buf[0] = 0x00;
    buf[1] = 0x00;
    buf[2] = 0xff;
    if (commandLen <= 255) {
        /* normal frame */
        buf[3] = commandLen;
        buf[4] = (uint8_t)-buf[3];
        writeSerial(buf, 5);
    } else {
        /* extended frame */
        buf[3] = 0xff;
        buf[4] = 0xff;
        buf[5] = (uint8_t)((commandLen >> 8) & 0xff);
        buf[6] = (uint8_t)((commandLen >> 0) & 0xff);
        buf[7] = (uint8_t)-(buf[5] + buf[6]);
        writeSerial(buf, 8);
    }
    writeSerial(command, commandLen);
    buf[0] = dcs;
    buf[1] = 0x00;
    writeSerial(buf, 2);

    /* receive an ACK */
    ret = readSerial(buf, 6);
    if (!ret || (memcmp(buf, ""\x00\x00\xff\x00\xff\x00"", 6) != 0)) {
        cancel();
        return 0;
    }

    /* receive a response */
    ret = readSerial(buf, 5);
    if (!ret) {
        cancel();
        return 0;
    } else if  (memcmp(buf, ""\x00\x00\xff"", 3) != 0) {
        return 0;
    }
    if ((buf[3] == 0xff) && (buf[4] == 0xff)) {
        ret = readSerial(buf + 5, 3);
        if (!ret || (((buf[5] + buf[6] + buf[7]) & 0xff) != 0)) {
            return 0;
        }
        *responseLen = (((uint16_t)buf[5] << 8) |
                        ((uint16_t)buf[6] << 0));
    } else {
        if (((buf[3] + buf[4]) & 0xff) != 0) {
            return 0;
        }
        *responseLen = buf[3];
    }
    if (*responseLen > RCS620S_MAX_RW_RESPONSE_LEN) {
        return 0;
    }

    ret = readSerial(response, *responseLen);
    if (!ret) {
        cancel();
        return 0;
    }

    dcs = calcDCS(response, *responseLen);

    ret = readSerial(buf, 2);
    if (!ret || (buf[0] != dcs) || (buf[1] != 0x00)) {
        cancel();
        return 0;
    }

    return 1;
}

void RCS620S::cancel(void)
{
    /* transmit an ACK */
    writeSerial((const uint8_t*)""\x00\x00\xff\x00\xff\x00"", 6);
    thread_sleep_for(1);
    flushSerial();
}

uint8_t RCS620S::calcDCS(
    const uint8_t* data,
    uint16_t len)
{
    uint8_t  [MASK]  = 0;

    for (uint16_t i = 0; i < len; i++) {
         [MASK]  += data[i];
    }

    return (uint8_t)-( [MASK]  & 0xff);
}

void RCS620S::writeSerial(
    const uint8_t* data,
    uint16_t len)
{
    _serial.write(data, len);
}

int RCS620S::readSerial(
    uint8_t* data,
    uint16_t len)
{
    ssize_t recv, nread = 0;
    time_t t0 = time(NULL);

    while (nread < len) {
        if (checkTimeout(t0)) {
            return 0;
        }
        recv = _serial.read(data, len);
        data += recv;
        nread += recv;
    }
    
    return 1;
}

void RCS620S::flushSerial(void)
{
}

int RCS620S::checkTimeout(unsigned long t0)
{
    time_t t = time(NULL);
    if ((t - t0) >= this->timeout) {
        return 1;
    }

    return 0;
}
",sum
150,"#include""DxLib.h""

#include""main.h""

#include""brast.h""

//プレイヤー
int playerbakuImage[BAKU_ANI];	//爆発画像格納用
XY playerbakuPos;	//爆発画像の位置
int playerbakuAni;	//爆発のアニメーション用
bool playerbakuFlag;	//爆発画像の状態

//敵
int enemybakuImage[BAKU_ANI];	//爆発画像格納用
XY enemybakuPos;	//爆発画像の位置
int enemybakuAni;	//爆発のアニメーション用
bool enemybakuFlag;	//爆発画像の状態

void BrastSystemInit(void)
{
	LoadDivGraph(""image/blast.png"", 24, 6, 4, BAKU_SIZE_X, BAKU_SIZE_Y, playerbakuImage);
	LoadDivGraph(""image/blast.png"", 24, 6, 4, BAKU_SIZE_X, BAKU_SIZE_Y, enemybakuImage);
}

void PlayerBrastGameInit(XY  [MASK] )
{
	//プレイヤー
	playerbakuPos.x =  [MASK] .x;
	playerbakuPos.y =  [MASK] .y;
	playerbakuAni = 0;
	playerbakuFlag = false;
}

void EnemyBrastGameInit(void)
{

}

void BrastControl(void)
{
	/*
		// 爆発の表示
		if (bakuFlag == true)
		{
			DrawGraph(bakuPosX, bakuPosY, bakuImage[bakuAni], true);
			bakuAni = bakuAni + 1;
			if (bakuAni >= BAKU_ANI)
			{
				bakuAni = 0;
				bakuFlag = false;
			}
		}

		// 爆発の表示
		if (bakuFlag == true)
		{
			bakuAni = bakuAni + 1;
			DrawGraph(bakuPosX, bakuPosY, bakuImage[bakuAni], true);

			if (bakuAni >= BAKU_ANI)
			{
				bakuAni = 0;
				bakuFlag = false;
			}
		}

		if (!bakuFlag)
		{
			bakuAni = 0;
			bakuPosX = PlayerPosX;
			bakuPosY = PlayerPosY;
		}
	*/
}

void BrastGameDraw(void)
{

}",playerPos
151,"/*
 * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. 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.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the ""license"" file accompanying this file. This file 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 ""SampleApp/KeywordObserver.h""
#include <AIP/AudioInputProcessor.h>
//Mohammad add
#include ""sock.h""
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netdb.h>
#include <thread>
#include <unistd.h>
//const char* books[] = {""War and Peace"",
//                       ""Pride and Prejudice"",
//                       ""The Sound and the Fury""};
//
void report(const char* msg, int terminate) {
  perror(msg);
  if (terminate) exit(-1); /* failure */
}

//Mohammad end

namespace alexaClientSDK {
namespace sampleApp {

capabilityAgents::aip::AudioProvider * static_audioProvider = NULL;
void notify_keyword_detection_over_network(avsCommon::avs::AudioInputStream::Index end_index);
void send_audio_to_SDK2();
void wait_for_start(){
      std::cout<<""wait_for_start [0]\n"";
      while(1){
         while(1){
		if(static_audioProvider == NULL){
		   std::cout<<""static_audioProvider is NULL[1]\n"";
		   break;
		}
		if(*(static_audioProvider->MegaMind_StartRecording) == 1){
		     break;
		}
	 }
	if(static_audioProvider == NULL){
	   std::cout<<""static_audioProvider is NULL[2]\n"";
	   continue;
	}
         *(static_audioProvider->MegaMind_StartRecording)  = 0;
         notify_keyword_detection_over_network(0);
         send_audio_to_SDK2();
         *(static_audioProvider->MegaMind_Allowed) = 1;
         *(static_audioProvider->MegaMind_Desision_Isready)  = 1;
         std::cout<<""should start recording\n""; 
      }
}
KeywordObserver::KeywordObserver(
    std::shared_ptr<defaultClient::DefaultClient> client,
    capabilityAgents::aip::AudioProvider audioProvider,
    std::shared_ptr<esp::ESPDataProviderInterface> espProvider) :
        m_client{client},
        m_audioProvider{audioProvider},
        m_espProvider{espProvider} {
 	static_audioProvider = &m_audioProvider;
        std::cout<<""before run the wait for start thread\n"";
        std::thread th2(wait_for_start);
        th2.detach();

        
}
int continue_to_record;
void wait_for_stop(){
//	int counter = 0;
   int option = 1;
   int fd = socket(AF_INET,     /* network versus AF_LOCAL */
                   SOCK_STREAM, /* reliable, bidirectional: TCP */
                   0);          /* system picks underlying protocol */
   if (fd < 0) report(""socket"", 1); /* terminate */
   setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));
   /* bind the server's local address in memory */
   struct sockaddr_in saddr;
   memset(&saddr, 0, sizeof(saddr));          /* clear the bytes */
   saddr.sin_family = AF_INET;                /* versus AF_LOCAL */
   saddr.sin_addr.s_addr = htonl(INADDR_ANY); /* host-to-network endian */
   saddr.sin_port = htons(PortNumber_stop);        /* for listening */
   if (bind(fd, (struct sockaddr *) &saddr, sizeof(saddr)) < 0)
    report(""bind"", 1); /* terminate */
   /* listen to the socket */
   if (listen(fd, MaxConnects) < 0) /* listen for clients, up to MaxConnects */
   report(""listen"", 1); /* terminate */
      fprintf(stderr, ""Listening on port %i for clients...\n"", PortNumber_stop);
   int client_fd;
   while (1) {
      struct sockaddr_in caddr; /* client address */
      int len = sizeof(caddr);  /* address length could change */
  
      client_fd = accept(fd, (struct sockaddr*) &caddr,(socklen_t*) &len);  /* accept blocks */
      if (client_fd < 0) {
        report(""accept"", 0); /* don't terminated, though there's a problem */
        continue;
      }
      setsockopt(client_fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));
      char buffer[1024];
      int count = read(client_fd, buffer, sizeof(buffer));
      if (count > 0) {
       //write(client_fd, buffer, sizeof(buffer)); /* echo as confirmation */
          std::cout<<count<<"" bytes read , recived to stop recording\n"";
	  continue_to_record --;
          if (continue_to_record ==0){
	     break;
	  }
	  continue;
      }else{
          std::cout<<"" count is negative\n"";
          continue;
      }

      int trueVar = 1;
      setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&trueVar,sizeof(int));
      setsockopt(client_fd,SOL_SOCKET,SO_REUSEADDR,&trueVar,sizeof(int));

      close(fd);
      close(client_fd); /* break connection */
   }  /* while(1) */

   close(fd);
   close(client_fd); /* break connection */
}

void notify_keyword_detection_over_network(avsCommon::avs::AudioInputStream::Index end_index){


    int sockfd = socket(AF_INET,      /* versus AF_LOCAL */
			SOCK_STREAM,  /* reliable, bidirectional */
			0);           /* system picks protocol (TCP) */
    if (sockfd < 0) report(""socket"", 1); /* terminate */
  
    /* get the address of the host */
    struct hostent* hptr = gethostbyname(Host); /* localhost: 127.0.0.1 */
    if (!hptr) report(""gethostbyname"", 1); /* is hptr NULL? */
    if (hptr->h_addrtype != AF_INET)       /* versus AF_LOCAL */
      report(""bad address family"", 1);
  
    /* connect to the server: configure server's address 1st */
    struct sockaddr_in saddr;
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr =
       ((struct in_addr*) hptr->h_addr_list[0])->s_addr;
    saddr.sin_port = htons(PortNumber_start); /* port number in big-endian */
  
    if (connect(sockfd, (struct sockaddr*) &saddr, sizeof(saddr)) < 0)
      report(""connect"", 1);
  
    /* Write some stuff and read the echoes. */
    puts(""Connect to server, about to write some stuff..."");
    uint64_t uend_index = end_index;
   
    if (write(sockfd, &uend_index, sizeof(uend_index)) < 0) {
           std::cout<<""error: could not send the packets\n"";
    }
    close(sockfd); /* close the connection */

}
void send_audio_to_SDK2(){

    int sockfd = socket(AF_INET,      /* versus AF_LOCAL */
			SOCK_STREAM,  /* reliable, bidirectional */
			0);           /* system picks protocol (TCP) */
    if (sockfd < 0) report(""socket"", 1); /* terminate */
  
    /* get the address of the host */
    struct hostent* hptr = gethostbyname(Host); /* localhost: 127.0.0.1 */
    if (!hptr) report(""gethostbyname"", 1); /* is hptr NULL? */
    if (hptr->h_addrtype != AF_INET)       /* versus AF_LOCAL */
      report(""bad address family"", 1);
  
    /* connect to the server: configure server's address 1st */
    struct sockaddr_in saddr;
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr =
       ((struct in_addr*) hptr->h_addr_list[0])->s_addr;
    saddr.sin_port = htons(PortNumber); /* port number in big-endian */
  
    if (connect(sockfd, (struct sockaddr*) &saddr, sizeof(saddr)) < 0)
      report(""connect"", 1);
  
    puts(""Connect to server, about to write some stuff..."");

    std::cout<<""Javad: add all the magic here\n"";
    if(static_audioProvider == NULL){
           std::cout<<""MegaMind: static audio provider is NULL\n"";
    }
    auto my_stream = static_audioProvider->stream;
    auto my_reader = my_stream->createReader(avsCommon::avs::AudioInputStream::Reader::Policy::NONBLOCKING);
    avsCommon::avs::AudioInputStream::Index beginIndex = *(static_audioProvider->MegaMind_begin_index);
    if(beginIndex == capabilityAgents::aip::AudioInputProcessor::INVALID_INDEX){
	beginIndex = my_reader->tell();
    }
    if( !my_reader->seek(beginIndex) ){
	 std::cout<<""Javad: seek failed"";
    }
    int read_words;
    int total_read_words = 0;
    int n_words = 10000;
    int word_size = my_reader->getWordSize();
    int size = n_words * word_size;
    void * buffer; 
    buffer = new char [size];
    std::ofstream oFile;
    oFile.open(""/tmp/oFile.pcm"");
    continue_to_record = 2;
    std::thread th1(wait_for_stop);
    //while(total_read_words < 300000){
    while(continue_to_record>0){
	memset(buffer, 0 , size);
	read_words = my_reader->read(buffer,n_words);
	if( (read_words<0) || (read_words>1000) ){
	    continue;
	}
	 //std::cout<<""read_words: ""<<read_words<<""\t total read words:""<<total_read_words<<""\n"";

	if (write(sockfd, buffer, read_words * word_size) < 0) {
	   std::cout<<""error: could not send the packets\n"";
	}
	oFile.write((char*)buffer,read_words * word_size);
	total_read_words += read_words;
    }	
    th1.join();

}
void KeywordObserver::onKeyWordDetected(
    std::shared_ptr<avsCommon::avs::AudioInputStream> stream,
    std::string keyword,
    avsCommon::avs::AudioInputStream::Index beginIndex,
    avsCommon::avs::AudioInputStream::Index endIndex,
    std::shared_ptr<const std::vector<char>>  [MASK] ) {
    if (endIndex != avsCommon::sdkInterfaces::KeyWordObserverInterface::UNSPECIFIED_INDEX &&
        beginIndex == avsCommon::sdkInterfaces::KeyWordObserverInterface::UNSPECIFIED_INDEX) {
        if (m_client) {
//Mohammad
            /* fd for the socket */
	    std::cout<< "" HEYYYY: \t""<<beginIndex<<""\t\t"" <<endIndex;
            m_client->notifyOfTapToTalk(m_audioProvider, endIndex);
        }
    } else if (
        endIndex != avsCommon::sdkInterfaces::KeyWordObserverInterface::UNSPECIFIED_INDEX &&
        beginIndex != avsCommon::sdkInterfaces::KeyWordObserverInterface::UNSPECIFIED_INDEX) {
        auto espData = capabilityAgents::aip::ESPData::EMPTY_ESP_DATA;
        if (m_espProvider) {
            espData = m_espProvider->getESPData();
        }

        if (m_client) {
            m_client->notifyOfWakeWord(m_audioProvider, beginIndex, endIndex, keyword, espData,  [MASK] );
        }
    }
}

}  // namespace sampleApp
}  // namespace alexaClientSDK
",KWDMetadata
152,"#include ""PixelEngine.h""

void PixelEngine::Reset()
{
  MGravity = 0;
  MBouncefactor = 0;
  MUsedPixels = 0;
  MCollisionDetection = false;
  MScreen.Clear();
}

void PixelEngine::AddPixel(int x, int y, const CRGB& _color, int  [MASK] , int _yspeed)
{
  if ( MUsedPixels < MAX_PIXELS )
  {
    PEPixel& pixel = MPixels[MUsedPixels++];
    pixel.xpos = x << 8;
    pixel.ypos = y << 8;
    pixel.color = _color;
    pixel.xspeed =  [MASK] ;
    pixel.yspeed = _yspeed;
    pixel.move =  [MASK]  != 0 || _yspeed != 0;
  }
}

void PixelEngine::Bounce(int& pos, int& speed)
{
  pos -= speed;
  if ( MBouncefactor )
  {
    if ( speed > 0) { if ( (speed -= MBouncefactor) < 0) speed = 0; }
    else            { if ( (speed += MBouncefactor) > 0) speed = 0; }
  }
  speed = -speed;
  pos += speed;
}

bool PixelEngine::Move(int& pos, int& speed, const int max)
{
  bool bounced = false;
  pos += speed;
  if ( pos < 0x80 || pos > max )
  {
    Bounce(pos, speed);
    bounced = true;
  }
  // Some safety guards.
  if ( pos < 0x80) pos = 0x80;
  if ( pos > max) pos = max;
  return bounced;
}

void PixelEngine::ExecuteStep()
{
  for ( int pixidx = 0; pixidx < MUsedPixels; pixidx++)
  {
    PEPixel& pixel = MPixels[pixidx];
    if ( pixel.move )
    {
      int prevx = pixel.xpos;
      int prevy = pixel.ypos;
      bool xbounced = Move(pixel.xpos, pixel.xspeed, MMaxx);
      bool ybounced = Move(pixel.ypos, pixel.yspeed, MMaxy);
      if ( MCollisionDetection )
      {
        int xpos = pixel.xpos >> 8;
        int ypos = pixel.ypos >> 8;
        prevx >>= 8;
        prevy >>= 8;
        if ( (prevx != xpos || prevy != ypos) && MScreen.Pixel(xpos, ypos))  // collision
        { // Check which movement contributed to the colission.
          if      ( !xbounced && prevy == ypos ) Bounce(pixel.xpos, pixel.xspeed);
          else if ( !ybounced && prevx == xpos ) Bounce(pixel.ypos, pixel.yspeed);
          else
          {
            Bounce(pixel.xpos, pixel.xspeed);
            Bounce(pixel.ypos, pixel.yspeed);
          }
        }
      }
      pixel.yspeed -= MGravity; // We have a simple liniair gravity :-)
    }
  }
}

void PixelEngine::Draw() const
{
  for ( int pixidx = 0; pixidx < MUsedPixels; pixidx++)
  {
    const PEPixel& pixel = MPixels[pixidx];
    // We could support fractions of units and spread them over multiple (max 4?) pixels.
    MScreen.Pixel(pixel.xpos >> 8, pixel.ypos >> 8) = pixel.color;
  }
}
",_xspeed
153,"#define EIGEN_USE_THREADS

#include <limits>
#include ""../util/ctc_ext_beam_search_decoder.h""
#include ""tensorflow/core/framework/op_kernel.h""

namespace tensorflow {

template <typename T>
class CTCExtBeamSearchDecoderOp : public OpKernel {
  public:
    explicit CTCExtBeamSearchDecoderOp(OpKernelConstruction *ctx) : OpKernel(ctx) {
      OP_REQUIRES_OK(ctx, ctx->GetAttr(""merge_repeated"", &merge_repeated_));
      OP_REQUIRES_OK(ctx, ctx->GetAttr(""beam_width"", &beam_width_));
      OP_REQUIRES_OK(ctx, ctx->GetAttr(""blank_index"", &blank_index_));
      OP_REQUIRES_OK(ctx, ctx->GetAttr(""blank_label"", &blank_label_));
      OP_REQUIRES_OK(ctx, ctx->GetAttr(""top_paths"", &top_paths_));
    }

    void Compute(OpKernelContext* ctx) override {
      // Read inputs and allocate outputs
      const Tensor* inputs;
      const Tensor* seq_len;
      OpOutputList dec_indices;
      OpOutputList dec_values;
      OpOutputList dec_shape;
      OpOutputList ali_indices;
      OpOutputList ali_values;
      OpOutputList ali_shape;
      Tensor* log_prob = nullptr;
      OP_REQUIRES_OK(ctx, ValidateInputsGenerateOutputs(ctx, &inputs, &seq_len,
        &log_prob, &dec_indices, &dec_values, &dec_shape,
        &ali_indices, &ali_values, &ali_shape));

      // Save variables as specific types
      auto inputs_t = inputs->tensor<T, 3>();
      auto seq_len_t = seq_len->vec<int32>();
      auto log_prob_t = log_prob->matrix<T>();
      log_prob_t.setZero();

      // Save shape of inputs and specific input dimensions
      const TensorShape& inputs_shape = inputs->shape();
      const int64 max_time = inputs_shape.dim_size(0);
      const int64 batch_size = inputs_shape.dim_size(1);
      const int64 num_classes = inputs_shape.dim_size(2);

      // For every time step, copy elements into input_list_t
      std::vector<typename TTypes<T>::UnalignedConstMatrix> input_list_t;
      for (std::size_t t = 0; t < max_time; ++t) {
        input_list_t.emplace_back(inputs_t.data() + t * batch_size * num_classes,
                                  batch_size, num_classes);
      }

      // The decoder
      ctc::CTCExtBeamSearchDecoder<T> decoder(num_classes, blank_index_,
                                            beam_width_, &beam_scorer_,
                                            blank_label_, 1, merge_repeated_);

      Tensor input_chip(DataTypeToEnum<T>::v(), TensorShape({num_classes}));
      auto input_chip_t = input_chip.flat<T>();

      // Store results
      std::vector<std::vector<std::vector<int>>> best_paths(batch_size);
      std::vector<std::vector<std::vector<int>>> best_alignments(batch_size);
      std::vector<T> log_probs;

      // Iterate over all batch elements
      for (int b = 0; b < batch_size; ++b) {
        auto& best_paths_b = best_paths[b];
        auto& best_alignments_b = best_alignments[b];
        best_paths_b.resize(top_paths_);
        best_alignments_b.resize(top_paths_);
        // Iterate over all time steps
        for (int t = 0; t < seq_len_t(b); ++t) {
          input_chip_t = input_list_t[t].chip(b, 0);
          auto input_bi = Eigen::Map<const Eigen::Array<T, Eigen::Dynamic, 1>>(
            input_chip_t.data(), num_classes);
          decoder.Step(input_bi);
        }
        // Get top paths
        OP_REQUIRES_OK(
          ctx, decoder.TopPaths(top_paths_, &best_paths_b, &best_alignments_b,
                                &log_probs, merge_repeated_));
        // beam search Reset
        decoder.Reset();
        // Copy log probs
        for (int bp = 0; bp < top_paths_; ++bp) {
          log_prob_t(b, bp) = log_probs[bp];
        }
      }
      // Store all decoded sequences
      OP_REQUIRES_OK(ctx, StoreAllDecodedSequences(
        best_paths, best_alignments, &dec_indices, &dec_values, &dec_shape,
        &ali_indices, &ali_values, &ali_shape));
    }

    Status ValidateInputsGenerateOutputs(OpKernelContext *ctx,
      const Tensor** inputs, const Tensor** seq_len, Tensor** log_prob,
      OpOutputList* dec_indices, OpOutputList* dec_values,
      OpOutputList* dec_shape, OpOutputList* ali_indices,
      OpOutputList* ali_values, OpOutputList* ali_shape) const {
      // Fetch inputs from context
      Status status = ctx->input(""inputs"", inputs);
      if (!status.ok()) return status;
      // Fetch sequence length from context
      status = ctx->input(""sequence_length"", seq_len);
      if (!status.ok()) return status;
      // Fetch shape of inputs
      const TensorShape& inputs_shape = (*inputs)->shape();
      // Throw error if input does not have 3 dims
      if (inputs_shape.dims() != 3) {
        return errors::InvalidArgument(""inputs is not a 3-Tensor"");
      }
      // Fetch sizes of individual dimensions
      const int64 max_time = inputs_shape.dim_size(0);
      const int64 batch_size = inputs_shape.dim_size(1);
      // Throw error if max time is 0
      if (max_time == 0) {
        return errors::InvalidArgument(""max_time is 0"");
      }
      // Throw error if sequence length is not a vector
      if (!TensorShapeUtils::IsVector((*seq_len)->shape())) {
        return errors::InvalidArgument(""sequence_length is not a vector"");
      }
      // Throw error if dim of sequence length is not the same as batch size
      if (!(batch_size == (*seq_len)->dim_size(0))) {
        return errors::FailedPrecondition(
            ""len(sequence_length) != batch_size.  "", ""len(sequence_length):  "",
            (*seq_len)->dim_size(0), "" batch_size: "", batch_size);
      }
      // sequence length as int32 vector
      auto seq_len_t = (*seq_len)->vec<int32>();
      // Throw error if sequence length is not always less than max time
      for (int b = 0; b < batch_size; ++b) {
        if (!(seq_len_t(b) <= max_time)) {
          return errors::FailedPrecondition(""sequence_length("", b, "") <= "",
                                            max_time);
        }
      }
      // Allocate log probability output
      Status s = ctx->allocate_output(""log_probability"",
        TensorShape({batch_size, top_paths_}), log_prob);
      if (!s.ok()) return s;
      // Allocate list of outputs for decoded
      s = ctx->output_list(""decoded_indices"", dec_indices);
      if (!s.ok()) return s;
      s = ctx->output_list(""decoded_values"", dec_values);
      if (!s.ok()) return s;
      s = ctx->output_list(""decoded_shape"", dec_shape);
      if (!s.ok()) return s;
      // Allocate list of outputs for alignments
      s = ctx->output_list(""alignment_indices"", ali_indices);
      if (!s.ok()) return s;
      s = ctx->output_list(""alignment_values"", ali_values);
      if (!s.ok()) return s;
      s = ctx->output_list(""alignment_shape"", ali_shape);
      if (!s.ok()) return s;
      // Return OK
      return Status::OK();
    }

    // sequences[b][p][ix] stores decoded value ""ix"" of path ""p"" for batch ""b"".
    Status StoreAllDecodedSequences(
      const std::vector<std::vector<std::vector<int> > >& sequences,
      const std::vector<std::vector<std::vector<int> > >& alignments,
      OpOutputList* dec_indices, OpOutputList* dec_values,
      OpOutputList* dec_shape, OpOutputList* ali_indices,
      OpOutputList* ali_values, OpOutputList* ali_shape) const {

      // Calculate the total number of entries for each path
      const int64 batch_size = sequences.size();
      std::vector<int64> num_entries_dec(top_paths_, 0);
      std::vector<int64>  [MASK] (top_paths_, 0);

      // Calculate num_entries per path
      for (const auto& batch_s : sequences) {
        CHECK_EQ(batch_s.size(), top_paths_);
        for (int p = 0; p < top_paths_; ++p) {
          num_entries_dec[p] += batch_s[p].size();
        }
      }

      // Calculate num_entries per alignment
      for (const auto& batch_s : alignments) {
        CHECK_EQ(batch_s.size(), top_paths_);
        for (int p = 0; p < top_paths_; ++p) {
           [MASK] [p] += batch_s[p].size();
        }
      }

      for (int p = 0; p < top_paths_; ++p) {
        Tensor* p_dec_indices = nullptr;
        Tensor* p_dec_values = nullptr;
        Tensor* p_dec_shape = nullptr;
        Tensor* p_ali_indices = nullptr;
        Tensor* p_ali_values = nullptr;
        Tensor* p_ali_shape = nullptr;

        const int64 p_num_dec = num_entries_dec[p];
        const int64 p_num_ali =  [MASK] [p];

        Status s = dec_indices->allocate(p, TensorShape({p_num_dec, 2}), &p_dec_indices);
        if (!s.ok()) return s;
        s = dec_values->allocate(p, TensorShape({p_num_dec}), &p_dec_values);
        if (!s.ok()) return s;
        s = dec_shape->allocate(p, TensorShape({2}), &p_dec_shape);
        if (!s.ok()) return s;
        s = ali_indices->allocate(p, TensorShape({p_num_ali, 2}), &p_ali_indices);
        if (!s.ok()) return s;
        s = ali_values->allocate(p, TensorShape({p_num_ali}), &p_ali_values);
        if (!s.ok()) return s;
        s = ali_shape->allocate(p, TensorShape({2}), &p_ali_shape);
        if (!s.ok()) return s;

        auto dec_indices_t = p_dec_indices->matrix<int64>();
        auto dec_values_t = p_dec_values->vec<int64>();
        auto dec_shape_t = p_dec_shape->vec<int64>();
        auto ali_indices_t = p_ali_indices->matrix<int64>();
        auto ali_values_t = p_ali_values->vec<int64>();
        auto ali_shape_t = p_ali_shape->vec<int64>();

        int64 max_decoded = 0;
        int64 offset = 0;

        for (int64 b = 0; b < batch_size; ++b) {
          auto& p_batch = sequences[b][p];
          int64 num_decoded = p_batch.size();
          max_decoded = std::max(max_decoded, num_decoded);
          std::copy_n(p_batch.begin(), num_decoded, &dec_values_t(offset));
          for (int64 t = 0; t < num_decoded; ++t, ++offset) {
            dec_indices_t(offset, 0) = b;
            dec_indices_t(offset, 1) = t;
          }
        }

        dec_shape_t(0) = batch_size;
        dec_shape_t(1) = max_decoded;

        max_decoded = 0;
        offset = 0;

        for (int64 b = 0; b < batch_size; ++b) {
          auto& p_batch = alignments[b][p];
          int64 num_decoded = p_batch.size();
          max_decoded = std::max(max_decoded, num_decoded);
          std::copy_n(p_batch.begin(), num_decoded, &ali_values_t(offset));
          for (int64 t = 0; t < num_decoded; ++t, ++offset) {
            ali_indices_t(offset, 0) = b;
            ali_indices_t(offset, 1) = t;
          }
        }

        ali_shape_t(0) = batch_size;
        ali_shape_t(1) = max_decoded;
      }
      return Status::OK();
    }

  private:
    typename ctc::CTCExtBeamSearchDecoder<T>::DefaultBeamScorer beam_scorer_;
    bool merge_repeated_;
    int beam_width_;
    int blank_index_;
    int blank_label_;
    int top_paths_;
    TF_DISALLOW_COPY_AND_ASSIGN(CTCExtBeamSearchDecoderOp);
};

#define REGISTER_CPU(T)                                                       \
REGISTER_KERNEL_BUILDER(                                                      \
      Name(""CTCExtBeamSearchDecoder"").Device(DEVICE_CPU).TypeConstraint<T>(""T""),  \
      CTCExtBeamSearchDecoderOp<T>);

REGISTER_CPU(float);
REGISTER_CPU(double);

#undef REGISTER_CPU

}  // end namespace tensorflow
",num_entries_ali
154,"#include <iostream>
#include <vector>
#include <random>
#include <algorithm>
#include <queue>
#include <limits>

void printVector(std::vector<int> array){
    for (auto v:array){
        std::cout << v << "" "";
    }
    std::cout << std::endl;
}

int next_power_of_two(int v){
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    return v++;
}

long merge_sort_iterative(std::vector<int> array){

    long inversions = 0;

    int  [MASK]  = next_power_of_two(array.size());

    std::queue<std::vector<int>> queue;
    for (auto value:array){
        queue.push(std::vector<int>{ value });
    }
    for (int i = array.size(); i <=  [MASK] ; i++){
        queue.push(std::vector<int>{ std::numeric_limits<int>::max() });
    }
    while (queue.size() > 1){
        auto first = queue.front();
        queue.pop();
        auto second = queue.front();
        queue.pop();

        std::cout << ""first: "";
        printVector(first);
        std::cout << ""second: "";
        printVector(second);

        int i = 0, j = 0, totalSize = first.size() + second.size();
        std::vector<int> sorted;
        int current;
        long currentInversions = 0;
        while (i < first.size() && j < second.size()){
            if (first[i] <= second[j]){
                current = first[i++];
            } else {
                current = second[j++];
                currentInversions += (first.size() - i);
            }
            sorted.push_back(current);

        }

        while (i < first.size()) {
            sorted.push_back(first[i++]);
        }

        while (j < second.size()) {
            sorted.push_back(second[j++]);
        }
        queue.push(sorted);
        std::cout << ""inversions: "" << currentInversions << std::endl;
        std::cout << ""sorted: "";
        printVector(sorted);
        inversions += currentInversions;
    }
    std::cout << ""inversions: "" << inversions << std::endl;
    std::cout << ""sorted: "";
    printVector(queue.front());
    return inversions;

}


int main() {

//    std::vector<int> array = {7, 6, 5, 4, 3, 2, 1 };
//    int n = array.size();
      int n;
      std::cin >> n;
      std::vector<int> array;
      for (int i = 0; i < n; i++){
            int element = 0; //dis(gen);
            std::cin >> element;
            array.push_back(element);
      }
      long inversionsCount = merge_sort_iterative(array);
      std::cout << inversionsCount << std::endl;
      return 0;
//        int n = 100000;
//        std::vector<int> array;
//        std::random_device rd;  //Will be used to obtain a seed for the random number engine
//        std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
//    std::uniform_int_distribution<> dis(1, 1000000000);
//          for (int i = 0; i < n; i++){
//            int element = dis(gen);
//            array.push_back(element);
//      }
//      long inversionsCount = merge_sort_iterative(array);
//      std::cout << inversionsCount << std::endl;
//      return 0;


}",sizeModified
155,"/***************************************************
 Library for SensorBoard

 Feel free to use the code as it is.

 <NAME>, <EMAIL>
 Embedded Systems
 University of Freiburg, Institute of Computer Science
 ****************************************************/

#include ""SensorBoard.h""

SensorBoard::SensorBoard(Stream * getter, 
        float tempHysteresis, float humHysteresis, int lightHysteresis, float minLEDWatt, float maxLEDWatt,
        // void (*loadStoreFunc)(bool store, uint8_t *data, size_t size), 
        void (*logFunc)(const char * msg, ...)
      ):
  updatePattern{NULL, &updateBlinkPattern, &updateRoundPattern, &updateGlowPattern, &updateActivePowerPattern},
  patternUpdateTimes{0, BLINK_STEP, ROUND_STEP, GLOW_STEP, ACTIVE_POWER_UPDATE}
{
  _getter = getter;
  buttonCB = NULL;
  PIRCB = NULL;
  lightCB = NULL;
  humCB = NULL;
  tempCB = NULL;
  fadeUpdate = false;
  preSet = false;

  _tempHysteresis = tempHysteresis;
  _humHysteresis = humHysteresis;
  _lightHysteresis = lightHysteresis;
  config.minLEDWatt = minLEDWatt;
  config.maxLEDWatt = maxLEDWatt;

  _logFunc = logFunc;
  // _loadStoreFunc = loadStoreFunc;

  // Current pattern
  mainColor = CRGB{255,0,0};
  bgColor = CRGB{0,0,0};
  currentPattern = LEDPattern::staticPattern;
  patternTimer = millis();
  patternState = INIT_PATTERN;

  // Old pattern that can be restored
  oldMainColor = CRGB{255,0,0};
  oldBGColor = CRGB{0,0,0};
  oldPattern = LEDPattern::numberOfPatterns;

  patternDuration = -1;
  patternStartMillis = millis();
}

static bool valueValid(float value, float min, float max) {
  if (isnan(value) || value < min || value > max) return false;
  return true;
}

bool SensorBoard::init() {
  // Note that config must be set prior to calling this function
  // check if values make sense
  if (!valueValid(this->config.brightness,    0,   100.0)) this->config.brightness = 50.0;
  if (!valueValid(this->config.humOffset,  -100,   100.0)) this->config.humOffset  = 0.0;
  if (!valueValid(this->config.lightCal,      0,   100.0)) this->config.lightCal   = 1.0;
  if (!valueValid(this->config.maxLEDWatt,    0, 10000.0)) this->config.maxLEDWatt = 200.0;
  if (!valueValid(this->config.minLEDWatt,    0, 10000.0)) this->config.minLEDWatt = 2.0;
  if (!valueValid(this->config.tempOffset,  -20,   200.0)) this->config.tempOffset = 0.0;

  // Send ? and wait for answer
  _getter->println(""??"");
  // if (_loadStoreFunc) _loadStoreFunc(false, (uint8_t*)&config, sizeof(config));
  handle(1000);
  return this->active;
}

enum NEW_SENSOR_VALUE SensorBoard::handle(int timeout) {
  NEW_SENSOR_VALUE avail = NEW_SENSOR_VALUE::NONE;
  if (timeout > 0) {
    long start = millis();
    while (millis() - start < timeout) {
      if (_getter->available()) break;
    }
  }
  // if not a valid message
  if (!(_getter->available())) return avail;
  // Allow all data to be sent
  delay(10);
  // read first char
  char c = _getter->read();
  // If it is not a !, return
  if (c != '!') return avail;
  // Parse data
  c = _getter->read();
  if (_logFunc) _logFunc(""Sensor cmd %c"", c);

  switch (c) {
    case 'b': {
      avail = NEW_SENSOR_VALUE::NEW_BTN;
      BUTTON_PRESS presses = BUTTON_PRESS::PRESS;
      // Optional single press, double press, long press etc.
      if (_getter->available()) {
        char e = _getter->read();
        if (e > '0' && e > '9') {
          presses = (BUTTON_PRESS)(e - '0');
        }
      }
      if (buttonCB) buttonCB(presses);
      break;
    }
    case 'r': {
      if (buttonCB) buttonCB(BUTTON_PRESS::RELEASE);
      break;
    }
    case 't': {
      float temp = parse<float>()+config.tempOffset;
      if (abs(temp-this->temperature) > _tempHysteresis) {
        avail = NEW_SENSOR_VALUE::NEW_TEMP;
        this->temperature = temp;
        if (tempCB) tempCB(this->temperature);
      }
      break;
    }
    case 'h': {
      float hum = parse<float>()+config.humOffset;
      if (this->humidity > 100) this->humidity = 100;
      else if (this->humidity < 0) this->humidity = 0;
      if (abs(hum-this->humidity) > _humHysteresis) {
        avail = NEW_SENSOR_VALUE::NEW_HUM;
        this->humidity = hum;
        if (humCB) humCB(this->humidity);
      }
      break;
    }
    case 'l': {
      int lig = (int)((float)(parse<int32_t>())*config.lightCal);
      if (abs(lig-this->light) > _lightHysteresis) {
        avail = NEW_SENSOR_VALUE::NEW_LIGHT;
        this->light = lig;
        if (lightCB) lightCB(this->light);
      }
      break;
    }
    case 'p': {
      bool pir = (uint8_t)_getter->read();
      if (pir != this->PIR) {
        avail = NEW_SENSOR_VALUE::NEW_PIR;
        this->PIR = pir;
        if (PIRCB) PIRCB(this->PIR);
      }
      break;
    }
    case '!': {
      avail = NEW_SENSOR_VALUE::ACTIVE;
      this->active = true;
      break;
    }
    // Invalid data
    default:
      avail = NEW_SENSOR_VALUE::UNKNOWN;
      break;
  }
  // Flush until newline
  if (_getter->available()) _getter->readStringUntil('\n');
  return avail;
}

void SensorBoard::setAutoSensorMode(bool on) {
  if (on) _getter->println(""!a"");
  else _getter->println(""!o"");
  this->autoMode = on;
}

bool SensorBoard::updateSensors(bool wait) {
  bool success = true;
  success &= updateLight(wait);
  success &= updateTemp(wait);
  success &= updateHum(wait);
  success &= updatePIR(wait);
  return success;
}

bool SensorBoard::updateLight(bool wait) {
  _getter->println(""?l"");
  if (wait) return handle(SENSOR_WAIT_TIME) == NEW_SENSOR_VALUE::NEW_LIGHT;
  else return true;
}

bool SensorBoard::updateTemp(bool wait) {
  _getter->println(""?t"");
  if (wait) return handle(SENSOR_WAIT_TIME) == NEW_SENSOR_VALUE::NEW_TEMP;
  else return true;
}

bool SensorBoard::updateHum(bool wait) {
  _getter->println(""?h"");
  if (wait) return handle(SENSOR_WAIT_TIME) == NEW_SENSOR_VALUE::NEW_HUM;
  else return true;
}

bool SensorBoard::updatePIR(bool wait) {
  _getter->println(""?p"");
  if (wait) return handle(SENSOR_WAIT_TIME) == NEW_SENSOR_VALUE::NEW_PIR;
  else return true;
}

void SensorBoard::update() {
  // Handle incoming data
  if (_getter->available()) handle();
  // Update leds
  updateLEDPattern();
}

// _____________________________________LED Stuff__________________________________________________
void SensorBoard::setBrightness(float brightness) {
  int bright = brightness/100.0*255;
  if (bright > 255) bright = 255;
  if (bright < 0) bright = 0;
  _getter->print(""!b"");
  _getter->write((uint8_t)bright);
  _getter->println();
  config.brightness = brightness;
}

void SensorBoard::powerToLEDs(float power) {
  int normalizes = (int)power;
  if (normalizes < 0) normalizes = 0;
  // Power goes from 0 - 3600 max but we say that even 200 Watt is bad and 
  // keep a linear mapping
  else if (normalizes > config.maxLEDWatt) normalizes = config.maxLEDWatt;
  
  uint8_t red = map(normalizes, 0, config.maxLEDWatt, 0, 255);
  uint8_t green = 255 - red;
  if (normalizes < config.minLEDWatt) {
    red = 0; 
    green = 0;
  }
  CRGB c = CRGB{red, green, 0};
  for (int i = 0; i < NUM_LEDS; i++) {
    LED[i] = c;
  }
  // updateLEDs();
}

void SensorBoard::setRainbow(long duration) {
  LED[2] = COLOR_RED;
  LED[0] = COLOR_GREEN;
  LED[1] = COLOR_BLUE;
  // Make sure timing and saving is done
  newLEDPattern(LEDPattern::staticPattern, duration, COLOR_BLACK, COLOR_BLACK);
  updateLEDs();
}

void SensorBoard::setDots(int dots, CRGB color, CRGB bgColor, long duration) {
  for (int i = 0; i < NUM_LEDS; i++) {
    // its that, because the Layout is
    //                                               TOP
    //                                  ______________________________
    //                                 |            ______________   |
    //                                 |    BTN    |LED2 LED0 LED1|  |
    //                                 |           |______________|  |
    //                                 |               ________      |
    //                                 |    PIR       |        |     |
    //                                 |              |  DHT   |     |
    //                                 |   Light      |________|     |
    //                       LEFT      |                             |     RIGHT
    //                                 |                             |
    //                                 |                             |
    //                                 |            _____            |
    //                                 |                             |
    //                                 |       ( O    0    O )       |
    //                                 |                             |
    //                                 |            -----            |
    //                                 |                             |
    //                                 |_____________________________|
    //                                             BOTTOM
    if (i < dots) LED[(i+2)%NUM_LEDS] = color;
    else LED[(i+2)%NUM_LEDS] = bgColor;
  }
  // Make sure timing and saving is done
  newLEDPattern(LEDPattern::staticPattern, duration, color, bgColor);
  updateLEDs();
}

void SensorBoard::setDots(int dots, CRGB color, long duration) {
  setDots(dots, color, COLOR_BLACK, duration);
}

void SensorBoard::setIndividualColors(CRGB *colors, size_t n, bool fade, long duration) {
  for (int i=0; i<NUM_LEDS; i++) {
    if (i >= n) break;
    LED[i] = colors[i];
  }
  fadeUpdate = fade;
  // Make sure timing and saving is done
  newLEDPattern(LEDPattern::staticPattern, duration, COLOR_BLACK, COLOR_BLACK);
  updateLEDs();
}

void SensorBoard::setColor(CRGB color, bool fade) {
  setColor(color, -1, fade);
}

void SensorBoard::setColor(CRGB color, int duration) {
  setColor(color, (long)duration, false);
}

void SensorBoard::setColor(CRGB color, long duration) {
  setColor(color, duration, false);
}

void SensorBoard::setColor(CRGB color, long duration, bool fade) {
  fadeUpdate = fade;
  allLEDs(color);
  // Make sure timing and saving is done
  newLEDPattern(LEDPattern::staticPattern, duration, color, COLOR_BLACK);
  updateLEDs();
}

void SensorBoard::displayPowerColor(long duration) {
  newLEDPattern(LEDPattern::activePowerPattern, duration, COLOR_BLACK, COLOR_BLACK);
}

void SensorBoard::glow(CRGB color, CRGB bgColor, long duration) {
  newLEDPattern(LEDPattern::glowPattern, duration, color, bgColor);
}

void SensorBoard::glow(CRGB color, long duration) {
  newLEDPattern(LEDPattern::glowPattern, duration, color, COLOR_BLACK);
}

void SensorBoard::blink(CRGB color, CRGB bgColor, long duration) {
  newLEDPattern(LEDPattern::blinkPattern, duration, color, bgColor);
}

void SensorBoard::blink(CRGB color, long duration) {
  newLEDPattern(LEDPattern::blinkPattern, duration, color, COLOR_BLACK);
}

void SensorBoard::allLEDs(CRGB c) {
  for (int i = 0; i < NUM_LEDS; i++) LED[i] = c;
}

void SensorBoard::setAllLEDs(CRGB c) {
  allLEDs(c);
  updateLEDs();
}

void SensorBoard::newLEDPattern(LEDPattern pattern, long duration, CRGB  [MASK] , CRGB theBGColor) {
  // Save old/current pattern if new duration is not infty and current duration is infty
  if (patternDuration == -1 and duration != -1) {
    saveOldPattern();
  }
  // Set new pattern variables
  patternDuration = duration;
  currentPattern = pattern;
  mainColor =  [MASK] ;
  bgColor = theBGColor;
  // Patern should init
  patternState = INIT_PATTERN;
  patternStartMillis = millis();
  // Update pattern once
  patternTimer = millis();
  updateLEDPattern();
}

void SensorBoard::saveOldPattern() {
  oldBGColor = bgColor;
  oldMainColor = mainColor;
  oldPattern = currentPattern;
}

void SensorBoard::restoreOldPattern() {
  bgColor = oldBGColor;
  mainColor = oldMainColor;
  currentPattern = oldPattern;
  // This is not nice but may be not necessary
  patternState = INIT_PATTERN;
  // Static pattern needs dedicated update
  if (oldPattern == LEDPattern::staticPattern) {
    setAllLEDs(mainColor);
  }
  patternTimer = millis();
}

void SensorBoard::updateLEDs() {
  _getter->print(""!L"");
  for (int l = 0; l < NUM_LEDS; l++) {
    for (int c = 0; c < 3; c++) _getter->write(LED[l].raw[c]);
  }
  if (fadeUpdate) {
    fadeUpdate = false;
    _getter->print(""f"");
  }
  _getter->println();
}


void SensorBoard::updateGlowPattern(SensorBoard* obj) {
  // on -1 init the glow pattern with black LEDs
  if (obj->patternState == INIT_PATTERN) {
    obj->allLEDs(CRGB{0,0,0});
    obj->patternState = GLOW_UP;
  }
  // Glow to main color here
  else if (obj->patternState == GLOW_UP) {
    obj->fadeUpdate = true;
    obj->fadeTowardColor(obj->mainColor, 8);
  }
  // Glow to bg color here
  else if (obj->patternState == GLOW_DOWN) {
    obj->fadeUpdate = true;
    obj->fadeTowardColor(obj->bgColor, 8);
  }
  // Check if mainColor is reached then glow back two background color
  if (obj->LED[0] == obj->mainColor) obj->patternState = GLOW_DOWN;
  else if (obj->LED[0] == obj->bgColor) obj->patternState = GLOW_UP;
}

void SensorBoard::updateBlinkPattern(SensorBoard* obj) {
  // On init start with black color
  CRGB color = CRGB{0,0,0};
  if (obj->patternState == INIT_PATTERN) obj->patternState = BLINK_ONE;
  // Foreground color is first state
  else if (obj->patternState == BLINK_ONE) {
    color = obj->mainColor;
    obj->patternState = BLINK_TWO;
  }
  // Background color is second state
  else if (obj->patternState == BLINK_TWO) {
    color = obj->bgColor;
    obj->patternState = BLINK_ONE;
  }
  obj->allLEDs(color);
}

void SensorBoard::updateActivePowerPattern(SensorBoard* obj) {
  if (obj->activePowerGetter) {
    float power = obj->activePowerGetter();
    obj->powerToLEDs(power);
    obj->fadeUpdate = true;
  }
  obj->patternState++;
}

void SensorBoard::updateRoundPattern(SensorBoard* obj) {
  // On init set all colors to bg color
  if (obj->patternState == INIT_PATTERN) {
    obj->allLEDs(obj->bgColor);
  } else {
    obj->allLEDs(obj->bgColor);
    if (obj->patternState >= 0 && obj->patternState < NUM_LEDS) obj->LED[obj->patternState] = obj->mainColor;
  }
  obj->patternState++;
  if (obj->patternState == NUM_LEDS) obj->patternState = 0;
}

void SensorBoard::updateLEDPattern() {
  // Check if old pattern needs to be restored
  if (patternDuration != -1) {
    if (millis()-patternStartMillis > patternDuration) {
      restoreOldPattern();
      patternStartMillis = millis();
      patternDuration = -1;
      if (_logFunc) {
        _logFunc(""Reset old pattern: %i, state: %i"", (int)currentPattern, patternState);
      }
    
    }
  }
  // precent overflow
  if (currentPattern >= LEDPattern::numberOfPatterns) return;
  // Static pattern already updated
  if (currentPattern == LEDPattern::staticPattern) return;
  // if pattern with no update time are specified only inititalize
  if (patternUpdateTimes[(int)currentPattern] == 0 && patternState != INIT_PATTERN) return;
  // Return if update time not reached or not inited yet
  if (patternState != INIT_PATTERN && millis() - patternTimer < patternUpdateTimes[(int)currentPattern]) return;
  // Handle the current pattern
  updatePattern[(int)currentPattern](this);
  // Update the timer and the leds
  if (_logFunc) _logFunc(""Pattern updated"");
  patternTimer = millis();
  updateLEDs();
}

void SensorBoard::nblendU8TowardU8(uint8_t& cur, const uint8_t target, uint8_t amount) {
  if(cur == target) return;
  if(cur < target) {
    uint8_t delta = target - cur;
    delta = (((int)delta * (int)amount) >> 8) + ((delta&&amount)?1:0);
    // if (delta > amount) delta = amount;
    cur += delta;
  } else {
    uint8_t delta = cur - target;
    delta = (((int)delta * (int)amount) >> 8) + ((delta&&amount)?1:0);
    // if (delta > amount) delta = amount;
    cur -= delta;
  }
}

void SensorBoard::fadeTowardColor(const CRGB& bgColor, uint8_t fadeAmount) {
  for(int i = 0; i < NUM_LEDS; i++) {
    nblendU8TowardU8(LED[i].red,   bgColor.red,   fadeAmount);
    nblendU8TowardU8(LED[i].green, bgColor.green, fadeAmount);
    nblendU8TowardU8(LED[i].blue,  bgColor.blue,  fadeAmount);
  }
}

template < typename TOut >
// TODO Test this!
TOut SensorBoard::parse() {
  TOut value;
  if (_getter->available() > sizeof(TOut)-1) {
    uint8_t bytes[sizeof(TOut)] = {};
    for (int i = 0; i < sizeof(TOut); i++) {
      bytes[i] = _getter->read();
    }
    memcpy(&value, &bytes[0], sizeof(value));
  }
  return value; 
}
",theFGColor
156,"/*
 * Copyright <NAME>. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */
#ifndef ALDDB_H
#define ALDDB_H

#include <map>
#include <memory>
#include <string>

#include <nlohmann/json.hpp>

#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentials.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/utils/Outcome.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/GetItemRequest.h>
#include <aws/dynamodb/model/QueryRequest.h>
#include <aws/dynamodb/model/QueryResult.h>
#include <aws/dynamodb/model/PutItemRequest.h>
#include <aws/dynamodb/model/PutItemResult.h>
#include <aws/dynamodb/model/UpdateItemRequest.h>
#include <aws/dynamodb/model/UpdateItemResult.h>
#include <aws/dynamodb/model/DeleteItemResult.h>
#include <aws/dynamodb/model/DeleteItemRequest.h>
#include <aws/dynamodb/model/ScanRequest.h>
#include <aws/dynamodb/model/ScanResult.h>

namespace alddb {
	class DynamoDB {
	public:

		struct PrimaryKey {
		public:

			PrimaryKey(const nlohmann::json& keys) {
				add_key_json(keys);
			}

			PrimaryKey(const std::string& k1_name, const std::string& k1_value) {
				add_key_string(k1_name.c_str(), k1_value.c_str());
			}

			PrimaryKey(const std::string& k1_name, const std::string& k1_value, const std::string& k2_name, const std::string& k2_value) {
				add_key_string(k1_name.c_str(), k1_value.c_str());
				add_key_string(k2_name.c_str(), k2_value.c_str());
			}

			void add_key_string(Aws::String keyname, Aws::String keyvalue) {
				Aws::DynamoDB::Model::AttributeValue value;
				value.SetS(keyvalue);
				pk.push_back(std::pair<Aws::String, Aws::DynamoDB::Model::AttributeValue>(keyname, value));
			}

			void add_key_json(const nlohmann::json& keys) {
				for (const auto& key : keys.items()) {
					Aws::DynamoDB::Model::AttributeValue value;
					value.SetS(key.value());
					pk.push_back(std::pair<Aws::String, Aws::DynamoDB::Model::AttributeValue>(key.key().c_str(), value));
				}
			}

			template<typename Number>
			void add_key_numer(Aws::String keyname, Number keyvalue) {
				Aws::DynamoDB::Model::AttributeValue value;
				value.SetN(keyvalue);
				pk.push_back(std::pair<Aws::String, Aws::DynamoDB::Model::AttributeValue>(keyname, value));
			}

		private:
			std::vector<std::pair<Aws::String, Aws::DynamoDB::Model::AttributeValue>> pk;

			void set_keys(Aws::DynamoDB::Model::GetItemRequest& req) {
				for (const auto& key : pk) {
					req.AddKey(key.first, key.second);
				}
			}

			void set_keys(Aws::DynamoDB::Model::UpdateItemRequest& req) {
				for (const auto& key : pk) {
					req.AddKey(key.first, key.second);
				}
			}

			void set_keys(Aws::DynamoDB::Model::DeleteItemRequest& req) {
				for (const auto& key : pk) {
					req.AddKey(key.first, key.second);
				}
			}

			friend DynamoDB;
		};


		// Basic Operations
		static inline void get_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, 
			const Aws::String& table_name,
			PrimaryKey& primary_key,
			nlohmann::json& result_out);
				
		static inline bool update_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, 
			const nlohmann::json& request,
			const std::string& table,
			PrimaryKey& primary_key);

		static inline bool delete_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, 
			const Aws::String& table_name,
			PrimaryKey& primary_key);

		// Put(update) item
		static inline bool put_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, 
			const nlohmann::json& request,
			const std::string& table);

		// Queries
		static inline void query_with_expression(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, 
			const Aws::String& table_name,
			const Aws::String& key_name,
			const Aws::String& expression,
			const nlohmann::json& expression_values,
			const Aws::String& projection,
			nlohmann::json& result_out);

		// Scan
		// Rarely, if ever, used.
		static inline void scan_table_items_dynamo(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, 
			const Aws::String& table_name, 
			nlohmann::json& result_out);


		// Make default client
		// This will load configuration files from the saved profile
		// Same as the ones used by the AWS CLI
		static inline std::unique_ptr<Aws::DynamoDB::DynamoDBClient> make_default_client();

	private:
		static inline void parse_collection(const Aws::Vector<Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue>>& dynamo_result, nlohmann::json& json_out);
		static inline void parse_object(const Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue>& dynamo_result, nlohmann::json& json_out);
		static inline nlohmann::json parse_type(Aws::DynamoDB::Model::AttributeValue attr);
		static inline void compose_type(Aws::DynamoDB::Model::AttributeValue& attr, const nlohmann::json& json);
		static inline void compose_object(Aws::DynamoDB::Model::AttributeValue& attr, const nlohmann::json& json);
		static inline Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> build_operation_values(const nlohmann::json& json);
		static inline Aws::String build_operation_expression(const nlohmann::json& json, const std::string& operation);

		friend PrimaryKey;
	};
}

// utilities
std::unique_ptr<Aws::DynamoDB::DynamoDBClient> alddb::DynamoDB::make_default_client() {
	Aws::Client::ClientConfiguration clientConfig;
	auto cli =
		std::make_unique<Aws::DynamoDB::DynamoDBClient>(clientConfig);
	return cli;
}

Aws::String alddb::DynamoDB::build_operation_expression(const nlohmann::json& json, const std::string& operation) {
	std::stringstream ss;
	ss << operation << "" "";
	for (const auto& item : json.items()) {
		ss << item.key() << "" = :"" << item.key() << "", "";
	}
	Aws::String expr = ss.str().c_str();
	expr.pop_back();
	expr.pop_back();
	return expr;
}

Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> alddb::DynamoDB::build_operation_values(const nlohmann::json& json) {
	Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> object;
	for (const auto& item : json.items()) {
		std::pair<Aws::String, Aws::DynamoDB::Model::AttributeValue> pair;

		Aws::DynamoDB::Model::AttributeValue temp_attr;

		Aws::String p1 = "":"";
		Aws::String p2 = item.key().c_str();

		pair.first = p1 + p2;
		compose_type(temp_attr, item.value());
		pair.second = temp_attr;

		object.insert(pair);
	}
	return object;
}


// type parsing
void alddb::DynamoDB::compose_object(Aws::DynamoDB::Model::AttributeValue& attr, const nlohmann::json& json) {
	Aws::Map<Aws::String, const std::shared_ptr<Aws::DynamoDB::Model::AttributeValue>> object;
	for (const auto& item : json.items()) {
		std::pair<Aws::String, std::shared_ptr<Aws::DynamoDB::Model::AttributeValue>> pair;

		Aws::DynamoDB::Model::AttributeValue temp_attr;

		pair.first = item.key().c_str();
		compose_type(temp_attr, item.value());
		pair.second = Aws::MakeShared<Aws::DynamoDB::Model::AttributeValue>("""", temp_attr);

		object.insert(pair);
	}
	attr.SetM(object);
}

void alddb::DynamoDB::parse_object(const Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue>& dynamo_result, nlohmann::json& json_out) {
	for (const auto& element : dynamo_result) {
		json_out[element.first.c_str()] = parse_type(element.second);
	}
}

nlohmann::json alddb::DynamoDB::parse_type(Aws::DynamoDB::Model::AttributeValue attr) {
	if (attr.GetType() == Aws::DynamoDB::Model::ValueType::STRING) {
		return attr.GetS();
	} else if (attr.GetType() == Aws::DynamoDB::Model::ValueType::NUMBER) {
		return attr.GetN();
	} else if (attr.GetType() == Aws::DynamoDB::Model::ValueType::BOOL) {
		return attr.GetBool();
	} else if (attr.GetType() == Aws::DynamoDB::Model::ValueType::ATTRIBUTE_MAP) {
		nlohmann::json json;
		auto type = attr.GetM();
		for (const auto& element : type) {
			json[element.first.c_str()] = parse_type(*element.second);
		}
		return json;
	} else if (attr.GetType() == Aws::DynamoDB::Model::ValueType::ATTRIBUTE_LIST) {
		nlohmann::json json = nlohmann::json::array();
		auto type = attr.GetL();
		for (const auto& element : type) {
			nlohmann::json obj = parse_type(*element);
			json.push_back(obj);
		}
		return json;
	} else if (attr.GetType() == Aws::DynamoDB::Model::ValueType::NULLVALUE) {
		return nullptr;
	} else {
		return nullptr;
	}
}

void alddb::DynamoDB::compose_type(Aws::DynamoDB::Model::AttributeValue& attr, const nlohmann::json& json) {
	for (const auto& item : json.items()) {
		if (item.value().is_number_integer()) {
			attr.SetN(std::to_string(item.value().get<long>()).c_str());
		} else if (item.value().is_number_float()) {
			attr.SetN(item.value().get<double>());
		} else if (item.value().is_string()) {
			attr.SetS(item.value().get<std::string>().c_str());
		} else if (item.value().is_boolean()) {
			attr.SetBool(item.value().get<bool>());
		} else if (item.value().is_array()) {
			Aws::Vector< std::shared_ptr<Aws::DynamoDB::Model::AttributeValue>> array;

			for (const auto& array_object : item.value().items()) {
				Aws::DynamoDB::Model::AttributeValue temp_attr;
				compose_object(temp_attr, array_object.value());
				array.push_back(Aws::MakeShared<Aws::DynamoDB::Model::AttributeValue>("""", temp_attr));
			}
			attr.SetL(array);
		} else if (item.value().is_object()) {
			Aws::Map<Aws::String, const std::shared_ptr<Aws::DynamoDB::Model::AttributeValue>> object;
			for (const auto& nested_item : item.value().items()) {
				std::pair<Aws::String, std::shared_ptr<Aws::DynamoDB::Model::AttributeValue>> pair;

				Aws::DynamoDB::Model::AttributeValue temp_attr;

				pair.first = nested_item.key().c_str();
				compose_type(temp_attr, nested_item.value());
				pair.second = Aws::MakeShared<Aws::DynamoDB::Model::AttributeValue>("""", temp_attr);

				object.insert(pair);
			}
			attr.SetM(object);
		} else if (item.value().is_null()) {
			attr.SetNull(true);
		}
	}
}

void alddb::DynamoDB::parse_collection(const Aws::Vector<Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue>>& dynamo_result, nlohmann::json& json_out) {
	json_out = nlohmann::json::array();
	for (const auto& object : dynamo_result) {
		nlohmann::json obj;
		parse_object(object, obj);
		json_out.push_back(obj);
	}
}


// Operations with a composite key
void alddb::DynamoDB::get_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, const Aws::String& table_name, PrimaryKey& primary_key, nlohmann::json& result_out) {
	Aws::DynamoDB::Model::GetItemRequest req;

	// Set up the request
	req.SetTableName(table_name); // table name

	// Setup the composite key for the GetItemRequest
	primary_key.set_keys(req);

	// Retrieve the item's fields and values
	const Aws::DynamoDB::Model::GetItemOutcome& result = client->GetItem(req);
	if (result.IsSuccess()) {
		parse_object(result.GetResult().GetItem(), result_out);
	} else {
		std::cout << ""Failed to get item: "" << result.GetError().GetMessage() << std::endl;
	}
}

bool alddb::DynamoDB::update_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, const nlohmann::json& request, const std::string& table, PrimaryKey& primary_key) {
	// Define TableName argument
	Aws::DynamoDB::Model::UpdateItemRequest uir;
	uir.SetTableName(table.c_str());

	primary_key.set_keys(uir);

	// set expression for SET
	uir.SetUpdateExpression(build_operation_expression(request, ""SET""));

	// Construct attribute value argument
	uir.SetExpressionAttributeValues(build_operation_values(request));

	// Update the item
	const Aws::DynamoDB::Model::UpdateItemOutcome& result = client->UpdateItem(uir);
	if (!result.IsSuccess()) {
		std::cout << result.GetError().GetMessage() << std::endl;
		return false;
	}

	return true;
}

bool alddb::DynamoDB::delete_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, const Aws::String& table_name, PrimaryKey& primary_key) {
	Aws::DynamoDB::Model::DeleteItemRequest req;

	primary_key.set_keys(req);

	// Set table name
	req.SetTableName(table_name);

	const Aws::DynamoDB::Model::DeleteItemOutcome& result = client->DeleteItem(req);
	if (result.IsSuccess()) {
		return true;
	} else {
		std::cout << ""Failed to delete item: "" << result.GetError().GetMessage();
		return false;
	}
}


// Put Item
bool alddb::DynamoDB::put_item(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, const nlohmann::json& request, const std::string& table) {
	Aws::DynamoDB::Model::PutItemRequest pir;
	pir.SetTableName(table.c_str());

	// Add body
	for (const auto& element : request.items()) {
		Aws::DynamoDB::Model::AttributeValue attribute_value;
		compose_type(attribute_value, element.value());
		pir.AddItem(element.key().c_str(), attribute_value);
	}

	const Aws::DynamoDB::Model::PutItemOutcome  [MASK]  = client->PutItem(pir);
	if (! [MASK] .IsSuccess()) {
		std::cout <<  [MASK] .GetError().GetMessage() << std::endl;
		return false;
	}
	return true;
}


// Query
void alddb::DynamoDB::query_with_expression(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, 
	const Aws::String& table_name,
	const Aws::String& key_name,
	const Aws::String& expression,
	const nlohmann::json& expression_values,
	const Aws::String& projection,
	nlohmann::json& result_out) {

	Aws::DynamoDB::Model::QueryRequest query_request;
	query_request.SetTableName(table_name);
	if (!key_name.empty()) {
		query_request.SetIndexName(key_name);
	}

	if (!projection.empty()) {
		query_request.SetProjectionExpression(projection);
	}

	query_request.SetKeyConditionExpression(expression);
	query_request.SetExpressionAttributeValues(build_operation_values(expression_values));

	// run the query
	const Aws::DynamoDB::Model::QueryOutcome& result = client->Query(query_request);
	if (!result.IsSuccess()) {
		std::cout << result.GetError().GetMessage() << std::endl;
	}

	alddb::DynamoDB::parse_collection(result.GetResult().GetItems(), result_out);
}


// Scan
// Not really recommended since the Adjecency Lists pattern(for which this library is designed)
// stores all records in a single table this will will return a huge resultset.
void alddb::DynamoDB::scan_table_items_dynamo(std::unique_ptr<Aws::DynamoDB::DynamoDBClient> client, const Aws::String& table_name, nlohmann::json& result_out) {

	Aws::DynamoDB::Model::ScanRequest scan_request;
	scan_request.SetTableName(table_name);

	// run the scan
	const Aws::DynamoDB::Model::ScanOutcome& result = client->Scan(scan_request);
	if (!result.IsSuccess()) {
		std::cout << result.GetError().GetMessage() << std::endl;
	}

	DynamoDB::parse_collection(result.GetResult().GetItems(), result_out);
}

#endif",outcome
157,"#include <iostream>
#include <libfp/retry_me.h>

bool func_success() {
    return true;
}

bool func_fail() {
    return false;
}

int32_t ok() {
    return 0;
}

int32_t not_ok() {
    return 1;
}

int main() {
    libfp::RetryMe retry;

    bool suceeded = retry.ExpectTrue(func_success);
    std::cout << ""func_success result="" << suceeded << std::endl;

    bool failed = retry.ExpectTrue(func_fail);
    std::cout << ""func_fail result="" << failed << std::endl;

    bool lambda_succeed = retry.ExpectTrue([]() { return 2 == 2; });
    std::cout << ""lambda_success result="" << lambda_succeed << std::endl;

    bool  [MASK]  = retry.ExpectTrue([]() { return 2 != 2; });
    std::cout << ""lambda_fail result="" <<  [MASK]  << std::endl;

    bool ok_result = retry.ExpectZero(ok);
    std::cout << ""ok_result="" << ok_result << std::endl;

    bool not_ok_result = retry.ExpectZero(not_ok);
    std::cout << ""not_ok_result="" << not_ok_result << std::endl;
    return 0;
}
",lambda_failed
158,"#include <memory>
#include <chrono>

#include ""rclcpp/rclcpp.hpp""
#include ""keyboard_teleop/KeyboardTeleop.hpp""

using namespace std::chrono_literals;
using std::placeholders::_1;

KeyboardTeleop::KeyboardTeleop() : Node(""keyboard_teleop"")
{
  RCLCPP_INFO(this->get_logger(), ""Keyboard Teleop node initialized"");
  
  _vel_publisher = this->create_publisher<geometry_msgs::msg::Twist>(""/cmd_vel"", 10);
  _keys_subscriber = this->create_subscription<keyboard_interface::msg::Keys>(""/keys"", 10,
                           std::bind(&KeyboardTeleop::keysCallback, this, _1));
  _key_event_subscriber = this->create_subscription<keyboard_interface::msg::KeyEvent>(""/key_event"", 10,
                           std::bind(&KeyboardTeleop::keyEventCallback, this, _1));

  _timer = this->create_wall_timer( 50ms, std::bind(&KeyboardTeleop::publishVelocity, this) );

  _move_forward             = this->declare_parameter<std::string>(""move_forward_key"",             ""W"");
  _move_backward            = this->declare_parameter<std::string>(""move_backward_key"",            ""S"");
  _move_left                = this->declare_parameter<std::string>(""move_left_key"",                ""A"");
  _move_right               = this->declare_parameter<std::string>(""move_right_key"",               ""D"");
  _rotate_clockwise         = this->declare_parameter<std::string>(""rotate_clockwise_key"",         ""E"");
  _rotate_counter_clockwise = this->declare_parameter<std::string>(""rotate_counter_clockwise_key"", ""Q"");
  _turbo                    = this->declare_parameter<std::string>(""turbo_key"",                    ""KEY.SHIFT"");
  _slow                     = this->declare_parameter<std::string>(""slow_key"",                     ""KEY.ALT"");
  _increase_linear          = this->declare_parameter<std::string>(""increase_linear_key"",          ""KEY.UP"");
  _decrease_linear          = this->declare_parameter<std::string>(""decrease_linear_key"",          ""KEY.DOWN"");
  _increase_angular         = this->declare_parameter<std::string>(""increase_angular_key"",         ""KEY.RIGHT"");
  _decrease_angular         = this->declare_parameter<std::string>(""decrease_angular_key"",         ""KEY.LEFT"");
  _scale_linear             = this->declare_parameter<double>(""scale_linear"",  1.0);
  _scale_angular            = this->declare_parameter<double>(""scale_angular"", 1.0);

  _k_lin = 0.5;
  _k_ang = 0.5;

  std::string msg = 
    ""\n\nReading from the keyboard  and Publishing to Twist!\n""
    ""---------------------------\n""
    ""Moving around:\n""
    ""   q  w  e\n""
    "" a    s    d\n""
    ""left Shift : 100% of max speed\n""
    ""left Alt : 25% of max speed\n""
    ""right/left arrows : increase/decrease linear speed by 10%\n""
    ""up/down arrows : increase/decrease linear speed by 10%\n""
    ""CTRL-C to exit\n"";

  RCLCPP_INFO(this->get_logger(), ""%s"", msg.c_str());

}

KeyboardTeleop::~KeyboardTeleop()
{
}

void KeyboardTeleop::keysCallback(const keyboard_interface::msg::Keys::SharedPtr msg)
{
  double vel_lin_x = 0.0;
  double vel_lin_y = 0.0;
  double vel_ang_z = 0.0;
  bool turbo_pressed = false;
  bool  [MASK]  = false;
  
  for(auto key : msg->pressed_keys)
  {
    if (key.c_str() == _move_forward)                  vel_lin_x += _scale_linear;
    else if (key.c_str() == _move_backward)            vel_lin_x -= _scale_linear;
    else if (key.c_str() == _move_left)                vel_lin_y += _scale_linear;
    else if (key.c_str() == _move_right)               vel_lin_y -= _scale_linear;
    else if (key.c_str() == _rotate_clockwise)         vel_ang_z -= _scale_angular;
    else if (key.c_str() == _rotate_counter_clockwise) vel_ang_z += _scale_angular;
    else if (key.c_str() == _turbo)                    turbo_pressed = true;
    else if (key.c_str() == _slow)                      [MASK]   = true;
  }

  if (turbo_pressed && ! [MASK] )
  {
    _twist.linear.x  = vel_lin_x;
    _twist.linear.y  = vel_lin_y;
    _twist.angular.z = vel_ang_z;
  }

  else if ( [MASK]  && !turbo_pressed)
  {
    _twist.linear.x  = 0.25*vel_lin_x;
    _twist.linear.y  = 0.25*vel_lin_y;
    _twist.angular.z = 0.25*vel_ang_z;
  }

  else
  {
    _twist.linear.x  = _k_lin*vel_lin_x;
    _twist.linear.y  = _k_lin*vel_lin_y;
    _twist.angular.z = _k_ang*vel_ang_z;
  }

}

void KeyboardTeleop::keyEventCallback(const keyboard_interface::msg::KeyEvent::SharedPtr msg)
{
  bool print_info = true;

  if (msg->key.c_str() == _increase_linear && !msg->event)
    _k_lin = std::min(_scale_linear, 1.1*_k_lin);
  else if (msg->key.c_str() == _decrease_linear && !msg->event)
    _k_lin = std::max(0.1*_scale_linear, 0.9*_k_lin);
  else if (msg->key.c_str() == _increase_angular && !msg->event)
    _k_ang = std::min(_scale_angular, 1.1*_k_ang);
  else if (msg->key.c_str() == _decrease_angular && !msg->event)
    _k_ang = std::max(0.1*_scale_angular, 0.9*_k_ang);
  else
    print_info = false;

  if (print_info)
    RCLCPP_INFO(this->get_logger(), ""Set linear velocity to %.2f and angular velocity to %.2f."", _k_lin, _k_ang);
}

void KeyboardTeleop::publishVelocity()
{
  _vel_publisher->publish(_twist);
}


int main(int argc, char **argv)
{
  rclcpp::init(argc, argv);
  rclcpp::spin(std::make_shared<KeyboardTeleop>());
  rclcpp::shutdown();
  return 0;
}
",slow_pressed
159,"#include ""VRT.h""
#include ""3rd/glew-2.1.0/GL/glew.h""
#include <iostream>
#define INTENSITY 0.05

const float vertices[] = {
        -1.0,-1.0,0.0,
        1.0,-1.0,0.0,
        1.0,1.0,0.0,
        -1.0,1.0,0.0,
};

const UInt indices[] = {
    0,1,2,
    0,2,3
};

UInt imageSize[] = { 3, 3, 3 };

float imageData[3][3][3] = {
    {{INTENSITY, 0.0, INTENSITY}, {INTENSITY, 0.0, INTENSITY}, {INTENSITY, 0.0, INTENSITY}},
    {{0.0, 0.0, 0.0}, {0.0, INTENSITY, 0.0}, {0.0, 0.0, 0.0}},
    {{INTENSITY, 0.0, INTENSITY}, {0.0, 0.0, 0.0}, {INTENSITY, 0.0, INTENSITY}}
};
VRT::~VRT()
{
    Finish();
}

void VRT::Init()
{
	InitShape();
    InitTexture();
    InitShader();
    InitRenderTarget();
    glViewport(0, 0, m_iTargetSize[0], m_iTargetSize[1]);
}
void VRT::Render()
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glUseProgram(m_iShader);
    glBindTextureUnit(0, m_iVolume);
	glBindVertexArray(m_iVAO);
	glDrawElements(GL_TRIANGLES, sizeof(indices), GL_UNSIGNED_INT, 0);
}
void VRT::RenderToTarget(float* _pData, UInt _x, UInt _y)
{
    if (_x > m_iTargetSize[0] && _y > m_iTargetSize[1])
    {
        _pData = nullptr;
        return;
    }
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_iFBO);
    Render();
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);

    glBindFramebuffer(GL_READ_FRAMEBUFFER, m_iFBO);
    glReadBuffer(GL_COLOR_ATTACHMENT0);
    glReadPixels(0, 0, m_iTargetSize[0], m_iTargetSize[1], GL_RED, GL_FLOAT, _pData);
    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
}
void VRT::Finish()
{
    glDeleteBuffers(1, &m_iVBO);
    glDeleteBuffers(1, &m_iEBO);
    glDeleteVertexArrays(1, &m_iVAO);

    glDeleteProgram(m_iShader);

    glDeleteFramebuffers(1, &m_iFBO);
    glDeleteRenderbuffers(2, m_iRBOs);
}
void VRT::GetTargetSize(UInt& x, UInt& y)
{
    x = m_iTargetSize[0];
    y = m_iTargetSize[1];
}
void VRT::InitShape()
{
    //OpenGL 4.5 and above
	glCreateBuffers(1, &m_iVBO);
	glNamedBufferData(m_iVBO, sizeof(vertices), vertices, GL_STATIC_DRAW);

	glCreateBuffers(1, &m_iEBO);
	glNamedBufferData(m_iEBO, sizeof(indices), indices, GL_STATIC_DRAW);

	glCreateVertexArrays(1, &m_iVAO);
	
	glVertexArrayElementBuffer(m_iVAO, m_iEBO);

    UInt vaoBindingIndex = 0;
    glVertexArrayVertexBuffer(m_iVAO, vaoBindingIndex, m_iVBO, 0, 3 * sizeof(float));
    UInt  [MASK]  = 0;
    glVertexArrayAttribBinding(m_iVAO,  [MASK] , vaoBindingIndex);
    glVertexArrayAttribFormat(m_iVAO,  [MASK] , 3, GL_FLOAT, GL_FALSE, 0);
    glEnableVertexArrayAttrib(m_iVAO,  [MASK] );

    //OpenGL 4.4 and below
    /*glGenVertexArrays(1, &m_iVAO);
    glGenBuffers(1, &m_iVBO);
    glGenBuffers(1, &m_iEBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(m_iVAO);

    glBindBuffer(GL_ARRAY_BUFFER, m_iVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iEBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);*/
}
void VRT::InitShader()
{
	const char* vertexShaderSource = 
        ""#version 460 core                                         \n""
        ""layout(location = 0) in vec3 aPos;                        \n""
        ""out vec2 texCoord;                                        \n""
        ""void main()                                               \n""
        ""{                                                         \n""
        ""    texCoord = vec2(aPos.x + 1.0, aPos.y + 1.0) * 0.5;    \n""
        ""    gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);      \n""
        ""}\n\0"";
	const char* fragmentShaderSource = 
        ""#version 460 core                                    \n""
        ""#define RAY_STEP 10                                  \n""
        ""uniform sampler3D volume;                            \n""
        ""in vec2 texCoord;                                    \n""
        ""out vec4 FragColor;                                  \n""
                                                              
        ""void main()                                          \n""
        ""{                                                    \n""
        ""    vec3 StartPos = vec3(texCoord.xy, 0.0);          \n""
        ""    vec3 Step = vec3(0.0, 0.0, 0.1);                 \n""
        ""    vec3 CurrentPos = StartPos;                      \n""
        ""    float res = 0.0;                                 \n""
        ""    for (int i = 0; i < 10; i++)                     \n""
        ""    {                                                \n""
        ""        float value = texture(volume, CurrentPos).r; \n""
        ""        res += value;                                \n""
        ""        CurrentPos += Step;                          \n""
        ""    }                                                \n""
        ""    FragColor = vec4(res);                           \n""
        ""}\n\0"";
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cout << ""ERROR::SHADER::VERTEX::COMPILATION_FAILED\n"" << infoLog << std::endl;
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << ""ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n"" << infoLog << std::endl;
    }
    // link shaders
    m_iShader = glCreateProgram();
    glAttachShader(m_iShader, vertexShader);
    glAttachShader(m_iShader, fragmentShader);
    glLinkProgram(m_iShader);
    // check for linking errors
    glGetProgramiv(m_iShader, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(m_iShader, 512, NULL, infoLog);
        std::cout << ""ERROR::SHADER::PROGRAM::LINKING_FAILED\n"" << infoLog << std::endl;
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
}
void VRT::InitTexture()
{
    glCreateTextures(GL_TEXTURE_3D, 1, &m_iVolume);
    glTextureStorage3D(m_iVolume, 1, GL_R32F, imageSize[0], imageSize[1], imageSize[2]);
    glTextureSubImage3D(m_iVolume,
        0,
        0, 0, 0,
        imageSize[0], imageSize[1], imageSize[2],
        GL_RED, GL_FLOAT,
        imageData);
}
void VRT::InitRenderTarget()
{
    m_iTargetSize[0] = 512;
    m_iTargetSize[1] = 512;

    //render to texture
    //glCreateTextures(GL_TEXTURE_2D, 1, &m_iRenderTarget);
    //glTextureStorage2D(m_iRenderTarget, 1, GL_R32F, m_iTargetSize[0], m_iTargetSize[1]);
    
    //render to buffer
    glCreateRenderbuffers(2, m_iRBOs);
    glNamedRenderbufferStorage(m_iRBOs[0], GL_R32F, m_iTargetSize[0], m_iTargetSize[1]);
    glNamedRenderbufferStorage(m_iRBOs[1], GL_DEPTH_COMPONENT, m_iTargetSize[0], m_iTargetSize[1]);
    glCreateFramebuffers(1, &m_iFBO);
    glNamedFramebufferRenderbuffer(m_iFBO, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_iRBOs[0]);
    glNamedFramebufferRenderbuffer(m_iFBO, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_iRBOs[1]);  
}",vaoAttributeSlot
160,"#include <iostream>

using namespace std;

int main() 
{
	double num1, [MASK] ; //Varibles declaration
	char op,op2;  
	cout<<""\n\n\t\t\t\""CALCULATOR\""\n\n"";
	do //Starting point of loop for another calcultion 
	{
	
	cout<<""\n\n\t\tEnter First number: ""; cin>>num1; //first input number from user
	cout<<""\n\t\tEnter Second number: ""; cin>> [MASK] ;  //second input number from user
	do //staring point of loop for wrong input
	{
	cout<<""\n\t\tEnter the Type of Operation (+,-,*,/): ""; cin>>op; //operation type input
	if(op!='+'&&op!='-'&&op!='*'&&op!='/')  //if input wrong operation by user 
	cout<<""\n\t\tWrong Input""<<endl; //this will execute
    }while(op!='+'&&op!='-'&&op!='*'&&op!='/'); //loop will execute again & again if wrong ""op"" is input
	
	 if(op == '+') 
        cout<<""\n\n\t\tResult= ""<<num1<<"" + ""<< [MASK] <<"" = ""<<num1+ [MASK] <<endl;
    else if(op == '-')
        cout<<""\n\n\t\tResult= ""<<num1<<"" - ""<< [MASK] <<"" = ""<<num1- [MASK] <<endl;
    else if(op == '*')
        cout<<""\n\n\t\tResult= ""<<num1<<"" * ""<< [MASK] <<"" = ""<<num1* [MASK] <<endl;
    else if(op == '/')
        cout<<""\n\n\t\tResult= ""<<num1<<"" / ""<< [MASK] <<"" = ""<<num1/ [MASK] <<endl;
    cout<<""\n\t\tPrss Y for another Calculation: ""; cin>>op2; //input for another calcultion
	    
        
    }while (op2=='y'||op2=='Y'); //loop will execute again & again till user presses Y for another calculation
    cout<<""\n\n\t\tTurning Off...""; //if not ,then program will be turned off
	return 0;
}
",num2
161,"#include ""gl_buffer_objects.h""

VertexBuffer::VertexBuffer(const void* data, uint32_t size, GLenum drawMode)
{ 
	glCreateBuffers(1, &mID);
	glBindBuffer(GL_ARRAY_BUFFER, mID);
	glBufferData(GL_ARRAY_BUFFER, size, data, drawMode);
}

VertexBuffer::VertexBuffer(uint32_t size)
{
	glCreateBuffers(1, &mID);
	glBindBuffer(GL_ARRAY_BUFFER, mID);
	glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_DYNAMIC_DRAW);
}

VertexBuffer::~VertexBuffer()
{
	glDeleteBuffers(1, &mID);
}

void VertexBuffer::Bind()
{
	glBindBuffer(GL_ARRAY_BUFFER, mID);
}

void VertexBuffer::Unbind()
{
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void VertexBuffer::Delete()
{
	glDeleteBuffers(1, &mID);
}

void VertexBuffer::SetData(const void* data, uint32_t size, uint32_t  [MASK] )
{
	glBindBuffer(GL_ARRAY_BUFFER, mID);
	glBufferSubData(GL_ARRAY_BUFFER,  [MASK] , size, data);
}

void VertexBuffer::SetLayout(const std::vector<VertexAttribute>& attributes)
{
	mVertexLayout = attributes;
}

IndexBuffer::IndexBuffer(uint32_t* data, uint32_t count, GLenum drawMode)
{
	mIndexCount = count;
	glCreateBuffers(1, &mID);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mID);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(uint32_t), data, drawMode);
}

IndexBuffer::~IndexBuffer()
{
	glDeleteBuffers(1, &mID);
}

void IndexBuffer::Bind()
{
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mID);
}

void IndexBuffer::Unbind()
{
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

void IndexBuffer::Delete()
{
	glDeleteBuffers(1, &mID);
}
",offset
162,"#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <WinSock2.h>
#include ""..\XMSocket\XMSocket.h""

#pragma comment(lib,""ws2_32.lib"")
/*
typedef struct _OVERLAPPEDExt{
	OVERLAPPED ol;
	char data[1024];
	int iotype;	//0, read, 1, write
}OVERLAPPEDExt, *LPOVERLAPPEDExt;

DWORD WINAPI serverThreadProc(LPVOID lpParameter){
	HANDLE hCompletePort = HANDLE(lpParameter);
	srand(time(NULL));
	int id = rand() % 97;
	printf(""I am thread %d.\n"", id);
	//while (true){
	//	Sleep(100);
	//}
	DWORD trans;
	ULONG key;
	LPOVERLAPPED ol;
	//	OVERLAPPED ol;
	::GetQueuedCompletionStatus(hCompletePort, &trans, &key, &ol, INFINITE);
	printf(""I am thread %d. I get key %lu.\n"", id, key);
	return 0;
}

int main(){
	printf(""%d%d\n"", sizeof(OVERLAPPED), sizeof(OVERLAPPEDExt));
	printf(""%d%d%d\n"", sizeof(ULONG), sizeof(DWORD), sizeof(HANDLE));
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);


	HANDLE hCompletePort = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
	DWORD threadId[6];
	HANDLE threadHd[6];
	for (int i = 0; i < 6; ++i){
		threadHd[i] = ::CreateThread(NULL, 0, serverThreadProc, (LPVOID)hCompletePort, 0, &threadId[i]);
		Sleep(1000);
	}
	Sleep(10000);
	for (int i = 0; i < 6; ++i){
		::PostQueuedCompletionStatus(hCompletePort, 0, i, 0);
	}
	for (int i = 0; i < 6; ++i){
		WaitForSingleObject(threadHd[i], INFINITE);
	}
	printf(""END\n"");
	getchar();

	WSACleanup();
	return 0;
}
*/

int main(){
	XMSocket::startup();

	char buf[1024];
	XMSocket  [MASK] ;
	 [MASK] .createClient(8888, ""127.0.0.1"");
	 [MASK] .connect();
	while (true){
		scanf(""%s"", buf);
		int ret =  [MASK] .send(buf, strlen(buf));
		printf(""send %3d:%s\n"", ret, buf);
		ret =  [MASK] .recv(buf, 1024);
		printf(""recv %3d:%s\n"", ret, buf);
	}

	XMSocket::cleanup();

	printf(""END\n"");
	getchar();
	return 0;
}",client
163,"// The author disclaims copyright to this source code.
#include ""Debug.h""

Debug* Debug::instance = NULL;

Debug* Debug::createInstance(Clock* clk) {
	if (!instance) {
		instance = new Debug(clk);
	}
	return instance;
}

Debug* Debug::getInstance() {
	return instance;
}

Debug::Debug(Clock* clk) {
	clock = clk;
	previousTimestamp = 0;
}

Debug::~Debug() {
}

void Debug::setup() {
	Serial.begin(115200);
	Debug::getInstance()->debug(""Debug::setup"");
}

void Debug::debug(String debug) {
	if (debugEnabled) {
		Serial.println(timestamps() + "";DEBUG;"" + debug);
	}
}

void Debug::info(String info) {
	if (infoEnabled) {
		Serial.println(timestamps() + "";INFO;"" + info);
	}
}

void Debug::error(String error) {
	if (errorEnabled) {
		Serial.println(timestamps() + "";ERROR;"" + error);
	}
}

const String Debug::zeroTemplate = ""00000000000000000000"";

String Debug::timestamps() {
	unsigned long now = clock->getTimestamp();
	unsigned long relative = now - previousTimestamp;
	previousTimestamp = now;
	return fixedLength(now) + "";"" + fixedLength(relative);
}

String Debug::fixedLength(unsigned long number) {
	String text = String(number);
	String maxed = text.substring(0, 10);
	int padLength = 10 - maxed.length();
	String  [MASK]  = zeroTemplate.substring(0, padLength);
	String result =  [MASK]  + maxed;
	return result;
}
",padding
164,"// SPDX-FileCopyrightText: 2022 <NAME> <<EMAIL>>
//
// SPDX-License-Identifier: MIT

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

int main() {
    // Read an image
    cv::Mat  [MASK]  = cv::imread(""../index.jpg"", cv::IMREAD_COLOR);
    if ( [MASK] .empty()) {
        std::cerr << ""Error: Could not read the image."" << std::endl;
        return 1;
    }

    // Convert the image to grayscale
    cv::Mat gray_image;
    cv::cvtColor( [MASK] , gray_image, cv::COLOR_BGR2GRAY);

    // Save the grayscale image
    cv::imwrite(""gray_image.jpg"", gray_image);

    // Display the input and grayscale images
    cv::imwrite(""Input Image.jpg"",  [MASK] );
    cv::imwrite(""Grayscale Image.jpg"", gray_image);

    // Wait for a key press and close the windows
    cv::waitKey(0);
    cv::destroyAllWindows();

    return 0;
}
",input_image
165,"#include ""MainWindow.h""

#include <QStyleOption>
#include <QStylePainter>

MainWindow::MainWindow(QWidget* parent)
    : QWidget(parent)
{
    this->setStyleSheet(""QWidget { background: #222244; color: #cccc00; }"");
}

void MainWindow::paintEvent(QPaintEvent* event)
{
    QStylePainter paint(this);
    paint.setPen(Qt::NoPen);

    paint.setRenderHint(QPainter::Antialiasing);

    QStyleOption opt;
    opt.initFrom(this);

    const auto grooveBrush = QColor(""#555555"");

    const auto backBrush = opt.palette.brush(this->backgroundRole());
    const auto foreBrush = opt.palette.brush(this->foregroundRole());

    const int thickness     = 6;
    const int minDimension  = std::min(opt.rect.width(), opt.rect.height()) - thickness;
    auto      barGrooveRect = QRect{ QPoint{ 0, 0 }, QSize{ minDimension, minDimension } };
    barGrooveRect.moveCenter(opt.rect.center());

    paint.setBrush(backBrush);
    paint.drawRect(opt.rect);

    paint.setBrush(Qt::NoBrush);
    paint.setPen(QPen(grooveBrush, thickness));
    paint.drawEllipse(barGrooveRect);

    paint.setPen(QPen(foreBrush, thickness));

    auto drawProgress = [&paint, barGrooveRect](int fromPromille, int toPromille) {
        const int  [MASK]  = 16; // qt считает в 1/16 долях градуса!
        const int fromDegree = fromPromille * 360 *  [MASK]  / 1000;
        const int toDegree   = toPromille * 360 *  [MASK]  / 1000;

        paint.drawArc(barGrooveRect, 90 *  [MASK]  - toDegree, toDegree - fromDegree);
    };

    drawProgress(0, 777);
}
",qtSpecific
166,"/*-------------------------------------------------------------------------
 *
 * orc_wrapper.cpp
 *    An encapsulator for ORC file reader/write functions
 *
 * 2020, <NAME>.
 *
 * Contains functions that wrap Apache ORC library functions to be used
 * by ORC FDW.
 *
 * Copyright (c) 2020, Highgo Software Inc.
 *
 * IDENTIFICATION
 *    src/orc_wrapper.cpp
 *
 *-------------------------------------------------------------------------
 */

/* ORC FDW header files */
#include <orc_wrapper.h>
#include <orc_interface_typedefs.h>

/* Apache ORC header files */
#include <orc/Exceptions.hh>
#include <orc/OrcFile.hh>

/* PostgreSQL and FDW header files */
extern ""C""
{
    #include ""c.h""
    #include ""orc_fdw.h""
}


/* Declare the functions to use within this file */
static std::string IsSupportedVersion(ORC_UNIQUE_PTR<orc::Reader> *p_reader);


/*
 * orcCreateReader
 *    Creates Apache ORC file reader for file in a safe way for fdw.
 *    Creates a reader for the specified filename and stores it in
 *    the unique_ptr in p_reader.
 */
bool
orcCreateReader(std::string filename,
                    ORC_UNIQUE_PTR<orc::Reader> *p_reader, 
                    orc::ReaderOptions &options,
                    bool blnVersionWarn)
{
    /* Let's catch exceptions and throw an error */
    try
    {
        ORC_UNIQUE_PTR<orc::InputStream> inStream =
            orc::readLocalFile(filename.c_str());

        *p_reader = orc::createReader(std::move(inStream), options);
    }
    catch (orc::ParseError& err)
    {
        ereport(ERROR, (errmsg(""%s: %s"", ORC_FDW_NAME, err.what())));
    }

    /* Throw a warning for unsupported ORC version */
    std::string fileVersion = IsSupportedVersion(p_reader);
    if (fileVersion.empty() == false && blnVersionWarn )
    {
        ereport(WARNING, (errmsg(""%s: Unsupported ORC file %s version 0.11."", ORC_FDW_NAME, filename.c_str()),
                         (errhint(""This may still work, but it's strongly recommended to use files that are supported by the fdw.""))));
    }

    /* *p_reader should never by NULL here, but just in case */
    return ((*p_reader) != NULL);
}

/*
 * orcCreateRowReader
 *    Creates Apache ORC file row reader in safe way for fdw.
 */
bool
orcCreateRowReader(ORC_UNIQUE_PTR<orc::Reader> *p_reader,
                    ORC_UNIQUE_PTR<orc::RowReader> *p_rowReader, 
                    orc::RowReaderOptions &rowReaderOptions)
{
    *p_rowReader = (*p_reader)->createRowReader(rowReaderOptions);

    if (*p_rowReader == NULL)
    {
        ereport(ERROR, (errmsg(""%s: Unable to create row reader for ORC file."", ORC_FDW_NAME)));
    }

    return true;
}

/*
 * orcGetNumberOfRows
 *    Returns number of rows in the ORC file.
 */
uint64_t
orcGetNumberOfRows(ORC_UNIQUE_PTR<orc::Reader> *p_reader)
{
    return (*p_reader)->getNumberOfRows();
}

/*
 * orcGetColsInfo
 *    Get column meta data and return an std::vector of OrcFileColInfo.
 */
std::vector<OrcFileColInfo>
orcGetColsInfo(std::string  [MASK] , ORC_UNIQUE_PTR<orc::Reader> *p_reader, orc::StructVectorBatch **p_root)
{
	orc::ReaderOptions options;
    (void) orcCreateReader( [MASK] , p_reader, options, true);

	orc::RowReaderOptions rowReaderOptions;
	ORC_UNIQUE_PTR<orc::RowReader> rowReader;
    (void) orcCreateRowReader(p_reader, &rowReader, rowReaderOptions);

    /* Check for batch for reading */
	ORC_UNIQUE_PTR<orc::ColumnVectorBatch> batch = rowReader->createRowBatch(1);
    if (batch == NULL)
    {
        ereport(ERROR, (errmsg(""%s: Unable to create row batch for reading."", ORC_FDW_NAME)));
    }

    /* Get the batch */
    *p_root = dynamic_cast<orc::StructVectorBatch *>(batch.get());
    if ((*p_root) == NULL)
    {
        ereport(ERROR, (errmsg(""%s: Unable to get batch from ORC file."", ORC_FDW_NAME)));
    }

    /* Return column information std::tuple */
    return orcGetColsInfo(p_reader, &rowReader, *p_root);
}

/*
 * orcGetColsInfo
 *    Fills and returns a vector of tuples with column meta data.
 */
std::vector<OrcFileColInfo>
orcGetColsInfo(ORC_UNIQUE_PTR<orc::Reader> *p_reader, ORC_UNIQUE_PTR<orc::RowReader> *p_rowReader, orc::StructVectorBatch *root)
{
    std::vector<OrcFileColInfo> col_list;

    // for (uint col_index = 0; col_index < (*p_rowReader)->getSelectedType().getSubtypeCount(); col_index++)
    for (uint col_index = 0; col_index < root->fields.size(); col_index++)
    {
        OrcFileColInfo col;
        auto orc_col_id = (*p_rowReader)->getSelectedType().getSubtype(col_index)->getColumnId();

        col.hasNull = (*p_reader)->getColumnStatistics(orc_col_id)->hasNull();
        col.kind = (*p_rowReader)->getSelectedType().getSubtype(col_index)->getKind();
        col.max_length = (*p_rowReader)->getSelectedType().getSubtype(col_index)->getMaximumLength();
        col.precision = (*p_rowReader)->getSelectedType().getSubtype(col_index)->getPrecision();
        col.scale = (*p_rowReader)->getSelectedType().getSubtype(col_index)->getScale();

        /* Index must be fixed if the rowReader was created for specific columns */
        col.index = col_index;
        col.name = (*p_rowReader)->getSelectedType().getFieldName(col_index);

        col_list.push_back(col);
    }

    return col_list;
}

/*
 * IsSupportedVersion
 *    To be used internally in this file, for a supported version, returns
 *    emptry string otherwise returns the ORC format version of file
 *    as string to be used in an message.
 */
static
std::string IsSupportedVersion(ORC_UNIQUE_PTR<orc::Reader> *p_reader)
{
    if ((*p_reader)->getFormatVersion() != orc::FileVersion(0, 12))
    {
        return (*p_reader)->getFormatVersion().toString();
    }

    return std::string("""");
}

/*
 * orcGetDefaultDecimalScale
 *    ORC version 0.11 does not define decimal places for a decimal
 *    value. This function handles that. Although we don't support
 *    version 0.11, but having this one additional check improves
 *    0.11 support in FDW.
 *
 *    Returns 6 which is the default number of decimal places in
 *    0.11 version. Otherwise, return empty so that we can pick
 *    number of decimal places from schema.
 */
int
orcGetDefaultDecimalScale(ORC_UNIQUE_PTR<orc::Reader> *p_reader)
{
    std::string fileVersion = IsSupportedVersion(p_reader);

    /* Let's assume that it 0.11 */
    if (fileVersion.empty() == false)
        return 6;
    else
        return 0;
}
",file_pathname
167,"#include ""SelectAminoAcidDialog.h""
#include ""AminoAcidList.h""
#include <StudyOptionsDialog.h>
#include <QuizOptionsDialog.h>
#include ""quizapp.h""
#include <sysfolders.h>
#include <sysscale.h>

#include <QDebug>

//Text for property type labels
const char *propertyTypeLabel[MAX_PROPERTY_TYPES] = {
    ""Acidic / Basic / Amide / Neutral"",
    ""Charged / Uncharged"",
    ""Polar / Nonpolar"",
    ""Hydrophobic / Hydrophilic"",
    ""Aromatic / Hydroxyl / Thiol / Aliphatic"",
    ""No Properties""
};

//Text for image type labels
const char *imageTypeLabel[MAX_IMAGE_TYPES] = {
    ""Space Filling"",
    ""Ball && Stick"",
    ""Stick"",
    ""Wireframe"",
    ""Structural Formula""
};

//Text for name type labels
const char *nameTypeLabel[MAX_NAME_TYPES] = {
    ""Full Name"",
    ""Single Letter Name"",
    ""Three Letter Name"",
    ""No Name""
};

SelectAminoAcidDialog * SelectAminoAcidDialog::s_instance = nullptr;

SelectAminoAcidDialog * SelectAminoAcidDialog::instance(QWidget * parent)
{
    if (!s_instance)
        s_instance = new SelectAminoAcidDialog(parent);
    return s_instance;
}

SelectAminoAcidDialog::SelectAminoAcidDialog(QWidget * parent)
    : QDialog(parent)
{
    int width = ppp(770);
    int height = ppp(385);

    setWindowTitle(""Select Amino Acids"");
    setGeometry(QRect(ppp(100), ppp(100), width, height));
    setMaximumSize(width, height);
    setMinimumSize(width, height);

    aAGroupBox = new QGroupBox(this);
    aAGroupBox->setGeometry(QRect(ppp(10), ppp(10), ppp(410), ppp(330)));
    aAGroupBox->setTitle(""Select Amino Acids"");

    choseAAListWidget = new QListWidget(aAGroupBox);
    choseAAListWidget->setGeometry(QRect(ppp(10), ppp(30), ppp(130), ppp(285)));
    choseAAListWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
    choseAAListWidget->setSortingEnabled(true);
    addListWidgetItems();

    selectedAAListWidget = new QListWidget(aAGroupBox);
    selectedAAListWidget->setGeometry(QRect(ppp(270), ppp(30), ppp(130), ppp(285)));
    selectedAAListWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
    selectedAAListWidget->setSortingEnabled(true);

    addAllButton = new QPushButton(""Add All->"", aAGroupBox );
    addAllButton->setGeometry(QRect(ppp(150), ppp(85), ppp(110), ppp(25)));
    QObject::connect(addAllButton, SIGNAL(clicked()), this, SLOT(addAll()));

    addButton = new QPushButton(""Add->"", aAGroupBox);
    addButton->setGeometry(QRect(ppp(150), ppp(120), ppp(110), ppp(25)));
    QObject::connect(addButton, SIGNAL(clicked()), this, SLOT(add()));

    removeButton = new QPushButton(""<-Remove"", aAGroupBox);
    removeButton->setGeometry(QRect(ppp(150), ppp(155), ppp(110), ppp(25)));
    QObject::connect(removeButton, SIGNAL(clicked()), this, SLOT(remove()));

    removeAllButton = new QPushButton(""<-Remove All"", aAGroupBox);
    removeAllButton->setGeometry(QRect(ppp(150), ppp(190), ppp(110), ppp(25)));
    QObject::connect(removeAllButton, SIGNAL(clicked()), this, SLOT(removeAll()));

    propertiesGroupBox = new QGroupBox( this );
    propertiesGroupBox->setGeometry(QRect(ppp(430), ppp(10), ppp(330), ppp(165)));
    propertiesGroupBox->setTitle(""Select Properties"");

    for (int x = ppp(10), y = ppp(35), width = ppp(300), height = ppp(15), n = 0; n < MAX_PROPERTY_TYPES; y += ppp(20), ++n)
    {
        propertyTypeRadioButton[n] = new QRadioButton(propertyTypeLabel[n], propertiesGroupBox);
        propertyTypeRadioButton[n]->setGeometry(x, y, width, height);
        QObject::connect(propertyTypeRadioButton[n], SIGNAL(clicked()), this, SLOT(noProperty()));
    }

    propertyTypeRadioButton[0]->setChecked(true);

    imageTypeGroupBox = new QGroupBox( this );
    imageTypeGroupBox->setGeometry(QRect(ppp(430), ppp(185), ppp(160), ppp(156)));
    imageTypeGroupBox->setTitle(""Image Type"");

    for (int x = ppp(10), y = ppp(35), width = ppp(145), height = ppp(15), n = 0; n < MAX_IMAGE_TYPES; y += ppp(20), ++n)
    {
        imageTypeRadioButton[n] = new QRadioButton(imageTypeLabel[n], imageTypeGroupBox);
        imageTypeRadioButton[n]->setGeometry(x, y, width, height);
    }

    imageTypeRadioButton[0]->setChecked(true);

    nameTypeGroupBox = new QGroupBox(this);
    nameTypeGroupBox->setGeometry(QRect(ppp(600), ppp(185), ppp(160), ppp(156)));
    nameTypeGroupBox->setTitle(""Name Type"");

    for (int x = ppp(10), y = ppp(35), width = ppp(145), height = ppp(15), n = 0; n < MAX_NAME_TYPES; y += ppp(20), ++n)
    {
        nameTypeRadioButton[n] = new QRadioButton(nameTypeLabel[n], nameTypeGroupBox);
        nameTypeRadioButton[n]->setGeometry(x, y, width, height);
        QObject::connect(nameTypeRadioButton[n], SIGNAL(clicked()), this, SLOT(noName()));
    }

    nameTypeRadioButton[0]->setChecked(true);

    cancelButton = new QPushButton(""Cancel"", this);
    cancelButton->setGeometry(QRect(ppp(320), ppp(350), ppp(100), ppp(25)));
    QObject::connect(cancelButton, SIGNAL(clicked()), this, SLOT(close()));


    finishButton = new QPushButton(""Finish"", this);
    finishButton->setGeometry(QRect(ppp(430), ppp(350), ppp(330), ppp(25)));
    finishButton->setDefault(true);
    finishButton->setAutoDefault(true);
    QObject::connect(finishButton, SIGNAL(clicked()), this, SLOT(finish()));

    propertyTypeChecked[0] = true;
    for (int i = 1; i < MAX_PROPERTY_TYPES; ++i)
        propertyTypeChecked[i] = false;

    imageTypeChecked[0] = true;
    for (int i = 1; i < MAX_IMAGE_TYPES; ++i)
        imageTypeChecked[i] = false;

    nameTypeChecked[0] = true;
    for (int i = 0; i < MAX_NAME_TYPES; ++i)
        nameTypeChecked[i] = false;

    tryingToStudy = false;
    tryingToTakeQuiz = false;
}

// Method that adds the amino acids to
// the list of Amino Acids to chose from
void SelectAminoAcidDialog::addListWidgetItems()
{
    QFile  [MASK] ;
     [MASK] .setFileName((ResourceFolder() + ""Properties.csv"").c_str());
    qDebug() << ""opening Properties file "" <<  [MASK] .fileName();

    if (! [MASK] .open( QIODevice::ReadOnly | QIODevice::Text))
        QMessageBox::warning(this, ""Invalid Filename"", tr(""Cannot be opened for reading""));

    QTextStream in;
    in.setDevice(& [MASK] );
    QString line = in.readLine();

    while(!in.atEnd())
    {
        line = in.readLine();
        QStringList attributeList = line.split("","");
        new QListWidgetItem(tr(""%1"").arg(attributeList.at(0)), choseAAListWidget);
        chooseFromList << attributeList.at(0);
    }

     [MASK] .close();
}

// Method called when the Add all button is clicked
// Moves all the Amino Acids to the right listbox
void SelectAminoAcidDialog::addAll()
{
    int size = choseAAListWidget->count();
    for (int i = 0; i < size; ++i)
    {
        choseAAListWidget->setCurrentRow(0);
        QListWidgetItem * currentItem = choseAAListWidget->currentItem();
        selectedAAListWidget->addItem(currentItem->text());
        choseAAListWidget->takeItem(choseAAListWidget->row(currentItem));
    }
}

// Method called when the add button is clicked.
// Moves the selected Amino Acid to the right listbox
void SelectAminoAcidDialog::add()
{
    QList<QListWidgetItem *> selectedItems = choseAAListWidget->selectedItems();
    for (int i = 0; i < selectedItems.size(); ++i)
    {
        QListWidgetItem * currentItem = selectedItems.at(i);
        selectedAAListWidget->addItem(currentItem->text());
        choseAAListWidget->takeItem(choseAAListWidget->row(currentItem));
    }
}

// Method called when the remove button is clicked.
// Moves the selected Amino Acid to the left listbox
void SelectAminoAcidDialog::remove()
{
    QList<QListWidgetItem *> selectedItems = selectedAAListWidget->selectedItems();
    for (int i = 0; i < selectedItems.size(); ++i)
    {
        QListWidgetItem * currentItem = selectedItems.at(i);
        choseAAListWidget->addItem(currentItem->text());
        selectedAAListWidget->takeItem(selectedAAListWidget->row(currentItem));
    }
}

// Method called when the remove all button is clicked.
// Moves the selected Amino Acid to the left listbox
void SelectAminoAcidDialog::removeAll()
{
    int size = selectedAAListWidget->count();
    for (int i = 0; i < size; ++i)
    {
        selectedAAListWidget->setCurrentRow(0);
        QListWidgetItem * currentItem = selectedAAListWidget->currentItem();
        choseAAListWidget->addItem(currentItem->text());
        selectedAAListWidget->takeItem(selectedAAListWidget->row(currentItem));
    }
}

// Method called when the No property option is checked.
// This mean that the no name option must be disabled
void SelectAminoAcidDialog::noProperty()
{
    if (propertyTypeRadioButton[ MAX_PROPERTY_TYPES - 1]->isChecked())
        nameTypeRadioButton[MAX_NAME_TYPES - 1]->setEnabled(false);
    else
        nameTypeRadioButton[MAX_NAME_TYPES - 1]->setEnabled(true);
}

// Method called when the No name option is checked.
// This mean that the no property option must be disabled
void SelectAminoAcidDialog::noName()
{
    if (nameTypeRadioButton[MAX_NAME_TYPES - 1]->isChecked())
        propertyTypeRadioButton[MAX_PROPERTY_TYPES - 1]->setEnabled(false);
    else
        propertyTypeRadioButton[MAX_PROPERTY_TYPES - 1]->setEnabled(true);
}

// Method called from the finish function
// If the user attempted to take a quiz/test
// or study with selecting any amino acids
// Then he would be intimated about it and
// directed to the select amino acids. So
// when he's done selected amino acids then
// we'd have to go back showing the user
// the quiz opition dialog or study option dialog
void SelectAminoAcidDialog::conclude()
{
    // Check if they got here because they tried
    // to start a quiz/test or study session
    if (tryingToStudy || tryingToTakeQuiz)
    {
        // The whole point of getting here was
        // to chose amino acids. Check to see
        // if that has been taken care off.
        if (isChosenAminoAcids())
        {
            hide();

            // Depending on what the user tried to do
            // before they got here, show them the study
            // or quiz/test dialog.
            if (tryingToStudy)
            {
                StudyOptionsDialog::instance()->moveToCenter();
                StudyOptionsDialog::instance()->exec();
            }
            else
            {
                QuizOptionsDialog::instance()->moveToCenter();
                QuizOptionsDialog::instance()->exec();
            }
        }
        else
        {
            // if Amino acids were not selected
            // ask then if the use would like to or not
            int yesno = QMessageBox::question( this, ""No Amino Acids Selected"",
                ""There are no Amino Acids selected for studying.\n ""
                ""Would you like to select Amino Acids now? "",
                QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes
            );

            // if not, then reset the flags
            // and hide the dialog
            if (yesno == QMessageBox::No)
            {
                tryingToStudy = false;
                tryingToTakeQuiz = false;
                hide();
            }
        }
    }
    else
        hide();
}

// Method called when the finish button is clicked
// This method saves the state of the selections
// and send the necessary information to other dialogs.
void SelectAminoAcidDialog::finish()
{
    chooseFromList.clear();
    chosenList.clear();

    // save property selection
    for (int i = 0; i < MAX_PROPERTY_TYPES; ++i)
        propertyTypeChecked[i] = propertyTypeRadioButton[i]->isChecked();

    // save property type selection
    for (int i = 0; i < MAX_IMAGE_TYPES; ++i)
        imageTypeChecked[i] = imageTypeRadioButton[i]->isChecked();

    // save image type selection
    for (int i = 0; i < MAX_NAME_TYPES; ++i)
      nameTypeChecked[i] = nameTypeRadioButton[i]->isChecked();

    // save the amino acids that were NOT selected
    for (int i = 0; i < choseAAListWidget->count(); ++i)
    {
        choseAAListWidget->setCurrentRow(i);
        QListWidgetItem * currentItem = choseAAListWidget->currentItem();
        chooseFromList << currentItem->text();
    }

    // clear the list of amino acids to study
    // for earlier quiz/test or study sessions
    StudyOptionsDialog::instance()->imagesToStudy.clear();
    QuizOptionsDialog::instance()->imagesToStudy.clear();

    // save the amino acids that were selected for
    // for quiz/test or study. Also give this information
    // to the Quiz and Study dialogs.
    for (int i = 0; i < selectedAAListWidget->count(); ++i)
    {
        selectedAAListWidget->setCurrentRow(i);
        QListWidgetItem * currentItem = selectedAAListWidget->currentItem();
        chosenList << currentItem->text();
        StudyOptionsDialog::instance()->imagesToStudy << currentItem->text();
        QuizOptionsDialog::instance()->imagesToStudy << currentItem->text();
    }

    // Tell the Quiz and Study dialogs
    // the type of Image, Name and property
    setImageType();
    setNameType();
    setPropertyType();
    conclude();
}

// Method called when the close button is clicked
// Resets all the values to it's original state
void SelectAminoAcidDialog::closeEvent(QCloseEvent* e)
{
    for (int i = 0; i < MAX_PROPERTY_TYPES; ++i)
        propertyTypeRadioButton[i]->setChecked(propertyTypeChecked[i]);

    for (int i = 0; i < MAX_IMAGE_TYPES; ++i)
        imageTypeRadioButton[i]->setChecked(imageTypeChecked[i]);

    for (int i = 0; i < MAX_NAME_TYPES; ++i)
        nameTypeRadioButton[i]->setChecked(nameTypeChecked[i]);

    choseAAListWidget->clear();
    selectedAAListWidget->clear();

    for (int i = 0; i < chooseFromList.size(); ++i)
        choseAAListWidget->addItem(chooseFromList.at(i));

    for (int i = 0; i < chosenList.size(); ++i)
        selectedAAListWidget->addItem(chosenList.at(i));

    conclude();
}

// Method called when the Esc button is
// pressed. Do nothing, simply ignore
void SelectAminoAcidDialog::reject()
{
}

// Method is see if atleast one
// Amino acid was chosen
bool SelectAminoAcidDialog::isChosenAminoAcids()
{
    if (0 == selectedAAListWidget->count())
        return false;
    return true;
}

// Method to set the tryingToStudy flag
// This will be used later to see if the
// was attempting to study before getting here
void SelectAminoAcidDialog::setTryingToStudy(bool flag)
{
    tryingToStudy = flag;
}


// Method to set the tryingToTakeQuiz flag
// This will be used later to see if the
// was attempting to Quiz before getting here
void SelectAminoAcidDialog::setTryingToTakeQuiz(bool flag)
{
    tryingToTakeQuiz = flag;
}

// Method to set the Image type in the
// Quiz/Test or Study sessions. The bg
// color is also set->White for structured
// formula. Black otherwise
void SelectAminoAcidDialog::setImageType()
{
    for (int i = 0; i < MAX_IMAGE_TYPES; ++i)
    {
        if (imageTypeChecked[i])
        {
            if (i != 4)
            {
                StudyOptionsDialog::instance()->setImageType(imageTypeLabel[i], Qt::black);
                QuizOptionsDialog::instance()->setImageType(imageTypeLabel[i], Qt::black);
            }
            else
            {
                StudyOptionsDialog::instance()->setImageType(imageTypeLabel[i], Qt::white);
                QuizOptionsDialog::instance()->setImageType(imageTypeLabel[i], Qt::white);
            }

            break;
        }
    }
    return;
}

// Method to set the Name type in the
// Quiz/Test or Study sessions
void SelectAminoAcidDialog::setNameType()
{
    for (int i = 0; i < MAX_NAME_TYPES; ++i)
    {
        if (nameTypeChecked[i])
        {
            StudyOptionsDialog::instance()->setNameType(i);
            QuizOptionsDialog::instance()->setNameType(i);
            break;
        }
    }

    return;
}

// Method to set the Property type in the
// Quiz/Test or Study sessions
void SelectAminoAcidDialog::setPropertyType()
{
    for (int i = 0; i < MAX_PROPERTY_TYPES; ++i)
    {
        if (propertyTypeChecked[i])
        {
            StudyOptionsDialog::instance()->setPropertyType(i);
            QuizOptionsDialog::instance()->setPropertyType(i);
            break;
        }
    }
    return;
}

SelectAminoAcidDialog::~SelectAminoAcidDialog()
{
}
",inFile
168,"#include ""datastore.h""

#include <QFile>
#include <QJsonArray>
#include <QJsonDocument>
#include <QMessageBox>
#include <QString>

DataStore::DataStore()
{
}

DataStore::~DataStore()
{
}

bool DataStore::read(QString filePath)
{
    issues.clear();
    QFile loadFile(filePath);

    if (!loadFile.open(QIODevice::ReadOnly)) {
        qWarning(""Couldn't open save file."");
        return false;
    }

    QByteArray saveData = loadFile.readAll();

    QJsonDocument loadDoc(QJsonDocument::fromJson(saveData));

    projectName = loadDoc.object()[""projectName""].toString();
    QJsonArray  [MASK]  = loadDoc.object()[""issues""].toArray();

    for (int i=0; i <  [MASK] .size(); i++)
    {
        QJsonObject issueObject =  [MASK] [i].toObject();
        Issue issue;
        issue.read(issueObject);

        //      QWidget *qw = new QWidget;
        //      QMessageBox::information(qw, QString(""Bla""), issueObject.value(""title"").toString(), QMessageBox::Save);

        issues.append(issue);
    }

    return true;
}

bool DataStore::write(QString filePath)
{
    QFile saveFile(filePath);

    if (!saveFile.open(QIODevice::WriteOnly)) {
        qWarning(""Couldn't open save file."");
        return false;
    }

    json[""projectName""] = projectName;

    QJsonArray issueArray;
    foreach (const Issue issue, issues) {
        QJsonObject issueObject;
        issue.write(issueObject);
//        QWidget *qw = new QWidget;
//        QMessageBox::information(qw, QString(""Bla""), issueObject.value(""title"").toString(), QMessageBox::Save);
        issueArray.append(issueObject);
    }

    json[""issues""] = issueArray;

    QJsonDocument saveDoc(json);
    saveFile.write(saveDoc.toJson());

    return true;
}

",jsonArray
169,"#include <Time.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

const byte sinArray[60] = {83, 101, 119, 136, 153, 169, 184, 198, 211, 222, 232, 240, 247, 251, 254, 255, 254, 251, 247, 240, 232, 222, 211, 198, 184, 169, 153, 136, 119, 101, 83, 65, 47, 30, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 30, 47, 65};
const int timeZone = -4;  // Eastern Standard Time (USA)

int nixieBulbDelayTime = 500;
int ledFadeTime = 8;

String ZIPCODE = ""*"";
String APPID = ""*"";

char ssid[] = ""*"";
char pass[] = ""*"";
char host[] = ""api.openweathermap.org"";

int GEIGER_PIN = 5;
int GEIGER_LED = 4;
int TIME_DATA_IN_PIN = 12;
int TIME_CLK_PIN = 13;
int TIME_LE_PIN = 0;
int TIME_BL_PIN = 2;
int STATUS_A_PIN = 14;
int STATUS_B_PIN = 15;
int STATUS_C_PIN = 16;

struct nixieStruct {
  byte hour1;
  byte hour2;
  byte minute1;
  byte minute2;
  byte bulbs;
};

time_t prevDisplay = 0; // when the digital clock was displayed

nixieStruct nixies = {2, 9, 9, 9, 15}; // initialize nixie tubes

unsigned int localPort = 2390;        // local port to listen for UDP packets
IPAddress timeServer(129, 6, 15, 28); // time.nist.gov NTP server
const int NTP_PACKET_SIZE = 48;       // NTP time stamp is in the first 48 bytes of the message
byte packetBuffer[NTP_PACKET_SIZE];   // buffer to hold incoming and outgoing packets
WiFiUDP udp;

void drawNixies() {
  if (now() != prevDisplay) { //update the display only if time has changed
    prevDisplay = now();
    nixies.hour1 = hour() / 10;
    nixies.hour2 = hour() % 10;
    nixies.minute1 = minute() / 10;
    nixies.minute2 = minute() % 10;
  }

  int c = 0;                            //initialize counter
  digitalWrite(TIME_LE_PIN, LOW);       //open shift register latch
  digitalWrite(TIME_DATA_IN_PIN, LOW);  //set next bit low
  for (c = 0; c < 32; c++) {            //push low bit 32 times to clear the register
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
  }
  digitalWrite(TIME_LE_PIN, HIGH);      //push latch
  digitalWrite(TIME_LE_PIN, LOW);       //open latch
  digitalWrite(TIME_DATA_IN_PIN, LOW);  //set next bit low
  for (c = 9; c > nixies.minute2; c--) {
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
  }
  digitalWrite(TIME_DATA_IN_PIN, HIGH);
  digitalWrite(TIME_CLK_PIN, HIGH);
  digitalWrite(TIME_CLK_PIN, LOW);
  digitalWrite(TIME_DATA_IN_PIN, LOW);
  for (c; c > 0; c--) {
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
  }
  digitalWrite(TIME_DATA_IN_PIN, LOW);
  for (c = 9; c > nixies.minute1; c--) {
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
  }
  digitalWrite(TIME_DATA_IN_PIN, HIGH);
  digitalWrite(TIME_CLK_PIN, HIGH);
  digitalWrite(TIME_CLK_PIN, LOW);
  digitalWrite(TIME_DATA_IN_PIN, LOW);
  for (c; c > 0; c--) {
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
  }
  digitalWrite(TIME_DATA_IN_PIN, LOW);
  for (c = 9; c > nixies.hour2; c--) {
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
  }
  digitalWrite(TIME_DATA_IN_PIN, HIGH);
  digitalWrite(TIME_CLK_PIN, HIGH);
  digitalWrite(TIME_CLK_PIN, LOW);
  digitalWrite(TIME_DATA_IN_PIN, LOW);
  for (c; c > 0; c--) {
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
  }
  digitalWrite(TIME_DATA_IN_PIN, LOW);
  if (nixies.hour1 != 0) {
    for (c = 2; c > nixies.hour1; c--) {
      digitalWrite(TIME_CLK_PIN, HIGH);
      digitalWrite(TIME_CLK_PIN, LOW);
    }
    digitalWrite(TIME_DATA_IN_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, HIGH);
    digitalWrite(TIME_CLK_PIN, LOW);
    digitalWrite(TIME_DATA_IN_PIN, LOW);
    for (c; c > 1; c--) {
      digitalWrite(TIME_CLK_PIN, HIGH);
      digitalWrite(TIME_CLK_PIN, LOW);
    }
  }
  else {
    for (int i = 0; i < 2; i++) {
      digitalWrite(TIME_CLK_PIN, HIGH);
      digitalWrite(TIME_CLK_PIN, LOW);
    }
  }
  digitalWrite(TIME_LE_PIN, HIGH);

  if (nixies.bulbs & 0x01) { // Top Colon
    digitalWrite(STATUS_A_PIN, LOW);
    digitalWrite(STATUS_B_PIN, LOW);
    digitalWrite(STATUS_C_PIN, LOW);
    delayMicroseconds(nixieBulbDelayTime);
  }
  if (nixies.bulbs & 0x02) { // Botton Colon
    digitalWrite(STATUS_A_PIN, HIGH);
    digitalWrite(STATUS_B_PIN, LOW);
    digitalWrite(STATUS_C_PIN, LOW);
    delayMicroseconds(nixieBulbDelayTime);
  }
  if (nixies.bulbs & 0x04) { // Sun
    digitalWrite(STATUS_A_PIN, LOW);
    digitalWrite(STATUS_B_PIN, HIGH);
    digitalWrite(STATUS_C_PIN, HIGH);
    delayMicroseconds(nixieBulbDelayTime);
  }
  if (nixies.bulbs & 0x08) { // Cloud
    digitalWrite(STATUS_A_PIN, LOW);
    digitalWrite(STATUS_B_PIN, HIGH);
    digitalWrite(STATUS_C_PIN, LOW);
    delayMicroseconds(nixieBulbDelayTime);
  }
  if (nixies.bulbs & 0x10) { // Rain
    digitalWrite(STATUS_A_PIN, LOW);
    digitalWrite(STATUS_B_PIN, LOW);
    digitalWrite(STATUS_C_PIN, HIGH);
    delayMicroseconds(nixieBulbDelayTime);
  }
  if (nixies.bulbs & 0x20) { // Snow
    digitalWrite(STATUS_A_PIN, HIGH);
    digitalWrite(STATUS_B_PIN, LOW);
    digitalWrite(STATUS_C_PIN, HIGH);
    delayMicroseconds(nixieBulbDelayTime);
  }
}

time_t getNtpTime() {
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println(""connection failed"");
  }
  String url = ""/data/2.5/forecast?zip="";
  url += ZIPCODE;
  url += "",us&APPID="";
  url += APPID;
  url += ""&cnt=3"";

  Serial.print(""Requesting URL: "");
  Serial.println(url);

  // This will send the request to the server
  client.print(String(""GET "") + url + "" HTTP/1.1\r\n"" +
               ""Host: "" + host + ""\r\n"" +
               ""Connection: close\r\n\r\n"");
  delay(1000);

  // Read all the lines of the reply from server and print them to Serial
  while (client.available()) {
    String storedRequestString = client.readStringUntil('\r');
    if (storedRequestString.charAt(1) == '{') {
      storedRequestString.remove(0, 1);
      storedRequestString.remove(storedRequestString.length() - 1);
      Serial.print(""String: "");
      Serial.println(storedRequestString);
      int index1 = storedRequestString.indexOf(""\""dt\"":"");
      int index2 = storedRequestString.indexOf(""\""dt\"":"", index1 + 1);
      int index3 = storedRequestString.indexOf(""\""dt\"":"", index2 + 1);
      int weatherIndex1 = storedRequestString.indexOf(""\""weather\"":[{\""id\"":"", index1);
      int weatherIndex2 = storedRequestString.indexOf(""\""weather\"":[{\""id\"":"", index2);
      int weatherIndex3 = storedRequestString.indexOf(""\""weather\"":[{\""id\"":"", index3);
      String forecastString1 = storedRequestString.substring(weatherIndex1 + 17, weatherIndex1 + 20);
      String forecastString2 = storedRequestString.substring(weatherIndex2 + 17, weatherIndex2 + 20);
      String forecastString3 = storedRequestString.substring(weatherIndex3 + 17, weatherIndex3 + 20);
      Serial.println(forecastString1);
      Serial.println(forecastString2);
      Serial.println(forecastString3);
      nixies.bulbs &= 3;
      if (forecastString1.charAt(0) == '6' || forecastString2.charAt(0) == '6' || forecastString3.charAt(0) == '6') {
        nixies.bulbs |= 0x20; //SNOW
        Serial.println(""Snow"");
      }
      else if (forecastString1.charAt(0) == '5' || forecastString2.charAt(0) == '5' || forecastString3.charAt(0) == '5' || forecastString1.charAt(0) == '3' || forecastString2.charAt(0) == '3' || forecastString3.charAt(0) == '3' || forecastString1.charAt(0) == '2' || forecastString2.charAt(0) == '2' || forecastString3.charAt(0) == '2') {
        nixies.bulbs |= 0x10; //RAIN
        Serial.println(""Rain"");
      }
      else if ((forecastString1.charAt(0) == '8' || forecastString2.charAt(0) == '8' || forecastString3.charAt(0) == '8') && (forecastString1.charAt(2) != '0' || forecastString2.charAt(2) != '0' || forecastString3.charAt(2) != '0')) {
        nixies.bulbs |= 0x08; //CLOUDS
        Serial.println(""Clouds"");
      }
      else {
        nixies.bulbs |= 0x04; //CLEAR
        Serial.println(""Clear"");
      }

      Serial.println(forecastString1);
      Serial.println(forecastString2);
      Serial.println(forecastString3);
      /*
      const char* sensor = root[""coord""];
      const char* time = root[""weather""];
      Serial.println(sensor);
      Serial.println(time);
      */
    }
  }
  Serial.println();
  Serial.println(""closing connection"");

  while (udp.parsePacket() > 0) ; // discard any previously received packets
  Serial.println(""Transmit NTP Request"");
  sendNTPpacket(timeServer);
  uint32_t  [MASK]  = millis();
  while (millis() -  [MASK]  < 1500) {
    if (!udp.parsePacket()) {}
    else {
      Serial.println(""Receive NTP Response"");
      udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
      unsigned long secsSince1900;
      // convert four bytes starting at location 40 to a long integer
      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
      secsSince1900 |= (unsigned long)packetBuffer[43];
      return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
    }
  }
  Serial.println(""No NTP Response :-("");
  return 0; // return 0 if unable to get the time
}

void setup() {
  pinMode(GEIGER_PIN, INPUT);
  pinMode(GEIGER_LED, OUTPUT);
  digitalWrite(GEIGER_LED, LOW);
  pinMode(TIME_DATA_IN_PIN, OUTPUT);
  digitalWrite(TIME_DATA_IN_PIN, LOW);
  pinMode(TIME_CLK_PIN, OUTPUT);
  digitalWrite(TIME_CLK_PIN, LOW);
  pinMode(TIME_LE_PIN, OUTPUT);
  digitalWrite(TIME_LE_PIN, HIGH);
  pinMode(TIME_BL_PIN, OUTPUT);
  digitalWrite(TIME_BL_PIN, HIGH);
  pinMode(STATUS_A_PIN, OUTPUT);
  digitalWrite(STATUS_A_PIN, HIGH);
  pinMode(STATUS_B_PIN, OUTPUT);
  digitalWrite(STATUS_B_PIN, HIGH);
  pinMode(STATUS_C_PIN, OUTPUT);
  digitalWrite(STATUS_C_PIN, HIGH);
  drawNixies();

  Serial.begin(115200);

  // We start by connecting to a WiFi network
  Serial.print(""Connecting to "");
  Serial.println(ssid);
  WiFi.begin(ssid, pass);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(""."");
  }
  Serial.println("""");

  Serial.println(""WiFi connected"");
  Serial.println(""IP address: "");
  Serial.println(WiFi.localIP());

  Serial.println(""Starting UDP"");
  udp.begin(localPort);
  Serial.print(""Local port: "");
  Serial.println(udp.localPort());

  setSyncProvider(getNtpTime);
}

void loop() {
  analogWrite(GEIGER_LED, constrain((sin((((millis() / ledFadeTime) % 1024) - 0) * (6.28 - 0.00) / (1024 - 0) + 0.00) + 1.00) * 512.00, 5, 1015));
  drawNixies();
}

unsigned long sendNTPpacket(IPAddress& address) { // send an NTP request to the time server at the given address
  Serial.println(""sending NTP packet..."");
  // set all bytes in the buffer to 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12]  = 49;
  //  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;

  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:
  udp.beginPacket(address, 123); //NTP requests are to port 123
  udp.write(packetBuffer, NTP_PACKET_SIZE);
  udp.endPacket();
}
",beginWait
170,"//Hello!, this is a sketch to get remote control to your dragino device by bridge mode
//The original source and Pubsubclient code comes from: 
//https://github.com/knolleary/pubsubclient
//this is a modified sketch from those repository
//
//Hola ! Este es un sketch de prueba para tomar control remoto de su dispositivo dragino en modo bridge
//la libreria Pubsubclient.* y el codigo fuente proviene desde:
//https://github.com/knolleary/pubsubclient
//y este es un sketch modificado desde el repositorio origen y adaptado para funcionar con nuestra
//plataforma iot.redlibre.cl

#include <SPI.h>
#include <PubSubClient.h>
#include <YunClient.h>
#include <string.h>

int out2 = 2;
int out3 = 3;
int out4 = 4;
int out6 = 6;

char message_buff[100];

////Please here paste info from ""devinfo""////////////////
#define IOTUSERNAME ""ioioioioio""
#define IOTPASSWORD ""<PASSWORD>""
#define IOTDEVICE ""iiiiiiiii""
#define USERNAME ""uuuuuuuu""
/////////////////////////////////////////////////////////


////from here dont' modify anything///////////////////////////////////////////////

#define TOPIC  ""redlibre/iot/""USERNAME""/""IOTDEVICE""/""IOTUSERNAME""/iot/control/""
#define STATUS ""redlibre/iot/""USERNAME""/""IOTDEVICE""/""IOTUSERNAME""/status/""
#define IOTID USERNAME""/""IOTDEVICE

IPAddress server(190, 97, 169, 126);


void callback(char* topic, byte* payload, unsigned int length);

YunClient ethClient;
PubSubClient client(server, 1883, callback, ethClient);


void callback(char* topic, byte* payload, unsigned int length) {

  int i = 0;
   for(i=0; i<length; i++) {
    message_buff[i] = payload[i];
  }
  message_buff[i] = '\0';
  
  String  [MASK]  = String(message_buff);
  
 
if ( [MASK] .equals(""gpio2on"")) {
  digitalWrite(out2, HIGH);}
    
else if ( [MASK] .equals(""gpio2off"")) {
  digitalWrite(out2, LOW);}

else if ( [MASK] .equals(""gpio3on"")) {
  digitalWrite(out3, HIGH);}

else if ( [MASK] .equals(""gpio3off"")) {
  digitalWrite(out3, LOW);}

else if ( [MASK] .equals(""gpio4on"")) {
  digitalWrite(out4, HIGH);}

else if ( [MASK] .equals(""gpio3off"")) {
  digitalWrite(out4, LOW);}

else if ( [MASK] .equals(""gpio6on"")) {
  digitalWrite(out6, HIGH);}

else if ( [MASK] .equals(""gpio6off"")) {
  digitalWrite(out6, LOW);}

 
}



void setup()
{
  Bridge.begin();
  pinMode(out2, OUTPUT);
  pinMode(out3, OUTPUT);
  pinMode(out4, OUTPUT);
  pinMode(out6, OUTPUT);
  

  if (client.connect(IOTID, IOTUSERNAME, IOTPASSWORD)) {
   client.publish(STATUS,""hello world - authenticated!!"");
   client.subscribe(TOPIC);
  }
}

void loop()
{
  client.loop();
}

",msgString
171,"/*
Copyright 2016 Codependable, LLC and <NAME>

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 <QVBoxLayout>
#include <QHBoxLayout>
#include <QLabel>
#include <QDialogButtonBox>
#include <QTableWidget>
#include <QHeaderView>
#include ""AboutView.h""
#include ""BuildInfoCore.h""
#include ""ResourceManager.h""
#include ""tools/Tools.h""

namespace terbit
{

AboutView::AboutView(QWidget *parent) : QDialog(parent)
{
   setWindowTitle(_STR_PRODUCT_NAME);

   QVBoxLayout* l = new QVBoxLayout();
   QVBoxLayout* layoutProduct = new QVBoxLayout();
   QHBoxLayout* layoutProductCenter = new QHBoxLayout();

   QPixmap  [MASK] (ResourceManager::GetLogo());
   QLabel* logo = new QLabel();
   logo->setPixmap( [MASK] );
   logo->setFixedSize( [MASK] .size());


   layoutProduct->addWidget(logo);
   QLabel* lbl = new QLabel(tr(""Version: %1 %2"").arg(_STR_PRODUCT_VERSION).arg(CompilerOptions()));
   lbl->setTextInteractionFlags(Qt::TextSelectableByMouse);
   layoutProduct->addWidget(lbl);
   QString buildId = BUILD_ID_STR;
   buildId = buildId.left(10);
   lbl = new QLabel(tr(""Build: %1"").arg(buildId));
   lbl->setTextInteractionFlags(Qt::TextSelectableByMouse);
   layoutProduct->addWidget(lbl);
   layoutProduct->addSpacing(5);
   lbl = new QLabel(tr(""Compiler: %1"").arg(CompilerInfo()));
   lbl->setTextInteractionFlags(Qt::TextSelectableByMouse);
   layoutProduct->addWidget(lbl);
   lbl = new QLabel(tr(""Compiled Qt: %1"").arg(QT_VERSION_STR));
   lbl->setTextInteractionFlags(Qt::TextSelectableByMouse);
   layoutProduct->addWidget(lbl);
   lbl = new QLabel(tr(""Runtime Qt: %1"").arg(qVersion()));
   lbl->setTextInteractionFlags(Qt::TextSelectableByMouse);
   layoutProduct->addWidget(lbl);

   //strech sides to center product info
   layoutProductCenter->addStretch(1);
   layoutProductCenter->addLayout(layoutProduct);
   layoutProductCenter->addStretch(1);

   l->addSpacing(5);
   l->addLayout(layoutProductCenter);
   l->addSpacing(15);

   QLabel* terbitLink = new QLabel();
   //terbitLink->setTextInteractionFlags(Qt::TextSelectableByMouse);
   terbitLink->setOpenExternalLinks(true);
   terbitLink->setText(""<a href=\""https://github.com/shootingsoul/terbit-connector\"">github terbit-connector</a>"");
   l->addWidget(terbitLink,0,Qt::AlignCenter);

   lbl = new QLabel(QString(_STR_LEGAL_COPYRIGHT));
   lbl->setTextInteractionFlags(Qt::TextSelectableByMouse);
   l->addWidget(lbl,0,Qt::AlignCenter);

   lbl = new QLabel(QString(_STR_LEGAL_TRADE_1));
   //lbl->setTextInteractionFlags(Qt::TextSelectableByMouse);
   lbl->setOpenExternalLinks(true);
   lbl->setText(""<a href=\""https://www.apache.org/licenses/LICENSE-2.0.html\"">Apache License 2.0</a>"");
   l->addWidget(lbl,0,Qt::AlignCenter);


   QDialogButtonBox* b = new QDialogButtonBox(this);
   b->addButton(QDialogButtonBox::Ok);
   l->addWidget(b);
   connect(b, SIGNAL(accepted()), this, SLOT(accept()));

   setLayout(l);
}


}
",pix
172,"#pragma once

namespace cfa
{
using namespace std;

int CFA::compute_next_vertex()
{
    int vertex;

  if (mission[id_task].trail.size() - 1 == id_vertex)
  {
    vertex = mission[id_task].trail[id_vertex];
    if (mission[id_task].take)
    {
      request_Mission();
    }
    else
    {
      // pubblico un messaggio al view_result e gli dico sono a casa. quando tutti hanno mandato il messaggio scrivo i
      // risultati e end_simulation.
      int value = ID_ROBOT;
      if (value == -1)
      {
        value = 0;
      }

      // [ID,msg_type,vertex,intention,0]
      c_print(""ATHOMEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"", red, Pr);
      std_msgs::Int16MultiArray msg;
      msg.data.clear();
      msg.data.push_back(value);
      msg.data.push_back(AT_HOME_MSG_TYPE);
      // results_pub.publish(msg);
      ros::spinOnce();

      at_home = true;
    }
    //  ^ Importatnte!
    // mission.clear();
    c_print(""id_v: "", id_vertex, "" vertex: "", vertex, magenta);
    send_task_reached();
    id_vertex = 0;
  }
  else
  {
    vertex = mission[id_task].trail[id_vertex];
    c_print(""id_v: "", id_vertex, "" vertex: "", vertex, yellow);
    id_vertex++;
  }

  return vertex;
}

void CFA::onGoalComplete()
{
  if (next_vertex > -1)
  {
    // Update Idleness Table:
    // update_idleness();
    current_vertex = next_vertex;
  }

  // devolver proximo vertex tendo em conta apenas as idlenesses;

  if (!at_home)
    next_vertex = compute_next_vertex();
  else
  {
    c_print(""sono a casa!"", yellow, Pr);
    sendGoal(next_vertex);
    end_simulation = true;
  }

  // next_vertex = compute_next_vertex();

  c_print(""   @ compute_next_vertex: "", next_vertex, green);

  // printf(""Move Robot to Vertex %d (%f,%f)\n"", next_vertex,
  // vertex_web[next_vertex].x, vertex_web[next_vertex].y);

  /** SEND GOAL (REACHED) AND INTENTION **/

  send_goal_reached();  // Send TARGET to monitor

  send_results();  // Algorithm specific function

  // Send the goal to the robot (Global Map)
  ROS_INFO(""Sending goal - Vertex %d (%f,%f)\n"", next_vertex, vertex_web[next_vertex].x, vertex_web[next_vertex].y);
  // sendGoal(vertex_web[next_vertex].x, vertex_web[next_vertex].y);
  sendGoal(next_vertex);  // send to move_base

  goal_complete = false;
}

void CFA::run()
{
  // get ready
  ready();

  c_print(""@ Ready!"", green);

  // initially clear the costmap (to make sure the robot is not trapped):
  std_srvs::Empty srv;
  std::string  [MASK] ;

  if (ID_ROBOT > -1)
  {
    std::ostringstream id_string;
    id_string << ID_ROBOT;
     [MASK]  = ""robot_"" + id_string.str() + ""/"";
  }
   [MASK]  += ""move_base/clear_costmaps"";

  if (ros::service::call( [MASK] .c_str(), srv))
  {
    // if (ros::service::call(""move_base/clear_costmaps"", srv)){
    ROS_INFO(""Costmap correctly cleared before patrolling task."");
  }
  else
  {
    ROS_WARN(""Was not able to clear costmap (%s) before patrolling..."",  [MASK] .c_str());
  }

  // Asynch spinner (non-blocking)
  ros::AsyncSpinner spinner(2);  // Use n threads
  spinner.start();
  // ros::waitForShutdown();

  /* Run Algorithm */
  // init_agent2();

  ros::Rate loop_rate(30);  // 0.033 seconds or 30Hz

  while (ros::ok())
  {

    if (goal_complete)
    {
      onGoalComplete();  // can be redefined
      resend_goal_count = 0;
    }
    else
    {  // goal not complete (active)
      if (interference)
      {
        do_interference_behavior();
      }

      if (ResendGoal)
      {
        ROS_INFO(""Re-Sending goal (%d) - Vertex %d (%f,%f)"", resend_goal_count, next_vertex, vertex_web[next_vertex].x,
                 vertex_web[next_vertex].y);
        send_resendgoal();
        sendGoal(next_vertex);

        ResendGoal = false;  // para nao voltar a entrar (envia goal so uma vez)
      }

      processEvents();

      if (end_simulation)
      {
        return;
      }

    }  // if (goal_complete)
    // }// if (initialization)

    loop_rate.sleep();

  }  // while ros.ok
}


}// namesapce cfa",mb_string
173,"#pragma once
#include <stdint.h>

#include <algorithm>
#include <map>

class StreamUtilities {
 public:
	enum class EncodingTypes : u_int8_t {
		VARINT = 0,
		I64 = 1,
		LEN = 2,
		I32 = 5,
		INVALID = 10
	};

	static uint8_t parseVarint(uint8_t* buffer, size_t& result);
	static size_t getFieldNumber(const size_t fieldVarint);
	static EncodingTypes getFieldEncodeType(const size_t fieldVarint);

 private:
	static const uint8_t ENCODING_TYPE_BIT_LENGTH = 3;
};

uint8_t StreamUtilities::parseVarint(uint8_t* buffer, size_t& result) {
	std::vector<uint8_t> byteList;

	uint8_t offset = 0;
	while ((*(buffer + offset) & 0x80) == 0x80) {
		byteList.push_back((*(buffer + offset) & 0x7F));	// strip sign bit
		offset++;
	}

	// add last byte whose sign bit is not set
	byteList.push_back((*(buffer + offset) & 0x7F));
	offset++;

	result = 0;
	for (ssize_t i = static_cast<ssize_t>(byteList.size() - 1); i >= 0; i--) {
		// concatenate 7-bit valued bytes
		result += (static_cast<size_t>(byteList.at(static_cast<size_t>(i))) << (7 * i));
	}

	return offset;
}

size_t StreamUtilities::getFieldNumber(const size_t fieldVarint) {
	return fieldVarint >> ENCODING_TYPE_BIT_LENGTH;
}

StreamUtilities::EncodingTypes StreamUtilities::getFieldEncodeType(const size_t fieldVarint) {
	static const std::map<uint8_t, EncodingTypes>  [MASK] {
			std::make_pair(0, EncodingTypes::VARINT),
			std::make_pair(1, EncodingTypes::I64),
			std::make_pair(2, EncodingTypes::LEN),
			std::make_pair(5, EncodingTypes::I32),
	};

	uint8_t typeAsInt = fieldVarint & ENCODING_TYPE_BIT_LENGTH;
	if (std::any_of( [MASK] .cbegin(),  [MASK] .cend(), [&](const auto& pair) { return pair.first == typeAsInt; })) {
		return  [MASK] .at(typeAsInt);
	} else {
		return StreamUtilities::EncodingTypes::INVALID;
	}
}",encodingTypeMap
174,"#ifndef __OCR_UTILS_H__
#define __OCR_UTILS_H__

#include <opencv2/core.hpp>
#include ""OcrStruct.h""
#include ""onnxruntime/core/session/onnxruntime_cxx_api.h""
#include <android/log.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>

#define TAG ""OcrLite""
#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE,TAG,__VA_ARGS__)
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,TAG,__VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,TAG,__VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG,__VA_ARGS__)

#define __ENABLE_CONSOLE__ false
#define Logger(format, ...) {\
  if(__ENABLE_CONSOLE__) LOGI(format,##__VA_ARGS__); \
}

template<typename T, typename... Ts>
static std::unique_ptr<T> makeUnique(Ts &&... params) {
    return std::unique_ptr<T>(new T(std::forward<Ts>(params)...));
}

template<typename T>
static double getMean(std::vector<T> &input) {
    auto sum = accumulate(input.begin(), input.end(), 0.0);
    return sum / input.size();
}

template<typename T>
static double getStdev(std::vector<T> &input, double mean) {
    if (input.size() <= 1) return 0;
    double accum = 0.0;
    for_each(input.begin(), input.end(), [&](const double d) {
        accum += (d - mean) * (d - mean);
    });
    double stdev = sqrt(accum / (input.size() - 1));
    return stdev;
}

template<class T>
inline T clamp(T x, T  [MASK] , T max) {
    if (x > max)
        return max;
    if (x <  [MASK] )
        return  [MASK] ;
    return x;
}

double getCurrentTime();

ScaleParam getScaleParam(cv::Mat &src, const float scale);

ScaleParam getScaleParam(cv::Mat &src, const int targetSize);

cv::RotatedRect getPartRect(std::vector<cv::Point> &box, float scaleWidth, float scaleHeight);

int getThickness(cv::Mat &boxImg);

std::vector<cv::Point2f> getBox(const cv::RotatedRect &rect);

void drawTextBox(cv::Mat &boxImg, cv::RotatedRect &rect, int thickness);

void drawTextBox(cv::Mat &boxImg, const std::vector<cv::Point> &box, int thickness);

void drawTextBoxes(cv::Mat &boxImg, std::vector<TextBox> &textBoxes, int thickness);

cv::Mat matRotateClockWise180(cv::Mat src);

cv::Mat matRotateClockWise90(cv::Mat src);

cv::Mat getRotateCropImage(const cv::Mat &src, std::vector<cv::Point> box);

cv::Mat adjustTargetImg(cv::Mat &src, int dstWidth, int dstHeight);

std::vector<cv::Point2f> getMinBoxes(const cv::RotatedRect &boxRect, float &maxSideLen);

float boxScoreFast(const std::vector<cv::Point2f> &boxes, const cv::Mat &pred);

cv::RotatedRect unClip(std::vector<cv::Point2f> box, float unClipRatio);

std::vector<float>
substractMeanNormalize(cv::Mat &src, const float *meanVals, const float *normVals);

std::vector<int> getAngleIndexes(std::vector<Angle> &angles);

std::vector<Ort::AllocatedStringPtr> getInputNames(Ort::Session *session);

std::vector<Ort::AllocatedStringPtr> getOutputNames(Ort::Session *session);

void *getModelDataFromAssets(AAssetManager *mgr, const char *modelName, int &size);

std::string jstringTostring(JNIEnv *env, jstring input);

#endif //__OCR_UTILS_H__
",min
175,"/*
   Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)
   2022 <NAME>
   https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode

    You are free to:
        Share — copy and redistribute the material in any medium or format
        Adapt — remix, transform, and build upon the material

    The licensor cannot revoke these freedoms as long as you follow the license terms.
    Under the following terms:
        Attribution                —  You must give appropriate credit, provide a link to the license, and indicate if 
                                      changes were made.You may do so in any reasonable manner, but not in any way that 
                                      suggests the licensor endorses you or your use.
        NonCommercial              —  You may not use the material for commercial purposes.
        ShareAlike                 —  If you remix, transform, or build upon the material, you must distribute your contributions
                                      under the same license as the original.

        No additional restrictions —  You may not apply legal terms or technological measures that legally restrict
                                      others from doing anything the license permits.

*/



#include ""Dataverse.h""

/*! @brief  Constructor for Dataverse */
Dataverse::Dataverse(){}


// *********************************************************
//      Upload a file to a Dataset on a Dataverse
// *********************************************************
void Dataverse::UploadToDataverse(byte counter) {
  Dataverse::UploadToDataverse(0);
}
// *********************************************************
void Dataverse::UploadToDataverse(byte counter) {
  if(counter> THIS->MAX_ATTEMPT_REQUESTS)
    return;
    
  //Check WiFi connection status
  if(WiFi.status() != WL_CONNECTED){
    mserial.printStrln(""WiFi Disconnected"");
    if (connect2WIFInetowrk()){
      UploadToDataverse(counter+1);
    }
  }

  bool uploadStatusNotOK=true;
  if(datasetInfoJson[""data""].containsKey(""id"")){
    if(datasetInfoJson[""data""][""id""] !=""""){
      String rawResponse = GetInfoFromDataverse(""/api/datasets/""+ datasetInfoJson[""data""][""id""] +""/locks"");
      const size_t capacity =2*rawResponse.length() + JSON_ARRAY_SIZE(1) + 7*JSON_OBJECT_SIZE(1);
      DynamicJsonDocument datasetLocksJson(capacity);  
      // Parse JSON object
      DeserializationError error = deserializeJson(datasetLocksJson, rawResponse);
      if (error) {
        mserial.printStr(""unable to retrive dataset lock status. Upload not possible. ERR: ""+error.f_str());
        //mserial.printStrln(rawResponse);
        return;
      }else{
         String stat = datasetInfoJson[""status""];
         if(datasetInfoJson.containsKey(""lockType"")){

           String locktype = datasetInfoJson[""data""][""lockType""];           
           mserial.printStrln(""There is a Lock on the dataset: ""+ locktype); 
           mserial.printStrln(""Upload of most recent data is not possible without removal of the lock."");  
           // Do unlocking 
                
         }else{
            mserial.printStrln(""The dataset is unlocked. Upload possible."");
            uploadStatusNotOK=false;     
         }
      }
    }else{
      mserial.printStrln(""dataset ID is empty. Upload not possible. ""); 
    }
  }else{
    mserial.printStrln(""dataset metadata not loaded. Upload not possible. ""); 
  }
  
  if(uploadStatusNotOK){
    return;
  }

  // Open the dataset file and prepare for binary upload
  File datasetFile = FFat.open(""/""+EXPERIMENTAL_DATA_FILENAME, FILE_READ);
  if (!datasetFile){
    mserial.printStrln(""Dataset file not found"");
    return;
  }
    
  String boundary = ""7MA4YWxkTrZu0gW"";
  String contentType = ""text/csv"";
  DATASET_REPOSITORY_URL =  ""/api/datasets/:persistentId/add?persistentId=""+PERSISTENT_ID;
  
  String datasetFileName = datasetFile.name();
  String datasetFileSize = String(datasetFile.size());
  mserial.printStrln(""Dataset File Details:"");
  mserial.printStrln(""Filename:"" + datasetFileName);
  mserial.printStrln(""size (bytes): ""+ datasetFileSize);
  mserial.printStrln("""");
    
  int str_len = SERVER_URL.length() + 1; // Length (with one extra character for the null terminator)
  char SERVER_URL_char [str_len];    // Prepare the character array (the buffer) 
  SERVER_URL.toCharArray(SERVER_URL_char, str_len);    // Copy it over 
    
  client.stop();
  client.setCACert(HARVARD_ROOT_CA_RSA_SHA1);
  if (!client.connect(SERVER_URL_char, SERVER_PORT)) {
      mserial.printStrln(""Cloud server URL connection FAILED!"");
      mserial.printStrln(SERVER_URL_char);
      int server_status = client.connected();
      mserial.printStrln(""Server status code: "" + String(server_status));
      return;
  }
  mserial.printStrln(""Connected to the dataverse of Harvard University""); 
  mserial.printStrln("""");

  mserial.printStr(""Requesting URL: "" + DATASET_REPOSITORY_URL);

  // Make a HTTP request and add HTTP headers    
  String postHeader = ""POST "" + DATASET_REPOSITORY_URL + "" HTTP/1.1\r\n"";
  postHeader += ""Host: "" + SERVER_URL + "":"" + String(SERVER_PORT) + ""\r\n"";
  postHeader += ""X-Dataverse-key: "" + API_TOKEN + ""\r\n"";
  postHeader += ""Content-Type: multipart/form-data; boundary="" + boundary + ""\r\n"";
  postHeader += ""Accept: text/html,application/xhtml+xml,application/xml,application/json;q=0.9,*/*;q=0.8\r\n"";
  postHeader += ""Accept-Encoding: gzip,deflate\r\n"";
  postHeader += ""Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"";
  postHeader += ""User-Agent: AeonLabs LDAD Smart DAQ device\r\n"";
  postHeader += ""Keep-Alive: 300\r\n"";
  postHeader += ""Connection: keep-alive\r\n"";
  postHeader += ""Accept-Language: en-us\r\n"";

  // jsonData header
  String jsonData = ""{\""description\"":\""LIVE Experimental data upload from LDAD Smart 12bit DAQ \"",\""categories\"":[\""Data\""], \""restrict\"":\""false\"", \""tabIngest\"":\""false\""}"";     
  String  [MASK]  = ""--"" + boundary + ""\r\n"";
   [MASK]  += ""Content-Disposition: form-data; name=\""jsonData\""\r\n\r\n"";
   [MASK]  += jsonData+""\r\n"";

  // dataset header
  String datasetHead = ""--"" + boundary + ""\r\n"";
  datasetHead += ""Content-Disposition: form-data; name=\""file\""; filename=\"""" + datasetFileName + ""\""\r\n"";
  datasetHead += ""Content-Type: "" + contentType + ""\r\n\r\n"";

  // request tail
  String tail = ""\r\n--"" + boundary + ""--\r\n\r\n"";

  // content length
  int contentLength =  [MASK] .length() + datasetHead.length() + datasetFile.size() + tail.length();
  postHeader += ""Content-Length: "" + String(contentLength, DEC) + ""\n\n"";
  
  // send post header
  int postHeader_len=postHeader.length() + 1; 
  char charBuf0[postHeader_len];
  postHeader.toCharArray(charBuf0, postHeader_len);
  client.print(charBuf0);
  mserial.printStr(charBuf0);

  // send key header
  char charBufKey[ [MASK] .length() + 1];
   [MASK] .toCharArray(charBufKey,  [MASK] .length() + 1);
  client.print(charBufKey);
  mserial.printStr(charBufKey);

  // send request buffer
  char charBuf1[datasetHead.length() + 1];
  datasetHead.toCharArray(charBuf1, datasetHead.length() + 1);
  client.print(charBuf1);
  mserial.printStr(charBuf1);

  // create buffer
  const int bufSize = 2048;
  byte clientBuf[bufSize];
  int clientCount = 0;

  while (datasetFile.available()) {
    clientBuf[clientCount] = datasetFile.read();
    clientCount++;
    if (clientCount > (bufSize - 1)) {
        client.write((const uint8_t *)clientBuf, bufSize);
        clientCount = 0;
    }
  }
  datasetFile.close();
  if (clientCount > 0) {
      client.write((const uint8_t *)clientBuf, clientCount);
      mserial.printStrln(""[binary data]"");
  }

  // send tail
  char charBuf3[tail.length() + 1];
  tail.toCharArray(charBuf3, tail.length() + 1);
  client.print(charBuf3);
  mserial.printStr(charBuf3);

  // Read all the lines on reply back from server and print them to mserial
  mserial.printStrln("""");
  mserial.printStrln(""Response Headers:"");
  String responseHeaders = """";

  while (client.connected()) {
    // mserial.printStrln(""while client connected"");
    responseHeaders = client.readStringUntil('\n');
    mserial.printStrln(responseHeaders);
    if (responseHeaders == ""\r"") {
      mserial.printStrln(""======   end of headers ======"");
      break;
    }
  }

  String responseContent = client.readStringUntil('\n');
  mserial.printStrln(""Harvard University's Dataverse reply was:"");
  mserial.printStrln(""=========="");
  mserial.printStrln(responseContent);
  mserial.printStrln(""=========="");
  mserial.printStrln(""closing connection"");
  client.stop();
}

// *********************************************************
//            Make data request to Dataverse (GET)
// *********************************************************
void Dataverse::GetInfoFromDataverse(String url) {
  Dataverse::GetInfoFromDataverse(url,0);
}

// *********************************************************
String Dataverse::GetInfoFromDataverse(String url, byte counter) {
    if(counter> THIS->MAX_ATTEMPT_REQUESTS)
        return;

    //Check WiFi connection status
    if(WiFi.status() != WL_CONNECTED){
        mserial.printStrln(""WiFi Disconnected"");
        if (connect2WIFInetowrk()){
            GetInfoFromDataverse(url, counter+1);
        }
    }
            
  int str_len = SERVER_URL.length() + 1; // Length (with one extra character for the null terminator)
  char SERVER_URL_char [str_len];    // Prepare the character array (the buffer) 
  SERVER_URL.toCharArray(SERVER_URL_char, str_len);    // Copy it over 
    
  client.stop();
  client.setCACert(HARVARD_ROOT_CA_RSA_SHA1);
    
  if (!client.connect(SERVER_URL_char, SERVER_PORT)) {
      mserial.printStrln(""Cloud server URL connection FAILED!"");
      mserial.printStrln(SERVER_URL_char);
      int server_status = client.connected();
      mserial.printStrln(""Server status code: "" + String(server_status));
      return """";
  }
  
  mserial.printStrln(""Connected to the dataverse of Harvard University""); 
  mserial.printStrln("""");
  
  // We now create a URI for the request
  mserial.printStr(""Requesting URL: "");
  mserial.printStrln(url);

  // Make a HTTP request and add HTTP headers    
  // post header
  String postHeader = ""GET "" + url + "" HTTP/1.1\r\n"";
  postHeader += ""Host: "" + SERVER_URL + "":"" + String(SERVER_PORT) + ""\r\n"";
  //postHeader += ""X-Dataverse-key: "" + API_TOKEN + ""\r\n"";
  postHeader += ""Content-Type: text/json\r\n"";
  postHeader += ""Accept: text/html,application/xhtml+xml,application/xml,application/json,text/json;q=0.9,*/*;q=0.8\r\n"";
  postHeader += ""Accept-Encoding: gzip,deflate\r\n"";
  postHeader += ""Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"";
  postHeader += ""User-Agent: AeonLabs LDAD Smart DAQ device\r\n"";
  //postHeader += ""Keep-Alive: 300\r\n"";
  postHeader += ""Accept-Language: en-us\r\n"";
  postHeader += ""Connection: close\r\n\r\n"";

  // request tail
  String boundary = ""7MA4YWxkTrZu0gW"";
  String tail = ""\r\n--"" + boundary + ""--\r\n\r\n"";

  // content length
  int contentLength = tail.length();
  //postHeader += ""Content-Length: "" + String(contentLength, DEC) + ""\n\n"";
  
  // send post header
  int postHeader_len=postHeader.length() + 1; 
  char charBuf0[postHeader_len];
  postHeader.toCharArray(charBuf0, postHeader_len);
  client.print(charBuf0);
  
  mserial.printStrln(""======= Headers ======="");
  mserial.printStrln(charBuf0);
  mserial.printStrln(""======= End of Headers ======="");
  
  // Read all the lines of the reply from server and print them to mserial
  String responseHeaders = """";

  mserial.printStr(""Waiting for server response..."");
  long timeout= millis();
  long ttl=millis()-timeout;
  while (client.connected() && abs(ttl) < HTTP_TTL) {
    ttl=millis()-timeout;      
    responseHeaders = client.readStringUntil('\n');
    if (responseHeaders == ""\r"") {
      break;
    }
  }
  if (abs(ttl) < 10000){
    mserial.printStrln(""OK"");
  }else{
    mserial.printStrln(""timed out."");  
  }
  
  String responseContent = client.readStringUntil('\n');
  client.stop();

  return responseContent;
  }",jsonDataHeader
176,"#include<iostream>
#include<conio.h>
#include<fstream>
#include<windows.h>
using namespace std;

struct node
{
    string data;
    node * next;
}*start[52];


class linked_Dic
{
    private:
        node *head, *tail;
        char words[50];
    public:
        linked_Dic();//for Linked List Creation
        void create();
        void display();//Display Linked List
        void search1(string);
};

linked_Dic::linked_Dic()//Alphabet Linked list creation
{
    char alphabet='A';
    for(int i=0; i<51; i++)//Capital+Small Alphabets
    {
        start[i]=new struct node;
        start[i]->data=alphabet;
        start[i]->next=NULL;
        alphabet++;
        if(i==25)
        {
            alphabet='a';
        }
    }
}

void linked_Dic::create()
{
    int i=0;
    char input='y';
    struct node *ptr_data, *ptr_trav;
    while(input=='y' || input=='Y')
    {
        cout<<""Enter New String : "";
        ptr_data=new struct node;
        cin>>ptr_data->data;
        ptr_data->next=NULL;

        char file_name[6];
        file_name[0]=ptr_data->data[0];
        file_name[1]='.';
        file_name[2]='t';
        file_name[3]='x';
        file_name[4]='t';
        file_name[5]='\0';
        struct node *link=NULL;
        fstream file_object;
        file_object.open(file_name,ios::out | ios::app);
        file_object<<ptr_data->data<<endl;

        while(start[i]->data[0]!=ptr_data->data[0])
        {
            i++;
        }
        ptr_trav=start[i];
        while(ptr_trav->next!=NULL)
        {
            ptr_trav=ptr_trav->next;
        }
        ptr_trav->next=ptr_data;
        ptr_trav=ptr_data;
        cout<<""Would you like to enter more..? (Y=Yes || N=No):"";
        cin>>input;
        i=0;
    }
}

void linked_Dic::search1(string arg1)
{
    string readString;
    char file_name[6];
    file_name[0]=arg1[0];
    file_name[1]='.';
    file_name[2]='t';
    file_name[3]='x';
    file_name[4]='t';
    file_name[5]='\0';
    fstream file_object;
    file_object.open(file_name,ios::in);
    if(file_object)
    {
        do
        {
            file_object>>readString;
            if(readString==arg1)
            {
                cout<<endl<<""Search Success-full - The searched word is present in the Dictionary"";
                break;
            }
        }
        while(!file_object.eof());
        if(file_object.eof())
        {
            cout<<endl<<""No such word saved in the Dictionary..."";
        }
    }
    else
    {
        cout<<endl<<""No such word saved in the Dictionary..."";
    }
    getch();
}
void linked_Dic::display()//display the Linked List.
{
    int i=0;
    struct node *ptr_tra=NULL;

    while(i<51)
    {
        ptr_tra=start[i];
        if(ptr_tra==NULL)
        {
            cout<<""Nothing to Display"";
        }
        else
        {
            do
            {
                cout<<"" ""<<ptr_tra->data;
            }
            while((ptr_tra->next!=NULL) && (cout<<"" -> "") && (ptr_tra=ptr_tra->next));
        }
        cout<<endl;
        i++;
    }
}

int main()
{
    linked_Dic obj;
    string input_string, value, strInput;
    int  [MASK] ;
    do
    {
        cout<<""**********Menu**********"";
        cout<<""\n1.Enter a word"";
        cout<<""\n2.Display Words"";
        cout<<""\n3.Search Word"";
        cout<<""\n4.Exit Screen"";
        cout<<""\n______________________"";
        cout<<""\n\nEnter Your Choice:"";

        cin>> [MASK] ;

        switch( [MASK] )
        {
            case 1:
                obj.create();
                getch();
                break;
            case 2:
                obj.display();
                getch();
                break;
            case 3:
                cout<<endl<<""Enter the word to be Searched: "";cin>>strInput;
                obj.search1(strInput);
                getch();
                break;
        }
        system(""CLS"");
    }while( [MASK] !=4);
}


",choice
177,"// Copyright 2016 <NAME> <<EMAIL>>
// Apache License Version 2.0. See LICENSE file
// Most Servo Sweep code by BARRAGAN <http://barraganstudio.com> and <NAME> http://www.arduino.cc/en/Tutorial/Sweep
// Heart pulse code by Sparkfun https://www.sparkfun.com/tutorials/329

#include <Servo.h>

const int buttonPin = 2;
const int ledPin1 = 10;
const int ledPin2 = 11;
const int heartPin = 6;
const int servoPin = 9;
unsigned long startTime;
unsigned long currentTime;

Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos = 0;    // variable to store the servo position
int buttonState = 0; 
int lookingLeft = 0;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(heartPin, OUTPUT);
  digitalWrite(ledPin1, LOW);
  digitalWrite(ledPin2, LOW);
  analogWrite(heartPin, 0);

  myservo.attach(servoPin);  // attaches the servo on pin 9 to the servo object
  myservo.write(90);              // tell servo to go to position in variable 'pos' 
  delay(1000);
  myservo.detach();  
}

void loop() {
  float heartIn,  [MASK] ;

  buttonState = digitalRead(buttonPin);

  if (lookingLeft == 0) {
    if (buttonState == HIGH) {
        digitalWrite(ledPin1, HIGH);
        digitalWrite(ledPin2, HIGH);
        myservo.attach(servoPin);  // attaches the servo on pin 9 to the servo object
        myservo.write(180);              // tell servo to go to position in variable 'pos'
        delay(1500);
        myservo.detach();  

        // Check time
        startTime = millis();
      
        lookingLeft = 1;
    }
  } else {
     // Pulse Heart
     for (heartIn = 0; heartIn < 6.283; heartIn = heartIn + 0.001)
     {
        [MASK]  = sin(heartIn) * 127.5 + 127.5;
       analogWrite(heartPin,  [MASK] );
     }
     
     // Check time elapsed
     currentTime = millis();
      
     // If 10 seconds passed, look straight again else exit and loop
     if (currentTime - startTime >= 10000){
        digitalWrite(ledPin1, LOW);
        digitalWrite(ledPin2, LOW);
        analogWrite(heartPin, 0);
        myservo.attach(servoPin);  // attaches the servo on pin 9 to the servo object
        myservo.write(90);              // tell servo to go to position in variable 'pos'   
        delay(1500);
        myservo.detach();  
        lookingLeft = 0;
      }
  }
}

",heartOut
178,"//          Copyright <NAME> 2018.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE.md or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#include <fmidi/fmidi.h>
#include <getopt.h>
#if defined(FMIDI_GREP_HAVE_FTS)
#include <fts.h>
#else
#include <filesystem>
#include <system_error>
namespace fs = std::filesystem;
#endif
#include <sys/stat.h>
#include <regex>
#include <stdio.h>
#include <string.h>

#if defined(FMIDI_GREP_HAVE_FTS)
struct FTS_Deleter {
    void operator()(FTS *x) const noexcept
        { fts_close(x); }
};
#endif

class Pattern {
public:
    virtual ~Pattern() {}
    virtual bool match(const char *p, size_t n, const char **matchp, size_t *matchn) const = 0;
};

static bool do_file(const char *path, const Pattern &pattern, bool &has_match, bool matched_part_only)
{
    fmidi_smf_u smf(fmidi_smf_file_read(path));
    if (!smf)
        return false;

    struct callback_data {
        const char *path = nullptr;
        const Pattern *pattern = nullptr;
        bool *has_match = nullptr;
        bool matched_part_only = false;
    };

    callback_data cbdata;
    cbdata.path = path;
    cbdata.pattern = &pattern;
    cbdata.has_match = &has_match;
    cbdata.matched_part_only = matched_part_only;

    fmidi_smf_describe_by_line(
        smf.get(), [](const char *data, size_t size, void *cookie) {
            callback_data *cbdata = (callback_data *)cookie;
            const char *matchp = nullptr;
            size_t matchn = 0;
            if (cbdata->pattern->match(data, size, &matchp, &matchn)) {
                fputs(cbdata->path, stdout);
                fputc(':', stdout);
                if (!cbdata->matched_part_only) {
                    fwrite(data, 1, size, stdout);
                    if (size == 0 || data[size - 1] != '\n')
                        fputc('\n', stdout);
                }
                else {
                    fwrite(matchp, 1, matchn, stdout);
                    if (matchn == 0 || matchp[matchn - 1] != '\n')
                        fputc('\n', stdout);
                }
                *cbdata->has_match = true;
            }
        },
        &cbdata);

    return true;
}

static bool do_tree(const char *path, const Pattern &pattern, bool &has_match, bool matched_part_only)
{
    bool success = true;

#if defined(FMIDI_GREP_HAVE_FTS)
    char *const path_argv[2] = {(char *)path, nullptr};
    std::unique_ptr<FTS, FTS_Deleter> fts(fts_open(path_argv, FTS_LOGICAL|FTS_NOCHDIR, nullptr));

    if (!fts)
        return false;

    while (FTSENT *ent = fts_read(fts.get())) {
        if (S_ISREG(ent->fts_statp->st_mode))
            success &= do_file(ent->fts_path, pattern, has_match, matched_part_only);
    }
#else
    std::error_code ec;
    fs::recursive_directory_iterator it{path, ec};
    if (ec)
        return false;
    while (it != fs::recursive_directory_iterator{}) {
        ec.clear();
        fs::file_status st = it->status(ec);
        if (!ec && st.type() == fs::file_type::regular) {
#if defined(_WIN32)
            success &= do_file(it->path().u8string().c_str(), pattern, has_match, matched_part_only);
#else
            success &= do_file(it->path().c_str(), pattern, has_match, matched_part_only);
#endif
        }
        ec.clear();
        it.increment(ec);
        if (ec) {
            success = false;
            break;
        }
    }
#endif

    return success;
}

class Grep_Pattern : public Pattern {
public:
    explicit Grep_Pattern(const char *pattern)
        : re_(pattern, std::regex::grep) {}
    bool match(const char *p, size_t n, const char **matchp, size_t *matchn) const override
    {
        std::cmatch m;
        if (!std::regex_search(p, p + n, m, re_))
            return false;
        *matchp = m[0].first;
        *matchn = m[0].length();
        return true;
    }
private:
    std::regex re_;
};

class EGrep_Pattern : public Pattern {
public:
    explicit EGrep_Pattern(const char *pattern)
        : re_(pattern, std::regex::egrep) {}
    bool match(const char *p, size_t n, const char **matchp, size_t *matchn) const override
    {
        std::cmatch m;
        if (!std::regex_search(p, p + n, m, re_))
            return false;
        *matchp = m[0].first;
        *matchn = m[0].length();
        return true;
    }
private:
    std::regex re_;
};

class Text_Pattern : public Pattern {
public:
    explicit Text_Pattern(const char *pattern)
        : pat_(pattern), patlen_(strlen(pattern)) {}
    bool match(const char *p, size_t n, const char **matchp, size_t *matchn) const override
    {
        const char *q = (const char *)memmem(p, n, pat_, patlen_);
        if (!q)
            return false;
        *matchp = q;
        *matchn = patlen_;
        return true;
    }
private:
    const char *pat_ = nullptr;
    size_t patlen_ = 0;
};

void usage()
{
    fputs(
        ""Usage: fmidi-grep [options] <pattern> <input> [input...]\n""
        ""  -r,-R   recursive\n""
        ""  -E      extended pattern\n""
        ""  -F      fixed string pattern\n""
        ""  -o      matched part only\n""
        """",
        stderr);
}

int main(int argc, char *argv[])
{
    bool recurse = false;
    unsigned pattern_mode = std::regex::grep;
    bool matched_part_only = false;

    for (int c; (c = getopt(argc, argv, ""rREFoh"")) != -1;) {
        switch (c) {
        case 'r': case 'R':
            recurse = true; break;
        case 'E':
            pattern_mode = std::regex::egrep; break;
        case 'F':
            pattern_mode = 0; break;
        case 'o':
            matched_part_only = true; break;
        case 'h':
            usage(); return 0;
        default:
            usage(); return 1;
        }
    }

    if (argc - optind < 2) {
        usage();
        return 1;
    }

    bool success = true;

    const char *pattern = argv[optind];
    const char **inputs = (const char **)&argv[optind + 1];
    unsigned  [MASK]  = argc - optind - 1;

    std::unique_ptr<Pattern> pat;
    switch (pattern_mode) {
    case std::regex::grep:
        pat.reset(new Grep_Pattern(pattern)); break;
    case std::regex::egrep:
        pat.reset(new EGrep_Pattern(pattern)); break;
    default:
        pat.reset(new Text_Pattern(pattern)); break;
    }

    bool has_match = false;
    for (unsigned i = 0; i <  [MASK] ; ++i) {
        const char *input = inputs[i];
        success &= (recurse ? do_tree : do_file)(input, *pat, has_match, matched_part_only);
    }
    if (!has_match)
        success = false;

    return success ? 0 : 1;
}
",num_inputs
179,"#include ""Ledstrip.h""

uint8_t redValue, blueValue, greenValue = 0;
CRGB leds[NUM_LEDS];

void setupLedstrip() {
  LEDS.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  LEDS.setBrightness(50);
  Serial.println(""Ledstrip initialized"");
  powerOffLedstrip();
  updateLedstrip();
}
void updateBrigtness(double  [MASK] ) {
  LEDS.setBrightness( [MASK] );
}
void setRGBLedstrip(uint8_t red, uint8_t green, uint8_t blue) {
  for (int j = 0; j < NUM_LEDS; j++) {
    leds[j].setRGB(red, green, blue);
  }

  if(redValue != red || blueValue != blue || greenValue != green) {
    redValue = red;
    blueValue = blue;
    greenValue = green;
    updateLedstrip();
  }
}

void powerOffLedstrip() {
  for (int j = 0; j < NUM_LEDS; j++) {
     leds[j].nscale8( 250);
  }
  updateLedstrip();
}

void setRedValue(int position, uint8_t red) {
  redValue = red;
  leds[position].setRGB(red, 0, 0);
}

void setBlueValue(int position, uint8_t blue) {
  blueValue = blue;
  leds[position].setRGB(0, 0, blue);
}

void setGreenValue(int position, uint8_t green) {
  greenValue = green;
  leds[position].setRGB(0, green, 0);
}

void updateLedstrip() {
  FastLED.show();
}
",brightness
180,"/*
Copyright 2019 <NAME>

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 ""barista.h""

void GhettoBarista::setCelsiusMode(bool enable) {
  m_isCelsius = enable;
}

void GhettoBarista::setFahrenheitMode(bool enable) {
  m_isCelsius = !enable;
}

void GhettoBarista::setGroupHeadTemp(double temp) {
  m_groupTemp = temp;
}

void GhettoBarista::setGroupHeadOffset(double  [MASK] ) {
  m_groupOffset =  [MASK] ;
}

void GhettoBarista::setDesiredWaterTemp(double temp) {
  m_waterTempSetpoint = temp;
}

void GhettoBarista::startPumpTimer(unsigned long start) {
  if (m_pumpStart)
    return;
  m_pumpStart = start;
}

void GhettoBarista::startPumpTimer() {
  startPumpTimer(millis());
}

void GhettoBarista::stopPumpTimer() {
  updatePumpRuntime();
  m_pumpStart = 0;
}

void GhettoBarista::updatePumpRuntime() {
  if (m_pumpStart)
    m_pumpRuntime = millis() - m_pumpStart;
}

void GhettoBarista::resetPumpRuntime() {
  m_pumpRuntime = 0;
}

void GhettoBarista::estimateWaterTemp() {
  m_waterTemp = m_groupTemp + m_groupOffset;
}

void GhettoBarista::refresh() {
  estimateWaterTemp();
  if (m_isCooling && m_waterTemp <= m_waterTempSetpoint)
    stopCoolingFlush();
}

void GhettoBarista::startCoolingFlush() {
  if (m_waterTemp <= m_waterTempSetpoint)
    return;
  m_shouldStartPump = true;
  m_isCooling = true;
}

void GhettoBarista::stopCoolingFlush() {
  m_shouldStartPump = false;
  m_isCooling = false;
}

bool GhettoBarista::getPumpWantedState() {
  return m_shouldStartPump;
}
",offset
181,"#include <iostream>
#include <array>
#include <vector>
#include <iomanip>
#include <map>
#include <random>
#include <cmath>

#include ""src/Ckmeans.1d.dp.h""

template <int N, int K> struct cluster {
   std::array<int,N>    clusters;
   std::array<double,N> centers;
   std::array<double,N> withinss;
   std::array<double,K> size;
   std::array<double,K> BIC; // TODO check - fixes the segfault but should probably be kMax
};

// FORWARD DECLARATIONS

template <int N, int K> void rebase(cluster<N,K>&);
template <int N, int K> void compare(cluster<N,K>&,cluster<N,K>&);

void testWeightedInput(const std::string&);
void testGivenK(const std::string&);
void testNlteK(const std::string&);
void testKeq2(const std::string&);
void testKeq1(const std::string&);
void testN10K3(const std::string&);
void testN14K8(const std::string&);
void testEstimateKExampleSet1(const std::string& method);
void testEstimateKExampleSet2(const std::string& method);
void testEstimateKExampleSet3(const std::string& method);
void testEstimateKExampleSet4(const std::string& method);

void testTaps();

// MAIN
int main(int argc,char *argv[]) {
    std::cout << ""ckmeans v4.3.3"" << std::endl;

   std::string methods[] = { ""linear"", ""loglinear"", ""quadratic"" };

   for (const std::string &method: methods) {
        std::cout << std::endl << method << std::endl;
    
        testWeightedInput(method);           // Go'd
        testGivenK(method);                  // Go'd
        testNlteK(method);                   // Go'd
        testKeq2(method);                    // Go'd
        testKeq1(method);                    // Go'd
        testN10K3(method);                   // Go'd
        testN14K8(method);                   // Go'd
        testEstimateKExampleSet1(method);
        testEstimateKExampleSet2(method);
        testEstimateKExampleSet3(method);
        testEstimateKExampleSet4(method);

   }
    
    testTaps();

    return 0;
}


void testTaps() {
     double taps[] = { 4.570271991, 5.063594027, 5.603539973, 6.102690998, 6.642708943, 7.141796968, 7.710649857, 8.192470916,
                       4.506176116, 5.045971061, 5.591722996, 6.114172975, 6.619153989, 7.13578898,  7.693071891, 8.203885893,
                       4.52956007,  5.057670039, 5.591721996, 6.13742393,  6.630941966, 7.1766839,   7.69897488,  8.227207848,
                       4.52956007,  5.069284016, 5.603428973, 6.102591998, 6.613455,    7.147644957, 7.69912088,  8.215609871,
                       4.517865093, 5.022782107, 5.580101018, 6.096715009, 6.654118921, 7.1763719,   7.681405914, 8.215537871,
                                    5.133092891, 5.545395086, 6.067721066, 6.578564068, 7.130096991, 7.652464971, 8.13427303,
                       4.494581138, 5.040234073, 5.562732052, 6.079333043, 6.624973977, 7.141650968, 7.664070948, 8.198270905,
                       4.52940807,  5.040295073, 5.556940064, 6.131584941, 6.654145921, 7.193876866, 7.722112835, 8.244539814,
                       4.523631082, 5.046071061, 5.586102007, 6.09099502,  6.596029034, 7.130224991, 7.652501971, 8.180805939,
                       4.517979093, 5.046165061, 5.551068075, 6.073547054, 6.607636011, 7.165018923, 7.687334903, 8.238953825,
                       4.517911093, 5.069403016, 5.586174007, 6.108568986, 6.578649068, 7.147523957, 7.681606914, 8.26211078
                     };

     cluster<87,87> p = {{},{},{},{}};
     std::map<int, std::vector<double>>  [MASK] ;

     kmeans_1d_dp(taps, 87, NULL, 1, 87,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                 ""BIC"", ""linear"", L2);
 
     rebase(p);

     for (int i=0; i<87; i++) {
         int beat = p.clusters[i];

          [MASK] [beat].push_back(taps[i]) ;
     }

     std::cout << ""TAPS:"" << std::endl << ""   "";
     std::copy(std::begin(p.clusters), std::end(p.clusters), std::ostream_iterator<int>(std::cout, "" ""));
     std::cout << std::endl;

     for (std::map<int,std::vector<double>>::iterator it= [MASK] .begin(); it !=  [MASK] .end(); ++it) {
         std::cout << ""   "" << it->first << "" => "";
         for (std::vector<double>::iterator j=it->second.begin(); j != it->second.end(); ++j) {
             std::cout << std::setprecision(6) << std::setfill(' ') << std::setw(9) << std::left << *j;
         }
         // std::copy(std::begin(it->second), std::end(it->second), std::ostream_iterator<double>(std::cout, "" ""));
         std::cout << std::endl;
     }

     std::cout << ""centers:  "";
     for (int i=0; i< [MASK] .size(); i++) {
         std::cout << p.centers[i] << "" "";  
     }
     std::cout << std::endl;

     std::cout << ""withinss: "";
     for (int i=0; i< [MASK] .size(); i++) {
         std::cout << p.withinss[i] << "" "";  
     }
     std::cout << std::endl;

     std::cout << ""sizes:    "";
     for (int i=0; i< [MASK] .size(); i++) {
         std::cout << p.size[i] << "" "";  
     }
     std::cout << std::endl;
}

// test_that(""Weighted input"", {
void testWeightedInput(const std::string& method) {
     std::cout << ""   test with weighted input"" << std::endl;

     { double        data[]    = {-1, 2, 4, 5, 6};
       double        weights[] = { 4, 3, 1, 1, 1};
       cluster<5,3> p = {{},{},{},{}};
       cluster<5,3> q = {{1,2,3,3,3},{-1, 2, 5},{0,0,2},{4,3,3}};

       kmeans_1d_dp(data, 5, weights, 3, 3,
                    p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                    ""BIC"", method, L2);
 
       rebase(p);
       compare(p,q);
     }

     { double data[]    = {-0.9, 1, 1.1, 1.9, 2, 2.1};
       double weights[] = { 3,   1, 2,   2,   1, 1  };
       cluster<6,3> p = {{},{},{},{}};
       cluster<6,3> q = {{1,2,2,3,3,3},{-0.9, 1.0666667, 1.975},{0,0.00666667,0.0275},{3,3,4}};
//     cluster<6,3> q = {{1,2,2,3,3,3},{-0.9, (1+2.2)/3, (1.9*2+2+2.1)/4},{0,0.00666667,0.0275},{3,3,4}};

       kmeans_1d_dp(data, 6, weights, 1, 6,
                    p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                    ""BIC"", method, L2);
 
       rebase(p);
       compare(p,q);
     }
}

// test_that(""Given the number of clusters"", {
void testGivenK(const std::string& method) {
     std::cout << ""   test with given number of clusters"" << std::endl;

     double        data[] = {-1, 2, -1, 2, 4, 5, 6, -1, 2, -1};
     cluster<10,3> p = {{},{},{},{}};
     cluster<10,3> q = {{1,2,1,2,3,3,3,1,2,1},{-1, 2, 5},{0,0,2},{4,3,3}};

     kmeans_1d_dp(data, 10, NULL, 3, 3,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);

     // Ref. https://stackoverflow.com/questions/8637460/k-means-return-value-in-r
     //
     // totss.truth <- sum(scale(x, scale=FALSE)^2)
     // expect_equal(result$totss, totss.truth)
     // expect_equal(result$tot.withinss, 2)
     // expect_equal(result$betweenss, totss.truth - sum(withinss.truth))
}

// test_Ckmeans.1d.dp::test_that(""n<=k""...
void testNlteK(const std::string& method) {
     std::cout << ""   test with N<=K"" << std::endl;

     double        data[] = {3, 2, -5.4, 0.1};
     cluster<4,4> p = {{},{},{},{}};
     cluster<4,4> q = {{4, 3, 1, 2},{-5.4, 0.1, 2, 3},{0, 0, 0, 0},{1, 1, 1, 1}};

     kmeans_1d_dp(data, 4, NULL, 4, 4,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);
}

// test_Ckmeans.1d.dp::test_that(""k==2""...
void testKeq2(const std::string& method) {
     std::cout << ""   test with K=2"" << std::endl;

     double        data[] = {1,2,3,4,5,6,7,8,9,10};
     cluster<10,2> p = {{},{},{},{}};
     cluster<10,2> q = {{1, 1, 1, 1, 1, 2, 2, 2, 2, 2},{3,8},{10,10},{5,5}};

     kmeans_1d_dp(data, 10, NULL, 2, 2,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);
}


// test_Ckmeans.1d.dp::test_that(""k==1""...
void testKeq1(const std::string& method) {
     { std::cout << ""   test with single unique value"" << std::endl;
     
       double       data[] = {-2.5,-2.5,-2.5,-2.5};
       cluster<4,1> p = {{},{},{},{}};
       cluster<4,1> q = {{1,1,1,1}, {-2.5}, {0}, {4}};

       kmeans_1d_dp(data, 4, NULL, 1, 1,
                    p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                    ""BIC"" ,method, L2);

       rebase(p);
       compare(p,q);
     }

     { static std::random_device rd;
       static std::mt19937 e2(rd());
       static std::uniform_real_distribution<> dist(-100.0, +100.0);
  
       std::cout << ""   test with K=1"" << std::endl;
  
       double         data[100];
       cluster<100,1> p = {{},{},{},{}};
       cluster<100,1> q = {{}, {}, {}, {100}};
  
       for (int i=0; i<100; i++) {
           data[i] = dist(rd);
       }
  
       kmeans_1d_dp(data, 100, NULL, 1, 1,
                    p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                    ""BIC"", method, L2);
   
       if (p.size != q.size) {
          std::cout << "" returned invalid size"" << std::endl;
          std::cout << ""   expected: [ "";
          std::copy(std::begin(q.size), std::end(q.size), std::ostream_iterator<double>(std::cout, "" ""));
          std::cout << ""]"" << std::endl;
          std::cout << ""   got:      [ "";
          std::copy(std::begin(p.size), std::end(p.size), std::ostream_iterator<double>(std::cout, "" ""));
          std::cout << ""]"" << std::endl;
       }
     }
}

// test_that(""n==10, k==3""...
void testN10K3(const std::string& method) {
     std::cout << ""   test with n=10, k=3"" << std::endl;

     double        data[]    = {3, 3, 3, 3, 1, 1, 1, 2, 2, 2};
     cluster<10,3> p = {{},{},{},{}};
     cluster<10,3> q = {{3, 3, 3, 3, 1, 1, 1, 2, 2, 2},{1, 2, 3},{0, 0, 0},{3, 3, 4}};

     kmeans_1d_dp(data, 10, NULL, 3, 3,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);
}

// test_that(""n==14, k==8""...
void testN14K8(const std::string& method) {
     std::cout << ""   test with n=14, k=8"" << std::endl;

     double        data[] = {-3, 2.2, -6, 7, 9, 11, -6.3, 75, 82.6, 32.3, -9.5, 62.5, 7, 95.2};
     cluster<14,8> p = {{},{},{},{}};
     cluster<14,8> q = {{2, 2, 1, 3, 3, 3, 1, 6, 7, 4, 1, 5, 3, 8},
                        {-7.266666667, -0.4, 8.5, 32.3, 62.5, 75.0, 82.6, 95.2},
                        {7.526666667, 13.52, 11.0, 0.0, 0.0, 0.0, 0.0, 0.0},
                        {3, 2, 4, 1, 1, 1, 1, 1}};

     kmeans_1d_dp(data, 14, NULL, 8, 8,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);
}

// test_that(""Estimating k example set 1""...
void testEstimateKExampleSet1(const std::string& method) {
     std::cout << ""   test estimate K, example set 1"" << std::endl;

     { double       data[] = {0.9, 1, 1.1, 1.9, 2, 2.1};
       cluster<6,6> p = {{},{},{},{}};
       cluster<6,6> q = {{1,1,1,2,2,2},{1,2},{0.02,0.02},{3,3}};

       kmeans_1d_dp(data, 6, NULL, 1, 6,
                    p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                    ""BIC"", method, L2);
 
       rebase(p);
       compare(p,q);
     }

     { double       data[] = {2.1, 2, 1.9, 1.1, 1, 0.9};
       cluster<6,6> p = {{},{},{},{}};
       cluster<6,6> q = {{2,2,2,1,1,1},{1,2},{0.02,0.02},{3,3}};

       kmeans_1d_dp(data, 6, NULL, 1, 6,
                    p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                    ""BIC"", method, L2);
 
       rebase(p);
       compare(p,q);
     }

     { double       data[] = {2.1, 2, 1.9, 1.1, 1, 0.9};
       cluster<6,6> p = {{},{},{},{}};
       cluster<6,6> q = {{2,2,2,1,1,1},{1,2},{0.02,0.02},{3,3}};

       kmeans_1d_dp(data, 6, NULL, 1, 10,
                    p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                    ""BIC"", method, L2);

       rebase(p);
       compare(p,q);
     }
}

// test_that(""Estimating k example set 2""...
void testEstimateKExampleSet2(const std::string& method) {
     std::cout << ""   test estimate K, example set 2"" << std::endl;

     double        data[] = {3.5, 3.6, 3.7, 3.1, 1.1, 0.9, 0.8, 2.2, 1.9, 2.1};
     cluster<10,3> p = {{},{},{},{}};
     cluster<10,3> q = {{3, 3, 3, 3, 1, 1, 1, 2, 2, 2},{0.933333333333, 2.066666666667, 3.475},{0.0466666666667, 0.0466666666667, 0.2075},{3, 3, 4}};

     kmeans_1d_dp(data, 10, NULL, 2, 5,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);
}

// test_that(""Estimating k example set 3 cosine""...
void testEstimateKExampleSet3(const std::string& method) {
     std::cout << ""   test estimate K, example set 3 (cosine)"" << std::endl;

     // x <- cos((-10:10))
     double data[] = { -0.8390715,-0.9111303,-0.1455000,0.7539023,0.9601703,0.2836622,
                       -0.6536436,-0.9899925,-0.4161468,0.5403023,1.0000000,0.5403023,
                       -0.4161468,-0.9899925,-0.6536436,0.2836622,0.9601703,0.7539023,
                       -0.1455000,-0.9111303,-0.8390715
                     };

     cluster<21,2> p = {{},{},{},{}};
     cluster<21,2> q = {{1,1,1,2,2,2,1,1,1,2,2,2,1,1,1,2,2,2,1,1,1}, {-0.6592474631, 0.6751193405},{1.0564793100, 0.6232976959},{12,9}};

     kmeans_1d_dp(data, 21, NULL, 1, 21,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);
     
}

// test_that(""Estimating k example set 4 gamma"", {
void testEstimateKExampleSet4(const std::string& method) {
     std::cout << ""   test estimate K, example set 4 (gamma)"" << std::endl;

     // x <- dgamma(seq(1,10, by=0.5), shape=2, rate=1)
     double data[] = { 0.3678794412,0.3346952402,0.2706705665,0.2052124966,0.1493612051,
                       0.1056908420,0.0732625556,0.0499904844,0.0336897350,0.0224772429,
                       0.0148725131,0.0097723548,0.0063831738,0.0041481328,0.0026837010,
                       0.0017294811,0.0011106882,0.0007110924,0.0004539993
                     };

     cluster<19,3> p = {{},{},{},{}};
     cluster<19,3> q = {{3,3,3,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1}, {0.01702193495, 0.15342151455, 0.32441508262},{0.006126754998,0.004977009034,0.004883305120},{13,3,3}};

     kmeans_1d_dp(data, 19, NULL, 1, 19,
                  p.clusters.data(), p.centers.data(), p.withinss.data(), p.size.data(), p.BIC.data(),
                  ""BIC"", method, L2);
 
     rebase(p);
     compare(p,q);
}

template <int N, int K> void rebase(cluster<N,K>& p) {
     for (size_t i=0; i<N; ++i) {
         p.clusters[i] += 1;
     }
}

template <int N, int K> void compare(cluster<N,K>& p, cluster<N,K>& q) {
     if (p.clusters != q.clusters) {
        std::cout << ""     returned invalid clusters"" << std::endl;
        std::cout << ""        expected: [ "";
        std::copy(std::begin(q.clusters), std::end(q.clusters), std::ostream_iterator<int>(std::cout, "" ""));
        std::cout << ""]"" << std::endl;
        std::cout << ""        got:      [ "";
        std::copy(std::begin(p.clusters), std::end(p.clusters), std::ostream_iterator<int>(std::cout, "" ""));
        std::cout << ""]"" << std::endl;
     }

     if (p.centers != q.centers) {
        for (int i=0; i<K; i++) {
            double d = abs(p.centers[i] - q.centers[i]);

            if (d > 0.00001) {
               std::cout << ""     returned invalid centers"" << std::endl;
               std::cout << ""        expected: [ "";
               std::copy(std::begin(q.centers), std::end(q.centers), std::ostream_iterator<double>(std::cout, "" ""));
               std::cout << ""]"" << std::endl;
               std::cout << ""        got:      [ "";
               std::copy(std::begin(p.centers), std::end(p.centers), std::ostream_iterator<double>(std::cout, "" ""));
               std::cout << ""]"" << std::endl;
               break;
            }
        }
     }

     if (p.withinss != q.withinss) {
        for (int i=0; i<K; i++) {
            double d = abs(p.withinss[i] - q.withinss[i]);

            if (d > 0.00001) {
               std::cout << ""     returned invalid withins"" << std::endl;
               std::cout << ""       expected: [ "";
               std::copy(std::begin(q.withinss), std::end(q.withinss), std::ostream_iterator<double>(std::cout, "" ""));
               std::cout << ""]"" << std::endl;
               std::cout << ""       got:      [ "";
               std::copy(std::begin(p.withinss), std::end(p.withinss), std::ostream_iterator<double>(std::cout, "" ""));
               std::cout << ""]"" << std::endl;
               break;
            }
        }
     }

     if (p.size != q.size) {
        std::cout << ""     returned invalid size"" << std::endl;
        std::cout << ""       expected: [ "";
        std::copy(std::begin(q.size), std::end(q.size), std::ostream_iterator<double>(std::cout, "" ""));
        std::cout << ""]"" << std::endl;
        std::cout << ""       got:      [ "";
        std::copy(std::begin(p.size), std::end(p.size), std::ostream_iterator<double>(std::cout, "" ""));
        std::cout << ""]"" << std::endl;
     }
}

",beats
182,"#include ""Ellipse.h""

// Constructeur par défaut : Centre à (0,0), a = 1 et b = 0.5 par défaut.
Ellipse::Ellipse() : h(0), k(0), a(1), b(0.5), orientation('X') {
    if (a <= b) {
        std::swap(a, b);
    }
}

Ellipse::Ellipse(double h, double k, double a, double b, char orientation)
    : h(h), k(k), a(a), b(b), orientation(orientation) {
    if (a <= b) {
        std::cerr << ""Erreur : a doit etre superieur a b. Les valeurs sont echangées."" << std::endl;
        std::swap(this->a, this->b);
    }
}

Ellipse::Ellipse(const Ellipse &other)
    : h(other.h), k(other.k), a(other.a), b(other.b), orientation(other.orientation) {}

void Ellipse::setCenter(double h, double k) {
    this->h = h;
    this->k = k;
}

std::pair<double, double> Ellipse::getCenter() const {
    return {h, k};
}

void Ellipse::setAxes(double a, double b) {
    if (a > b) {
        this->a = a;
        this->b = b;
    } else {
        std::cerr << ""Erreur : a doit etre superieur a b."" << std::endl;
    }
}

std::pair<double, double> Ellipse::getAxes() const {
    return {a, b};
}

void Ellipse::setOrientation(char orientation) {
    if (orientation == 'X' || orientation == 'Y')
        this->orientation = orientation;
}

char Ellipse::getOrientation() const {
    return orientation;
}

double Ellipse::computeC() const {
    return sqrt(a * a - b * b);
}

std::vector<std::pair<double, double>> Ellipse::getVertices() const {
    std::vector<std::pair<double, double>> vertices;
    if (orientation == 'X') {
        vertices.push_back({h - a, k});
        vertices.push_back({h + a, k});
    } else {
        vertices.push_back({h, k - a});
        vertices.push_back({h, k + a});
    }
    return vertices;
}

std::vector<std::pair<double, double>> Ellipse::getFoci() const {
    double c = computeC();
    std::vector<std::pair<double, double>> foci;
    if (orientation == 'X') {
        foci.push_back({h - c, k});
        foci.push_back({h + c, k});
    } else {
        foci.push_back({h, k - c});
        foci.push_back({h, k + c});
    }
    return foci;
}

double Ellipse::getFocalChordLength() const {
    return (2 * b * b) / a;
}

double Ellipse::getEccentricity() const {
    return computeC() / a;
}

void Ellipse::printEquationAndPoints() const {
    if (orientation == 'X')
        std::cout << ""Equation: ((x - "" << h << "")^2)/"" << (a * a)
                  << "" + ((y - "" << k << "")^2)/"" << (b * b) << "" = 1"" << std::endl;
    else
        std::cout << ""Equation: ((x - "" << h << "")^2)/"" << (b * b)
                  << "" + ((y - "" << k << "")^2)/"" << (a * a) << "" = 1"" << std::endl;
    
    std::cout << ""Centre: ("" << h << "", "" << k << "")"" << std::endl;
    
    auto vertices = getVertices();
    std::cout << ""Vertices: "";
    for (auto &v : vertices)
        std::cout << ""("" << v.first << "", "" << v.second << "") "";
    std::cout << std::endl;
    
    auto foci = getFoci();
    std::cout << ""Foyers: "";
    for (auto &f : foci)
        std::cout << ""("" << f.first << "", "" << f.second << "") "";
    std::cout << std::endl;
}

int Ellipse::pointPosition(double x, double y) const {
    double value;
    if (orientation == 'X')
        value = ((x - h) * (x - h)) / (a * a) + ((y - k) * (y - k)) / (b * b);
    else
        value = ((x - h) * (x - h)) / (b * b) + ((y - k) * (y - k)) / (a * a);
    
    if (fabs(value - 1.0) < 1e-6)
        return 0;   // Sur l'ellipse
    else if (value < 1)
        return -1;  // A l'interieur
    else
        return 1;   // A l'exterieur
}

double Ellipse::approximatePerimeter() const {
    return M_PI * (3 * (a + b) - sqrt((3 * a + b) * (a + 3 * b)));
}

double Ellipse::area() const {
    return M_PI * a * b;
}

double Ellipse::computeOtherCoordinate(double  [MASK] , bool isXGiven) const {
    double result = 0, term;
    if (isXGiven) { // x donné, calcul de y
        if (orientation == 'X')
            term = 1 - (( [MASK]  - h) * ( [MASK]  - h)) / (a * a);
        else
            term = 1 - (( [MASK]  - h) * ( [MASK]  - h)) / (b * b);
        
        if (term < 0) {
            std::cerr << ""La coordonnee x="" <<  [MASK]  << "" n'appartient pas a l'ellipse."" << std::endl;
            return NAN;
        }
        result = (orientation == 'X') ? k + b * sqrt(term) : k + a * sqrt(term);
    } else { // y donné, calcul de x
        if (orientation == 'X')
            term = 1 - (( [MASK]  - k) * ( [MASK]  - k)) / (b * b);
        else
            term = 1 - (( [MASK]  - k) * ( [MASK]  - k)) / (a * a);
        
        if (term < 0) {
            std::cerr << ""La coordonnee y="" <<  [MASK]  << "" n'appartient pas a l'ellipse."" << std::endl;
            return NAN;
        }
        result = (orientation == 'X') ? h + a * sqrt(term) : h + b * sqrt(term);
    }
    return result;
}
",givenValue
183,"//Copyright (c) 2006-2008 <NAME> and <NAME>, Inc.

//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef UUID_0552D49838DD11DD90146B8956D89593
#define UUID_0552D49838DD11DD90146B8956D89593

#include <boost/exception/get_error_info.hpp>
#include <exception>
#include <sstream>
#include <string>

namespace
boost
    {
    namespace
    exception_detail
        {
        inline
        char const *
        get_diagnostic_information( exception const & x )
            {
            if( error_info_container * c=x.data_.get() )
                try
                    {
                    return c->diagnostic_information();
                    }
                catch(...)
                    {
                    }
            return 0;
            }
        }

    inline
    std::string
    diagnostic_information( exception const & x )
        {
        std::ostringstream  [MASK] ;
        if( boost::shared_ptr<char const * const> f=get_error_info<throw_file>(x) )
            {
             [MASK]  << *f;
            if( boost::shared_ptr<int const> l=get_error_info<throw_line>(x) )
                 [MASK]  << '(' << *l << ""): "";
            }
         [MASK]  << ""Throw in function "";
        if( boost::shared_ptr<char const * const> fn=get_error_info<throw_function>(x) )
             [MASK]  << *fn;
        else
             [MASK]  << ""(unknown)"";
#ifndef BOOST_NO_RTTI
         [MASK]  << ""\nDynamic exception type: "" << BOOST_EXCEPTION_DYNAMIC_TYPEID(x).name();
        if( std::exception const * e=dynamic_cast<std::exception const *>(&x) )
             [MASK]  << ""\nstd::exception::what: "" << e->what();
#endif
        if( char const * s=exception_detail::get_diagnostic_information(x) )
            if( *s )
                 [MASK]  << '\n' << s;
        return  [MASK] .str();
        }
    }

#endif
",tmp
184,"/*--- 
      FIRST VERSION:
      COPY this into a main.cpp in a NetBeans
      C++ Application Project (replace the given contents)

      improved 2019-03-30 with comment with ready-for-test-expression cout
      for easier test call setup (thanks <NAME>!)
 ---*/

/*---
    by: <NAME> & <NAME>
    last modified:
---*/

#include <cstdlib>
#include <iostream>
#include <string>
#include <cmath>
#include <fstream>

using namespace std;

/*--- PUT YOUR SIGNATURES, PURPOSES, and FUNCTION DEFINITIONS HERE ---*/






/*---
   test the functions above
---*/

int main()
{
    cout << boolalpha;
    
    // From Autumn
    
    const string FONT_SIZE = ""<font size= \""+2\"">"";
    
    
    string file_name;
    string cat_name;
    string cat_sex;
    string cat_;
    string adoptee_name;
    string adoptee_age;
    string adoptee_address;
    string why_adopt;
    string past_experience;
    string DL_number;
    string litter_box; 
    string financial_food;
    string  [MASK] ;
    string title;
    
    cout << ""Give File Name(ex. Ruby1123): "";
    
    cin >> file_name;
    cout << endl;
    
    //file_name = ""/c/Users/west/Desktop/Cats/"" + file_name + "".html""; // set to .html later //
    
    
    file_name = file_name + "".html"";
    cout << file_name << endl;
    
    ofstream fout;
    fout.open(file_name);
    if(fout.fail())
    {
        cout << ""Failed to open file"" << endl;
    }
    
    
    
    cout << ""Adoptee Name: "";
    
    getline(cin, adoptee_name);  
    getline(cin, adoptee_name);
    
    cout << endl;
            
    cout << endl << ""Adoptee Address: "";
    
    getline(cin, adoptee_address);
    
    cout << endl;
            
    cout << endl << ""DL #: "";
    
    getline(cin, DL_number);
    
    cout << endl;
            
    cout << ""Why they want to adopt? "";
    
    getline(cin, why_adopt);
    
    cout << endl;
            
    cout << ""Any Past Experiences with cats? "";
    
    getline(cin, past_experience);
    
    cout << endl;
    
    cout << ""Do you have a litter box? "";
    
    getline(cin, litter_box);
            
    cout << endl;
    
    cout << ""Adequate financial means to feed a cat? "";
    
    getline(cin, financial_food);
    
    cout << endl;
    
    cout << ""Will you allow the cat to roam outside? "";
    
    getline(cin,  [MASK] );
    
    cout << endl;
    
    
    
    //fout << FONT_SIZE << ""Name: "" << ""<input type=\""text\"" value= "" << cat_name << "">"" << ""<br>"";
    
    //cout << ""Any past""
    
    
   // fout << ""<font size= \""+6\"">"" << ""           People Trying to Adopt a cat          "" << title << endl;
     
    
    
    fout << FONT_SIZE << ""<h1><pre>"" << ""          People Trying to Adopt a cat          "" << ""</pre></h1>"" << endl;
    
    fout << ""<ul>"" << endl;
    
    fout << ""<li>Adoptee Name: "" << adoptee_name << ""</li>"";
    
    fout << endl;
    
    fout << ""<li>Adoptee Address: "" << adoptee_address << ""</li>"";
    
    fout << endl;
    
    
    fout << ""<li>DL #: "" << DL_number << ""</li>"";
    
    fout << endl;
    
    fout << ""<li>Why they want to adopt?: "" << why_adopt << ""</li>"";
    
    fout << endl;
    
    fout << ""<li>Any Past Experiences with cats?: "" << past_experience << ""</li>"";
    
    fout << endl;
    
    fout << ""<li>Do you have a litter box?: "" << litter_box << ""</li>"";
    
    fout << endl;
    
    fout << ""<li>Adequate financial means to feed a cat?: "" << financial_food << ""</li>"";
    
    fout << endl;
    
    fout << ""<li>Will you allow the cat to roam outside?: "" <<  [MASK]  << ""</li>"";
    
    fout << ""</ul>"" << endl;
    
    
    
    
    
    return EXIT_SUCCESS;
}",inside_outside_cat
185,"#include ""Application.h""

#include ""ECS/ECS.h""
#include ""Log.h""
#include ""Renderer.h""
#include ""InputManager.h""

#include ""SDL.h""
#include ""SDL_ttf.h""
#include ""SDL_image.h""
#include ""SDL_mixer.h""

namespace DrEngine {

	Renderer* Application::renderer = nullptr;
	SDL_Event Application::event;
	float Application::DeltaTime = 0.0f;
	Uint32 Application::Milliseconds = 0;
	InputManager* Application::inputManager;

	ECS::Manager* Application::manager;

	Uint64 NOW = SDL_GetPerformanceCounter();
	Uint64 LAST = 0;
	
	Application::Application(char* name, int  [MASK] , int height, bool fullscreen)
	{
		AppName = name;

		/* SDL Init */
		if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
		{
			DE_CORE_ERROR(""SDL_Init Error: {0}"", SDL_GetError());
		}

		/* Creating Window */
		window = new Window();
		if (!window->Initialize(AppName,  [MASK] , height, fullscreen))
		{
			DE_CORE_ERROR(""Window failed to initialize"");
		}

		/* Creating Renderer */
		renderer = new Renderer();
		if (!renderer->Initialize(window))
		{
			DE_CORE_ERROR(""Renderer failed to initialize"");
		}

		/* Attaching Renderer to Window */
		window->SetRenderer(renderer);

		/* TTF Init */
		if (TTF_Init() != 0)
		{
			DE_CORE_ERROR(""TTF_Init Error: {0}"", TTF_GetError());
		}

		/* Image Init */
		constexpr int ImgFlags = IMG_INIT_PNG | IMG_INIT_JPG;
		if (IMG_Init(ImgFlags) != ImgFlags)
		{
			DE_CORE_ERROR(""IMG_Init Error: {0}"", IMG_GetError());
		}

		/* Mixer Init */
		constexpr int MixerFlags = 0 | MIX_INIT_MP3;
		if (Mix_Init(MixerFlags) != MixerFlags)
		{
			DE_CORE_ERROR(""Mix_Init Error: {0}"", Mix_GetError());
		}
		if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 8, 1024) < 0)
		{
			DE_CORE_ERROR(""Mix_OpenAudio Error: {0}"", Mix_GetError());
		}
		Mix_AllocateChannels(32);
		
		/* Init Manager */
		manager = new ECS::Manager();
	}

	Application::~Application()
	{

	}

	void Application::Run()
	{
		BeginPlay();
		while (true)
		{
			Milliseconds = SDL_GetTicks();
			
			LAST = NOW;
			NOW = SDL_GetPerformanceCounter();

			DeltaTime = (NOW - LAST)*1000 / (float)SDL_GetPerformanceFrequency();
			
			SDL_PumpEvents();
			while (SDL_PollEvent(&Application::event))
			{
				Application::inputManager->PollEvent();
				if ((event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE) || event.type == SDL_QUIT)
				{
					SDL_Quit();
					return;
				}
			}
			
			Update(DeltaTime);
			Draw(DeltaTime);
			
			Application::inputManager->ResetMouseDelta();
		}
	}

	void Application::BeginPlay()
	{
		inputManager = new InputManager();
		inputManager->Init();
	}

	void Application::Update(float deltaTime)
	{
		Application::inputManager->Update();
		manager->Update(deltaTime);
	}

	void Application::Draw(float deltaTime)
	{
		SDL_RenderClear(Application::renderer->GetSDLRenderer());
		
		manager->Draw(deltaTime); // Calls Draw() on all Entities and Components
		
		SDL_SetRenderDrawColor(Application::renderer->GetSDLRenderer(), 0, 0, 0, 255);	// Let components draw color without worrying to set the colour back to default (black) before
		SDL_RenderPresent(Application::renderer->GetSDLRenderer());								// rendering next frame, if color not set to default then whole screen will be colored the RenderDrawColor.
	}

	void Application::AddCollisionComp(CollisionComponent* inComp)
	{
		manager->AddCollisionComp(inComp);
	}
}
",width
186,"#include ""BasicCamera.h""

#include <GLFW\glfw3.h>
#include <glm\glm.hpp>
#include <glm\gtc\matrix_transform.hpp>

#include ""Input.h""

using namespace glm;

BasicCamera::BasicCamera() : BasicCamera(vec3(0, 0, 0)) {
    
}

BasicCamera::BasicCamera(vec3  [MASK] ) {
    _pos =  [MASK] ;
    _front_vec = glm::vec3(0, 0, 1);
    _theta = degrees(atan(_front_vec.x / _front_vec.z));
    _phi = degrees(atan(_front_vec.y / length(vec2(_front_vec.x, _front_vec.z))));
    _speed = 40;
    _rotation_speed = 0.1;
}

BasicCamera::~BasicCamera() {}

void BasicCamera::update(float time_elapsed) {
    vec3 up_vec = vec3(0, 1, 0);
    if (Input::key_pressed_down(GLFW_KEY_W)) {
        _pos += _front_vec * _speed * time_elapsed;
    }
    if (Input::key_pressed_down(GLFW_KEY_S)) {
        _pos -= _front_vec * _speed * time_elapsed;
    }
    if (Input::key_pressed_down(GLFW_KEY_D)) {
        _pos += normalize(cross(_front_vec, up_vec)) * _speed * time_elapsed;
    }
    if (Input::key_pressed_down(GLFW_KEY_A)) {
        _pos -= normalize(cross(_front_vec, up_vec)) * _speed * time_elapsed;
    }
    if (Input::key_pressed_down(GLFW_KEY_Q)) {
        _pos += up_vec * _speed * time_elapsed;
    }
    if (Input::key_pressed_down(GLFW_KEY_E)) {
        _pos -= up_vec * _speed * time_elapsed;
    }

    vec2 mouse_change = Input::cursor_change();

    if (length(mouse_change) < FLT_EPSILON) return;

    _theta += mouse_change.x * _rotation_speed;
    _phi -= mouse_change.y * _rotation_speed;

    if (_phi > 89.0f)
        _phi = 89.0f;
    if (_phi < -89.0f)
        _phi = -89.0f;

    vec3 front;
    front.x = cos(radians(_theta)) * cos(radians(_phi));
    front.y = sin(radians(_phi));
    front.z = sin(radians(_theta)) * cos(radians(_phi));
    _front_vec = normalize(front);
}

glm::mat4 BasicCamera::getViewMatrix() {
    return glm::lookAt(_pos, _pos + _front_vec, vec3(0, 1, 0));
}

glm::mat4 BasicCamera::getProjectionMatrix() {
    int width, height;
    glfwGetWindowSize(glfwGetCurrentContext(), &width, &height);
    return glm::perspective(radians(45.f), width / (float) height, 0.01f, 1000.f);
}",starting_pos
187,"#include ""./downloader.hpp""

#include ""./strategy.hpp""

#include ""cryptoconnect/structs/events.hpp""
#include ""cryptoconnect/structs/universe.hpp""

#include <boost/asio/thread_pool.hpp>

CBProDownloader::CBProDownloader(CBProStrategy *strategy) : strategy_(strategy){};

void CBProDownloader::downloadLatestBars(
    Universe::Universe const &universe,
    std::unordered_map<std::string, Events::bars_t> &barsDataMap)
{
    constexpr int numDays = 3;
    constexpr int numBars = 288 * numDays; // 288 x 5 mins per day
    uint64_t timeNow = Utils::Datetime::epochNow<std::chrono::seconds>();

    // Public endpoint rate limit is 3 req/sec for CoinbasePro
    boost::asio::thread_pool pool(3);
    for (auto const productId : universe)
    {
        // Emplace an empty vector into the map
        barsDataMap.emplace(productId, Events::bars_t());
        barsDataMap[productId].reserve(numBars);

        boost::asio::post(
            pool,
            [this, timeNow, productId, &barsDataMap]
            {
                uint64_t  [MASK]  = timeNow;
                // Get 7 days of data
                for (int j = 0; j < numDays; j++)
                {
                    this->strategy_->adapter_->getBars(
                        productId,
                        ""300"",                                                   // 5-min bars
                        Utils::Datetime::epochToIsostring( [MASK]  - 86100), // - 23hrs 55mins
                        Utils::Datetime::epochToIsostring( [MASK] ),
                        barsDataMap[productId]);
                     [MASK]  -= 86400;
                }
            });
    }
    pool.join();
}
",queryEndTime
188,"#include <atomic>
#include <iostream>
#include <typeinfo>
#include <cxxabi.h>
#include <memory>
#include <string>
#include <vector>

template<typename T>
void is_lock_free(std::atomic<T>& a);

std::string demangle(const char* name) {
    int status = -1;
    std::unique_ptr<char, void(*)(void*)>  [MASK]  {
        abi::__cxa_demangle(name, NULL, NULL, &status),
        std::free
    };
    return (status == 0) ?  [MASK] .get() : name;
}

int main() {
    std::cout << ""C++ Standard: "" << __cplusplus << "" :"" << std::endl;

    std::atomic<int> x = 10;
    is_lock_free(x);

    std::atomic<double> y = 10.4;
    is_lock_free(y);

    std::atomic<char> c = 'z';
    is_lock_free(c);

    std::atomic<int*> cp = nullptr;
    is_lock_free(cp);

    std::atomic<std::shared_ptr<std::string>> z(std::make_shared<std::string>(""Hello""));
    is_lock_free(z);
}

template<typename T>
void is_lock_free(std::atomic<T>& a) {
    if (std::atomic_is_lock_free(&a)) {
        std::cout << demangle(typeid(T).name()) << "" is lock-free"" << std::endl;
    } else {
        std::cout << demangle(typeid(T).name()) << "" is NOT lock-free"" << std::endl;
    }
}",res
189,"/*!
 * @copyright This example code is in the Public Domain (or CC0 licensed, at your option.)

 * Unless required by applicable law or agreed to in writing, this
   software is distributed on an ""AS IS"" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
 */

#include ""app_priv.h""

extern ""C"" {
#include <app_reset.h>
#include <sdkconfig.h>
}

bool rm_sgl_sw_state = DEFAULT_SWITCH_POWER;
bool rm_light_sw_state = DEFAULT_SWITCH_POWER;
bool rm_relay_sw_state[4] = {DEFAULT_SWITCH_POWER};

int8_t brt_level = DEFAULT_BRT;
int16_t hue_level = DEFAULT_HUE;
static bool brt_sw_direction = SW_DIRECTION_UP;
static bool hue_sw_direction = SW_DIRECTION_UP;

static unsigned long last_event_time_brt = 0;
static unsigned long last_event_time_hue = 0;

/* Index 0: on/off; Index 1: Brt; Index 2: Hue */
bool light_sw_array[3] = {false};
/* Index 0: switch_1; Index 1: switch_2; Index 2: switch_3; Index 3: switch_4 */
bool relay_sw_array[4] = {false};

/**
 * This section is for driver initialisation and other generic driver functions.
 */
//=======================================================================================================================

/*!
 *  @brief Initiate the driver, of all the display screens and modules.
 */
void init_app_driver(void) 
{
    Serial.begin(115200);
    init_m5();
    init_images();
    init_neohex();
    display_start_screen();
    display_sgl_switch_screen();
    display_light_screen();
    display_relay_screen();
    esp_log_level_set(""gpio"", ESP_LOG_NONE);
}

/*!
 *  @brief This is the main screen callback to switch between examples,
           reset wifi or factory reset.
 *  @param event Logs in the type of event that is driven by the type
                  of example and button pressed.
 */
void scrn_event_cb(lv_event_t *event) 
{

    lv_event_code_t event_code = lv_event_get_code(event);

    /* Handle different events */
    switch (event_code) {
    case LV_EVENT_PRESSING: // Return to home screen
        if (lvgl_port_lock()) {
            disc_relay();
            set_start_scrn();
            show_start_screen();
            lvgl_port_unlock();
        }
        break;
    case LV_EVENT_PRESSED: // Switch to next page
        if (is_sgl_sw_scrn) {
            set_lighting_state(DEFAULT_SWITCH_POWER);
            set_light_scrn();
            show_light_scrn();
            set_light_sw_state(rm_light_sw_state);
        } else if (is_light_scrn) {
            set_lighting_state(DEFAULT_SWITCH_POWER);
            init_relay();
            set_relay_sw_scrn();
            show_relay_scrn();
            set_relay_sw_state();
        } else if (is_relay_scrn) {
            disc_relay();
            set_sgle_sw_scrn();
            show_sgl_switch_screen();
            set_sgl_sw_state(rm_sgl_sw_state);
        }
        break;
    case LV_EVENT_LONG_PRESSED: // RainMaker reset or factory reset is enabled
        if (is_wifi_reset) {
            is_wifi_reset = false;
            esp_rmaker_wifi_reset(RESET_DELAY, REBOOT_DELAY);
        } else if (is_factory_reset) {
            is_factory_reset = false;
            esp_rmaker_factory_reset(RESET_DELAY, REBOOT_DELAY);
        }
        break;
    default:
        break;
    }
}

/*!
 *  @brief Update param by name or by type to the cloud of a given specific param.
 *  @param param_attr Attribute of the param, which two cases; PARAM_TYPE or PARAM_NAME.
 *  @param param_id The param identity i.e. ESP_RMAKER_PARAM_POWER
 *  @param device The specific device that have been initiated in app_main.cpp i.e. light_device.
 *  @param val Value of the param that can be of different types which includes int, float, bool, strm json
 * object.
 */
void update_rm_param(const char *param_attr, const char *param_id, esp_rmaker_device_t *device,
                     esp_rmaker_param_val_t val) 
{
    esp_rmaker_param_t *param = NULL;
    if (strcmp(param_attr, PARAM_TYPE) == 0) {
        param = esp_rmaker_device_get_param_by_type(device, param_id);
    } else if (strcmp(param_attr, PARAM_NAME) == 0) {
        param = esp_rmaker_device_get_param_by_name(device, param_id);
    }
    if (param != NULL) {
        esp_rmaker_param_update_and_report(param, val);
    } else {
        ESP_LOGE(""RM"", ""Parameter '%s' not found for device"", param_id);
    }
}

/*!
 *  @brief Deinitiate the i2c connection to prevent signal conflict when FastLED task is running.
 */
void deinit_i2c(void) 
{
    M5.Ex_I2C.release();
    pinMode(M5.Ex_I2C.getSCL(), OUTPUT);
    pinMode(M5.Ex_I2C.getSDA(), OUTPUT);
    digitalWrite(M5.Ex_I2C.getSCL(), HIGH);
    digitalWrite(M5.Ex_I2C.getSDA(), HIGH);
}

/**
 * This section is for start scrn driver.
 */
//=======================================================================================================================

/*!
 *  @brief Callback function for start button.
 *  @param event Logs in the type of event that is driven by the type
                  of example and button pressed.
 */
void start_btn_cb(lv_event_t *event) 
{
    lv_event_code_t code = lv_event_get_code(event);
    if (is_start_scrn) {
        if (code == LV_EVENT_CLICKED) {
            display_start_btn_pressed();
        } else if (code == LV_EVENT_RELEASED) {
            set_sgle_sw_scrn();
            show_sgl_switch_screen();
        } else if (code == LV_EVENT_REFRESH) {
            reset_start_btn();
        }
    }
}

/**
 * This section is for single switch device driver.
 */
//=======================================================================================================================

static bool is_sgl_switch_off(lv_event_code_t code) 
{ 
    return is_sgl_sw_scrn && !rm_sgl_sw_state; 
}

static bool is_sgl_switch_on(lv_event_code_t code) 
{ 
    return is_sgl_sw_scrn && rm_sgl_sw_state; 
}

static void on_sgl_sw(void) 
{
    if (lvgl_port_lock()) {
        display_light_bulb_on();
        lv_obj_add_state(sgl_sw, LV_STATE_CHECKED);
        rm_sgl_sw_state = true;
        lvgl_port_unlock();
    }
}

static void off_sgl_sw(void) {
    if (lvgl_port_lock()) {
        display_light_bulb_off();
        if (lv_obj_has_state(sgl_sw, LV_STATE_CHECKED)) {
            lv_obj_clear_state(sgl_sw, LV_STATE_CHECKED);
        }
        rm_sgl_sw_state = false;
        lvgl_port_unlock();
    }
}

void set_sgl_sw_state(bool state) {
    if (state) {
        on_sgl_sw();
    } else {
        off_sgl_sw();
    }
    set_lighting_state(rm_sgl_sw_state);
}

/*!
 *  @brief Callback function for single switch button and to update cloud.
 *  @param event Logs in the type of event that is driven by the type
                  of example and button pressed.
 */
void my_single_switch_cb(lv_event_t *event) 
{
    lv_event_code_t code = lv_event_get_code(event);
    if (is_sgl_switch_off(code)) {
        on_sgl_sw();
    } else if (is_sgl_switch_on(code)) {
        off_sgl_sw();
    }
    set_lighting_state(rm_sgl_sw_state);
    update_rm_param(PARAM_TYPE, ESP_RMAKER_PARAM_POWER, switch_device, esp_rmaker_bool(rm_sgl_sw_state));
}

/**
 * This section is for light device driver.
 */
//=======================================================================================================================

static bool is_light_sw_off(lv_event_code_t code) 
{
    return is_light_scrn && light_sw_array[ON_OFF_SW] && !rm_light_sw_state;
}

static bool is_light_sw_on(lv_event_code_t code) 
{
    return is_light_scrn && light_sw_array[ON_OFF_SW] && rm_light_sw_state;
}

static void on_light_sw(void) 
{
    if (lvgl_port_lock()) {
        lv_obj_add_state(light_sw, LV_STATE_CHECKED);
        rm_light_sw_state = true;
        lvgl_port_unlock();
    }
}

static void off_light_sw(void) 
{
    if (lvgl_port_lock()) {
        lv_obj_clear_state(light_sw, LV_STATE_CHECKED);
        rm_light_sw_state = false;
        lvgl_port_unlock();
    }
}

static void set_indicator_color(lv_obj_t *object, int color) 
{
    if (lvgl_port_lock()) {
        lv_obj_set_style_bg_color(object, lv_color_hex(color), LV_PART_KNOB);
        lvgl_port_unlock();
    }
}

/*!
 *  @brief To set the indicator color on the light switch to determine if it is going
           up or going down.
 *  @note  Green increases in value, orange decreases in value.
 */
static void set_indicator_dir_color(lv_obj_t *object, bool sw_direction) 
{
    if (lvgl_port_lock()) {
        if (sw_direction) {
            lv_obj_set_style_bg_color(object, lv_color_hex(COLOR_GREEN), LV_PART_KNOB);
        } else {
            lv_obj_set_style_bg_color(object, lv_color_hex(COLOR_ORANGE), LV_PART_KNOB);
        }
        lvgl_port_unlock();
    }
}

/*!
 *  @brief Sets the frequency of how fast the button can be pressed in a period of time.
 *  @param event_btn_time The time at which the button was last pressed.
 */
static void set_btn_freq(unsigned long event_btn_time) 
{
    unsigned long  [MASK]  = esp_timer_get_time() / 1000;
    if ( [MASK]  - event_btn_time < EVENT_DEBOUNCE_INTERVAL) {
        return;
    }
    event_btn_time =  [MASK] ;
}

bool get_light_sw_status(int call_sw) 
{ 
    return light_sw_array[call_sw]; 
}

void set_sw(int call_sw) 
{
    for (int i = 0; i < 3; i++) {
        if (i == call_sw) {
            light_sw_array[call_sw] = true;
        } else {
            light_sw_array[i] = false;
        }
    }
}

void set_light_sw_state(bool state) 
{
    if (state) {
        on_light_sw();
    } else {
        off_light_sw();
    }
    set_lighting_state(rm_light_sw_state);
}

void set_light_brt(int brt_value) 
{
    if (lvgl_port_lock()) {
        lv_slider_set_value(brt_slider, brt_value, LV_ANIM_ON);
        lvgl_port_unlock();
    }
    set_brt();
}

void set_light_hue(int hue_value) 
{
    if (lvgl_port_lock()) {
        lv_slider_set_value(hue_slider, hue_value, LV_ANIM_ON);
        lvgl_port_unlock();
    }
    set_hue();
}

/*!
 *  @brief Callback function to select the type of switch within the light device.
 *  @param event Logs in the type of event that is driven by the type of example and button pressed.
 */
void light_sw_select_cb(lv_event_t *event) 
{
    lv_event_code_t code = lv_event_get_code(event);
    if (is_light_scrn && code == LV_EVENT_SHORT_CLICKED) {
        if (get_light_sw_status(ON_OFF_SW)) {
            set_sw(BRT_SW);
            set_indicator_color(light_sw, COLOR_WHITE);
            set_indicator_dir_color(brt_slider, brt_sw_direction);
        } else if (get_light_sw_status(BRT_SW)) {
            set_sw(HUE_SW);
            set_indicator_color(brt_slider, COLOR_WHITE);
            set_indicator_dir_color(hue_slider, hue_sw_direction);
        } else if (get_light_sw_status(HUE_SW)) {
            set_sw(ON_OFF_SW);
            set_indicator_color(hue_slider, COLOR_WHITE);
            set_indicator_color(light_sw, COLOR_ORANGE);
        }
    }
}

/*!
 *  @brief Callback function to control on/off function of light device.
 *  @param event Logs in the type of event that is driven by the type of example and button pressed.
 */
void light_sw_cb(lv_event_t *event) 
{
    lv_event_code_t code = lv_event_get_code(event);
    if (is_light_sw_off(code)) {
        on_light_sw();
    } else if (is_light_sw_on(code)) {
        off_light_sw();
    }
    set_lighting_state(rm_light_sw_state);
    update_rm_param(PARAM_TYPE, ESP_RMAKER_PARAM_POWER, light_device, esp_rmaker_bool(rm_light_sw_state));
}

/*!
 *  @brief Callback function to control the brightness function of light device.
 *  @param event Logs in the type of event that is driven by the type of example and button pressed.
 */
void light_brt_cb(lv_event_t *event) 
{
    lv_event_code_t code = lv_event_get_code(event);
    if (code == LV_EVENT_CLICKED) {
        set_btn_freq(last_event_time_brt);
        if (brt_sw_direction == SW_DIRECTION_UP && brt_level <= FULL_BRT) {
            brt_level += 5;
        } else if (brt_sw_direction == SW_DIRECTION_DOWN && brt_level >= NULL_BRT) {
            brt_level -= 5;
        }
        set_light_brt(brt_level);
        update_rm_param(PARAM_TYPE, ESP_RMAKER_PARAM_BRIGHTNESS, light_device, esp_rmaker_int(brt_level));
    } else if (code == LV_EVENT_LONG_PRESSED) {
        brt_sw_direction ^= 1;
        set_indicator_dir_color(brt_slider, brt_sw_direction);
    }
}

/*!
 *  @brief Callback function to control the hue function of light device.
 *  @param event Logs in the type of event that is driven by the type of example and button pressed.
 */
void light_hue_cb(lv_event_t *event) 
{
    lv_event_code_t code = lv_event_get_code(event);
    if (code == LV_EVENT_CLICKED) {
        set_btn_freq(last_event_time_hue);
        if (hue_sw_direction == SW_DIRECTION_UP && hue_level <= MAX_HUE) {
            hue_level += 10;

        } else if (hue_sw_direction == SW_DIRECTION_DOWN && hue_level >= MIN_HUE) {
            hue_level -= 10;
        }
        if (hue_level > MAX_HUE) {
            hue_level = MAX_HUE;
        } else if (hue_level < MIN_HUE) {
            hue_level = MIN_HUE;
        }
        set_light_hue(hue_level);
        update_rm_param(PARAM_TYPE, ESP_RMAKER_PARAM_HUE, light_device, esp_rmaker_int(hue_level));
    } else if (code == LV_EVENT_LONG_PRESSED) {
        hue_sw_direction ^= 1;
        set_indicator_dir_color(hue_slider, hue_sw_direction);
    }
}

/**
 * This section is for relay device driver.
 */
//=======================================================================================================================

static bool is_relay_sw_off(int relay_sw, bool rm_relay_sw_state) 
{
    return is_relay_scrn && relay_sw_array[relay_sw] && !rm_relay_sw_state;
}

static bool is_relay_sw_on(int relay_sw, bool rm_relay_sw_state) 
{
    return is_relay_scrn && relay_sw_array[relay_sw] && rm_relay_sw_state;
}

static bool get_relay_sw_status(int call_sw) 
{ 
    return relay_sw_array[call_sw]; 
}

static void on_relay_sw(lv_obj_t *relay_sw) 
{
    if (lvgl_port_lock()) {
        lv_obj_add_state(relay_sw, LV_STATE_CHECKED);
        lvgl_port_unlock();
    }
}

static void off_relay_sw(lv_obj_t *relay_sw) 
{
    if (lvgl_port_lock()) {
        lv_obj_clear_state(relay_sw, LV_STATE_CHECKED);
        lvgl_port_unlock();
    }
}

/*!
 *  @brief Set the relay switch state based on the button pressed and update cloud.
 *  @param relay_sw object of the relay switch on M5 interface.
 *  @param relay_name param name set in app_main.cpp during param creation for relay device.
 *  @param relay_index To select the switch index to obtain its bool state as it is stored in an array.
 *  @param rm_relay_state actual state of particular relay switch state.
 */
static void set_relay_sw_btn(lv_obj_t *relay_sw, const char *relay_name, uint8_t relay_index,
                             bool rm_relay_state) 
{
    if (rm_relay_state) {
        rm_relay_sw_state[relay_index] = false;
        off_relay_sw(relay_sw);
    } else {
        rm_relay_sw_state[relay_index] = true;
        on_relay_sw(relay_sw);
    }
    update_rm_param(PARAM_NAME, relay_name, relay_device, esp_rmaker_bool(rm_relay_sw_state[relay_index]));
}

/*!
 *  @brief Set which relay switch to be selected on the M5 interface.
 *  @param call_sw An indexing of the relay switch.
 *                 Index 0: switch_1; Index 1: switch_2
 *                 Index 2: switch_3; Index 3: switch_4
 */
void set_relay_sw(int call_sw) 
{
    for (int i = 0; i < 4; i++) {
        if (i == call_sw) {
            relay_sw_array[call_sw] = true;
        } else {
            relay_sw_array[i] = false;
        }
    }
}

/*!
 *  @brief To set the state of the relay switch in the M5stickCplus interface.
 */
void set_relay_sw_state(void) 
{
    for (int relay_sw = 0; relay_sw < 4; relay_sw++) {
        if (rm_relay_sw_state[relay_sw]) {
            if (relay_sw == RELAY_SW_1) {
                on_relay_sw(relay_sw_1);
            } else if (relay_sw == RELAY_SW_2) {
                on_relay_sw(relay_sw_2);
            } else if (relay_sw == RELAY_SW_3) {
                on_relay_sw(relay_sw_3);
            } else if (relay_sw == RELAY_SW_4) {
                on_relay_sw(relay_sw_4);
            }
        } else {
            if (relay_sw == RELAY_SW_1) {
                off_relay_sw(relay_sw_1);
            } else if (relay_sw == RELAY_SW_2) {
                off_relay_sw(relay_sw_2);
            } else if (relay_sw == RELAY_SW_3) {
                off_relay_sw(relay_sw_3);
            } else if (relay_sw == RELAY_SW_4) {
                off_relay_sw(relay_sw_4);
            }
        }
    }
    set_relay();
}

/*!
 *  @brief To disconnect the relay module from the current task. Switch all relay to off,
 *         then turning deinitialising i2c signal else. set FastLED to default state.
 */
void disc_relay(void) 
{
    if (is_relay_scrn) {
        set_lighting_state(DEFAULT_SWITCH_POWER);
        set_relay_off();
        deinit_i2c();
    } else {
        set_lighting_state(DEFAULT_SWITCH_POWER);
    }
}

/*!
 *  @brief Callback function for selection of relay switch.
 *  @param event Logs in the type of event that is driven by the type of example and button pressed.
 */
void relay_sw_select_cb(lv_event_t *event) 
{
    lv_event_code_t code = lv_event_get_code(event);
    if (is_relay_scrn && code == LV_EVENT_SHORT_CLICKED) {
        if (get_relay_sw_status(RELAY_SW_1)) {
            set_relay_sw(RELAY_SW_2);
            set_indicator_color(relay_sw_1, COLOR_WHITE);
            set_indicator_color(relay_sw_2, COLOR_ORANGE);
        } else if (get_relay_sw_status(RELAY_SW_2)) {
            set_relay_sw(RELAY_SW_3);
            set_indicator_color(relay_sw_2, COLOR_WHITE);
            set_indicator_color(relay_sw_3, COLOR_ORANGE);
        } else if (get_relay_sw_status(RELAY_SW_3)) {
            set_relay_sw(RELAY_SW_4);
            set_indicator_color(relay_sw_3, COLOR_WHITE);
            set_indicator_color(relay_sw_4, COLOR_ORANGE);
        } else if (get_relay_sw_status(RELAY_SW_4)) {
            set_relay_sw(RELAY_SW_1);
            set_indicator_color(relay_sw_4, COLOR_WHITE);
            set_indicator_color(relay_sw_1, COLOR_ORANGE);
        }
    }
}

/*!
 *  @brief Callback function for relay switch.
 *  @param event Logs in the type of event that is driven by the type of example and button pressed.
 */
void relay_sw_cb(lv_event_t *event) 
{
    if (is_relay_sw_on(RELAY_SW_1, rm_relay_sw_state[RELAY_SW_1])) {
        set_relay_sw_btn(relay_sw_1, ""switch_1"", RELAY_SW_1, rm_relay_sw_state[RELAY_SW_1]);
    } else if (is_relay_sw_on(RELAY_SW_2, rm_relay_sw_state[RELAY_SW_2])) {
        set_relay_sw_btn(relay_sw_2, ""switch_2"", RELAY_SW_2, rm_relay_sw_state[RELAY_SW_2]);
    } else if (is_relay_sw_on(RELAY_SW_3, rm_relay_sw_state[RELAY_SW_3])) {
        set_relay_sw_btn(relay_sw_3, ""switch_3"", RELAY_SW_3, rm_relay_sw_state[RELAY_SW_3]);
    } else if (is_relay_sw_on(RELAY_SW_4, rm_relay_sw_state[RELAY_SW_4])) {
        set_relay_sw_btn(relay_sw_4, ""switch_4"", RELAY_SW_4, rm_relay_sw_state[RELAY_SW_4]);
    } else if (is_relay_sw_off(RELAY_SW_1, rm_relay_sw_state[RELAY_SW_1])) {
        set_relay_sw_btn(relay_sw_1, ""switch_1"", RELAY_SW_1, rm_relay_sw_state[RELAY_SW_1]);
    } else if (is_relay_sw_off(RELAY_SW_2, rm_relay_sw_state[RELAY_SW_2])) {
        set_relay_sw_btn(relay_sw_2, ""switch_2"", RELAY_SW_2, rm_relay_sw_state[RELAY_SW_2]);
    } else if (is_relay_sw_off(RELAY_SW_3, rm_relay_sw_state[RELAY_SW_3])) {
        set_relay_sw_btn(relay_sw_3, ""switch_3"", RELAY_SW_3, rm_relay_sw_state[RELAY_SW_3]);
    } else if (is_relay_sw_off(RELAY_SW_4, rm_relay_sw_state[RELAY_SW_4])) {
        set_relay_sw_btn(relay_sw_4, ""switch_4"", RELAY_SW_4, rm_relay_sw_state[RELAY_SW_4]);
    }
    set_relay();
}",now
190,"#pragma once

#include <cassert>
#include <utility>
#include <algorithm>

#include <memory>
#include <new>

namespace nonstd {
    namespace Detail {

        template <typename T>
        [[nodiscard]] T* allocate_uninit(size_t count) {
            return reinterpret_cast<T*>(::operator new[](sizeof(T)* count, std::align_val_t{ alignof(T) }));
        }
        template <typename T>
        void deallocate_no_destroy(T* ptr, size_t  [MASK] ) {
            ::operator delete[](static_cast<void*>(ptr),  [MASK]  * sizeof(T), std::align_val_t{ alignof(T) });
        }

        template <typename T>
        void destroy_range_reverse(T* start, T* end) {
            // Note: Compiler should be able to figure this out its own,
            //       but better make sure.
            if constexpr (!std::is_trivially_destructible_v<T>) {
                while (end != start) {
                    --end;
                    std::destroy_at(end);
                }
            }
        }

        template <typename T, typename... Args>
        inline void construct_at(T* const ptr, Args&&... args) {
            ::new (static_cast<void*>(ptr)) T(std::forward<Args>(args)...);
        }

    } // end namespace Detail

    template <typename T>
    class vector {
        T* m_first = nullptr;
        T* m_next = nullptr;
        T* m_end = nullptr;

        [[nodiscard]] size_t calculate_new_cap(const size_t new_cap) {
            const auto old_cap = capacity();
            const auto geometric_cap = old_cap + old_cap / 2;
            return std::max(new_cap, geometric_cap);
        }

        void adopt_new_memory(T* new_memory, size_t new_capacity) {
            const auto old_size = size();
            m_next = std::uninitialized_move(m_first, m_next, new_memory);
            Detail::deallocate_no_destroy(m_first, old_size);
            m_first = new_memory;
            m_end = m_first + new_capacity;
        }

        static_assert(std::is_nothrow_move_constructible_v<T>, ""No."");

    public:
        using iterator = T*;
        using const_iterator = T const*;
        vector() = default;
        ~vector() {
            Detail::destroy_range_reverse(m_first, m_next);
            Detail::deallocate_no_destroy(m_first, size());
        }

        // We don't need these for benchmarks/tests
        vector(vector const& rhs) : vector() {
            reserve(rhs.size());
            std::uninitialized_copy(rhs.begin(), rhs.end(), m_first);
        }
        vector& operator=(vector const& rhs) {
            if (this == &rhs) {
                return *this;
            }
            // If the elements are no-throw copy constructible, we
            // can avoid a temporary allocation if we hold enough
            // memory.
            if constexpr (std::is_nothrow_copy_constructible_v<T>) {
                Detail::destroy_range_reverse(m_first, m_next);
                if (rhs.size() > capacity()) {
                    Detail::deallocate_no_destroy(m_first, size());
                    m_first = Detail::allocate_uninit<T>(rhs.size());
                    m_end = m_first + rhs.size();
                }
                m_next = std::uninitialized_copy(rhs.m_first, rhs.m_next, m_first);
            } else {
                // For throwing copies we have to make a temporary
                // allocation, so we go with the copy & swap idiom
                auto temp(rhs);
                swap(*this, temp);
            }
            return *this;
        }
        vector(vector&& rhs) noexcept :
            m_first(std::exchange(rhs.m_first, nullptr)),
            m_next(std::exchange(rhs.m_next, nullptr)),
            m_end(std::exchange(rhs.m_end, nullptr))
        {}

        vector& operator=(vector&& rhs) noexcept {
            auto temp(std::move(rhs));
            swap(*this, temp);
            return *this;
        }

        void push_back(T const& elem) {
            if (m_next != m_end) {
                Detail::construct_at(m_next, elem);
                ++m_next;
                return;
            }
            const auto current_size = size();
            const auto new_cap = calculate_new_cap(current_size + 1);
            auto* new_memory = Detail::allocate_uninit<T>(new_cap);
            // Constructing new element has to happen before we move
            // old elements, in case someone is doing `v.push_back(v[0])`
            try {
                Detail::construct_at(new_memory + current_size, elem);
            }
            catch (...) {
                Detail::deallocate_no_destroy(new_memory, new_cap);
                // rethrow after fixup, so user knows it happened
                throw;
            }
            adopt_new_memory(new_memory, new_cap);
            // Account for the inserted element
            ++m_next;
        }
        void push_back(T&& elem) {
            if (m_next != m_end) {
                Detail::construct_at(m_next, std::move(elem));
                ++m_next;
                return;
            }
            const auto current_size = size();
            const auto new_cap = calculate_new_cap(current_size + 1);
            auto* new_memory = Detail::allocate_uninit<T>(new_cap);
            // Constructing new element has to happen before we move
            // old elements, in case someone is doing `v.push_back(v[0])`
            // We do not have to catch exception here, as we static assert
            // nothrow move constructibility on our elements.
            Detail::construct_at(new_memory + current_size, std::move(elem));
            adopt_new_memory(new_memory, new_cap);
            // Account for the element inserted ahead of time
            ++m_next;
        }
        void push_back_unchecked(T const& elem) noexcept(std::is_nothrow_copy_constructible_v<T>) {
            assert(m_next != m_end);
            Detail::construct_at(m_next, elem);
            ++m_next;
        }
        void push_back_unchecked(T&& elem) noexcept {
            assert(m_next != m_end);
            Detail::construct_at(m_next, std::move(elem));
            ++m_next;
        }

        void reserve(size_t target_capacity) {
            if (target_capacity <= capacity()) { return; }
            const auto new_cap = calculate_new_cap(target_capacity);
            auto new_memory = Detail::allocate_uninit<T>(new_cap);
            adopt_new_memory(new_memory, new_cap);
        }

        friend void swap(vector& lhs, vector& rhs) noexcept {
            std::swap(lhs.m_first, rhs.m_first);
            std::swap(lhs.m_next, rhs.m_next);
            std::swap(lhs.m_end, rhs.m_end);
        }

        [[nodiscard]] T& operator[](size_t idx) {
            return m_first[idx];
        }
        [[nodiscard]] T const& operator[](size_t idx) const {
            return m_first[idx];
        }

        [[nodiscard]] size_t size() const {
            return m_next - m_first;
        }
        [[nodiscard]] size_t capacity() const {
            return m_end - m_first;
        }

        [[nodiscard]] iterator begin() { return m_first; }
        [[nodiscard]] const_iterator begin() const { return m_first; }
        [[nodiscard]] iterator end() { return m_next; }
        [[nodiscard]] const_iterator end() const { return m_next; }
    };

} // end nonstd namespace
",num_elements
191,"//Card.cpp : Contains all card related functions.
//Authors : <NAME> (<EMAIL>)

//#include ""stdafx.h""       //INCLUDE FOR VISUAL STUDIO
#include ""Card.h""

using namespace std;


Card::Card() :cardRank(TWO), cardSuit(CLUBS) {}
Card::Card(int r, int s) : cardRank((Card::rank)r), cardSuit((Card::suit)s) {}

int parse_cards(vector<Card> & cards, char * file_name)
{

	ifstream ifs;
	ifs.open(file_name);

	if (ifs.is_open())
	{

		while (!ifs.eof())	//continue reading until we reach the end of the file
		{

			vector<Card> tmpHand;	//holds cards temporarally to make sure they perfectly fill a hand on each line (exactly five cards)
			string line, word;
			getline(ifs, line);		//read off each line of the file
			istringstream iss(line);

			while (iss >> word)		//read off each word to parse card information from it
			{

				Card card;
				const int word_first_index = 0;
				const int word_second_index = 1;
				const int word_last_index = word.size() - 1;
				const int normal_card_size = 2;
				const int card_size_if_ten = 3;
				const int beginCommentLength = 2;
				const char commentCharacter = '/';
				char suitChar = word[word_last_index];
				bool valid = true;
				

				if (word.size() >= beginCommentLength && word[word_first_index] == commentCharacter && word[word_second_index] == commentCharacter)		//if we hit a comment, we want to stop reading cards from this line
				{
					break;
				}

				if (word.size() == normal_card_size || word.size() == card_size_if_ten)		//a normal card will have 2 characters unless it has a 10 in which case it will have 3 characters
				{

					if (suitChar == 'C' || suitChar == 'c')
					{
						card.cardSuit = Card::suit::CLUBS;
					}

					else if (suitChar == 'D' || suitChar == 'd')
					{
						card.cardSuit = Card::suit::DIAMONDS;
					}

					else if (suitChar == 'H' || suitChar == 'h')
					{
						card.cardSuit = Card::suit::HEARTS;
					}

					else if (suitChar == 'S' || suitChar == 's')
					{
						card.cardSuit = Card::suit::SPADES;
					}

					else
					{
						valid = false;
					}

					if (word.size() == card_size_if_ten && word[word_first_index] == '1' && word[word_second_index] == '0')		//special check if a card has rank 10 since this is the only rank with two characters
					{
						card.cardRank = Card::rank::TEN;
					}
					else
					{

						switch (word[word_first_index])
						{
						case 'A' :
						case 'a' :
							card.cardRank = Card::rank::ACE;
							break;
						case 'K' :
						case 'k' :
							card.cardRank = Card::rank::KING;
							break;
						case 'Q':
						case 'q':
							card.cardRank = Card::rank::QUEEN;
							break;
						case 'J':
						case 'j':
							card.cardRank = Card::rank::JACK;
							break;
						case '9':
							card.cardRank = Card::rank::NINE;
							break;
						case '8':
							card.cardRank = Card::rank::EIGHT;
							break;
						case '7':
							card.cardRank = Card::rank::SEVEN;
							break;
						case '6':
							card.cardRank = Card::rank::SIX;
							break;
						case '5':
							card.cardRank = Card::rank::FIVE;
							break;
						case '4':
							card.cardRank = Card::rank::FOUR;
							break;
						case '3':
							card.cardRank = Card::rank::THREE;
							break;
						case '2':
							card.cardRank = Card::rank::TWO;
							break;
						default :
							valid = false;	//a card that does not fall into any above catagory has an invalid rank
						}
					}

					if (valid)	//only add valid cards
					{
						tmpHand.push_back(card);
					}
				}
			}

		

				for (Card card : tmpHand)	//go through cards from the line adding each to overall vector
				{
					cards.push_back(card);
				}
		}
	}
	else
	{
		cout << ""Error opening file!"" << endl;
		return errors::fileOpenError;
	}

	

	ifs.close();//close the filestream when done
	return errors::noError;
}

int print_cards(const vector<Card> & cards)
{

	for (Card card : cards)
	{

		string cardString;
		const int firstIndex = 0;

		if (card.cardRank < firstIndex || card.cardRank >= numRanks || card.cardSuit < firstIndex || card.cardSuit >= numSuits)		//all cards that correspond to indexes of the card suit and rank arrays will be valid all others are errors
		{	
			cout << ""Error reading cards from vector!"" << endl;
			return errors::cardReadError;
		}

		cardString = rankStrings[card.cardRank] + suitStrings[card.cardSuit];
		cout << cardString << endl;
	}

	return errors::noError;
}

void usage_message(string program_name, string message)
{

	cout << program_name <<"": ""<< message << endl;
}

bool Card::operator< (const Card & crd) const
{
	return (cardRank < crd.cardRank) || ((cardRank == crd.cardRank) && (cardSuit < crd.cardSuit));		//sorts first by rank and then by suit
}

bool Card::operator== (const Card & crd) const
{
	return (cardRank == crd.cardRank) && (cardSuit == crd.cardSuit);		//equality
}

int print_poker_rank(vector<Card> & cards)
{

	const int  [MASK]  = 5;		//size of a valid hand
	const int quad = 4;			//number of cards in a four of a kind
	const int triplet = 3;		//number of cards in a three of a kind
	const int pair = 2;			//number of cards in a two of a kind

	vector<Card> crntHand;	//the current five cards we are detemining the rank of

	int itr = 0;
	while (itr +  [MASK]  <= cards.size())	//go through each hand while we still have a hand's worth of cards to check
	{

		int i = 0;
		while (i <  [MASK] )	//built a hand out of the next cards
		{

			crntHand.push_back(cards[itr+i]);	//itr+i to get the cards after the current start point
			++i;

		}

		sort(crntHand.begin(), crntHand.end());		//sorts the crntHand according to the less than operator

		//checks the overall hand for a flush or a straight
		bool flush = crntHand[0].cardSuit == crntHand[1].cardSuit && crntHand[0].cardSuit == crntHand[2].cardSuit && crntHand[0].cardSuit == crntHand[3].cardSuit && crntHand[0].cardSuit == crntHand[4].cardSuit;
		bool straight = (crntHand[0].cardRank + 1) == crntHand[1].cardRank && (crntHand[1].cardRank + 1) == crntHand[2].cardRank && (crntHand[2].cardRank + 1) == crntHand[3].cardRank && (crntHand[3].cardRank + 1) == crntHand[4].cardRank;

		//checks for any multiples of a rank
		int maxCount = 0;		//maximum number of cards of the same rank in hand
		int secondCount = 0;	//second best amount of cards of the same rank (for full house and two pairs)
		int j;
		for (j = 0; j <  [MASK] ; j++)		//go through all cards in hand beginning with first one
		{

			Card cardOne = crntHand[j];		//store card currently examined
			int crntCount = 1;				//there are one of that rank so far

			int k;
			for (k = j + 1; k <  [MASK] ; ++k)	//go through rest of cards finding the rest of that rank
			{

				Card cardTwo = crntHand[k];	

				if (cardOne.cardRank == cardTwo.cardRank)	//check if ranks are the same
				{

					++j;		//increment j so we dont double count the matching card
					++crntCount;	//increment count of the rank seen

				}
				else		//since cards are sorted, we know we will not hit any more of that rank once we find the first that is not of that rank so we can break
				{

					break;

				}
			}

			if (crntCount > maxCount)		//if we found a new maximum set it as so
			{
				
				secondCount = maxCount;
				maxCount = crntCount;

			}
			else if (crntCount > secondCount)		//if we found a new second most cards set it as so
			{

				secondCount = crntCount;

			}
		}

		//go through all hand possibilities starting with the best down to the worst and declare which we match
		if (flush && straight)
		{

			cout << ""straight flush"" << endl;

		}
		else if (maxCount == quad)
		{

			cout << ""four of a kind"" << endl;

		}
		else if (maxCount == triplet && secondCount == pair)
		{

			cout << ""full house"" << endl;

		}
		else if (flush)
		{

			cout << ""flush"" << endl;

		}
		else if (straight)
		{

			cout << ""straight"" << endl;

		}
		else if (maxCount == triplet)
		{

			cout << ""three of a kind"" << endl;

		}
		else if (maxCount == pair && secondCount == pair)
		{

			cout << ""two pairs"" << endl;

		}
		else if (maxCount == pair)
		{

			cout << ""one pair"" << endl;

		}
		else
		{

			cout << ""no rank"" << endl;

		}

		crntHand.clear();		//remove the cards we were examining so we can examine the next hand
		itr +=  [MASK] ;				//incerment the hand start we are on by a whole hand since we have just examined that hand.
	}
	return 0;		//no error
}

Card & Card::operator= (const Card & other)
{
	cardRank = other.cardRank;
	cardSuit = other.cardSuit;
	return *this;
}

int rank_count(const Card * begin, const Card * end, const Card card)
{
	int rank = card.cardRank;
	int count = 0;
	while (begin != end)
	{
		if ((*begin).cardRank == rank)
		{
			++count;
		}
		++begin;
	}
	return count;
}
",handSize
192,"// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// -*- Mode: C++ -*-
//
// Copyright (C) 2021 Oracle, Inc.
//
// Author: <NAME>

/// @file
///
/// This file implement the CTF testsuite. It reads ELF binaries
/// containing CTF, save them in XML corpus files and diff the
/// corpus files against reference XML corpus files.

#include <cstdlib>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include ""abg-ctf-reader.h""
#include ""test-read-common.h""

using std::string;
using std::cerr;
using std::vector;

using abigail::tests::read_common::InOutSpec;
using abigail::tests::read_common::test_task;
using abigail::tests::read_common::display_usage;
using abigail::tests::read_common::options;

using abigail::ctf_reader::read_context_sptr;
using abigail::ctf_reader::create_read_context;
using abigail::xml_writer::SEQUENCE_TYPE_ID_STYLE;
using abigail::xml_writer::HASH_TYPE_ID_STYLE;
using abigail::tools_utils::emit_prefix;

static InOutSpec in_out_specs[] =
{
  {
    ""data/test-read-ctf/test0"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test0.abi"",
    ""output/test-read-ctf/test0.abi""
  },
  {
    ""data/test-read-ctf/test0"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test0.hash.abi"",
    ""output/test-read-ctf/test0.hash.abi""
  },
  {
    ""data/test-read-ctf/test1.so"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test1.so.abi"",
    ""output/test-read-ctf/test1.so.abi""
  },
  {
    ""data/test-read-ctf/test1.so"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test1.so.hash.abi"",
    ""output/test-read-ctf/test1.so.hash.abi""
  },
  {
    ""data/test-read-ctf/test2.so"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test2.so.abi"",
    ""output/test-read-ctf/test2.so.abi""
  },
  {
    ""data/test-read-ctf/test2.so"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test2.so.hash.abi"",
    ""output/test-read-ctf/test2.so.hash.abi""
  },
  {
    ""data/test-read-common/test3.so"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test3.so.abi"",
    ""output/test-read-ctf/test3.so.abi""
  },
  {
    ""data/test-read-common/test3.so"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test3.so.hash.abi"",
    ""output/test-read-ctf/test3.so.hash.abi""
  },
  {
    ""data/test-read-ctf/test-enum-many.o"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-enum-many.o.hash.abi"",
    ""output/test-read-ctf/test-enum-many.o.hash.abi""
  },
  {
    ""data/test-read-ctf/test-ambiguous-struct-A.o"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-ambiguous-struct-A.o.hash.abi"",
    ""output/test-read-ctf/test-ambiguous-struct-A.o.hash.abi""
  },
  {
    ""data/test-read-ctf/test-ambiguous-struct-B.o"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-ambiguous-struct-B.o.hash.abi"",
    ""output/test-read-ctf/test-ambiguous-struct-B.o.hash.abi""
  },
  {
    ""data/test-read-ctf/test-conflicting-type-syms-a.o"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-conflicting-type-syms-a.o.hash.abi"",
    ""output/test-read-ctf/test-conflicting-type-syms-a.o.hash.abi""
  },
  {
    ""data/test-read-ctf/test-conflicting-type-syms-b.o"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-conflicting-type-syms-b.o.hash.abi"",
    ""output/test-read-ctf/test-conflicting-type-syms-b.o.hash.abi""
  },
  {
    ""data/test-read-common/test4.so"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test4.so.abi"",
    ""output/test-read-ctf/test4.so.abi""
  },
  {
    ""data/test-read-common/test4.so"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test4.so.hash.abi"",
    ""output/test-read-ctf/test4.so.hash.abi""
  },
  {
    ""data/test-read-ctf/test5.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test5.o.abi"",
    ""output/test-read-ctf/test5.o.abi""
  },
  {
    ""data/test-read-ctf/test7.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test7.o.abi"",
    ""output/test-read-ctf/test7.o.abi""
  },
  {
    ""data/test-read-ctf/test8.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test8.o.abi"",
    ""output/test-read-ctf/test8.o.abi""
  },
  {
    ""data/test-read-ctf/test9.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test9.o.abi"",
    ""output/test-read-ctf/test9.o.abi""
  },
  {
    ""data/test-read-ctf/test-enum.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-enum.o.abi"",
    ""output/test-read-ctf/test-enum.o.abi""
  },
  {
    ""data/test-read-ctf/test-enum-symbol.o"",
    """",
    """",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-enum-symbol.o.hash.abi"",
    ""output/test-read-ctf/test-enum-symbol.o.hash.abi""
  },
  {
    ""data/test-read-ctf/test-dynamic-array.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-dynamic-array.o.abi"",
    ""output/test-read-ctf/test-dynamic-array.o.abi""
  },
  {
    ""data/test-read-ctf/test-anonymous-fields.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-anonymous-fields.o.abi"",
    ""output/test-read-ctf/test-anonymous-fields.o.abi""
  },
  {
    ""data/test-read-common/PR27700/test-PR27700.o"",
    """",
    ""data/test-read-common/PR27700/pub-incdir"",
    HASH_TYPE_ID_STYLE,
    ""data/test-read-ctf/PR27700/test-PR27700.abi"",
    ""output/test-read-ctf/PR27700/test-PR27700.abi"",
  },
  {
    ""data/test-read-ctf/test-callback.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-callback.abi"",
    ""output/test-read-ctf/test-callback.abi"",
  },
  {
    ""data/test-read-ctf/test-array-of-pointers.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-array-of-pointers.abi"",
    ""output/test-read-ctf/test-array-of-pointers.abi"",
  },
  {
    ""data/test-read-ctf/test-functions-declaration.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-functions-declaration.abi"",
    ""output/test-read-ctf/test-functions-declaration.abi"",
  },
  {
    ""data/test-read-ctf/test-forward-type-decl.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-forward-type-decl.abi"",
    ""output/test-read-ctf/test-forward-type-decl.abi"",
  },
  {
    ""data/test-read-ctf/test-list-struct.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-list-struct.abi"",
    ""output/test-read-ctf/test-list-struct.abi"",
  },
  {
    ""data/test-read-common/test-PR26568-1.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-PR26568-1.o.abi"",
    ""output/test-read-ctf/test-PR26568-1.o.abi"",
  },
  {
    ""data/test-read-common/test-PR26568-2.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-PR26568-2.o.abi"",
    ""output/test-read-ctf/test-PR26568-2.o.abi"",
  },
  {
    ""data/test-read-ctf/test-callback2.o"",
    """",
    """",
    SEQUENCE_TYPE_ID_STYLE,
    ""data/test-read-ctf/test-callback2.abi"",
    ""output/test-read-ctf/test-callback2.abi"",
  },
  // This should be the last entry.
  {NULL, NULL, NULL, SEQUENCE_TYPE_ID_STYLE, NULL, NULL}
};

/// Task specialization to perform CTF tests.
struct test_task_ctf : public test_task
{
  test_task_ctf(const InOutSpec &s,
                string& a_out_abi_base,
                string& a_in_elf_base,
                string& a_in_abi_base);
  virtual void
  perform();

  virtual
  ~test_task_ctf()
  {}
}; // end struct test_task_ctf

/// Constructor.
///
/// Task to be executed for each CTF test entry in @ref
/// abigail::tests::read_common::InOutSpec.
/// @param InOutSpec the array containing set of tests.
///
/// @param a_out_abi_base the output base directory for abixml files.
///
/// @param a_in_elf_base the input base directory for object files.
///
/// @param a_in_elf_base the input base directory for expected
/// abixml files.
test_task_ctf::test_task_ctf(const InOutSpec &s,
                             string& a_out_abi_base,
                             string& a_in_elf_base,
                             string& a_in_abi_base)
        : test_task(s, a_out_abi_base, a_in_elf_base, a_in_abi_base)
  {}

/// The thread function to execute each CTF test entry in @ref
/// abigail::tests::read_common::InOutSpec.
///
/// This reads the corpus into memory, saves it to disk, loads it
/// again and compares the new in-memory representation against the
void
test_task_ctf::perform()
{
  abigail::ir::environment_sptr env;

  set_in_elf_path();
  set_in_suppr_spec_path();

  env.reset(new abigail::ir::environment);
  abigail::elf_reader::status status =
    abigail::elf_reader::STATUS_UNKNOWN;
  vector<char**> di_roots;
  ABG_ASSERT(abigail::tools_utils::file_exists(in_elf_path));

  read_context_sptr ctxt = create_read_context(in_elf_path,
                                               di_roots,
                                               env.get());
  ABG_ASSERT(ctxt);

  corpus_sptr corp = read_corpus(ctxt.get(), status);
  // if there is no output and no input, assume that we do not care about the
  // actual read result, just that it succeeded.
  if (!spec.in_abi_path && !spec.out_abi_path)
    {
        // Phew! we made it here and we did not crash! yay!
        return;
    }
  if (!corp)
    {
        error_message = string(""failed to read "") + in_elf_path  + ""\n"";
        is_ok = false;
        return;
    }
  corp->set_path(spec.in_elf_path);
  // Do not take architecture names in comparison so that these
  // test input binaries can come from whatever arch the
  // programmer likes.
  corp->set_architecture_name("""");

  if (!(is_ok = set_out_abi_path()))
      return;

  if (!(is_ok = serialize_corpus(out_abi_path, corp)))
       return;

  if (!(is_ok = run_abidw(""--ctf "")))
    return;

  if (!(is_ok = run_diff()))
      return;
}

/// Create a new CTF instance for task to be execute by the testsuite.
///
/// @param s the @ref abigail::tests::read_common::InOutSpec
/// tests container.
///
/// @param a_out_abi_base the output base directory for abixml files.
///
/// @param a_in_elf_base the input base directory for object files.
///
/// @param a_in_abi_base the input base directory for abixml files.
///
/// @return abigail::tests::read_common::test_task instance.
static test_task*
new_task(const InOutSpec* s, string& a_out_abi_base,
         string& a_in_elf_base, string& a_in_abi_base)
{
  return new test_task_ctf(*s, a_out_abi_base,
                           a_in_elf_base, a_in_abi_base);
}

int
main(int argc, char *argv[])
{
  options  [MASK] ;
  if (!parse_command_line(argc, argv,  [MASK] ))
    {
      if (! [MASK] .wrong_option.empty())
        emit_prefix(argv[0], cerr)
          << ""unrecognized option: "" <<  [MASK] .wrong_option << ""\n"";
      display_usage(argv[0], cerr);
      return 1;
    }

  // compute number of tests to be executed.
  const size_t num_tests = sizeof(in_out_specs) / sizeof(InOutSpec) - 1;

  return run_tests(num_tests, in_out_specs,  [MASK] , new_task);
}
",opts
193,"#include <SFML/Graphics.hpp>
#include <ctime>
#include <cstdlib>


//PLAYING FIELD DIMENSIONS//
const int H = 4; // HIGHT
const int W = 4; // WEIGHT


int field[H+2][W+2] = {
	{-1, -1, -1, -1, -1, -1},
	{-1, 0, 1, 2, 3, -1},
	{-1, 4, 5, 6, 7, -1},
	{-1, 8, 9, 10, 11, -1},
	{-1, 12, 13, 14, 15, -1},
	{-1, -1, -1, -1, -1, -1},
};
int tiles[16][2] = {
	{0, 0}, {0, 1}, {0, 2}, {0, 3}, // 1 2 3 4
	{1, 0}, {1, 1}, {1, 2}, {1, 3}, // 5 6 7 8
	{2, 0}, {2, 1}, {2, 2}, {2, 3}, // 9 10 11 12
	{3, 0}, {3, 1}, {3, 2}, {3, 3}, // 13 14 15 16
};

int main()
{
	// Îáúåêò, êîòîðûé, ñîáñòâåííî, ÿâëÿåòñÿ ãëàâíûì îêíîì ïðèëîæåíèÿ
	sf::RenderWindow  [MASK] (sf::VideoMode(256, 256), ""Fivenashki"");

	// shuffling  for field
	srand(time(0));
	for (int i = 1; i <= H; ++i) {
		for (int j = 1; j <= W; ++j) {
			std::swap(field[i][j], field[(std::rand() % H) + 1][(std::rand() % W) + 1]);
		}
	}

	// connectings texture
	sf::Texture texture;
	int w = 64;
	const char* path = ""five.png"";
	texture.loadFromFile(path);

	// start sprite
	sf::Sprite sprite(texture);

	// mouse
	sf::Vector2i pos = sf::Mouse::getPosition( [MASK] );
	int x = (pos.x / w) - 1;
	int y = (pos.y / w) - 1;
	std::swap(field[2][1], field[2][3]);

	// Ãëàâíûé öèêë ïðèëîæåíèÿ. Âûïîëíÿåòñÿ, ïîêà îòêðûòî îêíî
	while ( [MASK] .isOpen())
	{
		sf::Vector2i pos = sf::Mouse::getPosition( [MASK] );
		int x = (pos.x / w)+1;
		int y = (pos.y / w)+1;
		// Îáðàáàòûâàåì î÷åðåäü ñîáûòèé â öèêëå
		sf::Event event;
		while ( [MASK] .pollEvent(event))
		{
			// Ïîëüçîâàòåëü íàæàë íà «êðåñòèê» è õî÷åò çàêðûòü îêíî?
			if (event.type == sf::Event::Closed)
				// òîãäà çàêðûâàåì åãî
				 [MASK] .close();
			else if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
				if (!(15-field[x - 1][y])) std::swap(field[x][y], field[x - 1][y]);
				else if (!(15 - field[x][y - 1])) std::swap(field[x][y], field[x][y - 1]);
				else if (!(15 - field[x][y + 1])) std::swap(field[x][y], field[x][y + 1]);
				else if (!(15 - field[x + 1][y])) std::swap(field[x][y], field[x + 1][y]);
			}
		}
		// Îòðèñîâêà îêíà
		for (int i = 1; i <= H; ++i)
			for (int j = 1; j <= W; ++j)
			{
				sprite.setTextureRect(sf::IntRect(tiles[field[i][j]][0] * w, tiles[field[i][j]][1] *w, w, w));
				sprite.setPosition((i-1) * w, (j-1) * w);
				 [MASK] .draw(sprite);
			}

		 [MASK] .display();
	}

	return 0;
}
",window
194,"#ifndef MATH_ANGLE_H
#define MATH_ANGLE_H

#include ""math_Rational.h""
#include ""math_Vector.h""

namespace math
{
    // Return sin(x) Taylor series to order x^(2n+1).
    Rational sin(const Rational& x, Unsigned n)
    {
        Rational x2 = -x * x;
        Rational term = x;
        Rational series = term;
        for (Unsigned k = 1; k <= n; ++k)
        {
            term *= (x2 / (2 * k * (2 * k + 1)));
            series += term;
        }
        return series;
    }

    // Return cos(x) Taylor series to order x^(2n).
    Rational cos(const Rational& x, Unsigned n)
    {
        Rational x2 = -x * x;
        Rational term = 1;
        Rational series = term;
        for (Unsigned k = 1; k <= n; ++k)
        {
            term *= (x2 / (2 * k * (2 * k - 1)));
            series += term;
        }
        return series;
    }

    // Return 1/sqrt(x) with ~200-bit accuracy.
    Rational inv_sqrt(const Rational& x)
    {
        // Iterate Newton's method with f(y) = y^-2 - x.
        Rational y = std::sqrt((1 / x).to_double());
        for (int i = 0; i < 2; ++i)
        {
            y *= ((3 - x * y * y) / 2);
        }
        return y;
    }

    const Rational PI = Rational(
        ""3.14159265358979323846264338327950288419716939937510582097494"");

    // Return atan(sqrt(x2)) with ~200-bit accuracy.
    Rational atan_sqrt(Rational x2)
    {
        // Assume 0 < x2 <= 1 using atan(x) == pi/2 - atan(1/x).
        if (x2 == 0)
        {
            return 0;
        }
        bool  [MASK]  = (x2 > 1);
        if ( [MASK] )
        {
            x2 = 1 / x2;
        }

        // Compute Euler's series for atan(x) to n=200.
        Rational y = x2 / (1 + x2);
        Rational term = y;
        Rational series = term;
        for (Unsigned n = 1; n <= 200; ++n)
        {
            term *= (y * (2 * n) / (2 * n + 1));
            series += term;
        }
        y = inv_sqrt(x2) * series;

        // Convert back if we used reciprocal identity.
        if ( [MASK] )
        {
            y = PI / 2 - y;
        }
        return y;
    }

    // Return ""exact"" angle(u, v) with ~200-bit accuracy.
    Rational angle_exact(const Vector& u, const Vector& v)
    {
        Rational ux = u.x, uy = u.y, uz = u.z;
        Rational vx = v.x, vy = v.y, vz = v.z;
        Rational d = ux * vx + uy * vy + uz * vz; // dot(u, v)
        Rational
            cx = uy * vz - uz * vy, // cross(u, v)
            cy = uz * vx - ux * vz,
            cz = ux * vy - uy * vx;
        if (d == 0)
        {
            return PI / 2;
        }
        Rational angle = atan_sqrt((cx * cx + cy * cy + cz * cz) / (d * d));
        if (d < 0)
        {
            angle = PI - angle;
        }
        return angle;
    }

    // Return angle between vectors using same ""cross/dot product"" formula.
    double angle(const Vector& u, const Vector& v)
    {
        return std::atan2(norm(cross(u, v)), dot(u, v));
    }

    // Return angle between vectors using law of cosines.
    double angle0(const Vector& u, const Vector& v)
    {
        double u2 = u.x * u.x + u.y * u.y + u.z * u.z;
        double v2 = v.x * v.x + v.y * v.y + v.z * v.z;
        Vector d = u - v;
        return std::acos(std::min(1.0, std::max(-1.0,
            (u2 + v2 - (d.x * d.x + d.y * d.y + d.z * d.z)) /
            (2 * std::sqrt(u2) * std::sqrt(v2)))));
    }

    // Following are three alternative formulas discussed in:
    // <NAME>., How Futile are Mindless Assessments of Roundoff in
    // Floating-Point Computation?
    // (http://people.eecs.berkeley.edu/~wkahan/Mindless.pdf)

    double angle1(const Vector& u, const Vector& v)
    {
        return std::acos(std::min(1.0, std::max(-1.0,
            dot(u, v) / (norm(u) * norm(v)))));
    }

    double angle2(const Vector& u, const Vector& v)
    {
        double angle = std::asin(std::min(1.0,
            norm(cross(u, v)) / (norm(u) * norm(v))));
        if (dot(u, v) < 0)
        {
            angle = 3.141592653589793 - angle;
        }
        return angle;
    }

    double angle3(const Vector& u, const Vector& v)
    {
        double nu = norm(u);
        double nv = norm(v);
        return 2 * std::atan2(norm(nv * u - nu * v), norm(nv * u + nu * v));
    }
} // namespace math

#endif // MATH_ANGLE_H
",invert
195,"//
//  KittyMemory.cpp
//
//  Created by MJ (Ruit) on 1/1/19.
//

#include <src/Includes/obfuscate.h>
#include ""KittyMemory.h""
#include <iostream>
#include <string>
#include <src/Includes/Logger.h>
#include <fstream>
#include <src/Includes/Utils.h>

using KittyMemory::Memory_Status;
using KittyMemory::ProcMap;


struct mapsCache {
    std::string identifier;
    ProcMap map;
};

static std::vector<ProcMap> _procMaps;
static std::vector<mapsCache> __mapsCache;
static ProcMap findMapInCache(std::string id){
    ProcMap ret;
    for(int i = 0; i < __mapsCache.size(); i++){
        if(__mapsCache[i].identifier.compare(id) == 0){
            ret = __mapsCache[i].map;
            break;
        }
    }
    return ret;
}


bool KittyMemory::ProtectAddr(void *addr, size_t length, int protection) {
   uintptr_t pageStart = _PAGE_START_OF_(addr);
   uintptr_t pageLen   = _PAGE_LEN_OF_(addr, length);
   return (
     mprotect(reinterpret_cast<void *>(pageStart), pageLen, protection) != -1
 );
}


Memory_Status KittyMemory::memWrite(void *addr, const void *buffer, size_t len) {
    if (addr == NULL)
        return INV_ADDR;

    if (buffer == NULL)
        return INV_BUF;

    if (len < 1 || len > INT_MAX)
        return INV_LEN;

    if (!ProtectAddr(addr, len, _PROT_RWX_))
        return INV_PROT;

    if (memcpy(addr, buffer, len) != NULL && ProtectAddr(addr, len, _PROT_RX_))
        return SUCCESS;

    return FAILED;
}


Memory_Status KittyMemory::memRead(void *buffer, const void *addr, size_t len) {
    if (addr == NULL)
        return INV_ADDR;

    if (buffer == NULL)
        return INV_BUF;

    if (len < 1 || len > INT_MAX)
        return INV_LEN;

    if (memcpy(buffer, addr, len) != NULL)
        return SUCCESS;

    return FAILED;
}

std::vector<uintptr_t>
scanMem(uintptr_t startAddr, uintptr_t endAddr, unsigned char *val, size_t len) {
    std::vector<uintptr_t> result;
    unsigned __int64  [MASK]  = startAddr;
    unsigned char readBuffer[4096] = {0,};
    size_t readLen = sizeof(readBuffer);

    LOGI(stringFormat(""scanMem: Start: %p, End: %p, Length: %p"", startAddr, endAddr,
                      endAddr - startAddr).c_str());


    while (true) {
        if ( [MASK]  + readLen > endAddr)
            readLen = endAddr -  [MASK] ;

        if (KittyMemory::memRead(readBuffer, (const void *)  [MASK] , readLen) ==
            KittyMemory::SUCCESS) {
            for (int i = 0; i < readLen; ++i) {
                if (readBuffer[i] != val[0])
                    continue;

                if (readLen - i <= len)
                    break;

                if (memcmp(readBuffer + i, val, len) == 0) {
                    result.push_back( [MASK]  + i);
                    i += len;
                }
            }
        }

        std::memset(readBuffer, 0, sizeof(readBuffer));
         [MASK]  += readLen;

        if ( [MASK]  >= endAddr)
            break;
        usleep(10);
    }

    LOGI(""scanMem: end"");
    return result;
}

std::string KittyMemory::read2HexStr(const void *addr, size_t len) {
    char temp[len];
    memset(temp, 0, len);

    const size_t bufferLen = len * 2 + 1;
    char buffer[bufferLen];
    memset(buffer, 0, bufferLen);

    std::string ret;

    if (memRead(temp, addr, len) != SUCCESS)
        return ret;

    for (int i = 0; i < len; i++) {
        sprintf(&buffer[i * 2], ""%02X"", (unsigned char) temp[i]);
    }

    ret += buffer;
    return ret;
}

std::vector<ProcMap> KittyMemory::getMaps() {
    char line[512] = { 0, };
    FILE *fp = fopen(""/proc/self/maps"", ""rt"");

    if(fp != nullptr) {
        _procMaps.clear();

        while(fgets(line, sizeof(line), fp)) {
            ProcMap tmpMap;
            char tmpPerms[5] = {0}, tmpDev[12] = {0}, tmpPathname[444] = {0};

            sscanf(line, ""%llx-%llx %s %ld %s %d %s"",
                   (long long unsigned *) &tmpMap.startAddr,
                   (long long unsigned *) &tmpMap.endAddr,
                   tmpPerms, &tmpMap.offset, tmpDev, &tmpMap.inode, tmpPathname);

            tmpMap.length = (uintptr_t) tmpMap.endAddr - (uintptr_t) tmpMap.startAddr;
            tmpMap.perms = tmpPerms;
            tmpMap.dev = tmpDev;
            tmpMap.pathname = tmpPathname;

            _procMaps.push_back(tmpMap);
        }

        fclose(fp);
    }

    return _procMaps;
}

std::vector<ProcMap> KittyMemory::getMaps(const char *name) {
    std::vector<ProcMap> maps;
    char line[512] = { 0, };
    FILE *fp = fopen(""/proc/self/maps"", ""rt"");

    if(fp != nullptr) {
        _procMaps.clear();

        while(fgets(line, sizeof(line), fp)) {
            if(strstr(line, name)) {
                ProcMap tmpMap;
                char tmpPerms[5] = {0}, tmpDev[12] = {0}, tmpPathname[444] = {0};

                sscanf(line, ""%llx-%llx %s %ld %s %d %s"",
                       (long long unsigned *) &tmpMap.startAddr,
                       (long long unsigned *) &tmpMap.endAddr,
                       tmpPerms, &tmpMap.offset, tmpDev, &tmpMap.inode, tmpPathname);

                tmpMap.length = (uintptr_t) tmpMap.endAddr - (uintptr_t) tmpMap.startAddr;
                tmpMap.perms = tmpPerms;
                tmpMap.dev = tmpDev;
                tmpMap.pathname = tmpPathname;

                maps.push_back(tmpMap);
            }
        }

        fclose(fp);
    }

    return maps;
}

ProcMap KittyMemory::getRegionMap(uintptr_t adr) {
    ProcMap map = { 0, };

    for(ProcMap map: KittyMemory::getMaps()) {
        if(reinterpret_cast<uintptr_t>(map.startAddr) <= adr && reinterpret_cast<uintptr_t>(map.endAddr) >= adr)
            return map;
    }

    return map;
}

ProcMap KittyMemory::getLibraryMap(const char *libraryName) {
    ProcMap retMap;
    char line[512] = {0};

    FILE *fp = fopen(OBFUSCATE(""/proc/self/maps""), OBFUSCATE(""rt""));
    if (fp != nullptr) {
        while (fgets(line, sizeof(line), fp)) {
            if (strstr(line, libraryName)) {
                char tmpPerms[5] = {0}, tmpDev[12] = {0}, tmpPathname[444] = {0};
                // parse a line in maps file
                // (format) startAddress-endAddress perms offset dev inode pathname
                sscanf(line, ""%llx-%llx %s %ld %s %d %s"",
                       (long long unsigned *) &retMap.startAddr,
                       (long long unsigned *) &retMap.endAddr,
                       tmpPerms, &retMap.offset, tmpDev, &retMap.inode, tmpPathname);

                retMap.length = (uintptr_t) retMap.endAddr - (uintptr_t) retMap.startAddr;
                retMap.perms = tmpPerms;
                retMap.dev = tmpDev;
                retMap.pathname = tmpPathname;

                break;
            }
        }
        fclose(fp);
    }
    return retMap;
}

uintptr_t KittyMemory::getAbsoluteAddress(const char *libraryName, uintptr_t relativeAddr, bool useCache) {
    ProcMap libMap;

    if(useCache){
        libMap = findMapInCache(libraryName);
        if(libMap.isValid())
        return (reinterpret_cast<uintptr_t>(libMap.startAddr) + relativeAddr);
    }

    libMap = getLibraryMap(libraryName);
    if (!libMap.isValid())
        return 0;

    if(useCache){
        mapsCache cachedMap;
        cachedMap.identifier = libraryName;
        cachedMap.map        = libMap;
        __mapsCache.push_back(cachedMap);
    }

    return (reinterpret_cast<uintptr_t>(libMap.startAddr) + relativeAddr);
}
",targetAddr
196,"#include <iostream>
#include <string>

int main() {
    std::string input; // Manter essa linha sob observação
    int  [MASK]  = 0;

    // Solicita ao usuário para inserir uma string
    std::cout << ""Digite uma string: "";
    std::getline(std::cin, input); // Lê a string completa, incluindo espaços

    // Percorre a string e conta as ocorrências de 'a' e 'A'
    for (char c : input) {
        if (c == 'a' || c == 'A') {
             [MASK] ++; // Incrementa o contador se encontrar 'a' ou 'A'
        }
    }

    // Verifica se a letra 'a' foi encontrada e exibe o resultado
    if ( [MASK]  > 0) {
        std::cout << ""A letra 'a' aparece "" <<  [MASK]  << "" vez(es) na string."" << std::endl;
    } else {
        std::cout << ""A letra 'a' não foi encontrada na string."" << std::endl;
    }

    return 0; 
}
",count
197,"// Button
int buttonPin = 34;

// Motor DC
int motor1Pin1 = 27; 
int motor1Pin2 = 26; 
int enable1Pin = 14;


// Setting PWM properties
const int freq = 30000;
const int pwmChannel = 0;
const int resolution = 8;
int dutyCycle = 200;

void setup() {
  // sets the pins as outputs:
  pinMode(motor1Pin1, OUTPUT);
  pinMode(motor1Pin2, OUTPUT);
  pinMode(enable1Pin, OUTPUT);
  //set the Button as input sign
  pinMode(buttonPin, INPUT_PULLUP);
  
  // configure LED PWM functionalitites
  ledcSetup(pwmChannel, freq, resolution);
  
  // attach the channel to the GPIO to be controlled
  ledcAttachPin(enable1Pin, pwmChannel);

  Serial.begin(115200);

  // testing
  Serial.print(""Testing DC Motor..."");
}

void loop() {

  int  [MASK]  = digitalRead(buttonPin);
  Serial.println( [MASK] );

  if ( [MASK]  == 0)
  {// Move the DC motor forward at maximum speed
  Serial.println(""Moving Forward"");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, HIGH);
  }

  else
  
  // Stop the DC motor
  Serial.println(""Motor stopped"");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, LOW);
  delay(5);
  

  // Move DC motor backwards at maximum speed
  //Serial.println(""Moving Backwards"");
  //digitalWrite(motor1Pin1, HIGH);
  //digitalWrite(motor1Pin2, LOW); 
  //delay(2000);

}",buttonValue
198,"#pragma once

#include <iostream>
#include <memory>
#include <sstream>
#include <vector>

#include ""magic_enum.hpp""

enum class SymbolType {
    Program,
    ExtDefList,
    ExtDef,
    ExtDecList,
    Specifier,
    StructSpecifier,
    OptTag,
    Tag,
    VarDec,
    FunDec,
    VarList,
    ParamDec,
    CompSt,
    StmtList,
    Stmt,
    DefList,
    Def,
    DecList,
    Dec,
    Exp,
    Args,
    INT,
    FLOAT,
    ID,
    SEMI,
    COMMA,
    ASSIGN,
    RELOP,
    PLUS,
    MINUS,
    STAR,
    DIV,
    AND,
    OR,
    DOT,
    NOT,
    TYPE,
    LP,
    RP,
    LB,
    RB,
    LC,
    RC,
    STRUCT,
    RETURN,
    IF,
    ELSE,
    WHILE
};

class Node {
public:
    using Type = SymbolType;
    std::string label;
    Type type;
    std::pair<int, int> position;
    // children is stored in reversed order
    std::vector<std::shared_ptr<Node>> children;
    Node(std::string const &label, Type type)
        : label(label), type(type) {}
    Node(std::string const &label, int line_pos, int char_pos, Type type)
        : label(label), type(type), position(line_pos, char_pos) {}
    ~Node() = default;
    std::string to_string() { return to_string("""", true, true); }

protected:
    std::string to_string(std::string prefix, bool last, bool root) {
        children.erase(std::remove(children.begin(), children.end(), nullptr), children.end());
        std::ostringstream  [MASK] ;
         [MASK]  << prefix;
        if (!root) {
             [MASK]  << (last ? ""└──"" : ""├──"");
        }
         [MASK]  << magic_enum::enum_name(type) << "" ("" << position.first << "") "" << label << std::endl;
        for (auto i = children.rbegin(); i != children.rend(); ++i) {
            auto new_prefix = prefix;
            if (!root) {
                new_prefix += (last ? ""    "" : ""│   "");
            }
            if (i + 1 != children.rend()) {
                 [MASK]  << (*i)->to_string(new_prefix, false, false);
            } else {
                 [MASK]  << (*i)->to_string(new_prefix, true, false);
            }
        }
        return  [MASK] .str();
    }
};

inline auto new_node(Node::Type type,
                     std::shared_ptr<Node> firschild = nullptr) {
    return std::make_shared<Node>("""", type);
}

inline auto make_node(Node::Type type) { return new_node(type, nullptr); }
template <class H>
inline auto make_node(Node::Type type, H first) {
    auto node = new_node(type, first);
    node->children.emplace_back(first);
    return node;
}

template <class H, class... T>
inline auto make_node(Node::Type type, H first, T... children) {
    auto node = make_node(type, children...);
    node->children.emplace_back(first);
    return node;
}
",buf
199,"#pragma once

#include <memory>
#include <type_traits>
#include <systemd/sd-bus.h>
#include <sdbusplus/message/append.hpp>
#include <sdbusplus/message/read.hpp>
#include <sdbusplus/message/native_types.hpp>

namespace sdbusplus
{

// Forward declare sdbusplus::bus::bus for 'friend'ship.
namespace bus
{
struct bus;
};

namespace message
{

using msgp_t = sd_bus_message*;
class message;

namespace details
{

/** @brief unique_ptr functor to release a msg reference. */
struct MsgDeleter
{
    void operator()(msgp_t ptr) const
    {
        sd_bus_message_unref(ptr);
    }
};

/* @brief Alias 'msg' to a unique_ptr type for auto-release. */
using msg = std::unique_ptr<sd_bus_message, MsgDeleter>;

} // namespace details

/** @class message
 *  @brief Provides C++ bindings to the sd_bus_message_* class functions.
 */
struct message
{
    /* Define all of the basic class operations:
     *     Not allowed:
     *         - Default constructor to avoid nullptrs.
     *         - Copy operations due to internal unique_ptr.
     *     Allowed:
     *         - Move operations.
     *         - Destructor.
     */
    message() = delete;
    message(const message&) = delete;
    message& operator=(const message&) = delete;
    message(message&&) = default;
    message& operator=(message&&) = default;
    ~message() = default;

    /** @brief Conversion constructor for 'msgp_t'.
     *
     *  Takes increment ref-count of the msg-pointer and release when
     *  destructed.
     */
    explicit message(msgp_t m) : _msg(sd_bus_message_ref(m))
    {
    }

    /** @brief Constructor for 'msgp_t'.
     *
     *  Takes ownership of the msg-pointer and releases it when done.
     */
    message(msgp_t m, std::false_type) : _msg(m)
    {
    }

    /** @brief Release ownership of the stored msg-pointer. */
    msgp_t release()
    {
        return _msg.release();
    }

    /** @brief Check if message contains a real pointer. (non-nullptr). */
    explicit operator bool() const
    {
        return bool(_msg);
    }

    /** @brief Perform sd_bus_message_append, with automatic type deduction.
     *
     *  @tparam ...Args - Type of items to append to message.
     *  @param[in] args - Items to append to message.
     */
    template <typename... Args> void append(Args&&... args)
    {
        sdbusplus::message::append(_msg.get(), std::forward<Args>(args)...);
    }

    /** @brief Perform sd_bus_message_read, with automatic type deduction.
     *
     *  @tparam ...Args - Type of items to read from message.
     *  @param[out] args - Items to read from message.
     */
    template <typename... Args> void read(Args&&... args)
    {
        sdbusplus::message::read(_msg.get(), std::forward<Args>(args)...);
    }

    /** @brief Get the dbus bus from the message. */
    // Forward declare.
    auto get_bus();

    /** @brief Get the signature of a message.
     *
     *  @return A [weak] pointer to the signature of the message.
     */
    const char* get_signature()
    {
        return sd_bus_message_get_signature(_msg.get(), true);
    }

    /** @brief Get the path of a message.
     *
     *  @return A [weak] pointer to the path of the message.
     */
    const char* get_path()
    {
        return sd_bus_message_get_path(_msg.get());
    }

    /** @brief Get the interface of a message.
     *
     *  @return A [weak] pointer to the interface of the message.
     */
    const char* get_interface()
    {
        return sd_bus_message_get_interface(_msg.get());
    }

    /** @brief Get the member of a message.
     *
     *  @return A [weak] pointer to the member of the message.
     */
    const char* get_member()
    {
        return sd_bus_message_get_member(_msg.get());
    }

    /** @brief Get the destination of a message.
     *
     *  @return A [weak] pointer to the destination of the message.
     */
    const char* get_destination()
    {
        return sd_bus_message_get_destination(_msg.get());
    }

    /** @brief Get the sender of a message.
     *
     *  @return A [weak] pointer to the sender of the message.
     */
    const char* get_sender()
    {
        return sd_bus_message_get_sender(_msg.get());
    }

    /** @brief Check if message is a method error.
     *
     *  @return True - if message is a method error.
     */
    bool is_method_error()
    {
        return sd_bus_message_is_method_error(_msg.get(), nullptr);
    }

    /** @brief Get the transaction cookie of a message.
     *
     * @return The transaction cookie of a message.
     */
    auto get_cookie()
    {
        uint64_t cookie;
        sd_bus_message_get_cookie(_msg.get(), &cookie);
        return cookie;
    }

    /** @brief Check if message is a method call for an interface/method.
     *
     *  @param[in] interface - The interface to match.
     *  @param[in] method - The method to match.
     *
     *  @return True - if message is a method call for interface/method.
     */
    bool is_method_call(const char* interface, const char* method)
    {
        return sd_bus_message_is_method_call(_msg.get(), interface, method);
    }

    /** @brief Check if message is a signal for an interface/member.
     *
     *  @param[in] interface - The interface to match.
     *  @param[in] member - The member to match.
     */
    bool is_signal(const char* interface, const char* member)
    {
        return sd_bus_message_is_signal(_msg.get(), interface, member);
    }

    /** @brief Create a 'method_return' type message from an existing message.
     *
     *  @return method-return message.
     */
    message new_method_return()
    {
        msgp_t  [MASK]  = nullptr;
        sd_bus_message_new_method_return(this->get(), & [MASK] );

        return message( [MASK] , std::false_type());
    }

    /** @brief Perform a 'method-return' response call. */
    void method_return()
    {
        auto b = sd_bus_message_get_bus(this->get());
        sd_bus_send(b, this->get(), nullptr);
    }

    /** @brief Perform a 'signal-send' call. */
    void signal_send()
    {
        method_return();
    }

    friend struct sdbusplus::bus::bus;

  private:
    /** @brief Get a pointer to the owned 'msgp_t'. */
    msgp_t get()
    {
        return _msg.get();
    }
    details::msg _msg;
};

} // namespace message

} // namespace sdbusplus
",reply
200,"#include <random>
#include <optional>
#include ""constants.h""
#include ""application_ui.h""
#include ""SDL2_gfxPrimitives.h""
#include ""wall.h""
#include ""ellipse.h""

std::random_device rd;

Ellipse getEllipseRGBA(std::optional<Ellipse_Coordinates> coordinates, std::optional<Ellipse_Color> color)
{
	Ellipse ellipse;

	// Définition des dimensions de l'ellipse à partir du rayon
	ellipse.rad = BALL_RADIUS;

	// Définition des couleurs de l'ellipse
	// On vérifie si les paramètres optionnel contienent des valeurs, sinon nous en générons aléatoirement
	if (color.has_value())
	{
		ellipse.color.r = color->r;
		ellipse.color.g = color->g;
		ellipse.color.b = color->b;
	}
	else
	{
		Ellipse_Color color = getRandomColor();
		ellipse.color.r = color.r;
		ellipse.color.g = color.g;
		ellipse.color.b = color.b;
	}

	// Définition des coordonnées de l'ellipse (avec décalage de l'origine pour éviter les débordements)
	// On vérifie si les paramètres optionnel contienent des valeurs, sinon nous en générons aléatoirement
	if (coordinates.has_value())
	{
		ellipse.coordinates.x = coordinates->x;
		ellipse.coordinates.y = coordinates->y;
	}
	else
	{
		Ellipse_Coordinates coordinates = getRandomCoordinates();
		ellipse.coordinates.x = coordinates.x;
		ellipse.coordinates.y = coordinates.y;
	}

	// Définition du vecteur directeur de l'ellipse
	Ellipse_Direction direction = getRandomDirectionVector(BALLS_VECT_MAX);
	ellipse.direction.vx = direction.vx;
	ellipse.direction.vy = direction.vy;

	return ellipse;
}

Ellipse_Color getRandomColor()
{
	// Création d'un générateur de nombres aléatoires
	std::mt19937 gen(rd());

	// Création d'une distribution uniforme entre les limites
	std::uniform_int_distribution<> dis(0, 255);

	// Génération d'une couleur aléatoire
	Uint8 r = dis(gen), g = dis(gen), b = dis(gen);

	return {r, g, b};
}

// TODO: On voudrais que la balle ne puisse pas apparaitre dans un mur, pour l'instant c'est pas le cas
Ellipse_Coordinates getRandomCoordinates()
{
	// Création d'un générateur de nombres aléatoires
	std::mt19937 gen(rd());

	// Création d'une distribution uniforme entre les limites
	// Les coordonnées dépendent du rayon des ellipses afin de toujours les faires apparaitre entièrement dans la fenêtre, tant que le diamètre des ellipses ne dépasse pas la taille de la fenêtre, nous sommes assurés qu'elles seront comprises dedans. On ajoute 1 pour la marge de la première frame.
	std::uniform_int_distribution<> dis1(0 + (BALL_RADIUS + 1), SCREEN_WIDTH - (BALL_RADIUS + 1));
	std::uniform_int_distribution<> dis2(0 + (BALL_RADIUS + 1), SCREEN_HEIGHT - (BALL_RADIUS + 1));

	// // Génération de coordonnées aléatoire
	int x = dis1(gen), y = dis2(gen);

	return {x, y};
}

Ellipse_Direction getRandomDirectionVector(int maxVect)
{
	// Création d'un générateur de nombres aléatoires
	std::mt19937 gen(rd());

	// Création d'une distribution uniforme entre les limites
	std::uniform_int_distribution<> dis((maxVect * -1), maxVect);

	int vx, vy = 0;

	do
	{
		vx = dis(gen);
		vy = dis(gen);
		// On exclu la valeur 0, sinon l'ellipse ne bougera pas (vecteur nul)
	} while (vx == 0 || vy == 0);

	return {vx, vy};
}

void drawEllipses(SDL_Renderer *renderer, std::vector<Ellipse> *ellipses)
{
	// Boucler dans le toute les ellipses
	for (size_t i = 0; i < ellipses->size(); i++)
	{
		Ellipse ellipse = (*ellipses)[i];
		// Dessiner l'ellipse
		filledEllipseRGBA(renderer, ellipse.coordinates.x, ellipse.coordinates.y, ellipse.rad, ellipse.rad, ellipse.color.r, ellipse.color.g, ellipse.color.b, 255);
	}
}

bool checkCollision(Ellipse &ball, Shape &shape)
{
	int ellipseX = ball.coordinates.x;
	int ellipseY = ball.coordinates.y;
	int ellipseR = ball.rad;
	int shapeX1 = shape.wallTop.x1;
	int  [MASK]  = shape.wallTop.y1;
	int shapeX2 = shape.wallBottom.x2;
	int shapeY2 = shape.wallBottom.y2;

	// Check collision with top wall
	if (ellipseY - ellipseR <=  [MASK]  && ellipseY + ellipseR >=  [MASK]  && (ellipseX + ellipseR >= shapeX1 && ellipseX - ellipseR <= shapeX2))
	{
		ball.direction.vy = -ball.direction.vy;
		return true;
	}
	// Check collision with bottom wall
	else if (ellipseY + ellipseR >= shapeY2 && ellipseY - ellipseR <= shapeY2 && (ellipseX + ellipseR >= shapeX1 && ellipseX - ellipseR <= shapeX2))
	{
		ball.direction.vy = -ball.direction.vy;
		return true;
	}
	// Check collision with left wall
	else if (ellipseX - ellipseR <= shapeX1 && ellipseX + ellipseR >= shapeX1 && (ellipseY + ellipseR >=  [MASK]  && ellipseY - ellipseR <= shapeY2))
	{
		ball.direction.vx = -ball.direction.vx;
		return true;
	}
	// Check collision with right wall
	else if (ellipseX + ellipseR >= shapeX2 && ellipseX - ellipseR <= shapeX2 && (ellipseY + ellipseR >=  [MASK]  && ellipseY - ellipseR <= shapeY2))
	{
		ball.direction.vx = -ball.direction.vx;
		return true;
	}
	return false;
}

void moveEllipes(std::vector<Ellipse> *ellipses, Shape *shape)
{
	Shape windowWalls = getWindowWalls();
	for (size_t i = 0; i < ellipses->size(); i++)
	{
		Ellipse ellipse = (*ellipses)[i];
		// Génère un nombre aléatoire entre 1 et 4 pour pouvoir le multiplier au BALLS_SPEED
		// TODO: FIX THIS (bug, ball trop rapide, voir comment on peut différencier direction et vitesse)
		// attention, ne pas laissé ici, la génération et nombre aléatoire et le changement de vitesse ne doit se faire qu'a la collision avec un mur, par a chaque avancé de la balle
		// int randomSpeed = (1 + (rand() % 4)) * BALLS_SPEED;
		int randomSpeed = 1;

		// Changement des postions de l'ellipse
		(*ellipses)[i].coordinates.x += randomSpeed * ellipse.direction.vx;
		(*ellipses)[i].coordinates.y += randomSpeed * ellipse.direction.vy;

		if (!checkCollision((*ellipses)[i], *shape))
			checkCollision((*ellipses)[i], windowWalls);
	}
}

void handleOnClick(std::vector<Ellipse> *ellipses, int mouseX, int mouseY)
{
	const Ellipse_Coordinates mouseCoordinates = {mouseX, mouseY};
	bool foundIt = false;
	size_t i = 0;

	while (!foundIt && i < ellipses->size())
	{
		Ellipse ellipse = (*ellipses)[i];

		int x_diff = mouseCoordinates.x - ellipse.coordinates.x;
		int y_diff = mouseCoordinates.y - ellipse.coordinates.y;
		int distance = sqrt(x_diff * x_diff + y_diff * y_diff);

		if (distance <= ellipse.rad)
			foundIt = true;
		else
			i++;
	}

	if (foundIt)
	{
		// Suppression d'une ellipse
		(*ellipses).erase((*ellipses).begin() + i);
	}
	else
	{
		// Créaton d'une nouvelle ellipse
		Ellipse ellipse = getEllipseRGBA(mouseCoordinates);
		(*ellipses).push_back(ellipse);
	}
}",shapeY1
201,"#pragma once

#include ""Core.h""

namespace NV
{
   
    // Event types
    enum class EventType
    {
        None = 0,
        WindowClose, WindowResize, WindowFocus, WindowLostFocus, WindowMoved,
        AppTick, AppUpdate, AppRender,
        KeyPressed, KeyReleased, KeyTyped,
        MouseButtonPressed, MouseButtonReleased, MouseMoved, MouseScrolled
    };

    // Event categories
    enum class EventCategory
    {
        None = 0,
        Application= BIT(0),
        Input = BIT(1),
        Keyboard = BIT(2),
        Mouse = BIT(3),
        MouseButton = BIT(4)
    };

    // 重载位运算符 |
    inline constexpr int operator|(EventCategory lhs, EventCategory  [MASK] ) {
    return static_cast<int>(lhs) | static_cast<int>( [MASK] );
    }

    // Event base class
    #define EVENT_CLASS_TYPE(type) static EventType GetStaticType() { return EventType::type; }\
                                   virtual EventType GetEventType() const override { return GetStaticType(); }\
                                   virtual const char* GetName() const override { return #type; }
                                 


    #define EVENT_CLASS_CATEGORY(category) virtual int GetCategoryFlags() const override { return (int)category; }

    // Event base class

    class Event
    {

        public:
            virtual ~Event() = default;
            virtual const char* GetName() const = 0;
            virtual EventType GetEventType() const = 0;
            virtual int GetCategoryFlags() const = 0;
            virtual std::string ToString() const { return GetName(); };
            

            inline bool IsInCategory(EventCategory category)
            {
                return GetCategoryFlags() & (int)category;
            }

            bool m_Handled = false;
    };


    // Event dispatcher
    class EventDispatcher
    {
        public:
            EventDispatcher(Event& event) : m_Event(event) {}

            template<typename T>
            using EventFn = std::function<bool(T&)>;

            template<typename T>
            bool Dispatch(EventFn<T> func)
            {
                if (m_Event.GetEventType() == T::GetStaticType())
                {
                    m_Event.m_Handled = func(*(T*)&m_Event);
                    return true;
                }
                return false;
            }
        private:
            Event& m_Event;
    };

    inline std::ostream& operator<<(std::ostream& os, const Event& e)
    {
        return os << e.ToString();
    }
}",rhs
202,"/*
 * Copyright (c) 2022 <NAME> <<EMAIL>>
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/sys/cbprintf.h>

#include <Arduino.h>
#include <api/Print.h>

namespace arduino
{
namespace zephyr
{

int cbprintf_callback(int c, void *ctx)
{
	return reinterpret_cast<arduino::Print *>(ctx)->write((unsigned char)c);
}

size_t wrap_cbprintf(void *ctx, const char *format, ...)
{
	va_list ap;
	int rc;

	va_start(ap, format);
	rc = cbvprintf(reinterpret_cast<cbprintf_cb>(cbprintf_callback), ctx, format, ap);
	va_end(ap);

	return static_cast<size_t>(rc > 0 ? rc : 0);
}

size_t print_number_base_any(void *ctx, unsigned long long ull, int base)
{
	arduino::Print &print = *reinterpret_cast<arduino::Print *>(ctx);
	char string[sizeof(unsigned long long) * 8] = {0};
	size_t digit = 0;
	unsigned value;

	if (base < 2 || base > ('~' - 'A' + 10)) {
		base = 10;
	}

	while (ull != 0) {
		value = ull % base;
		if (value < 10) {
			string[sizeof(string) - digit] = '0' + value;
		} else {
			string[sizeof(string) - digit] = 'A' + (value- 10);
		}

		digit++;
		ull /= base;
	}

	return print.write(string + (sizeof(string) - digit), digit + 1);
}

size_t print_number_base_pow2(void *ctx, unsigned long long ull, unsigned  [MASK] )
{
	arduino::Print &print = *reinterpret_cast<arduino::Print *>(ctx);
	const unsigned long long mask = (1 <<  [MASK] ) - 1;
	int digit = (((sizeof(unsigned long long) * 8) +  [MASK] ) /  [MASK] );
	int output_count = -1;
	unsigned value;

	while (digit >= 0) {
		value = (ull & (mask << (digit *  [MASK] ))) >> (digit *  [MASK] );
		if (value != 0 && output_count < 0) {
			output_count = 0;
		}

		if (output_count >= 0) {
			if (value < 10) {
				print.write('0' + value);
			} else {
				print.write('A' + (value- 10));
			}
			output_count++;
		}
		digit--;
	}

	return output_count;
}

} // namespace zephyr
} // namespace arduino

/*
 * This is the default implementation.
 * It will be overridden by subclassese.
 */
size_t arduino::Print::write(const uint8_t *buffer, size_t size)
{
  size_t i;
  for (i=0; i<size && write(buffer[i]); i++) {
  }

  return i;
}
",bits
203,"/*
 * CSRMatrixIO.h
 *
 *  Created on: 9 nov. 2015
 *      Author: guignont
 */

#ifndef SRC_MCGS_MATRIXVECTOR_IO_CSRMATRIXIO_H_
#define SRC_MCGS_MATRIXVECTOR_IO_CSRMATRIXIO_H_

namespace HartsSolver
{

template <typename ProfileType>
void exportProfile(Exporter &exporter,Exporter::FileNode base_node,const ProfileType &profile)
{
  typedef Exporter::FileNode FileNode;

  FileNode profile_node = exporter.createFileNode(base_node,""profile"");
  FileNode profile_type_node = exporter.createFileNode(profile_node,""profile-type"");
  exporter.dump(profile_type_node,std::string(""CSR""));
  exporter.closeFileNode(profile_type_node);

  FileNode profile_nlin_node = exporter.createFileNode(profile_node,""nlin"");
  int nlin = profile.getNRows();
  exporter.dump(profile_nlin_node, nlin);
  exporter.closeFileNode(profile_nlin_node);

  FileNode profile_ncol_node = exporter.createFileNode(profile_node,""ncol"");
  exporter.dump(profile_ncol_node,profile.getNCols());
  exporter.closeFileNode(profile_ncol_node);

  FileNode profile_nelem_node = exporter.createFileNode(profile_node,""nelem"");
  int nelem = profile.getNElems();
  exporter.dump(profile_nelem_node,nelem);
  exporter.closeFileNode(profile_nelem_node);

  FileNode profile_line_list_node = exporter.createFileNode(profile_node,""line-list"");
  exporter.dump(profile_line_list_node,profile.getKCol(),nlin+1);
  exporter.closeFileNode(profile_line_list_node);

  FileNode profile_col_idx_node = exporter.createFileNode(profile_node,""col-idx"");
  exporter.dump(profile_col_idx_node,profile.getCols(),nelem);
  exporter.closeFileNode(profile_col_idx_node);

  exporter.closeFileNode(profile_node);
}

template <typename MatrixType>
void exportMatrix(Exporter &exporter,Exporter::FileNode base_node,const MatrixType &matrix,const std::string &node_name)
{
  typedef Exporter::FileNode FileNode;

  FileNode matrix_node = exporter.createFileNode(base_node,node_name);
  FileNode element_blocksize_node = exporter.createFileNode(matrix_node,""element-blocksize"");
  int element_blocksize[2];
  element_blocksize[0] = matrix.getBlockSize();
  element_blocksize[1] = matrix.getBlockSize2();
  exporter.dump(element_blocksize_node,element_blocksize,2);
  exporter.closeFileNode(element_blocksize_node);

  FileNode values_node = exporter.createFileNode(matrix_node,""values"");
  exporter.dump(values_node,matrix.getAddressScalarData(),
      matrix.getProfile().getNElems()*matrix.getBlockSize()*matrix.getBlockSize2());
  FileNode  [MASK]  = exporter.createFileNode(values_node,""values-ordering"");
  exporter.dump( [MASK] ,std::string(""line-order""));
  exporter.closeFileNode( [MASK] );
  exporter.closeFileNode(values_node);

  exportProfile(exporter,matrix_node,matrix.getProfile());

  exporter.closeFileNode(matrix_node);
}

template <typename ProfileType>
void importProfile(Importer &importer,Importer::FileNode base_node,ProfileType &profile)
{
  typedef Importer::FileNode FileNode;

  FileNode profile_node = importer.openFileNode(base_node,""profile"");
  FileNode profile_type_node = importer.openFileNode(profile_node,""profile-type"");
  std::string profile_type;
  importer.read(profile_type_node,profile_type);
  if(profile_type != ""CSR""){
    throw BaseException::RunTimeError(""CSR profile expected, found :""+profile_type);
  }
  importer.closeFileNode(profile_type_node);

  FileNode profile_nlin_node = importer.openFileNode(profile_node,""nlin"");
  int nlin = 0;
  importer.read(profile_nlin_node,nlin);
  importer.closeFileNode(profile_nlin_node);

  FileNode profile_ncol_node = importer.openFileNode(profile_node,""ncol"");
  int ncol = 0;
  importer.read(profile_ncol_node,ncol);
  importer.closeFileNode(profile_ncol_node);

  FileNode profile_nelem_node = importer.openFileNode(profile_node,""nelem"");
  int nelem = 0;
  importer.read(profile_nelem_node,nelem);
  importer.closeFileNode(profile_nelem_node);

  profile.init(nlin,ncol,nelem);

  FileNode profile_line_list_node = importer.openFileNode(profile_node,""line-list"");
  importer.read(profile_line_list_node,profile.getKCol(),nlin+1);
  importer.closeFileNode(profile_line_list_node);

  FileNode profile_col_idx_node = importer.openFileNode(profile_node,""col-idx"");
  importer.read(profile_col_idx_node,profile.getCols(),nelem);
  importer.closeFileNode(profile_col_idx_node);

  importer.closeFileNode(profile_node);

  profile.prepare();
}

template <typename MatrixType>
void importMatrix(Importer &importer,Importer::FileNode base_node,MatrixType &matrix,const std::string &node_name=std::string(""matrix""))
{
  typedef typename MatrixType::ProfileType ProfileType;
  typedef Importer::FileNode FileNode;

  ProfileType *profile = new ProfileType();

  FileNode matrix_node = importer.openFileNode(base_node,node_name);

  importProfile(importer,matrix_node,*profile);
  matrix.setProfile(profile,true); // get profile ownership
  matrix.allocate();

  FileNode element_blocksize_node = importer.openFileNode(matrix_node,""element-blocksize"");
  int element_blocksize[2] = {0,0};
  importer.read(element_blocksize_node,element_blocksize,2);
  importer.closeFileNode(element_blocksize_node);

  if(element_blocksize[0] != MatrixType::m_block_size || element_blocksize[1] != MatrixType::m_block_size2){
    throw BaseException::RunTimeError(""Matrix element block size does not correspond to file element block size"");
  }

  FileNode values_node = importer.openFileNode(matrix_node,""values"");
  // TODO check for line/column data ordering
  importer.read(values_node,matrix.getAddressScalarData(),
      profile->getNElems()*MatrixType::m_block_size*MatrixType::m_block_size2);
  importer.closeFileNode(values_node);
}

}
#endif /* SRC_MCGS_MATRIXVECTOR_IO_CSRMATRIXIO_H_ */
",values_ordering_node
204,"//
// Created by <NAME>
// <EMAIL>
//

#include ""audioPlayer.h""
#include ""logger.h""

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <stdbool.h>

#define LOG_TAG ""[audioPlayer.c]""

#define SLASSERT(x)                   \
  do {                                \
    assert(SL_RESULT_SUCCESS == (x)); \
    (void)(x);                        \
  } while (0)

#define BUFFER_QUEUE_LEN    4

typedef struct SampleFormat {
    uint32_t sampleRate;
    uint32_t framesPerBuf;
    uint16_t numChannels;
    uint16_t pcmFormat;  // 8 bit, 16 bit, 24 bit ...
    uint32_t representation;  // android extensions
} SampleFormat;

// SL buffer queue player interfaces
typedef struct SLBufferQueuePlayer {
    SLObjectItf outputMixObjectItf;
    SLObjectItf playerObjectItf;
    SLPlayItf playItf;
    SLAndroidSimpleBufferQueueItf playBufferQueueItf;
    SampleFormat sampleInfo;
    uint32_t bufferSize;
    short *buffer;
} SLPlayer;

typedef struct SLEngine {
    SLmilliHertz fastPathSampleRate;
    uint32_t fastPathFramesPerBuf;
    uint16_t sampleChannels;
    uint16_t bitsPerSample;
    SLObjectItf slEngineObj;
    SLEngineItf slEngineItf;
} SLEngine;

SLEngine engine;
SLPlayer player;
SampleFormat sampleFormat;

FILE  *file = NULL;
bool isEOF = false;

static void bufferQueuePlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{
    assert(bq == player.playBufferQueueItf);
    assert(NULL == context);

    int bytes = fread(player.buffer, 1, player.bufferSize*sizeof(short), file);
    // int bytes = processGnFiveBandEq(player.buffer, engine.fastPathFramesPerBuf);
    SLresult result = (*bq)->Enqueue(bq, player.buffer, bytes);

    // LOG_DEBUG("" === === === Enqueue === === === %d"", bytes);

    // ToDo: need to handle EOF
    // Currently we listen to ""SL_RESULT_PARAMETER_INVALID"" to handle EOF
    if(SL_RESULT_PARAMETER_INVALID == result) {
        isEOF = true;
    } else {
        SLASSERT(result);
    }
}

static void ConvertToSLSampleFormat(SLAndroidDataFormat_PCM_EX* pFormat, SampleFormat* pSampleInfo_)
{
    assert(pFormat);
    memset(pFormat, 0, sizeof(*pFormat));

    pFormat->formatType = SL_DATAFORMAT_PCM;
    // Only support 2 channels
    // For channelMask, refer to wilhelm/src/android/channels.c for details
    if (pSampleInfo_->numChannels <= 1) {
        pFormat->numChannels = 1;
        pFormat->channelMask = SL_SPEAKER_FRONT_LEFT;
    } else {
        pFormat->numChannels = 2;
        pFormat->channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
    }
    pFormat->sampleRate = pSampleInfo_->sampleRate;

    pFormat->endianness = SL_BYTEORDER_LITTLEENDIAN;
    pFormat->bitsPerSample = pSampleInfo_->pcmFormat;
    pFormat->containerSize = pSampleInfo_->pcmFormat;

    // fixup for android extended representations...
    pFormat->representation = pSampleInfo_->representation;
    switch (pFormat->representation) {
        case SL_ANDROID_PCM_REPRESENTATION_UNSIGNED_INT:
            pFormat->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_8;
            pFormat->containerSize = SL_PCMSAMPLEFORMAT_FIXED_8;
            pFormat->formatType = SL_ANDROID_DATAFORMAT_PCM_EX;
            break;
        case SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT:
            pFormat->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;  // supports 16, 24, and 32
            pFormat->containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
            pFormat->formatType = SL_ANDROID_DATAFORMAT_PCM_EX;
            break;
        case SL_ANDROID_PCM_REPRESENTATION_FLOAT:
            pFormat->bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_32;
            pFormat->containerSize = SL_PCMSAMPLEFORMAT_FIXED_32;
            pFormat->formatType = SL_ANDROID_DATAFORMAT_PCM_EX;
            break;
        case 0:
            break;
        default:
            assert(0);
    }
}

static void createSLEngine(int sampleRate, int framesPerBuf, int numChannels)
{
    LOG_DEBUG("" == createSLEngine == "");
    LOG_DEBUG("" SampleRate: %d, SampleBufferSize: %d, numChannels: %d"",
              sampleRate, framesPerBuf, numChannels);

    SLresult result;
    memset(&engine, 0, sizeof(engine));

    engine.fastPathSampleRate = (SLmilliHertz)(sampleRate) * 1000;
    engine.fastPathFramesPerBuf = (uint32_t)(framesPerBuf);
    engine.sampleChannels = (uint16_t)numChannels;
    engine.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;

    memset(&sampleFormat, 0, sizeof(sampleFormat));
    sampleFormat.pcmFormat = (uint16_t)engine.bitsPerSample;
    sampleFormat.framesPerBuf = engine.fastPathFramesPerBuf;

    sampleFormat.representation = SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT;
    sampleFormat.numChannels = (uint16_t)engine.sampleChannels;
    sampleFormat.sampleRate = engine.fastPathSampleRate;

    // create SL engine
    result = slCreateEngine(&engine.slEngineObj, 0, NULL, 0, NULL, NULL);
    SLASSERT(result);

    result = (*engine.slEngineObj)->Realize(engine.slEngineObj, SL_BOOLEAN_FALSE);
    SLASSERT(result);

    result = (*engine.slEngineObj)->GetInterface(engine.slEngineObj, SL_IID_ENGINE, &engine.slEngineItf);
    SLASSERT(result);
}

static void deleteSLEngine()
{
    LOG_DEBUG("" == deleteSLEngine =="");

    if (engine.slEngineObj != NULL) {
        (*engine.slEngineObj)->Destroy(engine.slEngineObj);
        engine.slEngineObj = NULL;
        engine.slEngineItf = NULL;
    }
}

static void createSLPlayer(SampleFormat *sampleFormat, SLEngineItf slEngine)
{
    LOG_DEBUG("" == createSLBufferQueueAudioPlayer =="");

    SLresult result;
    assert(sampleFormat);
    player.sampleInfo = *sampleFormat;

    // create and realize the output mix
    result = (*slEngine)->CreateOutputMix(slEngine, &player.outputMixObjectItf, 0, NULL, NULL);
    SLASSERT(result);
    result = (*player.outputMixObjectItf)->Realize(player.outputMixObjectItf, SL_BOOLEAN_FALSE);
    SLASSERT(result);

    // configure audio source
    SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {
            SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, BUFFER_QUEUE_LEN};

    SLAndroidDataFormat_PCM_EX  [MASK] ;
    ConvertToSLSampleFormat(& [MASK] , &player.sampleInfo);
    SLDataSource audioSrc = {&loc_bufq, & [MASK] };

    // configure audio sink
    SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, player.outputMixObjectItf};
    SLDataSink audioSnk = {&loc_outmix, NULL};

    // create fast path audio player: SL_IID_BUFFERQUEUE and SL_IID_VOLUME
    // and other non-signal processing interfaces are ok.
    SLInterfaceID ids[2] = {SL_IID_BUFFERQUEUE, SL_IID_VOLUME};
    SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
    result = (*slEngine)->CreateAudioPlayer(slEngine, &player.playerObjectItf, &audioSrc, &audioSnk,
                                            sizeof(ids) / sizeof(ids[0]), ids, req);
    SLASSERT(result);

    // realize the player
    result = (*player.playerObjectItf)->Realize(player.playerObjectItf, SL_BOOLEAN_FALSE);
    SLASSERT(result);

    // get the play interface
    result = (*player.playerObjectItf)->GetInterface(player.playerObjectItf, SL_IID_PLAY,
                                                     &player.playItf);
    SLASSERT(result);

    // get the buffer queue interface
    result = (*player.playerObjectItf)->GetInterface(player.playerObjectItf, SL_IID_BUFFERQUEUE,
                                                     &player.playBufferQueueItf);
    SLASSERT(result);

    // register callback on the buffer queue
    result = (*player.playBufferQueueItf)->RegisterCallback(player.playBufferQueueItf,
                                                            bufferQueuePlayerCallback, NULL);
    SLASSERT(result);
}

static void deleteSLPlayer()
{
    LOG_DEBUG("" == deleteSLPlayer =="");

    // destroy buffer queue audio player object, and invalidate all associated
    // interfaces
    if (player.playerObjectItf != NULL) {
        (*player.playerObjectItf)->Destroy(player.playerObjectItf);
        player.playerObjectItf = NULL;
        player.playItf = NULL;
        player.playBufferQueueItf = NULL;
    }

    // free buffer
    free(player.buffer);
    player.buffer = NULL;

    // destroy output mix object, and invalidate all associated interfaces
    if (player.outputMixObjectItf) {
        (*player.outputMixObjectItf)->Destroy(player.outputMixObjectItf);
        player.outputMixObjectItf = NULL;
    }
}

static void shutdownAudioPlayer()
{
    LOG_DEBUG("" == shutdownAudioPlayer =="");

    // make sure the audio player was created
    if (NULL != player.playItf) {
        SLresult result = (*player.playItf)->SetPlayState(player.playItf, SL_PLAYSTATE_STOPPED);
        SLASSERT(result);
    }

    deleteSLPlayer();
    deleteSLEngine();
}

void playAudioPlayer(const char* audioFilePath, int sampleRate, int bufSize)
{
    LOG_DEBUG("" == playAudioPlayer =="");

    file = fopen(audioFilePath, ""r"");

    // ToDo: Hardcoded number of channel for now
    // createSLEngine(48000, 1024, 2);  // (sampleRate, framesPerBuffer, numChannels)
    createSLEngine(sampleRate, bufSize, 2);  // (sampleRate, framesPerBuffer, numChannels)
    createSLPlayer(&sampleFormat, engine.slEngineItf);

    SLresult result = (*player.playItf)->SetPlayState(player.playItf, SL_PLAYSTATE_PLAYING);
    SLASSERT(result);

    // buffer size (2 channels)
    player.bufferSize = sampleFormat.framesPerBuf * 2;
    player.buffer = (short *)calloc(player.bufferSize, sizeof(short));
    (*player.playBufferQueueItf)->Enqueue(player.playBufferQueueItf, player.buffer,
                                          player.bufferSize*sizeof(short));

    // ToDo: need an event loop and handle EOF
    // usleep(10000000);

    isEOF = false;
    while(1)
    {
        if(isEOF) {
            break;
        }
    }

    shutdownAudioPlayer();
}

void stopAudioPlayer()
{
    LOG_DEBUG("" == stopAudioPlayer =="");
    isEOF = true;
}
",format_pcm
205,"
#define _CRT_SECURE_NO_WARNINGS

#include ""DataBase.h""
#include ""Student.h""
#include <fstream>
#include <iostream>
// uzupelnij !!!

using namespace std;

DataBase::DataBase(const char* file)
    {
    strcpy(dataFileName, file);
    }

void DataBase::ListData(bool akt)
{
	// uzupelnij !!!
	ifstream wej(""data.bin"", ios::in | ios::binary);	//Otwarcie
	if (!wej)
	{
		cout << ""Nie mozna otworzyc pliku !!!"" << endl;
		return;
	}

	wej.seekg(0, ios::end);		//Ile obiektów
	long ile = wej.tellg() / sizeof(Student);
	wej.seekg(0, ios::beg);

	Student* studenciaki = new Student[ile];
	Student st;
	int i = 0;

	while (wej.read((char*)&st, sizeof(Student)))	//pobranie danych (można by całość na bieżąco wypisywać)
	{
		studenciaki[i] = st;
		i++;
	}

	for (int i = 0; i < ile; i++)	//wypisywanie warunkowe
	{
		if (akt == studenciaki[i].Active)
			cout << studenciaki[i];
	}


	//if (wej.eof())		//Usunięcie EOF??
	//	wej.clear();
	//else 
	//{
	//	cout << ""Niepoprawny odczyt pliku: "" << dataFileName << endl;
	//	return;
	//}
	
	delete[] studenciaki;
	wej.close();
	return;
}

void DataBase::Append()
{
    // uzupelnij !!!
	Student st;
	cout << ""Podaj imie: "" << endl;
	cin >> st.FirstName;
	cout << ""Podaj nazwisko: "" << endl;
	cin >> st.LastName;
	cout << ""Podaj NrInd: "" << endl;
	cin >> st.IdNumber;
	cout << ""Podaj grupe: "" << endl;
	cin >> st.Group;
	cout << ""Podaj srednia: "" << endl;
	cin >> st.Average;
	st.Active = 1;

	ofstream  [MASK] (""data.bin"", ios::in | ios::binary);	//Otwarcie
	if (! [MASK] )
	{
		cout << ""Nie mozna otworzyc pliku !!!"" << endl;
		return;
	}

	 [MASK] .seekp(0, ios::end);		//Append
	if ( [MASK] .write((char*)&st, sizeof(Student)))
		cout << ""Dane poprawione !"" << endl;
	else 
		cout << ""Niepowodzenie"" << endl;

	 [MASK] .close();
	return;
}

void DataBase::Modify()
{
    // uzupelnij !!!
	fstream plik(dataFileName, ios::in | ios::out | ios::binary);	//Otwarcie
	if (!plik)
	{
		cout << ""Nie mozna otworzyc pliku !!!"" << endl;
		return;
	}

	plik.seekg(0, ios::end);		//Ile obiektów
	long ile = plik.tellg() / sizeof(Student);
	plik.seekg(0, ios::beg);

	Student* studenciaki = new Student[ile];
	Student st;
	int i = 0;

	while (plik.read((char*)&st, sizeof(Student)))	//pobranie danych (można by całość na bieżąco wypisywać)
	{
		studenciaki[i] = st;
		i++;
	}
	plik.clear();

	cout << ""Podaj NrInd: "" << endl;
	cin >> st.IdNumber;

	for (int i = 0; i < ile; i++)
	{
		if (st.IdNumber == studenciaki[i].IdNumber)
		{

			plik.seekg(sizeof(Student)*(i), ios::beg);		// w to samo miejsce
			plik.read((char*)&st, sizeof(Student));

			cout << st;

			cout << ""Podaj grupe: "" << endl;
			cin >> st.Group;
			cout << ""Podaj srednia: "" << endl;
			cin >> st.Average;
			cout << ""Czy aktywny? (0/1)"";
			cin >> st.Active;

			plik.seekp(sizeof(Student)*(i), ios::beg);
			if (plik.write((char*)&st, sizeof(Student)))
				cout << ""Dane poprawione!"" << endl;
			else cout << ""???"";
			return;
		}
	}

	cout << ""Nie ma takiego studenta"";
	plik.close();
	return;
}

void DataBase::Pack()
{
    // uzupelnij !!!
}

void DataBase::WriteTextData()
{
    // uzupelnij !!!
}

void DataBase::ReadTextData()
{
    // uzupelnij !!!
}
",wyj
206,"#include ""WindowsWindow.h""
#include ""Jogo/Log.h""

namespace Jogo
{
	static bool s_GLFWInitialized = false;

	Window* Window::Create(const WindowProps& props)
	{
		return new WindowsWindow(props);
	}


	WindowsWindow::WindowsWindow(const WindowProps& props)
	{
		Init(props);
	}

	WindowsWindow::~WindowsWindow()
	{
		Shutdown();
	}

	void WindowsWindow::Init(const WindowProps& props)
	{
		m_Data.Title = props.Title;
		m_Data.Width = props.Width;
		m_Data.Height = props.Height;

		JG_CORE_INFO(""Creating window {0} ({1}, {2})"", props.Title, props.Width, props.Height);

		if (!s_GLFWInitialized)
		{
			int success = glfwInit();
			assert(success, ""Couldn't initialize GLFW!"");

			s_GLFWInitialized = true;
		}

		m_Window = glfwCreateWindow((int)m_Data.Width, (int)m_Data.Height, m_Data.Title.c_str(), nullptr, nullptr);
		glfwMakeContextCurrent(m_Window);
		glfwSetWindowUserPointer(m_Window, &m_Data);
		SetVSync(true);
	}

	void WindowsWindow::Shutdown()
	{
		glfwDestroyWindow(m_Window);
	}

	void WindowsWindow::OnUpdate()
	{
		glfwPollEvents();
		glfwSwapBuffers(m_Window);
	}

	void WindowsWindow::SetVSync(bool  [MASK] )
	{
		if ( [MASK] )
			glfwSwapInterval(1);
		else
			glfwSwapInterval(0);

		m_Data.VSync =  [MASK] ;
	}

	bool WindowsWindow::IsVSync() const
	{
		return m_Data.VSync;
	}



}",enabled
207,"#include <gui/screen1_screen/Screen1View.hpp>
#include <texts/TextKeysAndLanguages.hpp>
#include <touchgfx/containers/SlideMenu.hpp>
#include <algorithm>
#include <global_val.h>
#include <mysignal.h>

#define SCREEN_HEIGHT 260
#define SCREEN_WIDTH 200
#define MAX_X_SCALE_INDEX 6
#define MAX_Y_SCALE_INDEX 12
#define MAX_OFFSET 130
#define MIN_OFFSET -130
#define MAX_LEVEL 270
#define MIN_LEVEL 25
#define MAX_CURSOR_1X 435
#define MIN_CURSOR_1X 20
#define MAX_CURSOR_1Y 250
#define MIN_CURSOR_1Y 25

extern int16_t encoderValue;
extern uint8_t trigger_level; // 0-255
extern uint8_t offset; // 0-255

extern trigger_mode_typedef trigger_mode;
extern int32_t time_scale;         // capture 1 data from every n points
extern uint8_t read_encoder;
extern int8_t set_relay;

extern float input_v_pp;
extern float input_frequency;
extern float input_period;
extern float x_unit;
extern float y_unit;

// map [0, 255] to [-5, 5] (float) for display purpose
float UnMap(uint8_t  [MASK] )
{
	return ((float) [MASK]  / 25.5) - 5;
}

Screen1View::Screen1View()
{
	singleToggle[0] = &XScaleToggle;
	singleToggle[1] = &YScaleToggle;
	singleToggle[2] = &offsetToggle;
	singleToggle[3] = &levelToggle;
	singleToggle[4] = &cursor1XToggle;
	singleToggle[5] = &cursor1YToggle;
	singleToggle[6] = &cursor2XToggle;
	singleToggle[7] = &cursor2YToggle;

	menuList[0] = &mainMenu;
	menuList[1] = &displayMenu;
	menuList[2] = &measureMenu;
	menuList[3] = &triggerMenu;
	menuList[4] = &cursorMenu;

}

void Screen1View::setupScreen()
{
    Screen1ViewBase::setupScreen();
}

void Screen1View::tearDownScreen()
{
    Screen1ViewBase::tearDownScreen();
}

void Screen1View::onBackButtonClicked()
{
	// hide every menu container
	for (int i = 1; i < 5; i ++)
	{
		menuList[i]->setVisible(false);
		menuList[i]->invalidate();
	}

	// hide back button itself
	backButton.setVisible(false);
	backButton.invalidate();

	// show main menu back on
	mainMenu.setVisible(true);
	mainMenu.invalidate();
}

void Screen1View::onDisplayMenuClicked()
{
	// hide main menu first
	mainMenu.setVisible(false);

	// show display menu and back button
	displayMenu.setVisible(true);
	backButton.setVisible(true);

	mainMenu.invalidate();
	displayMenu.invalidate();
	backButton.invalidate();
}

void Screen1View::onMeasureMenuClicked()
{
	mainMenu.setVisible(false);
	measureMenu.setVisible(true);
	backButton.setVisible(true);

	mainMenu.invalidate();
	measureMenu.invalidate();
	backButton.invalidate();
}

void Screen1View::onTriggerMenuClicked()
{
	mainMenu.setVisible(false);
	triggerMenu.setVisible(true);
	backButton.setVisible(true);

	mainMenu.invalidate();
	triggerMenu.invalidate();
	backButton.invalidate();
}

void Screen1View::onCursorMenuClicked()
{
    mainMenu.setVisible(false);
    cursorMenu.setVisible(true);
    backButton.setVisible(true);

    mainMenu.invalidate();
	cursorMenu.invalidate();
	backButton.invalidate();
}

// TODO: naive implementation for toggling measure
// should rearrange text position

void Screen1View::onMeasureToggled(
		const touchgfx::ToggleButton* targetButton,
		touchgfx::TextArea* targetText)
{
	targetText->setVisible(!(targetButton->getState()));
	targetText->invalidate();
}
void Screen1View::onVppToggled()
{
	Screen1View::onMeasureToggled(&VppToggle, &VppText);
}
void Screen1View::onFreqToggled()
{
	Screen1View::onMeasureToggled(&freqToggle, &freqText);
}
void Screen1View::onPeriodToggled()
{
	Screen1View::onMeasureToggled(&periodToggle, &periodText);
}

void Screen1View::onSingleToggle(const touchgfx::ToggleButton* targetToggle)
{
	encoderZero = encoderValue;
	for (int i = 0; i < 8; i ++)
	{
		if (singleToggle[i] != targetToggle)
		{
			singleToggle[i]->forceState(false);
			singleToggle[i]->invalidate();
		}
	}
	horizontalLine0.setVisible(false);
	horizontalLine0.invalidate();
	horizontalLine1.setVisible(false);
	horizontalLine1.invalidate();
	verticalLine1.setVisible(false);
	verticalLine1.invalidate();
	horizontalLine2.setVisible(false);
	horizontalLine2.invalidate();
	verticalLine2.setVisible(false);
	verticalLine2.invalidate();
	lastXScaleIndex = curXScale;
	lastYScaleIndex = curYScale;
	lastOffset = curOffset;
	lastLevel = triggerLevel;
	lastCursor1X = curCursor1X;
	lastCursor1Y = curCursor1Y;
	lastCursor2X = curCursor2X;
	lastCursor2Y = curCursor2Y;
}

void Screen1View::onXScaleToggled()
{
	encoderTarget = (XScaleToggle.getState()) ? 1 : 0;
	if(XScaleToggle.getState() == false) {
			lastXScaleIndex = curXScale;
		}
		else {
			curXScale = lastXScaleIndex;
		}
	onSingleToggle(&XScaleToggle);
}

void Screen1View::onYScaleToggled()
{
	encoderTarget = (YScaleToggle.getState()) ? 2 : 0;
	if(YScaleToggle.getState() == false) {
		lastYScaleIndex = curYScale;
	}
	else {
		curYScale = lastYScaleIndex;
	}
	onSingleToggle(&YScaleToggle);
}

void Screen1View::onOffsetToggled()
{
	encoderTarget = (offsetToggle.getState()) ? 3 : 0;
	if(offsetToggle.getState() == false) {
		lastOffset = curOffset;
	}
	else {
		curOffset = lastOffset;
	}
	onSingleToggle(&offsetToggle);
}

void Screen1View::onLevelToggled()
{
	encoderTarget = (levelToggle.getState()) ? 4 : 0;
	onSingleToggle(&levelToggle);
	if (levelToggle.getState())
	{
		triggerLevel = lastLevel;
		horizontalLine0.setVisible(true);
		horizontalLine0.invalidate();
	}
	else {
		lastLevel = triggerLevel;
	}
}

void Screen1View::onCursor1XToggled()
{
	encoderTarget = (cursor1XToggle.getState()) ? 5 : 0;
	onSingleToggle(&cursor1XToggle);
	if(cursor1XToggle.getState() == false) {
		lastCursor1X = curCursor1X;
	}
	else {
		curCursor1X = lastCursor1X;
		horizontalLine1.setVisible(true);
		horizontalLine1.invalidate();
		verticalLine1.setVisible(true);
		verticalLine1.invalidate();
	}
}

void Screen1View::onCursor2XToggled()
{
	encoderTarget = (cursor2XToggle.getState()) ? 7 : 0;
	onSingleToggle(&cursor2XToggle);
	if (cursor2XToggle.getState() == false)
	{
		lastCursor2X = curCursor2X;
	}
	else
	{
		curCursor2X = lastCursor2X;
		horizontalLine2.setVisible(true);
		horizontalLine2.invalidate();
		verticalLine2.setVisible(true);
		verticalLine2.invalidate();
	}
}
void Screen1View::onCursor1YToggled()
{
	encoderTarget = (cursor1YToggle.getState()) ? 6 : 0;
	onSingleToggle(&cursor1YToggle);
	if(cursor1YToggle.getState() == false) {
		lastCursor1Y = curCursor1Y;
	}
	else {
		curCursor1Y = lastCursor1Y;
		horizontalLine1.setVisible(true);
		horizontalLine1.invalidate();
		verticalLine1.setVisible(true);
		verticalLine1.invalidate();
	}
}

void Screen1View::onCursor2YToggled()
{
	encoderTarget = (cursor2YToggle.getState()) ? 8 : 0;
	onSingleToggle(&cursor2YToggle);
	if (cursor2YToggle.getState() == false)
	{
		lastCursor2Y = curCursor2Y;
	}
	else
	{
		curCursor2Y = lastCursor2Y;
		horizontalLine2.setVisible(true);
		horizontalLine2.invalidate();
		verticalLine2.setVisible(true);
		verticalLine2.invalidate();
	}

}

void Screen1View::tick()
{
	switch(encoderTarget) {
		case 0:
			break;
		case 1: // XScale
			read_encoder = 1;
			curXScale = lastXScaleIndex + encoderValue - encoderZero;
			if(curXScale > MAX_X_SCALE_INDEX) {
				curXScale = MAX_X_SCALE_INDEX;
				encoderZero = lastXScaleIndex + encoderValue - curXScale;
			}
			if(curXScale < 0) {
				curXScale = 0;
				encoderZero = lastXScaleIndex + encoderValue - curXScale;
			}
			time_scale = XScaleTable[curXScale];
			break;
		case 2: // YScale
			read_encoder = 1;
			curYScale = lastYScaleIndex + encoderValue - encoderZero;
			if(curYScale > MAX_Y_SCALE_INDEX) {
				curYScale = MAX_Y_SCALE_INDEX;
				encoderZero = lastYScaleIndex + encoderValue - curYScale;
			}
			if(curYScale < 0) {
				curYScale = 0;
				encoderZero = lastYScaleIndex + encoderValue - curYScale;
			}
			if(nowRelay == -1 && curYScale >= switchYScaleIndex) {
				nowRelay = 1;
				set_relay = 1;
			}
			else if(nowRelay == 1 && curYScale < switchYScaleIndex) {
				nowRelay = -1;
				set_relay = -1;
			}
			break;
		case 3: // offset
			read_encoder = 1;
			curOffset = lastOffset + (encoderValue - encoderZero) * 5;
			if(curOffset > MAX_OFFSET) {
				curOffset = MAX_OFFSET;
				encoderZero = encoderValue - (curOffset - lastOffset) / 5;
			}
			if(curOffset < MIN_OFFSET) {
				curOffset = MIN_OFFSET;
				encoderZero = encoderValue - (curOffset - lastOffset) / 5;
			}
			offset = (curOffset - MIN_OFFSET) * 255 / (MAX_OFFSET - MIN_OFFSET);
			break;
		case 4: // level
			read_encoder = 1;
			triggerLevel = lastLevel + (encoderValue - encoderZero) * 5;
			if(triggerLevel >= MAX_CURSOR_1Y) {
				triggerLevel = MAX_CURSOR_1Y;
				encoderZero = encoderValue - (triggerLevel - lastLevel) / 5;
			}
			if(triggerLevel <= MIN_CURSOR_1Y) {
				triggerLevel = MIN_CURSOR_1Y;
				encoderZero = encoderValue - (triggerLevel - lastLevel) / 5;
			}
			trigger_level = (triggerLevel - MIN_LEVEL) * 255 / (MAX_LEVEL - MIN_LEVEL);
			horizontalLine0.setPosition(15, (int16_t)(MAX_LEVEL - triggerLevel), slideMenu1.getState() == SlideMenu::COLLAPSED ? 430 : 297, 15);
			horizontalLine0.invalidate();
			break;
		case 5: // cursor1X
			read_encoder = 1;
			curCursor1X = lastCursor1X + (encoderValue - encoderZero) * 5;
			if(curCursor1X >= MAX_CURSOR_1X) {
				curCursor1X = MAX_CURSOR_1X;
				encoderZero = encoderValue - (curCursor1X - lastCursor1X) / 5;
			}
			if(curCursor1X <= MIN_CURSOR_1X) {
				curCursor1X = MIN_CURSOR_1X;
				encoderZero = encoderValue - (curCursor1X - lastCursor1X) / 5;
			}
			verticalLine1.setPosition(slideMenu1.getState() == SlideMenu::COLLAPSED ? (int16_t)curCursor1X : (int16_t)curCursor1X * 297 / 450, 20, 15, 230);
			verticalLine1.invalidate();
			break;
		case 6: // cursor1Y
			read_encoder = 1;
			curCursor1Y = lastCursor1Y + (encoderValue - encoderZero) * 5;
			if(curCursor1Y >= MAX_CURSOR_1Y) {
				curCursor1Y = MAX_CURSOR_1Y;
				encoderZero = encoderValue - (curCursor1Y - lastCursor1Y) / 5;
			}
			if(curCursor1Y <= MIN_CURSOR_1Y) {
				curCursor1Y = MIN_CURSOR_1Y;
				encoderZero = encoderValue - (curCursor1Y - lastCursor1Y) / 5;
			}
			horizontalLine1.setPosition(15, (int16_t)(MAX_LEVEL - curCursor1Y), slideMenu1.getState() == SlideMenu::COLLAPSED ? 435 : 297, 15);
			horizontalLine1.invalidate();
			break;
		case 7:
			read_encoder = 1;
			curCursor2X = lastCursor2X + (encoderValue - encoderZero) * 5;
			if(curCursor2X >= MAX_CURSOR_1X) {
				curCursor2X = MAX_CURSOR_1X;
				encoderZero = encoderValue - (curCursor2X - lastCursor2X) / 5;
			}
			if(curCursor2X <= MIN_CURSOR_1X) {
				curCursor2X = MIN_CURSOR_1X;
				encoderZero = encoderValue - (curCursor2X - lastCursor2X) / 5;
			}
			verticalLine2.setPosition(slideMenu1.getState() == SlideMenu::COLLAPSED ? (int16_t)curCursor2X : (int16_t)curCursor2X * 297 / 450, 20, 15, 230);
			verticalLine2.invalidate();
			break;
		case 8:
			read_encoder = 1;
			curCursor2Y = lastCursor2Y + (encoderValue - encoderZero) * 5;
			if(curCursor2Y >= MAX_CURSOR_1Y) {
				curCursor2Y = MAX_CURSOR_1Y;
				encoderZero = encoderValue - (curCursor2Y - lastCursor2Y) / 5;
			}
			if(curCursor2Y <= MIN_CURSOR_1Y) {
				curCursor2Y = MIN_CURSOR_1Y;
				encoderZero = encoderValue - (curCursor2Y - lastCursor2Y) / 5;
			}
			horizontalLine2.setPosition(15, (int16_t)(MAX_LEVEL - curCursor2Y), slideMenu1.getState() == SlideMenu::COLLAPSED ? 435 : 297, 15);
			horizontalLine2.invalidate();
			break;
		default:
			break;
	}
	Unicode::snprintfFloat(cursor1DataTextBuffer1, 10, ""%.3f\0"", curCursor1X);
	Unicode::snprintfFloat(cursor1DataTextBuffer2, 10, ""%.3f\0"", curCursor1Y);
	Unicode::snprintfFloat(cursor2DataTextBuffer1, 10, ""%.3f\0"", curCursor2X);
	Unicode::snprintfFloat(cursor2DataTextBuffer2, 10, ""%.3f\0"", curCursor2Y);
	cursor1DataText.invalidate();
	cursor2DataText.invalidate();
}

void Screen1View::onSlideMenuUpdated()
{
	if (slideMenu1.getState() == SlideMenu::COLLAPSED)
	{
//		slideMenu.setPisition()
		backButton.setVisible(false);
		for (int i = 1; i < 5; i ++)
		{
			menuList[i]->setVisible(false);
		}
		mainMenu.setVisible(true);
		displayGraph.setPosition(15, 20, 435, 230);
		displayGraph.invalidate();
//		slideMenu1.setXY(486, 0);
//		slideMenu1.invalidate();
		horizontalLine0.setPosition(15, (int16_t)(250 - triggerLevel), 435, 15);
		horizontalLine0.invalidate();
		horizontalLine1.setPosition(15, (int16_t)(250 - curCursor1Y), 435, 15);
		horizontalLine1.invalidate();
		verticalLine1.setPosition((int16_t)curCursor1X, 20, 15, 230);
		verticalLine1.invalidate();
		horizontalLine2.setPosition(15, (int16_t)(250 - curCursor2Y), 435, 15);
		horizontalLine2.invalidate();
		verticalLine2.setPosition((int16_t)curCursor2X, 20, 15, 230);
		verticalLine2.invalidate();
	}
	else
	{
		displayGraph.setPosition(15, 20, 297, 230);
		displayGraph.invalidate();
		horizontalLine0.setPosition(15, (int16_t)(250 - triggerLevel), 297, 15);
		horizontalLine0.invalidate();
		horizontalLine1.setPosition(15, (int16_t)(250 - curCursor1Y), 297, 15);
		horizontalLine1.invalidate();
		verticalLine1.setPosition((int16_t)curCursor1X * 297 / 435, 20, 15, 230);
		verticalLine1.invalidate();
		horizontalLine2.setPosition(15, (int16_t)(250 - curCursor2Y), 297, 15);
		horizontalLine2.invalidate();
		verticalLine2.setPosition((int16_t)curCursor2X * 297 / 435, 20, 15, 230);
		verticalLine2.invalidate();
	}
}

void Screen1View::UpdateGraph(uint8_t* dataHead, uint8_t* dataTail, uint8_t* graphHead)
{
	displayGraph.clear();
	for (uint8_t* i = graphHead; i < dataTail; i ++)
	{
		displayGraph.addDataPoint((*i - (SCREEN_HEIGHT / 2)) * YScaleTable[curYScale] * (nowRelay == 1 ? 2 : 1) + (SCREEN_HEIGHT / 2) + curOffset);
	}
	for (uint8_t* i = dataHead; i < graphHead; i++)
	{
		displayGraph.addDataPoint((*i - (SCREEN_HEIGHT / 2)) * YScaleTable[curYScale] * (nowRelay == 1 ? 2 : 1) + (SCREEN_HEIGHT / 2) + curOffset);
	}
	displayGraph.invalidateContent();
// extern float input_v_pp;
//	extern float input_frequency;
//	extern float input_period;
	Unicode::snprintfFloat(VppTextBuffer, sizeof(VppTextBuffer), ""%.3f"", input_v_pp);
	Unicode::snprintfFloat(freqTextBuffer, sizeof(freqTextBuffer), ""%.1f"", input_frequency / 1000);
	Unicode::snprintfFloat(periodTextBuffer, sizeof(periodTextBuffer), ""%.3f"", input_period * 1000000);
	VppText.invalidateContent();
	freqText.invalidateContent();
	periodText.invalidateContent();
	Unicode::snprintfFloat(dispXTextBuffer, 10, ""%.1f"", x_unit * 1000);
	Unicode::snprintfFloat(dispYTextBuffer, 10, ""%.3f"", y_unit / YScaleTable[curYScale]);
	dispXText.invalidateContent();
	dispYText.invalidateContent();
}

void Screen1View::onTriggerTypeClicked()
{
	triggerType = !triggerType;
	if (triggerType)
	{
		Unicode::strncpy(triggerTypeTextBuffer, ""falling"", TRIGGERTYPETEXT_SIZE);
		trigger_mode = TRIGGER_MODE_FALLING;
	}
	else
	{
		Unicode::strncpy(triggerTypeTextBuffer, ""rising"", TRIGGERTYPETEXT_SIZE);
		trigger_mode = TRIGGER_MODE_RISING;
	}
	triggerTypeText.invalidate();
}
",value
208,"#include <iostream>
#include <string>
#include <vector>
#include <math.h>

#include <cvode/cvode.h>             /* main integrator header file */
#include <cvode/cvode_dense.h>       /* use CVDENSE linear solver */
#include <cvode/cvode_band.h>        /* use CVBAND linear solver */
#include <cvode/cvode_diag.h>        /* use CVDIAG linear solver */
#include <nvector/nvector_serial.h>  /* serial N_Vector types, fct. and macros */
#include <sundials/sundials_types.h> /* definition of realtype */
#include <sundials/sundials_math.h>  /* contains the macros ABS, SUNSQR, and EXP*/

#include <csim/model.h>
#include <csim/error_codes.h>
#include <csim/executable_functions.h>

/* Shared Problem Constants */

#define ATOL RCONST(1.0e-6)
#define RTOL RCONST(0.0)

/* Functions called by CVODE */
static int f(realtype t, N_Vector y, N_Vector ydot, void *user_data);

/* Private function to check function return values */
static int check_flag(void *flagvalue, const char *funcname, int opt);

// My user data class
struct UserData
{
    csim::ModelFunction modelFunction;
    N_Vector states, inputs, outputs;
};

void usage(int argc, char* argv[])
{
    if (argc < 3)
    {
        std::cerr << ""CSim example: CVODE integrator\n""
                  << argv[0] << "" <CellML model file> <output variable 1> [output 2...]"" << std::endl;
        std::cerr << ""\tOutput variables should be indentified using component_name/variable_name\n""
                  << ""\tAt least one output must be specified. "" << std::endl;
        exit(-1);
    }
}

void printResults(UserData& ud)
{
    for (int i = 0; i < NV_LENGTH_S(ud.outputs); ++i)
    {
        if (i != 0) std::cout << ""\t"";
        std::cout << NV_Ith_S(ud.outputs, i);
    }
    std::cout << std::endl;
}

int main(int argc, char* argv[])
{
    // for collecting data passed into CVODE
    UserData ud;
    // define the simulation for now
    double x0 = 0, x1 = M_PI * 2.0;
    int  [MASK]  = 100;
    // check command line arguments
    usage(argc, argv);
    csim::Model model;
    model.loadCellmlModel(argv[1]);
    // output variables
    std::vector<std::string> outputNames;
    std::vector<int> outputIndicies;
    int error = 0;
    for (int i = 2; i < argc; ++i)
    {
        outputNames.push_back(argv[i]);
        int index = model.setVariableAsOutput(argv[i]);
        if (index < 0) error++;
        else outputIndicies.push_back(index);
    }
    if (error)
    {
        std::cerr << ""There was an error setting output variables."" << std::endl;
        return -2;
    }
    if (model.instantiate() != csim::CSIM_OK)
    {
        std::cerr << ""There was an error instantiating the model."" << std::endl;
        return -3;
    }
    // grab the model's executable functions
    csim::InitialiseFunction initFunction = model.getInitialiseFunction();
    ud.modelFunction = model.getModelFunction();
    if ((initFunction == NULL) || (ud.modelFunction == NULL))
    {
        std::cerr << ""Unable to get the model's executable function(s)."" << std::endl;
        return -4;
    }
    ud.states = N_VNew_Serial(model.numberOfStateVariables());
	N_Vector rates = N_VNew_Serial(model.numberOfStateVariables());
    ud.inputs = N_VNew_Serial(0);
    ud.outputs = N_VNew_Serial(outputNames.size());
    // now get CVODE set up
    double reltol = RTOL, abstol = ATOL;
    // initialise the inputs and initial values of the state variables
    initFunction(NV_DATA_S(ud.states), NV_DATA_S(ud.outputs), NV_DATA_S(ud.inputs));
    // and calculate and print the initial state of the model
    ud.modelFunction(x0, NV_DATA_S(ud.states), NV_DATA_S(rates), NV_DATA_S(ud.outputs), NV_DATA_S(ud.inputs));
    std::cout << ""results headed goes here"" << std::endl;
    printResults(ud);

    // create and initialise our CVODE integrator
    void* cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL);
    if(check_flag((void *)cvode_mem, ""CVodeCreate"", 0)) return(1);
    int flag = CVodeInit(cvode_mem, f, x0, ud.states);
    if(check_flag(&flag, ""CVodeInit"", 1)) return(1);
    flag = CVodeSStolerances(cvode_mem, reltol, abstol);
    if(check_flag(&flag, ""CVodeSStolerances"", 1)) return(1);

    // add our user data
    flag = CVodeSetUserData(cvode_mem, (void*)(&ud));
    if (check_flag(&flag,""CVodeSetUserData"",1)) return(1);

    double dx = (x1 - x0) /  [MASK] ;
    double x = x0, xout = x0;
    for (int i = 0; i <  [MASK] ; ++i)
    {
        xout += dx;
        flag = CVodeSetStopTime(cvode_mem, xout);
        if (check_flag(&flag,""CVodeSetStopStime"",1)) return(1);
        flag = CVode(cvode_mem, xout, ud.states, &x, CV_NORMAL);
        if (check_flag(&flag,""CVode"",1)) return(1);
        // call the model's function to make sure all the outputs are at the current time
        ud.modelFunction(xout, NV_DATA_S(ud.states), NV_DATA_S(rates), NV_DATA_S(ud.outputs), NV_DATA_S(ud.inputs));
        printResults(ud);
    }
    return 0;
}

int f(realtype x, N_Vector y, N_Vector ydot, void *user_data)
{
    UserData* ud = (UserData*)user_data;
    ud->modelFunction(x, NV_DATA_S(y), NV_DATA_S(ydot), NV_DATA_S(ud->outputs), NV_DATA_S(ud->inputs));
    return 0;
}

static int check_flag(void *flagvalue, const char *funcname, int opt)
{
  int *errflag;

  /* Check if SUNDIALS function returned NULL pointer - no memory allocated */
  if (opt == 0 && flagvalue == NULL) {
    fprintf(stderr, ""\nSUNDIALS_ERROR: %s() failed - returned NULL pointer\n\n"",
            funcname);
    return(1); }

  /* Check if flag < 0 */
  else if (opt == 1) {
    errflag = (int *) flagvalue;
    if (*errflag < 0) {
      fprintf(stderr, ""\nSUNDIALS_ERROR: %s() failed with flag = %d\n\n"",
              funcname, *errflag);
      return(1); }}

  /* Check if function returned NULL pointer - no memory allocated */
  else if (opt == 2 && flagvalue == NULL) {
    fprintf(stderr, ""\nMEMORY_ERROR: %s() failed - returned NULL pointer\n\n"",
            funcname);
    return(1); }

  return(0);
}
",nSteps
209,"#include ""messagedialog.h""
#include ""ui_messagedialog.h""

#include <QDialog>
#include <QImage>
#include <QDebug>

MessageDialog::MessageDialog(QString title, QString message, DialogType  [MASK] , QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MessageDialog)
{
    ui->setupUi(this);
    switch( [MASK] )
    {
    case ShowMessage:
        break;

    case Select:
        break;
    }
    Qt::WindowFlags flags = Qt::Dialog;
    flags = flags | Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint | Qt::WindowCloseButtonHint;
    setWindowFlags(flags);

    if(title.isEmpty())
        title = tr(""Default Title"");
    if(message.isEmpty())
        message = tr(""Default Message"");

    setWindowTitle(title);
    ui->label_message->setText(message);

    QImage image("":/dialoglib/icon-default.png"");
    ui->label_image->setMinimumSize(image.size());
    qDebug() << ui->label_image->size();
    adjustSize();
    qDebug() << ui->label_image->size();
}

MessageDialog::~MessageDialog()
{
    delete ui;
}

int MessageDialog::exec()
{
    setAttribute(Qt::WA_ShowModal, true);
    show();
    m_eventloop = new QEventLoop();
    m_eventloop->exec();
    m_eventloop = NULL;
    return m_result;
}

void MessageDialog::on_pushButton_OK_clicked()
{
    m_result = QDialog::Accepted;
    if(m_eventloop)
    {
        m_eventloop->exit();
    }
}

void MessageDialog::on_pushButton_Cancel_clicked()
{
    m_result = QDialog::Rejected;
    if(m_eventloop)
    {
        m_eventloop->exit();
    }
}
",type
210,"/*Author: <NAME>
  File  : main.cpp
  Desc  : Entry point to answer data structs homework questions for current homework.
  Date  : 3/1/23
*/

#include ""tree.cpp""
#include <chrono>

int main()
{

  // timer for calcNumNodes execution time--setNumNodes is the actual method that calculates the number of nodes.
  auto startCalcNumNodesTimer = std::chrono::high_resolution_clock::now();

  // Timer for calcNumLeaves execution time--setNumLeaves is the actual method that calculates the number of leavs.
  auto startCalcNumLeaves = std::chrono::high_resolution_clock::now();

  // Timer for calcNumFull execution time--setNumFull is the actual method that calculates the number of full nodes.
  auto startCalcNumFull = std::chrono::high_resolution_clock::now();

  // create the binary tree.
  IntBinaryTree tree;

  std::cout << ""*********Welcome to my demonstration tree app**********************\n\n"";

  // Insert some values.
  tree.insertNode(4);
  tree.insertNode(2);
  tree.insertNode(3);
  tree.insertNode(1);
  tree.insertNode(9);

  // calculate the number of nodes and leaves in tree.

  tree.calcNumNodes();
  auto endCalcNumNodesTimer = std::chrono::high_resolution_clock::now();
  //--------------------------------------------------------------------------------------------------------

  tree.calcNumLeaves();
  auto endCalcNumLeaves = std::chrono::high_resolution_clock::now();
  //-------------------------------------------------------------------------------------------------------

  tree.calcNumFull();
  auto endCalcNumFull = std::chrono::high_resolution_clock::now();
  //---------------------------------------------------------------------------------------------------------

  // time difference for the calcNumNodes timer
  auto timeDiffCalcNumNodes = std::chrono::duration_cast<std::chrono::microseconds>(endCalcNumNodesTimer - startCalcNumNodesTimer);

  // time difference for the calcNumLeaves timer
  auto timeDiffCalcNumLeaves = std::chrono::duration_cast<std::chrono::microseconds>(endCalcNumLeaves - startCalcNumLeaves);

  // time difference for the calcNumFull
  auto timeDiffCalcNumFull = std::chrono::duration_cast<std::chrono::microseconds>(endCalcNumFull - startCalcNumFull);

  // Display the current values in the tree.
  std::cout << ""\nHere are the values in the tree: \n"";
  tree.displayInOrder();

  std::cout << std::endl;
  std::cout << std::endl;

  // Display the current number of nodes in the tree.
  std::cout << ""Here are the number of nodes in the tree: \n"";

  int tempNodes = tree.getNumNodes();
  std::cout << tempNodes << std::endl;

  // Execution time for calcNumNodes and setNumNodes methods.
  std::cout << ""Execution time:   "" << timeDiffCalcNumNodes.count()
            << ""  microseconds. "" << std::endl;

  // Display the current number of leaves in the tree.
  int tempLeaves = tree.getNumLeaves();

  std::cout << ""Here are the number of leaves in the tree: \n"";
  std::cout << tempLeaves << std::endl;

  // Execution time for calcNumLeaves and setNumLeaves methods.
  std::cout << ""Execution time:   "" << timeDiffCalcNumLeaves.count()
            << ""  microseconds."" << std::endl;

  // Display the current number of full nodes in the tree.
  int  [MASK]  = tree.getNumFull();

  std::cout << ""Here are the number of full nodes in the tree: \n"";
  std::cout <<  [MASK]  << std::endl;

  // Execution time for calcNumFull and setNumFull methods.
  std::cout << ""Execution time:   "" << timeDiffCalcNumFull.count()
            << ""  microseconds."" << std::endl;

  //--------------------End of Question 1 implementation.-------------------

  //-------------------Beginning of Question 2 implementation---------------
  std::cout << std::endl
            << std::endl;

  std::cout << ""Beginning of Q2 Implementation********************\n\n"";

  std::cout << ""Test for search order property of tree\n\n"";

  // test for search order property of tree
  tree.isSearchOrderPropertySatisfied();

  // Get the result from the test
  if (tree.getSearchProp() == true)
  {
    std::cout << ""Search order property is satisfied\n\n"";
  }
  else
  {
    std::cout << ""Search order property is not satisfied\n\n"";
  }

  //--------------------End of Question 2 implementation-----------------------

  //--------------------Beginning of Question 3 implementation---------------
  std::cout << ""Beginning of Q3 Implementation******************************\n\n"";
  std::cout << ""Here's the implementation of level wise order printing\n\n"";
  tree.displayLevelOrder();
  //-------------------------------------------------------------------------
}",tempFullNodes
211,"#pragma once

#include <rclcpp/rclcpp.hpp>
#include <geometry_msgs/msg/twist.hpp>
#include ""tf2/LinearMath/Quaternion.h""
#include ""tf2_ros/transform_broadcaster.h""
#include ""tf2_ros/buffer.h""
#include ""tf2_ros/transform_listener.h""
#include ""ros2_aruco_interfaces/msg/aruco_markers.hpp""
#include ""nav_msgs/msg/odometry.hpp""
#include <vector>
#include ""mage_msgs/msg/advanced_logical_camera_image.hpp""
#include ""mage_msgs/msg/part.hpp""

class MazeSolver : public rclcpp::Node{

public:
    MazeSolver(std::string maze_solver): Node(maze_solver){
        // aruco marker id
        this->declare_parameter<std::string>(""aruco_marker_0"");
        this->declare_parameter<std::string>(""aruco_marker_1"");
        this->declare_parameter<std::string>(""aruco_marker_2"");
        m_aruco_marker_0 = this->get_parameter(""aruco_marker_0"").as_string();
        m_aruco_marker_1 = this->get_parameter(""aruco_marker_1"").as_string();
        m_aruco_marker_2 = this->get_parameter(""aruco_marker_2"").as_string();

        // map to determine the color and part from the Part.msg file
        color_map[mage_msgs::msg::Part::RED] = ""Red"";
        color_map[mage_msgs::msg::Part::GREEN] = ""Green"";
        color_map[mage_msgs::msg::Part::BLUE] = ""Blue"";
        color_map[mage_msgs::msg::Part::ORANGE] = ""Orange"";
        color_map[mage_msgs::msg::Part::PURPLE] = ""Purple"";
        part_map[mage_msgs::msg::Part::BATTERY] = ""battery"";
        part_map[mage_msgs::msg::Part::PUMP] = ""pump"";
        part_map[mage_msgs::msg::Part::SENSOR] = ""sensor"";
        part_map[mage_msgs::msg::Part::REGULATOR] = ""regulator"";

        m_msg = geometry_msgs::msg::Twist();
        
        // MultiThreading
        m_callback_group_odom = this->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);
        auto  [MASK]  = rclcpp::SubscriptionOptions();
         [MASK] .callback_group = m_callback_group_odom;

        m_callback_group_aruco = this->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);
        auto subscription_aruco = rclcpp::SubscriptionOptions();
        subscription_aruco.callback_group = m_callback_group_aruco;

        // m_callback_group_logical_camera = this->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);
        // auto subscription_logical_camera = rclcpp::SubscriptionOptions();
        // subscription_logical_camera.callback_group = m_callback_group_logical_camera;

        // timer
        m_timer = this->create_wall_timer(std::chrono::milliseconds((int)(500)), std::bind(&MazeSolver::timer_callback, this));
        m_timer_listener = this->create_wall_timer(std::chrono::milliseconds((int)(500)), std::bind(&MazeSolver::listener_callback, this));
        // m_timer_listener2 = this->create_wall_timer(std::chrono::milliseconds((int)(500)), std::bind(&MazeSolver::listener2_callback, this));

        // publisher
        m_publisher = this->create_publisher<geometry_msgs::msg::Twist>(""cmd_vel"", 10);

        // Subscriber
        aruco_subscriber = this->create_subscription<ros2_aruco_interfaces::msg::ArucoMarkers>(""aruco_markers"", 10, std::bind(&MazeSolver::aruco_callback, this, std::placeholders::_1), subscription_aruco);
        odom_subscriber = this->create_subscription<nav_msgs::msg::Odometry>(""odom"", 10, std::bind(&MazeSolver::odom_callback, this, std::placeholders::_1),  [MASK] );
        logical_camera_subscriber = this->create_subscription<mage_msgs::msg::AdvancedLogicalCameraImage>(""/mage/advanced_logical_camera/image"", rclcpp::SensorDataQoS(), std::bind(&MazeSolver::logical_camera_callback, this, std::placeholders::_1));

        // broadcaster
        tf_broadcaster = std::make_unique<tf2_ros::TransformBroadcaster>(*this);
        // tf_broadcaster2 = std::make_unique<tf2_ros::TransformBroadcaster>(*this);

        // Listener
        tf_buffer = std::make_unique<tf2_ros::Buffer>(this->get_clock());               // aruco marker
        tf_listener = std::make_shared<tf2_ros::TransformListener>(*tf_buffer);

        // tf_buffer2 = std::make_unique<tf2_ros::Buffer>(this->get_clock());               // parts
        // tf_listener2 = std::make_shared<tf2_ros::TransformListener>(*tf_buffer);

    }


    private:
        std::string m_aruco_marker_0;
        std::string m_aruco_marker_1;
        std::string m_aruco_marker_2; 
        double aruco_z_position;     // which marker to choose; Setting a random high value;
        int m_id;                   // Selecting the marker id of the nearest marker
        std::string m_turn;         // direction to turn 

        // Part
        std::map<int, std::string> color_map;
        std::map<int, std::string> part_map;
        std::string part_name_type;
        std::map<std::string, int> color_part_map;
        // std::vector<geometry_msgs::msg::TransformStamped> tf_msgs;
        geometry_msgs::msg::TransformStamped t_aruco;
        // geometry_msgs::msg::TransformStamped t_part;

        int flag{1};

        double target_angle = 0;

        geometry_msgs::msg::Twist m_msg;
        std::vector<int64_t> marker_ids;
        // double odomToAruco;
        // double odomToBasefootprint;
        double arucoToBasefootprint;

        double robot_yaw_angle;
        // double angle = 0;

        // MultiThreading
        rclcpp::CallbackGroup::SharedPtr m_callback_group_odom;
        rclcpp::CallbackGroup::SharedPtr m_callback_group_aruco;
        rclcpp::CallbackGroup::SharedPtr m_callback_group_logical_camera;

        // Subscriber
        rclcpp::Subscription<ros2_aruco_interfaces::msg::ArucoMarkers>::SharedPtr aruco_subscriber;
        rclcpp::Subscription<nav_msgs::msg::Odometry>::SharedPtr odom_subscriber;
        rclcpp::Subscription<mage_msgs::msg::AdvancedLogicalCameraImage>::SharedPtr logical_camera_subscriber;

        // Timer
        rclcpp::TimerBase::SharedPtr m_timer;
        rclcpp::TimerBase::SharedPtr m_timer_listener;      // aruco
        // rclcpp::TimerBase::SharedPtr m_timer_listener2;     // parts

        
        // Publisher
        rclcpp::Publisher<geometry_msgs::msg::Twist>::SharedPtr m_publisher;
        
        // broadcaster
        std::unique_ptr<tf2_ros::TransformBroadcaster> tf_broadcaster;          // broadcasting aruco position
        // std::unique_ptr<tf2_ros::TransformBroadcaster> tf_broadcaster2;         // broadcasting parts position

        // Listener
        std::shared_ptr<tf2_ros::Buffer> tf_buffer;                             // aruco marker
        std::shared_ptr<tf2_ros::TransformListener> tf_listener{nullptr};

        // std::shared_ptr<tf2_ros::Buffer> tf_buffer2;                            // parts
        // std::shared_ptr<tf2_ros::TransformListener> tf_listener2{nullptr};

        void aruco_callback(const ros2_aruco_interfaces::msg::ArucoMarkers::SharedPtr msg);
        void timer_callback();
        void listener_callback();
        // void listener2_callback();
        void odom_callback(const nav_msgs::msg::Odometry::SharedPtr msg);
        void logical_camera_callback(const mage_msgs::msg::AdvancedLogicalCameraImage::SharedPtr msg);
};",subscription_odom
212,"#pragma once

#include <vector>
#include <cstdint>

#include ""myheader.hpp""
#include ""mypointfield.hpp""


class MyPointCloud2
{
public:
  MyHeader header;
  uint32_t height;
  uint32_t width;

  std::vector<MyPointField> fields;

  bool is_bigendian;

  uint32_t point_step;
  uint32_t row_step;

  std::vector<uint8_t> data;

  bool is_dense;

  MyPointCloud2() = default;

  MyPointCloud2(const MyHeader& header_,
              uint32_t height_,
              uint32_t width_,
              const std::vector<MyPointField>& fields_,
              bool is_bigendian_,
              uint32_t  [MASK] ,
              uint32_t row_step_,
              const std::vector<uint8_t>& data_,
              bool is_dense_)
      : header(header_),
        height(height_),
        width(width_),
        fields(fields_),
        is_bigendian(is_bigendian_),
        point_step( [MASK] ),
        row_step(row_step_),
        data(data_),
        is_dense(is_dense_) {}
};

",point_step_
213,"// SPDX-FileCopyrightText: 2006-2025 <NAME> & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 <NAME> & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/quality/aliases.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/debug_stream.hpp>

using seqan3::operator""""_dna4;
using seqan3::operator""""_dna5;
using seqan3::operator""""_phred42;

int main()
{
    // A vector of combined sequence and quality information.
    std::vector<seqan3::dna4q> sequence1{{'A'_dna4, '!'_phred42},
                                         {'C'_dna4, 'A'_phred42},
                                         {'G'_dna4, '6'_phred42},
                                         {'T'_dna4, '&'_phred42}};
    // A vector of dna5.
    std::vector<seqan3::dna5> sequence2{""AGNCGTNNCAN""_dna5};

    // Convert dna4q to dna4.
    // Since `sequence1` is an lvalue, we capture `in` via const &. When unsure, use the general case below.
    auto view1 = sequence1
               | std::views::transform(
                     [](auto const & in)
                     {
                         return static_cast<seqan3::dna4>(in);
                     });
    seqan3::debug_stream << view1 << '\n'; // ACGT

    // Convert dna5 to dna4.
    // General case: Perfect forward.
    auto  [MASK]  = sequence2 | std::views::take(8)
               | std::views::transform(
                     [](auto && in)
                     {
                         return static_cast<seqan3::dna4>(std::forward<decltype(in)>(in));
                     });
    seqan3::debug_stream <<  [MASK]  << '\n'; // AGACGTAA

    return 0;
}
",view2
214,"#include <Servo.h>


// Digital pins.
#define PIN_IR_LEFT 4
#define PIN_IR_CENTER 5
#define PIN_IR_RIGHT 6
#define PIN_HALL_EFFECT_LEFT 7
#define PIN_HALL_EFFECT_RIGHT 8
#define PIN_LASER_POWER 10
#define PIN_MOTOR_LEFT 3
#define PIN_MOTOR_RIGHT 9
// Analog pins.
#define PIN_LASER_READER 0

// Configs.
#define ROTATIONS_COLLECTED 100

// Define State Machine.
enum PathState {
  START,
  CHECKPOINT_ONE,
  CHECKPOINT_TWO,
  BROOM_STICK_BEGIN,
  BROOM_STICK_ABYSS,
  JUMP_EXIT_LANE,
  DO_A_FLIP,
  FIND_THE_LINE,
  RED_LINE_RIDER,
  INVERTED_CUP_STRAIGHT,
  INVERTED_CUP_RIGHT,
  FINISH
};
PathState currentPathState = START;

// Motor Setup ------------------
Servo lMotor; 
Servo rMotor; 

// Debug printer:
// The last time that a Serial.print was made.
uint64_t lastTime = 0;

// Wheel data container.
struct Wheel {
  // Revolution collector:
  // The collection of timestamps of last revolutions.
  uint64_t ticks[ROTATIONS_COLLECTED];
  // The position to insert the next revolution.
  int index = 0;
  // The global revolutions for this motor since reset.
  int tickCount = 0;
  // Motor controller.
  Servo servo;

  void recordTick() {
    tickCount++;
    ticks[index] = millis();
    index = (++index) % ROTATIONS_COLLECTED;
  }

  int countTicks(uint64_t now, uint64_t window) {
    int count = 0;

    // Circuluar access to last node.
    int i = index - 1;
    if (i < 0) i += ROTATIONS_COLLECTED;

    uint64_t min_time = now - window;
    if (min_time < 0)
      return 0;

    while (true) {
      if (ticks[i] >= min_time) {
        count++;
        if (count > ROTATIONS_COLLECTED) {
          // FUCK!
          break;
        }

        i--;
        if (i < 0) i += ROTATIONS_COLLECTED;
      } else {
        // Expected.
        break;
      }
    }
    return count;
  }
};

void initWheel(Wheel wheel, int  [MASK] , int pin_hall_effect) {
  // Setup Struct.
  wheel.index = 0;
  wheel.tickCount = 0;
  for (int i = 0; i < sizeof(wheel.ticks); i++) wheel.ticks[i] = -1;

  // Attach servo monitor.
  wheel.servo.attach( [MASK] );
}
Wheel left;
Wheel right;

void recieveHallEffectLeft() {
  left.recordTick();
}

void recieveHallEffectRight() {
  right.recordTick();
}

void setup() {
  // Set up wheel servos.
  initWheel(left, PIN_MOTOR_LEFT, PIN_HALL_EFFECT_LEFT);
  initWheel(right, PIN_MOTOR_RIGHT, PIN_HALL_EFFECT_RIGHT);

  // Set up IR sensors.
  pinMode(PIN_IR_LEFT, INPUT);
  pinMode(PIN_IR_CENTER, INPUT);
  pinMode(PIN_IR_RIGHT, INPUT);

  // Set up the Hall Effect Sensors.
  pinMode(PIN_HALL_EFFECT_LEFT, INPUT);
  pinMode(PIN_HALL_EFFECT_RIGHT, INPUT);
  // Attach hall effect sensor.
  attachInterrupt(digitalPinToInterrupt(PIN_HALL_EFFECT_LEFT), recieveHallEffectLeft, FALLING);
  attachInterrupt(digitalPinToInterrupt(PIN_HALL_EFFECT_RIGHT), recieveHallEffectRight, FALLING);

  Serial.begin(9600);
  Serial.println(""Let's go!"");
}

// AI told me this is how I print a uint64.
void printUint64(uint64_t value) {
  uint32_t high = value >> 32;
  uint32_t low = value & 0xFFFFFFFF;
  Serial.print(high, HEX);
  Serial.print(low, HEX);
}

void printDebugUpdate(uint64_t now) {
    Serial.print(""[1s @"");
    printUint64(now);
    Serial.print(""] left ticks: "");
    //Serial.println(left.tickCount);
    Serial.print(left.countTicks(now, 1000));
    Serial.print("" right ticks: "");
    Serial.println(right.countTicks(now, 1000));
}

void executeDefaultLineRider() {
  // TODO: do something!
}

void executeStateMachine() {
  switch (currentPathState) {
    default:
    executeDefaultLineRider();
    break;
  }
}

void loop() {
  executeStateMachine();

  // Only give a status update every second.
  uint64_t now = millis();
  if ((now - lastTime) >= 1000) {
    printDebugUpdate(now);
    lastTime = now;
  }
}
",pin_servo
215,"#include ""TestUtils.h""
#include <string.h>
#include <fstream>

namespace pcpp_tests
{

int getFileLength(const char* filename)
{
	std::ifstream infile(filename, std::ifstream::binary);
	if (!infile)
		return -1;
	infile.seekg(0, infile.end);
	int length = infile.tellg();
	infile.close();
	return length;
}

uint8_t* readFileIntoBuffer(const char* filename, int& bufferLength)
{
	int fileLength = getFileLength(filename);
	if (fileLength == -1)
		return NULL;

	std::ifstream infile(filename);
	if (!infile)
		return NULL;

	bufferLength = fileLength/2 + 2;
	uint8_t* result = new uint8_t[bufferLength];
	int i = 0;
	while (!infile.eof())
	{
		char byte[3];
		memset(byte, 0, 3);
		infile.read(byte, 2);
		result[i] = (uint8_t)strtol(byte, NULL, 16);
		i++;
	}
	infile.close();
	bufferLength -= 2;
	return result;
}

void printBufferDifferences(const uint8_t* buffer1, size_t buffer1Len, const uint8_t* buffer2, size_t  [MASK] )
{
	printf(""\n\n\n"");
	for(int i = 0; i<(int)buffer1Len; i++)
		printf("" 0x%2X  "", buffer1[i]);
	printf(""\n\n\n"");
	for(int i = 0; i<(int) [MASK] ; i++)
	{
		if (buffer2[i] != buffer1[i])
			printf(""*0x%2X* "", buffer2[i]);
		else
			printf("" 0x%2X  "", buffer2[i]);
	}
	printf(""\n\n\n"");
}

#ifdef PCPP_TESTS_DEBUG
#include <pcap.h>

void savePacketToPcap(Packet& packet, std::string fileName)
{
   pcap_t* pcap;
   pcap = pcap_open_dead(1, 65565);

   pcap_dumper_t* d;
   /* open output file */
   d = pcap_dump_open(pcap, fileName.c_str());
   if (d == NULL)
   {
       pcap_perror(pcap, ""pcap_dump_fopen"");
       return;
   }

   /* prepare for writing */
   struct pcap_pkthdr hdr;
   hdr.ts.tv_sec = 0;  /* sec */
   hdr.ts.tv_usec = 0; /* ms */
   hdr.caplen = hdr.len = packet.getRawPacket()->getRawDataLen();
   /* write single IP packet */
   pcap_dump((u_char*)d, &hdr, packet.getRawPacketReadOnly()->getRawData());

   /* finish up */
   pcap_dump_close(d);
   return;
}
#endif

}",buffer2Len
216,"#ifndef _STATE_MACHINE_HPP_
#define _STATE_MACHINE_HPP_

#include <memory>
#include <functional>
#include <thread>
#include <map>
#include <exception>
#include <sstream>

class Alphabet
{
    public:
    explicit Alphabet(int k, std::shared_ptr<void> v = nullptr)
        : key(k), value(v)
    {}
    virtual ~Alphabet() {}

    int key;
    std::shared_ptr<void> value;
};

class State
{
    public:
    explicit State(int key, std::function<std::shared_ptr<Alphabet>(std::shared_ptr<Alphabet>)> exec)
        : key_(key), execute_(exec)
    {
        transitions_.clear();
    }

    virtual ~State() {}

    int get_key()
    {
        return key_;
    }

    void add_transition(int alphabet, int state)
    {
        transitions_[alphabet] = state;
    }

    int get_transition_state(int alphabet)
    {
        if(transitions_.find(alphabet) == transitions_.end())
        {
            std::ostringstream error;
            error << ""transition "" << alphabet << "" is undefine in state "" << key_ << ""."";
            throw std::range_error(error.str());
        }            
        return transitions_[alphabet];
    }

    std::shared_ptr<Alphabet> execute(std::shared_ptr<Alphabet> alphabet)
    {
        if(execute_ != nullptr)
            return execute_(alphabet);
        else
            return nullptr;
    }

    protected:    
    int key_;

    private:
    std::map<int, int> transitions_;
    std::function<std::shared_ptr<Alphabet>(std::shared_ptr<Alphabet>)> execute_;

    State(const State& ) {}
    State& operator=(const State& )
    {
        return *this;
    }
};

class StateMachine
{
    public:
    StateMachine()
        : current_(nullptr) 
    {
        states_.clear();
    }
    ~StateMachine() {}

    void add_state(std::shared_ptr<State> state)
    {
        states_[state->get_key()] = state;
    }

    void add_state_transition(int key, int alphabet, int state)
    {
        get_next_state(key)->add_transition(alphabet, state);
    }

    void start(int state)
    {
        current_ = get_next_state(state);
        std::thread  [MASK] (&StateMachine::process, this);
         [MASK] .detach();
    }     

    void stop()
    {
        current_ = nullptr;   
    }

    int get_current_state()
    {
        return current_->get_key();
    }

    private:
    std::shared_ptr<State> current_;
    std::map<int, std::shared_ptr<State>> states_;

    void process()
    {
        std::shared_ptr<Alphabet> alphabet = nullptr;
        while(current_ != nullptr)
        {
            alphabet = current_->execute(alphabet);
            if(alphabet == nullptr)
                break;
            current_ = get_next_state(current_->get_transition_state(alphabet->key));      
        }
    }

    std::shared_ptr<State> get_next_state(int key)
    {
        if(states_.find(key) == states_.end())
        {
            std::ostringstream error;
            error << ""state "" << key << "" is undefine in state machine."";
            throw std::range_error(error.str());
        }
        return states_[key]; 
    }  

    StateMachine(const StateMachine& ) {}
    StateMachine& operator=(const StateMachine& )
    {
        return *this;
    }
};

#endif",process_thread
217,"/*
 * Copyright (c) 2014, <NAME>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#include <iostream>

#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>

#include <ui/Action.h>
#include <ui/Area.h>
#include <ui/VideoConfigWidget.h>

#include ""common/WidgetRenderer.h""

int main() {
  const std::string  [MASK]  = ""libsuit: test of the video configuration widget"";

  sf::RenderWindow window(sf::VideoMode(800, 600),  [MASK] );
  WidgetRenderer renderer(window);

  ui::Area area({ 200.0f, 100.0f, 400.0f, 200.0f });
  area.addChild(new ui::VideoConfigWidget(window,  [MASK] ));

  area.updateLayout();

  ui::StandardActionSet actions;

  auto escapeAction = std::make_shared<ui::Action>(""Escape"");
  escapeAction->addKeyControl(sf::Keyboard::Escape);
  escapeAction->addCloseControl();
  actions.addAction(escapeAction);

  while (window.isOpen()) {

    sf::Event event;
    while (window.pollEvent(event)) {
      actions.update(event);

      if (event.type == sf::Event::MouseButtonPressed) {
        area.onClick(event.mouseButton.button, { static_cast<float>(event.mouseButton.x), static_cast<float>(event.mouseButton.y) });
      }
    }

    if (escapeAction->isActive()) {
      window.close();
    }

    actions.handleArea(area);

    window.clear(sf::Color::White);
    renderer.draw(area, false);
    window.display();

    actions.reset();
  }

  return 0;
}
",title
218,"#include ""instructionSet.h""

//NOTE: to link program files each file can consist of a class, each class can be called by its various functions through object creation (when START message is fetched) each class is capable of sending messages into main loop through their own messaging procedures
//These messages can then be handled through the main loop, when a message is passed it will call its relevant function /  functions from its source file to execute the required procedure.

//Basic messages for all classes :
/*
   PULL MESSAGE (PULLS first priority message from a given source files que, sends it into mainMessage loop to be executed) (This should be done for every file (in priority order) at the end of a message FDE cycle)
	   relevant function:
						 queMessage(MSG) internal messaging procedure for source file, ques parameter message into relavent que, ready to be fetched by the main messaging cycle.

   INITIALIZEOBJ (Initialises object for all source file instances, pulling them into scope within the main file procedures.

   */
int main()
{

	tree  [MASK] ;
	temporalLobe::node* root =  [MASK] .initialiseMemory(0);

	 [MASK] .sendMessage( [MASK] .START, 10);
	 [MASK] .sendMessage( [MASK] .TEST, 4);
	 [MASK] .sendMessage( [MASK] .START, 3);
	 [MASK] .sendMessage( [MASK] .TEST, 6);

	std::cout << ""Binary Tree Populated\n"" << ""-----------------------------------\n"";

	while (true) //LOOP
	{

		bool flag = false;
		int num{};
		 [MASK] .sendMessage( [MASK] .fetchPost(),  [MASK] ); //CHECK MESSAGE QUE PRIORITY, TAKE PRIORITY MESSAGE

		while (flag == false) // loop implemented to pause system at runtime as to see console outputs of main message loop.
		{
			while (std::cout << ""|please enter 1 to continue|\n"" && !(std::cin >> num))
			{
				std::cin.clear();
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				std::cout << "" |Incorrect data input| \n"";
			}
			if (num == 1)
			{
				flag = true;
			}
		}


		/*

		LOOP

	CATCH MESSAGE _/

	PASS TO MESSAGE QUE _/

	CHECK MESSAGE QUE PRIORITY _/

	TAKE PRIORITY MESSAGE _/

	DO FUNC FROM MESSAGE _/

	RECIEVE MESSAGE FROM FUNC

	RECIEVE MESSAGE FROM PARIETAL

	DO BACKGROUND FUNC FROM SECOND MESSAGE SET (IF IN HIBERNATION, OR A SET AMOUNT OF TIME HAS PASSED)

	SET MESSAGE PRIORITIES (IF REACTORY FUNCTIONS RETURN THAT A FUNCTION NEEDS COMPLETING IMMEDIATELY)

		LOOP

		*/

		//POSSIBLE TO HAVE MULTIPLE PRIORITY QUES CALLED IN PRIORITY ORDER, MIMICKING BACKGROUND FUNCTIONS OF BRAIN
		//POSSIBLE MESSAGE LOOP FOR EACH SECTION OF THE BRAIN IF REQUIRED, may be out of limitations however.
	}
















	return 0;
}

//need to set enum message before passing into function


//In not to creating ralph I have defined a set structure in which each part of Ralphs brain will form. In which each part will originate from a root node, as seen in the temporal lobe program, data processed by each respective part of the brain will store data in its respective root sector; howeveer, these sectors will not be independant, but instead will be connected through relations in the data processed (aka each sector will be connected by weight) these weights will act as direct connections in how ralphs brain communicates, for instance connecting the logical solution of what and a previously processed solution of kangaroo to the kangaroo data node, which will be connected to the data cluster of the data of a processed image of a kangaroo. 
// an example of how  this may be used within programmative thinking within ralph is here: ralph takes in data via a question, ""what is a kangaroo"", he checks his processing centre to see if the answer or data regarding this answer is stored within its respective cluster, pulling nodes related to this and displaying the data in the desired language and format, he simultaneously looks for this data within other clusters, if one is found in a cluster it checks to see if a connection exists to a different cluster , if it does it follows it and pulls its respective data. If it is found that related data is not connected to each cluster then new connections will be formed, this may be as abstract as connecting the picture of a kangaroo to the data point within long term memory of the sahara or sarengheti in response to a positive response or ""dopamine"" being released on the correct answer of ""what is a sarengheti animal"" and kangaroo being the response
//this will give ralph the ability to cross referance between different sections and pieces of his brain to form ideas, connections and referances to different matters as to answer matters more efficiently, as we are all learning machines after all.

// process diagram

//data input --> processing centre / find answer / try answer / store solution if correct --> if not pull data from seperate cluster and try and format answer from current data, according to the data provided / if simallar answer exists to current question, format in a simalar way --> check how output is reecieved, if good add respective connections, store solution in processing cluster (next to / in relation to similar answer if used) / connect data points in different cluster e.g what is a kangaroo to kangaroo imagery cluster, kangaroo long term memory data point, sahara data point etc

//ToDO
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//possibly modify translation function within temporalLobe as to cater for all sections of ralph, currently programmed to translate long term memory structure only, however could be coded logically as to read all structures if they use the same basic structure (nodes) for the tree.
//
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------",mainLoop
219,"#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ModbusMaster.h>

ModbusMaster node;

#define SLAVE_ID 2

#define VOLTAGE_ADDR 0x0000
#define VOLTAGE_LEN 2
#define CURRENT_ADDR 0x0E
#define CURRENT_LEN 2
#define POWER_ADDR 0x14
#define POWER_LEN 2
#define KILOWATTS_HOUR_ADDR 0x112
#define KILOWATTS_HOUR_LEN 2

#define VOLTAGE_WEIGHT 0.1
#define CURRENT_WEIGHT 0.001
#define POWER_WEIGHT 0.1
#define KILOWATTS_HOUR_WEIGHT 0.1

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup()
{
  Serial1.begin(9600);
  Serial.begin(9600);

  node.begin(SLAVE_ID, Serial1);

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
  {
    Serial.println(F(""SSD1306 allocation failed""));
    for (;;)
      ;
  }

  delay(2000);
  display.clearDisplay();
  display.display();
}

void loop()
{
  uint8_t result;
  float voltage, current, power,  [MASK] ;

  result = node.readHoldingRegisters(VOLTAGE_ADDR, VOLTAGE_LEN);
  voltage = (float)node.getResponseBuffer(0) + ((float)node.getResponseBuffer(1) / 100.0);
  voltage = voltage * VOLTAGE_WEIGHT;

  delay(500);
  result = node.readHoldingRegisters(CURRENT_ADDR, CURRENT_LEN);
  current = (float)node.getResponseBuffer(0) + ((float)node.getResponseBuffer(1) / 100.0);
  current = current * CURRENT_WEIGHT;

  delay(500);
  result = node.readHoldingRegisters(POWER_ADDR, POWER_LEN);
  power = (float)node.getResponseBuffer(0) + ((float)node.getResponseBuffer(1) / 100.0);
  power = power * POWER_WEIGHT;

  delay(500);
  result = node.readHoldingRegisters(KILOWATTS_HOUR_ADDR, KILOWATTS_HOUR_LEN);
   [MASK]  = (float)node.getResponseBuffer(0) + ((float)node.getResponseBuffer(1) / 100.0);
   [MASK]  =  [MASK]  * KILOWATTS_HOUR_WEIGHT;

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print(""Voltage: "");
  display.println(voltage);
  display.print(""Current: "");
  display.println(current);
  display.print(""Power: "");
  display.println(power);
  display.print(""KWh: "");
  display.println( [MASK] );
  display.display();

  delay(10000);
}
",kilowatts_hour
220,"#include ""videoControls.h""
#include ""vsliderwidget.h""

const char* Property_Rate = ""RateValue"";

VideoControls::VideoControls(QWidget *parent)
	:QWidget(parent)
{
	ui.setupUi(this);
	setWindowFlags(Qt::FramelessWindowHint/* | Qt::Tool*/);
	setAttribute(Qt::WA_TranslucentBackground);

	initVolumeSlider();

	//播放/暂停
	connect(ui.pushButton_play, &QPushButton::clicked, this, &VideoControls::sltVideoPlayOrPause);
	//声音
	connect(ui.pushButton_volum, &QPushButton::clicked, this, &VideoControls::sltVolumControls);
	//进度
	connect(ui.slider_progress, &CustomSlider::costomSliderClicked, this, &VideoControls::sltSliderProgressClicked);
	connect(ui.slider_progress, &CustomSlider::sliderReleased, this, &VideoControls::sltSliderProgressReleased);
	//倍速
	ui.pushButton_rate->setProperty(Property_Rate, 1.0);
	connect(ui.pushButton_rate, &QPushButton::clicked, this, &VideoControls::sltSetVideoRate);
}

VideoControls::~VideoControls()
{
}

void VideoControls::setProgressDuration(qint64  [MASK] )
{
	ui.slider_progress->setMaximum( [MASK] );
}

bool VideoControls::isSliderDown()
{
	return ui.slider_progress->isSliderDown();
}

void VideoControls::setSliderPosition(int position)
{
	ui.slider_progress->setSliderPosition(position);
}

void VideoControls::setProgressText(const QString & text)
{
	ui.label_volumNum->setText(text);
}

void VideoControls::setPlaying(bool state)
{
	//启用播放/暂停按钮，并将其文本设置为“暂停”
	ui.pushButton_play->setChecked(state);
}

void VideoControls::setVoiceValue(int value)
{
	m_volumeSlider->setVoiceValue(value);
}

bool VideoControls::getVolumVisible()
{
	if (m_volumeSlider) {
		return m_volumeSlider->isVisible();
	}
	return false;
}

void VideoControls::initVolumeSlider()
{
	m_volumeSlider = QSharedPointer<VSliderWidget>(new VSliderWidget(this));
	if (m_volumeSlider) {
		m_volumeSlider->installEventFilter(this);
		m_volumeSlider->setWindowFlags(Qt::FramelessWindowHint | Qt::Tool);
		connect(m_volumeSlider.data(), &VSliderWidget::sigValueChanged, this, &VideoControls::sltSoundVoiceValue);
	}
}

void VideoControls::locateWidgets()
{
	if (m_volumeSlider) {
		int posX = ui.pushButton_volum->x() + 6;
		int posY = -m_volumeSlider->height();
		m_volumeSlider->move(mapToGlobal(QPoint(posX, posY)));
	}
}

void VideoControls::closeWidget()
{
	if (m_volumeSlider) {
		m_volumeSlider->close();
	}
}

void VideoControls::sltSliderProgressClicked()
{
	auto value = ui.slider_progress->value();
	emit sigSetPosition(value);
}

void VideoControls::sltSliderProgressReleased()
{
	auto value = ui.slider_progress->value();
	emit sigSetPosition(value);
}

void VideoControls::sltSoundVoiceValue(int value)
{
	if (0 == value) {
		ui.pushButton_volum->setStyleSheet(""border-image: url(:/qrc/qrc/yyf_ico_yl_gb.png);"");
	}
	else {
		ui.pushButton_volum->setStyleSheet(""border-image: url(:/qrc/qrc/yyf_ico_yl.png);"");
	}
	emit sigSoundVoiceValue(value);
}

void VideoControls::sltVolumControls()
{
	if (m_volumeSlider) {
		locateWidgets();
		auto isVisible = m_volumeSlider->isVisible();
		m_volumeSlider->setVisible(!isVisible);
	}
}

void VideoControls::sltSetVideoRate()
{
	auto rate = ui.pushButton_rate->property(Property_Rate).toFloat();
	if (1.0 == rate) {
		rate = 1.5;
	}
	else if (1.5 == rate) {
		rate = 2.0;
	}
	else if (2.0 == rate) {
		rate = 3.0;
	}
	else if (3.0 == rate) {
		rate = 0.5;
	}
	else if (0.5 == rate) {
		rate = 1.0;
	}
	ui.pushButton_rate->setProperty(Property_Rate, rate);
	ui.pushButton_rate->setText(QString(""x%1"").arg(rate));
	emit sigSetRate(rate);
}

void VideoControls::sltVideoPlayOrPause()
{
	auto isPlay = ui.pushButton_play->isChecked();
	emit sigVideoPlayOrPause(isPlay);
}
",duration
221,"// main.cpp
// This is the main game builder file which reads in two hands from
// text files and plays the game
// <NAME> - 6872774

#include <iostream>
#include <fstream>
#include <string>

#include ""cards.h""
#include ""utility.h""

using namespace std;

void AliceTurn(PlayerHand& alice, PlayerHand& bob);
void BobTurn(PlayerHand& alice, PlayerHand& bob);

void AliceTurn(PlayerHand& alice, PlayerHand& bob){
    Card curCard = alice.getLowestCard();
    while(true){
        if (curCard.getValue() == 0) return;
        if(bob.contains(curCard)){
            //bob also has this card
            cout<<""Alice picked matching card "";
            curCard.printCardShort();
            bob.deleteCard(curCard);
            alice.deleteCard(curCard);
            BobTurn(alice, bob);
        }
        else {
            //bob doesn't have the card
            curCard = alice.getSuccessor(curCard);
        }
    }
}

void BobTurn(PlayerHand& alice, PlayerHand& bob){
    Card curCard = bob.getHighestCard();
    while(true){
        if(curCard.getValue() == 0) return;
        if(alice.contains(curCard)){
            //alice also has this card
            cout<<""Bob picked matching card "";
            curCard.printCardShort();
            alice.deleteCard(curCard);
            bob.deleteCard(curCard);
            AliceTurn(alice, bob);
        }
        else {
            //alice doesn't have the card
            curCard = bob.getPredecessor(curCard);
        }
    }
}

int main(int argv, char** argc){
    if(argv < 3){
        cout << ""Please provide 2 file names"" << endl;
        return 1;
    }

    ifstream cardFile1 (argc[1]);
    ifstream cardFile2 (argc[2]);
    string line;


    if (cardFile1.fail() || cardFile2.fail() ){
        cout << ""Could not open file "" << argc[2];
        return 1;
    }

    char  [MASK]  = ' ';

    PlayerHand alice;
    PlayerHand bob;

    //Read each file
    while (getline (cardFile1, line) && (line.length() > 0)){
        char suit = line.at(0);
        string face = line.substr(line.find( [MASK] )+1,-1);

        alice.insert(Card(suit, face));
    }
    cardFile1.close();


    while (getline (cardFile2, line) && (line.length() > 0)){
        char suit = line.at(0);
        string face = line.substr(line.find( [MASK] )+1,-1);

        bob.insert(Card(suit, face));
    }
    cardFile2.close();


    // Begin Alice's Turn
    AliceTurn(alice, bob);

    cout<<endl;
    cout<<""Alice's cards:""<<endl;
    alice.printInOrder();
    cout<<endl;

    cout<<""Bob's cards:""<<endl;
    bob.printInOrder();

    return 0;
}
",delim
222,"//   Copyright (c) 2021 PaddlePaddle 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.

// The code is based on:
// https://github.com/CnybTseng/JDE/blob/master/platforms/common/trajectory.h
// Ths copyright of CnybTseng/JDE is as follows:
// MIT License

#pragma once

#include <vector>
#include <opencv2/opencv.hpp>

namespace PaddleDetection {

typedef enum
{
    New = 0,
    Tracked = 1,
    Lost = 2,
    Removed = 3
} TrajectoryState;

class Trajectory;
typedef std::vector<Trajectory> TrajectoryPool;
typedef std::vector<Trajectory>::iterator TrajectoryPoolIterator;
typedef std::vector<Trajectory *>TrajectoryPtrPool;
typedef std::vector<Trajectory *>::iterator TrajectoryPtrPoolIterator;

class TKalmanFilter : public cv::KalmanFilter
{
public:
    TKalmanFilter(void);
    virtual ~TKalmanFilter(void) {}
    virtual void init(const cv::Mat &measurement);
    virtual const cv::Mat &predict();
    virtual const cv::Mat &correct(const cv::Mat &measurement);
    virtual void project(cv::Mat &mean, cv::Mat &covariance) const;
private:
    float std_weight_position;
    float std_weight_velocity;
};

inline TKalmanFilter::TKalmanFilter(void) : cv::KalmanFilter(8, 4)
{
    cv::KalmanFilter::transitionMatrix = cv::Mat::eye(8, 8, CV_32F);
    for (int i = 0; i < 4; ++i)
        cv::KalmanFilter::transitionMatrix.at<float>(i, i + 4) = 1;
    cv::KalmanFilter::measurementMatrix = cv::Mat::eye(4, 8, CV_32F);
    std_weight_position = 1/20.f;
    std_weight_velocity = 1/160.f;
}

class Trajectory : public TKalmanFilter
{
public:
    Trajectory();
    Trajectory(cv::Vec4f &ltrb, float score, const cv::Mat &embedding);
    Trajectory(const Trajectory &other);
    Trajectory &operator=(const Trajectory &rhs);
    virtual ~Trajectory(void) {};

    static int next_id();
    virtual const cv::Mat &predict(void);
    virtual void update(Trajectory &traj, int timestamp, bool update_embedding=true);
    virtual void activate(int timestamp);
    virtual void reactivate(Trajectory &traj, int timestamp, bool newid=false);
    virtual void mark_lost(void);
    virtual void mark_removed(void);

    friend TrajectoryPool operator+(const TrajectoryPool &a, const TrajectoryPool &b);
    friend TrajectoryPool operator+(const TrajectoryPool &a, const TrajectoryPtrPool &b);
    friend TrajectoryPool &operator+=(TrajectoryPool &a, const TrajectoryPtrPool &b);
    friend TrajectoryPool operator-(const TrajectoryPool &a, const TrajectoryPool &b);
    friend TrajectoryPool &operator-=(TrajectoryPool &a, const TrajectoryPool &b);
    friend TrajectoryPtrPool operator+(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
    friend TrajectoryPtrPool operator+(const TrajectoryPtrPool &a, TrajectoryPool &b);
    friend TrajectoryPtrPool operator-(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);

    friend cv::Mat embedding_distance(const TrajectoryPool &a, const TrajectoryPool &b);
    friend cv::Mat embedding_distance(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
    friend cv::Mat embedding_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b);

    friend cv::Mat mahalanobis_distance(const TrajectoryPool &a, const TrajectoryPool &b);
    friend cv::Mat mahalanobis_distance(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
    friend cv::Mat mahalanobis_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b);

    friend cv::Mat iou_distance(const TrajectoryPool &a, const TrajectoryPool &b);
    friend cv::Mat iou_distance(const TrajectoryPtrPool &a, const TrajectoryPtrPool &b);
    friend cv::Mat iou_distance(const TrajectoryPtrPool &a, const TrajectoryPool &b);
private:   
    void update_embedding(const cv::Mat &embedding);
public:
    TrajectoryState state;
    cv::Vec4f ltrb;
    cv::Mat smooth_embedding;
    int id;
    bool is_activated;
    int timestamp;
    int starttime;
    float score;
private:
    static int count;
    cv::Vec4f xyah;
    cv::Mat current_embedding;
    float eta;
    int length;
};

inline cv::Vec4f ltrb2xyah(cv::Vec4f &ltrb)
{
    cv::Vec4f xyah;
    xyah[0] = (ltrb[0] + ltrb[2]) * 0.5f;
    xyah[1] = (ltrb[1] + ltrb[3]) * 0.5f;
    xyah[3] =  ltrb[3] - ltrb[1];
    xyah[2] = (ltrb[2] - ltrb[0]) / xyah[3];
    return xyah;
}

inline Trajectory::Trajectory() :
    state(New), ltrb(cv::Vec4f()), smooth_embedding(cv::Mat()), id(0),
    is_activated(false), timestamp(0), starttime(0), score(0), eta(0.9), length(0)
{
}

inline Trajectory::Trajectory(cv::Vec4f &ltrb_, float  [MASK] , const cv::Mat &embedding) :
    state(New), ltrb(ltrb_), smooth_embedding(cv::Mat()), id(0),
    is_activated(false), timestamp(0), starttime(0), score( [MASK] ), eta(0.9), length(0)
{
    xyah = ltrb2xyah(ltrb);
    update_embedding(embedding);
}

inline Trajectory::Trajectory(const Trajectory &other):
    state(other.state), ltrb(other.ltrb), id(other.id), is_activated(other.is_activated),
    timestamp(other.timestamp), starttime(other.starttime), xyah(other.xyah),
    score(other.score), eta(other.eta), length(other.length)
{    
    other.smooth_embedding.copyTo(smooth_embedding);
    other.current_embedding.copyTo(current_embedding);
    // copy state in KalmanFilter
    
    other.statePre.copyTo(cv::KalmanFilter::statePre);
    other.statePost.copyTo(cv::KalmanFilter::statePost);
    other.errorCovPre.copyTo(cv::KalmanFilter::errorCovPre);
    other.errorCovPost.copyTo(cv::KalmanFilter::errorCovPost);
    
}

inline Trajectory &Trajectory::operator=(const Trajectory &rhs)
{
    this->state = rhs.state;
    this->ltrb = rhs.ltrb;
    rhs.smooth_embedding.copyTo(this->smooth_embedding);
    this->id = rhs.id;
    this->is_activated = rhs.is_activated;
    this->timestamp = rhs.timestamp;
    this->starttime = rhs.starttime; 
    this->xyah = rhs.xyah;
    this->score = rhs.score;
    rhs.current_embedding.copyTo(this->current_embedding);            
    this->eta = rhs.eta;    
    this->length = rhs.length;

    // copy state in KalmanFilter
    
    rhs.statePre.copyTo(cv::KalmanFilter::statePre);
    rhs.statePost.copyTo(cv::KalmanFilter::statePost);
    rhs.errorCovPre.copyTo(cv::KalmanFilter::errorCovPre);
    rhs.errorCovPost.copyTo(cv::KalmanFilter::errorCovPost);
    
    return *this;
}

inline int Trajectory::next_id()
{
    ++count;
    return count;
}

inline void Trajectory::mark_lost(void)
{
    state = Lost;
}

inline void Trajectory::mark_removed(void)
{
    state = Removed;
}

}   // namespace PaddleDetection 
",score_
223,"#include <Wire.h>
#include <stdint.h>
#include <Smartcar.h>

Car car;
const int motorSpeed = 80; //80% of the max speed
const uint8_t distanceThreshold = 25;

const uint8_t SONIC_DISC_I2C_ADDRESS = 0x09;
const uint8_t NUM_OF_SENSORS = 8; // No. of ultrasonic sensors on SonicDisc
// The packet contains NUM_OF_MEASUREMENTS measurements and an error code
const uint8_t I2C_PACKET_SIZE = NUM_OF_SENSORS + 1;
// The number of measurements from each sensor to filter
const uint8_t MEASUREMENTS_TO_FILTER = 5;
const uint8_t INT_PIN = 2;
// The max valid variance in a set of MEASUREMENTS_TO_FILTER measurements
const unsigned int VARIANCE_THRESHOLD = 3;

// Sonic Disc's operational states
enum State {
  STANDBY, // MCU and sensors are on but no measurements are being made
  MEASURING // Sonic Disc is conducting measurements using the sensors
};

// Values to be received via I2C from master
enum I2C_RECEIPT_CODE {
  STATE_TO_STANDBY = 0x0A,
  STATE_TO_MEASURING = 0x0B
};

// Error codes to be transmitted via I2c to the master
enum I2C_ERROR_CODE {
  NO_ERROR,
  IN_STANDBY,
  INCOMPLETE_MEASUREMENT
};

// Flag to indicate the SonicDisc is ready to send a new set of data
volatile bool newData = false;

uint8_t filterIndex = 0;
uint8_t filterBuffer[MEASUREMENTS_TO_FILTER][NUM_OF_SENSORS] = {0};
uint8_t filteredMeasurements[NUM_OF_SENSORS] = {0};
bool newFilteredMeasurements = false;

/**
   Requests an I2C packet from the SonicDisc
   @param  i2cInput         The array that will hold the incoming packet
   @param  transmissionSize The size/length of the incoming packet
   @return                  Error code contained inside the incoming packet
*/
I2C_ERROR_CODE requestPacket(uint8_t i2cInput[], const uint8_t transmissionSize = I2C_PACKET_SIZE) {
  Wire.requestFrom(SONIC_DISC_I2C_ADDRESS, transmissionSize);
  uint8_t packetIndex = 0;
  while (Wire.available() && packetIndex < transmissionSize) {
    i2cInput[packetIndex++] = Wire.read();
  }
  return i2cInput[0]; // Return the packet's error code
}

/**
   Sends the supplied byte to the SonicDisc
   @param byteToSend The byte to be sent
*/
void sendData(uint8_t byteToSend) {
  Wire.beginTransmission(SONIC_DISC_I2C_ADDRESS);
  Wire.write(byteToSend);
  Wire.endTransmission(SONIC_DISC_I2C_ADDRESS);
}

/**
   ISR that raises a flag whenever SonicDisc is ready to transmit new data.
*/
void newSonicDiscData() {
  newData = true;
}

/*
   Adds the specified i2c packet in the buffer to be sorted later.
*/
void addInputToFilterBuffer(uint8_t i2cInput[], const uint8_t  [MASK] ) {
  // Copy the whole packet (except error code) in the specified row of the buffer
  for (int i = 0, j = 1; i < NUM_OF_SENSORS; i++, j++) {
    filterBuffer[ [MASK] ][i] = i2cInput[j];
  }
}

/*
    Sorts the measurements of each sensor for every cycle of measurements.
*/
void sortMeasurements() {
  // For each sensor
  for (int s = 0; s < NUM_OF_SENSORS; s++) {
    // Use bubble sort to sort all measurements throughout the cycle
    for (int i = 0; i < MEASUREMENTS_TO_FILTER - 1; i++) {
      for (int j = 0; j < MEASUREMENTS_TO_FILTER - i - 1; j++) {
        if (filterBuffer[j][s] > filterBuffer[j + 1][s]) {
          uint8_t toSwap = filterBuffer[j][s];
          filterBuffer[j][s] = filterBuffer[j + 1][s];
          filterBuffer[j + 1][s] = toSwap;
        }
      }
    }
  }
}

/*
    Filter measurements depending on the variance.
    If variance is too high for a MEASUREMENTS_TO_FILTER measurements of a sensor
    then these measurements are disregarded. Otherwise the mean value is chosen.
*/
void filterMeasurements() {
  // Go through all the measurements taken for each sensor
  for (int i = 0; i < NUM_OF_SENSORS; i++) {
    // Calculate the variance across the different measurements
    // by subtracting the first and the last element
    // of the *sorted* measurement cycle.
    int variance = filterBuffer[0][i] - filterBuffer[MEASUREMENTS_TO_FILTER - 1][i];
    if (abs(variance) > VARIANCE_THRESHOLD) {
      filteredMeasurements[i] = 0;
    } else {
      filteredMeasurements[i] = filterBuffer[MEASUREMENTS_TO_FILTER / 2][i];
    }
  }
}

void setup() {
  Wire.begin();
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(INT_PIN), newSonicDiscData, RISING);
  Serial.println(""Requesting packet from SonicDisc"");
  uint8_t dummyInput[I2C_PACKET_SIZE] = {0}; // A throw-away array
  // Do not proceed unless the SonicDisc is in ""MEASURING"" state
  while (requestPacket(dummyInput, I2C_PACKET_SIZE) == IN_STANDBY) {
    Serial.println(""Setting state to MEASURING"");
    sendData(STATE_TO_MEASURING);
  }
  Serial.println(""Communication is established and SonicDisc is measuring distances"");
  car.begin();
}

void loop() {
  if (newData) {
    newData = false; // Indicate that we have read the latest data

    uint8_t sonicDiscInput[I2C_PACKET_SIZE] = {0};
    // Get the I2C packet
    I2C_ERROR_CODE ret = requestPacket(sonicDiscInput, I2C_PACKET_SIZE);
    // Now sonicDiscInput contains the latest measurements from the sensors.
    // However we need to make sure that the data is also of good quality
    // Process the packet only if it is a valid one
    if (ret == NO_ERROR) {
      addInputToFilterBuffer(sonicDiscInput, filterIndex);
      // When we have filled up the filter buffer, time to filter the measurements
      if (filterIndex + 1 == MEASUREMENTS_TO_FILTER) {
        // For each measurement
        sortMeasurements();
        filterMeasurements();
        // Indicate the the measurements are filtered
        newFilteredMeasurements = true;
      }
      // Move along the index
      filterIndex = (filterIndex + 1) % MEASUREMENTS_TO_FILTER;
    }
  }

  if (newFilteredMeasurements) {
    newFilteredMeasurements = false;
    // Now that the measurements are filtered, let's determine where to turn
    if (filteredMeasurements[6] != 0 && filteredMeasurements[6] < distanceThreshold) {
      // If the obstacle is in the front, stop rotating
      car.stop();
    } else {
      int rotation = 0; // The side to rotate. Plus is clockwise.
      for (int i = 0; i < NUM_OF_SENSORS; i++) {
        if (filteredMeasurements[i] == 0) { // Ignore the measurement if it is 0 (error value)
          continue;
        } else if (filteredMeasurements[i] < distanceThreshold) { // There is an obstacle nearby
          if (i < 6 && i > 2) {
            rotation--;
          } else if (i > 6 || i <= 2) {
            rotation++;
          }
        }
      }
      if (rotation > 0) {
        // Rotate clockwise
        car.setMotorSpeed(motorSpeed, -motorSpeed);
      } else if (rotation < 0) {
        // Rotate counter clockwise
        car.setMotorSpeed(-motorSpeed, motorSpeed);
      } else {
        car.stop();
      }
    }
  }
}
",bufferIndex
224,"//
//  Histogram.cpp
//  VINWidget
//
//  Created by ___saradhi___ on 30/11/11.
//  Copyright 2011 ___technolabssoftware___. All rights reserved.
//




#include <Histogram.h>
#include <zxing/common/IllegalArgumentException.h>
#include <zxing/common/Array.h>
#include <math.h>
#include <zxing/common/GreyscaleLuminanceSource.h>
#include <ImageProcessing.h>

namespace zxing {
    using namespace std;
    
    const int LUMINANCE_BITS = 5;
    const int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
    const int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
    
    const int BLOCK_SIZE_POWER = 3;
    const int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER;
    //const int BLOCK_SIZE_MASK = BLOCK_SIZE - 1;
    const int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
    
    
    static const int MID_SHADE_REMOVAL_HANDLER = 1;
	//static const int HIGH_SHADE_REMOVAL_HANDLER = 2;
    
    Histogram::Histogram(Ref<LuminanceSource> source) :
    Binarizer(source), cached_matrix_(NULL),cached_matrix_2(NULL), cached_row_(NULL), cached_row_num_(-1) {
        
        try {
            binarizeEntireImage();
            binarizeEntireImage2();
        } catch (IllegalArgumentException re) {
            throw new IllegalArgumentException(""Cannot binarize the image."");
        }
        
    }
    
    Histogram::~Histogram() {
    }
    
    
    Ref<BitArray> Histogram::getBlackRow(int y, Ref<BitArray> row) {
        if (y == cached_row_num_) {
            if (cached_row_ != NULL) {
                return cached_row_;
            } else {
                throw IllegalArgumentException(""Too little dynamic range in luminance"");
            }
        }
        
        vector<int> histogram(LUMINANCE_BUCKETS, 0);
        LuminanceSource& source = *getLuminanceSource();
        int width = source.getWidth();
        if (row == NULL || static_cast<int>(row->getSize()) < width) {
            row = new BitArray(width);
        } else {
            row->clear();
        }
        
        //TODO(flyashi): cache this instead of allocating and deleting per row
        unsigned char* row_pixels = NULL;
        try {
            row_pixels = new unsigned char[width];
            row_pixels = source.getRow(y, row_pixels);
            for (int x = 0; x < width; x++) {
                histogram[row_pixels[x] >> LUMINANCE_SHIFT]++;
            }
            int blackPoint = estimate(histogram) << LUMINANCE_SHIFT;
            
            BitArray& array = *row;
            int left = row_pixels[0];
            int center = row_pixels[1];
            for (int x = 1; x < width - 1; x++) {
                int right = row_pixels[x + 1];
                // A simple -1 4 -1 box filter with a weight of 2.
                int luminance = ((center << 2) - left - right) >> 1;
                if (luminance < blackPoint) {
                    array.set(x);
                }
                left = center;
                center = right;
            }
            
            cached_row_ = row;
            cached_row_num_ = y;
            delete [] row_pixels;
            return row;
        } catch (IllegalArgumentException const& iae) {
            // Cache the fact that this row failed.
            cached_row_ = NULL;
            cached_row_num_ = y;
            delete [] row_pixels;
            throw iae;
        }
    }
    
    Ref<BitMatrix> Histogram::getBlackMatrix() {
        if (cached_matrix_ != NULL) {
            return cached_matrix_;
        }
        
        // Faster than working with the reference
        LuminanceSource& source = *getLuminanceSource();
        int width = source.getWidth();
        int height = source.getHeight();
        vector<int> histogram(LUMINANCE_BUCKETS, 0);
        
        // Quickly calculates the histogram by sampling four rows from the image.
        // This proved to be more robust on the blackbox tests than sampling a
        // diagonal as we used to do.
        ArrayRef<unsigned char> ref (width);
        unsigned char* row = &ref[0];
        for (int y = 1; y < 5; y++) {
            int rownum = height * y / 5;
            int right = (width << 2) / 5;
            row = source.getRow(rownum, row);
            for (int x = width / 5; x < right; x++) {
                histogram[row[x] >> LUMINANCE_SHIFT]++;
            }
        }
        
        int blackPoint = estimate(histogram) << LUMINANCE_SHIFT;
        
        Ref<BitMatrix> matrix_ref(new BitMatrix(width, height));
        BitMatrix& matrix = *matrix_ref;
        for (int y = 0; y < height; y++) {
            row = source.getRow(y, row);
            for (int x = 0; x < width; x++) {
                if (row[x] <= blackPoint)
                    matrix.set(x, y);
            }
        }
        
        cached_matrix_ = matrix_ref;
        // delete [] row;
        return matrix_ref;
    }
    
    int Histogram::estimate(vector<int> &histogram) {
        int numBuckets = histogram.size();
        int maxBucketCount = 0;
        
        // Find tallest peak in histogram
        int firstPeak = 0;
        int firstPeakSize = 0;
        for (int i = 0; i < numBuckets; i++) {
            if (histogram[i] > firstPeakSize) {
                firstPeak = i;
                firstPeakSize = histogram[i];
            }
            if (histogram[i] > maxBucketCount) {
                maxBucketCount = histogram[i];
            }
        }
        
        // Find second-tallest peak -- well, another peak that is tall and not
        // so close to the first one
        int secondPeak = 0;
        int  [MASK]  = 0;
        for (int i = 0; i < numBuckets; i++) {
            int distanceToBiggest = i - firstPeak;
            // Encourage more distant second peaks by multiplying by square of distance
            int score = histogram[i] * distanceToBiggest * distanceToBiggest;
            if (score >  [MASK] ) {
                secondPeak = i;
                 [MASK]  = score;
            }
        }
        
        // Put firstPeak first
        if (firstPeak > secondPeak) {
            int temp = firstPeak;
            firstPeak = secondPeak;
            secondPeak = temp;
        }
        
        // Kind of arbitrary; if the two peaks are very close, then we figure there is
        // so little dynamic range in the image, that discriminating black and white
        // is too error-prone.
        // Decoding the image/line is either pointless, or may in some cases lead to
        // a false positive for 1D formats, which are relatively lenient.
        // We arbitrarily say ""close"" is
        // ""<= 1/16 of the total histogram buckets apart""
        if (secondPeak - firstPeak <= numBuckets >> 4) {
            throw IllegalArgumentException(""Too little dynamic range in luminance"");
        }
        
        // Find a valley between them that is low and closer to the white peak
        int bestValley = secondPeak - 1;
        int bestValleyScore = -1;
        for (int i = secondPeak - 1; i > firstPeak; i--) {
            int fromFirst = i - firstPeak;
            // Favor a ""valley"" that is not too close to either peak -- especially not
            // the black peak -- and that has a low value of course
            int score = fromFirst * fromFirst * (secondPeak - i) *
            (maxBucketCount - histogram[i]);
            if (score > bestValleyScore) {
                bestValley = i;
                bestValleyScore = score;
            }
        }
        
        return bestValley;
    }
    
    
    Ref<Binarizer> Histogram::createBinarizer(Ref<LuminanceSource> source) {
        return Ref<Binarizer> (new Histogram(source));
    }
    
    
    
    
    
    Ref<BitArray> Histogram::getBlackRowHybrid(int y, Ref<BitArray> row, int binarizerLevel) {
        
        if (binarizerLevel == MID_SHADE_REMOVAL_HANDLER) {
            binarizeEntireImage2();
            return cached_matrix_2->getRow(y, row);
        }
        else {
            binarizeEntireImage();
            return cached_matrix_->getRow(y, row);
        }
        
    }
    
    
    void Histogram::binarizeEntireImage() {
        if (cached_matrix_ == NULL) {
            Ref<LuminanceSource> source = getLuminanceSource();
            if (source->getWidth() >= MINIMUM_DIMENSION && source->getHeight() >= MINIMUM_DIMENSION) {
                unsigned char* luminances = source->getMatrix();
                //unsigned char* outluminances = source->getMatrix();
                
                int width = source->getWidth();
                int height = source->getHeight();
                
                zxing::ImageProcessing img ;
                img.HandleImage(luminances, width, height);
                
                
                int subWidth = width >> 3;
                if (width & 0x07) {
                    subWidth++;
                }
                int subHeight = height >> 3;
                if (height & 0x07) {
                    subHeight++;
                }
                int *blackPoints = calculateBlackPoints(luminances, subWidth, subHeight, width, height);
                cached_matrix_.reset(new BitMatrix(width,height));
                calculateThresholdForBlock(luminances, subWidth, subHeight, width, height, blackPoints, cached_matrix_);
                delete [] blackPoints;
                delete [] luminances;
            } else {
                // If the image is too small, fall back to the global histogram approach.
                cached_matrix_.reset(Histogram::getBlackMatrix());
            }
        }
    }
    
    
    
    void Histogram::calculateThresholdForBlock(unsigned char* luminances,
                                               int subWidth,
                                               int subHeight,
                                               int width,
                                               int height,
                                               int blackPoints[],
                                               Ref<BitMatrix>  matrix) {
        for (int y = 0; y < subHeight; y++) {
            int yoffset = y << BLOCK_SIZE_POWER;
            if (yoffset + BLOCK_SIZE >= height) {
                yoffset = height - BLOCK_SIZE;
            }
            for (int x = 0; x < subWidth; x++) {
                int xoffset = x << BLOCK_SIZE_POWER;
                if (xoffset + BLOCK_SIZE >= width) {
                    xoffset = width - BLOCK_SIZE;
                }
                int left = (x > 1) ? x : 2;
                left = (left < subWidth - 2) ? left : subWidth - 3;
                int top = (y > 1) ? y : 2;
                top = (top < subHeight - 2) ? top : subHeight - 3;
                int sum = 0;
                for (int z = -2; z <= 2; z++) {
                    int *blackRow = &blackPoints[(top + z) * subWidth];
                    sum += blackRow[left - 2];
                    sum += blackRow[left - 1];
                    sum += blackRow[left];
                    sum += blackRow[left + 1];
                    sum += blackRow[left + 2];
                }
                int average = sum / 25;
                threshold8x8Block(luminances, xoffset, yoffset, average, width, matrix);
            }
        }
    }
    
    void Histogram::threshold8x8Block(unsigned char* luminances,
                                      int xoffset,
                                      int yoffset,
                                      int threshold,
                                      int stride,
                                      Ref<BitMatrix>  matrix) {
        for (int y = 0, offset = yoffset * stride + xoffset;
             y < BLOCK_SIZE;
             y++,  offset += stride) {
            for (int x = 0; x < BLOCK_SIZE; x++) {
                int pixel = luminances[offset + x] & 0xff;
                if (pixel <= threshold) {
                    matrix->set(xoffset + x, yoffset + y);
                }
            }
        }
    }
    
    namespace {
        inline int getBlackPointFromNeighbors(int* blackPoints, int subWidth, int x, int y) {
            return (blackPoints[(y-1)*subWidth+x] +
                    2*blackPoints[y*subWidth+x-1] +
                    blackPoints[(y-1)*subWidth+x-1]) >> 2;
        }
    }
    
    int* Histogram::calculateBlackPoints(unsigned char* luminances, int subWidth, int subHeight,
                                         int width, int height) {
        int *blackPoints = new int[subHeight * subWidth];
        for (int y = 0; y < subHeight; y++) {
            int yoffset = y << BLOCK_SIZE_POWER;
            if (yoffset + BLOCK_SIZE >= height) {
                yoffset = height - BLOCK_SIZE;
            }
            for (int x = 0; x < subWidth; x++) {
                int xoffset = x << BLOCK_SIZE_POWER;
                if (xoffset + BLOCK_SIZE >= width) {
                    xoffset = width - BLOCK_SIZE;
                }
                int sum = 0;
                int min = 0xFF;
                int max = 0;
                for (int yy = 0, offset = yoffset * width + xoffset;
                     yy < BLOCK_SIZE;
                     yy++, offset += width) {
                    for (int xx = 0; xx < BLOCK_SIZE; xx++) {
                        int pixel = luminances[offset + xx] & 0xFF;
                        sum += pixel;
                        if (pixel < min) {
                            min = pixel;
                        }
                        if (pixel > max) {
                            max = pixel;
                        }
                    }
                }
                
                int average = sum >> 6;
                if (max - min <= 24) {
                    average = min >> 1;
                    if (y > 0 && x > 0) {
                        int bp = getBlackPointFromNeighbors(blackPoints, subWidth, x, y);
                        if (min < bp) {
                            average = bp;
                        }
                    }
                }
                blackPoints[y * subWidth + x] = average;
            }
        }
        return blackPoints;
    }
    
    
    
    
    // binarizer - 3 ..  created on 13-02-2012
    //
    //
    
    void Histogram::binarizeEntireImage2() {
        if (cached_matrix_2 == NULL) {
            Ref<GreyscaleLuminanceSource> source = getLuminanceSource();
            if (source->getWidth() >= MINIMUM_DIMENSION && source->getHeight() >= MINIMUM_DIMENSION) {
                unsigned char* luminances = source->getMatrix();
                //unsigned char* outluminances = source->getMatrix();
                
                int width = source->getWidth();
                int height = source->getHeight();
                
                zxing::ImageProcessing img ;
                img.HandleImage2(luminances, width, height);
                
                
                int subWidth = width >> 3;
                if (width & 0x07) {
                    subWidth++;
                }
                int subHeight = height >> 3;
                if (height & 0x07) {
                    subHeight++;
                }
                int *blackPoints = calculateBlackPoints2(luminances, subWidth, subHeight, width, height);
                cached_matrix_2.reset(new BitMatrix(width,height));
                calculateThresholdForBlock2(luminances, subWidth, subHeight, width, height, blackPoints, cached_matrix_2);
                delete [] blackPoints;
                delete [] luminances;
            } else {
                // If the image is too small, fall back to the global histogram approach.
                cached_matrix_2.reset(Histogram::getBlackMatrix());
            }
        }
    }
    
    
    int* Histogram::calculateBlackPoints2(unsigned char* luminances, int subWidth, int subHeight,
                                          int width, int height) {
        int *blackPoints = new int[subHeight * subWidth];
        for (int y = 0; y < subHeight; y++) {
            int yoffset = y << BLOCK_SIZE_POWER;
            if (yoffset + BLOCK_SIZE >= height) {
                yoffset = height - BLOCK_SIZE;
            }
            for (int x = 0; x < subWidth; x++) {
                int xoffset = x << BLOCK_SIZE_POWER;
                if (xoffset + BLOCK_SIZE >= width) {
                    xoffset = width - BLOCK_SIZE;
                }
                int sum = 0;
                int min = 0xFF;
                int max = 0;
                for (int yy = 0, offset = yoffset * width + xoffset;
                     yy < BLOCK_SIZE;
                     yy++, offset += width) {
                    for (int xx = 0; xx < BLOCK_SIZE; xx++) {
                        int pixel = luminances[offset + xx] & 0xFF;
                        sum += pixel;
                        if (pixel < min) {
                            min = pixel;
                        }
                        if (pixel > max) {
                            max = pixel;
                        }
                    }
                }
                
                int average = sum >> 6;
                int average2 = average;
                
                if (max - min <= 24) {
                    average = max == 0 ? 1 : (int) (min * 0.3125f);
                    average2 = (int) (min * 0.3125f);
                    if (y > 0 && x > 0) {
                        int bp = getBlackPointFromNeighbors(blackPoints, subWidth, x, y);
                        if (min < bp) {
                            average2 = bp;
                        }
                    }
                }
                blackPoints[y * subWidth + x] = (average + average2) >> 1;
            }
        }
        return blackPoints;
    }
    
    void Histogram::calculateThresholdForBlock2(unsigned char* luminances,
                                                int subWidth,
                                                int subHeight,
                                                int width,
                                                int height,
                                                int blackPoints[],
                                                Ref<BitMatrix>  matrix) {
        for (int y = 0; y < subHeight; y++) {
            int yoffset = y << BLOCK_SIZE_POWER;
            if (yoffset + BLOCK_SIZE >= height) {
                yoffset = height - BLOCK_SIZE;
            }
            for (int x = 0; x < subWidth; x++) {
                int xoffset = x << BLOCK_SIZE_POWER;
                if (xoffset + BLOCK_SIZE >= width) {
                    xoffset = width - BLOCK_SIZE;
                }
                int left = (x > 1) ? x : 2;
                left = (left < subWidth - 2) ? left : subWidth - 3;
                int top = (y > 1) ? y : 2;
                top = (top < subHeight - 2) ? top : subHeight - 3;
                int sum = 0;
                for (int z = -2; z <= 2; z++) {
                    int *blackRow = &blackPoints[(top + z) * subWidth];
                    sum += blackRow[left - 2];
                    sum += blackRow[left - 1] + 3.25;
                    sum += blackRow[left];
                    sum += blackRow[left + 1];
                    sum += blackRow[left + 2];
                }
                int average = sum / 30;
                if (average > 255)
					average = (int) (average * 0.7125f);
                threshold8x8Block(luminances, xoffset, yoffset, average, width, matrix);
            }
        }
    }
    
    
} // namespace VIN

",secondPeakScore
225,"/*
BMFont example implementation with Kerning, for C++ and OpenGL 2.0

This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.

In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.

THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

For more information, please refer to <http://unlicense.org/>
*/

#include <windows.h>
#include ""sys_gl.h""
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include ""log.h""
#include <iostream> // for cerr
//For CheckOpenGLError StringStream
#include <sstream>
//For simple shader code
#include <vector>
#include <string>
#include <fstream>

// Required OpenGL Libraries, placed here to make it easier
#pragma comment(lib, ""opengl32.lib"")
#pragma comment(lib, ""glu32.lib"")


//OpenGL Globals for context
HDC hDC;
HGLRC hRC;

#pragma warning (disable : 4996)
constexpr auto  PI = 3.14159265358979323846;

// Code below from https://blog.nobel-joergensen.com/2013/01/29/debugging-opengl-using-glgeterror/

void CheckGLError(const char* file, int line) {
	GLenum err(glGetError());

	while (err != GL_NO_ERROR) {
		std::string error;

		switch (err) {
		case GL_INVALID_OPERATION:      error = ""INVALID_OPERATION"";      break;
		case GL_INVALID_ENUM:           error = ""INVALID_ENUM"";           break;
		case GL_INVALID_VALUE:          error = ""INVALID_VALUE"";          break;
		case GL_OUT_OF_MEMORY:          error = ""OUT_OF_MEMORY"";          break;
		case GL_INVALID_FRAMEBUFFER_OPERATION:  error = ""INVALID_FRAMEBUFFER_OPERATION"";  break;
		}

		wrlog(""OpenGL Error: %s in %s file at line %d "", error.c_str(), file, line);
		err = glGetError();
	}
}


void CheckGLError2() {
	GLenum err(glGetError());

	while (err != GL_NO_ERROR) {
		std::string error;

		err = glGetError();

		switch (err) {
		case GL_INVALID_OPERATION:      error = ""INVALID_OPERATION"";      break;
		case GL_INVALID_ENUM:           error = ""INVALID_ENUM"";           break;
		case GL_INVALID_VALUE:          error = ""INVALID_VALUE"";          break;
		case GL_OUT_OF_MEMORY:          error = ""OUT_OF_MEMORY"";          break;
		case GL_INVALID_FRAMEBUFFER_OPERATION:  error = ""INVALID_FRAMEBUFFER_OPERATION"";  break;
		}

		if (err != GL_NO_ERROR) wrlog(""OpenGL Error: %s "", error.c_str());

	}
}


void CheckGLVersionSupport()
{
	const char* version;
	int major, minor;

	version = (char*)glGetString(GL_VERSION);
	sscanf(version, ""%d.%d"", &major, &minor);
	wrlog(""OpenGl Version supported %d.%d"", major, minor);

	if (major < 2)
	{
		//MessageBox(NULL, ""This program WILL not work, your supported opengl version is less then 2.0"", ""OpenGL version warning"", MB_ICONERROR | MB_OK);
	}
}


//========================================================================
// Setup and OpenGl Ortho 2D Window, Depreciated OGL 1.0-2.0 
//========================================================================
void ViewOrtho(int width, int height)
{
	glViewport(0, 0, width, height);             // Set Up An Ortho View	 
	glMatrixMode(GL_PROJECTION);			  // Select Projection
	glLoadIdentity();						  // Reset The Matrix
	glOrtho(0, width-1, height-1, 0, -1, 1);	  // Select Ortho 2D Mode DirectX style(640x480)
	glMatrixMode(GL_MODELVIEW);				  // Select Modelview Matrix
	glLoadIdentity();						  // Reset The Matrix
}


//========================================================================
// Resize OpenGL Window
//========================================================================
void OnResize(GLsizei width, GLsizei height)
{
	if (height == 0)                // Prevent A Divide By Zero By
		height = 1;                    // Making Height Equal One
	SCREEN_W = width;             // Screen Width
	SCREEN_H = height;            // Screen Height
	ViewOrtho(width, height);
}


//========================================================================
// Enable Opengl Code, currently depreciated 2.0 only
//========================================================================
int OpenGL2Enable()
{
	PIXELFORMATDESCRIPTOR pfd;
	int format;

	// get the device context (DC)
	hDC = GetDC(win_get_window());

	// set the pixel format for the DC
	ZeroMemory(&pfd, sizeof(pfd));
	pfd.nSize = sizeof(pfd);
	pfd.nVersion = 1;
	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = 24;
	pfd.cDepthBits = 16;
	pfd.iLayerType = PFD_MAIN_PLANE;
	format = ChoosePixelFormat(hDC, &pfd);
	SetPixelFormat(hDC, format, &pfd);

	// create and enable the render context (RC)
	hRC = wglCreateContext(hDC);
	wglMakeCurrent(hDC, hRC);

	//Enable GLEW
	GLenum error = glewInit(); // Enable GLEW
	if (error != GLEW_OK) // If GLEW fails
	{
		wrlog(""Glew Init Failed"");	return false;
	}

	wrlog(""OpenGL %s, GLSL %s\n"", glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION));
	return true;
}

//========================================================================
// Enable Opengl 3/4 Code.
//========================================================================
int OpenGL3Enable()
{
	hDC = GetDC(win_get_window());

	PIXELFORMATDESCRIPTOR pfd; // Create a new PIXELFORMATDESCRIPTOR (PFD)
	memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR)); // Clear our  PFD
	pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); // Set the size of the PFD to the size of the class
	pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW; // Enable double buffering, opengl support and drawing to a window
	pfd.iPixelType = PFD_TYPE_RGBA; // Set our application to use RGBA pixels
	pfd.cColorBits = 32; // Give us 32 bits of color information (the higher, the more colors)
	pfd.cDepthBits = 32; // Give us 32 bits of depth information (the higher, the more depth levels)
	pfd.iLayerType = PFD_MAIN_PLANE; // Set the layer of the PFD

	int nPixelFormat = ChoosePixelFormat(hDC, &pfd); // Check if our PFD is valid and get a pixel format back
	if (nPixelFormat == 0) // If it fails
		return false;

	int bResult = SetPixelFormat(hDC, nPixelFormat, &pfd); // Try and set the pixel format based on our PFD
	if (!bResult) // If it fails
		return false;

	HGLRC tempOpenGLContext = wglCreateContext(hDC); // Create an OpenGL 2.1 context for our device context
	wglMakeCurrent(hDC, tempOpenGLContext); // Make the OpenGL 2.1 context current and active

	glewExperimental = true;
	GLenum error = glewInit(); // Enable GLEW
	if (error != GLEW_OK) // If GLEW fails
	{
		wrlog(""Glew Init Failed"");	return false;
	}

	const int attributes[] = {
		WGL_CONTEXT_MAJOR_VERSION_ARB, 3, // Set the MAJOR version of OpenGL to 3
		WGL_CONTEXT_MINOR_VERSION_ARB, 2, // Set the MINOR version of OpenGL to 2
		WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, // Set our OpenGL context to be forward compatible
		WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB , //Set the compatibility
		0
	};

	if (wglewIsSupported(""WGL_ARB_create_context"") == 1) { // If the OpenGL 3.x context creation extension is available
		hRC = wglCreateContextAttribsARB(hDC, NULL, attributes); // Create and OpenGL 3.x context based on the given attributes
		wglMakeCurrent(NULL, NULL); // Remove the temporary context from being active
		wglDeleteContext(tempOpenGLContext); // Delete the temporary OpenGL 2.1 context
		wglMakeCurrent(hDC, hRC); // Make our OpenGL 3.0 context current
	}
	else
	{
		hRC = tempOpenGLContext; // If we didn't have support for OpenGL 3.x and up, use the OpenGL 2.1 context
	}

	int glVersion[2] = { -1, -1 }; // Set some default values for the version
	glGetIntegerv(GL_MAJOR_VERSION, &glVersion[0]); // Get back the OpenGL MAJOR version we are using
	glGetIntegerv(GL_MINOR_VERSION, &glVersion[1]); // Get back the OpenGL MAJOR version we are using

	wrlog(""Gl version %x:%x"", glVersion[0], glVersion[1]);
	wrlog(""OpenGL %s, GLSL %s\n"", glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION));

	if (GLEW_EXT_framebuffer_multisample)
	{
		//Example of checking extensions
	}

	return true; // We have successfully created a context, return true
};


//========================================================================
// Disable and release the OpenGL Context
//========================================================================
void OpenGLShutDown()
{
	wglMakeCurrent(NULL, NULL);
	wglDeleteContext(hRC);
	ReleaseDC(win_get_window(), hDC);
}


//========================================================================
// Swap GL Buffers
//========================================================================
void GLSwapBuffers()
{
	SwapBuffers(hDC);
}


//========================================================================
// Enable / Disable vSync
//========================================================================
void osWaitVsync(bool enable)
{
	if (enable == TRUE)
	{
		wglSwapIntervalEXT(1);
	}
	else
	{
		wglSwapIntervalEXT(0);
	}
}



// Really simple shader loader copied from the OpenGL examples on the web
GLuint LoadShaders(const char* vertex_file, const char* fragment_file, bool file_or_char)
{
	// Create the shaders
	GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
	GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
	std::string VertexShaderCode;
	std::string FragmentShaderCode;
	// If these are file names, read the data in.
	// Otherwise, use these directly.
	if (file_or_char)
	{
		// Read the Vertex Shader code from the file

		std::ifstream VertexShaderStream(vertex_file, std::ios::in);
		if (VertexShaderStream.is_open()) {
			std::string Line = """";
			while (getline(VertexShaderStream, Line))
				VertexShaderCode += ""\n"" + Line;
			VertexShaderStream.close();
		}
		else {
			wrlog(""Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n"", vertex_file);
			return 0;
		}

		// Read the Fragment Shader code from the file

		std::ifstream FragmentShaderStream(fragment_file, std::ios::in);
		if (FragmentShaderStream.is_open()) {
			std::string Line = """";
			while (getline(FragmentShaderStream, Line))
				FragmentShaderCode += ""\n"" + Line;
			FragmentShaderStream.close();
		}
		else {
			wrlog(""Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n"", fragment_file);
			return 0;
		}
	}
	else
	{
		VertexShaderCode = vertex_file;
		FragmentShaderCode = fragment_file;
	}

	GLint Result = GL_FALSE;
	int  [MASK] ;

	// Compile Vertex Shader
	wrlog(""Compiling vertex shader"");
	char const* VertexSourcePointer = VertexShaderCode.c_str();
	glShaderSource(VertexShaderID, 1, &VertexSourcePointer, NULL);
	glCompileShader(VertexShaderID);

	// Check Vertex Shader
	glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
	glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, & [MASK] );
	if ( [MASK]  > 0) {
		std::vector<char> VertexShaderErrorMessage( [MASK]  + 1);
		glGetShaderInfoLog(VertexShaderID,  [MASK] , NULL, &VertexShaderErrorMessage[0]);
		wrlog(""%s\n"", &VertexShaderErrorMessage[0]);
	}

	// Compile Fragment Shader
	wrlog(""Compiling fragment shader"");
	char const* FragmentSourcePointer = FragmentShaderCode.c_str();
	glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL);
	glCompileShader(FragmentShaderID);

	// Check Fragment Shader
	glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
	glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, & [MASK] );
	if ( [MASK]  > 0) {
		std::vector<char> FragmentShaderErrorMessage( [MASK]  + 1);
		glGetShaderInfoLog(FragmentShaderID,  [MASK] , NULL, &FragmentShaderErrorMessage[0]);
		wrlog(""%s\n"", &FragmentShaderErrorMessage[0]);
	}

	// Link the program
	wrlog(""Linking program\n"");
	GLuint ProgramID = glCreateProgram();
	glAttachShader(ProgramID, VertexShaderID);
	glAttachShader(ProgramID, FragmentShaderID);
	glLinkProgram(ProgramID);

	// Check the program
	glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
	glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, & [MASK] );
	if ( [MASK]  > 0) {
		std::vector<char> ProgramErrorMessage( [MASK]  + 1);
		glGetProgramInfoLog(ProgramID,  [MASK] , NULL, &ProgramErrorMessage[0]);
		wrlog(""%s\n"", &ProgramErrorMessage[0]);
	}

	glDetachShader(ProgramID, VertexShaderID);
	glDetachShader(ProgramID, FragmentShaderID);

	glDeleteShader(VertexShaderID);
	glDeleteShader(FragmentShaderID);

	GLenum err;
	while ((err = glGetError()) != GL_NO_ERROR)
	{
		wrlog(""GL Error in shader processing  %d"", err);
		//Process/log the error.
	}

	return ProgramID;
}

bool ShaderIsValid(GLuint program) {
	glValidateProgram(program);
	int params = -1;
	glGetProgramiv(program, GL_VALIDATE_STATUS, &params);
	wrlog(""program %i GL_VALIDATE_STATUS = %i\n"", program, params);
	if (GL_TRUE != params) {
		//_print_programme_info_log(programme);
		return false;
	}
	return true;
}",InfoLogLength
226,"#ifndef BOOPY_AI_H
#define BOOPY_AI_H

#include ""../AI.h""

/** 
 * Goal of the AI: 
 *      Play the moves that create the most change in board state.
 *      Play the moves that boop the most pieces.
 */
class Boopy_AI : public AI {
    public:
        Boopy_AI() { }
        std::string think(std::queue<std::string> moves, Timer& timer) override;
    private:
        Boop::PieceType board[Boop::SIZE][Boop::SIZE];
        // Count the number of different squares from the current board state
        int board_difference(Boop* future);
};

std::string Boopy_AI::think(std::queue<std::string> moves, Timer& timer) {
    std::string best_move;
    // Check timer.times_up() between loops as to not go over the time limit
    int boops;
    int  [MASK]  = -1;
    Boop* future;

    game->clone_board(board);

    while(!moves.empty()) {
        future = game->clone();
        future -> make_move(moves.front( ));
        boops = board_difference(future);
        delete future;

        if(boops >  [MASK] ) {
             [MASK]  = boops;
            best_move = moves.front();
        }

        moves.pop( );
        if(timer.times_up()) { return best_move; }
    }

    return best_move;
}

int Boopy_AI::board_difference(Boop* future) {
    int c = 0;
    Boop::PieceType future_board[6][6];
    future->clone_board(future_board);

    for(int y = 0; y < Boop::SIZE; ++y) {
        for(int x = 0; x < Boop::SIZE; ++x) {
            if(board[x][y] != future_board[x][y]) { ++c; }
        }
    }

    return c;
}

#endif",most_boops
227,"#include <openssl/evp.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
#include <iostream>
#include <cstring>
#include <vector>
#include <iomanip>
#include <sstream>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h> // For using std::string with pybind11
#include <filesystem>
#include <openssl/bio.h>
#include <openssl/buffer.h>
#include <openssl/evp.h>
#include <fstream>



// Function to generate a random AES key of the specified length (in bytes) and return it as a hex string
std::string generate_random_key() {
    std::vector<unsigned char> key(16);
    if (!RAND_bytes(key.data(), 16)) {
        throw std::runtime_error(""Error: Random key generation failed."");
    }

    // Convert key to hex string
    std::ostringstream oss;
    for (unsigned char c : key) {
        oss << std::hex << std::setw(2) << std::setfill('0') << (int)c;
    }
    return oss.str();
}

// Convert hex string to byte vector
std::vector<unsigned char> hex_string_to_bytes(const std::string& hex_str) {
    std::vector<unsigned char> bytes;
    for (size_t i = 0; i < hex_str.length(); i += 2) {
        std::string byte_string = hex_str.substr(i, 2);
        unsigned char byte = (unsigned char) strtol(byte_string.c_str(), nullptr, 16);
        bytes.push_back(byte);
    }
    return bytes;
}

bool aes_encrypt_file(const std::string& input_file, const std::string& hex_key) {
    // Convert key from hex string to byte vector
    std::vector<unsigned char> key = hex_string_to_bytes(hex_key);

    // Open input file
    std::ifstream infile(input_file, std::ios::binary);
    if (!infile.is_open()) {
        std::cerr << ""Error: Cannot open input file.\n"";
        return false;
    }

    // Define the path for the temp folder relative to the executable location
    std::filesystem::path  [MASK]  = std::filesystem::current_path() / ""temp"";
    std::filesystem::create_directory( [MASK] );

    // Construct the output file path in the temp directory with .enc extension
    std::filesystem::path input_path(input_file);
    std::filesystem::path output_path =  [MASK]  / (input_path.filename().string() + "".enc"");

    // Open output file for encrypted content
    std::ofstream outfile(output_path, std::ios::binary);
    if (!outfile.is_open()) {
        std::cerr << ""Error: Cannot open output file.\n"";
        return false;
    }

    // Initialize context for encryption (AES-128-ECB)
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, EVP_aes_128_ecb(), nullptr, key.data(), nullptr);

    const int buffer_size = 4096;
    unsigned char buffer[buffer_size]; // Read buffer
    unsigned char cipher_buffer[buffer_size + AES_BLOCK_SIZE]; // Ciphertext buffer
    int len = 0, cipher_len = 0;

    // Read from input file and encrypt in chunks
    while (infile.good()) {
        infile.read(reinterpret_cast<char*>(buffer), buffer_size);
        int read_len = infile.gcount();

        // Encrypt the data read from the file
        if (!EVP_EncryptUpdate(ctx, cipher_buffer, &len, buffer, read_len)) {
            std::cerr << ""Error: Encryption failed.\n"";
            EVP_CIPHER_CTX_free(ctx);
            return false;
        }
        outfile.write(reinterpret_cast<char*>(cipher_buffer), len);
    }

    // Finalize encryption
    if (!EVP_EncryptFinal_ex(ctx, cipher_buffer, &cipher_len)) {
        std::cerr << ""Error: Final encryption step failed.\n"";
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }
    outfile.write(reinterpret_cast<char*>(cipher_buffer), cipher_len);

    // Cleanup
    EVP_CIPHER_CTX_free(ctx);
    infile.close();
    outfile.close();
    return true;
}

bool aes_decrypt_file(const std::string& input_file, const std::string& output_file, const std::string& hex_key) {
    // Convert key from hex string to byte vector
    std::vector<unsigned char> key = hex_string_to_bytes(hex_key);

    // Open input file for decryption
    std::ifstream infile(input_file, std::ios::binary);
    if (!infile.is_open()) {
        std::cerr << ""Error: Cannot open input file for decryption.\n"";
        return false;
    }

    // Open output file for decrypted content
    std::ofstream outfile(output_file, std::ios::binary);
    if (!outfile.is_open()) {
        std::cerr << ""Error: Cannot open output file for decryption.\n"";
        return false;
    }

    // Initialize context for decryption (AES-128-ECB)
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_DecryptInit_ex(ctx, EVP_aes_128_ecb(), nullptr, key.data(), nullptr);

    const int buffer_size = 4096;
    unsigned char buffer[buffer_size]; // Read buffer
    unsigned char plain_buffer[buffer_size + AES_BLOCK_SIZE]; // Plaintext buffer
    int len = 0, plain_len = 0;

    // Read from input file and decrypt in chunks
    while (infile.good()) {
        infile.read(reinterpret_cast<char*>(buffer), buffer_size);
        int read_len = infile.gcount();

        // Decrypt the data read from the file
        if (!EVP_DecryptUpdate(ctx, plain_buffer, &len, buffer, read_len)) {
            std::cerr << ""Error: Decryption failed.\n"";
            EVP_CIPHER_CTX_free(ctx);
            return false;
        }
        outfile.write(reinterpret_cast<char*>(plain_buffer), len);
    }

    // Finalize decryption
    if (!EVP_DecryptFinal_ex(ctx, plain_buffer, &plain_len)) {
        std::cerr << ""Error: Final decryption step failed.\n"";
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }
    outfile.write(reinterpret_cast<char*>(plain_buffer), plain_len);

    // Cleanup
    EVP_CIPHER_CTX_free(ctx);
    infile.close();
    outfile.close();
    return true;
}

std::string base64_encode(const std::vector<unsigned char>& input) {
    BIO* b64 = BIO_new(BIO_f_base64());
    BIO* bmem = BIO_new(BIO_s_mem());
    b64 = BIO_push(b64, bmem);

    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); // No newlines in base64 output
    BIO_write(b64, input.data(), input.size());
    BIO_flush(b64);

    BUF_MEM* bptr;
    BIO_get_mem_ptr(b64, &bptr);

    std::string output(bptr->data, bptr->length);
    BIO_free_all(b64);

    return output;
}

// Base64 decoding function
std::vector<unsigned char> base64_decode(const std::string& input) {
    BIO* b64 = BIO_new(BIO_f_base64());
    BIO* bmem = BIO_new_mem_buf(input.data(), input.size());
    b64 = BIO_push(b64, bmem);

    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); // No newlines in base64 input

    std::vector<unsigned char> output(input.size());
    int decoded_length = BIO_read(b64, output.data(), input.size());
    output.resize(decoded_length);
    BIO_free_all(b64);

    return output;
}


PYBIND11_MODULE(pybind_aes, m) {
    m.def(""aes_file_encrypt"", &aes_encrypt_file, """");
    m.def(""aes_file_decrypt"", &aes_decrypt_file, """");
    m.def(""aes_key_generate"", &generate_random_key, ""Generate random 16 bytes key"");
}",temp_folder
228,"
#include ""BaseScene.h""
#include ""../ui/BaseGuiScreen.h""

BaseScene::BaseScene(const Ogre::String  [MASK] , HappyRoll2Application *application, BaseGuiScreen *gui)
	: ogre_root(application->ogre_root), ogre_window(application->ogre_window), 
	ogre_scene_manager(nullptr), ogre_overlay_system(application->ogre_overlay_system), ogre_viewport(nullptr), gui(gui)
{
	ogre_scene_manager = ogre_root->createSceneManager(Ogre::ST_GENERIC,  [MASK] );
}

void BaseScene::attach_display()
{
	ogre_viewport = ogre_window->addViewport(this->getCamera(), this->getZOrder());
	ogre_viewport->setAutoUpdated(true);
	ogre_viewport->setBackgroundColour(Ogre::ColourValue(0, 0, 0));
	this->getCamera()->setAspectRatio(float(ogre_viewport->getActualWidth()) / float(ogre_viewport->getActualHeight()));

	ogre_root->addFrameListener(this);
	ogre_scene_manager->addRenderQueueListener(ogre_overlay_system);

	gui->show();
}

void BaseScene::detach_display()
{
	gui->hide();
	ogre_scene_manager->removeRenderQueueListener(ogre_overlay_system);
	ogre_window->removeViewport(ogre_viewport->getZOrder());
	ogre_root->removeFrameListener(this);
}

BaseScene::~BaseScene()
{
	ogre_root->destroySceneManager(ogre_scene_manager);
	delete gui;
}

bool BaseScene::frameStarted(const Ogre::FrameEvent &evt)
{
	return gui->update(evt.timeSinceLastFrame) && this->update(evt.timeSinceLastFrame);
}
",name
229,"#include ""Deserializer.hpp""

namespace oatpp { namespace mariadb { namespace mapping {

Deserializer::InData::InData(MYSQL_BIND* pBind,
                             const std::shared_ptr<const data::mapping::TypeResolver>& pTypeResolver)
{
  bind = pBind;
  typeResolver = pTypeResolver;
  oid = bind->buffer_type;
  isNull = (bind->is_null != nullptr && *bind->is_null == 1);
}

Deserializer::Deserializer() {

  m_methods.resize(data::mapping::type::ClassId::getClassCount(), nullptr);

  setDeserializerMethod(data::mapping::type::__class::String::CLASS_ID, &Deserializer::deserializeString);
  setDeserializerMethod(data::mapping::type::__class::Any::CLASS_ID, &Deserializer::deserializeAny);
  setDeserializerMethod(data::mapping::type::__class::Boolean::CLASS_ID, &Deserializer::deserializeBoolean);

  setDeserializerMethod(data::mapping::type::__class::Int8::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int8>);
  setDeserializerMethod(data::mapping::type::__class::UInt8::CLASS_ID, &Deserializer::deserializeInt<oatpp::UInt8>);

  setDeserializerMethod(data::mapping::type::__class::Int16::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int16>);
  setDeserializerMethod(data::mapping::type::__class::UInt16::CLASS_ID, &Deserializer::deserializeInt<oatpp::UInt16>);

  setDeserializerMethod(data::mapping::type::__class::Int32::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int32>);
  setDeserializerMethod(data::mapping::type::__class::UInt32::CLASS_ID, &Deserializer::deserializeInt<oatpp::UInt32>);

  setDeserializerMethod(data::mapping::type::__class::Int64::CLASS_ID, &Deserializer::deserializeInt<oatpp::Int64>);
  setDeserializerMethod(data::mapping::type::__class::UInt64::CLASS_ID, &Deserializer::deserializeInt<oatpp::UInt64>);

  setDeserializerMethod(data::mapping::type::__class::Float32::CLASS_ID, &Deserializer::deserializeFloat32);
  setDeserializerMethod(data::mapping::type::__class::Float64::CLASS_ID, &Deserializer::deserializeFloat64);

  setDeserializerMethod(data::mapping::type::__class::AbstractObject::CLASS_ID, nullptr);
  setDeserializerMethod(data::mapping::type::__class::AbstractEnum::CLASS_ID, &Deserializer::deserializeEnum);

  setDeserializerMethod(data::mapping::type::__class::AbstractVector::CLASS_ID, nullptr);
  setDeserializerMethod(data::mapping::type::__class::AbstractList::CLASS_ID, nullptr);
  setDeserializerMethod(data::mapping::type::__class::AbstractUnorderedSet::CLASS_ID, nullptr);

  setDeserializerMethod(data::mapping::type::__class::AbstractPairList::CLASS_ID, nullptr);
  setDeserializerMethod(data::mapping::type::__class::AbstractUnorderedMap::CLASS_ID, nullptr);

}

void Deserializer::setDeserializerMethod(const data::mapping::type::ClassId& classId, DeserializerMethod method) {
  const v_uint32 id = classId.id;
  if(id >= m_methods.size()) {
    m_methods.resize(id + 1, nullptr);
  }
  m_methods[id] = method;
}

oatpp::Void Deserializer::deserialize(const InData& data, const Type* type) const {

  // OATPP_LOGD(""Deserializer::deserialize()"", ""type=%s, oid=%d, isNull=%d"", type->classId.name, data.oid, data.isNull);

  auto id = type->classId.id;
  auto& method = m_methods[id];

  if(method) {
    return (*method)(this, data, type);
  }

  auto* interpretation = type->findInterpretation(data.typeResolver->getEnabledInterpretations());
  if(interpretation) {
    return interpretation->fromInterpretation(deserialize(data, interpretation->getInterpretationType()));
  }

  throw std::runtime_error(""[oatpp::mariadb::mapping::Deserializer::deserialize()]: ""
                           ""Error. No deserialize method for type '"" + std::string(type->classId.name) + ""'"");

}

v_int64 Deserializer::deInt(const InData& data) {
  v_int64 value;

  switch(data.oid) {
    case MYSQL_TYPE_BIT: {
      value = *(uint64_t*) data.bind->buffer;
      std::memset(data.bind->buffer, 0, sizeof(uint64_t));
      return value;
    }
    case MYSQL_TYPE_TINY: {
      value = *(int8_t*) data.bind->buffer;
      std::memset(data.bind->buffer, 0, sizeof(int8_t));
      return value;
    }
    case MYSQL_TYPE_SHORT: {
      value = *(int16_t*) data.bind->buffer;
      std::memset(data.bind->buffer, 0, sizeof(int16_t));
      return value;
    }
    case MYSQL_TYPE_LONG: {
      value = *(int32_t*) data.bind->buffer;
      std::memset(data.bind->buffer, 0, sizeof(int32_t));
      return value;
    }
    case MYSQL_TYPE_LONGLONG: {
      value = *(int64_t*) data.bind->buffer;
      std::memset(data.bind->buffer, 0, sizeof(int64_t));
      return value;
    }
  }

  throw std::runtime_error(""[oatpp::mariadb::mapping::Deserializer::deInt()]: Error. Unknown OID."");
}

oatpp::Void Deserializer::deserializeString(const Deserializer* _this, const InData& data, const Type* type)
{
  (void) _this;
  (void) type;

  if(data.isNull) {
    return oatpp::String();
  }

  auto ptr = (const char*) data.bind->buffer;
  auto size = *data.bind->length;  // Use the actual data length

  oatpp::String value(ptr, size);
  std::memset(data.bind->buffer, 0, data.bind->buffer_length);
  return value;
}

oatpp::Void Deserializer::deserializeFloat32(const Deserializer* _this, const InData& data, const Type* type) {

  (void) _this;
  (void) type;

  if(data.isNull) {
    return oatpp::Float32();
  }

  float value;

  switch(data.oid) {
    case MYSQL_TYPE_LONG:
    case MYSQL_TYPE_FLOAT: {
      value = *(float*) data.bind->buffer;
      std::memset(data.bind->buffer, 0, sizeof(float));
      return oatpp::Float32(value);
    }
  }

  throw std::runtime_error(""[oatpp::mariadb::mapping::Deserializer::deserializeFloat32()]: Error. Unknown OID."");

}

oatpp::Void Deserializer::deserializeFloat64(const Deserializer* _this, const InData& data, const Type* type) {
  OATPP_LOGD(""Deserializer"", ""Deserializing Float64 value"");
  
  if(data.isNull) {
    OATPP_LOGD(""Deserializer"", ""Float64 value is null"");
    return oatpp::Float64();
  }
  
  double value = 0;
  
  switch(data.oid) {
    case MYSQL_TYPE_TINY: {
      value = static_cast<double>(*static_cast<int8_t*>(data.bind->buffer));
      break;
    }
    case MYSQL_TYPE_SHORT: {
      value = static_cast<double>(*static_cast<int16_t*>(data.bind->buffer));
      break;
    }
    case MYSQL_TYPE_LONG: {
      value = static_cast<double>(*static_cast<int32_t*>(data.bind->buffer));
      break;
    }
    case MYSQL_TYPE_LONGLONG: {
      value = static_cast<double>(*static_cast<int64_t*>(data.bind->buffer));
      break;
    }
    case MYSQL_TYPE_FLOAT: {
      value = static_cast<double>(*static_cast<float*>(data.bind->buffer));
      break;
    }
    case MYSQL_TYPE_DOUBLE: {
      value = *static_cast<double*>(data.bind->buffer);
      break;
    }
    default:
      OATPP_LOGE(""Deserializer"", ""Unsupported buffer type for Float64: %d"", data.oid);
      throw std::runtime_error(""Unsupported buffer type for Float64: "" + std::to_string(data.oid));
  }
  
  OATPP_LOGD(""Deserializer"", ""Float64 value: %f"", value);
  return oatpp::Float64(value);
}

template<class IntWrapper>
oatpp::Void Deserializer::deserializeInt(const Deserializer* _this, const InData& data, const Type* type) {
  (void) _this;
  (void) type;

  if(data.isNull) {
    OATPP_LOGD(""Deserializer"", ""Int value is null"");
    return IntWrapper();
  }

  if (std::is_same<IntWrapper, oatpp::Int64>::value || std::is_same<IntWrapper, oatpp::UInt64>::value) {
    switch(data.oid) {
      case MYSQL_TYPE_LONGLONG: {
        if (data.bind->is_unsigned) {
          uint64_t value = *static_cast<uint64_t*>(data.bind->buffer);
          OATPP_LOGD(""Deserializer"", ""Unsigned Int64 value: %llu"", value);
          if (std::is_same<IntWrapper, oatpp::UInt64>::value) {
            return IntWrapper(value);
          } else {
            return IntWrapper(static_cast<int64_t>(value));
          }
        } else {
          int64_t value = *static_cast<int64_t*>(data.bind->buffer);
          OATPP_LOGD(""Deserializer"", ""Signed Int64 value: %lld"", value);
          if (std::is_same<IntWrapper, oatpp::UInt64>::value) {
            return IntWrapper(static_cast<uint64_t>(value));
          } else {
            return IntWrapper(value);
          }
        }
      }
      default: {
        auto value = deInt(data);
        if (std::is_same<IntWrapper, oatpp::UInt64>::value) {
          return IntWrapper(static_cast<uint64_t>(value));
        } else {
          return IntWrapper(value);
        }
      }
    }
  }

  auto value = deInt(data);
  return IntWrapper((typename IntWrapper::UnderlyingType) value);
}

// Explicit template instantiations
template oatpp::Void Deserializer::deserializeInt<oatpp::Int8>(const Deserializer* _this, const InData& data, const Type* type);
template oatpp::Void Deserializer::deserializeInt<oatpp::UInt8>(const Deserializer* _this, const InData& data, const Type* type);
template oatpp::Void Deserializer::deserializeInt<oatpp::Int16>(const Deserializer* _this, const InData& data, const Type* type);
template oatpp::Void Deserializer::deserializeInt<oatpp::UInt16>(const Deserializer* _this, const InData& data, const Type* type);
template oatpp::Void Deserializer::deserializeInt<oatpp::Int32>(const Deserializer* _this, const InData& data, const Type* type);
template oatpp::Void Deserializer::deserializeInt<oatpp::UInt32>(const Deserializer* _this, const InData& data, const Type* type);
template oatpp::Void Deserializer::deserializeInt<oatpp::Int64>(const Deserializer* _this, const InData& data, const Type* type);
template oatpp::Void Deserializer::deserializeInt<oatpp::UInt64>(const Deserializer* _this, const InData& data, const Type* type);

oatpp::Void Deserializer::deserializeBoolean(const Deserializer* _this, const InData& data, const Type* type) {
  (void) _this;
  (void) type;

  if(data.isNull) {
    OATPP_LOGD(""Deserializer"", ""Deserializing null boolean value"");
    return oatpp::Boolean();
  }

  switch(data.oid) {
    case MYSQL_TYPE_BIT: {
      uint64_t value = *static_cast<uint64_t*>(data.bind->buffer);
      OATPP_LOGD(""Deserializer"", ""Deserializing BIT value: %llu"", value);
      return oatpp::Boolean(value != 0);
    }
    case MYSQL_TYPE_TINY: {
      signed char value = *static_cast<signed char*>(data.bind->buffer);
      OATPP_LOGD(""Deserializer"", ""Deserializing boolean value: %d"", (int)value);
      return oatpp::Boolean(value != 0);
    }
    default:
      OATPP_LOGD(""Deserializer"", ""Unsupported buffer type: %d"", data.oid);
      throw std::runtime_error(""[oatpp::mariadb::mapping::Deserializer::deserializeBoolean()]: Error. Unsupported buffer type: "" + std::to_string(data.oid));
  }
}

oatpp::Void Deserializer::deserializeAny(const Deserializer* _this, const InData& inData, const Type* type) {

  (void) type;

  if(inData.isNull) {
    return oatpp::Void(Any::Class::getType());
  }

  const Type* valueType;

  switch(inData.oid) {
    case MYSQL_TYPE_TINY:
      if (inData.bind->is_unsigned) {
        auto value = *(static_cast<unsigned char*>(inData.bind->buffer));
        if (type == oatpp::Boolean::Class::getType()) {
          return oatpp::Boolean(value != 0);
        }
        return oatpp::UInt8(value);
      } else {
        auto value = *(static_cast<signed char*>(inData.bind->buffer));
        if (type == oatpp::Boolean::Class::getType()) {
          return oatpp::Boolean(value != 0);
        }
        return oatpp::Int8(value);
      }
    case MYSQL_TYPE_SHORT:
      valueType = oatpp::Int16::Class::getType();
      break;
    case MYSQL_TYPE_LONG:
      valueType = oatpp::Int32::Class::getType();
      break;
    case MYSQL_TYPE_LONGLONG:
      valueType = oatpp::Int64::Class::getType();
      break;
    case MYSQL_TYPE_FLOAT:
      valueType = oatpp::Float32::Class::getType();
      break;
    case MYSQL_TYPE_DOUBLE:
      valueType = oatpp::Float64::Class::getType();
      break;
    case MYSQL_TYPE_STRING:
      valueType = oatpp::String::Class::getType();
      break;
    case MYSQL_TYPE_BIT:
      if (type == oatpp::UInt64::Class::getType()) {
        return oatpp::UInt64(*static_cast<v_uint64*>(inData.bind->buffer));
      }
      valueType = oatpp::UInt64::Class::getType();
      break;
    default:
      throw std::runtime_error(""[oatpp::mariadb::mapping::Deserializer::deserializeAny()]: Error. Unknown OID."");
  }

  auto value = _this->deserialize(inData, valueType);
  auto  [MASK]  = std::make_shared<data::mapping::type::AnyHandle>(value.getPtr(), value.getValueType());
  return oatpp::Void( [MASK] , Any::Class::getType());

}

oatpp::Void Deserializer::deserializeEnum(const Deserializer* _this, const InData& data, const Type* type) {

  auto polymorphicDispatcher = static_cast<const data::mapping::type::__class::AbstractEnum::PolymorphicDispatcher*>(
    type->polymorphicDispatcher
  );

  data::mapping::type::EnumInterpreterError e = data::mapping::type::EnumInterpreterError::OK;
  const auto& value = _this->deserialize(data, polymorphicDispatcher->getInterpretationType());

  const auto& result = polymorphicDispatcher->fromInterpretation(value, e);

  if(e == data::mapping::type::EnumInterpreterError::OK) {
    return result;
  }

  switch(e) {
    case data::mapping::type::EnumInterpreterError::CONSTRAINT_NOT_NULL:
      throw std::runtime_error(""[oatpp::mariadb::mapping::Deserializer::deserializeEnum()]: Error. Enum constraint violated - 'NotNull'."");

    default:
      throw std::runtime_error(""[oatpp::mariadb::mapping::Deserializer::deserializeEnum()]: Error. Can't deserialize Enum."");
  }

}

}}}
",anyHandle
230,"// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0

#include <cassert>
#include <fstream>
#include <iostream>

#include ""Vtop_verilator__Syms.h""
#include ""ibex_pcounts.h""
#include ""ibex_demo_system.h""
#include ""verilated_toplevel.h""
#include ""verilator_memutil.h""
#include ""verilator_sim_ctrl.h""

DemoSystem::DemoSystem(const char *ram_hier_path, int  [MASK] )
    : _ram(ram_hier_path,  [MASK] , 4) {}

int DemoSystem::Main(int argc, char **argv) {
  bool exit_app;
  int ret_code = Setup(argc, argv, exit_app);

  if (exit_app) {
    return ret_code;
  }

  Run();

  if (!Finish()) {
    return 1;
  }

  return 0;
}

int DemoSystem::Setup(int argc, char **argv, bool &exit_app) {
  VerilatorSimCtrl &simctrl = VerilatorSimCtrl::GetInstance();

  simctrl.SetTop(&_top, &_top.clk_i, &_top.rst_ni,
                 VerilatorSimCtrlFlags::ResetPolarityNegative);

  _memutil.RegisterMemoryArea(""ram"", 0x0, &_ram);
  simctrl.RegisterExtension(&_memutil);

  exit_app = false;
  return simctrl.ParseCommandArgs(argc, argv, exit_app);
}

void DemoSystem::Run() {
  VerilatorSimCtrl &simctrl = VerilatorSimCtrl::GetInstance();

  std::cout << ""Simulation of Ibex Demo System"" << std::endl
            << ""=============================="" << std::endl
            << std::endl;

  simctrl.RunSimulation();
}

bool DemoSystem::Finish() {
  VerilatorSimCtrl &simctrl = VerilatorSimCtrl::GetInstance();

  if (!simctrl.WasSimulationSuccessful()) {
    return false;
  }

  // Set the scope to the root scope, the ibex_pcount_string function otherwise
  // doesn't know the scope itself. Could be moved to ibex_pcount_string, but
  // would require a way to set the scope name from here, similar to MemUtil.
  svSetScope(svGetScopeFromName(""TOP.top_verilator.u_ibex_demo_system""));

  std::cout << ""\nPerformance Counters"" << std::endl
            << ""===================="" << std::endl;
  std::cout << ibex_pcount_string(false);

  std::ofstream pcount_csv(""ibex_demo_system_pcount.csv"");
  pcount_csv << ibex_pcount_string(true);

  return true;
}
",ram_size_words
231,"#ifndef RKNNPOOL_H
#define RKNNPOOL_H

#include ""ThreadPool.hpp""
#include <iostream>
#include <memory>
#include <mutex>
#include <queue>
#include <vector>

// rknnModel模型类, inputType模型输入类型, outputType模型输出类型
template <typename rknnModel, typename inputType, typename outputType>
class rknnPool {
private:
  int id;
  std::mutex idMtx, queueMtx;
  std::unique_ptr<dpool::ThreadPool> pool;
  std::queue<std::future<outputType>> futs;
  std::vector<std::shared_ptr<rknnModel>> models;

protected:
  int getModelId();

public:
  int threadNum;
  std::string det_model_path;
  std::string pose_model_path;

  rknnPool(const std::string det_model_path, const std::string pose_model_path,
           int threadNum);
  int init();
  // 模型推理/Model inference
  int put(inputType inputData);
  // 获取推理结果/Get the results of your inference
  int get(outputType &outputData);
  ~rknnPool();
};

template <typename rknnModel, typename inputType, typename outputType>
rknnPool<rknnModel, inputType, outputType>::rknnPool(
    const std::string det_model_path, const std::string pose_model_path,
    int threadNum) {
  this->det_model_path = det_model_path;
  this->pose_model_path = pose_model_path;
  this->threadNum = threadNum;
  this->id = 0;
}

template <typename rknnModel, typename inputType, typename outputType>
int rknnPool<rknnModel, inputType, outputType>::init() {
  try {
    this->pool = std::make_unique<dpool::ThreadPool>(this->threadNum);
    for (int i = 0; i < this->threadNum; i++)
      models.push_back(std::make_shared<rknnModel>(this->det_model_path.c_str(),this->pose_model_path.c_str()));
  } catch (const std::bad_alloc &e) {
    std::cout << ""Out of memory: "" << e.what() << std::endl;
    return -1;
  }
  // 初始化模型/Initialize the model
  for (int i = 0, ret = 0; i < threadNum; i++) {
    ret = models[i]->init();
    if (ret != 0)
      return ret;
  }

  return 0;
}

template <typename rknnModel, typename inputType, typename outputType>
int rknnPool<rknnModel, inputType, outputType>::getModelId() {
  std::lock_guard<std::mutex> lock(idMtx);
  int  [MASK]  = id % threadNum;
  if (id == threadNum) {
    id = 0;
  }
  id++;
  return  [MASK] ;
}

template <typename rknnModel, typename inputType, typename outputType>
int rknnPool<rknnModel, inputType, outputType>::put(inputType inputData) {
  futs.push(
      pool->submit(&rknnModel::infer, models[this->getModelId()], inputData));
  return 0;
}

template <typename rknnModel, typename inputType, typename outputType>
int rknnPool<rknnModel, inputType, outputType>::get(outputType &outputData) {
  std::lock_guard<std::mutex> lock(queueMtx);
  if (futs.empty() == true)
    return 1;
  outputData = futs.front().get();
  futs.pop();
  return 0;
}

template <typename rknnModel, typename inputType, typename outputType>
rknnPool<rknnModel, inputType, outputType>::~rknnPool() {
  while (!futs.empty()) {
    outputType temp = futs.front().get();
    futs.pop();
  }
}

#endif",modelId
232,"#include ""SDL2_gfxPrimitives.h""
#include ""application_ui.h""
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <vector>

using namespace std;

#define EPSILON 0.0001f

struct Coords {
  int x, y;

  bool operator==(const Coords &other) const {
    return x == other.x and y == other.y;
  }
};
struct Polygone {
  std::vector<Coords> points;
};
struct Segment {
  Coords p1, p2;
};

struct Triangle {
  Coords p1, p2, p3;
  bool complet = false;
};

struct Vertex {
  Coords point;
  double angle;

  bool operator<(const Vertex &other) const { return angle < other.angle; }
};

struct Application {
  int width, height;
  Coords focus{100, 100};

  std::vector<Polygone> polygones;
  std::vector<Coords> points;
  std::vector<Triangle> triangles;
  std::vector<Segment> voronoiSeg;
};

// changement => trie par x
bool compareCoords(Coords point1, Coords point2) {
  // Si les points x sont égaux, alors on les distingue selon leur point y
  if (point1.x == point2.x)
    return point1.y < point2.y;

  return point1.x < point2.x;
}

// changement => trie par x
bool compareCoordsReverse(Coords point1, Coords point2) {
  // Si les points x sont égaux, alors on les distingue selon leur point y
  if (point1.x == point2.x)
    return point1.y < point2.y;

  return point1.x > point2.x;
}

/*
   Détermine si un point se trouve dans un cercle définit par trois points
   Retourne, par les paramètres, le centre et le rayon
*/
bool CircumCircle(float pX, float pY, float x1, float y1, float x2, float y2,
                  float x3, float y3, float *xc, float *yc, float *rsqr) {
  float m1, m2, mx1, mx2, my1, my2;
  float dx, dy, drsqr;
  float fabsy1y2 = fabs(y1 - y2);
  float fabsy2y3 = fabs(y2 - y3);

  /* Check for coincident points */
  if (fabsy1y2 < EPSILON && fabsy2y3 < EPSILON)
    return (false);

  if (fabsy1y2 < EPSILON) {
    m2 = -(x3 - x2) / (y3 - y2);
    mx2 = (x2 + x3) / 2.0;
    my2 = (y2 + y3) / 2.0;
    *xc = (x2 + x1) / 2.0;
    *yc = m2 * (*xc - mx2) + my2;
  } else if (fabsy2y3 < EPSILON) {
    m1 = -(x2 - x1) / (y2 - y1);
    mx1 = (x1 + x2) / 2.0;
    my1 = (y1 + y2) / 2.0;
    *xc = (x3 + x2) / 2.0;
    *yc = m1 * (*xc - mx1) + my1;
  } else {
    m1 = -(x2 - x1) / (y2 - y1);
    m2 = -(x3 - x2) / (y3 - y2);
    mx1 = (x1 + x2) / 2.0;
    mx2 = (x2 + x3) / 2.0;
    my1 = (y1 + y2) / 2.0;
    my2 = (y2 + y3) / 2.0;
    *xc = (m1 * mx1 - m2 * mx2 + my2 - my1) / (m1 - m2);
    if (fabsy1y2 > fabsy2y3) {
      *yc = m1 * (*xc - mx1) + my1;
    } else {
      *yc = m2 * (*xc - mx2) + my2;
    }
  }

  dx = x2 - *xc;
  dy = y2 - *yc;
  *rsqr = dx * dx + dy * dy;

  dx = pX - *xc;
  dy = pY - *yc;
  drsqr = dx * dx + dy * dy;

  return ((drsqr - *rsqr) <= EPSILON ? true : false);
}

void drawPoints(SDL_Renderer *renderer, const std::vector<Coords> &points) {
  for (std::size_t i = 0; i < points.size(); i++) {
    filledCircleRGBA(renderer, points[i].x, points[i].y, 3, 240, 240, 23,
                     SDL_ALPHA_OPAQUE);
  }
}

void drawSegments(SDL_Renderer *renderer,
                  const std::vector<Segment> &segments) {
  for (std::size_t i = 0; i < segments.size(); i++) {
    lineRGBA(renderer, segments[i].p1.x, segments[i].p1.y, segments[i].p2.x,
             segments[i].p2.y, 240, 240, 20, SDL_ALPHA_OPAQUE);
  }
}

void drawTriangles(SDL_Renderer *renderer,
                   const std::vector<Triangle> &triangles) {
  for (std::size_t i = 0; i < triangles.size(); i++) {
    const Triangle &t = triangles[i];
    trigonRGBA(renderer, t.p1.x, t.p1.y, t.p2.x, t.p2.y, t.p3.x, t.p3.y, 0, 240,
               160, SDL_ALPHA_OPAQUE);
  }
}

void drawCircles(SDL_Renderer *renderer,
                 const std::vector<Triangle> &triangles) {
  float xC, yC, rC;
  for (std::size_t i = 0; i < triangles.size(); i++) {
    const Triangle &t = triangles[i];
    CircumCircle(t.p1.x, t.p1.y, t.p1.x, t.p1.y, t.p2.x, t.p2.y, t.p3.x, t.p3.y,
                 &xC, &yC, &rC);
    circleRGBA(renderer, xC, yC, sqrt(rC), 30, 30, 30, SDL_ALPHA_OPAQUE);
  }
}

void drawCenterCircles(SDL_Renderer *renderer,
                       const std::vector<Triangle> &triangles) {
  float xC, yC, rC;
  for (std::size_t i = 0; i < triangles.size(); i++) {
    const Triangle &t = triangles[i];
    CircumCircle(t.p1.x, t.p1.y, t.p1.x, t.p1.y, t.p2.x, t.p2.y, t.p3.x, t.p3.y,
                 &xC, &yC, &rC);
    filledCircleRGBA(renderer, xC, yC, 3, 240, 23, 23, SDL_ALPHA_OPAQUE);
  }
}

void drawPolygones(SDL_Renderer *renderer,
                   const std::vector<Polygone> &polygones) {
  for (auto polygone : polygones) {
    std::vector<Coords> points = polygone.points;
    std::vector<Sint16> vx;
    std::vector<Sint16> vy;
    for (auto point : points) {
      vx.push_back(point.x);
      vy.push_back(point.y);
    }
  }
}

/* ********** D  R  A  W  ********** */

void drawVoronoi(Application &app) {

  float xCircle1, yCircle1, rCircle1, xCircle2, yCircle2,  [MASK] ;
  for (auto _triangle1 : app.triangles) {
    for (auto _triangle2 : app.triangles) {

      int _nb = 0;
      if (_triangle1.p1 == _triangle2.p1 || _triangle1.p1 == _triangle2.p2 ||
          _triangle1.p1 == _triangle2.p3) {
        _nb++;
      }
      if (_triangle1.p2 == _triangle2.p1 || _triangle1.p2 == _triangle2.p2 ||
          _triangle1.p2 == _triangle2.p3) {
        _nb++;
      }
      if (_triangle1.p3 == _triangle2.p1 || _triangle1.p3 == _triangle2.p2 ||
          _triangle1.p3 == _triangle2.p3) {
        _nb++;
      }

      if (_nb == 2) {
        CircumCircle(_triangle1.p1.x, _triangle1.p1.y, _triangle2.p1.x,
                     _triangle2.p1.y, _triangle2.p2.x, _triangle2.p2.y,
                     _triangle2.p3.x, _triangle2.p3.y, &xCircle1, &yCircle1,
                     &rCircle1);
        CircumCircle(_triangle2.p1.x, _triangle2.p1.y, _triangle1.p1.x,
                     _triangle1.p1.y, _triangle1.p2.x, _triangle1.p2.y,
                     _triangle1.p3.x, _triangle1.p3.y, &xCircle2, &yCircle2,
                     & [MASK] );

        Segment _segment = Segment{Coords{(int)xCircle1, (int)yCircle1},
                                   Coords{(int)xCircle2, (int)yCircle2}};

        bool seg = false;

        for (auto _s : app.voronoiSeg) {
          if (seg)
            break;
          seg = _segment.p1 == _s.p1 && _segment.p2 == _s.p2;
        }
        if (!seg)
          app.voronoiSeg.push_back(_segment);
      }
    }
  }
}

void draw(SDL_Renderer *renderer, Application &app) {
  /* Remplissez cette fonction pour faire l'affichage du jeu */
  int width, height;
  SDL_GetRendererOutputSize(renderer, &width, &height);

  drawPolygones(renderer, app.polygones);
  drawTriangles(renderer, app.triangles);
  drawPoints(renderer, app.points);
  drawSegments(renderer, app.voronoiSeg);
  drawVoronoi(app);
}

void construitVoronoi(Application &app) {
  //* --- Trier les points selon x ---*/
  std::sort(app.points.begin(), app.points.end(), compareCoords);

  printf(""\n\nAfter sorting vector : "");
  for (auto i = app.points.begin(); i < app.points.end(); i++) {
    cout << ""\n("" << i->x << "";"" << i->y << "")"" << endl;
  }

  //* --- Vider la liste existante de triangles ---*/
  app.triangles.clear();
  app.voronoiSeg.clear();
  app.polygones.clear();

  //* --- Créer un très grand triangle ---*/
  Triangle big =
      Triangle({Coords{-1000, -1000}, Coords{500, 3000}, Coords{1500, -1000}});
  // Le rajouter à la liste de triangles déjà créés
  app.triangles.push_back(big);

  //* --- pour chaque point P du repère --- */
  for (auto point : app.points) {
    // Créer une liste de segments LS
    std::vector<Segment> segments;

    //* --- chaque triangle T déjà créé --- */
    for (std::size_t t = 0; t < app.triangles.size(); t++) {
      Triangle _triangle = app.triangles[t];

      // si le cercle circonscrit contient le point P alors
      float xCircle, yCircle, rCircle;
      if (CircumCircle(point.x, point.y, _triangle.p1.x, _triangle.p1.y,
                       _triangle.p2.x, _triangle.p2.y, _triangle.p3.x,
                       _triangle.p3.y, &xCircle, &yCircle, &rCircle)) {
        // Récupérer les différents segments de ce triangles dans LS
        segments.push_back(Segment{_triangle.p1, _triangle.p2});
        segments.push_back(Segment{_triangle.p2, _triangle.p3});
        segments.push_back(Segment{_triangle.p3, _triangle.p1});

        // Effacer le triangle de la liste
        app.triangles.erase(app.triangles.begin() + t);
        t--;
      }
    }
    //* --- pour chaque segment S de la liste LS faire --- */
    for (std::size_t j = 0; j < segments.size(); j++) {
      Segment _segment1 = segments[j];

      for (std::size_t k = 0; k < segments.size(); k++) {
        Segment _segment2 = segments[k];
        // si un segment est un doublon d’un autre* alors
        if (k != j && _segment1.p1 == _segment2.p2 &&
            _segment1.p2 == _segment2.p1) {
          // On les enlève de la liste
          segments.erase(segments.begin() + k);
          segments.erase(segments.begin() + j);
          j--;
          break;
        }
      }
    }
    //* --- pour Pour chaque segment S de la liste LS faire --- */
    for (auto segment : segments) {
      // créer un nouveau triangle composé du segment S et du point P
      app.triangles.push_back(Triangle({segment.p1, segment.p2, point}));
    }
  }
}

bool handleEvent(Application &app) {
  /* Remplissez cette fonction pour gérer les inputs utilisateurs */
  SDL_Event e;
  while (SDL_PollEvent(&e)) {
    if (e.type == SDL_QUIT)
      return false;
    else if (e.type == SDL_WINDOWEVENT_RESIZED) {
      app.width = e.window.data1;
      app.height = e.window.data1;
    } else if (e.type == SDL_MOUSEWHEEL) {
    } else if (e.type == SDL_MOUSEBUTTONUP) {
      if (e.button.button == SDL_BUTTON_RIGHT) {
        app.focus.x = e.button.x;
        app.focus.y = e.button.y;
        app.points.clear();
      } else if (e.button.button == SDL_BUTTON_LEFT) {
        app.focus.y = 0;
        // Création de points
        app.points.push_back(Coords{e.button.x, e.button.y});
        construitVoronoi(app);
      }
    }
  }
  return true;
}

int main(int argc, char **argv) {
  SDL_Window *gWindow;
  SDL_Renderer *renderer;
  Application app{720, 720, Coords{0, 0}};
  bool is_running = true;

  // Creation de la fenetre
  gWindow = init(""Awesome Voronoi"", 720, 720);

  if (!gWindow) {
    SDL_Log(""Failed to initialize!\n"");
    exit(1);
  }

  renderer = SDL_CreateRenderer(gWindow, -1, 0); // SDL_RENDERER_PRESENTVSYNC

  /* **********  G A M E   L O O P ********** */
  while (true) {
    // INPUTS
    is_running = handleEvent(app);
    if (!is_running)
      break;

    // EFFACAGE FRAME
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);

    // DESSIN
    draw(renderer, app);

    // VALIDATION FRAME
    SDL_RenderPresent(renderer);

    // PAUSE en ms
    SDL_Delay(1000 / 30);
  }

  // Free resources and close SDL
  close(gWindow, renderer);

  return 0;
}",rCircle2
233,"// Copyright 2016-2018 California Institute of Technology.
//
// 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.

//
// Created by dfremont on 6/20/17.
//

#include ""ConcolicTest.h""

#include ""llvm/Support/raw_ostream.h""

using namespace llvm;
using namespace klee;

unsigned ConcolicTest::nextTestID = 0;

void ConcolicTest::dump() const {
  llvm::errs() << ""gen "" << generation << "", score "" << newBlocks << "", rep "" << isReplacement << "", "" << objects.size()
               << "" objects: \n"";
  for (const ConcolicTestObject &obj : objects) {
    llvm::errs() << ""  "" << obj.name << "": "";
    for (unsigned i = 0; i < obj.bytes->size; i++)
      llvm::errs() << (int) obj.bytes->bytes[i] << "" "";
    llvm::errs() << ""\n"";
  }
  llvm::errs() << "" path: "";
  for (bool b : expectedPath)
    llvm::errs() << (int) b;
  llvm::errs() << ""\n"";
}

static void *interpretAsPointer(const ConcolicTestObject &obj) {
  assert(obj.bytes->size == sizeof(void *) && ""object does not have pointer size!"");
  return *reinterpret_cast<void **>(obj.bytes->bytes);
}

void ConcolicTest::dumpArgs() const {
  if (objects.size() < 2)
    return;
  if (*objects[0].name != ""n_args"")
    return;
  if (*objects[1].name != ""arg0"")
    return;

  unsigned *addr = static_cast<unsigned *>(interpretAsPointer(objects[0]));
  unsigned  [MASK]  = *addr;
  for (unsigned i = 0; i <  [MASK] ; i++) {
    char *saddr = static_cast<char *>(interpretAsPointer(objects[i + 1]));
    llvm::errs() << ""\"""" << std::string(saddr) << ""\"" "";
  }
}
",nargs
234,"#include <esp_now.h>
#include <WiFi.h>

// Define data structure for gauge readings
typedef struct __attribute__((packed)) {
  uint32_t timestamp;
  uint16_t rpm;
  uint16_t speed;
  uint16_t coolantTemp;
  uint16_t oilPressure;
  uint16_t fuelLevel;
  uint16_t batteryVoltage;
  uint16_t boostPressure;
  uint8_t checkEngine;
  uint8_t turnSignals;
} DashboardData_t;

// MAC address of your child gauge (actual MAC you found)
uint8_t childGaugeAddresses[][6] = {
  {0x18, 0x8B, 0x0E, 0xCD, 0x06, 0x48}  // Your first child gauge
  // Add more child gauges here as you get their MAC addresses
};

// Number of child gauges
const int NUM_GAUGES = sizeof(childGaugeAddresses) / sizeof(childGaugeAddresses[0]);

// Variables to track transmission success
int successCount = 0;
int failCount = 0;
unsigned long lastStatsTime = 0;

// Dashboard data structure
DashboardData_t dashboardData;

// Timing variables
unsigned long lastBroadcastTime = 0;
const int BROADCAST_INTERVAL = 500;  // Broadcast every 50ms (20Hz update rate)

// Callback function called when data is sent
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  if (status == ESP_NOW_SEND_SUCCESS) {
    successCount++;
  } else {
    failCount++;
  }
  
  // Print stats every 5 seconds
  unsigned long currentTime = millis();
  if (currentTime - lastStatsTime >= 5000) {
    lastStatsTime = currentTime;
    
    int totalAttempts = successCount + failCount;
    float successRate = (totalAttempts > 0) ? (successCount * 100.0 / totalAttempts) : 0;
    
    Serial.print(""ESP-NOW Stats - Success: "");
    Serial.print(successCount);
    Serial.print("", Fails: "");
    Serial.print(failCount);
    Serial.print("", Success Rate: "");
    Serial.print(successRate);
    Serial.println(""%"");
    
    // Reset counters
    successCount = 0;
    failCount = 0;
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  Serial.println(""\nCentral Dashboard Hub"");
  Serial.println(""--------------------"");
  
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);
  
  // Print MAC address
  Serial.print(""Hub MAC Address: "");
  Serial.println(WiFi.macAddress());
  
  // Initialize ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println(""Error initializing ESP-NOW"");
    return;
  }
  
  // Register the send callback
  esp_now_register_send_cb(OnDataSent);
  
  // Register all child gauges as peers
  esp_now_peer_info_t  [MASK] ;
  memset(& [MASK] , 0, sizeof( [MASK] ));
   [MASK] .channel = 0;  // Use WiFi channel 0 (auto)
   [MASK] .encrypt = false;  // No encryption
  
  // Register each gauge as a peer
  for (int i = 0; i < NUM_GAUGES; i++) {
    memcpy( [MASK] .peer_addr, childGaugeAddresses[i], 6);
    if (esp_now_add_peer(& [MASK] ) != ESP_OK) {
      Serial.print(""Failed to add peer: "");
      Serial.println(i);
    } else {
      Serial.print(""Added peer gauge: "");
      for (int j = 0; j < 6; j++) {
        Serial.printf(""%02X"", childGaugeAddresses[i][j]);
        if (j < 5) Serial.print("":"");
      }
      Serial.println();
    }
  }
  
  // Initialize CAN bus communication
  // setupCAN(); // Uncomment and implement when ready for CAN integration
  
  Serial.println(""Central hub initialized and ready!"");
}

void loop() {
  // Read data from CAN bus (actual implementation would read from CAN)
  // readCANData(); // Uncomment and implement when ready
  
  // For testing, generate some sample data
  updateDashboardData();
  
  // Broadcast data at specified interval
  unsigned long currentTime = millis();
  if (currentTime - lastBroadcastTime >= BROADCAST_INTERVAL) {
    lastBroadcastTime = currentTime;
    broadcastDashboardData();
  }
}

void updateDashboardData() {
  // In a real implementation, this would read from CAN bus
  // For testing, we'll generate sample data
  dashboardData.timestamp = 0;
  dashboardData.rpm = 0;
  dashboardData.speed = 0;
  dashboardData.coolantTemp = random(55, 87);
  dashboardData.oilPressure = 0;
  dashboardData.fuelLevel = 0;
  dashboardData.batteryVoltage = 0; // In tenths of a volt (12.0 - 14.5V)
  dashboardData.boostPressure = 0;  // In PSI, negative for vacuum
  dashboardData.checkEngine = 0; // Occasionally turn on check engine light
  dashboardData.turnSignals = 0;  // Random turn signal state
}

void broadcastDashboardData() {
  // Send data to each gauge
  for (int i = 0; i < NUM_GAUGES; i++) {
    esp_err_t result = esp_now_send(childGaugeAddresses[i], (uint8_t *)&dashboardData, sizeof(dashboardData));
    
    if (result != ESP_OK) {
      Serial.print(""Failed to send to gauge: "");
      Serial.println(i);
    }
  }
}
",peerInfo
235,"//-------Source Code for Course Registration System-------//
/* Created by
	<NAME>
*/
#include<iostream>
#include<cstdlib>
#include<fstream>
#include<cstring>
#include<conio.h>
#include<windows.h>
using namespace std;
//Function declarations
class CourseRegistration{
	char name[50],fname[50],username[20],password[20],password1[20],course[50],email[50],mob[11],address[100],hper[5],iper[5];
	fstream file;
	public:
		void Register();
		void Login();
		void MainMenu();
};
//Driver-function
int main(){
	system(""color F4"");
	CourseRegistration  [MASK] ;
	 [MASK] .MainMenu();
	
}
//For register
void CourseRegistration:: Register(){
	
	cout<<""---------------------------Register---------------------------\n\n"";
	cout<<""Enter your name: "";
	fflush(stdin);
	gets(name);
	cout<<""Enter your father's name: "";
	fflush(stdin);
	gets(fname);
	cout<<""Enter your email id: "";
	fflush(stdin);
	gets(email);
	cout<<""Enter your contact number: "";
	fflush(stdin);
	gets(mob);
	cout<<""Enter your address: "";
	fflush(stdin);
	gets(address);
	cout<<""Enter your High School percentage: "";
	cin>>hper;
	cout<<""Enter your Intermediate percentage: "";
	cin>>iper;
	cout<<""\nSelect your course choice:\n\n"";
	cout<<""1.Civil Engineering\n"";
	cout<<""2.Computer Science and Engineering\n"";
	cout<<""3.Electrical Engineering\n"";
	cout<<""4.Electronics and Communiction Engineering\n"";
	cout<<""5.Mechanical Enginering\n"";
	cout<<""6.Chemical Engineering\n"";
	int choice;
	do{
		cin.clear();
		fflush(stdin);
	cin>>choice;
	switch(choice){
		case 1:
			cout<<""Your selected choice is: "";
			cout<<""Civil Engineering\n"";
			strcpy(course,""Civil Engineering"");break;
		case 2:
			cout<<""Your selected choice is: "";
			cout<<""Computer Science and Engineering\n"";
			strcpy(course,""Computer Science and Engineering"");break;
		case 3:
			cout<<""Your selected choice is: "";
			cout<<""Electrical Engineering\n"";
			strcpy(course,""Electrical Engineering"");break;
		case 4:
			cout<<""Your selected choice is: "";
			cout<<""Electronics and Communiction Engineering\n"";
			strcpy(course,""Electronics and Communiction Engineering"");break;
		case 5:
			cout<<""Your selected choice is: "";
			cout<<""Mechanical Enginering\n"";
			strcpy(course,""Mechanical Enginering"");break;
		case 6:
			cout<<""Your selected choice is: "";
			cout<<""Chemical Engineering\n"";
			strcpy(course,""Chemical Engineering"");break;
		default:
			cout<<""Invalid choice,try again\n"";
		}
	}while(choice>6||choice<1);
	while(1){
	cout<<""Enter your username: "";
	cin>>username;
	file.open(username);
	if(file){
		cout<<""Username already exist,try different\n\n"";
		file.close();
	}
	else{
		file.close();break;
	}
	}
	while(1){
		char ch;int i=0;
	cout<<""Enter your password: "";
	ch=getch();
	while(ch!=13){
	password[i++]=ch;
	cout<<""*"";
	ch=getch();
	}password[i]='\0';i=0;
	cout<<endl;
	cout<<""Re-enter your password: "";
	ch=getch();
	while(ch!=13){
	password1[i++]=ch;
	cout<<""*"";
	ch=getch();
	}password1[i]='\0';
	cout<<endl;
	if(strcmp(password,password1)==0)
		break;
	cout<<""Password mismatched,try again\n"";
	}
	file.open(username,ios::out);
	file<<""Name: ""<<name<<endl;
	file<<""Father's name: ""<<fname<<endl;
	file<<""Course name: ""<<course<<endl;
	file<<""Email: ""<<email<<endl;
	file<<""Contact: ""<<mob<<endl;
	file<<""Address: ""<<address<<endl;
	file<<""High School percentage: ""<<hper<<endl;
	file<<""Intermediate percentage: ""<<iper<<endl;
	file.close();
	file.open(""data"",ios::app);
	file<<username<<"" "";
	file<<password<<"" "";
	file.close();
	cout<<""\n\nRegistered successfully\n\n\n"";
	cout<<""---------------------------------\n"";
	cout<<""Press any key for main menu . . . \n"";
			getch();
			system(""cls"");
			MainMenu();
	
}
//For login
void CourseRegistration:: Login(){
	char username[20],password[20],ch;
	int i=0;
	cout<<""---------------------------Login---------------------------\n\n"";
	cout<<""Enter username: "";
	cin>>username;
	cout<<""Enter password: "";
	ch=getch();
	while(ch!=13){
	password[i++]=ch;
	cout<<""*"";
	ch=getch();
	}i=0;
	cout<<endl;
	ifstream file(""data"");
	if(!file){
		cout<<""Data not found\n"";
		exit(0);	
	}
	char s1[20],s2[20],temp=1;
	while(!file.eof()){
		file>>s1;file>>s2;
		if((strcmp(username,s1)==0)&&(strcmp(password,s2)==0)){temp=0;
			file.close();
			system(""cls"");
			ifstream f1(username);
			char ch;
			f1.get(ch);
			while(!f1.eof()){
				cout<<ch;
				f1.get(ch);	
			}f1.close();
			cout<<""\n\n\n---------------------------------\n"";
			cout<<""Press any key for main menu . . . \n"";
			getch();
			system(""cls"");
			MainMenu();
			getch();break;
		}
	}if(temp)
		{
			cout<<""\nInvalid username/password\n\n\n"";
			file.close();
			cout<<""---------------------------------\n"";
			cout<<""Press any key for main menu . . . \n"";
			getch();
			system(""cls"");
			MainMenu();
		}
	
}
//Front page(main menu) of program
void CourseRegistration:: MainMenu(){
	cout<<""---------------------------Main Menu---------------------------\n\n"";
	cout<<""Enter your option:\n"";
	cout<<""1.Register\n2.Login\n3.Exit\n\n"";
	char ch;
	cin>>ch;
	system(""cls"");
	switch(ch){
		case '1':
			Register(); break;
		case '2':
			Login(); break;
		case '3':
			exit(0);break;
		default:
			cout<<""Invalid option,try again\n\n"";
			MainMenu();
	}
}
",obj
236,"#ifndef INCLUDED_HH_LRU_CACHE_HPP
#define INCLUDED_HH_LRU_CACHE_HPP
#include <experimental/iterator>
#include <functional>
#include <hh/hash.hpp>
#include <hh/optional.hpp>
#include <list>
#include <mutex>
#include <tl/expected.hpp>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <utility>

namespace hh {
  namespace functools {

    /**
     * Functional-style lru-cache which either calls the function from cache or returns a previouly
     * attained value.
     *
     * The cache is initialised with a specific size and only the most-recently used N argument
     * tuples will be recorded. After the size paramter exceeds the maximum allowed size previous
     * tuples return values will be dropped. Providing a max size of zero makes the cache size
     * infinite, and can retain cached values as long as memory is available. The underlying
     * implementation is based on hastaples to look up the hashed parmaeter tuples which have been
     * used to call the function, for this reason all types in the argument list for the underlying
     * function must implement the std::hash<T> specialisation and all for equality comparison.
     *
     * @see std::hash()
     * @see make_lrucache
     * @tparam RETURN_TYPE The return type of the function used to instantiate this cache.
     * @tparams ARGUMENTS... Paramter Pack of types which this function declares in its signature.
     */
    template <typename RETURN_TYPE, typename... ARGUMENTS> class lru_cache {
    public:
      static constexpr std::size_t key_size = sizeof...(ARGUMENTS);
      using return_type = RETURN_TYPE; /** The return type of this cache.*/
      using decayed_return_type
          = std::decay_t<RETURN_TYPE>; /** The decayed returned type of this cache. */
      using cache_key
          = std::tuple<std::decay_t<ARGUMENTS>...>; /** The tuple type used to key return values.
                                                       Two equal cache keys should return equal
                                                       return values. */
      using cache_entry
          = std::pair<cache_key,
                      decayed_return_type>; /** The entry in the cache implementation. The decayed
                                               type is used to prevent naught reference tricks. */
      using function_signature = std::function<RETURN_TYPE(ARGUMENTS...)>;

      function_signature d_func;
      unsigned int d_max_size;
      mutable std::list<cache_entry> d_cache;
      mutable std::unordered_map<cache_key, typename decltype(d_cache)::iterator> d_cache_map;

      lru_cache() = delete;
      /**
       * Constructs a cache with a given function and size.
       *
       * @see make_lrucache()
       * @param func The underlying function which will be used to populate the cache on call.
       * @param cache_size The maximum size of the underlying cache.
       */
      constexpr lru_cache(RETURN_TYPE (*func)(ARGUMENTS...), unsigned int cache_size)
          : d_func{func}, d_max_size{cache_size}, d_cache{}, d_cache_map{cache_size} {}
      /**
       * Constructs a cache with a given function and size.
       *
       * @see make_lrucache()
       * @param func The underlying function which will be used to populate the cache on call.
       * @param cache_size The maximum size of the underlying cache.
       */
      constexpr lru_cache(function_signature func, unsigned int cache_size)
          : d_func{func}, d_max_size{cache_size}, d_cache{}, d_cache_map{cache_size} {}
      virtual ~lru_cache() = default;

      /**
       * Calls the underlying function or returns historic value.
       *
       * Will first check to see if the tuple has been calculated previously, to do this is requires
       * us to hash the arguments and call an equality of cache keys. This can have performance
       * implications for functions which have very long argument lists where this operation is more
       * expensive than calling the underlying function.
       *
       * @see lru_cache()
       * @tparam INPUT_ARGUMENTS A collection of arguments which should be convertibale to the
       * cachekey of the underlying. A static assertion checks this property.
       * @params args The arguments to call the function with, arguments are perfectly forwarded to
       * the underlying signature of the function this cache was initialised with. Implicitly
       * converting arguments as required.
       */
      template <typename... INPUT_ARGUMENTS> RETURN_TYPE operator()(INPUT_ARGUMENTS&&... args) {
        cache_key key{std::forward<INPUT_ARGUMENTS>(args)...};
        get_entry_from_cache(key)
            .map([this](const auto& entry_it) { d_cache.splice(d_cache.end(), d_cache, entry_it); })
            .map_error(
                [this, &key](...) { put_in_cache(std::move(key), std::apply(d_func, key)); });
        return d_cache.back().second;
      }

      /** The maximum number of entries this cache can store. If 0 an infinite number of values can
       * be stored. */
      constexpr auto max_size() const { return d_max_size; }

      /** The current number of retained historic values */
      auto size() const { return d_cache_map.size(); }

    private:
      struct unexpected_tag {};

      hh::optional<typename decltype(d_cache)::iterator> get_entry_from_cache(
          const cache_key& key) const {
        auto  [MASK]  = d_cache_map.find(key);
        if ( [MASK]  == d_cache_map.end()) {
          return hh::nullopt;
        }
        return  [MASK] ->second;
      }

      template <typename... ARGS>
      tl::expected<void, unexpected_tag> put_in_cache(cache_key&& key,
                                                      decayed_return_type&& return_value) const {
        d_cache.emplace_back(std::move(key), std::move(return_value));
        d_cache_map[key] = std::prev(d_cache.end());
        if (max_size() != 0 && size() > max_size()) {
          d_cache_map.erase(d_cache.front().first);
          d_cache.pop_front();
        }
        return {};
      }
    };

    constexpr static auto DEFAULT_SIZE = 128u;

    template <typename RETURN_TYPE, typename... ARGUMENTS>
    constexpr auto make_lrucache(std::function<RETURN_TYPE(ARGUMENTS...)> func,
                                 unsigned int size = DEFAULT_SIZE) {
      return lru_cache<RETURN_TYPE, ARGUMENTS...>(func, size);
    }
    template <typename RETURN_TYPE, typename... ARGUMENTS>
    constexpr auto make_lrucache(RETURN_TYPE (*func)(ARGUMENTS...),
                                 unsigned int size = DEFAULT_SIZE) {
      return lru_cache<RETURN_TYPE, ARGUMENTS...>(func, size);
    }

    template <class Ch, class Tr, class Tuple, std::size_t... Is> void print_tuple_impl(
        std::basic_ostream<Ch, Tr>& os, const Tuple& t,
        std::index_sequence<Is...> = std::make_index_sequence<std::tuple_size<Tuple>::value>()) {
      ((os << (Is == 0 ? """" : "", "") << std::get<Is>(t)), ...);
    }

    template <typename RETURN_TYPE, typename... ARGUMENTS> inline std::ostream& operator<<(
        std::ostream& os, const typename lru_cache<RETURN_TYPE, ARGUMENTS...>::cache_key& key) {
      os << ""("";
      print_tuple_impl(os, key);
      os << "")"";
      return os;
    }

    template <typename RETURN_TYPE, typename... ARGUMENTS> inline std::ostream& operator<<(
        std::ostream& os, const typename lru_cache<RETURN_TYPE, ARGUMENTS...>::cache_entry& entry) {
      os << entry.first << "" -> "" << entry.second;
      return os;
    }

    /**
     * Helper function to print the contents of the cache, used for debugging purposes. This
     * operation can be expensive so should not be used in production code.
     *
     * @see make_lrucache()
     * @param os The output strem to stream the cache into.
     * @param cache The cache to output to the given stream.
     * @tparam RETURN_TYPE The return type of the cache.
     * @tparam ARGUMENTS... The arguments that are used to construct the cache keys.
     */
    template <typename RETURN_TYPE, typename... ARGUMENTS>
    inline std::ostream& operator<<(std::ostream& os,
                                    const lru_cache<RETURN_TYPE, ARGUMENTS...>& cache) {
      os << ""lru_cache<"" << cache.size() << ""/"" << cache.max_size() << "">[ "";
      std::copy(cache.d_cache.begin(), cache.d_cache.end(),
                std::experimental::make_ostream_joiner(os, "", ""));
      os << "" ]"";
      return os;
    }
  }  // namespace functools

}  // namespace hh
#endif
",found_it
237,"/* Copyright (c) 2021 International Business Machines Corporation
   Prepared by: <NAME> <<EMAIL>>

   This program finds clusters of near-duplicate files of source code.
   The clusters do not overlap; each input sample is either assigned to a
   unique cluster or is declared to be a singleton set.

   Input format is lines of tokenized source file data. Each line is:
     <unique id (e.g. full filename path)> TAB <list of tokens>
   The list of tokens is never empty and tokens are either separated by
   solely SPACES or solely TABs.
     <token> ( SP <token> )*, or
     <token> ( TAB <token> )*
   (Also, all comments have been removed.)

   All token strings across all samples are collected in a vocabulary.
   That way all strings are stored only once and are associated with
   a unique index (counted from 0). All further processing can be done
   with the index; Jaccard similarity and LCS do not need the strings.
   The inverse relation is stored in the vector tokid2string.

   Per sample, the tokens are first inserted in an unordered_map keyed
   by the token id and recording a list of all positions for this token.
   Clearly, the length of this list per token is the token frequency.
   Then this dictionary is copied into a vector and sorted by the keys.
   Since we don't need the positions per token, this vector is split in
   a token_bag recording just the frequency and a token_seq.

   This way we have with minimal memory use represented the original sample
   both as a sequence of tokens (token_seq) and as a multiset (token_bag).
   The bag of token representation can be seen as a sparse feature vector:
   A feature is a vocabulary index and it either does not occur in a sample
   or it does occur with a certain recorded frequency. Having the bag ordered
   by index eases the computation of metrics like Jaccard and dot-product.

   Be careful to keep results deterministic. Using unordered_map for ids
   does not obey order of insertion of course, but depends on some hash
   function.

   All samples are in memory.
*/

#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>		// sqrt()
#include <unistd.h>		// getopt()
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>

static int debug = 0;		 // when 1 debug output to stderr
static int verbose = 0;		 // when 1 info output to stderr
static int nowarn = 0;		 // when 1 warnings are suppressed
static int csv_summary = 0;	 // when 1 output in CSV format
static int out_singles = 0;	 // when 1 output singletons as well
static unsigned num_tokens_threshold = 20;
static unsigned num_samples_discarded = 0;
static double threshold_0 = 0.9; // Jaccard, LCS, COSINE
static double threshold_1 = 0.8; // Jaccard
static enum { JACCARD, LCS, COSINE } mode = JACCARD;
static const char *delim = "" "";
static const char *filename = ""stdin"";

using namespace std;

// Original input token sequence:
typedef vector<unsigned> TokenSeq;
// Single element of TokenBag:
typedef pair<unsigned, unsigned> TokenFreq;
// (Arbitrarily) sorted sequence of tokens in order to compare them:
typedef vector<TokenFreq> TokenBag;
// Pair of doubles:
typedef pair<double, double> Double2;

// all strings
static unordered_map<string, unsigned> vocabulary;
//static vector<string> tokid2string; NOT USED

struct Sample {
  string id;
  TokenSeq token_seq;
  TokenBag token_bag;
  bool flag;

  Sample(const string &id) : id(id), flag(false) {}

  // Sample size equals length of token sequence.
  unsigned size() const {
    return token_seq.size();
  }

#if 0
  // NOT USED
  void show(FILE *fp = stderr) const {
    fputs(""tokens:"", fp);
    for (auto k : token_seq)
      fprintf(fp, "" %s"", tokid2string[k].c_str());
    fputc('\n', fp);
  }
#endif
};

// all samples
static unordered_set<string> all_ids;
static vector<Sample> samples; // in order of input

/* Split tokens and determine number of occurrences and store as
   vectors under id in global samples.
*/
static void process_sample(const char *id, char *tokens)
{
  // Verify uniqueness of id:
  if (all_ids.find(id) != all_ids.end()) {
    if (!nowarn)
      fprintf(stderr, ""(W): Non-unique id %s; sample discarded.\n"", id);
    return;
  }

  Sample s(id);
  unsigned num_tokens = 0;
  // Per token instance string record all its positions:
  typedef vector<unsigned> Positions;
  typedef pair<unsigned, Positions> TokenPos;
  unordered_map<unsigned, Positions> dict;

  // Split the tokens:
#if 1
  char *p = tokens;
  do {
    const char *token = p;
    while (*p && *p != *delim)
      p++;
    // Here: *p == '\0' || *p == delim
    if (token == p) // empty token
      break;
    if (*p == *delim)
      *p++ = '\0';
    //use token:

    unsigned token_id; // unique id for token string
    // Uniquely store all token strings in global vocabulary:
    auto it = vocabulary.find(token);
    if (it == vocabulary.end()) { // a fresh one
      token_id = vocabulary.size();
      vocabulary[token] = token_id;
      //tokid2string.push_back(token); NOT USED
    }
    else
      token_id = it->second;
    // Locally store all positions for this token:
    dict[token_id].push_back(num_tokens); // size of second is frequency
    num_tokens++;

  } while (true);

#else
  // strtok is slow
  const char *token = strtok(tokens, delim);
  while (token) {
    unsigned token_id; // unique id for token string
    // Uniquely store all token strings in global vocabulary:
    auto it = vocabulary.find(token);
    if (it == vocabulary.end()) { // a fresh one
      token_id = vocabulary.size();
      vocabulary[token] = token_id;
      //tokid2string.push_back(token); NOT USED
    }
    else
      token_id = it->second;
    // Locally store all positions for this token:
    dict[token_id].push_back(num_tokens); // size of second is frequency
    num_tokens++;
    token = strtok(NULL, delim);
  }
#endif
  // In Allamanis paper this is number of identifier tokens.
  // Hard to tell from a token list (of unknown language).
  if (num_tokens < num_tokens_threshold) {
    num_samples_discarded++;
    if (!nowarn)
      fprintf(stderr, ""(W): Sample %s has less than %u tokens; discarded.\n"",
	      id, num_tokens_threshold);
    return;
  }

  // Should we normalize the frequencies? Don't think so.

  // Convert dict to vector (order does not matter):
  vector<TokenPos> vec;
  for (const auto &t : dict)
    vec.emplace_back(t);

  // Sort by token id:
  sort(vec.begin(), vec.end(),
       [](const TokenPos &a, const TokenPos &b)
       { return a.first < b.first; });

  // Fill in token_bag and token_seq:
  s.token_seq.resize(num_tokens);
  s.token_bag.resize(vec.size());
  for (unsigned i = 0, size = vec.size(); i < size; i++) {
    unsigned token_id = vec[i].first;
    // Stuff token id and frequency in bag (multiset):
    s.token_bag[i] = {token_id, vec[i].second.size()};
    // Put token_id in all the required positions:
    for (auto p : vec[i].second)
      s.token_seq[p] = token_id;
  }

  samples.emplace_back(s);
}

/* Longest Common Subsequence (LCS) (not necessarily consecutive)
   Simplified. O(mn) time, O(n) space.
*/
static unsigned lcs(const TokenSeq &X, const TokenSeq &Y,
		    const unsigned m, const unsigned n)
{
  // Here: m,n >= 0.
  unsigned L[2][n+1]; // small 2 by n+1 matrix
  unsigned bi; // odd(i)

  // 0-th row and 0-th column contains all zeroes:
  for (unsigned j = 0; j<=n; j++) // at least once
    L[0][j] = 0;
  L[1][0] = 0;

  for (unsigned i = 1; i<=m; i++) { // at least once
    bi = i & 1;
    for (unsigned j = 1; j<=n; j++) // at least once
      if (X[i-1] == Y[j-1])
	L[bi][j] = L[1-bi][j-1] + 1;
      else
	L[bi][j] = max(L[1-bi][j], L[bi][j-1]);
    // After seeing i elems: L[bi][n] <= i is actual length; i is upperbound.
    // i - L[bi][n] is # different elements; might only get larger (1 per row)
    //cerr << ""L["" << i << ""][n]: "" << L[bi][n] << endl;
    //if (L[bi][n] >= mincommon) break;
  }
  /* L[m][n] contains length of LCS for X[0..n-1] and Y[0..m-1] */
  return L[bi][n];
}

// An upperbound for the length of an LCS.
static unsigned lcs_upperbound(const TokenBag &t1, const TokenBag &t2)
{
  unsigned share_1 = 0;	// card. of intersection considering multiplicity

  // Lock-step traversal of the 2 vectors:
  auto it1 = t1.cbegin();
  auto it2 = t2.cbegin();
  auto t1_cend = t1.cend();
  auto t2_cend = t2.cend();

  while (it1 != t1_cend && it2 != t2_cend) {
    if (it1->first < it2->first)
      ++it1;
    else
    if (it1->first > it2->first)
      ++it2;
    else { // intersection
      share_1 += it1->second < it2->second ? it1->second : it2->second;
      ++it1; ++it2;
    }
  }
  return share_1;
}

/* Compute cosine similarity of 2 multisets.
*/
static double cosine(const TokenBag &t1, const TokenBag &t2)
{
  double dot = 0.0;
  double norm1 = 0.0;
  double norm2 = 0.0;

  // Lock-step traversal of the 2 vectors:
  auto it1 = t1.cbegin();
  auto it2 = t2.cbegin();
  auto t1_cend = t1.cend();
  auto t2_cend = t2.cend();

  // Feature value is the frequency.
  while (it1 != t1_cend && it2 != t2_cend) {
    // For normalization:
    norm1 += it1->second * it1->second;
    norm2 += it2->second * it2->second;

    if (it1->first < it2->first)
      ++it1;
    else
    if (it1->first > it2->first)
      ++it2;
    else { // intersection of features
      dot += it1->second * it2->second;
      ++it1; ++it2;
    }
  }
  // Handle leftover tails:
  for (; it1 != t1_cend; ++it1)
    norm1 += it1->second * it1->second;
  for (; it2 != t2_cend; ++it2)
    norm2 += it2->second * it2->second;

  return dot / sqrt(norm1 * norm2);
}

/* Compute Jaccard similarity of 2 multisets, both with ignoring an
   element's multiplicity and with considering it. The first case of
   course equals to assuming an overall multiplicity of 1.
   Returns a pair of numbers.
*/
static Double2 jaccard(const TokenBag &t1, const TokenBag &t2)
{
  unsigned share_0 = 0;	// card. of intersection ignoring multiplicity
  unsigned total_0 = 0;	// card. of union ignoring multiplicity
  unsigned share_1 = 0;	// card. of intersection considering multiplicity
  unsigned total_1 = 0;	// card. of union considering multiplicity

  /* Example:
     A   = 1 1 2   3 3 3 4 4 5    | 1 2 3 4 5   |  9 | 5
     B   =     2 2 3 3 3 4     6  |   2 3 4   6 |  7 | 4
     ---------------------------------------------------
     A*B =     2   3 3 3 4        |   2 3 4     |  5 | 3
     A+B=  1 1 2 2 3 3 3 4 4 5 6  | 1 2 3 4 5 6 | 11 | 6

     share_0 = 3, total_0 =  6, share_0/total_0 = 0.5
     share_1 = 5, total_1 = 11, share_1/total_1 = 0.45
     (of course _0 and _1 the same when multiplicity is 1 overall)

     Note: result numbers are independent, can have
     share_0/total_0 (<, ==, >) share_1/total_1
  */

  // Lock-step traversal of the 2 vectors:
  auto it1 = t1.cbegin();
  auto it2 = t2.cbegin();
  auto t1_cend = t1.cend();
  auto t2_cend = t2.cend();

  while (it1 != t1_cend && it2 != t2_cend) {
    total_0++;
    if (it1->first < it2->first) // difference
      total_1 += (it1++)->second;
    else
    if (it1->first > it2->first) // difference
      total_1 += (it2++)->second;
    else { // intersection
      share_0++;
      // just as fast as single if
      total_1 += max(it1->second, it2->second);
      share_1 += min(it1->second, it2->second);
      ++it1; ++it2;
    }
  }
  // Handle leftover tails:
  while (it1 != t1_cend) {
    total_0++;
    total_1 += (it1++)->second;
  }
  while (it2 != t2_cend) {
    total_0++;
    total_1 += (it2++)->second;
  }
  return { double(share_0)/total_0, double(share_1)/total_1 };
}

/* Check pairs of samples for similarity.
   All n(n-1)/2 pairs are considered in principle.
   Avoid a quadratic number of tests by flagging samples
   that are found similar.
*/
static void check_samples()
{
  unsigned num_clusters = 0;
  unsigned max_cluster_size = 0;
  unsigned total_cluster_size = 0;
  unsigned singletons = 0;
  unsigned num_samples = samples.size();

  if (!num_samples)
    return;

  // Output only non-singleton clusters separated by a blank line.

  // Tried using a std::queue for inner loop but does not seem to affect
  // performance much. Probably because of underlying deque.
  // Even simple queue using fixed size array does no improve things.

  for (auto it1 = samples.begin(), end = samples.end(); it1 != end; ++it1) {
    //fprintf(stderr, ""id: %s\n"", it1->id.c_str());
    if (it1->flag) continue;
    const unsigned s1 = it1->size();
    // FIXME: Put all samples similar to this one in a cluster.
    unsigned cluster_size = 1;
    for (auto it2 = next(it1), end = samples.end(); it2 != end; ++it2) {
      if (it2->flag) continue;
      const unsigned s2 = it2->size(); 

      // Allow s2 to deviate up to +- 5% from s1:
      if (::abs(s1 - s2) * 100.0 / s1 > 5.0) continue;

      switch (mode) {
      case LCS: {
	// Cheap upperbound calculation:
	unsigned up = lcs_upperbound(it1->token_bag, it2->token_bag);
	if (up < s1 * threshold_0)
	  continue;

	unsigned lcs_len = lcs(it1->token_seq, it2->token_seq, s1, s2);
	if (lcs_len >= s1 * threshold_0) {
	  // Flag it2 (always beyond it1) as dealt with:
	  it2->flag = true;
	  if (cluster_size == 1)
	    fprintf(stdout, ""%s:     (%3u)\n"", it1->id.c_str(), s1);
	  fprintf(stdout, ""%s: %3u (%3u)\n"", it2->id.c_str(), lcs_len, s2);
	  cluster_size++;
	}
	break;
      }

      case JACCARD: {
	Double2 similarity = jaccard(it1->token_bag, it2->token_bag);
	if (similarity.first  >= threshold_0 &&
	    similarity.second >= threshold_1) {

	  // Flag it2 (always beyond it1) as dealt with:
	  it2->flag = true;
	  if (cluster_size == 1)
	    fprintf(stdout, ""%s:\n"", it1->id.c_str());
	  fprintf(stdout, ""%s: %5.2f,%5.2f\n"", it2->id.c_str(),
		  similarity.first, similarity.second);
	  cluster_size++;
	}
	break;
      }

      case COSINE: {
	double similarity = cosine(it1->token_bag, it2->token_bag);
	if (similarity >= threshold_0) {
	  // Flag it2 (always beyond it1) as dealt with:
	  it2->flag = true;
	  if (cluster_size == 1)
	    fprintf(stdout, ""%s:\n"", it1->id.c_str());
	  fprintf(stdout, ""%s: %5.2f\n"", it2->id.c_str(), similarity);
	  cluster_size++;
	}
	break;
      }
      }
    }
    if (cluster_size > 1) {
      if (next(it1) != end)
	fputc('\n', stdout);
      num_clusters++;
      if (cluster_size > max_cluster_size)
	max_cluster_size = cluster_size;
      total_cluster_size += cluster_size;
    }
    else {
      if (out_singles) {
	fprintf(stdout, ""%s:\n"", it1->id.c_str());
	if (next(it1) != end)
	  fputc('\n', stdout);
      }
      singletons++;
    }
  }

  // Sanity check:
  assert(total_cluster_size + singletons == num_samples);

  // samples with size 1 cluster: num_samples - total_cluster_size
  // unique samples: num_clusters + size 1 samples
  // duplication factor: (num_samples - unique samples) / num_samples
  // = (total_cluster_size - num_clusters) / num_samples

  if (csv_summary) {
   // identifier,samples,discarded,unique,clusters,duplicates,max,average,factor
    fprintf(stderr, ""%s,%u,%u,%u,%u,%u,%u,%.1f,%.1f%%\n"",
	    filename, num_samples+num_samples_discarded, num_samples_discarded,
	    num_samples + num_clusters - total_cluster_size,
	    num_clusters, total_cluster_size, max_cluster_size,
	    double(total_cluster_size)/num_clusters,
	    (total_cluster_size - num_clusters) * 100.0 / num_samples);
  }
  else
  fprintf(stderr,
	  ""Found %u clusters (avg: %3.1f, max: %u) among the %u samples.\n""
	  ""Duplication factor: %5.1f%%\n"",
	  num_clusters, double(total_cluster_size)/num_clusters,
	  max_cluster_size, num_samples,
	  (total_cluster_size - num_clusters) * 100.0 / num_samples);
}

int main(int argc, char *argv[])
{
  extern int optind;
  int option;
  char const *opt_str = ""cdhi:j:m:M:o:stvw"";
  char usage_str[80];

  char *outfile = 0;
  unsigned num_files = 0;	// number of files read

  sprintf(usage_str, ""usage: %%s [ -%s ] [ FILE ]\n"", opt_str);

  /* Process arguments: */
  while ((option = getopt(argc, argv, opt_str)) != EOF) {
    switch (option) {

    case 'c':
      csv_summary = 1;
      break;

    case 'd':
      debug = verbose = 1;
      break;

    case 'h':
fputs(
""This program finds clusters of near-duplicate files of source code.\n""
""The input is a file (or files) with one sample per line. A sample consists\n""
""of a unique (within the input) identifier for the source code, e.g.\n""
""its file name or its file name path, and a list of space-separated tokens.\n\n""
""Two samples are reported as near-duplicates depending on the thresholds set\n""
""for the various similarity metrics (thresholds must be in [0..1]):\n""
""1. in Jaccard mode, the set similarity score must meet the 1st threshold and\n""
""   the multiset score meet the 2nd threshold;\n""
""2. in LCS mode, the ratio of common subsequence length and input length must\n""
""   be at least the 1st threshold value;\n""
""3. in Cosine mode, the cosine similarity must be at least the 1st threshold.\n\n""
, stdout);
fprintf(stderr, usage_str, basename(argv[0]));
fputs(
""\nCommand line options are:\n""
""-c       : output summary in CSV instead of plain text (default) to stderr.\n""
""-d       : print debug info to stderr; implies -v.\n""
""-h       : print just this text to stderr and stop.\n""
""-i<num>  : 1st Jaccard (or LCS, or Cosine) threshold value (default 0.9).\n""
""-j<num>  : 2nd Jaccard threshold value (default 0.8).\n""
""-m<mode> : operation mode either jaccard (default), lcs, or cosine.\n""
""-M<int>  : samples smaller than this number are discarded (default 20).\n""
""-o<file> : name for output file (instead of stdout).\n""
""-s       : also output singleton clusters (default don't).\n""
""-t       : insist tokens are TAB-separated (default autodetect).\n""
""-v       : print action summary to stderr.\n""
""-w       : suppress all warning messages.\n"",
      stderr);
      return 0;

    case 'i':
      threshold_0 = atof(optarg);
      break;

    case 'j':
      threshold_1 = atof(optarg);
      break;

    case 'm':
      if (!strcmp(optarg, ""jaccard""))
        mode = JACCARD;
      else if (!strcmp(optarg, ""lcs""))
        mode = LCS;
      else if (!strcmp(optarg, ""cosine""))
        mode = COSINE;
      else {
	if (!nowarn)
	  fprintf(stderr, ""(W): Invalid mode %s (using jaccard).\n"", optarg);
        mode = JACCARD;
      }
      break;

    case 'M':
      num_tokens_threshold = atoi(optarg);
      break;

    case 'o':
      outfile = optarg;
      break;

    case 's':
      out_singles = 1;
      break;

    case 't':
      delim = ""\t"";
      break;

    case 'v':
      verbose = 1;
      break;

    case 'w':
      nowarn = 1;
      break;

    case '?':
    default:
      fputs(""(F): unknown option. Stop.\n"", stderr);
      fprintf(stderr, usage_str, argv[0]);
      return 1;
    }
  }

  if (outfile && outfile[0]) {
    if (!freopen(outfile, ""w"", stdout)) {
      fprintf(stderr, ""(F): cannot open %s for writing.\n"", outfile);
      exit(3);
    }
  }

  char *line = NULL;
  size_t alloc_len;
  ssize_t  [MASK] ;

  // CSV header (once)
  /*
  if (csv_summary)
    fputs(""identifier,samples,discarded,unique,clusters,duplicates,max,""
	  ""average,factor\n"", stderr);
  */
  if (optind == argc)
    goto doit;

  do {
    filename = argv[optind];
    if (!freopen(filename, ""r"", stdin)) {
      if (!nowarn)
	fprintf(stderr, ""(W): Cannot read file %s.\n"", filename);
      continue;
    }

  doit:
    unsigned linenr = 0;
    num_files++;

    if (verbose) fprintf(stderr, ""(I): Processing file %s...\n"", filename);

    while (( [MASK]  = getline(&line, &alloc_len, stdin)) != -1) {
      linenr++;

      // Remove white-space from end of line:
      char *p = line +  [MASK] ;
      while (isspace(*(p-1)))
	p--;
      *p = '\0';

      // Skip blank lines:
      if (!*line) continue;

      // Split line at first TAB:
#if 1
      const char *id = p = line;
      while (*p && *p != '\t')
	p++;
      // Here: *p == '\0' || *p == '\t'
      if (*p != '\t') {
	fprintf(stderr, ""(W): Line %u with id `%s' has no tokens; skipped.\n"",
		linenr, id);
	continue;
      }
      *p++ = '\0';
      char *tokens = p;
#else
      const char *id = strtok(line, ""\t"");
      char *tokens = strtok(NULL, """");
      p = tokens;
#endif
      // if see a TAB in tokens assume delim=""\t""
      if (delim[0] == ' ')
	for (; *p; p++)
	  if (*p == '\t') {
	    delim = ""\t"";
	    break;
	  }

      process_sample(id, tokens);
    }
  } while (++optind < argc);
  //if (line) free(line);

  if (verbose)
    fprintf(stderr, ""(I): Total distinct tokens in vocabulary: %u\n"",
	    vocabulary.size());

  check_samples();

  if (num_files > 1 && verbose)
    fprintf(stderr, ""(I): Total number of files processed: %u\n"", num_files);

  return 0;
}
",nchars
238,"#include ""Pch.h""
#include ""MainEditorLayer.h""
#include <glm/gtc/type_ptr.inl>
#include ""EditorBuiltinCamera.h""
#include ""ImGuizmo.h""
#include ""ModelEditor/ModelEditorLayer.h""
#include ""SceneEditor/SceneEditorLayer.h""

namespace Wuya
{
	MainEditorLayer::MainEditorLayer()
		: ILayer(""MainEditorLayer"")
	{
		PROFILE_FUNCTION();
	}

	void MainEditorLayer::OnAttached()
	{
		PROFILE_FUNCTION();
		
	}

	void MainEditorLayer::OnDetached()
	{
		PROFILE_FUNCTION();

		ILayer::OnDetached();
	}

	void MainEditorLayer::OnImGuiRender()
	{
		PROFILE_FUNCTION();

		/* 菜单 */
		ShowMenuUI();
		/* 场景控制UI */
		ShowSceneControllerUI();
		/* 资源管理窗口 */
		m_ResourceBrowser.OnImGuiRenderer();

		// bool show = true;
		// ImGui::ShowDemoWindow(&show);
	}

	void MainEditorLayer::OnEvent(IEvent* event)
	{
		PROFILE_FUNCTION();

		if (!event)
			return;

		EventDispatcher dispatcher(event);
		dispatcher.Dispatch<KeyPressedEvent>(BIND_EVENT_FUNC(MainEditorLayer::OnKeyPressed));
		dispatcher.Dispatch<MouseButtonPressedEvent>(BIND_EVENT_FUNC(MainEditorLayer::OnMouseButtonPressed));
	}

	bool MainEditorLayer::OnKeyPressed(KeyPressedEvent* event)
	{
		PROFILE_FUNCTION();

		if (event->GetRepeatCount() > 0)
			return false;

		bool is_ctrl_pressed = Input::IsKeyPressed(Key::LeftControl) || Input::IsKeyPressed(Key::RightControl);
		bool is_shift_pressed = Input::IsKeyPressed(Key::LeftShift) || Input::IsKeyPressed(Key::RightShift);
		bool is_button_right_pressed = Input::IsMouseButtonPressed(Mouse::ButtonRight);

		switch (event->GetKeyCode())
		{
		case Key::N: /* Ctrl+N：新建一个场景 */
			{
				if (is_ctrl_pressed)
					NewScene();
			}
			break;
		case Key::S: /* Ctrl+S: 保存场景; Ctrl+Shift+S: 场景另存为 */
			if (is_ctrl_pressed)
			{
				if (is_shift_pressed)
					SaveSceneAs();
				else
					SaveScene();
			}
			break;
		case Key::I: /* Ctrl+I：导入一个场景 */
			{
				if (is_ctrl_pressed)
					ImportScene();
			}
			break;
		case Key::Q:
			{
				if (!ImGuizmo::IsUsing() && !is_button_right_pressed)
				{
					m_GizmoType = -1;
					NotifyGizmoTypeChanged();
				}
			}
			break;
		case Key::W:
			{
				if (!ImGuizmo::IsUsing() && !is_button_right_pressed)
				{
					m_GizmoType = ImGuizmo::OPERATION::TRANSLATE;
					NotifyGizmoTypeChanged();
				}
			}
			break;
		case Key::E:
			{
				if (!ImGuizmo::IsUsing() && !is_button_right_pressed)
				{
					m_GizmoType = ImGuizmo::OPERATION::ROTATE;
					NotifyGizmoTypeChanged();
				}
			}
			break;
		case Key::R:
			{
				if (!ImGuizmo::IsUsing() && !is_button_right_pressed)
				{
					m_GizmoType = ImGuizmo::OPERATION::SCALE;
					NotifyGizmoTypeChanged();
				}
			}
			break;
		}

		return true;
	}

	bool MainEditorLayer::OnMouseButtonPressed(MouseButtonPressedEvent* event)
	{
		PROFILE_FUNCTION();
		return false;
	}
	
	void MainEditorLayer::NewScene()
	{
		PROFILE_FUNCTION();

		const auto& scene_editor_layer = reinterpret_cast<const SharedPtr<SceneEditorLayer>&>(Application::Instance()->GetLayerByName(""SceneEditorLayer""));
		scene_editor_layer->NewScene();
	}

	void MainEditorLayer::ImportScene()
	{
		PROFILE_FUNCTION();

		const auto file_path = FileDialog::OpenFile(""scene(*.scn)\0*.scn\0"");
		if (!file_path.empty())
		{
		}
	}

	void MainEditorLayer::SaveScene()
	{
		PROFILE_FUNCTION();
	}

	/* 保存场景到指定路径 */
	void MainEditorLayer::SaveSceneAs()
	{
		PROFILE_FUNCTION();

		std::string file_path = FileDialog::SaveFile(""scene(*.scn)\0*.scn\0"");

	}

	void MainEditorLayer::ShowMenuUI()
	{
		PROFILE_FUNCTION();

		static bool p_open = true;
		static bool opt_fullscreen = true;
		static bool opt_padding = false;
		static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_None;

		// We are using the ImGuiWindowFlags_NoDocking flag to make the parent window not dockable into,
		// because it would be confusing to have two docking targets within each others.
		ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
		if (opt_fullscreen)
		{
			const ImGuiViewport* viewport = ImGui::GetMainViewport();
			ImGui::SetNextWindowPos(viewport->WorkPos);
			ImGui::SetNextWindowSize(viewport->WorkSize);
			ImGui::SetNextWindowViewport(viewport->ID);
			ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
			ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
			window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
			window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
		}
		else
		{
			dockspace_flags &= ~ImGuiDockNodeFlags_PassthruCentralNode;
		}

		// When using ImGuiDockNodeFlags_PassthruCentralNode, DockSpace() will render our background
		// and handle the pass-thru hole, so we ask Begin() to not render a background.
		if (dockspace_flags & ImGuiDockNodeFlags_PassthruCentralNode)
			window_flags |= ImGuiWindowFlags_NoBackground;

		// Important: note that we proceed even if Begin() returns false (aka window is collapsed).
		// This is because we want to keep our DockSpace() active. If a DockSpace() is inactive,
		// all active windows docked into it will lose their parent and become undocked.
		// We cannot preserve the docking relationship between an active window and an inactive docking, otherwise
		// any change of dockspace/settings would lead to windows being stuck in limbo and never being visible.
		if (!opt_padding)
			ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
		ImGui::Begin(""DockSpace Demo"", &p_open, window_flags);
		{
			if (!opt_padding)
				ImGui::PopStyleVar();

			if (opt_fullscreen)
				ImGui::PopStyleVar(2);

			// Submit the DockSpace
			ImGuiIO& io = ImGui::GetIO();
			if (io.ConfigFlags & ImGuiConfigFlags_DockingEnable)
			{
				ImGuiID dockspace_id = ImGui::GetID(""MyDockSpace"");
				ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags);
			}

			ImGuiStyle& style = ImGui::GetStyle();
			style.WindowMinSize.x = 200.0f;

			/* 菜单栏 */
			if (ImGui::BeginMenuBar())
			{
				if (ImGui::BeginMenu(""File""))
				{
					if (ImGui::MenuItem(""New Scene"", ""Ctrl+N""))
					{
						NewScene();
					}

					if (ImGui::MenuItem(""Open Scene"", ""Ctrl+O""))
					{
						ImportScene();
					}

					if (ImGui::MenuItem(""Save Scene"", ""Ctrl+S""))
					{
						SaveScene();
					}

					if (ImGui::MenuItem(""Save Scene As"", ""Ctrl+Shift+S""))
					{
						SaveSceneAs();
					}

					if (ImGui::MenuItem(""Import Model(.obj)"", ""Ctrl+I""))
					{
						m_ActiveModelEditor = true;
						const auto& model_editor_layer = reinterpret_cast<const SharedPtr<ModelEditorLayer>&>(Application::Instance()->GetLayerByName(""ModelEditorLayer""));
						model_editor_layer->Active(m_ActiveModelEditor);
						model_editor_layer->ImportModel();
					}

					if (ImGui::MenuItem(""Export Mesh & Mtl(.mesh & .mtl)"", ""Ctrl+E""))
					{
						//ExportMeshAndMtl();
						const auto& scene_editor_layer = reinterpret_cast<const SharedPtr<SceneEditorLayer>&>(Application::Instance()->GetLayerByName(""SceneEditorLayer""));
						static bool active = false;
						scene_editor_layer->Active(active);
						active = !active;
					}

					if (ImGui::MenuItem(""Exit""))
						Application::Instance()->Close();

					ImGui::EndMenu();
				}

				if (ImGui::BeginMenu(""Windows""))
				{
					const auto& scene_editor_layer = reinterpret_cast<const SharedPtr<SceneEditorLayer>&>(Application::Instance()->GetLayerByName(""SceneEditorLayer""));
					m_ActiveSceneEditor = scene_editor_layer->IsActivated();
					if (ImGui::MenuItem(""SceneEditor"", NULL, &m_ActiveSceneEditor))
					{
						scene_editor_layer->Active(m_ActiveSceneEditor);
					}

					const auto& model_editor_layer = reinterpret_cast<const SharedPtr<ModelEditorLayer>&>(Application::Instance()->GetLayerByName(""ModelEditorLayer""));
					m_ActiveModelEditor = model_editor_layer->IsActivated();
					if (ImGui::MenuItem(""ModelEditor"", NULL, &m_ActiveModelEditor))
					{
						model_editor_layer->Active(m_ActiveModelEditor);
					}

					ImGui::EndMenu();
				}

				if (ImGui::BeginMenu(""Options""))
				{
					// Disabling fullscreen would allow the window to be moved to the front of other windows,
					// which we can't undo at the moment without finer window depth/z control.
					ImGui::MenuItem(""Fullscreen"", NULL, &opt_fullscreen);
					ImGui::MenuItem(""Padding"", NULL, &opt_padding);
					ImGui::Separator();

					if (ImGui::MenuItem(""Flag: NoSplit"", """", (dockspace_flags & ImGuiDockNodeFlags_NoSplit) != 0)) { dockspace_flags ^= ImGuiDockNodeFlags_NoSplit; }
					if (ImGui::MenuItem(""Flag: NoResize"", """", (dockspace_flags & ImGuiDockNodeFlags_NoResize) != 0)) { dockspace_flags ^= ImGuiDockNodeFlags_NoResize; }
					if (ImGui::MenuItem(""Flag: NoDockingInCentralNode"", """", (dockspace_flags & ImGuiDockNodeFlags_NoDockingInCentralNode) != 0)) { dockspace_flags ^= ImGuiDockNodeFlags_NoDockingInCentralNode; }
					if (ImGui::MenuItem(""Flag: AutoHideTabBar"", """", (dockspace_flags & ImGuiDockNodeFlags_AutoHideTabBar) != 0)) { dockspace_flags ^= ImGuiDockNodeFlags_AutoHideTabBar; }
					if (ImGui::MenuItem(""Flag: PassthruCentralNode"", """", (dockspace_flags & ImGuiDockNodeFlags_PassthruCentralNode) != 0, opt_fullscreen)) { dockspace_flags ^= ImGuiDockNodeFlags_PassthruCentralNode; }
					ImGui::Separator();

					if (ImGui::MenuItem(""Close"", NULL, false))
						p_open = false;
					ImGui::EndMenu();
				}

				ImGui::EndMenuBar();
			}
		}
		ImGui::End();
	}

	/* 显示场景控制UI */
	void MainEditorLayer::ShowSceneControllerUI()
	{
		PROFILE_FUNCTION();

		static auto save_icon = TextureAssetManager::Instance().GetOrCreateTexture(ABSOLUTE_PATH(""EditorRes/icons/save.png""));
		static auto  [MASK]  = TextureAssetManager::Instance().GetOrCreateTexture(ABSOLUTE_PATH(""EditorRes/icons/translate.png""));
		static auto rotate_icon = TextureAssetManager::Instance().GetOrCreateTexture(ABSOLUTE_PATH(""EditorRes/icons/rotate.png""));
		static auto scale_icon = TextureAssetManager::Instance().GetOrCreateTexture(ABSOLUTE_PATH(""EditorRes/icons/scale.png""));
		static auto play_icon = TextureAssetManager::Instance().GetOrCreateTexture(ABSOLUTE_PATH(""EditorRes/icons/play.png""));
		static auto stop_icon = TextureAssetManager::Instance().GetOrCreateTexture(ABSOLUTE_PATH(""EditorRes/icons/stop.png""));
		static auto menu_icon = TextureAssetManager::Instance().GetOrCreateTexture(ABSOLUTE_PATH(""EditorRes/icons/menu.png""));

		ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 2)); /* 指定间隔 */
		ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, ImVec2(0, 2));

		ImGui::Begin(""##Scene Controller"", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
		{
			const float icon_size = ImGui::GetWindowHeight() - 4.0f;
			const float panel_width = ImGui::GetWindowContentRegionMax().x;

			START_TRANSPARENT_BUTTON;

			constexpr float cursor_offset = 10.0f;
			/* 保存按钮 */
			ImGui::SetCursorPosX(cursor_offset);
			/*if (ImGui::ImageButton((ImTextureID)save_icon->GetTextureID(), ImVec2(icon_size, icon_size), ImVec2(0, 1), ImVec2(1, 0), 0))
				SaveScene();*/
			bool checked = false;
			ImGuiExt::DrawCheckedImageButtonUI(""Save"", save_icon, ImVec2(icon_size, icon_size), checked,
				[&]()
				{
					SaveScene();
				});

			/* 移动/旋转/平移操作 */
			{
				/* translate */
				ImGui::SameLine(cursor_offset + icon_size * 2);
				bool checked = m_GizmoType == ImGuizmo::OPERATION::TRANSLATE;
				ImGuiExt::DrawCheckedImageButtonUI(""Translate"",  [MASK] , ImVec2(icon_size, icon_size), checked,
					[&]()
					{
						m_GizmoType = ImGuizmo::OPERATION::TRANSLATE;
						NotifyGizmoTypeChanged();
					});

				/* rotate */
				ImGui::SameLine();
				checked = m_GizmoType == ImGuizmo::OPERATION::ROTATE;
				ImGuiExt::DrawCheckedImageButtonUI(""Rotate"", rotate_icon, ImVec2(icon_size, icon_size), checked,
					[&]()
					{
						m_GizmoType = ImGuizmo::OPERATION::ROTATE;
						NotifyGizmoTypeChanged();
					});

				/* scale */

				ImGui::SameLine();
				checked = m_GizmoType == ImGuizmo::OPERATION::SCALE;
				ImGuiExt::DrawCheckedImageButtonUI(""Scale"", scale_icon, ImVec2(icon_size, icon_size), checked,
					[&]()
					{
						m_GizmoType = ImGuizmo::OPERATION::SCALE;
						NotifyGizmoTypeChanged();
					});
			}

			/* 切换执行模式 */
			{
				ImGui::SameLine();
				const SharedPtr<Texture> icon = (m_PlayMode == PlayMode::Edit) ? play_icon : stop_icon;
				ImGui::SetCursorPosX((panel_width - icon_size) * 0.5f);
				if (ImGui::ImageButton((ImTextureID)icon->GetTextureID(), ImVec2(icon_size, icon_size), ImVec2(0, 1), ImVec2(1, 0), 0))
				{
					m_PlayMode = (m_PlayMode == PlayMode::Edit) ? PlayMode::Runtime : PlayMode::Edit;
					NotifyPlayModeChanged();
				}
			}

			/* 配置 */
			{
				ImGui::SameLine(panel_width - cursor_offset - 20);
				START_STYLE_ALPHA(0.5f);
				if (ImGui::ImageButton((ImTextureID)menu_icon->GetTextureID(), ImVec2(20, 20), ImVec2(0, 1), ImVec2(1, 0)))
					ImGui::OpenPopup(""ConfigPopup"");
				END_STYLE_ALPHA;

				/* 展开弹窗时，显示控件 */
				// if (ImGui::BeginPopup(""ConfigPopup""))
				// {
				// 	ImGui::PushItemWidth(200);
				//
				// 	bool is_focus = m_pEditorCamera->IsFocus();
				// 	ImGui::Checkbox(""FocusMode"", &is_focus);
				// 	m_pEditorCamera->SetFocus(is_focus);
				//
				// 	ImGui::PopItemWidth();
				// 	ImGui::EndPopup();
				// }
			}

			END_TRANSPARENT_BUTTON;
		}

		ImGui::End();
		ImGui::PopStyleVar(2);
	}

	/* 显示渲染统计信息 */
	void MainEditorLayer::ShowStatisticInfoUI()
	{
		PROFILE_FUNCTION();

		ImGui::Begin(""Stat Info"");
		{
			// todo: 帧率等
			// Renderer3D Stats
			if (ImGui::CollapsingHeader(""3D""))
			{
				// todo: 三角形、模型数量
			}
		}
		ImGui::End();
	}

	void MainEditorLayer::NotifyGizmoTypeChanged()
	{
		const auto& scene_editor_layer = reinterpret_cast<const SharedPtr<SceneEditorLayer>&>(Application::Instance()->GetLayerByName(""SceneEditorLayer""));
		scene_editor_layer->SetGizmoType(m_GizmoType);
	}

	void MainEditorLayer::NotifyPlayModeChanged()
	{
		const auto& scene_editor_layer = reinterpret_cast<const SharedPtr<SceneEditorLayer>&>(Application::Instance()->GetLayerByName(""SceneEditorLayer""));
		scene_editor_layer->SetPlayMode(m_PlayMode);
	}

	void MainEditorLayer::OnUpdate(float delta_time)
	{
		PROFILE_FUNCTION();
		
	}
}
",translate_icon
239,"/*
 * Copyright <NAME>, 2021
 * Use, modification and distribution are subject to the
 * Boost Software License, Version 1.0. (See accompanying file
 * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

#include ""math_unit_test.hpp""
#include <random>
#include <boost/math/tools/cubic_roots.hpp>
#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
using boost::multiprecision::float128;
#endif

using boost::math::tools::cubic_roots;
using boost::math::tools::cubic_root_residual;
using std::cbrt;

template<class Real>
void test_zero_coefficients()
{
    Real a = 0;
    Real b = 0;
    Real c = 0;
    Real d = 0;
    auto roots = cubic_roots(a,b,c,d);
    CHECK_EQUAL(roots[0], Real(0));
    CHECK_EQUAL(roots[1], Real(0));
    CHECK_EQUAL(roots[2], Real(0));

    a = 1;
    roots = cubic_roots(a,b,c,d);
    CHECK_EQUAL(roots[0], Real(0));
    CHECK_EQUAL(roots[1], Real(0));
    CHECK_EQUAL(roots[2], Real(0));

    a = 1;
    d = 1;
    // x^3 + 1 = 0:
    roots = cubic_roots(a,b,c,d);
    CHECK_EQUAL(roots[0], Real(-1));
    CHECK_NAN(roots[1]);
    CHECK_NAN(roots[2]);
    d = -1;
    // x^3 - 1 = 0:
    roots = cubic_roots(a,b,c,d);
    CHECK_EQUAL(roots[0], Real(1));
    CHECK_NAN(roots[1]);
    CHECK_NAN(roots[2]);

    d = -2;
    // x^3 - 2 = 0
    roots = cubic_roots(a,b,c,d);
    CHECK_ULP_CLOSE(roots[0], cbrt(Real(2)), 2);
    CHECK_NAN(roots[1]);
    CHECK_NAN(roots[2]);

    d = -8;
    roots = cubic_roots(a,b,c,d);
    CHECK_EQUAL(roots[0], Real(2));
    CHECK_NAN(roots[1]);
    CHECK_NAN(roots[2]);


    // (x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x - 6
    roots = cubic_roots(Real(1), Real(-6), Real(11), Real(-6));
    CHECK_ULP_CLOSE(roots[0], Real(1), 2);
    CHECK_ULP_CLOSE(roots[1], Real(2), 2);
    CHECK_ULP_CLOSE(roots[2], Real(3), 2);

    // Double root:
    // (x+1)^2(x-2) = x^3 - 3x - 2:
    // Note: This test is unstable wrt to perturbations!
    roots = cubic_roots(Real(1), Real(0), Real(-3), Real(-2));
    CHECK_ULP_CLOSE(Real(-1), roots[0], 2);
    CHECK_ULP_CLOSE(Real(-1), roots[1], 2);
    CHECK_ULP_CLOSE(Real(2), roots[2], 2);

    std::uniform_real_distribution<Real> dis(-2,2);
    std::mt19937  [MASK] (12345);
    // Expected roots
    std::array<Real, 3> r;
    int trials = 10;
    for (int i = 0; i < trials; ++i) {
        // Mathematica:
        // Expand[(x - r0)*(x - r1)*(x - r2)]
        // - r0 r1 r2 + (r0 r1 + r0 r2 + r1 r2) x
        // - (r0 + r1 + r2) x^2 + x^3
        for (auto & root : r) {
            root = static_cast<Real>(dis( [MASK] ));
        }
        std::sort(r.begin(), r.end());
        Real a = 1;
        Real b = -(r[0] + r[1] + r[2]);
        Real c = r[0]*r[1] + r[0]*r[2] + r[1]*r[2];
        Real d = -r[0]*r[1]*r[2];

        auto roots = cubic_roots(a, b, c, d);
        // I could check the condition number here, but this is fine right?
        if(!CHECK_ULP_CLOSE(r[0], roots[0], 25)) {
            std::cerr << ""  Polynomial x^3 + "" << b << ""x^2 + "" << c << ""x + "" << d << "" has roots {"";
            std::cerr << r[0] << "", "" << r[1] << "", "" << r[2] << ""}, but the computed roots are {"";
            std::cerr << roots[0] << "", "" << roots[1] << "", "" << roots[2] << ""}\n"";
        }
        CHECK_ULP_CLOSE(r[1], roots[1], 25);
        CHECK_ULP_CLOSE(r[2], roots[2], 25);
        for (auto root : roots) {
            auto res = cubic_root_residual(a, b,c,d, root);
            CHECK_LE(abs(res[0]), 20*res[1]);
        }
    }
}


int main()
{
    test_zero_coefficients<float>();
    test_zero_coefficients<double>();
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
    test_zero_coefficients<long double>();
#endif

#ifdef BOOST_HAS_FLOAT128
    // For some reason, the quadmath is way less accurate than the float/double/long double:
    //test_zero_coefficients<float128>();
#endif


    return boost::math::test::report_errors();
}
",gen
240,"#ifndef KEYPAD_H
#define KEYPAD_H

#include ""Key.h""

#define OPEN LOW
#define CLOSED HIGH

typedef char KeypadEvent;
typedef unsigned int uint;
typedef unsigned long ulong;

typedef struct {
    byte rows;
    byte columns;
} KeypadSize;

#define LIST_MAX 10		// Max number of keys on the active list.
#define MAPSIZE 10		// MAPSIZE is the number of rows (times 16 columns)
#define makeKeymap(x) ((char*)x)

#define ROWS 4
#define COLS 4

class Keypad4x4 : public Key {
public:
    Keypad4x4(char *userKeymap, byte *row, byte *col);

    virtual void pin_mode(byte pinNum, byte mode) { pinMode(pinNum, mode); }
    virtual void pin_write(byte pinNum, boolean  [MASK] ) { digitalWrite(pinNum,  [MASK] ); }
    virtual int  pin_read(byte pinNum) { return digitalRead(pinNum); }

    uint bitMap[MAPSIZE];	// 10 row x 16 column array of bits. Except Due which has 32 columns.
    Key key[LIST_MAX];
    unsigned long holdTimer;

    char getKey();
    bool getKeys();
    KeyState getState();
    void begin(char *userKeymap);
    bool isPressed(char keyChar);
    void setDebounceTime(uint);
    void setHoldTime(uint);
    void addEventListener(void (*listener)(char));
    int findInList(char keyChar);
    int findInList(int keyCode);
    char waitForKey();
    bool keyStateChanged();
    byte numKeys();

private:
    unsigned long startTime;
    char *keymap;
    byte *rowPins;
    byte *columnPins;
    KeypadSize sizeKpd;
    uint debounceTime;
    uint holdTime;
    bool single_key;

    void scanKeys();
    bool updateList();
    void nextKeyState(byte n, boolean button);
    void transitionTo(byte n, KeyState nextState);
    void (*keypadEventListener)(char);
};

#endif",level
241,"#include ""appintegration.h""
#include <QDebug>
#include <QFile>
#include <QDir>
#include <QCoreApplication>
#include <QFileInfo>
#include <QStandardPaths>
#include <QProcess>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QTextStream>

namespace {
    /**
     * @brief Updates a field in desktop file if the value is different
     * @param desktopFilePath Path to the desktop file
     * @param fieldName Name of the field to update
     * @param fieldValue New value for the field
     */
    void updateDesktopField(const QString& desktopFilePath, 
                           const QString& fieldName, 
                           const QString& fieldValue)
    {
#ifdef Q_OS_LINUX
        QFile file(desktopFilePath);
        if (file.open(QIODevice::ReadWrite | QIODevice::Text)) {
            QString content = file.readAll();
            file.close();
            
            // Match field and replace with new value if different
            QRegularExpression regex(fieldName + ""=(.*)"");
            QString replacement = fieldName + ""="" + fieldValue;
            QRegularExpressionMatch match = regex.match(content);
            QString oldValue = match.hasMatch() ? match.captured(1) : """";
            if (oldValue != fieldValue) {
                content.replace(regex, replacement);
            } else {
                qDebug() << ""Field value is the same, skipping update for"" << fieldName;
                return;
            }
            
            // Write back to file
            if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                file.write(content.toUtf8());
                file.close();
                qDebug() << ""Updated desktop file:"" << desktopFilePath;
                qDebug() << ""Field name:"" << fieldName;
                qDebug() << ""Old value:"" << oldValue;
                qDebug() << ""New value:"" << fieldValue;
            } else {
                qDebug() << ""Failed to update desktop file:"" << desktopFilePath;
            }
        } else {
            qDebug() << ""Failed to open desktop file for reading:"" << desktopFilePath;
        }
#else
        // Non-Linux platforms - do nothing
        Q_UNUSED(desktopFilePath);
        Q_UNUSED(fieldName);
        Q_UNUSED(fieldValue);
#endif
    }

    /**
     * @brief Refreshes system caches for desktop files and icons
     */
    void refreshSystemCache()
    {
#ifdef Q_OS_LINUX
        // Update desktop database
        QProcess::execute(""update-desktop-database"", QStringList() << QDir::homePath() + ""/.local/share/applications"");
        
        // Ensure icon directories exist for cache update
        QDir().mkpath(QDir::homePath() + ""/.local/share/icons/hicolor"");
        
        // Refresh icon cache - try different commands based on available tools
        QProcess::execute(""gtk-update-icon-cache"", QStringList() << ""-f"" << ""-t"" << QDir::homePath() + ""/.local/share/icons"");
        QProcess::execute(""xdg-icon-resource"", QStringList() << ""forceupdate"");
        
        // Notify desktop environment of changes - works for many desktop environments
        QProcess::execute(""dbus-send"", QStringList() 
            << ""--session"" 
            << ""--dest=org.freedesktop.DBus"" 
            << ""--type=method_call""
            << ""/org/freedesktop/DBus"" 
            << ""org.freedesktop.DBus.ReloadConfig"");
#endif
    }
}

void AppIntegration::loadApplicationIcon(QApplication& app)
{
    // Try to load icon from resource
    QIcon icon("":/app-icon-png"");
    if (!icon.isNull()) {
        app.setWindowIcon(icon);
        qDebug() << ""Icon loaded from resource"";
    }

#ifdef Q_OS_LINUX
    // Setup desktop entry for Linux
    setupDesktopEntry();
#endif
}

#ifdef Q_OS_LINUX
void AppIntegration::setupDesktopEntry()
{
    // Check if running from AppImage
    const char* appImage = getenv(""APPIMAGE"");
    if (!appImage) {
        // Not running from AppImage, nothing to do
        return;
    }
    
    // Get paths
    QString appImagePath(appImage);
    QString appDir = QCoreApplication::applicationDirPath();
    QString  [MASK]  = appDir + ""/../icons/longview.png"";
    QString appDesktopPath = appDir + ""/../applications/longview.desktop"";
    const QString USER_LOCAL_DATA_DIR = QDir::homePath() + ""/.local/share"";
    QString userDesktopFilePath = USER_LOCAL_DATA_DIR + ""/applications/longview.desktop"";
    QString userIconDir = USER_LOCAL_DATA_DIR + ""/icons"";
    QString userIconPath = userIconDir + ""/longview.png"";
    
    // Ensure icon directory exists
    QDir().mkpath(userIconDir);

    // Try to copy icon from AppImage to user directory
    if (QFile::copy( [MASK] , userIconPath)) {
        qDebug() << ""Icon copied from:"" <<  [MASK]  << ""to:"" << userIconPath;
    }
    
    // Check if desktop file exists
    QFile desktopFile(userDesktopFilePath);
    if (!desktopFile.exists()) {
        // Desktop file doesn't exist, copy from template and update
        QDir().mkpath(QFileInfo(userDesktopFilePath).path());
        if (QFile::copy(appDesktopPath, userDesktopFilePath)) {
            qDebug() << ""Desktop file copied from:"" << appDesktopPath << ""to:"" << userDesktopFilePath;
            // Update Icon fields in the new desktop file
            updateDesktopField(userDesktopFilePath, ""Icon"", userIconPath);
            
            // Force system to reload desktop files and refresh icon cache
            // Only do this on first run (when desktop file doesn't exist)
            qDebug() << ""First run detected - refreshing desktop database and icon cache"";
            refreshSystemCache();
        }
    }
    // Whether desktop file is newly created or exists already, check and update Exec field if necessary
    updateDesktopField(userDesktopFilePath, ""Exec"", appImagePath);
}
#endif ",appIconPath
242,"#include ""config_parser_factory.h""

#include <algorithm>

bool ConfigParserFactory::registerConfigParser(
      const std::string& name, ConfigParserCreateMethod createMethod, bool overwrite
    ) noexcept
{
  if (overwrite) {
    _createMethods.insert_or_assign(name, createMethod);
    return true;
  }
  else {
    bool can_create = canCreateConfigParser(name);
    if (!can_create)
      _createMethods[name] = createMethod;
    return !can_create;
  }
}


std::shared_ptr<ConfigParserBase> ConfigParserFactory::createConfigParser(
      const std::string& name
    ) noexcept
{
  if (canCreateConfigParser(name))
    return _createMethods.at(name)();
  return nullptr;
}


bool ConfigParserFactory::canCreateConfigParser(const std::string& name) noexcept
{
  auto it = _createMethods.find(name);
  return it != _createMethods.end();
}


std::vector<std::string> ConfigParserFactory::registeredConfigParsers() noexcept
{
  static constexpr auto key_selector = [](auto  [MASK] ){ return  [MASK] .first; };
  std::vector<std::string> keys(_createMethods.size());
  std::transform(_createMethods.begin(), _createMethods.end(), keys.begin(), key_selector);
  return keys;
        
}
",pair
243,"#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const int NUM_CITIES = 4;

//calculate distance between two cities
int dist(char city1, char city2) {
    // Example for 4 cities / input size
    if(city1 == 'A') {
        if(city2 == 'B') return 10;
        else if(city2 == 'C') return 20;
        else if(city2 == 'D') return 30;
    }
    else if(city1 == 'B') {
        if(city2 == 'A') return 10;
        else if(city2 == 'C') return 10;
        else if(city2 == 'D') return 20;
    }
    else if(city1 == 'C') {
        if(city2 == 'A') return 20;
        else if(city2 == 'B') return 10;
        else if(city2 == 'D') return 15;
    }
    else if(city1 == 'D') {
        if(city2 == 'A') return 30;
        else if(city2 == 'B') return 20;
        else if(city2 == 'C') return 15;
    }
    return -1;
}

vector<char> nearest_neighbor(char start_city) {
    vector<char> route;
    vector<bool> visited(NUM_CITIES, false);
    char  [MASK]  = start_city;
    route.push_back( [MASK] );
    visited[ [MASK]  - 'A'] = true;
    for (int i = 0; i < NUM_CITIES-1; i++) {
        int nearest_distance = INT_MAX;
        int nearest_city = -1;
        for (int j = 0; j < NUM_CITIES; j++) {
            if (!visited[j]) {
                int distance = dist( [MASK] , 'A' + j);
                if (distance < nearest_distance) {
                    nearest_distance = distance;
                    nearest_city = j;
                }
            }
        }
         [MASK]  = 'A' + nearest_city;
        route.push_back( [MASK] );
        visited[nearest_city] = true;
    }
    return route;
}

int main() {
    vector<char> best_route = nearest_neighbor('A');
    for (auto city : best_route) {
        cout << city << "" "";
    }
    cout << endl;
    return 0;
}
",current_city
244,"// mine sweeper.cpp : このファイルには 'main' 関数が含まれています。プログラム実行の開始と終了がそこで行われます。
//
#define _SILENCE_FPOS_SEEKPOS_DEPRECATION_WARNING

#include <ostream>
#include <istream>
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <algorithm>
#include <random>
#include <sstream>
#include <exception>
#include ""boost/spirit/include/qi.hpp""

namespace mnsw{
	namespace {
		class bomb_exception : public std::exception {
		public:
			bomb_exception() : std::exception{""""} {}
		};
		constexpr char BOMB_CHAR[] = "" B"";
		constexpr char FLAG_CHAR[] = ""！"";
		constexpr char NONE_CHAR[] = ""  "";
		constexpr char NOT_OPENED[] = ""■"";
	}

	class cell {
		
		bool bomb_;
		bool flag_;
		bool opened_;
		int bomb_around_;
	public:
		cell(bool bomb) noexcept : bomb_{bomb}, flag_{false}, opened_{false} {}
		cell() noexcept : bomb_{false}, flag_{false}, opened_{false} {}

		void print(std::ostream & out) const {
			if (flag_) {
				out << FLAG_CHAR;
			}
			else if (!opened_) {
				out << NOT_OPENED;
			} else if (bomb_around_) {
				out << ' ' << bomb_around_;
			} else {
				out << NONE_CHAR;
			}
		}

		/// <summary>
		/// mark as bomb or disable flag
		/// </summary>
		/// <returns>current flag state</returns>
		bool flag() noexcept {
			flag_ ^= true;
			return flag_;
		}
		/// <summary>
		/// open and THROW EXCEPTION IF BOMB IS HERE
		/// </summary>
		/// <returns>
		/// bomb count around this cell
		/// </returns>
		int open() noexcept(false) {
			if (flag_) return false;
			opened_ = true;
			if (bomb_) throw bomb_exception();
			return bomb_around_;
		}
		void set_bomb_around(int bombcnt) noexcept { bomb_around_ = bombcnt; }
		void set_as_bomb() noexcept { bomb_ = true; }
		bool is_bomb() const noexcept { return bomb_; }
		bool is_opened() const noexcept { return opened_; }
		int get_around() const noexcept { return bomb_around_; }
	};

	class map {
		std::vector<cell> map_;
		size_t open_cnt_;

		size_t width_, height_;
		size_t flag_, bomb_;

		size_t coord_to_idx(const std::pair<size_t, size_t> & coord) {
			return width_ * coord.second + coord.first;
		}
		size_t coord_to_idx(std::pair<size_t, size_t> && coord) { return coord_to_idx(coord); }
		auto idx_to_coord(size_t idx)->std::pair<size_t, size_t> {
			return std::make_pair(idx % width_, idx / width_);
		}

		auto cells_around_cell(std::pair<size_t, size_t> const & coord)->std::array<cell *, 8>{
			std::array<cell *, 8> result{ nullptr };
			/**
			 * 0 1 2
			 * 3   4
			 * 5 6 7
			 **/
			// flag is true, no elm in the direction
			bool top = coord.second == 0, bottom = coord.second == height_ - 1;
			bool left = coord.first == 0, right = coord.first == width_ - 1;

			// top lane
			if (!top) {
				for (auto i = (left ? 1ULL : 0ULL); i < (right ? 2ULL : 3ULL); i++) {
					result[i] = &map_.at(coord_to_idx({ coord.first + i - 1, coord.second - 1 }));
				}
			}
			// mid lane
			{
				if (!left) result[3] = &map_.at(coord_to_idx({ coord.first-1, coord.second }));
				if (!right) result[4] = &map_.at(coord_to_idx({ coord.first + 1, coord.second }));
			}
			// bottom lane
			if (!bottom) {
				for (auto i = (left ? 1ULL : 0ULL); i < (right ? 2ULL : 3ULL); i++) {
					result[i + 5] = &map_.at(coord_to_idx({ coord.first + i - 1, coord.second + 1 }));
				}
			}
			return result;
		}
		
		void init(std::pair<size_t, size_t> first_coord) {
			const auto idx = coord_to_idx(first_coord);
			std::random_device rd;
			for (auto i = 0ULL; i < bomb_; i++) {
				map_.at(i).set_as_bomb();
			}
			do {
				std::shuffle(std::begin(map_), std::end(map_), std::mt19937{rd()});
			} while (map_.at(idx).is_bomb());

			// count bomb around each cell
			auto is_bomb = [](cell const * c) {return c == nullptr ? 0 : static_cast<unsigned>(c->is_bomb()); };
			for (auto i = 0ULL; i < width_ * height_; i++) {
				auto cur_coord = idx_to_coord(i);
				auto cells = cells_around_cell(cur_coord);
				int cnt(0);
				for (auto const & j : cells) cnt += is_bomb(j);
				map_.at(i).set_bomb_around(cnt);
			}
		}

	public:
		map(size_t width, size_t height, size_t bomb) : open_cnt_{ 0 } {
			set(width, height, bomb);
		}
		map() : open_cnt_{ 0 } {}

		void set(size_t width, size_t height, size_t bomb){
			const std::pair<size_t, size_t> size(std::min(9ull, width), std::min(9ull, height));
			width_ = size.first;
			height_ = size.second;
			bomb_ = std::min(!bomb?1ULL:bomb, size.first * size.second / 2);
			map_.reserve(size.first * size.second + 20);
			for (auto i = 0ULL; i < size.first * size.second; i++) {
				map_.emplace_back();
			}
		}

		/// <summary>
		/// open cell, invalid cell coordinate will be ignored
		/// </summary>
		/// <param name=""x"">cell coord</param>
		/// <param name=""y"">cell coord</param>
		/// <returns>@true : still alive; @false : game over</returns>
		size_t open(size_t x, size_t y) {
			if(open_cnt_ == 0)init({ x, y });
			if (map_.at(coord_to_idx({ x,y })).is_opened()) return width_ * height_ - open_cnt_ - bomb_;
			open_cnt_++;
			try {
				if (!map_.at(coord_to_idx({ x, y })).open()) {
					for (auto & i : cells_around_cell({ x, y })) {
						if (!i) continue;
						auto coord = idx_to_coord(std::distance(&map_.front(), i));
						open(coord.first, coord.second);
					}
				}
			} catch (bomb_exception&) { return 0; }
			return width_ * height_ - open_cnt_ - bomb_;
		}
		void flag(size_t x, size_t y) {
			map_.at(coord_to_idx({ x, y })).flag();
		}
		void finish() {
			map_.clear();
		}
		void print(std::ostream & out) {
			for (auto i = 0ULL; i < width_; i++) out << ' ' << i;
			for (auto i = 0ULL; i < width_ * height_; i++) {
				if (i % width_ == 0) out << std::endl << (char)('a' + i/width_);
				map_.at(i).print(out);
			}
		}
	};

	class game {
		map map_;

	public:
		game() = default;

		/// <summary>
		/// make user's dreams come true.
		/// </summary>
		/// <param name=""cmd"">
		/// o [a-i]-[0-8] : open designated cell.
		/// f [a-i]-[0-8] : mark designated cell as bomb.
		/// s [0-9]-[0-9] [0-n] : (re)start at designated map size and bomb count.
		/// e : quit game
		/// </param>
		/// <returns>
		/// @true : game is still continuing.
		/// @false : game is over.
		/// </returns>
		bool command(std::string_view cmd) {
			namespace qi = boost::spirit::qi;
			char comtype;
			char y;
			int x;
			int bomb_cnt;
			auto beg = std::begin(cmd);

			auto expr = qi::char_ >> qi::char_ >> '-' >> qi::int_ >> qi::int_;
			bool success = qi::phrase_parse(beg, std::end(cmd), expr, qi::space, comtype, y, x, bomb_cnt);
			std::stringstream ss;
			switch (comtype) {
			case 'o':
				if(!map_.open(x, y - 'a')) return false;
				break;
			case 'f':
				map_.flag(x, y - 'a');
				break;
			case 's':
				map_.finish();
				map_.set(x, y - 'a', bomb_cnt);
				break;
			case 'e':
				map_.finish();
				return false;
			}
			map_.print(ss);
			std::cout << ss.str() << std::endl;
			return true;
		}
	};
}

int main() {
	std::string  [MASK] ;
	mnsw::game g;

	do {
		std::cout << std::endl << '>' << std::flush;
		std::getline(std::cin,  [MASK] );
	} while (g.command( [MASK] ));
	return 0;
}
",combuf
245,"/***  libraries/EeValues/Examples/MyIdent/MyIdent.ino  June 2015, <NAME> ***/

//  Ardu 1.5: Required to make EeValues class compile OK.
#include <crc8.h>

#include <EeValues.h>
#include <CnUtils.h>


/* ------------------------------------------------------------------- */

#define REC_IDENT   MK4CODE('I','D', 'N', 'T')
#define REC_EE_OFFSET   10

struct MyIdent
{
    byte    poll_addr;
    char       SN[ 8 ];
} flim;

EeValues    eeMyIdent(REC_IDENT);

/* ------------------------------------------------------------------- */

// #undef F
// #define F(str) str

void dump_some_ee()
{
  Serial.println();
  dumpEE( Serial, 0, 64 );
  Serial.println();
}   /* end dump_some_ee() */


boolean validate_record()
{
    Serial.println();

    boolean  res = false;

    struct MyIdent   [MASK] ;
    memset( &  [MASK] , 0x55, sizeof( [MASK] ) );

      eeoffset_t   ee;
      byte *       ptr;

      ee = eeMyIdent.lastStoredOffset() - 1;

      for( int cnt = eeMyIdent.userRecordSize() ; --cnt >= 0 ; --ee )
      {
          ptr = (byte *) (((byte *)& [MASK] ) + cnt);
          eeMyIdent.readToUser( ee, ptr, 1 );
      }
      
      if( memcmp( &flim, & [MASK] , sizeof( [MASK] ) ) == 0 )
      {
          Serial.println( ""OK, single byte reading is correct."" );
          res = true;
      }
      else
      {
          Serial.println( ""ERROR: single byte reading FAILED!!"" );
      }

    return( res );
}   /* end validate_record() */


void
update_poll_addr()
{

      if( eeMyIdent.userRecordSize() == sizeof(flim) )
      {
            eeMyIdent.readToUser();

            flim.poll_addr += 1;
            
            eeMyIdent.updateCrc8();
            eeMyIdent.writeToEe();
      }
      else
      {
          Serial.println( ""*** WRONG SIZE ***"" );
      }

}   /* end update_poll_addr() */


/* ------------------------------------------------------------------- */


void setup() {
  // put your setup code here, to run once:
    Serial.begin(9600);  delay(1000);

    eeMyIdent.setUserDataPtr( & flim );
    eeMyIdent.setUserSize( sizeof(flim) );    

    //  Go look for thing in EE.
  boolean res = false;

#if EEVALUES_CONF_HUNT_FOR_RECORD
  res = eeMyIdent.findHeader();
  if( res )
  {
      Serial.print( ""Found it at EE offset $"" );
      printHexWidth( Serial, eeMyIdent.eeOffsetOfHeader(), 3 );
      Serial.println();
  }
  else
  {
      //  If none found, provide a default location in EEMEM.
      Serial.println( ""None found, so providing default location"" );
      eeMyIdent.setEeOffset( REC_EE_OFFSET );
  }
#else
  eeMyIdent.setEeOffset( REC_EE_OFFSET );
  res = eeMyIdent.isHeaderValid();
#endif
  if( res )
  {
      Serial.print( F(""Found "") );
      Serial.print( eeMyIdent.userRecordSize() );
      Serial.println( F("" USER bytes in EE."") );

      if( eeMyIdent.userRecordSize() == sizeof(flim) )
      {
            eeMyIdent.readToUser();
      }
      else
      {
          Serial.println( ""*** WRONG SIZE ***"" );
      }
  }
  else
  {
      Serial.println( F(""No record found, creating default one..."") );
      flim.poll_addr = 0x41 ;
      memcpy( flim.SN, ""12345678"", sizeof(flim.SN) );

      eeMyIdent.updateCrc8();
      eeMyIdent.writeToEe();
      
      //  Do a verification cycle, since this is an example sketch!
      eeMyIdent.setEeOffset( REC_EE_OFFSET );
      res = eeMyIdent.isHeaderValid();
      if( res )
      {
          Serial.println( F(""Yes, EE block verified!!"") );
      }
      else
      {
          Serial.println( F(""ERROR: EE BLOCK FAILURE VERIFICATION!!"") );
      }
  }

  //  See if can read EE one byte at a time.
  validate_record();

  dump_some_ee();

  Serial.print( F(""Bytes in heap = "") );
  Serial.println( freeRam() );
  
  //  Menu of commands.
  Serial.println( ""Commands:  E = Erase EEMEM ; D = Dump some EEMEM ; V = Validate Record ;"" );
  Serial.println( ""           U = Update record."" );
  Serial.println();
}

int  ch;

void loop() {

    // send data only when you receive data:
    if (Serial.available() > 0 && (ch = Serial.read()) > 0 )
    {
        if( 'a' <= ch && ch <= 'z' )        // TOUPPER(ch)
            ch -= 0x020;

        // read the incoming byte.
        switch( ch )
        {
            case 'E' :
                {
                EeValues  erasure( 0 );
                erasure.setEeOffset( 0 );
                erasure.setUserSize( erasure.eeSize() - 16 );
                erasure.eraseWholeRecord();
                }
     
                 Serial.println( ""EE erased."" );
                 break;
                 
             case 'D' :
                 dump_some_ee();
                 break;

            case 'U' :
                update_poll_addr();
                break;

            case 'V' :
                validate_record();
                break;
        }
    }
}
",second_chance
246,"/*
 * Program Name:
 *  CS 207 (Lec 001) - Project
 *  Cyborg Headpiece (cs207-2017-project)
 *  
 * Description:
 *  A cyborg headpiece, by my definition, will be a piece of 
 *   wearable technology, affixed to the head of the wearer, 
 *   but made to look as though it is integrated into the 
 *   flesh of the wearer.
 *   
 *   This sketch will take inputs from an accelerometer and
 *    a microphone, and then react to the inputs by driving
 *    a NeoPixel Ring and NeoPixel Matrix respectively.
 * 
 * 
 * Legend:
 *  (cp)  - Adafruit Circuit Playground - Developer Edition
 *  (nps) - Adafruit NeoPixel Shield for Arduino - 40 RGB LED Pixel Matrix
 *  (npr) - Adafruit NeoPixel Ring - 24 x 5050 RGB LED
 * 
 * Setup:
 *  Connect Ext on (nps) to GND on (cp)
 *  Connect 5V on (nps) to VBATT on (cp)
 *  Connect Din on (nps) to #6 on (cp)
 *  
 *  Connect GND on (npr) to GND on (cp)
 *  Connect PWR +5V on (npr) to VBATT on (cp)
 *  Connect Data Input on (npr) to #3 on (cp)
 *  
 *  
 * Date:
 *  2017-04-05
 * 
 * Name:
 *  <NAME>
 * 
 */

// Include Adafruit libraries for operation of Circuit Playground
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>

// Serial Communication details
const int baud = 9600;

// Which pins are connected to what
const int pinShield = 6;
const int pinRing = 3;

// Stored time counts
unsigned long previousMillisCPNeoPixel;
unsigned long previousMillisShield;
unsigned long previousMillisRing;

// Motion delay thresholds
int holdCPNeoPixel;
int holdShield;
int holdRing;

// The NeoPixel on the Circuit Playground details
const int cpNeoPixelCount = 10;
int cpNeoPixel;
int cpNeoPixelColor;

// Adafruit NeoPixel Shield for Arduino - 40 RGB LED Pixel Matrix details
const int shieldRows = 8;
const int shieldCols = 5;
int shieldTotal = shieldRows * shieldCols;
Adafruit_NeoPixel shield = Adafruit_NeoPixel(shieldTotal, pinShield, NEO_GRB + NEO_KHZ800);
int shieldY;  // corresponds with rows
int shieldX;  // corresponds with cols

// Adafruit NeoPixel Ring - 24 x 5050 RGB LED details
const int ringTotal = 24;
Adafruit_NeoPixel ring = Adafruit_NeoPixel(ringTotal, pinRing, NEO_GRB + NEO_KHZ800);
int ringX;

// Mode details
boolean mode1State;
boolean mode2State;

// Mode details - Dot
int dotDirection;
boolean dotDouble;

// Sound mechanism details
const int soundSensorThresh = 339;
const int soundSensorRange = 125;
int soundSensorMax = soundSensorThresh + (soundSensorRange / 2);
int soundSensorMin = soundSensorThresh - (soundSensorRange / 2);

// Sound mechanism details - Bars
const int soundBarNeoPixelCols = shieldCols;
float soundBarNeoPixelColRatio[] = { 0.45, 0.85, 1.0, 0.85, 0.45 };
const int soundBarNeoPixelCount = shieldRows;
int soundBarNeoPixelMin = 0;
int soundBarNeoPixelMax = soundBarNeoPixelCount - 1;
float soundBarNeoPixelMid = soundBarNeoPixelMax / 2.0;

// sound bar active is used as follows:
//   0 - inactive
//   1 - active, bar goes up
//  -1 - active, bar goes down
int soundBarActive;
float soundBarRaw;
boolean soundBarPeakLoActive;
float soundBarPeakLo;
boolean soundBarPeakHiActive;
float soundBarPeakHi;
const int soundBarDropRate = 1;

// Accelerometer mechanism details
const float accelThresh = 0.5;
const float accelSensitivity = 0.03;
float accelX;  // + is force in direction towards power connector; - is force in direction towards microUSB connector
float accelY;  // + is force in direction towards pin #6 & #9; - is force in direction towards pin #0 & #2
float accelZ;  // + is force in direction below playground; - is force in direction above playground

// Accelerometer mechanism details - Dots
const int accelDotXColor = 0;
float accelDotX;
const int accelDotYColor = 85;
float accelDotY;
const int accelDotZColor = 171;
float accelDotZ;

// If this is true, debug mode is on
boolean stateDebug = false;


void setup() {
  // run once at beginning

  // prepare serial output
  Serial.begin(baud);
  Serial.println(""Begin program"");

  // initialize Circuit Playground
  CircuitPlayground.begin();

  // initialize NeoPixel Shield
  shield.begin();
  shield.show();  // Initialize all pixels to 'off'

  // initialize NeoPixel Ring
  ring.begin();
  ring.show();  // Initialize all pixels to 'off'

  // setting initial values for variables
  previousMillisShield = 0;
  previousMillisRing = 0;
  previousMillisCPNeoPixel = 0;
  holdShield = 300;
  holdRing = 50;
  holdCPNeoPixel = 75;

  cpNeoPixel = 0;
  cpNeoPixelColor = 0;
  shieldX = 3;
  shieldY = 0;
  ringX = 0;

  mode1State = false;
  mode2State = false;
  dotDirection = 1;
  dotDouble = false;

  soundBarActive = 0;
  soundBarRaw = soundBarNeoPixelMid;
  soundBarPeakLoActive = false;
  soundBarPeakLo = soundBarNeoPixelMid;
  soundBarPeakHiActive = false;
  soundBarPeakHi = soundBarNeoPixelMid;

  accelX = 0;
  accelY = 0;
  accelZ = 0;
  accelDotX = 0;
  accelDotY = 0;
  accelDotZ = 0;
}


void loop() {
  // run repeatedly

  // determine current time count
  unsigned long currentMillis = millis();

  // detect inputs
  boolean stateSwitch = CircuitPlayground.slideSwitch();
  boolean stateButton1 = CircuitPlayground.leftButton();
  boolean stateButton2 = CircuitPlayground.rightButton();
  int stateSoundSensor = CircuitPlayground.soundSensor();
  float stateMotionX = CircuitPlayground.motionX();
  float stateMotionY = CircuitPlayground.motionY();
  float stateMotionZ = CircuitPlayground.motionZ();

  // switch holds state, or releases state
  if (stateSwitch) {
    // check buttons
    if (stateButton1 != mode1State) {
      if (stateButton1) {
        // change direction of playground pattern
        dotDirection *= -1;
      }
    }
    if (stateButton2 != mode2State) {
      if (stateButton2) {
        // toggle double of playground pattern
        if (dotDouble) {
          dotDouble = false;
        } else {
          dotDouble = true;
        }
      }
    }

    // update mode states
    mode1State = stateButton1;
    mode2State = stateButton2;

    // run Circuit Playground NeoPixel reactor
    cpNeoPixelDisplay(currentMillis);

    // run sound reactor
    shieldDisplay(currentMillis, stateSoundSensor);

    // run accelerometer reactor
    ringDisplay(currentMillis, stateMotionX, stateMotionY, stateMotionZ);
  }


/*
  // debuging code for displays
  if (stateDebug) {
    int pixel = 0;

    if (stateSwitch) {
      pixel = 5;
    }

    CircuitPlayground.clearPixels();
    CircuitPlayground.setPixelColor(pixel, CircuitPlayground.colorWheel(0));
  }
*/

  // send message to serial output
  if (stateDebug) {
    // accelerometer details
    Serial.println();
    Serial.print(""Switch: "");
    Serial.print(stateSwitch);
    Serial.print(""  But 1: "");
    Serial.print(stateButton1);
    Serial.print(""  But 2: "");
    Serial.println(stateButton2);

    delay(120);
  }
}


void cpNeoPixelDisplay(unsigned long currentMillis) {
  // update Circuit Playground NeoPixels

  // change NeoPixel to illuminate
  if (currentMillis - previousMillisCPNeoPixel > holdCPNeoPixel) {
    previousMillisCPNeoPixel = currentMillis;

    cpNeoPixel += dotDirection;
    if (cpNeoPixel < 0) {
      cpNeoPixel += cpNeoPixelCount;
    }
    if (cpNeoPixel >= cpNeoPixelCount) {
      cpNeoPixel -= cpNeoPixelCount;
    }
  }

  // change colour of NeoPixel
  cpNeoPixelColor++;
  if (cpNeoPixelColor >= 255) {
    cpNeoPixelColor = 0;
  }

  // update NeoPixels
  CircuitPlayground.clearPixels();
  CircuitPlayground.setPixelColor(cpNeoPixel, CircuitPlayground.colorWheel(cpNeoPixelColor));
  if (dotDouble) {
    CircuitPlayground.setPixelColor(cpNeoPixelCount - cpNeoPixel - 1, CircuitPlayground.colorWheel(cpNeoPixelColor));
  }
}


int shieldPixel(int row, int col) {
  // return the NeoPixel number for the desired row and col
  // remember that row 0 is first row, and col 0 is first col
  int pixel = (col * shieldRows) + row;
  return pixel;
}

void shieldDisplay(unsigned long currentMillis, int valueRaw) {
  // update shield display based on sound sensor value

  // map raw value to sound bar raw value
  soundBarRaw = float(soundBarNeoPixelMax - soundBarNeoPixelMin) / float(soundSensorMax - soundSensorMin) * float(valueRaw - soundSensorMin) + float(soundBarNeoPixelMin);

  // if sound bar raw value is outside range, limit
  soundBarRaw = constrain(soundBarRaw, soundBarNeoPixelMin - (soundBarNeoPixelCount / 2), soundBarNeoPixelMax + (soundBarNeoPixelCount / 2));

  // decide if live bar should show something
  //  0 - no bar
  //  1 - bar above middle
  // -1 - bar below middle
  float soundBarActiveTest = (soundBarRaw - soundBarNeoPixelMid) * 10.0;
  if (abs(soundBarActiveTest) < 10) {
    soundBarActive = 0;
  } else {
    soundBarActive = abs(soundBarActiveTest) / soundBarActiveTest;
  }

  // slowly drop peak bars towards middle
  if (currentMillis - previousMillisShield > holdShield) {
    previousMillisShield = currentMillis;

    soundBarPeakLo += soundBarDropRate;
    if (soundBarPeakLo > soundBarNeoPixelMid) {
      soundBarPeakLo = soundBarNeoPixelMid;
      soundBarPeakLoActive = false;
    }

    soundBarPeakHi -= soundBarDropRate;
    if (soundBarPeakHi < soundBarNeoPixelMid) {
      soundBarPeakHi = soundBarNeoPixelMid;
      soundBarPeakHiActive = false;
    }
  }

  // if live bar is active, update appropriate peak bar, if necessary
  if (soundBarActive != 0) {
    if (soundBarActive > 0) {
      soundBarPeakHi = max(soundBarPeakHi, soundBarRaw);
      soundBarPeakHiActive = true;
    } else {
      soundBarPeakLo = min(soundBarPeakLo, soundBarRaw);
      soundBarPeakLoActive = true;
    }
  }

  // draw bars on shield
  for (int i = 0; i < soundBarNeoPixelCols; i++) {
    float ratio = soundBarNeoPixelColRatio[i];
    float ratioPeakLo = (soundBarPeakLo - soundBarNeoPixelMid) * ratio + soundBarNeoPixelMid;
    float ratioPeakHi = (soundBarPeakHi - soundBarNeoPixelMid) * ratio + soundBarNeoPixelMid;
    float ratioRaw = (soundBarRaw - soundBarNeoPixelMid) * ratio + soundBarNeoPixelMid;

    for (int j = 0; j < soundBarNeoPixelCount; j++) {
      // set default colour to black
      int pickColor = 0;

      // if within peak bar ranges, change to peak colour
      if (soundBarPeakLoActive) {
        if ((j >= ratioPeakLo) && (j < soundBarNeoPixelMid)) {
          pickColor = 1;
        }
      }
      if (soundBarPeakHiActive) {
        if ((j <= ratioPeakHi) && (j > soundBarNeoPixelMid)) {
          pickColor = 1;
        }
      }

      // if within live bar range, change to live colour
      if (soundBarActive != 0) {
        if (soundBarActive > 0) {
          if ((j <= ratioRaw) && (j > soundBarNeoPixelMid)) {
            pickColor = 2;
          }
        } else {
          if ((j >= ratioRaw) && (j < soundBarNeoPixelMid)) {
            pickColor = 2;
          }
        }
      }

      int soundBarNeoPixelColorR;
      int soundBarNeoPixelColorG;
      int soundBarNeoPixelColorB;
      switch (pickColor) {
        case 1:  // red
          soundBarNeoPixelColorR = 63;
          soundBarNeoPixelColorG = 0;
          soundBarNeoPixelColorB = 0;
          break;
        case 2:  // green
          soundBarNeoPixelColorR = 0;
          soundBarNeoPixelColorG = 255;
          soundBarNeoPixelColorB = 0;
          break;
        default:  // black
          soundBarNeoPixelColorR = 0;
          soundBarNeoPixelColorG = 0;
          soundBarNeoPixelColorB = 0;
          break;
      }

      // update NeoPixel colour (does not update shield immediately)
      int pixel = shieldPixel(j, i);
      shield.setPixelColor(pixel, soundBarNeoPixelColorR, soundBarNeoPixelColorG, soundBarNeoPixelColorB);
    }
  }

  // update shield
  shield.show();
}


void ringDisplay(unsigned long currentMillis, float valueX, float valueY, float valueZ) {
  // update ring display based on accelerometer values

  // slow down the movements
  if (currentMillis - previousMillisRing > holdRing) {
    previousMillisRing = currentMillis;

    // turn off dots
    ring.setPixelColor(accelX, 0, 0, 0);
    ring.setPixelColor(accelY, 0, 0, 0);
    ring.setPixelColor(accelZ, 0, 0, 0);

    // accelerometer values are greater than threshold, move dot
    if (abs(valueX) > accelThresh) {
      accelX += valueX * accelSensitivity;

      if (accelX < 0) {
        accelX += ringTotal;
      }
      if (accelX > ringTotal) {
        accelX -= ringTotal;
      }
    }
    if (abs(valueY) > accelThresh) {
      accelY += valueY * accelSensitivity;

      if (accelY < 0) {
        accelY += ringTotal;
      }
      if (accelY > ringTotal) {
        accelY -= ringTotal;
      }
    }
    if (abs(valueZ) > accelThresh) {
      accelZ += valueZ * accelSensitivity;

      if (accelZ < 0) {
        accelZ += ringTotal;
      }
      if (accelZ > ringTotal) {
        accelZ -= ringTotal;
      }
    }
  }

  // find integers from tracked values
  int dotX = accelX;
  int dotY = accelY;
  int  [MASK]  = accelZ;

  // in case of overlapping, add colours together
  if (dotX == dotY) {
    if (dotX ==  [MASK] ) {
      ring.setPixelColor(dotX, 255, 255, 255);
    } else {
      ring.setPixelColor(dotX, 255, 0, 255);
      ring.setPixelColor( [MASK] , 0, 255, 0);
    }
  } else {
    if (dotX ==  [MASK] ) {
      ring.setPixelColor(dotX, 255, 255, 0);
      ring.setPixelColor(dotY, 0, 0, 255);
    } else {
      if (dotY ==  [MASK] ) {
        ring.setPixelColor(dotX, 255, 0, 0);
        ring.setPixelColor(dotY, 0, 255, 255);
      } else {
        ring.setPixelColor(dotX, 255, 0, 0);
        ring.setPixelColor(dotY, 0, 0, 255);
        ring.setPixelColor( [MASK] , 0, 255, 0);
      }
    }
  }

  // update ring
  ring.show();
}

",dotZ
247,"#include <AccelStepper.h>
#include <SoftwareSerial.h>
#include <FastLED.h>
#include <string.h>
SoftwareSerial Serial2(3,4); // RX,TX
#include ""Countimer.h""
Countimer DippingTimer;
Countimer LiftingTimer;
Countimer TrayTimer;

#define LED_PIN A0
#define NUM_LEDS A1
#define BUZZER_PIN 5
#define HALL_SENSOR 6
#define TRAY_HALL_SENSOR 7
CRGB leds[NUM_LEDS];

int EN_1 = 8;
int EN_2 = 9;
int STEP_1 = 10;
int STEP_2 = 11;
int DIR_1 = 12;
int DIR_2 = 13;

AccelStepper myStepper(1, STEP_1, DIR_1); //Number of Motors,StepPin,DirPin
AccelStepper myStepper_2(1, STEP_2, DIR_2);

const byte numChars = 200;
char receivedChars[numChars];
char tempChars[numChars];
int valuesCount = 0;
bool dataarrived=0;
float Data[74]={0.0};
boolean newData = false;
long Homing=-1;
long TrayHoming=-1;
int Cycles=0;
bool Dipped=1;
bool Withdraw=1;
bool flage=1;
bool flage2=1;
bool flage3=0;
bool flage4=1;
bool flage5=0;
bool flage6=0;
bool Donesim=1;
bool activelight=0;
int count=0;
char global_rc;
int total_cycle_count = 1;
int currentPosition = 0;

void setup() {
  pinMode(EN_1, OUTPUT);
  digitalWrite(EN_1, LOW);
  pinMode(EN_2, OUTPUT);
  digitalWrite(EN_2, LOW);
  pinMode(BUZZER_PIN,OUTPUT);
  //FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
  pinMode(HALL_SENSOR, INPUT);
  pinMode(TRAY_HALL_SENSOR, INPUT);
  homefunction();
  Serial.begin(9600);
  Serial2.begin(9600);
  //DippingTimer.setCounter(0, 0, 10, DippingTimer.COUNT_UP, onComplete); 
  //LiftingTimer.setCounter(0, 0, 10, LiftingTimer.COUNT_UP, onComplete1);
  DippingTimer.setInterval(DippingTimeDisp, 1000);   // For Displaying Time every 1sec
  LiftingTimer.setInterval(LiftingTimeDisp, 1000);
  TrayTimer.setInterval(TrayTimeDisp, 1000);
}

void loop() {
  DippingTimer.run();
  LiftingTimer.run();
  recvWithStartEndMarkers();
  if (newData == true){
    memcpy(tempChars, receivedChars, numChars * sizeof(char));
    parseData();
    showParsedData();
    flage=1;
    flage2=1;
    flage3=1;
    flage4=1;
    flage5=1;
    Donesim=1;
    Cycles=0;
    count=0;
    currentPosition = myStepper.currentPosition();
    newData = false;
  }
  
  CheckCycle(0);
  CheckCycle(6);
  CheckCycle(12);
  CheckCycle(18);
  CheckCycle(24);
  CheckCycle(30);

  if(Donesim==1){
    if(count==0){
      Serial2.print(""n2.val=1\xFF\xFF\xFF"");
      Sumulation(2);
    }
    else if(count==1){
      Serial2.print(""n2.val=2\xFF\xFF\xFF"");
      Sumulation(9);
    }
    else if(count==2){
      Serial2.print(""n2.val=3\xFF\xFF\xFF"");
      Sumulation(16);
    }
    else if(count==3){
      Serial2.print(""n2.val=4\xFF\xFF\xFF"");
      Sumulation(23);
    }
  }
  
  if(activelight==1){
    for (int i = 2; i >= 0; i--) {
      leds[i] = CRGB ( 0, 0, 255);
      FastLED.show();
      activelight=0;
    }
  }
}

void recvWithStartEndMarkers() {
  static boolean  [MASK]  = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (Serial2.available() > 0) {
    rc = Serial2.read();
    delay(1);
    if (rc == startMarker) {
       [MASK]  = true;
    }
    else if ( [MASK]  == true) {
      if (rc != endMarker) {
        receivedChars[ndx] = rc;
        ndx++;
        if (ndx >= numChars) {
          ndx = numChars - 1;
        }
      }
      else {
        receivedChars[ndx] = '\0'; // terminate the string
        Serial.println(receivedChars);
         [MASK]  = false;
        ndx = 0;
        newData = true;
      }
    }
    if (rc=='U'){
      Serial.println(""Move Up"");
      MoveUp();
    }
    else if (rc=='D'){
      Serial.println(""Move Down"");
      MoveDown();
    }
    else if (rc=='H'){
      Serial.println(""Homing"");
      homefunction();
    }
    else if (rc=='S'){
      Serial.println(""Stop"");
      StopMotor();           
    }
    else if (rc=='R'){
      Serial.println(""Sound"");
      if(flage6==0){
        flage6=1;
      }
      else{
        tone(BUZZER_PIN, 350); // Send 1KHz sound signal...
        delay(1000);        // ...for 1 sec
        noTone(BUZZER_PIN);     // Stop sound...
        flage6=0;
      }
    }
    else if (rc=='Q'){
      Serial.println(""LED"");
    }
    else if(rc=='g'){
      Donesim=0;
      Data[74]={0.0};
      homefunction();
    }
    global_rc=rc;
  }
}
void parseData() {      // split the data into  parts and convert it to Float
  char * strtokIndx; //  strtok()  index
  strtokIndx = strtok(tempChars,"","");
  while (strtokIndx != NULL && valuesCount < 74){
    Data[valuesCount++] = atof(strtokIndx);
    strtokIndx = strtok(NULL, "","");
  }
  valuesCount = 0; // Reset the Count
  Data[0]='X';
  Data[2]='Y';
  Data[4]='Z';
  Data[6]='A';
  Data[13]='B';
  Data[20]='C';
  Data[27]='D';
  Data[34]='m';
  Data[36]='h';
  Data[38]='t';
  Data[44]='e';
  Data[50]='p';
  Data[56]='y';
  Data[62]='s';
  Data[68]='w';
}

void showParsedData() {   // For Deubgging
  for(int e = 0;e<74;e++){
    Serial.print(Data[e]);
    Serial.print("" "");
  }
  Serial.println();
}

void DippingTimeDisp(){ // Displaying Dipping Time
   Serial2.print(""n0.val="");
   Serial2.print(DippingTimer.getCurrentSeconds());
   Serial2.print(""\xFF\xFF\xFF"");
}
void LiftingTimeDisp(){ // Displaying Lifting Time
   Serial2.print(""n0.val="");
   Serial2.print(LiftingTimer.getCurrentSeconds());
   Serial2.print(""\xFF\xFF\xFF"");
}
void TrayTimeDisp(){ // Displaying Lifting Time
   Serial2.print(""n4.val="");
   Serial2.print(TrayTimer.getCurrentSeconds());
   Serial2.print(""\xFF\xFF\xFF"");
}

void onComplete() { // For Deubgging 
}

void onComplete1() { // For Deubgging 
}
void onComplete2() { // For Deubgging 
}
void onComplete3() { // For Deubgging 
}


void homefunction() {
  for (int i = 2; i >= 0; i--) {
    leds[i] = CRGB ( 255, 0, 0);
    FastLED.show();
  }

  while (digitalRead(HALL_SENSOR) == LOW) {
    myStepper.setMaxSpeed(1000);
    myStepper.setAcceleration(2000);
    myStepper.moveTo(Homing); //CCW
    Homing--;
    myStepper.run();
  }
  myStepper.setCurrentPosition(0); //reset postion
  TrayHome();

  myStepper_2.setMaxSpeed(200);
  myStepper_2.setAcceleration(200);
  myStepper_2.moveTo(450); //CW 1mm increment
  myStepper_2.runToPosition();
  myStepper.setMaxSpeed(1000);
  myStepper.setAcceleration(2000);
  myStepper.moveTo(5250); //CW 1mm increment
  myStepper.runToPosition();
  
  myStepper.setCurrentPosition(0); //reset postion
  myStepper_2.setCurrentPosition(0); //reset postion
  activelight=1;
}

void LiftHome(){
  while (digitalRead(HALL_SENSOR) == LOW) {
    myStepper.setMaxSpeed(1000);
    myStepper.setAcceleration(2000);
    myStepper.moveTo(Homing); //CCW
    Homing--;
    myStepper.run();
  }
  Homing=0;
  while (digitalRead(HALL_SENSOR) == HIGH) {
    myStepper.setMaxSpeed(1000);
    myStepper.setAcceleration(2000);
    myStepper.moveTo(Homing); //CCW
    Homing++;
    myStepper.run();
  }
}

void TrayHome(){
  while(digitalRead(TRAY_HALL_SENSOR) == LOW){ //if else atılacak pinleri ayırmak için !
    myStepper_2.setMaxSpeed(250);
    myStepper_2.setAcceleration(125);
    myStepper_2.moveTo(TrayHoming); //CW 1mm increment
    TrayHoming--;
    myStepper_2.run();
  }
  myStepper_2.setCurrentPosition(0); //reset postion
}
void MoveUp(){
    myStepper.setCurrentPosition(0); //reset postion 
    myStepper.setMaxSpeed(1000);
    myStepper.setAcceleration(2000);
    myStepper.moveTo(-4000); //CCW 10mm increment 
    while( myStepper.distanceToGo() !=0 && digitalRead(HALL_SENSOR) == 0 && Serial2.available()==0 ){
     myStepper.run();
  } 
   myStepper.setCurrentPosition(0); //reset postion 
}
void MoveDown(){
    myStepper.setCurrentPosition(0); //reset postion 
    myStepper.setMaxSpeed(1000);
    myStepper.setAcceleration(2000);
    myStepper.moveTo(4000);
    while( myStepper.distanceToGo() !=0 && Serial2.available()==0){
      myStepper.run();
    }
   myStepper.setCurrentPosition(0); //reset postion 
}
void StopMotor(){
   myStepper.setCurrentPosition(0); //reset postion 
   myStepper.stop();
}
void StopMotor_2(){
   myStepper_2.setCurrentPosition(0); //reset postion 
   myStepper_2.stop();
}
void motor_tray_move(){
  myStepper_2.setCurrentPosition(0);
  myStepper_2.setMaxSpeed(200);
  myStepper_2.setAcceleration(200);
  myStepper_2.moveTo(725); //CCW 10mm increment
  while( myStepper_2.distanceToGo() !=0 && digitalRead(TRAY_HALL_SENSOR) == 0){ //Hall Sensör kontrol edilecek, diğer motor en tepeye ulaştığında dönmesi lazım
    myStepper_2.run();
  }
  myStepper_2.setCurrentPosition(0); //reset postion 
}

void reverse_motor_tray_move(){
  myStepper_2.setCurrentPosition(0);
  myStepper_2.setMaxSpeed(200);
  myStepper_2.setAcceleration(200);
  myStepper_2.moveTo(-725); //CW 10mm increment
  while( myStepper_2.distanceToGo() !=0 && digitalRead(TRAY_HALL_SENSOR) == 0){ //Hall Sensör kontrol edilecek, diğer motor en tepeye ulaştığında dönmesi lazım
    myStepper_2.run();
  }
  myStepper_2.setCurrentPosition(0); //reset postion
}

void reset() {
  flage = 1;
  flage2 = 1;
  flage3 = 1;
  flage4 = 0;
  flage5 = 1;
  Cycles = 0;
  Dipped = 1;
  Withdraw = 1;
  Donesim = 1;
  // Reset Nextion screen values
  DippingTimer.setInterval(DippingTimeDisp, 1000);   // For Displaying Time every 1sec
  LiftingTimer.setInterval(LiftingTimeDisp, 1000);
  TrayTimer.setInterval(TrayTimeDisp, 1000);
}

void Done(){
  Donesim=0;
  Serial2.print(""n0.val=0\xFF\xFF\xFF"");
  Serial2.print(""n1.val=0\xFF\xFF\xFF"");
  Serial2.print(""n2.val=0\xFF\xFF\xFF"");
  Serial2.print(""n3.val=0\xFF\xFF\xFF"");
  Serial2.print(""n4.val=0\xFF\xFF\xFF"");
  Serial2.print(""t10.txt="");
  Serial2.print(""\"""");
  Serial2.print(""Done"");
  Serial2.print(""\"""");
  Serial2.print(""\xFF\xFF\xFF"");
  /*Homing=0;
  TrayHoming=0;
  while (digitalRead(HALL_SENSOR) == LOW) {
    myStepper.setMaxSpeed(500);
    myStepper.setAcceleration(1000); 
    myStepper.moveTo(Homing); //CCW
    Homing--;
    myStepper.run();
  }
  while (digitalRead(TRAY_HALL_SENSOR) == LOW) {
    myStepper_2.setMaxSpeed(200);
    myStepper_2.setAcceleration(200);
    myStepper_2.moveTo(TrayHoming); //CW 1mm increment
    TrayHoming--;
    myStepper_2.run();
  }
  myStepper.setCurrentPosition(0); //reset postion
  myStepper.setMaxSpeed(1000);
  myStepper.setAcceleration(2000);
  myStepper.moveTo(5250);
  while( myStepper.distanceToGo() !=0 && Serial2.available()==0){
    myStepper.run();
  }

  myStepper_2.setCurrentPosition(0); //reset postion
  myStepper_2.setMaxSpeed(200);
  myStepper_2.setAcceleration(200);
  myStepper_2.moveTo(375);
  while( myStepper_2.distanceToGo() !=0 && Serial2.available()==0){
    myStepper_2.run();
  }
  */
  myStepper.setCurrentPosition(0); //reset postion
  myStepper_2.setCurrentPosition(0); //reset postion
  if(flage6==0){
    while(true){
      tone(BUZZER_PIN, 350); // Send 1KHz sound signal...
      delay(1000);        // ...for 1 sec
      noTone(BUZZER_PIN);     // Stop sound...
      delay(300);
      global_rc = Serial2.read();
      if(global_rc=='k' || global_rc=='o'){
        homefunction();
        break;
      }
    }
    noTone(BUZZER_PIN);
  }
}

void Next(){
  Serial2.print(""page 4""); // Upload Simulation Screen In Nextion Display 
  Serial2. print(""\xFF\xFF\xFF"");
  Serial2.print(""n4.val=0\xFF\xFF\xFF"");
  Serial2.print(""n3.val="");
  Serial2.print(total_cycle_count);
  Serial2.print(""\xFF\xFF\xFF"");
  Serial2.print(""t10.txt="");
  Serial2.print(""\"""");
  Serial2.print(""Next"");
  Serial2.print(""\"""");
  Serial2.print(""\xFF\xFF\xFF"");
}

void TimerSet(){
  Serial2.print(""n0.val=0\xFF\xFF\xFF"");
  Serial2.print(""n1.val=0\xFF\xFF\xFF"");
  Serial2.print(""n2.val=0\xFF\xFF\xFF"");
}

void TrayCheck(){
  if(count == 0){
    if(Data[7] == 0 || (Data[14]!=0 || Data[21]!=0 || Data[28]!=0) || global_rc!='g'){
      Serial.println(""Hoşgeldin Ebubekir Sıddık Bebek"");
      reset();
      Next();
      LiftHome();
      motor_tray_move();
    }
    else{
      //Done();
    }
  }
  else if(count == 1){
    if(Data[21]!=0 || Data[28]!=0 || global_rc!='g'){
      Serial.println(""Şemseddin"");
      reset();
      Next();
      LiftHome();
      motor_tray_move();
    }
    else{
      //Done();
    }
  }

  else if(count == 2){
    if(Data[28]!=0 || global_rc!='g'){
      Serial.println(""Fatih Sultan Mehmet"");
      reset();
      Next();
      LiftHome();
      reverse_motor_tray_move();
    }
    else{
      //Done();
    }
  }
}

void CheckCycle(int a){
  if(Data[39+a]==total_cycle_count && total_cycle_count!=Data[35]){
    if(Data[40+a]==0 && count==0){
      count=1;
      Serial.println(""BOM-1"");
      LiftHome();
      motor_tray_move();
    }
    else if(Data[41+a]==0 && count==1){
      count=2;
      Serial.println(""BOM-2"");
      LiftHome();
      motor_tray_move();
    }
    else if(Data[42+a]==0 && count==2){
      count=3;
      Serial.println(""BOM-3"");
      LiftHome();
      reverse_motor_tray_move();
    }
    else if(Data[43+a]==0 && count==3){
      count=0;
      total_cycle_count++;
      Serial.println(""BOM-4"");
      TrayTimer.setCounter(0, 0, Data[37], TrayTimer.COUNT_DOWN, onComplete2);
      TrayTimer.start();
      TimerSet();
      for(int i = 0;i < 5*Data[37];i+=1){
        TrayTimer.run();
        TrayTimer.setInterval(TrayTimeDisp, 1000);
        delay(200);
      }
      Serial2.print(""n0.val=0\xFF\xFF\xFF"");
      Serial2.print(""n1.val=0\xFF\xFF\xFF"");
      Serial2.print(""n2.val=0\xFF\xFF\xFF"");
      Serial2.print(""n3.val="");
      Serial2.print(total_cycle_count);
      Serial2.print(""\xFF\xFF\xFF"");
      Serial2.print(""n4.val=0\xFF\xFF\xFF"");
      Serial2.print(""t10.txt="");
      Serial2.print(""\"""");
      Serial2.print(""NC"");
      Serial2.print(""\"""");
      Serial2.print(""\xFF\xFF\xFF"");
      LiftHome();
      while (digitalRead(TRAY_HALL_SENSOR) == LOW) {
        myStepper_2.setMaxSpeed(200);
        myStepper_2.setAcceleration(200);
        myStepper_2.moveTo(TrayHoming); //CW 1mm increment
        TrayHoming--;
        myStepper_2.run();
      }
      myStepper_2.setCurrentPosition(0); //reset postion
      myStepper_2.setMaxSpeed(200);
      myStepper_2.setAcceleration(200);
      myStepper_2.moveTo(400);
      while( myStepper_2.distanceToGo() !=0 && Serial2.available()==0){
        myStepper_2.run();
      }
      reset();
    }
  }
}

void Sumulation(int t){

  Serial2.print(""n3.val="");
  Serial2.print(total_cycle_count);
  Serial2.print(""\xFF\xFF\xFF"");

  if(Data[5+t]>0 && Data[6+t]>0 && Data[7+t]>0 && Data[8+t]>0 && Data[9+t]>0 && Data[5+t]<=20 && Data[8+t]<=20 && global_rc!='g'){
    if(Cycles<Data[10+t] && Data[10+t]>=1.0 ){
        if(flage==1){ // Upload the Simualtion Page for one time only 
        Serial2.print(""page 4""); // Upload Simulation Screen In Nextion Display 
        Serial2. print(""\xFF\xFF\xFF"");
        reset();
        for (int i = 0; i <= 2; i++) {
        leds[i] = CRGB ( 0, 255, 0);
        FastLED.show();
        }
        flage=0;
        }
        if(flage2==1){ // Setting the Time for the counter 
          DippingTimer.setCounter(0, 0, Data[7+t], DippingTimer.COUNT_DOWN, onComplete); 
          LiftingTimer.setCounter(0, 0, Data[9+t], LiftingTimer.COUNT_DOWN, onComplete1);
          flage2=0;
        }
        
    //////////////////// Dipping Process //////////////////////
      if(!DippingTimer.isCounterCompleted()){
        Serial2.print(""t10.txt="");
        Serial2.print(""\"""");
        Serial2.print(""Dip"");
        Serial2.print(""\"""");
        Serial2.print(""\xFF\xFF\xFF"");
      // myStepper.setCurrentPosition(0); //reset postion 
        if(Dipped==1){
          myStepper.setMaxSpeed(200*Data[5+t]);
          myStepper.setAcceleration(20000);
          myStepper.moveTo(200*Data[6+t]);
          while(myStepper.distanceToGo() !=0 ){
            myStepper.run();
            if(global_rc=='g'){
              myStepper.distanceToGo() == 0;
            }
          }
        }
        if(myStepper.distanceToGo() == 0 && Dipped==1){
          DippingTimer.start(); //Start The Dipping Time
          myStepper.setCurrentPosition(0); //reset postion 
          Dipped=0;
        }
      }
      
    //////////////////// Withdrawal Process //////////////////////
      if( DippingTimer.isCounterCompleted() && !LiftingTimer.isCounterCompleted() ){ 
        Serial2.print(""t10.txt="");
        Serial2.print(""\"""");
        Serial2.print(""Lift"");
        Serial2.print(""\"""");
        Serial2.print(""\xFF\xFF\xFF"");
        //myStepper.setCurrentPosition(0); //reset postion 
        if(Withdraw==1){
          myStepper.setMaxSpeed(200*Data[8+t]);
          myStepper.setAcceleration(20000); 
          myStepper.moveTo(-200*Data[6+t]); 
          while(myStepper.distanceToGo() !=0 &&  digitalRead(HALL_SENSOR) == 0 ){
            myStepper.run();
            if(global_rc=='g'){
              myStepper.distanceToGo() == 0;
            }
          }
        }
        if(myStepper.distanceToGo() == 0 &&  Withdraw==1){
          LiftingTimer.start(); //Start The Lifting Time
          myStepper.setCurrentPosition(0); //reset postion 
          Withdraw=0; 
        }
      }
    //////////////////// Reset Process ///////////////////////////
      if(DippingTimer.isCounterCompleted() && LiftingTimer.isCounterCompleted()){
            Cycles++;
            Serial2.print(""n1.val="");
            Serial2.print(Cycles);
            Serial2.print(""\xFF\xFF\xFF"");
            Dipped=1;
            Withdraw=1;
            DippingTimer.restart();
            LiftingTimer.restart();
            DippingTimer.pause();
            LiftingTimer.pause();
      }
    } else  if(Cycles>=Data[10+t] && Data[10+t]>=1){
        if(count==0){
          TrayTimer.setCounter(0, 0, Data[1], TrayTimer.COUNT_DOWN, onComplete2);
          TrayTimer.start();
          TimerSet();
          for(int i = 0;i < 5*Data[1];i+=1){
            TrayTimer.run();
            TrayTimer.setInterval(TrayTimeDisp, 1000);
            delay(200);
          }
          TrayCheck();
        }
        else if(count==1){
          TrayTimer.setCounter(0, 0, Data[3], TrayTimer.COUNT_DOWN, onComplete2);
          TrayTimer.start();
          TimerSet();
          for(int i = 0;i < 5*Data[3];i+=1){
            TrayTimer.run();
            TrayTimer.setInterval(TrayTimeDisp, 1000);
            delay(200);
          }
          TrayCheck();
        }
        else if(count==2){
          TrayTimer.setCounter(0, 0, Data[5], TrayTimer.COUNT_DOWN, onComplete2);
          TrayTimer.start();
          TimerSet();
          for(int i = 0;i < 5*Data[5];i+=1){
            TrayTimer.run();
            TrayTimer.setInterval(TrayTimeDisp, 1000);
            delay(200);
          }
          TrayCheck();
        }
        else if(count==3){
          if(total_cycle_count==Data[35]){
            total_cycle_count=1;
            flage3=0;
            Done();
          }
          else{
            total_cycle_count++;
            Serial.println(""Yukarı"");
            Serial.println(total_cycle_count);
            TrayTimer.setCounter(0, 0, Data[37], TrayTimer.COUNT_DOWN, onComplete2);
            TrayTimer.start();
            TimerSet();
            for(int i = 0;i < 5*Data[37];i+=1){
              TrayTimer.run();
              TrayTimer.setInterval(TrayTimeDisp, 1000);
              delay(200);
            }
            Serial2.print(""n0.val=0\xFF\xFF\xFF"");
            Serial2.print(""n1.val=0\xFF\xFF\xFF"");
            Serial2.print(""n2.val=0\xFF\xFF\xFF"");
            Serial2.print(""n3.val="");
            Serial2.print(total_cycle_count);
            Serial2.print(""\xFF\xFF\xFF"");
            Serial2.print(""n4.val=0\xFF\xFF\xFF"");
            Serial2.print(""t10.txt="");
            Serial2.print(""\"""");
            Serial2.print(""NC"");
            Serial2.print(""\"""");
            Serial2.print(""\xFF\xFF\xFF"");
            LiftHome();
            while (digitalRead(TRAY_HALL_SENSOR) == LOW) {
              myStepper_2.setMaxSpeed(200);
              myStepper_2.setAcceleration(200);
              myStepper_2.moveTo(TrayHoming); //CW 1mm increment
              TrayHoming--;
              myStepper_2.run();
            }
            myStepper_2.setCurrentPosition(0); //reset postion
            myStepper_2.setMaxSpeed(200);
            myStepper_2.setAcceleration(200);
            myStepper_2.moveTo(450);
            while( myStepper_2.distanceToGo() !=0 && Serial2.available()==0){
              myStepper_2.run();
            }
            count=-1;
            reset();
          }
        }
        Serial.println(""Sultan Selim geliyor!"");
        count++;
    }
  }
  else if(Data[5+t]<=0 || Data[6+t]<=0 || Data[7+t]<=0 || Data[8+t]<=0 || Data[9+t]<=0 || Data[5+t]>20 || Data[8+t]>20 || global_rc=='g'){
    Serial.println(count);
    if(count==3 && flage3==1){
      if(total_cycle_count==Data[35]){
        Serial.println(""69"");
        total_cycle_count=1;
        flage3=0;
        Done();
      }
      else{
        Serial.println(""77"");
        total_cycle_count++;
        Serial.println(""Aşağı"");
        Serial.println(total_cycle_count);
        TrayTimer.setCounter(0, 0, Data[37], TrayTimer.COUNT_DOWN, onComplete2);
        TrayTimer.start();
        TimerSet();
        for(int i = 0;i < 5*Data[37];i+=1){
          TrayTimer.run();
          TrayTimer.setInterval(TrayTimeDisp, 1000);
          delay(200);
        }
        Serial2.print(""n0.val=0\xFF\xFF\xFF"");
        Serial2.print(""n1.val=0\xFF\xFF\xFF"");
        Serial2.print(""n2.val=0\xFF\xFF\xFF"");
        Serial2.print(""n3.val="");
        Serial2.print(total_cycle_count);
        Serial2.print(""\xFF\xFF\xFF"");
        Serial2.print(""n4.val=0\xFF\xFF\xFF"");
        Serial2.print(""t10.txt="");
        Serial2.print(""\"""");
        Serial2.print(""NC"");
        Serial2.print(""\"""");
        Serial2.print(""\xFF\xFF\xFF"");
        LiftHome();
        while (digitalRead(TRAY_HALL_SENSOR) == LOW) {
          myStepper_2.setMaxSpeed(200);
          myStepper_2.setAcceleration(200);
          myStepper_2.moveTo(TrayHoming); //CW 1mm increment
          TrayHoming--;
          myStepper_2.run();
        }
        myStepper_2.setCurrentPosition(0); //reset postion
        myStepper_2.setMaxSpeed(200);
        myStepper_2.setAcceleration(200);
        myStepper_2.moveTo(450);
        while(myStepper_2.distanceToGo() !=0 && Serial2.available()==0){
          myStepper_2.run();
        }
        count=-1;
        reset();
      }
    }
    if(flage5==1){
      Serial.println(""Şakşuka"");
      TrayCheck();
    }
    count++;
    Serial.println(""Sultan Selim gelemedi!"");
  }
} //MS",recvInProgress
248,"/*
XBee TX test for a Arduino Mega2560 using Serial3 as the XBee serial
input for a Series 2 XBee.  This is NOT based on the examples that come with
the Arduino XBee library.

See, the examples there and most other places on the web SUCK.  Andrew's
library is much easier to use than the illustrations would lead you to believe.

This is a HEAVILY commented example of how send a text packet using series 2
XBees.  Series 1 XBees are left as an exercise for the student.
*/

#include <XBee.h>
#include <Console.h>
#include <SoftwareSerial.h>

SoftwareSerial mySerial(8, 9); // RX, TX

XBee xbee = XBee();
// This is the XBee broadcast address.  You can use the address
// of any device you have also.
XBeeAddress64 Broadcast = XBeeAddress64(0x00000000, 0x0000ffff);

char Hello[] = ""Hello World"";
char Buffer[128];  // this needs to be longer than your longest packet.

void setup() { 
  // start serial
  Bridge.begin();
  Console.begin();
  // and the software serial port
  mySerial.begin(9600);
  // now that they are started, hook the XBee into
  // Software Serial
  xbee.setSerial(mySerial);
  Console.println(""Initialization all done!"");
}

void loop() {
  ZBTxRequest  [MASK]  = ZBTxRequest(Broadcast, (uint8_t *)Hello, strlen(Hello));
  xbee.send( [MASK] );
  delay(2000);
  strcpy(Buffer,""I saw what you did last night."");
   [MASK]  = ZBTxRequest(Broadcast, (uint8_t *)Buffer, strlen(Buffer));
  xbee.send( [MASK] );
  delay(2000);
}

",zbtx
249,"#include ""http_server_interface.h""

Server_interface::Server_interface(std::string host, unsigned short port) {
	this->host = net::ip::make_address(host);
	this->port = port;
}

template <class Body, class Allocator>
http::message_generator Server_interface::handle_request(http::request<Body, http::basic_fields<Allocator>>&& request) {
	std::vector request_tokens = parse_request_string(request.target());
	
	try {
		if (request.target().empty() ||
			request.target()[0] != '/' ||
			request.target().find("".."") != beast::string_view::npos)
			throw Bad_request_error{ request.version(), request.keep_alive(), ""Illegal request-target"" };

		switch (request.method()) {
			case http::verb::get:
			{
				std::string response_body;
				if (request_tokens.size() == 3)
					response_body = mongo_schedule_db.query_document(request_tokens[PARITY], ""day"", request_tokens[DAY]);
				else if (request_tokens.size() < 3)
					response_body = mongo_schedule_db.query_collection(request_tokens[PARITY]);

				if (response_body == ""-1"")
					throw Resource_not_found_error{ request.version(), request.keep_alive(), ""Requested week type not found"" };

				http::response<http::string_body> response{
					std::piecewise_construct,
					std::make_tuple(std::move(response_body)),
					std::make_tuple(http::status::ok, request.version()),
				};
				response.set(http::field::server, ""RedArmy.il"");
				response.prepare_payload();
				response.keep_alive(response.keep_alive());
				return response;
			}
			break;

			case http::verb::post:
			{
				if (request_tokens[2] == ""add"") {
					std::cout << request.body() << std::endl;

					try {
						mongo_schedule_db.insert_collection(request_tokens[PARITY], request.body());
					} 
					catch (std::exception &e) {
						throw Internal_server_error{ request.version(), request.keep_alive(), ""Failed to load data from string"" };
					}
					
					http::response<http::string_body> response{
						http::status::ok, request.version(),
					};
					response.set(http::field::server, ""RedArmy.il"");
					response.body() = ""it is all OK!"";
					response.prepare_payload();
					response.keep_alive(response.keep_alive());
					return response;
				}
				else if (request_tokens.size() == 5 && request_tokens[4] == ""comment"") {
					try {
						mongo_schedule_db.add_comment(request_tokens[PARITY], request_tokens[DAY], request_tokens[CLASS_NUM], request.body());
					}
					catch (std::exception& e) {
						throw Internal_server_error{ request.version(), request.keep_alive(), ""Failed to load data from string"" };
					}

					http::response<http::string_body> response{
						http::status::ok, request.version(),
					};
					response.set(http::field::server, ""RedArmy.il"");
					response.body() = ""it is all OK!"";
					response.prepare_payload();
					response.keep_alive(response.keep_alive());
					return response;
				}
				else if (request_tokens[1] == ""drop"") {
					if (request_tokens.size() == 3) {
						mongo_schedule_db.drop_schedule(request_tokens[2]);
					}
					else {
						mongo_schedule_db.drop_schedule(""odd"", ""even"");
					}
					http::response<http::string_body> response{
						http::status::ok, request.version(),
					};
					response.set(http::field::server, ""RedArmy.il"");
					response.body() = ""it is all OK!"";
					response.prepare_payload();
					response.keep_alive(response.keep_alive());
					return response;
				}
				else {
					throw Internal_server_error{ request.version(), request.keep_alive(), ""OOPS! The developer is probably a dummy :3"" };
				}
			}
			break;
		}
	} 
	catch (Exception e) {
		return e.what();
	}
}

void fail(boost::beast::error_code ec, std::string what) {
	std::cout << what << "":"" << ec.message() << std::endl;
}

void Server_interface::manage_session(tcp::socket&& connection) {
	boost::beast::flat_buffer read_req_buffer;
	boost::beast::error_code ec;

	while (true) {
		http::request<http::string_body> request;
		http::read(connection, read_req_buffer, request, ec);

		if (ec == http::error::end_of_stream) break;
		if (ec) return fail(ec, ""read"");

		http::message_generator response_message = handle_request(std::move(request));

		bool keepalive = response_message.keep_alive();
		boost::beast::write(connection, std::move(response_message), ec);

		if (ec) return fail(ec, ""write"");

		if (!keepalive) break;
	}
	connection.shutdown(tcp::socket::shutdown_send);
}

void Server_interface::accept_connections() {
	tcp::acceptor  [MASK] { this->ioc, {this->host, this->port} };
	while (true) {
		tcp::socket new_connection{ this->ioc };
		 [MASK] .accept(new_connection);
		std::cout << ""Connected:"" << new_connection.remote_endpoint() << std::endl;

		std::thread thr(&Server_interface::manage_session, this, std::move(new_connection));
		thr.detach();
	}
}
	
",connections_acceptor
250,"#include<mysql.h>
#include<bits/stdc++.h>
#include<fstream>
#include<string>
#include ""header/Engineer.h""

MYSQL mysql;
MYSQL_RES *res;//这个结构代表返回行的一个查询结果集
MYSQL_ROW column;//一个行数据的类型安全(type-safe)的表示
using namespace std;

bool connectMysql();
void freeConnect();
bool updateData(const string& sql);
bool outMysql();
bool queryDatabase(const string& sql);

bool addEngineer(const Engineer& engineer);
void updateEngineerInfos(const string& engineer_number);
void updateEngineerInfo(const string& engineer_number);
void deleteEngineer(const string& engineer_number);
void sortByEngineer();
void selectEngineer();
void selectAllEngineer();
bool createFile();

int main() {
    bool page1 = true;
    connectMysql();
    while (page1) {
        cout << ""***********************"" << endl;
        cout << ""*欢迎来到软件工程师管理系统*"" << endl;
        cout << ""*****请选择以下功能：*****"" << endl;
        cout << ""***********************"" << endl;
        cout << ""***1、显示全部工程师信息***"" << endl;
        cout << ""***2、条件查询工程师信息***"" << endl;
        cout << ""***3、添加单个工程师信息***"" << endl;
        cout << ""***4、条件修改工程师信息***"" << endl;
        cout << ""***5、删除单个工程师信息***"" << endl;
        cout << ""***6、按条件排序薪水信息***"" << endl;
        cout << ""***7、导出目前工程师信息***"" << endl;
        cout << ""***8、退出工程师管理系统***"" << endl;
        cout << ""***********************"" << endl;
        cout << ""你的选择是："" << endl;
        int selection1 = 0;
        cin >> selection1;
        if (selection1 == 1) {
            selectAllEngineer();
            cout << ""查询完毕，输入任一数字返回主菜单……"" << endl;
            getchar();
            getchar();
        } else if (selection1 == 2) {
            bool page2 = true;
            while (page2) {
                selectEngineer();
                cout << ""是否继续查询？（是/否==1/其他数字）"" << endl;
                int selection2 = 0;
                cin >> selection2;
                if (selection2 == 1) {
                    continue;
                } else {
                    page2 = false;
                }
            }
        } else if (selection1 == 3) {
            bool page2 = true;
            while (page2) {
                Engineer engineer;
                int engineer_number = 0;
                cout << ""请输入工号："" << endl;
                bool page3 = true;
                while (page3) {
                    cin >> engineer_number;
                    if (engineer_number <= 0 || engineer_number > 1000) {
                        page3 = true;
                        cout << ""范围在0-1000，输入有误，请重新输入……"" << endl;
                    } else {
                        page3 = false;
                    }
                }
                engineer.setEngineerNumber(engineer_number);
                string engineer_name;
                string engineer_gender;
                string engineer_degree;
                int engineer_age;
                int engineer_salary;
                string engineer_address;
                string engineer_phone;
                cout << ""请输入姓名："" << endl;
                cin >> engineer_name;
                cout << ""请输入性别："" << endl;
                cin >> engineer_gender;
                cout << ""请输入学位："" << endl;
                cin >> engineer_degree;
                cout << ""请输入年龄："" << endl;
                cin >> engineer_age;
                cout << ""请输入薪水："" << endl;
                cin >> engineer_salary;
                cout << ""请输入地址："" << endl;
                cin >> engineer_address;
                cout << ""请输入电话："" << endl;
                cin >> engineer_phone;
                engineer.setEngineerName(engineer_name);
                engineer.setEngineerGender(engineer_gender);
                engineer.setEngineerDegree(engineer_degree);
                engineer.setEngineerAge(engineer_age);
                engineer.setEngineerSalary(engineer_salary);
                engineer.setEngineerAddress(engineer_address);
                engineer.setEngineerPhone(engineer_phone);
                addEngineer(engineer);
                cout << ""是否继续添加？（是/否==1/其他数字）"" << endl;
                int selection2 = 0;
                cin >> selection2;
                if (selection2 == 1) {
                    continue;
                } else {
                    page2 = false;
                }
            }
        } else if (selection1 == 4) {
            bool page2 = true;
            while (page2) {
                cout << ""请选择一下修改方式：（输入其他数字则表示退出选择）"" << endl;
                cout << ""1.全部信息修改"" << endl;
                cout << ""2.部分信息修改"" << endl;
                cout << ""你的选择是："" << endl;
                int selection2 = 0;
                cin >> selection2;
                if (selection2 == 1) {
                    cout << ""请输入需要修改的工程师工号："" << endl;
                    string engineer_number;
                    cin >> engineer_number;
                    updateEngineerInfos(engineer_number);
                } else if (selection2 == 2) {
                    cout << ""请输入需要修改的工程师工号："" << endl;
                    string engineer_number;
                    cin >> engineer_number;
                    updateEngineerInfo(engineer_number);
                } else {
                    cout << ""正在退出……"" << endl;
                    page2 = false;
                }
                cout << ""是否继续修改？（是/否==1/其他数字）"" << endl;
                cin >> selection2;
                if (selection2 == 1) {
                    continue;
                } else {
                    page2 = false;
                }
            }
        } else if (selection1 == 5) {
            bool page2 = true;
            while (page2) {
                cout << ""请输入你要删除的工程师工号："" << endl;
                string engineer_number;
                cin >> engineer_number;
                deleteEngineer(engineer_number);
                cout << ""是否继续删除？（是/否==1/其他数字）"" << endl;
                int selection2 = 0;
                cin >> selection2;
                if (selection2 == 1) {
                    continue;
                } else {
                    page2 = false;
                }
            }
        } else if (selection1 == 6) {
            bool page2 = true;
            while (page2) {
                sortByEngineer();
                cout << ""是否继续排序？（是/否==1/其他数字）"" << endl;
                int selection2 = 0;
                cin >> selection2;
                if (selection2 == 1) {
                    continue;
                } else {
                    page2 = false;
                }
            }
        } else if (selection1 == 7) {
            createFile();
            cout << ""保存成功，路径在D:\\work.txt！输入任一数字退出……"" << endl;
            getchar();
            getchar();
        } else if (selection1 == 8) {
            int selection2 = 0;
            cout << ""是否退出系统(是/否 == 1/其他数字)："" << endl;
            cin >> selection2;
            if (selection2 == 1) {
                page1 = false;
            } else {
                page1 = true;
                cout << ""取消退出成功！正在返回主菜单……"" << endl;
            }
        } else {
            page1 = true;
            cout << ""输入有误！输入任一数字返回主菜单……"" << endl;
            getchar();
            getchar();
        }
    }
    freeConnect();
    return 0;
}

/**
 * 获取数据库连接
 * @return
 */
bool connectMysql() {
    mysql_init(&mysql);//初始化mysql
    if (!(mysql_real_connect(&mysql,
                             ""localhost"",//主机
                             ""root"",//用户名
                             ""<PASSWORD>"",//密码
                             ""cpp_database"",//数据库名
                             3306,//端口号
                             nullptr, 0//最后两个参数的常用写法
    ))) {
        cout << ""连接数据库出错:"" + (string) mysql_error(&mysql) << endl;
        return false;
    } else {
        cout << ""已经连接数据库！"" << endl;
        return true;
    }
}

/**
 * 释放连接
 */
void freeConnect() {
    mysql_free_result(res);
    mysql_close(&mysql);
}

/**
 * 作更新操作
 * @param sql
 * @return
 */
bool updateData(const string& sql) {
    mysql_query(&mysql, ""set names gbk"");//设置编码格式 否则mysql里中文乱码
    // 执行SQL语句
    // 0 执行成功
    // 1 执行失败
    if (mysql_query(&mysql, sql.c_str())) {//mysql_query第二个参数只接受const char* 需要将string类型转化
        cout << ""更新数据库失败 ( "" + (string) mysql_error(&mysql) + "" )"" << endl;
        return false;
    } else {
        cout << ""数据库更新成功！"" << endl;
        return true;
    }
}

/**
 * 打印查询到的数据
 */
bool outMysql() {
    if (mysql_affected_rows(&mysql) != 0) {
        //打印数据行数
        cout << ""查询工程师数量为： "" << mysql_affected_rows(&mysql) << endl;

        char *field[32];//字段名

        int num = mysql_num_fields(res);//获取列数
        for (int i = 0; i < num; ++i) {//获取字段名
            field[i] = mysql_fetch_field(res)->name;
        }

        for (int i = 0; i < num; ++i) {
            cout << (string) field[i] << ""\t"";
        }
        cout << endl;

        column = mysql_fetch_row(res);
        while (column) {//获取一行数据
            for (int i = 0; i < num; ++i) {
                cout << column[i] << ""\t"";
            }
            cout << endl;
            column = mysql_fetch_row(res);
        }
        return true;
    } else {
        cout << ""查询结果数量为："" << mysql_affected_rows(&mysql) << ""，请确认后查询！"" << endl;
        return false;
    }
}

/**
 * 查询数据库
 * @param sql 
 * @return 
 */
bool queryDatabase(const string& sql) {
    mysql_query(&mysql, ""set names gbk"");//设置编码格式 否则cmd下中文乱码
    // 执行SQL语句
    // 0 执行成功
    // 1 执行失败
    if (mysql_query(&mysql, sql.c_str())) {//mysql_query第二个参数只接受const char* 需要将string类型转化
        cout << ""查询失败 ( "" + (string) mysql_error(&mysql) + "" )"" << endl;
        return false;
    } else {
        cout << ""正在查询……"" << endl;
    }

    //获得结果集 MYSQL_RES *res;
    if (!(res = mysql_store_result(&mysql))) {
        cout << ""Couldn't get result from "" + (string) mysql_error(&mysql) << endl;
        return false;
    }
    bool b = outMysql();//打印结果
    return b;
}

/**
 * 添加一个工程师信息
 * @param engineer_number
 * @param engineer_name
 * @param engineer_gender
 * @param engineer_degree
 * @param engineer_age
 * @param engineer_salary
 * @param engineer_address
 * @param engineer_phone
 */
bool addEngineer(const Engineer& engineer) {
    mysql_query(&mysql, ""set names gbk"");//设置编码格式 否则cmd下中文乱码
    // 执行SQL语句
    // 0 执行成功
    // 1 执行失败
    string sql = ""select * from t_engineer where engineer_number = "" + to_string(engineer.getEngineerNumber());
    if (mysql_query(&mysql, sql.c_str())) {//mysql_query第二个参数只接受const char* 需要将string类型转化
        cout << ""查询失败 ( "" + (string) mysql_error(&mysql) + "" )"" << endl;
        return false;
    } else {
        cout << ""正在查询……"" << endl;
    }

    //获得结果集 MYSQL_RES *res;
    if (!(res = mysql_store_result(&mysql))) {
        cout << ""Couldn't get result from "" + (string) mysql_error(&mysql) << endl;
        return false;
    }
    if (mysql_affected_rows(&mysql) != 0) {
        cout << ""工号重复，请重新输入！"" << endl;
        return false;
    } else {
        updateData(""insert into t_engineer values(null,'""
                   + to_string(engineer.getEngineerNumber()) + ""','""
                   + engineer.getEngineerName() + ""','""
                   + engineer.getEngineerGender() + ""','""
                   + engineer.getEngineerDegree() + ""','""
                   + to_string(engineer.getEngineerAge()) + ""','""
                   + to_string(engineer.getEngineerSalary()) + ""','""
                   + engineer.getEngineerAddress() + ""','""
                   + engineer.getEngineerPhone() + ""')"");
        cout << to_string(engineer.getEngineerNumber()) << ""号员工添加成功！"" << endl;
        return true;
    }
}

/**
 * 根据工号更新一个工程师所有信息
 * @param engineer_number
 */
void updateEngineerInfos(const string& engineer_number) {
    cout << ""该工程师信息如下："" << endl;
    bool b = queryDatabase(
            ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer where engineer_number = "" +
            engineer_number);
    if (!b) {
        return;
    }
    string engineer_name;
    string engineer_gender;
    string engineer_degree;
    string engineer_age;
    string engineer_salary;
    string engineer_address;
    string engineer_phone;
    cout << ""请输入修改后的姓名："" << endl;
    cin >> engineer_name;
    cout << ""请输入修改后的性别："" << endl;
    cin >> engineer_gender;
    cout << ""请输入修改后的学位："" << endl;
    cin >> engineer_degree;
    cout << ""请输入修改后的年龄："" << endl;
    cin >> engineer_age;
    cout << ""请输入修改后的薪水："" << endl;
    cin >> engineer_salary;
    cout << ""请输入修改后的地址："" << endl;
    cin >> engineer_address;
    cout << ""请输入修改后的电话："" << endl;
    cin >> engineer_phone;
    updateData(
            ""update t_engineer set engineer_name = '""
            + engineer_name + ""',engineer_gender = '""
            + engineer_gender + ""',engineer_degree = '""
            + engineer_degree + ""',engineer_age = ""
            + engineer_age + "",engineer_salary = ""
            + engineer_salary + "",engineer_address = '""
            + engineer_age + ""',engineer_phone = '""
            + engineer_phone + ""' where engineer_number = ""
            + engineer_number);
    cout << engineer_number << ""号员工修改成功！"" << endl;
}

/**
 * 根据工号更新一个工程师某项信息
 * @param engineer_number
 */
void updateEngineerInfo(const string& engineer_number) {
    cout << ""该工程师信息如下："" << endl;
    bool b = queryDatabase(
            ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer where engineer_number = "" +
            engineer_number);
    if (!b) {
        return;
    }
    int selection = 0;
    cout << ""请选择你要修改的信息：(输入其他数字表示退出选择)"" << endl;
    cout << ""1.姓名"" << endl;
    cout << ""2.性别"" << endl;
    cout << ""3.学位"" << endl;
    cout << ""4.年龄"" << endl;
    cout << ""5.薪水"" << endl;
    cout << ""6.地址"" << endl;
    cout << ""7.电话"" << endl;
    cin >> selection;
    if (selection == 1) {
        string engineer_name;
        cout << ""请输入修改后的姓名："" << endl;
        cin >> engineer_name;
        updateData(""update t_engineer set engineer_name = '"" + engineer_name +
                   ""' where engineer_number = '"" + engineer_number + ""'"");
        cout << engineer_number << ""号员工修改成功！"" << endl;
    } else if (selection == 2) {
        string engineer_gender;
        cout << ""请输入修改后的性别："" << endl;
        cin >> engineer_gender;
        updateData(""update t_engineer set engineer_gender = '"" + engineer_gender +
                   ""' where engineer_number = '"" + engineer_number + ""'"");
        cout << engineer_number << ""号员工修改成功！"" << endl;
    } else if (selection == 3) {
        string engineer_degree;
        cout << ""请输入修改后的学位："" << endl;
        cin >> engineer_degree;
        updateData(""update t_engineer set engineer_degree = '"" + engineer_degree +
                   ""' where engineer_number = '"" + engineer_number + ""'"");
        cout << engineer_number << ""号员工修改成功！"" << endl;
    } else if (selection == 4) {
        string engineer_age;
        cout << ""请输入修改后的年龄："" << endl;
        cin >> engineer_age;
        updateData(""update t_engineer set engineer_age = '"" + engineer_age +
                   ""' where engineer_number = '"" + engineer_number + ""'"");
        cout << engineer_number << ""号员工修改成功！"" << endl;
    } else if (selection == 5) {
        string engineer_salary;
        cout << ""请输入修改后的薪水："" << endl;
        cin >> engineer_salary;
        updateData(""update t_engineer set engineer_salary = '"" + engineer_salary +
                   ""' where engineer_number = '"" + engineer_number + ""'"");
        cout << engineer_number << ""号员工修改成功！"" << endl;
    } else if (selection == 6) {
        string engineer_address;
        cout << ""请输入修改后的地址："" << endl;
        cin >> engineer_address;
        updateData(""update t_engineer set engineer_address = '"" + engineer_address +
                   ""' where engineer_number = '"" + engineer_number + ""'"");
        cout << engineer_number << ""号员工修改成功！"" << endl;
    } else if (selection == 7) {
        string engineer_phone;
        cout << ""请输入修改后的电话："" << endl;
        cin >> engineer_phone;
        updateData(""update t_engineer set engineer_phone = '"" + engineer_phone +
                   ""' where engineer_number = '"" + engineer_number + ""'"");
        cout << engineer_number << ""号员工修改成功！"" << endl;
    } else {
        cout << ""正在退出……"" << endl;
        return;
    }
    cout << ""修改完毕，输入任一数字以退出……"" << endl;
    getchar();
    getchar();
}


/**
 * 根据工号删除一个工程师信息
 * @param engineer_number
 */
void deleteEngineer(const string& engineer_number) {
    cout << ""该工程师删除前信息如下："" << endl;
    bool b = queryDatabase(
            ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer where engineer_number = "" +
            engineer_number);
    if (!b) {
        return;
    }
    updateData(""delete from t_engineer where engineer_number = '"" + engineer_number + ""'"");
}

/**
 * 升序排序
 */
void sortByEngineer() {
    cout << ""请选择一下排序方式：（输入其他数字则表示退出选择）"" << endl;
    cout << ""1.升序排序"" << endl;
    cout << ""2.降序排序"" << endl;
    int selection = 0;
    cin >> selection;
    if (selection == 1) {
        queryDatabase(
                ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer order by engineer_salary"");
    } else if (selection == 2) {
        queryDatabase(
                ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer order by engineer_salary desc"");
    } else {
        cout << ""正在退出……"" << endl;
        return;
    }
}

/**
 * 根据条件查询工程师信息
 */
void selectEngineer() {
    cout << ""请选择一下查找方式：（输入其他数字则表示退出选择）"" << endl;
    cout << ""1.工号查找"" << endl;
    cout << ""2.姓名查找"" << endl;
    cout << ""3.学历查找"" << endl;
    int selection = 0;
    cin >> selection;
    if (selection == 1) {
        cout << ""请输入工号："" << endl;
        string engineer_number;
        cin >> engineer_number;
        queryDatabase(
                ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer where engineer_number = "" +
                engineer_number);
    } else if (selection == 2) {
        cout << ""请输入姓名："" << endl;
        string engineer_name;
        cin >> engineer_name;
        queryDatabase(
                ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer where engineer_name = '"" +
                engineer_name + ""'"");
    } else if (selection == 3) {
        cout << ""请输入学历："" << endl;
        string engineer_degree;
        cin >> engineer_degree;
        queryDatabase(
                ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer where engineer_degree = '"" +
                engineer_degree + ""'"");
    } else {
        cout << ""正在退出……"" << endl;
        return;
    }
    cout << ""查询完毕，输入任一数字以退出……"" << endl;
    getchar();
    getchar();
}


/**
 * 查询数据库中所有工程师的信息
 */
void selectAllEngineer() {
    queryDatabase(
            ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer"");
}

/**
 * 生成txt文件
 */
bool createFile() {
    mysql_query(&mysql, ""set names gbk"");//设置编码格式 否则cmd下中文乱码
    // 执行SQL语句
    // 0 执行成功
    // 1 执行失败
    string sql = ""select engineer_number 工号,engineer_name 姓名,engineer_gender 性别,engineer_degree 学位,engineer_age 年龄,engineer_salary 薪水,engineer_address 地址,engineer_phone 电话 from t_engineer"";
    if (mysql_query(&mysql, sql.c_str())) {//mysql_query第二个参数只接受const cahr* 需要将string类型转化
        cout << ""查询失败 ( "" + (string) mysql_error(&mysql) + "" )"" << endl;
        return false;
    }

    //获得结果集 MYSQL_RES *res;
    if (!(res = mysql_store_result(&mysql))) {
        cout << ""Couldn't get result from "" + (string) mysql_error(&mysql) << endl;
        return false;
    }

    std::ofstream  [MASK] (""d:\\work.txt"", std::ofstream::out);
    char *field[32];//字段名
    int num = mysql_num_fields(res);//获取列数
    for (int i = 0; i < num; ++i) {//获取字段名
        field[i] = mysql_fetch_field(res)->name;
    }
    for (int i = 0; i < num; ++i) {
         [MASK]  << (((string) field[i]) + ""\t "");
    }
     [MASK]  << endl;
    column = mysql_fetch_row(res);
    while (column) {//获取一行数据
        for (int i = 0; i < num; ++i) {
             [MASK]  << column[i] << ""\t  "";
        }
         [MASK]  << endl;
        column = mysql_fetch_row(res);
    }
     [MASK] .close();
    return true;
}",OsWrite
251,"#define _GNU_SOURCE

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <chrono>
#include <math.h>
#include <thread>
#include <fstream>
#include <sys/syscall.h>
#include <string.h>
#include <sched.h>

#define __NR_set_bpf_level 440

#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)

#define READ_SIZE_SHIFT 9
#define READ_SIZE (1 << READ_SIZE_SHIFT)

#define MAX_PAGE_INDEX  (1 << 23)

using namespace std::chrono;
using namespace std;


int num_thread;
int num_file;
int level;
long iteration;

long *latency_measure;
char **file_names;


long sys_bpf_set_level(int fd, int level) {
	return syscall(__NR_set_bpf_level, fd, level);
}

void read_key(int fd, long index, void *buffer) {
	off_t  [MASK]  = lseek(fd, index << PAGE_SHIFT, SEEK_SET);
	if ( [MASK]  != index << PAGE_SHIFT) {
		printf(""lseek error, errno %d, ret: %ld\n"", errno,  [MASK] );
		exit(1);
	}
	int read_ret = read(fd, buffer, READ_SIZE);
	if (read_ret != READ_SIZE) {
		printf(""read error, errno %d, ret: %d\n"", errno, read_ret);
		exit(1);
	}
}

void read_thread_fn(int thread_idx) {
	unsigned int seedp = thread_idx;
	void *buffer = aligned_alloc(PAGE_SIZE, PAGE_SIZE);
	if (!buffer) {
		printf(""cannot allocate buffer\n"");
		exit(1);
	}
	memset(buffer, 0, PAGE_SIZE);

	int *fd_arr = (int *) malloc(num_file * sizeof(int));
	if (!fd_arr) {
		printf(""cannot allocate fs array\n"");
		exit(1);
	}
	for (int file_idx = 0; file_idx < num_file; ++file_idx) {
		fd_arr[file_idx] = open(file_names[file_idx], O_DIRECT | O_RDONLY);
		if (fd_arr[file_idx] < 0) {
			printf(""cannot open file, errno: %d\n"", errno);
			exit(1);
		}
		long sys_ret = sys_bpf_set_level(fd_arr[file_idx], level);
		if (sys_ret < 0) {
			printf(""sys_bpf_set_level error, ret: %ld\n"", sys_ret);
			exit(1);
		}
	}

	steady_clock::time_point *start_time_arr = new steady_clock::time_point[iteration];
	if (!start_time_arr) {
		printf(""cannot allocate start_time_arr\n"");
		exit(1);
	}
	steady_clock::time_point *end_time_arr = new steady_clock::time_point[iteration];
	if (!end_time_arr) {
		printf(""cannot allocate end_time_arr\n"");
		exit(1);
	}

	for (long i = 0; i < iteration; i++) {
		start_time_arr[i] = steady_clock::now();
		read_key(fd_arr[rand_r(&seedp) % num_file], rand_r(&seedp) % MAX_PAGE_INDEX, buffer);
		end_time_arr[i] = steady_clock::now();
	}

	for (long i = 0; i < iteration; i++) {
		auto duration = duration_cast<nanoseconds>(end_time_arr[i] - start_time_arr[i]);
		latency_measure[thread_idx * iteration + i] = duration.count();
	}
}

int main(int argc, char *argv[]) {
	if (argc < 5) {
		printf(""Usage: %s <num_thread> <level> <iteration> <filenames>\n"", argv[0]);
		exit(1);
	}
	sscanf(argv[1], ""%d"", &num_thread);
	sscanf(argv[2], ""%d"", &level);
	sscanf(argv[3], ""%ld"", &iteration);
	num_file = argc - 4;
	file_names = argv + 4;

	latency_measure = (long *) malloc(sizeof(long) * num_thread * iteration);
	if (!latency_measure) {
		printf(""cannot allocate measurements\n"");
		return 1;
	}
	memset(latency_measure, 0, sizeof(long) * num_thread * iteration);

	thread *read_threads = new thread[num_thread];
	for (int i = 0; i < num_thread; i++) {
		read_threads[i] = thread(read_thread_fn, i);
	}
	for (int i = 0; i < num_thread; i++) {
		read_threads[i].join();
	}

	for (long i = 0; i < num_thread * iteration; ++i) {
		printf(""%ld\n"", latency_measure[i]);
	}
}
",lseek_ret
252,"#include <algorithm>
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <ostream>
#include <queue>
#include <tuple>
#include <unordered_map>

class LimitReachedException : public std::exception {
public:
  [[nodiscard(""exception"")]] const char *what() const noexcept override {
    return ""PriorityQueueWithMessagesTimestamps limit reached"";
  }
};

using priority_type = std::int16_t;

template <typename T>
using message_t =
    std::tuple<priority_type, decltype(std::chrono::system_clock::now()), T>;


template <typename T>
struct priority_less {
constexpr bool operator()(const message_t<T> & lhs, const message_t<T>& rhs) {
  return std::get<0>(lhs) < std::get<0>(rhs);
};
};

template <typename T, typename Container_t = std::vector<message_t<T> >, typename Comp = priority_less<T> >
class PriorityQueueWithMessagesTimestamps
    : protected std::priority_queue<message_t<T>, Container_t, Comp> {
public:
  using value_type = typename Container_t::value_type;
  using reference = typename Container_t::reference;
  using const_reference = typename Container_t::const_reference;
  using size_type = typename Container_t::size_type;
  using container_type = Container_t;  

  PriorityQueueWithMessagesTimestamps() = default;

  PriorityQueueWithMessagesTimestamps(
      const PriorityQueueWithMessagesTimestamps &) = default;

  PriorityQueueWithMessagesTimestamps(PriorityQueueWithMessagesTimestamps &&) =
      default;

  PriorityQueueWithMessagesTimestamps &
  operator=(const PriorityQueueWithMessagesTimestamps &) = default;

  PriorityQueueWithMessagesTimestamps &
  operator=(PriorityQueueWithMessagesTimestamps &&) = default;

  bool empty() {
    clear_expired();
    return this->c.empty();
  }

  size_t size() {
    clear_expired();
    return this->c.size();
  }

  void pop() {
    clear_expired();
    std::priority_queue<message_t<T>, Container_t, Comp>::pop();
  }

  void push(const message_t<T> &value) {
    clear_expired();
    if (this->c.size() >= max_amount) {
      clear_expired();
      if (this->c.size() >= max_amount) {
        throw LimitReachedException();
      }
    }
    std::priority_queue<message_t<T>, Container_t, Comp>::push(value);
  }

  template <class... Args> void emplace(Args &&...args) {
    clear_expired();
    if (this->c.size() >= max_amount) {
      throw LimitReachedException();
    }
    std::priority_queue<message_t<T>, Container_t, Comp>::emplace(
        std::forward<Args>(args)...);
  }

  const message_t<T>& top() {
    clear_expired();
    return this->c.front();
  }

  void clear_expired() {
    auto expired = [now = std::chrono::system_clock::now()](
                       const message_t<T> &m) { return std::get<1>(m) < now; };
    auto new_end = std::remove_if(this->c.begin(), this->c.end(), expired);
    this->c.erase(new_end, this->c.end());
    std::make_heap(this->c.begin(), this->c.end(), Comp{});
  }

  void set_max_amount(uint64_t max_amount) { this->max_amount = max_amount; }

  [[nodiscard]] uint64_t get_max_amount() const { return max_amount; }

  template <class, class, class > friend class QueueAnalyzer;

private:
  uint64_t max_amount = 50;
};

namespace fs = std::filesystem;

template <typename T, typename Container_t = std::vector<message_t<T>>, typename Comp = priority_less<T> >
class QueueAnalyzer {
public:
  QueueAnalyzer(
      const PriorityQueueWithMessagesTimestamps<T, Container_t, Comp> &queue)
      : queue_(queue) {}

  void analyze(const fs::path &file_path) {
    std::ofstream file(file_path, std::ios::out | std::ios::trunc);
    if (!file.is_open()) {
      throw std::runtime_error(""Failed to open file for writing."");
    }

    // Get the current time
    const auto  [MASK]  =
        std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
    file << ""Current time: "" << std::ctime(& [MASK] );

    // Get the size of the queue in KiB
    const auto queue_size_kib =
        (queue_.c.size() * sizeof(typename Container_t::value_type)) >> 10;
    file << ""Queue size: "" << queue_.c.size() << ""\n"";
    file << ""Queue size (KiB): "" << queue_size_kib << ""\n"";

    // Calculate the percentage of messages by their priority
    std::unordered_map<priority_type, uint64_t> count;
    count.reserve(queue_.c.size());
    for (const auto &message : queue_.c) {
      if (count.find(std::get<0>(message)) == count.end()) {
        count[std::get<0>(message)] = 1;
      } else {
        ++count[std::get<0>(message)];
      };
    }
    file << ""Priority distribution:\n"";
    for (const auto &pair : count) {
      const auto percentage = (pair.second * 100.0) / queue_.c.size();
      file << ""Priority "" << pair.first << "": "" << percentage << ""%\n"";
    }

    // Get the max time difference of messages
    if (!queue_.c.empty()) {
      const auto minmax_it =
          std::minmax_element(queue_.c.begin(), queue_.c.end(),
                              [](const auto &lhs, const auto &rhs) {
                                return std::get<1>(lhs) < std::get<1>(rhs);
                              });
      const auto &oldest_message = *minmax_it.first;
      const auto &newest_message = *minmax_it.second;
      const auto max_time_diff =
          std::chrono::duration_cast<std::chrono::seconds>(
              std::get<1>(newest_message) - std::get<1>(oldest_message))
              .count();
      file << ""Max time difference of messages (s): "" << max_time_diff << ""\n"";
    }
    file.close();
  }

private:
  const PriorityQueueWithMessagesTimestamps<T, Container_t> &queue_;
};
",current_time
253,"#include ""Microtask.h""

#include ""SharedPointer.h""
#include ""SharedValue.h""
#include ""helper.h""

using namespace llvm;

Microtask::Microtask(CallInst *fork_call)
{
    _fork_call = fork_call;

    // Get the microtask function from the fork calls arguments
    Value *microtask_arg = fork_call->getArgOperand(2);
    _function = dyn_cast<Function>(microtask_arg->stripPointerCasts());

    // Collect the shared variables
    for (Argument &argument : _function->args())
    {
        // The first shared variable has index 2
        if (argument.getArgNo() > 1)
        {
            //_shared_variables.push_back(new SharedVariable(&argument, _function));
            int pointer_depth = get_pointer_depth(&argument);

            assert(pointer_depth > 0 && ""Shared Variable is not of pointer type"");
            _shared_variables.push_back(&argument);
            // if (pointer_depth == 1)
            // {
            //     _shared_variables.push_back(&argument);
            // }
            // else
            // {
            //     _shared_variables.push_back(&argument);
            // }
        }
    }

    auto call_instructions = get_instruction_in_function<CallInst>(_function);

    // Look for a parallel for inside the microtask;
    ParallelForData tmp_parallel_for;
    tmp_parallel_for.init = nullptr;
    tmp_parallel_for.fini = nullptr;
    for (auto &call : call_instructions)
    {
        std::vector<std::string> function_list = {
            ""__kmpc_for_static_init_4"", ""__kmpc_for_static_init_4u"",
            ""__kmpc_for_static_init_8"", ""__kmpc_for_static_init_8u""};

        if (is_in_list(call->getCalledFunction()->getName(), function_list))
        {
            tmp_parallel_for.init = call;
        }
        else if (call->getCalledFunction()->getName().equals(""__kmpc_for_static_fini""))
        {
            tmp_parallel_for.fini = call;
        }

        if (tmp_parallel_for.init != nullptr && tmp_parallel_for.fini != nullptr)
        {
            _parallel_for.push_back(tmp_parallel_for);
            tmp_parallel_for.init = nullptr;
            tmp_parallel_for.fini = nullptr;
        }
    }

    // Look for a reduction inside the microtask;
    ReductionData  [MASK] ;
     [MASK] .reduce = nullptr;
     [MASK] .end_reduce = nullptr;
    for (auto &call : call_instructions)
    {
        std::vector<std::string> function_list_start = {""__kmpc_reduce_nowait"",
                                                        ""__kmpc_reduce""};
        std::vector<std::string> function_list_end = {""__kmpc_end_reduce_nowait"",
                                                      ""__kmpc_end_reduce""};

        if (is_in_list(call->getCalledFunction()->getName(), function_list_start))
        {
             [MASK] .reduce = call;
        }
        else if (is_in_list(call->getCalledFunction()->getName(), function_list_end))
        {
             [MASK] .end_reduce = call;
        }

        if ( [MASK] .reduce != nullptr &&  [MASK] .end_reduce != nullptr)
        {
            _reduction.push_back( [MASK] );
             [MASK] .reduce = nullptr;
             [MASK] .end_reduce = nullptr;
        }
    }

    // Look for a critical inside the microtask
    CriticalData tmp_critical_data;
    tmp_critical_data.critical = nullptr;
    tmp_critical_data.end_critical = nullptr;
    for (auto &call : call_instructions)
    {
        if (call->getCalledFunction()->getName().equals(""__kmpc_critical""))
        {
            tmp_critical_data.critical = call;
        }
        else if (call->getCalledFunction()->getName().equals(""__kmpc_end_critical""))
        {
            tmp_critical_data.end_critical = call;
        }

        if (tmp_critical_data.critical != nullptr && tmp_critical_data.end_critical != nullptr)
        {
            _critical.push_back(tmp_critical_data);
            tmp_critical_data.critical = nullptr;
            tmp_critical_data.end_critical = nullptr;
        }
    }
}

Microtask::~Microtask() {}

CallInst *Microtask::get_fork_call() { return _fork_call; }

Function *Microtask::get_function() { return _function; }

std::vector<ParallelForData> *Microtask::get_parallel_for()
{
    if (_parallel_for.size() > 0)
    {
        return &_parallel_for;
    }
    else
    {
        return nullptr;
    }
}

std::vector<ReductionData> *Microtask::get_reductions()
{
    if (_reduction.size() > 0)
    {
        return &_reduction;
    }
    else
    {
        return nullptr;
    }
}

std::vector<CriticalData> *Microtask::get_critical()
{
    if (_critical.size() > 0)
    {
        return &_critical;
    }
    else
    {
        return nullptr;
    }
}

bool Microtask::has_shared_variables() { return _shared_variables.size(); }

std::vector<Value *> &Microtask::get_shared_variables() { return _shared_variables; }
",tmp_reduction_data
254,"#include <functional>
#include <iostream>

#include <spdlog/spdlog.h>
#include <docopt/docopt.h>

#include <imgui.h>
#include <imgui-SFML.h>
#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/System/Clock.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Graphics/CircleShape.hpp>

int main()//int argc, const char **argv)
{
  //std::map<std::string, docopt::value> args = docopt::docopt(USAGE,
    //{ std::next(argv), std::next(argv, argc) },
    //true,// show help if requested
    //""Naval Fate 2.0"");// version string

  //for (auto const &arg : args) {
    //std::cout << arg.first << arg.second << std::endl;
  //}

  //Use the default logger (stdout, multi-threaded, colored)
  spdlog::info(""Starting ImGui + SFML"");

  sf::RenderWindow  [MASK] (sf::VideoMode(1024, 1024), ""ImGui + SFML = <3"");
   [MASK] .setFramerateLimit(60);
  ImGui::SFML::Init( [MASK] );
  
  constexpr auto scale_factor = 2;
  ImGui::GetStyle().ScaleAllSizes(scale_factor);
  ImGui::GetIO().FontGlobalScale = scale_factor;

  sf::CircleShape shape(400.f);
  shape.setFillColor(sf::Color::Green);

  sf::Clock deltaClock;
  while ( [MASK] .isOpen()) {
    sf::Event event;
    while ( [MASK] .pollEvent(event)) {
      ImGui::SFML::ProcessEvent(event);

      if (event.type == sf::Event::Closed) {
         [MASK] .close();
      }
    }

    ImGui::SFML::Update( [MASK] , deltaClock.restart());

    ImGui::Begin(""Hello, world!"");
    ImGui::Button(""Look at this pretty button"");
    ImGui::End();

     [MASK] .clear();
     [MASK] .draw(shape);
    ImGui::SFML::Render( [MASK] );
     [MASK] .display();
  }

  ImGui::SFML::Shutdown();

  return 0;
}
",window
255,"#include ""esp_adc_cal.h""
#include ""QuickMedianLib.h""
#include ""esp_adc_cal.h""
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <Preferences.h>
#include ""driver/touch_sensor.h""

Preferences preferences;

// #define DEBUG

#ifdef DEBUG
// TEMP - Display for debugging
#include ""Free_Fonts.h""
#include ""SPI.h""
#include ""TFT_eSPI.h""

// Use hardware SPI
TFT_eSPI tft = TFT_eSPI();
#endif

#define DEFAULT_REFRESH_RATE        60
#define NUM_SAMPLES                 10
#define TOUCHPIN                    T5
#define VOLTPIN                     32
#define VOLTCHAN                    ADC1_CHANNEL_4

#define SERVER_NAME                 ""RV Server""
#define SERVICE_UUID                ""68f9860f-4946-4031-8107-9327cd9f92ca""
#define TOUCH_CHARACTERISTIC_UUID   ""bcdd0001-b67f-46c7-b2b8-e8a385ac70fc""
#define VOLTAGE_CHARACTERISTIC_UUID ""bcdd0002-b67f-46c7-b2b8-e8a385ac70fc""
#define TOUCH_CALIBRATION_CHARACTERISTIC_UUID ""bcdd0011-b67f-46c7-b2b8-e8a385ac70fc""
#define REFRESH_RATE_CHARACTERISTIC_UUID ""bcdd0005-b67f-46c7-b2b8-e8a385ac70fc""

#define TOUCH_CALIBRATION_PREF_KEY ""calibration""
#define RW_MODE                     false

static esp_adc_cal_characteristics_t adc1_value;

int voltRawValues[NUM_SAMPLES];
int touchValues[NUM_SAMPLES];
BLECharacteristic *bleTouchValue;
BLECharacteristic *bleVoltageValue;
BLECharacteristic *bleTouchCalibration;
BLECharacteristic *bleRefreshRate;
int refreshRate = DEFAULT_REFRESH_RATE;

std::string calibrationData = ""0:0""; // format: value:percentage,value:percentage,...

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      pServer->startAdvertising(); // restart advertising
    };

    void onDisconnect(BLEServer* pServer) {
      pServer->startAdvertising(); // restart advertising
    }
};

class RefreshRateWriteCallback : public BLECharacteristicCallbacks {

  void onWrite(BLECharacteristic *pCharacteristic) {
    uint8_t *byteRefreshRate = pCharacteristic->getData();
    size_t size = pCharacteristic->getLength();
    if (size != 4) {
      Serial.print('Invalid length for refresh: ');
      Serial.println(size);
      return;
    }
    refreshRate = byteRefreshRate[0];
    Serial.print(""Refresh rate updated to: "");
    Serial.println(refreshRate);
  }
};

class CalibrationWriteCallback : public BLECharacteristicCallbacks {

  void onWrite(BLECharacteristic *pCharacteristic) {
    calibrationData = pCharacteristic->getValue();
    Serial.print(""Received calibration data:'"");
    Serial.print(calibrationData.c_str());
    Serial.println(""'"");
    if (!validCalibrationData(calibrationData)) {
      Serial.println(""Calibration invalid - ignoring"");
    } else {
      preferences.begin(""rvsetting"", RW_MODE);
      preferences.putString(TOUCH_CALIBRATION_PREF_KEY, calibrationData.c_str());
      preferences.end();
    }
  };

  bool validCalibrationData(std::string data) {
    return data.length() > 10;
    //TODO: Implement a more robust validation
  }
    
};

void setup() {
  Serial.begin(115200);
  delay(1000); // give me time to bring up serial monitor
  Serial.println(""Starting RV Meter"");

  // setup voltage measurement
  pinMode(VOLTPIN, INPUT);
  if (adc1_config_width(ADC_WIDTH_BIT_12) != ESP_OK) {
    Serial.println(""Error configuring ADC1"");
  }
  if (adc1_config_channel_atten(VOLTCHAN, ADC_ATTEN_DB_11) != ESP_OK) {
    Serial.println(""Error configuring channel atten."");
  }
  esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 0, &adc1_value);

  // setup touch sensor
  touch_pad_init();
  touch_pad_set_voltage(TOUCH_HVOLT_2V7, TOUCH_LVOLT_0V5, TOUCH_HVOLT_ATTEN_1V5);
  

  // setup bluetooth low energy
  BLEDevice::init(SERVER_NAME);
  BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);
  pServer->setCallbacks(new MyServerCallbacks());
  bleTouchValue = pService->createCharacteristic(
                                         TOUCH_CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ
                                       );
  bleVoltageValue = pService->createCharacteristic(
                                         VOLTAGE_CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ
                                       );
  bleTouchCalibration = pService->createCharacteristic(
                                         TOUCH_CALIBRATION_CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ  |
                                          BLECharacteristic::PROPERTY_WRITE
                                       );
  bleRefreshRate = pService->createCharacteristic(
                                         REFRESH_RATE_CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ  |
                                          BLECharacteristic::PROPERTY_WRITE
                                       );
  pService->start();
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);  // functions that help with iPhone connections issue
  pAdvertising->setMinPreferred(0x12);
  BLEDevice::startAdvertising();

  // Setup preferenches for saving touch calibration
  preferences.begin(""rvsetting"", RW_MODE);
  if (preferences.isKey(TOUCH_CALIBRATION_PREF_KEY)) {
    String prefsValue = preferences.getString(TOUCH_CALIBRATION_PREF_KEY);
    calibrationData = std::string(prefsValue.c_str());
    Serial.print(""Prefs value for touch config read: '"");
    Serial.print(prefsValue);
    Serial.println(""'"");
  } else {
    // Need to initialize
    preferences.putString(TOUCH_CALIBRATION_PREF_KEY, ""TEST"");
    Serial.println(""No prefs calibration data - using default"");
  }
  preferences.end();
  bleTouchCalibration->setValue(calibrationData);
  bleTouchCalibration->setCallbacks(new CalibrationWriteCallback());
  bleRefreshRate->setValue(refreshRate);
  bleRefreshRate->setCallbacks(new RefreshRateWriteCallback());
  // 
  Serial.println(""RV Service Started"");

#ifdef DEBUG
    tft.begin();

  tft.setRotation(1);
  tft.setTextDatum(MC_DATUM);

  // Set text colour to orange with black background
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  
  tft.fillScreen(TFT_BLACK);            // Clear screen
  tft.setFreeFont(FF18);                 // Select the font
  String TEXT = ""Started..."";
  tft.drawString(TEXT, 160, 120, GFXFF);
#endif
}

int count = 0;
void loop() {
  for (int i = 0; i < NUM_SAMPLES; i++) {
    voltRawValues[i] = adc1_get_raw(VOLTCHAN);
    touchValues[i] = touchRead(TOUCHPIN);
    delay(100);
  }
  int voltRaw = QuickMedian<int>::GetMedian(voltRawValues, NUM_SAMPLES);
  float milliVoltSample = esp_adc_cal_raw_to_voltage(voltRaw, &adc1_value) * 5.7;
  Serial.print(""Voltage: "");
  Serial.println(milliVoltSample / 1000);
  Serial.print(""Raw voltage: "");
  Serial.println(voltRaw);
  int  [MASK]  = int(trunc(milliVoltSample));
  bleVoltageValue->setValue( [MASK] ); // send in millivolts
  int touchSample = QuickMedian<int>::GetMedian(touchValues, NUM_SAMPLES);
  Serial.print(""Touch: "");
  Serial.println(touchSample);
  bleTouchValue->setValue(touchSample);

#ifdef DEBUG
  String TEXT = ""Loop number "" + String(count);
  count++;
  tft.drawString(TEXT, 10, 120, GFXFF);
#endif

  delay(refreshRate * 1000);
}
",milliVoltSampleInt
256,"// Application.cpp

#include ""Application.hpp""
#include <iostream>
#include <random>
#include <ctime>

Application::Application(int blockAmount)
    : blockAmount(blockAmount) {
    srand(static_cast<unsigned int>(time(0)));

    if (!loadUsersFromFile(""users.txt"")) {
        std::cerr << ""Failed to load users. Exiting application."" << std::endl;
        exit(EXIT_FAILURE); 
    }
}

void Application::run() {
    std::cout << ""Program started!"" << std::endl;

    RandomTransactionGenerator transactionGenerator(users);

    // Initialize the miner and CrowServer with the current blockchain and settings
    Miner miner(blockchain, maxNonce, startingNonce, genesisPrevCash);
    CrowServer server(blockchain, miner, transactionGenerator);

    // Start the server, which handles transactions and mining via API
    server.run();
}

bool Application::loadUsersFromFile(const std::string& filename) {
    std::ifstream infile(filename);
    if (!infile) {
        std::cerr << ""Error: Unable to open users file: "" << filename << std::endl;
        return false;
    }

    std::string line;
    while (std::getline(infile, line)) {
        size_t start = line.find_first_not_of("" \t\r\n"");
        size_t end = line.find_last_not_of("" \t\r\n"");
        if (start != std::string::npos && end != std::string::npos) {
            std::string name = line.substr(start, end - start + 1);
            if (!name.empty()) {
                users.push_back(name);
            }
        }
    }

    infile.close();
    return !users.empty();
}

HorovyiBlockchain::Transaction Application::genRanTransaction() {
    if (users.empty()) {
        std::cerr << ""Error: User list is empty. Cannot generate transaction."" << std::endl;
        exit(EXIT_FAILURE); // Exit if no users are available
    }

    static std::random_device rd;
    static std::mt19937 gen(rd());

    // Create uniform distributions based on the size of the users vector
    std::uniform_int_distribution<> userDist(0, users.size() - 1);
    std::uniform_int_distribution<> amountDist(1, 1000);

    int senderIndex = userDist(gen);

    int recipientIndex;
    do {
        recipientIndex = userDist(gen);
    } while (recipientIndex == senderIndex);

    int  [MASK]  = amountDist(gen);

    return HorovyiBlockchain::Transaction(users[senderIndex], users[recipientIndex],  [MASK] );
}",moneyAmount
257,"#include <PZEM004Tv30.h>
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h> //Version 1.4.6

typedef struct
{
  float currentLimit;  
  bool restoreCmd;
}masterToNode_t;

typedef struct
{
  char id;
  bool overcurrentState;
}nodeToMaster_t;

const char nodeID = '1';
const uint8_t pzemTx = 16;
const uint8_t pzemRx = 17;
const uint8_t relayPin = 4;
const uint8_t chipEn = 15; 
const uint8_t chipSel = 5; 
const byte room1RxPipe[] = ""rm1Tx"";
const byte room1TxPipe[] = ""rm1Rx"";

PZEM004Tv30 pzem(&Serial2,pzemTx,pzemRx);
RF24 nrf24(chipEn,chipSel);
uint32_t prevTime = millis();
static masterToNode_t masterToNode;

/**
 * @brief Set float to zero if it is not a number.
*/
static void SetToZeroIfNaN(float* floatPtr)
{
  if(isnan(*floatPtr))
  {
    *floatPtr = 0.0;
  }
}

/**
 * @brief Send data to the master
*/
static void SendDataToMaster(RF24& nrf24,char id,bool overcurrentState)
{
  nodeToMaster_t nodeToMaster = {id,overcurrentState};
  nrf24.stopListening();
  nrf24.openWritingPipe(room1TxPipe);
  nrf24.write(&nodeToMaster,sizeof(nodeToMaster_t));
  nrf24.startListening();   
}

void setup() 
{
  Serial.begin(9600);
  pinMode(relayPin,OUTPUT);
  Serial.println(""INIT"");
  nrf24.begin();
  nrf24.openReadingPipe(1,room1RxPipe);
  nrf24.setPALevel(RF24_PA_MAX);
  nrf24.startListening();
}

void loop() 
{
  static bool overcurrentPrevDetected;
  //float measuredCurrent = pzem.current();
  float measuredCurrent = 10.2;
  SetToZeroIfNaN(&measuredCurrent);

  if(nrf24.available())
  {
    nrf24.read(&masterToNode,sizeof(masterToNode_t));
    Serial.print(""Current limit = "");
    Serial.println(masterToNode.currentLimit);
    Serial.print(""Restore cmd = "");
    Serial.println(masterToNode.restoreCmd);
  }
  
  bool  [MASK]  = lround(measuredCurrent * 100) > lround(masterToNode.currentLimit * 100);
  
  if( [MASK]  && !overcurrentPrevDetected)
  {
    Serial.println(""Current limit exceeded"");
    digitalWrite(relayPin,LOW); //disconnect the user from mains
    overcurrentPrevDetected = true; 
    SendDataToMaster(nrf24,nodeID,overcurrentPrevDetected);
  }
  
  if(! [MASK]  && masterToNode.restoreCmd)
  {
    Serial.println(""Power restored"");
    digitalWrite(relayPin,HIGH); //leave user connected to the mains 
    masterToNode.restoreCmd = false;
    overcurrentPrevDetected = false;
    SendDataToMaster(nrf24,nodeID,overcurrentPrevDetected);
  }
}
",overcurrentDetected
258,"#pragma once

#include ""subprocess.h""

#include <thread>
#include <chrono>

#include <fcntl.h>
#include <spawn.h>
#include <unistd.h>
#include <sys/wait.h>

namespace splib
{

	namespace detail
	{
		struct pipe_handle
		{
			int handles[2] = { -1, -1 };

			inline ~pipe_handle() noexcept
			{
			}
			void close_pipe() noexcept
			{
				if (handles[1] != -1)
					close(handles[1]);
				if (handles[0] != -1)
					close(handles[0]);
			}

			pipe_handle() = default;
			pipe_handle(pipe_handle&) = delete;
			pipe_handle& operator=(const pipe_handle&) = delete;
		};

		class posix_stream_handle : public pipe_handle
		{
		public:
			inline posix_stream_handle(subprocess::stdfunc_t&& f) noexcept
				: func(std::move(f))
			{
			}

			subprocess::stdfunc_t func;
		};

	}

	class suprocess_impl
	{
	public:
		inline suprocess_impl(subprocess::stdfunc_t&& stdout_func, subprocess::stdfunc_t&& stderr_func) noexcept
			: stdout_handle(std::move(stdout_func))
			, stderr_handle(std::move(stderr_func))
		{
		}
		inline ~suprocess_impl()
		{
			::write(m_close_pipe.handles[1], ""."", 1);

			if (m_buffer_thread.joinable())
				m_buffer_thread.join();

			stdout_handle.close_pipe();
			stderr_handle.close_pipe();
			m_close_pipe.close_pipe();
		}

		void start(const std::size_t buffer_size) noexcept
		{
			if (pipe(m_close_pipe.handles) != 0)
			{
				return;
			}

			SUBPROCESS_ASSERT(m_buffer_thread.joinable() == false);
			m_buffer_thread = std::thread([this, buffer_size]() {
				std::unique_ptr<char[]> buffer(new char[buffer_size]);

				while (true)
				{
					bool ok = this->stream_buffering(buffer.get(), buffer_size);
					if (ok == false)
						break;
				}
			});
		}

		bool stream_buffering(char* buffer, std::size_t max_buffer_size)
		{
			SUBPROCESS_ASSERT(buffer != nullptr && max_buffer_size > 0);

			auto hout = stdout_handle.handles[0];
			auto herr = stderr_handle.handles[0];
			auto  [MASK]  = m_close_pipe.handles[0];

			if (hout == -1 || herr == -1 ||  [MASK]  == -1)
				return false;

			fd_set set;
			FD_ZERO(&set);
			FD_SET(hout, &set);
			FD_SET(herr, &set);
			FD_SET( [MASK] , &set);

			auto hmax = std::max( [MASK] , std::max(hout, herr));

			if (select(hmax + 1, &set, NULL, NULL, nullptr) == -1)
				return false;

			bool data_read = false;

			if (FD_ISSET( [MASK] , &set))
				return false;

			if (FD_ISSET(hout, &set))
			{
				auto num = read(hout, buffer, max_buffer_size);
				if (num <= 0)
					return false;
				if (stdout_handle.func != nullptr)
					stdout_handle.func(buffer, std::size_t(num));
				data_read = true;
			}

			if (FD_ISSET(herr, &set))
			{
				auto num = read(herr, buffer, max_buffer_size);
				if (num <= 0)
					return false;
				if (stderr_handle.func != nullptr)
					stderr_handle.func(buffer, std::size_t(num));
				data_read = true;
			}

			return data_read;
		}

	public:
		detail::posix_stream_handle stdout_handle;
		detail::posix_stream_handle stderr_handle;

		pid_t pid = 0;

	protected:
		std::thread			m_buffer_thread;
		detail::pipe_handle m_close_pipe;
	};

	class pipe_impl : public detail::pipe_handle
	{
	public:
		inline ~pipe_impl()
		{
			close_pipe();
		}
		inline bool write(const char* data, const std::size_t sz) noexcept
		{
			SUBPROCESS_ASSERT(handles[1] != -1 && data != nullptr && sz > 0);
			auto num = ::write(handles[1], data, sz);
			return num > 0;
		}
	};

	bool subprocess::start(const CreateData& cd, stdfunc_t stdout_func, stdfunc_t stderr_func) noexcept
	{

		// run_cmd(""ls"");

		auto simpl = std::make_unique<suprocess_impl>(std::move(stdout_func), std::move(stderr_func));
		auto pimpl = std::make_unique<pipe_impl>();

		if (pipe(simpl->stdout_handle.handles) != 0)
		{
			return false;
		}
		if (pipe(simpl->stderr_handle.handles) != 0)
		{
			return false;
		}
		if (pipe(pimpl->handles) != 0)
		{
			return false;
		}

		posix_spawn_file_actions_t action;
		posix_spawn_file_actions_init(&action);

		posix_spawn_file_actions_adddup2(&action, pimpl->handles[0], STDIN_FILENO);
		posix_spawn_file_actions_adddup2(&action, simpl->stdout_handle.handles[1], STDOUT_FILENO);
		posix_spawn_file_actions_adddup2(&action, simpl->stderr_handle.handles[1], STDERR_FILENO);

		std::vector<std::string> argbuffers;
		std::vector<char*>		 argv;

		for (const auto& a : cd.argv)
		{
			argbuffers.push_back(a);
		}
		for (auto& a : argbuffers)
		{
			argv.push_back(&a[0]);
		}
		argv.push_back(nullptr);

		const char* exe = cd.exe.c_str();

		if (posix_spawn(&(simpl->pid), exe, &action, nullptr, argv.data(), nullptr) != 0)
		{
			return false;
		}

		simpl->start(cd.buffer_size);

		{
			std::lock_guard<std::mutex> lock(m_process_mutex);
			SUBPROCESS_ASSERT(m_process_handle == nullptr);

			m_process_handle.swap(simpl);
			m_stdin_pipe.swap(pimpl);
		}

		return true;
	}

	int subprocess::join() noexcept
	{
		pid_t pid;
		{
			std::lock_guard<std::mutex> lock(m_process_mutex);
			SUBPROCESS_ASSERT(m_process_handle != nullptr);
			pid = m_process_handle->pid;
		}
		SUBPROCESS_ASSERT(pid != 0);

		int status = -1;
		int result = -1;
		do
		{
			if (waitpid(pid, &status, 0) == -1)
			{
				result = -1;
				break;
			}

			result = WEXITSTATUS(status);
		} while (!WIFEXITED(status) && !WIFSIGNALED(status));

#ifdef SUBPROCESS_POSIX_SIGNALED_JOIN_ERROR
		if (WIFSIGNALED(status) && result == 0)
		{
			if (status > 0)
				result = -status;
			else if (status < 0)
				result = status;
			else
				result = -1;
		}
#endif

		{
			std::lock_guard<std::mutex> lock(m_process_mutex);
			this->reset_no_lock();
		}

		return result;
	}

	void subprocess::kill() noexcept
	{
		{
			std::lock_guard<std::mutex> lock(m_process_mutex);
			if (m_process_handle == nullptr)
				return;

			auto id = m_process_handle->pid;

			::kill(-id, SIGTERM);
			::kill(id, SIGTERM);
		}

		std::this_thread::sleep_for(std::chrono::milliseconds(16));
		// give 16 ms time for the process to terminate, then kill

		{
			std::lock_guard<std::mutex> lock(m_process_mutex);
			if (m_process_handle == nullptr)
				return;

			auto id = m_process_handle->pid;
			::kill(-id, SIGKILL);
			::kill(id, SIGKILL);

			this->reset_no_lock();
		}
	}

}
",hexit
259,"//////////////////////////////////////////////////////////////////////////
//
// Helpers.cpp : Miscellaneous helpers.
//
// THIS CODE AND INFORMATION IS PROVIDED ""AS IS"" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
//////////////////////////////////////////////////////////////////////////

#include ""EVRPresenter.h""


//-----------------------------------------------------------------------------
// SamplePool class
//-----------------------------------------------------------------------------

SamplePool::SamplePool() : m_bInitialized(FALSE), m_cPending(0)
{
    InitializeCriticalSection(&m_lock);
}

SamplePool::~SamplePool()
{
    DeleteCriticalSection(&m_lock);
}


//-----------------------------------------------------------------------------
// GetSample
//
// Gets a sample from the pool. If no samples are available, the method
// returns MF_E_SAMPLEALLOCATOR_EMPTY.
//-----------------------------------------------------------------------------

HRESULT SamplePool::GetSample(IMFSample **ppSample)
{
    EnterCriticalSection(&m_lock);

    if (!m_bInitialized)
    {
        LeaveCriticalSection(&m_lock);
        return MF_E_NOT_INITIALIZED;
    }

    if (m_VideoSampleQueue.IsEmpty())
    {
        LeaveCriticalSection(&m_lock);
        return MF_E_SAMPLEALLOCATOR_EMPTY;
    }


    // Get a sample from the allocated queue.

    // It doesn't matter if we pull them from the head or tail of the list,
    // but when we get it back, we want to re-insert it onto the opposite end.
    // (see ReturnSample)

    IMFSample *pSample = NULL;

    HRESULT hr = m_VideoSampleQueue.RemoveFront(&pSample);

    if (SUCCEEDED(hr))
    {
        m_cPending++;

        // Give the sample to the caller.
        *ppSample = pSample;
        (*ppSample)->AddRef();
    }

    SafeRelease(&pSample);
    LeaveCriticalSection(&m_lock);
    return hr;
}

//-----------------------------------------------------------------------------
// ReturnSample
//
// Returns a sample to the pool.
//-----------------------------------------------------------------------------

HRESULT SamplePool::ReturnSample(IMFSample *pSample)
{
    EnterCriticalSection(&m_lock);

    if (!m_bInitialized)
    {
        LeaveCriticalSection(&m_lock);
        return MF_E_NOT_INITIALIZED;
    }

    HRESULT hr = m_VideoSampleQueue.InsertBack(pSample);

    if (SUCCEEDED(hr))
    {
        m_cPending--;
    }

    LeaveCriticalSection(&m_lock);
    return hr;
}

//-----------------------------------------------------------------------------
// AreSamplesPending
//
// Returns TRUE if any samples are in use.
//-----------------------------------------------------------------------------

BOOL SamplePool::AreSamplesPending()
{
    EnterCriticalSection(&m_lock);

    BOOL  [MASK]  = FALSE;

    if (!m_bInitialized)
    {
         [MASK]  = FALSE;
    }
    else
    {
         [MASK]  = (m_cPending > 0);
    }

    LeaveCriticalSection(&m_lock);
    return  [MASK] ;
}


//-----------------------------------------------------------------------------
// Initialize
//
// Initializes the pool with a list of samples.
//-----------------------------------------------------------------------------

HRESULT SamplePool::Initialize(VideoSampleList& samples)
{
    EnterCriticalSection(&m_lock);

    if (m_bInitialized)
    {
        LeaveCriticalSection(&m_lock);
        return MF_E_INVALIDREQUEST;
    }

    HRESULT hr = S_OK;

    IMFSample *pSample = NULL;

    // Move these samples into our allocated queue.
    VideoSampleList::POSITION pos = samples.FrontPosition();
    while (pos != samples.EndPosition())
    {
        hr = samples.GetItemByPosition(pos, &pSample);
        if (FAILED(hr))
        {
            goto done;
        }
        
        hr = m_VideoSampleQueue.InsertBack(pSample);
        if (FAILED(hr))
        {
            goto done;
        }

        pos = samples.Next(pos);
        SafeRelease(&pSample);
    }

    m_bInitialized = TRUE;

done:
    samples.Clear();
    SafeRelease(&pSample);
    LeaveCriticalSection(&m_lock);
    return hr;
}


//-----------------------------------------------------------------------------
// Clear
//
// Releases all samples.
//-----------------------------------------------------------------------------

HRESULT SamplePool::Clear()
{
    HRESULT hr = S_OK;

    EnterCriticalSection(&m_lock);

    m_VideoSampleQueue.Clear();
    m_bInitialized = FALSE;
    m_cPending = 0;


    LeaveCriticalSection(&m_lock);
    return S_OK;
}

",bRet
260,"#include ""network.hpp""

void forward_prop(network& net){
	for(int i = 0; i < 784; i++){
		if(net.A0->elements[i][0] < 0){
			net.A0->elements[i][0] += 255;
		}
	}

	apply_func(sigmoid, net.A0, net.A0);
	
	mat* temp1 = dot(net.W1, net.A0);
	add(net.B1, temp1, net.Z1);
	apply_func(sigmoid, net.Z1, net.A1);

	mat* temp2 = dot(net.W2, net.A1);
	add(net.B2, temp2, net.Z2);
	apply_func(sigmoid, net.Z2, net.A2);
	//softmax(net);

	mfree(temp1);
	mfree(temp2);
}

void back_prop(network& net){
	// output layer
	mat* delta_A2 = sub(net.A2, net.Y);
	mat* A1_trans = transpose(net.A1);
	
	dot(delta_A2, A1_trans, net.dW2);
	scale(LEARNING_RATE, net.dW2, net.dW2);
	sub(net.W2, net.dW2, net.W2);
	
	scale(LEARNING_RATE, delta_A2, net.dB2);
	sub(net.B2, net.dB2, net.B2);
	
	// input layer
	mat* dactivation = mcopy(net.A1);
	mfill(dactivation, 1);
	sub(dactivation, net.A1, dactivation);
	multiply(dactivation, net.A1, dactivation);
	
	mat* W2_trans = transpose(net.W2);
	mat* delta_A1 = dot(W2_trans, delta_A2);
	multiply(delta_A1, dactivation, delta_A1);

	mat* A0_trans = transpose(net.A0);
	
	dot(delta_A1, A0_trans, net.dW1);
	scale(LEARNING_RATE, net.dW1, net.dW1);
	sub(net.W1, net.dW1, net.W1);

	add(net.dB1, delta_A1, net.dB1);
	scale(LEARNING_RATE, net.dB1, net.dB1);
	sub(net.B1, net.dB1, net.B1);
	
	// memory clean up
	mfree(delta_A2);
	mfree(A1_trans);
	
	mfree(dactivation);
	mfree(W2_trans);
	mfree(delta_A1);
	mfree(A0_trans);
}

void update_net(network& net){
	scale(LEARNING_RATE, net.dW2, net.dW2);
	sub(net.W2, net.dW2, net.W2);
	mfill(net.dW2, 0);

	scale(LEARNING_RATE, net.dB2, net.dB2);
	sub(net.B2, net.dB2, net.B2);
	mfill(net.dB2, 0);

	scale(LEARNING_RATE, net.dW1, net.dW1);
	sub(net.W1, net.dW1, net.W1);
	mfill(net.dW1, 0);

	scale(LEARNING_RATE, net.dB1, net.dB1);
	sub(net.B1, net.dB1, net.B1);
	mfill(net.dB1, 0);
}

void ntrain(network& net, char** images, char* labels, int itter){
	int guess = 0;
	double correct = 0,  [MASK]  = 0;

	for(int epoch = 0; epoch < 100; epoch++){
		for(int i = 0; i < itter; i++){
			for(int j = 0; j < INPUT_LAYER; j++){
				net.A0->elements[j][0] = images[i][j];
			}

			forward_prop(net);
			hot_encode_y(net, (int)(labels[i]));
			back_prop(net);
			
			guess = argmax(net);
			if(guess == (int)labels[i]){ correct++; }
		}

		if(epoch % 10 == 0){
			 [MASK]  = correct / itter * 10;
			P(""----------"");
			P(""epoch: "" << epoch);
			P(""Accuracy: "" <<  [MASK]  << ""%"");
			correct = 0;
		}
	}
}

void ntest(network& net, char** images, char* labels, int itter){
	int guess = 0;
	int correct = 0;
	for(int i = 0; i < itter; i++){
		for(int j = 0; j < INPUT_LAYER; j++){
			net.A0->elements[j][0] = images[i][j];
		}
		
		forward_prop(net);
		
		guess = argmax(net);
		if(guess == (int)labels[i]){ correct++; }

		// P(""network guess: "" << guess << "" Actual "" << (int)labels[i]);
	}
	P(""Out of "" << itter << "" guesses, the network got "" << correct << "" correct"");
}

",acc
261,"/*
 * Copyright (C) 2024 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)

 * 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 <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
#include <iostream>
#include <libgen.h>  // for basename()
#include <limits.h> // for PATH_MAX

#include ""sesamController.hpp""

using namespace std;

void usage(){
  printf(""Sesam user controller\n"");
  printf(""v0.2\n"");
  printf(""Usage: sesam <command> <parameter>\n"");
  printf(""\nCommand:\n"");
  printf(""    help\t\tShow this message\n"");
  printf(""    show\t\tShow component status\n"");
  printf(""    benchmark\t\tShow performance statistics of the executed program\n"");
  printf(""    quit\t\tQuit VPSim\n"");
}

bool file_exists(const char *path) {
    return access(path, F_OK) == 0;
}
bool is_system_command(const char *cmd) {
    // Check if the command is a system command in the PATH
    return system((string(""command -v "") + cmd + "" >/dev/null 2>&1"").c_str()) == 0;
}
int main(int argc, char **argv)
{
  char cmd[20];
  char parameter[10][30]; /* Maximum 10 parameters */
  int  [MASK] ;

  int i;

  if (argc < 2) {
    usage();
    exit(1);
  }

  /* Copy input variables to internal */
  strcpy(cmd, argv[1]);

  map_sesam_mem();

  /* Verify command */
  if (strcmp(cmd,""help"") == 0) {
    printf(""Help: "");
    usage();
    return 0;
  }
  else if (strcmp(cmd,""quit"") == 0) {
    /* Call function to quit vpsim */
    printf(""Quitting VPSIM environment ...\n"");
    sesam_quit();
  }
  else if (strcmp(cmd,""list"") == 0) {
    /* Call function to list vpsim components */
    printf(""Components in VPSIM: \n"");
    sesam_list_component();
  }
  else if (strcmp(cmd,""benchmark"") == 0) {
    if (argc < 3) {
      printf(""Please put your benchmark application..."");
      printf(""Usage: sesam benchmark <name_of_application>"");
      exit(1);
    }

    ostringstream s;
    string tmp = argv[2];
    bool is_local_executable = false;

    // Check if the provided executable name contains a path
    if (tmp.find('/') == string::npos) { // no path provided
      // Check if it's a system command
      if (!is_system_command(tmp.c_str())) {
        // Not a system command, prepend ""./"" to check the current directory
        string current_dir_app = ""./"" + tmp;
        if (file_exists(current_dir_app.c_str())) {
            tmp = current_dir_app;  // Use current directory version
            is_local_executable = true;
        } else {
            printf(""Application %s not found in current directory or system PATH\n"", tmp.c_str());
            exit(1);
        }
      } // Continue if the app is a system command
    } else { //A path is provided with the app
        is_local_executable = true;
    }
    string base_name;
    if (is_local_executable) {
        // Resolve the absolute path for local executables
        char resolved_path[PATH_MAX];
        if (realpath(tmp.c_str(), resolved_path) == NULL) {
            perror(""realpath"");
            exit(1);
        }
        // Extract the base name from the resolved path
        base_name = basename(resolved_path);
        tmp = string(resolved_path);
    } else {
      // command is in PATH (system comand), keep its name
      base_name = tmp;
    }

    int n = base_name.length();
    char name[n+1];
    strcpy(name, base_name.c_str());
    // Get the app name in HOST machine
    sesam_get_name(n, name);

    // Build the command string with absolute path and additional arguments
    s << tmp;
    for (int i = 3; i < argc; ++i) {
        s << "" "" << argv[i];
    }
    sesam_start_bench();
    // Execute the command using system()
    system(s.str().c_str());
    sesam_end_bench();

  } else {
    if (argc < 3) {
      printf(""Missing argument: "");
      usage();
      exit(1);
    }

    /* Get argument */
     [MASK]  = argc - 1;
    for (i = 0; i <  [MASK] ; ++i) {
      strcpy(parameter[i],argv[i+1]);
    }

    sesam_exec_command( [MASK] , parameter);

  }

  unmap_sesam();

  return 0;
}
",nb_param
262,"/* peer.cc
   <NAME>, 12 August 2015

*/

#include <iostream>
#include <stdexcept>

#include <arpa/inet.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>

#include <pistache/async.h>
#include <pistache/peer.h>
#include <pistache/transport.h>

namespace Pistache {
namespace Tcp {

std::atomic<size_t> idCounter{0};

namespace {
struct ConcretePeer : Peer {
  ConcretePeer() = default;
  ConcretePeer(Fd fd, const Address &addr, void *ssl) : Peer(fd, addr, ssl) {}
};
} // namespace

Peer::Peer(Fd fd, const Address &addr, void *ssl)
    : fd_(fd), addr(addr), ssl_(ssl), id_(idCounter++) {}

Peer::~Peer() {
#ifdef PISTACHE_USE_SSL
  if (ssl_)
    SSL_free(static_cast<SSL *>(ssl_));
#endif /* PISTACHE_USE_SSL */
}

std::shared_ptr<Peer> Peer::Create(Fd fd, const Address &addr) {
  return std::make_shared<ConcretePeer>(fd, addr, nullptr);
}

std::shared_ptr<Peer> Peer::CreateSSL(Fd fd, const Address &addr, void *ssl) {
  return std::make_shared<ConcretePeer>(fd, addr, ssl);
}

const Address &Peer::address() const { return addr; }

const std::string &Peer::hostname() {
  if (hostname_.empty()) {
    char host[NI_MAXHOST];
    struct sockaddr_in sa;
    sa.sin_family = AF_INET;
    if (inet_pton(AF_INET, addr.host().c_str(), &sa.sin_addr) == 0) {
      hostname_ = addr.host();
    } else {
      if (!getnameinfo((struct sockaddr *)&sa, sizeof(sa), host, sizeof(host),
                       NULL, 0 // Service info
                       ,
                       NI_NAMEREQD // Raise an error if name resolution failed
                       )) {
        hostname_.assign((char *)host);
      }
    }
  }
  return hostname_;
}

void *Peer::ssl() const { return ssl_; }
size_t Peer::getID() const { return id_; }

int Peer::fd() const {
  if (fd_ == -1) {
    throw std::runtime_error(""The peer has no associated fd"");
  }

  return fd_;
}

void Peer::setParser(std::shared_ptr<Http::RequestParser> parser) {
  parser_ = parser;
}

std::shared_ptr<Http::RequestParser> Peer::getParser() const { return parser_; }

Http::Request &Peer::request() {
  if (!parser_) {
    throw std::runtime_error(""The peer has no associated parser"");
  }

  return parser_->request;
}

Async::Promise<ssize_t> Peer::send(const RawBuffer &buffer, int  [MASK] ) {
  return transport()->asyncWrite(fd_, buffer,  [MASK] );
}

std::ostream &operator<<(std::ostream &os, Peer &peer) {
  const auto &addr = peer.address();
  os << ""("" << addr.host() << "", "" << addr.port() << "") ["" << peer.hostname()
     << ""]"";
  return os;
}

void Peer::associateTransport(Transport *transport) { transport_ = transport; }

Transport *Peer::transport() const {
  if (!transport_)
    throw std::logic_error(""Orphaned peer"");

  return transport_;
}

} // namespace Tcp
} // namespace Pistache
",flags
263,"#include ""simple_license.h""
#include <WinSock2.h>
#include <IPHlpApi.h>
#include <string.h>
#include <ctime>
#include <iomanip>
#include <exception>
#include <sstream>
#include <streambuf>
#include <iterator>
#include ""lib_license\aes256.h""

#pragma warning(disable : 4996) //_CRT_SECURE_NO_WARNINGS

std::ostream & PT::operator<<(std::ostream& os, const License& license)
{
	auto expire_day = std::chrono::system_clock::to_time_t(license.m_expire);
	os << license.m_mac << "" "" << std::put_time(std::localtime(&expire_day), ""%F %T"");

	return os;
}

std::string PT::GetLocalMacAddr()
{
	IP_ADAPTER_INFO pAdapterInfo[32];
	DWORD dwBufLen = sizeof(pAdapterInfo);

	DWORD  [MASK]  = GetAdaptersInfo(pAdapterInfo, &dwBufLen);
	if ( [MASK]  != ERROR_SUCCESS)
		return """";

	PIP_ADAPTER_INFO pAdapter = pAdapterInfo;
	BYTE* mac = pAdapter->Address;
	char buf[18];
	snprintf(buf, sizeof(buf), ""%02X-%02X-%02X-%02X-%02X-%02X"", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	return std::string(buf);
}

std::ostream& PT::operator<<(std::ostream& os, const LicenseCrypto& licCrypto)
{
	aes256_context ctx;
	aes256_init(&ctx, LicenseCrypto::gKey);

	std::ostringstream oss;
	oss << *licCrypto.m_pLic;
	std::string plaintext = oss.str();
	std::vector<unsigned char> ciphertext(16 * (plaintext.size() / 16 + 1), 0);
	std::copy(plaintext.begin(), plaintext.end(), ciphertext.begin());
	for (size_t i = 0; i < ciphertext.size(); i += 16)
		aes256_encrypt_ecb(&ctx, &ciphertext[i]);
	
	for (auto c : ciphertext)
		os << c;

	return os;
}

PT::License::License(const std::string& strMac, int month): m_mac(strMac), m_expire(std::chrono::system_clock::now() + months{ month })
{
}

PT::License::License(std::istream& is)
{
	std::tm tm = {};
	try {
		is >> m_mac >> std::get_time(&tm, ""%Y-%m-%d %T"");
		m_expire = std::chrono::system_clock::from_time_t(std::mktime(&tm));
	}
	catch (const std::exception& e) {
		std::cout << e.what();
	}
}

std::pair<bool, std::string> PT::License::Check() const
{
	if (GetLocalMacAddr() != m_mac)
		return std::make_pair(false, ""The MAC Address does not match."");

	if (std::chrono::system_clock::now() > m_expire)
		return std::make_pair(false, ""The license has expired."");

	return std::make_pair(true, ""success"");
}

PT::LicenseCrypto::LicenseCrypto(std::istream& is)
{
	aes256_context ctx;
	aes256_init(&ctx, gKey);

	try {
		std::vector<unsigned char> ciphertext((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
		for (size_t i = 0; i < ciphertext.size(); i += 16)
			aes256_decrypt_ecb(&ctx, &ciphertext[i]);
		std::string plaintext(ciphertext.begin(), ciphertext.end());
		std::istringstream iss(plaintext);
		m_pLic = std::make_shared<License>(iss);
	}
	catch (const std::exception& e) {
		std::cout << e.what() << std::endl;
	}
}",dwRetVal
264,"#include <iostream>
#include <string>

using namespace std;



void displayWelcomeMessage() 
{
    cout <<""---------------------------------""<<endl;
	cout <<""|Welcome to the Pos Terminal    |""<<endl;
    cout <<""|1. Add a Item                  |""<<endl;
    cout <<""|2. View Cart                   |""<<endl;
    cout <<""|3. CheckOut                    |""<<endl;
    cout <<""|4. Settings                    |""<<endl;
    cout <<""|5. Exit                        |""<<endl;
    cout <<""---------------------------------"";
}

void viewItems(string itemNames[], int itemPrice[], int itemCount) {
    if (itemCount == 0) {
        cout << ""No Products Added.\n"";
    } else {
        cout << ""Cart:\n"";
        int total = 0;
        for (int i = 0; i < itemCount; i++) {
        total += itemPrice[i];
        }
        cout<<""----------------------------------""<<endl;
        cout<<""|Total: $"" << total << ""                     ""<<endl;
        for (int i = 0; i < itemCount; i++) {
       cout <<""|""<<i + 1 << "". "" << itemNames[i] << "" ----------- "" << itemPrice[i]<<""$"" << ""             ""<<endl;
        
		}
    }
    cout<<""----------------------------------""<<endl;
}

void addItem(string itemNames[], int itemPrice[], int& itemCount) {
        int  [MASK] =10;
	if (itemCount < [MASK] )
	 {
        int total=0;
		cout << ""Enter the item name: "";
        cin >> itemNames[itemCount];
        cout << ""Enter "" << itemNames[itemCount] << ""'s Price: "";
        cin >> itemPrice[itemCount];
        
		itemCount++;
        cout << ""Item added to cart!\n"";}
     
	else {
        cout << ""Maximum number of items reached.\n"";
    }
     
}
int main() 
{
    string itemNames[50];
    int itemPrice[50];
    int itemCount = 0;
    int choice;
    int total=0;
    

    displayWelcomeMessage();
    
    
    do {
        cout<<""\nEnter your Choice :"";
        cin >> choice;

        switch (choice) 
		{
            case 1:
                addItem(itemNames, itemPrice, itemCount);
                break;
            case 2:
                viewItems(itemNames, itemPrice, itemCount);
                break;
            case 3:
            	 if (itemCount == 0) {
                    cout << ""Cart is empty. Please add items first.\n"";
                } 
				else {
            	cout<<""\n"";
            	cout<<""\n"";
            	cout<<""\n"";
                viewItems(itemNames, itemPrice, itemCount);
                cout<<total;
                cout << ""Proceed with checkout? (y/n): "";
                char confirm;
                cin >> confirm;
                if (confirm == 'y' || confirm == 'Y') {
                cout << ""\nThank you for shopping!\n"";}
                for (int i = 0; i < itemCount; i++) {
                itemNames[i] = """";
                itemPrice[i] = 0;
                }
                itemCount = 0;
				break;
            case 4:
            cout << ""Exiting the program.\n"";
                break;
			case 5:
			default:
                cout << ""Invalid choice. Please try again.\n"";
				}
        }
    } while (choice != 4);

    return 0;
}



",cartsize
265,"/*
** Ncurses.cpp for arcade in /home/aubanel_m/tek2/cpp_arcade/arcade/GUIs
**
** Made by aubanel_m
** Login   <<EMAIL>>
**
** Started on  Thu Mar 09 21:08:53 2017 aubanel_m
** Last update Sun Apr  9 22:17:31 2017 <NAME>
*/

#include ""../../Include/Ncurses.hpp""

void          Ncurses::Init_Game(int y, int x)
{
  WIN = initscr();
  nodelay(WIN, TRUE);
  start_color();
  use_default_colors();
  noecho();
  curs_set(0);
  init_pair(1, COLOR_WHITE, COLOR_GREEN);
  init_pair(2, COLOR_BLACK, COLOR_WHITE);
  init_pair(3, COLOR_WHITE, COLOR_BLACK);
  init_pair(4, COLOR_BLUE, COLOR_BLUE);
  init_pair(5, COLOR_BLACK, COLOR_YELLOW);
  init_pair(11, COLOR_RED, COLOR_RED);
  init_pair(12, COLOR_BLUE, COLOR_BLUE);
  init_pair(13, COLOR_CYAN, COLOR_CYAN);
  init_pair(14, COLOR_MAGENTA, COLOR_MAGENTA);
  init_pair(15, COLOR_WHITE, COLOR_WHITE);
  _y = y;
  _x = x;
  BOARD = subwin(WIN, _y + 2, _x + 2, (LINES / 2) - (_y / 2), (COLS / 2) - (_x / 2));
  SCORE = subwin(WIN, 5, 17, 2, 30);
  wborder(SCORE, 0, 0, 0, 0, 0, 0, 0, 0);
  wborder(WIN, 0, 0, 0, 0, 0, 0, 0, 0);
  wborder(BOARD, 0, 0, 0, 0, 0, 0, 0, 0);
  wrefresh(WIN);
  wrefresh(BOARD);
}

void          Ncurses::Init_GUI()
{
  WIN = initscr();
  nodelay(WIN, TRUE);
  start_color();
  use_default_colors();
  noecho();
  curs_set(0);
  init_pair(1, COLOR_WHITE, COLOR_GREEN);
  init_pair(2, COLOR_BLACK, COLOR_WHITE);
  init_pair(3, COLOR_WHITE, COLOR_BLACK);
  init_pair(4, COLOR_BLUE, COLOR_BLUE);
  init_pair(5, COLOR_BLACK, COLOR_YELLOW);
  init_pair(11, COLOR_RED, COLOR_RED);
  init_pair(12, COLOR_BLUE, COLOR_BLUE);
  init_pair(13, COLOR_CYAN, COLOR_CYAN);
  init_pair(14, COLOR_MAGENTA, COLOR_MAGENTA);
  init_pair(15, COLOR_WHITE, COLOR_WHITE);
}

void          Ncurses::B_Circle_Yellow(int y, int x, Game::Command  [MASK] )
{
  (void) [MASK] ;
  wattron(BOARD, COLOR_PAIR(5));
  mvwprintw(BOARD, y, x, ""O"");
  wattroff(BOARD, COLOR_PAIR(5));
}

void          Ncurses::Dead_Ghost(int y, int x)
{
  wattron(BOARD, COLOR_PAIR(15));
  mvwprintw(BOARD, y, x, ""O"");
  wattroff(BOARD, COLOR_PAIR(15));
}

void          Ncurses::Ghost(int y, int x, int type)
{
  wattron(BOARD, COLOR_PAIR(type));
  mvwprintw(BOARD, y, x, ""0"");
  wattroff(BOARD, COLOR_PAIR(type));
}


void          Ncurses::B_Circle(int y, int x, Game::Command DIR)
{
  (void)DIR;
  wattron(BOARD, COLOR_PAIR(2));
  mvwprintw(BOARD, y, x, ""O"");
  wattroff(BOARD, COLOR_PAIR(2));
}

void          Ncurses::S_Star(int y, int x)
{
  mvwprintw(BOARD, y, x, ""X"");
}

void          Ncurses::S_Dot(int y, int x)
{
  mvwprintw(BOARD, y, x, ""."");
}

void 		       Ncurses::B_Dot(int y, int x)
{
  mvwprintw(BOARD, y, x, ""*"");
}

void          Ncurses::Space(int y, int x)
{
  mvwprintw(BOARD, y, x, "" "");
}

void          Ncurses::S_Circle(int y, int x)
{
  wattron(BOARD, COLOR_PAIR(1));
  mvwprintw(BOARD, y, x, ""o"");
  wattroff(BOARD, COLOR_PAIR(1));
}

void          Ncurses::B_Block(int y, int x)
{
  wattron(BOARD, COLOR_PAIR(4));
  mvwprintw(BOARD, y, x, "" "");
  wattroff(BOARD, COLOR_PAIR(4));
}

void          Ncurses::DISPLAY_Score(int _SCORE)
{
  mvwprintw(SCORE, 1, 1, ""Score :"");
  mvwprintw(SCORE, 1, 9, std::to_string(_SCORE).c_str());
}

void          Ncurses::DISPLAY_Level(int _LVL)
{
  mvwprintw(SCORE, 2, 1, ""Level :"");
  mvwprintw(SCORE, 2, 9, std::to_string(_LVL).c_str());
}

void          Ncurses::Refresh()
{
  wrefresh(BOARD);
  wrefresh(SCORE);
}

void          Ncurses::Keyboard()
{
  char    key;

  key = getch();
  if (key != ERR)
    {
      if (key == ' ')
        {
          _DIR = Game::Command::PAUSE;
          return ;
        }
      if (key == '\'')
        {
          _DIR = Game::Command::NEXTLIB;
          return ;
        }
      if (key == '(')
        {
          _DIR = Game::Command::NEXTGAME;
          return ;
        }
      if (key == '_')
        {
          _DIR = Game::Command::RESTART;
          return ;
        }
      if (key == '""')
        {
          _DIR = Game::Command::PREVLIB;
          return ;
        }
      if (key == 27)
        {
          key = getch();
          if (key == ERR)
            {
              _DIR = Game::Command::ESCAPE;
              return ;
            }
          key = getch();
          if (key == 'A')
            {
              _DIR = Game::Command::UP;
              return ;
            }
          else if (key == 'B')
            {
              _DIR = Game::Command::DOWN;
              return ;
            }
          else if (key == 'C')
            {
              _DIR = Game::Command::RIGHT;
              return ;
            }
          else if (key == 'D')
            {
              _DIR = Game::Command::LEFT;
              return ;
            }
        }
    }
}

void                     Ncurses::Launcher_Header()
{
  wattron(WIN, A_BOLD);
  mvwprintw(WIN, 10, 42, "" .----------------.  .----------------.  .----------------.  .----------------.  .----------------.  .----------------.   "");
  mvwprintw(WIN, 11, 42, ""| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |  "");
  mvwprintw(WIN, 12, 42, ""| |      __      | || |  _______     | || |     ______   | || |      __      | || |  ________    | || |  _________   | |  "");
  mvwprintw(WIN, 13, 42, ""| |     /  \\     | || | |_   __  \\   | || |   .' ___  |  | || |     /  \\     | || | |_   ___ `.  | || | |_   ___  |  | |  "");
  mvwprintw(WIN, 14, 42, ""| |    / /\\ \\    | || |   | |__) |   | || |  / .'   \\_|  | || |    / /\\ \\    | || |   | |   `. \\ | || |   | |_  \\_|  | |  "");
  mvwprintw(WIN, 15, 42, ""| |   / ____ \\   | || |   |  __ /    | || |  | |         | || |   / ____ \\   | || |   | |    | | | || |   |  _|  _   | |  "");
  mvwprintw(WIN, 16, 42, ""| | _/ /    \\ \\_ | || |  _| |  \\ \\_  | || |  \\ `.___.'\\  | || | _/ /    \\ \\_ | || |  _| |___.' / | || |  _| |___/ |  | |  "");
  mvwprintw(WIN, 17, 42, ""| ||____|  |____|| || | |____| |___| | || |   `._____.'  | || ||____|  |____|| || | |________.'  | || | |_________|  | |  "");
  mvwprintw(WIN, 18, 42, ""| |              | || |              | || |              | || |              | || |              | || |              | |  "");
  mvwprintw(WIN, 19, 42, ""| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |  "");
  mvwprintw(WIN, 20, 42, "" '----------------'  '----------------'  '----------------'  '----------------'  '----------------'  '----------------'   "");
  wattroff(WIN, A_BOLD);
}

std::string              Ncurses::Launcher(std::vector<t_directory> v)
{
  std::string            string;
  WINDOW*                menu_win;
  unsigned long int      n = v.size();
  ITEM**                 items;
  int                    c = 0;
  char                   key;
  MENU*                  menu;
  unsigned long int      pos = 0;
  char str[100];

  items = (ITEM**)calloc(n + 1, sizeof(ITEM*));
  for (std::vector<t_directory>::iterator i = v.begin(); i != v.end(); ++i)
    {
      items[c] = new_item(i->name.c_str(), NULL);
      c = c + 1;
    }
  menu = new_menu(items);
  menu_win = newwin(9, 40, (LINES / 2) - 5, (COLS / 2) - 20);
  box(menu_win, 0, 0);
  mvwprintw(menu_win, 0, 14, ""SELECT GAME"");
  set_menu_win(menu, menu_win);
  set_menu_sub(menu, derwin(menu_win, 6, 38, 3, 1));
  post_menu(menu);
  wrefresh(WIN);
  wrefresh(menu_win);
  while ((key = getch()) != 10)
    {
     Launcher_Header();
     if (key != ERR)
      {
        if (key == 27)
          {
            key = getch();
            if (key == ERR)
              {
                string.clear();
                return (string);
              }
            key = getch();
            switch(key)
      	     {
               case 'B':
      			      menu_driver(menu, REQ_DOWN_ITEM);
                  if (pos < n - 1)
                    pos = pos + 1;
                  break;
      			   case 'A':
      			      menu_driver(menu, REQ_UP_ITEM);
                  if (pos >= 1)
                    pos = pos - 1;
                  break;
                }
            }
          }
      wrefresh(menu_win);
      wrefresh(WIN);
    }
  echo();
  nodelay(WIN, FALSE);
  mvwprintw(WIN, 45, 80, ""Enter your name : "");
  mvwgetstr(WIN, 45, 100, str);
  nodelay(WIN, TRUE);
  noecho();
  wclear(WIN);
  wrefresh(WIN);
  return (v[pos].path);
}

Game::Command    Ncurses::GET_key()
{
  return (_DIR);
}

void             Ncurses::Clear_WIN()
{
  _DIR = Game::Command::NONE;
  wclear(WIN);
}

void                    Ncurses::DISPLAY_background(std::string& path)
{
  (void)path;
}

Ncurses::Ncurses()
{
  _DIR = Game::Command::NONE;
}

Ncurses::~Ncurses()
{
  endwin();
}

extern ""C"" Ncurses* C_LIB()
{
  return (new Ncurses());
}
",cmd
266,"/* 
 *****************************************************************************************************************************
 *  COPYRIGHT (c) 2025 <NAME> (<EMAIL>) unless otherwise noted.
 *
 *  This program and all its associated modules is free software:
 *  you can redistribute it and/or modify it under the terms of the
 *  GNU General Public License as published by the Free Software
 *  Foundation, either version 3 of the License, or (at your option)
 *  any later version.
 *  This program 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 General Public License for more details.
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses
 *
 *****************************************************************************************************************************
*/
/*

 *   By <NAME> <EMAIL>

*/

#ifndef THROTTLE_PAGE_H
#define THROTTLE_PAGE_H

#include ""functions.h""

void populateLocoDetails()
{
//  Serial.printf(""LocoID being Populated: %d\n"", activeLocoID);
  if(activeLocoID != 255)
  {
    lv_slider_set_value(objects.slider, locoSpeed[activeLocoID], LV_ANIM_OFF);
    char speedString[10] = """";
    itoa(locoSpeed[activeLocoID], speedString, 10);
    lv_label_set_text(objects.lbl_slider,speedString);                    //Update the speed label to the previously set speed value
    lv_label_set_text(objects.lbl_address, locoAddress[activeLocoID]);                    //Update the address label to the previously set address

    //Setup the Direction
    if(locoDir[activeLocoID] == 1)
    { lv_obj_add_state(objects.sw_dir, LV_STATE_CHECKED);
    }else lv_obj_clear_state(objects.sw_dir, LV_STATE_CHECKED);
    //Setup the Function Buttons
    for(int i = 0; i < NUM_FUNC_SLOTS; i++)
    {
      int val = atoi(funcNumber[activeLocoID][i]);
      if(val != 255)
      {
        btnMap_functions[map_xlate[i]] = funcName[activeLocoID][i];
        lv_btnmatrix_clear_btn_ctrl(objects.function_mtx, func_xlate[i], LV_BTNMATRIX_CTRL_HIDDEN);
        if(funcState[activeLocoID][i] == 1)
        { 
          lv_btnmatrix_set_btn_ctrl(objects.function_mtx, func_xlate[i], LV_BTNMATRIX_CTRL_CHECKED);
        }else
        {
          lv_btnmatrix_clear_btn_ctrl(objects.function_mtx, func_xlate[i], LV_BTNMATRIX_CTRL_CHECKED);
        }
      }else
      {
        btnMap_functions[map_xlate[i]] = "" "";
        lv_btnmatrix_set_btn_ctrl(objects.function_mtx, func_xlate[i], LV_BTNMATRIX_CTRL_HIDDEN);
      }
    }
    lv_btnmatrix_set_map(objects.function_mtx, btnMap_functions);
  }else
  {
    loadScreen(SCREEN_ID_ROSTER);
  }
}


void populateThrottle()
{
  lv_dropdown_clear_options(objects.dd_locos);                          //Clear the previous list
  lv_label_set_text(objects.lbl_throttle_page,throttleName[activeThrottle]);        //Update the page heading
  activeLocoID = selectedIDs[activeThrottle][activeSlot[activeThrottle]];
  for(int i = 0; i < NUM_LOCO_SLOTS; i++)
  {
    if(selectedIDs[activeThrottle][i] != 255)                           //ignore unused Loco IDs
    {
      lv_dropdown_add_option(objects.dd_locos,locoName[selectedIDs[activeThrottle][i]],i); //Add all valid Locos to the list
//      Serial.print(""loco "");Serial.println(locoName[selectedIDs[activeThrottle][i]]);
    }else
    {
      lv_dropdown_add_option(objects.dd_locos,"""",i); //Blank out unused Loco IDs in the list
    }
  }
  lv_dropdown_set_selected(objects.dd_locos, activeSlot[activeThrottle]); //Set the previously active Loco as selected
  populateLocoDetails();
}

void clearGuest()
{
  rosterMode = GUEST_INACTIVE;
  //UNCHECK Guest_address TextArea 
}


static void throttle_selection_handler_cb(lv_event_t * e)
{
  lv_event_code_t code = lv_event_get_code(e);
  lv_obj_t * obj = lv_event_get_target(e);
  if(code == LV_EVENT_VALUE_CHANGED) 
  {
    uint32_t id = lv_btnmatrix_get_selected_btn(objects.throttle_mtx);    //Retrieve the Selected Throttle number
    activeThrottle = id;                                                  //Make this the new Active Throttle
    populateThrottle();
    loadScreen(SCREEN_ID_THROTTLE);
  }
}

static void functions_cb(lv_event_t * e)
{
  if(rosterMode == GUEST_INACTIVE)
  {
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t * obj = lv_event_get_target(e);
    uint32_t mapslot = lv_btnmatrix_get_selected_btn(obj); 
    if(mapslot >9) return;
    uint32_t fslot = abs_xlate[mapslot];
    if(funcName[activeLocoID][fslot] != """")
    {
      if(code == LV_EVENT_PRESSED)
      {
//        Serial.printf(""Function Pressed: %d\n"", funcOption[activeLocoID][fslot]);
        if(funcState[activeLocoID][fslot] == 1) funcState[activeLocoID][fslot] = 0;
        else funcState[activeLocoID][fslot] = 1;
        //Send the DCCEX Command...
        String functionCMD = (""<F "" + String(locoAddress[activeLocoID]) + "" "" + String(atoi(funcNumber[activeLocoID][fslot])) + "" "" + String(funcState[activeLocoID][fslot]) + "">"");
        Serial.println(functionCMD);
//        client.print(functionCMD);
        if(!client.print(functionCMD)) Serial.println(""Transmit Failed"");
      }else if(code == LV_EVENT_RELEASED)
      {
 //       Serial.printf(""Function Released: %d\n"", funcOption[activeLocoID][fslot]);
        if(funcOption[activeLocoID][fslot] == 1)
        {
          lv_btnmatrix_clear_btn_ctrl(obj, func_xlate[fslot], LV_BTNMATRIX_CTRL_CHECKED);
          funcState[activeLocoID][fslot] = 0;
          //Send the DCCEX Command...
          String functionCMD = (""<F "" + String(locoAddress[activeLocoID]) + "" "" + String(atoi(funcNumber[activeLocoID][fslot])) + "" "" + String(funcState[activeLocoID][fslot]) + "">"");
          Serial.println(functionCMD);
          if(!client.print(functionCMD)) Serial.println(""Transmit Failed"");
//          client.print(functionCMD);
        }
      }
    }
  }
}

void dd_locos_cb(lv_event_t * e)
{
  //clearGuest();
  lv_event_code_t code = lv_event_get_code(e);
//  lv_obj_t * obj = lv_event_get_target(e);
  if(code == LV_EVENT_VALUE_CHANGED) 
  {
    activeSlot[activeThrottle] = lv_dropdown_get_selected(objects.dd_locos);
    activeLocoID = selectedIDs[activeThrottle][activeSlot[activeThrottle]];       //update activeLocoID
    populateLocoDetails();
  }
}
void setSpeed(uint16_t locoAddr, uint16_t newSpeed, uint8_t newDir)
{
  char speedString[10] = """";
  itoa(newSpeed, speedString, 10);
  lv_slider_set_value(objects.slider, newSpeed, LV_ANIM_OFF);
  lv_label_set_text(objects.lbl_slider,speedString);
  String  [MASK]  = (""<t "" + String(locoAddr) + "" ""
         + speedString + "" "" + String(newDir) + "">"");
  Serial.println( [MASK] );
  if(!client.print( [MASK] )) Serial.println(""Transmit Failed"");
}

void action_throttle_button(lv_event_t * e)
{
  void *user_data = lv_event_get_user_data(e);
  int pressedButton = *((int*)(&user_data));
  switch(pressedButton)
  {
    case 1:       
      rosterMode = GUEST_ACTIVE;
      lv_obj_clear_flag(objects.kbd_guest, LV_OBJ_FLAG_HIDDEN);
      lv_slider_set_value(objects.slider, 0, LV_ANIM_OFF);
      lv_label_set_text(objects.lbl_slider,""0"");
      lv_label_set_text(objects.lbl_address, lv_textarea_get_text(objects.ta_guest_address));
      for(int i = 0; i < NUM_FUNC_SLOTS; i++)
      {
        lv_btnmatrix_set_btn_ctrl(objects.function_mtx, func_xlate[i], LV_BTNMATRIX_CTRL_HIDDEN);        
      }
      gfx.flush();

//#if defined ( ESP32DIS02170A ) || defined ( ESP32DIS08070H ) || defined ( ESP3202170A_LS )
//#else
//      gfx.flush(true);
//#endif
      break;
    case 2:       //Guest Loco
//      Serial.println(""Guest InActive"");
      lv_obj_add_flag(objects.kbd_guest, LV_OBJ_FLAG_HIDDEN);
      rosterMode = GUEST_INACTIVE;
//      Serial.printf(""Roster Mode: %d\n"", rosterMode);
      populateLocoDetails();
      break;
    case 3:       //Slider 
    {
//      Serial.printf(""Roster Mode: %d\n"", rosterMode);
//      if(runState == 0) break;
      if(rosterMode != GUEST_ACTIVE)
      {
//        Serial.println(""Setting Loco Speed"");
        locoSpeed[activeLocoID] = lv_slider_get_value(objects.slider);
        setSpeed(atoi(locoAddress[activeLocoID]), locoSpeed[activeLocoID], locoDir[activeLocoID]);
      }else     //Guest Active
      {
//        Serial.println(""Setting Guest Speed"");
        guestSpeed = lv_slider_get_value(objects.slider);
        setSpeed(atoi(lv_textarea_get_text(objects.ta_guest_address)), guestSpeed, guestDir);
      }
      break;
    }
    case 4:       //Direction - Set to Forward
    {
//      Serial.println(""Direction set Forward"");
      if(rosterMode != GUEST_ACTIVE)
      {
        if(locoSpeed[activeLocoID] > thresholdSpeed) locoSpeed[activeLocoID] = 0;
        locoDir[activeLocoID] = 1;
        setSpeed(atoi(locoAddress[activeLocoID]), locoSpeed[activeLocoID], locoDir[activeLocoID]);
      }else
      {
        if(guestSpeed > thresholdSpeed) guestSpeed = 0;
        guestDir = 1;
        setSpeed(atoi(lv_textarea_get_text(objects.ta_guest_address)), guestSpeed, guestDir);
      }
      break;
    }
    case 5:       //Direction - Set to Reverse
    {
//      Serial.println(""Direction set Reverse"");
      if(rosterMode != GUEST_ACTIVE)
      {
        if(locoSpeed[activeLocoID] > thresholdSpeed) locoSpeed[activeLocoID] = 0;
        locoDir[activeLocoID] = 0;
        setSpeed(atoi(locoAddress[activeLocoID]), locoSpeed[activeLocoID], locoDir[activeLocoID]);
      }else
      {
        if(guestSpeed > thresholdSpeed) guestSpeed = 0;
        guestDir = 0;
        setSpeed(atoi(lv_textarea_get_text(objects.ta_guest_address)), guestSpeed, guestDir);
      }
      break;
    }
    case 6:
//      Serial.println(""Clicked Up"");
      if(locoSpeed[activeLocoID] < 126) locoSpeed[activeLocoID] = locoSpeed[activeLocoID] + 1;
      setSpeed(atoi(locoAddress[activeLocoID]), locoSpeed[activeLocoID], locoDir[activeLocoID]);
//      Serial.printf(""New Speed: %d\n"", locoSpeed[activeLocoID]);
      break;
    case 7:
//      Serial.println(""Clicked Down"");
      if(locoSpeed[activeLocoID] > 0) locoSpeed[activeLocoID] = locoSpeed[activeLocoID] - 1;
      setSpeed(atoi(locoAddress[activeLocoID]), locoSpeed[activeLocoID], locoDir[activeLocoID]);
//      Serial.printf(""New Speed: %d\n"", locoSpeed[activeLocoID]);
      break;
    case 29:    //Edit Button
    {
      clearGuest();
      editingID = activeLocoID;
      lv_textarea_set_text(objects.ta_name, locoName[editingID]);
      lv_textarea_set_text(objects.ta_address, locoAddress[editingID]);
      setupFuncEditSlots();
      callingPage = SCREEN_ID_THROTTLE;
      loadScreen(SCREEN_ID_EDIT_LOCO);
      break;
    }
    case 30:    //Prog Button
      clearGuest();
      callingPage = SCREEN_ID_THROTTLE;
      loadScreen(SCREEN_ID_PROGRAM);
      break;
    case 31:    //Roster
      clearGuest();
      callingPage = SCREEN_ID_THROTTLE;
      loadScreen(SCREEN_ID_ROSTER);
      break;
    case 32:    //Acc
//      callingPage = SCREEN_ID_THROTTLE;
//      loadScreen(SCREEN_ID_ACCESSORIES);
      break;
    default:
      break;
  }
}


void setLocoFwd()
{
  Serial.println(""Direction set Forward"");
  if(rosterMode != GUEST_ACTIVE)
  {
    if(locoSpeed[activeLocoID] > thresholdSpeed) locoSpeed[activeLocoID] = 0;
    locoDir[activeLocoID] = 1;
    setSpeed(atoi(locoAddress[activeLocoID]), locoSpeed[activeLocoID], locoDir[activeLocoID]);
  }else
  {
    if(guestSpeed > thresholdSpeed) guestSpeed = 0;
    guestDir = 1;
    setSpeed(atoi(lv_textarea_get_text(objects.ta_guest_address)), guestSpeed, guestDir);
  }
}

void setLocoRev()
{
  Serial.println(""Direction set Reverse"");
  if(rosterMode != GUEST_ACTIVE)
  {
    if(locoSpeed[activeLocoID] > thresholdSpeed) locoSpeed[activeLocoID] = 0;
    locoDir[activeLocoID] = 0;
    setSpeed(atoi(locoAddress[activeLocoID]), locoSpeed[activeLocoID], locoDir[activeLocoID]);
  }else
  {
    if(guestSpeed > thresholdSpeed) guestSpeed = 0;
    guestDir = 0;
    setSpeed(atoi(lv_textarea_get_text(objects.ta_guest_address)), guestSpeed, guestDir);
  }
}

#if defined ESP32DIS06043H || defined ESP32DIS08070H || defined ESP32DIS02170A

void action_functions_button(lv_event_t * e)
{
  void *user_data = lv_event_get_user_data(e);
  int pressedButton = *((int*)(&user_data));
  switch(pressedButton)
  {
    case 30:    //Cancel Button
     loadScreen(SCREEN_ID_THROTTLE);
      break;
    case 31:    //Description Button
      break;
    case 32:    //Done Button
      loadScreen(SCREEN_ID_THROTTLE);
      break;
    default:
      break;
  }
}

static void ex_functions_cb(lv_event_t * e)
{
  if(rosterMode == GUEST_INACTIVE)
  {
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t * obj = lv_event_get_target(e);
    uint32_t fNum = lv_btnmatrix_get_selected_btn(obj); 
    if(fNum == 65535) return;
//    Serial.printf(""Button: %d\n"", fNum);
    if(lv_btnmatrix_has_btn_ctrl(obj, fNum, LV_BTNMATRIX_CTRL_DISABLED)) return;
    if(code == LV_EVENT_PRESSED)
    {
      if(lv_obj_get_state(objects.desc_button) == LV_STATE_CHECKED)
      {
        Serial.printf(""Function Pressed: %d\n"", fNum);
        Serial.printf(""Active ID: %d\n"", activeLocoID);
        Serial.println(funcName[activeLocoID][fNum]);
//        std::string s = std::to_string(fNum);
//        s = ""Function Pressed: F"" + s;
//        const char* fDesc = s.c_str();
//        lv_label_set_text(objects.func_description, fDesc);
        lv_label_set_text(objects.func_description, funcName[activeLocoID][fNum]);


//        if(funcState[activeLocoID][fslot] == 1) funcState[activeLocoID][fslot] = 0;
//        else funcState[activeLocoID][fslot] = 1;
//        //Send the DCCEX Command...
//        String functionCMD = (""<F "" + String(locoAddress[activeLocoID]) + "" "" + String(atoi(funcNumber[activeLocoID][fslot])) + "" "" + String(funcState[activeLocoID][fslot]) + "">"");
//        Serial.println(functionCMD);
//        client.print(functionCMD);
//        if(!client.print(functionCMD)) Serial.println(""Transmit Failed"");
      }
    }else if(code == LV_EVENT_RELEASED)
    {
      if(lv_obj_get_state(objects.desc_button) == LV_STATE_CHECKED)
      {
        Serial.printf(""Function Released: %d\n"", fNum);
        lv_label_set_text(objects.func_description, """");
        lv_btnmatrix_clear_btn_ctrl(obj, fNum, LV_BTNMATRIX_CTRL_CHECKED);
 //       if(funcOption[activeLocoID][fslot] == 1)
 //       {
 //         lv_btnmatrix_clear_btn_ctrl(obj, func_xlate[fslot], LV_BTNMATRIX_CTRL_CHECKED);
 //         funcState[activeLocoID][fslot] = 0;
 //         //Send the DCCEX Command...
 //         String functionCMD = (""<F "" + String(locoAddress[activeLocoID]) + "" "" + String(atoi(funcNumber[activeLocoID][fslot])) + "" "" + String(funcState[activeLocoID][fslot]) + "">"");
 //         Serial.println(functionCMD);
 //         if(!client.print(functionCMD)) Serial.println(""Transmit Failed"");
 //          client.print(functionCMD);
 //       }
      }
    }
  }
}

#endif
#endif  // THROTTLE_PAGE_H

",speedCMD
267,"#include ""arduino_secrets.h""
/*----------------------------------------------------------------------------*/
/*                                 Includes                                   */
/*----------------------------------------------------------------------------*/
#include ""thingProperties.h""
/*----------------------------------------------------------------------------*/
/*                               Local defines                                */
/*----------------------------------------------------------------------------*/
#define ECHO_PIN    (21u)    /* Digital output PIN_21   */
#define TRIGGER_PIN (22u)    /* Digital input PIN_22    */
#define BLUE_PIN    (12u)    /* Digital output PIN_12   */


#define TEMT_PIN    (36u)    /* Analog input PIN_36    */

#define MAX_DISTANCE (100u)
#define MIN_LIGHT_INTENSITY (50u)
#define NUMBER_OF_SAMPLES_AVERAGE (5u)
/*----------------------------------------------------------------------------*/
/*                             Global data at RAM                             */
/*----------------------------------------------------------------------------*/
bool user_cntrl = false;
bool led_on = false;

xSemaphoreHandle xSemaphore;
/*----------------------------------------------------------------------------*/
/*                       Declaration of local functions                       */
/*----------------------------------------------------------------------------*/

void SDTR_UpdateCloud(void *pvParameters);

void SDTR_MeasureDistance(void *pvParameters);

void SDTR_MeasureLightIntensity(void *pvParameters);

void SDTR_BlinkLed(void *pvParameters);

/*----------------------------------------------------------------------------*/
/*                     Implementation of global functions                     */
/*----------------------------------------------------------------------------*/
void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);

  // Defined in thingProperties.h
  initProperties();

  xSemaphore = xSemaphoreCreateBinary();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);

  //Pin settings
  pinMode(TRIGGER_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(TEMT_PIN, INPUT);
  pinMode(BLUE_PIN, OUTPUT);

  //Task creation
  xTaskCreatePinnedToCore(
    SDTR_UpdateCloud,            // Task function
    ""SDTR_UpdateCloud"",          // Name
    1024 * 7,                       // Stack size of the task
    NULL,                        // Parameters
    1,                           // Priority
    NULL,                       // Task handle
    0);                         // Core

  xTaskCreatePinnedToCore(
    SDTR_MeasureDistance,        // Task function
    ""SDTR_MeasureDistance"",      // Name
    1024 * 7,                       // Stack size of the task
    NULL,                        // Parameters
    1,                           // Priority
    NULL,                       // Task handle
    0);                         //Core

  xTaskCreatePinnedToCore(
    SDTR_MeasureLightIntensity,        // Task function
    ""SDTR_MeasureLightIntensity"",      // Name
    1024 * 7,                       // Stack size of the task
    NULL,                        // Parameters
    1,                           // Priority
    NULL,                       // Task handle
    0);                         //Core

  xTaskCreatePinnedToCore(
    SDTR_BlinkLed,        // Task function
    ""SDTR_BlinkLed"",      // Name
    1024 * 7,                       // Stack size of the task
    NULL,                        // Parameters
    1,                           // Priority
    NULL,                       // Task handle
    0);                         //Core


  xSemaphoreGive(xSemaphore);
}

void loop() {
  //
  // Your code here


}



/*----------------------------------------------------------------------------*/
/*                     Implementation of local functions                      */
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/* SDTR_UpdateCloud                                                      */
/*----------------------------------------------------------------------------*/

void SDTR_UpdateCloud(void *pvParameters) {
  (void) pvParameters;
  // A task shall never return or exit
  for (;;) {
    xSemaphoreTake(xSemaphore, portMAX_DELAY);
    Serial.println(""Start WEB service..."");
    ArduinoCloud.update();
    xSemaphoreGive(xSemaphore);
    vTaskDelay(100 / portTICK_PERIOD_MS); //delay of 100ms
  }
}


/*----------------------------------------------------------------------------*/
/* SDTR_MeasureDistance                                                      */
/*----------------------------------------------------------------------------*/

void SDTR_MeasureDistance(void *pvParameters) {
  (void) pvParameters;
  // A task shall never return or exit
  for (;;) {
    SDTR_GetDistance();
    vTaskDelay(100 / portTICK_PERIOD_MS); //delay of 100ms
  }
}

/*----------------------------------------------------------------------------*/
/* SDTR_GetDistance                                                     */
/*----------------------------------------------------------------------------*/
void SDTR_GetDistance() {
  long pulseWidthInMicro = 0;
  int measured_distance = 0;

  digitalWrite(TRIGGER_PIN, HIGH);
  //10 us wait = 0.01ms/portTICK_PERIOD_MS
  vTaskDelay(0.01 / portTICK_PERIOD_MS);
  digitalWrite(TRIGGER_PIN, LOW);
  pulseWidthInMicro = pulseIn(ECHO_PIN, HIGH);
  measured_distance = (pulseWidthInMicro * 340 / 10000) / 2; //cm
  //distanta = (durata impuls*0,034secunde)/2
  xSemaphoreTake(xSemaphore, portMAX_DELAY);
  distance_cm = measured_distance;
  Serial.print(""Distance: "");
  Serial.print(distance_cm);
  Serial.print("" cm"");
  Serial.println();
  xSemaphoreGive(xSemaphore);
}

/*----------------------------------------------------------------------------*/
/* SDTR_MeasureLightIntensity                                                     */
/*----------------------------------------------------------------------------*/
void SDTR_MeasureLightIntensity(void *pvParameters) {
  (void) pvParameters;

  // A task shall never return or exit
  for (;;) {
    SDTR_GetIntensity();
    vTaskDelay(100 / portTICK_PERIOD_MS ); //delay of 100ms
  }
}

/*----------------------------------------------------------------------------*/
/* SDTR_GetIntensity                                                     */
/*----------------------------------------------------------------------------*/
void SDTR_GetIntensity() {
  long light_intensity_pin = 0; //pin light intensity
  long sum = 0;
  int adc_sample = 0;
  int  [MASK] ;

  for (adc_sample = 0; adc_sample < NUMBER_OF_SAMPLES_AVERAGE; adc_sample++)
  {
    sum = sum + analogRead(TEMT_PIN);
  }

  light_intensity_pin = sum / NUMBER_OF_SAMPLES_AVERAGE;
   [MASK]  = (light_intensity_pin * 100) / 4096;
  xSemaphoreTake(xSemaphore, portMAX_DELAY);
  light_intensity =  [MASK] ;
  Serial.print(""Light intensity: "");
  Serial.print(light_intensity);
  Serial.print(""%"");
  Serial.println();
  xSemaphoreGive(xSemaphore);
}

/*----------------------------------------------------------------------------*/
/* SDTR_BlinkLed                                                    */
/*----------------------------------------------------------------------------*/
void SDTR_BlinkLed(void *pvParameters) {
  (void) pvParameters;

  // A task shall never return or exit
  for (;;) {
    SDTR_Blink();
    vTaskDelay(100 / portTICK_PERIOD_MS ); //delay of 100ms
  }
}

/*----------------------------------------------------------------------------*/
/* SDTR_Blink                                                 */
/*----------------------------------------------------------------------------*/
void SDTR_Blink() {
  xSemaphoreTake(xSemaphore, portMAX_DELAY);
  if (user_cntrl == false)
  {
    if ((distance_cm > MAX_DISTANCE) && (light_intensity < MIN_LIGHT_INTENSITY))
    {
      led_status = true;
      Serial.println(""Turning on led... "");
      // digitalWrite(RED_PIN, LOW);
      digitalWrite(BLUE_PIN, HIGH);
      //digitalWrite(GREEN_PIN, HIGH);
      xSemaphoreGive(xSemaphore);
    }
    else
    {
      led_status = false;
      Serial.println(""Turning off led..."");
      // digitalWrite(RED_PIN, LOW);
      digitalWrite(BLUE_PIN, LOW);
      // digitalWrite(GREEN_PIN, LOW);
      xSemaphoreGive(xSemaphore);
    }
  }
  else
  {
    if (led_on == true)
    {
      // digitalWrite(RED_PIN, LOW);
      digitalWrite(BLUE_PIN, HIGH);
      //  digitalWrite(GREEN_PIN, HIGH);

    }
    else
    {
      //  digitalWrite(RED_PIN, LOW);
      digitalWrite(BLUE_PIN, LOW);
      //  digitalWrite(GREEN_PIN, LOW);
    }
    xSemaphoreGive(xSemaphore);
  }
}


/*
  Since LedTurnOn is READ_WRITE variable, onLedTurnOnChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onLedTurnOnChange()  {
  led_on = led_turn_on;
}

/*
  Since UserControl is READ_WRITE variable, onUserControlChange() is
  executed every time a new value is received from IoT Cloud.
*/
void onUserControlChange()  {
  user_cntrl = user_control;
}",measured_intensity
268,"#define REMOTEXY_MODE__ESP8266_HARDSERIAL_POINT

#include <RemoteXY.h>

// RemoteXY connection settings 
#define REMOTEXY_SERIAL Serial
#define REMOTEXY_SERIAL_SPEED 115200
#define REMOTEXY_WIFI_SSID ""Elevator prototype""
#define REMOTEXY_WIFI_PASSWORD ""<PASSWORD>""
#define REMOTEXY_SERVER_PORT 6377


// RemoteXY configurate  
#pragma pack(push, 1)
uint8_t RemoteXY_CONF[] =   // 61 bytes
  { 255,2,0,0,0,54,0,16,55,1,1,0,23,44,17,17,2,31,85,112,
  0,1,0,24,69,17,17,2,31,68,111,119,110,0,129,0,8,25,49,5,
  37,87,101,108,99,111,109,101,32,116,111,32,69,108,101,118,97,116,111,114,
  0 };
  
// this structure defines all the variables and events of your control interface 
struct {

    // input variables
  uint8_t button_1; // =1 if button pressed, else =0 
  uint8_t button_2; // =1 if button pressed, else =0 

    // other variable
  uint8_t connect_flag;  // =1 if wire connected, else =0 

} RemoteXY;
#pragma pack(pop)

/////////////////////////////////////////////
//           END RemoteXY include          //
/////////////////////////////////////////////
#define MOTOR_SPEED 200

//Right motor
int enableRightMotor = 6;
int rightMotorPin1 = 7;
int rightMotorPin2 = 8;

//Left motor
int enableLeftMotor = 5;
int leftMotorPin1 = 9;
int leftMotorPin2 = 10;




void setup() 
{
  RemoteXY_Init (); 
  
  
   TCCR0B = TCCR0B & B11111000 | B00000010;

  // put your setup code here, to run once:
  pinMode(enableRightMotor, OUTPUT);
  pinMode(rightMotorPin1, OUTPUT);
  pinMode(rightMotorPin2, OUTPUT);

  pinMode(enableLeftMotor, OUTPUT);
  pinMode(leftMotorPin1, OUTPUT);
  pinMode(leftMotorPin2, OUTPUT);


  rotateMotor(0, 0);  
  
  

}

void loop() 
{ 
  RemoteXY_Handler ();
  
  
  if(RemoteXY.button_1==1 )
  {
    rotateMotor(MOTOR_SPEED, 0);
  }
  else if(RemoteXY.button_2==1)
  {    
   rotateMotor(-MOTOR_SPEED, 0);    
  }
  else
  {
    rotateMotor(0, 0);
  }
  // use the RemoteXY structure for data transfer
  
  // do not call delay(), use instead RemoteXY_delay() 

  


}

void rotateMotor(int  [MASK] , int leftMotorSpeed) {

  if ( [MASK]  < 0) {
    digitalWrite(rightMotorPin1, LOW);
    digitalWrite(rightMotorPin2, HIGH);
  } else if ( [MASK]  > 0) {
    digitalWrite(rightMotorPin1, HIGH);
    digitalWrite(rightMotorPin2, LOW);
  } else {
    digitalWrite(rightMotorPin1, LOW);
    digitalWrite(rightMotorPin2, LOW);
  }

  if (leftMotorSpeed < 0) {
    digitalWrite(leftMotorPin1, LOW);
    digitalWrite(leftMotorPin2, HIGH);
  } else if (leftMotorSpeed > 0) {
    digitalWrite(leftMotorPin1, HIGH);
    digitalWrite(leftMotorPin2, LOW);
  } else {
    digitalWrite(leftMotorPin1, LOW);
    digitalWrite(leftMotorPin2, LOW);
  }
  analogWrite(enableRightMotor, abs( [MASK] ));
  analogWrite(enableLeftMotor, abs(leftMotorSpeed));
}",rightMotorSpeed
269,"#pragma once
#include ""llvm/IR/Function.h""
#include <deque>
#include <unordered_set>
#include <unordered_map>
#include <utility>

namespace llvm
{
    struct Context
    {
        std::deque<const llvm::Value *> values; // e.g., function or instruction

        Context() = default;
        Context(std::initializer_list<const llvm::Value *> il) : values(il) {}

        bool operator==(const Context &other) const
        {
            return values == other.values;
        }

        bool empty() const { return values.empty(); }
        size_t size() const { return values.size(); }
        const llvm::Value *operator[](size_t  [MASK] ) const { return values[ [MASK] ]; }
        auto begin() const { return values.begin(); }
        auto end() const { return values.end(); }

        void print(llvm::raw_ostream &os) const
        {
            os << ""["";
            for (size_t i = 0; i < values.size(); ++i)
            {
                os << ""("" + std::to_string(i) + "") "";
                auto ctx = values[i];
                if (ctx)
                    ctx->print(os);
                else
                    os << ""null"";
                if (i < values.size() - 1)
                    os << "", "";
            }
            os << ""]"";
        }
    };

    inline Context Everywhere = Context(); // Singleton instance for context-insensitive analysis

    // Overload operator<< for Node as a free function
    inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const llvm::Context &context)
    {
        context.print(os);
        return os;
    }

    struct CGNode
    {
        int id; // Unique node ID
        llvm::Function *function;
        Context context;

        // Default constructor
        CGNode() : id(0), function(nullptr), context(Everywhere) {}

        CGNode(int id, llvm::Function *func, Context ctx = Everywhere)
            : id(id), function(func), context(ctx) {}

        bool operator==(const CGNode &other) const
        {
            if (function != other.function)
                return false;
            if (context == Everywhere && other.context == Everywhere)
                return true;
            if (context.size() != other.context.size())
                return false;
            for (size_t i = 0; i < context.size(); ++i)
            {
                if (context[i] != other.context[i])
                    return false;
            }
            return true;
        }

        void print(llvm::raw_ostream &os) const
        {
            os << ""[CGNode id="" << id << "", function="";
            if (function)
                os << function->getName();
            else
                os << ""null"";
            os << "", context=["";
            if (context == Everywhere)
            {
                os << ""Everywhere"";
            }
            else
            {
                context.print(os);
            }
            os << ""]"";
            os << ""]"";
        }
    };
    inline CGNode NullCGNode = CGNode(); // Singleton instance for empty CGNode

    // Overload operator<< for Node as a free function
    inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const llvm::CGNode &node)
    {
        node.print(os);
        return os;
    }

} // namespace llvm

namespace std
{
    template <>
    struct hash<llvm::Context>
    {
        std::size_t operator()(const llvm::Context &ctx) const noexcept
        {
            std::size_t h = 0;
            for (const auto *v : ctx.values)
            {
                h ^= std::hash<const llvm::Value *>{}(v) + 0x9e3779b9 + (h << 6) + (h >> 2);
            }
            return h;
        }
    };

    template <>
    struct hash<llvm::CGNode>
    {
        std::size_t operator()(const llvm::CGNode &node) const noexcept
        {
            std::size_t h1 = std::hash<llvm::Function *>{}(node.function);
            std::size_t h2 = std::hash<llvm::Context>{}(node.context);
            return h1 ^ (h2 << 1);
        }
    };

    template <>
    struct hash<std::pair<llvm::Value *, llvm::Context>>
    {
        std::size_t operator()(const std::pair<llvm::Value *, llvm::Context> &p) const noexcept
        {
            std::size_t h1 = std::hash<llvm::Value *>{}(p.first);
            std::size_t h2 = std::hash<llvm::Context>{}(p.second);
            return h1 ^ (h2 << 1);
        }
    };
}

namespace llvm
{
    class CallGraph
    {
    private:
        using NodeKey = std::pair<llvm::Function *, Context>;
        struct NodeKeyHash
        {
            std::size_t operator()(const NodeKey &k) const noexcept
            {
                std::size_t h1 = std::hash<llvm::Function *>{}(k.first);
                std::size_t h2 = 0;
                if (!k.second.empty())
                {
                    for (const auto *v : k.second)
                    {
                        h2 ^= std::hash<const llvm::Value *>{}(v) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
                    }
                }
                // If context is empty, h2 remains 0
                return h1 ^ (h2 << 1);
            }
        };

        int nextNodeId = 0;                          // Monotonically increasing node ID
        std::unordered_map<int, CGNode> idToNodeMap; // Map from node ID to CGNode
        std::unordered_map<NodeKey, CGNode, NodeKeyHash> ValueContextToNodeMap;

    public:
        using CallEdgeSet = std::unordered_set<int>;
        using Node2EdgeSet = std::unordered_map<int, CallEdgeSet>;

        CGNode getOrCreateNode(llvm::Function *func, Context ctx = Everywhere);

        // Add an edge from caller to callee
        void addEdge(CGNode caller, CGNode callee)
        {
            graph_[caller.id].insert(callee.id);
        }

        // Get callees for a given caller
        const CallEdgeSet &getCallees(CGNode caller) const
        {
            static CallEdgeSet empty;
            auto it = graph_.find(caller.id);
            return it != graph_.end() ? it->second : empty;
        }

        const CGNode getNode(int id) const
        {
            auto it = idToNodeMap.find(id);
            return it != idToNodeMap.end() ? it->second : NullCGNode;
        }

        const CGNode getNode(llvm::Function *func, Context ctx = Everywhere) const
        {
            auto it = ValueContextToNodeMap.find(std::make_pair(func, ctx));
            return it != ValueContextToNodeMap.end() ? it->second : NullCGNode;
        }

        // Get the underlying map (const)
        const Node2EdgeSet &getGraph() const { return graph_; }

        // Get the number of nodes
        size_t numNodes() const { return graph_.size(); }

        // Get the number of edges
        size_t numEdges() const
        {
            size_t edges = 0;
            for (const auto &entry : graph_)
                edges += entry.second.size();
            return edges;
        }

        // Iterate over all nodes
        auto begin() const { return graph_.begin(); }
        auto end() const { return graph_.end(); }

        void printCG(std::ofstream &outFile) const;

        void clear()
        {
            graph_.clear();
            idToNodeMap.clear();
            ValueContextToNodeMap.clear();
        }

    private:
        Node2EdgeSet graph_;
    };

} // namespace llvm
",idx
270,"/*
 * Copyright (C) 2021 Huawei Device Co., Ltd.
 * 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 ""delivery_callback.h""

#include <uv.h>

#include ""napi_util.h""
#include ""telephony_log_wrapper.h""

namespace OHOS {
namespace Telephony {
DeliveryCallback::DeliveryCallback(bool hasCallback, napi_env env, napi_ref thisVarRef, napi_ref callbackRef)
    : hasCallback_(hasCallback), env_(env), thisVarRef_(thisVarRef), callbackRef_(callbackRef)
{}

DeliveryCallback::~DeliveryCallback()
{
    env_ = nullptr;
    thisVarRef_ = nullptr;
    callbackRef_ = nullptr;
}

void CompleteSmsDeliveryWork(uv_work_t *work, int status)
{
    TELEPHONY_LOGI(""CompleteSmsDeliveryWork start"");
    std::unique_ptr<DeliveryCallbackContext> pContext(static_cast<DeliveryCallbackContext *>(work->data));
    if (pContext == nullptr) {
        TELEPHONY_LOGE(""CompleteSmsDeliveryWork pContext is nullptr!"");
        return;
    }
    napi_env env_ = pContext->env;
    napi_ref thisVarRef_ = pContext->thisVarRef;
    napi_ref callbackRef_ = pContext->callbackRef;
    std::string  [MASK]  = pContext->pduStr;
    napi_handle_scope scope = nullptr;
    napi_open_handle_scope(env_, &scope);
    if (scope == nullptr) {
        TELEPHONY_LOGE(""scope is nullptr"");
        napi_close_handle_scope(env_, scope);
        return;
    }
    napi_value callbackFunc = nullptr;
    napi_get_reference_value(env_, callbackRef_, &callbackFunc);
    napi_value callbackValues[2] = {0};
    if (! [MASK] .empty()) {
        callbackValues[0] = NapiUtil::CreateUndefined(env_);
        napi_create_object(env_, &callbackValues[1]);
        napi_value arrayValue = nullptr;
        napi_create_array(env_, &arrayValue);
        for (uint32_t i = 0; i < static_cast<uint32_t>( [MASK] .size()); ++i) {
            napi_value element = nullptr;
            int32_t intValue =  [MASK] [i];
            napi_create_int32(env_, intValue, &element);
            napi_set_element(env_, arrayValue, i, element);
        }
        std::string pduStr = ""pdu"";
        napi_set_named_property(env_, callbackValues[1],  [MASK] .c_str(), arrayValue);
    } else {
        callbackValues[0] = NapiUtil::CreateErrorMessage(env_, ""pdu empty"");
        callbackValues[1] = NapiUtil::CreateUndefined(env_);
    }
    napi_value callbackResult = nullptr;
    napi_value thisVar = nullptr;
    size_t argc = sizeof(callbackValues) / sizeof(callbackValues[0]);
    napi_get_reference_value(env_, thisVarRef_, &thisVar);
    napi_call_function(env_, thisVar, callbackFunc, argc, callbackValues, &callbackResult);
    napi_delete_reference(env_, thisVarRef_);
    napi_delete_reference(env_, callbackRef_);
    napi_close_handle_scope(env_, scope);
    if (work != nullptr) {
        delete work;
    }
    TELEPHONY_LOGI(""CompleteSmsDeliveryWork end"");
}

void DeliveryCallback::OnSmsDeliveryResult(const std::u16string pdu)
{
    TELEPHONY_LOGI(""OnSmsDeliveryResult start"");
    if (hasCallback_) {
        uv_loop_s *loop = nullptr;
        napi_get_uv_event_loop(env_, &loop);
        uv_work_t *work = new uv_work_t;
        if (work == nullptr) {
            TELEPHONY_LOGE(""OnSmsDeliveryResult work is nullptr!"");
            return;
        }
        DeliveryCallbackContext *pContext = std::make_unique<DeliveryCallbackContext>().release();
        if (pContext == nullptr) {
            TELEPHONY_LOGE(""OnSmsDeliveryResult pContext is nullptr!"");
            delete work;
            return;
        }
        pContext->env = env_;
        pContext->thisVarRef = thisVarRef_;
        pContext->callbackRef = callbackRef_;
        pContext->pduStr = NapiUtil::ToUtf8(pdu);
        work->data = static_cast<void *>(pContext);
        uv_queue_work(
            loop, work, [](uv_work_t *work) {},
            [](uv_work_t *work, int status) { CompleteSmsDeliveryWork(work, status); });
    }
}
} // namespace Telephony
} // namespace OHOS",pduStr_
271,"/*
 * Copyright 2024 WuXi EsionTech Co., Ltd.
 *
 * 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 _PYTHON_BRIDGE_H_
#define _PYTHON_BRIDGE_H_

#include <functional>
#include <mutex>

#include <riscv/abstract_device.h>
#include <riscv/csrs.h>
#include <riscv/disasm.h>
#include <riscv/extension.h>
#include <riscv/processor.h>
#include <riscv/rocc.h>

#include <pybind11/embed.h>
#include <pybind11/stl.h>

class PythonBridge {
private:
  PythonBridge();
  ~PythonBridge();

private:
  PythonBridge(const PythonBridge &) = delete;
  PythonBridge(const PythonBridge &&) = delete;
  PythonBridge &operator=(const PythonBridge &) = delete;
  PythonBridge &operator=(const PythonBridge &&) = delete;

public:
  // returns singleton instance of python bridge
  static PythonBridge &getInstance();

public:
  // keep the python object alive on the C++ side
  template <typename T> T track(pybind11::handle py_obj) {
    static_assert(
        std::is_pointer<T>::value &&
            (std::is_base_of<abstract_device_t,
                             typename std::remove_pointer<T>::type>::value ||
             std::is_base_of<const device_factory_t,
                             typename std::remove_pointer<T>::type>::value ||
             std::is_base_of<arg_t,
                             typename std::remove_pointer<T>::type>::value ||
             std::is_base_of<csr_t,
                             typename std::remove_pointer<T>::type>::value ||
             std::is_base_of<rocc_t,
                             typename std::remove_pointer<T>::type>::value ||
             std::is_base_of<extension_t,
                             typename std::remove_pointer<T>::type>::value ||
             std::is_base_of<insn_desc_t,
                             typename std::remove_pointer<T>::type>::value ||
             std::is_base_of<disasm_insn_t,
                             typename std::remove_pointer<T>::type>::value),
        ""T must be abstract_device_t, device_factory_t, arg_t, csr_t, rocc_t, ""
        ""extension_t, insn_desc_t, or disasm_insn_t"");
    T obj = pybind11::cast<T>(py_obj);
    uint64_t  [MASK]  = reinterpret_cast<uint64_t>(obj);
    if (references.emplace( [MASK] , py_obj).second) {
      py_obj.inc_ref();
    }
    return obj;
  };

private:
  // do we need to initialize the python interpreter?
  bool standalone;

  // references to python objects that need to be kept alive
  std::map<uint64_t, pybind11::handle> references;

private:
  static PythonBridge singleton;
};

std::string format_ptr(const void *ptr, size_t width = 16);

std::ostream &operator<<(std::ostream &os, insn_func_t &f);

#endif // _PYTHON_BRIDGE_H_
",addr
272,"#include ""iostream""

constexpr int SERIES_SIZE = 999;

bool sortedArrayIncludes(long *array, int size, long value)
{
    for (int i = 0; i < size; i++)
    {
        if (array[i] > value)
            return false;
        if (array[i] == value)
            return true;
    }
    return false;
}

void cleanArray(long *array, int &size, long removeuntil)
{
    int offset = 0;
    for (int i = 0; i < size; i++)
    {
        if (array[i] < removeuntil)
            continue; // XXX - consider <=
        offset = i;
        break;
    }

    for (int i = 0; i < size - offset; i++)
    {
        array[i] = array[i + offset];
    }
    size -= offset;
}

int main()
{
    long  [MASK]  = 1;
    long series[SERIES_SIZE];

    long lastadded = 1;
    series[0] = lastadded;
    int size = 1;

    while (true)
    {
        std::cout << lastadded << std::endl;
        if (size >= SERIES_SIZE)
        {
            cleanArray(series, size,  [MASK] );
            if (size >= SERIES_SIZE)
                return 0; // Could not free any memory!
            continue;
        }
        if (sortedArrayIncludes(series, size,  [MASK] ))
        {
             [MASK] ++;
            continue;
        }

        lastadded +=  [MASK] ;
         [MASK] ++;
        series[size] = lastadded,
        size++;
    }
    return 1;
}",current
273,"// Board   : Arduino Uno/Nano/Micro
// Author  : <NAME>
// Date    : 31 Aug 2022
// Purpose : Driver code for ADF4156 (6.2GHz Fractional-N) PLL Chip.

// Pins declarations
//        Pin Name    Arduino Pin     Remark
//        --------    -----------     ------
#define   PIN_CLK       13           // Clock
#define   PIN_DATA      12           // Serial data
#define   PIN_LE        11           // Latch enable
#define   PIN_MUXOUT    10           // For checking if PLL is phase-locked or not,
                                     // and for debugging.
#define   PIN_LED        9           // Optional, connect to LED via 1k resistor.
#define   PIN_TRIGGER    8           // Optional, to trigger oscilloscope.

// Global variables declarations
#define ASSERT_PIN_LE             LOW
#define DEASSERT_PIN_LE           HIGH

byte   gbytRead;
  
unsigned int unN;          // N divider for frequency synthesizer IC.

void setup()
{
  pinMode(PIN_CLK, OUTPUT);
  pinMode(PIN_DATA, OUTPUT);
  pinMode(PIN_LE, OUTPUT);
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_MUXOUT, INPUT);
  pinMode(PIN_TRIGGER, OUTPUT);
  Serial.begin(9600);  // Setup Serial Port.
}

void loop()
{
  static byte bytState = 0;
  static int  nTimer = 1;

  // --- Setup up PLL Chip ---
  // fosc = 16 MHz
  // R = 4
  // N = 3480
  // MOD = 100
  // FRAC = 0
  // fvco = (N + (FRAC/MOD))*(fosc/R) = 870 MHz.
  
  delay(1000);
  // Load register R4, the CLK DIV register.
  // 1. The internal clock divider allows the PLL IC to extract clocking signals from the 
  // reference oscillator.  This is used for the IC internal logic process such as
  // lock detection, modulation, fast-lock assist, cycle-slip reduction etc.  
  // Here it is not important and we set the clock divider to 16.  Thus:
  // Assuming fosc = 16MHz, a 1MHz internal clock is generated.
  // 2. Clock divider mode = off.  We set it to other modes when either fast-lock or
  // cycle-slip reduction functions are activated.  
  nSendData_ADF41XX(0x00000804,32);
  delay(1); // A short delay for the PLL chip to lock.
  //Load register R3, the Function Register.
  // 1. Counter reset = disabled.
  // 2. CP three-state = disabled.
  // 3. Power down = disabled.
  // 4. Phase detector polarity = positive (e.g. rising edge).
  // 5. Lock detect precision = high.
  // 6. Sigma-delta reset = yes whenever registor R0 is written.    
  nSendData_ADF41XX(0x00000043,32);  
  delay(1); // A short delay for the PLL chip to lock.
  //Load register R2, the MOD/R Register.
  // 1. Here we set the reference divider R to 4 by
  //    D=0, R=4, T=0.
  // 2. We also use P=8 (e.g. p/p+1) prescalar. This means minimum INT value allowed is 75.
  // 3. Here we set the modulus (MOD) = 10.
  // 4. Charge pump current setting = 3 (e.g. (3+1)/16 = 1/4 of max current),
  //    or for Rset = 10kOhm, Icp = (1/4)x2.55 mA = 0.6375 mA.
  // 5. Cycle-slip reduction = disabled.
  // 6. Noise mode = Low noise.     
  nSendData_ADF41XX(0x03420322,32); // Low noise mode, M = 100
  //nSendData_ADF41XX(0x63420322,32); // Low spur mode, M = 100
  delay(1); // A short delay for the PLL chip to lock. 
  // Load register R1, the Phase Register.
  // We can change the phase of the RF output in relation to the reference signal here 
  // at a resolution of (360degree)/MOD. Thus the value of Phase Register should always
  // be less than MOD.
  // If not used, set to 1 as per the recommendation of the datasheet.  Note that we
  // adjust this to optimize the RF output spurs.   
  nSendData_ADF41XX(0x00000009,32);  
  delay(1); // A short delay for the PLL chip to lock.
  //Load register R0, the FRAC/INT Register.
  // Here we set:
  // 1. FRAC = 0.
  // 2. INT or N = 870.
  // 3. MUX out = As per application.
  // Subsequently these can be changed as per application.      
  nSendData_ADF41XX(0x306C8180,32);   // N = 217, m = 50 
  //nSendData_ADF41XX(0x306B8000,32);   // N = 215, m = 0
  delay(1); // A short delay for the PLL chip to lock.

  // User routines
  while (1)
  {
    // Uncomment and comment as needed.
    /*
    // --- Small sweep 0.1 MHz ---
    delay(1000);
    CheckMuxOut();
    digitalWrite(PIN_TRIGGER, HIGH);
    nSendData_ADF41XX(0x31B20000,32);   // N + m/M = 868.0 (Make sure M is set properly in R2)
    digitalWrite(PIN_TRIGGER, LOW);
    delay(1000);
    CheckMuxOut();
    //nSendData_ADF41XX(0x31B20008,32);   // N + m/M = 868.1 (Make sure M is set properly in R2)
    //delay(1000);
    //CheckMuxOut();
    //nSendData_ADF41XX(0x31B20010,32);   // N + m/M = 868.2 (Make sure M is set properly in R2)
    //delay(1000);
    //CheckMuxOut();
    digitalWrite(PIN_TRIGGER, HIGH);
    nSendData_ADF41XX(0x31B20018,32);   // N + m/M = 868.3 (Make sure M is set properly in R2)         
    digitalWrite(PIN_TRIGGER, LOW);
    */
    
    
    // --- Large sweep 10 MHz ---
    delay(1000);
    CheckMuxOut();
    digitalWrite(PIN_TRIGGER, HIGH);    // Optional, to trigger oscilloscope.
    nSendData_ADF41XX(0x306C8180,32);   // N = 217, m = 50, M = 100, fref = 4 MHz.     
    digitalWrite(PIN_TRIGGER, LOW);     // fvco = 870 MHz.
    delay(1000);
    CheckMuxOut();
    digitalWrite(PIN_TRIGGER, HIGH);    // Optional, to trigger oscilloscope.
    nSendData_ADF41XX(0x306B8000,32);   // N = 215, m = 0, M =100, fref = 4 MHz.
    digitalWrite(PIN_TRIGGER, LOW);     // fvco = 860 MHz.
    
  }
}

// Function name  : SendData_ADF41XX
// Author         : <NAME>
// Last modified  : 22 July 2022
// Description    : To send serial data to ADF41XX family of PLL chip via 
//                  SPI bus. The length of the data is variable length  
//                  (1-32 bits), and data is shifted MSb first.
// Arguments      : ulnData - unsigned 32 bit data (max length) to be transmitted out.
//                  nLength - Length of data in bits, limited to 32 bits.
// Return         : 1 if successful
//                  else 0.
int nSendData_ADF41XX(unsigned long ulnData, int nLength)
{
    int nCount;
    int nTemp;
    unsigned long  [MASK] ;
    
    if (nLength > 32)       // Limit the maximum bit length.
    {
        nLength = 32;
    }
     [MASK]  = ulnData;
     [MASK]  =  [MASK]  << (32-nLength);          // Left shift the data by (32-nLength)
                                                // bits so that all the data bits to
                                                // be send out occupy left most bit
                                                // positions.
    //digitalWrite(PIN_LE, ASSERT_PIN_LE);  
    for (nCount = 0; nCount < nLength; nCount++)
    {
        digitalWrite(PIN_CLK, LOW);
        if (( [MASK]  & 0x80000000) > 0)       // Check MSb value.
        {
            digitalWrite(PIN_DATA, HIGH);
        }
        else
        {
            digitalWrite(PIN_DATA, LOW);
        }      
        nTemp++;            // Dummy instruction as delay.
        digitalWrite(PIN_CLK, HIGH);
        //nTemp++;            // Dummy instruction as delay.
         [MASK]  =  [MASK]  << 1;          // Left shift 1 unit.
    }
    
    digitalWrite(PIN_LE, DEASSERT_PIN_LE);  
    nTemp++;                // Dummy instruction as delay.
    digitalWrite(PIN_LE, ASSERT_PIN_LE);
    nTemp++;            // Dummy instruction as delay.
    digitalWrite(PIN_DATA, LOW);
    digitalWrite(PIN_CLK, LOW);
    return  1;
} 

// Function name  : CheckMuxOut
// Author         : <NAME>
// Last modified  : 29 Aug 2022
// Description    : To check the status of FoLD pin of ADF41XX family of PLL 
//                  chip. Lights up LED is pin is High, else turn off LED.
// Arguments      : None.
// Return         : None.
void CheckMuxOut()
{
  if (digitalRead(PIN_MUXOUT) == 1)
  {
    digitalWrite(PIN_LED, HIGH);
  }
  else
  {
    digitalWrite(PIN_LED, LOW);
  }
}
",ulnTemp
274,"#include<dos.h>
#include<stdio.h>
#include<ctype.h>

#define TRUE -1
#define FALSE 0
#define MIN(a,b) ((a)<(b)?(a):(b))
#define MAX(a,b) ((a)<(b)?(b):(a))

#define INTR(com,x,y) {_DX=com;_AH=x;_AL=y;geninterrupt(0x14);}

class COMM{
    int port,buf_idx;
    char buf[20];
  public:
    int OpenComm(int );
    int OpenComm(char *initstr);
    void SetSpeed(long speed);
    void SetData(int);
    void SetParity(int p);
    void SetStop(int n);
    void CharOut(char c);
    int CharIn();
    int WaitChar();
    void UnGetChar(int c);
    long Read(char *buf,long len);
    long Write(char *buf,long len);
    void ClrInBuf();
    void ClrOutBuf();
    unsigned int cbInQue();
    unsigned int cbOutQue();
    void SetDTR(char state);
    void SetRTS(char state);
    int GetCTS();
    int GetCarrier();
    int GetLineReg();
    int GetModemReg();
    int DriverPresent();
    void DriverRemove();
};

int COMM::OpenComm(int com)
{
        char str[]=""COMx:1200,8,N,1"";
        str[3]='0'+com;
        return OpenComm(str);
}

int COMM::OpenComm(char *initstr)
{
    int cport, [MASK] ,stop,data,sp;
    long speed;

    if (sscanf(initstr,""COM%d:%ld,%d,%c,%d"",&cport,&speed,&data,& [MASK] ,&stop)!=5)
        return FALSE;
    if (!DriverPresent()) return FALSE;
    port=MAX(1,MIN(4,cport));
    buf_idx=0;
    if (port!=cport) return FALSE;
    SetSpeed(speed);
    SetData(data);
    SetParity( [MASK] );
    SetStop(stop);
    return TRUE;
}

void COMM::SetSpeed(long speed)
{
    int b;
    switch(speed){
        case 50: b=1;break;
        case 75: b=2;break;
        case 110: b=3;break;
        case 150: b=4;break;
        case 300: b=5;break;
        case 600: b=6;break;
        case 1200: b=7;break;
        case 2400: b=8;break;
        case 9600: b=9;break;
        case 19200: b=10;break;
        case 38400: b=11;break;
        case 115200: b=12;break;
        default:speed=2400;b=8;break;
    }

    INTR(port,0,b);
}

void COMM::SetData(int data)
{
    data=MAX(5,MIN(8,data));
    INTR(port,1,data);
}

void COMM::SetParity(int p)
{
    switch(toupper(p)){
        case 'N': p=0;break;
        case 'E': p=1;break;
        case 'O': p=2;break;
    }

    INTR(port,2,p);
}

void COMM::SetStop(int n)
{
    n=MAX(1,MIN(2,n));
    INTR(port,3,n);
}

void COMM::CharOut(char c)
{
    INTR(port,5,c);
}

int COMM::WaitChar()
{
    int c;
    while((c=(*this).CharIn())==-1);
    return c;
}

int COMM::CharIn()
{
    if (buf_idx) return buf[--buf_idx];
    INTR(port,6,0);
    return _AX;
}

void COMM::UnGetChar(int c)
{
    buf[buf_idx++]=c;
}

long COMM::Read(char *buf,long len)
{
    long l=len;
    while(l--)
        *buf++=CharIn();
    return len;
}

long COMM::Write(char *buf,long len)
{
    long l;
    for(l=0;l<len;l++,buf++)
        CharOut(*buf);
    return len;
}

void COMM::ClrInBuf()
{
    buf_idx=0;
    INTR(port,7,0);
}

void COMM::ClrOutBuf()
{
    INTR(port,8,0);
}

void COMM::SetDTR(char state)
{
        INTR(port,9,state);
}

void COMM::SetRTS(char state)
{
        INTR(port,10,state);
}

int COMM::GetCarrier()
{
        INTR(port,11,0);
        return _AX;
}

int COMM::GetCTS()
{
        INTR(port,12,0);
        return _AX;
}

int COMM::DriverPresent()
{
        int myax;
        INTR(1,100,0);
        myax=_AX;
        if (myax==1234) return TRUE;
        else return FALSE;
}

void COMM::DriverRemove()
{
        INTR(1,13,0);
}

unsigned int COMM::cbInQue()
{
        INTR(port,14,0);
        return _AX+buf_idx;
}

unsigned int COMM::cbOutQue()
{
        INTR(port,15,0);
        return _AX;
}

int COMM::GetLineReg()
{
        INTR(port,16,0);
        return _AX;
}

int COMM::GetModemReg()
{
        INTR(port,17,0);
        return _AX;
}

",parity
275,"#include <chrono>
#include <sstream>
#include <ctime>
#include ""datetime.h""
#include ""utilities.h""

namespace Astro {

	Date::Date(int year, int month, int day, calendar c)
	:
		y(year), m(month), d(day), cal(c)
	{
	}	

	DateTime::DateTime(const Date& date, const Time& time)
	:
		d{ date }, t{ time }
	{
		update_jd();
	}

	void DateTime::update_jd()
	{
		bool ok;
		jd = Utilities::to_julian_day(*this, &ok);
		
		if(!ok) {

			ostringstream msg;
			msg << ""Invalid date/time: "" << *this;
			throw runtime_error{ msg.str() };
		}
	}

	Time::Time(int h, int m, int s)
	:
		h(h), m(m), s(s)
	{
		updateCount();
	}

	void Time::updateCount()
	{
		chrono::duration<double, ratio<3600>>  [MASK] ;

		 [MASK]  = chrono::hours{ h } + chrono::minutes{ m } + chrono::seconds{ s };

		c =  [MASK] .count();
	}

	void Time::setHour(int hours)
	{
		h = hours;
		updateCount();
	}

	void Time::setMinute(int minutes)
	{
		m = minutes;
		updateCount();
	}

	void Time::setSecond(int seconds)
	{
		s = seconds;
		updateCount();
	}

	ostream& operator<<(ostream& os, const Time& t) {

		return os << t.hours() << "":"" << t.minutes() << "":"" << t.seconds();
	}

	ostream& operator<<(ostream& os, const Date& d) {

		return os << d.year() << ""."" << d.month() << ""."" << d.day();
	}

	ostream& operator<<(ostream& os, const DateTime& dt) {

		return os << dt.date() << "" "" << dt.time();
	}
}",d_hours
276,"/*
 * Copyright [2023] [MALABZ_UESTC Pinglu Zhang]
 *
 * 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.
 */

// Author: <NAME>
// Contact: <EMAIL>
// Created: 2023-02-25

// The main function is the entry point of the program. It is where the program starts executing. 
// the program starts executing. 
#include ""include/common.h""
#include ""include/utils.h""
#include ""include/mem_finder.h""
#include ""include/sequence_split_align.h""
#if defined(__linux__)
#include ""include/thread_pool.h""
#endif
#include <thread>

GlobalArgs global_args;
int main(int argc, char** argv) {
    // Create a Timer object to record the execution time.
    Timer timer;
    // Create an ArgParser object to parse command line arguments.
    ArgParser parser;
    std::string output = """";
    // Add command line arguments to the ArgParser object.
    parser.add_argument(""i"", true, ""data/mt1x.fasta"");
    parser.add_argument_help(""i"", ""The path to the input file."");
    parser.add_argument(""t"", false, ""cpu_num"");
    parser.add_argument_help(""t"", ""The maximum number of threads that the program runs, the recommended setting is the number of CPUs."");
    parser.add_argument(""l"", false, ""default"");
    parser.add_argument_help(""l"", ""The minimum length of MEM, the default value is square root of mean length."");
    parser.add_argument(""c"", false, ""1"");
    parser.add_argument_help(""c"", ""A floating-point parameter that specifies the minimum coverage across all sequences, with values ranging from 0 to 1. The default \
setting is that if sequence number less 100, parameter is set to 1 otherwise 0.7."");
    parser.add_argument(""p"", false, ""mafft"");
    parser.add_argument_help(""p"", ""The MSA method used in parallel align. for example, halign3, halign2 and mafft."");
    parser.add_argument(""o"", false, ""output.fmaligned2.fasta"");
    parser.add_argument_help(""o"", ""The path to the output file."");
    parser.add_argument(""d"", false, ""0"");
    parser.add_argument_help(""d"", ""Depth of recursion, you could ignore it."");
    parser.add_argument(""f"", false, ""default"");
    parser.add_argument_help(""f"", ""The filter MEMs mode. The default setting is that if sequence number less 100, local mode otherwise global mode."");
    parser.add_argument(""v"", false, ""1"");
    parser.add_argument_help(""v"", ""Verbose option, 0 or 1. You could ignore it."");
    parser.add_argument(""h"", false, ""help"");
    parser.add_argument_help(""h"", ""print help information"");

    // Add command line arguments to the ArgParser object.
    try {
        parser.parse_args(argc, argv);
        global_args.data_path = parser.get(""i"");
        std::string tmp_thread = parser.get(""t"");
        if (tmp_thread == ""cpu_num"") {
            global_args.thread = std::thread::hardware_concurrency();
        }
        else {
            global_args.thread = std::stoi(tmp_thread);
        }
        std::string tmp_len = parser.get(""l"");
        if (tmp_len != ""default"") {
            global_args.min_mem_length = std::stoi(parser.get(""l""));
        }
        else {
            global_args.min_mem_length = -1;
        }

        std::string tmp_filter_mode = parser.get(""f"");
        if (tmp_filter_mode == ""default"") {
            global_args.filter_mode = tmp_filter_mode;
        }
        else if (tmp_filter_mode == ""global"" || tmp_filter_mode == ""local"") {
            global_args.filter_mode = tmp_filter_mode;
        }
        else {
            throw ""filer mode --f parameter should be global or local!"";
        }

        global_args.verbose = std::stoi(parser.get(""v""));
        if (global_args.verbose != 0 && global_args.verbose != 1) {
            throw ""verbose should be 1 or 0"";
        }

        global_args.degree = std::stoi(parser.get(""d""));
        if (global_args.degree > 2) {
            exit(1);
        }

        std::string tmp_c = parser.get(""c"");
        if (tmp_c == ""default"") {
            global_args.min_seq_coverage = -1;
        }
        else {
            global_args.min_seq_coverage = std::stof(parser.get(""c""));
            if (global_args.min_seq_coverage < 0 || global_args.min_seq_coverage > 1) {
                throw ""Error: min_seq_coverage should be ranged from 0 to 1!"";
            }
        }

        global_args.package = parser.get(""p"");
        if (global_args.package != ""halign2"" && global_args.package != ""halign3"" && global_args.package != ""mafft"") {
            throw (""Error: "" + global_args.package + "" is a invalid method!"");
        }

        global_args.output_path = parser.get(""o"");
    } // Catch any invalid arguments and print the help message.
    catch (const std::invalid_argument& e) {
        std::cerr << ""Error: "" << e.what() << std::endl;
        std::cerr << ""Program Exit!"" << std::endl;
        parser.print_help();
        return 1;
    }
    if (global_args.verbose) {
        print_algorithm_info();
    }

    std::vector<std::string> data;
    std::vector<std::string> name;

    try {
        // Read data from the input file and store in data and name vectors
        read_data(global_args.data_path.c_str(), data, name, true);
        // Find MEMs in the sequences and split the sequences into fragments for parallel alignment.
        std::vector<std::vector<std::pair<int_t, int_t>>> split_points_on_sequence = find_mem(data);
        split_and_parallel_align(data, name, split_points_on_sequence);
    }
    catch (const std::bad_alloc& e) { // Catch any bad allocations and print an error message.
        print_table_bound();
        std::cerr << ""Error: "" << e.what() << std::endl;
        std::cout << ""Program Exit!"" << std::endl;
        exit(1);
    }

    double  [MASK]  = timer.elapsed_time();
    std::stringstream s;
    s << std::fixed << std::setprecision(2) <<  [MASK] ;
    if (global_args.verbose) {
        output = ""FMAlign2 total time: "" + s.str() + "" seconds."";
        print_table_line(output);
        print_table_bound();
    }

    return 0;
}",total_time
277,"#include ""character.h""
#include <cstdlib>
#include <cwctype>
#include <ncurses.h>
#include <unistd.h>

bool empty_age(std::string const &age)
{
    if(age.empty())
    {
        return false;
    }
    for(char val : age)
    {
        if(!iswdigit(val))
        {
            return false;
        }
    }
    return true;
}

bool age_controller(int  [MASK] , const Character &game_character)
    {
        initscr();
        cbreak();
        WINDOW * startwin = newwin(10, 90, 0, 0);
        box(startwin, 0 , 0);
        refresh();
        wrefresh(startwin);
    if( [MASK]  >= 18)
    {
        mvwprintw(startwin, 3, 30, ""Welcome to the game 'Paradigma'!"");
        wrefresh(startwin);
        mvwprintw(startwin, 4, 18, ""Your character was created, your character`s name is: %s"", game_character.Get_name().c_str());
        wrefresh(startwin);
        sleep(3);
        return true;
    }
    else
    {
        if( [MASK]  == 0)
        {
            mvwprintw(startwin, 4, 25, ""Impossible 0_0"");
            wrefresh(startwin);
            sleep(3);
            return false;
        }
        else
        {
            mvwprintw(startwin, 4, 25, ""You are too young to play in this game"");
            wrefresh(startwin);
            sleep(3);
            return false;
        }
    }
}

bool name_controller(std::string const &input_name)
{
    return !input_name.empty();
}

bool only_letters(std::string const &input_name)
{
    return std::all_of(input_name.begin(), input_name.end(), [] (char const &c)
    {
        return std::isalpha(c);
    });
}

void start_game(std::string start)
{
    initscr();
    cbreak();
    WINDOW * startwin = newwin(10, 90, 0, 0);
    box(startwin, 0 , 0);
    refresh();
    wrefresh(startwin);
    start = ""Game will start now"";
    mvwprintw(startwin, 3, 35, ""%s"", start.c_str());
    wrefresh(startwin);
}
",input_age
278,"class Solution {
public://先对数组排个序。枚举第一个数，然后设两个指针，在第一个数的后半段开始王中间收缩，if sum > target则右指针往左移， if sum < target则左指针往右移。排序O(nlogn) + 查找O(n^2) = O(n^2)
    void quicksort(vector<int>& nums,int  [MASK] ,int end) { // 快排
    	if( [MASK] >=end) return ;
    	int i= [MASK] ,j=end,t=nums[ [MASK] ];  // 将基准挖出形成一个坑 
    	while(i<j) {
    		while(nums[j]>=t&&j>i) --j;  // 找到右边第一个小于基准的值 
    		if(j>i) nums[i++]=nums[j];   // 填坑   这时j位置为坑 
    		while(nums[i]<t&&i<j) ++i;  // 找到左边第一个大于分基准的值
    		if(i<j)	nums[j--]=nums[i];	// 填坑 这时i为坑 
    	}
    	nums[i]=t;   // 基准   基准左边做快排  右边做快排 
    	quicksort(nums, [MASK] ,i-1);quicksort(nums,i+1,end);
    }
    int threeSumClosest(vector<int>& nums, int target) {
        if(nums.size()<3) return 0;
        //sort(nums.begin(),nums.end());
        quicksort(nums,0,nums.size()-1);
        int i=0,j,k,sum,result;
        int min=INT_MAX;
        while(i<nums.size()){
            j=i+1;k=nums.size()-1; // 两边的指针
            while(j<k)
            {
                sum=nums[i]+nums[j]+nums[k];
                if(abs(sum-target)<min) {
                    min=abs(sum-target);
                    result=sum;
                }
                if(sum>target) --k;
                else ++j;
            }
 
            ++i;
        }
        return result;
    }
};",start
279,"#pragma once

#include <optional>
#include ""board.hpp""
#include ""matrix_algorithm.hpp""
#include ""mod_int.hpp""
#include ""point.hpp""
#include ""snake.hpp""
#include ""snake_arithmetic.hpp""

namespace snk {
namespace __details {
inline auto fill_snake_matrix(std::vector<std::vector<cell_info>>& matrix,
                              snake<mod_int> const& snake) {
  for (auto const& point : snake.body()) {
    auto const x = static_cast<std::size_t>(point.x.value());
    auto const y = static_cast<std::size_t>(point.y.value());
    matrix[y][x].set_body();
  }
  auto const  [MASK]  = static_cast<std::size_t>(snake.head().x.value());
  auto const head_y = static_cast<std::size_t>(snake.head().y.value());
  matrix[head_y][ [MASK] ].clear_body();
  matrix[head_y][ [MASK] ].set_head();
}

inline auto fill_fruit_matrix(std::vector<std::vector<cell_info>>& matrix,
                              point<std::size_t> const& fruit) {
  matrix[fruit.y][fruit.x].set_fruit();
}
}  // namespace __details

// Precondition:
//   - board.snake.head().x.modulus() == width
//   - board.snake.head().y.modulus() == height
//   - board.fruit_pos.x < width
//   - board.fruit_pos.y < height
// Postcondition:
//   - Returns a matrix with #rows = board.height, #cols = board.width
//   - if matrix[y][x] represents board at position (x, y) is occupied with
//     matrix[y][x] value
inline auto create_board_matrix(snk::board const& b) {
  std::vector matrix(b.height, std::vector(b.width, cell_info{}));
  __details::fill_snake_matrix(matrix, b.snake);
  __details::fill_fruit_matrix(matrix, b.fruit_pos);
  return matrix;
}

// Precondition:
//   - matrix[y][x] represents the board position info at position (x, y)
// Postcondition:
//   - returns a point (x, y) that is empty cell
//   - in case of no empty point is found nullopt is returned
template <typename RandomGenerator>
std::optional<point<std::size_t>> select_empty_cell(
    std::vector<std::vector<cell_info>> const& matrix,
    RandomGenerator&& generator) {
  auto const empty_cnt = nostd::count(matrix, cell_info{});
  if (empty_cnt == 0)
    return point{matrix[0].size(), matrix.size()};
  auto const nth =
      static_cast<std::size_t>(generator(1, static_cast<int>(empty_cnt)));
  auto const cell = nostd::find_n(matrix, cell_info{}, nth);
  return point{cell.second, cell.first};
}

// Postcondition:
//   - returns a point (x, y) that is empty cell
//   - in case of no empty point is found nullopt is returned
template <typename RandomGenerator>
auto generate_fruit(snk::board const& board, RandomGenerator&& rand) {
  return select_empty_cell(create_board_matrix(board),
                           std::forward<RandomGenerator>(rand));
}

// Postcondition:
//   - returns is_collided_to_self(board.snake)
inline auto has_collision(snk::board const& board) {
  return is_collided_to_self(board.snake);
}

// Postcondition:
//   - returns true if snake head is on fruit
inline auto ate_fruit(snk::board const& board) {
  return static_cast<std::size_t>(board.snake.head().x.value()) ==
             board.fruit_pos.x &&
         static_cast<std::size_t>(board.snake.head().y.value()) ==
             board.fruit_pos.y;
}
}  // namespace snk
",head_x
280,"#include <vector>
#include ""mbot.h""

using namespace std;
std::array<double, 36> odom_pose_covariance = {
    {1e-9, 0, 0, 0, 0, 0, 
    0, 1e-3,1e-9, 0, 0, 0, 
    0, 0, 1e6, 0, 0, 0,
    0, 0, 0, 1e6, 0, 0, 
    0, 0, 0, 0, 1e6, 0, 
    0, 0, 0, 0, 0, 1e-9}};
std::array<double, 36> odom_twist_covariance = {
    {1e-9, 0, 0, 0, 0, 0, 
    0, 1e-3,1e-9, 0, 0, 0, 
    0, 0, 1e6, 0, 0, 0, 
    0, 0, 0, 1e6, 0, 0, 
    0, 0, 0, 0, 1e6, 0, 
    0, 0, 0, 0, 0, 1e-9}};

#define PI           (3.1415926)
#define ROBOT_RADIUS (0.032)   //m
#define ROBOT_TRACK  (0.062)   //m
#define CAR_LENGTH   (0.243)   //m
double RobotV_  = 0;
double YawRate_ = 0;

// 速度控制消息的回调函数
void cmdCallback(const geometry_msgs::msg::Twist& msg)
{
    RobotV_  = msg.linear.x;  //m/s
    YawRate_ = msg.angular.z; //rad/s
}

Mbot::Mbot():
    Node(""mbot_bringup""),
    x_(0.0), y_(0.0), th_(0.0),
    vx_(0.0), vy_(0.0), vth_(0.0),
    sendLeftSpeed_(0),sendRightSpeed_(0),sendFrontAngle_(0),sendFlag_(0),
    readLeftSpeed_(0),readRightSpeed_(0),readYaw_(0),readFlag_(0)
{
    // 实例化参数列表
    this->declare_parameter<std::string>(""serial_port"", ""/dev/ttyUSB0"");
    this->declare_parameter<std::string>(""odom_topic"", ""odom"");
    this->declare_parameter<std::string>(""odom_frame_id"", ""odom"");
    this->declare_parameter<std::string>(""base_frame_id"", ""base_link"");
    this->declare_parameter<std::string>(""sub_twist"", ""cmd_vel"");
    this->declare_parameter<bool>(""diffCar_or_ackerCar"", false);
    // 从系统中获取参数值
    this->get_parameter(""serial_port"", serial_name_);
    this->get_parameter(""odom_topic"", odom_topic_name_);
    this->get_parameter(""odom_frame_id"", odom_frame_name_);
    this->get_parameter(""base_frame_id"", base_frame_name_);
    this->get_parameter(""sub_twist"", sub_twist_name_);
    this->get_parameter(""diffCar_or_ackerCar"", car_type_select_);

    // 串口初始化连接
    mbotSerial_.mbotSerialInit(serial_name_);
    // 时间相关初始化
    current_time_ = this->get_clock()->now();
    last_time_ = this->get_clock()->now();	
    // 实例化定时器,50Hz
    timer_ = this->create_wall_timer(20ms, std::bind(&Mbot::mainThread,this));
    // 订阅cmd_vel
    sub_ = this->create_subscription<geometry_msgs::msg::Twist>(sub_twist_name_,10, cmdCallback);
    // 发布odom
    pub_ = this->create_publisher<nav_msgs::msg::Odometry>(odom_topic_name_,50);
    // 发布tf
    odom_t_broadcaster_ = std::make_unique<tf2_ros::TransformBroadcaster>(*this);
}

Mbot::~Mbot(){}

void Mbot::diffCar(const double RobotV,const double YawRate)
{
    double r = RobotV / YawRate; // m
    // std::cout << ""RobotV = "" << RobotV << ""YawRate = "" << YawRate << std::endl;
    if(RobotV == 0)       // 旋转
    {
        sendLeftSpeed_  = (short)(-YawRate * 1000.0 * ROBOT_RADIUS);//mm/s
        sendRightSpeed_ = (short)(YawRate * 1000.0 * ROBOT_RADIUS);//mm/s
    }
    else if(YawRate == 0) // 直线
    {
        sendLeftSpeed_  = (short)(RobotV * 1000.0);//mm/s
        sendRightSpeed_ = (short)(RobotV * 1000.0);
    }
    else                  // 左右轮速度不一致
    {
        sendLeftSpeed_  = (short)(YawRate * 1000.0 * (r - ROBOT_RADIUS));//mm/s
        sendRightSpeed_ = (short)(YawRate * 1000.0 * (r + ROBOT_RADIUS));
    }
    // std::cout << ""sendLeftSpeed_ = "" << sendLeftSpeed_ << "" sendRightSpeed_ = "" << sendRightSpeed_ << std::endl;
}

void Mbot::ackerCar(const double RobotV,const double YawRate)
{
    double r = RobotV / YawRate; // m
    if(RobotV == 0)       // ackermann car can't trun rotation
    {
        sendLeftSpeed_  = 0;
        sendRightSpeed_ = 0;
        sendFrontAngle_ = 0;
    }
    else if(YawRate == 0) // Pure forward/backward motion
    {
        sendLeftSpeed_  = (short)(RobotV * 1000.0);//mm/s
        sendRightSpeed_ = (short)(RobotV * 1000.0);
        sendFrontAngle_ = 0;
    }
    else                  // Rotation about a point in space
    {
        sendLeftSpeed_  = (short)(YawRate * 1000.0 * (r - ROBOT_RADIUS));//mm/s
        sendRightSpeed_ = (short)(YawRate * 1000.0 * (r + ROBOT_RADIUS));

        // 阿克曼约束一：后左右车轮转动需同向
        if(RobotV > 0)
        {
            if(sendLeftSpeed_ < 0) {sendLeftSpeed_ = 0;}
            if(sendRightSpeed_ < 0) {sendRightSpeed_ = 0;}
        }
        else if(RobotV < 0)
        {
            if(sendLeftSpeed_ > 0) {sendLeftSpeed_ = 0;}
            if(sendRightSpeed_ > 0) {sendRightSpeed_ = 0;}            
        }
        // 阿克曼约束二：满足前轮转向和后轮的速度关系
        // # calculate the front steer servo
        sendFrontAngle_ = atan(CAR_LENGTH * YawRate / RobotV ) * (180.0 / PI); // Deg
        RCLCPP_INFO(this->get_logger(),""sendFrontAngle_ = %d\n"",sendFrontAngle_);
        // sendFrontAngle_ = (atan(2 * YawRate * CAR_LENGTH) / (2 * RobotV - 2 * ROBOT_RADIUS * YawRate)) * (180.0 / PI);
    }   
    // std::cout << ""sendLeftSpeed_ = "" << sendLeftSpeed_ << "" sendRightSpeed_ = "" << sendRightSpeed_ << std::endl;
    // std::cout << ""sendFrontAngle_ = "" << sendFrontAngle_ << std::endl;
}

void Mbot::calcSpeed(const short leftSpeedNow,const short rightSpeedNow,const short  [MASK] )
{
    // x方向速度，以及角速度
    vx_  = (rightSpeedNow + leftSpeedNow) / 2.0 / 1000.0;                       //m/s
    vth_ = (rightSpeedNow - leftSpeedNow) / (2.0 * ROBOT_RADIUS*1000.0) ;       //rad/s  
    th_  = ( [MASK]  / 50.0) * M_PI / 180.0;                                         //rad
}

/********************************************************
函数功能：根据机器人线速度和角度计算机器人里程计
入口参数：无
出口参数：无
********************************************************/
void Mbot::calcOdom(const double vx, const double vy, const double vth)
{
    rclcpp::Time curr_time;
    curr_time = this->get_clock()->now();
    
    double dt = (curr_time - last_time_).seconds();                                       //间隔时间
    double delta_x = (vx * cos(th_) - vy * sin(th_)) * dt;
    double delta_y = (vx * sin(th_) + vy * cos(th_)) * dt;
    double delta_th = vth * dt;
    //相隔20ms
    RCLCPP_INFO(this->get_logger(),""dt:%f\n"",dt); // s

    x_ += delta_x;
    y_ += delta_y;
    // th_ += delta_th;//实时角度信息,如果这里不使用IMU，也可以通过这种方式计算得出

    last_time_ = curr_time;  

    RCLCPP_INFO(this->get_logger(),""x_:%f\n"",x_);
    RCLCPP_INFO(this->get_logger(),""y_:%f\n"",y_);
    RCLCPP_INFO(this->get_logger(),""th_:%f\n"",th_*57.3);

}

void Mbot::sendTfAndPubOdom()
{
    current_time_ = this->get_clock()->now();
    // 发布TF
    geometry_msgs::msg::TransformStamped odom_t;
    odom_t.header.stamp = current_time_;
    odom_t.header.frame_id = odom_frame_name_;
    odom_t.child_frame_id  = base_frame_name_;

    tf2::Quaternion odom_quat;
    odom_quat.setRPY(0,0,th_);
    odom_t.transform.translation.x = x_;
    odom_t.transform.translation.y = y_;
    odom_t.transform.translation.z = 0.0;
    odom_t.transform.rotation.x = odom_quat.x();
    odom_t.transform.rotation.y = odom_quat.y();
    odom_t.transform.rotation.z = odom_quat.z();
    odom_t.transform.rotation.w = odom_quat.w();
    
    odom_t_broadcaster_->sendTransform(odom_t);

    nav_msgs::msg::Odometry msg;
    msg.header.stamp = current_time_;
    msg.header.frame_id = odom_frame_name_;

    msg.pose.pose.position.x = x_;
    msg.pose.pose.position.y = y_;
    msg.pose.pose.position.z = 0.0;
    msg.pose.pose.orientation.x = odom_quat.x();
    msg.pose.pose.orientation.y = odom_quat.y();
    msg.pose.pose.orientation.z = odom_quat.z();
    msg.pose.pose.orientation.w = odom_quat.w();
    msg.pose.covariance = odom_pose_covariance;

    msg.child_frame_id = base_frame_name_;
    msg.twist.twist.linear.x = vx_;
    msg.twist.twist.linear.y = vy_;
    msg.twist.twist.angular.z = vth_;
    msg.twist.covariance = odom_twist_covariance;

    pub_->publish(msg);
}

/********************************************************
函数功能：mbotRun，实现整合，并且发布TF变换和Odom
入口参数：机器人线速度和角速度，调用上面三个函数
出口参数：bool
********************************************************/
void Mbot::mbotRun(double RobotV, double YawRate)
{
    // * 1. 根据车模解析控制量
    if(car_type_select_)
    {
        diffCar(RobotV, YawRate);
    }
    else
    {
        ackerCar(RobotV, YawRate);
    }

    // * 2. 与STM32串口通信，线材一定要短且优质
    mbotSerial_.mbotWrite(sendLeftSpeed_, sendRightSpeed_, sendFrontAngle_, sendFlag_);
    mbotSerial_.mbotRead(readLeftSpeed_, readRightSpeed_, readYaw_, readFlag_);

    // * 3. 更新最新的速度和角度信息
    calcSpeed(readLeftSpeed_, readRightSpeed_, readYaw_);

    // * 4. 里程计计算
    calcOdom(vx_, vy_, vth_);

    // * 5. 发布TF和Odom
    sendTfAndPubOdom();
}

/********************************************************
函数功能：主函数线程
入口参数：机器人线速度和角速度，调用上面三个函数
出口参数：无
********************************************************/
void Mbot::mainThread()
{
    mbotRun(RobotV_, YawRate_);
}",yaw
281,"#ifndef GENERIC_UTILS_H
#define GENERIC_UTILS_H

#include <random>

//new array and multidimensional arrays
template<typename T, typename... U>
T* new_array1(int a, U... params) {
    size_t s = 1*sizeof(int) + a*sizeof(T);
    char* chunk = (char*) malloc(s);
    int* sp = (int*) chunk; 
    T* data = (T*) (chunk + 1*sizeof(int));
    sp[0] = a;
    for (int i=0; i<a; ++i)
        new (data+i) T(params...);
    return data;
};

template<typename T>
void delete_array1(T* data) {
    char* chunk = (char*) data;
    int* sp = (int*) (chunk - 1*sizeof(int));
    int a = sp[0];
    for (int i=0; i<a; ++i)
        (data+i)->~T();
    free(sp); //address of the original chunk
};


template<typename T, typename... U>
T** new_array2(int a, int b, U... params) {
    size_t s = 2*sizeof(int) + a*b*sizeof(T) + a*sizeof(T*);
    char* chunk = (char*) malloc(s);
    int* sp = (int*) chunk; 
    T** data2 = (T**) (chunk + 2*sizeof(int));
    T* data1 = (T*) (chunk + 2*sizeof(int) + a*sizeof(T*)); 
    sp[0] = a;
    sp[1] = b;
    for (int i=0; i<a*b; ++i)
        new (data1+i) T(params...);
    for (int i=0; i<a; ++i)
        data2[i]=data1+i*b;
    return data2;
};

template<typename T>
void delete_array2(T** data) {
    char* chunk = (char*) data;
    int* sp = (int*) (chunk - 2*sizeof(int));
    int a = sp[0];
    int b = sp[1];
    T* data1 = data[0]; 
    for (int i=0; i<a*b; ++i)
        (data1+i)->~T();
    free(sp); //address of the original chunk
};


template<typename T, typename... U>
T*** new_array3(int a, int b, int c, U... params) {
    size_t s = 3*sizeof(int) + a*b*c*sizeof(T) + a*b*sizeof(T*) + a*sizeof(T**);
    char* chunk = (char*) malloc(s);
    int* sp = (int*) chunk; 
    T*** data3 = (T***) (chunk + 3*sizeof(int));
    T** data2 = (T**) (chunk + 3*sizeof(int) + a*sizeof(T**)); 
    T* data1 =  (T*) (chunk + 3*sizeof(int) + a*sizeof(T**) + a*b*sizeof(T*)); 
    sp[0] = a;
    sp[1] = b;
    sp[2] = c;
    for (int i=0; i<a*b*c; ++i)
        new (data1+i) T(params...);
    for (int i=0; i<a*b; ++i)
        data2[i]=data1+i*c;
    for (int i=0; i<a; ++i)
        data3[i]=data2+i*b;
    return data3;
};

template<typename T>
void delete_array3(T*** data) {
    char* chunk = (char*) data;
    int* sp = (int*) (chunk - 3*sizeof(int));
    int a = sp[0];
    int b = sp[1];
    int c = sp[2];
    T* data1 = data[0][0]; 
    for (int i=0; i<a*b*c; ++i)
        (data1+i)->~T();
    free(sp); //address of the original chunk
};

template<typename T, typename... U>
T**** new_array4(int a, int b, int c, int d, U... params) {
    size_t s = 4*sizeof(int) + a*b*c*d*sizeof(T) + a*b*c*sizeof(T*) + a*b*sizeof(T**) + a*sizeof(T***);
    char* chunk = (char*) malloc(s);
    int* sp = (int*) chunk; 
    T**** data4 = (T****) (chunk + 4*sizeof(int));
    T*** data3 = (T***) (chunk + 4*sizeof(int) + a*sizeof(T***));
    T** data2 = (T**) (chunk + 4*sizeof(int) + a*sizeof(T***) + a*b*sizeof(T**)); 
    T* data1 = (T*) (chunk + 4*sizeof(int) + a*sizeof(T***) + a*b*sizeof(T**)+ a*b*c*sizeof(T*)); 
    sp[0] = a;
    sp[1] = b;
    sp[2] = c;
    sp[3] = d;
    for (int i=0; i<a*b*c*d; ++i)
        new (data1+i) T(params...);
    for (int i=0; i<a*b*c; ++i)
        data2[i]=data1+i*d;
    for (int i=0; i<a*b; ++i)
        data3[i]=data2+i*c;
    for (int i=0; i<a; ++i)
        data4[i]=data3+i*b;
    return data4;
};

template<typename T>
void delete_array4(T**** data) {
    char* chunk = (char*) data;
    int* sp = (int*) (chunk - 4*sizeof(int));
    int a = sp[0];
    int b = sp[1];
    int c = sp[2];
    int d = sp[3];
    T* data1 = data[0][0][0]; 
    for (int i=0; i<a*b*c*d; ++i)
        (data1+i)->~T();
    free(sp); //address of the original chunk
};

//////////////
//#define FALSE_RANDOM
#ifdef FALSE_RANDOM

inline int random_bit() { return 1; }
inline int32_t random_int32() { return 0xcccccccc; }
inline int64_t random_int64() { return 0xccccccccccccccccul; }
inline double random_gaussian_double(double center, double stdev) {
    return center; 
}

inline int32_t random_gaussian32(int32_t center, double stdev) {
    return center;    
}

inline int64_t random_gaussian64(int64_t center, double stdev) {
    return center;    
}

class Random {};

#else
/////// TRUE RANDOM
class Random {
    public:
        std::default_random_engine generator;
        std::uniform_int_distribution<int> bit_distribution;
        std::uniform_int_distribution<int32_t> int32_distribution;
        std::uniform_int_distribution<int64_t> int64_distribution;
        std::normal_distribution<double> gaussian_distribution;
        Random():
            bit_distribution(0,1),
            int32_distribution(std::numeric_limits<int32_t>::min(),std::numeric_limits<int32_t>::max()),
            int64_distribution(std::numeric_limits<int64_t>::min(),std::numeric_limits<int64_t>::max()),
            gaussian_distribution(0.,1.) {}
};

extern Random* global_random; 

inline int random_bit() { return global_random->bit_distribution(global_random->generator); }
inline int32_t random_int32() { return global_random->int32_distribution(global_random->generator); }
inline int64_t random_int64() { return global_random->int64_distribution(global_random->generator); }
inline double random_gaussian_double(double center, double stdev) { 
    return stdev*global_random->gaussian_distribution(global_random->generator)+center; 
}

inline int32_t random_gaussian32(int32_t center, double stdev) {
    static const double  [MASK]  = pow(2.,32);
    double val = stdev*global_random->gaussian_distribution(global_random->generator)* [MASK] ;
    int32_t ival = (int32_t) val;
    return ival+center;    
}

inline int64_t random_gaussian64(int64_t center, double stdev) {
    static const double _2p64 = pow(2.,64);
    double val = stdev*global_random->gaussian_distribution(global_random->generator)*_2p64;
    int64_t ival = (int64_t) val;
    //printf(""ival: %ld\n"", ival);
    return ival+center;    
}
#endif
////////////

#endif // GENERIC_UTILS_H
",_2p32
282,"#include ""Motor.h""

#define DEBUG_LOG false

void Motor::begin(short rpm, int accel){
	this->rpm = rpm;
	this->accel = accel;
}

short Motor::getRPM() {
	return rpm;
}

void Motor::setRPM(short rpm) {
	this->rpm = rpm;
}

short Motor::getAcceleration() {
	return accel;
}

void Motor::setAcceleration(int accel) {
	this->accel = accel;
}

void Motor::enable() {
    digitalWrite(enablePin, LOW);
}

void Motor::disable(){
    digitalWrite(enablePin, HIGH);
}

void Motor::rotate(long deg){
    move(calcStepsForRotation(deg));
}

long Motor::calcStepsForRotation(long deg){
	return deg * motorSteps / 360;
}

#define ACCELERATING 0
#define CRUISING 1
#define BRAKING 2

void Motor::move(long steps){
	short dirState = steps >= 0 ? HIGH : LOW;
	digitalWrite(dirPin, dirState);

	long totalSteps = abs(steps);

	unsigned long cruisePulseLength = 60000000L / ((long)rpm * motorSteps);
	unsigned long cruiseStepsPerSecond = (long)rpm * motorSteps / 60;


	long stepsToCruise = cruiseStepsPerSecond * cruiseStepsPerSecond / (2 * accel);
	long stepsToBrake = stepsToCruise;	// = stepsToCruise * accel / decel


	bool cruiseSpeedAchieved = true;
	if (totalSteps < stepsToCruise + stepsToBrake){
		// cannot reach max speed, will need to brake early
		stepsToCruise = totalSteps / 2; // = steps * decel / (accel + decel);
		stepsToBrake = totalSteps - stepsToCruise;
		cruiseSpeedAchieved = false;
	}

#ifdef DEBUG_LOG
	Serial.println();
	Serial.println(""rpm:          "" + String(rpm));
	Serial.println(""rps:          "" + String((float)rpm / 60));
	Serial.println(""motorSteps:   "" + String(motorSteps));
	Serial.println(""accel:        "" + String(accel));
	Serial.println(""cruisePulseLength:    "" + String(cruisePulseLength) + "" us"");
	Serial.println(""cruiseStepsPerSecond: "" + String(cruiseStepsPerSecond));
	Serial.println(""totalSteps:    "" + String(totalSteps));
	Serial.println(""stepsToCruise: "" + String(stepsToCruise));
	Serial.println(""stepsToBrake:  "" + String(stepsToBrake));

	short debugEntries = 10;
	short halfDebugEntries = debugEntries/2;
	long stepNumbers[3][debugEntries];
	long remSteps[3][debugEntries];
	long actualTimes[3][debugEntries];
	long desiredTimes[3][debugEntries];
	long processingTimes[3][debugEntries];

	for (short state=0; state<3; state++) {
		for (short i=0; i<debugEntries; i++) {
			stepNumbers[state][i] = 0;
			remSteps[state][i] = 0;
			actualTimes[state][i] = 0;
			desiredTimes[state][i] = 0;
			processingTimes[state][i] = 0;
		}
	}

	unsigned long moveStartTime = micros();
	unsigned long previousTime = moveStartTime;
#endif

	float millionTimesSqrtOf2DivA = 1000000.0 * sqrt(2.0/(float)accel);
	float sqrtOfCurrStep = 0.0;

	for (long step=0; step<totalSteps; step++) {
		unsigned long pulseStartTime = micros();

#ifdef DEBUG_LOG
		unsigned long microsSincePrevPulse = pulseStartTime - previousTime;
		unsigned long microsSinceStart = pulseStartTime - moveStartTime;
#endif

		digitalWrite(stepPin, HIGH);
		delayMicroseconds(stepHighMin);
		digitalWrite(stepPin, LOW);


#ifdef DEBUG_LOG
		short state;
		unsigned long internalStep;
		unsigned long totalInternalSteps;
#endif

		unsigned long desiredPulseLength;

		long stepsRemaining = totalSteps - 1 - step;

		if (step < stepsToCruise) {
			// accelerating
			float sqrtOfNextStep = sqrt((float)step+1.0);
			desiredPulseLength = (long)(millionTimesSqrtOf2DivA * (sqrtOfNextStep - sqrtOfCurrStep));
			sqrtOfCurrStep = sqrtOfNextStep;
		} else if (step >= totalSteps - stepsToBrake) {
			// braking
			float sqrtOfNextStep = sqrt((float)stepsRemaining-1.0);
			desiredPulseLength = (long)(millionTimesSqrtOf2DivA * (sqrtOfCurrStep - sqrtOfNextStep));
			sqrtOfCurrStep = sqrtOfNextStep;
		} else {
			// cruising
			desiredPulseLength = cruisePulseLength;
		}

#ifdef DEBUG_LOG
		if (step < stepsToCruise) {
			state = ACCELERATING;
			internalStep = step;
			totalInternalSteps = stepsToCruise;
		} else if (step >= totalSteps - stepsToBrake) {
			state = BRAKING;
			internalStep = step - (totalSteps - stepsToBrake);
			totalInternalSteps = stepsToBrake;
		} else {
			state = CRUISING;
			internalStep = step - stepsToCruise;
			totalInternalSteps = totalSteps - stepsToCruise - stepsToBrake;
		}

		previousTime = pulseStartTime;

		if (internalStep < halfDebugEntries || internalStep >= totalInternalSteps - halfDebugEntries) {
			short pos = internalStep < halfDebugEntries ? internalStep : (internalStep - totalInternalSteps + debugEntries);
			stepNumbers[state][pos] = step;
			remSteps[state][pos] = stepsRemaining;
			actualTimes[state][pos] = microsSincePrevPulse;
			desiredTimes[state][pos] = desiredPulseLength;
		}
#endif

		unsigned long processingTime = micros() - pulseStartTime;

#ifdef DEBUG_LOG
		if (internalStep < halfDebugEntries || internalStep >= totalInternalSteps - halfDebugEntries) {
			short pos = internalStep < halfDebugEntries ? internalStep : (internalStep - totalInternalSteps + debugEntries);
			processingTimes[state][pos] = processingTime;
		}
#endif

		if (desiredPulseLength > processingTime) {
			delayMicroseconds(desiredPulseLength - processingTime);
		}
	}

#ifdef DEBUG_LOG
	for (short state=0; state<3; state++) {
		if (state == CRUISING && !cruiseSpeedAchieved) {
			continue;
		}
		for (int i=0; i<debugEntries; i++) {
			Serial.print(padRight(String(stepNumbers[state][i]), 8));
			Serial.print(F(""remain: ""));
			Serial.print(padRight(String(remSteps[state][i]), 8));
			Serial.print(F(""since prev pulse: ""));
			Serial.print(padRight(String(actualTimes[state][i]), 12));
			Serial.print(F(""processing: ""));
			Serial.print(padRight(String(processingTimes[state][i]), 12));
			Serial.print(F(""desired: ""));
			Serial.print(padRight(String(desiredTimes[state][i]), 12));
			Serial.println();
			if (i == halfDebugEntries-1) {
				Serial.println(""..."");
			}
		}
		Serial.println(F(""======================""));
	}
#endif

}

String padRight(String  [MASK] , int width) {
	short padWidth = width -  [MASK] .length();
	String p = """";
    for (int i=0; i<padWidth; i++) {
    	p = p + "" "";
    }
    return  [MASK]  + p;
}
",str
283,"#include ""map.h""

#include <algorithm>
#include <iostream>
#include <windows.h>

#include ""innards.h""
#include ""player.h""
#include ""room.h""

using namespace std;

/**
 * Shows the help menu
 */
void help();

/**
 * Sets up the console
 */
void setup();

/**
 * Converts a string to lowercase
 * @param str the string to convert
 * @return the converted string
 */
string toLowerCase(string str);

/**
 * Prints the options for the player
 * @param player the player
 * @param map the map
 */
void printOptions(const Player *player, const Map *map);

int main() {
  setup();
  auto *player = new Player();
  const auto map = new Map(player);

  string input;
  string  [MASK] ;

  bool debug = false;
  cout << ""Play in debug mode? (y/n): "";
  cin >> input;
  if (toLowerCase(input) == ""y"") {
    debug = true;
  }
  input = """";

  while (input != ""q"" && !map->is_over()) {
    if (debug) {
      map->display(player->getRoom());
    }
    player->printNear();
    printOptions(player, map);
    cin >> input;
    input = toLowerCase(input);

    if (input == ""h"") {
      help();
    } else if (input == ""m"") {
      map->display(player->getRoom());
    } else if (input == ""r"") {
      while ( [MASK]  != ""n"" &&  [MASK]  != ""s"" &&  [MASK]  != ""e"" &&
              [MASK]  != ""w"") {
        cout << ""use harpoon in which direction? (n/s/e/w): "";
        cin >>  [MASK] ;
         [MASK]  = toLowerCase( [MASK] );
      }
      player->useItem(*map, 'h',  [MASK] .at(0));
       [MASK]  = """";
    } else if (input == ""t"") {
      while ( [MASK]  != ""n"" &&  [MASK]  != ""s"" &&  [MASK]  != ""e"" &&
              [MASK]  != ""w"") {
        cout << ""use net in which direction? (n/s/e/w): "";
        cin >>  [MASK] ;
         [MASK]  = toLowerCase( [MASK] );
      }
      player->useItem(*map, 't',  [MASK] .at(0));
       [MASK]  = """";
    } else if (input == ""n"" || input == ""s"" || input == ""e"" || input == ""w"") {
      player->playerMove(input.at(0));
      player->getRoom()->getInnard()->trigger(*map, *player);
      int airRemaining = player->getAir();
      if (airRemaining > 0 && !map->is_over()) {
        cout << ""You have "" << airRemaining << "" units of oxygen remaining""
             << endl;
      } else if (!map->is_over()) {
        cout << ""You have run out of air."" << endl;
        map->set_game_over(true);
        map->set_win(false);
      }
    }
  }

  if (map->is_win()) {
    cout << ""You win!"";
  } else {
    cout << ""You lose!"";
  }
  delete map;
  delete player;
  return 0;
}

void help() {
  // This is pure text output for the help menu, so the size of the method is
  // not a concern
  cout << ""Welcome to hunt the Kraken. You are a deep sea scuba diver seeking ""
          ""to kill the Kraken before you run out of oxygen. The sea floor is ""
          ""divided into 30 spaces in a 5 high 6 wide rectangle. Each space is ""
          ""connected to 4 others.""
       << endl
       << endl;
  cout << ""Hazards:"" << endl;
  cout << ""Whirlpool - One space has a whirlpool. If you go there, you will be ""
          ""whisked away to a random space and will lose 11 oxygen.""
       << endl;
  cout << ""Riptide - Two spaces have riptides. If you go there, you will be ""
          ""whisked away to a random space on the edge of the map and will lose ""
          ""6 oxygen.""
       << endl
       << endl;
  cout << ""Kraken:"" << endl;
  cout << ""If you attempt to move into the Kraken's space, it eats you and you ""
          ""lose.""
       << endl
       << endl;
  cout << ""You:"" << endl;
  cout << ""Each turn you may move or use a weapon."" << endl;
  cout << ""Moving: You can move one space North, South, East, or West if there ""
          ""is a room in that direction.""
       << endl;
  cout << ""Oxygen: Each move consumes 1 Oxygen. If you run out of Oxygen you ""
          ""lose. There is one Oxygen tank that you can find. You start with 50 ""
          ""Oxygen""
       << endl;
  cout << ""Using Weapons: You can use the Harpoon to attack an adjacent space ""
          ""(you start with 1 harpoon and can find 2 more).""
       << endl;
  cout << ""If you hit the Kraken with a Harpoon, you win."" << endl;
  cout << ""If you find the net, you can throw it to see if the Kraken is ""
          ""hiding in any of the nearest 3 spaces in the direction you choose. ""
          ""The net does not kill the Kraken.""
       << endl;
  cout << ""You will be given hints indicating when a hazard or the Kraken is ""
          ""nearby.""
       << endl
       << endl;
}

void setup() {
  // get the console handle
  HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  // set the console text color
  SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE);
}

string toLowerCase(string str) {
  // easy way to convert a string to lowercase to make input case insensitive
  transform(str.begin(), str.end(), str.begin(), ::tolower);
  return str;
}

void printOptions(const Player *player, const Map *map) {
  // Only showing the options that are possible according to the map
  cout << ""\nAction: "";
  if (Map::roomExists(player->getRoom(), 'n')) {
    cout << ""(N)orth, "";
  }
  if (Map::roomExists(player->getRoom(), 's')) {
    cout << ""(S)outh, "";
  }
  if (Map::roomExists(player->getRoom(), 'e')) {
    cout << ""(E)ast, "";
  }
  if (Map::roomExists(player->getRoom(), 'w')) {
    cout << ""(W)est, "";
  }
  cout << ""(M)ap, (H)elp"";
  if (player->getHarpoons() > 0) {
    cout << "", shoot ha(R)poon"";
  }
  if (player->getNets() > 0) {
    cout << "", use ne(T)"";
  }
  cout << "", Q)uit: "";
}
",weaponDir
284,"/*
 * namespace WServer::WTypes::
 */

#include <spdlog/spdlog.h>

#include <wserver/debug.hpp>
#include <wserver/types/types.hpp>

namespace WServer {

namespace WTypes {

WSocket::~WSocket() {
  __xsocket_cleanup();
  xsocket_close(sockfd_);
};

WSocket::WSocket(const std::string &socket) {
  if (std::regex_search(socket, socket_sm_, socket_rgx_)) {
    if (socket_sm_.size() != 6) {
      throw std::runtime_error(WServer::WDebug::WMessage{
          WServer::WDebug::WPrefix,
          ""WSocket(const std::string &socket) failed""
          "", regular expression groups error (ip:port)""});
    }

    socket_ = socket;
    ip_.oct.a = (uint8_t)std::stoull(socket_sm_[1].str());
    ip_.oct.b = (uint8_t)std::stoull(socket_sm_[2].str());
    ip_.oct.c = (uint8_t)std::stoull(socket_sm_[3].str());
    ip_.oct.d = (uint8_t)std::stoull(socket_sm_[4].str());
    port_ = (uint16_t)std::stoull(socket_sm_[5].str());
  } else {
    throw std::runtime_error(
        WServer::WDebug::WMessage{WServer::WDebug::WPrefix,
                                  ""WSocket(const std::string &socket) failed""
                                  "", invalid socket format (ip:port)""});
  }

  if (__xsocket_init()) {
    throw std::runtime_error(
        WServer::WDebug::WMessage{WServer::WDebug::WPrefix,
                                  ""WSocket(const std::string &socket) failed""
                                  "", __xsocket_init() caused an error""});
  }

  struct sockaddr_in addr;
  const socklen_t  [MASK]  = sizeof(addr);
  memset(&addr, 0,  [MASK] );

  addr.sin_family = AF_INET;
  addr.sin_port = htons(port_);
  inet_pton(AF_INET, getIp4S().data(), &addr.sin_addr);

  sockfd_ = xsocket(addr.sin_family, SOCK_STREAM, IPPROTO_TCP);
  if (sockfd_ == -1) {
    __xsocket_cleanup();
    throw std::runtime_error(
        WServer::WDebug::WMessage{WServer::WDebug::WPrefix,
                                  ""WSocket(const std::string &socket) failed""
                                  "", xsocket() caused an error""});
  }

  bind(sockfd_, (struct sockaddr *)&addr,  [MASK] );
  listen(sockfd_, INT_MAX);

  spdlog::info(""{}Initialized socket '{}'"", WServer::WDebug::WPrefix, socket_);
}

}  // namespace WTypes

}  // namespace WServer
",addr_len
285,"#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

struct Student {
    std::string name;
    int rollNumber;
    int marksBiology;
    int marksPhysics;
    int marksChemistry;
    int totalMarks;
    int stream; // 0 for Bio, 1 for Math
    int classNumber;

    bool operator<(const Student& other) const {
        return totalMarks > other.totalMarks; // Sort in descending order of total marks
    }
};

class School {
private:
    std::vector<Student> students;

public:
    void addStudent(const Student& student) {
        students.push_back(student);
    }

    void calculateRanks() {
        // Calculate total marks and sort students
        for (auto& student : students) {
            student.totalMarks = student.marksBiology + student.marksPhysics + student.marksChemistry;
        }
        std::sort(students.begin(), students.end());

        // Assign school rank
        for (size_t i = 0; i < students.size(); ++i) {
            students[i].rollNumber = i + 1;
        }

        // Assign class rank
        for (int stream = 0; stream <= 1; ++stream) {
            for (int classNumber = 1; classNumber <= (stream == 0 ? 3 : 5); ++classNumber) {
                std::vector<Student> classStudents;
                for (const auto& student : students) {
                    if (student.stream == stream && student.classNumber == classNumber) {
                        classStudents.push_back(student);
                    }
                }
                std::sort(classStudents.begin(), classStudents.end());
                for (size_t i = 0; i < classStudents.size(); ++i) {
                    for (auto& student : students) {
                        if (student.stream == stream && student.classNumber == classNumber &&
                            student.name == classStudents[i].name) {
                            student.classNumber = i + 1;
                        }
                    }
                }
            }
        }
    }

    void printRanks() {
        std::ofstream  [MASK] (""rankings.txt"");
        if (! [MASK] .is_open()) {
            std::cerr << ""Error opening output file."" << std::endl;
            return;
        }
        
        for (const auto& student : students) {
             [MASK]  << (student.stream == 0 ? ""Bio"" : ""Math"") << ""\t"" << student.classNumber << ""\t""
                       << student.rollNumber << ""\t"" << student.name << ""\t"" << student.totalMarks << std::endl;
        }

         [MASK] .close();
    }
};

int main() {
    School school;

    // Dummy data - replace this with actual data input
    for (int stream = 0; stream <= 1; ++stream) {
        for (int classNumber = 1; classNumber <= (stream == 0 ? 3 : 5); ++classNumber) {
            for (int i = 1; i <= 40; ++i) {
                Student student;
                student.name = ""Student"" + std::to_string(i);
                student.marksBiology = rand() % 101;
                student.marksPhysics = rand() % 101;
                student.marksChemistry = rand() % 101;
                student.stream = stream;
                student.classNumber = classNumber;
                school.addStudent(student);
            }
        }
    }

    school.calculateRanks();
    school.printRanks();

    return 0;
}
",outputFile
286,"#include <hal/debug.h>
#include <hal/video.h>
#include <pbkit/pbkit.h>
#include <windows.h>

#include <set>

#include ""debug_output.h""
#include ""nxdk_ext.h""
#include ""pbkit_ext.h""
#include ""renderer.h""
#include ""tracelib/tracer_state_machine.h""
#include ""xbdm.h""

#define ENABLE_TRACER_THREAD

static constexpr int kFramebufferWidth = 640;
static constexpr int kFramebufferHeight = 480;
static constexpr int kTextureWidth = 256;
static constexpr int kTextureHeight = 256;

//! Send nop commands, used as a mechanism to mark interesting things it the
//! pgraph log.
static void Mark(uint32_t num_nops = 8);
static void Initialize(Renderer& renderer);
static void CreateGeometry(Renderer& renderer);

static std::atomic_bool has_rendered_frame(false);

static std::atomic<TracerState> tracer_state;
static std::atomic_bool request_processed(false);

static void OnTracerStateChanged(TracerState new_state) {
  std::string state_name;
#define HANDLE_STATE(val) \
  case val:               \
    state_name = #val;    \
    break

  switch (new_state) {
    HANDLE_STATE(STATE_FATAL_NOT_IN_NEW_FRAME_STATE);
    HANDLE_STATE(STATE_FATAL_NOT_IN_STABLE_STATE);
    HANDLE_STATE(STATE_FATAL_DISCARDING_FAILED);
    HANDLE_STATE(STATE_FATAL_PROCESS_PUSH_BUFFER_COMMAND_FAILED);
    HANDLE_STATE(STATE_SHUTDOWN_REQUESTED);
    HANDLE_STATE(STATE_SHUTDOWN);
    HANDLE_STATE(STATE_UNINITIALIZED);
    HANDLE_STATE(STATE_INITIALIZING);
    HANDLE_STATE(STATE_INITIALIZED);
    HANDLE_STATE(STATE_IDLE);
    HANDLE_STATE(STATE_IDLE_STABLE_PUSH_BUFFER);
    HANDLE_STATE(STATE_IDLE_NEW_FRAME);
    HANDLE_STATE(STATE_IDLE_LAST);
    HANDLE_STATE(STATE_WAITING_FOR_STABLE_PUSH_BUFFER);
    HANDLE_STATE(STATE_DISCARDING_UNTIL_FLIP);
    HANDLE_STATE(STATE_TRACING_UNTIL_FLIP);
    default:
      state_name = ""<<UNKNOWN>>"";
      break;
  }

  PrintMsg(""Tracer state changed: %s[%d]\n"", state_name.c_str(), new_state);
  tracer_state = new_state;
}

static void OnRequestProcessed() { request_processed = true; }

static uint8_t discard_buffer[4096];
static void OnPGRAPHBytesAvailable(uint32_t bytes_written) {
  PrintMsg(""New PGRAPH bytes available: %u"", bytes_written);
  TracerLockPGRAPHBuffer();
  while (TracerReadPGRAPHBuffer(discard_buffer, sizeof(discard_buffer))) {
  }
  TracerUnlockPGRAPHBuffer();
}

static void OnAuxBytesAvailable(uint32_t bytes_written) {
  PrintMsg(""New aux bytes available: %u"", bytes_written);
  TracerLockAuxBuffer();
  while (TracerReadAuxBuffer(discard_buffer, sizeof(discard_buffer))) {
  }
  TracerUnlockAuxBuffer();
}

static void WaitForState(TracerState state) {
  while (tracer_state != state) {
    Sleep(1);
  }
}

// static void WaitForState(const std::set<TracerState>& states) {
//   while (states.find(tracer_state) == states.cend()) {
//     Sleep(1);
//   }
// }

static void WaitForRequestComplete() {
  while (TracerIsProcessingRequest()) {
    Sleep(1);
  }
}

#ifdef ENABLE_TRACER_THREAD
static DWORD __attribute__((stdcall)) TracerThreadMain(
    LPVOID lpThreadParameter) {
  while (!has_rendered_frame) {
    Sleep(1);
  }

  auto init_result =
      TracerInitialize(OnTracerStateChanged, OnRequestProcessed,
                       OnPGRAPHBytesAvailable, OnAuxBytesAvailable);
  if (!XBOX_SUCCESS(init_result)) {
    PrintMsg(""Failed to initialize tracer: 0x%X"", init_result);
    return init_result;
  }

  // Create a tracer instance and wait for it to stabilize.
  TracerConfig config;
  TracerGetDefaultConfig(&config);
  auto create_result = TracerCreate(&config);
  if (!XBOX_SUCCESS(create_result)) {
    PrintMsg(""Failed to create tracer: 0x%X"", create_result);
    return init_result;
  }
  WaitForState(STATE_IDLE);

  //  TracerCreate
  PrintMsg(""About to start wait for stable pbuffer state..."");
  request_processed = false;
  if (!TracerBeginWaitForStablePushBufferState()) {
    PrintMsg(""TracerBeginWaitForStablePushBufferState failed!"");
    TracerShutdown();
    return 1;
  } else {
    WaitForRequestComplete();
  }
  PrintMsg(""Achieved stable pbuffer state..."");

  PrintMsg(""About to discard until next frame flip..."");
  request_processed = false;
  if (!TracerBeginDiscardUntilFlip(TRUE)) {
    PrintMsg(""TracerBeginDiscardUntilFlip failed!"");
    TracerShutdown();
    return 1;
  } else {
    WaitForRequestComplete();
  }
  PrintMsg(""New frame started!"");

  request_processed = false;
  if (!TracerTraceCurrentFrame()) {
    PrintMsg(""TracerTraceCurrentFrame failed!"");
    TracerShutdown();
    return 1;
  } else {
    WaitForRequestComplete();
  }

  TracerShutdown();
  return 0;
}
#endif  // ENABLE_TRACER_THREAD

static float wrap_color(float val) {
  while (val < 0.f) {
    val += 1.f;
  }
  while (val > 1.f) {
    val -= 1.f;
  }
  return val;
}

int main() {
  XVideoSetMode(kFramebufferWidth, kFramebufferHeight, 32, REFRESH_DEFAULT);

  int status = pb_init();
  if (status) {
    debugPrint(""pb_init Error %d\n"", status);
    pb_show_debug_screen();
    Sleep(2000);
    return 1;
  }

  pb_show_front_screen();

  auto renderer = Renderer(kFramebufferWidth, kFramebufferHeight, kTextureWidth,
                           kTextureHeight);

  CreateGeometry(renderer);

#ifdef ENABLE_TRACER_THREAD
  DWORD tracer_thread_id;
  auto tracer_thread =
      CreateThread(nullptr, 0, TracerThreadMain, nullptr, 0, &tracer_thread_id);
  if (!tracer_thread) {
    debugPrint(""Failed to create tracer thread.\n"");
    pb_show_debug_screen();
    Sleep(2000);
    return 1;
  }
#endif  // ENABLE_TRACER_THREAD

  // Render some test content.
  // Note that this is intentionally inefficient, the intent is to test the
  // pgraph tracer, so there is more frequent interaction with the pushbuffer
  // than necessary.

  float r = 1.0f;
  float g = 0.25f;
  float b = 0.33f;
  while (true) {
    Initialize(renderer);

    MATRIX matrix;
    matrix_unit(matrix);
    renderer.SetFixedFunctionModelViewMatrix(matrix);
    renderer.SetFixedFunctionProjectionMatrix(matrix);

    renderer.PrepareDraw(0xFF333333);

    auto p = pb_begin();

    // Set up a directional light.
    p = pb_push1(p, NV097_SET_LIGHT_ENABLE_MASK,
                 NV097_SET_LIGHT_ENABLE_MASK_LIGHT0_INFINITE);

    // Ambient color comes from the material's diffuse color.
    p = pb_push3(p, NV097_SET_LIGHT_AMBIENT_COLOR, 0, 0, 0);
    p = pb_push3f(p, NV097_SET_LIGHT_DIFFUSE_COLOR, r, g, b);
    p = pb_push3f(p, NV097_SET_LIGHT_SPECULAR_COLOR, 0.f, 0.f, 0.f);
    p = pb_push1(p, NV097_SET_LIGHT_LOCAL_RANGE, 0x7149f2ca);  // 1e+30
    p = pb_push3(p, NV097_SET_LIGHT_INFINITE_HALF_VECTOR, 0, 0, 0);
    p = pb_push3f(p, NV097_SET_LIGHT_INFINITE_DIRECTION, 0.0f, 0.0f, 1.0f);

    uint32_t control0 =
        MASK(NV097_SET_CONTROL0_Z_FORMAT, NV097_SET_CONTROL0_Z_FORMAT_FIXED);
    p = pb_push1(p, NV097_SET_CONTROL0, control0);

    p = pb_push1(p, NV097_SET_VERTEX_DATA4UB + 0x0C, 0xFFFFFFFF);
    p = pb_push1(p, NV097_SET_VERTEX_DATA4UB + 0x10, 0);
    p = pb_push1(p, NV097_SET_VERTEX_DATA4UB + 0x1C, 0xFFFFFFFF);
    p = pb_push1(p, NV097_SET_VERTEX_DATA4UB + 0x20, 0);

    p = pb_push1(p, NV10_TCL_PRIMITIVE_3D_POINT_PARAMETERS_ENABLE, 0x0);

    p = pb_push1(p, NV097_SET_SPECULAR_PARAMS, 0xBF7730E0);
    p = pb_push1(p, NV097_SET_SPECULAR_PARAMS + 4, 0xC0497B30);
    p = pb_push1(p, NV097_SET_SPECULAR_PARAMS + 8, 0x404BAEF8);
    p = pb_push1(p, NV097_SET_SPECULAR_PARAMS + 12, 0xBF6E9EE4);
    p = pb_push1(p, NV097_SET_SPECULAR_PARAMS + 16, 0xC0463F88);
    p = pb_push1(p, NV097_SET_SPECULAR_PARAMS + 20, 0x404A97CF);

    p = pb_push1(p, NV097_SET_LIGHT_CONTROL, 0x10001);

    p = pb_push1(p, NV097_SET_LIGHTING_ENABLE, 0x1);
    p = pb_push1(p, NV097_SET_SPECULAR_ENABLE, 0x1);

    p = pb_push1(p, NV097_SET_COLOR_MATERIAL,
                 NV097_SET_COLOR_MATERIAL_DIFFUSE_FROM_MATERIAL);
    p = pb_push3(p, NV097_SET_SCENE_AMBIENT_COLOR, 0x0, 0x3C6DDACA, 0x0);

    p = pb_push1(p, NV097_SET_MATERIAL_EMISSION, 0x0);
    p = pb_push1(p, NV097_SET_MATERIAL_EMISSION + 4, 0x0);
    p = pb_push1(p, NV097_SET_MATERIAL_EMISSION + 8, 0x0);

    float material_alpha = 0.75f;
    uint32_t alpha_int = *(uint32_t*)&material_alpha;
    p = pb_push1(p, NV097_SET_MATERIAL_ALPHA, alpha_int);

    pb_end(p);

    renderer.DrawArrays(renderer.POSITION | renderer.NORMAL | renderer.DIFFUSE |
                        renderer.SPECULAR);

    Mark();

    renderer.FinishDraw();

    has_rendered_frame = true;

    r = wrap_color(r + 0.001f);
    g = wrap_color(g - 0.005f);
    b = wrap_color(b + 0.005f);
  }

  return 0;
}

static void Mark(uint32_t num_nops) {
  auto p = pb_begin();
  for (auto i = 0; i < num_nops; ++i) {
    p = pb_push1(p, NV097_NO_OPERATION, 0);
  }
  pb_end(p);
}

static void Initialize(Renderer& renderer) {
  const uint32_t kFramebufferPitch = renderer.GetFramebufferWidth() * 4;
  renderer.SetSurfaceFormat(Renderer::SCF_A8R8G8B8, Renderer::SZF_Z16,
                            renderer.GetFramebufferWidth(),
                            renderer.GetFramebufferHeight());

  auto p = pb_begin();
  p = pb_push1(p, NV097_SET_SURFACE_PITCH,
               SET_MASK(NV097_SET_SURFACE_PITCH_COLOR, kFramebufferPitch) |
                   SET_MASK(NV097_SET_SURFACE_PITCH_ZETA, kFramebufferPitch));
  p = pb_push1(p, NV097_SET_SURFACE_CLIP_HORIZONTAL,
               renderer.GetFramebufferWidth() << 16);
  p = pb_push1(p, NV097_SET_SURFACE_CLIP_VERTICAL,
               renderer.GetFramebufferHeight() << 16);

  p = pb_push1(p, NV097_SET_LIGHTING_ENABLE, false);
  p = pb_push1(p, NV097_SET_SPECULAR_ENABLE, false);
  p = pb_push1(p, NV097_SET_LIGHT_CONTROL, 0x20001);
  p = pb_push1(p, NV097_SET_LIGHT_ENABLE_MASK,
               NV097_SET_LIGHT_ENABLE_MASK_LIGHT0_OFF);
  p = pb_push1(p, NV097_SET_COLOR_MATERIAL,
               NV097_SET_COLOR_MATERIAL_ALL_FROM_MATERIAL);
  p = pb_push1f(p, NV097_SET_MATERIAL_ALPHA, 1.0f);

  p = pb_push1(p, NV20_TCL_PRIMITIVE_3D_LIGHT_MODEL_TWO_SIDE_ENABLE, 0);
  p = pb_push1(p, NV097_SET_FRONT_POLYGON_MODE,
               NV097_SET_FRONT_POLYGON_MODE_V_FILL);
  p = pb_push1(p, NV097_SET_BACK_POLYGON_MODE,
               NV097_SET_FRONT_POLYGON_MODE_V_FILL);

  p = pb_push1(p, NV097_SET_VERTEX_DATA4UB + 0x10, 0);           // Specular
  p = pb_push1(p, NV097_SET_VERTEX_DATA4UB + 0x1C, 0xFFFFFFFF);  // Back diffuse
  p = pb_push1(p, NV097_SET_VERTEX_DATA4UB + 0x20, 0);  // Back specular

  p = pb_push1(p, NV097_SET_POINT_PARAMS_ENABLE, false);
  p = pb_push1(p, NV097_SET_POINT_SMOOTH_ENABLE, false);
  p = pb_push1(p, NV097_SET_POINT_SIZE, 8);

  p = pb_push1(p, NV097_SET_DOT_RGBMAPPING, 0);

  p = pb_push1(p, NV097_SET_SHADE_MODEL, NV097_SET_SHADE_MODEL_SMOOTH);
  pb_end(p);

  Renderer::SetWindowClipExclusive(false);
  // Note, setting the first clip region will cause the hardware to also set all
  // subsequent regions.
  Renderer::SetWindowClip(renderer.GetFramebufferWidth(),
                          renderer.GetFramebufferHeight());

  renderer.SetBlend();

  renderer.ClearInputColorCombiners();
  renderer.ClearInputAlphaCombiners();
  renderer.ClearOutputColorCombiners();
  renderer.ClearOutputAlphaCombiners();

  renderer.SetCombinerControl(1);
  renderer.SetInputColorCombiner(
      0, Renderer::SRC_DIFFUSE, false, Renderer::MAP_UNSIGNED_IDENTITY,
      Renderer::SRC_ZERO, false, Renderer::MAP_UNSIGNED_INVERT);
  renderer.SetInputAlphaCombiner(
      0, Renderer::SRC_DIFFUSE, true, Renderer::MAP_UNSIGNED_IDENTITY,
      Renderer::SRC_ZERO, false, Renderer::MAP_UNSIGNED_INVERT);

  renderer.SetOutputColorCombiner(0, Renderer::DST_DISCARD,
                                  Renderer::DST_DISCARD, Renderer::DST_R0);
  renderer.SetOutputAlphaCombiner(0, Renderer::DST_DISCARD,
                                  Renderer::DST_DISCARD, Renderer::DST_R0);

  renderer.SetFinalCombiner0(
      Renderer::SRC_ZERO, false, false, Renderer::SRC_ZERO, false, false,
      Renderer::SRC_ZERO, false, false, Renderer::SRC_R0);
  renderer.SetFinalCombiner1(Renderer::SRC_ZERO, false, false,
                             Renderer::SRC_ZERO, false, false, Renderer::SRC_R0,
                             true, false, false, false, true);

  renderer.SetShaderStageProgram(Renderer::STAGE_NONE, Renderer::STAGE_NONE,
                                 Renderer::STAGE_NONE, Renderer::STAGE_NONE);

  while (pb_busy()) {
    /* Wait for completion... */
  }

  p = pb_begin();

  MATRIX identity_matrix;
  matrix_unit(identity_matrix);
  for (auto i = 0; i < 4; ++i) {
    auto& stage = renderer.GetTextureStage(i);
    stage.SetUWrap(TextureStage::WRAP_CLAMP_TO_EDGE, false);
    stage.SetVWrap(TextureStage::WRAP_CLAMP_TO_EDGE, false);
    stage.SetPWrap(TextureStage::WRAP_CLAMP_TO_EDGE, false);
    stage.SetQWrap(false);

    stage.SetEnabled(false);
    stage.SetCubemapEnable(false);
    stage.SetFilter();
    stage.SetAlphaKillEnable(false);
    stage.SetLODClamp(0, 4095);

    stage.SetTextureMatrixEnable(false);
    stage.SetTextureMatrix(identity_matrix);

    stage.SetTexgenS(TextureStage::TG_DISABLE);
    stage.SetTexgenT(TextureStage::TG_DISABLE);
    stage.SetTexgenR(TextureStage::TG_DISABLE);
    stage.SetTexgenQ(TextureStage::TG_DISABLE);
  }

  // TODO: Set up with TextureStage instances in renderer.
  {
    uint32_t address = NV097_SET_TEXTURE_ADDRESS;
    uint32_t control = NV097_SET_TEXTURE_CONTROL0;
    uint32_t filter = NV097_SET_TEXTURE_FILTER;
    p = pb_push1(p, address, 0x10101);
    p = pb_push1(p, control, 0x3ffc0);
    p = pb_push1(p, filter, 0x1012000);

    address += 0x40;
    control += 0x40;
    filter += 0x40;
    p = pb_push1(p, address, 0x10101);
    p = pb_push1(p, control, 0x3ffc0);
    p = pb_push1(p, filter, 0x1012000);

    address += 0x40;
    control += 0x40;
    filter += 0x40;
    p = pb_push1(p, address, 0x10101);
    p = pb_push1(p, control, 0x3ffc0);
    p = pb_push1(p, filter, 0x1012000);

    address += 0x40;
    control += 0x40;
    filter += 0x40;
    p = pb_push1(p, address, 0x10101);
    p = pb_push1(p, control, 0x3ffc0);
    p = pb_push1(p, filter, 0x1012000);
  }

  p = pb_push1(p, NV097_SET_FOG_ENABLE, false);
  p = pb_push4(p, NV097_SET_TEXTURE_MATRIX_ENABLE, 0, 0, 0, 0);

  p = pb_push1(p, NV097_SET_FRONT_FACE, NV097_SET_FRONT_FACE_V_CW);
  p = pb_push1(p, NV097_SET_CULL_FACE, NV097_SET_CULL_FACE_V_BACK);
  p = pb_push1(p, NV097_SET_CULL_FACE_ENABLE, true);

  p = pb_push1(p, NV097_SET_COLOR_MASK,
               NV097_SET_COLOR_MASK_BLUE_WRITE_ENABLE |
                   NV097_SET_COLOR_MASK_GREEN_WRITE_ENABLE |
                   NV097_SET_COLOR_MASK_RED_WRITE_ENABLE |
                   NV097_SET_COLOR_MASK_ALPHA_WRITE_ENABLE);

  p = pb_push1(p, NV097_SET_DEPTH_TEST_ENABLE, false);
  p = pb_push1(p, NV097_SET_DEPTH_MASK, true);
  p = pb_push1(p, NV097_SET_DEPTH_FUNC, NV097_SET_DEPTH_FUNC_V_LESS);
  p = pb_push1(p, NV097_SET_STENCIL_TEST_ENABLE, false);
  p = pb_push1(p, NV097_SET_STENCIL_MASK, true);

  p = pb_push1(p, NV097_SET_NORMALIZATION_ENABLE, false);
  pb_end(p);

  renderer.SetDefaultViewportAndFixedFunctionMatrices();
  renderer.SetDepthBufferFloatMode(false);

  renderer.SetVertexShaderProgram(nullptr);

  const TextureFormatInfo& texture_format =
      GetTextureFormatInfo(NV097_SET_TEXTURE_FORMAT_COLOR_SZ_X8R8G8B8);
  renderer.SetTextureFormat(texture_format, 0);
  renderer.SetDefaultTextureParams(0);
  renderer.SetTextureFormat(texture_format, 1);
  renderer.SetDefaultTextureParams(1);
  renderer.SetTextureFormat(texture_format, 2);
  renderer.SetDefaultTextureParams(2);
  renderer.SetTextureFormat(texture_format, 3);
  renderer.SetDefaultTextureParams(3);

  renderer.SetTextureStageEnabled(0, false);
  renderer.SetTextureStageEnabled(1, false);
  renderer.SetTextureStageEnabled(2, false);
  renderer.SetTextureStageEnabled(3, false);
  renderer.SetShaderStageProgram(Renderer::STAGE_NONE);
  renderer.SetShaderStageInput(0, 0);

  p = pb_begin();
  p = pb_push1(p, NV097_SET_SHADER_STAGE_PROGRAM, 0);
  pb_end(p);
}

static void CreateGeometry(Renderer& renderer) {
  auto fb_width = static_cast<float>(renderer.GetFramebufferWidth());
  auto  [MASK]  = static_cast<float>(renderer.GetFramebufferHeight());

  float left = -1.0f * floorf(fb_width / 4.0f);
  float right = floorf(fb_width / 4.0f);
  float top = -1.0f * floorf( [MASK]  / 3.0f);
  float bottom = floorf( [MASK]  / 3.0f);
  float mid_width = left + (right - left) * 0.5f;

  uint32_t num_quads = 2;
  std::shared_ptr<VertexBuffer> buffer =
      renderer.AllocateVertexBuffer(6 * num_quads);

  Color ul{0.4f, 0.1f, 0.1f, 0.25f};
  Color ll{0.0f, 1.0f, 0.0f, 1.0f};
  Color lr{0.0f, 0.0f, 1.0f, 1.0f};
  Color ur{0.5f, 0.5f, 0.5f, 1.0f};
  Color ul_s{0.0f, 1.0f, 0.0f, 0.5f};
  Color ll_s{1.0f, 0.0f, 0.0f, 0.1f};
  Color lr_s{1.0f, 1.0f, 0.0f, 0.5f};
  Color ur_s{0.0f, 1.0f, 1.0f, 0.75f};

  float z = 10.0f;
  buffer->DefineBiTri(0, left + 10, top + 4, mid_width + 10, bottom - 10, z, z,
                      z, z, ul, ll, lr, ur, ul_s, ll_s, lr_s, ur_s);
  // Point normals for half the quad away from the camera.
  Vertex* v = buffer->Lock();
  v[0].normal[2] = -1.0f;
  v[1].normal[2] = -1.0f;
  v[2].normal[2] = -1.0f;
  buffer->Unlock();

  ul.SetRGBA(1.0f, 1.0f, 0.0f, 1.0f);
  ul_s.SetRGBA(1.0f, 0.0f, 0.0f, 0.25f);

  ll.SetGreyA(0.5, 1.0f);
  ll_s.SetRGBA(0.3f, 0.3f, 1.0f, 1.0f);

  ur.SetRGBA(0.0f, 0.3f, 0.8f, 0.15f);
  ur_s.SetRGBA(0.9f, 0.9f, 0.4f, 0.33);

  lr.SetRGBA(1.0f, 0.0f, 0.0f, 0.75f);
  lr_s.SetRGBA(0.95f, 0.5f, 0.8f, 0.05);
  z = 9.75f;
  buffer->DefineBiTri(1, mid_width - 10, top + 4, right - 10, bottom - 10, z, z,
                      z, z, ul, ll, lr, ur, ul_s, ll_s, lr_s, ur_s);
}
",fb_height
287,"#include""EPaperDrive.h""

EPaperDrive::EPaperDrive(
    /* args */
    uint8_t BUSY_Pin,
    uint8_t RES_Pin,
    uint8_t DC_Pin,
    uint8_t CS_Pin,
    uint8_t SCK_Pin,
    uint8_t SDI_Pin)
{
    _BUSY_Pin = BUSY_Pin; 
    _RES_Pin = RES_Pin; 
    _DC_Pin = DC_Pin; 
    _CS_Pin = CS_Pin; 
    _SCK_Pin = SCK_Pin; 
    _SDI_Pin = SDI_Pin;

    pinMode(BUSY_Pin, INPUT); 
    pinMode(RES_Pin, OUTPUT);  
    pinMode(DC_Pin, OUTPUT);    
    pinMode(CS_Pin, OUTPUT);    
    pinMode(SCK_Pin, OUTPUT);    
    pinMode(SDI_Pin, OUTPUT);
}

EPaperDrive::~EPaperDrive()
{
}

void EPaperDrive::driver_delay_us(unsigned int  [MASK] )  //1us
{
  for(; [MASK] >1; [MASK] --);
}
void driver_delay_xms(unsigned long xms) //1ms
{  
    unsigned long i = 0 , j=0;

    for(j=0;j<xms;j++)
  {
        for(i=0; i<256; i++);
    }
}

void EPaperDrive::DELAY_S(unsigned int delaytime)     
{
  int i,j,k;
  for(i=0;i<delaytime;i++)
  {
    for(j=0;j<4000;j++)           
    {
      for(k=0;k<222;k++);
                
    }
  }
}

void EPaperDrive::SPI_Delay(uint8_t xrate)
{
  uint8_t i;
  while(xrate)
  {
    for(i=0;i<2;i++);
    xrate--;
  }
}

void EPaperDrive::SPI_Write(uint8_t value)                                    
{                                                           
   uint8_t i;  
   SPI_Delay(1);
    for(i=0; i<8; i++)   
    {
        EPD_CLK_0;
       SPI_Delay(1);
       if(value & 0x80)
          EPD_MOSI_1;
        else
          EPD_MOSI_0;   
        value = (value << 1); 
       SPI_Delay(1);
       driver_delay_us(1);
        EPD_CLK_1; 
        SPI_Delay(1);
    }
}

void EPaperDrive::EPD_WriteCMD(uint8_t command)
{
  SPI_Delay(1);
  EPD_CS_0;                   
  EPD_DC_0;   // command write
  SPI_Write(command);
  EPD_CS_1;
}

void EPaperDrive::EPD_WriteData(uint8_t command)
{
  SPI_Delay(1);
  EPD_CS_0;                   
  EPD_DC_1;   // command write
  SPI_Write(command);
  EPD_CS_1;
}

void EPaperDrive::EPD_Init_Full(void)
{
  EPD_RST_0;  // Module reset      
  delay(10); //At least 10ms delay 
  EPD_RST_1; 
  delay(10); //At least 10ms delay  
    
  EPD_READBUSY();   
  EPD_WriteCMD(0x12);  //SWRESET
  EPD_READBUSY();   
    
  EPD_WriteCMD(0x01); //Driver output control      
  EPD_WriteData(0xF9);
  EPD_WriteData(0x00);
  EPD_WriteData(0x00);

  EPD_WriteCMD(0x11); //data entry mode       
  EPD_WriteData(0x01);

  EPD_WriteCMD(0x44); //set Ram-X address start/end position   
  EPD_WriteData(0x00);
  EPD_WriteData(0x0F);    //0x0F-->(15+1)*8=128

  EPD_WriteCMD(0x45); //set Ram-Y address start/end position          
  EPD_WriteData(0xF9);   //0xF9-->(249+1)=250
  EPD_WriteData(0x00);
  EPD_WriteData(0x00);
  EPD_WriteData(0x00); 

  EPD_WriteCMD(0x3C); //BorderWavefrom
  EPD_WriteData(0x05);  
      
  EPD_WriteCMD(0x18); //Read built-in temperature sensor
  EPD_WriteData(0x80);  
  
  EPD_WriteCMD(0x21); //  Display update control
  EPD_WriteData(0x00);  
  EPD_WriteData(0x80);  

  EPD_WriteCMD(0x4E);   // set RAM x address count to 0;
  EPD_WriteData(0x00);
  EPD_WriteCMD(0x4F);   // set RAM y address count to 0X199;    
  EPD_WriteData(0xF9);
  EPD_WriteData(0x00);
  EPD_READBUSY();
  
}

void EPaperDrive::EPD_WhiteScreen_ALL(const unsigned char *BW_datas,const unsigned char *R_datas)
{
   unsigned int i;  
  EPD_WriteCMD(0x24);   //write RAM for black(0)/white (1)
   for(i=0;i<ALLSCREEN_GRAGHBYTES;i++)
   {               
     EPD_WriteData(pgm_read_byte(&BW_datas[i]));
   }
  EPD_WriteCMD(0x26);   //write RAM for black(0)/white (1)
   for(i=0;i<ALLSCREEN_GRAGHBYTES;i++)
   {               
     EPD_WriteData(~(pgm_read_byte(&R_datas[i])));
   }
   EPD_Update();   
}

void EPaperDrive::EPD_WhiteScreen_ALL_Clean(void)
{
   unsigned int i;  
  EPD_WriteCMD(0x24);   //write RAM for black(0)/white (1)
   for(i=0;i<ALLSCREEN_GRAGHBYTES;i++)
   {               
     EPD_WriteData(0xff);
   }
  EPD_WriteCMD(0x26);   //write RAM for black(0)/white (1)
   for(i=0;i<ALLSCREEN_GRAGHBYTES;i++)
   {               
     EPD_WriteData(0x00);
   }
   EPD_Update();   
}

void EPaperDrive::EPD_Update(void)
{
  EPD_WriteCMD(0x22); //Display Update Control
  EPD_WriteData(0xF7);   
  EPD_WriteCMD(0x20);  //Activate Display Update Sequence
  EPD_READBUSY();   

}

void EPaperDrive::EPD_DeepSleep(void)
{  
  EPD_WriteCMD(0x10); //enter deep sleep
  EPD_WriteData(0x01); 
  delay(100);
}

void EPaperDrive::EPD_READBUSY(void)
{ 
  while(1)
  {   //=1 BUSY
     if(isEPD_BUSY==0) break;
  }  
}",xus
288,"
/**
*
*	Open Source Code
*
*	Author: <NAME>
*
**/

#pragma once



#include <cassert>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <vector>




class BinaryWriter
{
	private:
		std::ofstream& writer;



	public:

		BinaryWriter(std::ofstream& givenWriter) : writer(givenWriter)
		{
			assert(writer.good());
		}



		bool good() const
		{
			return writer.good();
		}

		std::ofstream * GetStream()
		{
			return &writer;
		}

		template <typename T>
		bool put(const T& value);

		template<>
		bool put< uint8_t >(const uint8_t& value)
		{
			writer.write(reinterpret_cast<const char*> (&value), sizeof(uint8_t));
			return good();
		}

		template<>
		bool put< uint32_t >(const uint32_t& value)
		{
			writer.write(reinterpret_cast<const char*> (&value), sizeof(uint32_t));
			return good();
		}

		template<>
		bool put< uint64_t >(const uint64_t& value)
		{
			writer.write(reinterpret_cast<const char*> (&value), sizeof(uint64_t));
			return good();
		}

		template<>
		bool put< std::string >(const std::string& value)
		{
			std::vector<unsigned char>  [MASK] (value.begin(), value.end());

			size_t length =  [MASK] .size();

			put(length);

			writer.write(reinterpret_cast<const char*>( [MASK] .data()), length);

			return good();
		}
};
",utf8_bytes
289,"#include ""utils.h""

boolean initConfig(ConfigStore &configStore)
{
    EEPROM.begin(sizeof(ConfigStore));
    return readConfig(configStore);
}

// 将配置写入flash
void writeConfig(ConfigStore &configStore) { 
    EEPROM.put(EEPROM_CONFIG_START, configStore);
    EEPROM.commit();
}

// 从flash读取配置
boolean readConfig(ConfigStore &configStore) { 
    EEPROM.get(EEPROM_CONFIG_START, configStore);
    if (configStore.magic != configDefault.magic) {
        DEBUG_PRINT(""Using default config."");
        configStore = configDefault;
        return false;
    }
    else
        return true;
}

void connectWiFi(ConfigStore &configStore)
{
    int  [MASK]  = 0;
    boolean connected = true;
    if (WiFi.status() != WL_CONNECTED) {
        WiFi.mode(WIFI_STA);
        WiFi.begin(configStore.wifiSSID, configStore.wifiPass);
        pinMode(LED_PIN, OUTPUT);
        DEBUG_PRINT(""Connecting to WiFi."");
        while(WiFi.status() != WL_CONNECTED)
        {
            digitalWrite(LED_PIN, HIGH);
            delay(250);
            digitalWrite(LED_PIN, LOW);
            delay(250);
             [MASK] ++;
            if( [MASK]  > 20)
            {
                connected = false;
                break;
            }
        }
        if(!connected)
        {
            DEBUG_PRINT(""Connect to WiFi Failed."");
            smartConfig(configStore);
        }
    }
}


void monitorWiFi(ConfigStore &configStore)
{
    if(configStore.flagConfig == 1)
    {
        WiFi.disconnect();
        configStore.flagWiFiFail = 1;
        smartConfig(configStore);
    }

    if (WiFi.status() != WL_CONNECTED) {
        if(configStore.flagWiFiFail == 0)
            configStore.flagWiFiFail = 1;
        connectWiFi(configStore);
    }
    else if (configStore.flagWiFiFail == 1)
    {
        configStore.flagWiFiFail = 0;
        DEBUG_PRINT(""WiFi connected:"");
        DEBUG_PRINT(WiFi.SSID().c_str());
        DEBUG_PRINT(""Local IP:"");
        DEBUG_PRINT(WiFi.localIP());
    }
    else
        configStore.flagWiFiFail == 0;
}

// 通过Smart Config获取密码
void smartConfig(ConfigStore &configStore)
{
    boolean flag = true;
    uint8_t brightness;//, m_Counter = 0;
    uint16_t m_Counter = 0;
    uint8_t i = 0;
    WiFi.mode(WIFI_STA);
    DEBUG_PRINT(""Wait for SmartConfig"");
    WiFi.beginSmartConfig();
    pinMode(LED_PIN, OUTPUT);
    while (flag) {
        if(m_Counter == 0) Serial.print(""."");
        // analogWriteRange(new_range)
        // analogWriteFreq(new_frequency) 
        //analogWriteResolution(10);
        //analogWrite(LED_PIN, map(brightness, 0, 1023, 0, 1023));
        m_Counter = (m_Counter + 1) % 256;
        brightness = (m_Counter < 128) ? m_Counter : 256 - m_Counter;
        // m_Counter = (m_Counter + 1) % 1024;
        // brightness = (m_Counter < 512) ? m_Counter : 1024 - m_Counter;
        //analogWrite(LED_PIN, BOARD_PWM_MAX * ((float)brightness / (BOARD_PWM_MAX/2)));
        analogWrite(LED_PIN, BOARD_PWM_MAX - brightness * 2);
        delay(10);
        
        if (WiFi.smartConfigDone()) {
            Serial.print("""");
            DEBUG_PRINTF(""\r\nSmartConfig Success."");
            // DEBUG_PRINTF(""SSID: %s\r\n"", WiFi.SSID().c_str());
            // DEBUG_PRINTF(""PSW: %s\r\n"", WiFi.psk().c_str());

            // 保存配置
            DEBUG_PRINT(""Save config..."");
            // sprintf(configStore.wifiSSID, ""%s"", WiFi.SSID().c_str());
            // sprintf(configStore.wifiPass, ""%s"", WiFi.psk().c_str());
            memset(configStore.wifiSSID, 0, sizeof(configStore.wifiSSID));
            memset(configStore.wifiPass, 0, sizeof(configStore.wifiPass));
            strcpy(configStore.wifiSSID, WiFi.SSID().c_str());
            strcpy(configStore.wifiPass, WiFi.psk().c_str());
            DEBUG_PRINTF(""SSID: %s\n"", configStore.wifiSSID);
            DEBUG_PRINTF(""PSW: %s\n"", configStore.wifiPass);
            writeConfig(configStore);
            DEBUG_PRINT(""Save config done!"");
            WiFi.stopSmartConfig();
            flag = false;
        }
    }
    for(i=0; i<10; i++) // 状态提示
    {
        delay(100);
        digitalWrite(LED_PIN, i % 2);
    }
}



// 固件升级
void firmwareUpdate(ConfigStore &configStore)
{
    DEBUG_PRINTF(""Updating firmware -> "");
    t_httpUpdate_return ret = ESPhttpUpdate.update(configStore.cloudHost, configStore.cloudPort, configStore.cloudUpdateUrl, configStore.version);
    //t_httpUpdate_return ret = ESPhttpUpdate.update(""http://192.168.1.101:5000/firmware"", configStore.version);
    //t_httpUpdate_return  ret = ESPhttpUpdate.update(""https://server/file.bin"");
    
    switch(ret) {
        case HTTP_UPDATE_FAILED:
            DEBUG_PRINT(""HTTP_UPDATE_FAILED"");
            break;

        case HTTP_UPDATE_NO_UPDATES:
            DEBUG_PRINT(""HTTP_UPDATE_NO_UPDATES"");
            break;

        case HTTP_UPDATE_OK:
            DEBUG_PRINT(""HTTP_UPDATE_OK"");
            break;
    }
}

// 检查固件升级信息
int checkFirmwareUpdate(ConfigStore &configStore)
{
    int result = 0;
    HTTPClient http;
    http.begin(configStore.cloudHost, configStore.cloudPort, configStore.cloudFwCheckUrl);
    int httpCode =  http.GET(); // 使用GET形式来取得数据
    DEBUG_PRINTF(""Code: %d\n"", httpCode);
    if(httpCode == 200) { // 访问成功，取得返回参数
        String payload = http.getString();
        DEBUG_PRINTF(""Context: %s\n"", payload.c_str());
        if(payload == ""1"")
            result = 1;
        else
            result = 0;
    } else { // 访问不成功，打印原因
        String payload = http.getString();
        DEBUG_PRINTF(""Context: %s\n"", payload.c_str());
        result = 0;
    }
    return result;
}


",try_count
290,"/*
    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleServer.cpp
    Ported to Arduino ESP32 by <NAME>
    updates by chegewara
*/
#include <Arduino.h>

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

#include ""OpenRadiation_V2.h""
#include ""Utils.h""
#include ""OpenRadiation_Oled.h""

#define BLUETOOTH_NAME ""OpengKIT72""

// See the following for generating UUIDs:
// https://www.uuidgenerator.net/

#define SERVICE_UUID        ""4fafc201-1fb5-459e-8fcc-c5c9c331914b""
#define RX_CHARACTERISTIC_UUID ""beb5483e-36e1-4688-b7f5-ea07361b26a8""
#define TX_CHARACTERISTIC_UUID ""beb5483f-36e1-4688-b7f5-ea07361b26a8""

#define MANUFACTURER_DATA {0x00,0x00,0x30,0x30,0x30,0x30,0x31}

/** In packets types **/

#define IN_PACKET_STEALTH                   0x01
#define IN_PACKET_SILENT                    0x02
#define IN_PACKET_SET_TENSION               0x11
#define IN_PACKET_SEND_INFO                 0x12

#define VERSION_BUFFER_SIZE                    5
#define SENSOR_BUFFER_SIZE                    20
#define TUBE_BUFFER_SIZE                       8
#define VOLTAGE_BUFFER_SIZE                    5
#define DATA_BUFFER_SIZE                      19

uint8_t p_version_buffer[VERSION_BUFFER_SIZE] = {0x02, 0x03, '1', '.', '0'};
uint8_t p_sensor_buffer[SENSOR_BUFFER_SIZE] = {0x03, 0x12, 'G', 'e', 'i', 'g', 'e', 'r', '-', 'M', 'u', 'l', 'l', 'e', 'r', ' ','t' ,'u' ,'b' ,'e'};
uint8_t p_tube_buffer[TUBE_BUFFER_SIZE] = {0x10,0x06, 'J', '3', '0', '5', 0x62, 0x64};
uint8_t p_actual_tension[VOLTAGE_BUFFER_SIZE] = {0x12, 0x43, 0xBE, 0x00, 0x00};

//uint8_t p_tube_buffer_p_actual_tension[TUBE_BUFFER_SIZE+VOLTAGE_BUFFER_SIZE] = {0x10,0x06, 'J', '3', '0', '5', 0x62, 0x64, 0x12, 0x00, 0x00, 0xBE, 0x43};
uint8_t p_tube_buffer_p_actual_tension[TUBE_BUFFER_SIZE+VOLTAGE_BUFFER_SIZE] = {0x10,0x06, 'S', 'B', 'M', '-', '2', '0', 0x12, 0x00, 0x00, 0xBE, 0x43};


uint8_t p_data_buffer[DATA_BUFFER_SIZE] = {0x05, 0x00, 0x06, 0x00, 0x00, 0xD8, 0x41, 0xD1, 0x1D, 0x12, 0x00, 0x00, 0xBE, 0x43, 0x13, 0x00, 0x00, 0x00, 0x00};

BLEServer *pServer = NULL;
BLECharacteristic * pTxCharacteristic;
BLECharacteristic * pRxCharacteristic;

bool deviceConnected = false;
bool oldDeviceConnected = false;
uint8_t txValue = 0;

unsigned long pulse_millis = 0;
unsigned int nb_pulse = 0;

unsigned long previousMillis = 0;
const long interval = 1000;  
const long led_interval = 50;

unsigned int nb_pulse_to_send = 0;
int current_state = 0;
int old_state = 0;
unsigned int nb_measure = 0;

boolean b_new_pulse = false;
boolean b_data_to_send = false;
boolean b_debug_data_to_send = false;

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

boolean stealthMode = false;
boolean silentMode = false;

class MyTxCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pTxCharacteristic) {
      std::string value = pTxCharacteristic->getValue();

      if (value.length() > 0) {
        byte datatype = value[0];

        switch (datatype) {
          
          case IN_PACKET_STEALTH:
            stealthMode = value[1];
            if (stealthMode) {
              disableFollowerLED();
            } else {
              enableFollowerLED();
            }
          break;
      
          case IN_PACKET_SILENT:
            silentMode = value[1];
            if (silentMode) {
              disableFollowerBuzzer();
            } else {
              enableFollowerBuzzer();
            }
            break;
          
          case IN_PACKET_SEND_INFO:
              pRxCharacteristic->setValue(p_version_buffer, VERSION_BUFFER_SIZE);
              pRxCharacteristic->notify();
              delay(100);
              pRxCharacteristic->setValue(p_sensor_buffer,SENSOR_BUFFER_SIZE);
              pRxCharacteristic->notify();
              delay(100);
              pRxCharacteristic->setValue(p_tube_buffer_p_actual_tension,TUBE_BUFFER_SIZE+VOLTAGE_BUFFER_SIZE);
              pRxCharacteristic->notify();
              delay(100);
          break;
          default: break;
        }
      }
    }
};

void setup() {
  Serial.begin(115200);
  Serial.println(""Starting BLE work!"");

  delay(100);
  initialization();

  // Create the BLE Device
  BLEDevice::init(BLUETOOTH_NAME);

  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());
  
  BLEService *pService = pServer->createService(SERVICE_UUID);
  
  pRxCharacteristic = pService->createCharacteristic(
                                         RX_CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ |
                                         BLECharacteristic::PROPERTY_NOTIFY
                                      );
  
  

  pTxCharacteristic = pService->createCharacteristic(
                                         TX_CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_WRITE
                                       );

  
  pTxCharacteristic->setCallbacks(new MyTxCallbacks());

  // Create a BLE Descriptor
  pRxCharacteristic->addDescriptor(new BLE2902());

  pService->start();
  
  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
 
  oAdvertisementData.setManufacturerData(MANUFACTURER_DATA);

  //BLEAdvertising *pAdvertising = pServer->getAdvertising();  // this still is working for backward compatibility
  BLEAdvertising *pRxAdvertising = BLEDevice::getAdvertising();
  
  pRxAdvertising->addServiceUUID(SERVICE_UUID);
  pRxAdvertising->setScanResponse(false);
  pRxAdvertising->setMinPreferred(0x00);  // functions that help with iPhone connections issue
  pRxAdvertising->setMinPreferred(0x12);
  pRxAdvertising->setScanResponseData(oAdvertisementData);
  BLEDevice::startAdvertising();
  Serial.println(""Characteristic defined! Now you can read it in your phone!"");

  pRxCharacteristic->setValue(p_version_buffer, VERSION_BUFFER_SIZE);
  pRxCharacteristic->notify();
  delay(10);
  pRxCharacteristic->setValue(p_sensor_buffer,SENSOR_BUFFER_SIZE);
  pRxCharacteristic->notify();
  delay(10);
  pRxCharacteristic->setValue(p_tube_buffer,TUBE_BUFFER_SIZE);
  pRxCharacteristic->notify();
  delay(10);

  //OledInitialization();
 }


void loop() {
  unsigned long  [MASK]  = millis();
 
  current_state = digitalRead(COUNT_INPUT);
  if ((old_state == 0) && (current_state == 1))
  {
    nb_pulse++;
    b_new_pulse = true;
  }
  old_state = current_state;

  //Check timer
  if ( [MASK]  - previousMillis >= interval)
  {
      previousMillis =  [MASK] ;
      
      nb_pulse_to_send = nb_pulse;
      nb_pulse = 0;

      temp_of_board = get_temperature(0, true);
      switch_sensor(0);

      battery_voltage = analogRead(BATTERY_CAN) / 512;

      ht_voltage = analogRead(HIGH_VOLTAGE_CAN) / 1024;

      b_data_to_send = true;
      b_debug_data_to_send = true;
            
  }


  if ((DEBUG_MODE) && (b_debug_data_to_send))
      {
          String data_to_send = ""Nb pulse = "";
          data_to_send += String(nb_pulse_to_send, DEC);
          Serial.println(data_to_send);
          data_to_send = String(""Temp = "");
          data_to_send += String(temp_of_board, DEC);
          Serial.println(data_to_send);
          data_to_send = String(""Batterie Voltage = "");
          data_to_send += String(battery_voltage, DEC);
          Serial.println(data_to_send);
          data_to_send = String(""Hight Voltage = "");
          data_to_send += String(ht_voltage, DEC);
          Serial.println(data_to_send);
          b_debug_data_to_send = false;
      }
  
  if (deviceConnected) {
    if (b_data_to_send)
      {
          b_data_to_send = false;
          p_data_buffer[1] = nb_pulse_to_send;
          ConvertFloatToBuffer(temp_of_board, p_data_buffer, 3); 
          pRxCharacteristic->setValue(p_data_buffer, DATA_BUFFER_SIZE);
          pRxCharacteristic->notify();
          delay(10);
      }
    }

      // disconnecting
  if (!deviceConnected && oldDeviceConnected) {
        delay(500); // give the bluetooth stack the chance to get things ready
        pServer->startAdvertising(); // restart advertising
        Serial.println(""start advertising"");
        oldDeviceConnected = deviceConnected;
        communication_disable();
    }
  
  // connecting
    if (deviceConnected && !oldDeviceConnected) {
    // do stuff here on connecting
        Serial.println(""Connected"");
        oldDeviceConnected = deviceConnected;
        communication_enable();
    }

  //Flash led
  if (b_new_pulse)
  {
    buzzer_on();
    led_on();
    pulse_millis =  [MASK] ;
    b_new_pulse = false;
  }

  if (( [MASK]  - pulse_millis) >= led_interval)
  {
    //digitalWrite(LED_PIN, HIGH);
    buzzer_off();
    led_off();
  }
 }
",currentMillis
291,"/*
 * Copyright (C) 2025 Huawei Device Co., Ltd.
 * 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 ""credential_base.h""

using namespace Hdc;

char HdcCredentialBase::GetPathSep()
{
#ifdef _WIN32
    const char sep = '\\';
#else
    const char sep = '/';
#endif
    return sep;
}

int HdcCredentialBase::RemoveDir(const std::string& dir)
{
    DIR *pdir = opendir(dir.c_str());
    if (pdir == nullptr) {
        WRITE_LOG(LOG_FATAL, ""opendir failed dir:%s"", dir.c_str());
        return -1;
    }
    struct dirent *ent;
    struct stat st;
    while ((ent = readdir(pdir)) != nullptr) {
        if (ent->d_name[0] == '.') {
            continue;
        }
        std::string subpath = dir + HdcCredentialBase::GetPathSep() + ent->d_name;
        if (lstat(subpath.c_str(), &st) == -1) {
            WRITE_LOG(LOG_WARN, ""lstat failed subpath:%s"", subpath.c_str());
            continue;
        }
        if (S_ISDIR(st.st_mode)) {
            if (RemoveDir(subpath) == -1) {
                closedir(pdir);
                return -1;
            }
            rmdir(subpath.c_str());
        } else if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
            if (unlink(subpath.c_str()) == -1) {
                WRITE_LOG(LOG_FATAL, ""Failed to unlink file or symlink, error is :%s"", strerror(errno));
            }
        } else {
            WRITE_LOG(LOG_DEBUG, ""lstat st_mode:%07o subpath:%s"", st.st_mode, subpath.c_str());
        }
    }
    if (rmdir(dir.c_str()) == -1) {
        closedir(pdir);
        return -1;
    }
    closedir(pdir);
    return 0;
}

int HdcCredentialBase::RemovePath(const std::string& path)
{
    struct stat st;
    if (lstat(path.c_str(), &st) == -1) {
        WRITE_LOG(LOG_WARN, ""lstat failed path:%s"", path.c_str());
        return -1;
    }
    if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
        if (unlink(path.c_str()) == -1) {
            WRITE_LOG(LOG_FATAL, ""Failed to unlink file or symlink,, error is :%s"", strerror(errno));
        }
    } else if (S_ISDIR(st.st_mode)) {
        if (path == ""."" || path == "".."") {
            return 0;
        }
        int rc = HdcCredentialBase::RemoveDir(path);
        WRITE_LOG(LOG_INFO, ""RemoveDir rc:%d path:%s"", rc, path.c_str());
        return rc;
    }
    return 0;
}

const std::string HdcCredentialBase::StringFormat(const char* const formater, ...)
{
    va_list vaArgs;
    va_start(vaArgs, formater);
    std::string ret = StringFormat(formater, vaArgs);
    va_end(vaArgs);
    return ret;
}

const std::string HdcCredentialBase::StringFormat(const char* const formater, va_list& vaArgs)
{
    std::vector<char> args(MAX_SIZE_IOBUF_STABLE);
    const int  [MASK]  = vsnprintf_s(
        args.data(), MAX_SIZE_IOBUF_STABLE, (args.size() >= 1) ? (args.size() - 1) : 0, formater, vaArgs);
    if ( [MASK]  < 0) {
        return std::string("""");
    } else {
        return std::string(args.data(),  [MASK] );
    }
}",retSize
292,"// ReSharper disable CppZeroConstantCanBeReplacedWithNullptr
// ReSharper disable CppCStyleCast
// ReSharper disable CppInconsistentNaming
// ReSharper disable CppClangTidyBugproneNarrowingConversions

#include <Arduino.h>
#include <SdFat.h>
#include <Keyboard.h>
#include <LCDWIKI_KBV.h> //Hardware-specific library

#include ""AppDefinitions.h""
#include ""Serialprint.h""
#include ""Button.h""
#include ""Memory.h""

uint8_t Button::InitBMP(String* path)
{
	SetBMPPath(path);

	File f;
	const bool success = f.open(GetBMPPath().c_str());
	if (!success)
		return DEF_ERR_CANT_OPEN_FILE;

	f.readBytes((char*)&_file_header, sizeof(BMPFileHeader));

	if (_file_header.file_type != 0x4D42)
		return DEF_ERR_UNRECOGNIZED_FILE_FORMAT;

	f.readBytes((char*)&_bmp_info_header, sizeof(BMPInfoHeader));

	// The BMPColorHeader is used only for transparent images
	if (_bmp_info_header.bit_count == 32)
	{
		// Check if the file has bit mask color information
		if (_bmp_info_header.size >= (sizeof(BMPInfoHeader) + sizeof(BMPColorHeader)))
		{
			f.read((char*)&_bmp_color_header, sizeof(BMPColorHeader));

			// Check if the pixel data is stored as BGRA and if the color space type is sRGB
			constexpr BMPColorHeader expected_color_header;
			if (expected_color_header.red_mask != _bmp_color_header.red_mask ||
				expected_color_header.blue_mask != _bmp_color_header.blue_mask ||
				expected_color_header.green_mask != _bmp_color_header.green_mask ||
				expected_color_header.alpha_mask != _bmp_color_header.alpha_mask)
				return DEF_ERR_UNEXPECTED_COLOR_MASK_FORMAT;
			
			if (expected_color_header.color_space_type != _bmp_color_header.color_space_type)
				return DEF_ERR_UNEXPECTED_COLOR_SPACE_TYPE;
		}
		else
		{
			return DEF_ERR_NO_BIT_MASK_INFO;
		}
	}

	// Jump to the pixel data location
	f.seek(_file_header.offset_data);

	// Adjust the header fields for output.
	// Some editors will put extra info in the image file, we only save the headers and the data.
	if (_bmp_info_header.bit_count == 32)
	{
		_bmp_info_header.size = sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
		_file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
	}
	else
	{
		_bmp_info_header.size = sizeof(BMPInfoHeader);
		_file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
	}
	_file_header.file_size = _file_header.offset_data;

	if (_bmp_info_header.planes == 1) // # planes -- must be '1'
	{
		if ((_bmp_info_header.bit_count == 24 || _bmp_info_header.bit_count == 16) && (_bmp_info_header.compression ==
			0)) // only 24/16 bit per pixel depth is supported; 0 = uncompressed
		{
			if (_bmp_info_header.height < 0)
			{
				_bmpIsFlipped = true;
				_bmp_info_header.height = -_bmp_info_header.height;
			}
			else
			{
				_bmpIsFlipped = false;
			}
			_isInitialized = true;
		}
	}

	f.close();
	return DEF_ERR_NONE;
}

// Read row by row and immediately send to the screen
uint8_t Button::DrawBMP(LCDWIKI_KBV* my_lcd) const
{
	if (!IsInitialized())
		return DEF_ERR_ACCESS_TO_NOT_INITIALIZED_BMP;

	//const uint32_t time = millis();

	File f;
	const bool success = f.open(GetBMPPath().c_str());
	if (!success)
	{
		return DEF_ERR_CANT_OPEN_FILE;
	}

	f.seek(GetBMPOffset());

	const uint8_t bytesPerPixel = GetBMPDepth() / 8;
	const int16_t paddedWidth = (GetBMPWidth() * bytesPerPixel + 3) & ~3;

	auto data = (uint8_t*) mallocWrapper(paddedWidth);
	if (data == NULL)
		return DEF_ERR_NOT_ENOUGH_MEMORY;

	// TODO was only tested with width % 4 == 0
	//Serialprint(""Width = %d, Padded width = %d\n"", GetBMPWidth() * bytesPerPixel, paddedWidth);

	auto colors = (uint16_t*) mallocWrapper(GetBMPWidth() * sizeof(uint16_t));
	if (colors == NULL)
	{
		free(data);
		return DEF_ERR_NOT_ENOUGH_MEMORY;
	}

	for (size_t rowNum = 0; rowNum < GetBMPHeight(); ++rowNum)
	{
		size_t m = 0;
		f.readBytes(data, paddedWidth);

		switch (bytesPerPixel)
		{
		case 3:
			{
				for (size_t i = 0; i < GetBMPWidth(); ++i)
				{
					colors[i] = my_lcd->Color_To_565(data[m + 2], data[m + 1], data[m + 0]);
					m += bytesPerPixel;
				}
				break;
			}
		case 2:
			{
				for (size_t i = 0; i < GetBMPWidth(); ++i)
				{
					/*
					if (data[m] > 0) {
					  Serialprint(""data[%d] = %d binary = "", m, data[m]);
					  PrintBinary(data[m]);
		  
					  Serialprint(""data[%d] = %d binary = "", m+1, data[m+1]);
					  PrintBinary(data[m+1]);
		  
					  uint16_t combined = (data[m+1] << 8) | data[m];
					  Serialprint(""Combined = %d binary = "", combined);
					  PrintBinary(combined);
		  
					  colors[i] = 0;
					  uint8_t* pointer = (uint8_t*) &colors[i];
					  Serialprint(""Address of [0] = %p Address of [1] = %p"", &(pointer[0]), &(pointer[1]));
					  pointer[0] = data[m];
					  pointer[1] = data[m+1];
					  Serial.println();
					  PrintBinary(colors[i]);
		  
					  delay(100000000);
					}
					*/

					const auto pointer = (uint8_t*)&colors[i];
					pointer[0] = data[m + 1];
					pointer[1] = data[m];
					m += bytesPerPixel;
				}
				break;
			}
		}

		if (_bmpIsFlipped)
			my_lcd->Set_Addr_Window(GetBMPX(), GetBMPY() + rowNum, GetBMPX() + GetBMPWidth() - 1, GetBMPY() + rowNum);
		else
			my_lcd->Set_Addr_Window(GetBMPX(), GetBMPY() + GetBMPHeight() - rowNum, GetBMPX() + GetBMPWidth() - 1,
			                        GetBMPY() + GetBMPHeight() - rowNum);

		my_lcd->Push_Any_Color(colors, GetBMPWidth(), true, DEF_LCDWIKI_KBV_FLAGS_NONE);
	}

	f.close();
	free(data);
	data = NULL;
	free(colors);
	colors = NULL;

	//Serialprint(""Drawing took %d\n"", millis() - time);
	return DEF_ERR_NONE;
}

void Button::DrawSelection(LCDWIKI_KBV* my_lcd) const
{
	if (IsSelected())
		my_lcd->Set_Draw_color(GREEN);
	else
		my_lcd->Set_Draw_color(BLACK);

	if (IsInitialized())
	{
		for (uint16_t i = 1; i < 8; ++i)
		{
			const uint16_t x0 = GetBMPX() - i;
			const uint16_t y0 = GetBMPY() - i;
			const uint16_t x1 = x0 + GetBMPWidth() + i * 2;
			const uint16_t y1 = y0 + GetBMPHeight() + i * 2;
			my_lcd->Draw_Rectangle(x0, y0, x1, y1);
		}
	}
	else
	{
		for (uint16_t i = 1; i < 8; ++i)
		{
			my_lcd->Draw_Round_Rectangle(GetX1() + i, GetY1() + i, GetX2() - i, GetY2() - i,
			                             DEF_BUTTON_RECTANGLE_ROUNDNESS);
		}
	}
}

void Button::DrawRectangle(LCDWIKI_KBV* my_lcd, const char* text) const
{
	my_lcd->Set_Text_Size(2);
	my_lcd->Set_Text_colour(GREEN);
	my_lcd->Set_Text_Back_colour(BLACK);

	if (text != NULL)
	{
		if (GetType() == DEF_BUTTON_TYPE_NEXT)
			my_lcd->Print_String("">"", GetX1() + GetWidth() / 5, GetY1() + GetHeight() / 2);
		else if (GetType() == DEF_BUTTON_TYPE_PREV)
			my_lcd->Print_String(""<"", GetX1() + GetWidth() / 5, GetY1() + GetHeight() / 2);
		else if (GetType() == DEF_BUTTON_TYPE_SELECT_ALL)
			my_lcd->Print_String(""A"", GetX1() + GetWidth() / 5, GetY1() + GetHeight() / 2);
		else
			my_lcd->Print_String(text, GetX1() + GetWidth() / 5, GetY1() + GetHeight() / 2);
	}

	my_lcd->Set_Draw_color(WHITE);
	my_lcd->Draw_Round_Rectangle(GetX1(), GetY1(), GetX2(), GetY2(), DEF_BUTTON_RECTANGLE_ROUNDNESS);
}

void Button::SendKeys() const
{
	const String  [MASK]  = GetKeys();
	int index =  [MASK] .indexOf('[');
	while (index >= 0)
	{
		String str =  [MASK] .substring(index + 1,  [MASK] .indexOf(']', index));

		uint16_t key = 0;
		if (str.equalsIgnoreCase(""up""))
			key = KEY_UP_ARROW;
		else if (str.equalsIgnoreCase(""down""))
			key = KEY_DOWN_ARROW;
		else if (str.equalsIgnoreCase(""right""))
			key = KEY_RIGHT_ARROW;
		else if (str.equalsIgnoreCase(""left""))
			key = KEY_LEFT_ARROW;
		else if (str.equalsIgnoreCase(""ctrl""))
			key = KEY_LEFT_CTRL;
		else if (str.length() == 1)
		{
			key = str[0];
		}

		//Serialprint(""str = '%s', key = %x\n"", str.c_str(), key);
		if (key > 0)
		{
			Keyboard.press(key);
			delay(DEF_KEY_SEND_DELAY);
			Keyboard.release(key);
			delay(DEF_KEY_SEND_DELAY);
		}

		index =  [MASK] .indexOf('[', index + 1);
	}
}
",keys
293,"/*
 *
 *    Copyright (c) 2025 Project CHIP 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.
 */

#pragma once

#include <app-common/zap-generated/cluster-objects.h>

#include ""camera-device-interface.h""
#include <app/util/config.h>
#include <cstring>
#include <protocols/interaction_model/StatusCode.h>
#include <utility>

// Camera App defines all the cluster servers needed for a particular device
class CameraApp
{

public:
    // This class is responsible for initialising all the camera clusters and managing the interactions between them
    explicit CameraApp(chip::EndpointId  [MASK] , CameraDeviceInterface * cameraDevice) :
        mChimeServer( [MASK] , cameraDevice->GetChimeDelegate())
    {}

    // Initialize all the camera device clusters.
    void InitCameraDeviceClusters();

private:
    // SDK cluster servers
    chip::app::Clusters::ChimeServer mChimeServer;
};

void CameraAppInit(CameraDeviceInterface * cameraDevice);

void CameraAppShutdown();
",aClustersEndpoint
294,"#ifndef PATH_SMOOTHING_INCLUDED
#define PATH_SMOOTHING_INCLUDED

#include <eigen3/Eigen/Dense>
#include ""RRTStar_DOM_kd_tree.hpp""

using namespace Eigen;

vector<Point2f> QuadraticBSplineSmoothing(const vector<RRTStarNode*>& node_path) {
    vector<Point2f> res;
    if (node_path.size() < 3) {
        cout << ""No sufficient control points on the input path!\n""
             << ""(At least 3 control points are needed for quadratic B-Spline smoothing.)\n"";
        return res;
    }

    const float step_width = 0.05;   // For MatrixxXf.block() mathod needs constexpr as argument.
    const int step_num = 1 / step_width + 1,
              pts_num = node_path.size();

    Matrix3f coefficient_mat_1, coefficient_mat_2, coefficient_mat_3;
    MatrixXf parameter_var(3, step_num), 
             control_pts(2, pts_num);
    Matrix<float, 2, Dynamic> smoothed_path;

    coefficient_mat_1 << 1, -2, 1, -1.5, 2, 0, 0.5, 0, 0;
    coefficient_mat_2 << 0.5, -1, 0.5, -1, 1, 0.5, 0.5, 0, 0;
    coefficient_mat_3 << 0.5, -1, 0.5, -1.5, 1, 0.5, 1, 0, 0;
    
    for (int i = 0; i < step_num; i++) {
        float cur_var = step_width * i;
        parameter_var(0, i) = cur_var * cur_var;
        parameter_var(1, i) = cur_var;
        parameter_var(2, i) = 1;
    }
    for (int i = 0; i < pts_num; i++) {
        control_pts(0, i) = node_path[i]->pos.x;
        control_pts(1, i) = node_path[i]->pos.y;
    }

    MatrixXf cur_pts = control_pts.block<2, 3>(0, 0);
    MatrixXf cur_spline = cur_pts * coefficient_mat_1 * parameter_var;
    smoothed_path = cur_spline;

    for (int i = 1; i < pts_num - 3; i++) {
        cur_pts = control_pts.block<2, 3>(0, i);
        cur_spline = cur_pts * coefficient_mat_2 * parameter_var;
        smoothed_path.conservativeResize(2, smoothed_path.cols() + cur_spline.cols());
        smoothed_path.block<2, step_num>(0, smoothed_path.cols() - step_num) = cur_spline;
    }
    cur_pts = control_pts.block<2, 3>(0, pts_num - 3);
    cur_spline = cur_pts * coefficient_mat_3 * parameter_var;
    smoothed_path.conservativeResize(2, smoothed_path.cols() + cur_spline.cols());
    smoothed_path.block<2, step_num>(0, smoothed_path.cols() - step_num) = cur_spline;

/*     cout << ""path smoothing:\n""
         << node_path.size() << ' '
         << smoothed_path.rows() << "" x "" << smoothed_path.cols() << '\n'
         << cur_spline.rows() << "" x "" << cur_spline.cols() << endl; */
    for (int i = 0; i < smoothed_path.cols(); i++)
        res.push_back(Point2f(smoothed_path(0, i), smoothed_path(1, i)));
    return res;
}


int SearchByDistance(vector<Point2f>& search_path, Point2f desired_pos) {
    int res_idx = 0;
    if (search_path.empty()) {
        cout << ""An empty path is given."" << endl;
        return res_idx;
    }

    Point2f trivial_sol = search_path.back();
    float ref_distance = norm(desired_pos - trivial_sol),
          cur_distance_dif;

    for (int i = search_path.size() - 1; i >= 0; i--) {
        cur_distance_dif = abs(norm(desired_pos - search_path[i]) - ref_distance);
        if (cur_distance_dif < 2)
            res_idx = i;
    }
    return res_idx;
}


vector<vector<Point2f>> GeneratePathSet(const vector<Point2f>& initial_feedback_pts, 
                                        const vector<Point2f>& target_feedback_pts, 
                                        int pivot_idx,
                                        float feedback_pts_radius,
                                        const vector<PolygonObstacle>& obs,
                                        Mat source_img) {
    vector<vector<Point2f>> res_path_set(initial_feedback_pts.size());                                            
    RRTStarPlanner planner(initial_feedback_pts[pivot_idx], target_feedback_pts[pivot_idx], obs);
    bool plan_success = planner.Plan(source_img, feedback_pts_radius, true);
    if (!plan_success) {
        cout << ""Path planning failed! An empty path set is reutrned.\n"";
        return {};
    }

    vector<RRTStarNode*> pivot_path = planner.GetPath();
    vector<RRTStarNode*> sparse_pivot_path;
    for (int i = 0; i < pivot_path.size(); i += 1)
        sparse_pivot_path.push_back(pivot_path[i]);
    if (sparse_pivot_path.back() != pivot_path.back())
        sparse_pivot_path.push_back(pivot_path.back());
    vector<Point2f> smooth_pivot_path = QuadraticBSplineSmoothing(sparse_pivot_path);
    res_path_set[pivot_idx] = smooth_pivot_path;
    
    for (int i = 0; i < initial_feedback_pts.size(); i++) {
        if (i != pivot_idx) {
            Point2f cur_dif = initial_feedback_pts[i] - initial_feedback_pts[pivot_idx];
            res_path_set[i] = smooth_pivot_path;
            for (Point2f& pt : res_path_set[i])
                pt += cur_dif;
            
            if (normSqr(res_path_set[i].back() - target_feedback_pts[i]) > normSqr(res_path_set[i].front() - target_feedback_pts[i])){
                res_path_set[i].erase(res_path_set[i].begin() + 1, res_path_set[i].end());
            }
            else {
                int truncation_idx = SearchByDistance(res_path_set[i], target_feedback_pts[i]);
                res_path_set[i].erase(res_path_set[i].begin() + truncation_idx, res_path_set[i].end());
            }
            
            Point2f temp_end = res_path_set[i].back(), segment = target_feedback_pts[i] - temp_end;
            float segment_length = cv::norm(segment), temp_path_length = cv::norm(temp_end - res_path_set[i].front()), 
                  interpolation_ratio;
            int segment_pt_num;
            if (temp_path_length > 1)  // in case temp_path_length becomes 0
                segment_pt_num = segment_length / temp_path_length * res_path_set[i].size();
            else
                segment_pt_num = 100;
            for (int interpolation_idx = 1; interpolation_idx <= segment_pt_num; interpolation_idx++) {
                interpolation_ratio = (float)interpolation_idx / segment_pt_num;
                res_path_set[i].push_back(temp_end + segment * interpolation_ratio);
            }
            // res_path_set[i].push_back(target_feedback_pts[i]);
        }
    }
    return res_path_set; 
}


vector<Point2f> ProcessCollisionPath(const vector<Point2f>& pivot_path, 
                                    Point2f pivot_pt, Point2f cur_pt, 
                                    Point2f cur_target_pt,
                                    const PolygonObstacle& original_obstacle, 
                                    float safety_dis = 20) {
    vector<Point2f> inflated_obs_vertices = original_obstacle.vertices;
    Point2f vertices_centroid = Point2f(0, 0);
    for (Point2f& pt : inflated_obs_vertices)
        vertices_centroid += pt;
    vertices_centroid /= (float) inflated_obs_vertices.size();
    for (Point2f& pt : inflated_obs_vertices)
        pt = vertices_centroid + 1.1 * (pt - vertices_centroid);
    PolygonObstacle obstacle(inflated_obs_vertices);


    vector<Point2f> res_path(pivot_path.size());
    Point2f cur_dif = cur_pt - pivot_pt;
    float cur_dif_norm = cv::norm(cur_dif);
    vector<int> collision_indices;
    
    for (int i = 0; i < pivot_path.size(); i++) {
        Point2f ref_pt = pivot_path[i] + cur_dif;
        if (!ObstacleFree(obstacle, pivot_path[i], ref_pt))
            collision_indices.push_back(i);
    }
    
    // std::sort(collision_indices.begin(), collision_indices.end());
    int collision_start_idx = collision_indices.front(), 
        collision_end_idx = collision_indices.back(),
        reconnection_start_idx = collision_start_idx, reconnection_end_idx = collision_end_idx;
    float dis_ref = 3 * safety_dis;
    for (int i = collision_start_idx - 1; i >= 0; i--) {
        float dis_to_obs = MinDistanceToObstacle(obstacle, pivot_path[i] + cur_dif);
        if (dis_to_obs >= dis_ref) {
            reconnection_start_idx = i;
            break;
        }
    }
    if (reconnection_start_idx == collision_start_idx)
        reconnection_start_idx = 0;
    
    Point2f intersection_start_pt = GetClosestIntersectionPt(obstacle, pivot_path[collision_start_idx],
                            pivot_path[collision_start_idx] + cur_dif, pivot_path[collision_start_idx]),
            shift_pt_1 = intersection_start_pt - safety_dis / cur_dif_norm * cur_dif 
                         - (pivot_path[reconnection_start_idx] + cur_dif); 
    for (int i = collision_end_idx + 1; i < pivot_path.size(); i++) {
        float dis_to_obs = MinDistanceToObstacle(obstacle, pivot_path[i] + cur_dif);
        if (dis_to_obs >= dis_ref) {
            reconnection_end_idx = i;
            break;
        }
    }
    if (reconnection_end_idx == collision_end_idx)
        reconnection_end_idx = pivot_path.size() - 1;
    Point2f intersection_end_pt = GetClosestIntersectionPt(obstacle, pivot_path[collision_end_idx],
                            pivot_path[collision_end_idx] + cur_dif, pivot_path[collision_end_idx]),
            shift_pt_2 = pivot_path[reconnection_end_idx] + cur_dif - 
                        (intersection_end_pt - safety_dis / cur_dif_norm * cur_dif); 
                        
    for (int i = 0; i < reconnection_start_idx; i++)
        res_path[i] = pivot_path[i] + cur_dif;
    int step_num = collision_start_idx - reconnection_start_idx;
    for (int i = reconnection_start_idx; i < collision_start_idx; i++) {
        float shift_ratio = (float)(i - reconnection_start_idx) / (float)step_num;
        res_path[i] = pivot_path[reconnection_start_idx] + cur_dif + shift_ratio * shift_pt_1;
    }
    for (int i = collision_start_idx; i < collision_end_idx; i++) {
        Point2f intersection_pt = GetClosestIntersectionPt(obstacle, pivot_path[i], pivot_path[i] + cur_dif, pivot_path[i]);
        res_path[i] = intersection_pt - safety_dis / cur_dif_norm * cur_dif;
    }
    step_num = reconnection_end_idx - collision_end_idx;
    for (int i = collision_end_idx; i < reconnection_end_idx; i++) {
        float shift_ratio = (float) (i - collision_end_idx) / step_num;
        res_path[i] = intersection_end_pt - safety_dis / cur_dif_norm * cur_dif + shift_ratio * shift_pt_2;
    }
    for (int i = reconnection_end_idx; i < pivot_path.size(); i++)
        res_path[i] = pivot_path[i] + cur_dif;

    // postprocessing
    int truncation_idx = SearchByDistance(res_path, cur_target_pt);
    res_path.erase(res_path.begin() + truncation_idx, res_path.end());
    Point2f temp_end = res_path.back(), segment = cur_target_pt - temp_end;
    float segment_length = cv::norm(segment), temp_path_length = cv::norm(temp_end - res_path.front()), 
            interpolation_ratio;
    int segment_pt_num;
    if (temp_path_length > 1)  // in case temp_path_length becomes 0
        segment_pt_num = segment_length / temp_path_length * res_path.size();
    else
        segment_pt_num = 100;
    for (int interpolation_idx = 1; interpolation_idx <= segment_pt_num; interpolation_idx++) {
        interpolation_ratio = (float)interpolation_idx / segment_pt_num;
        res_path.push_back(temp_end + segment * interpolation_ratio);
    }
    // std::cout << ""OK5\n"";
    return res_path; 
}

vector<float>  GetLocalPathWidth2D( const vector<Point2f>& path, 
                                    vector<PolygonObstacle>& obstacles,
                                    Size2f config_size = Size2f(640, 480)) {
    vector<float> local_path_width(path.size(), 0);
    vector<int> path_width_type(path.size(), 0);  // 0: two-side free, 1: one-side free, one-side obstacle
                                                  // 2: two-side obstacle
    float slope, x_max = config_size.width, y_max = config_size.height,
          cur_x, cur_y,
          x_intercept, y_intercept,
          x_at_y_max,  [MASK] ;

    for (int i = 1; i < path.size() - 1; i++) {
        cur_x = path[i].x;
        cur_y = path[i].y;
        slope = -(path[i + 1].x - path[i - 1].x) / (path[i + 1].y - path[i - 1].y);
        vector<Point2f> boundary_insection_pts;

        y_intercept = cur_y + slope * (0 - cur_x);
        if (0 <= y_intercept && y_intercept <= y_max)
            boundary_insection_pts.push_back(Point2f(0, y_intercept));
        x_intercept = cur_x - cur_y / slope;
        if (0 <= x_intercept && x_intercept <= x_max)
            boundary_insection_pts.push_back(Point2f(x_intercept, 0));
        x_at_y_max = cur_x + (y_max - cur_y) / slope;
        if (0 <= x_at_y_max && x_at_y_max <= x_max)
            boundary_insection_pts.push_back(Point2f(x_at_y_max, y_max));
         [MASK]  = cur_x + slope * (x_max - cur_x);
        if (0 <=  [MASK]  &&  [MASK]  <= y_max)
            boundary_insection_pts.push_back(Point2f(x_max,  [MASK] ));
        
        // std::cout << ""OK_1\n"";
        if (boundary_insection_pts.empty()) {
            std::cout << ""Error!\n"";
            std::cout << path[i] << '\n' << ""slope: "" << slope << '\n';
        }
        Point2f end_pt1 = boundary_insection_pts[0], end_pt2 = boundary_insection_pts[1],
                direction1 = end_pt1 - path[i], direiction2 = end_pt2 - path[i];
        vector<Point2f> obs_intersection_pts, direction1_pts, direction2_pts;
        for (PolygonObstacle& cur_obs : obstacles) {
            if (ObstacleFree(cur_obs, end_pt1, end_pt2))
                continue;
            Point2f cur_obs_intersection_pt = GetClosestIntersectionPt(cur_obs, end_pt1, end_pt2, path[i]);
            obs_intersection_pts.push_back(cur_obs_intersection_pt);
        }
        
        if (obs_intersection_pts.empty())
            local_path_width[i] = cv::norm(end_pt1 - end_pt2);
        else {
            for (Point2f cur_pt : obs_intersection_pts) {
                Point2f cur_vec = cur_pt - path[i];
                if (cur_vec.x * direction1.x + cur_vec.y * direction1.y > 0)
                    direction1_pts.push_back(cur_pt);
                else
                    direction2_pts.push_back(cur_pt);
            }
            if (!direction1_pts.empty()) {
                path_width_type[i]++;
                for (Point2f& cur_direction1_pt : direction1_pts) {
                    if (normSqr(cur_direction1_pt - path[i]) < normSqr(end_pt1 - path[i]))
                        end_pt1 = cur_direction1_pt;
                }
            }
            if (!direction2_pts.empty()) {
                path_width_type[i]++;
                for (Point2f& cur_direction2_pt : direction2_pts)
                    if (normSqr(cur_direction2_pt - path[i]) < normSqr(end_pt2 - path[i]))
                        end_pt2 = cur_direction2_pt;
            }
            local_path_width[i] = cv::norm(end_pt1 - end_pt2);
        }
    }

    if (local_path_width.size() >= 2) {
        local_path_width.front() = local_path_width[1];
        local_path_width.back() = local_path_width[local_path_width.size() - 2];
    }
    return local_path_width;
}

vector<vector<int>> FilterRawPassagePairsByVisibility(const vector<PolygonObstacle>& obstacles, 
                                                    const vector<vector<int>>& raw_passage_pairs) {
    vector<vector<int>> res;
    vector<set<int>> valid_passage_pair_set(obstacles.size());
    for (const vector<int>& cur_passage_pair : raw_passage_pairs)
        valid_passage_pair_set[cur_passage_pair[0]].insert(cur_passage_pair[1]);

    for (int i = 0; i < valid_passage_pair_set.size(); i++) {
        for (auto it = valid_passage_pair_set[i].begin(); it != valid_passage_pair_set[i].end();) {
            if (ObstacleFreeVecForPassage(obstacles, i, *it) == false)
                it = valid_passage_pair_set[i].erase(it);  // Be careful when dynamically deleting a set element
            else
                it++;
        }
    }

    for (int i = 0; i < raw_passage_pairs.size(); i++) {
        if (valid_passage_pair_set[raw_passage_pairs[i][0]].find(raw_passage_pairs[i][1]) != valid_passage_pair_set[raw_passage_pairs[i][0]].end())
            res.push_back(raw_passage_pairs[i]);
    }
    return res;
}

vector<vector<int>> FilterPassagePairsBySortedWidth(const vector<PolygonObstacle>& obstacles,
                                                    const vector<vector<int>>& raw_passage_pairs) {
    vector<vector<int>> res;
    vector<vector<int>> passage_pairs_mutual_map(obstacles.size());
    for (const vector<int>& cur_passage_pair : raw_passage_pairs) {
        passage_pairs_mutual_map[cur_passage_pair[0]].push_back(cur_passage_pair[1]);
        passage_pairs_mutual_map[cur_passage_pair[1]].push_back(cur_passage_pair[0]);
    }

    vector<int> obs_idx_2_candidate_vec(obstacles.size(), -1);
    for (int i = 0; i < obstacles.size(); i++) {
        if (passage_pairs_mutual_map[i].size() == 0)
            continue;
        vector<pair<float, int>> width_to_obs_idx;
        PolygonObstacle obs1 = obstacles[i];
        for (int j = 0; j < passage_pairs_mutual_map[i].size(); j++) {
            int obs_idx_2 = passage_pairs_mutual_map[i][j];
            PolygonObstacle obs2 = obstacles[obs_idx_2];
            vector<Point2f> cur_passage_inner_ends = GetPassageInnerEnds(obs1, obs2);
            float cur_passage_width = cv::norm(cur_passage_inner_ends[0] - cur_passage_inner_ends[1]);
            width_to_obs_idx.push_back(make_pair(cur_passage_width, obs_idx_2));
        }
        std::sort(width_to_obs_idx.begin(), width_to_obs_idx.end());
        obs_idx_2_candidate_vec[i] = width_to_obs_idx[0].second;
    }

    for (int i = 0; i < obstacles.size(); i++) {
        if (passage_pairs_mutual_map[i].size() == 0)
            continue;
        int obs_idx_2 = obs_idx_2_candidate_vec[i];
        if (obs_idx_2 > i && i == obs_idx_2_candidate_vec[obs_idx_2])
            res.push_back({i, obs_idx_2});
    }
    return res;    
}

vector<vector<int>> GetPassagesPathPasses(const vector<PolygonObstacle>& obstacles, 
                                        const vector<RRTStarNode*>& path) {
    // Raw, non-smoothed path is preferred for efficiency.
    vector<vector<int>> raw_passage_pairs;
    vector<Point2f> obs_centroids = GetObstaclesCentroids(obstacles);
    
    for (int i = 0; i < path.size() - 1; i++) 
        for (int j = 0; j < obs_centroids.size() - 1; j++) 
            for (int k = j + 1; k < obs_centroids.size(); k++) 
                if (SegmentIntersection(path[i]->pos, path[i + 1]->pos, obs_centroids[j], obs_centroids[k]) == true) 
                    raw_passage_pairs.push_back({j, k});
    // Filter invalid passages
    vector<vector<int>> physical_valid_passage_pairs = FilterRawPassagePairsByVisibility(obstacles, raw_passage_pairs);
    return FilterPassagePairsBySortedWidth(obstacles, physical_valid_passage_pairs);
}

vector<vector<Point2f>> GetPassageIntersectionsOfPathSet(const vector<PolygonObstacle>& obstacles, 
                                                        const vector<vector<int>>& passage_pairs,
                                                        const vector<Point2f>& smooth_pivot_path, 
                                                        vector<vector<int>>& path_node_intersection_idx_log,
                                                        const vector<Point2f>& initial_feedback_pts, 
                                                        int pivot_idx) {
    int pts_num = initial_feedback_pts.size();
    vector<vector<Point2f>> res(pts_num, vector<Point2f>(passage_pairs.size()));
    path_node_intersection_idx_log = vector<vector<int>>(pts_num, vector<int>(passage_pairs.size(), 0));
    vector<Point2f> obs_centroids = GetObstaclesCentroids(obstacles);

    for (int i = 0; i < pts_num; i++) {
        int path_node_idx = 0;
        Point2f pt_dif = initial_feedback_pts[i] - initial_feedback_pts[pivot_idx];
        for (int j = 0; j < passage_pairs.size(); j++) {
            // cout << ""Testing passage: "" << passage_pairs[j][0] << ""---"" << passage_pairs[j][1] << ""\n"";
            Point2f obs_centroid_1 = obs_centroids[passage_pairs[j][0]],
                    obs_centroid_2 = obs_centroids[passage_pairs[j][1]],
                    direction_obs_1_2 = (obs_centroid_2 - obs_centroid_1) / cv::norm(obs_centroid_2 - obs_centroid_1),
                    extended_obs_centroid_1 = obs_centroid_1 - 300 * direction_obs_1_2,
                    extended_obs_centroid_2 = obs_centroid_2 + 300 * direction_obs_1_2;
            // cout << ""Obstacle centroid 1: "" << obs_centroid_1 << "" Obstacle centroid 2: "" << obs_centroid_2 << ""\n"";
            // cout << ""Extended obstacle centroid 1: "" << extended_obs_centroid_1 << "" Extended obstacle centroid 2: "" << extended_obs_centroid_2 << ""\n"";
            for (int k = path_node_idx; k < smooth_pivot_path.size() - 1; k++) {
                if (SegmentIntersection(extended_obs_centroid_1, extended_obs_centroid_2, smooth_pivot_path[k] + pt_dif, smooth_pivot_path[k + 1] + pt_dif)) {
                    res[i][j] = GetSegmentsIntersectionPt(extended_obs_centroid_1, extended_obs_centroid_2, smooth_pivot_path[k] + pt_dif, smooth_pivot_path[k + 1] + pt_dif);
                    // cout << ""Intersection detected with point:\n"" << res[i][j] << '\n';
                    path_node_intersection_idx_log[i][j] = k;
                    // In theory, the same path segment can pass two or more passages, so do not use path_node_idx = k + 1.  
                    // Also, next intersection can be placed before the current one, simply setting path_node = 0 is ok. Here, locality search is used.
                    path_node_idx = (k - (int)smooth_pivot_path.size() / 5) < 0 ? 0 : k - (int)smooth_pivot_path.size() / 5; 
                    break;
                }
            }
        }
    }
    cout << ""Intersection pts of path set:\n"";
    for (auto pt_vec : res) {
        for (auto pt : pt_vec) 
            cout << pt << "", "";
        cout << ""\n"";
    }
    return res;
}

vector<Point2f> GetPivotPathRepositionPts(const vector<PolygonObstacle>& obstacles, 
                                        const vector<vector<int>>& passage_pairs, 
                                        const vector<vector<Point2f>>& intersection_points, 
                                        int pivot_idx) {
    vector<Point2f> chord_ends, passage_inner_ends, res(passage_pairs.size());
    vector<Point2f> obs_centroids = GetObstaclesCentroids(obstacles);

    int pts_num = intersection_points.size();
    for (int i = 0; i < passage_pairs.size(); i++) {
        vector<Point2f> cur_passage_intersection_pts(pts_num);
        for (int j = 0; j < pts_num; j++)
            cur_passage_intersection_pts[j] = intersection_points[j][i];
        chord_ends = GetEndsOfColinearPts(cur_passage_intersection_pts);
        passage_inner_ends = GetPassageInnerEnds(obstacles[passage_pairs[i][0]], obstacles[passage_pairs[i][1]]);
/*         cout << ""Passage inner ends:\n""
             << passage_inner_ends[0] << ""-"" << passage_inner_ends[1] << '\n';
        cout << ""Chord ends:\n""
             << chord_ends[0] << ""-"" << chord_ends[1] << '\n';
        cout << ""Passage intersection point:\n""
             << cur_passage_intersection_pts[pivot_idx] << '\n'; */

        Point2f reposition_intersection_pt;
        if (normSqr(chord_ends[1] - chord_ends[0]) < normSqr(passage_inner_ends[1] - passage_inner_ends[0])
            && OnSegment(passage_inner_ends[0], passage_inner_ends[1], chord_ends[0])
            && OnSegment(passage_inner_ends[0], passage_inner_ends[1], chord_ends[1])) {
                // cout << ""case 1\n"";
                res[i] = cur_passage_intersection_pts[pivot_idx];
                continue;
            }
        else if (normSqr(chord_ends[1] - chord_ends[0]) < normSqr(passage_inner_ends[1] - passage_inner_ends[0])) {
            if (OnSegment(passage_inner_ends[0], passage_inner_ends[1], chord_ends[0])) {
                if (normSqr(passage_inner_ends[0] - chord_ends[1]) <= normSqr(passage_inner_ends[1] - chord_ends[1]))
                    reposition_intersection_pt = cur_passage_intersection_pts[pivot_idx] + 1.2 * (passage_inner_ends[0] - chord_ends[1]);
                else 
                    reposition_intersection_pt = cur_passage_intersection_pts[pivot_idx] + 1.2 * (passage_inner_ends[1] - chord_ends[1]);
            }
            else {
                if (normSqr(passage_inner_ends[0] - chord_ends[0]) <= normSqr(passage_inner_ends[1] - chord_ends[0]))
                    reposition_intersection_pt = cur_passage_intersection_pts[pivot_idx] + 1.2 * (passage_inner_ends[0] - chord_ends[0]);
                else 
                    reposition_intersection_pt = cur_passage_intersection_pts[pivot_idx] + 1.2 * (passage_inner_ends[1] - chord_ends[0]);                
            }
            // cout << ""Reposition intersection point:\n"" 
            //      << reposition_intersection_pt << '\n';
            res[i] = reposition_intersection_pt;
            continue;
        }
        
        Point2f chord_center = (chord_ends[0] + chord_ends[1]) / 2,
                passage_inner_center = (passage_inner_ends[0] + passage_inner_ends[1]) / 2,
                chord_to_passage_center_dif = passage_inner_center - chord_center,
                pivot_path_intersection_pt = cur_passage_intersection_pts[pivot_idx];
        reposition_intersection_pt = pivot_path_intersection_pt + chord_to_passage_center_dif;
        if (OnSegment(passage_inner_ends[0], passage_inner_ends[1], reposition_intersection_pt) == false) {
            if (normSqr(reposition_intersection_pt - passage_inner_ends[0]) <= normSqr(reposition_intersection_pt - passage_inner_ends[1]))
                reposition_intersection_pt = passage_inner_ends[0] + 0.2 * (passage_inner_ends[1] - passage_inner_ends[0]);
            else 
                reposition_intersection_pt = passage_inner_ends[1] + 0.2 * (passage_inner_ends[0] - passage_inner_ends[1]);
        }
        // cout << ""Reposition intersection point:\n"" 
        //         << reposition_intersection_pt << '\n';        
        res[i] = reposition_intersection_pt;
    }
    return res;
}

vector<vector<Point2f>> AdjustRepositionPtsForPathSet(const vector<PolygonObstacle>& obstacles, 
                                                    const vector<vector<int>>& passage_pairs,
                                                    const vector<vector<Point2f>>& path_set_intersection_pts,
                                                    int pivot_idx) {
    vector<vector<Point2f>> res = path_set_intersection_pts;
    int pts_num = res.size();
    vector<Point2f> chord_ends, passage_inner_ends;
    for (int i = 0; i < passage_pairs.size(); i++) {
        vector<Point2f> cur_passage_intersection_pts(pts_num);
        for (int j = 0; j < pts_num; j++)
            cur_passage_intersection_pts[j] = res[j][i];
        chord_ends = GetEndsOfColinearPts(cur_passage_intersection_pts);
        passage_inner_ends = GetPassageInnerEnds(obstacles[passage_pairs[i][0]], obstacles[passage_pairs[i][1]]); 
        
        if (OnSegment(passage_inner_ends[0], passage_inner_ends[1], chord_ends[0])
            && OnSegment(passage_inner_ends[0], passage_inner_ends[1], chord_ends[1])) {
                continue;
            }
        
        Point2f passage_direction_1 = passage_inner_ends[0] - res[pivot_idx][i],
                passage_direction_2 = passage_inner_ends[1] - res[pivot_idx][i];
        float safety_interior_distance = 15,
              interior_distance_1 = cv::norm(passage_direction_1),
              interior_distance_2 = cv::norm(passage_direction_2),
              max_dif_length_1 = 1e-5,
              max_dif_length_2 = 1e-5;
        if (interior_distance_1 > safety_interior_distance)
            interior_distance_1 -= safety_interior_distance;
        if (interior_distance_2 > safety_interior_distance)
            interior_distance_2 -= safety_interior_distance;
            
        for (int j = 0; j < pts_num; j++) {
            if (j == pivot_idx)
                continue;
            Point2f intersection_pt_dif = res[j][i] - res[pivot_idx][i];
            if (passage_direction_1.dot(intersection_pt_dif) > 0) {
                max_dif_length_1 = max(max_dif_length_1, (float)cv::norm(intersection_pt_dif));
            }
            else {
                max_dif_length_2 = max(max_dif_length_2, (float)cv::norm(intersection_pt_dif));
            }
        }
        float compression_ritio = min(interior_distance_1 / max_dif_length_1, interior_distance_2 / max_dif_length_2);
        for (int j = 0; j < pts_num; j++) {
            if (j == pivot_idx)
                continue;
            // cout << ""Original intersection pt: "" << res[j][i] << "" "";
            res[j][i] = res[pivot_idx][i] + (res[j][i] - res[pivot_idx][i]) * compression_ritio;
            // cout << ""Repositioned intersction pt: "" << res[j][i] << '\n';
        }
    }
    return res;
}

void DeformPath(vector<Point2f>& path, 
                const vector<Point2f>& intersection_pts, 
                const vector<Point2f>& reposition_intersection_pts, 
                vector<int> path_intersection_idx) {
    vector<float> accumulated_path_length(path.size(), 0);
    for (int i = 1; i < accumulated_path_length.size(); i++) {
        accumulated_path_length[i] = accumulated_path_length[i - 1] + cv::norm(path[i] - path[i - 1]);
    }
        
    vector<int> reposition_idx(path_intersection_idx.size() + 2, 0);
    reposition_idx.back() = path.size() - 1;
    for (int i = 0; i < path_intersection_idx.size(); i++)
        reposition_idx[i + 1] = path_intersection_idx[i];

    float total_path_length = accumulated_path_length.back();
    Point2f cur_shift, next_shift, pre_shift;
    for (int i = 0; i < reposition_idx.size() - 1; i++) {
        int cur_path_idx = reposition_idx[i], next_path_idx = reposition_idx[i + 1];
        float cur_path_length_parameter = accumulated_path_length[cur_path_idx] / total_path_length,
              next_path_length_parameter = accumulated_path_length[next_path_idx] / total_path_length,
              path_segment_length_parameter = next_path_length_parameter - cur_path_length_parameter;
        if (cur_path_idx == 0) 
            cur_shift = Point2f(0, 0);
        else
            cur_shift = reposition_intersection_pts[i - 1] - intersection_pts[i - 1];
        if (next_path_idx == path.size() - 1) 
            next_shift = Point2f(0, 0);
        else
            next_shift = reposition_intersection_pts[i] - intersection_pts[i];
        
        for (int j = cur_path_idx; j < next_path_idx; j++) {
            float path_length_parameter = accumulated_path_length[j] / total_path_length,
                  ratio = (path_length_parameter - cur_path_length_parameter) / path_segment_length_parameter;
            path[j] = path[j] + ratio * next_shift + (1 - ratio) * cur_shift;
            // cout << path_length_parameter << "", "" << ratio << "", "" << next_shift << "", "" << cur_shift << '\n';
        }
    }
}

void DeformPathWithTargetPt(vector<Point2f>& path, 
                            const vector<Point2f>& intersection_pts, 
                            const vector<Point2f>& reposition_intersection_pts, 
                            vector<int> path_intersection_idx) {
    vector<float> accumulated_path_length(path.size(), 0);
    for (int i = 1; i < accumulated_path_length.size(); i++) {
        accumulated_path_length[i] = accumulated_path_length[i - 1] + cv::norm(path[i] - path[i - 1]);
    }
        
    vector<int> reposition_idx(path_intersection_idx.size() + 2, 0);
    reposition_idx.back() = path.size() - 1;
    for (int i = 0; i < path_intersection_idx.size(); i++)
        reposition_idx[i + 1] = path_intersection_idx[i];

    float total_path_length = accumulated_path_length.back();
    Point2f cur_shift, next_shift, pre_shift;
    for (int i = 0; i < reposition_idx.size() - 1; i++) {
        int cur_path_idx = reposition_idx[i], next_path_idx = reposition_idx[i + 1];
        float cur_path_length_parameter = accumulated_path_length[cur_path_idx] / total_path_length,
              next_path_length_parameter = accumulated_path_length[next_path_idx] / total_path_length,
              path_segment_length_parameter = next_path_length_parameter - cur_path_length_parameter;
        if (cur_path_idx == 0) 
            cur_shift = Point2f(0, 0);
        else
            cur_shift = reposition_intersection_pts[i - 1] - intersection_pts[i - 1];
        // if (next_path_idx == path.size() - 1) 
        //   next_shift = Point2f(0, 0);
        // else
        next_shift = reposition_intersection_pts[i] - intersection_pts[i];
        
        for (int j = cur_path_idx; j < next_path_idx; j++) {
            float path_length_parameter = accumulated_path_length[j] / total_path_length,
                  ratio = (path_length_parameter - cur_path_length_parameter) / path_segment_length_parameter;
            path[j] = path[j] + ratio * next_shift + (1 - ratio) * cur_shift;
            // cout << path_length_parameter << "", "" << ratio << "", "" << next_shift << "", "" << cur_shift << '\n';
        }
    }
    path.back() = reposition_intersection_pts.back();
}

vector<vector<Point2f>> GeneratePathSetInGeneralCondition(const vector<Point2f>& initial_feedback_pts, 
                                                          const vector<Point2f>& target_feedback_pts, 
                                                          int pivot_idx,
                                                          float feedback_pts_radius,
                                                          const vector<PolygonObstacle>& obs,
                                                          Mat source_img) {
    // vector<vector<Point2f>> res_path_set(initial_feedback_pts.size());   

    RRTStarPlanner planner(initial_feedback_pts[pivot_idx], target_feedback_pts[pivot_idx], obs, 25);
    bool plan_success = planner.Plan(source_img, feedback_pts_radius, true);
    if (!plan_success) {
        cout << ""Path planning failed! An empty path set is reutrned.\n"";
        return {};
    }

    vector<RRTStarNode*> pivot_path = planner.GetPath();
    vector<RRTStarNode*> sparse_pivot_path;
    for (int i = 0; i < pivot_path.size(); i += 1)
        sparse_pivot_path.push_back(pivot_path[i]);
    if (sparse_pivot_path.back() != pivot_path.back())
        sparse_pivot_path.push_back(pivot_path.back());
    vector<Point2f> smooth_pivot_path = QuadraticBSplineSmoothing(sparse_pivot_path);

    vector<vector<int>> passage_passed = GetPassagesPathPasses(obs, pivot_path);
    vector<vector<int>> intersection_idx; 
    vector<vector<Point2f>> passage_intersection_pts = GetPassageIntersectionsOfPathSet(obs, passage_passed, smooth_pivot_path, intersection_idx, initial_feedback_pts, pivot_idx);
    vector<Point2f> reposition_points = GetPivotPathRepositionPts(obs, passage_passed, passage_intersection_pts, pivot_idx);
    DeformPath(smooth_pivot_path, passage_intersection_pts[pivot_idx], reposition_points, intersection_idx[pivot_idx]); 

    passage_intersection_pts = GetPassageIntersectionsOfPathSet(obs, passage_passed, smooth_pivot_path, intersection_idx, initial_feedback_pts, pivot_idx);
    vector<vector<Point2f>> adjusted_passage_intersection_pts = AdjustRepositionPtsForPathSet(obs, passage_passed, passage_intersection_pts, pivot_idx);

    vector<vector<Point2f>> res_path_set(initial_feedback_pts.size(), smooth_pivot_path);
    for (int i = 0; i < initial_feedback_pts.size(); i++) {
        if (i == pivot_idx) 
            continue;
        for (Point2f& path_node : res_path_set[i])
            path_node += initial_feedback_pts[i] - initial_feedback_pts[pivot_idx];

        passage_intersection_pts[i].push_back(res_path_set[i].back());
        adjusted_passage_intersection_pts[i].push_back(target_feedback_pts[i]);
        DeformPathWithTargetPt(res_path_set[i], passage_intersection_pts[i], adjusted_passage_intersection_pts[i], intersection_idx[i]);
        //res_path_set[i].back() = target_feedback_pts[i];
    }    
    return res_path_set; 
}

/* Upgraded */
vector<int> RetrievePassedPassages(const vector<RRTStarNode*>& raw_pivot_path, const vector<vector<Point2f>>& passage_pts) {
    vector<int> res;
    for (int path_node_idx = 0; path_node_idx < raw_pivot_path.size() - 1; path_node_idx++) {
        for (int passage_idx = 0; passage_idx < passage_pts.size(); passage_idx++) {
            if (SegmentIntersection(raw_pivot_path[path_node_idx]->pos, raw_pivot_path[path_node_idx + 1]->pos, 
                                    passage_pts[passage_idx][0], passage_pts[passage_idx][1]))
            res.push_back(passage_idx);
        }
    }
    return res;
}

#endif",y_at_x_max
295,"#include <iostream>  // Biblioteca para entrada y salida en C++.
#include <vector>    // Biblioteca para manejar vectores dinámicos en C++.

// Función que calcula la suma de los elementos de un vector.
// Parámetros:
// - const std::vector<int>& array: Usamos una referencia constante para evitar copias innecesarias y asegurar que el vector
// no se modifique. Retorno:
// - La suma de los elementos del vector como un entero.

// Declaración de la plantilla genérica
template<typename T>  // T es un parámetro genérico que representa cualquier tipo de dato.
T sumArray(const std::vector<T>& array)
{
  T sum = 0;  // Inicializamos la variable 'sum' en 0 para acumular la suma.

  // Usamos un bucle basado en rango (introducido en C++11) para recorrer el vector.
  // Ventaja: Es más legible y elimina la necesidad de manejar índices manualmente.
  for (T num : array)
  {
    sum += num;  // Añadimos cada elemento del vector a 'sum'.
  }
  return sum;  // Devolvemos el resultado final.
}

int main()
{
  // Usamos std::vector<int> para un ejemplo con enteros
  std::vector<int> intArray = { 10, 20, 30, 40, 50 };

  // Usamos std::vector<double> para un ejemplo con decimales
  std::vector<double> doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };

  // Llamamos a la función genérica para calcular la suma de ambos vectores
  int  [MASK]  = sumArray(intArray);           // Suma de enteros
  double doubleSum = sumArray(doubleArray);  // Suma de decimales

  // Mostramos los resultados
  std::cout << ""Suma de enteros: "" <<  [MASK]  << std::endl;
  std::cout << ""Suma de decimales: "" << doubleSum << std::endl;
  std::cout << ""Salida JJ"" << std::endl;
  return 0;
}",intSum
296,"#include ""gameobjects.hpp""


std::vector<Sprite> sprites;
u8 spriteIdIndex = 0;

u8 getSpriteId(){
    spriteIdIndex++;
    return spriteIdIndex;
}


EventBinding::EventBinding(std::string ctgry, voidFunction func){
    stateType = ctgry;
    callable = func;
};


InputManager::InputManager(){
    keyMaps.push_back(std::make_tuple(KEY_UP, KEY_HELD, EVENT_UP));
    keyMaps.push_back(std::make_tuple(KEY_DOWN, KEY_HELD, EVENT_DOWN));
    keyMaps.push_back(std::make_tuple(KEY_RIGHT, KEY_HELD, EVENT_RIGHT));
    keyMaps.push_back(std::make_tuple(KEY_LEFT, KEY_HELD, EVENT_LEFT));
    keyMaps.push_back(std::make_tuple(KEY_START, KEY_PRESS, EVENT_PAUSE));
};


void InputManager::registerBinding(std::string eventName, std::string stateType, voidFunction func){
    bindings[eventName].push_back(EventBinding(stateType, func));
};

void InputManager::pollInput(){
    scanKeys();
    u16 heldKeys = keysHeld();
    u16 pressedKeys = keysDown();

    for (u8 i = 0; i < keyMaps.size(); i++){
        u8 keyCode = std::get<0>(keyMaps[i]);
        std::string keyAction = std::get<1>(keyMaps[i]);
        std::string eventKey = std::get<2>(keyMaps[i]);

        if (keyAction == KEY_HELD && (! (heldKeys & keyCode))){
            continue;
        }

        if (keyAction == KEY_PRESS && (! (pressedKeys & keyCode))){
            continue;
        }

        std::vector<EventBinding> allBindings = bindings.find(eventKey)->second;
        std::vector<EventBinding> activeBindings;

        for (u8 i=0; i < allBindings.size(); i++){
            if (state != allBindings[i].stateType){
               continue;
            }

            activeBindings.push_back(allBindings[i]);
        }


        for (u8 i=0; i < activeBindings.size(); i++){
            activeBindings[i].callable();
        }
    }
}


void InputManager::pause(){
    state = GAME_PAUSED;
};


void InputManager::unpause(){
    state = GAME_RUNNING;
};

AnimationFrame::AnimationFrame(u8 tile, u8 length){
    tileOffset = tile;
    duration = length;
}

Animation::Animation(){};

Animation::Animation(u16  [MASK] ){
    baseTile =  [MASK] ;
    frame = 0;
    tileSetOffset=0;
};

void Animation::tick(){
    frame ++;
}


AnimationFrame Animation::currentFrame(){
    u8 frameIndex = 0;
    u8 cumulativeFrames = 0;

    for(u8 i = 0; i <= frames.size(); i++){
        if (i == frames.size()){
            frame = 0;
            frameIndex = 0;
            break;
        }

        cumulativeFrames += frames[i].duration;

        if (frame < cumulativeFrames){
            frameIndex = i;
            break;
        }
    }

    return frames[frameIndex];
};


u16 Animation::tile(){
    return baseTile + tileSetOffset + (currentFrame().tileOffset * 4);
}


Sprite::Sprite(){
    spriteId = getSpriteId();
};

Sprite::Sprite(OBJATTR* oamRef, u8 xPos, u8 yPos){
    oam = oamRef;
    x = xPos;
    y = yPos;
    spriteId = getSpriteId();
};

void Sprite::draw(){
    // TODO: Implement width and height for different sized sprites

    oam->attr0 = OBJ_16_COLOR | ATTR0_SQUARE | OBJ_Y(y);
    oam->attr1 = ATTR1_SIZE_16 | OBJ_X(x);
    oam->attr2 = animation.tile() | ATTR2_PALETTE(0);

    if (animation.flip){
        oam->attr1 |= OBJ_HFLIP;
    }
};

void Sprite::update(){
    animation.tick();
};

void Sprite::faceNorth(){
    animation.tileSetOffset = 24;
    animation.flip = false;

    if (!checkCollision(x, y- 1 )){
       y = max(y - 1, 0);
    }
};

void Sprite::faceSouth(){
    animation.tileSetOffset = 0;
    animation.flip = false;

    if (!checkCollision(x, y + 1)){
        y = min(y + 1, SCREEN_HEIGHT - 16);    
    }
};

void Sprite::faceEast(){
    animation.tileSetOffset = 12;
    animation.flip = true;

    if (!checkCollision(x + 1, y)){
        x = min(x + 1, SCREEN_WIDTH - 16);    
    }
};

void Sprite::faceWest(){
    animation.tileSetOffset = 12;
    animation.flip = false;

    if (!checkCollision(x - 1, y)){
        x = max(x - 1, 0);
    }
};

bool Sprite::checkCollision(int x, int y){
    bool collision = false;

    for (u8 i = 0; i < sprites.size(); i++) {
        Sprite other = sprites[i];

        if (spriteId == other.spriteId){
            continue;
        }

        // TODO: Change so that min and max for x and y are methods on the Sprite object
        int a_min_x = x; 
        int a_max_x = x + 16;
        int a_min_y = y;
        int a_max_y = y + 16;

        int b_min_x = other.x;
        int b_max_x = other.x + 16;
        int b_min_y = other.y;
        int b_max_y = other.y + 16;


        bool doesNotIntersect = (a_max_x < b_min_x) || (b_max_x < a_min_x) || (a_max_y < b_min_y) || (b_max_y < a_min_y);
        collision = collision || !doesNotIntersect;
    }

    return collision;
}


void registerInputBindings(InputManager* eventManager, Sprite* player){
    eventManager->registerBinding(EVENT_UP, GAME_RUNNING, std::bind(&Sprite::faceNorth, player));
    eventManager->registerBinding(EVENT_DOWN, GAME_RUNNING, std::bind(&Sprite::faceSouth, player));
    eventManager->registerBinding(EVENT_LEFT, GAME_RUNNING, std::bind(&Sprite::faceWest, player));
    eventManager->registerBinding(EVENT_RIGHT, GAME_RUNNING, std::bind(&Sprite::faceEast, player));

    eventManager->registerBinding(EVENT_PAUSE, GAME_PAUSED, std::bind(&InputManager::unpause, eventManager));
    eventManager->registerBinding(EVENT_PAUSE, GAME_RUNNING, std::bind(&InputManager::pause, eventManager));
}


",baseTileValue
297,"#include ""kss2-bios.h""

#include ""string.h""

#include ""../common.h""

#define FILL_VALUE(parent, childName, dest, minVal, maxVal)                                   \
    {                                                                                         \
        int a = atoi(dxml_child(parent, childName)                                            \
                         ->txt);                                                              \
        if (!(a >= minVal && a <= maxVal))                                                    \
            printf(""Invalid value for child %s of %s. It should've been between %d and %d\n"", \
                   childName, parent->name, minVal, maxVal);                                  \
        else                                                                                  \
            dest = a;                                                                         \
    }

#define FILL_VALUE_2(parent, childNameNoStr, dest, minVal, maxVal)                            \
    {                                                                                         \
        int a = atoi(dxml_child(parent, #childNameNoStr)                                      \
                         ->txt);                                                              \
        if (!(a >= minVal && a <= maxVal))                                                    \
            printf(""Invalid value for child %s of %s. It should've been between %d and %d\n"", \
                   #childNameNoStr,                                                           \
                   parent->name, minVal, maxVal);                                             \
        else                                                                                  \
            dest.childNameNoStr = a;                                                          \
    }

namespace kss2_bios
{

auto load(const char *filename,
          SBios_Dinamic &bios_dyn,
          SRestart &restart,
          S_various_flegs &vf) -> int
{

    dxml_t file = dxml_open(filename);

    dxml_t kssBios = dxml_child(file, ""KSS_BIOS"");

    auto &sbd = bios_dyn.proc;

    FILL_VALUE(kssBios, ""mod"", sbd.mod, 0, 3);
    FILL_VALUE(kssBios, ""cord_loc"", sbd.koord_lok, 0, 1);
    FILL_VALUE(kssBios, ""fors_table"", sbd.fors_tab, 0, 1);
    FILL_VALUE(kssBios, ""vh_fl"", sbd.v_trep, 0, 1);
    FILL_VALUE(kssBios, ""pd_fl"", sbd.p_trep, 0, 1);
    FILL_VALUE(kssBios, ""adaptive"", sbd.detektor, 0, 1);
    FILL_VALUE(kssBios, ""stages"", sbd.najava, 0, 1);

    dxml_t knfMode = dxml_child(file, ""KNF_MODE"");

    // Now knf_mode is being loaded.
    /* It is very important that elements of c and xml 
     structures have same names */
    auto &km = bios_dyn.knfl.km;
    FILL_VALUE_2(knfMode, pg1, km, 0, 3);
    FILL_VALUE_2(knfMode, pg2, km, 0, 3);
    FILL_VALUE_2(knfMode, pg3, km, 0, 3);
    FILL_VALUE_2(knfMode, pg4, km, 0, 3);
    FILL_VALUE_2(knfMode, vpg1, km, 0, 1);
    FILL_VALUE_2(knfMode, vpg2, km, 0, 1);
    FILL_VALUE_2(knfMode, vpg3, km, 0, 1);
    FILL_VALUE_2(knfMode, vpg4, km, 0, 1);
    FILL_VALUE_2(knfMode, glm, km, 0, 3);
    FILL_VALUE_2(knfMode, glt, km, 0, 1);
    FILL_VALUE_2(knfMode, fl, km, 0, 1);

    dxml_t variosFlags = dxml_child(file, ""VARIOUS_FLAGS"");

    // for (dxml_t c = variosFlags->child; c; c = c->sibling)
    //     printf(""%s\n"", c->name);

    FILL_VALUE(variosFlags, ""CD_demoONOFF"", vf.CD_demoONOFF_flag, 0, 3);
    FILL_VALUE(variosFlags, ""setUPDW"", vf.setUPDW_flag, 0, 3);
    FILL_VALUE(variosFlags, ""RTCold"", vf.RTCold_flag, 0, 3);
    FILL_VALUE(variosFlags, ""Logger_ONOFF"", vf.Logger_ONOFF, 0, 3);
    FILL_VALUE(variosFlags, ""reserved1"", vf.reserved1, 0, 3);
    FILL_VALUE(variosFlags, ""reserved4"", vf.reserved4, 0, 3);
    FILL_VALUE(variosFlags, ""reserved2"", vf.reserved2, 0, 3);
    FILL_VALUE(variosFlags, ""reserved3"", vf.reserved3, 0, 3);

    dxml_t restartd = dxml_child(file, ""RESART"");

    //Next two lines should be checked
    FILL_VALUE(restartd, ""nrof_restarts"", restart.no, 0, 3);

    FILL_VALUE(restartd, ""wait_for_restart"", restart.time, 0, 63);

    dxml_free(file);
    return 0;
}

auto num_to_str(const int num, const size_t size) -> char *
{
    auto buffer = new char[size + 1];
    memset(buffer, 0, size + 1);
    snprintf(buffer, size + 1, ""%d"", num);
    return buffer;
}

#define DXML_SET_TXT(a, b)  \
    {                       \
        auto d = a;         \
        auto e = b;         \
        dxml_set_txt(d, e); \
    }

auto save(const char *filename,
          const SBios_Dinamic &bios_dyn,
          const SRestart &restart,
          const S_various_flegs &vf) -> int
{
    auto root = dxml_new(""KSS_BIOS_DATA"");
    create_children(root, ""KSS_BIOS"", ""KNF_MODE"", ""VARIOUS_FLAGS"", ""RESART"");

    auto kss_bios = dxml_child(root, ""KSS_BIOS"");
    auto knf_mode = dxml_child(root, ""KNF_MODE"");
    auto var_flags = dxml_child(root, ""VARIOUS_FLAGS"");
    auto  [MASK]  = dxml_child(root, ""RESTART"");

    // filling up kss_bios
    create_children(kss_bios, ""mod"", ""cord_loc"", ""fors_table"", ""vh_fl"", ""pd_fl"", ""adaptive"", ""stages"");
    const auto &sbd = bios_dyn.proc;
    DXML_SET_TXT(dxml_child(kss_bios, ""mod""), num_to_str(sbd.mod, 1));
    DXML_SET_TXT(dxml_child(kss_bios, ""cord_loc""), num_to_str(sbd.koord_lok, 1));
    DXML_SET_TXT(dxml_child(kss_bios, ""fors_table""), num_to_str(sbd.fors_tab, 1));
    DXML_SET_TXT(dxml_child(kss_bios, ""vh_fl""), num_to_str(sbd.v_trep, 1));
    DXML_SET_TXT(dxml_child(kss_bios, ""pd_fl""), num_to_str(sbd.p_trep, 1));
    DXML_SET_TXT(dxml_child(kss_bios, ""adaptive""), num_to_str(sbd.detektor, 1));
    DXML_SET_TXT(dxml_child(kss_bios, ""stages""), num_to_str(sbd.najava, 1));

    // filling up knf_mode
    create_children(knf_mode, ""pg1"", ""pg2"", ""pg3"", ""pg4"",
                    ""vpg1"", ""vpg2"", ""vpg3"", ""vpg4"",
                    ""glm"", ""glt"", ""fl"");
    const auto &knf = bios_dyn.knfl.km;
    DXML_SET_TXT(dxml_child(knf_mode, ""pg1""), num_to_str(knf.pg1, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""pg2""), num_to_str(knf.pg2, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""pg3""), num_to_str(knf.pg3, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""pg4""), num_to_str(knf.pg4, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""vpg1""), num_to_str(knf.vpg1, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""vpg2""), num_to_str(knf.vpg2, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""vpg3""), num_to_str(knf.vpg3, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""vpg4""), num_to_str(knf.vpg4, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""glm""), num_to_str(knf.glm, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""glt""), num_to_str(knf.glt, 1));
    DXML_SET_TXT(dxml_child(knf_mode, ""fl""), num_to_str(knf.fl, 1));

    // filling up var_flags
    create_children(var_flags, ""CD_demoONOFF"", ""setUPDW"",
                    ""RTCold"", ""Logger_ONOFF"",
                    ""reserved1"", ""reserved2"",
                    ""reserved3"", ""reserved4"");
    DXML_SET_TXT(dxml_child(var_flags, ""CD_demoONOFF""), num_to_str(vf.CD_demoONOFF_flag, 1));
    DXML_SET_TXT(dxml_child(var_flags, ""setUPDW""), num_to_str(vf.setUPDW_flag, 1));
    DXML_SET_TXT(dxml_child(var_flags, ""RTCold""), num_to_str(vf.RTCold_flag, 1));
    DXML_SET_TXT(dxml_child(var_flags, ""Logger_ONOFF""), num_to_str(vf.Logger_ONOFF, 1));
    DXML_SET_TXT(dxml_child(var_flags, ""reserved1""), num_to_str(vf.reserved1, 1));
    DXML_SET_TXT(dxml_child(var_flags, ""reserved2""), num_to_str(vf.reserved2, 1));
    DXML_SET_TXT(dxml_child(var_flags, ""reserved3""), num_to_str(vf.reserved3, 1));
    DXML_SET_TXT(dxml_child(var_flags, ""reserved4""), num_to_str(vf.reserved4, 1));

    // filling up restart
    create_children( [MASK] , ""nrof_restarts"", ""wait_for_restart"");
    DXML_SET_TXT(dxml_child( [MASK] , ""nrof_restarts""), num_to_str(restart.no, 1));
    DXML_SET_TXT(dxml_child( [MASK] , ""wait_for_restart""), num_to_str(restart.time, 2));

    auto buffer = dxml_toxml(root);
    auto fp = fopen(filename, ""w"");
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fclose(fp);
    delete[] buffer;

    return 0;
}
} // namespace kss2_bios",restart_tag
298,"// Kinect_Depth.cpp : 定义控制台应用程序的入口点。
//

//#include ""windows.h""
#include ""stdafx.h""
#include ""NuiApi.h""						// Kinetc数据API
#include ""DepthBasics.h""				// 深度图像基础定义
#include ""Kinect_DepthData.h""			// 深度图像基础数据
#include <iostream>						// 数据流
#include <cmath>

using namespace std;

Data_Pixel Data_In_Pixel[480][640];		// 定义存放像素点信息的数组，有480行，680列
//Data_Pixel * ptrData_In_Pixel = (Data_Pixel*)Data_In_Pixel;
INuiCoordinateMapper* DepthCoordinate = nullptr;

BOOL CreateFirstConnected()
{
	INuiSensor * pNuiSensor = nullptr;
	HRESULT hr;

	int iSensorCount = 0;
	hr = NuiGetSensorCount(&iSensorCount);  // 获取连接的kinect数量
	cout << ""kinect num:"" << iSensorCount << endl;
	if (FAILED(hr))
	{
		m_pNuiSensor = pNuiSensor;
		return FALSE;
	}

	// Look at each Kinect sensor 对每个kinect进行初始化
	for (int i = 0; i < iSensorCount; ++i)
	{
		// Create the sensor so we can check status, if we can't create it, move on to the next
		// 获取kinect对象 
		hr = NuiCreateSensorByIndex(i, &pNuiSensor);
		if (FAILED(hr))
		{
			continue;
		}

		// Get the status of the sensor, and if connected, then we can initialize it
		// 查看kinect状态，有的设备没连接电源，也许有的设备有其他异常  
		hr = pNuiSensor->NuiStatus();
		if (S_OK == hr)		// 如果有一台正常的，那我们这个程序的初始化就算完毕了，因为这个例子只用一个kinect而已
		{
			m_pNuiSensor = pNuiSensor;
			cout << ""finding "" << i+1 << "" kinect waiting for connecting"" << endl;
			//break;
		}

		// This sensor wasn't OK, so release it since we're not using it 如果是不正常的设备，那么Release掉，免得内存泄露 
		pNuiSensor->Release();
	}

	if (NULL != m_pNuiSensor)  // 如果pNuiSensor不为空，那表明找到某一个正常的kinect设备了
	{
		// Initialize the Kinect and specify that we'll be using depth 初始化kinect，用NUI_INITIALIZE_FLAG_USES_DEPTH表示要使用深度图 
		hr = m_pNuiSensor->NuiInitialize(NUI_INITIALIZE_FLAG_USES_DEPTH);
		if (SUCCEEDED(hr))
		{
			HANDLE m_hNextDepthFrameEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
			
			// Open a depth image stream to receive depth frames  打开深度图流，用来接收图像 
			hr = m_pNuiSensor->NuiImageStreamOpen(
				NUI_IMAGE_TYPE_DEPTH,				// 表示要打开深度图流
				NUI_IMAGE_RESOLUTION_640x480,		// 深度图大小
				0,									// 帧设置，0表示无设置
				2,									// 缓存多少帧，最大为4
				m_hNextDepthFrameEvent,				// 用来通信的Event句柄
				&m_pDepthStreamHandle);				// 用来读取数据的流句柄，要从这里读取深度图数据
			
			cout << ""Successful connected with Kinect"" << endl;
			return TRUE;
		}
		else
		{
			cout << ""Failed connected with Kinect"" << endl;
		}
	}
	if (NULL == m_pNuiSensor || FAILED(hr))
	{
		cout << ""No ready Kinect found!"" << m_pNuiSensor << endl;
		return FALSE;
	}
	return SUCCEEDED(hr);
}

void ProcessDepth()
{
	HRESULT hr;
	NUI_IMAGE_FRAME imageFrame;

	// Attempt to get the depth frame
	// 通过kinect对象，从m_pDepthStreamHandle中获取图像数据，还记得m_pDepthStreamHandle么，是在初始化kinect设备时创建的深度图流  
	// 在这里调用这个代码的意义是：将一帧深度图，保存在imageFrame中
	hr = m_pNuiSensor->NuiImageStreamGetNextFrame(m_pDepthStreamHandle, 100, &imageFrame);
	if (FAILED(hr))
	{
		cout << ""Image getting failed"" << endl;
		return;
	}

	BOOL nearMode = false;
	INuiFrameTexture* pTexture;

	// Get the depth image pixel texture 通过imageFrame把数据转化成纹理 
	hr = m_pNuiSensor->NuiImageFrameGetDepthImagePixelFrameTexture(
		m_pDepthStreamHandle, &imageFrame, &nearMode, &pTexture);
	if (FAILED(hr))
	{
		goto ReleaseFrame;
	}

	NUI_LOCKED_RECT LockedRect;

	// Lock the frame data so the Kinect knows not to modify it while we're reading it 锁定数据
	pTexture->LockRect(0, &LockedRect, NULL, 0);

											// Make sure we've received valid data
	if (LockedRect.Pitch != 0)
	{
		int i = 0; 
		/*Vector4 *pSkeletonPoint[640*480];
		NUI_DEPTH_IMAGE_POINT *Data_In_Pixel[640*480];*/

		// Get the min and max reliable depth for the current frame
		int minDepth = (nearMode ? NUI_IMAGE_DEPTH_MINIMUM_NEAR_MODE : NUI_IMAGE_DEPTH_MINIMUM) >> NUI_IMAGE_PLAYER_INDEX_SHIFT;
		int maxDepth = (nearMode ? NUI_IMAGE_DEPTH_MAXIMUM_NEAR_MODE : NUI_IMAGE_DEPTH_MAXIMUM) >> NUI_IMAGE_PLAYER_INDEX_SHIFT;

		cout << ""minDepth："" << minDepth << ""   "" << ""maxDepth："" << maxDepth << endl;
		// 将m_depthRGBX的首地址保存在rgbrun，方便赋值
		BYTE * rgbrun = m_depthRGBX;

		NUI_DEPTH_IMAGE_PIXEL * pBufferRun = reinterpret_cast< NUI_DEPTH_IMAGE_PIXEL *>(LockedRect.pBits);  // 去掉了const声明

		const NUI_DEPTH_IMAGE_PIXEL * pBufferStart = pBufferRun;

		// end pixel is start + width*height - 1
		const NUI_DEPTH_IMAGE_PIXEL * pBufferEnd = pBufferRun + (cDepthWidth * cDepthHeight);

		 //对m_depthRGBX也就是rgbrun赋值
		while (pBufferRun < pBufferEnd)
		{
			// 定义像素点的位置信息
			int Index_Pixel = pBufferRun - pBufferStart;							// 明确像素点是第几个
			//cout << Index_Pixel << endl;

			// 第X行，第Y列的像素点
			int X_Pixel = Index_Pixel / cDepthWidth;
			int Y_Pixel = Index_Pixel % cDepthWidth ;
			//Data_In_Pixel[Index_Pixel]->x = X_Pixel; Data_In_Pixel[Index_Pixel]->y = Y_Pixel;		// 存入x,y的值
			
			// discard the portion of the depth that contains only the player index
			USHORT depth = pBufferRun->depth;
			
			Data_In_Pixel[X_Pixel][X_Pixel].Depth = depth;			// 保存深度值
			//ptrData_In_Pixel->Depth = depth;						// 保存深度值
			
			//hr = DepthCoordinate->MapDepthPointToSkeletonPoint(NUI_IMAGE_RESOLUTION_640x480, Data_In_Pixel[X_Pixel * 640 + Y_Pixel], pSkeletonPoint[X_Pixel * 640 + Y_Pixel]);
			////
			//if (S_OK == hr)
			//{
			//	cout << pSkeletonPoint[X_Pixel * 640 + Y_Pixel]->x << pSkeletonPoint[X_Pixel * 640 + Y_Pixel]->y << pSkeletonPoint[X_Pixel * 640 + Y_Pixel]->z << endl;
			//}

			// To convert to a byte, we're discarding the most-significant
			// rather than least-significant bits.
			// We're preserving detail, although the intensity will ""wrap.""
			// Values outside the reliable depth range are mapped to 0 (black).

			// Note: Using conditionals in this loop could degrade performance.
			// Consider using a lookup table instead when writing production code.
			BYTE intensity = static_cast<BYTE>(depth >= minDepth && depth <= maxDepth ? depth % 256 : 0);

			Data_In_Pixel[X_Pixel][Y_Pixel].intensity = intensity;	// 保存色素信息
			//ptrData_In_Pixel->Depth = intensity;

			//cout << X_Pixel << "" "" << Y_Pixel << "" "" << depth  << "" "" << int(intensity) << endl;
			//cout << depth << "" "" << intensity << endl;

			// Write out blue byte	写蓝色素位
			*(rgbrun++) = intensity;

			// Write out green byte 写绿色素位
			*(rgbrun++) = intensity;

			// Write out red byte   写红色素位
			*(rgbrun++) = intensity;

			// We're outputting BGR, the last byte in the 32 bits is unused so skip it
			// If we were outputting BGRA, we would write alpha here.
			++rgbrun;

			// Increment our index into the Kinect's depth buffer
			++pBufferRun;
		}
		//delete pSkeletonPoint;
		//delete Data_In_Pixel;
	}
	//cout << Data_In_Pixel[240][320].Depth << ""    "" << Data_In_Pixel[240][320].intensity << endl;  // 用来测试数据流是否正确
	// We're done with the texture so unlock it 解锁和释放纹理
	pTexture->UnlockRect(0);

	pTexture->Release();

ReleaseFrame:
	// Release the frame 释放帧
	m_pNuiSensor->NuiImageStreamReleaseFrame(m_pDepthStreamHandle, &imageFrame);
}

int main()
{
	bool  [MASK]  = CreateFirstConnected();		// 进行连接检测程序
	while ( [MASK] )										// while的循环条件可以用作控制
	{
		ProcessDepth();								// 完成主程序过程
	}
}
",connect_hr
299,"// BackgroundParser.cpp

// Implements the BackgroundParser class representing the background thread pool for parsing files / folders.





#include ""BackgroundParser.h""
#include <QThread>
#include <QDir>
#include <QDebug>
#include ""FileParser.h""





////////////////////////////////////////////////////////////////////////////////
/** Task executed inside BackgroundParser to parse a single file. */
class FileParseTask:
	public QRunnable
{
public:
	FileParseTask(BackgroundParser & a_BackgroundParser, const QString & a_FileName):
		m_FileName(a_FileName),
		m_BackgroundParser(a_BackgroundParser)
	{
	}


	virtual void run()
	{
		FileParser parser(m_BackgroundParser.m_ShouldAbort);
		QObject::connect(&parser, &FileParser::finishedParsingFile, &m_BackgroundParser, &BackgroundParser::finishedParsingFile);
		parser.parse(m_FileName);
	}


protected:

	QString m_FileName;
	BackgroundParser & m_BackgroundParser;
};





////////////////////////////////////////////////////////////////////////////////
/** Task executed inside BackgroundParser to parse a folder. */
class FolderParseTask:
	public QRunnable
{
public:
	FolderParseTask(BackgroundParser & a_BackgroundParser, const QString & a_FolderPath):
		m_FolderPath(a_FolderPath),
		m_BackgroundParser(a_BackgroundParser)
	{
	}


	virtual void run() override
	{
		addFolderLogFiles(m_FolderPath);
	}


	void addFolderLogFiles(const QString & a_FolderPath)
	{
		static QStringList  [MASK] ;
		if ( [MASK] .isEmpty())
		{
			 [MASK]  << ""*.log"" << ""*.gz"" << ""*.txt"";
		}

		QDir folder(a_FolderPath);
		QStringList res;
		for (const auto & fileName: folder.entryList( [MASK] , QDir::Files | QDir::Hidden | QDir::System))
		{
			m_BackgroundParser.addFile(a_FolderPath + ""/"" + fileName);
		}
		for (const auto & folderPath: folder.entryList(QStringList(), QDir::AllDirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System))
		{
			addFolderLogFiles(a_FolderPath + ""/"" + folderPath);
		}
	}


protected:

	QString m_FolderPath;
	BackgroundParser & m_BackgroundParser;
};





////////////////////////////////////////////////////////////////////////////////
// BackgroundParser:

BackgroundParser::BackgroundParser():
	Super(nullptr)
{
}





BackgroundParser::~BackgroundParser()
{
	qDebug() << ""Aborting all parsers"";
	m_ThreadPool.clear();
	m_ShouldAbort.store(true);
}





void BackgroundParser::addFile(const QString & a_FileName)
{
	m_ThreadPool.start(new FileParseTask(*this, a_FileName));
}





void BackgroundParser::addFolder(const QString & a_FolderPath)
{
	m_ThreadPool.start(new FolderParseTask(*this, a_FolderPath));
}
",logFileNameFilters
300,"#include ""bootloader.h""

using namespace bootloader::architecture;
namespace bootloader {

void Bootloader::run()
{
    m_metadataInterface.init();

    size_t  [MASK]  = selectImageSlot();
    // Update Metadata
    const GlobalImageMetadata* globalImageMetadata = m_metadataInterface.getGlobalImageMetadata();
    m_metadataInterface.updateCurrentImage( [MASK] );
    m_metadataInterface.updateGlobalBootcounter(globalImageMetadata->globalBootcounter + 1);
    m_metadataInterface.updateImageBootcounter(
        globalImageMetadata->images[ [MASK] ].bootcounter + 1,  [MASK] );

    m_metadataInterface.loadImage( [MASK] );

    // Start Image
    Disable_Interrupts();
    Move_Vector_Table();
    Enable_Interrupts();

    Trigger_Watchdog();

    Start_App();
}

size_t Bootloader::selectImageSlot()
{
    size_t preferredImage = m_metadataInterface.getGlobalImageMetadata()->preferredImage;
    if (isImageValid(preferredImage) && lastBootSuccessful(preferredImage)) {
        return preferredImage;
    }
    size_t lastImage = m_metadataInterface.getGlobalImageMetadata()->currentImage;
    if (isImageValid(lastImage) && lastBootSuccessful(lastImage)) {
        return lastImage;
    }

    return selectBestGuessImageSlot();
}

size_t Bootloader::selectBestGuessImageSlot()
{
    // Find image that is complete, has correct checksum and last boot was successful
    size_t currentImage = m_metadataInterface.getGlobalImageMetadata()->currentImage;
    for (size_t i = 0; i < MetadataInterface::getNumberOfImages(); i++) {
        size_t imageIndex = (currentImage + i) % MetadataInterface::getNumberOfImages();
        if (isImageValid(imageIndex) && lastBootSuccessful(imageIndex)) {
            return (currentImage + i) % MetadataInterface::getNumberOfImages();
        }
    }

    // Find image that is complete and has correct checksum (no matter if last boot was successful)
    for (size_t i = 0; i < MetadataInterface::getNumberOfImages(); i++) {
        size_t imageIndex = (currentImage + i) % MetadataInterface::getNumberOfImages();
        if (isImageValid(imageIndex)) {
            return imageIndex;
        }
    }

    // Otherwise only use round robin
    return (currentImage + 1) % MetadataInterface::getNumberOfImages();
}

bool Bootloader::isImageValid(size_t index)
{
    return m_metadataInterface.getGlobalImageMetadata()->images[index].completionStatus ==
               CompletionStatus::COMPLETE &&
           verifyChecksum(index);
}

bool Bootloader::lastBootSuccessful(size_t index)
{
    const GlobalImageMetadata* globalImageMetadata = m_metadataInterface.getGlobalImageMetadata();
    return globalImageMetadata->images[index].bootcounter ==
               globalImageMetadata->images[index].lastSuccessStatus ||
           globalImageMetadata->images[index].bootcounter ==
               globalImageMetadata->images[index].lastSuccessStatus + 1;
}

bool Bootloader::verifyChecksum(size_t index)
{
    return m_metadataInterface.verifyChecksum(index);
}

} // namespace bootloader
",selectedImage
301,"#include <iostream>
#include <string>

#include ""gms_matcher.h""
#include ""ORB_modify.h""
#include ""ORBextractor.h""
#include <opencv2/opencv.hpp>
#include ""opencv2/imgcodecs/legacy/constants_c.h""

using namespace std;
using namespace cv;
//extern double ORBextractor::ORBextractorDescriptorsTime;

//计算均匀度Uniformity
double ComputeUniformity(cv::Mat &img, std::vector<cv::KeyPoint> &keypoints)
{
    //******************************************************************均匀性计算
    int KPLeftNum = 0, KPRightNum = 0;              //左右部分的关键点数量
    int KPTopNum = 0, KPDownNum = 0;                //上下部分的关键点数量
    int KP_Right_Top_Num = 0, KP_Left_Down_Num = 0; //右上,左下部分的关键点数量
    int KP_Left_Top_Num = 0, KP_Right_Down_Num = 0; //左上，右下部分的关键点数量
   int KPCentreNum = 0, KPPeripheryNum = 0;        //中心，外围部分的关键点数量
//******************************************************************均匀性计算
//**********************************************************************************

    const int minBorderX = 0;
    const int minBorderY = 0;
    const int maxBorderX = img.cols;
    const int maxBorderY = img.rows;
//     cout << ""maxBorderX:"" << img.cols << endl;
//     cout << ""maxBorderY:"" << img.rows << endl;
//   cout << ""img.size:"" << img.size << endl;

//**********************************************************************************

    for (std::vector<cv::KeyPoint>::iterator vit = keypoints.begin(); vit != keypoints.end(); vit++)
    {

        //****************************左右*************************************//
        // line(img, Point((maxBorderX - minBorderX) / 2, 0), Point((maxBorderX - minBorderX) / 2, maxBorderY), 8);
        // imshow(""左右"", img);
        if ((*vit).pt.x <= (maxBorderX - minBorderX) / 2) //左半部分的特征点数量
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 255, 120), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            // waitKey(0);//敲键盘关图片，别直接×
            KPLeftNum++;
        }
        else //右半部分的特征点数量
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 0, 255), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            // waitKey(0);//敲键盘关图片，别直接×
            KPRightNum++;
        }

        //****************************上下*************************************//
        // line(img, Point(0, (maxBorderY - minBorderY) / 2), Point(maxBorderX, (maxBorderY - minBorderY) / 2), 8);
        // imshow(""上下"", img);
        if ((*vit).pt.y <= (maxBorderY - minBorderY) / 2) //上半部分的特征点数量
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 255, 120), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            KPTopNum++;
        }
        else //下半部分的特征点数量
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 0, 255), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            KPDownNum++;
        }
        
        //****************************右上左下*************************************//
        // line(img, Point(0, 0), Point(maxBorderX, maxBorderY), 8);
        // imshow(""右上左下"", img);
        if (((*vit).pt.y - maxBorderY) * (maxBorderX - minBorderX) -
            ((*vit).pt.x - maxBorderX) * (maxBorderY - minBorderY) >=
            0) //右上半部分的特征点数量
            //这是对角线方程 (y - y2)*(x1 - x2) - (x - x2)*(y1 - y2)
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 255, 120), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            KP_Right_Top_Num++;
        }
        else //左下半部分的特征点数量
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 0, 255), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            KP_Left_Down_Num++;
        }

        //****************************右下左上*************************************//
        // line(img, Point(maxBorderX, 0), Point(0, maxBorderY), 8);
        // imshow(""右下左上"", img);
        if (((*vit).pt.y - maxBorderY) * (maxBorderX - minBorderX) -
            ((*vit).pt.x - minBorderX) * (minBorderY - maxBorderY) >
            0) //左上半部分的特征点数量
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 255, 120), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            // waitKey(0);//敲键盘关图片，别直接×
            KP_Left_Top_Num++;
        }
        else //右下半部分的特征点数量
        {
            // circle(img,(*vit).pt, 3, Scalar(0, 0, 255), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            KP_Right_Down_Num++;
        }
//  不要中心外围这部分的数据,原因:不能平分面积
        //****************************中心外围*************************************//
        float X1 =     (maxBorderX - minBorderX) / 6 - 8; //中心框的坐标X1
        float X2 = 5 * (maxBorderX - minBorderX) / 6 + 8; //中心框的坐标X2
        float Y1 =     (maxBorderY - minBorderY) / 6 - 8; //中心框的坐标Y1
        float Y2 = 5 * (maxBorderY - minBorderY) / 6 + 8; //中心框的坐标Y2 

        // line(img, Point(X1, Y1), Point(X2, Y1), 8);
        // line(img, Point(X1, Y1), Point(X1, Y2), 8);
        // line(img, Point(X2, Y1), Point(X2, Y2), 8);
        // line(img, Point(X1, Y2), Point(X2, Y2), 8);

        // imshow(""中心外围"", img);
       if (((*vit).pt.x >= X1) & ((*vit).pt.x <= X2) & ((*vit).pt.y >= Y1) & ((*vit).pt.y <= Y2) )//中心部分的特征点数量
       {
            // circle(img,(*vit).pt, 3, Scalar(0, 255, 120), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            KPCentreNum++;
       }
       else //外围部分的特征点数量
       {
            // circle(img,(*vit).pt, 3, Scalar(0, 0, 255), -1);//画点，其实就是实心圆
            // imshow(""PointsinImage"", img);
            KPPeripheryNum++;
       }
    }
    //***********************************去除中心外围,共8个区域***********************************************
//     int sum_ =
//             KPLeftNum + KPRightNum + KPTopNum + KPDownNum + KP_Right_Top_Num + KP_Left_Down_Num + KP_Left_Top_Num +
//             KP_Right_Down_Num ;
//     double mean_ = sum_ / 8;
//     double Variance = (pow((KPLeftNum - mean_),2)  + pow((KPRightNum - mean_),2) +
//                        pow((KPTopNum - mean_),2) + pow((KPDownNum - mean_) ,2) +
//                        pow((KP_Right_Top_Num - mean_) ,2) + pow((KP_Left_Down_Num - mean_) ,2) +
//                        pow((KP_Left_Top_Num - mean_) ,2)+ pow((KP_Right_Down_Num - mean_) ,2)) /8;
//     double Uniformity =  101*log(Variance);
//    cout << ""左半部分的特征点数量:"" << KPLeftNum << endl;
//    cout << ""右半部分的特征点数量:"" << KPRightNum << endl;
//    cout << ""上半部分的特征点数量:"" << KPTopNum << endl;
//    cout << ""下半部分的特征点数量:"" << KPDownNum << endl;
//    cout << ""右上半部分的特征点数量:"" << KP_Right_Top_Num << endl;
//    cout << ""左下半部分的特征点数量:"" << KP_Left_Down_Num << endl;
//    cout << ""左上半部分的特征点数量:"" << KP_Left_Top_Num << endl;
//    cout << ""右下半部分的特征点数量:"" << KP_Right_Down_Num << endl;
//    cout << ""八个区域特征点数的平均值:"" << mean_ << endl;
//    cout << ""八个区域特征点数的方差:"" << Variance << endl;
//    cout << ""图像特征点均匀度:"" << Uniformity << endl;
//     cout << endl;
//     return Uniformity;
    //***********************************加上中心外围,共10个区域***********************************************

   int sum_ =
           KPLeftNum + KPRightNum + KPTopNum + KPDownNum + KP_Right_Top_Num + KP_Left_Down_Num + KP_Left_Top_Num +
           KP_Right_Down_Num + KPCentreNum + KPPeripheryNum;
   double mean_ = sum_ / 10; //约等于500
   double Variance = (pow((KPLeftNum - mean_),2)  + pow((KPRightNum - mean_),2) +
                      pow((KPTopNum - mean_),2) + pow((KPDownNum - mean_) ,2) +
                      pow((KP_Right_Top_Num - mean_) ,2) + pow((KP_Left_Down_Num - mean_) ,2) +
                      pow((KP_Left_Top_Num - mean_) ,2)+ pow((KP_Right_Down_Num - mean_) ,2)  +
                      pow((KPCentreNum - mean_) ,2) + pow((KPPeripheryNum - mean_) ,2) ) /10;
   double Uniformity =  101*log10(Variance);
//    cout << ""左半部分的特征点数量:"" << KPLeftNum << endl;
//    cout << ""右半部分的特征点数量:"" << KPRightNum << endl;
//    cout << ""上半部分的特征点数量:"" << KPTopNum << endl;
//    cout << ""下半部分的特征点数量:"" << KPDownNum << endl;
//    cout << ""右上半部分的特征点数量:"" << KP_Right_Top_Num << endl;
//    cout << ""左下半部分的特征点数量:"" << KP_Left_Down_Num << endl;
//    cout << ""左上半部分的特征点数量:"" << KP_Left_Top_Num << endl;
//    cout << ""右下半部分的特征点数量:"" << KP_Right_Down_Num << endl;
//    cout << ""中心部分的特征点数量:"" << KPCentreNum << endl;
//    cout << ""外围部分的特征点数量:"" << KPPeripheryNum << endl;
//    cout << ""十个区域特征点数的平均值:"" << mean_ << endl;
//    cout << ""十个区域特征点数的方差:"" << Variance << endl;
//    cout << ""图像特征点均匀度:"" << Uniformity << endl;
//    cout << endl;
    return Uniformity;
}
//**********************************************************************************
//计算RANSAC后的RMSE
double calculate_RANSAC_inliers_RMSE(Mat& img1, Mat& img2, 
                                    vector<DMatch> & all_matches, 
                                    std::vector<cv::KeyPoint>  & leftmvKeysUn,
                                    std::vector<cv::KeyPoint>  & rightmvKeysUn,string &Argv4)
{
// Take only the matched points that will be used to calculate the
    // transformation between both images
    // TODO:只取匹配的点，用于计算两个图像之间的转换
    std::vector<cv::Point2d> matched_pts1, matched_pts2;
    for (cv::DMatch _match_ : all_matches)// TODO:不用描述子距离判断all_matches_filter
    {
        matched_pts1.push_back(leftmvKeysUn[_match_.queryIdx].pt);
        matched_pts2.push_back(rightmvKeysUn[_match_.trainIdx].pt);
    }
    // Find the homography that transforms a point in the first image to a point in the second image.
    cv::Mat inliers;
    cv::Mat H = cv::findHomography(matched_pts1, matched_pts2, cv::RANSAC, 3, inliers);
    // Print the number of inliers, that is, the number of points correctly
    // mapped by the transformation that we have estimated
    std::cout << ""RANSAC去除错误匹配后的内点数: "" << cv::sum(inliers)[0]
              << "" ( 精度:"" << (100.0f * cv::sum(inliers)[0] / all_matches.size()) << ""% )"" << std::endl;//cv::sum(inliers)[0] / all_matches.size())
//    cout<< ""H："" <<  H <<endl;
    const double h11 = H.at<double>(0,0);
    const double h12 = H.at<double>(0,1);
    const double h13 = H.at<double>(0,2);
    const double h21 = H.at<double>(1,0);
    const double h22 = H.at<double>(1,1);
    const double h23 = H.at<double>(1,2);
    const double h31 = H.at<double>(2,0);
    const double h32 = H.at<double>(2,1);
    const double h33 = H.at<double>(2,2);
//        const float h11 = 1.0107879e+00;
//        const float h12 = 8.2814684e-03;
//        const float h13 = 1.8576800e+01;
//        const float h21 = -4.9128885e-03;
//        const float h22 = 1.0148779e+00 ;
//        const float h23 = -2.8851517e+01;
//        const float h31 = -1.9166087e-06;
//        const float h32 = 8.1537620e-06 ;
//        const float h33 = 1.0000000e+00;

    vector<DMatch> optimizeM;
    for(int i = 0; i < inliers.rows; i++)
    {
        if(inliers.at<bool>(i,0))
        {
            optimizeM.push_back(all_matches[i]);// TODO:不用描述子距离判断all_matches_filter
        }
    }

    std::vector<cv::Point2d>  [MASK] , matched_pts4;
    for (cv::DMatch matc1 : optimizeM)
    {
         [MASK] .push_back(leftmvKeysUn[matc1.queryIdx].pt);
        matched_pts4.push_back(rightmvKeysUn[matc1.trainIdx].pt);
    }
    Mat result2;
    drawMatches(img1, leftmvKeysUn, img2, rightmvKeysUn, optimizeM, result2, Scalar(0, 255, 0), Scalar::all(-1));//Scalar::all(-1)

    imwrite(""./result/ORB_RANSAC_matcher_""+Argv4+"".png"", result2);
    // imshow(""ORB_RANSAC_matcher"", result2);

    std::vector<Point2d> matched_pts2_ture_H;
//  ""[x',y',1] "" <<  H*[x,y,1]
    for (std::vector<cv::Point2d>::iterator vit =  [MASK] .begin(); vit !=  [MASK] .end(); vit++)
    {

        double x1 = (*vit).x;//左图匹配的特征点的x坐标
        double y1 = (*vit).y;//左图匹配的特征点的y坐标
        // Reprojection error in second image
        // x1in2 = H21*x1
        Point2d temp;
        temp.x =(h11*x1 + h12*y1 + h13)/(h31*x1 + h32*y1 + h33);//左图匹配的特征点的x坐标 经过单应矩阵H  变换到右图的x坐标
        temp.y =(h21*x1 + h22*y1 + h23)/(h31*x1 + h32*y1 + h33);//左图匹配的特征点的y坐标 经过单应矩阵H  变换到右图的y坐标
        matched_pts2_ture_H.push_back(temp);
    }

    std::vector<cv::Point2d>::iterator vit = matched_pts2_ture_H.begin();
    std::vector<cv::Point2d>::iterator vit2 = matched_pts4.begin();

    double fsum=0,RMSE=0;
    int sum=0;
    while(vit != matched_pts2_ture_H.end())
    {
//        cout<< ""vit "" <<  (*vit) <<endl;//左图匹配的点坐标[x1,y1]经过单应矩阵H变换到右图的点坐标[x2,y2]
//        cout<< ""vit2 "" <<  (*vit2) <<endl;//测量值
        fsum += pow(((*vit).x-(*vit2).x),2) + pow(((*vit).y-(*vit2).y),2);
        vit++;
        vit2++;
        sum++;
    }
    RMSE = sqrt(fsum/matched_pts4.size());
    cout<< ""RANSAC去除错误匹配后,配对点(内点)的均方根误差RMSE: "" <<  RMSE <<endl;
    cout<<endl;
    return  RMSE;
}

int main(int argc, char **argv)
{
    if (argc != 5)
    {
        cout << ""usage: ./orb_matcher path_to_settings path_to_image1 path_to_image2 oxford1x"" << endl;
        return 1;
    }
    cout<<""***********************************************************"";
    cout<<argv[4]<<endl;
    string Argv4;
    Argv4 =argv[4];
    // Check settings file
    const string strSettingsFile = argv[1];
    cv::FileStorage fsSettings(strSettingsFile.c_str(), cv::FileStorage::READ);
    if (!fsSettings.isOpened())
    {
        cerr << ""Failed to open settings file at: "" << strSettingsFile << endl;
        exit(-1);
    }

    cv::Mat img1 = imread(argv[2], CV_LOAD_IMAGE_COLOR);
    cv::Mat img2 = imread(argv[3], CV_LOAD_IMAGE_COLOR);

    ORB_modify ORB_left(strSettingsFile);  //读取yaml文件
    ORB_modify ORB_right(strSettingsFile); //读取yaml文件
    ORB_left.ORB_feature(img1);            //提取左图特征  因为不是TUM2数据集,所以其他图片不要用mvKeysUn这个,用未矫正的mvKeys!!!!!
    ORB_right.ORB_feature(img2);           //提取右图特征  因为不是TUM2数据集,所以其他图片不要用mvKeysUn这个,用未矫正的mvKeys!!!!!

    Mat img1_ORB_feature;
    Mat img2_ORB_feature;


    drawKeypoints(img1, ORB_left.mvKeys, img1_ORB_feature, cv::Scalar(0, 255, 0), cv::DrawMatchesFlags::DEFAULT);
    drawKeypoints(img2, ORB_right.mvKeys, img2_ORB_feature, cv::Scalar(0, 255, 0), cv::DrawMatchesFlags::DEFAULT);

    // cv::imshow(""img1_ORB_feature"", img1_ORB_feature);//不显示图片的特征点
    // cv::imwrite(""./result/img1_ORB_feature.png"", img1_ORB_feature);//不保存图片的特征点
//    cout << ""img1 Get total "" << ORB_left.mvKeys.size() << "" keypoints."" << endl;

    // cv::imshow(""img2_ORB_feature"", img2_ORB_feature);//不显示图片的特征点
    // cv::imwrite(""./result/img2_ORB_feature.png"", img2_ORB_feature);//不保存图片的特征点
//    cout << ""img2 Get total "" << ORB_right.mvKeys.size() << "" keypoints."" << endl;

//***************************调用特征点均匀度函数ComputeUniformity*************************************************
//   cvtColor(img1,img1,CV_RGB2GRAY);
//   cvtColor(img2,img2,CV_RGB2GRAY);
    double leftUniformity = ComputeUniformity(img1, ORB_left.mvKeys);
    double rightUniformity = ComputeUniformity(img2, ORB_right.mvKeys);
    cout << ""左图特征点均匀度:  ""<< leftUniformity  << endl;
    cout << ""右图特征点均匀度:  ""<< rightUniformity <<endl;

//****************************暴力匹配:对两幅图像中的BRIEF描述子进行匹配，使用 Hamming 距离************************************************
    // // BFMatcher
    // BFMatcher matcher(NORM_HAMMING,true);
    // vector<DMatch> all_matches_BF, gms_matches;
    // matcher.match(ORB_left.mDescriptors, ORB_right.mDescriptors, all_matches_BF); //输出结果all_matches
    // Mat all_matches_img;
    // drawMatches(img1, ORB_left.mvKeys, img2, ORB_right.mvKeys, all_matches_BF, all_matches_img, Scalar(0, 255, 0), Scalar::all(-1));
    // imwrite(""./result/ORB_BFmatcher.png"", all_matches_img);
    // imshow(""ORB_BFmatcher"", all_matches_img);
    // cout << ""图1获得特征点数 "" << ORB_left.mvKeys.size() << "" keypoints."" << endl;
    // cout << ""图2获得特征点数 "" << ORB_right.mvKeys.size() << "" keypoints."" << endl;
    // std::cout << ""暴力匹配后个数: "" << all_matches_BF.size() << std::endl;

// ****************************Hamming 距离筛选匹配:对两幅图像中的BRIEF描述子进行匹配，使用 Hamming 距离************************************************
//*** 匹配耗时
std::chrono::steady_clock::time_point t11 = std::chrono::steady_clock::now();
   vector<DMatch> all_matches_BF, gms_matches,all_matches_distance_filter;
   Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(""BruteForce-Hamming"");
   matcher->match(ORB_left.mDescriptors, ORB_right.mDescriptors, all_matches_BF); //输出结果all_matches

   cout << ""图1获得特征点数 "" << ORB_left.mvKeys.size() << "" keypoints."" << endl;
   cout << ""图2获得特征点数 "" << ORB_right.mvKeys.size() << "" keypoints."" << endl;

//***********************匹配点对筛选(人为设计)**********************************************
   double min_dist = 10000, max_dist = 0;

   //找出所有匹配之间的最小距离和最大距离, 即是最相似的和最不相似的两组点之间的距离
   for (int i = 0; i < all_matches_BF.size(); i++) {
       double dist = all_matches_BF[i].distance;
       if (dist < min_dist) min_dist = dist;
       if (dist > max_dist) max_dist = dist;
   }

//    printf(""BRIEF描述子-- Max dist : %f \n"", max_dist);
//    printf(""BRIEF描述子-- Min dist : %f \n"", min_dist);

   //当描述子之间的距离大于两倍的最小距离时,即认为匹配有误.但有时候最小距离会非常小,设置一个经验值30作为下限
   for (int i = 0; i < all_matches_BF.size(); i++) {
       if (all_matches_BF[i].distance <= max(2 * min_dist, 30.0))//增加特征点数或减少特征点数再这里调整
       {
           all_matches_distance_filter.push_back(all_matches_BF[i]);
       }
   }
std::chrono::steady_clock::time_point t22 = std::chrono::steady_clock::now();
double ORBmatchTime= std::chrono::duration_cast<std::chrono::duration<double> >(t22 - t11).count();
cout << ""匹配耗时 :"" << ORBmatchTime << endl;
   printf(""ORB-- All matches : %d \n"", (int) all_matches_BF.size());
//    printf(""ORB-- Descriptors max distance : %d \n"", (int) max(2 * min_dist, 30.0));
   printf(""ORB-- Optimized matching : %d \n"", (int) all_matches_distance_filter.size());
   Mat result;
   drawMatches(img1, ORB_left.mvKeys, img2, ORB_right.mvKeys, all_matches_distance_filter, result, Scalar(0, 255, 0), Scalar(0, 255, 0));///Scalar::all(-1)
//    imwrite(""./result/ORB_matcher_distance_""+Argv4+"".png"", result); 
//    imshow(""ORB_matcher_distance"", result);

//*****************************************计算RMSE********参考BEBLID算法和SIFTS算法*******************************
//SIFT算法详解(附有完整代码)https://blog.csdn.net/weixin_47156401/article/details/122367593?spm=1001.2014.3001.5502
//***************************************************************************************************************
//TODO     计算经过RANSAC后的内点的均方根误差RMSE
    // calculate_RANSAC_inliers_RMSE(img1, img2, all_matches_BF, ORB_left.mvKeys, ORB_right.mvKeys);//暴力匹配筛选的
   calculate_RANSAC_inliers_RMSE(img1, img2, all_matches_distance_filter, ORB_left.mvKeys, ORB_right.mvKeys,Argv4);//Hamming距离阈值匹配筛选的

//*****************************************计算RMSE**************************************************************
//***************************************************************************************************************















    // GMS filter
    std::vector<bool> vbInliers;
    gms_matcher gms(ORB_left.mvKeys, img1.size(), ORB_right.mvKeys, img2.size(), all_matches_BF);
    // cout<< img1.size() <<endl;
    int num_inliers = gms.GetInlierMask(vbInliers, false, false);
//    cout << ""With GMS Get total "" << num_inliers << "" matches."" << endl;

    // collect matches
    for (size_t i = 0; i < vbInliers.size(); ++i)
    {
        if (vbInliers[i] == true)
        {
            gms_matches.push_back(all_matches_BF[i]);
        }
    }

    // draw matching
    Mat show = gms.DrawInlier(img1, img2, ORB_left.mvKeys, ORB_right.mvKeys, gms_matches, 2);

//    imwrite(""./result/ORB_matcher_with_GMS.png"", show);
//    imshow(""ORB_matcher_with_GMS"", show);

    cv::waitKey(0);
    return 0;
}",matched_pts3
302,"#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include <iostream>
#include ""map.h""
#include <sstream>

using namespace sf;
using namespace std;

float offsetX = 0, offsetY = 0;
String TileMap[HEIGHT_MAP];

class PLAYER {
public:

	short countApple = 0;
	float dx, dy;
	FloatRect coordinate, firstCoordinateTp, secondCoordinateTp;
	bool onGround, check;
	Sprite spritePlayer;
	float currentFrame;

	void init(Texture &image, float time) {
		spritePlayer.setTexture(image);
		//coordinate = FloatRect(70 * 32, 2 * 32, 60, 97);
		coordinate = FloatRect(3 * 32, 12 * 32, 60, 97);

		dx = dy = 0.1;
		currentFrame = 0;
		offsetX = 0;
	}

	PLAYER(Texture &image, float time) {
		init(image, time);
	}
	

};

short startMenu(RenderWindow &window);
short startGame(RenderWindow &window, short countAllApple);
void update(PLAYER &player, float time);
void collision(PLAYER &player, bool variables);
short showEndGameMenu(RenderWindow &window, short countAllApple);


void update(PLAYER &player, float time) {

	player.coordinate.left += player.dx * time; // Перемещение по x
	collision(player, true); // x

	if (!player.onGround) {
		player.dy = player.dy + 0.0005*time; // Падение с ускорением
	}
	player.coordinate.top += player.dy*time;
	player.onGround = false;
	collision(player, false); // y

	player.currentFrame += 0.005*time;
	if (player.currentFrame > 6) player.currentFrame -= 6;

	if (player.dx == 0) {
		player.spritePlayer.setTextureRect(IntRect(30, 19, 60, 97));
	}
	if (player.dx > 0) {
		player.spritePlayer.setTextureRect(IntRect(180 + (150 * int(player.currentFrame)), 19, 60, 97));
	}
	if (player.dx < 0) {
		player.spritePlayer.setTextureRect(IntRect(180 + (150 * int(player.currentFrame)) + 60, 19, -60, 97));
	}

	player.spritePlayer.setPosition(player.coordinate.left - offsetX, player.coordinate.top - offsetY);

	player.dx = 0;
}

void collision(PLAYER &player, bool variables) {
	Clock clock;
	for (int i(player.coordinate.top / 32); i < (player.coordinate.top + player.coordinate.height) / 32; i++) {
		for (int j(player.coordinate.left / 32); j < (player.coordinate.left + player.coordinate.width) / 32; j++) {
			if ((TileMap[i][j] == '0') || (TileMap[i][j] == 'b') || (TileMap[i][j] == 'p') || (TileMap[i][j] == 'd')) {
				if ((player.dx > 0) && (variables == true)) {
					player.coordinate.left = j * 32 - player.coordinate.width;
				}
				if ((player.dx < 0) && (variables == true)) {
					player.coordinate.left = j * 32 + 32;
				}
				if ((player.dy > 0) && (variables == false)) {
					player.coordinate.top = i * 32 - player.coordinate.height;
					player.dy = 0;
					player.onGround = true;
				}
				if ((player.dy < 0) && (variables == false)) {
					player.coordinate.top = i * 32 + 32;
					player.dy = 0;
				}
			}
			if (TileMap[i][j] == '1') {
				player.coordinate = player.firstCoordinateTp;
				update(player, 0);

			}
			if (TileMap[i][j] == '3') {
				player.coordinate = player.secondCoordinateTp;
				update(player, 0);
			}
			if (TileMap[i][j] == 'a') {
				TileMap[i][j] = ' ';
				player.countApple++;
			}

		}
	}
}

short startMenu(RenderWindow &window) {
	
	short elementMenu(0);
	
	Texture tMenuBackground, tMenuStartGame, tMenuRecords, tMenuExit, tMenuImageChoice, tMenuRecordsBackground;
	tMenuBackground.loadFromFile(""images/menuBackground.png"");
	tMenuStartGame.loadFromFile(""images/menuStartGame.png"");
	tMenuImageChoice.loadFromFile(""images/menuImageChoice.png"");
	tMenuExit.loadFromFile(""images/menuExit.png"");
	tMenuRecords.loadFromFile(""images/menuRecords.png"");
	tMenuRecordsBackground.loadFromFile(""images/menuRecordsBackground.png"");

	Sprite sMenuBackground(tMenuBackground), sMenuStartGame(tMenuStartGame), sMenuRecords(tMenuRecords), sMenuExit(tMenuExit), sMenuImageChoice(tMenuImageChoice), sMenuRecordsBackground(tMenuRecordsBackground);
	sMenuBackground.setPosition(0, 0);
	sMenuStartGame.setPosition(145, 423);
	sMenuRecords.setPosition(168, 476);
	sMenuExit.setPosition(145, 530);
	sMenuRecordsBackground.setPosition(0, 0);
	
	while (window.isOpen()) {
		
		Event event;
		while (window.pollEvent(event)) {
			if (event.type == Event::Closed)
				window.close();
		}
		window.draw(sMenuBackground);
			
		sMenuStartGame.setColor(Color(86, 59, 56));
		sMenuRecords.setColor(Color(86, 59, 56));
		sMenuExit.setColor(Color(86, 59, 56));

		elementMenu = 0;

		if (IntRect(145, 423, 143, 23).contains(Mouse::getPosition(window))) {
			sMenuStartGame.setColor(Color(164, 72, 68));
			sMenuImageChoice.setPosition(89, 405);
			window.draw(sMenuImageChoice);
			elementMenu = 1;
		}
		if (IntRect(166, 476, 96, 23).contains(Mouse::getPosition(window))) {
			sMenuRecords.setColor(Color(164, 72, 68)); 
			sMenuImageChoice.setPosition(111, 458);
			window.draw(sMenuImageChoice);
			elementMenu = 2;
		}
		if (IntRect(145, 530, 71, 18).contains(Mouse::getPosition(window))) {
			sMenuExit.setColor(Color(164, 72, 68)); 
			sMenuImageChoice.setPosition(89, 511);
			window.draw(sMenuImageChoice);
			elementMenu = 3;
		}

		if (Mouse::isButtonPressed(Mouse::Left)) {
			switch (elementMenu) {
			case 1: {
				return elementMenu;
				break;
			}
			case 2: {
				window.draw(sMenuRecordsBackground);
				window.display();
				while (!Keyboard::isKeyPressed(Keyboard::Escape));
				break;
			}
			case 3: {
				return elementMenu;
				break;
			}
			default:
				break;
			}
		}
			
		window.draw(sMenuStartGame);
		window.draw(sMenuRecords);
		window.draw(sMenuExit);

		window.display();
	}
}


short startGame(RenderWindow &window, short countAllApple) {

	View view;

	Font font;
	font.loadFromFile(""adominorevobl_bold.ttf"");

	Text textCountApple("""", font, 24), textTimer("""", font, 24);
	textCountApple.setFillColor(Color(255, 255, 255));
	textCountApple.setStyle(Text::Bold);
	textTimer.setFillColor(Color(255, 255, 255));
	textTimer.setStyle(Text::Bold);


	Texture texturePlayer, bg, tGround, tTiles, tApple, tDoorOpen, tDoorClosed, tTimer;
	texturePlayer.loadFromFile(""images/newton-sheet.png"");
	bg.loadFromFile(""images/bg.png"");
	tGround.loadFromFile(""images/ground.png"");
	tTiles.loadFromFile(""images/tiles.png"");
	tApple.loadFromFile(""images/apple.png"");
	tDoorClosed.loadFromFile(""images/door_closed.png"");
	tDoorOpen.loadFromFile(""images/door_open.png"");
	tTimer.loadFromFile(""images/timer_32.png"");

	texturePlayer.setSmooth(true);
	bg.setSmooth(true);
	tGround.setSmooth(true);
	tTiles.setSmooth(true);
	tApple.setSmooth(true);
	tDoorClosed.setSmooth(true);
	tDoorOpen.setSmooth(true);
	tTimer.setSmooth(true);

	Sprite sBg(bg), sGround(tGround), sTiles(tTiles), sApple(tApple), sDoorOpen(tDoorOpen), sDoorClosed(tDoorClosed), sTimer(tTimer);

	copy(begin(TileMapOrigin), end(TileMapOrigin), begin(TileMap)); // Копирование начальной карты

	PLAYER p(texturePlayer, 0);

	SoundBuffer buffer;
	buffer.loadFromFile(""sounds/jump.ogg"");
	Sound sound(buffer);


	Music music;
	music.openFromFile(""sounds/Monkeys_Spinning_Monkeys.ogg"");
	music.play();
	music.setLoop(true);


	Clock clock;
	float currentFrame(0); 
	int timer(20000 * 6); // 10 sec ~ 20000
	
	while (window.isOpen())
	{
		float time = clock.getElapsedTime().asMicroseconds();
		clock.restart();

		time /= 500;

		if (time > 20) {
			time = 20;
		}

		timer -= time;
		if (timer < 0) {
			countAllApple = p.countApple;
			return countAllApple;
		}

		Event event;
		while (window.pollEvent(event)) {
			if (event.type == Event::Closed)
				window.close();
		}

		if (Keyboard::isKeyPressed(Keyboard::Left) || Keyboard::isKeyPressed(Keyboard::A))
		{
			p.dx = -0.1;

		}

		if (Keyboard::isKeyPressed(Keyboard::Right) || Keyboard::isKeyPressed(Keyboard::D))
		{
			p.dx = 0.1;
		}
		if (Keyboard::isKeyPressed(Keyboard::Up) || Keyboard::isKeyPressed(Keyboard::W) || Keyboard::isKeyPressed(Keyboard::Space)) {
			if (p.onGround) {
				p.dy = -0.4;
				p.onGround = false;
				sound.play();
			}
		}
		if (Keyboard::isKeyPressed(Keyboard::R))
		{
			music.play();
			music.setLoop(true);
		}
		if (Keyboard::isKeyPressed(Keyboard::F))
		{
			music.stop();
		}

		if (Keyboard::isKeyPressed(Keyboard::G)) { // Перемещение в начало
			p.init(texturePlayer, time);
		}

		update(p, time);

		if ((p.coordinate.left > 400) && ((880 < 150 * 32 - p.coordinate.left))) {
			offsetX = p.coordinate.left - 400;
		}

		window.clear(Color::White);
		window.draw(sBg);

		for (int i(0); i < HEIGHT_MAP; i++) {
			for (int j(0); j < WIDTH_MAP; j++) {
				if (TileMap[i][j] == '0') {
					continue;
				}
				if (TileMap[i][j] == ' ') {
					continue;
				}
				if (TileMap[i][j] == 'b') {
					sGround.setTextureRect(IntRect(6 * 32, 2 * 32, 32, 16));
				}
				if (TileMap[i][j] == 'p') {
					sGround.setTextureRect(IntRect(160, 288, 32, 32));
				}
				if (TileMap[i][j] == '1' || TileMap[i][j] == '3') {
					sDoorOpen.setTextureRect(IntRect(0, 0, 64, 128));
					sDoorOpen.setPosition(j * 32 - offsetX, i * 32 - 32 - offsetY);
					window.draw(sDoorOpen);
				}
				if (TileMap[i][j] == '2') {
					sDoorClosed.setTextureRect(IntRect(0, 0, 64, 128));
					sDoorClosed.setPosition(j * 32 - offsetX, i * 32 - 32 - offsetY);
					p.firstCoordinateTp = FloatRect(j * 32, i * 32 - 32, 60, 97);
					window.draw(sDoorClosed);
				}
				if (TileMap[i][j] == '4') {
					sDoorClosed.setTextureRect(IntRect(0, 0, 64, 128));
					sDoorClosed.setPosition(j * 32 - offsetX, i * 32 - 32 - offsetY);
					p.secondCoordinateTp = FloatRect(j * 32 , i * 32 - 32, 60, 97);
					window.draw(sDoorClosed);

				}
				if (TileMap[i][j] == 'a') {
					sApple.setTextureRect(IntRect(0, 0, 32, 32));
					sApple.setPosition(j * 32 - offsetX, i * 32 - offsetY);
					window.draw(sApple);
				}
				if (TileMap[i][j] == 'd') {
					sGround.setTextureRect(IntRect(1 * 32, 10 * 32, 32, 16));
				}

				if (!((TileMap[i][j] == '1') || (TileMap[i][j] == '2') || (TileMap[i][j] == 'a') || (TileMap[i][j] == '3') || (TileMap[i][j] == '4'))) {
					sGround.setPosition(j * 32 - offsetX, i * 32 - offsetY);
					window.draw(sGround);
				}
			}
		}
		
		ostringstream countAppleString, timerString;
		
		// Отображение кол-ва яблок
		sApple.setTextureRect(IntRect(0, 0, 32, 32));
		sApple.setPosition(view.getCenter().x - 446, view.getCenter().y - 473);
		window.draw(sApple);

		countAppleString << p.countApple;
		textCountApple.setString("": "" + countAppleString.str());
		textCountApple.setPosition(view.getCenter().x - 410, view.getCenter().y - 471);
		window.draw(textCountApple);

		//Таймер
		sTimer.setTextureRect(IntRect(0, 0, 35, 35));
		sTimer.setPosition(view.getCenter().x + 50, view.getCenter().y - 473);
		window.draw(sTimer);

		timerString << (timer / 2000);
		textTimer.setString("": "" + timerString.str());
		textTimer.setPosition(view.getCenter().x + 87, view.getCenter().y - 470);
		window.draw(textTimer);

		window.draw(p.spritePlayer);
		window.display();
	}

}

short showEndGameMenu(RenderWindow &window, short countAllApple) {
	View view;

	Font font;
	font.loadFromFile(""PT_SANS-WEB-BOLDITALIC.TTF"");

	wstring strRepeatGame = L""Начать заново"", strBackToMainMenu = L""Выйти в главное меню"";

	Text textRepeatGame(strRepeatGame, font, 36),  [MASK] (strBackToMainMenu, font, 36), textCountAllApple("""", font, 42);
	textRepeatGame.setFillColor(Color(86, 59, 56));
	 [MASK] .setFillColor(Color(86, 59, 56));
	textCountAllApple.setFillColor(Color(86, 59, 56));

	Texture tMenuBackground;
	tMenuBackground.loadFromFile(""images/menuRepeatBackground.png"");

	Sprite sMenuBackground(tMenuBackground);
	sMenuBackground.setPosition(0, 0);

	short elementMenu(0);

	while (window.isOpen()) {

		Event event;
		while (window.pollEvent(event)) {
			if (event.type == Event::Closed)
				window.close();
		}
		window.draw(sMenuBackground);

		ostringstream countAllAppleString;

		countAllAppleString << countAllApple;
		textCountAllApple.setString(countAllAppleString.str());
		
		if (countAllApple < 10 && countAllApple > -10) {
			textCountAllApple.setPosition(view.getCenter().x + 130, view.getCenter().y - 350);
		}
		if (countAllApple > 9 || countAllApple < -9) {
			textCountAllApple.setPosition(view.getCenter().x + 120, view.getCenter().y - 350);
		}
		textCountAllApple.setStyle(Text::Bold);
		window.draw(textCountAllApple);

		textRepeatGame.setPosition(view.getCenter().x + 25, view.getCenter().y - 150);
		window.draw(textRepeatGame);
		 [MASK] .setPosition(view.getCenter().x - 40, view.getCenter().y - 100);
		window.draw( [MASK] );

		textRepeatGame.setStyle(Text::Regular);
		 [MASK] .setStyle(Text::Regular);


		elementMenu = 0;

		if (IntRect(523, 355, 231, 30).contains(Mouse::getPosition(window))) {
			textRepeatGame.setStyle(Text::Underlined);
			elementMenu = 1;
		}
		if (IntRect(460, 410, 360, 26).contains(Mouse::getPosition(window))) {
			 [MASK] .setStyle(Text::Underlined);
			elementMenu = 2;
		}

		if (Mouse::isButtonPressed(Mouse::Left)) {
			return elementMenu;
		}
			window.display();
	}
}


int main(){
	RenderWindow window(VideoMode(1280, 720), ""Newton [1.0]"");
	window.setFramerateLimit(100);
	short elementMenu(2);
	short countAllApple(0);
	
	while (elementMenu != 3) {
		if (elementMenu == 2) { 
			elementMenu = startMenu(window); 
		}
		
		if (elementMenu == 1) {
			countAllApple = startGame(window, countAllApple);

			elementMenu = showEndGameMenu(window, countAllApple);

		}
	}
	window.close();

}",textBackToMainMenu
303,"#include <Arduino.h>
#include <LoRa.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <Firebase_ESP_Client.h>
#include <PubSubClient.h>
#include <config.h>

#define LORA_SS 18
#define LORA_RST 14
#define LORA_DI0 26
#define BAND 915E6

const char* mqttServer = ""demo.thingsboard.io"";

WiFiClient espClient;
PubSubClient client(espClient);

void reconnect();

void readData() {
  int packetSize = LoRa.parsePacket();
  String data = """";

  if(packetSize) {
    while (LoRa.available()) {
      data += (char) LoRa.read();
    }
    if(!client.connected()) {
      reconnect();
    }
    if(client.publish(""v1/devices/me/telemetry"", data.c_str())) {
      Serial.print(""\nDados Enviados! -> "" + data);
    }
  }
}

void sendDataDashboardTester() {
  srand(time(NULL));
  double mockTemperature = 25.00;
  double mockAccel = (rand() % (400 - 100+1) + 100);
  double mockAxisX = (rand() % (20 - 5+1) + 100);
  double  [MASK]  = (rand() % (350 - 100+1) + 100);
  double mockAxisY = (rand() % (1 - (-10)+1) + 100);

  String PacketTeste = ""{\""nodeID\"":"" + String(1) +
          "",\""time\"":"" + String(millis()) +
          "",\""temperature\"":"" + String(mockTemperature) +
          "",\""accel\"":"" + String(mockAccel) +
          "",\""axisX\"":"" + String(mockAxisX) +
          "",\""axisY\"":"" + String(mockAxisY) +
          "",\""axisZ\"":"" + String( [MASK] ) +
          ""}"";

  if(client.publish(""v1/devices/me/telemetry"", PacketTeste.c_str())) {
    Serial.print(""Dados de teste Enviados"");
  }

  delay(10000);
}

void reconnect() {
  while (!client.connected()) {
    Serial.print(""\nBuscando broker..."");
    if (client.connect(BROKER_CID, BROKER_USER, BROKER_PSWD)) {
      Serial.println("" OK!"");
    } else {
      Serial.print(""Falha ao reconectar: "");
      Serial.print(client.state());
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  client.setServer(mqttServer, 1883);

  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(""..."");
    delay(300);
  }
  Serial.print(""WiFi Conectado! "");

  LoRa.setPins(LORA_SS, LORA_RST, LORA_DI0);
  if(!LoRa.begin(BAND)) {
    Serial.print(""Erro ao incializar o Gateway"");
    while(1);
  }

  while(!client.connected()) {
    Serial.print(""\nBuscando MQTT... "");
    if(client.connect(BROKER_CID, BROKER_USER, BROKER_PSWD)) {
      Serial.print(""Broker MQTT Conectado"");
      client.subscribe(""v1/devices/me/telemetry"");
    } else {
      Serial.print(""fail: "");
      Serial.println(client.state());
      reconnect();
    }
  }

  Serial.print(""\nGateway Pronto!\n"");
}

void loop() {
  readData();
}",mockAxisZ
304,"const int buttonPin1 = 4;  
const int buttonPin2 = 5;  
const int buttonPin3 = 6; 
const int buttonPin4 = 7;  

// Button states and debounce variables for Button1 and Button2
int buttonState1 = 0;
int lastButtonState1 = 0;
int buttonState2 = 0;
int lastButtonState2 = 0;
unsigned long lastDebounceTime1 = 0;
unsigned long lastDebounceTime2 = 0;

// Button states and debounce variables for Button3 and Button4
int buttonState3 = 0;
int lastButtonState3 = 0;
int buttonState4 = 0;
int lastButtonState4 = 0;
unsigned long lastDebounceTime3 = 0;
unsigned long lastDebounceTime4 = 0;

unsigned long debounceDelay = 10; // Debounce delay in milliseconds

void setup() {
  // Initialize serial communication
  Serial.begin(115200); // Ensure this matches the baud rate in Godot.

  pinMode(buttonPin1, INPUT);
  pinMode(buttonPin2, INPUT);
  pinMode(buttonPin3, INPUT);
  pinMode(buttonPin4, INPUT);
}

void loop() {
  // Read the current state of all buttons
  int reading1 = digitalRead(buttonPin1);
  int  [MASK]  = digitalRead(buttonPin2);
  int reading3 = digitalRead(buttonPin3);
  int reading4 = digitalRead(buttonPin4);

  // Handle debouncing for Button 1
  if (reading1 != lastButtonState1) {
    lastDebounceTime1 = millis(); // Reset debounce timer for Button1
  }

  if ( [MASK]  != lastButtonState2) {
    lastDebounceTime2 = millis(); 
  }

  if (reading3 != lastButtonState3) {
    lastDebounceTime3 = millis(); 
  }

  if (reading4 != lastButtonState4) {
    lastDebounceTime4 = millis(); 
  }

  // Process Button1 if the debounce delay has passed
  if ((millis() - lastDebounceTime1) > debounceDelay) {
    if (reading1 != buttonState1) {
      buttonState1 = reading1;
      if (buttonState1 == HIGH) {
        Serial.println(""Button1Pressed""); // Send signal to Godot
      }
    }
  }

  if ((millis() - lastDebounceTime2) > debounceDelay) {
    if ( [MASK]  != buttonState2) {
      buttonState2 =  [MASK] ;
      if (buttonState2 == HIGH) {
        Serial.println(""Button2Pressed""); 
      }
    }
  }

  if ((millis() - lastDebounceTime3) > debounceDelay) {
    if (reading3 != buttonState3) {
      buttonState3 = reading3;
      if (buttonState3 == HIGH) {
        Serial.println(""Button3Pressed""); // Send signal to Godot for Player2
      }
    }
  }

  if ((millis() - lastDebounceTime4) > debounceDelay) {
    if (reading4 != buttonState4) {
      buttonState4 = reading4;
      if (buttonState4 == HIGH) {
        Serial.println(""Button4Pressed"");
      }
    }
  }

  // Save the current button states for the next loop iteration
  lastButtonState1 = reading1;
  lastButtonState2 =  [MASK] ;
  lastButtonState3 = reading3;
  lastButtonState4 = reading4;
}
",reading2
305,"// compiler parameter: g++ -O4 name.cpp -lgmpxx -lgmp -pthread -std=c++11
#include <math.h>
#include <iostream>
#include <ctime>
#include <vector>
#include <string>
#include <iostream>
#include <gmpxx.h>
#include <fstream>
#include <algorithm>
#include <stdio.h>
#include <thread>
#include <future>

using namespace std;

void write_file(const string &str){
  FILE *f;
  string a;
  f = fopen(""1.txt"",""w"");
  ofstream fout (""1.txt"");
  fout << str;
  fclose(f);
}

int time_time(){
  time_t seconds;
  seconds = time (NULL);
  return int(seconds);
}

void naiti_prostie_menshe(vector <mpz_class> &prostie, unsigned long long int n){
       vector <unsigned char> vsen(n+1);
       unsigned long int i = 0;
       // 1 = False
       // 0 = True
       unsigned int koren = sqrt(float(n));
       unsigned long int p = 2;
       while(p <= koren){
               prostie.push_back(p);
               for (i=p; i < (n+1); i += p){
                       vsen[i] = 1;
               }
               for (i=p; i < (n+1); i ++){
                       if (vsen[i] == 0){
                               p = i;
                               break;
                       }
              }
       }
       for (i = p; i < (n+1); i++){
               if (vsen[i] == 0){
                       prostie.push_back(i);
               }
       }
}


vector <mpz_class> slice(vector<mpz_class>& v, unsigned int start = 0, int end = -1) {
    int oldlen = v.size();
    int newlen;
    if (end == -1 or end >= oldlen){
        newlen = oldlen-start;
    } else {
        newlen = end-start;
    }
    vector<mpz_class> nv(newlen);
    for (int i = 0; i < newlen; i++) {
        nv[i] = v[start+i];
        v[start+i] = 0; //bit saves memory
    }
    return nv;
}

void group(vector <mpz_class>& iterable, vector<vector<mpz_class>>& a, const int count){
    int ss = iterable.size() / count;
    int b = 0;
    for (int i = 1; i != count; i++){
      a.push_back(slice(iterable, b, ss * i));
      b = ss * i;
    }
    a.push_back(slice(iterable, b));
}

void peremnozh(const vector <mpz_class>&& chisla, vector <mpz_class>& otveti, const int thread_n){
  mpz_class ss;
  ss = ""1"";
  for(int i = 0; i != chisla.size(); i++){
    ss = ss * chisla[i];
  }
  otveti[thread_n] = ss;
}

mpz_class poizvedenie(vector <mpz_class> &chisla, int razmer_grupi = 2){
  //razmer_grup -- can not be less 2
  if(chisla.size() == 0){
    mpz_class ss;
    return ss;
  }
  vector<vector<mpz_class>> grupi;
  int kolichestvo_group = chisla.size() / razmer_grupi;
  if (kolichestvo_group == 0){
    kolichestvo_group = 1;
  } else if(kolichestvo_group > 8096){
    kolichestvo_group = 8096;
  }
  group(chisla, grupi, kolichestvo_group);

  chisla.clear();
  vector<mpz_class> otveti(grupi.size());
  vector<thread> thread_list(grupi.size());
  for(int i = 0; i != grupi.size(); i++){
    thread_list[i] = thread (peremnozh, grupi[i], ref(otveti), i);
  }
  for(int i = 0; i != thread_list.size(); i++){
    thread_list[i].join();
  }
  if(otveti.size() == 1){
    cout << ""Zakonchili umnozhati"" << '\n';
    return otveti[0];

  }else{
    grupi.clear();
    thread_list.clear();
    return poizvedenie(otveti);
  }
}

unsigned long long int kagda_zakonchiti(vector <mpz_class> &prostie, unsigned long long  [MASK] ){
      unsigned int c;
      for (int i = 0; i != prostie.size(); i++){
              c = prostie[i].get_ui();
              if((c * c) >  [MASK] ){
                break;
              }
      }
      return c;
}

mpz_class glav(unsigned long long dokuda){
      cout << ""Shitaem primes"" << '\n';
      vector <mpz_class> prostie;
      naiti_prostie_menshe(prostie, dokuda);
      cout << ""zakonchili shitati primes"" << '\n';
      cout << ""dobavlyaem list"" << '\n';
      unsigned long long int ae = kagda_zakonchiti(prostie, dokuda);
      for (int i = 0; i != prostie.size(); i++){
              unsigned int j = prostie[i].get_ui();
              if(ae == j){
                break;
              }
              unsigned int k = 1;
              while (true) {
                k *= j;
                if(k * j <= dokuda){
                  prostie.push_back(j);
                } else{
                  break;
                }
              }
      }
      //cout << prostie.size() << '\n';
      cout << ""zakinchili dobavlyati list"" << '\n';
      cout << ""Umnozhaem"" << '\n';
      return poizvedenie(prostie);
}

int main (){
        // 2520 is the smallest number that can be divided by each of the
        // numbers from 1 to 10 without any remainder.
        // What is the smallest positive number that is evenly divisible
        // by all of the numbers from 1 to n?
        int n = 1000000000;
        int start_time = time_time();
        glav(n);
        //write_file(glav(n).get_str());
        cout << time_time() - start_time <<""\n"";
}
",potolok
306,"/* Copyright 2011 <NAME>
 * 
 * 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.
 * 
 * File:   BuiltInClasses.cpp
 * Author: tjoppen
 * 
 * Created on February 14, 2010, 6:48 PM
 */

#include <stdexcept>
#include <sstream>
#include ""BuiltInClasses.h""
#include ""main.h""

using namespace std;

const string t = ""    ""; // Python indentation step (four spaces)

BuiltInClass::BuiltInClass(string name) : Class(FullName(XSL, name), Class::SIMPLE_TYPE) {
}

BuiltInClass::~BuiltInClass() {
}

bool BuiltInClass::isBuiltIn() const {
    return true;
}

string BuiltInClass::generateAppender() const {
    throw runtime_error(""generateAppender() called in BuiltInClass"");
}

string BuiltInClass::generateElementSetter(string memberName, string nodeName, string tabs) const {
    ostringstream oss;
    oss << tabs << ""tmp = document.createElement(\"""" << nodeName << ""\"")"" << endl;
    oss << tabs << ""tmpText = document.createTextNode(unicode("" << memberName << ""))"" << endl;
    oss << tabs << ""tmp.appendChild(tmpText)"" << endl;
    oss << tabs << ""node.appendChild(tmp)"" << endl;

    return oss.str();
}

string BuiltInClass::generateAttributeSetter(string memberName, string  [MASK] , string tabs) const {
    ostringstream oss;

    oss << tabs << ""tmpAttr = document.createAttribute(\"""" << memberName << ""\"")"" << endl;
    oss << tabs << ""tmpAttr.value = unicode("" <<  [MASK]  << "")"" << endl;
    oss << tabs << ""node.setAttributeNode(tmpAttr)"" << endl;

    return oss.str();
}

string BuiltInClass::generateParser() const {
    throw runtime_error(""generateParser() called in BuiltInClass"");
}

string BuiltInClass::generateMemberSetter(string memberName, string nodeName, string tabs) const {
    ostringstream oss;
    
    oss << tabs << ""if node.firstChild == None:"" << endl;
    oss << tabs << t << memberName << "" = None"" << endl;
    oss << tabs << ""else:"" << endl;

    oss << tabs << t << memberName << "" = "";
    string type = getClassname();
    if(type == ""int"" || type == ""short"" || type == ""unsignedShort"" || type == ""unsignedInt"" || type == ""byte"" || type == ""unsignedByte"" || type == ""integer"" || type == ""unsignedInteger"") {
        oss << ""int(node.firstChild.nodeValue)"";
    } else if(type == ""long"" || type == ""unsignedLong"") {
        oss << ""long(node.firstChild.nodeValue)"";
    } else if(type == ""float"" || type == ""double"") {
        oss << ""float(node.firstChild.nodeValue)"";
    } else if(type == ""string"") {
        oss << ""node.firstChild.nodeValue"";
    } else {
        oss << ""unicode(node.firstChild.nodeValue)"";
    } 

    return oss.str();
}
",attributeName
307,"#include ""IO.h""

#include <fstream>

namespace {
	auto isFinite(glm::vec3 v) -> bool {
		return std::isfinite(v.x) || std::isfinite(v.y) || std::isfinite(v.z);
	}

	auto isFinite(const Triangle& t) -> bool {
		return isFinite(t[0]) || isFinite(t[1]) || isFinite(t[2]);
	}
}

void saveTriangles(std::filesystem::path path, const std::vector<Triangle>& triangles) {
	if (path.has_parent_path())
		create_directories(path.parent_path());
	std::ofstream f{path, std::ios::binary};
	const char header[80] = ""STL whatever"";
	f.write(header, sizeof(header));

	uint32_t count = static_cast<uint32_t>(triangles.size());
	f.write(reinterpret_cast<const char*>(&count), sizeof(count));

	const uint16_t  [MASK]  = 0;
	for (const auto& t : triangles) {
		const auto normal = glm::normalize(glm::cross(t[0] - t[1], t[0] - t[2]));
		if (!isFinite(t)) {
			count--;
			continue;
		}
		f.write(reinterpret_cast<const char*>(&normal), sizeof(normal));
		f.write(reinterpret_cast<const char*>(&t), sizeof(t));
		f.write(reinterpret_cast<const char*>(& [MASK] ), sizeof( [MASK] ));
	}

	f.seekp(sizeof(header), std::ios::beg);
	f.write(reinterpret_cast<const char*>(&count), sizeof(count));

	f.close();
}

void savePoints(std::filesystem::path path, const std::vector<glm::vec3>& points) {
	if (path.has_parent_path())
		create_directories(path.parent_path());
	std::ofstream f{path, std::ios::binary};
	f << ""ply\n"";
	f << ""format binary_little_endian 1.0\n"";
	f << ""element vertex "" << points.size() << ""\n"";
	f << ""property float x\n"";
	f << ""property float y\n"";
	f << ""property float z\n"";
	f << ""end_header\n"";
	f.write(reinterpret_cast<const char*>(points.data()), points.size() * sizeof(glm::vec3));
	f.close();
}
",attributeCount
308,"#ifdef _WIN32
#  include <io.h>
#  include <winsock2.h>
#  include <ws2tcpip.h>
#  pragma comment(lib, ""ws2_32.lib"")
#  include ""stdint_msvc.h""
#else
#  define _BSD_SOURCE 1
#  define _DEFAULT_SOURCE 1
#  include <sys/socket.h>
#  include <netinet/in.h>
#  include <netdb.h>
#  include <unistd.h>
#  include <sys/mman.h>
#  include <stdint.h>
#  define closesocket close
#endif

#ifndef _cpluslplus
# ifndef _WIN32
#  include <stdbool.h>
# else
#  define bool int
# endif
#endif

#include <stdio.h>
#include <sys/types.h>

#include ""cache/cached_tree.h""
#include <stdlib.h>
#include <string.h>

#include <fcntl.h>
#include <sys/stat.h>
#include <assert.h>
#include <errno.h>

struct sockaddr_in server;
struct sockaddr_in m_client;
struct sockaddr_in s_client;

#include ""micronfs.h""
#include ""rpc_serializer.h""

#ifndef MAP_UNINITIALIZED
#  define MAP_UNINITIALIZED 0
#endif
#define MAX_BUFFER_SIZE 4096

static char recvbuffer[MAX_BUFFER_SIZE];

/// connects to a name on a given port
/// returns -1 if it fails
int connect_name(const char* hostname, const char* port)
{
   struct addrinfo* addr = 0;

    int sfd = -1;
    if (getaddrinfo(hostname, port, 0, &addr) != 0)
    {
        perror(""getaddrinfo failed "");
    }

    for (struct addrinfo* rp = addr; rp != NULL; rp = rp->ai_next) {
           sfd = socket(rp->ai_family, rp->ai_socktype,
                        rp->ai_protocol);
        if (sfd == -1)
           continue;

       if (connect(sfd, rp->ai_addr, rp->ai_addrlen) == 0)
       {
            break;             /* Success */
       }
    }

    return sfd;
}


void PushUnixAuthN(RPCSerializer* self)
{
    uint32_t aux_gids[1] = {0};

    RPCSerializer_PushUnixAuth(self, 0, """", 0, 0, 1, aux_gids);
}


#define PORTMAP_PROGRAM         100000
#define PORTMAP_DUMP_PROCEDURE       4
#define PORTMAP_DUMP_GETPORT         3

#define MOUNT_PROGRAM           100005
#define MOUNT_MNT_PROCEDURE          1
#define MOUNT_DUMP_PROCEDURE         2
#define MOUNT_UMNT_PROCEDURE         3
#define MOUNT_EXPORT_PROCEDURE       5

#define NFS_PROGRAM             100003
#define NFS_READ_PROCEDURE           6
#define NFS_WRITE_PROCEDURE          7
#define NFS_CREATE_PROCEDURE         8
#define NFS_MKNOD_PROCEDURE         11
#define NFS_READDIR_PROCEDURE       16
#define NFS_READDIRPLUS_PROCEDURE   17
#define MESSAGE_TYPE_CALL 0
#define PROTO_TCP 6


void InitCache(cache_t* cache)
{
    uint32_t initial_name_storage_capacity = 65536;
    uint32_t initial_name_nodes_capacity = 4096;
    uint32_t  [MASK]  = 16384;

    uint32_t initial_metadata_nodes = 16384 * 8;
    uint32_t initial_dir_nodes = 2048;
    uint32_t initial_toc_capacity = 2048;
    uint32_t initial_limb_capacity = 16384;

    uint8_t* cache_memory = (uint8_t*) malloc(
        sizeof(cache_t) + initial_name_storage_capacity
                        + (initial_name_nodes_capacity *
                            sizeof(name_cache_node_t)));

    toc_entry_t* toc_mem = (toc_entry_t*) calloc(
        initial_toc_capacity, sizeof(toc_entry_t));

    name_cache_node_t* tree_mem = (name_cache_node_t*)
                                (cache_memory + sizeof(cache_t)
                                + initial_name_storage_capacity);

    meta_data_entry_t* meta_mem = (meta_data_entry_t*) calloc(
        initial_metadata_nodes , sizeof(meta_data_entry_t));

    cached_dir_t* dirs_mem = (cached_dir_t*)calloc(
        initial_dir_nodes, sizeof(cached_dir_t));

    uint32_t* limbs_mem = (uint32_t*) calloc(
        initial_limb_capacity, sizeof(uint32_t));

    cached_file_t* files_mem = (cached_file_t*)
        calloc( [MASK] , sizeof(cached_file_t));


    cache->toc_entries = toc_mem;
    cache->root = meta_mem++;

    cache->toc_size = 0;
    cache->toc_capacity = initial_toc_capacity;

    cache->metadata_size = 1;
    cache->metadata_capacity = initial_metadata_nodes;

    cache->name_stringtable  = (char*)(cache_memory + sizeof(cache_t));
    cache->name_stringtable_size = 0;
    cache->name_stringtable_capacity = initial_name_storage_capacity;

    cache->name_cache_root = tree_mem;
    cache->name_cache_node_size = 1;
    cache->name_cache_node_capacity = initial_name_nodes_capacity;

    cache->dir_entries = dirs_mem;
    cache->dir_entries_size = 0;
    cache->dir_entries_capacity = initial_dir_nodes;

    cache->file_entries = files_mem;
    cache->file_entries_size = 0;
    cache->file_entries_capacity =  [MASK] ;

    cache->limbs = limbs_mem;
    cache->limbs_size = 0;
    cache->limbs_capacity = initial_limb_capacity;

    ResetCache(cache);

    cache->root->cached_dir = cache->dir_entries + cache->dir_entries_size++;
    cache->root->cached_dir->fullPath = GetOrAddName(cache, ""/"");
}

void portmap_nullCall(int sock_fd)
{
    RPCSerializer s = {0};

    RPCSerializer_InitCall(&s,
        PORTMAP_PROGRAM, 2, 0);
    RPCSerializer_PushNullAuth(&s);
    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, sock_fd);
}

uint16_t portmap_getport(int sock_fd,
    uint32_t program, uint32_t version_, uint32_t proto)
{
        RPCSerializer s = {0};

    RPCSerializer_InitCall(&s,
        PORTMAP_PROGRAM, 2, PORTMAP_DUMP_GETPORT);

    RPCSerializer_PushNullAuth(&s);

    // arguments to getport
    RPCSerializer_PushU32(&s, program);
    RPCSerializer_PushU32(&s, version_);
    RPCSerializer_PushU32(&s, proto);
    RPCSerializer_PushU32(&s, 0);

    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, sock_fd);

    RPCDeserializer d = {0};
    RPCDeserializer_Init(&d, sock_fd);
    RPCHeader header =
        RPCDeserializer_RecvHeader(&d);


    bool accepted = RPCDeserializer_ReadBool(&d);

    RPCDeserializer_SkipAuth(&d);

    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);
    uint32_t port = RPCDeserializer_ReadU32(&d);
    assert(port <= 0xFFFF);

    return port;
}

typedef struct mountlist_t {
    const char* hostname;
    const char* directory;
    struct mountlist_t* next;
} mountlist_t;


void printFileHandle(const fhandle3* handle)
{
    const uint32_t* ptr = (const uint32_t*)
        &handle->handle[0];

    printf(""fh: %x %x %x %x %x %x %x %x\n"",
        ptr[0], ptr[1], ptr[2], ptr[3],
        ptr[4], ptr[5], ptr[6], ptr[7]);
}

void mountd_umnt(int mountd_fd, const char* dirPath)
{
    RPCSerializer s = {0};
    mountlist_t* result = 0;

    uint32_t mount_dump_xid =
        RPCSerializer_InitCall(&s,
            MOUNT_PROGRAM, 3, MOUNT_UMNT_PROCEDURE);

    RPCSerializer_PushNullAuth(&s);
    uint32_t dirPathLength = strlen(dirPath);

    RPCSerializer_PushString(&s, dirPathLength, dirPath);
    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, mountd_fd);

    // not sure if I should issue a read since it's a void proc
}

fhandle3 mountd_mnt(int mountd_fd, const char* dirPath)
{
    RPCSerializer s = {0};
    fhandle3 result = {{0}};

    uint32_t mount_dump_xid = RPCSerializer_InitCall(&s,
        MOUNT_PROGRAM, 3, MOUNT_MNT_PROCEDURE);

    //RPCSerializer_PushNullAuth(&s);
    PushUnixAuthN(&s);

    uint32_t dirPathLength = strlen(dirPath);

    RPCSerializer_PushString(&s, dirPathLength, dirPath);
    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, mountd_fd);

    RPCDeserializer d = {0};
    RPCDeserializer_Init(&d, mountd_fd);

    RPCDeserializer_RecvHeader(&d);

    int reply_accepted = RPCDeserializer_ReadBool(&d);

    RPCDeserializer_SkipAuth(&d);

    int rpc_accepted = RPCDeserializer_ReadBool(&d);

    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);

    result = RPCDeserializer_ReadFileHandle(&d);
    //TODO we should ready the required auth here .... maybe

    return result;

}

mountlist_t* mountd_dump(int mountd_fd)
{
    RPCSerializer s = {0};
    mountlist_t* result = 0;

    uint32_t mount_dump_xid =
        RPCSerializer_InitCall(&s,
            MOUNT_PROGRAM, 3, MOUNT_DUMP_PROCEDURE);

    RPCSerializer_PushNullAuth(&s);
    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, mountd_fd);

    RPCDeserializer d;
    RPCDeserializer_Init(&d, mountd_fd);
    RPCHeader header = RPCDeserializer_RecvHeader(&d);

    bool accepted = RPCDeserializer_ReadBool(&d);

    RPCDeserializer_SkipAuth(&d);

    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);
    // now the actual params come ...

    static char mountlist_storage[8192];
    char* writePtr = mountlist_storage;
    uint32_t storage_left = sizeof(mountlist_storage);

    bool hadPrev = 0;
    if (status == 0)
    {
        bool hasNext = RPCDeserializer_ReadBool(&d);
        mountlist_t* entry = 0;
        if (hasNext)
        {
            result = entry = (mountlist_t*) mountlist_storage;
        }

        while(hasNext)
        {
            if (hadPrev)
            {
                entry->next = (mountlist_t*)
                    writePtr;
            }

            entry = (mountlist_t*)
                writePtr;
            writePtr += sizeof(mountlist_t);
            storage_left -= sizeof(mountlist_t);

            {
                const uint32_t hlen = RPCDeserializer_ReadU32(&d);
                assert(storage_left > hlen + 1);
                entry->hostname = RPCDeserializer_ReadString(&d, &writePtr, hlen);
                storage_left -= (hlen + 1);
            }
            {
                uint32_t dlen = RPCDeserializer_ReadU32(&d);
                assert(storage_left > dlen - 1);
                entry->directory = RPCDeserializer_ReadString(&d, &writePtr, dlen);
                storage_left -= (dlen + 1);
            }
            hasNext = RPCDeserializer_ReadBool(&d);
            hadPrev = 1;
        }
    }
    else
    {
        printf(""Error: %s\n"", nfsstat3_toChars(status));
    }

    return result;
}

void ReadWcc(RPCDeserializer* self)
{
    wcc_attr pre_op;
    fattr3 post_op;
    if (RPCDeserializer_ReadBool(self))
    {
        pre_op.size = RPCDeserializer_ReadU64(self);
        uint64_t mtime_u64 = RPCDeserializer_ReadU64(self);
        pre_op.mtime = *(nfstime3*) &mtime_u64;
        uint64_t ctime_u64 = RPCDeserializer_ReadU64(self);
        pre_op.ctime = *(nfstime3*)&ctime_u64;
    }
    if (RPCDeserializer_ReadBool(self))
    {
        post_op = RPCDeserializer_ReadFileAttribs(self);
    }
}

fhandle3 nfs_create(SOCKET nfs_fd, const fhandle3* parentDir, const char* filename, mode3 mode)
{
    fhandle3 result = {0};
    RPCSerializer s = {0};

    uint32_t create_xid = RPCSerializer_InitCall(&s,
        NFS_PROGRAM, 3, NFS_CREATE_PROCEDURE);

    PushUnixAuthN(&s);

    uint32_t length = fhandle3_length(parentDir);
    RPCSerializer_PushString(&s, length, (const char*)parentDir);
    uint32_t fn_length = strlen(filename);
    RPCSerializer_PushString(&s, fn_length, filename);
    RPCSerializer_PushU32(&s, GUARDED);

    // push mode
    RPCSerializer_PushU32(&s, 1);
    RPCSerializer_PushU32(&s, mode);

    RPCSerializer_PushU32(&s, 0); // no uid
    RPCSerializer_PushU32(&s, 0); // no gid
    RPCSerializer_PushU32(&s, 0); // no size
    RPCSerializer_PushU32(&s, 0); // no atime
    RPCSerializer_PushU32(&s, 0); // no mtime



    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, nfs_fd);

    // -------------------------------------------

    RPCDeserializer d = {0};
    RPCDeserializer_Init(&d, nfs_fd);

    RPCHeader header = RPCDeserializer_RecvHeader(&d);

    assert(header.xid == create_xid);

    int accepted = RPCDeserializer_ReadBool(&d);
    RPCDeserializer_SkipAuth(&d);
    int accept_state = RPCDeserializer_ReadBool(&d);

    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);
    if (status != 0) printf(""Status: %s\n"", nfsstat3_toChars(status));


    if (status == 0)
    {
        if (RPCDeserializer_ReadBool(&d))
        {
            result = RPCDeserializer_ReadFileHandle(&d);
        }

        if (RPCDeserializer_ReadBool(&d))
        {
            fattr3 attrs = RPCDeserializer_ReadFileAttribs(&d);
        }
    }

    ReadWcc(&d);
}


void nfs_remove(SOCKET nfs_fd, fhandle3* dirHandle, const char* filename, uint32_t filename_length)
{

}

fhandle3 nfs_mknod(SOCKET nfs_sock_fd, const fhandle3* parentDir, const char* filename)
{
    fhandle3 result = {0};
    RPCSerializer s = {0};

    uint32_t mknod_xid = RPCSerializer_InitCall(&s,
        NFS_PROGRAM, 3, NFS_MKNOD_PROCEDURE);

    PushUnixAuthN(&s);


    uint32_t length = fhandle3_length(parentDir);
    RPCSerializer_PushString(&s, length, (const char*)parentDir);
    uint32_t fn_length = strlen(filename);
    RPCSerializer_PushString(&s, fn_length, filename);
    RPCSerializer_PushU32(&s, GUARDED);
        // push sattr3
    RPCSerializer_PushEmptySattr3(&s);
    // ---------------------------------------------


    assert (0); // Not implemented
    return result;
}

int64_t nfs_write(SOCKET nfs_fd, const fhandle3* file
               , const void* data, uint32_t size
               , uint64_t offset)
{
    RPCSerializer s = {0};

    uint32_t write_xid = RPCSerializer_InitCall(&s,
        NFS_PROGRAM, 3, NFS_WRITE_PROCEDURE);

    PushUnixAuthN(&s);


    int length = fhandle3_length(file);
    RPCSerializer_PushString(&s, length, (const char*)file->handle);
    RPCSerializer_PushU64(&s, offset);
    RPCSerializer_PushU32(&s, size);
    RPCSerializer_PushU32(&s, FILE_SYNC);

    RPCSerializer_PushString(&s, size, (const char*)data);

    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, nfs_fd);
    // ----------------------------------------------
    RPCDeserializer d = {0};
    RPCDeserializer_Init(&d, nfs_fd);

    RPCHeader header = RPCDeserializer_RecvHeader(&d);

    assert(header.xid == write_xid);

    int accepted = RPCDeserializer_ReadBool(&d);
    RPCDeserializer_SkipAuth(&d);
    int accept_state = RPCDeserializer_ReadBool(&d);

    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);
    if (status != 0) printf(""Status: %s\n"", nfsstat3_toChars(status));
    // -----------------------------------------------------

    if (status)
    {
        fprintf(stderr, ""Error [%s] while reading '%s'\n""
             , nfsstat3_toChars(status)
             , """" /*LookupNameInCache(file)*/
        );
        return -1;
    }

    if (status == 0)
    {
        ReadWcc(&d);
        uint32_t count =
            RPCDeserializer_ReadU32(&d);
        stable_how comitted = (stable_how) RPCDeserializer_ReadU32(&d);
        uint64_t verf = RPCDeserializer_ReadU64(&d);
        return count;
    }
}


int64_t nfs_read(SOCKET nfs_fd, const fhandle3* file
               , void* data, uint32_t size
               , uint64_t offset)
{
    RPCSerializer s = {0};

    uint32_t read_xid = RPCSerializer_InitCall(&s,
        NFS_PROGRAM, 3, NFS_READ_PROCEDURE);

    PushUnixAuthN(&s);


    int length = fhandle3_length(file);
    RPCSerializer_PushString(&s, length, (const char*)file->handle);
    RPCSerializer_PushU64(&s, offset);
    RPCSerializer_PushU32(&s, size);
    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, nfs_fd);
    // ----------------------------------------------
    RPCDeserializer d = {0};
    RPCDeserializer_Init(&d, nfs_fd);

    RPCHeader header = RPCDeserializer_RecvHeader(&d);

    assert(header.xid == read_xid);

    int accepted = RPCDeserializer_ReadBool(&d);
    RPCDeserializer_SkipAuth(&d);
    int accept_state = RPCDeserializer_ReadBool(&d);

    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);
    if (status != 0) printf(""Status: %s\n"", nfsstat3_toChars(status));
    // -----------------------------------------------------

    if (status)
    {
        fprintf(stderr, ""Error [%s] while reading '%s'\n""
             , nfsstat3_toChars(status)
             , """" /*LookupNameInCache(file)*/
        );
        return -1;
    }

    //TODO FIXME make sure size if less than rtMax form FSINFO Query!
    if (RPCDeserializer_ReadU32(&d) != 0)
    {
        (void) RPCDeserializer_ReadFileAttribs(&d);
    }
    uint32_t result_count = RPCDeserializer_ReadU32(&d);
    int eof = RPCDeserializer_ReadU32(&d) != 0;
    uint32_t arraySize = RPCDeserializer_ReadU32(&d);
    uint32_t bufferLeft = RPCDeserializer_BufferLeft(&d);

    uint32_t readAlready = 0;
    while(bufferLeft < arraySize - readAlready)
    {
        // RPCDeserializer_EnsureSize(&d, bufferLeft);
        memcpy((uint8_t*)data + readAlready, d.ReadPtr, bufferLeft);
        readAlready += bufferLeft;
        d.ReadPtr += (ALIGN4(bufferLeft) / 4);
        RPCDeserializer_EnsureSize(&d, 4);
        bufferLeft = RPCDeserializer_BufferLeft(&d);
    }

    if (bufferLeft >= arraySize - readAlready)
    {
        memcpy((uint8_t*)data + readAlready, d.ReadPtr, bufferLeft);
    }
    else
    {
        assert(0);
        while (arraySize)
        {
         //   RPCDeserializer_EnsureSize(&d, )
        }
    }

    return result_count;
}

int nfs_readdirplus(SOCKET nfs_fd, const fhandle3* dir
               , uint64_t *cookie, uint64_t *cookieverf
               , int (*fileIter)(const char* fName, const fhandle3* handle,
                                 const fattr3* attribs,
                                 void* userData)
               , void* userData)
{
    RPCSerializer s = {0};

    mountlist_t* result = 0;

    uint32_t readdirplus_xid = RPCSerializer_InitCall(&s,
            NFS_PROGRAM, 3, NFS_READDIRPLUS_PROCEDURE);

    PushUnixAuthN(&s);

    int length = fhandle3_length(dir);
    RPCSerializer_PushString(&s, length, (const char*)dir->handle);

    uint32_t cookie_hi = *cookie >> 32;
    uint32_t cookie_lw = *cookie & 0xFFFFFFFF;

    uint32_t cookie_verif_hi = *cookieverf >> 32;
    uint32_t cookie_verif_lw = *cookieverf & 0xFFFFFFFF;

    RPCSerializer_PushU32(&s, cookie_hi);
    RPCSerializer_PushU32(&s, cookie_lw);

    RPCSerializer_PushU32(&s, cookie_verif_hi);
    RPCSerializer_PushU32(&s, cookie_verif_lw);

    RPCSerializer_PushU32(&s, 4096);
    // max size of attribs ... it's recommeded that that's shorter than max size

    RPCSerializer_PushU32(&s, 32768); // max size of result structure

    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, nfs_fd);
    // --------------------------------------------------------------

    RPCDeserializer d = {0};
    RPCDeserializer_Init(&d, nfs_fd);

    RPCHeader header = RPCDeserializer_RecvHeader(&d);

    assert(header.xid == readdirplus_xid);

    int accepted = RPCDeserializer_ReadBool(&d);  //16
    RPCDeserializer_SkipAuth(&d);
    int accept_state = RPCDeserializer_ReadBool(&d);

    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);
    if (status != 0) printf(""Status: %s\n"", nfsstat3_toChars(status));
    // -------------------------------------------------------------------

    int hasAttrs = RPCDeserializer_ReadBool(&d);
    if (hasAttrs)
    {
        RPCDeserializer_ReadFileAttribs(&d);
    }

    *cookieverf = RPCDeserializer_ReadU64(&d);
    cookie3 lastCookie;
    // ---------------------------------------------------------------------
    int hasNext = RPCDeserializer_ReadBool(&d);
    int shouldContinueReading;
    while (hasNext)
    {
        RPCDeserializer_EnsureSize(&d, 12);
        char name_buffer[1024];
        char* namePtr = name_buffer;
        uint64_t fileid  = RPCDeserializer_ReadU64(&d);
        uint32_t name_length = RPCDeserializer_ReadU32(&d);

        // the name might be longer than our buffer can hold
        RPCDeserializer_EnsureSize(&d, ALIGN4(name_length));
        const char* name  = RPCDeserializer_ReadString(&d, &namePtr, name_length);
        uint32_t afterNameBufferLeft = RPCDeserializer_BufferLeft(&d);

        RPCDeserializer_EnsureSize(&d, 12);
        lastCookie = RPCDeserializer_ReadU64(&d);

        const fattr3* attribsPtr = 0;
        uint32_t bufferLeftBeforeAttribs;
        if (RPCDeserializer_ReadBool(&d))
        {
            bufferLeftBeforeAttribs = RPCDeserializer_BufferLeft(&d);
            const fattr3 attribs = RPCDeserializer_ReadFileAttribs(&d);
            attribsPtr = &attribs;
        }

        const fhandle3* handlePtr = 0;
        RPCDeserializer_EnsureSize(&d, 4);
        if (RPCDeserializer_ReadBool(&d))
        {
            const fhandle3 handle = RPCDeserializer_ReadFileHandle(&d);
            handlePtr = &handle;
        }

        if (!fileIter(name, handlePtr, attribsPtr, userData))
        {
            *cookie = lastCookie;
            shouldContinueReading = 0;
            // Flush out recv queue;
            while(((int)d.FragmentSizeLeft) > 0)
            {
                (*(int8_t**)&d.ReadPtr) += RPCDeserializer_BufferLeft(&d);
                assert(RPCDeserializer_BufferLeft(&d) == 0);
                int maxQuerySize = d.MaxBuffer;
                if(d.FragmentSizeLeft < maxQuerySize)
                    maxQuerySize = d.FragmentSizeLeft;
                RPCDeserializer_EnsureSize(&d, maxQuerySize);
            }
            goto Lreturn;
        }
        RPCDeserializer_EnsureSize(&d, 4);
        hasNext = RPCDeserializer_ReadBool(&d);
    }
    // printf(""Writing lastCookie into ptr"");
    *cookie = lastCookie;
    RPCDeserializer_EnsureSize(&d, 4);
    shouldContinueReading = !RPCDeserializer_ReadBool(&d);
Lreturn:
    return shouldContinueReading;

}

int nfs_readdir(int nfs_fd, const fhandle3* dir
               , uint64_t *cookie, uint64_t *cookieverf
               , int (*dirIter)(const char* fName, uint64_t fileId) )
{
    RPCSerializer s = {0};

    mountlist_t* result = 0;

    uint32_t readdir_xid = RPCSerializer_InitCall(&s,
            NFS_PROGRAM, 3, NFS_READDIR_PROCEDURE);

    PushUnixAuthN(&s);


    int length = fhandle3_length(dir);
    RPCSerializer_PushString(&s, length, (const char*)dir->handle);

    uint32_t cookie_hi = *cookie >> 32;
    uint32_t cookie_lw = *cookie & 0xFFFFFFFF;

    uint32_t cookie_verif_hi = *cookieverf >> 32;
    uint32_t cookie_verif_lw = *cookieverf & 0xFFFFFFFF;

    RPCSerializer_PushU32(&s, cookie_hi);
    RPCSerializer_PushU32(&s, cookie_lw);

    RPCSerializer_PushU32(&s, cookie_verif_hi);
    RPCSerializer_PushU32(&s, cookie_verif_lw);

    RPCSerializer_PushU32(&s, 2048); // max size of result structure

    RPCSerializer_Finalize(&s);
    RPCSerializer_Send(&s, nfs_fd);

    RPCDeserializer d;
    RPCDeserializer_Init(&d, nfs_fd);

    const RPCHeader header = RPCDeserializer_RecvHeader(&d);
    int accepted = RPCDeserializer_ReadBool(&d);  //16
    RPCDeserializer_SkipAuth(&d);
    int accept_state = RPCDeserializer_ReadBool(&d);
    nfsstat3 status = (nfsstat3)RPCDeserializer_ReadU32(&d);

    if (status != 0) printf(""Status: %s\n"", nfsstat3_toChars(status));

    bool hasAttrs = RPCDeserializer_ReadBool(&d);
    if (hasAttrs)
    {
        RPCDeserializer_ReadFileAttribs(&d);
    }

    *cookieverf = RPCDeserializer_ReadU64(&d);
    cookie3 lastCookie;
    for(;;)
    {
        bool hasNext = RPCDeserializer_ReadBool(&d);
        if (!hasNext)
            break;
        fileid3 fileId = RPCDeserializer_ReadU64(&d);

        uint32_t name_length = RPCDeserializer_ReadU32(&d);

        char str_buf[1024];
        char* writePtr = str_buf;

        const char* fname = RPCDeserializer_ReadString(&d, &writePtr, name_length);

        lastCookie = RPCDeserializer_ReadU64(&d);
        if (!dirIter(fname, fileId))
            break;
    }
    bool wasLastList = RPCDeserializer_ReadBool(&d);

    return !wasLastList;
    // printf(""%x %x %x %x"", *readPtr++, *readPtr++, *readPtr++, *readPtr++);

}

#ifndef _WIN32
#  define INVALID_SOCKET -1
#endif

struct search_dir_t
{
    const char* name;
    fhandle3 result_handle;
};

int searchDir_cb(const char* fName, const fhandle3* handle,
                 const fattr3* attribs, void* userData)
{
    struct search_dir_t *search_req = (struct search_dir_t*) userData;
    // printf(""name: %s [%d] {%s}\n"", fName, attribs->size, ftype3_toChars(attribs->type));
    if (0 == strcmp(search_req->name, fName))
    {
        assert(handle);
        search_req->result_handle = *handle;
        return 0;
    }
    return 1;
}

typedef struct populate_cache_cb_args_t
{
    cache_t* cache;
    meta_data_entry_t* parentDir;
} populate_cache_cb_args_t;

int populateCache_cb(const char* fName, const fhandle3* handle,
                     const fattr3* attribs, void* userData)
{
    populate_cache_cb_args_t* args =
        (populate_cache_cb_args_t*) userData;

    cache_t* cache = args->cache;
    meta_data_entry_t* parentDir = args->parentDir;

    const uint32_t len = strlen(fName);
    meta_data_entry_t* entry = 0;

    if (attribs)
    {
        if (attribs->type == NF3DIR)
        {
            if (!parentDir->cached_dir)
            {
                parentDir->cached_dir = cache->dir_entries + cache->dir_entries_size++;
            }
            entry = GetOrCreateSubdirectory(cache, parentDir->cached_dir, fName, len);
            if (
                   (fName[0] != '.' && fName[1] != '\0')
                && (fName[0] != '.' && fName[1] != '.' && fName[2] != '\0')
            )
            {
                // printf(""reading dir: %s\n"", fName);
                uint64_t cookie = 0;
                uint64_t verifier = 0;
                populate_cache_cb_args_t newArgs = {
                    args->cache, entry
                };

                SOCKET newSock = connect_name(""192.168.178.26"", ""2049"");
                nfs_readdirplus(newSock, handle, &cookie, &verifier
                  , populateCache_cb, &newArgs);
                closesocket(newSock);
            }
        }
        else if (attribs->type == NF3REG)
        {
            entry = CreateFileEntry(cache, parentDir, fName, len);
            entry->cached_file->size = attribs->size;
        }
        else
        {
            printf(""Unexpected type: %s on file: %s\n"", ftype3_toChars(attribs->type), fName);
            return 1;
        }
    }
    else
    {
        printf(""No attribs for: %s\n"", fName);
    }
    if (handle)
    {
        entry->handle = handleToPtr(cache, handle);
    }

    return 1;
}

uint32_t handleSum(const fhandle3* handle)
{
    uint32_t sum = 0;

    for(int i = 0; i < fhandle3_length(handle); i++)
    {
        sum += handle->handle[i];
    }

    return sum;
}

",initial_files_capacity
309,"/**
 * Eggs.SQLite <eggs/sqlite/error.hpp>
 * 
 * Copyright <NAME>, Fusion Fenix 2012
 * 
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 * 
 * Library home page: http://github.com/eggs-cpp/eggs-sqlite
 */

#ifndef EGGS_SQLITE_ERROR_HPP
#define EGGS_SQLITE_ERROR_HPP

#include <eggs/sqlite/detail/sqlite3.hpp>

#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>

#include <string>

namespace eggs { namespace sqlite {

    struct result_code
    {
        enum enum_type
        {
            ok = SQLITE_OK /* Successful result */

          , error = SQLITE_ERROR /* SQL error or missing database */
          , internal = SQLITE_INTERNAL /* Internal logic error in SQLite */
          , perm = SQLITE_PERM /* Access permission denied */
          , abort = SQLITE_ABORT /* Callback routine requested an abort */
          , busy = SQLITE_BUSY /* The database file is locked */
          , locked = SQLITE_LOCKED /* A table in the database is locked */
          , no_mem = SQLITE_NOMEM /* A malloc() failed */
          , read_only = SQLITE_READONLY /* Attempt to write a readonly database */
          , interrupt = SQLITE_INTERRUPT /* Operation terminated by sqlite3_interrupt()*/
          , io_error = SQLITE_IOERR /* Some kind of disk I/O error occurred */
          , corrupt = SQLITE_CORRUPT /* The database disk image is malformed */
          , not_found = SQLITE_NOTFOUND /* Unknown opcode in sqlite3_file_control() */
          , full = SQLITE_FULL /* Insertion failed because database is full */
          , cant_open = SQLITE_CANTOPEN /* Unable to open the database file */
          , protocol = SQLITE_PROTOCOL /* Database lock protocol error */
          , empty = SQLITE_EMPTY /* Database is empty */
          , schema = SQLITE_SCHEMA /* The database schema changed */
          , too_big = SQLITE_TOOBIG /* String or BLOB exceeds size limit */
          , contraint = SQLITE_CONSTRAINT /* Abort due to constraint violation */
          , mismatch = SQLITE_MISMATCH /* Data type mismatch */
          , misuse = SQLITE_MISUSE /* Library used incorrectly */
          , no_lfs = SQLITE_NOLFS /* Uses OS features not supported on host */
          , auth = SQLITE_AUTH /* Authorization denied */
          , format = SQLITE_FORMAT /* Auxiliary database format error */
          , range = SQLITE_RANGE /* 2nd parameter to sqlite3_bind out of range */
          , not_a_db = SQLITE_NOTADB /* File opened that is not a database file */
          , row = SQLITE_ROW /* sqlite3_step() has another row ready */
          , done = SQLITE_DONE /* sqlite3_step() has finished executing */
        };
    };

    namespace detail {

        class sqlite_category_impl
          : public boost::system::error_category
        {
        public:
            virtual char const* name() const
            {
                return ""sqlite"";
            }

            virtual std::string message( int error_code ) const
            {
                switch ( error_code )
                {
                case result_code::ok:
                    return ""OK"";

                case result_code::error:
                    return ""SQL error or missing database"";
                case result_code::internal:
                    return ""Internal logic error in SQLite"";
                case result_code::perm:
                    return ""Access permission denied"";
                case result_code::abort:
                    return ""Callback routine requested an abort"";
                case result_code::busy:
                    return ""The database file is locked"";
                case result_code::locked:
                    return ""A table in the database is locked"";
                case result_code::no_mem:
                    return ""A malloc() failed"";
                case result_code::read_only:
                    return ""Attempt to write a readonly database"";
                case result_code::interrupt:
                    return ""Operation terminated by sqlite3_interrupt()"";
                case result_code::io_error:
                    return ""Some kind of disk I/O error occurred"";
                case result_code::corrupt:
                    return ""The database disk image is malformed"";
                case result_code::not_found:
                    return ""Unknown opcode in sqlite3_file_control()"";
                case result_code::full:
                    return ""Insertion failed because database is full"";
                case result_code::cant_open:
                    return ""Unable to open the database file"";
                case result_code::protocol:
                    return ""Database lock protocol error"";
                case result_code::empty:
                    return ""Database is empty"";
                case result_code::schema:
                    return ""The database schema changed"";
                case result_code::too_big:
                    return ""String or BLOB exceeds size limit"";
                case result_code::contraint:
                    return ""Abort due to constraint violation"";
                case result_code::mismatch:
                    return ""Data type mismatch"";
                case result_code::misuse:
                    return ""Library used incorrectly"";
                case result_code::no_lfs:
                    return ""Uses OS features not supported on host"";
                case result_code::auth:
                    return ""Authorization denied"";
                case result_code::format:
                    return ""Auxiliary database format error"";
                case result_code::range:
                    return ""2nd parameter to sqlite3_bind out of range"";
                case result_code::not_a_db:
                    return ""File opened that is not a database file"";
                case result_code::row:
                    return ""sqlite3_step() has another row ready"";
                case result_code::done:
                    return ""sqlite3_step() has finished executing"";

                default:
                    return ""Unknown SQLite error"";
                }
            }
        };

    } // namespace detail
    
    inline boost::system::error_category const& sqlite_category()
    {
        static detail::sqlite_category_impl  [MASK] ;
        
        return  [MASK] ;
    }
    
    inline boost::system::error_code make_error_code( result_code::enum_type error )
    {
        return
            boost::system::error_code(
                static_cast< int >( error )
              , sqlite_category()
            );
    }

    inline boost::system::error_condition make_error_condition( result_code::enum_type error )
    {
        return
            boost::system::error_condition(
                static_cast< int >( error )
              , sqlite_category()
            );
    }

    class sqlite_error
      : public boost::system::system_error
    {
    public:
        explicit sqlite_error( int result_code )
          : boost::system::system_error(
                boost::system::error_code(
                    result_code
                  , sqlite_category()
                )
            )
        {}
    };

    class sqlite_syntax_error
      : public sqlite_error
    {
    public:
        explicit sqlite_syntax_error( sqlite3* db_handle = 0 )
          : sqlite_error( result_code::error )
          , _message(
                db_handle != 0
                  ? sqlite3_errmsg( db_handle )
                  : 0
            )
        {}

        char const* message() const
        {
            return _message.c_str();
        }

        char const* what() const
        {
            if( _what.empty() )
            {
                try
                {
                    _what = sqlite_error::what();
                    if( !_what.empty() )
                        _what += "": "";
                    _what += _message;
                } catch( ... ) {
                    return sqlite_error::what();
                }
            }
            return _what.c_str();
        }

    private:
        std::string _message;
        mutable std::string _what;
    };

} } // namespace eggs::sqlite

namespace boost { namespace system {

    template<>
    struct is_error_code_enum< eggs::sqlite::result_code::enum_type >
    {
        static const bool value = true;
    };

} } // namespace boost::system

#endif /*EGGS_SQLITE_ERROR_HPP*/
",category_instance
310,"#include <DHT.h>
#include <PubSubClient.h>
#include <ESP8266WiFi.h>

// Replace these with your WiFi and MQTT credentials
const char* ssid = ""Seline"";
const char* password = ""<PASSWORD>"";
const char* mqtt_server = ""172.16.31.10"";
const int mqtt_port = 1883;

const char* mqtt_topic_temperature = ""DT/temperature"";
const char* mqtt_topic_humidity = ""DT/humidity"";
const char* mqtt_topic_gas = ""MQ/gas"";

const int MQ2_PIN = A0; // Connect the MQ2 sensor analog output to A0
const int DHT_PIN = D2; // Connect DHT11 data pin to D2

DHT dht(DHT_PIN, DHT11);
WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  delay(10);

  pinMode(DHT_PIN, INPUT);
  dht.begin();

  connectToWiFi();
  client.setServer(mqtt_server, mqtt_port);
}

void connectToWiFi() {
  Serial.println(""Connecting to WiFi..."");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println(""Connecting to WiFi..."");
  }
  Serial.println(""Connected to WiFi"");
}

void reconnect() {
  while (!client.connected()) {
    Serial.println(""Attempting MQTT connection..."");
    if (client.connect(""arduino-client"")) {
      Serial.println(""Connected to MQTT server"");
    } else {
      Serial.print(""Failed to connect to MQTT server, rc="");
      Serial.print(client.state());
      Serial.println("" Retrying in 5 seconds..."");
      delay(5000);
    }
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }

  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();
  int  [MASK]  = analogRead(MQ2_PIN);


  if (isnan(temperature) || isnan(humidity)) {
    Serial.println(""Failed to read data from DHT sensor"");
    delay(2000);
    return;
  }

  Serial.print(""Temperature: "");
  Serial.println(temperature);
  Serial.print(""Humidity: "");
  Serial.println(humidity);
  Serial.print(""Gas Value: "");
  Serial.println( [MASK] );

  char temperatureStr[8];
  char humidityStr[8];
  char gasStr[8];
  dtostrf(temperature, 6, 2, temperatureStr);
  dtostrf(humidity, 6, 2, humidityStr);
  itoa( [MASK] , gasStr, 10);

  client.publish(mqtt_topic_temperature, temperatureStr);
  client.publish(mqtt_topic_humidity, humidityStr);
  client.publish(mqtt_topic_gas, gasStr);

  delay(1200000); // Publish data every 20 min

}",gasValue
311,"#include ""donewdialog.h""
#include ""ui_donewdialog.h""

DoNewDialog::DoNewDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::DoNewDialog)
{
    ui->setupUi(this);
    backColor=Qt::white;
}

DoNewDialog::~DoNewDialog()
{
    delete ui;
}

double DoNewDialog::getWidth()
{
    return ui->widthSpinBox->text().toDouble();
}

double DoNewDialog::getHeight()
{
    return ui->heightSpinBox->text().toDouble();
}
QColor DoNewDialog::getBackColor()
{
    return backColor;
}

void DoNewDialog::on_toolButton_clicked()
{
    //创建颜色对话框
    QColor  [MASK] =QColorDialog::getColor();
    if( [MASK] .isValid())//可用颜色
    {
        backColor =  [MASK] ;
        //调色
        QPalette palette = ui->textBrowser->palette();
        palette.setColor(QPalette::Base,backColor);//设置颜色
        ui->textBrowser->setPalette(palette);//设置textBrower中颜色
        update();
    }
}
",newColor
312,"//
// Created by 李卫东 on 2019-02-18.
//
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>

#include ""appbase/application.hpp""
#include ""hb/log_plugin/log_plugin.h""
#include ""hb/qdii_monitor_plugin/qdii_monitor_plugin.h""

using namespace appbase;
using namespace hb::plugin;

int main(int argc, char **argv) {
    auto  [MASK]  = boost::filesystem::initial_path<boost::filesystem::path>();
    app().set_default_config_dir( [MASK]  / ""config"");
    app().set_default_data_dir( [MASK]  / ""data"");
    // app().
    if (!app().initialize<qdii_monitor_plugin>(argc, argv)) return 1;
    printf(""app version %s\n"", app().version_string().c_str());
    printf(""app config directory is %s\n"", app().config_dir().c_str());
    printf(""app using config file %s\n"", app().full_config_file_path().string().c_str());
    printf(""app using log config file %s\n"", app().get_logging_conf().string().c_str());
    printf(""app data directory is %s\n"", app().data_dir().string().c_str());
    app().startup();
    app().exec();
    return 0;
}",exePath
313,"
#include ""PlayerController_InGame.h""
#include ""EnhancedInputSubsystems.h""
#include ""EnhancedInputComponent.h""
#include ""Logging/LogMacros.h""


DEFINE_LOG_CATEGORY(TEST);

APlayerController_InGame::APlayerController_InGame()
{
}

void APlayerController_InGame::BeginPlay()
{
    Super::BeginPlay();

    FInputModeGameOnly InputMode;
    SetInputMode(InputMode);
    bShowMouseCursor = true;

    if (UEnhancedInputLocalPlayerSubsystem* Subsystem =
        ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer()))
    {
        Subsystem->AddMappingContext(DefaultMappingContext, 0);
    }
}

void APlayerController_InGame::Possess(APawn* InPawn)
{
    Super::Possess(InPawn);


}

void APlayerController_InGame::SetupInputComponent()
{
    Super::SetupInputComponent();

    // Add Input Mapping Context
    if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer()))
    {
        Subsystem->AddMappingContext(DefaultMappingContext, 0);
    }

    if (UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(InputComponent))
    {
        EnhancedInputComponent->BindAction(MouseMoving, ETriggerEvent::Triggered, this, &APlayerController_InGame::HandleMouseMoving);
        EnhancedInputComponent->BindAction(MouseClick, ETriggerEvent::Completed, this, &APlayerController_InGame::HandleMouseClick);
    }
}

void APlayerController_InGame::HandleMouseMoving(const FInputActionValue& Value)
{
    FVector2D  [MASK]  = Value.Get<FVector2D>();
    AddYawInput( [MASK] .X);
    AddPitchInput( [MASK] .Y);
}

void APlayerController_InGame::HandleMouseClick(const FInputActionValue& Value)
{
}
",Delta
314,"#include <bits/stdc++.h>

using namespace std;

/*************************************************************************************************************
 *                                              
 * Link : https://practice.geeksforgeeks.org/problems/max-rectangle/1
 * Description:
 *  Given a binary matrix. 
 *  Find the maximum area of a rectangle formed only of 1s in the given matrix.
 *  Expected Time Complexity : O(n*m)
 *  Expected Auixiliary Space : O(m)
 * Resources:
 *  https://www.geeksforgeeks.org/maximum-size-rectangle-binary-sub-matrix-1s/
 *  https://leetcode.com/problems/maximal-square/solution/#
 * 
*************************************************************************************************************/

#define si(x) scanf(""%d"", &x)
#define sll(x) scanf(""%lld"", &x)
#define ss(s) getline(cin, s)
#define pi(x) printf(""%d\n"", x)
#define pll(x) printf(""%lld\n"", x)
#define ps(s) cout << s << ""\n""
#define fo(i, n) for (int i = 0; i < n; i++)
// #define fo(i, k, n) for (int i = k; k < n ? i < n : i >= n; k < n ? i++ : i--)
#define ll long long
#define deb(x) cout << #x << ""="" << x << ""\n""
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(a, it) for (auto it = a.begin(); it != a.end(); it++)
#define present(c, x) (c.find(x) != c.end())
#define cpresent(c, x) (find(all(c), x) != c.end())

typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<vi> vvi;
typedef vector<vl> vvl;

int maxHist(int row[], int n)
{
    stack<int> result;

    int top_val,  [MASK] {0}, area{0};

    int i{0};
    while (i < n)
    {
        if (result.empty() || row[result.top()] <= row[i])
            result.push(i++);

        else
        {
            top_val = row[result.top()];
            result.pop();
            area = top_val * i;

            if (!result.empty())
                area = top_val * (i - result.top() - 1);
             [MASK]  = max(area,  [MASK] );
        }
    }

    while (!result.empty())
    {
        top_val = row[result.top()];
        result.pop();
        area = top_val * i;
        if (!result.empty())
            area = top_val * (i - result.top() - 1);

         [MASK]  = max(area,  [MASK] );
    }
    
    return  [MASK] ;
}

int main()
{
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    srand(chrono::high_resolution_clock::now().time_since_epoch().count());

    int t{0};
    si(t);

    while (t--)
    {
        int m{0}, n{0};
        si(m);
        si(n);

        int arr[m][n];
        fo(i, m)
        {
            fo(j, n)
            {
                si(arr[i][j]);
            }
        }

        int result = maxHist(arr[0], n);

        for (int i = 1; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (arr[i][j] == 1)
                {
                    arr[i][j] += arr[i - 1][j];
                }
            }
            result = max(result, maxHist(arr[i], n));
        }

        ps(result);
    }

    return 0;
}",max_area
315,"#include <iostream>
#include <vector>

#include <spdlog/spdlog.h>
#include <fmt/format.h>
#include <docopt/docopt.h>

#include <imgui.h>
#include <imgui-SFML.h>
#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/System/Clock.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Graphics/CircleShape.hpp>

#include <iostream>

static constexpr auto USAGE =
  R""(C++ Weekly Game.

    Usage:
        game [options]

 Options:
          -h --help         Show this screen.
          --width=WIDTH     Scaling width in pixels [default: 1024]
          --height=HEIGHT   Scaling height in pixels [default: 768]
          --scale=SCALE     Scaling factor [default: 2]
)"";

int main(int argc, const char **argv)
{
  std::map<std::string, docopt::value> args = docopt::docopt(USAGE,
    { std::next(argv), std::next(argv, argc) },
    true);// version string

  const auto width = args[""--width""].asLong();
  const auto height = args[""--height""].asLong();
  const auto scale = args[""--scale""].asLong();

  if (width < 0 || height < 0 || scale < 1 || scale > 5) {
    spdlog::error(""Command line options are outside reasonable range!"");
    for (const auto &arg : args) {
      if (arg.second.isString()) {
        spdlog::info(""Parameter set: {}: {}"", arg.first, arg.second.asString());
      }
    }
    abort();
  }

  // Use the default logger (stdout, multi-threaded, colored)
  spdlog::info(""Hello, {}!"", ""World"");

  sf::RenderWindow window(sf::VideoMode(static_cast<unsigned int>(width),
                            static_cast<unsigned int>(height)),
    ""ImGui + SFML = <3"");
  window.setFramerateLimit(60);
  ImGui::SFML::Init(window);

  const auto scale_factor = static_cast<float>(scale);
  ImGui::GetStyle().ScaleAllSizes(scale_factor);
  ImGui::GetIO().FontGlobalScale = scale_factor;


  sf::CircleShape shape(100.F);
  shape.setFillColor(sf::Color::Green);

  constexpr std::array steps = { ""The Plan"",
    ""Getting Started"",
    ""Finding Errors As Soon As Possible"",
    ""Handling Command Line Parameters"",
    ""Reading SFML Input States"",
    ""Managing Game State"",
    ""Making the Game Testable"",
    ""Making Game State Allocator Aware"",
    ""Add Logging to Game Engine"",
    ""Draw A Game Map"",
    ""Dialog Trees"",
    ""Porting from SFML to SDL"" };
  std::array<bool, steps.size()> states{};

  sf::Clock  [MASK] ;
  while (window.isOpen()) {
    sf::Event event{};
    while (window.pollEvent(event)) {
      ImGui::SFML::ProcessEvent(event);

      if (event.type == sf::Event::Closed) { window.close(); }
    }

    ImGui::SFML::Update(window,  [MASK] .restart());

    ImGui::Begin(""The Plan"");

    std::size_t index = 0;
    for (const auto &step : steps) {
      ImGui::Checkbox(
        fmt::format(""{} : {}"", index, step).c_str(), &states.at(index));
      ++index;
    }

    ImGui::End();

    window.clear();
    window.draw(shape);
    ImGui::SFML::Render(window);
    window.display();
  }

  ImGui::SFML::Shutdown();
  return 0;
}
",deltaClock
316,"
#include ""AppComponent.hpp""
#include ""DatabaseComponent.hpp""
#include ""ServiceComponent.hpp""
#include ""controller/PasteController.hpp""

#include ""oatpp/network/Server.hpp""

#include <iostream>

void run(const oatpp::base::CommandLineArguments &args) {

  AppComponent appComponent(args);
  ServiceComponent  [MASK] ;
  DatabaseComponent databaseComponent;

  /* create ApiControllers and add endpoints to router */

  auto router =  [MASK] .httpRouter.getObject();
  router->addController(PasteController::createShared());

  /* create server */

  oatpp::network::Server server(
       [MASK] .serverConnectionProvider.getObject(),
       [MASK] .serverConnectionHandler.getObject());

  OATPP_LOGD(""Server"", ""Running on port %s..."",
              [MASK] .serverConnectionProvider.getObject()
                 ->getProperty(""port"")
                 .toString()
                 ->c_str());

  server.run();
}

int main(int argc, const char *argv[]) {

  oatpp::base::Environment::init();

  run(oatpp::base::CommandLineArguments(argc, argv));

  oatpp::base::Environment::destroy();

  return 0;
}
",serviceComponent
317,"#include ""GameLayer.h""
#include ""Hero.h""
#include ""PlaneEnemy.h""
#include ""CombatManager.h""
#include ""Bullet.h""

GameLayer::GameLayer()
: m_pHero(NULL),
m_nKeyPressed(0),
m_bIsPressed(false),
m_nbgSpeed(1)
{
}


GameLayer::~GameLayer()
{
}

bool GameLayer::init()
{
	if (!Layer::init())
	{
		return false;
	}
	m_pHero = Hero::create();
	m_pHero->setPosition(Director::getInstance()->getVisibleSize().width / 2, 50);
	addChild(m_pHero, 2);
	m_pHero->SetLayer(this);
	GetCombatManager()->SetRunGameLayer(this);

	//在基类场景增加键盘按键移动飞机和飞机射出子弹的控制
	auto keyboardEventListener = EventListenerKeyboard::create();
	keyboardEventListener->onKeyPressed = CC_CALLBACK_2(GameLayer::onKeyPressed, this);
	keyboardEventListener->onKeyReleased = CC_CALLBACK_2(GameLayer::onKeyReleased, this);
	_eventDispatcher->addEventListenerWithSceneGraphPriority(keyboardEventListener, m_pHero);
	return true;
}

void GameLayer::Update(float dt)
{
	UpdateHero(dt);
	UpdateEnemy(dt);
	UpdateBullet(dt);
	ProductEnemy(dt);
}
void GameLayer::UpdateHero(float dt)
{
	m_pHero->Update(dt);

}
void GameLayer::UpdateEnemy(float dt)
{
	for (auto it = m_enemyList.begin(); it != m_enemyList.end(); /*++it*/)
	{
        if ((*it)->IsDeath() || !IsInMap(**it))
		{
            (*it)->removeFromParent();
			m_enemyList.erase(it++);
		}
		else
		{
			(*it)->Update(dt);
			++it;
		}
	}
}
void GameLayer::UpdateBullet(float dt)
{
	// m_heroBulletList;
    for (auto it = m_heroBulletList.begin(); it != m_heroBulletList.end(); /*++it*/)
    {
        for (auto enemy = m_enemyList.begin(); enemy != m_enemyList.end(); ++enemy)
        {
            if (!(*enemy)->IsDeath() || !IsInMap(**it))
            {
                if ((*it)->HitTest(*enemy, dt))
                {
                    break;
                }
            }
        }
        // (*it)->Update(dt);
        ++it;
    }
	for (auto it = m_heroBulletList.begin(); it != m_heroBulletList.end(); /*++it*/)
	{
        if ((*it)->IsDeath() || !IsInMap(**it))
		{
            (*it)->removeFromParent();
			m_heroBulletList.erase(it++);
		}
		else
		{
			(*it)->Update(dt);
			++it;
		}
	}

	// m_enemyBulletList;
    for (auto it = m_enemyBulletList.begin(); it != m_enemyBulletList.end(); ++it)
    {
        (*it)->HitTest(m_pHero, dt);
    }
	for (auto it = m_enemyBulletList.begin(); it != m_enemyBulletList.end(); /*++it*/)
	{
		if ((*it)->IsDeath() || !IsInMap (**it))
		{
            (*it)->removeFromParent();
			m_enemyBulletList.erase(it++);
		}
		else
		{
			// (*it)->HitTest(m_pHero, dt);
			(*it)->Update(dt);
			++it;
		}
	}
}
void GameLayer::ProductEnemy(float dt)
{
	if (m_enemyList.empty())
	{
		AirPlane* pAP = PlaneEnemy::create();
		pAP->setPosition(Director::getInstance()->getVisibleSize().width / 2, 300);
		addChild(pAP, 1, ""enemy"");
		pAP->SetLayer(this);
		m_enemyList.push_back(pAP);
	}
}

bool GameLayer::IsInMap(const SceneNode& node)
{
    static Size size = Director::getInstance()->getVisibleSize();
    Rect rect = node.getTextureRect();
    Point p = node.getPosition();
    rect.origin = p;
    if (rect.getMaxX () < 0 || rect.getMinX () > size.width
        || rect.getMinY() > size.height || rect.getMaxY () < 0)
    {
        return false;
    }

    return true;
}

void GameLayer::AddHeroBullet(Bullet* pB)
{
	this->addChild(pB, 3);
	this->m_heroBulletList.push_back(pB);
}
void GameLayer::AddEnemyBullet(Bullet* pB)
{
	this->addChild(pB, 3);
	this->m_enemyBulletList.push_back(pB);
}
// 键盘触摸回调事件
void GameLayer::onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event)
{
	if (keyCode == EventKeyboard::KeyCode::KEY_LEFT_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_UP_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_RIGHT_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_DOWN_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_A
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_W
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_D
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_S
		|| keyCode == EventKeyboard::KeyCode::KEY_A
		|| keyCode == EventKeyboard::KeyCode::KEY_W
		|| keyCode == EventKeyboard::KeyCode::KEY_D
		|| keyCode == EventKeyboard::KeyCode::KEY_S)
	{
		m_bIsPressed = true;
		switch (keyCode)
		{
		case cocos2d::EventKeyboard::KeyCode::KEY_RIGHT_ARROW:
		{
																 m_pHero->SetSpeed(Point(300, 0));
		}
			break;
		case cocos2d::EventKeyboard::KeyCode::KEY_UP_ARROW:
		{
															  m_pHero->SetSpeed(Point(0, 300));
		}
			break;
		case cocos2d::EventKeyboard::KeyCode::KEY_DOWN_ARROW:
		{
																m_pHero->SetSpeed(Point(0, -300));
		}
			break;
		case cocos2d::EventKeyboard::KeyCode::KEY_LEFT_ARROW:
		{
																m_pHero->SetSpeed(Point(-300, 0));
		}
			break;
		case cocos2d::EventKeyboard::KeyCode::KEY_CAPITAL_A:
		{
															   m_pHero->SetSpeed(Point(-300, 0));
		}
			break;

		case cocos2d::EventKeyboard::KeyCode::KEY_CAPITAL_D:
		{
															   m_pHero->SetSpeed(Point(300, 0));
		}
			break;

		case cocos2d::EventKeyboard::KeyCode::KEY_CAPITAL_S:
		{
															   m_pHero->SetSpeed(Point(0, -300));
		}
			break;

		case cocos2d::EventKeyboard::KeyCode::KEY_CAPITAL_W:
		{
															   m_pHero->SetSpeed(Point(0, 300));
		}
															   break;

		case cocos2d::EventKeyboard::KeyCode::KEY_A:
		{
													   m_pHero->SetSpeed(Point(-300, 0));
		}
			break;

		case cocos2d::EventKeyboard::KeyCode::KEY_D:
		{
													   m_pHero->SetSpeed(Point(300, 0));
		}
			break;

		case cocos2d::EventKeyboard::KeyCode::KEY_S:
		{
													   m_pHero->SetSpeed(Point(0, -300));
		}
			break;

		case cocos2d::EventKeyboard::KeyCode::KEY_W:
		{
													   m_pHero->SetSpeed(Point(0, 300));

		}
			break;
		default:
			return;
		}
			m_nKeyPressed++;
			m_bIsPressed = true;
			schedule(CC_SCHEDULE_SELECTOR(GameLayer::HeroMove));
		}
}

void GameLayer::onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event)
{
	if (keyCode == EventKeyboard::KeyCode::KEY_LEFT_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_UP_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_RIGHT_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_DOWN_ARROW
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_A
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_W
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_D
		|| keyCode == EventKeyboard::KeyCode::KEY_CAPITAL_S
		|| keyCode == EventKeyboard::KeyCode::KEY_A
		|| keyCode == EventKeyboard::KeyCode::KEY_W
		|| keyCode == EventKeyboard::KeyCode::KEY_D
		|| keyCode == EventKeyboard::KeyCode::KEY_S)
	{
		if (m_bIsPressed)
		{
			m_nKeyPressed--;
			if (m_nKeyPressed <= 0)
			{
				m_bIsPressed = false;
				unschedule(CC_SCHEDULE_SELECTOR(GameLayer::HeroMove));
			}
		}
	}
}

void GameLayer::HeroMove(float dt)
{
	auto heroCurrentPos = m_pHero->getPosition();
	auto size = Director::getInstance()->getVisibleSize();
	auto  [MASK]  = m_pHero->getContentSize();
	if (m_pHero->GetSpeed().x <= 0 && m_pHero->GetSpeed().y <= 0)
	{
		if (heroCurrentPos.x -  [MASK] .width / 2 < 0 || heroCurrentPos.y -  [MASK] .height / 2 < 0)
		{
			return;
		}
	}
	else if(m_pHero->GetSpeed().x <= 0 && m_pHero->GetSpeed().y > 0)
	{
		if (heroCurrentPos.x -  [MASK] .width / 2 < 0 || heroCurrentPos.y +  [MASK] .height / 2 > size.height)
		{
			return;
		}
	}
	else if (m_pHero->GetSpeed().x > 0 && m_pHero->GetSpeed().y <= 0)
	{
		if (heroCurrentPos.x +  [MASK] .width / 2 > size.width || heroCurrentPos.y -  [MASK] .height / 2 < 0)
		{
			return;
		}
	}
	else if (m_pHero->GetSpeed().x > 0 && m_pHero->GetSpeed().y > 0)
	{
		if (heroCurrentPos.x +  [MASK] .width / 2 > size.width || heroCurrentPos.y +  [MASK] .height / 2 > size.height)
		{
			return;
		}
	}
	else
	{
		return;
	}
	m_pHero->Moving(dt);
}

Hero *GameLayer::GetHero()
{
	if (NULL != m_pHero)
	{
		return m_pHero;
	}
	else
	{
		return NULL;
	}
}

void GameLayer::RockerMoveHero()
{
	schedule(CC_SCHEDULE_SELECTOR(GameLayer::HeroMove));
}

void GameLayer::RockerStopMoveHero()
{
	unschedule(CC_SCHEDULE_SELECTOR(GameLayer::HeroMove));
}
",heroSize
318,"//===-- ARMBaseInstrInfo.cpp - ARM Instruction Information ----------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the Base ARM implementation of the TargetInstrInfo class.
//
//===----------------------------------------------------------------------===//

#include ""ARM.h""
#include ""ARMBaseInstrInfo.h""
#include ""ARMBaseRegisterInfo.h""
#include ""ARMConstantPoolValue.h""
#include ""ARMFeatures.h""
#include ""ARMHazardRecognizer.h""
#include ""ARMMachineFunctionInfo.h""
#include ""MCTargetDesc/ARMAddressingModes.h""
#include ""llvm/ADT/STLExtras.h""
#include ""llvm/CodeGen/LiveVariables.h""
#include ""llvm/CodeGen/MachineConstantPool.h""
#include ""llvm/CodeGen/MachineFrameInfo.h""
#include ""llvm/CodeGen/MachineInstrBuilder.h""
#include ""llvm/CodeGen/MachineJumpTableInfo.h""
#include ""llvm/CodeGen/MachineMemOperand.h""
#include ""llvm/CodeGen/MachineRegisterInfo.h""
#include ""llvm/CodeGen/SelectionDAGNodes.h""
#include ""llvm/CodeGen/TargetSchedule.h""
#include ""llvm/IR/Constants.h""
#include ""llvm/IR/Function.h""
#include ""llvm/IR/GlobalValue.h""
#include ""llvm/MC/MCAsmInfo.h""
#include ""llvm/MC/MCExpr.h""
#include ""llvm/Support/BranchProbability.h""
#include ""llvm/Support/CommandLine.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/Support/ErrorHandling.h""
#include ""llvm/Support/raw_ostream.h""

using namespace llvm;

#define DEBUG_TYPE ""arm-instrinfo""

#define GET_INSTRINFO_CTOR_DTOR
#include ""ARMGenInstrInfo.inc""

static cl::opt<bool>
EnableARM3Addr(""enable-arm-3-addr-conv"", cl::Hidden,
               cl::desc(""Enable ARM 2-addr to 3-addr conv""));

static cl::opt<bool>
WidenVMOVS(""widen-vmovs"", cl::Hidden, cl::init(true),
           cl::desc(""Widen ARM vmovs to vmovd when possible""));

static cl::opt<unsigned>
SwiftPartialUpdateClearance(""swift-partial-update-clearance"",
     cl::Hidden, cl::init(12),
     cl::desc(""Clearance before partial register updates""));

/// ARM_MLxEntry - Record information about MLA / MLS instructions.
struct ARM_MLxEntry {
  uint16_t MLxOpc;     // MLA / MLS opcode
  uint16_t MulOpc;     // Expanded multiplication opcode
  uint16_t AddSubOpc;  // Expanded add / sub opcode
  bool NegAcc;         // True if the acc is negated before the add / sub.
  bool HasLane;        // True if instruction has an extra ""lane"" operand.
};

static const ARM_MLxEntry ARM_MLxTable[] = {
  // MLxOpc,          MulOpc,           AddSubOpc,       NegAcc, HasLane
  // fp scalar ops
  { ARM::VMLAS,       ARM::VMULS,       ARM::VADDS,      false,  false },
  { ARM::VMLSS,       ARM::VMULS,       ARM::VSUBS,      false,  false },
  { ARM::VMLAD,       ARM::VMULD,       ARM::VADDD,      false,  false },
  { ARM::VMLSD,       ARM::VMULD,       ARM::VSUBD,      false,  false },
  { ARM::VNMLAS,      ARM::VNMULS,      ARM::VSUBS,      true,   false },
  { ARM::VNMLSS,      ARM::VMULS,       ARM::VSUBS,      true,   false },
  { ARM::VNMLAD,      ARM::VNMULD,      ARM::VSUBD,      true,   false },
  { ARM::VNMLSD,      ARM::VMULD,       ARM::VSUBD,      true,   false },

  // fp SIMD ops
  { ARM::VMLAfd,      ARM::VMULfd,      ARM::VADDfd,     false,  false },
  { ARM::VMLSfd,      ARM::VMULfd,      ARM::VSUBfd,     false,  false },
  { ARM::VMLAfq,      ARM::VMULfq,      ARM::VADDfq,     false,  false },
  { ARM::VMLSfq,      ARM::VMULfq,      ARM::VSUBfq,     false,  false },
  { ARM::VMLAslfd,    ARM::VMULslfd,    ARM::VADDfd,     false,  true  },
  { ARM::VMLSslfd,    ARM::VMULslfd,    ARM::VSUBfd,     false,  true  },
  { ARM::VMLAslfq,    ARM::VMULslfq,    ARM::VADDfq,     false,  true  },
  { ARM::VMLSslfq,    ARM::VMULslfq,    ARM::VSUBfq,     false,  true  },
};

ARMBaseInstrInfo::ARMBaseInstrInfo(const ARMSubtarget& STI)
  : ARMGenInstrInfo(ARM::ADJCALLSTACKDOWN, ARM::ADJCALLSTACKUP),
    Subtarget(STI) {
  for (unsigned i = 0, e = array_lengthof(ARM_MLxTable); i != e; ++i) {
    if (!MLxEntryMap.insert(std::make_pair(ARM_MLxTable[i].MLxOpc, i)).second)
      llvm_unreachable(""Duplicated entries?"");
    MLxHazardOpcodes.insert(ARM_MLxTable[i].AddSubOpc);
    MLxHazardOpcodes.insert(ARM_MLxTable[i].MulOpc);
  }
}

// Use a ScoreboardHazardRecognizer for prepass ARM scheduling. TargetInstrImpl
// currently defaults to no prepass hazard recognizer.
ScheduleHazardRecognizer *
ARMBaseInstrInfo::CreateTargetHazardRecognizer(const TargetSubtargetInfo *STI,
                                               const ScheduleDAG *DAG) const {
  if (usePreRAHazardRecognizer()) {
    const InstrItineraryData *II =
        static_cast<const ARMSubtarget *>(STI)->getInstrItineraryData();
    return new ScoreboardHazardRecognizer(II, DAG, ""pre-RA-sched"");
  }
  return TargetInstrInfo::CreateTargetHazardRecognizer(STI, DAG);
}

ScheduleHazardRecognizer *ARMBaseInstrInfo::
CreateTargetPostRAHazardRecognizer(const InstrItineraryData *II,
                                   const ScheduleDAG *DAG) const {
  if (Subtarget.isThumb2() || Subtarget.hasVFP2())
    return (ScheduleHazardRecognizer *)new ARMHazardRecognizer(II, DAG);
  return TargetInstrInfo::CreateTargetPostRAHazardRecognizer(II, DAG);
}

MachineInstr *
ARMBaseInstrInfo::convertToThreeAddress(MachineFunction::iterator &MFI,
                                        MachineBasicBlock::iterator &MBBI,
                                        LiveVariables *LV) const {
  // FIXME: Thumb2 support.

  if (!EnableARM3Addr)
    return nullptr;

  MachineInstr *MI = MBBI;
  MachineFunction &MF = *MI->getParent()->getParent();
  uint64_t TSFlags = MI->getDesc().TSFlags;
  bool isPre = false;
  switch ((TSFlags & ARMII::IndexModeMask) >> ARMII::IndexModeShift) {
  default: return nullptr;
  case ARMII::IndexModePre:
    isPre = true;
    break;
  case ARMII::IndexModePost:
    break;
  }

  // Try splitting an indexed load/store to an un-indexed one plus an add/sub
  // operation.
  unsigned MemOpc = getUnindexedOpcode(MI->getOpcode());
  if (MemOpc == 0)
    return nullptr;

  MachineInstr *UpdateMI = nullptr;
  MachineInstr *MemMI = nullptr;
  unsigned AddrMode = (TSFlags & ARMII::AddrModeMask);
  const MCInstrDesc &MCID = MI->getDesc();
  unsigned NumOps = MCID.getNumOperands();
  bool isLoad = !MI->mayStore();
  const MachineOperand &WB = isLoad ? MI->getOperand(1) : MI->getOperand(0);
  const MachineOperand &Base = MI->getOperand(2);
  const MachineOperand &Offset = MI->getOperand(NumOps-3);
  unsigned WBReg = WB.getReg();
  unsigned BaseReg = Base.getReg();
  unsigned OffReg = Offset.getReg();
  unsigned OffImm = MI->getOperand(NumOps-2).getImm();
  ARMCC::CondCodes Pred = (ARMCC::CondCodes)MI->getOperand(NumOps-1).getImm();
  switch (AddrMode) {
  default: llvm_unreachable(""Unknown indexed op!"");
  case ARMII::AddrMode2: {
    bool isSub = ARM_AM::getAM2Op(OffImm) == ARM_AM::sub;
    unsigned Amt = ARM_AM::getAM2Offset(OffImm);
    if (OffReg == 0) {
      if (ARM_AM::getSOImmVal(Amt) == -1)
        // Can't encode it in a so_imm operand. This transformation will
        // add more than 1 instruction. Abandon!
        return nullptr;
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBri : ARM::ADDri), WBReg)
        .addReg(BaseReg).addImm(Amt)
        .addImm(Pred).addReg(0).addReg(0);
    } else if (Amt != 0) {
      ARM_AM::ShiftOpc ShOpc = ARM_AM::getAM2ShiftOpc(OffImm);
      unsigned SOOpc = ARM_AM::getSORegOpc(ShOpc, Amt);
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrsi : ARM::ADDrsi), WBReg)
        .addReg(BaseReg).addReg(OffReg).addReg(0).addImm(SOOpc)
        .addImm(Pred).addReg(0).addReg(0);
    } else
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrr : ARM::ADDrr), WBReg)
        .addReg(BaseReg).addReg(OffReg)
        .addImm(Pred).addReg(0).addReg(0);
    break;
  }
  case ARMII::AddrMode3 : {
    bool isSub = ARM_AM::getAM3Op(OffImm) == ARM_AM::sub;
    unsigned Amt = ARM_AM::getAM3Offset(OffImm);
    if (OffReg == 0)
      // Immediate is 8-bits. It's guaranteed to fit in a so_imm operand.
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBri : ARM::ADDri), WBReg)
        .addReg(BaseReg).addImm(Amt)
        .addImm(Pred).addReg(0).addReg(0);
    else
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrr : ARM::ADDrr), WBReg)
        .addReg(BaseReg).addReg(OffReg)
        .addImm(Pred).addReg(0).addReg(0);
    break;
  }
  }

  std::vector<MachineInstr*> NewMIs;
  if (isPre) {
    if (isLoad)
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc), MI->getOperand(0).getReg())
        .addReg(WBReg).addImm(0).addImm(Pred);
    else
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc)).addReg(MI->getOperand(1).getReg())
        .addReg(WBReg).addReg(0).addImm(0).addImm(Pred);
    NewMIs.push_back(MemMI);
    NewMIs.push_back(UpdateMI);
  } else {
    if (isLoad)
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc), MI->getOperand(0).getReg())
        .addReg(BaseReg).addImm(0).addImm(Pred);
    else
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc)).addReg(MI->getOperand(1).getReg())
        .addReg(BaseReg).addReg(0).addImm(0).addImm(Pred);
    if (WB.isDead())
      UpdateMI->getOperand(0).setIsDead();
    NewMIs.push_back(UpdateMI);
    NewMIs.push_back(MemMI);
  }

  // Transfer LiveVariables states, kill / dead info.
  if (LV) {
    for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
      MachineOperand &MO = MI->getOperand(i);
      if (MO.isReg() && TargetRegisterInfo::isVirtualRegister(MO.getReg())) {
        unsigned Reg = MO.getReg();

        LiveVariables::VarInfo &VI = LV->getVarInfo(Reg);
        if (MO.isDef()) {
          MachineInstr *NewMI = (Reg == WBReg) ? UpdateMI : MemMI;
          if (MO.isDead())
            LV->addVirtualRegisterDead(Reg, NewMI);
        }
        if (MO.isUse() && MO.isKill()) {
          for (unsigned j = 0; j < 2; ++j) {
            // Look at the two new MI's in reverse order.
            MachineInstr *NewMI = NewMIs[j];
            if (!NewMI->readsRegister(Reg))
              continue;
            LV->addVirtualRegisterKilled(Reg, NewMI);
            if (VI.removeKill(MI))
              VI.Kills.push_back(NewMI);
            break;
          }
        }
      }
    }
  }

  MFI->insert(MBBI, NewMIs[1]);
  MFI->insert(MBBI, NewMIs[0]);
  return NewMIs[0];
}

// Branch analysis.
bool
ARMBaseInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
                                MachineBasicBlock *&FBB,
                                SmallVectorImpl<MachineOperand> &Cond,
                                bool AllowModify) const {
  TBB = nullptr;
  FBB = nullptr;

  MachineBasicBlock::iterator I = MBB.end();
  if (I == MBB.begin())
    return false; // Empty blocks are easy.
  --I;

  // Walk backwards from the end of the basic block until the branch is
  // analyzed or we give up.
  while (isPredicated(*I) || I->isTerminator() || I->isDebugValue()) {

    // Flag to be raised on unanalyzeable instructions. This is useful in cases
    // where we want to clean up on the end of the basic block before we bail
    // out.
    bool CantAnalyze = false;

    // Skip over DEBUG values and predicated nonterminators.
    while (I->isDebugValue() || !I->isTerminator()) {
      if (I == MBB.begin())
        return false;
      --I;
    }

    if (isIndirectBranchOpcode(I->getOpcode()) ||
        isJumpTableBranchOpcode(I->getOpcode())) {
      // Indirect branches and jump tables can't be analyzed, but we still want
      // to clean up any instructions at the tail of the basic block.
      CantAnalyze = true;
    } else if (isUncondBranchOpcode(I->getOpcode())) {
      TBB = I->getOperand(0).getMBB();
    } else if (isCondBranchOpcode(I->getOpcode())) {
      // Bail out if we encounter multiple conditional branches.
      if (!Cond.empty())
        return true;

      assert(!FBB && ""FBB should have been null."");
      FBB = TBB;
      TBB = I->getOperand(0).getMBB();
      Cond.push_back(I->getOperand(1));
      Cond.push_back(I->getOperand(2));
    } else if (I->isReturn()) {
      // Returns can't be analyzed, but we should run cleanup.
      CantAnalyze = !isPredicated(*I);
    } else {
      // We encountered other unrecognized terminator. Bail out immediately.
      return true;
    }

    // Cleanup code - to be run for unpredicated unconditional branches and
    //                returns.
    if (!isPredicated(*I) &&
          (isUncondBranchOpcode(I->getOpcode()) ||
           isIndirectBranchOpcode(I->getOpcode()) ||
           isJumpTableBranchOpcode(I->getOpcode()) ||
           I->isReturn())) {
      // Forget any previous condition branch information - it no longer applies.
      Cond.clear();
      FBB = nullptr;

      // If we can modify the function, delete everything below this
      // unconditional branch.
      if (AllowModify) {
        MachineBasicBlock::iterator DI = std::next(I);
        while (DI != MBB.end()) {
          MachineInstr *InstToDelete = DI;
          ++DI;
          InstToDelete->eraseFromParent();
        }
      }
    }

    if (CantAnalyze)
      return true;

    if (I == MBB.begin())
      return false;

    --I;
  }

  // We made it past the terminators without bailing out - we must have
  // analyzed this branch successfully.
  return false;
}


unsigned ARMBaseInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
  MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
  if (I == MBB.end())
    return 0;

  if (!isUncondBranchOpcode(I->getOpcode()) &&
      !isCondBranchOpcode(I->getOpcode()))
    return 0;

  // Remove the branch.
  I->eraseFromParent();

  I = MBB.end();

  if (I == MBB.begin()) return 1;
  --I;
  if (!isCondBranchOpcode(I->getOpcode()))
    return 1;

  // Remove the branch.
  I->eraseFromParent();
  return 2;
}

unsigned ARMBaseInstrInfo::InsertBranch(MachineBasicBlock &MBB,
                                        MachineBasicBlock *TBB,
                                        MachineBasicBlock *FBB,
                                        ArrayRef<MachineOperand> Cond,
                                        const DebugLoc &DL) const {
  ARMFunctionInfo *AFI = MBB.getParent()->getInfo<ARMFunctionInfo>();
  int BOpc   = !AFI->isThumbFunction()
    ? ARM::B : (AFI->isThumb2Function() ? ARM::t2B : ARM::tB);
  int BccOpc = !AFI->isThumbFunction()
    ? ARM::Bcc : (AFI->isThumb2Function() ? ARM::t2Bcc : ARM::tBcc);
  bool isThumb = AFI->isThumbFunction() || AFI->isThumb2Function();

  // Shouldn't be a fall through.
  assert(TBB && ""InsertBranch must not be told to insert a fallthrough"");
  assert((Cond.size() == 2 || Cond.size() == 0) &&
         ""ARM branch conditions have two components!"");

  // For conditional branches, we use addOperand to preserve CPSR flags.

  if (!FBB) {
    if (Cond.empty()) { // Unconditional branch?
      if (isThumb)
        BuildMI(&MBB, DL, get(BOpc)).addMBB(TBB).addImm(ARMCC::AL).addReg(0);
      else
        BuildMI(&MBB, DL, get(BOpc)).addMBB(TBB);
    } else
      BuildMI(&MBB, DL, get(BccOpc)).addMBB(TBB)
        .addImm(Cond[0].getImm()).addOperand(Cond[1]);
    return 1;
  }

  // Two-way conditional branch.
  BuildMI(&MBB, DL, get(BccOpc)).addMBB(TBB)
    .addImm(Cond[0].getImm()).addOperand(Cond[1]);
  if (isThumb)
    BuildMI(&MBB, DL, get(BOpc)).addMBB(FBB).addImm(ARMCC::AL).addReg(0);
  else
    BuildMI(&MBB, DL, get(BOpc)).addMBB(FBB);
  return 2;
}

bool ARMBaseInstrInfo::
ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
  ARMCC::CondCodes CC = (ARMCC::CondCodes)(int)Cond[0].getImm();
  Cond[0].setImm(ARMCC::getOppositeCondition(CC));
  return false;
}

bool ARMBaseInstrInfo::isPredicated(const MachineInstr &MI) const {
  if (MI.isBundle()) {
    MachineBasicBlock::const_instr_iterator I = MI.getIterator();
    MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
    while (++I != E && I->isInsideBundle()) {
      int PIdx = I->findFirstPredOperandIdx();
      if (PIdx != -1 && I->getOperand(PIdx).getImm() != ARMCC::AL)
        return true;
    }
    return false;
  }

  int PIdx = MI.findFirstPredOperandIdx();
  return PIdx != -1 && MI.getOperand(PIdx).getImm() != ARMCC::AL;
}

bool ARMBaseInstrInfo::PredicateInstruction(
    MachineInstr &MI, ArrayRef<MachineOperand> Pred) const {
  unsigned Opc = MI.getOpcode();
  if (isUncondBranchOpcode(Opc)) {
    MI.setDesc(get(getMatchingCondBranchOpcode(Opc)));
    MachineInstrBuilder(*MI.getParent()->getParent(), MI)
      .addImm(Pred[0].getImm())
      .addReg(Pred[1].getReg());
    return true;
  }

  int PIdx = MI.findFirstPredOperandIdx();
  if (PIdx != -1) {
    MachineOperand &PMO = MI.getOperand(PIdx);
    PMO.setImm(Pred[0].getImm());
    MI.getOperand(PIdx+1).setReg(Pred[1].getReg());
    return true;
  }
  return false;
}

bool ARMBaseInstrInfo::SubsumesPredicate(ArrayRef<MachineOperand> Pred1,
                                         ArrayRef<MachineOperand> Pred2) const {
  if (Pred1.size() > 2 || Pred2.size() > 2)
    return false;

  ARMCC::CondCodes CC1 = (ARMCC::CondCodes)Pred1[0].getImm();
  ARMCC::CondCodes CC2 = (ARMCC::CondCodes)Pred2[0].getImm();
  if (CC1 == CC2)
    return true;

  switch (CC1) {
  default:
    return false;
  case ARMCC::AL:
    return true;
  case ARMCC::HS:
    return CC2 == ARMCC::HI;
  case ARMCC::LS:
    return CC2 == ARMCC::LO || CC2 == ARMCC::EQ;
  case ARMCC::GE:
    return CC2 == ARMCC::GT;
  case ARMCC::LE:
    return CC2 == ARMCC::LT;
  }
}

bool ARMBaseInstrInfo::DefinesPredicate(
    MachineInstr &MI, std::vector<MachineOperand> &Pred) const {
  bool Found = false;
  for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI.getOperand(i);
    if ((MO.isRegMask() && MO.clobbersPhysReg(ARM::CPSR)) ||
        (MO.isReg() && MO.isDef() && MO.getReg() == ARM::CPSR)) {
      Pred.push_back(MO);
      Found = true;
    }
  }

  return Found;
}

static bool isCPSRDefined(const MachineInstr *MI) {
  for (const auto &MO : MI->operands())
    if (MO.isReg() && MO.getReg() == ARM::CPSR && MO.isDef() && !MO.isDead())
      return true;
  return false;
}

static bool isEligibleForITBlock(const MachineInstr *MI) {
  switch (MI->getOpcode()) {
  default: return true;
  case ARM::tADC:   // ADC (register) T1
  case ARM::tADDi3: // ADD (immediate) T1
  case ARM::tADDi8: // ADD (immediate) T2
  case ARM::tADDrr: // ADD (register) T1
  case ARM::tAND:   // AND (register) T1
  case ARM::tASRri: // ASR (immediate) T1
  case ARM::tASRrr: // ASR (register) T1
  case ARM::tBIC:   // BIC (register) T1
  case ARM::tEOR:   // EOR (register) T1
  case ARM::tLSLri: // LSL (immediate) T1
  case ARM::tLSLrr: // LSL (register) T1
  case ARM::tLSRri: // LSR (immediate) T1
  case ARM::tLSRrr: // LSR (register) T1
  case ARM::tMUL:   // MUL T1
  case ARM::tMVN:   // MVN (register) T1
  case ARM::tORR:   // ORR (register) T1
  case ARM::tROR:   // ROR (register) T1
  case ARM::tRSB:   // RSB (immediate) T1
  case ARM::tSBC:   // SBC (register) T1
  case ARM::tSUBi3: // SUB (immediate) T1
  case ARM::tSUBi8: // SUB (immediate) T2
  case ARM::tSUBrr: // SUB (register) T1
    return !isCPSRDefined(MI);
  }
}

/// isPredicable - Return true if the specified instruction can be predicated.
/// By default, this returns true for every instruction with a
/// PredicateOperand.
bool ARMBaseInstrInfo::isPredicable(MachineInstr &MI) const {
  if (!MI.isPredicable())
    return false;

  if (!isEligibleForITBlock(&MI))
    return false;

  ARMFunctionInfo *AFI =
      MI.getParent()->getParent()->getInfo<ARMFunctionInfo>();

  if (AFI->isThumb2Function()) {
    if (getSubtarget().restrictIT())
      return isV8EligibleForIT(&MI);
  } else { // non-Thumb
    if ((MI.getDesc().TSFlags & ARMII::DomainMask) == ARMII::DomainNEON)
      return false;
  }

  return true;
}

namespace llvm {
template <> bool IsCPSRDead<MachineInstr>(MachineInstr *MI) {
  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    if (!MO.isReg() || MO.isUndef() || MO.isUse())
      continue;
    if (MO.getReg() != ARM::CPSR)
      continue;
    if (!MO.isDead())
      return false;
  }
  // all definitions of CPSR are dead
  return true;
}
}

/// GetInstSize - Return the size of the specified MachineInstr.
///
unsigned ARMBaseInstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
  const MachineBasicBlock &MBB = *MI->getParent();
  const MachineFunction *MF = MBB.getParent();
  const MCAsmInfo *MAI = MF->getTarget().getMCAsmInfo();

  const MCInstrDesc &MCID = MI->getDesc();
  if (MCID.getSize())
    return MCID.getSize();

  // If this machine instr is an inline asm, measure it.
  if (MI->getOpcode() == ARM::INLINEASM)
    return getInlineAsmLength(MI->getOperand(0).getSymbolName(), *MAI);
  unsigned Opc = MI->getOpcode();
  switch (Opc) {
  default:
    // pseudo-instruction sizes are zero.
    return 0;
  case TargetOpcode::BUNDLE:
    return getInstBundleLength(MI);
  case ARM::MOVi16_ga_pcrel:
  case ARM::MOVTi16_ga_pcrel:
  case ARM::t2MOVi16_ga_pcrel:
  case ARM::t2MOVTi16_ga_pcrel:
    return 4;
  case ARM::MOVi32imm:
  case ARM::t2MOVi32imm:
    return 8;
  case ARM::CONSTPOOL_ENTRY:
  case ARM::JUMPTABLE_INSTS:
  case ARM::JUMPTABLE_ADDRS:
  case ARM::JUMPTABLE_TBB:
  case ARM::JUMPTABLE_TBH:
    // If this machine instr is a constant pool entry, its size is recorded as
    // operand #2.
    return MI->getOperand(2).getImm();
  case ARM::Int_eh_sjlj_longjmp:
    return 16;
  case ARM::tInt_eh_sjlj_longjmp:
  case ARM::tInt_WIN_eh_sjlj_longjmp:
    return 10;
  case ARM::Int_eh_sjlj_setjmp:
  case ARM::Int_eh_sjlj_setjmp_nofp:
    return 20;
  case ARM::tInt_eh_sjlj_setjmp:
  case ARM::t2Int_eh_sjlj_setjmp:
  case ARM::t2Int_eh_sjlj_setjmp_nofp:
    return 12;
  case ARM::SPACE:
    return MI->getOperand(1).getImm();
  }
}

unsigned ARMBaseInstrInfo::getInstBundleLength(const MachineInstr *MI) const {
  unsigned Size = 0;
  MachineBasicBlock::const_instr_iterator I = MI->getIterator();
  MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
  while (++I != E && I->isInsideBundle()) {
    assert(!I->isBundle() && ""No nested bundle!"");
    Size += GetInstSizeInBytes(&*I);
  }
  return Size;
}

void ARMBaseInstrInfo::copyFromCPSR(MachineBasicBlock &MBB,
                                    MachineBasicBlock::iterator I,
                                    unsigned DestReg, bool KillSrc,
                                    const ARMSubtarget &Subtarget) const {
  unsigned Opc = Subtarget.isThumb()
                     ? (Subtarget.isMClass() ? ARM::t2MRS_M : ARM::t2MRS_AR)
                     : ARM::MRS;

  MachineInstrBuilder MIB =
      BuildMI(MBB, I, I->getDebugLoc(), get(Opc), DestReg);

  // There is only 1 A/R class MRS instruction, and it always refers to
  // APSR. However, there are lots of other possibilities on M-class cores.
  if (Subtarget.isMClass())
    MIB.addImm(0x800);

  AddDefaultPred(MIB);

  MIB.addReg(ARM::CPSR, RegState::Implicit | getKillRegState(KillSrc));
}

void ARMBaseInstrInfo::copyToCPSR(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator I,
                                  unsigned SrcReg, bool KillSrc,
                                  const ARMSubtarget &Subtarget) const {
  unsigned Opc = Subtarget.isThumb()
                     ? (Subtarget.isMClass() ? ARM::t2MSR_M : ARM::t2MSR_AR)
                     : ARM::MSR;

  MachineInstrBuilder MIB = BuildMI(MBB, I, I->getDebugLoc(), get(Opc));

  if (Subtarget.isMClass())
    MIB.addImm(0x800);
  else
    MIB.addImm(8);

  MIB.addReg(SrcReg, getKillRegState(KillSrc));

  AddDefaultPred(MIB);

  MIB.addReg(ARM::CPSR, RegState::Implicit | RegState::Define);
}

void ARMBaseInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator I,
                                   const DebugLoc &DL, unsigned DestReg,
                                   unsigned SrcReg, bool KillSrc) const {
  bool GPRDest = ARM::GPRRegClass.contains(DestReg);
  bool GPRSrc = ARM::GPRRegClass.contains(SrcReg);

  if (GPRDest && GPRSrc) {
    AddDefaultCC(AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::MOVr), DestReg)
                                    .addReg(SrcReg, getKillRegState(KillSrc))));
    return;
  }

  bool SPRDest = ARM::SPRRegClass.contains(DestReg);
  bool SPRSrc = ARM::SPRRegClass.contains(SrcReg);

  unsigned Opc = 0;
  if (SPRDest && SPRSrc)
    Opc = ARM::VMOVS;
  else if (GPRDest && SPRSrc)
    Opc = ARM::VMOVRS;
  else if (SPRDest && GPRSrc)
    Opc = ARM::VMOVSR;
  else if (ARM::DPRRegClass.contains(DestReg, SrcReg) && !Subtarget.isFPOnlySP())
    Opc = ARM::VMOVD;
  else if (ARM::QPRRegClass.contains(DestReg, SrcReg))
    Opc = ARM::VORRq;

  if (Opc) {
    MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(Opc), DestReg);
    MIB.addReg(SrcReg, getKillRegState(KillSrc));
    if (Opc == ARM::VORRq)
      MIB.addReg(SrcReg, getKillRegState(KillSrc));
    AddDefaultPred(MIB);
    return;
  }

  // Handle register classes that require multiple instructions.
  unsigned BeginIdx = 0;
  unsigned SubRegs = 0;
  int Spacing = 1;

  // Use VORRq when possible.
  if (ARM::QQPRRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VORRq;
    BeginIdx = ARM::qsub_0;
    SubRegs = 2;
  } else if (ARM::QQQQPRRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VORRq;
    BeginIdx = ARM::qsub_0;
    SubRegs = 4;
  // Fall back to VMOVD.
  } else if (ARM::DPairRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 2;
  } else if (ARM::DTripleRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 3;
  } else if (ARM::DQuadRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 4;
  } else if (ARM::GPRPairRegClass.contains(DestReg, SrcReg)) {
    Opc = Subtarget.isThumb2() ? ARM::tMOVr : ARM::MOVr;
    BeginIdx = ARM::gsub_0;
    SubRegs = 2;
  } else if (ARM::DPairSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 2;
    Spacing = 2;
  } else if (ARM::DTripleSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 3;
    Spacing = 2;
  } else if (ARM::DQuadSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 4;
    Spacing = 2;
  } else if (ARM::DPRRegClass.contains(DestReg, SrcReg) && Subtarget.isFPOnlySP()) {
    Opc = ARM::VMOVS;
    BeginIdx = ARM::ssub_0;
    SubRegs = 2;
  } else if (SrcReg == ARM::CPSR) {
    copyFromCPSR(MBB, I, DestReg, KillSrc, Subtarget);
    return;
  } else if (DestReg == ARM::CPSR) {
    copyToCPSR(MBB, I, SrcReg, KillSrc, Subtarget);
    return;
  }

  assert(Opc && ""Impossible reg-to-reg copy"");

  const TargetRegisterInfo *TRI = &getRegisterInfo();
  MachineInstrBuilder Mov;

  // Copy register tuples backward when the first Dest reg overlaps with SrcReg.
  if (TRI->regsOverlap(SrcReg, TRI->getSubReg(DestReg, BeginIdx))) {
    BeginIdx = BeginIdx + ((SubRegs - 1) * Spacing);
    Spacing = -Spacing;
  }
#ifndef NDEBUG
  SmallSet<unsigned, 4> DstRegs;
#endif
  for (unsigned i = 0; i != SubRegs; ++i) {
    unsigned Dst = TRI->getSubReg(DestReg, BeginIdx + i * Spacing);
    unsigned Src = TRI->getSubReg(SrcReg, BeginIdx + i * Spacing);
    assert(Dst && Src && ""Bad sub-register"");
#ifndef NDEBUG
    assert(!DstRegs.count(Src) && ""destructive vector copy"");
    DstRegs.insert(Dst);
#endif
    Mov = BuildMI(MBB, I, I->getDebugLoc(), get(Opc), Dst).addReg(Src);
    // VORR takes two source operands.
    if (Opc == ARM::VORRq)
      Mov.addReg(Src);
    Mov = AddDefaultPred(Mov);
    // MOVr can set CC.
    if (Opc == ARM::MOVr)
      Mov = AddDefaultCC(Mov);
  }
  // Add implicit super-register defs and kills to the last instruction.
  Mov->addRegisterDefined(DestReg, TRI);
  if (KillSrc)
    Mov->addRegisterKilled(SrcReg, TRI);
}

const MachineInstrBuilder &
ARMBaseInstrInfo::AddDReg(MachineInstrBuilder &MIB, unsigned Reg,
                          unsigned SubIdx, unsigned State,
                          const TargetRegisterInfo *TRI) const {
  if (!SubIdx)
    return MIB.addReg(Reg, State);

  if (TargetRegisterInfo::isPhysicalRegister(Reg))
    return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
  return MIB.addReg(Reg, State, SubIdx);
}

void ARMBaseInstrInfo::
storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                    unsigned SrcReg, bool isKill, int FI,
                    const TargetRegisterClass *RC,
                    const TargetRegisterInfo *TRI) const {
  DebugLoc DL;
  if (I != MBB.end()) DL = I->getDebugLoc();
  MachineFunction &MF = *MBB.getParent();
  MachineFrameInfo &MFI = *MF.getFrameInfo();
  unsigned Align = MFI.getObjectAlignment(FI);

  MachineMemOperand *MMO = MF.getMachineMemOperand(
      MachinePointerInfo::getFixedStack(MF, FI), MachineMemOperand::MOStore,
      MFI.getObjectSize(FI), Align);

  switch (RC->getSize()) {
    case 4:
      if (ARM::GPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::STRi12))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else if (ARM::SPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTRS))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 8:
      if (ARM::DPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTRD))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else if (ARM::GPRPairRegClass.hasSubClassEq(RC)) {
        if (Subtarget.hasV5TEOps()) {
          MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(ARM::STRD));
          AddDReg(MIB, SrcReg, ARM::gsub_0, getKillRegState(isKill), TRI);
          AddDReg(MIB, SrcReg, ARM::gsub_1, 0, TRI);
          MIB.addFrameIndex(FI).addReg(0).addImm(0).addMemOperand(MMO);

          AddDefaultPred(MIB);
        } else {
          // Fallback to STM instruction, which has existed since the dawn of
          // time.
          MachineInstrBuilder MIB =
            AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::STMIA))
                             .addFrameIndex(FI).addMemOperand(MMO));
          AddDReg(MIB, SrcReg, ARM::gsub_0, getKillRegState(isKill), TRI);
          AddDReg(MIB, SrcReg, ARM::gsub_1, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 16:
      if (ARM::DPairRegClass.hasSubClassEq(RC)) {
        // Use aligned spills if the stack can be realigned.
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1q64))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMQIA))
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addFrameIndex(FI)
                     .addMemOperand(MMO));
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 24:
      if (ARM::DTripleRegClass.hasSubClassEq(RC)) {
        // Use aligned spills if the stack can be realigned.
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1d64TPseudo))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
          AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 32:
      if (ARM::QQPRRegClass.hasSubClassEq(RC) || ARM::DQuadRegClass.hasSubClassEq(RC)) {
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          // FIXME: It's possible to only store part of the QQ register if the
          // spilled def has a sub-register index.
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1d64QPseudo))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
                AddDReg(MIB, SrcReg, ARM::dsub_3, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 64:
      if (ARM::QQQQPRRegClass.hasSubClassEq(RC)) {
        MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                         .addFrameIndex(FI))
                         .addMemOperand(MMO);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_3, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_4, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_5, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_6, 0, TRI);
              AddDReg(MIB, SrcReg, ARM::dsub_7, 0, TRI);
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    default:
      llvm_unreachable(""Unknown reg class!"");
  }
}

unsigned
ARMBaseInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
                                     int &FrameIndex) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::STRrs:
  case ARM::t2STRs: // FIXME: don't use t2STRs to access frame.
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isReg() &&
        MI->getOperand(3).isImm() &&
        MI->getOperand(2).getReg() == 0 &&
        MI->getOperand(3).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::STRi12:
  case ARM::t2STRi12:
  case ARM::tSTRspi:
  case ARM::VSTRD:
  case ARM::VSTRS:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isImm() &&
        MI->getOperand(2).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VST1q64:
  case ARM::VST1d64TPseudo:
  case ARM::VST1d64QPseudo:
    if (MI->getOperand(0).isFI() &&
        MI->getOperand(2).getSubReg() == 0) {
      FrameIndex = MI->getOperand(0).getIndex();
      return MI->getOperand(2).getReg();
    }
    break;
  case ARM::VSTMQIA:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  }

  return 0;
}

unsigned ARMBaseInstrInfo::isStoreToStackSlotPostFE(const MachineInstr *MI,
                                                    int &FrameIndex) const {
  const MachineMemOperand *Dummy;
  return MI->mayStore() && hasStoreToStackSlot(MI, Dummy, FrameIndex);
}

void ARMBaseInstrInfo::
loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                     unsigned DestReg, int FI,
                     const TargetRegisterClass *RC,
                     const TargetRegisterInfo *TRI) const {
  DebugLoc DL;
  if (I != MBB.end()) DL = I->getDebugLoc();
  MachineFunction &MF = *MBB.getParent();
  MachineFrameInfo &MFI = *MF.getFrameInfo();
  unsigned Align = MFI.getObjectAlignment(FI);
  MachineMemOperand *MMO = MF.getMachineMemOperand(
      MachinePointerInfo::getFixedStack(MF, FI), MachineMemOperand::MOLoad,
      MFI.getObjectSize(FI), Align);

  switch (RC->getSize()) {
  case 4:
    if (ARM::GPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::LDRi12), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));

    } else if (ARM::SPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDRS), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 8:
    if (ARM::DPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDRD), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
    } else if (ARM::GPRPairRegClass.hasSubClassEq(RC)) {
      MachineInstrBuilder MIB;

      if (Subtarget.hasV5TEOps()) {
        MIB = BuildMI(MBB, I, DL, get(ARM::LDRD));
        AddDReg(MIB, DestReg, ARM::gsub_0, RegState::DefineNoRead, TRI);
        AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
        MIB.addFrameIndex(FI).addReg(0).addImm(0).addMemOperand(MMO);

        AddDefaultPred(MIB);
      } else {
        // Fallback to LDM instruction, which has existed since the dawn of
        // time.
        MIB = AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::LDMIA))
                                 .addFrameIndex(FI).addMemOperand(MMO));
        MIB = AddDReg(MIB, DestReg, ARM::gsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
      }

      if (TargetRegisterInfo::isPhysicalRegister(DestReg))
        MIB.addReg(DestReg, RegState::ImplicitDefine);
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 16:
    if (ARM::DPairRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1q64), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMQIA), DestReg)
                       .addFrameIndex(FI)
                       .addMemOperand(MMO));
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 24:
    if (ARM::DTripleRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1d64TPseudo), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                         .addFrameIndex(FI)
                         .addMemOperand(MMO));
        MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
        if (TargetRegisterInfo::isPhysicalRegister(DestReg))
          MIB.addReg(DestReg, RegState::ImplicitDefine);
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
   case 32:
    if (ARM::QQPRRegClass.hasSubClassEq(RC) || ARM::DQuadRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1d64QPseudo), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        MachineInstrBuilder MIB =
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_3, RegState::DefineNoRead, TRI);
        if (TargetRegisterInfo::isPhysicalRegister(DestReg))
          MIB.addReg(DestReg, RegState::ImplicitDefine);
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 64:
    if (ARM::QQQQPRRegClass.hasSubClassEq(RC)) {
      MachineInstrBuilder MIB =
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                     .addFrameIndex(FI))
                     .addMemOperand(MMO);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_3, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_4, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_5, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_6, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_7, RegState::DefineNoRead, TRI);
      if (TargetRegisterInfo::isPhysicalRegister(DestReg))
        MIB.addReg(DestReg, RegState::ImplicitDefine);
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  default:
    llvm_unreachable(""Unknown regclass!"");
  }
}

unsigned
ARMBaseInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
                                      int &FrameIndex) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::LDRrs:
  case ARM::t2LDRs:  // FIXME: don't use t2LDRs to access frame.
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isReg() &&
        MI->getOperand(3).isImm() &&
        MI->getOperand(2).getReg() == 0 &&
        MI->getOperand(3).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::LDRi12:
  case ARM::t2LDRi12:
  case ARM::tLDRspi:
  case ARM::VLDRD:
  case ARM::VLDRS:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isImm() &&
        MI->getOperand(2).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VLD1q64:
  case ARM::VLD1d64TPseudo:
  case ARM::VLD1d64QPseudo:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VLDMQIA:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  }

  return 0;
}

unsigned ARMBaseInstrInfo::isLoadFromStackSlotPostFE(const MachineInstr *MI,
                                             int &FrameIndex) const {
  const MachineMemOperand *Dummy;
  return MI->mayLoad() && hasLoadFromStackSlot(MI, Dummy, FrameIndex);
}

/// \brief Expands MEMCPY to either LDMIA/STMIA or LDMIA_UPD/STMID_UPD
/// depending on whether the result is used.
void ARMBaseInstrInfo::expandMEMCPY(MachineBasicBlock::iterator MBBI) const {
  bool isThumb1 = Subtarget.isThumb1Only();
  bool isThumb2 = Subtarget.isThumb2();
  const ARMBaseInstrInfo *TII = Subtarget.getInstrInfo();

  MachineInstr *MI = MBBI;
  DebugLoc dl = MI->getDebugLoc();
  MachineBasicBlock *BB = MI->getParent();

  MachineInstrBuilder LDM, STM;
  if (isThumb1 || !MI->getOperand(1).isDead()) {
    LDM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2LDMIA_UPD
                                                 : isThumb1 ? ARM::tLDMIA_UPD
                                                            : ARM::LDMIA_UPD))
             .addOperand(MI->getOperand(1));
  } else {
    LDM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2LDMIA : ARM::LDMIA));
  }

  if (isThumb1 || !MI->getOperand(0).isDead()) {
    STM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2STMIA_UPD
                                                 : isThumb1 ? ARM::tSTMIA_UPD
                                                            : ARM::STMIA_UPD))
             .addOperand(MI->getOperand(0));
  } else {
    STM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2STMIA : ARM::STMIA));
  }

  AddDefaultPred(LDM.addOperand(MI->getOperand(3)));
  AddDefaultPred(STM.addOperand(MI->getOperand(2)));

  // Sort the scratch registers into ascending order.
  const TargetRegisterInfo &TRI = getRegisterInfo();
  llvm::SmallVector<unsigned, 6> ScratchRegs;
  for(unsigned I = 5; I < MI->getNumOperands(); ++I)
    ScratchRegs.push_back(MI->getOperand(I).getReg());
  std::sort(ScratchRegs.begin(), ScratchRegs.end(),
            [&TRI](const unsigned &Reg1,
                   const unsigned &Reg2) -> bool {
              return TRI.getEncodingValue(Reg1) <
                     TRI.getEncodingValue(Reg2);
            });

  for (const auto &Reg : ScratchRegs) {
    LDM.addReg(Reg, RegState::Define);
    STM.addReg(Reg, RegState::Kill);
  }

  BB->erase(MBBI);
}


bool
ARMBaseInstrInfo::expandPostRAPseudo(MachineBasicBlock::iterator MI) const {
  MachineFunction &MF = *MI->getParent()->getParent();
  Reloc::Model RM = MF.getTarget().getRelocationModel();

  if (MI->getOpcode() == TargetOpcode::LOAD_STACK_GUARD) {
    assert(getSubtarget().getTargetTriple().isOSBinFormatMachO() &&
           ""LOAD_STACK_GUARD currently supported only for MachO."");
    expandLoadStackGuard(MI, RM);
    MI->getParent()->erase(MI);
    return true;
  }

  if (MI->getOpcode() == ARM::MEMCPY) {
    expandMEMCPY(MI);
    return true;
  }

  // This hook gets to expand COPY instructions before they become
  // copyPhysReg() calls.  Look for VMOVS instructions that can legally be
  // widened to VMOVD.  We prefer the VMOVD when possible because it may be
  // changed into a VORR that can go down the NEON pipeline.
  if (!WidenVMOVS || !MI->isCopy() || Subtarget.isCortexA15() ||
      Subtarget.isFPOnlySP())
    return false;

  // Look for a copy between even S-registers.  That is where we keep floats
  // when using NEON v2f32 instructions for f32 arithmetic.
  unsigned DstRegS = MI->getOperand(0).getReg();
  unsigned SrcRegS = MI->getOperand(1).getReg();
  if (!ARM::SPRRegClass.contains(DstRegS, SrcRegS))
    return false;

  const TargetRegisterInfo *TRI = &getRegisterInfo();
  unsigned DstRegD = TRI->getMatchingSuperReg(DstRegS, ARM::ssub_0,
                                              &ARM::DPRRegClass);
  unsigned SrcRegD = TRI->getMatchingSuperReg(SrcRegS, ARM::ssub_0,
                                              &ARM::DPRRegClass);
  if (!DstRegD || !SrcRegD)
    return false;

  // We want to widen this into a DstRegD = VMOVD SrcRegD copy.  This is only
  // legal if the COPY already defines the full DstRegD, and it isn't a
  // sub-register insertion.
  if (!MI->definesRegister(DstRegD, TRI) || MI->readsRegister(DstRegD, TRI))
    return false;

  // A dead copy shouldn't show up here, but reject it just in case.
  if (MI->getOperand(0).isDead())
    return false;

  // All clear, widen the COPY.
  DEBUG(dbgs() << ""widening:    "" << *MI);
  MachineInstrBuilder MIB(*MI->getParent()->getParent(), MI);

  // Get rid of the old <imp-def> of DstRegD.  Leave it if it defines a Q-reg
  // or some other super-register.
  int ImpDefIdx = MI->findRegisterDefOperandIdx(DstRegD);
  if (ImpDefIdx != -1)
    MI->RemoveOperand(ImpDefIdx);

  // Change the opcode and operands.
  MI->setDesc(get(ARM::VMOVD));
  MI->getOperand(0).setReg(DstRegD);
  MI->getOperand(1).setReg(SrcRegD);
  AddDefaultPred(MIB);

  // We are now reading SrcRegD instead of SrcRegS.  This may upset the
  // register scavenger and machine verifier, so we need to indicate that we
  // are reading an undefined value from SrcRegD, but a proper value from
  // SrcRegS.
  MI->getOperand(1).setIsUndef();
  MIB.addReg(SrcRegS, RegState::Implicit);

  // SrcRegD may actually contain an unrelated value in the ssub_1
  // sub-register.  Don't kill it.  Only kill the ssub_0 sub-register.
  if (MI->getOperand(1).isKill()) {
    MI->getOperand(1).setIsKill(false);
    MI->addRegisterKilled(SrcRegS, TRI, true);
  }

  DEBUG(dbgs() << ""replaced by: "" << *MI);
  return true;
}

/// Create a copy of a const pool value. Update CPI to the new index and return
/// the label UID.
static unsigned duplicateCPV(MachineFunction &MF, unsigned &CPI) {
  MachineConstantPool *MCP = MF.getConstantPool();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();

  const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPI];
  assert(MCPE.isMachineConstantPoolEntry() &&
         ""Expecting a machine constantpool entry!"");
  ARMConstantPoolValue *ACPV =
    static_cast<ARMConstantPoolValue*>(MCPE.Val.MachineCPVal);

  unsigned PCLabelId = AFI->createPICLabelUId();
  ARMConstantPoolValue *NewCPV = nullptr;

  // FIXME: The below assumes PIC relocation model and that the function
  // is Thumb mode (t1 or t2). PCAdjustment would be 8 for ARM mode PIC, and
  // zero for non-PIC in ARM or Thumb. The callers are all of thumb LDR
  // instructions, so that's probably OK, but is PIC always correct when
  // we get here?
  if (ACPV->isGlobalValue())
    NewCPV = ARMConstantPoolConstant::Create(
        cast<ARMConstantPoolConstant>(ACPV)->getGV(), PCLabelId, ARMCP::CPValue,
        4, ACPV->getModifier(), ACPV->mustAddCurrentAddress());
  else if (ACPV->isExtSymbol())
    NewCPV = ARMConstantPoolSymbol::
      Create(MF.getFunction()->getContext(),
             cast<ARMConstantPoolSymbol>(ACPV)->getSymbol(), PCLabelId, 4);
  else if (ACPV->isBlockAddress())
    NewCPV = ARMConstantPoolConstant::
      Create(cast<ARMConstantPoolConstant>(ACPV)->getBlockAddress(), PCLabelId,
             ARMCP::CPBlockAddress, 4);
  else if (ACPV->isLSDA())
    NewCPV = ARMConstantPoolConstant::Create(MF.getFunction(), PCLabelId,
                                             ARMCP::CPLSDA, 4);
  else if (ACPV->isMachineBasicBlock())
    NewCPV = ARMConstantPoolMBB::
      Create(MF.getFunction()->getContext(),
             cast<ARMConstantPoolMBB>(ACPV)->getMBB(), PCLabelId, 4);
  else
    llvm_unreachable(""Unexpected ARM constantpool value type!!"");
  CPI = MCP->getConstantPoolIndex(NewCPV, MCPE.getAlignment());
  return PCLabelId;
}

void ARMBaseInstrInfo::
reMaterialize(MachineBasicBlock &MBB,
              MachineBasicBlock::iterator I,
              unsigned DestReg, unsigned SubIdx,
              const MachineInstr *Orig,
              const TargetRegisterInfo &TRI) const {
  unsigned Opcode = Orig->getOpcode();
  switch (Opcode) {
  default: {
    MachineInstr *MI = MBB.getParent()->CloneMachineInstr(Orig);
    MI->substituteRegister(Orig->getOperand(0).getReg(), DestReg, SubIdx, TRI);
    MBB.insert(I, MI);
    break;
  }
  case ARM::tLDRpci_pic:
  case ARM::t2LDRpci_pic: {
    MachineFunction &MF = *MBB.getParent();
    unsigned CPI = Orig->getOperand(1).getIndex();
    unsigned PCLabelId = duplicateCPV(MF, CPI);
    MachineInstrBuilder MIB = BuildMI(MBB, I, Orig->getDebugLoc(), get(Opcode),
                                      DestReg)
      .addConstantPoolIndex(CPI).addImm(PCLabelId);
    MIB->setMemRefs(Orig->memoperands_begin(), Orig->memoperands_end());
    break;
  }
  }
}

MachineInstr *
ARMBaseInstrInfo::duplicate(MachineInstr *Orig, MachineFunction &MF) const {
  MachineInstr *MI = TargetInstrInfo::duplicate(Orig, MF);
  switch(Orig->getOpcode()) {
  case ARM::tLDRpci_pic:
  case ARM::t2LDRpci_pic: {
    unsigned CPI = Orig->getOperand(1).getIndex();
    unsigned PCLabelId = duplicateCPV(MF, CPI);
    Orig->getOperand(1).setIndex(CPI);
    Orig->getOperand(2).setImm(PCLabelId);
    break;
  }
  }
  return MI;
}

bool ARMBaseInstrInfo::produceSameValue(const MachineInstr *MI0,
                                        const MachineInstr *MI1,
                                        const MachineRegisterInfo *MRI) const {
  unsigned Opcode = MI0->getOpcode();
  if (Opcode == ARM::t2LDRpci ||
      Opcode == ARM::t2LDRpci_pic ||
      Opcode == ARM::tLDRpci ||
      Opcode == ARM::tLDRpci_pic ||
      Opcode == ARM::LDRLIT_ga_pcrel ||
      Opcode == ARM::LDRLIT_ga_pcrel_ldr ||
      Opcode == ARM::tLDRLIT_ga_pcrel ||
      Opcode == ARM::MOV_ga_pcrel ||
      Opcode == ARM::MOV_ga_pcrel_ldr ||
      Opcode == ARM::t2MOV_ga_pcrel) {
    if (MI1->getOpcode() != Opcode)
      return false;
    if (MI0->getNumOperands() != MI1->getNumOperands())
      return false;

    const MachineOperand &MO0 = MI0->getOperand(1);
    const MachineOperand &MO1 = MI1->getOperand(1);
    if (MO0.getOffset() != MO1.getOffset())
      return false;

    if (Opcode == ARM::LDRLIT_ga_pcrel ||
        Opcode == ARM::LDRLIT_ga_pcrel_ldr ||
        Opcode == ARM::tLDRLIT_ga_pcrel ||
        Opcode == ARM::MOV_ga_pcrel ||
        Opcode == ARM::MOV_ga_pcrel_ldr ||
        Opcode == ARM::t2MOV_ga_pcrel)
      // Ignore the PC labels.
      return MO0.getGlobal() == MO1.getGlobal();

    const MachineFunction *MF = MI0->getParent()->getParent();
    const MachineConstantPool *MCP = MF->getConstantPool();
    int CPI0 = MO0.getIndex();
    int CPI1 = MO1.getIndex();
    const MachineConstantPoolEntry &MCPE0 = MCP->getConstants()[CPI0];
    const MachineConstantPoolEntry &MCPE1 = MCP->getConstants()[CPI1];
    bool isARMCP0 = MCPE0.isMachineConstantPoolEntry();
    bool isARMCP1 = MCPE1.isMachineConstantPoolEntry();
    if (isARMCP0 && isARMCP1) {
      ARMConstantPoolValue *ACPV0 =
        static_cast<ARMConstantPoolValue*>(MCPE0.Val.MachineCPVal);
      ARMConstantPoolValue *ACPV1 =
        static_cast<ARMConstantPoolValue*>(MCPE1.Val.MachineCPVal);
      return ACPV0->hasSameValue(ACPV1);
    } else if (!isARMCP0 && !isARMCP1) {
      return MCPE0.Val.ConstVal == MCPE1.Val.ConstVal;
    }
    return false;
  } else if (Opcode == ARM::PICLDR) {
    if (MI1->getOpcode() != Opcode)
      return false;
    if (MI0->getNumOperands() != MI1->getNumOperands())
      return false;

    unsigned Addr0 = MI0->getOperand(1).getReg();
    unsigned Addr1 = MI1->getOperand(1).getReg();
    if (Addr0 != Addr1) {
      if (!MRI ||
          !TargetRegisterInfo::isVirtualRegister(Addr0) ||
          !TargetRegisterInfo::isVirtualRegister(Addr1))
        return false;

      // This assumes SSA form.
      MachineInstr *Def0 = MRI->getVRegDef(Addr0);
      MachineInstr *Def1 = MRI->getVRegDef(Addr1);
      // Check if the loaded value, e.g. a constantpool of a global address, are
      // the same.
      if (!produceSameValue(Def0, Def1, MRI))
        return false;
    }

    for (unsigned i = 3, e = MI0->getNumOperands(); i != e; ++i) {
      // %vreg12<def> = PICLDR %vreg11, 0, pred:14, pred:%noreg
      const MachineOperand &MO0 = MI0->getOperand(i);
      const MachineOperand &MO1 = MI1->getOperand(i);
      if (!MO0.isIdenticalTo(MO1))
        return false;
    }
    return true;
  }

  return MI0->isIdenticalTo(*MI1, MachineInstr::IgnoreVRegDefs);
}

/// areLoadsFromSameBasePtr - This is used by the pre-regalloc scheduler to
/// determine if two loads are loading from the same base address. It should
/// only return true if the base pointers are the same and the only differences
/// between the two addresses is the offset. It also returns the offsets by
/// reference.
///
/// FIXME: remove this in favor of the MachineInstr interface once pre-RA-sched
/// is permanently disabled.
bool ARMBaseInstrInfo::areLoadsFromSameBasePtr(SDNode *Load1, SDNode *Load2,
                                               int64_t &Offset1,
                                               int64_t &Offset2) const {
  // Don't worry about Thumb: just ARM and Thumb2.
  if (Subtarget.isThumb1Only()) return false;

  if (!Load1->isMachineOpcode() || !Load2->isMachineOpcode())
    return false;

  switch (Load1->getMachineOpcode()) {
  default:
    return false;
  case ARM::LDRi12:
  case ARM::LDRBi12:
  case ARM::LDRD:
  case ARM::LDRH:
  case ARM::LDRSB:
  case ARM::LDRSH:
  case ARM::VLDRD:
  case ARM::VLDRS:
  case ARM::t2LDRi8:
  case ARM::t2LDRBi8:
  case ARM::t2LDRDi8:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRi12:
  case ARM::t2LDRBi12:
  case ARM::t2LDRSHi12:
    break;
  }

  switch (Load2->getMachineOpcode()) {
  default:
    return false;
  case ARM::LDRi12:
  case ARM::LDRBi12:
  case ARM::LDRD:
  case ARM::LDRH:
  case ARM::LDRSB:
  case ARM::LDRSH:
  case ARM::VLDRD:
  case ARM::VLDRS:
  case ARM::t2LDRi8:
  case ARM::t2LDRBi8:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRi12:
  case ARM::t2LDRBi12:
  case ARM::t2LDRSHi12:
    break;
  }

  // Check if base addresses and chain operands match.
  if (Load1->getOperand(0) != Load2->getOperand(0) ||
      Load1->getOperand(4) != Load2->getOperand(4))
    return false;

  // Index should be Reg0.
  if (Load1->getOperand(3) != Load2->getOperand(3))
    return false;

  // Determine the offsets.
  if (isa<ConstantSDNode>(Load1->getOperand(1)) &&
      isa<ConstantSDNode>(Load2->getOperand(1))) {
    Offset1 = cast<ConstantSDNode>(Load1->getOperand(1))->getSExtValue();
    Offset2 = cast<ConstantSDNode>(Load2->getOperand(1))->getSExtValue();
    return true;
  }

  return false;
}

/// shouldScheduleLoadsNear - This is a used by the pre-regalloc scheduler to
/// determine (in conjunction with areLoadsFromSameBasePtr) if two loads should
/// be scheduled togther. On some targets if two loads are loading from
/// addresses in the same cache line, it's better if they are scheduled
/// together. This function takes two integers that represent the load offsets
/// from the common base address. It returns true if it decides it's desirable
/// to schedule the two loads together. ""NumLoads"" is the number of loads that
/// have already been scheduled after Load1.
///
/// FIXME: remove this in favor of the MachineInstr interface once pre-RA-sched
/// is permanently disabled.
bool ARMBaseInstrInfo::shouldScheduleLoadsNear(SDNode *Load1, SDNode *Load2,
                                               int64_t Offset1, int64_t Offset2,
                                               unsigned NumLoads) const {
  // Don't worry about Thumb: just ARM and Thumb2.
  if (Subtarget.isThumb1Only()) return false;

  assert(Offset2 > Offset1);

  if ((Offset2 - Offset1) / 8 > 64)
    return false;

  // Check if the machine opcodes are different. If they are different
  // then we consider them to not be of the same base address,
  // EXCEPT in the case of Thumb2 byte loads where one is LDRBi8 and the other LDRBi12.
  // In this case, they are considered to be the same because they are different
  // encoding forms of the same basic instruction.
  if ((Load1->getMachineOpcode() != Load2->getMachineOpcode()) &&
      !((Load1->getMachineOpcode() == ARM::t2LDRBi8 &&
         Load2->getMachineOpcode() == ARM::t2LDRBi12) ||
        (Load1->getMachineOpcode() == ARM::t2LDRBi12 &&
         Load2->getMachineOpcode() == ARM::t2LDRBi8)))
    return false;  // FIXME: overly conservative?

  // Four loads in a row should be sufficient.
  if (NumLoads >= 3)
    return false;

  return true;
}

bool ARMBaseInstrInfo::isSchedulingBoundary(const MachineInstr *MI,
                                            const MachineBasicBlock *MBB,
                                            const MachineFunction &MF) const {
  // Debug info is never a scheduling boundary. It's necessary to be explicit
  // due to the special treatment of IT instructions below, otherwise a
  // dbg_value followed by an IT will result in the IT instruction being
  // considered a scheduling hazard, which is wrong. It should be the actual
  // instruction preceding the dbg_value instruction(s), just like it is
  // when debug info is not present.
  if (MI->isDebugValue())
    return false;

  // Terminators and labels can't be scheduled around.
  if (MI->isTerminator() || MI->isPosition())
    return true;

  // Treat the start of the IT block as a scheduling boundary, but schedule
  // t2IT along with all instructions following it.
  // FIXME: This is a big hammer. But the alternative is to add all potential
  // true and anti dependencies to IT block instructions as implicit operands
  // to the t2IT instruction. The added compile time and complexity does not
  // seem worth it.
  MachineBasicBlock::const_iterator I = MI;
  // Make sure to skip any dbg_value instructions
  while (++I != MBB->end() && I->isDebugValue())
    ;
  if (I != MBB->end() && I->getOpcode() == ARM::t2IT)
    return true;

  // Don't attempt to schedule around any instruction that defines
  // a stack-oriented pointer, as it's unlikely to be profitable. This
  // saves compile time, because it doesn't require every single
  // stack slot reference to depend on the instruction that does the
  // modification.
  // Calls don't actually change the stack pointer, even if they have imp-defs.
  // No ARM calling conventions change the stack pointer. (X86 calling
  // conventions sometimes do).
  if (!MI->isCall() && MI->definesRegister(ARM::SP))
    return true;

  return false;
}

bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &MBB,
                    unsigned NumCycles, unsigned ExtraPredCycles,
                    BranchProbability Probability) const {
  if (!NumCycles)
    return false;

  // If we are optimizing for size, see if the branch in the predecessor can be
  // lowered to cbn?z by the constant island lowering pass, and return false if
  // so. This results in a shorter instruction sequence.
  if (MBB.getParent()->getFunction()->optForSize()) {
    MachineBasicBlock *Pred = *MBB.pred_begin();
    if (!Pred->empty()) {
      MachineInstr *LastMI = &*Pred->rbegin();
      if (LastMI->getOpcode() == ARM::t2Bcc) {
        MachineBasicBlock::iterator CmpMI = LastMI;
        if (CmpMI != Pred->begin()) {
          --CmpMI;
          if (CmpMI->getOpcode() == ARM::tCMPi8 ||
              CmpMI->getOpcode() == ARM::t2CMPri) {
            unsigned Reg = CmpMI->getOperand(0).getReg();
            unsigned PredReg = 0;
            ARMCC::CondCodes P = getInstrPredicate(*CmpMI, PredReg);
            if (P == ARMCC::AL && CmpMI->getOperand(1).getImm() == 0 &&
                isARMLowRegister(Reg))
              return false;
          }
        }
      }
    }
  }

  // Attempt to estimate the relative costs of predication versus branching.
  // Here we scale up each component of UnpredCost to avoid precision issue when
  // scaling NumCycles by Probability.
  const unsigned ScalingUpFactor = 1024;
  unsigned UnpredCost = Probability.scale(NumCycles * ScalingUpFactor);
  UnpredCost += ScalingUpFactor; // The branch itself
  UnpredCost += Subtarget.getMispredictionPenalty() * ScalingUpFactor / 10;

  return (NumCycles + ExtraPredCycles) * ScalingUpFactor <= UnpredCost;
}

bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &TMBB,
                    unsigned TCycles, unsigned TExtra,
                    MachineBasicBlock &FMBB,
                    unsigned FCycles, unsigned FExtra,
                    BranchProbability Probability) const {
  if (!TCycles || !FCycles)
    return false;

  // Attempt to estimate the relative costs of predication versus branching.
  // Here we scale up each component of UnpredCost to avoid precision issue when
  // scaling TCycles/FCycles by Probability.
  const unsigned ScalingUpFactor = 1024;
  unsigned TUnpredCost = Probability.scale(TCycles * ScalingUpFactor);
  unsigned FUnpredCost =
      Probability.getCompl().scale(FCycles * ScalingUpFactor);
  unsigned UnpredCost = TUnpredCost + FUnpredCost;
  UnpredCost += 1 * ScalingUpFactor; // The branch itself
  UnpredCost += Subtarget.getMispredictionPenalty() * ScalingUpFactor / 10;

  return (TCycles + FCycles + TExtra + FExtra) * ScalingUpFactor <= UnpredCost;
}

bool
ARMBaseInstrInfo::isProfitableToUnpredicate(MachineBasicBlock &TMBB,
                                            MachineBasicBlock &FMBB) const {
  // Reduce false anti-dependencies to let Swift's out-of-order execution
  // engine do its thing.
  return Subtarget.isSwift();
}

/// getInstrPredicate - If instruction is predicated, returns its predicate
/// condition, otherwise returns AL. It also returns the condition code
/// register by reference.
ARMCC::CondCodes llvm::getInstrPredicate(const MachineInstr &MI,
                                         unsigned &PredReg) {
  int PIdx = MI.findFirstPredOperandIdx();
  if (PIdx == -1) {
    PredReg = 0;
    return ARMCC::AL;
  }

  PredReg = MI.getOperand(PIdx+1).getReg();
  return (ARMCC::CondCodes)MI.getOperand(PIdx).getImm();
}


unsigned llvm::getMatchingCondBranchOpcode(unsigned Opc) {
  if (Opc == ARM::B)
    return ARM::Bcc;
  if (Opc == ARM::tB)
    return ARM::tBcc;
  if (Opc == ARM::t2B)
    return ARM::t2Bcc;

  llvm_unreachable(""Unknown unconditional branch opcode!"");
}

MachineInstr *ARMBaseInstrInfo::commuteInstructionImpl(MachineInstr *MI,
                                                       bool NewMI,
                                                       unsigned OpIdx1,
                                                       unsigned OpIdx2) const {
  switch (MI->getOpcode()) {
  case ARM::MOVCCr:
  case ARM::t2MOVCCr: {
    // MOVCC can be commuted by inverting the condition.
    unsigned PredReg = 0;
    ARMCC::CondCodes CC = getInstrPredicate(*MI, PredReg);
    // MOVCC AL can't be inverted. Shouldn't happen.
    if (CC == ARMCC::AL || PredReg != ARM::CPSR)
      return nullptr;
    MI = TargetInstrInfo::commuteInstructionImpl(MI, NewMI, OpIdx1, OpIdx2);
    if (!MI)
      return nullptr;
    // After swapping the MOVCC operands, also invert the condition.
    MI->getOperand(MI->findFirstPredOperandIdx())
      .setImm(ARMCC::getOppositeCondition(CC));
    return MI;
  }
  }
  return TargetInstrInfo::commuteInstructionImpl(MI, NewMI, OpIdx1, OpIdx2);
}

/// Identify instructions that can be folded into a MOVCC instruction, and
/// return the defining instruction.
static MachineInstr *canFoldIntoMOVCC(unsigned Reg,
                                      const MachineRegisterInfo &MRI,
                                      const TargetInstrInfo *TII) {
  if (!TargetRegisterInfo::isVirtualRegister(Reg))
    return nullptr;
  if (!MRI.hasOneNonDBGUse(Reg))
    return nullptr;
  MachineInstr *MI = MRI.getVRegDef(Reg);
  if (!MI)
    return nullptr;
  // MI is folded into the MOVCC by predicating it.
  if (!MI->isPredicable())
    return nullptr;
  // Check if MI has any non-dead defs or physreg uses. This also detects
  // predicated instructions which will be reading CPSR.
  for (unsigned i = 1, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    // Reject frame index operands, PEI can't handle the predicated pseudos.
    if (MO.isFI() || MO.isCPI() || MO.isJTI())
      return nullptr;
    if (!MO.isReg())
      continue;
    // MI can't have any tied operands, that would conflict with predication.
    if (MO.isTied())
      return nullptr;
    if (TargetRegisterInfo::isPhysicalRegister(MO.getReg()))
      return nullptr;
    if (MO.isDef() && !MO.isDead())
      return nullptr;
  }
  bool DontMoveAcrossStores = true;
  if (!MI->isSafeToMove(/* AliasAnalysis = */ nullptr, DontMoveAcrossStores))
    return nullptr;
  return MI;
}

bool ARMBaseInstrInfo::analyzeSelect(const MachineInstr *MI,
                                     SmallVectorImpl<MachineOperand> &Cond,
                                     unsigned &TrueOp, unsigned &FalseOp,
                                     bool &Optimizable) const {
  assert((MI->getOpcode() == ARM::MOVCCr || MI->getOpcode() == ARM::t2MOVCCr) &&
         ""Unknown select instruction"");
  // MOVCC operands:
  // 0: Def.
  // 1: True use.
  // 2: False use.
  // 3: Condition code.
  // 4: CPSR use.
  TrueOp = 1;
  FalseOp = 2;
  Cond.push_back(MI->getOperand(3));
  Cond.push_back(MI->getOperand(4));
  // We can always fold a def.
  Optimizable = true;
  return false;
}

MachineInstr *
ARMBaseInstrInfo::optimizeSelect(MachineInstr *MI,
                                 SmallPtrSetImpl<MachineInstr *> &SeenMIs,
                                 bool PreferFalse) const {
  assert((MI->getOpcode() == ARM::MOVCCr || MI->getOpcode() == ARM::t2MOVCCr) &&
         ""Unknown select instruction"");
  MachineRegisterInfo &MRI = MI->getParent()->getParent()->getRegInfo();
  MachineInstr *DefMI = canFoldIntoMOVCC(MI->getOperand(2).getReg(), MRI, this);
  bool Invert = !DefMI;
  if (!DefMI)
    DefMI = canFoldIntoMOVCC(MI->getOperand(1).getReg(), MRI, this);
  if (!DefMI)
    return nullptr;

  // Find new register class to use.
  MachineOperand FalseReg = MI->getOperand(Invert ? 2 : 1);
  unsigned       DestReg  = MI->getOperand(0).getReg();
  const TargetRegisterClass *PreviousClass = MRI.getRegClass(FalseReg.getReg());
  if (!MRI.constrainRegClass(DestReg, PreviousClass))
    return nullptr;

  // Create a new predicated version of DefMI.
  // Rfalse is the first use.
  MachineInstrBuilder NewMI = BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                                      DefMI->getDesc(), DestReg);

  // Copy all the DefMI operands, excluding its (null) predicate.
  const MCInstrDesc &DefDesc = DefMI->getDesc();
  for (unsigned i = 1, e = DefDesc.getNumOperands();
       i != e && !DefDesc.OpInfo[i].isPredicate(); ++i)
    NewMI.addOperand(DefMI->getOperand(i));

  unsigned CondCode = MI->getOperand(3).getImm();
  if (Invert)
    NewMI.addImm(ARMCC::getOppositeCondition(ARMCC::CondCodes(CondCode)));
  else
    NewMI.addImm(CondCode);
  NewMI.addOperand(MI->getOperand(4));

  // DefMI is not the -S version that sets CPSR, so add an optional %noreg.
  if (NewMI->hasOptionalDef())
    AddDefaultCC(NewMI);

  // The output register value when the predicate is false is an implicit
  // register operand tied to the first def.
  // The tie makes the register allocator ensure the FalseReg is allocated the
  // same register as operand 0.
  FalseReg.setImplicit();
  NewMI.addOperand(FalseReg);
  NewMI->tieOperands(0, NewMI->getNumOperands() - 1);

  // Update SeenMIs set: register newly created MI and erase removed DefMI.
  SeenMIs.insert(NewMI);
  SeenMIs.erase(DefMI);

  // If MI is inside a loop, and DefMI is outside the loop, then kill flags on
  // DefMI would be invalid when tranferred inside the loop.  Checking for a
  // loop is expensive, but at least remove kill flags if they are in different
  // BBs.
  if (DefMI->getParent() != MI->getParent())
    NewMI->clearKillInfo();

  // The caller will erase MI, but not DefMI.
  DefMI->eraseFromParent();
  return NewMI;
}

/// Map pseudo instructions that imply an 'S' bit onto real opcodes. Whether the
/// instruction is encoded with an 'S' bit is determined by the optional CPSR
/// def operand.
///
/// This will go away once we can teach tblgen how to set the optional CPSR def
/// operand itself.
struct AddSubFlagsOpcodePair {
  uint16_t PseudoOpc;
  uint16_t MachineOpc;
};

static const AddSubFlagsOpcodePair AddSubFlagsOpcodeMap[] = {
  {ARM::ADDSri, ARM::ADDri},
  {ARM::ADDSrr, ARM::ADDrr},
  {ARM::ADDSrsi, ARM::ADDrsi},
  {ARM::ADDSrsr, ARM::ADDrsr},

  {ARM::SUBSri, ARM::SUBri},
  {ARM::SUBSrr, ARM::SUBrr},
  {ARM::SUBSrsi, ARM::SUBrsi},
  {ARM::SUBSrsr, ARM::SUBrsr},

  {ARM::RSBSri, ARM::RSBri},
  {ARM::RSBSrsi, ARM::RSBrsi},
  {ARM::RSBSrsr, ARM::RSBrsr},

  {ARM::t2ADDSri, ARM::t2ADDri},
  {ARM::t2ADDSrr, ARM::t2ADDrr},
  {ARM::t2ADDSrs, ARM::t2ADDrs},

  {ARM::t2SUBSri, ARM::t2SUBri},
  {ARM::t2SUBSrr, ARM::t2SUBrr},
  {ARM::t2SUBSrs, ARM::t2SUBrs},

  {ARM::t2RSBSri, ARM::t2RSBri},
  {ARM::t2RSBSrs, ARM::t2RSBrs},
};

unsigned llvm::convertAddSubFlagsOpcode(unsigned OldOpc) {
  for (unsigned i = 0, e = array_lengthof(AddSubFlagsOpcodeMap); i != e; ++i)
    if (OldOpc == AddSubFlagsOpcodeMap[i].PseudoOpc)
      return AddSubFlagsOpcodeMap[i].MachineOpc;
  return 0;
}

void llvm::emitARMRegPlusImmediate(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator &MBBI,
                                   const DebugLoc &dl, unsigned DestReg,
                                   unsigned BaseReg, int NumBytes,
                                   ARMCC::CondCodes Pred, unsigned PredReg,
                                   const ARMBaseInstrInfo &TII,
                                   unsigned MIFlags) {
  if (NumBytes == 0 && DestReg != BaseReg) {
    BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), DestReg)
      .addReg(BaseReg, RegState::Kill)
      .addImm((unsigned)Pred).addReg(PredReg).addReg(0)
      .setMIFlags(MIFlags);
    return;
  }

  bool isSub = NumBytes < 0;
  if (isSub) NumBytes = -NumBytes;

  while (NumBytes) {
    unsigned RotAmt = ARM_AM::getSOImmValRotate(NumBytes);
    unsigned ThisVal = NumBytes & ARM_AM::rotr32(0xFF, RotAmt);
    assert(ThisVal && ""Didn't extract field correctly"");

    // We will handle these bits from offset, clear them.
    NumBytes &= ~ThisVal;

    assert(ARM_AM::getSOImmVal(ThisVal) != -1 && ""Bit extraction didn't work?"");

    // Build the new ADD / SUB.
    unsigned Opc = isSub ? ARM::SUBri : ARM::ADDri;
    BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg)
      .addReg(BaseReg, RegState::Kill).addImm(ThisVal)
      .addImm((unsigned)Pred).addReg(PredReg).addReg(0)
      .setMIFlags(MIFlags);
    BaseReg = DestReg;
  }
}

bool llvm::tryFoldSPUpdateIntoPushPop(const ARMSubtarget &Subtarget,
                                      MachineFunction &MF, MachineInstr *MI,
                                      unsigned NumBytes) {
  // This optimisation potentially adds lots of load and store
  // micro-operations, it's only really a great benefit to code-size.
  if (!MF.getFunction()->optForMinSize())
    return false;

  // If only one register is pushed/popped, LLVM can use an LDR/STR
  // instead. We can't modify those so make sure we're dealing with an
  // instruction we understand.
  bool IsPop = isPopOpcode(MI->getOpcode());
  bool IsPush = isPushOpcode(MI->getOpcode());
  if (!IsPush && !IsPop)
    return false;

  bool IsVFPPushPop = MI->getOpcode() == ARM::VSTMDDB_UPD ||
                      MI->getOpcode() == ARM::VLDMDIA_UPD;
  bool IsT1PushPop = MI->getOpcode() == ARM::tPUSH ||
                     MI->getOpcode() == ARM::tPOP ||
                     MI->getOpcode() == ARM::tPOP_RET;

  assert((IsT1PushPop || (MI->getOperand(0).getReg() == ARM::SP &&
                          MI->getOperand(1).getReg() == ARM::SP)) &&
         ""trying to fold sp update into non-sp-updating push/pop"");

  // The VFP push & pop act on D-registers, so we can only fold an adjustment
  // by a multiple of 8 bytes in correctly. Similarly rN is 4-bytes. Don't try
  // if this is violated.
  if (NumBytes % (IsVFPPushPop ? 8 : 4) != 0)
    return false;

  // ARM and Thumb2 push/pop insts have explicit ""sp, sp"" operands (+
  // pred) so the list starts at 4. Thumb1 starts after the predicate.
  int RegListIdx = IsT1PushPop ? 2 : 4;

  // Calculate the space we'll need in terms of registers.
  unsigned FirstReg = MI->getOperand(RegListIdx).getReg();
  unsigned RD0Reg, RegsNeeded;
  if (IsVFPPushPop) {
    RD0Reg = ARM::D0;
    RegsNeeded = NumBytes / 8;
  } else {
    RD0Reg = ARM::R0;
    RegsNeeded = NumBytes / 4;
  }

  // We're going to have to strip all list operands off before
  // re-adding them since the order matters, so save the existing ones
  // for later.
  SmallVector<MachineOperand, 4> RegList;
  for (int i = MI->getNumOperands() - 1; i >= RegListIdx; --i)
    RegList.push_back(MI->getOperand(i));

  const TargetRegisterInfo *TRI = MF.getRegInfo().getTargetRegisterInfo();
  const MCPhysReg *CSRegs = TRI->getCalleeSavedRegs(&MF);

  // Now try to find enough space in the reglist to allocate NumBytes.
  for (unsigned CurReg = FirstReg - 1; CurReg >= RD0Reg && RegsNeeded;
       --CurReg) {
    if (!IsPop) {
      // Pushing any register is completely harmless, mark the
      // register involved as undef since we don't care about it in
      // the slightest.
      RegList.push_back(MachineOperand::CreateReg(CurReg, false, false,
                                                  false, false, true));
      --RegsNeeded;
      continue;
    }

    // However, we can only pop an extra register if it's not live. For
    // registers live within the function we might clobber a return value
    // register; the other way a register can be live here is if it's
    // callee-saved.
    if (isCalleeSavedRegister(CurReg, CSRegs) ||
        MI->getParent()->computeRegisterLiveness(TRI, CurReg, MI) !=
        MachineBasicBlock::LQR_Dead) {
      // VFP pops don't allow holes in the register list, so any skip is fatal
      // for our transformation. GPR pops do, so we should just keep looking.
      if (IsVFPPushPop)
        return false;
      else
        continue;
    }

    // Mark the unimportant registers as <def,dead> in the POP.
    RegList.push_back(MachineOperand::CreateReg(CurReg, true, false, false,
                                                true));
    --RegsNeeded;
  }

  if (RegsNeeded > 0)
    return false;

  // Finally we know we can profitably perform the optimisation so go
  // ahead: strip all existing registers off and add them back again
  // in the right order.
  for (int i = MI->getNumOperands() - 1; i >= RegListIdx; --i)
    MI->RemoveOperand(i);

  // Add the complete list back in.
  MachineInstrBuilder MIB(MF, &*MI);
  for (int i = RegList.size() - 1; i >= 0; --i)
    MIB.addOperand(RegList[i]);

  return true;
}

bool llvm::rewriteARMFrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
                                unsigned FrameReg, int &Offset,
                                const ARMBaseInstrInfo &TII) {
  unsigned Opcode = MI.getOpcode();
  const MCInstrDesc &Desc = MI.getDesc();
  unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
  bool isSub = false;

  // Memory operands in inline assembly always use AddrMode2.
  if (Opcode == ARM::INLINEASM)
    AddrMode = ARMII::AddrMode2;

  if (Opcode == ARM::ADDri) {
    Offset += MI.getOperand(FrameRegIdx+1).getImm();
    if (Offset == 0) {
      // Turn it into a move.
      MI.setDesc(TII.get(ARM::MOVr));
      MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
      MI.RemoveOperand(FrameRegIdx+1);
      Offset = 0;
      return true;
    } else if (Offset < 0) {
      Offset = -Offset;
      isSub = true;
      MI.setDesc(TII.get(ARM::SUBri));
    }

    // Common case: small offset, fits into instruction.
    if (ARM_AM::getSOImmVal(Offset) != -1) {
      // Replace the FrameIndex with sp / fp
      MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
      MI.getOperand(FrameRegIdx+1).ChangeToImmediate(Offset);
      Offset = 0;
      return true;
    }

    // Otherwise, pull as much of the immedidate into this ADDri/SUBri
    // as possible.
    unsigned RotAmt = ARM_AM::getSOImmValRotate(Offset);
    unsigned ThisImmVal = Offset & ARM_AM::rotr32(0xFF, RotAmt);

    // We will handle these bits from offset, clear them.
    Offset &= ~ThisImmVal;

    // Get the properly encoded SOImmVal field.
    assert(ARM_AM::getSOImmVal(ThisImmVal) != -1 &&
           ""Bit extraction didn't work?"");
    MI.getOperand(FrameRegIdx+1).ChangeToImmediate(ThisImmVal);
 } else {
    unsigned ImmIdx = 0;
    int InstrOffs = 0;
    unsigned NumBits = 0;
    unsigned Scale = 1;
    switch (AddrMode) {
    case ARMII::AddrMode_i12: {
      ImmIdx = FrameRegIdx + 1;
      InstrOffs = MI.getOperand(ImmIdx).getImm();
      NumBits = 12;
      break;
    }
    case ARMII::AddrMode2: {
      ImmIdx = FrameRegIdx+2;
      InstrOffs = ARM_AM::getAM2Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM2Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 12;
      break;
    }
    case ARMII::AddrMode3: {
      ImmIdx = FrameRegIdx+2;
      InstrOffs = ARM_AM::getAM3Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM3Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 8;
      break;
    }
    case ARMII::AddrMode4:
    case ARMII::AddrMode6:
      // Can't fold any offset even if it's zero.
      return false;
    case ARMII::AddrMode5: {
      ImmIdx = FrameRegIdx+1;
      InstrOffs = ARM_AM::getAM5Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM5Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 8;
      Scale = 4;
      break;
    }
    default:
      llvm_unreachable(""Unsupported addressing mode!"");
    }

    Offset += InstrOffs * Scale;
    assert((Offset & (Scale-1)) == 0 && ""Can't encode this offset!"");
    if (Offset < 0) {
      Offset = -Offset;
      isSub = true;
    }

    // Attempt to fold address comp. if opcode has offset bits
    if (NumBits > 0) {
      // Common case: small offset, fits into instruction.
      MachineOperand &ImmOp = MI.getOperand(ImmIdx);
      int ImmedOffset = Offset / Scale;
      unsigned Mask = (1 << NumBits) - 1;
      if ((unsigned)Offset <= Mask * Scale) {
        // Replace the FrameIndex with sp
        MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
        // FIXME: When addrmode2 goes away, this will simplify (like the
        // T2 version), as the LDR.i12 versions don't need the encoding
        // tricks for the offset value.
        if (isSub) {
          if (AddrMode == ARMII::AddrMode_i12)
            ImmedOffset = -ImmedOffset;
          else
            ImmedOffset |= 1 << NumBits;
        }
        ImmOp.ChangeToImmediate(ImmedOffset);
        Offset = 0;
        return true;
      }

      // Otherwise, it didn't fit. Pull in what we can to simplify the immed.
      ImmedOffset = ImmedOffset & Mask;
      if (isSub) {
        if (AddrMode == ARMII::AddrMode_i12)
          ImmedOffset = -ImmedOffset;
        else
          ImmedOffset |= 1 << NumBits;
      }
      ImmOp.ChangeToImmediate(ImmedOffset);
      Offset &= ~(Mask*Scale);
    }
  }

  Offset = (isSub) ? -Offset : Offset;
  return Offset == 0;
}

/// analyzeCompare - For a comparison instruction, return the source registers
/// in SrcReg and SrcReg2 if having two register operands, and the value it
/// compares against in CmpValue. Return true if the comparison instruction
/// can be analyzed.
bool ARMBaseInstrInfo::
analyzeCompare(const MachineInstr *MI, unsigned &SrcReg, unsigned &SrcReg2,
               int &CmpMask, int &CmpValue) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::CMPri:
  case ARM::t2CMPri:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = 0;
    CmpMask = ~0;
    CmpValue = MI->getOperand(1).getImm();
    return true;
  case ARM::CMPrr:
  case ARM::t2CMPrr:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = MI->getOperand(1).getReg();
    CmpMask = ~0;
    CmpValue = 0;
    return true;
  case ARM::TSTri:
  case ARM::t2TSTri:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = 0;
    CmpMask = MI->getOperand(1).getImm();
    CmpValue = 0;
    return true;
  }

  return false;
}

/// isSuitableForMask - Identify a suitable 'and' instruction that
/// operates on the given source register and applies the same mask
/// as a 'tst' instruction. Provide a limited look-through for copies.
/// When successful, MI will hold the found instruction.
static bool isSuitableForMask(MachineInstr *&MI, unsigned SrcReg,
                              int CmpMask, bool CommonUse) {
  switch (MI->getOpcode()) {
    case ARM::ANDri:
    case ARM::t2ANDri:
      if (CmpMask != MI->getOperand(2).getImm())
        return false;
      if (SrcReg == MI->getOperand(CommonUse ? 1 : 0).getReg())
        return true;
      break;
  }

  return false;
}

/// getSwappedCondition - assume the flags are set by MI(a,b), return
/// the condition code if we modify the instructions such that flags are
/// set by MI(b,a).
inline static ARMCC::CondCodes getSwappedCondition(ARMCC::CondCodes CC) {
  switch (CC) {
  default: return ARMCC::AL;
  case ARMCC::EQ: return ARMCC::EQ;
  case ARMCC::NE: return ARMCC::NE;
  case ARMCC::HS: return ARMCC::LS;
  case ARMCC::LO: return ARMCC::HI;
  case ARMCC::HI: return ARMCC::LO;
  case ARMCC::LS: return ARMCC::HS;
  case ARMCC::GE: return ARMCC::LE;
  case ARMCC::LT: return ARMCC::GT;
  case ARMCC::GT: return ARMCC::LT;
  case ARMCC::LE: return ARMCC::GE;
  }
}

/// isRedundantFlagInstr - check whether the first instruction, whose only
/// purpose is to update flags, can be made redundant.
/// CMPrr can be made redundant by SUBrr if the operands are the same.
/// CMPri can be made redundant by SUBri if the operands are the same.
/// This function can be extended later on.
inline static bool isRedundantFlagInstr(MachineInstr *CmpI, unsigned SrcReg,
                                        unsigned SrcReg2, int ImmValue,
                                        MachineInstr *OI) {
  if ((CmpI->getOpcode() == ARM::CMPrr ||
       CmpI->getOpcode() == ARM::t2CMPrr) &&
      (OI->getOpcode() == ARM::SUBrr ||
       OI->getOpcode() == ARM::t2SUBrr) &&
      ((OI->getOperand(1).getReg() == SrcReg &&
        OI->getOperand(2).getReg() == SrcReg2) ||
       (OI->getOperand(1).getReg() == SrcReg2 &&
        OI->getOperand(2).getReg() == SrcReg)))
    return true;

  if ((CmpI->getOpcode() == ARM::CMPri ||
       CmpI->getOpcode() == ARM::t2CMPri) &&
      (OI->getOpcode() == ARM::SUBri ||
       OI->getOpcode() == ARM::t2SUBri) &&
      OI->getOperand(1).getReg() == SrcReg &&
      OI->getOperand(2).getImm() == ImmValue)
    return true;
  return false;
}

/// optimizeCompareInstr - Convert the instruction supplying the argument to the
/// comparison into one that sets the zero bit in the flags register;
/// Remove a redundant Compare instruction if an earlier instruction can set the
/// flags in the same way as Compare.
/// E.g. SUBrr(r1,r2) and CMPrr(r1,r2). We also handle the case where two
/// operands are swapped: SUBrr(r1,r2) and CMPrr(r2,r1), by updating the
/// condition code of instructions which use the flags.
bool ARMBaseInstrInfo::
optimizeCompareInstr(MachineInstr *CmpInstr, unsigned SrcReg, unsigned SrcReg2,
                     int CmpMask, int CmpValue,
                     const MachineRegisterInfo *MRI) const {
  // Get the unique definition of SrcReg.
  MachineInstr *MI = MRI->getUniqueVRegDef(SrcReg);
  if (!MI) return false;

  // Masked compares sometimes use the same register as the corresponding 'and'.
  if (CmpMask != ~0) {
    if (!isSuitableForMask(MI, SrcReg, CmpMask, false) || isPredicated(*MI)) {
      MI = nullptr;
      for (MachineRegisterInfo::use_instr_iterator
           UI = MRI->use_instr_begin(SrcReg), UE = MRI->use_instr_end();
           UI != UE; ++UI) {
        if (UI->getParent() != CmpInstr->getParent()) continue;
        MachineInstr *PotentialAND = &*UI;
        if (!isSuitableForMask(PotentialAND, SrcReg, CmpMask, true) ||
            isPredicated(*PotentialAND))
          continue;
        MI = PotentialAND;
        break;
      }
      if (!MI) return false;
    }
  }

  // Get ready to iterate backward from CmpInstr.
  MachineBasicBlock::iterator I = CmpInstr, E = MI,
                              B = CmpInstr->getParent()->begin();

  // Early exit if CmpInstr is at the beginning of the BB.
  if (I == B) return false;

  // There are two possible candidates which can be changed to set CPSR:
  // One is MI, the other is a SUB instruction.
  // For CMPrr(r1,r2), we are looking for SUB(r1,r2) or SUB(r2,r1).
  // For CMPri(r1, CmpValue), we are looking for SUBri(r1, CmpValue).
  MachineInstr *Sub = nullptr;
  if (SrcReg2 != 0)
    // MI is not a candidate for CMPrr.
    MI = nullptr;
  else if (MI->getParent() != CmpInstr->getParent() || CmpValue != 0) {
    // Conservatively refuse to convert an instruction which isn't in the same
    // BB as the comparison.
    // For CMPri w/ CmpValue != 0, a Sub may still be a candidate.
    // Thus we cannot return here.
    if (CmpInstr->getOpcode() == ARM::CMPri ||
       CmpInstr->getOpcode() == ARM::t2CMPri)
      MI = nullptr;
    else
      return false;
  }

  // Check that CPSR isn't set between the comparison instruction and the one we
  // want to change. At the same time, search for Sub.
  const TargetRegisterInfo *TRI = &getRegisterInfo();
  --I;
  for (; I != E; --I) {
    const MachineInstr &Instr = *I;

    if (Instr.modifiesRegister(ARM::CPSR, TRI) ||
        Instr.readsRegister(ARM::CPSR, TRI))
      // This instruction modifies or uses CPSR after the one we want to
      // change. We can't do this transformation.
      return false;

    // Check whether CmpInstr can be made redundant by the current instruction.
    if (isRedundantFlagInstr(CmpInstr, SrcReg, SrcReg2, CmpValue, &*I)) {
      Sub = &*I;
      break;
    }

    if (I == B)
      // The 'and' is below the comparison instruction.
      return false;
  }

  // Return false if no candidates exist.
  if (!MI && !Sub)
    return false;

  // The single candidate is called MI.
  if (!MI) MI = Sub;

  // We can't use a predicated instruction - it doesn't always write the flags.
  if (isPredicated(*MI))
    return false;

  switch (MI->getOpcode()) {
  default: break;
  case ARM::RSBrr:
  case ARM::RSBri:
  case ARM::RSCrr:
  case ARM::RSCri:
  case ARM::ADDrr:
  case ARM::ADDri:
  case ARM::ADCrr:
  case ARM::ADCri:
  case ARM::SUBrr:
  case ARM::SUBri:
  case ARM::SBCrr:
  case ARM::SBCri:
  case ARM::t2RSBri:
  case ARM::t2ADDrr:
  case ARM::t2ADDri:
  case ARM::t2ADCrr:
  case ARM::t2ADCri:
  case ARM::t2SUBrr:
  case ARM::t2SUBri:
  case ARM::t2SBCrr:
  case ARM::t2SBCri:
  case ARM::ANDrr:
  case ARM::ANDri:
  case ARM::t2ANDrr:
  case ARM::t2ANDri:
  case ARM::ORRrr:
  case ARM::ORRri:
  case ARM::t2ORRrr:
  case ARM::t2ORRri:
  case ARM::EORrr:
  case ARM::EORri:
  case ARM::t2EORrr:
  case ARM::t2EORri: {
    // Scan forward for the use of CPSR
    // When checking against MI: if it's a conditional code that requires
    // checking of the V bit or C bit, then this is not safe to do.
    // It is safe to remove CmpInstr if CPSR is redefined or killed.
    // If we are done with the basic block, we need to check whether CPSR is
    // live-out.
    SmallVector<std::pair<MachineOperand*, ARMCC::CondCodes>, 4>
        OperandsToUpdate;
    bool isSafe = false;
    I = CmpInstr;
    E = CmpInstr->getParent()->end();
    while (!isSafe && ++I != E) {
      const MachineInstr &Instr = *I;
      for (unsigned IO = 0, EO = Instr.getNumOperands();
           !isSafe && IO != EO; ++IO) {
        const MachineOperand &MO = Instr.getOperand(IO);
        if (MO.isRegMask() && MO.clobbersPhysReg(ARM::CPSR)) {
          isSafe = true;
          break;
        }
        if (!MO.isReg() || MO.getReg() != ARM::CPSR)
          continue;
        if (MO.isDef()) {
          isSafe = true;
          break;
        }
        // Condition code is after the operand before CPSR except for VSELs.
        ARMCC::CondCodes CC;
        bool IsInstrVSel = true;
        switch (Instr.getOpcode()) {
        default:
          IsInstrVSel = false;
          CC = (ARMCC::CondCodes)Instr.getOperand(IO - 1).getImm();
          break;
        case ARM::VSELEQD:
        case ARM::VSELEQS:
          CC = ARMCC::EQ;
          break;
        case ARM::VSELGTD:
        case ARM::VSELGTS:
          CC = ARMCC::GT;
          break;
        case ARM::VSELGED:
        case ARM::VSELGES:
          CC = ARMCC::GE;
          break;
        case ARM::VSELVSS:
        case ARM::VSELVSD:
          CC = ARMCC::VS;
          break;
        }

        if (Sub) {
          ARMCC::CondCodes NewCC = getSwappedCondition(CC);
          if (NewCC == ARMCC::AL)
            return false;
          // If we have SUB(r1, r2) and CMP(r2, r1), the condition code based
          // on CMP needs to be updated to be based on SUB.
          // Push the condition code operands to OperandsToUpdate.
          // If it is safe to remove CmpInstr, the condition code of these
          // operands will be modified.
          if (SrcReg2 != 0 && Sub->getOperand(1).getReg() == SrcReg2 &&
              Sub->getOperand(2).getReg() == SrcReg) {
            // VSel doesn't support condition code update.
            if (IsInstrVSel)
              return false;
            OperandsToUpdate.push_back(
                std::make_pair(&((*I).getOperand(IO - 1)), NewCC));
          }
        } else {
          // No Sub, so this is x = <op> y, z; cmp x, 0.
          switch (CC) {
          case ARMCC::EQ: // Z
          case ARMCC::NE: // Z
          case ARMCC::MI: // N
          case ARMCC::PL: // N
          case ARMCC::AL: // none
            // CPSR can be used multiple times, we should continue.
            break;
          case ARMCC::HS: // C
          case ARMCC::LO: // C
          case ARMCC::VS: // V
          case ARMCC::VC: // V
          case ARMCC::HI: // C Z
          case ARMCC::LS: // C Z
          case ARMCC::GE: // N V
          case ARMCC::LT: // N V
          case ARMCC::GT: // Z N V
          case ARMCC::LE: // Z N V
            // The instruction uses the V bit or C bit which is not safe.
            return false;
          }
        }
      }
    }

    // If CPSR is not killed nor re-defined, we should check whether it is
    // live-out. If it is live-out, do not optimize.
    if (!isSafe) {
      MachineBasicBlock *MBB = CmpInstr->getParent();
      for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
               SE = MBB->succ_end(); SI != SE; ++SI)
        if ((*SI)->isLiveIn(ARM::CPSR))
          return false;
    }

    // Toggle the optional operand to CPSR.
    MI->getOperand(5).setReg(ARM::CPSR);
    MI->getOperand(5).setIsDef(true);
    assert(!isPredicated(*MI) && ""Can't use flags from predicated instruction"");
    CmpInstr->eraseFromParent();

    // Modify the condition code of operands in OperandsToUpdate.
    // Since we have SUB(r1, r2) and CMP(r2, r1), the condition code needs to
    // be changed from r2 > r1 to r1 < r2, from r2 < r1 to r1 > r2, etc.
    for (unsigned i = 0, e = OperandsToUpdate.size(); i < e; i++)
      OperandsToUpdate[i].first->setImm(OperandsToUpdate[i].second);
    return true;
  }
  }

  return false;
}

bool ARMBaseInstrInfo::FoldImmediate(MachineInstr *UseMI,
                                     MachineInstr *DefMI, unsigned Reg,
                                     MachineRegisterInfo *MRI) const {
  // Fold large immediates into add, sub, or, xor.
  unsigned  [MASK]  = DefMI->getOpcode();
  if ( [MASK]  != ARM::t2MOVi32imm &&  [MASK]  != ARM::MOVi32imm)
    return false;
  if (!DefMI->getOperand(1).isImm())
    // Could be t2MOVi32imm <ga:xx>
    return false;

  if (!MRI->hasOneNonDBGUse(Reg))
    return false;

  const MCInstrDesc &DefMCID = DefMI->getDesc();
  if (DefMCID.hasOptionalDef()) {
    unsigned NumOps = DefMCID.getNumOperands();
    const MachineOperand &MO = DefMI->getOperand(NumOps-1);
    if (MO.getReg() == ARM::CPSR && !MO.isDead())
      // If DefMI defines CPSR and it is not dead, it's obviously not safe
      // to delete DefMI.
      return false;
  }

  const MCInstrDesc &UseMCID = UseMI->getDesc();
  if (UseMCID.hasOptionalDef()) {
    unsigned NumOps = UseMCID.getNumOperands();
    if (UseMI->getOperand(NumOps-1).getReg() == ARM::CPSR)
      // If the instruction sets the flag, do not attempt this optimization
      // since it may change the semantics of the code.
      return false;
  }

  unsigned UseOpc = UseMI->getOpcode();
  unsigned NewUseOpc = 0;
  uint32_t ImmVal = (uint32_t)DefMI->getOperand(1).getImm();
  uint32_t SOImmValV1 = 0, SOImmValV2 = 0;
  bool Commute = false;
  switch (UseOpc) {
  default: return false;
  case ARM::SUBrr:
  case ARM::ADDrr:
  case ARM::ORRrr:
  case ARM::EORrr:
  case ARM::t2SUBrr:
  case ARM::t2ADDrr:
  case ARM::t2ORRrr:
  case ARM::t2EORrr: {
    Commute = UseMI->getOperand(2).getReg() != Reg;
    switch (UseOpc) {
    default: break;
    case ARM::ADDrr:
    case ARM::SUBrr: {
      if (UseOpc == ARM::SUBrr && Commute)
        return false;

      // ADD/SUB are special because they're essentially the same operation, so
      // we can handle a larger range of immediates.
      if (ARM_AM::isSOImmTwoPartVal(ImmVal))
        NewUseOpc = UseOpc == ARM::ADDrr ? ARM::ADDri : ARM::SUBri;
      else if (ARM_AM::isSOImmTwoPartVal(-ImmVal)) {
        ImmVal = -ImmVal;
        NewUseOpc = UseOpc == ARM::ADDrr ? ARM::SUBri : ARM::ADDri;
      } else
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getSOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getSOImmTwoPartSecond(ImmVal);
      break;
    }
    case ARM::ORRrr:
    case ARM::EORrr: {
      if (!ARM_AM::isSOImmTwoPartVal(ImmVal))
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getSOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getSOImmTwoPartSecond(ImmVal);
      switch (UseOpc) {
      default: break;
      case ARM::ORRrr: NewUseOpc = ARM::ORRri; break;
      case ARM::EORrr: NewUseOpc = ARM::EORri; break;
      }
      break;
    }
    case ARM::t2ADDrr:
    case ARM::t2SUBrr: {
      if (UseOpc == ARM::t2SUBrr && Commute)
        return false;

      // ADD/SUB are special because they're essentially the same operation, so
      // we can handle a larger range of immediates.
      if (ARM_AM::isT2SOImmTwoPartVal(ImmVal))
        NewUseOpc = UseOpc == ARM::t2ADDrr ? ARM::t2ADDri : ARM::t2SUBri;
      else if (ARM_AM::isT2SOImmTwoPartVal(-ImmVal)) {
        ImmVal = -ImmVal;
        NewUseOpc = UseOpc == ARM::t2ADDrr ? ARM::t2SUBri : ARM::t2ADDri;
      } else
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getT2SOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getT2SOImmTwoPartSecond(ImmVal);
      break;
    }
    case ARM::t2ORRrr:
    case ARM::t2EORrr: {
      if (!ARM_AM::isT2SOImmTwoPartVal(ImmVal))
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getT2SOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getT2SOImmTwoPartSecond(ImmVal);
      switch (UseOpc) {
      default: break;
      case ARM::t2ORRrr: NewUseOpc = ARM::t2ORRri; break;
      case ARM::t2EORrr: NewUseOpc = ARM::t2EORri; break;
      }
      break;
    }
    }
  }
  }

  unsigned OpIdx = Commute ? 2 : 1;
  unsigned Reg1 = UseMI->getOperand(OpIdx).getReg();
  bool isKill = UseMI->getOperand(OpIdx).isKill();
  unsigned NewReg = MRI->createVirtualRegister(MRI->getRegClass(Reg));
  AddDefaultCC(AddDefaultPred(BuildMI(*UseMI->getParent(),
                                      UseMI, UseMI->getDebugLoc(),
                                      get(NewUseOpc), NewReg)
                              .addReg(Reg1, getKillRegState(isKill))
                              .addImm(SOImmValV1)));
  UseMI->setDesc(get(NewUseOpc));
  UseMI->getOperand(1).setReg(NewReg);
  UseMI->getOperand(1).setIsKill();
  UseMI->getOperand(2).ChangeToImmediate(SOImmValV2);
  DefMI->eraseFromParent();
  return true;
}

static unsigned getNumMicroOpsSwiftLdSt(const InstrItineraryData *ItinData,
                                        const MachineInstr *MI) {
  switch (MI->getOpcode()) {
  default: {
    const MCInstrDesc &Desc = MI->getDesc();
    int UOps = ItinData->getNumMicroOps(Desc.getSchedClass());
    assert(UOps >= 0 && ""bad # UOps"");
    return UOps;
  }

  case ARM::LDRrs:
  case ARM::LDRBrs:
  case ARM::STRrs:
  case ARM::STRBrs: {
    unsigned ShOpVal = MI->getOperand(3).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 1;
    return 2;
  }

  case ARM::LDRH:
  case ARM::STRH: {
    if (!MI->getOperand(2).getReg())
      return 1;

    unsigned ShOpVal = MI->getOperand(3).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 1;
    return 2;
  }

  case ARM::LDRSB:
  case ARM::LDRSH:
    return (ARM_AM::getAM3Op(MI->getOperand(3).getImm()) == ARM_AM::sub) ? 3:2;

  case ARM::LDRSB_POST:
  case ARM::LDRSH_POST: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    return (Rt == Rm) ? 4 : 3;
  }

  case ARM::LDR_PRE_REG:
  case ARM::LDRB_PRE_REG: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rt == Rm)
      return 3;
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 2;
    return 3;
  }

  case ARM::STR_PRE_REG:
  case ARM::STRB_PRE_REG: {
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 2;
    return 3;
  }

  case ARM::LDRH_PRE:
  case ARM::STRH_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (!Rm)
      return 2;
    if (Rt == Rm)
      return 3;
    return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub)
      ? 3 : 2;
  }

  case ARM::LDR_POST_REG:
  case ARM::LDRB_POST_REG:
  case ARM::LDRH_POST: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    return (Rt == Rm) ? 3 : 2;
  }

  case ARM::LDR_PRE_IMM:
  case ARM::LDRB_PRE_IMM:
  case ARM::LDR_POST_IMM:
  case ARM::LDRB_POST_IMM:
  case ARM::STRB_POST_IMM:
  case ARM::STRB_POST_REG:
  case ARM::STRB_PRE_IMM:
  case ARM::STRH_POST:
  case ARM::STR_POST_IMM:
  case ARM::STR_POST_REG:
  case ARM::STR_PRE_IMM:
    return 2;

  case ARM::LDRSB_PRE:
  case ARM::LDRSH_PRE: {
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm == 0)
      return 3;
    unsigned Rt = MI->getOperand(0).getReg();
    if (Rt == Rm)
      return 4;
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 3;
    return 4;
  }

  case ARM::LDRD: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(2).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub) ?4:3;
    return (Rt == Rn) ? 3 : 2;
  }

  case ARM::STRD: {
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub) ?4:3;
    return 2;
  }

  case ARM::LDRD_POST:
  case ARM::t2LDRD_POST:
    return 3;

  case ARM::STRD_POST:
  case ARM::t2STRD_POST:
    return 4;

  case ARM::LDRD_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(3).getReg();
    unsigned Rm = MI->getOperand(4).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(5).getImm()) == ARM_AM::sub) ?5:4;
    return (Rt == Rn) ? 4 : 3;
  }

  case ARM::t2LDRD_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(3).getReg();
    return (Rt == Rn) ? 4 : 3;
  }

  case ARM::STRD_PRE: {
    unsigned Rm = MI->getOperand(4).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(5).getImm()) == ARM_AM::sub) ?5:4;
    return 3;
  }

  case ARM::t2STRD_PRE:
    return 3;

  case ARM::t2LDR_POST:
  case ARM::t2LDRB_POST:
  case ARM::t2LDRB_PRE:
  case ARM::t2LDRSBi12:
  case ARM::t2LDRSBi8:
  case ARM::t2LDRSBpci:
  case ARM::t2LDRSBs:
  case ARM::t2LDRH_POST:
  case ARM::t2LDRH_PRE:
  case ARM::t2LDRSBT:
  case ARM::t2LDRSB_POST:
  case ARM::t2LDRSB_PRE:
  case ARM::t2LDRSH_POST:
  case ARM::t2LDRSH_PRE:
  case ARM::t2LDRSHi12:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRSHpci:
  case ARM::t2LDRSHs:
    return 2;

  case ARM::t2LDRDi8: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(2).getReg();
    return (Rt == Rn) ? 3 : 2;
  }

  case ARM::t2STRB_POST:
  case ARM::t2STRB_PRE:
  case ARM::t2STRBs:
  case ARM::t2STRDi8:
  case ARM::t2STRH_POST:
  case ARM::t2STRH_PRE:
  case ARM::t2STRHs:
  case ARM::t2STR_POST:
  case ARM::t2STR_PRE:
  case ARM::t2STRs:
    return 2;
  }
}

// Return the number of 32-bit words loaded by LDM or stored by STM. If this
// can't be easily determined return 0 (missing MachineMemOperand).
//
// FIXME: The current MachineInstr design does not support relying on machine
// mem operands to determine the width of a memory access. Instead, we expect
// the target to provide this information based on the instruction opcode and
// operands. However, using MachineMemOperand is the best solution now for
// two reasons:
//
// 1) getNumMicroOps tries to infer LDM memory width from the total number of MI
// operands. This is much more dangerous than using the MachineMemOperand
// sizes because CodeGen passes can insert/remove optional machine operands. In
// fact, it's totally incorrect for preRA passes and appears to be wrong for
// postRA passes as well.
//
// 2) getNumLDMAddresses is only used by the scheduling machine model and any
// machine model that calls this should handle the unknown (zero size) case.
//
// Long term, we should require a target hook that verifies MachineMemOperand
// sizes during MC lowering. That target hook should be local to MC lowering
// because we can't ensure that it is aware of other MI forms. Doing this will
// ensure that MachineMemOperands are correctly propagated through all passes.
unsigned ARMBaseInstrInfo::getNumLDMAddresses(const MachineInstr *MI) const {
  unsigned Size = 0;
  for (MachineInstr::mmo_iterator I = MI->memoperands_begin(),
         E = MI->memoperands_end(); I != E; ++I) {
    Size += (*I)->getSize();
  }
  return Size / 4;
}

unsigned
ARMBaseInstrInfo::getNumMicroOps(const InstrItineraryData *ItinData,
                                 const MachineInstr *MI) const {
  if (!ItinData || ItinData->isEmpty())
    return 1;

  const MCInstrDesc &Desc = MI->getDesc();
  unsigned Class = Desc.getSchedClass();
  int ItinUOps = ItinData->getNumMicroOps(Class);
  if (ItinUOps >= 0) {
    if (Subtarget.isSwift() && (Desc.mayLoad() || Desc.mayStore()))
      return getNumMicroOpsSwiftLdSt(ItinData, MI);

    return ItinUOps;
  }

  unsigned Opc = MI->getOpcode();
  switch (Opc) {
  default:
    llvm_unreachable(""Unexpected multi-uops instruction!"");
  case ARM::VLDMQIA:
  case ARM::VSTMQIA:
    return 2;

  // The number of uOps for load / store multiple are determined by the number
  // registers.
  //
  // On Cortex-A8, each pair of register loads / stores can be scheduled on the
  // same cycle. The scheduling for the first load / store must be done
  // separately by assuming the address is not 64-bit aligned.
  //
  // On Cortex-A9, the formula is simply (#reg / 2) + (#reg % 2). If the address
  // is not 64-bit aligned, then AGU would take an extra cycle.  For VFP / NEON
  // load / store multiple, the formula is (#reg / 2) + (#reg % 2) + 1.
  case ARM::VLDMDIA:
  case ARM::VLDMDIA_UPD:
  case ARM::VLDMDDB_UPD:
  case ARM::VLDMSIA:
  case ARM::VLDMSIA_UPD:
  case ARM::VLDMSDB_UPD:
  case ARM::VSTMDIA:
  case ARM::VSTMDIA_UPD:
  case ARM::VSTMDDB_UPD:
  case ARM::VSTMSIA:
  case ARM::VSTMSIA_UPD:
  case ARM::VSTMSDB_UPD: {
    unsigned NumRegs = MI->getNumOperands() - Desc.getNumOperands();
    return (NumRegs / 2) + (NumRegs % 2) + 1;
  }

  case ARM::LDMIA_RET:
  case ARM::LDMIA:
  case ARM::LDMDA:
  case ARM::LDMDB:
  case ARM::LDMIB:
  case ARM::LDMIA_UPD:
  case ARM::LDMDA_UPD:
  case ARM::LDMDB_UPD:
  case ARM::LDMIB_UPD:
  case ARM::STMIA:
  case ARM::STMDA:
  case ARM::STMDB:
  case ARM::STMIB:
  case ARM::STMIA_UPD:
  case ARM::STMDA_UPD:
  case ARM::STMDB_UPD:
  case ARM::STMIB_UPD:
  case ARM::tLDMIA:
  case ARM::tLDMIA_UPD:
  case ARM::tSTMIA_UPD:
  case ARM::tPOP_RET:
  case ARM::tPOP:
  case ARM::tPUSH:
  case ARM::t2LDMIA_RET:
  case ARM::t2LDMIA:
  case ARM::t2LDMDB:
  case ARM::t2LDMIA_UPD:
  case ARM::t2LDMDB_UPD:
  case ARM::t2STMIA:
  case ARM::t2STMDB:
  case ARM::t2STMIA_UPD:
  case ARM::t2STMDB_UPD: {
    unsigned NumRegs = MI->getNumOperands() - Desc.getNumOperands() + 1;
    if (Subtarget.isSwift()) {
      int UOps = 1 + NumRegs;  // One for address computation, one for each ld / st.
      switch (Opc) {
      default: break;
      case ARM::VLDMDIA_UPD:
      case ARM::VLDMDDB_UPD:
      case ARM::VLDMSIA_UPD:
      case ARM::VLDMSDB_UPD:
      case ARM::VSTMDIA_UPD:
      case ARM::VSTMDDB_UPD:
      case ARM::VSTMSIA_UPD:
      case ARM::VSTMSDB_UPD:
      case ARM::LDMIA_UPD:
      case ARM::LDMDA_UPD:
      case ARM::LDMDB_UPD:
      case ARM::LDMIB_UPD:
      case ARM::STMIA_UPD:
      case ARM::STMDA_UPD:
      case ARM::STMDB_UPD:
      case ARM::STMIB_UPD:
      case ARM::tLDMIA_UPD:
      case ARM::tSTMIA_UPD:
      case ARM::t2LDMIA_UPD:
      case ARM::t2LDMDB_UPD:
      case ARM::t2STMIA_UPD:
      case ARM::t2STMDB_UPD:
        ++UOps; // One for base register writeback.
        break;
      case ARM::LDMIA_RET:
      case ARM::tPOP_RET:
      case ARM::t2LDMIA_RET:
        UOps += 2; // One for base reg wb, one for write to pc.
        break;
      }
      return UOps;
    } else if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
      if (NumRegs < 4)
        return 2;
      // 4 registers would be issued: 2, 2.
      // 5 registers would be issued: 2, 2, 1.
      int A8UOps = (NumRegs / 2);
      if (NumRegs % 2)
        ++A8UOps;
      return A8UOps;
    } else if (Subtarget.isLikeA9()) {
      int A9UOps = (NumRegs / 2);
      // If there are odd number of registers or if it's not 64-bit aligned,
      // then it takes an extra AGU (Address Generation Unit) cycle.
      if ((NumRegs % 2) ||
          !MI->hasOneMemOperand() ||
          (*MI->memoperands_begin())->getAlignment() < 8)
        ++A9UOps;
      return A9UOps;
    } else {
      // Assume the worst.
      return NumRegs;
    }
  }
  }
}

int
ARMBaseInstrInfo::getVLDMDefCycle(const InstrItineraryData *ItinData,
                                  const MCInstrDesc &DefMCID,
                                  unsigned DefClass,
                                  unsigned DefIdx, unsigned DefAlign) const {
  int RegNo = (int)(DefIdx+1) - DefMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    // Def is the address writeback.
    return ItinData->getOperandCycle(DefClass, DefIdx);

  int DefCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // (regno / 2) + (regno % 2) + 1
    DefCycle = RegNo / 2 + 1;
    if (RegNo % 2)
      ++DefCycle;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    DefCycle = RegNo;
    bool isSLoad = false;

    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::VLDMSIA:
    case ARM::VLDMSIA_UPD:
    case ARM::VLDMSDB_UPD:
      isSLoad = true;
      break;
    }

    // If there are odd number of 'S' registers or if it's not 64-bit aligned,
    // then it takes an extra cycle.
    if ((isSLoad && (RegNo % 2)) || DefAlign < 8)
      ++DefCycle;
  } else {
    // Assume the worst.
    DefCycle = RegNo + 2;
  }

  return DefCycle;
}

int
ARMBaseInstrInfo::getLDMDefCycle(const InstrItineraryData *ItinData,
                                 const MCInstrDesc &DefMCID,
                                 unsigned DefClass,
                                 unsigned DefIdx, unsigned DefAlign) const {
  int RegNo = (int)(DefIdx+1) - DefMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    // Def is the address writeback.
    return ItinData->getOperandCycle(DefClass, DefIdx);

  int DefCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // 4 registers would be issued: 1, 2, 1.
    // 5 registers would be issued: 1, 2, 2.
    DefCycle = RegNo / 2;
    if (DefCycle < 1)
      DefCycle = 1;
    // Result latency is issue cycle + 2: E2.
    DefCycle += 2;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    DefCycle = (RegNo / 2);
    // If there are odd number of registers or if it's not 64-bit aligned,
    // then it takes an extra AGU (Address Generation Unit) cycle.
    if ((RegNo % 2) || DefAlign < 8)
      ++DefCycle;
    // Result latency is AGU cycles + 2.
    DefCycle += 2;
  } else {
    // Assume the worst.
    DefCycle = RegNo + 2;
  }

  return DefCycle;
}

int
ARMBaseInstrInfo::getVSTMUseCycle(const InstrItineraryData *ItinData,
                                  const MCInstrDesc &UseMCID,
                                  unsigned UseClass,
                                  unsigned UseIdx, unsigned UseAlign) const {
  int RegNo = (int)(UseIdx+1) - UseMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    return ItinData->getOperandCycle(UseClass, UseIdx);

  int UseCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // (regno / 2) + (regno % 2) + 1
    UseCycle = RegNo / 2 + 1;
    if (RegNo % 2)
      ++UseCycle;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    UseCycle = RegNo;
    bool isSStore = false;

    switch (UseMCID.getOpcode()) {
    default: break;
    case ARM::VSTMSIA:
    case ARM::VSTMSIA_UPD:
    case ARM::VSTMSDB_UPD:
      isSStore = true;
      break;
    }

    // If there are odd number of 'S' registers or if it's not 64-bit aligned,
    // then it takes an extra cycle.
    if ((isSStore && (RegNo % 2)) || UseAlign < 8)
      ++UseCycle;
  } else {
    // Assume the worst.
    UseCycle = RegNo + 2;
  }

  return UseCycle;
}

int
ARMBaseInstrInfo::getSTMUseCycle(const InstrItineraryData *ItinData,
                                 const MCInstrDesc &UseMCID,
                                 unsigned UseClass,
                                 unsigned UseIdx, unsigned UseAlign) const {
  int RegNo = (int)(UseIdx+1) - UseMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    return ItinData->getOperandCycle(UseClass, UseIdx);

  int UseCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    UseCycle = RegNo / 2;
    if (UseCycle < 2)
      UseCycle = 2;
    // Read in E3.
    UseCycle += 2;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    UseCycle = (RegNo / 2);
    // If there are odd number of registers or if it's not 64-bit aligned,
    // then it takes an extra AGU (Address Generation Unit) cycle.
    if ((RegNo % 2) || UseAlign < 8)
      ++UseCycle;
  } else {
    // Assume the worst.
    UseCycle = 1;
  }
  return UseCycle;
}

int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    const MCInstrDesc &DefMCID,
                                    unsigned DefIdx, unsigned DefAlign,
                                    const MCInstrDesc &UseMCID,
                                    unsigned UseIdx, unsigned UseAlign) const {
  unsigned DefClass = DefMCID.getSchedClass();
  unsigned UseClass = UseMCID.getSchedClass();

  if (DefIdx < DefMCID.getNumDefs() && UseIdx < UseMCID.getNumOperands())
    return ItinData->getOperandLatency(DefClass, DefIdx, UseClass, UseIdx);

  // This may be a def / use of a variable_ops instruction, the operand
  // latency might be determinable dynamically. Let the target try to
  // figure it out.
  int DefCycle = -1;
  bool LdmBypass = false;
  switch (DefMCID.getOpcode()) {
  default:
    DefCycle = ItinData->getOperandCycle(DefClass, DefIdx);
    break;

  case ARM::VLDMDIA:
  case ARM::VLDMDIA_UPD:
  case ARM::VLDMDDB_UPD:
  case ARM::VLDMSIA:
  case ARM::VLDMSIA_UPD:
  case ARM::VLDMSDB_UPD:
    DefCycle = getVLDMDefCycle(ItinData, DefMCID, DefClass, DefIdx, DefAlign);
    break;

  case ARM::LDMIA_RET:
  case ARM::LDMIA:
  case ARM::LDMDA:
  case ARM::LDMDB:
  case ARM::LDMIB:
  case ARM::LDMIA_UPD:
  case ARM::LDMDA_UPD:
  case ARM::LDMDB_UPD:
  case ARM::LDMIB_UPD:
  case ARM::tLDMIA:
  case ARM::tLDMIA_UPD:
  case ARM::tPUSH:
  case ARM::t2LDMIA_RET:
  case ARM::t2LDMIA:
  case ARM::t2LDMDB:
  case ARM::t2LDMIA_UPD:
  case ARM::t2LDMDB_UPD:
    LdmBypass = 1;
    DefCycle = getLDMDefCycle(ItinData, DefMCID, DefClass, DefIdx, DefAlign);
    break;
  }

  if (DefCycle == -1)
    // We can't seem to determine the result latency of the def, assume it's 2.
    DefCycle = 2;

  int UseCycle = -1;
  switch (UseMCID.getOpcode()) {
  default:
    UseCycle = ItinData->getOperandCycle(UseClass, UseIdx);
    break;

  case ARM::VSTMDIA:
  case ARM::VSTMDIA_UPD:
  case ARM::VSTMDDB_UPD:
  case ARM::VSTMSIA:
  case ARM::VSTMSIA_UPD:
  case ARM::VSTMSDB_UPD:
    UseCycle = getVSTMUseCycle(ItinData, UseMCID, UseClass, UseIdx, UseAlign);
    break;

  case ARM::STMIA:
  case ARM::STMDA:
  case ARM::STMDB:
  case ARM::STMIB:
  case ARM::STMIA_UPD:
  case ARM::STMDA_UPD:
  case ARM::STMDB_UPD:
  case ARM::STMIB_UPD:
  case ARM::tSTMIA_UPD:
  case ARM::tPOP_RET:
  case ARM::tPOP:
  case ARM::t2STMIA:
  case ARM::t2STMDB:
  case ARM::t2STMIA_UPD:
  case ARM::t2STMDB_UPD:
    UseCycle = getSTMUseCycle(ItinData, UseMCID, UseClass, UseIdx, UseAlign);
    break;
  }

  if (UseCycle == -1)
    // Assume it's read in the first stage.
    UseCycle = 1;

  UseCycle = DefCycle - UseCycle + 1;
  if (UseCycle > 0) {
    if (LdmBypass) {
      // It's a variable_ops instruction so we can't use DefIdx here. Just use
      // first def operand.
      if (ItinData->hasPipelineForwarding(DefClass, DefMCID.getNumOperands()-1,
                                          UseClass, UseIdx))
        --UseCycle;
    } else if (ItinData->hasPipelineForwarding(DefClass, DefIdx,
                                               UseClass, UseIdx)) {
      --UseCycle;
    }
  }

  return UseCycle;
}

static const MachineInstr *getBundledDefMI(const TargetRegisterInfo *TRI,
                                           const MachineInstr *MI, unsigned Reg,
                                           unsigned &DefIdx, unsigned &Dist) {
  Dist = 0;

  MachineBasicBlock::const_iterator I = MI; ++I;
  MachineBasicBlock::const_instr_iterator II = std::prev(I.getInstrIterator());
  assert(II->isInsideBundle() && ""Empty bundle?"");

  int Idx = -1;
  while (II->isInsideBundle()) {
    Idx = II->findRegisterDefOperandIdx(Reg, false, true, TRI);
    if (Idx != -1)
      break;
    --II;
    ++Dist;
  }

  assert(Idx != -1 && ""Cannot find bundled definition!"");
  DefIdx = Idx;
  return &*II;
}

static const MachineInstr *getBundledUseMI(const TargetRegisterInfo *TRI,
                                           const MachineInstr *MI, unsigned Reg,
                                           unsigned &UseIdx, unsigned &Dist) {
  Dist = 0;

  MachineBasicBlock::const_instr_iterator II = ++MI->getIterator();
  assert(II->isInsideBundle() && ""Empty bundle?"");
  MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();

  // FIXME: This doesn't properly handle multiple uses.
  int Idx = -1;
  while (II != E && II->isInsideBundle()) {
    Idx = II->findRegisterUseOperandIdx(Reg, false, TRI);
    if (Idx != -1)
      break;
    if (II->getOpcode() != ARM::t2IT)
      ++Dist;
    ++II;
  }

  if (Idx == -1) {
    Dist = 0;
    return nullptr;
  }

  UseIdx = Idx;
  return &*II;
}

/// Return the number of cycles to add to (or subtract from) the static
/// itinerary based on the def opcode and alignment. The caller will ensure that
/// adjusted latency is at least one cycle.
static int adjustDefLatency(const ARMSubtarget &Subtarget,
                            const MachineInstr *DefMI,
                            const MCInstrDesc *DefMCID, unsigned DefAlign) {
  int Adjust = 0;
  if (Subtarget.isCortexA8() || Subtarget.isLikeA9() || Subtarget.isCortexA7()) {
    // FIXME: Shifter op hack: no shift (i.e. [r +/- r]) or [r + r << 2]
    // variants are one cycle cheaper.
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal = DefMI->getOperand(3).getImm();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          (ShImm == 2 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        --Adjust;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt = DefMI->getOperand(3).getImm();
      if (ShAmt == 0 || ShAmt == 2)
        --Adjust;
      break;
    }
    }
  } else if (Subtarget.isSwift()) {
    // FIXME: Properly handle all of the latency adjustments for address
    // writeback.
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal = DefMI->getOperand(3).getImm();
      bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (!isSub &&
          (ShImm == 0 ||
           ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
            ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
        Adjust -= 2;
      else if (!isSub &&
               ShImm == 1 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsr)
        --Adjust;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt = DefMI->getOperand(3).getImm();
      if (ShAmt == 0 || ShAmt == 1 || ShAmt == 2 || ShAmt == 3)
        Adjust -= 2;
      break;
    }
    }
  }

  if (DefAlign < 8 && Subtarget.isLikeA9()) {
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::VLD1q8:
    case ARM::VLD1q16:
    case ARM::VLD1q32:
    case ARM::VLD1q64:
    case ARM::VLD1q8wb_fixed:
    case ARM::VLD1q16wb_fixed:
    case ARM::VLD1q32wb_fixed:
    case ARM::VLD1q64wb_fixed:
    case ARM::VLD1q8wb_register:
    case ARM::VLD1q16wb_register:
    case ARM::VLD1q32wb_register:
    case ARM::VLD1q64wb_register:
    case ARM::VLD2d8:
    case ARM::VLD2d16:
    case ARM::VLD2d32:
    case ARM::VLD2q8:
    case ARM::VLD2q16:
    case ARM::VLD2q32:
    case ARM::VLD2d8wb_fixed:
    case ARM::VLD2d16wb_fixed:
    case ARM::VLD2d32wb_fixed:
    case ARM::VLD2q8wb_fixed:
    case ARM::VLD2q16wb_fixed:
    case ARM::VLD2q32wb_fixed:
    case ARM::VLD2d8wb_register:
    case ARM::VLD2d16wb_register:
    case ARM::VLD2d32wb_register:
    case ARM::VLD2q8wb_register:
    case ARM::VLD2q16wb_register:
    case ARM::VLD2q32wb_register:
    case ARM::VLD3d8:
    case ARM::VLD3d16:
    case ARM::VLD3d32:
    case ARM::VLD1d64T:
    case ARM::VLD3d8_UPD:
    case ARM::VLD3d16_UPD:
    case ARM::VLD3d32_UPD:
    case ARM::VLD1d64Twb_fixed:
    case ARM::VLD1d64Twb_register:
    case ARM::VLD3q8_UPD:
    case ARM::VLD3q16_UPD:
    case ARM::VLD3q32_UPD:
    case ARM::VLD4d8:
    case ARM::VLD4d16:
    case ARM::VLD4d32:
    case ARM::VLD1d64Q:
    case ARM::VLD4d8_UPD:
    case ARM::VLD4d16_UPD:
    case ARM::VLD4d32_UPD:
    case ARM::VLD1d64Qwb_fixed:
    case ARM::VLD1d64Qwb_register:
    case ARM::VLD4q8_UPD:
    case ARM::VLD4q16_UPD:
    case ARM::VLD4q32_UPD:
    case ARM::VLD1DUPq8:
    case ARM::VLD1DUPq16:
    case ARM::VLD1DUPq32:
    case ARM::VLD1DUPq8wb_fixed:
    case ARM::VLD1DUPq16wb_fixed:
    case ARM::VLD1DUPq32wb_fixed:
    case ARM::VLD1DUPq8wb_register:
    case ARM::VLD1DUPq16wb_register:
    case ARM::VLD1DUPq32wb_register:
    case ARM::VLD2DUPd8:
    case ARM::VLD2DUPd16:
    case ARM::VLD2DUPd32:
    case ARM::VLD2DUPd8wb_fixed:
    case ARM::VLD2DUPd16wb_fixed:
    case ARM::VLD2DUPd32wb_fixed:
    case ARM::VLD2DUPd8wb_register:
    case ARM::VLD2DUPd16wb_register:
    case ARM::VLD2DUPd32wb_register:
    case ARM::VLD4DUPd8:
    case ARM::VLD4DUPd16:
    case ARM::VLD4DUPd32:
    case ARM::VLD4DUPd8_UPD:
    case ARM::VLD4DUPd16_UPD:
    case ARM::VLD4DUPd32_UPD:
    case ARM::VLD1LNd8:
    case ARM::VLD1LNd16:
    case ARM::VLD1LNd32:
    case ARM::VLD1LNd8_UPD:
    case ARM::VLD1LNd16_UPD:
    case ARM::VLD1LNd32_UPD:
    case ARM::VLD2LNd8:
    case ARM::VLD2LNd16:
    case ARM::VLD2LNd32:
    case ARM::VLD2LNq16:
    case ARM::VLD2LNq32:
    case ARM::VLD2LNd8_UPD:
    case ARM::VLD2LNd16_UPD:
    case ARM::VLD2LNd32_UPD:
    case ARM::VLD2LNq16_UPD:
    case ARM::VLD2LNq32_UPD:
    case ARM::VLD4LNd8:
    case ARM::VLD4LNd16:
    case ARM::VLD4LNd32:
    case ARM::VLD4LNq16:
    case ARM::VLD4LNq32:
    case ARM::VLD4LNd8_UPD:
    case ARM::VLD4LNd16_UPD:
    case ARM::VLD4LNd32_UPD:
    case ARM::VLD4LNq16_UPD:
    case ARM::VLD4LNq32_UPD:
      // If the address is not 64-bit aligned, the latencies of these
      // instructions increases by one.
      ++Adjust;
      break;
    }
  }
  return Adjust;
}



int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    const MachineInstr *DefMI, unsigned DefIdx,
                                    const MachineInstr *UseMI,
                                    unsigned UseIdx) const {
  // No operand latency. The caller may fall back to getInstrLatency.
  if (!ItinData || ItinData->isEmpty())
    return -1;

  const MachineOperand &DefMO = DefMI->getOperand(DefIdx);
  unsigned Reg = DefMO.getReg();
  const MCInstrDesc *DefMCID = &DefMI->getDesc();
  const MCInstrDesc *UseMCID = &UseMI->getDesc();

  unsigned DefAdj = 0;
  if (DefMI->isBundle()) {
    DefMI = getBundledDefMI(&getRegisterInfo(), DefMI, Reg, DefIdx, DefAdj);
    DefMCID = &DefMI->getDesc();
  }
  if (DefMI->isCopyLike() || DefMI->isInsertSubreg() ||
      DefMI->isRegSequence() || DefMI->isImplicitDef()) {
    return 1;
  }

  unsigned UseAdj = 0;
  if (UseMI->isBundle()) {
    unsigned NewUseIdx;
    const MachineInstr *NewUseMI = getBundledUseMI(&getRegisterInfo(), UseMI,
                                                   Reg, NewUseIdx, UseAdj);
    if (!NewUseMI)
      return -1;

    UseMI = NewUseMI;
    UseIdx = NewUseIdx;
    UseMCID = &UseMI->getDesc();
  }

  if (Reg == ARM::CPSR) {
    if (DefMI->getOpcode() == ARM::FMSTAT) {
      // fpscr -> cpsr stalls over 20 cycles on A8 (and earlier?)
      return Subtarget.isLikeA9() ? 1 : 20;
    }

    // CPSR set and branch can be paired in the same cycle.
    if (UseMI->isBranch())
      return 0;

    // Otherwise it takes the instruction latency (generally one).
    unsigned Latency = getInstrLatency(ItinData, DefMI);

    // For Thumb2 and -Os, prefer scheduling CPSR setting instruction close to
    // its uses. Instructions which are otherwise scheduled between them may
    // incur a code size penalty (not able to use the CPSR setting 16-bit
    // instructions).
    if (Latency > 0 && Subtarget.isThumb2()) {
      const MachineFunction *MF = DefMI->getParent()->getParent();
      // FIXME: Use Function::optForSize().
      if (MF->getFunction()->hasFnAttribute(Attribute::OptimizeForSize))
        --Latency;
    }
    return Latency;
  }

  if (DefMO.isImplicit() || UseMI->getOperand(UseIdx).isImplicit())
    return -1;

  unsigned DefAlign = DefMI->hasOneMemOperand()
    ? (*DefMI->memoperands_begin())->getAlignment() : 0;
  unsigned UseAlign = UseMI->hasOneMemOperand()
    ? (*UseMI->memoperands_begin())->getAlignment() : 0;

  // Get the itinerary's latency if possible, and handle variable_ops.
  int Latency = getOperandLatency(ItinData, *DefMCID, DefIdx, DefAlign,
                                  *UseMCID, UseIdx, UseAlign);
  // Unable to find operand latency. The caller may resort to getInstrLatency.
  if (Latency < 0)
    return Latency;

  // Adjust for IT block position.
  int Adj = DefAdj + UseAdj;

  // Adjust for dynamic def-side opcode variants not captured by the itinerary.
  Adj += adjustDefLatency(Subtarget, DefMI, DefMCID, DefAlign);
  if (Adj >= 0 || (int)Latency > -Adj) {
    return Latency + Adj;
  }
  // Return the itinerary latency, which may be zero but not less than zero.
  return Latency;
}

int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    SDNode *DefNode, unsigned DefIdx,
                                    SDNode *UseNode, unsigned UseIdx) const {
  if (!DefNode->isMachineOpcode())
    return 1;

  const MCInstrDesc &DefMCID = get(DefNode->getMachineOpcode());

  if (isZeroCost(DefMCID.Opcode))
    return 0;

  if (!ItinData || ItinData->isEmpty())
    return DefMCID.mayLoad() ? 3 : 1;

  if (!UseNode->isMachineOpcode()) {
    int Latency = ItinData->getOperandCycle(DefMCID.getSchedClass(), DefIdx);
    if (Subtarget.isLikeA9() || Subtarget.isSwift())
      return Latency <= 2 ? 1 : Latency - 1;
    else
      return Latency <= 3 ? 1 : Latency - 2;
  }

  const MCInstrDesc &UseMCID = get(UseNode->getMachineOpcode());
  const MachineSDNode *DefMN = dyn_cast<MachineSDNode>(DefNode);
  unsigned DefAlign = !DefMN->memoperands_empty()
    ? (*DefMN->memoperands_begin())->getAlignment() : 0;
  const MachineSDNode *UseMN = dyn_cast<MachineSDNode>(UseNode);
  unsigned UseAlign = !UseMN->memoperands_empty()
    ? (*UseMN->memoperands_begin())->getAlignment() : 0;
  int Latency = getOperandLatency(ItinData, DefMCID, DefIdx, DefAlign,
                                  UseMCID, UseIdx, UseAlign);

  if (Latency > 1 &&
      (Subtarget.isCortexA8() || Subtarget.isLikeA9() ||
       Subtarget.isCortexA7())) {
    // FIXME: Shifter op hack: no shift (i.e. [r +/- r]) or [r + r << 2]
    // variants are one cycle cheaper.
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          (ShImm == 2 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        --Latency;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      if (ShAmt == 0 || ShAmt == 2)
        --Latency;
      break;
    }
    }
  } else if (DefIdx == 0 && Latency > 2 && Subtarget.isSwift()) {
    // FIXME: Properly handle all of the latency adjustments for address
    // writeback.
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
           ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        Latency -= 2;
      else if (ShImm == 1 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsr)
        --Latency;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl 0-3 only.
      Latency -= 2;
      break;
    }
    }
  }

  if (DefAlign < 8 && Subtarget.isLikeA9())
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::VLD1q8:
    case ARM::VLD1q16:
    case ARM::VLD1q32:
    case ARM::VLD1q64:
    case ARM::VLD1q8wb_register:
    case ARM::VLD1q16wb_register:
    case ARM::VLD1q32wb_register:
    case ARM::VLD1q64wb_register:
    case ARM::VLD1q8wb_fixed:
    case ARM::VLD1q16wb_fixed:
    case ARM::VLD1q32wb_fixed:
    case ARM::VLD1q64wb_fixed:
    case ARM::VLD2d8:
    case ARM::VLD2d16:
    case ARM::VLD2d32:
    case ARM::VLD2q8Pseudo:
    case ARM::VLD2q16Pseudo:
    case ARM::VLD2q32Pseudo:
    case ARM::VLD2d8wb_fixed:
    case ARM::VLD2d16wb_fixed:
    case ARM::VLD2d32wb_fixed:
    case ARM::VLD2q8PseudoWB_fixed:
    case ARM::VLD2q16PseudoWB_fixed:
    case ARM::VLD2q32PseudoWB_fixed:
    case ARM::VLD2d8wb_register:
    case ARM::VLD2d16wb_register:
    case ARM::VLD2d32wb_register:
    case ARM::VLD2q8PseudoWB_register:
    case ARM::VLD2q16PseudoWB_register:
    case ARM::VLD2q32PseudoWB_register:
    case ARM::VLD3d8Pseudo:
    case ARM::VLD3d16Pseudo:
    case ARM::VLD3d32Pseudo:
    case ARM::VLD1d64TPseudo:
    case ARM::VLD1d64TPseudoWB_fixed:
    case ARM::VLD3d8Pseudo_UPD:
    case ARM::VLD3d16Pseudo_UPD:
    case ARM::VLD3d32Pseudo_UPD:
    case ARM::VLD3q8Pseudo_UPD:
    case ARM::VLD3q16Pseudo_UPD:
    case ARM::VLD3q32Pseudo_UPD:
    case ARM::VLD3q8oddPseudo:
    case ARM::VLD3q16oddPseudo:
    case ARM::VLD3q32oddPseudo:
    case ARM::VLD3q8oddPseudo_UPD:
    case ARM::VLD3q16oddPseudo_UPD:
    case ARM::VLD3q32oddPseudo_UPD:
    case ARM::VLD4d8Pseudo:
    case ARM::VLD4d16Pseudo:
    case ARM::VLD4d32Pseudo:
    case ARM::VLD1d64QPseudo:
    case ARM::VLD1d64QPseudoWB_fixed:
    case ARM::VLD4d8Pseudo_UPD:
    case ARM::VLD4d16Pseudo_UPD:
    case ARM::VLD4d32Pseudo_UPD:
    case ARM::VLD4q8Pseudo_UPD:
    case ARM::VLD4q16Pseudo_UPD:
    case ARM::VLD4q32Pseudo_UPD:
    case ARM::VLD4q8oddPseudo:
    case ARM::VLD4q16oddPseudo:
    case ARM::VLD4q32oddPseudo:
    case ARM::VLD4q8oddPseudo_UPD:
    case ARM::VLD4q16oddPseudo_UPD:
    case ARM::VLD4q32oddPseudo_UPD:
    case ARM::VLD1DUPq8:
    case ARM::VLD1DUPq16:
    case ARM::VLD1DUPq32:
    case ARM::VLD1DUPq8wb_fixed:
    case ARM::VLD1DUPq16wb_fixed:
    case ARM::VLD1DUPq32wb_fixed:
    case ARM::VLD1DUPq8wb_register:
    case ARM::VLD1DUPq16wb_register:
    case ARM::VLD1DUPq32wb_register:
    case ARM::VLD2DUPd8:
    case ARM::VLD2DUPd16:
    case ARM::VLD2DUPd32:
    case ARM::VLD2DUPd8wb_fixed:
    case ARM::VLD2DUPd16wb_fixed:
    case ARM::VLD2DUPd32wb_fixed:
    case ARM::VLD2DUPd8wb_register:
    case ARM::VLD2DUPd16wb_register:
    case ARM::VLD2DUPd32wb_register:
    case ARM::VLD4DUPd8Pseudo:
    case ARM::VLD4DUPd16Pseudo:
    case ARM::VLD4DUPd32Pseudo:
    case ARM::VLD4DUPd8Pseudo_UPD:
    case ARM::VLD4DUPd16Pseudo_UPD:
    case ARM::VLD4DUPd32Pseudo_UPD:
    case ARM::VLD1LNq8Pseudo:
    case ARM::VLD1LNq16Pseudo:
    case ARM::VLD1LNq32Pseudo:
    case ARM::VLD1LNq8Pseudo_UPD:
    case ARM::VLD1LNq16Pseudo_UPD:
    case ARM::VLD1LNq32Pseudo_UPD:
    case ARM::VLD2LNd8Pseudo:
    case ARM::VLD2LNd16Pseudo:
    case ARM::VLD2LNd32Pseudo:
    case ARM::VLD2LNq16Pseudo:
    case ARM::VLD2LNq32Pseudo:
    case ARM::VLD2LNd8Pseudo_UPD:
    case ARM::VLD2LNd16Pseudo_UPD:
    case ARM::VLD2LNd32Pseudo_UPD:
    case ARM::VLD2LNq16Pseudo_UPD:
    case ARM::VLD2LNq32Pseudo_UPD:
    case ARM::VLD4LNd8Pseudo:
    case ARM::VLD4LNd16Pseudo:
    case ARM::VLD4LNd32Pseudo:
    case ARM::VLD4LNq16Pseudo:
    case ARM::VLD4LNq32Pseudo:
    case ARM::VLD4LNd8Pseudo_UPD:
    case ARM::VLD4LNd16Pseudo_UPD:
    case ARM::VLD4LNd32Pseudo_UPD:
    case ARM::VLD4LNq16Pseudo_UPD:
    case ARM::VLD4LNq32Pseudo_UPD:
      // If the address is not 64-bit aligned, the latencies of these
      // instructions increases by one.
      ++Latency;
      break;
    }

  return Latency;
}

unsigned ARMBaseInstrInfo::getPredicationCost(const MachineInstr &MI) const {
  if (MI.isCopyLike() || MI.isInsertSubreg() || MI.isRegSequence() ||
      MI.isImplicitDef())
    return 0;

  if (MI.isBundle())
    return 0;

  const MCInstrDesc &MCID = MI.getDesc();

  if (MCID.isCall() || MCID.hasImplicitDefOfPhysReg(ARM::CPSR)) {
    // When predicated, CPSR is an additional source operand for CPSR updating
    // instructions, this apparently increases their latencies.
    return 1;
  }
  return 0;
}

unsigned ARMBaseInstrInfo::getInstrLatency(const InstrItineraryData *ItinData,
                                           const MachineInstr *MI,
                                           unsigned *PredCost) const {
  if (MI->isCopyLike() || MI->isInsertSubreg() ||
      MI->isRegSequence() || MI->isImplicitDef())
    return 1;

  // An instruction scheduler typically runs on unbundled instructions, however
  // other passes may query the latency of a bundled instruction.
  if (MI->isBundle()) {
    unsigned Latency = 0;
    MachineBasicBlock::const_instr_iterator I = MI->getIterator();
    MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
    while (++I != E && I->isInsideBundle()) {
      if (I->getOpcode() != ARM::t2IT)
        Latency += getInstrLatency(ItinData, &*I, PredCost);
    }
    return Latency;
  }

  const MCInstrDesc &MCID = MI->getDesc();
  if (PredCost && (MCID.isCall() || MCID.hasImplicitDefOfPhysReg(ARM::CPSR))) {
    // When predicated, CPSR is an additional source operand for CPSR updating
    // instructions, this apparently increases their latencies.
    *PredCost = 1;
  }
  // Be sure to call getStageLatency for an empty itinerary in case it has a
  // valid MinLatency property.
  if (!ItinData)
    return MI->mayLoad() ? 3 : 1;

  unsigned Class = MCID.getSchedClass();

  // For instructions with variable uops, use uops as latency.
  if (!ItinData->isEmpty() && ItinData->getNumMicroOps(Class) < 0)
    return getNumMicroOps(ItinData, MI);

  // For the common case, fall back on the itinerary's latency.
  unsigned Latency = ItinData->getStageLatency(Class);

  // Adjust for dynamic def-side opcode variants not captured by the itinerary.
  unsigned DefAlign = MI->hasOneMemOperand()
    ? (*MI->memoperands_begin())->getAlignment() : 0;
  int Adj = adjustDefLatency(Subtarget, MI, &MCID, DefAlign);
  if (Adj >= 0 || (int)Latency > -Adj) {
    return Latency + Adj;
  }
  return Latency;
}

int ARMBaseInstrInfo::getInstrLatency(const InstrItineraryData *ItinData,
                                      SDNode *Node) const {
  if (!Node->isMachineOpcode())
    return 1;

  if (!ItinData || ItinData->isEmpty())
    return 1;

  unsigned Opcode = Node->getMachineOpcode();
  switch (Opcode) {
  default:
    return ItinData->getStageLatency(get(Opcode).getSchedClass());
  case ARM::VLDMQIA:
  case ARM::VSTMQIA:
    return 2;
  }
}

bool ARMBaseInstrInfo::
hasHighOperandLatency(const TargetSchedModel &SchedModel,
                      const MachineRegisterInfo *MRI,
                      const MachineInstr *DefMI, unsigned DefIdx,
                      const MachineInstr *UseMI, unsigned UseIdx) const {
  unsigned DDomain = DefMI->getDesc().TSFlags & ARMII::DomainMask;
  unsigned UDomain = UseMI->getDesc().TSFlags & ARMII::DomainMask;
  if (Subtarget.isCortexA8() &&
      (DDomain == ARMII::DomainVFP || UDomain == ARMII::DomainVFP))
    // CortexA8 VFP instructions are not pipelined.
    return true;

  // Hoist VFP / NEON instructions with 4 or higher latency.
  unsigned Latency
    = SchedModel.computeOperandLatency(DefMI, DefIdx, UseMI, UseIdx);
  if (Latency <= 3)
    return false;
  return DDomain == ARMII::DomainVFP || DDomain == ARMII::DomainNEON ||
         UDomain == ARMII::DomainVFP || UDomain == ARMII::DomainNEON;
}

bool ARMBaseInstrInfo::
hasLowDefLatency(const TargetSchedModel &SchedModel,
                 const MachineInstr *DefMI, unsigned DefIdx) const {
  const InstrItineraryData *ItinData = SchedModel.getInstrItineraries();
  if (!ItinData || ItinData->isEmpty())
    return false;

  unsigned DDomain = DefMI->getDesc().TSFlags & ARMII::DomainMask;
  if (DDomain == ARMII::DomainGeneral) {
    unsigned DefClass = DefMI->getDesc().getSchedClass();
    int DefCycle = ItinData->getOperandCycle(DefClass, DefIdx);
    return (DefCycle != -1 && DefCycle <= 2);
  }
  return false;
}

bool ARMBaseInstrInfo::verifyInstruction(const MachineInstr *MI,
                                         StringRef &ErrInfo) const {
  if (convertAddSubFlagsOpcode(MI->getOpcode())) {
    ErrInfo = ""Pseudo flag setting opcodes only exist in Selection DAG"";
    return false;
  }
  return true;
}

// LoadStackGuard has so far only been implemented for MachO. Different code
// sequence is needed for other targets.
void ARMBaseInstrInfo::expandLoadStackGuardBase(MachineBasicBlock::iterator MI,
                                                unsigned LoadImmOpc,
                                                unsigned LoadOpc,
                                                Reloc::Model RM) const {
  MachineBasicBlock &MBB = *MI->getParent();
  DebugLoc DL = MI->getDebugLoc();
  unsigned Reg = MI->getOperand(0).getReg();
  const GlobalValue *GV =
      cast<GlobalValue>((*MI->memoperands_begin())->getValue());
  MachineInstrBuilder MIB;

  BuildMI(MBB, MI, DL, get(LoadImmOpc), Reg)
      .addGlobalAddress(GV, 0, ARMII::MO_NONLAZY);

  if (Subtarget.GVIsIndirectSymbol(GV, RM)) {
    MIB = BuildMI(MBB, MI, DL, get(LoadOpc), Reg);
    MIB.addReg(Reg, RegState::Kill).addImm(0);
    unsigned Flag = MachineMemOperand::MOLoad | MachineMemOperand::MOInvariant;
    MachineMemOperand *MMO = MBB.getParent()->getMachineMemOperand(
        MachinePointerInfo::getGOT(*MBB.getParent()), Flag, 4, 4);
    MIB.addMemOperand(MMO);
    AddDefaultPred(MIB);
  }

  MIB = BuildMI(MBB, MI, DL, get(LoadOpc), Reg);
  MIB.addReg(Reg, RegState::Kill).addImm(0);
  MIB.setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
  AddDefaultPred(MIB);
}

bool
ARMBaseInstrInfo::isFpMLxInstruction(unsigned Opcode, unsigned &MulOpc,
                                     unsigned &AddSubOpc,
                                     bool &NegAcc, bool &HasLane) const {
  DenseMap<unsigned, unsigned>::const_iterator I = MLxEntryMap.find(Opcode);
  if (I == MLxEntryMap.end())
    return false;

  const ARM_MLxEntry &Entry = ARM_MLxTable[I->second];
  MulOpc = Entry.MulOpc;
  AddSubOpc = Entry.AddSubOpc;
  NegAcc = Entry.NegAcc;
  HasLane = Entry.HasLane;
  return true;
}

//===----------------------------------------------------------------------===//
// Execution domains.
//===----------------------------------------------------------------------===//
//
// Some instructions go down the NEON pipeline, some go down the VFP pipeline,
// and some can go down both.  The vmov instructions go down the VFP pipeline,
// but they can be changed to vorr equivalents that are executed by the NEON
// pipeline.
//
// We use the following execution domain numbering:
//
enum ARMExeDomain {
  ExeGeneric = 0,
  ExeVFP = 1,
  ExeNEON = 2
};
//
// Also see ARMInstrFormats.td and Domain* enums in ARMBaseInfo.h
//
std::pair<uint16_t, uint16_t>
ARMBaseInstrInfo::getExecutionDomain(const MachineInstr *MI) const {
  // If we don't have access to NEON instructions then we won't be able
  // to swizzle anything to the NEON domain. Check to make sure.
  if (Subtarget.hasNEON()) {
    // VMOVD, VMOVRS and VMOVSR are VFP instructions, but can be changed to NEON
    // if they are not predicated.
    if (MI->getOpcode() == ARM::VMOVD && !isPredicated(*MI))
      return std::make_pair(ExeVFP, (1 << ExeVFP) | (1 << ExeNEON));

    // CortexA9 is particularly picky about mixing the two and wants these
    // converted.
    if (Subtarget.isCortexA9() && !isPredicated(*MI) &&
        (MI->getOpcode() == ARM::VMOVRS || MI->getOpcode() == ARM::VMOVSR ||
         MI->getOpcode() == ARM::VMOVS))
      return std::make_pair(ExeVFP, (1 << ExeVFP) | (1 << ExeNEON));
  }
  // No other instructions can be swizzled, so just determine their domain.
  unsigned Domain = MI->getDesc().TSFlags & ARMII::DomainMask;

  if (Domain & ARMII::DomainNEON)
    return std::make_pair(ExeNEON, 0);

  // Certain instructions can go either way on Cortex-A8.
  // Treat them as NEON instructions.
  if ((Domain & ARMII::DomainNEONA8) && Subtarget.isCortexA8())
    return std::make_pair(ExeNEON, 0);

  if (Domain & ARMII::DomainVFP)
    return std::make_pair(ExeVFP, 0);

  return std::make_pair(ExeGeneric, 0);
}

static unsigned getCorrespondingDRegAndLane(const TargetRegisterInfo *TRI,
                                            unsigned SReg, unsigned &Lane) {
  unsigned DReg = TRI->getMatchingSuperReg(SReg, ARM::ssub_0, &ARM::DPRRegClass);
  Lane = 0;

  if (DReg != ARM::NoRegister)
   return DReg;

  Lane = 1;
  DReg = TRI->getMatchingSuperReg(SReg, ARM::ssub_1, &ARM::DPRRegClass);

  assert(DReg && ""S-register with no D super-register?"");
  return DReg;
}

/// getImplicitSPRUseForDPRUse - Given a use of a DPR register and lane,
/// set ImplicitSReg to a register number that must be marked as implicit-use or
/// zero if no register needs to be defined as implicit-use.
///
/// If the function cannot determine if an SPR should be marked implicit use or
/// not, it returns false.
///
/// This function handles cases where an instruction is being modified from taking
/// an SPR to a DPR[Lane]. A use of the DPR is being added, which may conflict
/// with an earlier def of an SPR corresponding to DPR[Lane^1] (i.e. the other
/// lane of the DPR).
///
/// If the other SPR is defined, an implicit-use of it should be added. Else,
/// (including the case where the DPR itself is defined), it should not.
///
static bool getImplicitSPRUseForDPRUse(const TargetRegisterInfo *TRI,
                                       MachineInstr *MI,
                                       unsigned DReg, unsigned Lane,
                                       unsigned &ImplicitSReg) {
  // If the DPR is defined or used already, the other SPR lane will be chained
  // correctly, so there is nothing to be done.
  if (MI->definesRegister(DReg, TRI) || MI->readsRegister(DReg, TRI)) {
    ImplicitSReg = 0;
    return true;
  }

  // Otherwise we need to go searching to see if the SPR is set explicitly.
  ImplicitSReg = TRI->getSubReg(DReg,
                                (Lane & 1) ? ARM::ssub_0 : ARM::ssub_1);
  MachineBasicBlock::LivenessQueryResult LQR =
    MI->getParent()->computeRegisterLiveness(TRI, ImplicitSReg, MI);

  if (LQR == MachineBasicBlock::LQR_Live)
    return true;
  else if (LQR == MachineBasicBlock::LQR_Unknown)
    return false;

  // If the register is known not to be live, there is no need to add an
  // implicit-use.
  ImplicitSReg = 0;
  return true;
}

void
ARMBaseInstrInfo::setExecutionDomain(MachineInstr *MI, unsigned Domain) const {
  unsigned DstReg, SrcReg, DReg;
  unsigned Lane;
  MachineInstrBuilder MIB(*MI->getParent()->getParent(), MI);
  const TargetRegisterInfo *TRI = &getRegisterInfo();
  switch (MI->getOpcode()) {
    default:
      llvm_unreachable(""cannot handle opcode!"");
      break;
    case ARM::VMOVD:
      if (Domain != ExeNEON)
        break;

      // Zap the predicate operands.
      assert(!isPredicated(*MI) && ""Cannot predicate a VORRd"");

      // Make sure we've got NEON instructions.
      assert(Subtarget.hasNEON() && ""VORRd requires NEON"");

      // Source instruction is %DDst = VMOVD %DSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      // Change to a %DDst = VORRd %DSrc, %DSrc, 14, %noreg (; implicits)
      MI->setDesc(get(ARM::VORRd));
      AddDefaultPred(MIB.addReg(DstReg, RegState::Define)
                        .addReg(SrcReg)
                        .addReg(SrcReg));
      break;
    case ARM::VMOVRS:
      if (Domain != ExeNEON)
        break;
      assert(!isPredicated(*MI) && ""Cannot predicate a VGETLN"");

      // Source instruction is %RDst = VMOVRS %SSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      DReg = getCorrespondingDRegAndLane(TRI, SrcReg, Lane);

      // Convert to %RDst = VGETLNi32 %DSrc, Lane, 14, %noreg (; imps)
      // Note that DSrc has been widened and the other lane may be undef, which
      // contaminates the entire register.
      MI->setDesc(get(ARM::VGETLNi32));
      AddDefaultPred(MIB.addReg(DstReg, RegState::Define)
                        .addReg(DReg, RegState::Undef)
                        .addImm(Lane));

      // The old source should be an implicit use, otherwise we might think it
      // was dead before here.
      MIB.addReg(SrcReg, RegState::Implicit);
      break;
    case ARM::VMOVSR: {
      if (Domain != ExeNEON)
        break;
      assert(!isPredicated(*MI) && ""Cannot predicate a VSETLN"");

      // Source instruction is %SDst = VMOVSR %RSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      DReg = getCorrespondingDRegAndLane(TRI, DstReg, Lane);

      unsigned ImplicitSReg;
      if (!getImplicitSPRUseForDPRUse(TRI, MI, DReg, Lane, ImplicitSReg))
        break;

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      // Convert to %DDst = VSETLNi32 %DDst, %RSrc, Lane, 14, %noreg (; imps)
      // Again DDst may be undefined at the beginning of this instruction.
      MI->setDesc(get(ARM::VSETLNi32));
      MIB.addReg(DReg, RegState::Define)
         .addReg(DReg, getUndefRegState(!MI->readsRegister(DReg, TRI)))
         .addReg(SrcReg)
         .addImm(Lane);
      AddDefaultPred(MIB);

      // The narrower destination must be marked as set to keep previous chains
      // in place.
      MIB.addReg(DstReg, RegState::Define | RegState::Implicit);
      if (ImplicitSReg != 0)
        MIB.addReg(ImplicitSReg, RegState::Implicit);
      break;
    }
    case ARM::VMOVS: {
      if (Domain != ExeNEON)
        break;

      // Source instruction is %SDst = VMOVS %SSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      unsigned DstLane = 0, SrcLane = 0, DDst, DSrc;
      DDst = getCorrespondingDRegAndLane(TRI, DstReg, DstLane);
      DSrc = getCorrespondingDRegAndLane(TRI, SrcReg, SrcLane);

      unsigned ImplicitSReg;
      if (!getImplicitSPRUseForDPRUse(TRI, MI, DSrc, SrcLane, ImplicitSReg))
        break;

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      if (DSrc == DDst) {
        // Destination can be:
        //     %DDst = VDUPLN32d %DDst, Lane, 14, %noreg (; implicits)
        MI->setDesc(get(ARM::VDUPLN32d));
        MIB.addReg(DDst, RegState::Define)
           .addReg(DDst, getUndefRegState(!MI->readsRegister(DDst, TRI)))
           .addImm(SrcLane);
        AddDefaultPred(MIB);

        // Neither the source or the destination are naturally represented any
        // more, so add them in manually.
        MIB.addReg(DstReg, RegState::Implicit | RegState::Define);
        MIB.addReg(SrcReg, RegState::Implicit);
        if (ImplicitSReg != 0)
          MIB.addReg(ImplicitSReg, RegState::Implicit);
        break;
      }

      // In general there's no single instruction that can perform an S <-> S
      // move in NEON space, but a pair of VEXT instructions *can* do the
      // job. It turns out that the VEXTs needed will only use DSrc once, with
      // the position based purely on the combination of lane-0 and lane-1
      // involved. For example
      //     vmov s0, s2 -> vext.32 d0, d0, d1, #1  vext.32 d0, d0, d0, #1
      //     vmov s1, s3 -> vext.32 d0, d1, d0, #1  vext.32 d0, d0, d0, #1
      //     vmov s0, s3 -> vext.32 d0, d0, d0, #1  vext.32 d0, d1, d0, #1
      //     vmov s1, s2 -> vext.32 d0, d0, d0, #1  vext.32 d0, d0, d1, #1
      //
      // Pattern of the MachineInstrs is:
      //     %DDst = VEXTd32 %DSrc1, %DSrc2, Lane, 14, %noreg (;implicits)
      MachineInstrBuilder NewMIB;
      NewMIB = BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                       get(ARM::VEXTd32), DDst);

      // On the first instruction, both DSrc and DDst may be <undef> if present.
      // Specifically when the original instruction didn't have them as an
      // <imp-use>.
      unsigned CurReg = SrcLane == 1 && DstLane == 1 ? DSrc : DDst;
      bool CurUndef = !MI->readsRegister(CurReg, TRI);
      NewMIB.addReg(CurReg, getUndefRegState(CurUndef));

      CurReg = SrcLane == 0 && DstLane == 0 ? DSrc : DDst;
      CurUndef = !MI->readsRegister(CurReg, TRI);
      NewMIB.addReg(CurReg, getUndefRegState(CurUndef));

      NewMIB.addImm(1);
      AddDefaultPred(NewMIB);

      if (SrcLane == DstLane)
        NewMIB.addReg(SrcReg, RegState::Implicit);

      MI->setDesc(get(ARM::VEXTd32));
      MIB.addReg(DDst, RegState::Define);

      // On the second instruction, DDst has definitely been defined above, so
      // it is not <undef>. DSrc, if present, can be <undef> as above.
      CurReg = SrcLane == 1 && DstLane == 0 ? DSrc : DDst;
      CurUndef = CurReg == DSrc && !MI->readsRegister(CurReg, TRI);
      MIB.addReg(CurReg, getUndefRegState(CurUndef));

      CurReg = SrcLane == 0 && DstLane == 1 ? DSrc : DDst;
      CurUndef = CurReg == DSrc && !MI->readsRegister(CurReg, TRI);
      MIB.addReg(CurReg, getUndefRegState(CurUndef));

      MIB.addImm(1);
      AddDefaultPred(MIB);

      if (SrcLane != DstLane)
        MIB.addReg(SrcReg, RegState::Implicit);

      // As before, the original destination is no longer represented, add it
      // implicitly.
      MIB.addReg(DstReg, RegState::Define | RegState::Implicit);
      if (ImplicitSReg != 0)
        MIB.addReg(ImplicitSReg, RegState::Implicit);
      break;
    }
  }

}

//===----------------------------------------------------------------------===//
// Partial register updates
//===----------------------------------------------------------------------===//
//
// Swift renames NEON registers with 64-bit granularity.  That means any
// instruction writing an S-reg implicitly reads the containing D-reg.  The
// problem is mostly avoided by translating f32 operations to v2f32 operations
// on D-registers, but f32 loads are still a problem.
//
// These instructions can load an f32 into a NEON register:
//
// VLDRS - Only writes S, partial D update.
// VLD1LNd32 - Writes all D-regs, explicit partial D update, 2 uops.
// VLD1DUPd32 - Writes all D-regs, no partial reg update, 2 uops.
//
// FCONSTD can be used as a dependency-breaking instruction.
unsigned ARMBaseInstrInfo::
getPartialRegUpdateClearance(const MachineInstr *MI,
                             unsigned OpNum,
                             const TargetRegisterInfo *TRI) const {
  if (!SwiftPartialUpdateClearance ||
      !(Subtarget.isSwift() || Subtarget.isCortexA15()))
    return 0;

  assert(TRI && ""Need TRI instance"");

  const MachineOperand &MO = MI->getOperand(OpNum);
  if (MO.readsReg())
    return 0;
  unsigned Reg = MO.getReg();
  int UseOp = -1;

  switch(MI->getOpcode()) {
    // Normal instructions writing only an S-register.
  case ARM::VLDRS:
  case ARM::FCONSTS:
  case ARM::VMOVSR:
  case ARM::VMOVv8i8:
  case ARM::VMOVv4i16:
  case ARM::VMOVv2i32:
  case ARM::VMOVv2f32:
  case ARM::VMOVv1i64:
    UseOp = MI->findRegisterUseOperandIdx(Reg, false, TRI);
    break;

    // Explicitly reads the dependency.
  case ARM::VLD1LNd32:
    UseOp = 3;
    break;
  default:
    return 0;
  }

  // If this instruction actually reads a value from Reg, there is no unwanted
  // dependency.
  if (UseOp != -1 && MI->getOperand(UseOp).readsReg())
    return 0;

  // We must be able to clobber the whole D-reg.
  if (TargetRegisterInfo::isVirtualRegister(Reg)) {
    // Virtual register must be a foo:ssub_0<def,undef> operand.
    if (!MO.getSubReg() || MI->readsVirtualRegister(Reg))
      return 0;
  } else if (ARM::SPRRegClass.contains(Reg)) {
    // Physical register: MI must define the full D-reg.
    unsigned DReg = TRI->getMatchingSuperReg(Reg, ARM::ssub_0,
                                             &ARM::DPRRegClass);
    if (!DReg || !MI->definesRegister(DReg, TRI))
      return 0;
  }

  // MI has an unwanted D-register dependency.
  // Avoid defs in the previous N instructrions.
  return SwiftPartialUpdateClearance;
}

// Break a partial register dependency after getPartialRegUpdateClearance
// returned non-zero.
void ARMBaseInstrInfo::
breakPartialRegDependency(MachineBasicBlock::iterator MI,
                          unsigned OpNum,
                          const TargetRegisterInfo *TRI) const {
  assert(MI && OpNum < MI->getDesc().getNumDefs() && ""OpNum is not a def"");
  assert(TRI && ""Need TRI instance"");

  const MachineOperand &MO = MI->getOperand(OpNum);
  unsigned Reg = MO.getReg();
  assert(TargetRegisterInfo::isPhysicalRegister(Reg) &&
         ""Can't break virtual register dependencies."");
  unsigned DReg = Reg;

  // If MI defines an S-reg, find the corresponding D super-register.
  if (ARM::SPRRegClass.contains(Reg)) {
    DReg = ARM::D0 + (Reg - ARM::S0) / 2;
    assert(TRI->isSuperRegister(Reg, DReg) && ""Register enums broken"");
  }

  assert(ARM::DPRRegClass.contains(DReg) && ""Can only break D-reg deps"");
  assert(MI->definesRegister(DReg, TRI) && ""MI doesn't clobber full D-reg"");

  // FIXME: In some cases, VLDRS can be changed to a VLD1DUPd32 which defines
  // the full D-register by loading the same value to both lanes.  The
  // instruction is micro-coded with 2 uops, so don't do this until we can
  // properly schedule micro-coded instructions.  The dispatcher stalls cause
  // too big regressions.

  // Insert the dependency-breaking FCONSTD before MI.
  // 96 is the encoding of 0.5, but the actual value doesn't matter here.
  AddDefaultPred(BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                         get(ARM::FCONSTD), DReg).addImm(96));
  MI->addRegisterKilled(DReg, TRI, true);
}

bool ARMBaseInstrInfo::hasNOP() const {
  return Subtarget.getFeatureBits()[ARM::HasV6KOps];
}

bool ARMBaseInstrInfo::isSwiftFastImmShift(const MachineInstr *MI) const {
  if (MI->getNumOperands() < 4)
    return true;
  unsigned ShOpVal = MI->getOperand(3).getImm();
  unsigned ShImm = ARM_AM::getSORegOffset(ShOpVal);
  // Swift supports faster shifts for: lsl 2, lsl 1, and lsr 1.
  if ((ShImm == 1 && ARM_AM::getSORegShOp(ShOpVal) == ARM_AM::lsr) ||
      ((ShImm == 1 || ShImm == 2) &&
       ARM_AM::getSORegShOp(ShOpVal) == ARM_AM::lsl))
    return true;

  return false;
}

bool ARMBaseInstrInfo::getRegSequenceLikeInputs(
    const MachineInstr &MI, unsigned DefIdx,
    SmallVectorImpl<RegSubRegPairAndIdx> &InputRegs) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isRegSequenceLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VMOVDRR:
    // dX = VMOVDRR rY, rZ
    // is the same as:
    // dX = REG_SEQUENCE rY, ssub_0, rZ, ssub_1
    // Populate the InputRegs accordingly.
    // rY
    const MachineOperand *MOReg = &MI.getOperand(1);
    InputRegs.push_back(
        RegSubRegPairAndIdx(MOReg->getReg(), MOReg->getSubReg(), ARM::ssub_0));
    // rZ
    MOReg = &MI.getOperand(2);
    InputRegs.push_back(
        RegSubRegPairAndIdx(MOReg->getReg(), MOReg->getSubReg(), ARM::ssub_1));
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}

bool ARMBaseInstrInfo::getExtractSubregLikeInputs(
    const MachineInstr &MI, unsigned DefIdx,
    RegSubRegPairAndIdx &InputReg) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isExtractSubregLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VMOVRRD:
    // rX, rY = VMOVRRD dZ
    // is the same as:
    // rX = EXTRACT_SUBREG dZ, ssub_0
    // rY = EXTRACT_SUBREG dZ, ssub_1
    const MachineOperand &MOReg = MI.getOperand(2);
    InputReg.Reg = MOReg.getReg();
    InputReg.SubReg = MOReg.getSubReg();
    InputReg.SubIdx = DefIdx == 0 ? ARM::ssub_0 : ARM::ssub_1;
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}

bool ARMBaseInstrInfo::getInsertSubregLikeInputs(
    const MachineInstr &MI, unsigned DefIdx, RegSubRegPair &BaseReg,
    RegSubRegPairAndIdx &InsertedReg) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isInsertSubregLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VSETLNi32:
    // dX = VSETLNi32 dY, rZ, imm
    const MachineOperand &MOBaseReg = MI.getOperand(1);
    const MachineOperand &MOInsertedReg = MI.getOperand(2);
    const MachineOperand &MOIndex = MI.getOperand(3);
    BaseReg.Reg = MOBaseReg.getReg();
    BaseReg.SubReg = MOBaseReg.getSubReg();

    InsertedReg.Reg = MOInsertedReg.getReg();
    InsertedReg.SubReg = MOInsertedReg.getSubReg();
    InsertedReg.SubIdx = MOIndex.getImm() == 0 ? ARM::ssub_0 : ARM::ssub_1;
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}
",DefOpc
319,"/* 
 * File:   Game.cpp
 * Author: <NAME>
 *
 * Created on November 26, 2017, 1:59 PM
 * Purpose: Game Class Implementation
 */

#include ""Game.h""
#include <fcntl.h>      // File descriptor manipulator

//Constructor
Game::Game() { 
    base.size = 20;
    base.x = base.size / 2;
    base.y = base.size / 2;
    xToken = rand() % base.size;    //Standard token worth 10 pts
    yToken = rand() % base.size;    //Standard token worth 10 pts
    xMega = rand() % base.size + 1;     //Mega Token worth 20 pts
    yMega = rand() % base.size + 1;     //Mega Token worth 20 pts
    ckWin = true;
    sleep = 1;
    tempX = 0;
    tempY = 0;
    temp2X = 0;
    temp2Y = 0;
    ckPnt = false;
    nTail = 0;
    sec = 1; //pause in seconds
    xTail = new int[base.size * 5];
    yTail = new int[base.size * 5];
    
    //initialize board
    for(int i = 0;i < base.size + 2;i++)
    {
        cout << ""*"";
    }
    cout << endl;
    for(int i = 0;i < base.size + 2;i++) //height 
    {
        for(int j = 0;j < base.size + 2;j++)//width
        {
            if(j == 0)
            {
                cout << ""*"";
            }
         
                cout << "" "";
            
            if(j == base.size - 1)
            {
                cout << ""*"";
            }
        }

        cout << endl;
    }
    
    for(int i = 0;i < base.size + 2;i++)
    {
        cout << ""*"";
    }
    cout << endl;

    //Check if tokens randomly generate same value, if true add 1 or minus 1
    if(xMega == xToken)
    {
        xMega += 1;
    }  
    else if(yMega == yToken)
    {
        yMega -= 1;
    }
}

Game::~Game() {
}

/*Function Definition:
 * pause game so console out is more manageable for player
 */
void Game::pause(float sleep)
{
    int  [MASK]  = time(0),end;
    do
    {
        end = time(0);
    }while(sleep > end -  [MASK] );
}",beg
320,"#include <arrow/api.h>
#include <arrow/ipc/api.h>
#include <arrow/io/api.h>
#include <fletcher/api.h>
#include <fletcher/common.h>

#include <malloc.h>
#include <unistd.h>

#include <memory>
#include <iostream>
#include <bitset>

#define AFU_GUID ""3d5ee416-6f30-42d1-8109-a453b5b8e29d"";

#ifdef NDEBUG
#define PLATFORM ""opae""
#else
#define PLATFORM ""opae-ase""
#endif

int main(int argc, char **argv)
{
  if (argc != 3)
  {
    std::cerr << ""Incorrect number of arguments. Usage: primmap path/to/input_recordbatch.rb path/to/output_recordbatch.rb"" << std::endl;
    return -1;
  }

  std::vector<std::shared_ptr<arrow::RecordBatch>> batches;
  fletcher::ReadRecordBatchesFromFile(argv[1], &batches);
  if (batches.size() != 1)
  {
    std::cerr << ""File did not contain any input Arrow RecordBatches."" << std::endl;
    return -1;
  }
  std::shared_ptr<arrow::RecordBatch>  [MASK] ;
   [MASK]  = batches[0];

  // read output schema
  auto file = arrow::io::ReadableFile::Open(argv[2]).ValueOrDie();
  std::shared_ptr<arrow::Schema> schema = arrow::ipc::ReadSchema(file.get(), nullptr)
                                              .ValueOrDie();
  file->Close();

  size_t buffer_size = 4096;
  uint8_t *value_data = (uint8_t *)memalign(sysconf(_SC_PAGESIZE), buffer_size);
  memset(value_data, 2, buffer_size);
  auto value_buffer = std::make_shared<arrow::Buffer>(value_data, buffer_size);
  auto value_array = std::make_shared<arrow::PrimitiveArray>(arrow::uint64(), 0, value_buffer);
  std::vector<std::shared_ptr<arrow::Array>> arrays = {value_array};
  auto output_batch = arrow::RecordBatch::Make(schema, 0, arrays);

  fletcher::Status status;
  std::shared_ptr<fletcher::Platform> platform;

  status = fletcher::Platform::Make(PLATFORM, &platform, false);
  if (!status.ok())
  {
    std::cerr << ""Could not create Fletcher platform."" << std::endl;
    std::cerr << status.message << std::endl;
    return -1;
  }

  static const char *guid = AFU_GUID;
  platform->init_data = &guid;
  status = platform->Init();
  if (!status.ok())
  {
    std::cerr << ""Could not initialize platform."" << std::endl;
    std::cerr << status.message << std::endl;
    return -1;
  }

  std::shared_ptr<fletcher::Context> context;
  status = fletcher::Context::Make(&context, platform);
  if (!status.ok())
  {
    std::cerr << ""Could not create Fletcher context."" << std::endl;
    return -1;
  }

  status = context->QueueRecordBatch( [MASK] );
  if (!status.ok())
  {
    std::cerr << ""Could not add input recordbatch."" << std::endl;
    return -1;
  }

  status = context->QueueRecordBatch(output_batch);
  if (!status.ok())
  {
    std::cerr << ""Could not add output recordbatch."" << std::endl;
    return -1;
  }

  status = context->Enable();
  if (!status.ok())
  {
    std::cerr << ""Could not enable the context."" << std::endl;
    return -1;
  }

  for (int i = 0; i < context->num_buffers(); i++)
  {
    auto view = fletcher::HexView();
    view.AddData(context->device_buffer(i).host_address, 64);
    std::cout << view.ToString() << std::endl;
  }

  fletcher::Kernel kernel(context);
  status = kernel.Start();
  if (!status.ok())
  {
    std::cerr << ""Could not start the kernel."" << std::endl;
    return -1;
  }

  status = kernel.PollUntilDone();
  if (!status.ok())
  {
    std::cerr << ""Something went wrong waiting for the kernel to finish."" << std::endl;
    return -1;
  }

  for (int i = 0; i < context->num_buffers(); i++)
  {
    auto view = fletcher::HexView();
    view.AddData(context->device_buffer(i).host_address, 64);
    std::cout << view.ToString() << std::endl;
  }

  return 0;
}",input_batch
321,"#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;
using ll = long long;

int main(){
    int  [MASK]  = 0;
    string s1, s2, s3;
    while(cin >> s1 >> s2 >> s3){
        vector <int> value_1(52);
        vector <int> value_2(52);
        vector <int> value_3(52);
        for(int i=0; i<s1.size(); i++){
            int c = s1[i] - 'a';
            if(c < 0) c = 26 + s1[i] - 'A';
            value_1[c]++; 
        }
        for(int i=0; i<s2.size(); i++){
            int c = s2[i] - 'a';
            if(c < 0) c = 26 + s2[i] - 'A';
            value_2[c]++; 
        }
        for(int i=0; i<s3.size(); i++){
            int c = s3[i] - 'a';
            if(c < 0) c = 26 + s3[i] - 'A';
            value_3[c]++; 
        }
        for(int i=0; i<52; i++){
            if(value_1[i] >= 1 && value_2[i] >= 1 && value_3[i] >= 1){
                 [MASK]  += (i+1);
                break;
            }
        }
    }
    cout <<  [MASK]  << '\n';
    return 0;
}",ans
322,"#include ""Board.h""
#include ""board_def.h""
#include ""make_ref.h""

#include <cassert>
#include <osg/ShapeDrawable>
#include <osg/Geode>
#include <osg/MatrixTransform>
#include <osg/Fog>
#include <osg/Geometry>
#include <osg/ShadeModel>
#include <osg/Material>
#include <osg/Texture2D>
#include <osg/TexEnv>
#include <osgDB/ReadFile>
#include <osgDB/FileUtils>
#include <osgDB/FileNameUtils>


Board::Board(std::vector<std::string> &def, double sizeX, double sizeY, std::string dbPath)
    : m_sizeX(sizeX)
    , m_sizeY(sizeY)
    , m_dbPath(dbPath)
{
    assert(def.size() > 0);
    m_fieldMap.resize(def.size());

    auto height = def.size();
    auto width = def[0].size();

    for(auto elem : def) {
        assert(elem.size() >= width);
    }

    for(auto& elem : m_fieldMap) {
        elem.resize(width, FIELD_EMPTY);
    }

    for(auto i = 0; i < height; ++i)
        for(auto j = 0; j < width; ++j)
            m_fieldMap[i][j] = (def[i][j] == '*' ? FIELD_WALL : FIELD_EMPTY);
}

std::tuple<uint32_t, uint32_t> Board::getPlayerPosition() const
{
    return std::tuple<uint32_t, uint32_t>{m_pcX, m_pcY};
}

double Board::getSizeX() const
{
    return m_sizeX;
}

double Board::getSizeY() const
{
    return m_sizeY;
}

uint32_t Board::getFieldCountX() const
{
    return m_fieldMap[0].size();
}

uint32_t Board::getFieldCountY() const
{
    return m_fieldMap.size();
}

double Board::getFieldSizeX() const
{
    return m_sizeX / getFieldCountX();
}

double Board::getFieldSizeY() const
{
    return m_sizeY / getFieldCountY();
}

double Board::getFieldCenterX(uint32_t x) const
{
    return getFieldSizeX() / 2 + x * getFieldSizeX();
}

double Board::getFieldCenterY(uint32_t y) const
{
    return getSizeY() - getFieldSizeY() / 2 - y * getFieldSizeY();
}

Board::FieldType Board::getField(uint32_t x, uint32_t y) const
{
    return m_fieldMap[y][x];
}

void Board::setField(const double x, const double y, const FieldType fieldType)
{
    const auto intX = getFieldX(x);
    const auto intY = getFieldY(y);
    setField(intX, intY, fieldType);
}

void Board::setField(uint32_t x, uint32_t y, Board::FieldType type)
{
    if(type == FIELD_PC) {
        m_pcX = x;
        m_pcY = y;
    }

    m_fieldMap[y][x] = type;
}

osg::ref_ptr<osg::Node> Board::DrawSquare(double  [MASK] , double RootSizeY, uint16_t FragmentCount, uint32_t LOD, std::string TextureFile) const
{
    osg::Geode* CeilGeode = new osg::Geode();
    osg::Geometry* CeilGeometry = new osg::Geometry();

    CeilGeode->addDrawable(CeilGeometry);
    //specify vertices
    osg::Vec3dArray* CeilVertices = new osg::Vec3dArray;
    osg::DrawElementsUInt* CeilBase = new osg::DrawElementsUInt(osg::PrimitiveSet::QUADS, 0);
    osg::ref_ptr<osg::Vec2Array> CeilTexcoords = new osg::Vec2Array;

    double FragmentSizeX =  [MASK]  / FragmentCount;
    double FragmentSizeY = RootSizeY / FragmentCount;

    double sTexSizeX = 1.0 / LOD;
    double sTexSizeY = 1.0 / LOD;

    osg::ref_ptr<osg::Texture2D> CeilTexture = new osg::Texture2D;
    osg::ref_ptr<osg::Image> CeilImage = osgDB::readImageFile( m_dbPath + ""/"" + TextureFile );
    CeilTexture->setImage( CeilImage.get() );

    for(int fi = 0; fi < FragmentCount; ++fi) {
        for(int fj = 0; fj < FragmentCount; ++fj) {

            double sizeX = FragmentSizeX / LOD;
            double sizeY = FragmentSizeY / LOD;

            for(int i = 0; i < LOD; ++i) {
                for(int j = 0; j < LOD; ++j) {
                    CeilVertices->push_back(osg::Vec3d(fi * FragmentSizeX + i * sizeX, fj * FragmentSizeY + j * sizeY, 0));
                    CeilVertices->push_back(osg::Vec3d(fi * FragmentSizeX + i * sizeX + sizeX, fj * FragmentSizeY + j * sizeY, 0));
                    CeilVertices->push_back(osg::Vec3d(fi * FragmentSizeX + i * sizeX + sizeX, fj * FragmentSizeY + j * sizeY + sizeY, 0));
                    CeilVertices->push_back(osg::Vec3d(fi * FragmentSizeX + i * sizeX, fj * FragmentSizeY + j * sizeY + sizeY, 0));
                }
            }

            for(int i = 0; i < LOD; ++i) {
                for(int j = 0; j < LOD; ++j) {
                    CeilTexcoords->push_back(osg::Vec2d(i * sTexSizeX, j * sTexSizeY));
                    CeilTexcoords->push_back(osg::Vec2d(i * sTexSizeX + sTexSizeX, j * sTexSizeY));
                    CeilTexcoords->push_back(osg::Vec2d(i * sTexSizeX + sTexSizeX, j * sTexSizeY + sTexSizeY));
                    CeilTexcoords->push_back(osg::Vec2d(i * sTexSizeX, j * sTexSizeY + sTexSizeY));
                }
            }
        }
    }

    uint64_t ElemCount = LOD * LOD * 4 * FragmentCount * FragmentCount;
    for(uint64_t i = 0; i < ElemCount; ++i)
        CeilBase->push_back(i);

    CeilGeometry->setVertexArray( CeilVertices );
    CeilGeometry->addPrimitiveSet(CeilBase);

    osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array;
    normals->push_back( osg::Vec3(0.0f, 0.0f, 1.0f) );

    CeilGeometry->setNormalArray( normals );
    CeilGeometry->setNormalBinding( osg::Geometry::BIND_OVERALL );
    CeilGeometry->setTexCoordArray(1, CeilTexcoords.get() );


    osg::ref_ptr<osg::Material> material = new osg::Material;
    material->setAmbient( osg::Material::FRONT_AND_BACK, osg::Vec4(0.5f, 0.5f, 0.5f, 0.5f) );
    material->setDiffuse( osg::Material::FRONT_AND_BACK, osg::Vec4(1.0f, 1.0f, 1.0f, 0.5f) );
    material->setSpecular( osg::Material::FRONT_AND_BACK, osg::Vec4(1.0f, 1.0f, 1.0f, 0.5f) );
    material->setDataVariance(osg::Material::STATIC);
    material->setShininess(osg::Material::FRONT_AND_BACK, 0.2);

    //CeilGeode->getOrCreateStateSet()->setAttributeAndModes(material);
    CeilGeode->getOrCreateStateSet()->setTextureAttributeAndModes(TEXTURE_UNIT, CeilTexture.get() );
    CeilGeode->setCullingActive(true);

//    osg::TexEnv* blendTexEnv = new osg::TexEnv;
//    blendTexEnv->setMode(osg::TexEnv::BLEND);
//    CeilGeode->getOrCreateStateSet()->setTextureAttribute(1, blendTexEnv);
//
//    osg::TexEnv* decalTexEnv = new osg::TexEnv;
//    decalTexEnv->setMode(osg::TexEnv::DECAL);
//    CeilGeode->getOrCreateStateSet()->setTextureAttribute(2, decalTexEnv);

    return osg::ref_ptr<osg::Node>(CeilGeode);
}


std::vector<std::tuple<uint32_t, uint32_t>> Board::getEmptyFields() const
{
    std::vector<std::tuple<uint32_t, uint32_t>> empty;
    for(auto y = 0; y < getFieldCountY(); ++y) { // y
        for(auto x = 0; x < getFieldCountX(); ++x) { // x
            if(m_fieldMap[y][x] == FieldType::FIELD_EMPTY) {
                empty.push_back(std::tuple<uint32_t, uint32_t>{x, y});
            }
        }
    }

    return std::move(empty);
}

uint32_t Board::getFieldX(double x) const
{
    return static_cast<uint32_t>(x / getFieldSizeX());
}

uint32_t Board::getFieldY(double y) const
{
    return getFieldCountY() - (1 + static_cast<uint32_t >(y / getFieldSizeY()));
}

Board::FieldType Board::getField(const double x, const double y) const
{
    const auto intX = getFieldX(x);
    const auto intY = getFieldY(y);
    return getField(intX, intY);
}

osg::ref_ptr<osg::Node> Board::draw() const
{
    auto normalize = osg::Vec3d(0.0f, 0.0f, 0.0f);

    double blockSizeZ = std::max(getFieldSizeX(), getFieldSizeY());
    uint16_t blockCountZ = 2;

    auto boardObj = make_ref<osg::Group>();

    for(auto y = 0; y < getFieldCountY(); ++y) { // y
        for(auto x = 0; x < getFieldCountX(); ++x) { // x
            if(m_fieldMap[y][x] == FieldType::FIELD_WALL) {
 //           if(x == 15 && y == 14) {
                osg::Geode* WallGeode = new osg::Geode();
                osg::Geometry* WallGeometry = new osg::Geometry();

                WallGeode->addDrawable(WallGeometry);
                //specify vertices
                osg::Vec3dArray* WallVertices = new osg::Vec3dArray;

                uint32_t lod = BoardWallLOD;
                double totalSizeX = getFieldSizeX();
                double totalSizeY = getFieldSizeY();
                double totalSizeZ = blockSizeZ;

                double sizeX = totalSizeX / lod;
                double sizeY = totalSizeY / lod;
                double sizeZ = totalSizeZ / lod;

                osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
                osg::ref_ptr<osg::Image> image = osgDB::readImageFile(m_dbPath + ""/"" + ActiveTheme[WALL]);
                texture->setImage( image.get() );

                for(int z = 0; z < blockCountZ; ++z) {
                    for(int i = lod - 1; i >= 0; --i) {
                        for(int j = 0; j < lod; ++j) {
                            WallVertices->push_back(osg::Vec3d(0, i * sizeY, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(0, i * sizeY + sizeY, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(0, i * sizeY + sizeY, j * sizeZ + sizeZ));
                            WallVertices->push_back(osg::Vec3d(0, i * sizeY, j * sizeZ + sizeZ));
                        }
                    }

                    for(int i = lod - 1; i >= 0; --i) {
                        for(int j = 0; j < lod; ++j) {
                            WallVertices->push_back(osg::Vec3d(totalSizeX, i * sizeY, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(totalSizeX, i * sizeY + sizeY, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(totalSizeX, i * sizeY + sizeY, j * sizeZ + sizeZ));
                            WallVertices->push_back(osg::Vec3d(totalSizeX, i * sizeY, j * sizeZ + sizeZ));
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            WallVertices->push_back(osg::Vec3d(i * sizeX, 0, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(i * sizeX + sizeX, 0, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(i * sizeX + sizeX, 0, j * sizeZ + sizeZ));
                            WallVertices->push_back(osg::Vec3d(i * sizeX, 0, j * sizeZ + sizeZ));
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            WallVertices->push_back(osg::Vec3d(i * sizeX, totalSizeY, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(i * sizeX + sizeX, totalSizeY, j * sizeZ));
                            WallVertices->push_back(osg::Vec3d(i * sizeX + sizeX, totalSizeY, j * sizeZ + sizeZ));
                            WallVertices->push_back(osg::Vec3d(i * sizeX, totalSizeY, j * sizeZ + sizeZ));
                        }
                    }

                    WallGeometry->setVertexArray( WallVertices );

                    //specify the kind of geometry we want to draw here
                    osg::DrawElementsUInt* WallBase = new osg::DrawElementsUInt(osg::PrimitiveSet::QUADS, 0);
                    for(int i = 0; i < lod * lod * 4 * 4; ++i)
                        WallBase->push_back(i);

                    WallGeometry->addPrimitiveSet(WallBase);

                    osg::ref_ptr<osg::Vec2Array> texcoords = new osg::Vec2Array;

                    double tsizeX = 1.0 / lod;
                    double tsizeY = 1.0 / lod;

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY + tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY + tsizeY));
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY + tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY + tsizeY));
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY + tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY + tsizeY));
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX + tsizeX, j * tsizeY + tsizeY));
                            texcoords->push_back(osg::Vec2d(i * tsizeX, j * tsizeY + tsizeY));
                        }
                    }

                    osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array;
                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            normals->push_back( osg::Vec3(-1.0f, 0.0f, 0.0f) );
                            normals->push_back( osg::Vec3(-1.0f, 0.0f, 0.0f) );
                            normals->push_back( osg::Vec3(-1.0f, 0.0f, 0.0f) );
                            normals->push_back( osg::Vec3(-1.0f, 0.0f, 0.0f) );
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            normals->push_back( osg::Vec3(1.0f, 0.0f, 0.0f) );
                            normals->push_back( osg::Vec3(1.0f, 0.0f, 0.0f) );
                            normals->push_back( osg::Vec3(1.0f, 0.0f, 0.0f) );
                            normals->push_back( osg::Vec3(1.0f, 0.0f, 0.0f) );
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            normals->push_back( osg::Vec3(0.0f, 1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, 1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, 1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, 1.0f, 0.0f) );
                        }
                    }

                    for(int i = 0; i < lod; ++i) {
                        for(int j = 0; j < lod; ++j) {
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                            normals->push_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
                        }
                    }

                    WallGeometry->setTexCoordArray(1, texcoords.get() );
                    WallGeode->getOrCreateStateSet()->setTextureAttributeAndModes(1, texture.get() );

                    WallGeode->setCullingActive(true);

                    WallGeometry->setNormalArray(normals);
                    WallGeometry->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);

                    osg::ref_ptr<osg::Material> material = new osg::Material;
                    material->setAmbient( osg::Material::FRONT_AND_BACK, osg::Vec4(0.5f, 0.5f, 0.5f, 1.0f) );
                    material->setDiffuse( osg::Material::FRONT_AND_BACK, osg::Vec4(0.0f, 1.0f, 1.0f, 1.0f) );
                    material->setSpecular( osg::Material::FRONT_AND_BACK, osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f) );
                    material->setDataVariance(osg::Material::STATIC);
                    material->setShininess(osg::Material::FRONT_AND_BACK, 1.0);

                    //WallGeode->getOrCreateStateSet()->setAttributeAndModes(material);

                    auto translate = make_ref<osg::MatrixTransform>(osg::Matrix::translate(getFieldCenterX(x) - getFieldSizeX() / 2, getFieldCenterY(y) - getFieldSizeY() / 2, z * blockSizeZ));
                    translate->addChild(WallGeode);

                    boardObj->addChild(translate);
                }

            }
        }
    }

    auto FloorGeode = DrawSquare(getSizeX(), getSizeY(), std::atoi(ActiveTheme[FLOOR_REPEAT].c_str()), BoardFloorLOD, ActiveTheme[FLOOR]);
    auto CeilGeode = DrawSquare(getSizeX(), getSizeY(), 8, BoardFloorLOD, ActiveTheme[CEIL]);
    auto CeilTranslate = make_ref<osg::MatrixTransform>(osg::Matrix::translate(0, 0, blockCountZ * blockSizeZ));
    CeilTranslate->addChild(CeilGeode);

    boardObj->addChild(FloorGeode);
    boardObj->addChild(CeilTranslate);

    return boardObj;
}
",RootSizeX
323,"/*
 * Copyright 2023 Babit Authors
 *
 * This file 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 file 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.
 */

#include ""audio_fifo.h""

AudioFifo::AudioFifo(int format, int channels, uint64_t channel_layout, AVRational time_base, int sample_rate) {
    format_ = format;
    channels_ = channels;
    audio_fifo_ = av_audio_fifo_alloc((AVSampleFormat) format, channels, 2048);
    time_base_ = time_base;
    channel_layout_ = channel_layout;
    sample_rate_ = sample_rate;
    pts_per_sample_ = time_base.den / float(time_base.num) / sample_rate;
    if (!audio_fifo_)
        BMFLOG(BMF_ERROR) << ""Could not allocate audio_fifo_"";
}

int AudioFifo::read(int samples, bool partial, bool &got_frame, AVFrame *&frame) {
    int ret;
    got_frame = false;
    int buffered_samples = av_audio_fifo_size(audio_fifo_);
    if (buffered_samples < 1) {
        return 0;
    }
    if (buffered_samples < samples) {
        if (partial) {
            samples = buffered_samples;
        } else {
            return 0;
        }
    }
    frame->format = format_;
    frame->channel_layout = channel_layout_;
    frame->sample_rate = sample_rate_;
    frame->nb_samples = samples;
    ret = av_frame_get_buffer(frame, 0);
    if (ret < 0) {
        BMFLOG(BMF_ERROR) << ""Error allocating an audio buffer"";
        return ret;
    }
    int  [MASK]  = av_audio_fifo_read(audio_fifo_, (void **) (frame->extended_data), samples);
    if ( [MASK]  < 0) {
        BMFLOG(BMF_ERROR) << ""av_audio_fifo_read "" <<  [MASK] ;
        return  [MASK] ;
    }
    got_frame = true;
    frame->nb_samples =  [MASK] ;
    if (first_pts_ != AV_NOPTS_VALUE) {
        frame->pts = (int64_t) (pts_per_sample_ * samples_read_) + first_pts_;
    } else {
        frame->pts = AV_NOPTS_VALUE;
    }
    samples_read_ +=  [MASK] ;
    return 0;
}

int AudioFifo::read_many(int samples, bool partial, std::vector<AVFrame *> &frame_list) {
    while (1) {
        AVFrame *frame = NULL;
        frame = av_frame_alloc();
        if (!frame) {
            BMFLOG(BMF_ERROR) << ""Could not allocate AVFrame"";
            return -1;
        }
        bool got_frame = false;
        int ret = read(samples, partial, got_frame, frame);
        if (ret < 0) {
            return ret;
        }
        if (!got_frame) {
            av_frame_free(&frame);
            return 0;
        }
        frame_list.push_back(frame);
    }
    return 0;
}

int AudioFifo::write(AVFrame *frame) {
    int ret;
    if (first_frame_) {
        first_pts_ = frame->pts;
        first_frame_ = false;
    }
    ret = av_audio_fifo_write(audio_fifo_, (void **) (frame->extended_data), frame->nb_samples);
    return ret;
}

AudioFifo::~AudioFifo() {
    if (audio_fifo_)
        av_audio_fifo_free(audio_fifo_);
}
",read_samples
324,"#include ""rest_client_test.h""
#include <QtTest/QtTest>
#include <QDebug>
#include <QFuture>
#include <QtConcurrent>
#include <QList>

RestClientTest::RestClientTest()
{

}

void RestClientTest::initTestCase()
{
}

void RestClientTest::testSingleThreadWork()
{
    QEventLoop loop;
    HttpRequestInput* request =  new HttpRequestInput(""https://postman-echo.com/get?foo1=bar1&foo2=bar2"", Literals::getMethod);

    HttpRequestWorker* worker = new HttpRequestWorker();

    worker->setReadResponseOnError(true);
    worker->execute(request);

    bool ok = false;

    QObject::connect(worker, &HttpRequestWorker::executionFinished, [&loop, &ok, request](HttpRequestWorker * worker) mutable {
        QByteArray response = worker->response;
        qDebug() << ""status code "" << worker->statusCode;
        worker->deleteLater();
        delete request;
        if (worker->statusCode == 200)
        {
            ok = true;
        }
        loop.exit();
    });
    loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::ExcludeSocketNotifiers);
    QCOMPARE(ok, true);
}

void RestClientTest::testMultithreadWork()
{
    const int  [MASK]  = 10000;
    QFuture<bool> statuses[ [MASK] ];
    auto function = [=] () -> bool {
        QEventLoop loop;
        HttpRequestInput* request =  new HttpRequestInput(""https://postman-echo.com/get?foo1=bar1&foo2=bar2"", Literals::getMethod);

        HttpRequestWorker* worker = new HttpRequestWorker();

        worker->setReadResponseOnError(true);
        worker->execute(request);

        bool ok = false;

        QObject::connect(worker, &HttpRequestWorker::executionFinished, [&loop, &ok, request](HttpRequestWorker * worker) mutable {
            QByteArray response = worker->response;
            qWarning() << ""status code "" << worker->statusCode;
            worker->deleteLater();
            delete request;
            if (worker->statusCode == 200)
            {
                ok = true;
            }
            loop.exit(ok);
        });
        return loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::ExcludeSocketNotifiers);
    };

    for(int i = 0; i <  [MASK] ; ++i)
    {
        statuses[i] = QtConcurrent::run(function);
    }

    for(int i = 0; i <  [MASK] ; ++i)
    {
        statuses[i].waitForFinished();
    }

    bool ok = true;
    for(int i = 0; i <  [MASK] ; ++i)
    {
        if (!statuses[i].result())
        {
            qDebug() << ""result of "" << i << "" operation is false"";
            ok = false;
        }
    }
    QCOMPARE(ok, true);
}

void RestClientTest::cleanupTestCase()
{
}
",threadCount
325,"#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <vector>
#include <set>
#include <algorithm>
#include <random>

namespace py = pybind11;

std::vector<std::vector<int>> generate_negative_samples(const std::vector<std::vector<int>>& edge_index, 
                                                        const std::vector<std::vector<int>>& pos_edge_index, 
                                                        int num_neg_samples) {
    if (num_neg_samples <= 0) {
        throw std::invalid_argument(""num_neg_samples must be greater than 0"");
    }

    std::vector<int> neg_srcs;
    std::vector<int> neg_dsts;

    std::set<int> nodeset;
    std::unordered_map<int, std::set<int>>  [MASK] ;

    for (size_t i = 0; i < edge_index[0].size(); ++i) {
        int src = edge_index[0][i];
        int dst = edge_index[1][i];
        nodeset.insert(src);
        nodeset.insert(dst);
         [MASK] [src].insert(dst);
         [MASK] [dst].insert(src);
    }

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, nodeset.size() - 1);

    int src, dst, neg_node;
    for(int i = 0; i < pos_edge_index[0].size(); i++){
        src = pos_edge_index[0][i];
        dst = pos_edge_index[1][i];
        std::set<int> unavail_nodes;
        unavail_nodes.insert(src);
        unavail_nodes.insert(dst);
        unavail_nodes.insert( [MASK] [src].begin(),  [MASK] [src].end());
        unavail_nodes.insert( [MASK] [dst].begin(),  [MASK] [dst].end());


        for(int j = 0; j < num_neg_samples/2; j++){
            do {
                neg_node = dis(gen);
            } while (unavail_nodes.count(neg_node) > 0);
            neg_srcs.push_back(src);
            neg_dsts.push_back(neg_node);
        }
        for(int j = 0; j < num_neg_samples/2; j++){
            do {
                neg_node = dis(gen);
            } while (unavail_nodes.count(neg_node) > 0);
            neg_srcs.push_back(neg_node);
            neg_dsts.push_back(dst);
        }
    }
    return {neg_srcs, neg_dsts};
}

PYBIND11_MODULE(negative_sampling, m) {
    m.def(""generate_negative_samples"", &generate_negative_samples, ""A function to generate negative samples"",
          py::arg(""edge_index""), py::arg(""pos_edge_index""), py::arg(""num_neg_samples""));
}",adj_list
326,"#include <iostream>
#include <fstream>
#include <stdio.h>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <deque>
#include <algorithm>
#include <queue>

using namespace std;

int R,C,F,N,B,T;

int dist(int x1,int y1,int x2,int y2){
	return abs(x1-x2)+abs(y1-y2);
}

class ride {
public:
	int a,b,x,y,s,f,num;

	ride(int aa,int bb,int xx,int yy,int ss,int ff,int nnum){
		a=aa;
		b=bb;
		x=xx;
		y=yy;
		s=ss;
		f=ff;
		num=nnum;
	}

	int ddist(){
		return dist(a,b,x,y);
	}
};

class taxi {
public:
	deque<int> rides;
	int avail;
	int endx;
	int endy;
};

bool com(ride a,ride b){
	return a.s<b.s;
}

class compare{
public:
	bool operator() (taxi a, taxi b){
		return a.avail > b.avail;
	}
};

deque <ride> q;
priority_queue<taxi, vector<taxi>, compare> taxis;


int main() {

	int ee = 2;

	string si,so;
	switch(ee) {
	case 0: si=""a_example.in"";so=""a_example.out""; break;
	case 1: si=""b_should_be_easy.in"";so=""b_should_be_easy.out""; break;
	case 2: si=""c_no_hurry.in"";so=""c_no_hurry.out""; break;
	case 3: si=""d_metropolis.in"";so=""d_metropolis.out""; break;
	case 4: si=""e_high_bonus.in"";so=""e_high_bonus.out""; break;
	}

	int i,a,b,x,y,f,s;
	ifstream inf(si);
	if(inf.is_open()){
		cout << ""open\n"";
	}
	else {
		cout << ""close"";
		return -1;
	}
	inf >> R >> C >> F >> N >> B >> T;

	for(i=0;i<N;i++){

		inf >> a >> b >> x >> y >> s >> f;
		ride temp(a,b,x,y,s,f,i);
		q.push_back(temp);

	}
	inf.close();

	sort(q.begin(),q.end(),com);

	for(i=0;i<F;i++){
		taxi temp;
		temp.endx = 0;
		temp.endy = 0;
		temp.avail= 0;
		taxis.push(temp);
	}


	long  [MASK] =0;

	while(taxis.top().avail<T && q.size()>0){
		taxi temp=taxis.top();
		taxis.pop();
		long long bestnum = -2000000000000000000;
		int bestpos = -1;
		for(i=0;i<q.size();i++){
			if( max(dist(temp.endx,temp.endy,q[i].a,q[i].b) + temp.avail ,q[i].s)+q[i].ddist() >= q[i].f){
				continue;
			}
			long long tempnum = q[i].ddist();
			if (dist(temp.endx,temp.endy,q[i].a,q[i].b)+temp.avail < q[i].s){
				tempnum += B;
			}
			tempnum -= (dist(temp.endx,temp.endy,q[i].a,q[i].b) + max(q[i].s- (dist(temp.endx,temp.endy,q[i].a,q[i].b) + temp.avail),0))*200;
			if(tempnum > bestnum ) {
				bestpos = i;
				bestnum = tempnum;
			}
		}
		if(bestpos < 0) {
			temp.avail = T+2;
			taxis.push(temp);
			continue;
		}
		 [MASK]  += q[bestpos].ddist();
		if (dist(temp.endx,temp.endy,q[bestpos].a,q[bestpos].b)+temp.avail <= q[bestpos].s){
			 [MASK]  += B;
		}
		temp.rides.push_back(q[bestpos].num);

		temp.avail = max(dist(temp.endx,temp.endy,q[bestpos].a,q[bestpos].b)+temp.avail,q[bestpos].s)+q[bestpos].ddist();

		temp.endx = q[bestpos].x;
		temp.endy = q[bestpos].y;
		taxis.push(temp);
		q.erase(q.begin()+bestpos);
	}

	ofstream outf(so);
	while(!taxis.empty()){
		taxi temp = taxis.top();
		taxis.pop();
		outf << temp.rides.size() << "" "";
		for(int i = 0; i < temp.rides.size(); i++) {
			outf << temp.rides[i] << "" "";
		}
		outf << endl;
	}
	outf.close();

	cout <<  [MASK] ;

	return 0;
}
",total
327,"#include ""fat.hpp""

#include <cstring>
#include <locale>

namespace fat
{
    BPB *boot_volume_image;
    unsigned long bytes_per_cluster;

    void Initialize(void *volume_image)
    {
        boot_volume_image = reinterpret_cast<fat::BPB *>(volume_image);
        bytes_per_cluster = static_cast<unsigned long>(boot_volume_image->bytes_per_sec) *
                            boot_volume_image->sec_per_clus;
    }

    uintptr_t GetClusterAddr(unsigned long cluster)
    {
        unsigned long sector_num = boot_volume_image->rsvd_sec_cnt +
                                   boot_volume_image->num_fats * boot_volume_image->fat_sz_32 + (cluster - 2) * boot_volume_image->sec_per_clus;
        uintptr_t offset = sector_num * boot_volume_image->bytes_per_sec;
        return reinterpret_cast<uintptr_t>(boot_volume_image) + offset;
    }

    bool IsEndOfClusterchain(unsigned long cluster)
    {
        return cluster >= 0x0ffffff8ul;
    }
    uint32_t *GetFAT()
    {
        uintptr_t  [MASK]  =
            boot_volume_image->rsvd_sec_cnt *
            boot_volume_image->bytes_per_sec;
        return reinterpret_cast<uint32_t *>(
            reinterpret_cast<uintptr_t>(boot_volume_image) +  [MASK] );
    }

    void ReadName(const DirectoryEntry &entry, char *base, char *ext)
    {
        memcpy(base, &entry.name[0], 8);
        base[8] = 0;
        for (int i = 7; i >= 0 && base[i] == 0x20; i--)
        {
            base[i] = 0;
        }
        memcpy(ext, &entry.name[8], 3);
        {
            ext[3] = 0;
            for (int i = 2; i >= 0 && ext[i] == 0x20; i--)
            {
                ext[i] = 0;
            }
        }
    }

    void FormatName(const DirectoryEntry &entry, char *dest)
    {
        // extension length in fat format is 3.
        // 1 byte(period) + 3 byte(extension) + 1 byte(null string)
        char ext[5] = ""."";
        ReadName(entry, dest, &ext[1]);
        if (ext[1])
        {
            strcat(dest, ext);
        }
    }

    unsigned long NextCluster(unsigned long cluster)
    {
        uint32_t *fat = GetFAT();
        uint32_t next = fat[cluster];
        if (IsEndOfClusterchain(next))
        {
            return kEndOfClusterchain;
        }
        return next;
    }

    bool NameIsEqual(const DirectoryEntry &entry, const char *name)
    {
        unsigned char name83[11];
        // 0x20 is empty in ascii
        memset(name83, 0x20, sizeof(name83));

        int i = 0;
        int i83 = 0;

        for (; name[i] != 0 && i83 < sizeof(name83); i++, i83++)
        {
            if (name[i] == '.')
            {
                i83 = 7;
                continue;
            }
            name83[i83] = toupper(name[i]);
        }

        return memcmp(entry.name, name83, sizeof(name83)) == 0;
    }

    std::pair<DirectoryEntry *, bool>
    FindFile(const char *path, unsigned long directory_cluster)
    {
        if (path[0] == '/')
        {
            directory_cluster = boot_volume_image->root_clus;
            path++;
        }
        else if (directory_cluster == 0)
        {
            directory_cluster = boot_volume_image->root_clus;
        }
        char path_elem[13];
        const auto [next_path, post_slash] = NextPathElement(path, path_elem);
        const bool path_last = next_path == nullptr || next_path[0] == '\0';

        while (directory_cluster != kEndOfClusterchain)
        {
            auto dir = GetSectorByCluster<DirectoryEntry>(directory_cluster);
            for (int i = 0; i < bytes_per_cluster / sizeof(DirectoryEntry); i++)
            {
                if (dir[i].name[0] == 0x00)
                {
                    return {nullptr, post_slash};
                }
                else if (!NameIsEqual(dir[i], path_elem))
                {
                    continue;
                }
                if (dir[i].attr == Attribute::kDirectory && !path_last)
                {
                    return FindFile(next_path, dir[i].FirstCluster());
                }
                else
                {
                    // dir[i] is not directory, but we occured last path.
                    // so we finish searching.
                    return {&dir[i], post_slash};
                }
            }
            directory_cluster = NextCluster(directory_cluster);
        }

        return {nullptr, post_slash};
    }

    std::pair<const char *, bool> NextPathElement(const char *path, char *path_elem)
    {
        const char *next_slash = strchr(path, '/');
        if (next_slash == nullptr)
        {
            strcpy(path_elem, path);
            return {nullptr, false};
        }

        const auto elem_len = next_slash - path;
        strncpy(path_elem, path, elem_len);
        path_elem[elem_len] = '\0';
        return {&next_slash[1], true};
    }

    size_t LoadFile(void *buf, size_t len, const DirectoryEntry &entry)
    {
        auto is_valid_cluster = [](uint32_t c)
        {
            return c != 0 && c != fat::kEndOfClusterchain;
        };
        auto cluster = entry.FirstCluster();
        // why does we use uint8?
        const auto buf_uint8 = reinterpret_cast<uint8_t *>(buf);
        const auto buf_end = buf_uint8 + len;
        auto p = buf_uint8;

        while (is_valid_cluster(cluster))
        {
            if (bytes_per_cluster >= buf_end - p)
            {
                memcpy(p, GetSectorByCluster<uint8_t>(cluster), buf_end - p);
                return len;
            }
            memcpy(p, GetSectorByCluster<uint8_t>(cluster), bytes_per_cluster);
            p += bytes_per_cluster;
            cluster = NextCluster(cluster);
        }

        return p - buf_uint8;
    }

    FileDescriptor::FileDescriptor(DirectoryEntry &fat_entry) : fat_entry_{fat_entry} {}

    size_t FileDescriptor::Read(void *buf, size_t len)
    {
        if (rd_cluster_ == 0)
        {
            rd_cluster_ = fat_entry_.FirstCluster();
        }
        uint8_t *buf8 = reinterpret_cast<uint8_t *>(buf);
        len = std::min(len, fat_entry_.file_size - rd_off_);
        size_t total = 0;
        while (total < len)
        {
            uint8_t *sec = GetSectorByCluster<uint8_t>(rd_cluster_);
            size_t n = std::min(len - total, bytes_per_cluster - rd_cluster_off_);
            memcpy(&buf8[total], &sec[rd_cluster_off_], n);
            total += n;

            rd_cluster_off_ += n;
            if (rd_cluster_off_ == bytes_per_cluster)
            {
                rd_cluster_ = NextCluster(rd_cluster_);
                rd_cluster_off_ = 0;
            }
        }
        rd_off_ += total;
        return total;
    }

    size_t FileDescriptor::Write(const void *buf, size_t len)
    {
        auto num_cluster = [](size_t bytes)
        {
            return (bytes + bytes_per_cluster - 1) / bytes_per_cluster;
        };
        if (wr_cluster_ == 0)
        {
            if (fat_entry_.FirstCluster() != 0)
            {
                wr_cluster_ = fat_entry_.FirstCluster();
            }
            else
            {
                wr_cluster_ = AllocateClusterChain(num_cluster(len));
                fat_entry_.fst_clus_lo = wr_cluster_ & 0xffff;
                fat_entry_.fst_clus_hi = (wr_cluster_ >> 16) & 0xffff;
            }
        }

        const uint8_t *buf8 = reinterpret_cast<const uint8_t *>(buf);

        size_t total = 0;
        while (total < len)
        {
            if (wr_cluster_off_ == bytes_per_cluster)
            {
                const auto next_cluster = NextCluster(wr_cluster_);
                if (next_cluster == kEndOfClusterchain)
                {
                    wr_cluster_ = ExtendCluster(wr_cluster_, num_cluster(len - total));
                }
                else
                {
                    wr_cluster_ = next_cluster;
                }
                wr_cluster_off_ = 0;
            }

            uint8_t *sec = GetSectorByCluster<uint8_t>(wr_cluster_);
            size_t n = std::min(len, bytes_per_cluster - wr_cluster_off_);
            memcpy(&sec[wr_cluster_off_], &buf8[total], n);
            total += n;
            wr_cluster_off_ += n;
        }
        wr_off_ += total;
        fat_entry_.file_size = wr_off_;
        return total;
    }

    WithError<DirectoryEntry *> CreateFile(const char *path)
    {
        auto parent_dir_cluster = fat::boot_volume_image->root_clus;
        const char *filename = path;

        if (const char *slash_pos = strrchr(path, '/'))
        {
            filename = &slash_pos[1];
            if (slash_pos[1] == '\0')
            {
                return {nullptr, MAKE_ERROR(Error::kIsDirectory)};
            }

            char parent_dir_name[slash_pos - path + 1];
            strncpy(parent_dir_name, path, slash_pos - path);
            parent_dir_name[slash_pos - path] = '\0';

            if (parent_dir_name[0] != '\0')
            {
                auto [parent_dir, post_slash2] = fat::FindFile(parent_dir_name);
                if (parent_dir == nullptr)
                {
                    return {nullptr, MAKE_ERROR(Error::kNoSuchEntry)};
                }
                parent_dir_cluster = parent_dir->FirstCluster();
            }
        }
        auto dir = fat::AllocateEntry(parent_dir_cluster);
        if (dir == nullptr)
        {
            return {nullptr, MAKE_ERROR(Error::kNoEnoughMemory)};
        }
        fat::SetFileName(*dir, filename);
        dir->file_size = 0;
        return {dir, MAKE_ERROR(Error::kSuccess)};
    }

    DirectoryEntry *AllocateEntry(unsigned long dir_cluster)
    {
        while (true)
        {
            auto dir = GetSectorByCluster<DirectoryEntry>(dir_cluster);
            for (int i = 0; i < bytes_per_cluster / sizeof(DirectoryEntry); i++)
            {
                if (dir[i].name[0] == 0 || dir[i].name[0] == 0xe5)
                {
                    return &dir[i];
                }
            }
            auto next = NextCluster(dir_cluster);
            if (next == kEndOfClusterchain)
            {
                break;
            }
            dir_cluster = next;
        }

        dir_cluster = ExtendCluster(dir_cluster, 1);
        auto dir = GetSectorByCluster<DirectoryEntry>(dir_cluster);
        memset(dir, 0, bytes_per_cluster);
        return &dir[0];
    }

    unsigned long AllocateClusterChain(size_t n)
    {
        uint32_t *fat = GetFAT();
        unsigned long first_cluster;
        for (first_cluster = 2;; first_cluster++)
        {
            if (fat[first_cluster] == 0)
            {
                fat[first_cluster] = kEndOfClusterchain;
                break;
            }
        }

        if (n > 1)
        {
            ExtendCluster(first_cluster, n - 1);
        }
        return first_cluster;
    }

    unsigned long ExtendCluster(unsigned long eoc_cluster, size_t n)
    {
        uint32_t *fat = GetFAT();
        while (!IsEndOfClusterchain(fat[eoc_cluster]))
        {
            eoc_cluster = fat[eoc_cluster];
        }
        size_t num_allocated = 0;
        auto current = eoc_cluster;
        for (unsigned long candidate = 2; num_allocated < n; candidate++)
        {
            if (fat[candidate] != 0)
            {
                continue;
            }
            fat[current] = candidate;
            current = candidate;
            num_allocated++;
        }
        fat[current] = kEndOfClusterchain;
        return current;
    }
    void SetFileName(DirectoryEntry &entry, const char *name)
    {
        const char *dot_pos = strrchr(name, '.');
        memset(entry.name, ' ', 8 + 3);
        if (dot_pos)
        {
            for (int i = 0; i < 8 && i < dot_pos - name; i++)
            {
                entry.name[i] = toupper(name[i]);
            }
            for (int i = 0; i < 4 && dot_pos[i + 1]; i++)
            {
                entry.name[8 + i] = toupper(name[i + 1]);
            }
        }
        else
        {
            for (int i = 0; i < 8 && name[i]; i++)
            {
                entry.name[i] = toupper(name[i]);
            }
        }
    }
}",fat_offset
328,"#pragma once

#include <HardwareSerial.h>
#include <Arduino.h>
#include <BLEServer.h>
#include <BLEService.h>
#include <BLEUtils.h>
#include <forward_list>

#include ""usfl.h""
#include ""configuration.h""
#include ""ByteData.hpp""

struct BTServerCallbacks
{
    virtual void onWriteMode(unsigned int mode);
    virtual void onWriteData(const ByteData &data);
    virtual void onWriteLedCount(unsigned int led_count);
};

class BTServer : protected BLECharacteristicCallbacks, protected BLEServerCallbacks
{
public:
public:
    static BTServer &getInstance()
    {
        static BTServer  [MASK] ;
        return  [MASK] ;
    }

public:
    void addListener(BTServerCallbacks *callback)
    {
        _writeDataCallbacks.push_front(callback);
    }

    void removeListener(BTServerCallbacks *callback)
    {
        _writeDataCallbacks.remove(callback);
    }

private:
    void _writeModeNotify(unsigned int mode)
    {
        for (auto &callback : _writeDataCallbacks)
            callback->onWriteMode(mode);
    }

    void _writeDataNotify(const ByteData &data)
    {
        for (auto &callback : _writeDataCallbacks)
            callback->onWriteData(data);
    }

    void _writeLedCountNotify(unsigned int led_count)
    {
        for (auto &callback : _writeDataCallbacks)
            callback->onWriteLedCount(led_count);
    }

private:
    std::forward_list<BTServerCallbacks *> _writeDataCallbacks;

private:
    BTServer()
    {
        BLEDevice::init(DEVICE_NAME);
        bleserver = BLEDevice::createServer();
        bleserver->setCallbacks(this);

        BLEService *service = bleserver->createService(SERVICE_UUID);

        service->createCharacteristic(VERSION_CHAR_UUID,
                                      BLECharacteristic::PROPERTY_READ)
            ->setValue(PROG_VERSION);

        led_count_char = service->createCharacteristic(LED_COUNT_CHAR_UUID,
                                                       BLECharacteristic::PROPERTY_READ |
                                                           BLECharacteristic::PROPERTY_WRITE);
        led_count_char->setCallbacks(this);

        mode_char = service->createCharacteristic(MODE_CHAR_UUID,
                                                  BLECharacteristic::PROPERTY_READ |
                                                      BLECharacteristic::PROPERTY_WRITE);
        mode_char->setCallbacks(this);

        data_char = service->createCharacteristic(DATA_CHAR_UUID,
                                                  BLECharacteristic::PROPERTY_READ |
                                                      BLECharacteristic::PROPERTY_WRITE);
        data_char->setCallbacks(this);

        service->start();
        _startAdvertising();
    }

    ~BTServer() = default;
    BTServer(const BTServer &) = delete;
    BTServer &operator=(const BTServer &) = delete;

    void _startAdvertising()
    {
        BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
        pAdvertising->addServiceUUID(SERVICE_UUID);
        pAdvertising->setScanResponse(true);
        pAdvertising->setMinPreferred(0x06); // functions that help with iPhone connections issue
        pAdvertising->setMinPreferred(0x12);
        BLEDevice::startAdvertising();
    }

private:
    BLEServer *bleserver;
    BLECharacteristic *led_count_char;
    BLECharacteristic *mode_char;
    BLECharacteristic *data_char;

protected:
    void onConnect(BLEServer *pServer) override
    {
        Serial.printf(""Connected: id = %u\n"", pServer->getPeerDevices(true).begin()->first);
        // connectEvent.notify(nullptr);
    }

    void onDisconnect(BLEServer *pServer) override
    {
        Serial.printf(""Disconnected: id = %u\n"", pServer->getPeerDevices(true).begin()->first);
        // disconnectEvent.notify(nullptr);
    }

    void onRead(BLECharacteristic *pCharacteristic) override
    {
    }

    void onWrite(BLECharacteristic *pCharacteristic) override
    {
        if (pCharacteristic == mode_char)
        {
            _writeModeNotify(*(unsigned int *)pCharacteristic->getData());
            LOG(""mode_char"");
        }
        else if (pCharacteristic == data_char)
        {
            ByteData data{
                data_char->getData(),
                data_char->getValue().size()};
            _writeDataNotify(data);
            LOG(""data_char"");
        }
        else if (pCharacteristic == led_count_char)
        {
            _writeLedCountNotify(*(unsigned int *)pCharacteristic->getData());
            LOG(""led_count_char"");
        }
    }

private:
};
",instance
329,"// Copyright (c) 2021, NVIDIA CORPORATION.
//
// 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 <pybind11/pybind11.h>
#include <pybind11/numpy.h>

#include <mutex>
#include <memory>
#include <map>
#include <unordered_map>
#include <iostream>

namespace nvtabular
{
  namespace inference
  {

    namespace py = pybind11;

    struct ColumnMapping
    {
      explicit ColumnMapping(const std::string &column_name, const std::string &filename)
          : filename(filename)
      {
        // use pandas to read into a dataframe. Note: we're purposefully doing this on the
        // CPU here to avoid using gpu memory at inference time
        py::object pandas = py::module_::import(""pandas"");
        py::object df = pandas.attr(""read_parquet"")(filename);
        py::object isnull = pandas.attr(""isnull"");
        py::array values = df[column_name.c_str()].attr(""values"");
        auto dtype = values.dtype();

        if ((dtype.kind() == 'O') || (dtype.kind() == 'U'))
        {
          int64_t i = UNIQUE_OFFSET;
          for (auto &value : values)
          {
            if (!py::cast<bool>(isnull(value)))
            {
              if (PyUnicode_Check(value.ptr()) || PyBytes_Check(value.ptr()))
              {
                std::string key = py::cast<std::string>(value);
                mapping_str[key] = i;
              }
              else if (PyBool_Check(value.ptr()))
              {
                // so we're categorifying bool columns in the rossmann dataset - which makes little
                // sense but we have to handle I guess ?
                mapping_int[value.ptr() == Py_True] = i;
              }
              else if (PyLong_Check(value.ptr()))
              {
                auto key = py::cast<int64_t>(value);
                mapping_int[key] = i;
              }
              else
              {
                std::stringstream error;
                error << ""Don't know how to handle column "" << column_name << "" @ "" << filename;
                throw std::invalid_argument(error.str());
              }
            }
            i++;
          }
        }
        else
        {
          // TODO: array dispatch code
          switch (dtype.kind())
          {
          case 'f':
            switch (dtype.itemsize())
            {
            case 4:
              insert_int_mapping<float>(values);
              return;
            case 8:
              insert_int_mapping<double>(values);
              return;
            }
            break;
          case 'u':
            switch (dtype.itemsize())
            {
            case 1:
              insert_int_mapping<uint8_t>(values);
              return;
            case 2:
              insert_int_mapping<uint16_t>(values);
              return;
            case 4:
              insert_int_mapping<uint32_t>(values);
              return;
            case 8:
              insert_int_mapping<uint64_t>(values);
              return;
            }
            break;
          case 'i':
            switch (dtype.itemsize())
            {
            case 1:
              insert_int_mapping<int8_t>(values);
              return;
            case 2:
              insert_int_mapping<int16_t>(values);
              return;
            case 4:
              insert_int_mapping<int32_t>(values);
              return;
            case 8:
              insert_int_mapping<int64_t>(values);
              return;
            }
            break;
          }
          std::stringstream error;
          error << ""unhandled dtype "" << dtype.kind() << dtype.itemsize() << "" for column "" << column_name;
          throw std::invalid_argument(error.str());
        }
      }

      template <typename T>
      void insert_int_mapping(py::array_t<T> values)
      {
        const T *data = values.data();
        size_t size = values.size();
        for (size_t i = 0; i < size; ++i)
        {
          mapping_int[static_cast<int64_t>(data[i])] = i + UNIQUE_OFFSET;
        }
      }

      template <typename T>
      py::array transform_int(py::array_t<T> input) const
      {
        py::object pandas = py::module_::import(""pandas"");
        py::object isnull = pandas.attr(""isnull"");
        py::array_t<int64_t> output(input.size());
        const T *input_data = input.data();
        int64_t *output_data = output.mutable_data();
        for (int64_t i = 0; i < input.size(); ++i)
        {
          auto it = mapping_int.find(static_cast<int64_t>(input_data[i]));
          if (it == mapping_int.end())
          {
            output_data[i] = py::cast<bool>(isnull(input_data[i])) ? NULL_INDEX : OOV_INDEX;
          }
          else
          {
            output_data[i] = it->second;
          }
        }
        return output;
      }

      py::array transform(py::array input) const
      {
        auto dtype = input.dtype();
        auto kind = dtype.kind();
        if ((kind == 'O') || (kind == 'U'))
        {
          size_t i = 0;
          py::array_t<int64_t> output(input.size());
          int64_t *data = output.mutable_data();
          for (auto &value : input)
          {
            if (value.is_none())
            {
              data[i] = NULL_INDEX;
            }
            else if (PyUnicode_Check(value.ptr()) || PyBytes_Check(value.ptr()))
            {
              std::string key = py::cast<std::string>(value);
              auto it = mapping_str.find(key);
              data[i] = it == mapping_str.end() ? OOV_INDEX : it->second;
            }
            else if (PyBool_Check(value.ptr()))
            {
              auto it = mapping_int.find(value.ptr() == Py_True);
              data[i] = it == mapping_int.end() ? OOV_INDEX : it->second;
            }
            else
            {
              throw std::invalid_argument(""unknown dtype"");
            }
            i++;
          }
          return output;
        }
        else
        {
          // TODO: array dispatch code
          auto itemsize = dtype.itemsize();
          switch (kind)
          {
          // floats don't really make sense here, but can happen because of auto
          // conversion with pandas code involving none values
          case 'f':
            switch (itemsize)
            {
            case 4:
              return transform_int<float>(input);
            case 8:
              return transform_int<double>(input);
            }
            break;
          case 'u':
            switch (itemsize)
            {
            case 1:
              return transform_int<uint8_t>(input);
            case 2:
              return transform_int<uint16_t>(input);
            case 4:
              return transform_int<uint32_t>(input);
            case 8:
              return transform_int<uint64_t>(input);
            }
            break;
          case 'i':
            switch (itemsize)
            {
            case 1:
              return transform_int<int8_t>(input);
            case 2:
              return transform_int<int16_t>(input);
            case 4:
              return transform_int<int32_t>(input);
            case 8:
              return transform_int<int64_t>(input);
            }
            break;
          case 'b':
            return transform_int<char>(input);
          }
          std::stringstream error;
          error << ""unhandled dtype "" << kind << itemsize << "" for column '"" << column_name << ""'"";
          throw std::invalid_argument(error.str());
        }
      }

      std::string filename;
      std::string column_name;

      std::unordered_map<std::string, int64_t> mapping_str;
      std::unordered_map<int64_t, int64_t> mapping_int;

      // TODO: Handle multiple OOV buckets?
      const int64_t NULL_INDEX = 1;
      const int64_t OOV_INDEX = 2;
      const int64_t UNIQUE_OFFSET = 3;
    };

    // Reads in a parquet category mapping file in cpu memory using pandas
    std::shared_ptr<ColumnMapping> get_column_mapping(const std::string &column_name,
                                                      const std::string &filename)
    {
      // because of how we're doing multi-gpu inside of tritonserver, we could have
      // multiple instances of the same workflow running in the same process. (with
      // each workflow having unique per-gpu data).
      // Since we're storing this mapping in CPU memory, lets cache values across
      // processes to reduce duplicate memory usage.
      static std::map<std::string, std::weak_ptr<ColumnMapping>> cache;
      static std::mutex m;

      std::lock_guard<std::mutex> lock(m);
      auto cache_item = cache[filename].lock();
      if (!cache_item)
      {
        cache[filename] = cache_item = std::make_shared<ColumnMapping>(column_name, filename);
      }
      return cache_item;
    }

    // Accelerated categorify operator for running under triton inference server
    struct CategorifyTransform
    {
      explicit CategorifyTransform(py::object op)
      {
        py::dict categories = op.attr(""categories"");
        for (auto &item : categories)
        {
          auto column = py::cast<std::string>(item.first);
          auto filename = py::cast<std::string>(item.second);
          columns[column] = get_column_mapping(column, filename);
        }
      }

      py::object transform(py::object column_selector, py::dict  [MASK] )
      {
        for (auto it :  [MASK] )
        {
          auto column_name = py::cast<std::string>(it.first);
          auto mapping = columns.find(column_name);
          if (mapping == columns.end())
          {
            std::stringstream err;
            err << ""Unknown column for CategorifyTransform "" << column_name;
            throw std::invalid_argument(err.str());
          }

          if (PyTuple_Check(it.second.ptr()))
          {
            auto value_offsets = py::cast<py::tuple>(it.second);
            auto tensor = py::cast<py::array>(value_offsets[0]);
             [MASK] [column_name.c_str()] = py::make_tuple(mapping->second->transform(tensor), value_offsets[1]);
          }
          else
          {
            auto tensor = py::cast<py::array>(it.second);
             [MASK] [column_name.c_str()] = mapping->second->transform(tensor);
          }
        }
        return  [MASK] ;
      }
      std::unordered_map<std::string, std::shared_ptr<ColumnMapping>> columns;
    };

    void export_categorify(py::module_ m)
    {
      py::class_<CategorifyTransform>(m, ""CategorifyTransform"")
          .def(py::init<py::object>())
          .def(""transform"", &CategorifyTransform::transform)

          // this operator currently only supports CPU arrays
          .def_property_readonly(""supports"", [](py::object self)
                                 {
                                   py::object supports = py::module_::import(""nvtabular"").attr(""graph"").attr(""operator"").attr(""Supports"");
                                   return supports.attr(""CPU_DICT_ARRAY"");
                                 })
          .def_property_readonly(""supported_formats"", [](py::object self)
                                 {
                                   py::object supported = py::module_::import(""nvtabular"").attr(""graph"").attr(""operator"").attr(""DataFormats"");
                                   return supported.attr(""NUMPY_DICT_ARRAY"");
                                 });
    }
  } // namespace inference
} // namespace nvtabular
",tensors
330,"#include <Arduino.h>
#include <Wire.h>
#include <SoftwareSerial.h>
#include <MeMCore.h>

#define MOVE_FORWARD 1
#define MOVE_LEFT 2
#define MOVE_RIGHT 3
#define MOVE_REVERSE 4
#define MOVE_DANCE 7
#define MOVE_STAR_WARS 8
#define MOVE_STOP 6

#define SLOW_SPEED 100
#define DEFAULT_SPEED 200

//Definition of the notes' frequecies in Hertz.
#define c 261
#define d 294
#define e 329
#define f 349
#define g 391
#define gS 415
#define a 440
#define aS 455
#define b 466
#define cH 523
#define cSH 554
#define dH 587
#define dSH 622
#define eH 659
#define fH 698
#define fSH 740
#define gH 784
#define gSH 830
#define aH 880

// Variable declaration
MeDCMotor motor_9(9);
MeDCMotor motor_10(10);    
MeRGBLed rgbled_7(7, 7==7?2:4);
MeBuzzer buzzer;
int isPlayingMusic = 0;
int receivedCommand;
boolean newData = false;

/*
* Helper method for the handling of the 
*/
void updateSpeed(int leftSpeed, int rightSpeed){
      motor_9.run((9)==M1?-(leftSpeed):(leftSpeed));
      motor_10.run((10)==M1?-(rightSpeed):(rightSpeed));
}

void dance(){
    rgbled_7.setColor(1,0, 255, 213);
    rgbled_7.show();
    handle( MOVE_LEFT, SLOW_SPEED );
    _delay(1);
    handle( MOVE_RIGHT, SLOW_SPEED );
    _delay(1);
    handle( MOVE_LEFT, SLOW_SPEED );
    _delay(1);
    handle( MOVE_RIGHT, SLOW_SPEED );
    _delay(1);
    handle( MOVE_FORWARD, SLOW_SPEED );
    _delay(1);
    handle( MOVE_REVERSE, SLOW_SPEED );
    _delay(1);
    handle( MOVE_STOP, SLOW_SPEED );
    rgbled_7.setColor(1,255, 0, 255);
    rgbled_7.show();
}

/**
* Sample music playing of the Imperial march
*/
void starWars(){
    isPlayingMusic = 1;
    buzzer.tone(a, 500);
    buzzer.tone(a, 500);
    buzzer.tone(a, 500);
    buzzer.tone(f, 350);
    buzzer.tone(cH, 150);
    buzzer.tone(a, 500);
    buzzer.tone(f, 350);
    buzzer.tone(cH, 150);
    buzzer.tone(a, 650);
    
    rgbled_7.setColor(1,0, 255, 213);
    rgbled_7.show();
    handle( MOVE_LEFT, SLOW_SPEED );
    handle( MOVE_RIGHT, SLOW_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );
 
    //end of first bit
    
    buzzer.tone(eH, 500);    
    buzzer.tone(eH, 500);
    buzzer.tone(eH, 500);
    buzzer.tone(fH, 350);
    buzzer.tone(cH, 150);
    buzzer.tone(gS, 500);
    buzzer.tone(f, 350);
    buzzer.tone(cH, 150);
    buzzer.tone(a, 650);
    
    rgbled_7.setColor(1,55, 98, 100);
    rgbled_7.show();
    handle( MOVE_FORWARD, SLOW_SPEED );
    handle( MOVE_REVERSE, SLOW_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );
 
    //end of second bit...
 
    buzzer.tone(aH, 500);
    buzzer.tone(a, 300);
    buzzer.tone(a, 150);
    buzzer.tone(aH, 400);
    buzzer.tone(gSH, 200);
    buzzer.tone(gH, 200);
    buzzer.tone(fSH, 125);
    buzzer.tone(fH, 125);
    buzzer.tone(fSH, 250);

    rgbled_7.setColor(1,0, 255,0);
    rgbled_7.show();
    handle( MOVE_REVERSE, SLOW_SPEED );
    handle( MOVE_FORWARD, SLOW_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );
 
    buzzer.tone(aS, 250);
    buzzer.tone(dSH, 400);
    buzzer.tone(dH, 200);
    buzzer.tone(cSH, 200);
    buzzer.tone(cH, 125);
    buzzer.tone(b, 125);
    buzzer.tone(cH, 250);

    rgbled_7.setColor(1,0,0,255);
    rgbled_7.show();
    handle( MOVE_RIGHT, SLOW_SPEED );
    handle( MOVE_LEFT, SLOW_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );
 
    buzzer.tone(f, 125);
    buzzer.tone(gS, 500);
    buzzer.tone(f, 375);
    buzzer.tone(a, 125);
    buzzer.tone(cH, 500);
    buzzer.tone(a, 375);
    buzzer.tone(cH, 125);
    buzzer.tone(eH, 650);

    rgbled_7.setColor(1,255,0,0);
    rgbled_7.show();
    handle( MOVE_LEFT, SLOW_SPEED );
    handle( MOVE_RIGHT, SLOW_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );
    
    //end of third bit... (Though it doesn't play well)
    //let's repeat it
 
    buzzer.tone(aH, 500);
    buzzer.tone(a, 300);
    buzzer.tone(a, 150);
    buzzer.tone(aH, 400);
    buzzer.tone(gSH, 200);
    buzzer.tone(gH, 200);
    buzzer.tone(fSH, 125);
    buzzer.tone(fH, 125);
    buzzer.tone(fSH, 250);

    rgbled_7.setColor(1,0,255,0);
    rgbled_7.show();
    handle( MOVE_RIGHT, SLOW_SPEED );
    handle( MOVE_LEFT, SLOW_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );

    buzzer.tone(aS, 250);
    buzzer.tone(dSH, 400);
    buzzer.tone(dH, 200);
    buzzer.tone(cSH, 200);
    buzzer.tone(cH, 125);
    buzzer.tone(b, 125);
    buzzer.tone(cH, 250);

    rgbled_7.setColor(1,0,0,255);
    rgbled_7.show();
    handle( MOVE_FORWARD, SLOW_SPEED );
    handle( MOVE_REVERSE, SLOW_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );
     
    buzzer.tone(f, 250);
    buzzer.tone(gS, 500);
    buzzer.tone(f, 375);
    buzzer.tone(cH, 125);
    buzzer.tone(a, 500);
    buzzer.tone(f, 375);
    buzzer.tone(cH, 125);
    buzzer.tone(a, 650);
    //end of the song

    rgbled_7.setColor(1,255,0,0);
    rgbled_7.show();
    handle( MOVE_LEFT, SLOW_SPEED );
    handle( MOVE_RIGHT, SLOW_SPEED );
    handle( MOVE_REVERSE, DEFAULT_SPEED );
    handle( MOVE_FORWARD, DEFAULT_SPEED );
    handle( MOVE_STOP, SLOW_SPEED );    
    isPlayingMusic = 0;
}

void handle(int  [MASK] , int speed){
      int leftSpeed;
      int rightSpeed;
      switch(  [MASK]  ){
        case MOVE_FORWARD:
          leftSpeed = speed;
          rightSpeed = speed;
          break;
        case MOVE_REVERSE:
          leftSpeed = -speed;
          rightSpeed = -speed;
          break;
        case MOVE_LEFT:
          leftSpeed = -speed;
          rightSpeed = speed;
          updateSpeed( leftSpeed, rightSpeed );
          _delay(0.25);
          leftSpeed = speed;
          rightSpeed = speed;
          break;
        case MOVE_RIGHT:
          leftSpeed = speed;
          rightSpeed = -speed;
          updateSpeed( leftSpeed, rightSpeed );
          _delay(0.25);
          leftSpeed = speed;
          rightSpeed = speed;
          break;
        case MOVE_DANCE:
          dance();
          break;
        case MOVE_STAR_WARS:
          starWars();
          break;
        case MOVE_STOP:
          leftSpeed = 0;
          rightSpeed = 0;
          break;
        default:
          leftSpeed = 0;
          rightSpeed = 0;
      }

      updateSpeed(leftSpeed, rightSpeed);
}

void setup() {
    Serial.begin(115200);
    Serial.println(""mBot waiting for instructions"");

    // We show a yellow ready when the arduino is ready
    rgbled_7.setColor(1,156,14,179);
    rgbled_7.show();
    
    // We show a green when play music
    rgbled_7.setColor(1,255,255,0);
    rgbled_7.show();
}

void loop() {
    receiveCommand();
    handleInput();
    _delay(1.0);
}
void receiveCommand() {
    if (isPlayingMusic == 0 && Serial.available() > 0) {
        receivedCommand = Serial.read();
        newData = true;
    }
}
void handleInput() {
    if (newData == true) {
        Serial.print(""This just in ... "");
        Serial.println(receivedCommand, DEC);
        newData = false;
        rgbled_7.setColor(1,0,0,255);
        rgbled_7.show();

        handle( receivedCommand, DEFAULT_SPEED );
    }else{
        rgbled_7.setColor(1,255,0,0);
        rgbled_7.show();
    }
}
void _delay(float seconds){
    long endTime = millis() + seconds * 1000;
    while(millis() < endTime)_loop();
}
void _loop(){
  
}

",command
331,"#include <iostream>
#include <string>

#include ""person.hpp""

using namespace LCppIYM;

bool Person::isValidName(std::string name)
{
	return name.size() > 0
		&& name.find("" "") == std::string::npos;
}

Person::Person(std::string fname, std::string lname)
{
	if (! Person::isValidName(fname))
		throw std::runtime_error(""Invalid fname"");

	if (! Person::isValidName(lname))
		throw std::runtime_error(""Invalid lname"");

	this->fname = fname;
	this->lname = lname;
}

Person::~Person()
{
}

void Person::kick(Person* p) const
{
	std::cout
			<< this->getFirstName()
			<< "" kicked ""
			<< p->getFirstName()
			<< std::endl;
}

void Person::say(std::string  [MASK] ) const
{
	std::cout << ""\"""" <<  [MASK]  << ""\"", said "" << this->getFirstName() << std::endl;
}

std::string Person::getFirstName() const
{
	return this->fname;
}

std::string Person::getLastName() const
{
	return this->lname;
}

std::string Person::getName() const
{
	return this->fname + "" "" + this->lname;
}
",quote
332,"
#include ""box.hh""

#include ""debug.hh""
#include ""keyboard.hh""

namespace Box {

Box::Box() {
  if (tb_init() < 0) {
    exit(1);
  }
  this->Clear();
}

Box::~Box() {
  tb_shutdown();
}

void Box::SetClearAttributes(color_t fg, color_t bg) {
  tb_set_clear_attributes(fg, bg);
}

void Box::Clear() {
  tb_clear();
}

void Box::Present() {
  tb_present();
}

void Box::SetCursor(int cx, int cy) {
  tb_set_cursor(cx, cy);
}

void Box::HideCursor() {
  tb_set_cursor(TB_HIDE_CURSOR, TB_HIDE_CURSOR);
}

void Box::PutCell(int x, int y, const Cell::Cell &cell) {
  if ('\0' == cell.ch()) {
    return;
  }
  const auto tb = tb_cell(cell);
  tb_put_cell(x, y, &tb);
}

void Box::Blit(int x, int y, int w, int h, std::vector<Cell::Cell> cells) {
  std::vector<tb_cell> tb(cells.begin(), cells.end());
  tb_blit(x, y, w, h, tb.data());
}

int Box::SelectInputMode(int mode) {
  return tb_select_input_mode(mode);
}

int Box::SelectOutputMode(OutputMode mode) {
  return tb_select_output_mode(static_cast<int>(mode));
}

EventType Box::PeekEvent(struct tb_event *event, const int  [MASK] ) {
  auto ev = tb_peek_event(event,  [MASK] );
  if (ev == TB_EVENT_KEY) {
    return EventType::Key;
  }
  else if (ev == TB_EVENT_RESIZE) {
    return EventType::Resize;
  }
  else {
    return EventType::None;
  }
}

EventType Box::PollEvent(struct tb_event *event) {
  switch (tb_poll_event(event)) {
      case TB_EVENT_KEY: {
        return EventType::Key;

      }
      case TB_EVENT_RESIZE: {
        return EventType::Resize;

      }
      default: {
        return EventType::None;
      }
    }
}

} // namespace TB
",timeout
333,"/*
    Copyright 2022 Total Pave Inc

    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 <tp/qt/Node.h>
#include <stdexcept>

namespace TP { namespace qt {
    using namespace TP::geom;

    Node::Node(uint32_t bucketSize, const Extent<double>& extent, uint8_t depth) {
        $extent = extent;
        $bucketSize = bucketSize;
        $depth = depth;

        // These only exists once this node has been subdivided
        $nw = nullptr;
        $ne = nullptr;
        $sw = nullptr;
        $se = nullptr;
    }

    Node::~Node() {
        if ($nw != nullptr) {
            delete $nw;
            delete $ne;
            delete $sw;
            delete $se;
        }
    }

    const Extent<double>& Node::getExtent(void) const {
        return $extent;
    }

    void Node::query(const Extent<double>& extent, std::vector<const void*>& dataList, std::unordered_map<long, bool>& dataManifest, std::function<bool(const Extent<double>&, const QuadPoint*)>* filter) {
        // isInBounds is the first pass filter.
        // It checks to see if the requested extent is at least partially within the bounds of the quad extent.
        // The first pass filter is a very broad and inaccurate filter, it often includes many false possitives.
        // The false positives happen because quad extent is bigger than the requested extent, it ends up selecting
        // a lot of extra data in the general surrounding area of the requested extent.
        // The quad extent is often bigger than the requested extent because there is not enough data for the quad to split into smaller quads.
        if ($extent.isInBounds(extent)) {
            for (std::size_t i = 0; i < $children.size(); i++) {
                const QuadPoint* point = $children[i];
                const void* data = point->getData();
                long ptr = (long)data;
                if (
                    dataManifest.find(ptr) == dataManifest.end() &&
                    // Second pass filtering
                    // Test each QuadPoint against the requested extent.
                    // The second pass filter has medium accuracy.
                    // Most false positives are caught but long diagonal lines still have many false positives.
                    point->isInBounds(extent)
                ) {
                    if (
                        // If filter is defined...
                        filter != nullptr &&
                        !((*filter)(extent, point))
                    ) { // If point fails filter then continue to next point.
                        continue;
                    }
                    dataManifest.insert(std::pair<long, bool>(ptr, true));
                    dataList.push_back(data);
                }
            }

            if ($nw != nullptr) {
                $nw->query(extent, dataList, dataManifest, filter);
                $ne->query(extent, dataList, dataManifest, filter);
                $sw->query(extent, dataList, dataManifest, filter);
                $se->query(extent, dataList, dataManifest, filter);
            }
        }
    }

    void Node::insert(const QuadPoint* point) {
        if ($nw != nullptr) {
            // This node has quadrants, so it should be passed down.

            const Extent<double>& nwExtent = $nw->getExtent();
            const Extent<double>& neExtent = $ne->getExtent();
            const Extent<double>& swExtent = $sw->getExtent();
            const Extent<double>& seExtent = $se->getExtent();

            if (point->isInBounds(nwExtent)) {
                $nw->insert(point);
            }

            if (point->isInBounds(neExtent)) {
                $ne->insert(point);
            }

            if (point->isInBounds(swExtent)) {
                $sw->insert(point);
            }

            if (point->isInBounds(seExtent)) {
                $se->insert(point);
            }

            return;
        }

        if ($children.size() == 0) {
            $children.reserve($bucketSize);
        }
        // If we made it here, then we are at a leaf node.
        $children.push_back(point);

        if ($children.size() >= $bucketSize && $depth != 1) {
            subdivide();
        }
    }

    void Node::subdivide(void) {
        if ($nw != nullptr || $depth == 1) {
            // This node has already been subdivided.
            return;
        }

        Extent<double> quadExtent = Extent<double>::quad($extent);
        double tx, ty;
        uint8_t  [MASK]  = $depth - 1;
        
        quadExtent.getRange(tx, ty);
        $nw = new Node($bucketSize, quadExtent,  [MASK] );

        quadExtent.translate(tx, 0.0);
        $ne = new Node($bucketSize, quadExtent,  [MASK] );

        quadExtent.translate(0.0, ty);
        $se = new Node($bucketSize, quadExtent,  [MASK] );

        quadExtent.translate(-tx, 0.0);
        $sw = new Node($bucketSize, quadExtent,  [MASK] );

        const Extent<double>& nwExtent = $nw->getExtent();
        const Extent<double>& neExtent = $ne->getExtent();
        const Extent<double>& swExtent = $sw->getExtent();
        const Extent<double>& seExtent = $se->getExtent();

        while ($children.size() > 0) {
            const QuadPoint* point = $children.back();
            $children.pop_back();

            if (point->isInBounds(nwExtent)) {
                $nw->insert(point);
            }

            if (point->isInBounds(neExtent)) {
                $ne->insert(point);
            }

            if (point->isInBounds(swExtent)) {
                $sw->insert(point);
            }

            if (point->isInBounds(seExtent)) {
                $se->insert(point);
            }
        }

        $children.shrink_to_fit();
    }
}}
",childDepth
334,"#include <algorithm>
#include <assert.h>
#include <chrono>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <mpi.h>
#include <omp.h>
#include <random>
#include <vector>

#ifndef ITER_MAX
#define ITER_MAX 5000
#endif

// Communicator for a Pair of rank
// Useful for measuring Bi-Socket BW, and 2 Tile-GPU
MPI_Comm MPI_SUB_COMM;
MPI_Comm MPI_SUB_COMM_GATHER;

/*
 * Benchmark Utilities
 */

void bench(unsigned long *min_time, std::string bench_type, int globalWI, double *Aptr,
           double *Bptr, double *Cptr) {

  MPI_Barrier(MPI_SUB_COMM);

  // Save start and end
  const unsigned long l_start = std::chrono::duration_cast<std::chrono::nanoseconds>(
                                    std::chrono::high_resolution_clock::now().time_since_epoch())
                                    .count();

  if (bench_type == ""cpu"") {
#pragma omp parallel for
    for (int i = 0; i < globalWI; i++)
      Aptr[i] = 2.0 * Bptr[i] + Cptr[i];
  } else if (bench_type == ""gpu"") {
#pragma omp target teams distribute parallel for
    for (int i = 0; i < globalWI; i++)
      Aptr[i] = 2.0 * Bptr[i] + Cptr[i];
  }

  const unsigned long l_end = std::chrono::duration_cast<std::chrono::nanoseconds>(
                                  std::chrono::high_resolution_clock::now().time_since_epoch())
                                  .count();

  unsigned long start, end;
  MPI_Allreduce(&l_start, &start, 1, MPI_UNSIGNED_LONG, MPI_MIN, MPI_SUB_COMM);
  MPI_Allreduce(&l_end, &end, 1, MPI_UNSIGNED_LONG, MPI_MAX, MPI_SUB_COMM);

  unsigned long time = end - start;
  if (time <= *min_time) {
    *min_time = time;
  }
}

bool almost_equal(double x, double y, int ulp) {
  return std::abs(x - y) <= std::numeric_limits<double>::epsilon() * std::abs(x + y) * ulp ||
         std::abs(x - y) < std::numeric_limits<double>::min();
}

template <typename T1, typename T2> typename T1::value_type quant(const T1 &x, T2 q) {
  assert(q >= 0.0 && q <= 1.0);

  const auto n = x.size();
  const auto id = (n - 1) * q;
  const auto lo = floor(id);
  const auto hi = ceil(id);
  const auto qs = x[lo];
  const auto h = (id - lo);

  return (1.0 - h) * qs + h * x[hi];
}

int run(int globalWI, std::string name, std::string bench_type) {

  std::vector<double> A(globalWI), B(globalWI), C(globalWI);
  std::srand(0);
  std::generate(B.begin(), B.end(), std::rand);
  std::generate(C.begin(), C.end(), std::rand);
  double *Aptr{A.data()};
  double *Bptr{B.data()};
  double *Cptr{C.data()};

  unsigned long min_time = std::numeric_limits<unsigned long>::max();
  int errors = 0;

  if (bench_type == ""gpu"") {
#pragma omp target enter data map(alloc : Aptr[ : globalWI])                                       \
    map(to : Bptr[ : globalWI], Cptr[ : globalWI])
  }

  for (int iter = 0; iter < ITER_MAX; iter++) {
    bench(&min_time, bench_type, globalWI, Aptr, Bptr, Cptr);
  }
  if (bench_type == ""gpu"") {
#pragma omp target exit data map(from : Aptr[ : globalWI])
  }

  for (int i = 0; i < globalWI; i++) {
    assert(almost_equal(Aptr[i], 2.0 * Bptr[i] + Cptr[i], 10));
  }
  // Now do a gather
  int root_rank = 0;
  int world_rank;
  MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);

  if (world_rank == root_rank) {
    int gather_size;
    MPI_Comm_size(MPI_SUB_COMM_GATHER, &gather_size);

    std::vector<double> bw(gather_size);
    {
      std::vector<unsigned long> min_times(gather_size);
      MPI_Gather(&min_time, 1, MPI_UNSIGNED_LONG, min_times.data(), 1, MPI_UNSIGNED_LONG, root_rank,
                 MPI_SUB_COMM_GATHER);
      {
        int sub_size;
        MPI_Comm_size(MPI_SUB_COMM, &sub_size);
        std::transform(min_times.begin(), min_times.end(), bw.begin(), [&](unsigned long val) {
          return (3. * globalWI * sub_size * sizeof(double)) / val;
        });
      }
#ifdef SAVE
      {
        std::string filename = name + "".txt"";
        std::ofstream fout(filename.c_str());
        for (auto const &x : bw)
          fout << x << '\n';
      }
#endif
      std::sort(bw.begin(), bw.end());
    }
    std::cout << ""Result For "" << name << "" (sample size: "" << gather_size << "")"" << std::endl;
    std::cout << ""-Min "" << bw.front() << "" GByte/s"" << std::endl;
    std::cout << ""-Q1 "" << quant(bw, 0.25) << "" GByte/s"" << std::endl;
    std::cout << ""-Q2(median) "" << quant(bw, 0.50) << "" GByte/s"" << std::endl;
    std::cout << ""-Q3 "" << quant(bw, 0.75) << "" GByte/s"" << std::endl;
    std::cout << ""-Max "" << bw.back() << "" GByte/s"" << std::endl;

  } else if (MPI_SUB_COMM_GATHER != MPI_COMM_NULL) {
    MPI_Gather(&min_time, 1, MPI_UNSIGNED_LONG, NULL, 0, MPI_UNSIGNED_LONG, root_rank,
               MPI_SUB_COMM_GATHER);
  }

  int  [MASK]  = 0;
  MPI_Reduce(&errors, & [MASK] , 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
  return  [MASK] ;
}

/*
 * Main
 */

int main(int argc, char **argv) {

  MPI_Init(NULL, NULL);

  int my_rank;
  MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);

  std::string bench_type{argv[1]};

  if (bench_type == ""gpu"") {
    // Best of two Tiles
    MPI_Comm_split(MPI_COMM_WORLD, my_rank / 2, 0, &MPI_SUB_COMM);

    int world_size;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);
    std::vector<int> ranks(world_size / 2);
    {
      int n = -2;
      std::generate(ranks.begin(), ranks.end(), [&n] { return n += 2; });
    }
    {
      MPI_Group world_group;
      MPI_Comm_group(MPI_COMM_WORLD, &world_group);
      MPI_Group new_group;
      MPI_Group_incl(world_group, ranks.size(), ranks.data(), &new_group);
      MPI_Comm_create(MPI_COMM_WORLD, new_group, &MPI_SUB_COMM_GATHER);
    }
  } else if (bench_type == ""cpu"") {
    MPI_Comm_split(MPI_COMM_WORLD, my_rank, 0, &MPI_SUB_COMM);
    MPI_SUB_COMM_GATHER = MPI_COMM_WORLD;
  }

  int errors = 0;
  if (bench_type == ""cpu"") {
    // = 128*2*10^6 Bytes (LL2+LL3) * 4 (STREAM factor) / 8 (doubles)
    errors += run(128'000'000, ""stream"", bench_type);
  } else if (bench_type == ""gpu"") {
    // = 204*10^6 Bytes (LLC) * 4 (STREAM factor) / 8 (doubles)
    errors += run(102'000'000, ""stream"", bench_type);
  }
  MPI_Finalize();
  return errors;
}
",mpi_errors
335,"#include <array>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <vector>

#include <SDL.h>
#include <SDL_image.h>

#include ""glad/glad.h""

static const std::array<float, 16> s_vertices = {
    -0.5f, -0.5f, 0.0f, 0.0f, // Bottom left
    -0.5f, 0.5f,  0.0f, 1.0f, // Top left
    0.5f,  -0.5f, 1.0f, 0.0f, // Bottom right
    0.5f,  0.5f,  1.0f, 1.0f, // Top right
};

static const std::array<unsigned int, 6> s_indices = {
    0, 1, 3, 0, 3, 2,
};

static const char *const vertex_source = R""glsl(
  #version 330 core

  layout (location = 0) in vec2 position;
  layout (location = 1) in vec2 tex_coord;

  out vec2 v_tex_coord;

  void main() {
    gl_Position = vec4(position, 0.0, 1.0);
    v_tex_coord = tex_coord;
  }
)glsl"";

static const char *const fragment_source = R""glsl(
  #version 330 core

  in vec2 v_tex_coord;

  out vec4 f_color;

  uniform sampler2D u_texture;

  void main() {
    f_color = texture(u_texture, v_tex_coord);
  }
)glsl"";

std::uint32_t get_pixel(const SDL_Surface *surface, int x, int y) {
  // I'm not sure if this is going to be the case, but I'm assuming it is since
  // we're loading PNG data.
  assert(surface->format->BytesPerPixel == 4);
  std::uint8_t *p = reinterpret_cast<std::uint8_t *>(surface->pixels) + x * 4 +
                    y * surface->pitch;
  return *reinterpret_cast<std::uint32_t *>(p);
}

struct ImageData {
  std::vector<std::uint8_t> bytes;
  GLsizei width;
  GLsizei height;
};

ImageData load_png_data(const std::string &path) {
  SDL_Surface *surface = IMG_Load(path.c_str());
  if (surface == nullptr) {
    std::cerr << ""Failed to load image data: "" << IMG_GetError() << '\n';
    return {};
  }

  std::vector<std::uint8_t> bytes;

#define LOAD_PNG_DATA_LOOP_BACKWARD 1
#if LOAD_PNG_DATA_LOOP_BACKWARD
  for (int y = surface->h - 1; y >= 0; y--) {
    for (int x = 0; x < surface->w; x++) {
      std::uint32_t color = get_pixel(surface, x, y);
      std::uint8_t r, g, b, a;
      SDL_GetRGBA(color, surface->format, &r, &g, &b, &a);
      bytes.push_back(r);
      bytes.push_back(g);
      bytes.push_back(b);
      bytes.push_back(a);
    }
  }
#else
  for (int y = 0; y < surface->h; y++) {
    for (int x = 0; x < surface->w; x++) {
      std::uint32_t color = get_pixel(surface, x, y);
      std::uint8_t r, g, b, a;
      SDL_GetRGBA(color, surface->format, &r, &g, &b, &a);
      bytes.push_back(r);
      bytes.push_back(g);
      bytes.push_back(b);
      bytes.push_back(a);
    }
  }
#endif

  return {bytes, surface->w, surface->h};
}

// Don't change the signature of main even though argc and argv aren't used. SDL
// needs this on windows. FML.
int main(int argc, char *argv[]) {
  if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
    std::cerr << ""Failed to initialize SDL: "" << SDL_GetError() << '\n';
  }

  int img_flags = IMG_INIT_PNG;
  if (!(IMG_Init(img_flags) & img_flags)) {
    std::cerr << ""Failed to initialize SDL image: "" << IMG_GetError() << '\n';
  }

  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);

  SDL_Window *window =
      SDL_CreateWindow(""Better Breakout"", SDL_WINDOWPOS_UNDEFINED,
                       SDL_WINDOWPOS_UNDEFINED, 800, 600, SDL_WINDOW_OPENGL);
  if (window == nullptr) {
    std::cerr << ""Failed to create window: "" << SDL_GetError() << '\n';
  }

  SDL_GLContext context = SDL_GL_CreateContext(window);
  if (context == nullptr) {
    std::cerr << ""Failed to create OpenGL context: "" << SDL_GetError() << '\n';
  }

  if (gladLoadGLLoader(SDL_GL_GetProcAddress) == 0) {
    std::cerr << ""Failed to initialize glad\n"";
  }

  // Debug output some crap

  std::cerr << ""Vendor: "" << glGetString(GL_VENDOR) << '\n';
  std::cerr << ""Renderer: "" << glGetString(GL_RENDERER) << '\n';
  std::cerr << ""OpenGL version: "" << glGetString(GL_VERSION) << '\n';
  std::cerr << ""GLSL version: "" << glGetString(GL_SHADING_LANGUAGE_VERSION) << '\n';

  // Triangle stuff

  GLuint vertex_array;
  glGenVertexArrays(1, &vertex_array);
  glBindVertexArray(vertex_array);

  GLuint  [MASK] ;
  glGenBuffers(1, & [MASK] );
  glBindBuffer(GL_ARRAY_BUFFER,  [MASK] );
  glBufferData(GL_ARRAY_BUFFER, s_vertices.size() * sizeof(float),
               s_vertices.data(), GL_STATIC_DRAW);

  GLuint index_buffer;
  glGenBuffers(1, &index_buffer);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, s_indices.size() * sizeof(unsigned int),
               s_indices.data(), GL_STATIC_DRAW);

  glEnableVertexAttribArray(0);
  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float),
                        reinterpret_cast<void *>(0));

  glEnableVertexAttribArray(1);
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float),
                        reinterpret_cast<void *>(2 * sizeof(float)));

  // Shader stuff

  GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertex_shader, 1, &vertex_source, nullptr);
  glCompileShader(vertex_shader);

  GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragment_shader, 1, &fragment_source, nullptr);
  glCompileShader(fragment_shader);

  GLuint program = glCreateProgram();
  glAttachShader(program, vertex_shader);
  glAttachShader(program, fragment_shader);
  glLinkProgram(program);

  glDetachShader(program, vertex_shader);
  glDetachShader(program, fragment_shader);

  glDeleteShader(fragment_shader);
  glDeleteShader(vertex_shader);

  glUseProgram(program);

  ImageData data = load_png_data(""res/textures/awesomeface.png"");

  GLuint texture;
  glGenTextures(1, &texture);
  glBindTexture(GL_TEXTURE_2D, texture);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, data.width, data.height, 0, GL_RGBA,
               GL_UNSIGNED_BYTE, data.bytes.data());
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  // I think 0 is the default??
  glUniform1i(glGetUniformLocation(program, ""u_texture""), 0);

  // TODO: Error handling

  glClearColor(0.53f, 0.91f, 0.28f, 1.0f);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  bool window_should_close = false;
  while (!window_should_close) {
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
      if (event.type == SDL_QUIT) {
        window_should_close = true;
      }
    }

    glClear(GL_COLOR_BUFFER_BIT);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT,
                   reinterpret_cast<void *>(0));
    SDL_GL_SwapWindow(window);
  }

  glDeleteProgram(program);
  glDeleteBuffers(1, &index_buffer);
  glDeleteBuffers(1, & [MASK] );
  glDeleteVertexArrays(1, &vertex_array);

  SDL_GL_DeleteContext(context);
  SDL_DestroyWindow(window);
  SDL_Quit();

  return 0;
}
",vertex_buffer
336,"#include <iostream>
#include <cstddef>
#include <cstring>
#include <string_view>
#include <cassert>
#include <iomanip>

#define FUSE_USE_VERSION 31
#include <fuse.h>

#include ""ini.cc""

using namespace std::string_view_literals;

static struct options {
	char const* ini_filename;
	int show_help;
} options;

#define OPTION(t, p) \
 { t, offsetof(struct options, p), 1 }

static const struct fuse_opt option_spec[] = {
	OPTION(""--ini=%s"", ini_filename),
	OPTION(""-h"", show_help),
	OPTION(""--help"", show_help),
	FUSE_OPT_END
};

INI ini;
struct stat ini_stat;

inline void update_stat(struct stat *dst)
{
	dst->st_ctime = ini_stat.st_ctime;
	dst->st_atime = ini_stat.st_atime;
	dst->st_mtime = ini_stat.st_mtime;

	dst->st_uid = ini_stat.st_uid;
	dst->st_gid = ini_stat.st_gid;
}

namespace inifs
{
	static void* init(fuse_conn_info *, fuse_config *cfg)
	{
		cfg->kernel_cache = 1;
		return NULL;
	}

	static int getattr(char const* path, struct stat *stbuf, fuse_file_info*)
	{
		memset(stbuf, 0, sizeof(*stbuf));
		update_stat(stbuf);

		if (""/""sv == path) {
			stbuf->st_mode = S_IFDIR | 0755;
			stbuf->st_nlink = 2;
			return 0;
		}

		std::string_view p = path+1;

		if (auto split = p.find('/'); split != std::string_view::npos) {
			auto const section    = p.substr(0, split);
			auto const target_key = p.substr(split + 1);
			if (auto const key = std::find(ini.section_keys(section), {}, target_key); key) {
				stbuf->st_mode = S_IFREG | 0644;
				stbuf->st_nlink = 1;
				stbuf->st_size = key.value().size();
				return 0;
			}
			return -ENOENT;
		}

		if (auto section = ini.sections(); section && (section = std::find(section, {}, p))) {
			stbuf->st_mode = S_IFDIR | 0755;
			stbuf->st_nlink = 2;
			return 0;
		}
		if (auto key = ini.section_keys(); key && (key = std::find(key, {}, p))) {
			stbuf->st_mode = S_IFREG | 0644;
			stbuf->st_nlink = 1;
			stbuf->st_size = key.value().size();
			return 0;
		}

		return -ENOENT;
	}

	static int readdir(
			char const* path, void *buf,
			fuse_fill_dir_t filler,
			off_t,
			fuse_file_info*,
			fuse_readdir_flags)
	{
		filler(buf, ""."", NULL, 0, {});
		filler(buf, "".."", NULL, 0, {});
		if (path == ""/""sv) {
			for (auto section = ini.sections(); section; ++section) {
				filler(buf, section->c_str(), NULL, 0, {});
			}
			for (auto key = ini.section_keys(); key; ++key) {
				filler(buf, key->c_str(), NULL, 0, {});
			}
			return 0;
		}

		bool section_found = false;
		for (auto key = ini.section_keys(path + 1); key; ++key) {
			section_found = true;
			filler(buf, key->c_str(), NULL, 0, {});
		}

		return section_found ? 0 : -ENOENT;
	}

	static int open(char const* path, fuse_file_info *fi)
	{
		auto const p = std::string_view(path + 1);
		auto const split = p.find('/');

		if (!std::find(ini.section_keys(split == std::string_view::npos ? """" : p.substr(0, split)), {}, p.substr(split + 1)))
			return -ENOENT;

		if ((fi->flags & O_ACCMODE) != O_RDONLY)
			return -EACCES;

		return 0;
	}

	static int read(char const* path, char *buf, size_t size, off_t offset, fuse_file_info *)
	{
		auto const p = std::string_view(path + 1);
		auto const split = p.find('/');

		if (auto key = std::find(ini.section_keys(split == std::string_view::npos ? """" : p.substr(0, split)), {}, p.substr(split + 1));
				key) {
			auto const data = key.value().data();
			auto const len = key.value().size();
			if ((unsigned)offset < len) {
				if (offset + size > len)
					size = len - offset;
				memcpy(buf, data + offset, size);
			} else {
				size = 0;
			}
		} else {
			return -ENOENT;
		}

		return size;
	}

	static int mkdir(char const* path, mode_t mode)
	{
#ifdef Debug_Mode
		std::cerr << ""mkdir("" << std::quoted(path) << "", "" << std::oct << mode << "")\n"";
#else
		(void)mode;
#endif
		if (path == ""/""sv)
			return -EEXIST;

		auto const p = std::string_view(path+1);
		if (p.find_first_of(""/[]"") != std::string_view::npos)
			return -EINVAL;

		auto &new_node = ini.nodes.emplace_back();
		new_node.kind = INI::Node::Kind::Section;
		new_node.value = p;
		return 0;
	}

	static int rmdir(char const* path)
	{
#ifdef Debug_Mode
		std::cerr << ""rmdir("" << std::quoted(path) << "")\n"";
#endif

		if (path == ""/""sv)
			return -ENOTEMPTY;

		if (auto section = ini.sections(); section && (section = std::find(section, {}, path + 1))) {
			if (auto next = std::next(section); next ? next.node().kind == INI::Node::Kind::Section : 1) {
				ini.nodes.erase(ini.nodes.cbegin() + section.i);
				return 0;
			}
			return -ENOTEMPTY;
		}

		return -ENOTDIR;
	}

	int rename(char const* src, char const* dst, unsigned int flags)
	{
#ifdef Debug_Mode
		std::cerr << ""rename("" << std::quoted(src) << "", "" << std::quoted(dst) << "", "" << flags << "")\n"";
#endif

		if (dst == ""/""sv || src == ""/""sv)
			return -EPERM;

		auto const s = std::string_view(src+1);
		auto const d = std::string_view(dst+1);

		auto const s_split = s.find('/');
		auto const  [MASK]  = d.find('/');

		if (s_split == std::string_view::npos &&  [MASK]  == std::string_view::npos) {
			if (d.find_first_of(""[]"") != std::string_view::npos) {
				return -EINVAL;
			}
			if (auto s_sec = ini.sections(); s_sec && (s_sec = std::find(s_sec, {}, s))) {
				if (auto d_sec = ini.sections(); d_sec && (d_sec = std::find(d_sec, {}, d))) {
					switch (flags) {
					case RENAME_EXCHANGE:
						std::swap(ini.nodes[s_sec.i].value, ini.nodes[d_sec.i].value);
						return 0;
					case RENAME_NOREPLACE:
						return -EEXIST;
					}

					if (auto d_next = std::next(d_sec); d_next ? d_next.node().kind == INI::Node::Kind::Section : 1) {
						ini.nodes.erase(ini.nodes.cbegin() + d_sec.i);
						return 0;
					}
					return -ENOTEMPTY;
				}

				ini.nodes[s_sec.i].value = d;
				return 0;
			}
			return -EEXIST;
		} else {
			return -ENOSYS;
		}
	}
}

int main(int argc, char **argv)
{
	fuse_operations oper = {};
	oper.getattr = inifs::getattr;
	oper.init    = inifs::init;
	oper.mkdir   = inifs::mkdir;
	oper.open    = inifs::open;
	oper.read    = inifs::read;
	oper.readdir = inifs::readdir;
	oper.rename  = inifs::rename;
	oper.rmdir   = inifs::rmdir;

	fuse_args args = FUSE_ARGS_INIT(argc, argv);
	if (fuse_opt_parse(&args, &options, option_spec, nullptr) == -1)
		return 1;

	if (!options.ini_filename) {
		std::cerr << ""inifs: no INI file was provided\n"";
		return 2;
	}

	if (auto maybe_ini = INI::from_file(options.ini_filename); maybe_ini) {
		ini = *std::move(maybe_ini);
	} else {
		std::cerr << ""inifs: invalid INI file\n"";
		return 3;
	}

	lstat(options.ini_filename, &ini_stat);

	auto ret = fuse_main(args.argc, args.argv, &oper, nullptr);
	fuse_opt_free_args(&args);
	return ret;
}
",d_split
337,"#include <stdio.h>
#include <string.h>
#include ""windows.h""
#include <time.h>
#include <array>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <format>
#include <iostream>
#include <random>
#include <string>
#include <thread>
#include <vector>
#include <sstream>
#include <sys/timeb.h>

using namespace std;

string name = ""Rapfox"";
#define MAX_DEPTH 100
#define MAX_SCORE 50000

#define MONTH (\
  __DATE__ [2] == 'n' ? (__DATE__ [1] == 'a' ? ""01"" : ""06"") \
: __DATE__ [2] == 'b' ? ""02"" \
: __DATE__ [2] == 'r' ? (__DATE__ [0] == 'M' ? ""03"" : ""04"") \
: __DATE__ [2] == 'y' ? ""05"" \
: __DATE__ [2] == 'l' ? ""07"" \
: __DATE__ [2] == 'g' ? ""08"" \
: __DATE__ [2] == 'p' ? ""09"" \
: __DATE__ [2] == 't' ? ""10"" \
: __DATE__ [2] == 'v' ? ""11"" \
: ""12"")
#define DAY (std::string(1,(__DATE__[4] == ' ' ?  '0' : (__DATE__[4]))) + (__DATE__[5]))
#define YEAR ((__DATE__[7]-'0') * 1000 + (__DATE__[8]-'0') * 100 + (__DATE__[9]-'0') * 10 + (__DATE__[10]-'0') * 1)


static void PrintWelcome() {
	cout << name << "" "" << YEAR << ""-"" << MONTH << ""-"" << DAY << endl;
}

// FEN dedug positions
#define defFen ""rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 ""
#define tricky_position ""r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1 ""
#define killer_position ""rnbqkb1r/pp1p1pPp/8/2p1pP2/1P1P4/3P3P/P1P1P3/RNBQKBNR w KQkq e6 0 1""
#define cmk_position ""r2q1rk1/ppp2ppp/2n1bn2/2b1p3/3pP3/3P1NPP/PPP1NPB1/R1BQ1RK1 b - - 0 9 ""

// piece encoding
enum pieces { e, P, N, B, R, Q, K, p, n, b, r, q, k, o };

// square encoding
enum squares {
	a8 = 0, b8, c8, d8, e8, f8, g8, h8,
	a7 = 16, b7, c7, d7, e7, f7, g7, h7,
	a6 = 32, b6, c6, d6, e6, f6, g6, h6,
	a5 = 48, b5, c5, d5, e5, f5, g5, h5,
	a4 = 64, b4, c4, d4, e4, f4, g4, h4,
	a3 = 80, b3, c3, d3, e3, f3, g3, h3,
	a2 = 96, b2, c2, d2, e2, f2, g2, h2,
	a1 = 112, b1, c1, d1, e1, f1, g1, h1, no_sq
};

// capture flags
enum capture_flags { all_moves, only_captures };

// castling binary representation
//
//  bin  dec
// 0001    1  white king can castle to the king side
// 0010    2  white king can castle to the queen side
// 0100    4  black king can castle to the king side
// 1000    8  black king can castle to the queen side
//
// examples
// 1111       both sides an castle both directions
// 1001       black king => queen side
//            white king => king side

// castling writes
enum castling { KC = 1, QC = 2, kc = 4, qc = 8 };

// sides to move
enum sides { white, black };

// ascii pieces
string pieces = "".PNBRQKpnbrqk"";
string promoted_pieces = ""  nbrq  nbrq  "";

void UciCommand(string str);

static int CharToPiece(char c) {
	return pieces.find(c);
}

static char PieceToChar(int p) {
	return pieces[p];
}

static char PieceToPromotion(int p) {
	char c = promoted_pieces[p];
	//if (c == ' ') return '\0';
	return c;
}

int material_score[13] = {
	  0,      // empty square score
	100,      // white pawn score
	310,      // white knight score
	320,      // white bishop score
	500,      // white rook score
   900,      // white queen score
  10000,      // white king score
   -100,      // black pawn score
   -310,      // black knight score
   -320,      // black bishop score
   -500,      // black rook score
  -900,      // black queen score
 -10000,      // black king score

};

// castling rights

/*
							 castle   move     in      in
							  right    map     binary  decimal

		white king  moved:     1111 & 1100  =  1100    12
  white king's rook moved:     1111 & 1110  =  1110    14
 white queen's rook moved:     1111 & 1101  =  1101    13

		 black king moved:     1111 & 0011  =  1011    3
  black king's rook moved:     1111 & 1011  =  1011    11
 black queen's rook moved:     1111 & 0111  =  0111    7

*/

int castling_rights[128] = {
	 7, 15, 15, 15,  3, 15, 15, 11,  o, o, o, o, o, o, o, o,
	15, 15, 15, 15, 15, 15, 15, 15,  o, o, o, o, o, o, o, o,
	15, 15, 15, 15, 15, 15, 15, 15,  o, o, o, o, o, o, o, o,
	15, 15, 15, 15, 15, 15, 15, 15,  o, o, o, o, o, o, o, o,
	15, 15, 15, 15, 15, 15, 15, 15,  o, o, o, o, o, o, o, o,
	15, 15, 15, 15, 15, 15, 15, 15,  o, o, o, o, o, o, o, o,
	15, 15, 15, 15, 15, 15, 15, 15,  o, o, o, o, o, o, o, o,
	13, 15, 15, 15, 12, 15, 15, 14,  o, o, o, o, o, o, o, o
};

// pawn positional score
const int pawn_score[128] =
{
	90,  90,  90,  90,  90,  90,  90,  90,    o, o, o, o, o, o, o, o,
	30,  30,  30,  40,  40,  30,  30,  30,    o, o, o, o, o, o, o, o,
	20,  20,  20,  30,  30,  30,  20,  20,    o, o, o, o, o, o, o, o,
	10,  10,  10,  20,  20,  10,  10,  10,    o, o, o, o, o, o, o, o,
	 5,   5,  10,  20,  20,   5,   5,   5,    o, o, o, o, o, o, o, o,
	 0,   0,   0,   5,   5,   0,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   0, -10, -10,   0,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   0,   0,   0,   0,   0,   0,    o, o, o, o, o, o, o, o
};

// knight positional score
const int knight_score[128] =
{
	-5,   0,   0,   0,   0,   0,   0,  -5,    o, o, o, o, o, o, o, o,
	-5,   0,   0,  10,  10,   0,   0,  -5,    o, o, o, o, o, o, o, o,
	-5,   5,  20,  20,  20,  20,   5,  -5,    o, o, o, o, o, o, o, o,
	-5,  10,  20,  30,  30,  20,  10,  -5,    o, o, o, o, o, o, o, o,
	-5,  10,  20,  30,  30,  20,  10,  -5,    o, o, o, o, o, o, o, o,
	-5,   5,  20,  10,  10,  20,   5,  -5,    o, o, o, o, o, o, o, o,
	-5,   0,   0,   0,   0,   0,   0,  -5,    o, o, o, o, o, o, o, o,
	-5, -10,   0,   0,   0,   0, -10,  -5,    o, o, o, o, o, o, o, o
};

// bishop positional score
const int bishop_score[128] =
{
	 0,   0,   0,   0,   0,   0,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   0,   0,   0,   0,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   0,  10,  10,   0,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,  10,  20,  20,  10,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,  10,  20,  20,  10,   0,   0,    o, o, o, o, o, o, o, o,
	 0,  10,   0,   0,   0,   0,  10,   0,    o, o, o, o, o, o, o, o,
	 0,  30,   0,   0,   0,   0,  30,   0,    o, o, o, o, o, o, o, o,
	 0,   0, -10,   0,   0, -10,   0,   0,    o, o, o, o, o, o, o, o

};

// rook positional score
const int rook_score[128] =
{
	50,  50,  50,  50,  50,  50,  50,  50,    o, o, o, o, o, o, o, o,
	50,  50,  50,  50,  50,  50,  50,  50,    o, o, o, o, o, o, o, o,
	 0,   0,  10,  20,  20,  10,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,  10,  20,  20,  10,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,  10,  20,  20,  10,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,  10,  20,  20,  10,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,  10,  20,  20,  10,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   0,  20,  20,   0,   0,   0,    o, o, o, o, o, o, o, o

};

// king positional score
const int king_score[128] =
{
	 0,   0,   0,   0,   0,   0,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   5,   5,   5,   5,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   5,   5,  10,  10,   5,   5,   0,    o, o, o, o, o, o, o, o,
	 0,   5,  10,  20,  20,  10,   5,   0,    o, o, o, o, o, o, o, o,
	 0,   5,  10,  20,  20,  10,   5,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   5,  10,  10,   5,   0,   0,    o, o, o, o, o, o, o, o,
	 0,   5,   5,  -5,  -5,   0,   5,   0,    o, o, o, o, o, o, o, o,
	 0,   0,   5,   0, -15,   0,  10,   0,    o, o, o, o, o, o, o, o

};

// mirror positional score tables for opposite side
const int mirror_score[128] =
{
	a1, b1, c1, d1, e1, f1, g1, h1,    o, o, o, o, o, o, o, o,
	a2, b2, c2, d2, e2, f2, g2, h2,    o, o, o, o, o, o, o, o,
	a3, b3, c3, d3, e3, f3, g3, h3,    o, o, o, o, o, o, o, o,
	a4, b4, c4, d4, e4, f4, g4, h4,    o, o, o, o, o, o, o, o,
	a5, b5, c5, d5, e5, f5, g5, h5,    o, o, o, o, o, o, o, o,
	a6, b6, c6, d6, e6, f6, g6, h6,    o, o, o, o, o, o, o, o,
	a7, b7, c7, d7, e7, f7, g7, h7,    o, o, o, o, o, o, o, o,
	a8, b8, c8, d8, e8, f8, g8, h8,    o, o, o, o, o, o, o, o
};

// chess board representation
int board[128] = {
	r, n, b, q, k, b, n, r,  o, o, o, o, o, o, o, o,
	p, p, p, p, p, p, p, p,  o, o, o, o, o, o, o, o,
	e, e, e, e, e, e, e, e,  o, o, o, o, o, o, o, o,
	e, e, e, e, e, e, e, e,  o, o, o, o, o, o, o, o,
	e, e, e, e, e, e, e, e,  o, o, o, o, o, o, o, o,
	e, e, e, e, e, e, e, e,  o, o, o, o, o, o, o, o,
	P, P, P, P, P, P, P, P,  o, o, o, o, o, o, o, o,
	R, N, B, Q, K, B, N, R,  o, o, o, o, o, o, o, o
};

// side to move
int side = white;

// enpassant square
int enpassant = no_sq;

// castling rights (dec 15 => bin 1111 => both kings can castle to both sides)
int castle = 15;

// kings' squares
int king_square[2] = { e1, e8 };

/*
	Move formatting

	0000 0000 0000 0000 0111 1111       source square
	0000 0000 0011 1111 1000 0000       target square
	0000 0011 1100 0000 0000 0000       promoted piece
	0000 0100 0000 0000 0000 0000       capture flag
	0000 1000 0000 0000 0000 0000       double pawn flag
	0001 0000 0000 0000 0000 0000       enpassant flag
	0010 0000 0000 0000 0000 0000       castling

*/

// encode move
#define encode_move(source, target, piece, capture, pawn, enpassant, castling) \
(                          \
    (source) |             \
    (target << 7) |        \
    (piece << 14) |        \
    (capture << 18) |      \
    (pawn << 19) |         \
    (enpassant << 20) |    \
    (castling << 21)       \
)

// decode move's source square
#define get_move_source(move) (move & 0x7f)

// decode move's target square
#define get_move_target(move) ((move >> 7) & 0x7f)

// decode move's promoted piece
#define get_move_piece(move) ((move >> 14) & 0xf)

// decode move's capture flag
#define get_move_capture(move) ((move >> 18) & 0x1)

// decode move's double pawn push flag
#define get_move_pawn(move) ((move >> 19) & 0x1)

// decode move's enpassant flag
#define get_move_enpassant(move) ((move >> 20) & 0x1)

// decode move's castling flag
#define get_move_castling(move) ((move >> 21) & 0x1)

// convert board square indexes to coordinates
char* square_to_coords[] = {
	""a8"", ""b8"", ""c8"", ""d8"", ""e8"", ""f8"", ""g8"", ""h8"", ""i8"", ""j8"", ""k8"", ""l8"", ""m8"", ""n8"", ""o8"", ""p8"",
	""a7"", ""b7"", ""c7"", ""d7"", ""e7"", ""f7"", ""g7"", ""h7"", ""i7"", ""j7"", ""k7"", ""l7"", ""m7"", ""n7"", ""o7"", ""p7"",
	""a6"", ""b6"", ""c6"", ""d6"", ""e6"", ""f6"", ""g6"", ""h6"", ""i6"", ""j6"", ""k6"", ""l6"", ""m6"", ""n6"", ""o6"", ""p6"",
	""a5"", ""b5"", ""c5"", ""d5"", ""e5"", ""f5"", ""g5"", ""h5"", ""i5"", ""j5"", ""k5"", ""l5"", ""m5"", ""n5"", ""o5"", ""p5"",
	""a4"", ""b4"", ""c4"", ""d4"", ""e4"", ""f4"", ""g4"", ""h4"", ""i4"", ""j4"", ""k4"", ""l4"", ""m4"", ""n4"", ""o4"", ""p4"",
	""a3"", ""b3"", ""c3"", ""d3"", ""e3"", ""f3"", ""g3"", ""h3"", ""i3"", ""j3"", ""k3"", ""l3"", ""m3"", ""n3"", ""o3"", ""p3"",
	""a2"", ""b2"", ""c2"", ""d2"", ""e2"", ""f2"", ""g2"", ""h2"", ""i2"", ""j2"", ""k2"", ""l2"", ""m2"", ""n2"", ""o2"", ""p2"",
	""a1"", ""b1"", ""c1"", ""d1"", ""e1"", ""f1"", ""g1"", ""h1"", ""i1"", ""j1"", ""k1"", ""l1"", ""m1"", ""n1"", ""o1"", ""p1""
};

// piece move offsets
int knight_offsets[8] = { 33, 31, 18, 14, -33, -31, -18, -14 };
int bishop_offsets[4] = { 15, 17, -15, -17 };
int rook_offsets[4] = { 16, -16, 1, -1 };
int king_offsets[8] = { 16, -16, 1, -1, 15, 17, -15, -17 };

// move list structure
typedef struct {
	// move list
	int moves[256];

	// move count
	int count;
} moves;

/* get_ms() returns the milliseconds elapsed since midnight,
   January 1, 1970. */
int get_time_ms() {
	struct timeb timebuffer;
	ftime(&timebuffer);
	return (timebuffer.time * 1000) + timebuffer.millitm;
}

static vector<string> SplitString(string s) {
	vector<string>  [MASK] ;
	istringstream iss(s);
	string word;
	while (iss >> word)
		 [MASK] .push_back(word);
	return  [MASK] ;
}

static int GetInt(vector<string> vs, string name, int def) {
	bool r = false;
	for (string s : vs) {
		if (r) return stoi(s);
		r = s == name;
	}
	return def;
}

static void PrintBoard() {
	for (int rank = 0; rank < 8; rank++)
	{
		// loop over board files
		for (int file = 0; file < 16; file++)
		{
			// init square
			int square = rank * 16 + file;

			// print ranks
			if (file == 0)
				printf("" %d  "", 8 - rank);

			// if square is on board
			if (!(square & 0x88))
				printf(""%c "", pieces[board[square]]);
		}
		cout << endl;
	}

	// print files
	cout << ""    a b c d e f g h"" << endl;

	// print board stats
	printf(""    Side:     %s\n"", (side == white) ? ""white"" : ""black"");
	printf(""    Castling:  %c%c%c%c\n"", (castle & KC) ? 'K' : '-',
		(castle & QC) ? 'Q' : '-',
		(castle & kc) ? 'k' : '-',
		(castle & qc) ? 'q' : '-');
	printf(""    Enpassant:   %s\n"", (enpassant == no_sq) ? ""no"" : square_to_coords[enpassant]);
	printf(""    King square: %s\n\n"", square_to_coords[king_square[side]]);
}

// reset board
static void ResetBoard() {
	for (int rank = 0; rank < 8; rank++) {
		for (int file = 0; file < 16; file++) {
			int square = rank * 16 + file;

			// if square is on board
			if (!(square & 0x88))
				// reset current board square
				board[square] = e;
		}
	}
	side = white;
	castle = 0;
	enpassant = no_sq;
}




/***********************************************\

			 MOVE GENERATOR FUNCTIONS

\***********************************************/

// is square attacked
static inline int is_square_attacked(int square, int side)
{
	// pawn attacks
	if (!side)
	{
		// if target square is on board and is white pawn
		if (!((square + 17) & 0x88) && (board[square + 17] == P))
			return 1;

		// if target square is on board and is white pawn
		if (!((square + 15) & 0x88) && (board[square + 15] == P))
			return 1;
	}

	else
	{
		// if target square is on board and is black pawn
		if (!((square - 17) & 0x88) && (board[square - 17] == p))
			return 1;

		// if target square is on board and is black pawn
		if (!((square - 15) & 0x88) && (board[square - 15] == p))
			return 1;
	}

	// knight attacks
	for (int index = 0; index < 8; index++)
	{
		// init target square
		int target_square = square + knight_offsets[index];

		// lookup target piece
		int target_piece = board[target_square];

		// if target square is on board
		if (!(target_square & 0x88))
		{
			if (!side ? target_piece == N : target_piece == n)
				return 1;
		}
	}

	// king attacks
	for (int index = 0; index < 8; index++)
	{
		// init target square
		int target_square = square + king_offsets[index];

		// lookup target piece
		int target_piece = board[target_square];

		// if target square is on board
		if (!(target_square & 0x88))
		{
			// if target piece is either white or black king
			if (!side ? target_piece == K : target_piece == k)
				return 1;
		}
	}

	// bishop & queen attacks
	for (int index = 0; index < 4; index++)
	{
		// init target square
		int target_square = square + bishop_offsets[index];

		// loop over attack ray
		while (!(target_square & 0x88))
		{
			// target piece
			int target_piece = board[target_square];

			// if target piece is either white or black bishop or queen
			if (!side ? (target_piece == B || target_piece == Q) : (target_piece == b || target_piece == q))
				return 1;

			// break if hit a piece
			if (target_piece)
				break;

			// increment target square by move offset
			target_square += bishop_offsets[index];
		}
	}

	// rook & queen attacks
	for (int index = 0; index < 4; index++)
	{
		// init target square
		int target_square = square + rook_offsets[index];

		// loop over attack ray
		while (!(target_square & 0x88))
		{
			// target piece
			int target_piece = board[target_square];

			// if target piece is either white or black bishop or queen
			if (!side ? (target_piece == R || target_piece == Q) : (target_piece == r || target_piece == q))
				return 1;

			// break if hit a piece
			if (target_piece)
				break;

			// increment target square by move offset
			target_square += rook_offsets[index];
		}
	}

	return 0;
}

// print attack map
static void PrintAttackedSquares(int side) {
	printf(""\n"");
	printf(""    Attacking side: %s\n\n"", !side ? ""white"" : ""black"");

	// loop over board ranks
	for (int rank = 0; rank < 8; rank++)
	{
		// loop over board files
		for (int file = 0; file < 16; file++)
		{
			// init square
			int square = rank * 16 + file;

			// print ranks
			if (file == 0)
				printf("" %d  "", 8 - rank);

			// if square is on board
			if (!(square & 0x88))
				printf(""%c "", is_square_attacked(square, side) ? 'x' : '.');

		}

		// print new line every time new rank is encountered
		printf(""\n"");
	}

	printf(""\n    a b c d e f g h\n\n"");
}

// populate move list
static inline void add_move(moves* move_list, int move)
{
	// push move into the move list
	move_list->moves[move_list->count] = move;

	// increment move count
	move_list->count++;
}


// move generator
static inline void generate_moves(moves* move_list)
{
	// reset move count
	move_list->count = 0;

	// loop over all board squares
	for (int square = 0; square < 128; square++)
	{
		// check if the square is on board
		if (!(square & 0x88))
		{
			// white pawn and castling moves
			if (!side)
			{
				// white pawn moves
				if (board[square] == P)
				{
					// init target square
					int to_square = square - 16;

					// quite white pawn moves (check if target square is on board)
					if (!(to_square & 0x88) && !board[to_square])
					{
						// pawn promotions
						if (square >= a7 && square <= h7)
						{
							add_move(move_list, encode_move(square, to_square, Q, 0, 0, 0, 0));
							add_move(move_list, encode_move(square, to_square, R, 0, 0, 0, 0));
							add_move(move_list, encode_move(square, to_square, B, 0, 0, 0, 0));
							add_move(move_list, encode_move(square, to_square, N, 0, 0, 0, 0));
						}

						else
						{
							// one square ahead pawn move
							add_move(move_list, encode_move(square, to_square, 0, 0, 0, 0, 0));

							// two squares ahead pawn move
							if ((square >= a2 && square <= h2) && !board[square - 32])
								add_move(move_list, encode_move(square, square - 32, 0, 0, 1, 0, 0));
						}
					}

					// white pawn capture moves
					for (int index = 0; index < 4; index++)
					{
						// init pawn offset
						int pawn_offset = bishop_offsets[index];

						// white pawn offsets
						if (pawn_offset < 0)
						{
							// init target square
							int to_square = square + pawn_offset;

							// check if target square is on board
							if (!(to_square & 0x88))
							{
								// capture pawn promotion
								if (
									(square >= a7 && square <= h7) &&
									(board[to_square] >= 7 && board[to_square] <= 12)
									)
								{
									add_move(move_list, encode_move(square, to_square, Q, 1, 0, 0, 0));
									add_move(move_list, encode_move(square, to_square, R, 1, 0, 0, 0));
									add_move(move_list, encode_move(square, to_square, B, 1, 0, 0, 0));
									add_move(move_list, encode_move(square, to_square, N, 1, 0, 0, 0));
								}

								else
								{
									// casual capture
									if (board[to_square] >= 7 && board[to_square] <= 12)
										add_move(move_list, encode_move(square, to_square, 0, 1, 0, 0, 0));

									// enpassant capture
									if (to_square == enpassant)
										add_move(move_list, encode_move(square, to_square, 0, 1, 0, 1, 0));
								}
							}
						}
					}
				}

				// white king castling
				if (board[square] == K)
				{
					// if king side castling is available
					if (castle & KC)
					{
						// make sure there are empty squares between king & rook
						if (!board[f1] && !board[g1])
						{
							// make sure king & next square are not under attack
							if (!is_square_attacked(e1, black) && !is_square_attacked(f1, black))
								add_move(move_list, encode_move(e1, g1, 0, 0, 0, 0, 1));
						}
					}

					// if queen side castling is available
					if (castle & QC)
					{
						// make sure there are empty squares between king & rook
						if (!board[d1] && !board[b1] && !board[c1])
						{
							// make sure king & next square are not under attack
							if (!is_square_attacked(e1, black) && !is_square_attacked(d1, black))
								add_move(move_list, encode_move(e1, c1, 0, 0, 0, 0, 1));
						}
					}
				}
			}

			// black pawn and castling moves
			else
			{
				// black pawn moves
				if (board[square] == p)
				{
					// init target square
					int to_square = square + 16;

					// quite black pawn moves (check if target square is on board)
					if (!(to_square & 0x88) && !board[to_square])
					{
						// pawn promotions
						if (square >= a2 && square <= h2)
						{
							add_move(move_list, encode_move(square, to_square, q, 0, 0, 0, 0));
							add_move(move_list, encode_move(square, to_square, r, 0, 0, 0, 0));
							add_move(move_list, encode_move(square, to_square, b, 0, 0, 0, 0));
							add_move(move_list, encode_move(square, to_square, n, 0, 0, 0, 0));
						}

						else
						{
							// one square ahead pawn move
							add_move(move_list, encode_move(square, to_square, 0, 0, 0, 0, 0));

							// two squares ahead pawn move
							if ((square >= a7 && square <= h7) && !board[square + 32])
								add_move(move_list, encode_move(square, square + 32, 0, 0, 1, 0, 0));
						}
					}

					// black pawn capture moves
					for (int index = 0; index < 4; index++)
					{
						// init pawn offset
						int pawn_offset = bishop_offsets[index];

						// white pawn offsets
						if (pawn_offset > 0)
						{
							// init target square
							int to_square = square + pawn_offset;

							// check if target square is on board
							if (!(to_square & 0x88))
							{
								// capture pawn promotion
								if (
									(square >= a2 && square <= h2) &&
									(board[to_square] >= 1 && board[to_square] <= 6)
									)
								{
									add_move(move_list, encode_move(square, to_square, q, 1, 0, 0, 0));
									add_move(move_list, encode_move(square, to_square, r, 1, 0, 0, 0));
									add_move(move_list, encode_move(square, to_square, b, 1, 0, 0, 0));
									add_move(move_list, encode_move(square, to_square, n, 1, 0, 0, 0));
								}

								else
								{
									// casual capture
									if (board[to_square] >= 1 && board[to_square] <= 6)
										add_move(move_list, encode_move(square, to_square, 0, 1, 0, 0, 0));

									// enpassant capture
									if (to_square == enpassant)
										add_move(move_list, encode_move(square, to_square, 0, 1, 0, 1, 0));
								}
							}
						}
					}
				}

				// black king castling
				if (board[square] == k)
				{
					// if king side castling is available
					if (castle & kc)
					{
						// make sure there are empty squares between king & rook
						if (!board[f8] && !board[g8])
						{
							// make sure king & next square are not under attack
							if (!is_square_attacked(e8, white) && !is_square_attacked(f8, white))
								add_move(move_list, encode_move(e8, g8, 0, 0, 0, 0, 1));
						}
					}

					// if queen side castling is available
					if (castle & qc)
					{
						// make sure there are empty squares between king & rook
						if (!board[d8] && !board[b8] && !board[c8])
						{
							// make sure king & next square are not under attack
							if (!is_square_attacked(e8, white) && !is_square_attacked(d8, white))
								add_move(move_list, encode_move(e8, c8, 0, 0, 0, 0, 1));
						}
					}
				}
			}

			// knight moves
			if (!side ? board[square] == N : board[square] == n)
			{
				// loop over knight move offsets
				for (int index = 0; index < 8; index++)
				{
					// init target square
					int to_square = square + knight_offsets[index];

					// init target piece
					int piece = board[to_square];

					// make sure target square is onboard
					if (!(to_square & 0x88))
					{
						//
						if (
							!side ?
							(!piece || (piece >= 7 && piece <= 12)) :
							(!piece || (piece >= 1 && piece <= 6))
							)
						{
							// on capture
							if (piece)
								add_move(move_list, encode_move(square, to_square, 0, 1, 0, 0, 0));

							// on empty square
							else
								add_move(move_list, encode_move(square, to_square, 0, 0, 0, 0, 0));
						}
					}
				}
			}

			// king moves
			if (!side ? board[square] == K : board[square] == k)
			{
				// loop over king move offsets
				for (int index = 0; index < 8; index++)
				{
					// init target square
					int to_square = square + king_offsets[index];

					// init target piece
					int piece = board[to_square];

					// make sure target square is onboard
					if (!(to_square & 0x88))
					{
						//
						if (
							!side ?
							(!piece || (piece >= 7 && piece <= 12)) :
							(!piece || (piece >= 1 && piece <= 6))
							)
						{
							// on capture
							if (piece)
								add_move(move_list, encode_move(square, to_square, 0, 1, 0, 0, 0));

							// on empty square
							else
								add_move(move_list, encode_move(square, to_square, 0, 0, 0, 0, 0));
						}
					}
				}
			}

			// bishop & queen moves
			if (
				!side ?
				(board[square] == B) || (board[square] == Q) :
				(board[square] == b) || (board[square] == q)
				)
			{
				// loop over bishop & queen offsets
				for (int index = 0; index < 4; index++)
				{
					// init target square
					int to_square = square + bishop_offsets[index];

					// loop over attack ray
					while (!(to_square & 0x88))
					{
						// init target piece
						int piece = board[to_square];

						// if hits own piece
						if (!side ? (piece >= 1 && piece <= 6) : ((piece >= 7 && piece <= 12)))
							break;

						// if hits opponent's piece
						if (!side ? (piece >= 7 && piece <= 12) : ((piece >= 1 && piece <= 6)))
						{
							add_move(move_list, encode_move(square, to_square, 0, 1, 0, 0, 0));
							break;
						}

						// if steps into an empty squre
						if (!piece)
							add_move(move_list, encode_move(square, to_square, 0, 0, 0, 0, 0));

						// increment target square
						to_square += bishop_offsets[index];
					}
				}
			}

			// rook & queen moves
			if (
				!side ?
				(board[square] == R) || (board[square] == Q) :
				(board[square] == r) || (board[square] == q)
				)
			{
				// loop over bishop & queen offsets
				for (int index = 0; index < 4; index++)
				{
					// init target square
					int to_square = square + rook_offsets[index];

					// loop over attack ray
					while (!(to_square & 0x88))
					{
						// init target piece
						int piece = board[to_square];

						// if hits own piece
						if (!side ? (piece >= 1 && piece <= 6) : ((piece >= 7 && piece <= 12)))
							break;

						// if hits opponent's piece
						if (!side ? (piece >= 7 && piece <= 12) : ((piece >= 1 && piece <= 6)))
						{
							add_move(move_list, encode_move(square, to_square, 0, 1, 0, 0, 0));
							break;
						}

						// if steps into an empty squre
						if (!piece)
							add_move(move_list, encode_move(square, to_square, 0, 0, 0, 0, 0));

						// increment target square
						to_square += rook_offsets[index];
					}
				}
			}
		}
	}
}

static void PrintMoves()
{
	moves move_list[1];
	generate_moves(move_list);
	printf(""\n    Move     Capture  Double   Enpass   Castling\n\n"");

	// loop over moves in a movelist
	for (int index = 0; index < move_list->count; index++)
	{
		int move = move_list->moves[index];
		printf(""    %s%s"", square_to_coords[get_move_source(move)], square_to_coords[get_move_target(move)]);
		printf(""%c    "", get_move_piece(move) ? promoted_pieces[get_move_piece(move)] : ' ');
		printf(""%d        %d        %d        %d\n"", get_move_capture(move), get_move_pawn(move), get_move_enpassant(move), get_move_castling(move));
	}

	printf(""\n    Total moves: %d\n\n"", move_list->count);
}

// copy/restore board position macros
#define copy_board()                                \
    int board_copy[128], king_square_copy[2];       \
    int side_copy, enpassant_copy, castle_copy;     \
    memcpy(board_copy, board, 512);                 \
    side_copy = side;                               \
    enpassant_copy = enpassant;                     \
    castle_copy = castle;                           \
    memcpy(king_square_copy, king_square,8);        \

#define take_back()                                 \
    memcpy(board, board_copy, 512);                 \
    side = side_copy;                               \
    enpassant = enpassant_copy;                     \
    castle = castle_copy;                           \
    memcpy(king_square, king_square_copy,8);        \

// make move
static inline int MakeMove(int move, int capture_flag)
{
	// quiet move
	if (capture_flag == all_moves)
	{
		// copy board state
		copy_board();

		// parse move
		int from_square = get_move_source(move);
		int to_square = get_move_target(move);
		int promoted_piece = get_move_piece(move);
		int enpass = get_move_enpassant(move);
		int double_push = get_move_pawn(move);
		int castling = get_move_castling(move);

		// move piece
		board[to_square] = board[from_square];
		board[from_square] = e;

		// pawn promotion
		if (promoted_piece)
			board[to_square] = promoted_piece;

		// enpassant capture
		if (enpass)
			!side ? (board[to_square + 16] = e) : (board[to_square - 16] = e);

		// reset enpassant square
		enpassant = no_sq;

		// double pawn push
		if (double_push)
			!side ? (enpassant = to_square + 16) : (enpassant = to_square - 16);

		// castling
		if (castling)
		{
			// switch target square
			switch (to_square) {
				// white castles king side
			case g1:
				board[f1] = board[h1];
				board[h1] = e;
				break;

				// white castles queen side
			case c1:
				board[d1] = board[a1];
				board[a1] = e;
				break;

				// black castles king side
			case g8:
				board[f8] = board[h8];
				board[h8] = e;
				break;

				// black castles queen side
			case c8:
				board[d8] = board[a8];
				board[a8] = e;
				break;
			}
		}

		// update king square
		if (board[to_square] == K || board[to_square] == k)
			king_square[side] = to_square;

		// update castling rights
		castle &= castling_rights[from_square];
		castle &= castling_rights[to_square];

		// change side
		side ^= 1;

		// take move back if king is under the check
		if (is_square_attacked(!side ? king_square[side ^ 1] : king_square[side ^ 1], side))
		{
			// restore board state
			take_back();

			// illegal move
			return 0;
		}

		else
			// legal move
			return 1;
	}
	else
	{
		// if move is a capture
		if (get_move_capture(move))
			// make capture move
			MakeMove(move, all_moves);

		else
			// move is not a capture
			return 0;
	}
}


/***********************************************\

				  PERFT FUNCTIONS

\***********************************************/

// count nodes
long nodes = 0;

// perft driver
static inline void perft_driver(int depth)
{
	// escape condition
	if (!depth)
	{
		// count current position
		nodes++;
		return;
	}

	// create move list variable
	moves move_list[1];

	// generate moves
	generate_moves(move_list);

	// loop over the generated moves
	for (int move_count = 0; move_count < move_list->count; move_count++)
	{
		// copy board state
		copy_board();

		// make only legal moves
		if (!MakeMove(move_list->moves[move_count], all_moves))
			// skip illegal move
			continue;

		// recursive call
		perft_driver(depth - 1);

		// restore board state
		take_back();
	}
}

// perft test
static inline void PerftTest(int depth)
{
	printf(""\n    Performance test:\n\n"");

	// init start time
	int start_time = get_time_ms();

	// create move list variable
	moves move_list[1];

	// generate moves
	generate_moves(move_list);

	// loop over the generated moves
	for (int move_count = 0; move_count < move_list->count; move_count++)
	{
		// copy board state
		copy_board();

		// make only legal moves
		if (!MakeMove(move_list->moves[move_count], all_moves))
			// skip illegal move
			continue;

		// cummulative nodes
		long cum_nodes = nodes;

		// recursive call
		perft_driver(depth - 1);

		// old nodes
		long old_nodes = nodes - cum_nodes;

		// restore board state
		take_back();

		// print current move
		printf(""    move %d: %s%s%c    %ld\n"",
			move_count + 1,
			square_to_coords[get_move_source(move_list->moves[move_count])],
			square_to_coords[get_move_target(move_list->moves[move_count])],
			promoted_pieces[get_move_piece(move_list->moves[move_count])],
			old_nodes
		);
	}

	// print results
	printf(""\n    Depth: %d"", depth);
	printf(""\n    Nodes: %ld"", nodes);
	printf(""\n     Time: %d ms\n\n"", get_time_ms() - start_time);
}


/***********************************************\

			   EVALUATION FUNCTION

\***********************************************/

// evaluation of the position
static inline int evaluate_position()
{
	// init score
	int score = 0;

	// loop over board squares
	for (int square = 0; square < 128; square++)
	{
		// make sure square is on board
		if (!(square & 0x88))
		{
			// init piece
			int piece = board[square];

			// material score evaluation
			score += material_score[piece];

			// pieces evaluation
			switch (piece)
			{
				// white pieces
			case P:
				// positional score
				score += pawn_score[square];

				// double panws penalty
				if (board[square - 16] == P)
					score -= 100;

				break;

			case N: score += knight_score[square]; break;
			case B: score += bishop_score[square]; break;
			case R: score += rook_score[square]; break;
			case K: score += king_score[square]; break;

				// black pieces
			case p:
				// positional score
				score -= pawn_score[mirror_score[square]];

				// double pawns penalty
				if (board[square + 16] == p)
					score += 100;

				break;
			case n: score -= knight_score[mirror_score[square]]; break;
			case b: score -= bishop_score[mirror_score[square]]; break;
			case r: score -= rook_score[mirror_score[square]]; break;
			case k: score -= king_score[mirror_score[square]]; break;
			}

		}
	}

	// return positive score for white & negative for black
	return !side ? score : -score;
}


/***********************************************\

				 SEARCH FUNCTIONS

\***********************************************/

// most valuable victim & less valuable attacker

/*

	(Victims) Pawn Knight Bishop   Rook  Queen   King
  (Attackers)
		Pawn   105    205    305    405    505    605
	  Knight   104    204    304    404    504    604
	  Bishop   103    203    303    403    503    603
		Rook   102    202    302    402    502    602
	   Queen   101    201    301    401    501    601
		King   100    200    300    400    500    600

*/

static int mvv_lva[13][13] = {
	0,   0,   0,   0,   0,   0,   0,  0,   0,   0,   0,   0,   0,
	0, 105, 205, 305, 405, 505, 605,  105, 205, 305, 405, 505, 605,
	0, 104, 204, 304, 404, 504, 604,  104, 204, 304, 404, 504, 604,
	0, 103, 203, 303, 403, 503, 603,  103, 203, 303, 403, 503, 603,
	0, 102, 202, 302, 402, 502, 602,  102, 202, 302, 402, 502, 602,
	0, 101, 201, 301, 401, 501, 601,  101, 201, 301, 401, 501, 601,
	0, 100, 200, 300, 400, 500, 600,  100, 200, 300, 400, 500, 600,

	0, 105, 205, 305, 405, 505, 605,  105, 205, 305, 405, 505, 605,
	0, 104, 204, 304, 404, 504, 604,  104, 204, 304, 404, 504, 604,
	0, 103, 203, 303, 403, 503, 603,  103, 203, 303, 403, 503, 603,
	0, 102, 202, 302, 402, 502, 602,  102, 202, 302, 402, 502, 602,
	0, 101, 201, 301, 401, 501, 601,  101, 201, 301, 401, 501, 601,
	0, 100, 200, 300, 400, 500, 600,  100, 200, 300, 400, 500, 600
};

// killer moves [id][ply]
int killer_moves[2][64];

// history moves [piece][square]
int history_moves[13][128];

// PV moves
int pv_table[64][64];
int pv_length[64];

// half move
int ply = 0;

// score move for move ordering
static inline int score_move(int move){
	if (pv_table[0][ply] == move)
		// score 20000 ( search it first )
		return 20000;

	// init current move score
	int score;

	// score MVV LVA (scores 0 for quiete moves)
	score = mvv_lva[board[get_move_source(move)]][board[get_move_target(move)]];

	// on capture
	if (get_move_capture(move))
	{
		// add 10000 to current score
		score += 10000;
	}

	// on quiete move
	else {
		// on 1st killer move
		if (killer_moves[0][ply] == move)
			// score 9000
			score = 9000;

		// on 2nd killer move
		else if (killer_moves[1][ply] == move)
			// score 8000
			score = 8000;

		// on history move (previous alpha's best score)
		else
			// score with history depth
			score = history_moves[board[get_move_source(move)]][get_move_target(move)] + 7000;
	}

	// return move score
	return score;
}

static inline void sort_moves(moves* move_list)
{
	int move_scores[0xff];

	// init move scores array
	for (int count = 0; count < move_list->count; count++)
		// score move
		move_scores[count] = score_move(move_list->moves[count]);

	// loop over current move score
	for (int current = 0; current < move_list->count; current++)
	{
		// loop over next move score
		for (int next = current + 1; next < move_list->count; next++)
		{
			// order moves descending
			if (move_scores[current] < move_scores[next])
			{
				// swap scores
				int temp_score = move_scores[current];
				move_scores[current] = move_scores[next];
				move_scores[next] = temp_score;

				// swap corresponding moves
				int temp_move = move_list->moves[current];
				move_list->moves[current] = move_list->moves[next];
				move_list->moves[next] = temp_move;
			}
		}
	}
}
#define NODE_CHECK 9000
bool stop = false;
int g_max_depth = 0;
long nodeCheck = NODE_CHECK;
clock_t start_time=0;
clock_t g_max_time = 0;

// quiescence search
static inline int SearchQuiescence(int alpha, int beta, int depth){
	if (++nodes > nodeCheck)
	{
		nodeCheck = nodes + NODE_CHECK;
		stop = clock() - start_time > g_max_time;
	}
	if (stop)
		return 0;
	int eval = evaluate_position();
	if (eval >= beta)
		return beta;
	if (eval > alpha)
		alpha = eval;

	// create move list variable
	moves move_list[1];

	// generate moves
	generate_moves(move_list);

	// move ordering
	sort_moves(move_list);

	// loop over the generated moves
	for (int count = 0; count < move_list->count; count++)
	{
		// copy board state
		copy_board();

		// increment ply
		ply++;

		// make only legal moves
		if (!MakeMove(move_list->moves[count], only_captures))
		{
			// decrement ply
			ply--;

			// skip illegal move
			continue;
		}

		// recursive call
		int score = -SearchQuiescence(-beta, -alpha, depth);

		// restore board state
		take_back();

		// decrement ply
		ply--;

		//  fail hard beta-cutoff
		if (score >= beta)
			return beta;

		// alpha acts like max in MiniMax
		if (score > alpha)
			alpha = score;
	}

	// return alpha score
	return alpha;
}

// negamax search
static inline int SearchAlpha(int alpha, int beta, int depth)
{
	int legal_moves = 0;

	// best move
	int best_so_far = 0;

	// old alpha
	int old_alpha = alpha;

	// PV length
	pv_length[ply] = ply;

	// escape condition
	if (!depth)
		// search for calm position before evaluation
		return SearchQuiescence(alpha, beta, depth);

	if (++nodes > nodeCheck)
	{
		nodeCheck = nodes + NODE_CHECK;
		stop = clock() - start_time > g_max_time;
	}
	if (stop)
		return 0;

	// is king in check?
	int in_check = is_square_attacked(king_square[side], side ^ 1);

	// increase depth if king is in check
	if (in_check)
		depth++;

	// create move list variable
	moves move_list[1];

	// generate moves
	generate_moves(move_list);

	// move ordering
	sort_moves(move_list);

	// loop over the generated moves
	for (int count = 0; count < move_list->count; count++)
	{
		// copy board state
		copy_board();

		// increment ply
		ply++;

		// make only legal moves
		if (!MakeMove(move_list->moves[count], all_moves))
		{
			// decrement ply
			ply--;

			// skip illegal move
			continue;
		}

		// increment legal moves
		legal_moves++;

		// recursive call
		int score = -SearchAlpha(-beta, -alpha, depth - 1);

		// restore board state
		take_back();

		// decrement ply
		ply--;

		//  fail hard beta-cutoff
		if (score >= beta)
		{
			// update killer moves
			killer_moves[1][ply] = killer_moves[0][ply];
			killer_moves[0][ply] = move_list->moves[count];

			return beta;
		}

		// alpha acts like max in MiniMax
		if (score > alpha)
		{
			// update history score
			history_moves[board[get_move_source(move_list->moves[count])]][get_move_target(move_list->moves[count])] += depth;

			// set alpha score
			alpha = score;

			// store PV move
			pv_table[ply][ply] = move_list->moves[count];

			for (int i = ply + 1; i < pv_length[ply + 1]; i++)
				pv_table[ply][i] = pv_table[ply + 1][i];

			pv_length[ply] = pv_length[ply + 1];

			// store current best move
			if (!ply)
				best_so_far = move_list->moves[count];
		}
	}
	if (!legal_moves)
	{
		if (in_check)
			return -MAX_SCORE + ply;
		else
			return 0;
	}
	return alpha;
}

// search position
static void SearchIterate(int depth, int time)
{
	// init nodes count
	stop = false;
	nodes = 0;
	nodeCheck = NODE_CHECK;
	start_time = clock();
	// clear PV, killer and history moves
	memset(pv_table, 0, 16384);  // sizeof(pv_table)
	memset(killer_moves, 0, 512);  // sizeof(killer_moves)
	memset(history_moves, 0, 6656);  // sizeof(history_moves)

	// best score
	int score;

	// iterative deepening
	for (int current_depth = 1; current_depth <= depth; current_depth++)
	{
		// search position with current depth 3
		score = SearchAlpha(-MAX_SCORE,MAX_SCORE, current_depth);
		if (stop)
			break;
		clock_t elapsed = clock() - start_time;
		int del = MAX_SCORE - MAX_DEPTH;
		if (score > del)
			cout << ""info score mate "" << (MAX_SCORE - score + 1) / 2 << "" depth "" << current_depth << "" time "" << elapsed << "" nodes "" << nodes << "" pv "";
		else if (score < -del)
			cout << ""info score mate "" << (-MAX_SCORE - score) / 2 << "" depth "" << current_depth << "" time "" << elapsed << "" nodes "" << nodes << "" pv "";
		else
			cout << ""info score cp "" << score << "" depth "" << current_depth << "" time "" << elapsed << "" nodes "" << nodes << "" pv "";
		// output best move
		//printf(""info score cp %d depth %d nodes %ld pv "", score, current_depth, nodes);

		// print PV line
		for (int i = 0; i < pv_length[0]; i++)
		{
			cout << square_to_coords[get_move_source(pv_table[0][i])]
				<< square_to_coords[get_move_target(pv_table[0][i])]
					<< PieceToPromotion(get_move_piece(pv_table[0][i]));
		}
		cout << endl;
		if (elapsed > time / 8)
			break;
	}

	// print best move
	cout << ""bestmove ""
		<< square_to_coords[get_move_source(pv_table[0][0])]
		<< square_to_coords[get_move_target(pv_table[0][0])]
			<< PieceToPromotion(get_move_piece(pv_table[0][0]))
				<< endl;
}


/***********************************************\

			  UCI PROTOCOL FUNCTIONS

\***********************************************/

// parse move (from UCI)
int ParseMove(const char* move_str)
{
	// init move list
	moves move_list[1];

	// generate moves
	generate_moves(move_list);

	// parse move string
	int parse_from = (move_str[0] - 'a') + (8 - (move_str[1] - '0')) * 16;
	int parse_to = (move_str[2] - 'a') + (8 - (move_str[3] - '0')) * 16;
	int prom_piece = 0;

	// init move to encode
	int move;

	// loop over generated moves
	for (int count = 0; count < move_list->count; count++)
	{
		// pick up move
		move = move_list->moves[count];

		// if input move is present in the move list
		if (get_move_source(move) == parse_from && get_move_target(move) == parse_to)
		{
			// init promoted piece
			prom_piece = get_move_piece(move);

			// if promoted piece is present compare it with promoted piece from user input
			if (prom_piece)
			{
				if ((prom_piece == N || prom_piece == n) && move_str[4] == 'n')
					return move;

				else if ((prom_piece == B || prom_piece == b) && move_str[4] == 'b')
					return move;

				else if ((prom_piece == R || prom_piece == r) && move_str[4] == 'r')
					return move;

				else if ((prom_piece == Q || prom_piece == q) && move_str[4] == 'q')
					return move;

				continue;
			}

			// return move to make on board
			return move;
		}
	}

	// return illegal move
	return 0;
}

static void SetFen(vector<string> fen) {
	ResetBoard();
	int sq = 0;
	string ele = fen[0];
	for (char c : ele) {
		switch (c) {
		case 'p':board[sq++] = p; break;
		case 'n':board[sq++] = n; break;
		case 'b':board[sq++] = b; break;
		case 'r':board[sq++] = r; break;
		case 'q':board[sq++] = q; break;
		case 'k':king_square[black] = sq; board[sq++] = k; break;
		case 'P':board[sq++] = P; break;
		case 'N':board[sq++] = N; break;
		case 'B':board[sq++] = B; break;
		case 'R':board[sq++] = R; break;
		case 'Q':board[sq++] = Q; break;
		case 'K':king_square[white] = sq; board[sq++] = K; break;
		case '1': sq += 1; break;
		case '2': sq += 2; break;
		case '3': sq += 3; break;
		case '4': sq += 4; break;
		case '5': sq += 5; break;
		case '6': sq += 6; break;
		case '7': sq += 7; break;
		case '8': sq += 8; break;
		case '/': sq += 8; break;
		}
	}
	ele = fen[1];
	side = (ele == ""w"") ? white : black;
	ele = fen[2];
	for (char c : ele)
		switch (c)
		{
		case 'K':
			castle |= KC;
			break;
		case 'Q':
			castle |= QC;
			break;
		case 'k':
			castle |= kc;
			break;
		case 'q':
			castle |= qc;
			break;
		}
	if (fen[3][0] != '-')
	{
		int file = fen[3][0] - 'a';
		int rank = 7 - (fen[3][1] - '1');
		enpassant = rank * 16 + file;
	}
}

static void SetFen(string fen) {
	vector<string> v = SplitString(fen);
	SetFen(v);
}

static void ParsePosition(vector<string> commands) {
	vector<string> fen = {};
	vector<string> moves = {};
	int mark = 0;
	for (int i = 1; i < commands.size(); i++) {
		if (mark == 1)
			fen.push_back(commands[i]);
		if (mark == 2)
			moves.push_back(commands[i]);
		if (commands[i] == ""fen"")
			mark = 1;
		else if (commands[i] == ""moves"")
			mark = 2;
	}
	if (fen.size() != 6)
		fen = SplitString(defFen);
	SetFen(fen);
	for (string m : moves)
	{
		int move = ParseMove(m.c_str());
		MakeMove(move, all_moves);
	}

}

static void UciQuit() {
	exit(0);
}

static void UciTest() {
	UciCommand(""position startpos moves e2e4 e7e5 g1f3 b8c6 f1b5 a7a6 b5a4 f8e7 d2d4 e5d4 f3d4 g8f6 d4c6 d7c6 d1d8 e7d8 f2f3 b7b5 a4b3 c6c5 c2c4 b5c4 b3c4 c8e6 b1a3 e8g8 c4e6 f7e6 c1e3 d8e7 a1c1 a8b8 b2b3 f6d7 e1g1 b8d8 a3c4 f8e8 e3f4 d8c8 f1d1 e8d8 c4a5 d7f6 d1d8 c8d8 a5c6 d8e8 c6e7 e8e7 c1c5 f6e8 f4e5 e7d7 c5a5 d7d1 g1f2 d1d2 f2g3 c7c5 a5a6 g8f7 a6a7 f7f8 a2a4 h7h5 a4a5 h5h4 g3h4 d2g2 a5a6"");
	UciCommand(""go depth 5"");
}

void UciCommand(string line) {
	vector<string> commands = SplitString(line);
	fflush(stdout);
	if (commands[0] == ""uci"") {
		cout << ""id name "" << name << endl;
		cout << ""uciok"" << endl;
	}
	else if (commands[0] == ""isready"") {
		cout << ""readyok"" << endl;
	}
	else if (commands[0] == ""position"")
		ParsePosition(commands);
	else if (commands[0] == ""go"") {
		g_max_depth = GetInt(commands, ""depth"", 0xff);
		g_max_time = GetInt(commands, side == white ? ""wtime"" : ""btime"", 0) / 30;
		if (!g_max_time)
			g_max_time = GetInt(commands, ""movetime"", 0xffffff);
		SearchIterate(g_max_depth, g_max_time);
	}
	else if (commands[0] == ""print"")
		PrintBoard();
	else if (commands[0] == ""test"")
		UciTest();
	else if (commands[0] == ""quit"")
		UciQuit();
}

static void UciLoop() {
	string line;
	while (true) {
		getline(cin, line);
		UciCommand(line);
	}
}

// main driver
int main() {
	PrintWelcome();
	UciLoop();
	return 0;
}",words
338,"template <typename T>
inline g2d::animation::bazier<T>::bazier()
	: _running(false)
	, _time(0)
	, _node(0)
	, _speed(0.001)
	, _vector(std::vector<g2d::math::point3d<T>>())
{
}

template <typename T>
inline g2d::animation::bazier<T>::~bazier()
{
	this->_vector.clear();
}

template <typename T>
inline void g2d::animation::bazier<T>::update()
{
	this->_time = g2d::math::clamp(this->_time + this->_speed, 0.0, 1.0);
}

template <typename T>
inline void g2d::animation::bazier<T>::play()
{
	this->_running = true;
}

template <typename T>
inline void g2d::animation::bazier<T>::stop()
{
	this->_running = false;
}

template <typename T>
inline void g2d::animation::bazier<T>::replay()
{
	this->_running = true;
	this->_time = 0.0;
}

template <typename T>
inline void g2d::animation::bazier<T>::reset()
{
	this->_running = false;
	this->_time = 0.0;
}

template <typename T>
inline void g2d::animation::bazier<T>::bind_point(const g2d::math::point3d<T>& point)
{
	this->_vector.push_back(point);
	this->_node = this->_vector.size() - 1;
}

template <typename T>
inline void g2d::animation::bazier<T>::bind_point(T x, T y, T z)
{
	this->_vector.push_back(g2d::math::point3d<T>(x, y, z));
	this->_node = this->_vector.size() - 1;
}

template <typename T>
inline void g2d::animation::bazier<T>::bind_point(T point)
{
	this->_vector.push_back(g2d::math::point3d<T>(point));
	this->_node = this->_vector.size() - 1;
}

template <typename T>
inline void g2d::animation::bazier<T>::bind_point_x(T x)
{
	this->_vector.push_back(g2d::math::point3d<T>(x, static_cast<T>(0), static_cast<T>(0)));
	this->_node = this->_vector.size() - 1;
}

template <typename T>
inline void g2d::animation::bazier<T>::bind_point_y(T y)
{
	this->_vector.push_back(g2d::math::point3d<T>(static_cast<T>(0), y, static_cast<T>(0)));
	this->_node = this->_vector.size() - 1;
}

template <typename T>
inline void g2d::animation::bazier<T>::bind_point_z(T z)
{
	this->_vector.push_back(g2d::math::point3d<T>(static_cast<T>(0), static_cast<T>(0), z));
	this->_node = this->_vector.size() - 1;
}

template <typename T>
inline void g2d::animation::bazier<T>::speed(double speed)
{
	this->_speed = speed;
}


template <typename T>
inline g2d::math::point3d<T> g2d::animation::bazier<T>::point()
{
	int kn;
	int nn;
	int nkn;
	double blend;
	double  [MASK] ;
	double munk;

	g2d::math::point3d<T> b = g2d::math::point3d<T>(0.0);

	 [MASK]   = 1;
	munk = pow(1 - this->_time, (double)this->_node);

	for (int k = 0; k <= static_cast<int>(this->_node); k++)
	{
		nn = this->_node;
		kn = k;
		nkn = this->_node - k;
		blend =  [MASK]  * munk;
		 [MASK]  *= this->_time;
		munk /= (1 - this->_time);

		while (nn >= 1)
		{
			blend *= nn;
			nn--;

			if (kn > 1)
			{
				blend /= (double)kn;
				kn--;
			}

			if (nkn > 1)
			{
				blend /= (double)nkn;
				nkn--;
			}
		}

		b.x(b.x() + this->_vector[k].x() * blend);
		b.y(b.y() + this->_vector[k].y() * blend);
		b.z(b.z() + this->_vector[k].z() * blend);
	}

	if (this->_time == 1)
	{
		return this->_vector[this->_node];
	}

	if (this->_time == 0)
	{
		return this->_vector[0];
	}

	return b;
}

template <typename T>
inline double g2d::animation::bazier<T>::speed() const
{
	return this->_speed;
}

template <typename T>
inline double g2d::animation::bazier<T>::time() const
{
	return this->_time;
}

template <typename T>
inline std::size_t g2d::animation::bazier<T>::node() const
{
	return this->_node;
}

template <typename T>
inline bool g2d::animation::bazier<T>::bound() const
{
	return this->_time == 1.0;
}
",muk
339,"#include <Wire.h>
#include <DS3231.h>
#include <Adafruit_NeoPixel.h>
#include <avr/power.h>

// pins for leds
#define PIN_SWITCH         4
#define PIN_PIXELS         6
#define PIN_SWITCH_PULL_UP 7
#define NUMPIXELS          6
#define PIN_LATCH          11
#define PIN_CLOCK          12
#define PIN_DATA           10

// variables store date correction from serial
byte Year;
byte Month;
byte Date;
byte DoW;
byte Hour;
byte Minute;
byte Second;

//setup neopixel leds
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN_PIXELS, NEO_GRB + NEO_KHZ800);

//clocks
RTClib myRTC;
DS3231 Clock;

// used to toggle second led
bool secondsOn = false;

void setup() 
{
  // setup pins for shift register
  pinMode(PIN_LATCH, OUTPUT);
  pinMode(PIN_DATA, OUTPUT);  
  pinMode(PIN_CLOCK, OUTPUT);

  // setup pins for light control switch
  pinMode(PIN_SWITCH_PULL_UP, OUTPUT);
  pinMode(PIN_SWITCH, INPUT);
  digitalWrite(PIN_SWITCH_PULL_UP, HIGH);

  pixels.begin();
  Serial.begin(9600);
  Wire.begin();

  showAnimation();
}

// lookup map for numbers. digit[0] is 0, digit[1] is 1 and so on
byte digit[10]= {B00100001, B11111001, B00010101, B10010001, B11001001, B10000011, B00000011, B11110001, B00000001, B11000001};

// map for different states of the animation
byte init_animation[6]= {B00100011, B00100101, B00101001, B00110001, B10100001, B01100001};


void loop() {
  while (true){

    if (Serial.available()) {
      handleSerialData(Year, Month, Date, DoW, Hour, Minute, Second);
    } else {
      updateTime();
    
      for (int i = 0; i <= 60; i++) {
        if (Serial.available()){
          break;
        }
        if (digitalRead(PIN_SWITCH) == HIGH){
           turnLightOn();
           toggleSeconds();
        } 
        else {
           turnLightOff();
           secondsOn = false;
        }
        delay(1000);
      }
    }
  }
}

void showAnimation(){
  for (int i = 0; i <= 12; i++) {
    for (int j = 0; j < 6; j++){
      digitalWrite(PIN_LATCH, LOW);
      shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, init_animation[j]);
      shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, init_animation[j]);
      shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, init_animation[j]);
      shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, init_animation[j]);
      digitalWrite(PIN_LATCH, HIGH);
      delay(70);
      turnLightOff();
    }
    turnLightOn();
  }    
}

void toggleSeconds(){
  if (secondsOn){
    pixels.setPixelColor(5, pixels.Color(0,0,0)); 
    pixels.show();
    secondsOn = false;
  } else {
    pixels.setPixelColor(5, pixels.Color(7,20,0));
    pixels.show();
    secondsOn = true;
  }
}

void turnLightOn(){
  for (int j = 0; j < 5; j++){
    pixels.setPixelColor(j, pixels.Color(60,255,0));
    pixels.show();
  }
}

void turnLightOff(){
  for (int j = 0; j < 6; j++){
    pixels.setPixelColor(j, pixels.Color(0,0,0));
    pixels.show();
  }
}

void updateTime() {
  DateTime now = myRTC.now();
  
  int m1 = (now.minute() / 10) % 10;
  int m2 = (now.minute() / 1) % 10;
  
  int h1 = (now.hour() / 10) % 10;
  int h2 = (now.hour() / 1) % 10;
  
  
  digitalWrite(PIN_LATCH, LOW);
  shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, digit[h2]);
  shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, digit[h1]);
  shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, digit[m2]);
  shiftOut(PIN_DATA, PIN_CLOCK, LSBFIRST, digit[m1]);
  digitalWrite(PIN_LATCH, HIGH);
}

// from DS3231_set example
void handleSerialData(byte& Year, byte& Month, byte& Day, byte& DoW, 
    byte& Hour, byte& Minute, byte& Second) {
  // Call this if you notice something coming in on 
  // the serial port. The data coming in should be in 
  // the order YYMMDDwHHMMSS, with an 'x' at the end.
  boolean  [MASK]  = false;
  char InChar;
  byte Temp1, Temp2;
  char InString[20];

  byte j=0;
  while (! [MASK] ) {
    if (Serial.available()) {
      InChar = Serial.read();
      InString[j] = InChar;
      j += 1;
      if (InChar == 'x') {
         [MASK]  = true;
      }
    }
  }
  Serial.println(InString);
  // Read Year first
  Temp1 = (byte)InString[0] -48;
  Temp2 = (byte)InString[1] -48;
  Year = Temp1*10 + Temp2;
  // now month
  Temp1 = (byte)InString[2] -48;
  Temp2 = (byte)InString[3] -48;
  Month = Temp1*10 + Temp2;
  // now date
  Temp1 = (byte)InString[4] -48;
  Temp2 = (byte)InString[5] -48;
  Day = Temp1*10 + Temp2;
  // now Day of Week
  DoW = (byte)InString[6] - 48;   
  // now Hour
  Temp1 = (byte)InString[7] -48;
  Temp2 = (byte)InString[8] -48;
  Hour = Temp1*10 + Temp2;
  // now Minute
  Temp1 = (byte)InString[9] -48;
  Temp2 = (byte)InString[10] -48;
  Minute = Temp1*10 + Temp2;
  // now Second
  Temp1 = (byte)InString[11] -48;
  Temp2 = (byte)InString[12] -48;
  Second = Temp1*10 + Temp2;

  Clock.setClockMode(false);  // set to 24h
  
  Clock.setYear(Year);
  Clock.setMonth(Month);
  Clock.setDate(Date);
  Clock.setDoW(DoW);
  Clock.setHour(Hour);
  Clock.setMinute(Minute);
  Clock.setSecond(Second);

  //empty serial buffer
  while(Serial.available()) {
    Serial.read();
  }  
}
",GotString
340,"#include ""floor_object_detection.h""

#include <iostream>
#include <cstdlib>
#include <memory>
#include <vector>

#include <android/log.h>
#include <assert.h>
#include <jni.h>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/highgui/highgui.hpp>

namespace {
// The maximum number of frames to process per second
const int kProcessImagesFPS = 1;
// TODO: fx and fy should come from Tango through JNI
const float fx = 1521.046710;
const float fy = 1518.999642;
const char* kColorDirectory = ""/sdcard/datasets/tango/color/"";
const char* kDepthDirectory = ""/sdcard/datasets/tango/depth/"";
}  // namespace

namespace floor_object_detection {

void FloorObjectDetector::ConvertYCbCrtoRGB(uint8_t* rgb, uint8_t* ycbcr, int width, int height) {
    assert(rgb != nullptr);
    assert(ycbcr != nullptr);
    assert(width > 0);
    assert(height > 0);
    int num_pixels = width * height;
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            float y = 1.164f * ((float) (ycbcr[i * width + j] & 0xff)) - 16.0f;
            float u = (float) (ycbcr[num_pixels + 2 * (j / 2) + (i / 2) * width] & 0xff) - 128.0f;
            float v = (float) (ycbcr[num_pixels + 2 * (j / 2) + 1 + (i / 2) * width] & 0xff) - 128.0f;

            int b = (int) (y + 1.596f * v);
            int g = (int) (y - 0.392f * u - 0.813f * v);
            int r = (int) (y + 2.017f * u);

            if (r < 0) {
                r = 0;
            } else if (r > 255) {
                r = 255;
            }

            if (g < 0) {
                g = 0;
            } else if (g > 255) {
                g = 255;
            }

            if (b < 0) {
                b = 0;
            } else if (b > 255) {
                b = 255;
            }

            rgb[3 * (i * width + j)] = (uint8_t) (r & 0xff);
            rgb[3 * (i * width + j) + 1] = (uint8_t) (g & 0xff);
            rgb[3 * (i * width + j) + 2] = (uint8_t) (b & 0xff);
        }
    }
    return;
}

float* FloorObjectDetector::ProcessDepthAndColorImages(double timestamp, float* depth_data, uint8_t* image_data,
        int image_width, int image_height, int color_to_depth_ratio) {
    assert(timestamp > 0);
    assert(depth_data != nullptr);
    assert(image_data != nullptr);
    assert(image_width > 0);
    assert(image_height > 0);
    assert(color_to_depth_ratio > 0);
    char timestamp_str[128];
    sprintf(timestamp_str, ""%f"", timestamp * 1e9);
    if (timestamp < prev_image_timestamp_ + 1.0 / kProcessImagesFPS) {
        return nullptr;
    }
    prev_image_timestamp_ = timestamp;
    LOGI(""FloorObjectDetectionApplication: Timestamp: %f "", timestamp);

    //TODO: adjust the code below to work when the depth is at a lower resolution than color
    if (color_to_depth_ratio != 1) {
        return nullptr;
    }

    float half_height = image_height / 2;
    cv::Mat color_mat_ycbcr_420sp = cv::Mat(image_height + half_height, image_width, CV_8UC1, image_data);
    cv::Mat color_mat = cv::Mat(image_height, image_width, CV_8UC3);
    cvtColor(color_mat_ycbcr_420sp, color_mat, CV_YUV420sp2RGB);

    cv::Mat depth_mat = cv::Mat(image_height, image_width, CV_32FC1, depth_data);
    const double  [MASK]  = 1.5;
    cv::Mat depth_filtered;
    cv::threshold(depth_mat, depth_filtered,  [MASK] , 0.0, cv::THRESH_TOZERO_INV);

    //TODO: many of the parameters are hardcoded, these should be const variables
    //TODO: for loop below should be written in cleaner way
    //TODO: number of points used for plane fitting is currently around 650, could be reduced for speed
    std::vector<float> points_depth;
    points_depth.reserve(650);
    std::vector<cv::Point3f> points_location;
    points_location.reserve(650);
    for(int r = image_height - 160; r < image_height - 80; ++r) {
        const float* depth_row = depth_filtered.ptr<float>(r);
        cv::Mat labeled = cv::Mat::zeros(1, image_width, CV_32FC1);
        std::vector<int> labels_count;
        labels_count.reserve(20);
        bool component_active = false;
        int component_count = 0;
        int latest_label = 0;
        for (int c = 0; c < image_width; ++c) {
            float current_depth = depth_row[c];
            float component_depth;
            if (current_depth > 0) {
                if (component_active) {
                    if (fabs(current_depth - component_depth) < 0.03) {
                        labeled.at<float>(c) = latest_label;
                        component_depth = current_depth;
                        component_count += 1;
                    } else {
                        latest_label += 1;
                        labeled.at<float>(c) = latest_label;
                        component_depth = current_depth;
                        labels_count.push_back(component_count);
                        component_count = 1;
                    }
                } else {
                    latest_label += 1;
                    labeled.at<float>(c) = latest_label;
                    component_depth = current_depth;
                    labels_count.push_back(component_count);
                    component_count = 1;
                    component_active = true;
                }

            } else {
                component_active = false;
                labeled.at<float>(c) = 0;
            }
        }
        labels_count.push_back(component_count);
        auto max_labels_count_iter = std::max_element(std::begin(labels_count), std::end(labels_count));
        int max_labels_count_idx  = std::distance(std::begin(labels_count), max_labels_count_iter);
        int max_label_count = *max_labels_count_iter;
        if (max_label_count < 100) {
            continue;
        }
        std::vector<int> max_label_indxs;
        max_label_indxs.reserve(1500);
        // TODO: No need to loop over the whole width
        for (int i = 0; i < image_width; ++i) {
            if (labeled.at<float>(i) == max_labels_count_idx) {
                max_label_indxs.push_back(i);
            }
        }
        for(int j = max_label_count / 10; j < 8 * max_label_count / 10; j += max_label_count / 10) {
            points_depth.push_back(depth_row[max_label_indxs[j]]);
            cv::Point3f current_point;
            current_point.x = (max_label_indxs[j] - image_width / 2.0f) / fx;
            current_point.y = (r - image_height / 2.0f) / fy;
            current_point.z = 1;
            points_location.push_back(current_point);
        }
        labels_count.clear();
        max_label_indxs.clear();
    }
    if (points_depth.size() < 100 || points_location.size() < 100) {
        return nullptr;
    }

    cv::Mat left_hand_side = cv::Mat::zeros(points_location.size(), 3, CV_32FC1);
    cv::Mat right_hand_side = cv::Mat::zeros(points_depth.size(), 1, CV_32FC1);
    for (int k = 0; k < points_depth.size(); ++k) {
        left_hand_side.at<float>(k, 0) = points_location[k].x;
        left_hand_side.at<float>(k, 1) = points_location[k].y;
        left_hand_side.at<float>(k, 2) = points_location[k].z;
        right_hand_side.at<float>(k, 0) = points_depth[k];
    }
    points_location.clear();
    points_depth.clear();
    cv::Mat left_hand_side_transpose = left_hand_side.t();
    cv::Mat plane = (((left_hand_side_transpose * left_hand_side).inv()) * left_hand_side_transpose) * right_hand_side;
    std::unique_ptr<float[]> cols_x = std::unique_ptr<float[]>(new float[image_width]);
    std::unique_ptr<float[]> rows_y = std::unique_ptr<float[]>(new float[image_height]);
    float half_width = image_width / 2;
    for (int i = 0; i < image_width; ++i) {
        cols_x[i] =  (i - half_width) / fx;
    }
    for (int j = 0; j < image_height; ++j) {
        rows_y[j] = (j - half_height) / fy;
    }
    cv::Mat cols_x_mat = cv::Mat(1, image_width, CV_32FC1, cols_x.get());
    cv::Mat rows_y_mat = cv::Mat(image_height, 1, CV_32FC1, rows_y.get());
    cv::Mat Xs, Ys;
    cv::repeat(cols_x_mat, image_height, 1, Xs);
    cv::repeat(rows_y_mat, 1, image_width, Ys);
    cv::Mat Xs_Zs = Xs.mul(depth_filtered);
    cv::Mat Ys_Zs = Ys.mul(depth_filtered);
    float a_plane = plane.at<float>(0, 0);
    float b_plane = plane.at<float>(1, 0);
    float c_plane = plane.at<float>(2, 0);
    float vec_plane_norm = sqrt(pow(a_plane, 2) + pow(b_plane, 2) + 1);
    cv::Mat diff = (a_plane * Xs_Zs + b_plane * Ys_Zs + c_plane - depth_filtered)/vec_plane_norm;
    cv::Mat depth_mask;
    cv::threshold(depth_filtered, depth_mask, 0, 255, cv::THRESH_BINARY);
    depth_mask.convertTo(depth_mask, CV_8UC1);
    cv::Mat diff_filtered;
    diff.copyTo(diff_filtered, depth_mask);

    char file_name[256];
    strcpy(file_name, kDepthDirectory);
    strcat(file_name, ""diff-filtered.png"");
    cv::imwrite(file_name, diff_filtered * 3000);
    cv::Mat components_image;
    cv::threshold(diff_filtered, components_image, 0.03, 255, cv::THRESH_BINARY);
    components_image.convertTo(components_image, CV_8UC1);
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    findContours(components_image, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0));
    std::vector<cv::Rect> bound_rects;
    bound_rects.reserve(contours.size());
    if (contours.size() > 0) {
        cv::Scalar color = cv::Scalar(0, 0, 255);
        //TODO: approximating contours might speed up the computation
        for (int i = 1; i < contours.size(); ++i) {
            double contourArea = cv::contourArea(contours[i]);
            if (contourArea >  1000) {
                cv::drawContours(color_mat, contours, i, color, 5);
                bound_rects.push_back(cv::boundingRect(cv::Mat(contours[i])));
            }
        }
    }

    std::unique_ptr<float[]> bound_rect_arr = std::unique_ptr<float[]>(new float[5 * bound_rects.size() + 1]);
    bound_rect_arr[0] = bound_rects.size();
    cv::Scalar color_rect = cv::Scalar(0, 255, 255);
    for (int j = 0; j < bound_rects.size(); ++j) {
        cv::Rect current_rect = bound_rects[j];
        cv::rectangle(color_mat, current_rect.tl(), current_rect.br(), color_rect, 2, 8, 0);
        cv::Mat rect_roi = depth_filtered(current_rect);
        cv::Mat rect_roi_nonzero = rect_roi > 0;
        double min_depth_val, max_depth_val;
        cv::Point min_depth_loc, max_depth_loc;
        cv::minMaxLoc(rect_roi, &min_depth_val, &max_depth_val, &min_depth_loc, &max_depth_loc, rect_roi_nonzero);
        bound_rect_arr[5 * j + 1] = (current_rect.tl().x - half_width) / fx;
        bound_rect_arr[5 * j + 2] = (current_rect.tl().y - half_height) / fy;
        bound_rect_arr[5 * j + 3] = (current_rect.br().x - half_width) / fx;
        bound_rect_arr[5 * j + 4] = (current_rect.br().y - half_height) / fy;
        bound_rect_arr[5 * j + 5] = min_depth_val;
    }

    strcpy(file_name, kColorDirectory);
    strcat(file_name, ""contours.png"");
    cv::imwrite(file_name, color_mat);
    return bound_rect_arr.release();
}
}  // floor_object_detection",max_threshold
341,"#include ""ContentReader.hpp""

ContentReader::ContentReader(
    ContentSettings& contentSetting
){
    contentInit(std::forward<ContentSettings>(contentSetting));
}

ContentReader::ContentReader(
    ContentSettings&& contentSetting
){
    contentInit(std::forward<ContentSettings>(contentSetting));
}

void ContentReader::contentInit(
    ContentSettings&& contentSetting
){
    if(contentSetting.is_content){
        container_ = std::make_shared
            <content_reader::ContainerStr>(
                std::move(contentSetting.getContent())
        );
    }else if(contentSetting.is_file){
        container_ = std::make_shared
            <content_reader::FileContainer>(
                contentSetting.getFileName()
        );
    }
}

bool ContentReader::isEnd(){
    return container_->isEnd();
}

bool ContentReader::isNotEnd(){
    return container_->isNotEnd();
}

char ContentReader::current(){
    return container_->current();
}

char ContentReader::next(){
    return container_->next();
}

int ContentReader::pos(){
    return container_->pos();
}

void ContentReader::setPos(int  [MASK] ){
    return container_->setPos( [MASK] );
}

std::size_t ContentReader::find(
    std::string_view str, std::size_t s
){
    return container_->find(str, s);
}

std::size_t ContentReader::find(char c, std::size_t s ){
    return container_->find(c, s);
}

std::size_t ContentReader::size(){
    return container_->size();
}

void ContentReader::print(){
    container_->print();
}
",new_pos
342,"#include ""json_helper.hpp""

cJSON* root = 0;
/**
 * @brief 文本转键值对
 *
 * @param name 文本
 * @param mod  功能键
 * @param vk   按键
 * @return true
 * @return false
**/
bool string2key (string name, char& mod, char& vk) {
    int mod_pos[3] = { -1, -1, -1, };
    int  [MASK]  = -1;
    mod = 0;
    vk = 0;
    /* 转大写 */
    for (size_t i = 0; i < name.length (); i++) {
        char* p_char = (char*)(name.c_str () + i);
        *p_char = toupper (*p_char);
    }
    /* 功能键值 */
    if (name.find (""ALT"") != -1) { mod |= 0x01; mod_pos[0] = name.find (""ALT"") + 3; }
    if (name.find (""CTRL"") != -1) { mod |= 0x02; mod_pos[1] = name.find (""CTRL"") + 4; }
    if (name.find (""SHIFT"") != -1) { mod |= 0x04; mod_pos[2] = name.find (""SHIFT"") + 5; }
    /* 键值 */
    for (size_t i = 0; i < 3; i++) {
         [MASK]  =  [MASK]  < mod_pos[i] ? mod_pos[i] :  [MASK] ;
    }
     [MASK] ++;
    vk = name.c_str ()[ [MASK] ];
    if (vk == 0 || mod == 0) {
        return false;
    }
    else {
        return true;
    }
}
/**
 * @brief 键值对转文本
 *
**/
bool key2string (char mod, char vk, string& str) {
    str = """";

    if (mod & 0x02) { str += ""Ctrl+""; }
    if (mod & 0x01) { str += ""Alt+""; }
    if (mod & 0x04) { str += ""Shift+""; }

    str += vk;
    if (str.empty ()) {
        return false;
    }
    else {
        return true;
    }

}
/**
 * @brief 删除热键项并更新 json 文件
 *
 * @param json_path
 * @param index
**/
void del_to_json (const char* json_path, int index) {
    cJSON* hotkey_arr = NULL;
    if (root && cJSON_GetObjectItem (root, ""hotkeys"")) {
        hotkey_arr = cJSON_GetObjectItem (root, ""hotkeys"");
    }
    else {
        return;
    }
    if (hotkey_arr && cJSON_IsArray (hotkey_arr)) {
        cJSON_DeleteItemFromArray (hotkey_arr, index);
    }
    hotkey_num = cJSON_GetArraySize (hotkey_arr);
    ofstream out (json_path);
    if (out.is_open ()) {
        out << cJSON_Print (root);
        out.close ();
    }
    load_from_json (json_path);
}
/**
 * @brief 增加热键项并更新 json 文件
 *
 * @param json_path
 * @param obj
**/
void add_to_json (const char* json_path, hotkey_obj& obj) {
    cJSON* hotkey_arr = NULL;
    if (root && cJSON_GetObjectItem (root, ""hotkeys"")) {
        hotkey_arr = cJSON_GetObjectItem (root, ""hotkeys"");
    }
    else {
        root = cJSON_CreateObject ();
        hotkey_arr = cJSON_AddArrayToObject (root, ""hotkeys"");
    }
    if (hotkey_arr && cJSON_IsArray (hotkey_arr)) {
        cJSON* one_hotkey = cJSON_CreateObject ();
        cJSON_AddBoolToObject (one_hotkey, ""enable"", obj.enable);
        cJSON_AddStringToObject (one_hotkey, ""cmd_value"", obj.cmd_value.c_str ());
        cJSON_AddStringToObject (one_hotkey, ""key_name"", obj.key_name.c_str ());
        cJSON_AddItemToArray (hotkey_arr, one_hotkey);
    }
    hotkey_num = cJSON_GetArraySize (hotkey_arr);
    ofstream out (json_path);
    if (out.is_open ()) {
        out << cJSON_Print (root);
        out.close ();
    }
    load_from_json (json_path);
}
void save_to_json (const char* json_path) {
    ofstream out (json_path);

    //root = cJSON_CreateObject ();
    //cJSON* hotkey_arr = cJSON_AddArrayToObject (root, ""hotkeys"");

    //for (size_t i = 0; i < hotkey_num; i++) {
    //    cJSON* one_hotkey = cJSON_CreateObject ();
    //    cJSON_AddBoolToObject (one_hotkey, ""enable"", hotkey[i].enable);
    //    cJSON_AddStringToObject (one_hotkey, ""cmd_value"", hotkey[i].cmd_value.c_str ());
    //    cJSON_AddStringToObject (one_hotkey, ""key_name"", hotkey[i].key_name.c_str ());
    //    cJSON_AddItemToArray (hotkey_arr, one_hotkey);
    //}
    if (hotkey_num != 0) {
        cJSON* hotkeys = cJSON_GetObjectItem (root, ""hotkeys"");
        for (size_t i = 0; i < hotkey_num; i++) {
            cJSON* one_hotkey = cJSON_GetArrayItem (hotkeys, i);
            if (one_hotkey) {

                cJSON* _key_name =  cJSON_CreateString(hotkey[i].key_name.c_str ());
                cJSON* _cmd_value = cJSON_CreateString (hotkey[i].cmd_value.c_str());
                cJSON* _enable = cJSON_CreateBool (hotkey[i].enable);

                cJSON_DeleteItemFromObject (one_hotkey, ""key_name"");
                cJSON_DeleteItemFromObject (one_hotkey, ""cmd_value"");
                cJSON_DeleteItemFromObject (one_hotkey, ""enable"");

                cJSON_AddItemToObject (one_hotkey, ""key_name"", _key_name);
                cJSON_AddItemToObject (one_hotkey, ""cmd_value"", _cmd_value);
                cJSON_AddItemToObject (one_hotkey, ""enable"", _enable);

                DEBUG_OUT (""%s  %s  %d"",
                    hotkey[i].cmd_value.c_str (),
                    hotkey[i].key_name.c_str (),
                    hotkey[i].enable
                );
            }
        }
    }
    if (out.is_open ()) {
        out << cJSON_Print (root);
        out.close ();
    }
}
/**
 * @brief 载入 json 文件
 *
 * @param json_path
**/
void load_from_json (const char* json_path) {
    ifstream in (json_path);
    string one_line = """";
    string context = """";
    while (getline (in, one_line)) // 逐行读取
        context += one_line;
    if (root) {
        cJSON_Delete (root);
    }
    root = cJSON_Parse (context.c_str ());
    if (root) {
        cJSON* hotkeys = cJSON_GetObjectItem (root, ""hotkeys"");
        if (hotkeys && cJSON_IsArray (hotkeys)) {
            hotkey_num = cJSON_GetArraySize (hotkeys);
            if (hotkey_num != 0) {
                hotkey = new hotkey_obj[hotkey_num];
                for (size_t i = 0; i < hotkey_num; i++) {
                    cJSON* one_hotkey = cJSON_GetArrayItem (hotkeys, i);
                    if (one_hotkey) {

                        cJSON* _key_name = cJSON_GetObjectItem (one_hotkey, ""key_name"");
                        cJSON* _cmd_value = cJSON_GetObjectItem (one_hotkey, ""cmd_value"");
                        cJSON* _enable = cJSON_GetObjectItem (one_hotkey, ""enable"");

                        hotkey[i].cmd_value = cJSON_GetStringValue (_cmd_value);
                        hotkey[i].key_name = cJSON_GetStringValue (_key_name);
                        hotkey[i].enable = cJSON_IsTrue (_enable);

                        strcpy_s (hotkey[i].key_name_buff, hotkey[i].key_name.c_str ());
                        strcpy_s (hotkey[i].cmd_value_buff, hotkey[i].cmd_value.c_str ());

                        if (string2key (hotkey[i].key_name, hotkey[i].mod, hotkey[i].vk)) {
                            hotkey[i].id = GET_HOTKEY_ID (hotkey[i]);
                            if (hotkey[i].enable) {
                                UnregisterHotKey (glo_menu_hwnd, hotkey[i].id);
                                if (RegisterHotKey (glo_menu_hwnd, hotkey[i].id, hotkey[i].mod, hotkey[i].vk)) {
                                    hotkey[i].enable = true;
                                }
                                else {
                                    hotkey[i].enable = false;
                                }
                            }
                            else {
                                UnregisterHotKey (glo_menu_hwnd, hotkey[i].id);
                            }
                        }
                        DEBUG_OUT (""%s  %s  %d  %d  "",
                            hotkey[i].cmd_value.c_str (),
                            hotkey[i].key_name.c_str (),
                            hotkey[i].enable,
                            hotkey[i].id
                        );
                    }
                }
            }
        }
    }
    //cJSON_Delete (root);
}
",vk_pos
343,"/***************************************************************************
 *
 * Project         _____    __   ____   _      _
 *                (  _  )  /__\ (_  _)_| |_  _| |_
 *                 )(_)(  /(__)\  )( (_   _)(_   _)
 *                (_____)(__)(__)(__)  |_|    |_|
 *
 *
 * Copyright 2018-present, <NAME> <<EMAIL>>
 *
 * 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 ""Deserializer.hpp""

namespace oatpp { namespace xml {

oatpp::String Deserializer::parseElementName(State& state) {
  auto data = state.caret->getCurrData();
  auto size = state.caret->getDataSize() - state.caret->getPosition();
  for(v_buff_size i = 0; i < size; i ++) {
    auto c = data[i];
    if(i > 0 && (c == '/' || c == '>' || c == ' ' || c == '?' || c == '\t' || c == '\n' || c == '\r' || c == '\f')) {
      state.caret->inc(i);
      return oatpp::String(data, i);
    }
    bool validChar = c >= 'a' && c <= 'z' ||
                     c >= 'A' && c <= 'Z' ||
                     c >= '0' && c <= '9' ||
                     c == ':' || c == '.' || c == '_' || c == '-' ||
                     c > 127;
    if(!validChar) {
      state.errorStack.push(""[oatpp::xml::Deserializer::parseElementName()]: Invalid element name '"" + oatpp::String(data, i + 1) + ""'"");
      return nullptr;
    }
  }
  state.errorStack.push(""[oatpp::xml::Deserializer::parseElementName()]: Invalid element name"");
  return nullptr;
}

oatpp::String Deserializer::parseAttributeName(State& state) {
  auto data = state.caret->getCurrData();
  auto size = state.caret->getDataSize() - state.caret->getPosition();
  for(v_buff_size i = 0; i < size; i ++) {
    auto c = data[i];
    if(i > 0 && (c == '=' || c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f')) {
      state.caret->inc(i);
      return oatpp::String(data, i);
    }
    bool validChar = c >= 'a' && c <= 'z' ||
                     c >= 'A' && c <= 'Z' ||
                     c >= '0' && c <= '9' ||
                     c == ':' || c == '.' || c == '_' || c == '-' ||
                     c > 127;
    if(!validChar) {
      state.errorStack.push(""[oatpp::xml::Deserializer::parseAttributeName()]: Invalid attribute name '"" + oatpp::String(data, i + 1) + ""'"");
      return nullptr;
    }
  }
  state.errorStack.push(""[oatpp::xml::Deserializer::parseAttributeName()]: Invalid attribute name"");
  return nullptr;
}

oatpp::String Deserializer::parseAttributeValue(State& state) {

  char  [MASK] ;

  if(state.caret->isAtChar('\'')) {
     [MASK]  = '\'';
  } else if(state.caret->isAtChar('""')) {
     [MASK]  = '""';
  } else {
    state.errorStack.push(R""([oatpp::xml::Deserializer::parseElementName()]: ""'"" or '""' is missing)"");
    return nullptr;
  }

  state.caret->inc(1);

  auto label = state.caret->putLabel();

  if(!state.caret->findChar( [MASK] )) {
    state.errorStack.push(R""([oatpp::xml::Deserializer::parseElementName()]: Unterminated attribute value)"");
    return nullptr;
  }

  auto result = Utils::unescapeText(label.toString(), state.errorStack);
  state.caret->inc(1);
  return result;

}

void Deserializer::parseAttributes(State& state) {

  auto& caret = state.caret;
  while(caret->canContinue()) {

    caret->skipBlankChars();
    if(caret->isAtChar('/') || caret->isAtChar('>')) {
      return;
    }

    auto key = parseAttributeName(state);
    if(!state.errorStack.empty()) {
      state.errorStack.push(""[oatpp::xml::Deserializer::parseAttributes()]"");
      return;
    }

    caret->skipBlankChars();
    if(!caret->canContinueAtChar('=', 1)) {
      state.errorStack.push(""[oatpp::xml::Deserializer::parseAttributes()]: '=' is missing for '"" + key + ""'"");
      return;
    }

    caret->skipBlankChars();
    auto value = parseAttributeValue(state);

    if(!state.errorStack.empty()) {
      state.errorStack.push(""[oatpp::xml::Deserializer::parseAttributes()]: key='"" + key + ""'"");
      return;
    }

    state.tree->attributes()[key] = value;

  }

}

void Deserializer::parsePINode(State& state, oatpp::String& name) {

  if(!state.caret->isAtText(""<?"", 2, true)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parsePINode()]: '<?' expected"");
    return;
  }

  name = ""?"" + parseElementName(state);
  if(!state.errorStack.empty()) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parsePINode()]"");
    return;
  }

  state.caret->skipBlankChars();
  auto label = state.caret->putLabel();

  if(!state.caret->findText(""?>"", 2)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parsePINode()]: unterminated PI node"");
    return;
  }

  state.tree->setString(label.toString());
  state.caret->inc(2);

}

void Deserializer::parseCommentNode(State& state, oatpp::String& name) {

  if(!state.caret->isAtText(""<!--"", 4, true)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseCommentNode()]: '<!--' expected"");
    return;
  }

  auto label = state.caret->putLabel();

  if(!state.caret->findText(""-->"", 3)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseCommentNode()]: unterminated comment"");
    return;
  }

  state.tree->setString(label.toString());
  state.caret->inc(3);
  name = ""!COMMENT"";

}

void Deserializer::parseCDataNode(State& state, oatpp::String& name) {
  if(!state.caret->isAtText(""<![CDATA["", 9, true)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseCDataNode()]: '<![CDATA[' expected"");
    return;
  }

  auto label = state.caret->putLabel();

  if(!state.caret->findText(""]]>"", 3)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseCDataNode()]: unterminated CDATA node"");
    return;
  }

  state.tree->setString(label.toString());
  state.caret->inc(3);
  name = ""!CDATA"";
}

void Deserializer::parseElementContent(State& state, const oatpp::String& name) {

  std::vector<std::pair<oatpp::String, data::mapping::Tree>> nodes;

  auto data = state.caret->getData();
  auto size = state.caret->getDataSize();

  bool hasText = false;
  auto label = state.caret->putLabel();

  v_buff_size i = state.caret->getPosition();
  while( i < size) {

    auto c = data[i];

    if(!hasText) {
      bool isWhitespace = (c == ' ' || c == '\r' || c == '\n' || c == '\t' || c == '\f');
      if (!isWhitespace && c != '<') {
        hasText = true;
      }
    }

    if(c == '<') {

      state.caret->setPosition(i);

      if(hasText) {
        auto text = Utils::unescapeText(label.toString(), state.errorStack);
        if(!state.errorStack.empty()) {
          state.errorStack.push(""[oatpp::xml::Deserializer::parseElementContent()]"");
          return;
        }
        data::mapping::Tree node;
        node.setString(text);
        nodes.emplace_back(""!TEXT"", std::move(node));
      }

      if(state.caret->isAtText(""</"", 2, true)) {
        if(!state.caret->isAtText(name->c_str(), static_cast<v_buff_size>(name->size()), true)) {
          state.errorStack.push(""[oatpp::xml::Deserializer::parseElementContent()]: Invalid closing for tag '"" + name + ""'"");
          return;
        }
        state.caret->skipBlankChars();
        if(!state.caret->canContinueAtChar('>', 1)) {
          state.errorStack.push(""[oatpp::xml::Deserializer::parseElementContent()]: Invalid closing for tag '"" + name + ""' - '>' expected."");
          return;
        }
        break;
      }

      nodes.emplace_back();

      State nestedState;
      nestedState.caret = state.caret;
      nestedState.config = state.config;
      nestedState.tree = &nodes[nodes.size() - 1].second;

      oatpp::String nestedName;
      parseNode(nestedState, nestedName);

      if(!nestedState.errorStack.empty()) {
        state.errorStack.splice(nestedState.errorStack);
        state.errorStack.push(""[oatpp::xml::Deserializer::parseElementContent()]"");
        return;
      }

      nodes[nodes.size() - 1].first = nestedName;

      i = state.caret->getPosition();
      label = state.caret->putLabel();

    } else {
      i ++;
    }

  }

  if(!nodes.empty()) {
    if(nodes.size() == 1 && nodes[0].first == ""!TEXT"") {
      state.tree->setString(nodes[0].second.getString());
    } else {
      state.tree->setPairs(nodes);
    }
  }

}

void Deserializer::parseElementNode(State& state, oatpp::String& name) {

  if(!state.caret->isAtText(""<"", 1, true)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseElementNode()]: '<' expected"");
    return;
  }

  name = parseElementName(state);
  if(!state.errorStack.empty()) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseElementNode()]"");
    return;
  }

  parseAttributes(state);
  if(!state.errorStack.empty()) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseElementNode()]: tag='"" + name + ""'"");
    return;
  }

  if(state.caret->isAtChar('/')) {
    if(!(state.caret->canContinueAtChar('/', 1) && state.caret->canContinueAtChar('>', 1))) {
      state.errorStack.push(""[oatpp::xml::Deserializer::parseElementNode()]: tag='"" + name + ""' - '/>' expected"");
    }
    return;
  }

  if(!state.caret->canContinueAtChar('>', 1)) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseElementNode()]: tag='"" + name + ""' - '>' expected"");
    return;
  }

  parseElementContent(state, name);
  if(!state.errorStack.empty()) {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseElementNode()]: tag='"" + name + ""'"");
    return;
  }

}

void Deserializer::parseNode(State& state, oatpp::String& name) {

  if(state.caret->isAtText(""<?"", 2, false)) {
    parsePINode(state, name);
  } else if(state.caret->isAtText(""<!--"", 4, false)) {
    parseCommentNode(state, name);
  } else if(state.caret->isAtText(""<![CDATA["", 9, false)) {
    parseCDataNode(state, name);
  } else if( state.caret->isAtChar('<')) {
    parseElementNode(state, name);
  } else {
    state.errorStack.push(""[oatpp::xml::Deserializer::parseNode()]: '<' expected"");
    return;
  }

}

void Deserializer::deserialize(oatpp::xml::Deserializer::State &state) {

  state.tree->setPairs({});
  auto& pairs = state.tree->getPairs();

  state.caret->skipBlankChars();

  while (state.caret->canContinue()) {

    data::mapping::Tree nestedNode;

    State nestedState;
    nestedState.caret = state.caret;
    nestedState.config = state.config;
    nestedState.tree = &nestedNode;

    oatpp::String nestedName;
    parseNode(nestedState, nestedName);

    if(!nestedState.errorStack.empty()) {
      state.errorStack.splice(nestedState.errorStack);
      state.errorStack.push(""[oatpp::xml::Deserializer::deserialize()]"");
      return;
    }

    pairs.emplace_back(nestedName, std::move(nestedNode));

    state.caret->skipBlankChars();

  }

}


}}
",enclosingChar
344,"/**
 *  In this demo we use TCP/IP to communicate. This is a little bit more difficult then the other demos because we need to 
 *  setup up a server that is managing the connections first before we get the a Client - which is the Stream that we need to
 *  use in our SimpleMavlinkDrone.
 */

#include ""WiFi.h"" // ESP32 WiFi include
#include ""Ethernet.h""
#include ""SimpleMavlinkDrone.h""

const int port = 5760;
const char* ssid = ""<NAME>"";
const char* password = ""<PASSWORD>"";
WiFiServer server(port);
SimpleMavlinkDrone drone;

void connectToWifi() {
  WiFi.begin(ssid, password);
  Serial.print(""Connecting to ""); 
  Serial.println(ssid);

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(500);
  }

  Serial.print(""Connected with IP address: "");
  Serial.println(WiFi.localIP());
}

void setup() {
  // setup log
  Serial.begin(115200);
  
  // setup Wifi
  connectToWifi();
  
  // start the tcp ip server
  server.begin();
}

void loop() {
  WiFiClient  [MASK]  = server.available();
  if ( [MASK] ){
    // we did not define the Stream in the constructor so we assign it here
    drone.reconnect(& [MASK] );
    while( [MASK] .connected()){
        drone.loop();  
        delay(10);
    }
  }
}",client
345,"#include ""rmw_wasm_cpp/rmw_wasm_validation.hpp""

#include ""rmw/types.h""
#include ""rmw/validate_full_topic_name.h""
#include ""rmw/error_handling.h""

#include ""rcutils/error_handling.h""
#include ""rcutils/logging_macros.h""

#include ""rosidl_runtime_c/message_type_support_struct.h""
#include ""rosidl_runtime_c/service_type_support_struct.h""
#include ""rosidl_runtime_cpp/message_type_support_decl.hpp""
#include ""rosidl_runtime_cpp/service_type_support_decl.hpp""
#include ""rosidl_typesupport_introspection_c/identifier.h""
#include ""rosidl_typesupport_introspection_cpp/identifier.hpp""


namespace rmw_wasm_cpp
{
    bool is_valid_qos(const rmw_qos_profile_t * qos_profile)
    {
        RCUTILS_LOG_DEBUG_NAMED(""rmw_wasm_cpp"", ""trace is_valid_qos()"");

        return nullptr != qos_profile &&
            RMW_QOS_POLICY_HISTORY_UNKNOWN != qos_profile->history &&
            RMW_QOS_POLICY_RELIABILITY_UNKNOWN != qos_profile->reliability &&
            RMW_QOS_POLICY_DURABILITY_UNKNOWN != qos_profile->durability &&
            RMW_QOS_POLICY_LIVELINESS_UNKNOWN != qos_profile->liveliness;
    }

    bool is_valid_topic_name(const char * topic_name)
    {
        RCUTILS_LOG_DEBUG_NAMED(""rmw_wasm_cpp"", ""trace is_valid_topic_name()"");

        int  [MASK]  = RMW_TOPIC_VALID;
        rmw_ret_t ret = rmw_validate_full_topic_name(
            topic_name, & [MASK] , nullptr);
        if (RMW_RET_OK != ret) {
            return false;
        }
        return true;
    }

    bool is_valid_type_support_message(
        const rosidl_message_type_support_t * type_support)
    {
        RCUTILS_LOG_DEBUG_NAMED(""rmw_wasm_cpp"", ""trace is_valid_type_support_message()"");

        const rosidl_message_type_support_t * ts = nullptr;
        ts = get_message_typesupport_handle(
            type_support,
            rosidl_typesupport_introspection_c__identifier);
        if (ts) {
            return true;
        }
        rcutils_error_string_t error_c = rcutils_get_error_string();
        rcutils_reset_error();

        ts = get_message_typesupport_handle(
            type_support,
            rosidl_typesupport_introspection_cpp::typesupport_identifier);
        if (ts) {
            return true;
        }
        rcutils_error_string_t error_cpp = rcutils_get_error_string();
        rcutils_reset_error();

        RMW_SET_ERROR_MSG_WITH_FORMAT_STRING(
            ""Unable to find type support:\n""
            ""    C: %s\n""
            ""  C++: %s\n"",
            error_c.str,
            error_cpp.str);

        return false;
    }

    bool is_valid_type_support_service(
        const rosidl_service_type_support_t * type_support)
    {
        RCUTILS_LOG_DEBUG_NAMED(""rmw_wasm_cpp"", ""trace is_valid_type_support_service()"");
        
        const rosidl_service_type_support_t * ts = nullptr;
        ts = get_service_typesupport_handle(
            type_support,
            rosidl_typesupport_introspection_c__identifier);
        if (ts) {
            return true;
        }
        rcutils_error_string_t error_c = rcutils_get_error_string();
        rcutils_reset_error();

        ts = get_service_typesupport_handle(
            type_support,
            rosidl_typesupport_introspection_cpp::typesupport_identifier);
        if (ts) {
            return true;
        }
        rcutils_error_string_t error_cpp = rcutils_get_error_string();
        rcutils_reset_error();

        RMW_SET_ERROR_MSG_WITH_FORMAT_STRING(
            ""Unable to find type support:\n""
            ""    C: %s\n""
            ""  C++: %s\n"",
            error_c.str,
            error_cpp.str);

        return false;
    }

} // namespace rmw_wasm_cpp",validation_result
346,"#include <stdarg.h>

#define LIGHTS_SIZE 20
#define GROUPS_SIZE 5

#define PHASE_HIGH_AMBIENT_LIGHT     0
#define PHASE_MEDIUM_AMBIENT_LIGHT   1
#define PHASE_LOW_AMBIENT_LIGHT      2

void p(char *fmt, ... ) {
  char tmp[128];
  va_list args;
  va_start(args, fmt);
  vsnprintf(tmp, 128, fmt, args);
  va_end(args);
  Serial.print(tmp);
}

// Analog light sensor pin
static byte LDR = 4;

// Digital charliplexed LED pins
static byte A = 9, B = 10, C = 11, D = 12, E = 13;

// Pin pairs (HIGH, LOW) that each drive one LED
static byte pin_pairs[LIGHTS_SIZE][2] = {
  {A, B}, {A, C}, {A, D}, {A, E},
  {B, A}, {B, C}, {B, D}, {B, E},
  {C, A}, {C, B}, {C, D}, {C, E},
  {D, A}, {D, B}, {D, C}, {D, E},
  {E, A}, {E, B}, {E, C}, {E, D},
};

// State of a light (on or off), indexes match pin_pairs
static boolean lights[LIGHTS_SIZE];

// Which animation phase we're in
static byte phase = PHASE_HIGH_AMBIENT_LIGHT;

/* Groups */

struct light_group {
  byte count;
  byte * indexes;
  
  void (*timer)(unsigned long time, struct light_group * group);
  void * timer_data;
  
  void (*animator)(unsigned long time, struct light_group * group);
  void * animator_data;
};

static struct light_group groups[GROUPS_SIZE];

void light_group_init(struct light_group * group, byte count, byte * indexes, 
    void (*timer)(unsigned long time, struct light_group * group),
    void (*animator)(unsigned long time, struct light_group * group)) {
  group->count = count;
  group->indexes = indexes;
  group->timer = timer;
  group->timer_data = NULL;
  group->animator = animator;
  group->animator_data = NULL;
}

/* Arduino */

void setup() {
  Serial.begin(9600);
  
  // Configure light sensor
  pinMode(LDR, INPUT);
  
  // Turn off all lights
  for (byte i = 0; i < LIGHTS_SIZE; i++) {
    lights[i] = false;
  }
  
  static byte left_indexes[] = { 0, 8, 5, 4, 9 };
  light_group_init(&groups[0], 5, left_indexes, timer_monotonic, animate_increment);
  timer_monotonic_init(&groups[0], 517000, 0, 0);
  animate_increment_init(&groups[0]);
 
  static byte mid_left_indexes[] = { 2, 1, 12 };
  light_group_init(&groups[1], 3, mid_left_indexes, timer_monotonic, animate_increment);
  timer_monotonic_init(&groups[1], 1000000, 3000000, 0);
  animate_increment_init(&groups[1]);
  
  static byte nipples_indexes[] = { 16, 3 };
  light_group_init(&groups[2], 2, nipples_indexes, timer_monotonic, animate_increment);
  timer_monotonic_init(&groups[2], 1000000, 2000000, 3000000);
  animate_increment_init(&groups[2]);
  
  static byte snake_indxes[] = { 19, 15, 18, 11, 17 };
  light_group_init(&groups[3], 5, snake_indxes, timer_monotonic, animate_increment);
  timer_monotonic_init(&groups[3], 110000, 220000, 0);
  animate_increment_init(&groups[3]);
  
  static byte spikes_indexes[] = { 7, 14, 10, 13, 6 };
  light_group_init(&groups[4], 5, spikes_indexes, timer_monotonic, animate_flash);
  timer_monotonic_init(&groups[4], 130000, 0, 0);
  animate_flash_init(&groups[4]);
}

void loop() {
  sense_ambient_light();

  unsigned long time = micros();
  for (byte i = 0; i < GROUPS_SIZE; i++) {
    groups[i].timer(time, &groups[i]);
  }
  //Serial.println(micros() - time);
  
  update_lights();
/*
  unsigned long start = micros();  
  update_lights();
  byte lit_count = 0;
  for (byte i = 0; i < LIGHTS_SIZE; i++) {
    if (lights[i]) { lit_count++; }
  }
  p(""update %d = %lu\n"", lit_count, micros() - start);
*/

//  static unsigned long loops = 0;
//  static unsigned long last_time = 0;
//  loops++;
//  unsigned long diff = time - last_time;
//  if (diff > 1000000) {
//    p(""%lu\n"", loops);
//    loops = 0;
//    last_time = time;
//  }
}

/* Ambient light sensor updates phase with its results */
void sense_ambient_light() {
  int val = analogRead(LDR);
  //Serial.println(val);

  if (val > 700) {
    phase = PHASE_HIGH_AMBIENT_LIGHT;
  } else if (val > 300) {
    phase = PHASE_MEDIUM_AMBIENT_LIGHT;
  } else {
    phase = PHASE_LOW_AMBIENT_LIGHT;
  }
}


/* Increment Animator: Lights the next light each time, wrapping back to 0 */

struct animate_increment_data {
  byte lit;
};

void animate_increment_init(struct light_group * group) {
  struct animate_increment_data * data = (struct animate_increment_data *) 
    malloc(sizeof(struct animate_increment_data));
  data->lit = 0;
  group->animator_data = data;
}

void animate_increment(unsigned long time, struct light_group * group) {
  struct animate_increment_data * data = (struct animate_increment_data *) group->animator_data;

  lights[group->indexes[data->lit]] = false;
  
  if (data->lit == group->count - 1) {
    data->lit = 0;
  } else {
    data->lit++;
  }
  
  lights[group->indexes[data->lit]] = true;
}

/* Random Animator: Lights a random number of lights each time */

struct animate_random_data {
};

void animate_random_init(struct light_group * group) {
  struct animate_random_data * data = (struct animate_random_data *) 
    malloc(sizeof(struct animate_random_data));
  group->animator_data = data;
}

void animate_random(unsigned long time, struct light_group * group) {
  struct animate_random_data * data = (struct animate_random_data *) group->animator_data;
  for (byte i = 0; i < group->count; i++) {
    lights[group->indexes[i]] = (boolean) random(2);
  }
}

/* Flash Animator: Alternates between all lights on and off */

struct animate_flash_data {
  boolean lit;
};

void animate_flash_init(struct light_group * group) {
  struct animate_flash_data * data = (struct animate_flash_data *) 
    malloc(sizeof(struct animate_flash_data));
  data->lit = true;
  group->animator_data = data;
}

void animate_flash(unsigned long time, struct light_group * group) {
  struct animate_flash_data * data = (struct animate_flash_data *) group->animator_data;
  for (byte i = 0; i < group->count; i++) {
    lights[group->indexes[i]] = data->lit;
  }
  data->lit = !data->lit;
}

/* Monotonic Timer: Animates at a fixed frequency */

struct timer_monotonic_data {
  unsigned long low_ambient_light_period;
  unsigned long medium_ambient_light_period;
  unsigned long high_ambient_light_period;
  unsigned long last_animated;
};

void timer_monotonic_init(struct light_group * group, unsigned long low_ambient_light_period, 
  unsigned long medium_ambient_light_period, unsigned long high_ambient_light_period) {
  struct timer_monotonic_data * data = (struct timer_monotonic_data *) 
    malloc(sizeof(struct timer_monotonic_data));
  data->low_ambient_light_period = low_ambient_light_period;
  data->medium_ambient_light_period = medium_ambient_light_period;
  data->high_ambient_light_period = high_ambient_light_period;
  data->last_animated = 0;
  group->timer_data = data;
}

void timer_monotonic(unsigned long time, struct light_group * group) {
  struct timer_monotonic_data * data = (struct timer_monotonic_data *) group->timer_data;

  unsigned long period;
  switch (phase) {
    case PHASE_LOW_AMBIENT_LIGHT:
      period = data->low_ambient_light_period;
      break;
    case PHASE_MEDIUM_AMBIENT_LIGHT:
      period = data->medium_ambient_light_period;
      break;
    case PHASE_HIGH_AMBIENT_LIGHT:
      period = data->high_ambient_light_period;
      break;
  }
  
  // Disable animation for this group, turn all off
  if (period == 0) {
    for (byte i = 0; i < group->count; i++) {
      lights[group->indexes[i]] = 0;
    }
    return;
  }
  
  if (time - data->last_animated >= period) {
    if (group->animator != NULL) {
      group->animator(time, group);
    }
    data->last_animated = time;
  }
}

/* Light Update Utilities */

void pair_disable_all() {
  pinMode(A, INPUT);
  pinMode(B, INPUT);
  pinMode(C, INPUT);
  pinMode(D, INPUT);
  pinMode(E, INPUT);
}

void update_lights() {
  // Tracks whether there is one lit so we can elide resets for speed
  static boolean  [MASK]  = false;

  if ( [MASK] ) {
    pair_disable_all();
     [MASK]  = false;
  }
  
  for (byte i = 0; i < LIGHTS_SIZE; i++) {
    if (lights[i]) {
      if ( [MASK] ) {
        pair_disable_all();
      }
      pinMode(pin_pairs[i][0], OUTPUT);
      digitalWrite(pin_pairs[i][0], HIGH);
      pinMode(pin_pairs[i][1], OUTPUT);
      digitalWrite(pin_pairs[i][1], LOW);
       [MASK]  = true;
    }
  }
}
",any_lit
347,"//
// Created by david on 5/18/2016.
//
//          Copyright <NAME> 2016 - 2020.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#ifndef IPASS_NFC_H
#define IPASS_NFC_H

#ifndef HWLIB_H
#ifndef _SPI_H_INCLUDED
#error ""you have neither hwlib nor Arduino_SPI set up""
#endif
#endif

#include ""nfcController.hpp""
#include ""SPIsetup.hpp""

#ifdef HWLIB_H
void delay(int ms)
{
    hwlib::wait_ms(ms);
}
#endif

#ifdef _SPI_H_INCLUDED
#ifndef SPIsetup_INIT
#define SPIsetup_INIT
SPIsetupClass SPIsetup;
#endif
#endif

/**
 * Implementation for the MFRC522 chip to communicate with an MIFARE RFID card.
 *
 */
class MFRC522 : public nfcController {
    // List off register addresses
    const static byte CommandReg = 0x01;
    const static byte ComIEnReg = 0x02;
    const static byte DivIEnReg = 0x03;
    const static byte ComIrqReg = 0x04;
    const static byte DivIrqReg = 0x05;
    const static byte ErrorReg = 0x06;
    const static byte Status1Reg = 0x07;
    const static byte Status2Reg = 0x08;
    const static byte FIFODataReg = 0x09;
    const static byte FIFOLevelReg = 0x0A;
    const static byte WaterLevelReg = 0x0B;
    const static byte ControlReg = 0x0C;
    const static byte BitFramingReg = 0x0D;
    const static byte CollReg = 0x0E;
    const static byte ModeReg = 0x11;
    const static byte TxModeReg = 0x12;
    const static byte RxModeReg = 0x13;
    const static byte TxControlReg = 0x14;
    const static byte TxASKReg = 0x15;
    const static byte TxSelReg = 0x16;
    const static byte RxSelReg = 0x17;
    const static byte RxThresholdReg = 0x18;
    const static byte DemodReg = 0x19;
    const static byte MfTxReg = 0x1C;
    const static byte MfRxReg = 0x1D;
    const static byte SerialSpeedReg = 0x1F;
    const static byte CRCResultRegH = 0x21;
    const static byte CRCResultRegL = 0x22;
    const static byte ModWidthReg = 0x24;
    const static byte RFCfgReg = 0x26;
    const static byte GsNReg = 0x27;
    const static byte CWGsPReg = 0x28;
    const static byte ModGsPReg = 0x29;
    const static byte TModeReg = 0x2A;
    const static byte TPrescalerReg = 0x2B;
    const static byte TReloadRegH = 0x2C;
    const static byte TReloadRegL = 0x2D;
    const static byte TCounterValueRegH = 0x2E;
    const static byte TCounterValueRegL = 0x2F;
    const static byte TestSel1Reg = 0x31;
    const static byte TestSel2Reg = 0x32;
    const static byte TestPinEnReg = 0x33;
    const static byte TestPinValueReg = 0x34;
    const static byte TestBusReg = 0x35;
    const static byte AutoTestReg = 0x36;
    const static byte VersionReg = 0x37;
    const static byte AnalogTestReg = 0x38;
    const static byte TestDAC1Reg = 0x39;
    const static byte TestDAC2Reg = 0x3A;
    const static byte TestADCReg = 0x3B;

    // chip commands
    const static byte CMD_Idle = 0x00;
    const static byte CMD_Mem = 0x01;
    const static byte CMD_GenerateRandomID = 0x02;
    const static byte CMD_CalcCRC = 0x03;
    const static byte CMD_Transmit = 0x04;
    const static byte CMD_NoCmdChange = 0x07;
    const static byte CMD_Receive = 0x08;
    const static byte CMD_Transceive = 0x0C;
    const static byte CMD_MFAuthent = 0x0E;
    const static byte CMD_SoftReset = 0x0F;

    // MIFARE card commands
    const static byte APDU_REQA = 0x26;
    const static byte APDU_WUPA = 0x52;
    const static byte APDU_CT = 0x88;
    const static byte APDU_SEL_CL1 = 0x93;
    const static byte APDU_SEL_CL2 = 0x95;
    const static byte APDU_SEL_CL3 = 0x97;
    const static byte APDU_HLTA = 0x50;
    const static byte APDU_MF_AUTH_KEY_A = 0x60;
    const static byte APDU_MF_AUTH_KEY_B = 0x61;
    const static byte APDU_MF_READ = 0x30;
    const static byte APDU_MF_WRITE = 0xA0;
    const static byte APDU_MF_DECREMENT = 0xC0;
    const static byte APDU_MF_INCREMENT = 0xC1;
    const static byte APDU_MF_RESTORE = 0xC2;
    const static byte APDU_MF_TRANSFER = 0xB0;
    const static byte APDU_UL_WRITE = 0xA2;

    int chipSelect = 0;

    byte ReadReg(byte reg) {
        byte read[2] = {0};
        byte write[2] = {0};
        write[0] = (byte) (0x80 | ((reg << 1) & 0x7E));
        write[1] = 0x00;
        SPIsetup.write_and_read(chipSelect, 2, write, read);
        return read[1];
    }

    void ReadReg(byte reg, byte count, byte *values) {
        count++;
        byte out[30] = {0};
        byte in[30] = {0};
        for (int i = 0; i < count - 1; i++) {
            out[i] = (byte) (0x80 | ((reg << 1) & 0x7E));
        }
        out[count] = 0x00;
        SPIsetup.write_and_read(chipSelect, count, out, in);
        for (int i = 0; i < count; i++) {
            values[i] = in[i + 1];
        }
    }

    void WriteReg(byte reg, byte value) {
        byte read[2] = {0};
        byte write[2] = {0};
        write[0] = (byte) ((reg << 1) & 0x7E);
        write[1] = value;
        SPIsetup.write_and_read(chipSelect, 2, write, read);
    }

    void WriteReg(byte reg, byte count, byte *values) {
        count++;
        byte out[30] = {0};
        for (int i = 1; i < count; i++) {
            out[i] = values[i - 1];
        }
        out[0] = (byte) ((reg << 1) & 0x7E);
        SPIsetup.write_and_read(chipSelect, count, out, nullptr);
    }

    void ClearBitMask(byte reg, byte mask) {
        byte tmp = ReadReg(reg);
        WriteReg(reg, tmp & (~mask));
    }

    void SetBitMask(byte reg, byte mask) {
        byte tmp = ReadReg(reg);
        WriteReg(reg, tmp | mask);
    }

    void Reset() {
        WriteReg(CommandReg, CMD_SoftReset);
        delay(50);
        while (ReadReg(CommandReg) & 0x08) {
        }
    }

    bool Communicate(byte command,
                     byte *sendData,
                     byte sendLen,
                     byte *backData = nullptr,
                     byte *backLen = nullptr,
                     byte *validBits = nullptr,
                     bool checkCRC = false) {
        byte waitIRq = 0, n, _validBits = 0;

        byte bitFraming = (byte) (validBits ? *validBits : 0);

        if (command == CMD_Transceive) {
            waitIRq = 0x30;
        } else if (command == CMD_MFAuthent) {
            waitIRq = 0x10;
        }
        WriteReg(CommandReg, CMD_Idle);

        WriteReg(ComIrqReg, 0x7F);
        SetBitMask(FIFOLevelReg, 0x80);
        WriteReg(FIFODataReg, sendLen, sendData);
        WriteReg(BitFramingReg, bitFraming);
        WriteReg(CommandReg, command);
        if (command == CMD_Transceive) {
            SetBitMask(BitFramingReg, 0x80);
        }

        for (int i = 2000; i > 0;) {
            n = ReadReg(ComIrqReg);
            if (n & waitIRq) {
                break;
            }
            if (n & 0x01) {
                return 0;
            }
            if (--i == 0) {
                return 0;
            }
        }

        byte errorRegValue = ReadReg(ErrorReg);
        if (errorRegValue & 0x13) {
            return 0;
        }

        if (backData && backLen) {
            n = ReadReg(FIFOLevelReg);
            if (n > *backLen || n == 0) {
                return 0;
            }
            *backLen = n;
            ReadReg(FIFODataReg, n, backData);
            _validBits = (byte) (ReadReg(ControlReg) & 0x07);
            if (validBits) {
                *validBits = _validBits;
            }
        }

        if (errorRegValue & 0x08) {
            return 0;
        }

        if (backData && backLen && checkCRC) {
            byte controlBuffer[2];
            if (!calculate_crc(&backData[0], (byte) (*backLen - 2), &controlBuffer[0])) {
                return 0;
            }
            if ((backData[*backLen - 2] != controlBuffer[0]) || (backData[*backLen - 1] != controlBuffer[1])) {
                return 0;
            }
        }
        return 1;
    }

    bool calculate_crc(byte *data, int  [MASK] , byte *result) {
        WriteReg(CommandReg, CMD_Idle);
        WriteReg(DivIrqReg, 0x04);
        SetBitMask(FIFOLevelReg, 0x80);
        WriteReg(FIFODataReg,  [MASK] , data);
        WriteReg(CommandReg, CMD_CalcCRC);

        int i = 5000;
        byte n;
        while (1) {
            n = ReadReg(DivIrqReg);
            if (n & 0x04) {
                break;
            }
            if (--i == 0) {
                return 0;
            }
        }
        WriteReg(CommandReg, CMD_Idle);
        result[0] = ReadReg(CRCResultRegL);
        result[1] = ReadReg(CRCResultRegH);
        return 1;
    }

#ifdef HWLIB_H
    SPIsetupClass& SPIsetup;

public:
    /**
     * Setup the chip with chipselect number.
     *
     * /param SPI The SPIsetupClass object to use.
     * /param chipSelect The chipselect number where the chip is commected to0 Default = 0.
     */
    MFRC522(SPIsetupClass& SPI, int chipSelect = 0)
        : SPIsetup(SPI)
    {
        this->chipSelect = chipSelect;
    }
#else
public:
#endif

    /**
     * Setup the chip with chipselect number.
     *
     * /param chipSelect The chipselect number where the chip is commected to0 Default = 0.
     */
    void begin(int chipSelect = 0) {
#ifdef _SPI_H_INCLUDED
        SPIsetup.begin();
#endif
        this->chipSelect = chipSelect;

        if (SPIsetup.readReset() == 0) {
            SPIsetup.writeReset(1);
            delay(50);
        } else {
            Reset();
        }

        WriteReg(TModeReg, 0x80);
        WriteReg(TPrescalerReg, 0x9A);
        WriteReg(TReloadRegH, 0x03);
        WriteReg(TReloadRegL, 0xE8);

        WriteReg(TxASKReg, 0x40);
        WriteReg(ModeReg, 0x3D);

        byte value = ReadReg(TxControlReg);
        if ((value & 0x03) != 0x03) {
            SetBitMask(TxControlReg, 0x03);
        }
    }

    /**
     * Detect if there is an card to communicate with.
     *
     */
    bool DetectCard() {
        byte buffer[2];
        byte len = sizeof(buffer);
        byte validBits = 7;

        ClearBitMask(CollReg, 0x80);
        byte command[1] = {0x26};
        if (!Communicate(CMD_Transceive, command, 1, buffer, &len, &validBits)) {
            return 0;
        }
        if (len != 2 || validBits != 0) {
            return 0;
        }
        return 1;
    }

    /**
     * Get the id of the card that is detected.
     *
     * /param uid An array of bytes of the cards ID.
     */
    bool GetCardId(byte *uid) {
        byte buffer[9];
        byte backLen = 9;

        ClearBitMask(CollReg, 0x80);
        WriteReg(BitFramingReg, 0);
        buffer[0] = 0x93;
        buffer[1] = 0x20;

        if (!Communicate(CMD_Transceive, buffer, (byte) 2, buffer, &backLen, 0)) {
            return 0;
        }
        for (int i = 0; i < 4; i++) {
            uid[i] = buffer[i];
        }

        return 1;
    }

    /**
     * Select the card to communicate with.
     *
     * /param uid An array of bytes of the cards ID to select.
     */
    bool SelectCard(byte *uid) {
        byte index = 2;
        byte buffer[9];
        byte *responseBuffer;
        byte responseLength;

        ClearBitMask(CollReg, 0x80);

        buffer[0] = APDU_SEL_CL1;
        buffer[1] = 0x70;

        for (int count = 0; count < 4; count++) {
            buffer[index++] = uid[count];
        }

        buffer[6] = buffer[2] ^ buffer[3] ^ buffer[4] ^ buffer[5];
        if (!calculate_crc(buffer, 7, &buffer[7])) {
            return 0;
        }

        responseBuffer = &buffer[6];
        responseLength = 3;

        if (!Communicate(CMD_Transceive, buffer, 9, responseBuffer, &responseLength)) {
            return 0;
        }

        if (responseLength != 3) {
            return 0;
        }
        if (!calculate_crc(responseBuffer, 1, &buffer[2])) {
            return 0;
        }
        if ((buffer[2] != responseBuffer[1]) || (buffer[3] != responseBuffer[2])) {
            return 0;
        }
        return 1;
    }

    /**
     * Authenticate your self to get access to the data.
     *
     * /param authType The type to authenticate your self with. Types are 0x60 and 0x61.
     * /param blockAddr The block address to authenticate.
     * /param key The 6 byte array to authenticate your self with.
     * /param uid An array of bytes of the cards ID to authenticate.
     */
    bool Authenticate(byte authType, byte blockAddr, byte *key, byte *uid) {
        byte sendData[12];
        sendData[0] = authType;
        sendData[1] = blockAddr;
        for (byte i = 0; i < 6; i++) {
            sendData[2 + i] = key[i];
        }
        for (byte i = 0; i < 4; i++) {
            sendData[8 + i] = uid[i];
        }
        return Communicate(CMD_MFAuthent, &sendData[0], sizeof(sendData));
    }

    /**
     * Locks the card again.
     */
    bool Deauthenticate() {
        byte buffer[4] = {APDU_HLTA, 0x00};
        if (!calculate_crc(buffer, 2, &buffer[2])) {
            return 0;
        }
        byte n;
        WriteReg(CommandReg, CMD_Idle);
        WriteReg(ComIrqReg, 0x7F);
        SetBitMask(FIFOLevelReg, 0x80);
        WriteReg(FIFODataReg, 4, buffer);
        WriteReg(BitFramingReg, 0x00);
        WriteReg(CommandReg, CMD_Transceive);
        SetBitMask(BitFramingReg, 0x80);

        for (int i = 2000; i > 0;) {
            n = ReadReg(ComIrqReg);
            if (n & 0x30) {
                break;
            }
            if (n & 0x01) {
                ClearBitMask(Status2Reg, 0x08);
                return 1;
            }
            if (--i == 0) {
                ClearBitMask(Status2Reg, 0x08);
                return 1;
            }
        }
        return 0;
    }

    /**
     * Reads the block of the selected card.
     *
     * /param block_address The block address that you want to read.
     * /param data An 16 byte array to put the data in from the card.
     * /param dataLen The size of the data array.
     */
    bool ReadBlock(byte block_address, byte *data, byte &dataLen) {
        if (data == nullptr || dataLen > 16) {
            return 0;
        }

        byte buf[4] = {0};
        byte responseData[18] = {0};
        byte responseLen = 18;
        buf[0] = APDU_MF_READ;
        buf[1] = block_address;
        calculate_crc(buf, 2, &buf[2]);
        if (Communicate(CMD_Transceive, buf, 4, responseData, &responseLen)) {
            for (int i = 0; i < dataLen; ++i) {
                data[i] = responseData[i];
            }
            return 1;
        }
        return 0;
    }

    /**
     * Reads the block of the selected card.
     *
     * /param block_address The block address that you want to write.
     * /param data An 16 byte array to write to the card.
     * /param dataLen The size of the data array.
     */
    bool WriteBlock(byte blockAddr, byte *dataToWrite, byte dataLen) {
        if (dataToWrite == nullptr || dataLen != 16) {
            return 0;
        }
        byte bufLen = 4;
        byte validBits = 0;
        byte buf[4] = {APDU_MF_WRITE, blockAddr};
        if (!calculate_crc(buf, 2, &buf[2])) {
            return 0;
        }
        if (!Communicate(CMD_Transceive, buf, 4, buf, &bufLen, &validBits)) {
            return 0;
        }
        if (bufLen != 1 || validBits != 4) {
            return 0;
        }
        if (buf[0] != 0xA) {
            return 0;
        }

        byte writebuf[18] = {0};

        for (int i = 0; i < dataLen; ++i) {
            writebuf[i] = dataToWrite[i];
        }
        if (!calculate_crc(writebuf, dataLen, &writebuf[dataLen])) {
            return 0;
        }
        dataLen += 2;

        byte writebufLen = 18;
        validBits = 0;
        if (!Communicate(CMD_Transceive, writebuf, dataLen, writebuf, &writebufLen, &validBits)) {
            return 0;
        }

        if (writebufLen != 1 || validBits != 4) {
            return 0;
        }
        if (writebuf[0] != 0xA) {
            return 0;
        }
        return 1;
    }

    /**
     * Get the version of the firmware of the chip.
     */
    byte getFirmwareVersion() {

        byte v = ReadReg(VersionReg);
        return v;
    }
};

#endif
",length
348,"
//
// MakeMacRom - Helps build a custom ROM file for an emulated 68k Mac
//
// Written in 2017 by <NAME> <<EMAIL>>
//
// To the extent possible under law, the author(s) have dedicated all copyright
// and related and neighboring rights to this software to the public domain
// worldwide. This software is distributed without any warranty.
//
// You should have received a copy of the CC0 Public Domain Dedication along
// with this software. If not, see
// <http://creativecommons.org/publicdomain/zero/1.0/>.
//

#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stdexcept>
#include <vector>

// RomWriteError - thrown when an invalid write occurs, when building a Mac .rom file 
struct RomWriteError : std::exception {
    std::string _errorMessage;

    RomWriteError(const char * errorName, size_t errorAt, size_t writeStart, size_t writeSize) {
        std::ostringstream os;
        os << std::hex;
        os << errorName << "" at 0x"" << (errorAt)
           << "", via 0x"" << writeSize << "" byte write""
           << "" starting at 0x"" << writeStart;
        _errorMessage = os.str();
    }

    virtual const char* what() const noexcept {
        return _errorMessage.c_str();
    }
};

// RomWriter - utility class for writing binary data to a file, without overlaps
//
// Attempts to overwrite data, or write data past the end of _data's size, will
// result in an exception being thrown, of type RomWriteError.
struct RomWriter {
    // ROM data to-be
    std::vector<uint8_t> _data;

    // Record of already-written bytes; same size as _data; each
    // element is 0 if unwritten, or 1 if written.  All elements are initially
    // 0.  Elements are set to 1 as writes occur to _data.
    std::vector<uint8_t> _writtenBytes;

    // Constructor
    RomWriter(size_t sizeInBytes) :
        _data(sizeInBytes, 0x00),
        _writtenBytes(sizeInBytes, 0x00)
    {
    }

    // Basic accessors
    uint8_t * data()            { return _data.data(); }
    uint8_t * writtenBytes()    { return _writtenBytes.data(); }
    size_t size() const         { return _data.size(); }

    // Write the contents of a separate file, to _data
    void WriteFromFile(size_t offset, const char * fileName) {
        // Open file, or bail
        FILE * file = fopen(fileName, ""r"");
        if ( ! file) {
            fprintf(stderr, ""ERROR: Unable to open code file for reading. Reason: %s\n"",
                strerror(errno));
            std::exit(1);
        }

        // Get size of file
        fseek(file, 0, SEEK_END);
        size_t fileSize = ftell(file);
        fseek(file, 0, SEEK_SET);

        // Ensure valid write, bailing if not
        CheckWrite(offset, fileSize);

        // Copy file to data
        printf(""INFO: writing 0x%x bytes at 0x%x, from \""%s\""\n"",
            (int)fileSize,
            (int)offset,
            fileName
        );
        fread((data() + offset), fileSize, 1, file);

        // Read is done.  Clean up.
        fclose(file);
    }

    // Writes a set of bytes to _data
    void WriteBytes(size_t offset, std::initializer_list<uint8_t> bytes) {
        CheckWrite(offset, bytes.size());
        memcpy(data() + offset, bytes.begin(), bytes.size());
        memset(writtenBytes() + offset, 1, bytes.size());
    }

    // Called before every write, this will lead to program-error if a
    // double-write is detected, on a specific byte within _data.
    void CheckWrite(size_t offset, size_t  [MASK] ) {
        if ((offset +  [MASK] ) > size()) {
            throw RomWriteError(""write past end of ROM"", size(), offset,  [MASK] );
        }

        for (size_t i = 0; i <  [MASK] ; ++i) {
            if ((writtenBytes() + offset)[i] != 0) {
                throw RomWriteError(""double-write"", offset + i, offset,  [MASK] );
            }
        }
    }
};

int main(int argc, char ** argv) {
    if (argc < 3) {
        fprintf(stderr, ""Usage: %s OUTPUT_FILE INPUT_COMPILED_CODE\n\n"",
            argc > 0 ? argv[0] : ""makerom"");
        return 1;
    }

    FILE * outFile = fopen(argv[1], ""w"");
    if ( ! outFile) {
        fprintf(stderr, ""ERROR: Unable to open output file for writing. Reason: %s\n"",
            strerror(errno));
        return 1;
    }

    try {
        // Setup for a 512 KB .rom file
        RomWriter writer(1024 * 512);

        // Write: initial PC (Program Counter) value
        fprintf(stderr, ""INFO: writing initial PC (Program Counter)\n"");
        writer.WriteBytes(0x4, {0x00, 0x40, 0x00, 0x2a});

        // Write: compiled code
        writer.WriteFromFile(0x2a, argv[2]);

        // Finish writing ROM to disk
        fwrite(writer.data(), writer.size(), 1, outFile);
        fclose(outFile);
        fprintf(stderr, ""INFO: Rom successfully written to: %s\n"", argv[1]);
    }
    catch (const std::exception & ex) {
        fprintf(stderr, ""ERROR: %s\n"", ex.what());
        return 1;
    }

    return 0;
}
",numBytes
349,"#include <iostream>
#include <iomanip>
#include <string>
#include <openssl/conf.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include <openssl/aes.h>

void handleErrors(void) {
    ERR_print_errors_fp(stderr);
    abort();
}

int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key, unsigned char *iv, unsigned char *ciphertext) {
    EVP_CIPHER_CTX *ctx;

    int len;
    int ciphertext_len;

    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();

    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();

    if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len)) handleErrors();
    ciphertext_len = len;

    if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();
    ciphertext_len += len;

    EVP_CIPHER_CTX_free(ctx);

    return ciphertext_len;
}

int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext) {
    EVP_CIPHER_CTX *ctx;

    int len;
    int plaintext_len;

    if (!(ctx = EVP_CIPHER_CTX_new())) handleErrors();

    if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();

    if (1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len)) handleErrors();
    plaintext_len = len;

    if (1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors();
    plaintext_len += len;

    EVP_CIPHER_CTX_free(ctx);

    return plaintext_len;
}

int main() {
    unsigned char *key = (unsigned char *)""01234567890123456789012345678901""; // 256-bit key
    unsigned char *iv = (unsigned char *)""0123456789012345""; // 128-bit IV

    std::string  [MASK] ;
    std::cout << ""Enter a string to encrypt: "";
    std::getline(std::cin,  [MASK] );

    std::string seed_string = ""<KEY>"";

    unsigned char *plaintext = (unsigned char *) [MASK] .c_str();
    unsigned char ciphertext[128];
    unsigned char decryptedtext[128];

    int ciphertext_len = encrypt(plaintext, strlen((char *)plaintext), key, iv, ciphertext);

    std::cout << ""Ciphertext is: "";
    for (int i = 0; i < ciphertext_len; i++)
        std::cout << std::hex << std::setfill('0') << std::setw(2) << (int)ciphertext[i];
    std::cout << std::endl;

    int decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv, decryptedtext);
    decryptedtext[decryptedtext_len] = '\0';

    std::cout << ""Decrypted text is: "" << decryptedtext << std::endl;

    return 0;
}
",input
350,"// #include <iostream>
// #include <fstream>
// #include <string.h>
// #include <unistd.h>
// #include <sys/stat.h>
// #include <dirent.h>
// #include <ctime>
// #include <cstdlib>
// #include <random>
// #include <math.h>
// #include <iostream>
// #include <set>
// #include <map>
// #include <string>
// #include <algorithm>
// #include <sstream>
#include ""predictRatio.h""

#define EPS 0.00000000001



const std::string SZ_EXEC = ""/lcrc/project/ECP-EZ/hasan/workstation/github-repos/Mine/Ratio-estimation/v-latest/baselines/SZ3-predict-2022/build/install/bin/sz3"";
const std::string SZ_CONFIG_FILE = ""/lcrc/project/ECP-EZ/hasan/workstation/github-repos/Mine/Ratio-estimation/v-latest/baselines/SZ3-predict-2022/examples/sz3.config"";
const std::string WHITESPACE = "" \n\r\t\f\v"";


//////// Utilities start /////////
struct Data {
	float eb;
	float ratio;
};

// bool custom_compare(const Data &a, const Data &b) {
// 	if ( std::fabs(a.ratio - b.ratio) < EPS ) {
// 		return a.eb < b.eb;
// 	}
// 	else {
// 		return a.ratio < b.ratio;
// 	}
// }

std::string ltrim(const std::string &s)
{
    size_t start = s.find_first_not_of(WHITESPACE);
    return (start == std::string::npos) ? """" : s.substr(start);
}

std::string rtrim(const std::string &s)
{
    size_t end = s.find_last_not_of(WHITESPACE);
    return (end == std::string::npos) ? """" : s.substr(0, end + 1);
}

std::string trim(const std::string &s) {
    return rtrim(ltrim(s));
}


std::vector<std::string> mySplit(std::string const &str, const char delim)
{
    size_t start;
    size_t end = 0;

    std::vector<std::string> out; 
    while ((start = str.find_first_not_of(delim, end)) != std::string::npos)
    {
        end = str.find(delim, start);
        out.push_back(str.substr(start, end - start));
    }

    return out;
}



//////// Utilities end /////////

// stationary point (error bound vs compression ratio)
void predictRatio(const char *datafilePath, 
								const char *splitOnDataPath,
								const int num_dims, 
								const int *dims,
								const char* outputPath)
{

	
	char *command_buffer = (char* )malloc(500 * sizeof(char));

	printf(""\n\n===== %s start======\n"", __func__);
	printf(""dataset file path: %s\n"", datafilePath);
	sprintf(command_buffer, ""mkdir %s/model-output"", outputPath);
	system((const char* ) command_buffer);

	// get the dataset file name
	// example, /home/user/QCLOUDf48.dat --> QCLOUDf48.dat
	char* split=strtok((char*) splitOnDataPath,""/"");
	char* datafileName = NULL;

	while(split != NULL)
	{
		datafileName=split;
		split=strtok(NULL,""/"");
	}

	printf(""datafileName: %s\n"", datafileName);

	// Average 25 error bounds to generate stationary points
	float floating_error_bounds[] = {1e-7, 5e-7, 9e-7,
										1e-6, 3e-6, 5e-6, 7e-6, 9e-6, 
										1e-5, 3e-5, 5e-5, 7e-5, 9e-5,
										1e-4, 3e-4, 5e-4, 7e-4, 9e-4,
										1e-3, 2e-3, 3e-3, 4e-3, 5e-3, 6e-3, 7e-3, 8e-3, 9e-3,
										1e-2, 1.5e-2, 2e-2, 2.5e-2, 3e-2, 3.5e-2, 4e-2, 4.5e-2, 5e-2, 
										5.5e-2, 6e-2, 6.5e-2, 7e-2, 7.5e-2, 8e-2, 8.5e-2, 9e-2, 9.5e-2,
										1e-1, 1.5e-1, 2e-1, 2.5e-1}; 
	


	int num_floating_error_bounds = sizeof(floating_error_bounds) / sizeof(floating_error_bounds[0]);

	



	printf(""Number of floating error bounds = %d\n"", 
		num_floating_error_bounds);

	
	char *rm_buffer = (char* )malloc(500 * sizeof(char));	
	char *output_buffer = (char* )malloc(500 * sizeof(char));	
	sprintf(output_buffer, ""%s/icde22-model-output/sz-compression-info.txt"", outputPath);
	std::string output_sz(output_buffer);
		


	// free
	free(output_buffer);
		
	
	std::string cur_command;

	char *filename_buffer1 = (char* )malloc(500 * sizeof(char));

	// sz
	sprintf(filename_buffer1, ""%s/icde22-model-output/model-output-%s.csv"", outputPath, datafileName);
	std::string csv_cmd = ""rm -f ""; csv_cmd += filename_buffer1;
	system(csv_cmd.c_str());
	std::fstream fout_sz;
	


	std::vector<Data> sz_data;
	std::fstream extractFile;
	std::string  [MASK] ;

	for (int id = 0; id < num_floating_error_bounds; id++){
		float cur_eb = floating_error_bounds[id];
		
					
		
		fout_sz.open((const char* )filename_buffer1, std::fstream::out | std::fstream::app);

		

		// sz
		sprintf(command_buffer, ""%s -f -i %s -z %s.sz -%d"", SZ_EXEC.c_str(), datafilePath, datafilePath, num_dims);
		cur_command = """"; cur_command += command_buffer;
		for (int i = num_dims-1; i >= 0; i--) {
			cur_command += "" "";
			cur_command += std::to_string(dims[i]);
		}
		sprintf(command_buffer, "" -c %s -M REL %.12f &> %s"", SZ_CONFIG_FILE.c_str(), cur_eb, output_sz.c_str());
		cur_command += command_buffer;
		printf(""command: %s\n"", cur_command.c_str());
		system(cur_command.c_str());


		extractFile.open(output_sz, std::ios::in);
	

		float sz_cratio = 0.0;
		while (std::getline(extractFile,  [MASK] )) {
			if ( [MASK] .find(""Predicted compression ratio"") != std::string::npos){ 
				
				sz_cratio = std::stof(trim(mySplit( [MASK] , ':')[1]));
				break;
			}
		}	

		extractFile.close();


		if (sz_cratio > 0.0) {
			sz_data.push_back({cur_eb, sz_cratio});				
			printf(""==== model finished execution [eb %.10f, cratio: %.4f] ======\n\n\n"", cur_eb, sz_cratio);
		}	

					
		
		//
		std::vector<Data>:: iterator it;


		for(it = sz_data.begin(); it != sz_data.end(); it++) {
			float ratio = it->ratio;
			float eb = it->eb;

			fout_sz << eb << "", "" << ratio << ""\n"";
		}


		sz_data.clear();


		fout_sz.close();
	
		

		sprintf(rm_buffer, ""rm %s.sz.out"", datafilePath); 
		system((const char* )rm_buffer);	
		sprintf(rm_buffer, ""rm %s.sz"", datafilePath); 
		system((const char* )rm_buffer);
		system(""rm core.*"");		
		
	}
		

	



	// free all
	free(command_buffer);
	free(filename_buffer1);


	std::vector<Data>().swap(sz_data);

	sprintf(rm_buffer, ""rm %s"", output_sz.c_str());
	system((const char* )rm_buffer);

	free(rm_buffer);
	std::string().swap(output_sz);	
}



// void usage(int id)
// {
// 	printf(""Usage: obtainStationaryPoints -i <dataset file path> -3 <Slowest Mid Fastest> %d\n"", id);
// 	printf(""Example: obtainStationaryPoints -i QCLOUDf48.dat -3 100 500 500"");
// 	exit(0);
// }

// int main(int argc, char *argv[])
// {

// 	size_t i = 0;
// 	int num_dims = 0; 
// 	int* dims = NULL;
// 	char* datafilePath = NULL;
// 	char* splitOnDataPath = NULL;
// 	size_t dim3 = 0;
// 	size_t dim2 = 0; 
// 	size_t dim1 = 0;
// 	int len = 0;

// 	for(i=1;i<argc;i++)
// 	{
// 		if (argv[i][0] != '-' || argv[i][2])
// 			usage(1);
// 		switch (argv[i][1])
// 		{
// 		case '1': 
// 			num_dims = 1;
// 			if (++i == argc || sscanf(argv[i], ""%zu"", &dim1) != 1)
// 				usage(2);
// 			break;
// 		case '2':
// 			num_dims = 2;
// 			if (++i == argc || sscanf(argv[i], ""%zu"", &dim1) != 1 ||
// 				++i == argc || sscanf(argv[i], ""%zu"", &dim2) != 1)
// 				usage(3);
// 			break;
// 		case '3':
// 			num_dims = 3;
// 			if (++i == argc || sscanf(argv[i], ""%zu"", &dim1) != 1 ||
// 				++i == argc || sscanf(argv[i], ""%zu"", &dim2) != 1 ||
// 				++i == argc || sscanf(argv[i], ""%zu"", &dim3) != 1)
// 				usage(4);		
// 			break;
// 		case 'i':
// 			if (++i == argc)
// 				usage(5);
// 			datafilePath = argv[i];	
// 			while (argv[i][len] != '\0') len++;
// 			splitOnDataPath = (char* ) malloc(sizeof(char) * len);
// 			strcpy(splitOnDataPath, datafilePath);
// 			break;
// 		default: 
// 			usage(6);
// 			break;
// 		}
// 	}
	
// 	dims = (int*)malloc(sizeof(int) * num_dims);
// 	dims[0] = dim1;
// 	dims[1] = dim2;
// 	dims[2] = dim3;
	
// 	generate_sz_stationary_points(datafilePath, splitOnDataPath, num_dims, dims);

// 	// free
// 	// if (datafilePath) free(datafilePath);
// 	if (splitOnDataPath) free(splitOnDataPath);
// 	// if (dims) free(dims);
// 	return 0;
// }
",extractLine
351,"// src/Bird.cpp
#include ""../include/Bird.h""

Bird::Bird(const float startX, const float startY, const float birdSpeed, const std::vector<Texture2D>& frames)
    : position({startX, startY}),
      speed(birdSpeed),
      collisionRect({startX, startY, 30, 20}),
      flyFrames(frames),
      currentFrame(0),
      frameTimeCounter(0.0f),
      frameSpeed(0.15f)
{
    collisionRect = {
        position.x,
        position.y,
        static_cast<float>(flyFrames[0].width),
        static_cast<float>(flyFrames[0].height)
    };
}

Bird::~Bird() = default;

// 更新鸟的状态，每帧调用
void Bird::Update(const float deltaTime)
{
    // 根据速度和时间差更新鸟的X轴位置 (向左移动)
    position.x -= speed * deltaTime;

    // 更新动画帧
    frameTimeCounter += deltaTime;
    if (frameTimeCounter >= frameSpeed)
    {
        frameTimeCounter = 0.0f; // 重置计时器
        currentFrame++; // 切换到下一帧
        if (currentFrame >= flyFrames.size()) // 如果超出最后一帧
        {
            currentFrame = 0; // 回到第一帧，实现循环动画
        }
    }
    // 更新碰撞矩形的位置和大小
    UpdateCollisionRect();
}

// 绘制鸟
void Bird::Draw() const
{
    // 绘制当前动画帧的纹理
    DrawTexture(flyFrames[currentFrame], static_cast<int>(position.x), static_cast<int>(position.y), WHITE);
}

// 更新碰撞矩形的位置和大小，使其与鸟的当前状态同步
void Bird::UpdateCollisionRect()
{
    collisionRect.x = position.x;
    collisionRect.y = position.y;
    collisionRect.width = GetWidth(); // 使用GetWidth获取当前帧的宽度
    collisionRect.height = GetHeight(); // 使用GetHeight获取当前帧的高度
}

// 获取鸟的碰撞矩形
Rectangle Bird::GetCollisionRect() const
{
    return collisionRect;
}

// 检查鸟是否完全移出屏幕左侧
bool Bird::IsOffScreen() const
{
    // 如果鸟的右边缘小于0 (屏幕最左侧)，则认为其移出屏幕
    return (position.x + GetWidth()) < 0;
}

// 获取鸟的当前宽度
float Bird::GetWidth() const
{
    return static_cast<float>(flyFrames[currentFrame].width);
}

// 获取鸟的当前高度
float Bird::GetHeight() const
{
    return static_cast<float>(flyFrames[currentFrame].height);
}

// 设置鸟的飞行速度
void Bird::setSpeed(const float  [MASK] )
{
    speed =  [MASK] ;
}
",newSpeed
352,"#include ""Paystation.h""
#include <sstream>

Paystation::Paystation(PayStrategy *ps, std::string ap) {
  state_ = new PaystationState{0, 0};
  pay_strategy_ = ps;
  pin_ = ap;
}

int Paystation::insertCoin(const int &coin) {
  switch (coin) {
  case 1:
  case 5:
  case 10:
  case 25:
  case 100:
    state_->balance += coin;
    state_->timePurchased = pay_strategy_->calculate(state_->balance);
    return 0;
  default:
    return coin;
  }
}

PaystationState *Paystation::getState() { return state_; }

std::string Paystation::buy() {
  std::ostringstream s;
  s << ""Total: "" << state_->balance << '\n';
  s << ""Minutes purchased: "" << state_->timePurchased << '\n';
  state_->balance = 0;
  state_->timePurchased = 0;
  return s.str();
}

PayStrategy *Paystation::setPayStrategy(PayStrategy *ps) {
  /* Can be replaced with std::exchange() */
  auto  [MASK]  = pay_strategy_;
  pay_strategy_ = ps;
  return  [MASK] ;
}

bool Paystation::checkAdminPIN(const std::string &pin) { return pin == pin_; }

int Paystation::setAdminPIN(const std::string pin) {
  if (pin == pin_)
    return ERR_SAME_PIN;
  else {
    pin_ = pin;
    return 0;
  }
}
",old
353,"#include ""NN.h""


NN::NN(const int a, const int b, const int c):
NumOfInputNodes(a), NumOfHiddenNodes(b), NumOfOutputNodes(c), weightsIH(new Matrix(NumOfHiddenNodes, NumOfInputNodes)),
weightsHO(new Matrix(NumOfOutputNodes, NumOfHiddenNodes)), biasH(new Matrix(NumOfHiddenNodes, 1)), biasO(new Matrix(NumOfOutputNodes, 1))
{
	weightsIH->randomize();
	weightsHO->randomize();
	
	biasH->randomize();
	biasO->randomize();
}

std::vector<double> NN::predict(const std::vector<double>& input)
{
	Matrix inputs = Matrix::fromArray(input);
	Matrix hidden = *weightsIH * inputs;

	hidden += *biasH;
	hidden.map(d_sigmoid);

	Matrix output = *weightsHO * hidden;
	output += *biasO;
	output.map(d_sigmoid);

	return output.toArray();
}

void NN::train(const std::vector<double>& input, const std::vector<double>& target)
{

	Matrix inputs = Matrix::fromArray(input);
	Matrix hidden = *weightsIH * inputs;
	
	hidden += *biasH;
	hidden.map(d_sigmoid);

	Matrix output = *weightsHO * hidden;
	output += *biasO;
	output.map(d_sigmoid);
	Matrix targets = Matrix::fromArray(target);
	Matrix outputErrors = targets - output;

	Matrix gradients = Matrix::map(output, d_dsigmoid);

	gradients.hadamard(outputErrors);
	gradients * 0.1;

	Matrix  [MASK]  = Matrix::transpose(hidden);
	Matrix weightsHoDeltas = gradients *  [MASK] ;
	*weightsHO += weightsHoDeltas;
	
	*biasO += gradients;

	Matrix weightTranspose = Matrix::transpose(*weightsHO);
	Matrix hiddenErrors = weightTranspose * outputErrors;
	Matrix hiddenGradient = Matrix::map(hidden, d_dsigmoid);
	hiddenGradient.hadamard(hiddenErrors);
	hiddenGradient * 0.1;

	Matrix inputTranspose = Matrix::transpose(inputs);
	Matrix weightIHDeltas = hiddenGradient * inputTranspose;
	*weightsIH += weightIHDeltas;

	*biasH += hiddenGradient;
}

NN::~NN()
{
}
",hiddenTranpose
354,"#include <iostream>

// The lexer returns tokens [0-255] if it is an unknown character, otherwise one
// of these for known things.
enum Token {
	tok_eof = -1,			// EOF
	tok_def = -2,			// Function definition (""def"")
	tok_extern = -3,		// External prototype definition (""extern"")
	tok_identifier = -4,	// String identifier 
	tok_number = -5,		// Int/Double number
};

static std::string identifier;		// Filled in if tok_identifier
static double number;				// Filled in if tok_number

static int gettoken() {
	static int  [MASK]  = ' ';

	// Skip any whitespace.
	while (isspace( [MASK] ))  [MASK]  = getchar();

	// matches regex [a-zA-Z][a-zA-Z0-9]*
	if (isalpha( [MASK] ))
	{
		identifier =  [MASK] ;
		//add all following characters to the identifier
		while (isalnum(( [MASK]  = getchar()))) identifier +=  [MASK] ;

		//return tok_def if it is a definition, else if it is an extern return tok_extern
		if (identifier == ""def"") return tok_def;
		if (identifier == ""extern"") return tok_extern;

		//doesn't match anything, so just return the idenfitier token
		return tok_identifier;
	}

	// matches regex [0-9.]+
	if (isdigit( [MASK] ) ||  [MASK]  == '.') {
		std::string temp;
		do {
			temp +=  [MASK] ;
			 [MASK]  = getchar(); //get next char
		} while (isdigit( [MASK] ) ||  [MASK]  == '.');

		//set the raw value of temp to the number
		number = strtod(temp.c_str(), 0);

		//return tok_number (found a number)
		return tok_number;
	}


	if ( [MASK]  == '#') {
		// Comment until end of line.
		do  [MASK]  = getchar();
		while ( [MASK]  != EOF &&  [MASK]  != '\n' &&  [MASK]  != '\r');

		if ( [MASK]  != EOF)
			return gettoken();
	}
	// Check for end of file.  Don't eat the EOF.
	if ( [MASK]  == EOF) return tok_eof;

	// Otherwise, just return the character as its ascii value.
	int x =  [MASK] ;
	 [MASK]  = getchar();
	return x;
}",currChar
355,"/***************************************************
  This is an example for the AHT10 Humidity & Temp Sensor

  Designed specifically to work with the AHT10, modified using library from:
  Source: https://github.com/enjoyneering/

  These displays use I2C to communicate, 2 pins are required to
  interface
 ****************************************************/

#include <Wire.h>
#include <AHT10.h>
#include <LiquidCrystal.h>

// Connect Vin to 3-5VDC
// Connect GND to ground
// Connect SCL to I2C clock pin (A5 on UNO)
// Connect SDA to I2C data pin (A4 on UNO)

AHT10 myAHT10(0x38);
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  Wire.begin();
  lcd.begin(16,2);
  lcd.setCursor(0,0);
  lcd.print(""Temperature & "");
  lcd.setCursor(0,1);
  lcd.print(""Humidity Meter"");
  delay(2000);
  lcd.clear();
  Serial.begin(9600);
  Serial.println(""AHT10 test"");

  if (!myAHT10.begin()) {
    Serial.println(""Couldn't find sensor!"");
    while (1);
  }
}

void loop() {
    float temp = myAHT10.readTemperature();
    float  [MASK]  = myAHT10.readHumidity();
    Serial.print(""Temp: ""); Serial.print(temp); Serial.print("" C"");
    Serial.print(""\t\t"");
    Serial.print(""Humidity: ""); Serial.print( [MASK] ); Serial.println("" \%"");
    lcd.setCursor(0,0);
    lcd.print(""Temp:"");
    lcd.setCursor(5,0);
    lcd.print(temp);
    lcd.setCursor(10,0);
    lcd.print((char)223);
    lcd.setCursor(11,0);
    lcd.print(""C"");
    lcd.setCursor(0,1);
    lcd.print(""RH:"");
    lcd.setCursor(3,1);
    lcd.print( [MASK] );
    lcd.setCursor(8,1);
    lcd.print(""%"");
    delay(500);
}
",rel_hum
356,"//
// 2017 writen by <EMAIL>
//

#include ""node_binder/base/message_pump_node.h""

#include <algorithm>
#include <set>

#include ""base/lazy_instance.h""
#include ""base/logging.h""
#include ""base/threading/thread_local.h""
#include ""node/uv.h""
#include ""base/debug/stack_trace.h""

namespace base {

namespace {

base::LazyInstance<base::ThreadLocalPointer<MessagePumpNode>>::Leaky
    tls_ptr = LAZY_INSTANCE_INITIALIZER;

void IgnoreReleaseHandle(uv_handle_t* handle) {}

void ReleaseHandle(uv_handle_t* handle) {
  delete handle;
}

void OnPollNotification(uv_poll_t* event, int status, int  [MASK] ) {
  DCHECK(event && event->data);
  MessagePumpNode::FileDescriptorWatcher* controller =
      static_cast<MessagePumpNode::FileDescriptorWatcher*>(event->data);
  DCHECK(controller);
  controller->OnFileEventNotification(event->io_watcher.fd,  [MASK] );
}

}  // anonymouse namespace

MessagePumpNode::FileDescriptorWatcher::FileDescriptorWatcher()
    : pump_(nullptr),
      watcher_(nullptr),
      persistent_(false),
      event_mask_(0) {
}

MessagePumpNode::FileDescriptorWatcher::~FileDescriptorWatcher() {
  StopWatchingFileDescriptor();
}

bool MessagePumpNode::FileDescriptorWatcher::WatchFileDescriptor(
    int fd, bool persistent, int event_mask, MessagePumpNode* pump,
    Watcher* watcher) {
  DCHECK(pump);
  DCHECK(watcher);
  DCHECK_GT(event_mask, 0);
  DCHECK_GT(fd, 0);

  if (event_.get()) {
    event_mask |= event_mask_;
    StopWatchingFileDescriptor();
  }

  event_.reset(new uv_poll_t);
  event_->data = this;

  if (uv_poll_init(uv_default_loop(), event_.get(), fd)) {
    LOG(ERROR) << ""uv_poll_init failed"";
    return false;
  }

  if (uv_poll_start(event_.get(), event_mask, &OnPollNotification)) {
    uv_close(reinterpret_cast<uv_handle_t*>(event_.release()),
             &ReleaseHandle);
    LOG(ERROR) << ""watch file descriptor are failed"";
    return false;
  }

  event_mask_ = event_mask;
  persistent_ = persistent;
  pump_ = pump;
  watcher_ = watcher;

  return true;
}

bool MessagePumpNode::FileDescriptorWatcher::StopWatchingFileDescriptor() {
  // poll event already released
  if (!event_.get()) {
    return true;
  }

  if (uv_poll_stop(event_.get())) {
    LOG(ERROR) << ""uv_poll_stop are failed"";
    return false;
  }

  uv_close(reinterpret_cast<uv_handle_t*>(event_.release()), &ReleaseHandle);

  event_mask_ = 0;
  persistent_ = false;
  pump_ = nullptr;
  watcher_ = nullptr;

  return true;
}

void MessagePumpNode::FileDescriptorWatcher::OnFileEventNotification(
    int fd, int event_mask) {
  DCHECK(pump_);

  if (event_mask & UV_READABLE) {
    OnFileCanReadWithoutBlocking(fd, pump_);
  }

  if (event_mask & UV_WRITABLE) {
    OnFileCanWriteWithoutBlocking(fd, pump_);
  }

  if (!persistent_) {
    StopWatchingFileDescriptor();
  }
}

void MessagePumpNode::FileDescriptorWatcher::OnFileCanReadWithoutBlocking(
    int fd, MessagePumpNode* pump) {
  DCHECK(watcher_);
  watcher_->OnFileCanReadWithoutBlocking(fd);
}

void MessagePumpNode::FileDescriptorWatcher::OnFileCanWriteWithoutBlocking(
    int fd, MessagePumpNode* pump) {
  DCHECK(watcher_);
  watcher_->OnFileCanWriteWithoutBlocking(fd);
}

MessagePumpNode::MessagePumpNode()
  : delegate_(nullptr),
    async_handle_(new uv_async_t),
    timer_handle_(new uv_timer_t),
    message_pump_state_(STATE_IDLE) {
  tls_ptr.Pointer()->Set(this);
}

MessagePumpNode::~MessagePumpNode() {
  tls_ptr.Pointer()->Set(nullptr);
}

// static
MessagePumpNode* MessagePumpNode::current() {
  return tls_ptr.Pointer()->Get();
}

// static
void MessagePumpNode::OnWakeup(uv_async_t* handle) {
  MessagePumpNode* pump = static_cast<MessagePumpNode*>(handle->data);
  DCHECK(pump);
  pump->DoWork();
}

// static
void MessagePumpNode::OnTimeout(uv_timer_t* handle) {
  MessagePumpNode* pump = static_cast<MessagePumpNode*>(handle->data);
  DCHECK(pump);
  pump->DoDelayedWork();
}

// static
void MessagePumpNode::Run(Delegate* delegate) {
  NOTREACHED();
}

void MessagePumpNode::Quit() {
  NOTREACHED();
}

void MessagePumpNode::ScheduleWork() {
  if (uv_async_send(async_handle_.get())) {
    LOG(ERROR) << ""wakeup  async task are failed"";
  }
}

void MessagePumpNode::ScheduleDelayedWork(
    const base::TimeTicks& new_delayed_work_time) {
  // if wait a another timeout event
  if (!delayed_work_time_.is_null()) {
    DCHECK_EQ(message_pump_state_, STATE_RUNNING);
    if (new_delayed_work_time > delayed_work_time_) {
      return;
    }
  }
  delayed_work_time_ = new_delayed_work_time;

  base::TimeDelta delay = delayed_work_time_ - base::TimeTicks::Now();
  delay = std::max(delay, base::TimeDelta());

  if (message_pump_state_ == STATE_RUNNING) {
    uv_timer_stop(timer_handle_.get());
    message_pump_state_ = STATE_STOP;
  }

  DCHECK(message_pump_state_ == STATE_INIT ||
         message_pump_state_ == STATE_STOP);
  uv_timer_start(timer_handle_.get(), OnTimeout, delay.InMilliseconds(), 0);
  message_pump_state_ = STATE_RUNNING;
}

bool MessagePumpNode::WatchFileDescriptor(int fd,
                                          bool persistent,
                                          int mode,
                                          FileDescriptorWatcher* controller,
                                          Watcher* delegate) {
  DCHECK_GT(fd, 0);
  DCHECK(controller);
  DCHECK(delegate);
  DCHECK(mode == WATCH_READ || mode == WATCH_WRITE || mode == WATCH_READ_WRITE);
  DCHECK(thread_checker_.CalledOnValidThread());

  uint32_t event_mask = 0;
  if (mode & WATCH_READ) {
    event_mask |= UV_READABLE;
  }

  if (mode & WATCH_WRITE) {
    event_mask |= UV_WRITABLE;
  }

  controller->WatchFileDescriptor(fd, persistent, event_mask, this, delegate);

  return true;
}

void MessagePumpNode::DoWork() {
  DCHECK(delegate_);

  for (;;) {
    bool did_work = false;
    did_work |= delegate_->DoIdleWork();
    did_work |= delegate_->DoWork();
    if (!did_work) {
      break;
    }
  }
}

void MessagePumpNode::DoDelayedWork() {
  //DCHECK_EQ(message_pump_state_, STATE_RUNNING);
  DCHECK(delegate_);
  if (delayed_work_time_.is_null()) {
    return;
  }

  for (;;) {
    base::TimeDelta delay = delayed_work_time_ - base::TimeTicks::Now();
    if (delay > base::TimeDelta()) {
      uv_timer_start(timer_handle_.get(), OnTimeout,
                     delay.InMilliseconds(), 0);
      break;
    }

    delegate_->DoDelayedWork(&delayed_work_time_);
    if (delayed_work_time_.is_null()) {
      uv_timer_stop(timer_handle_.get());
      message_pump_state_ = STATE_STOP;
      break;
    }
  }
}

void MessagePumpNode::StartAsyncTask() {
  DCHECK_EQ(message_pump_state_, STATE_IDLE);

  async_handle_->data = this;
  CHECK_EQ(uv_async_init(uv_default_loop(), async_handle_.get(),
                         &MessagePumpNode::OnWakeup), 0);

  timer_handle_->data = this;
  CHECK_EQ(uv_timer_init(uv_default_loop(), timer_handle_.get()), 0);

  message_pump_state_ = STATE_INIT;
}

void MessagePumpNode::StopAsyncTask() {
  DCHECK_NE(message_pump_state_, STATE_IDLE);
  uv_close(reinterpret_cast<uv_handle_t*>(async_handle_.get()),
           &IgnoreReleaseHandle);

  CHECK_EQ(uv_timer_stop(timer_handle_.get()), 0);
  uv_close(reinterpret_cast<uv_handle_t*>(timer_handle_.get()),
           &IgnoreReleaseHandle);

  message_pump_state_ = STATE_IDLE;
}

void MessagePumpNode::CloseAsyncTask() {
  if (async_handle_.get()) {
    uv_close(reinterpret_cast<uv_handle_t*>(async_handle_.release()),
             &ReleaseHandle);
  }

  if (timer_handle_.get()) {
    uv_close(reinterpret_cast<uv_handle_t*>(timer_handle_.release()),
             &ReleaseHandle);
  }

  message_pump_state_ = STATE_TERMINATE;
}

}  // namespace base
",flags
357,"#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int diagSum(int n, vector<vector<int>> a){
    int  [MASK]  = 0;
    int sum_secdry = 0;

    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            if (i == j){
                 [MASK]  =  [MASK]  + a[i][j];
            }
        }

        for (int j = n-1; j>=0; j--){
            if ((i + j) == (n - 1)){
                sum_secdry = sum_secdry + a[i][j];
            }
        }
    }
    return abs( [MASK]  - sum_secdry);
}


int main(){
    int n;
    cin >> n;
    vector< vector<int> > a(n,vector<int>(n));
    for(int a_i = 0;a_i < n;a_i++){
        for(int a_j = 0;a_j < n;a_j++){
            cin >> a[a_i][a_j];
        }
    }

    cout << diagSum(n, a) << endl;

    return 0;
}",sum_prmry
358,"// <NAME> - <EMAIL>

#include <iostream>
#include ""Tas.h""
#include ""At.h""

using namespace std;

        At::At(takim renk, int x, int y): Tas(renk, ""At"", x, y){}

    bool At::yolKntrl(vector<Tas*> taslar, pair <int, int>  [MASK] ){

        // Gittigi yerde tas olma :
        for(int i = 0; i < taslar.size(); i++){
            if(taslar[i]->getKonum() == this->getKonum()){
                continue;
            }
            if(taslar[i]->getKonum() ==  [MASK] ) {
                if(taslar[i]->getTakim() == this->getTakim()){
                    return false;
                }
            }
        }

        // Kendi yerine oynayamaz :
        if(this->getKonum() ==  [MASK] ){
            return false;
        }

        // Oynanabilecek yerler :
        if(make_pair(this->getKonum().first-2,this->getKonum().second-1) ==  [MASK] ){
            return true;
        } else if(make_pair(this->getKonum().first-2,this->getKonum().second+1) ==  [MASK] ){
            return true;
        } else if(make_pair(this->getKonum().first-1,this->getKonum().second-2) ==  [MASK] ){
            return true;
        }else if(make_pair(this->getKonum().first-1,this->getKonum().second+2) ==  [MASK] ){
            return true;
        }else if(make_pair(this->getKonum().first+1,this->getKonum().second-2) ==  [MASK] ){
            return true;
        }else if(make_pair(this->getKonum().first+1,this->getKonum().second+2) ==  [MASK] ){
            return true;
        }else if(make_pair(this->getKonum().first+2,this->getKonum().second-1) ==  [MASK] ){
            return true;
        }else if(make_pair(this->getKonum().first+2,this->getKonum().second+1) ==  [MASK] ){
            return true;
        } else{
            return false;
        }
    }
",gidilecekyer
359,"#include ""InputHelper.h""

static const char* styleNames[] = {
    ""Pro Controller"",
    ""Joy-Con controller in handheld mode"",
    ""Joy-Con controller in dual mode"",
    ""Joy-Con left controller in single mode"",
    ""Joy-Con right controller in single mode"",
    ""GameCube controller"",
    ""Poké Ball Plus controller"",
    ""NES/Famicom controller"",
    ""NES/Famicom controller in handheld mode"",
    ""SNES controller"",
    ""N64 controller"",
    ""Sega Genesis controller"",
    ""generic external controller"",
    ""generic controller"",
};

nn::hid::NpadBaseState InputHelper::prevControllerState {};
nn::hid::NpadBaseState InputHelper::curControllerState {};

ulong InputHelper::selectedPort = -1;
bool InputHelper::isReadInput = true;
bool InputHelper::toggleInput = false;
bool InputHelper::disableMouse = false;

const char* getStyleName(nn::hid::NpadStyleSet style) {
    s32  [MASK]  = -1;

    if (style.Test((int)nn::hid::NpadStyleTag::NpadStyleFullKey)) {
         [MASK]  = 0;
    }
    if (style.Test((int)nn::hid::NpadStyleTag::NpadStyleHandheld)) {
         [MASK]  = 1;
    }
    if (style.Test((int)nn::hid::NpadStyleTag::NpadStyleJoyDual)) {
         [MASK]  = 2;
    }
    if (style.Test((int)nn::hid::NpadStyleTag::NpadStyleJoyLeft)) {
         [MASK]  = 3;
    }
    if (style.Test((int)nn::hid::NpadStyleTag::NpadStyleJoyRight)) {
         [MASK]  = 4;
    }
    if (style.Test((int)nn::hid::NpadStyleTag::NpadStyleSystemExt)) {
         [MASK]  = 12;
    }
    if (style.Test((int)nn::hid::NpadStyleTag::NpadStyleSystem)) {
         [MASK]  = 13;
    }

    if ( [MASK]  != -1) {
        return styleNames[ [MASK] ];
    } else {
        return ""Unknown"";
    }
}

void InputHelper::updatePadState() {
    prevControllerState = curControllerState;
    tryGetContState(&curControllerState, selectedPort);
}

bool InputHelper::tryGetContState(nn::hid::NpadBaseState* state, ulong port) {
    nn::hid::NpadStyleSet styleSet = nn::hid::GetNpadStyleSet(port);
    isReadInput = true;
    bool result = true;

    if (styleSet.Test((int)nn::hid::NpadStyleTag::NpadStyleFullKey)) {
        nn::hid::GetNpadState((nn::hid::NpadFullKeyState*)state, port);
    } else if (styleSet.Test((int)nn::hid::NpadStyleTag::NpadStyleHandheld)) {
        nn::hid::GetNpadState((nn::hid::NpadHandheldState*)state, port);
    } else if (styleSet.Test((int)nn::hid::NpadStyleTag::NpadStyleJoyDual)) {
        nn::hid::GetNpadState((nn::hid::NpadJoyDualState*)state, port);
    } else if (styleSet.Test((int)nn::hid::NpadStyleTag::NpadStyleJoyLeft)) {
        nn::hid::GetNpadState((nn::hid::NpadJoyLeftState*)state, port);
    } else if (styleSet.Test((int)nn::hid::NpadStyleTag::NpadStyleJoyRight)) {
        nn::hid::GetNpadState((nn::hid::NpadJoyRightState*)state, port);
    } else {
        result = false;
    }

    isReadInput = false;

    return result;
}

bool InputHelper::isButtonHold(nn::hid::NpadButton button) {
    return curControllerState.mButtons.Test((int)button);
}

bool InputHelper::isButtonPress(nn::hid::NpadButton button) {
    return curControllerState.mButtons.Test((int)button) && !prevControllerState.mButtons.Test((int)button);
}

bool InputHelper::isButtonRelease(nn::hid::NpadButton button) {
    return !curControllerState.mButtons.Test((int)button) && prevControllerState.mButtons.Test((int)button);
}",index
360,"#include <signal.h>

#include <cstring>
#include <iostream>
#include <memory>
#include <string>

#include ""FreeRTOS.h""
#include ""boost/program_options.hpp""
#include ""bootloader/core/message_handler.h""
#include ""bootloader/core/node_id.h""
#include ""can/core/ids.hpp""
#include ""can/simlib/sim_canbus.hpp""
#include ""common/core/logging.h""
#include ""task.h""

namespace po = boost::program_options;

static CANNodeId g_node_id = can_nodeid_pipette_left_bootloader;

/** The simulator's bootloader */
CANNodeId get_node_id(void) { return g_node_id; }

/**
 * Handle a new can message
 * @param cb_data callback data
 * @param identifier arbitration id
 * @param data data
 * @param length length of data
 */
void on_can_message(void* ctx, uint32_t identifier, uint8_t* data,
                    uint8_t length) {
    Message message;
    Message response;
    auto* canbus = static_cast<can::sim::bus::SimCANBus*>(ctx);
    message.arbitration_id.id = identifier;
    message.size = length;
    std::memcpy(
        message.data, data,
        std::min(static_cast<std::size_t>(length), sizeof(message.data)));

    auto  [MASK]  = handle_message(&message, &response);
    switch ( [MASK] ) {
        case handle_message_ok:
            LOG(""Message ok. No response"");
            break;
        case handle_message_has_response:
            LOG(""Message ok. Has response"");
            canbus->send(response.arbitration_id.id, response.data,
                         static_cast<CanFDMessageLength>(response.size));
            break;
        case handle_message_error:
            LOG(""Message error."");
            break;
        default:
            LOG(""Unknown return."");
            break;
    }
}

void signal_handler(int signum) {
    LOG(""Interrupt signal (%d) received."", signum);
    exit(signum);
}

auto node_from_arg(std::string const& val) -> CANNodeId {
    if (val == ""pipette_left"") {
        return can_nodeid_pipette_left_bootloader;
    } else if (val == ""pipette_right"") {
        return can_nodeid_pipette_right_bootloader;
    } else if (val == ""gantry_x"") {
        return can_nodeid_gantry_x_bootloader;
    } else if (val == ""gantry_y"") {
        return can_nodeid_gantry_y_bootloader;
    } else if (val == ""head"") {
        return can_nodeid_head_bootloader;
    } else if (val == ""gripper"") {
        return can_nodeid_gripper_bootloader;
    } else {
        throw po::validation_error(po::validation_error::invalid_option_value);
    }
}

// this function is automatically called by program options to validate inputs;
// if it throws, that's a validation failure.
void validate(boost::any& v, std::vector<std::string> const& values, CANNodeId*,
              int) {
    po::validators::check_first_occurrence(v);
    auto const& string_val = po::validators::get_single_string(values);
    // this throws appropriately if the arg is wrong
    v = boost::any(node_from_arg(string_val));
}

auto handle_options(int argc, char** argv) -> po::variables_map {
    auto cmdlinedesc = po::options_description(""simulator for OT-3 pipettes"");
    auto envdesc = po::options_description("""");
    cmdlinedesc.add_options()(""help,h"", ""Show this help message."");
    cmdlinedesc.add_options()(
        ""node,n"",
        po::value<CANNodeId>()->default_value(
            can_nodeid_pipette_left_bootloader),
        ""Which node id to use. Maybe  May be specified in an ""
        ""environment variable called NODE_ID. Accepted values: pipette_left, ""
        ""pipette_right, gantry_x, gantry_y, head, gripper"");
    envdesc.add_options()(""NODE_ID"", po::value<CANNodeId>()->default_value(
                                         can_nodeid_pipette_left_bootloader));
    auto can_arg_xform = can::sim::transport::add_options(cmdlinedesc, envdesc);

    po::variables_map vm;
    po::store(po::parse_command_line(argc, argv, cmdlinedesc), vm);
    if (vm.count(""help"")) {
        std::cout << cmdlinedesc << std::endl;
        std::exit(0);
    }
    po::store(po::parse_environment(
                  envdesc,
                  [can_arg_xform](const std::string& input_val) -> std::string {
                      if (input_val == ""NODE_ID"") {
                          return ""node"";
                      };
                      return can_arg_xform(input_val);
                  }),
              vm);
    po::notify(vm);
    return vm;
}

int main(int argc, char** argv) {
    signal(SIGINT, signal_handler);
    LOG_INIT(""BOOTLOADER"", []() -> const char* {
        return pcTaskGetName(xTaskGetCurrentTaskHandle());
    });

    auto options = handle_options(argc, argv);
    auto canbus = std::make_shared<can::sim::bus::SimCANBus>(
        can::sim::transport::create(options));
    g_node_id = options[""node""].as<CANNodeId>();
    LOG(""Running bootloader for node id %d"", g_node_id);
    canbus->setup_node_id_filter(static_cast<can::ids::NodeId>(get_node_id()));
    canbus->set_incoming_message_callback(canbus.get(), on_can_message);

    vTaskStartScheduler();
}
",handle_message_return
361,"#include <SFML/Graphics.hpp>
#include <iostream>
#include <fstream>
#include <sstream>

struct RGB
{
public:

    int red;
    int green;
    int blue;

public:

    RGB() = default;

    RGB(int r, int g, int b) : red(r), green(g), blue(b) {}

    ~RGB() {}

};

class AShape 
{
public:
   
    sf::Shape* shape;
    std::string shapeName;
    int shapeTag;
    RGB rgbVal;
    float radius;
    sf::Vector2f dimensions;
    sf::Vector2f initPosition;
    sf::Vector2f speed;

public:

    AShape() = default;

    AShape(std::string inputData) 
    {
       
        // Sort inputData
        // Create an input string stream from the given string
        std::istringstream dataStream(inputData);
        std::vector<std::string> dataElements;
        std::string element;

        while (dataStream >> element) 
        {
            dataElements.push_back(element);
        }

                   
        // Assign data
        if (!dataElements.empty())
        {
            if (dataElements[0] == (""Circle""))
            {
                radius = std::stof(dataElements[9]);
                shape = new sf::CircleShape(radius);
                shapeTag = 1;
                
            }
            else if (dataElements[0] == (""Rectangle""))
            {
                dimensions = sf::Vector2f(std::stof(dataElements[9]), std::stof(dataElements[10]));
                shape = new sf::RectangleShape(dimensions);
                shapeTag = 2;
               
            }

           
            shapeName = dataElements[1];
            initPosition = sf::Vector2f(std::stof(dataElements[2]), std::stof(dataElements[3]));
            speed = sf::Vector2f(std::stof(dataElements[4]), std::stof(dataElements[5]));

            rgbVal.red = std::stoi(dataElements[6]);
            rgbVal.green = std::stoi(dataElements[7]);
            rgbVal.blue = std::stoi(dataElements[8]);

            shape->setFillColor(sf::Color(rgbVal.red, rgbVal.green, rgbVal.blue));
            shape->setPosition(initPosition);
        }
    }

    ~AShape() 
    {
        if (shape != nullptr)
        {
            delete shape;
        }
        else
        {
            std::cout << ""shape is nullptr"" << std::endl;
        }      
    }
  
};

int main(int argc, char* argv[])
{
    // Get Config.txt
    std::string filePath = ""D:/SFML_GameEngine/Config.txt"";
    std::ifstream inputFile(filePath);
    sf::Font inputFont;

    // Import font 
    if (!inputFont.loadFromFile(""D:/SFML_GameEngine/Fonts/Dosis/Dosis.ttf""))
    {
        std::cerr << ""Error opening the font file."" << std::endl;
        return 1; 
    }

    // Check if the data file is open successfully
    if (!inputFile.is_open()) 
    {
        std::cerr << ""Error opening the data file: "" << filePath << std::endl;
        return 2; 
    }

    // Read and print the contents of the file
    std::string windowLine;
    std::string line;
    int lineNumber = 0;
    std::vector<std::string> lines = {};

    while (std::getline(inputFile, line)) 
    {
        if (lineNumber == 0) 
        {
            windowLine = line;   
        }
        else 
        {
            lines.push_back(line);           
        }

        lineNumber++;
    }

    inputFile.close();

    // Read windowLine and extract values
    std::istringstream inputWindowStream(windowLine);   
    std::vector<std::string>  [MASK] ;    
    std::string windowElement;
    while (inputWindowStream >> windowElement) 
    {
         [MASK] .push_back(windowElement);
    }
   
   
    // Set window properties
    int windowX = std::stoi( [MASK] [1]);
    int windowY = std::stoi( [MASK] [2]);
    sf::RenderWindow window(sf::VideoMode(windowX, windowY), ""Aquarium"");
    window.setFramerateLimit(60);

    // Set text properties
    sf::Text textName;    
    textName.setFont(inputFont);
    textName.setCharacterSize(24);
    textName.setFillColor(sf::Color::White);
    textName.setOutlineColor(sf::Color::Black);
    textName.setOutlineThickness(2.f);
    textName.setPosition(sf::Vector2f(500.f, 500.f));

    sf::Text quitText;
    quitText.setFont(inputFont);
    quitText.setCharacterSize(15);
    quitText.setFillColor(sf::Color::White);
    quitText.setOutlineColor(sf::Color::Black);
    quitText.setOutlineThickness(1.f);
    quitText.setPosition(sf::Vector2f(0.f, windowY - quitText.getCharacterSize() - 5.f));
    quitText.setString(""\"" ESC \"" to quit"");
   
    // Fill vector of shapes
    std::vector<AShape*> shapes = {};   

    for (const auto& line : lines) 
    {
        AShape* shape = new AShape(line);
        shapes.push_back(shape); 
    }


    // Main while loop
    std::cout << ""Start Game"" << std::endl;

    while (window.isOpen())
    {
        // Key events
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();

            if (event.type == sf::Event::KeyPressed)
            {
                if (event.key.code == sf::Keyboard::Escape)
                {
                    window.close();
                }
            }
        }

        // Rendering
        window.clear();

        for (auto& element : shapes)
        {
            // Shape rendering
            window.draw(*(element->shape));
            
            // Shape animation
            float currentX = element->shape->getPosition().x;
            float currentY = element->shape->getPosition().y; 
            sf::Vector2f textCenter = {};

            if(currentX <= 0)
            { 
                element->speed.x = -element->speed.x;
            }
            else if (currentY <= 0)
            {
                element->speed.y = -element->speed.y;
            }

            if (element->shapeTag == 1) // Circle
            {
                textCenter.x = currentX + element->radius;
                textCenter.y = currentY + element->radius;

                if (currentX + (2 * element->radius) >= windowX)
                {
                    element->speed.x = -element->speed.x;
                }
                else if (currentY + (2 * element->radius) >= windowY)
                {
                    element->speed.y = -element->speed.y;
                }
            }
            else if (element->shapeTag == 2) // Rectangle
            {
                textCenter.x = currentX + (element->dimensions.x/2);
                textCenter.y = currentY + (element->dimensions.y/2);

                if (currentX + (element->dimensions.x) >= windowX)
                {
                    element->speed.x = -element->speed.x;
                }
                else if (currentY + (element->dimensions.y) >= windowY)
                {
                    element->speed.y = -element->speed.y;
                }
            }
            
            element->shape->setPosition(currentX + element->speed.x, currentY + element->speed.y);

            // Text animation
            textName.setString(element->shapeName);
            float charSize = textName.getCharacterSize();
            std::size_t stringSize = textName.getString().getSize();         
            
            textName.setPosition(textCenter.x - (5 * stringSize) + element->speed.x, textCenter.y - (charSize*0.75f) + element->speed.y);
            window.draw(textName);
            window.draw(quitText);
        }
    
        window.display();
    }

    // Release memory
    for (AShape* shape : shapes)
    {
        if (shape != nullptr)
        {
            delete shape;
            std::cout << ""Release memory"" << std::endl;
        }
        
    }

    return 0;
}",windowElements
362,"//--------------------------------------
// File: QueueClass.h
// Class Queue
// Functions:
////		queue() : CDLList() {};
//			queue(listelem* hd, listelem* tl, unsigned size) :
//				CDLLList(hd, tl, size) {};
//			queue(const queue& qu) : CDLList(qu) {};
//			queue(iterator b, iterator e) : CDLList(b, e) {};
//			virtual ~queue() { release(); };
//			unsigned getSize();
//			iterator begin();
//			iterator end();
//			bool empty();
//			void release();
//			void push(T& element);
//			T pop();
//			print(ostream& sout);
//---------------------------------------
#ifndef PUBLICQUEUE_H
#define PUBLICQUEUE_H

#include ""CDLList.h""
#include <iostream>
#include <cassert>
#include <exception>
#include <cstdlib>

using namespace std;

//-----------------------------------------------------------------------------
//   Title: Queue Class Declaration and Definitions
//   Description: This file contains the class declarations and definitions for 
//					queue
//
//   Programmer: <NAME>
// 
//   Date: original: May 16, 2017
//   Version: 1.0
//
//   Environment: Intel Xeon PC
//     Software: Windows 10 Enterprise
//     Compiles under Microsoft Visual C++.Net 2015
//
//   class list:
//
//     Methods:
// 
//       inline: 
//			queue() : CDLList() {}; -- default constructor
//			queue(listelem* hd, listelem* tl, unsigned size) :
//				CDLLList(hd, tl, size) {}; -- constructor with two parameters
//			queue(const queue& qu) : CDLList(qu) {}; - constructor that copies a queue
//			Queue(const CDLList<T> & cl) : CDLList(cl) {}; -- constructor that takes CDLList
//			queue(iterator b, iterator e) : CDLList(b, e) {}; -- copy constructor with iterators
//			virtual ~queue() { release(); }; -- destructor for queue
//			unsigned getSize(); -- returns unsigned size of queue/CDLList
//			iterator begin(); -- returns iterator, beginning of queue/CDLList
//			iterator end();-- returns iterator, end of queue/CDLList
//			bool empty(); -- returns bool, false if list is not empty
//			void release(); -- returns non- releases and deletes list elements
//			void push(T& element);
//			T pop();
//			print(ostream& sout);
//
//   History Log:
//		5/16/2017 v1.0 completed by TR
//-----------------------------------------------------------------------------
namespace PB_ADT
{
	template<class T> class publicQueue : public CDLList<T>
	{
	public:
		publicQueue() : CDLList() {};
		publicQueue(size_t  [MASK] , T data) : CDLList( [MASK] , data) {};
		publicQueue(const publicQueue<T>& qu) : CDLList(qu) {};
		publicQueue(const CDLList<T> & cl) : CDLList(cl) {};
		publicQueue(CDLList<T>::iterator b, CDLList<T>::iterator e) : CDLList(b, e) {};

		virtual  ~publicQueue() { release(); };
		virtual unsigned getSize() { return CDLList<T>::getSize(); };
		virtual iterator begin() { return CDLList<T>::begin(); };
		virtual iterator end() { return CDLList<T>::end(); };
		virtual bool empty() { return CDLList<T>::empty(); };
		virtual void release() { return CDLList<T>::release(); };
		virtual void push(T& element) { return CDLList<T>::push_back(element); };
		T pop() { return CDLList<T>::pop_front(); };
		void print(ostream& sout);


		void push_front(T & datum) { throw methodNotSupported(); };
		T pop_front() { throw methodNotSupported(); };
		void push_back(T & datum) { throw methodNotSupported(); };
		T pop_back() { throw methodNotSupported(); };
		T& front() const { throw methodNotSupported(); };
		T& back() const { throw methodNotSupported(); };

			};

	//--------------------------------------------------
	// Function: void Queue<T>::print(ostream& sout)
	//
	// Description: prints a queue
	//
	// Programmer: <NAME>
	//
	// Date: 5/19/2017
	// Version: 1.0
	// Called by: main()
	//
	// output: outputs queue to ostream reference
	//
	// Parameters: ostream& sout 
	//
	// History Log:
	//    5/19/2017 TR completed v1
	//--------------------------------------------------
	template<class T>
	void publicQueue<T>::print(ostream& sout)
	{
		sout << ""("";
		iterator it = begin();
		while (it != end())
		{
			sout << *it << "", "";
			it++;
		}
		if (end() != nullptr)
			sout << *it;
		sout << "")"";
	}
}
#endif
		",qsize
363,"#include ""string_util.h""
#include <stdio.h>

void string_util::vector2str(const std::vector<std::string>& vec, std::string& desc, const std::string& seq) {
    if (vec.size() <= 0) return;

    auto iter = vec.begin();
    if (iter != vec.end()) {
        desc.append(*iter);
        ++iter;
    }

    while (iter != vec.end()) {
        desc.append(seq);
        desc.append(*iter);
        ++iter;
    }
}

void string_util::split(const std::string& text, const std::string& seq, std::vector<std::string>& desc) {
    if (text.size() == 0) return;

    size_t  [MASK]  = seq.size();
    size_t text_s = text.size();

    size_t start = 0;

    std::string tmp;
    while (start < text_s) {
        size_t pos = text.find_first_of(seq, start);

        if (pos != std::string::npos) {
            tmp = text.substr(start, pos - start);
            if (!tmp.empty()) {
                desc.push_back(tmp);
            }
            start = pos +  [MASK] ;
        } else {
            break;
        }
    }

    if (start < text_s) {
        tmp = text.substr(start);
        if (!tmp.empty()) {
            desc.push_back(tmp);
        }
    }
    return;
}

std::string string_util::trim(const std::string& src, const char seq) {
    if (src.empty()) return src;
    std::string tmp = src;

    size_t len = tmp.size(), pos = 0;
    
    for (size_t i = 0; i < len; i++) {
        if (seq == src[i]) pos += 1;
        else {
            break;
        }
    }

    if (pos > 0) {
        tmp.erase(0, pos);
    }

    pos = 0;
    len = tmp.size();
    int i = int(len - 1);
    for (; i >= 0; i--) {
        if (seq == src[i]) {
            pos += 1;
        } else {
            break;
        }
    }

    if (pos > 0) {
        tmp.erase(len - pos);
    }

    return tmp;
}


int string_util::parse_char(const char *str) {
    if (str == NULL) {
        return 0;
    }

    unsigned char p = (unsigned char)(*str);
    int n = 0;
    while (p & 0x80) {
        ++n;
        p = p << 1;
    }

    if (n == 0) {
        ++n;
    } else if (n > 4) {
        n = 1;
    }

    return n;
}

int string_util::punct_process(const std::string &raw_str, std::string &norm_str, const std::string &replacer) {
    if (raw_str.empty()) {
        return -1;
    }

    norm_str.clear();
    char *p = (char *)raw_str.c_str();
    size_t offset = 0;
    int len = 0;
    while (*p) {
        len = parse_char(p);
        if (len == 1) {
            if (ispunct(*p)) {
                norm_str += replacer;
            } else {
                norm_str.push_back(*p);
            }
        } else if (len > 1) {
            std::string c = raw_str.substr(offset, len);
            if (is_cn_punct(c)) {
                norm_str += replacer;
            } else {
                norm_str += c;
            }
        }
        p += len;
        offset += len;
    }
    
    norm_str = trim(norm_str);
    return 0;
}

bool string_util::is_cn_punct(const std::string &word) {
    if (word.empty()) {
        return false;
    }

    if (CN_PUNCS.find(word) != CN_PUNCS.end()) {
        return true;
    } else {
        return false;
    }
}
",seq_s
364,"#include <emscripten.h>
#include <GDX/gdx2d/gdx2d.h>

class Gdx {
    // Emscripten webidl don't support binding methods without a class so we need to create a wrapper
    public:
        static void* g2d_get_pixels(const gdx2d_pixmap* pixmap) { return (void*)pixmap->pixels; }
        static gdx2d_pixmap* g2d_load(void * void_buffer, int offset, uint32_t len) {
            unsigned char *buffer = static_cast<unsigned char*>(void_buffer);
            return gdx2d_load(buffer + offset, len);
        }
        static gdx2d_pixmap* g2d_new(uint32_t width, uint32_t height, uint32_t format) { return gdx2d_new(width, height, format); }
        static void g2d_free(const gdx2d_pixmap* pixmap) { gdx2d_free(pixmap); }
        static void g2d_set_blend(gdx2d_pixmap* pixmap, uint32_t blend) { gdx2d_set_blend(pixmap, blend); }
        static void g2d_set_scale(gdx2d_pixmap* pixmap, uint32_t scale) { gdx2d_set_scale(pixmap, scale); }
        static const char* g2d_get_failure_reason() { return gdx2d_get_failure_reason(); }
        static void g2d_clear(const gdx2d_pixmap* pixmap, uint32_t col) { gdx2d_clear(pixmap, col); }
        static void g2d_set_pixel(const gdx2d_pixmap* pixmap, int32_t x, int32_t y, uint32_t col) { gdx2d_set_pixel(pixmap, x, y, col); }
        static uint32_t g2d_get_pixel(const gdx2d_pixmap* pixmap, int32_t x, int32_t y) { return gdx2d_get_pixel(pixmap, x, y); }
        static void g2d_draw_line(const gdx2d_pixmap* pixmap, int32_t x, int32_t y, int32_t x2, int32_t y2, uint32_t col) { gdx2d_draw_line(pixmap, x, y, x2, y2, col); }
        static void g2d_draw_rect(const gdx2d_pixmap* pixmap, int32_t x, int32_t y, uint32_t width, uint32_t height, uint32_t col) { gdx2d_draw_rect(pixmap, x, y, width, height, col); }
        static void g2d_draw_circle(const gdx2d_pixmap* pixmap, int32_t x, int32_t y, uint32_t radius, uint32_t col) { gdx2d_draw_circle(pixmap, x, y, radius, col); }
        static void g2d_fill_rect(const gdx2d_pixmap* pixmap, int32_t x, int32_t y, uint32_t width, uint32_t height, uint32_t col) { gdx2d_fill_rect(pixmap, x, y, width, height, col); }
        static void g2d_fill_circle(const gdx2d_pixmap* pixmap, int32_t x, int32_t y, uint32_t radius, uint32_t col) { gdx2d_fill_circle(pixmap, x, y, radius, col); }
        static void g2d_fill_triangle(const gdx2d_pixmap* pixmap, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, uint32_t col) { gdx2d_fill_triangle(pixmap, x1, y1, x2, y2, x3, y3, col); }
        static void g2d_draw_pixmap(const gdx2d_pixmap* src_pixmap,
                                       const gdx2d_pixmap* dst_pixmap,
                                       int32_t src_x, int32_t src_y, uint32_t  [MASK] , uint32_t src_height,
                                       int32_t dst_x, int32_t dst_y, uint32_t dst_width, uint32_t dst_height) {
            gdx2d_draw_pixmap(src_pixmap, dst_pixmap, src_x, src_y,  [MASK] , src_height, dst_x, dst_y, dst_width, dst_height);
        }
        static uint32_t g2d_bytes_per_pixel(uint32_t format) { return gdx2d_bytes_per_pixel(format); }
};",src_width
365,"// Implementation of the acquisition module. It uses the ADC/DMA
// interrupts to process the ADC sampling.

// TODO: convert const naming style to kCammelCase.

#include ""acquisition.h""

#include <stdio.h>
#include <string.h>

#include ""filters.h""
#include ""hal/adc.h""
#include ""hal/dma.h""
#include ""hal/gpio.h""

namespace acquisition {

// Updated by sample_state(). This is the frozen copy of the
// state the UI can use.
static State sampled_state;

// 12 bit -> 4096 counts. 3.3V full scale.
// 0.4V per AMP (for +/- 2.5A sensor).
constexpr float kCountsPerAmp = 0.4 * 4096 / 3.3;

// We use this value to do multiplications instead of divisions.
constexpr float kAmpsPerCount = 1 / kCountsPerAmp;

constexpr float kMilliampsPerCount = 1000 / kCountsPerAmp;

// Energized/non-energized histeresis limits in ADC
// counts.
//
// TODO: specify here what the limits are as a percentage
// of full current scale.
//
constexpr uint16_t kNonEnergizedThresholdCounts = 50;
constexpr uint16_t kEnergizedThresholdCounts = 150;

// Hysteresis for determining quadrant transitions. In
// milliamps and in ADC counts.
// constexpr int kQuadrantHisteresisMilliamps = 100;
// constexpr int kQuadrantHysteresisCounts =
//     (kQuadrantHisteresisMilliamps * kCountsPerAmp) / 1000;

// Precompute signed histeresize for transition from the
// current quadrant q = [0, 2, 3, 3].
// static constexpr int quadrant_v1_histeresis[] = {
//     (kQuadrantHysteresisCounts / 2), (-kQuadrantHysteresisCounts / 2),
//     (kQuadrantHysteresisCounts / 2), (-kQuadrantHysteresisCounts / 2)};

// Allowed range for adc zero current offset setting.
// This range is wider than needed and actual offsets
// are expected to be around 1900.
constexpr int kMinOffset = 0;
constexpr int kMaxOffset = 4095;  // 12 bits max

enum CaptureState {
  // Filling half of the capture buffer.
  CAPTURE_HALF_FILL,
  // Keep filling in a circular way until a trigger event
  // or wait for trigger timeout.
  CAPTURE_PRE_TRIGGER,
  // Keep capture points as long as the capture buffer is not full.
  CAPTURE_POST_TRIGER,
  // Not capturing. ISR is guaranteed not to update or access the
  // capture buffer.
  CAPTURE_IDLE,
};

// This data is accessed from interrupt and thus should
// be access from main() with IRQ disabled.
struct IsrData {
  // The state visible to users.
  State state;

  // Current settings.
  Settings settings;

  // Signal capturing.
  // Time out for waiting for trigger in divided ADC ticks.
  uint32_t capture_pre_trigger_items_left = 0;
  // Factor to divide ADC ticks. Only every n'th sample is captured.
  uint16_t capture_divider = 1;
  // Up counter for capturing only every n'th samples.
  uint16_t capture_divider_counter = 0;
  // Capturing state.
  CaptureState capture_state = CAPTURE_IDLE;
  // The capture buffer itself. Updated by ISR when state != CAPTURE_IDLE
  // and accessible by the UI (ready only) when state = CAPTURE_IDLE.
  CaptureBuffer capture_buffer;
};

static IsrData isr_data;

extern bool is_capture_ready() {
  CaptureState capture_state;
  __disable_irq();
  { capture_state = isr_data.capture_state; }
  __enable_irq();
  return capture_state == CAPTURE_IDLE;
}

extern void start_capture(uint16_t divider) {
  // Force a reasonable range.
  if (divider < 1) {
    divider = 1;
  } else if (divider > 1000) {
    divider = 1000;
  }

  // Since capture may be active, data can co-access by ISR.
  __disable_irq();
  {
    isr_data.capture_buffer.items.clear();
    isr_data.capture_buffer.trigger_found = false;
    // This is an arbitrary number of divided samples that we allow
    // to wait for a trigger event.
    isr_data.capture_pre_trigger_items_left = 500;
    isr_data.capture_divider = divider;
    isr_data.capture_divider_counter = 0;
    isr_data.capture_state = CAPTURE_HALF_FILL;
  }
  __enable_irq();
}

// Users are expected to read this buffer only when capturing
// is not active.
const CaptureBuffer* capture_buffer() { return &isr_data.capture_buffer; }

const State* sample_state() {
  __disable_irq();
  sampled_state = isr_data.state;
  __enable_irq();
  return &sampled_state;
}

void reset_state() {
  __disable_irq();
  {
    isr_data.state.tick_count = 0;
    isr_data.state.non_energized_count = 0;
    isr_data.state.full_steps = 0;
    isr_data.state.max_full_steps = 0;
    isr_data.state.max_retraction_steps = 0;
    isr_data.state.quadrature_errors = 0;
    memset(isr_data.state.buckets, 0, sizeof(isr_data.state.buckets));
  }
  __enable_irq();
}

int adc_value_to_milliamps(int adc_value) {
  return (int)(adc_value * kMilliampsPerCount);
}

float adc_value_to_amps(int adc_value) {
  return ((float)adc_value) * kAmpsPerCount;
}

void calibrate_zeros() {
  __disable_irq();
  {
    isr_data.settings.offset1 += isr_data.state.v1;
    isr_data.settings.offset2 += isr_data.state.v2;
  }
  __enable_irq();
}

void set_direction(bool reverse_direction) {
  __disable_irq();
  { isr_data.settings.reverse_direction = reverse_direction; }
  __enable_irq();
}

void get_settings(Settings* settings) {
  __disable_irq();
  { *settings = isr_data.settings; }
  __enable_irq();
}

void dump_sampled_state() {
  // Remember last tick count and report only diff.
  static uint32_t last_tick_count = 0;

  Serial.printf(
      ""[%lu][er:%lu] [%5d, %5d] [en:%d %lu] s:%d/%d  steps:%d max_steps:%d\n"",
      sampled_state.tick_count - last_tick_count,
      sampled_state.quadrature_errors, sampled_state.v1, sampled_state.v2,
      sampled_state.is_energized, sampled_state.non_energized_count,
      sampled_state.quadrant, sampled_state.last_step_direction,
      sampled_state.full_steps, sampled_state.max_full_steps);

  last_tick_count = sampled_state.tick_count;

  for (int i = 0; i < acquisition::kNumHistogramBuckets; i++) {
    Serial.print(sampled_state.buckets[i].total_ticks_in_steps);
    Serial.print("" "");
  }
  Serial.println();

  Serial.println(""..."");

  for (int i = 0; i < acquisition::kNumHistogramBuckets; i++) {
    const uint32_t avg_peak_current =
        sampled_state.buckets[i].total_steps
            ? (sampled_state.buckets[i].total_step_peak_currents /
               sampled_state.buckets[i].total_steps)
            : 0;
    Serial.print(avg_peak_current);

    Serial.print("" "");
  }
  Serial.println();
}

// Assumes that capture data is ready.
void dump_capture(const CaptureBuffer& buffer) {
  for (int i = 0; i < buffer.items.size(); i++) {
    const acquisition::CaptureItem* item = buffer.items.get(i);
    // TODO: convert to Serial.printf().
    Serial.print(-15);
    Serial.print(' ');
    Serial.print(item->v1);
    Serial.print(' ');
    Serial.print(item->v2);
    Serial.print(' ');
    Serial.println(15);
  }
}

// Maybe add step's information to the histogram.
// Called from isr on step transition.
inline void isr_add_step_to_histogram(int quadrant, Direction entry_direction,
                                      Direction exit_direction,
                                      uint32_t ticks_in_step,
                                      uint32_t max_current_in_step) {
  // Ignoring this step if not entering and exiting this step in same forward or
  // backward direction.
  if (entry_direction != exit_direction ||
      entry_direction == UNKNOWN_DIRECTION) {
    return;
  }
  uint32_t steps_per_sec =
      TicksPerSecond / ticks_in_step;  // speed in steps per second
  if (steps_per_sec < 10) {
    return;  // ignore very slow steps as they dominate the time.
  }
  uint32_t  [MASK]  = steps_per_sec / kBucketStepsPerSecond;
  if ( [MASK]  >= kNumHistogramBuckets) {
     [MASK]  = kNumHistogramBuckets - 1;
  }
  HistogramBucket& bucket = isr_data.state.buckets[ [MASK] ];
  bucket.total_ticks_in_steps += ticks_in_step;
  bucket.total_step_peak_currents += max_current_in_step;
  bucket.total_steps++;
}

// A helper for the isr function.
static inline void isr_update_full_steps_counter(int increment) {
  State& isr_state = isr_data.state;  // alias

  // Update step counter based on direction setting.
  if (isr_data.settings.reverse_direction) {
    isr_state.full_steps -= increment;
  } else {
    isr_state.full_steps += increment;
  }

  // Track retraction.
  if (isr_state.full_steps > isr_state.max_full_steps) {
    isr_state.max_full_steps = isr_state.full_steps;
  }
  const int retraction_steps = isr_state.max_full_steps - isr_state.full_steps;
  if (retraction_steps > isr_state.max_retraction_steps) {
    isr_state.max_retraction_steps = retraction_steps;
  }
}

// NOTE: these four filters slow the interrupt handling. Consider
// to eliminate if free CPU time is insufficient.
//
// We use these filters to reduce internal and external noise.
static filters::Adc12BitsLowPassFilter<700> signal1_filter;
static filters::Adc12BitsLowPassFilter<400> signal2_filter;

// Slow filter, for display purposes.
// static filters::Adc12BitsLowPassFilter<1023> display1_filter;
// static filters::Adc12BitsLowPassFilter<1023> display2_filter;

// This function performs the bulk of the IRQ processing. It accepts
// one pair of ADC1, ADC2 readings, analyzes it, and updates the
// state.
void isr_handle_one_sample(const uint16_t raw_v1, const uint16_t raw_v2) {
  isr_data.state.tick_count++;

  // Fast filtering for signal analysis.
  const int16_t v1 =
      (uint16_t)signal1_filter.update(raw_v1) - isr_data.settings.offset1;
  const int16_t v2 =
      (uint16_t)signal2_filter.update(raw_v2) - isr_data.settings.offset2;

  // Slower filtering for display purposes.
  isr_data.state.v1 = v1;
  //   (uint16_t)display1_filter.update(raw_v1) - isr_data.settings.offset1;
  isr_data.state.v2 = v2;
  // (uint16_t)display2_filter.update(raw_v2) - isr_data.settings.offset2;

  // Handle signal capturing.
  // Release: 220ns, Debug: 1100ns.  (TODO: update timing for current code)
  if (isr_data.capture_state != CAPTURE_IDLE &&
      ++isr_data.capture_divider_counter >= isr_data.capture_divider) {
    isr_data.capture_divider_counter = 0;
    // Insert sample to circular buffer. If the buffer is full it drops
    // the oldest item.
    CaptureItem* capture_item = isr_data.capture_buffer.items.insert();
    capture_item->v1 = v1;
    capture_item->v2 = v2;

    switch (isr_data.capture_state) {
      // In this sate we blindly fill half of the buffer.
      case CAPTURE_HALF_FILL:
        if (isr_data.capture_buffer.items.size() >= kCaptureBufferSize / 2) {
          isr_data.capture_state = CAPTURE_PRE_TRIGGER;
        }
        break;

      // In this state we look for a trigger event or a pre trigger timeout.
      case CAPTURE_PRE_TRIGGER: {
        // Pre trigger timeout?
        if (isr_data.capture_pre_trigger_items_left == 0) {
          // NOTE: if the buffer is full here we could terminate
          // the capture but we go through the normal motions for simplicity.
          isr_data.capture_state = CAPTURE_POST_TRIGER;
          isr_data.capture_buffer.trigger_found = false;

          break;
        }
        isr_data.capture_pre_trigger_items_left--;
        // Trigger event?
        const int16_t old_v1 =
            isr_data.capture_buffer.items.get_reversed(5)->v1;
        // Trigger criteria, up crossing of the zero line.
        if (old_v1 < -10 && v1 >= 0) {
          // Keep only the last n/2 points. This way the trigger will
          // always be in the middle of the buffer.
          isr_data.capture_buffer.items.keep_at_most(kCaptureBufferSize / 2);
          isr_data.capture_buffer.trigger_found = true;
          isr_data.capture_state = CAPTURE_POST_TRIGER;
        }
      } break;

      // In this state we blindly fill the rest of the buffer.
      case CAPTURE_POST_TRIGER:
        if (isr_data.capture_buffer.items.is_full()) {
          isr_data.capture_state = CAPTURE_IDLE;
        }
        break;

      // This one is non reachable but makes the compiler happy.
      case CAPTURE_IDLE:
        break;
    }
  }

  // Determine if motor is energized. Use hysteresis for noise rejection.
  // Release: 200ns. Debug: 600ns.
  const bool old_is_energized = isr_data.state.is_energized;
  const uint16_t total_current = abs(v1) + abs(v2);
  // Using histeresis.
  const uint16_t energized_threshold = old_is_energized
                                           ? kNonEnergizedThresholdCounts
                                           : kEnergizedThresholdCounts;
  const bool new_is_energized = total_current > energized_threshold;
  isr_data.state.is_energized = new_is_energized;

  // Handle the non energized case. No need to go through quadrant decoding.
  // Pass through case: Release: 110ns. Debug: 250ns.
  if (!new_is_energized) {
    if (old_is_energized) {
      // Becoming non energized.
      isr_data.state.last_step_direction = UNKNOWN_DIRECTION;
      isr_data.state.ticks_in_step = 0;
      isr_data.state.non_energized_count++;
    } else {
      // Staying non energized
    }
    return;
  }

  // Here when energized. Decode quadrant.
  // We now go through a decision tree to collect the new quadrant, sector
  // and max coil current. Optimized for speed. See quadrants_plot.png
  // for the individual cases.
  uint8_t new_quadrant;  // set below to [0, 3]
  uint32_t max_current;  // max coil current
  if (v2 >= 0) {
    if (v1 >= 0) {
      // Quadrant 0: v1 > 0, V2 > 0.
      new_quadrant = 0;
      if (v1 > v2) {
        // Sector 0: v1 > 0, V2 > 0.  |v1| > |v2|
        max_current = v1;
      } else {
        // Sector 1: v1 > 0, V2 > 0.  |v1| < |v2|
        max_current = v2;
      }
    } else {
      // Quadrant 1: v1 < 0, V2 > 0
      new_quadrant = 1;
      if (-v1 < v2) {
        // Sector 2: v1 < 0, V2 > 0.  |v1| < |v2|
        max_current = v2;
      } else {
        // Sector 3: v1 < 0, V2 > 0.  |v1| > |v2|
        max_current = -v1;
      }
    }
  } else {
    if (v1 < 0) {
      // Quadrant 2:  v1 < 0, V2 < 0
      new_quadrant = 2;
      if (-v1 > -v2) {
        // Sector 4: v1 < 0, V2 < 0.  |v1| > |v2|
        max_current = -v1;
      } else {
        // Sector 5: v1 < 0, V2 < 0.  |v1| < |v2|
        max_current = -v2;
      }
    } else {
      // Quadrant 3 v1 > 0, V2 < 0.
      new_quadrant = 3;
      if (v1 < -v2) {
        // Sector 6: v1 > 1, V2 < 0.  |v1| < |v2|
        max_current = -v2;
      } else {
        // Sector 7: v1 > 0, V2 < 0.  |v1| > |v2|
        max_current = v1;
      }
    }
  }

  const int8_t old_quadrant = isr_data.state.quadrant;  // old quadrant [0, 3]
  isr_data.state.quadrant = new_quadrant;

  // Track quadrant transitions and update steps.
  if (!old_is_energized) {
    // Case 1: motor just became energized. Direction is still not known.
    isr_data.state.last_step_direction = UNKNOWN_DIRECTION;
    isr_data.state.ticks_in_step = 1;
    isr_data.state.max_current_in_step = max_current;
  } else if (new_quadrant == old_quadrant) {
    // Case 2: staying in same quadrant
    isr_data.state.ticks_in_step++;
    if (max_current > isr_data.state.max_current_in_step) {
      isr_data.state.max_current_in_step = max_current;
    }
  } else if (new_quadrant == ((old_quadrant + 1) & 0x03)) {
    // Case 3: Moved to next quadrant.
    isr_update_full_steps_counter(+1);
    isr_add_step_to_histogram(old_quadrant, isr_data.state.last_step_direction,
                              FORWARD, isr_data.state.ticks_in_step,
                              isr_data.state.max_current_in_step);
    isr_data.state.last_step_direction = FORWARD;
    isr_data.state.ticks_in_step = 1;
    isr_data.state.max_current_in_step = max_current;
  } else if (new_quadrant == ((old_quadrant - 1) & 0x03)) {
    // Case 4: Moved to previous quadrant.
    isr_update_full_steps_counter(-1);
    isr_add_step_to_histogram(old_quadrant, isr_data.state.last_step_direction,
                              BACKWARD, isr_data.state.ticks_in_step,
                              isr_data.state.max_current_in_step);
    isr_data.state.last_step_direction = BACKWARD;
    isr_data.state.ticks_in_step = 1;
    isr_data.state.max_current_in_step = max_current;
  } else {
    // Case 5: Invalid quadrant transition.
    // TODO: count and report errors.
    isr_data.state.quadrature_errors++;
    isr_data.state.last_step_direction = UNKNOWN_DIRECTION;
    isr_data.state.ticks_in_step = 1;
    isr_data.state.max_current_in_step = max_current;
  }
}

// Handle the first or second ADC/DMA buffer with collected
// samples.
void isr_handle_dma_buffer(const dma::AdcPoint* bfr, int n) {
  for (int i = 0; i < n; i++) {
    LED2_ON;
    const dma::AdcPoint& adc_point = bfr[i];
    isr_handle_one_sample(adc_point.v1, adc_point.v2);
    LED2_OFF;
  }
}

// HAL interrupt handler for the ADC/DMA 'half' completion.
// We process the data in buffer 1.
extern ""C"" void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc) {
  isr_handle_dma_buffer(dma::kDmaAdcPointBuffer1, dma::kDmaAdcPointBufferSize);
}

// HAL interrupt handler for the ADC/DMA 'full' completion.
// We process the data in buffer 2.
extern ""C"" void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
  isr_handle_dma_buffer(dma::kDmaAdcPointBuffer2, dma::kDmaAdcPointBufferSize);
}

// Force a valid settings offset value.
static int clip_offset(int requested_offset) {
  return max(kMinOffset, min(kMaxOffset, requested_offset));
}

// Call once on program initialization.
void setup(const Settings& settings) {
  isr_data.settings = settings;
  isr_data.settings.offset1 = clip_offset(isr_data.settings.offset1);
  isr_data.settings.offset2 = clip_offset(isr_data.settings.offset2);
}

// This involves floating point operations and thus slow. Do not
// call from the interrupt routine.
double state_steps(const State& state) {
  // If not energized, we can't compute fractional steps.
  if (!state.is_energized) {
    return state.full_steps;
  }

  // Compute fractional stept. We use the abs() to avoid
  // the discontinuity near -180 degrees. It provides better safety with
  // the non determinism of floating point values.
  // Range is in [0, PI];
  const double abs_radians = abs(atan2(state.v2, state.v1));

  // Rel radians in [-PI/4, PI/4].
  double rel_radians = 0;
  switch (state.quadrant) {
    case 0:
      rel_radians = abs_radians - (PI / 4);
      break;
    case 1:
      rel_radians = abs_radians - (3 * PI / 4);
      break;
    case 2:
      rel_radians = (3 * PI / 4) - abs_radians;
      break;
    case 3:
      rel_radians = (PI / 4) - abs_radians;
      break;
  }

  // Fraction is in the range [-0.5, 0.5]
  const double fraction = rel_radians * (2 / PI);

  // NOTE: this is a little bit hacky since we don't know the direction
  // flag setting at the time this sample was captured but should
  // be good enough for now.
  //
  // TODO: record last direction flag value in the state.
  const double result = isr_data.settings.reverse_direction
                            ? state.full_steps - fraction
                            : state.full_steps + fraction;

  // Serial.printf(""%d, %hu, (%hd, %hd), %d, "", state.full_steps,
  // state.quadrant,
  //               state.v1, state.v2, isr_data.settings.reverse_direction);
  // Serial.print(abs_radians);
  // Serial.print("", "");
  // Serial.print(rel_radians);
  // Serial.print("", "");
  // Serial.println(fraction);

  return result;
}

}  // namespace acquisition
",bucket_index
366,"#include <Arduino.h>
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>

/*
1. Set up your firebase project, enable authentication through Google
2. Create a Oauth2.0-Client-ID in developers console and copy Client-ID and Client-Secret into this sketch.
3. Replace ""<your_client_id>"" in this URL with your client_id and open it in your browser:
    https://accounts.google.com/o/oauth2/auth?redirect_uri=https://localhost&response_type=code&client_id=<your_client_id>&scope=https://www.googleapis.com/auth/firebase.database+https://www.googleapis.com/auth/userinfo.email&approval_prompt=force&access_type=offline
4. Log-in/select with the Google User you would like to authorize.
5. Copy the code after ""?code="" from the URL of your browser into this sketch. (without the # at the end)
    This code works only once, if you try to use it in Oauthplayground or somewhere else it wont work here anymore.
    (open URL again and get new code if you used it already)
4. Run the sketch.
5. Save all data printed to Serial, it is the access_token and the refresh_token you will need.
*/

#define WIFI_SSID ""ssid""
#define WIFI_PASSWORD ""<PASSWORD>""
String client_id = """"; //enter your Oauth2 account client id
String client_secret = """"; //enter your Oauth2 account client secret
String code = """"; //enter the code you recieved in the browser url field (only code, without beginning https://... or  &code=...)
String message = ""redirect_uri=https://localhost&client_id="" + client_id + ""&client_secret="" + client_secret + ""&code="" + code + ""&grant_type=authorization_code"";

WiFiClientSecure client;

void connectWifi(){
  Serial.print(""Connecting to "");
  Serial.println(WIFI_SSID);
  WiFi.mode(WIFI_STA);
  if(WiFi.status() != WL_CONNECTED){
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  }
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(""."");
  }
  Serial.println(""\nConnected"");
  Serial.print(""IP Address: "");
  Serial.println(WiFi.localIP());
}

void setup() {
  DynamicJsonBuffer jsonBuffer;
  String response;
  
  Serial.begin(9600);
  delay(5000);
  connectWifi();

  Serial.println(""Starting to redeem token from code..."");
  if(!client.connect(""accounts.google.com"", 443)){
    Serial.println(""Could not connect to accounts.google.com"");
  }

  client.print( String(""POST /o/oauth2/token HTTP/1.1\r\n"") +
                String(""Host: accounts.google.com\r\n"") +
                String(""Content-Type: application/x-www-form-urlencoded\r\n"") +
                String(""Content-Length: "" + String(message.length()) + ""\r\n\r\n"") +
                message
              );

  unsigned long  [MASK]  = millis();
  while(client.available() == 0){
    if(millis() -  [MASK]  > 5000){
      client.stop();
      Serial.println(""Failed to recieve response after 5 seconds, aborting"");
      break;
    }
  }

  while(client.available()){
    response = client.readString();
    int payloadStart = response.indexOf(""\r\n\r\n"");
    int payloadEnd = response.indexOf(""\r\n\r\n"", payloadStart+1);
    response = response.substring(payloadStart, payloadEnd);
    payloadStart = response.indexOf('{');
    payloadEnd = response.indexOf('}');
    response = response.substring(payloadStart, payloadEnd+1);
    response.trim();
  }
  JsonObject& responseJson = jsonBuffer.parseObject(response);

  if(responseJson.containsKey(""error"")){
    responseJson.printTo(Serial);
  } else {
    Serial.println(""Your Oauth2 token from google:"");
    Serial.println(""Access Token: "" + responseJson[""access_token""].as<String>());
    Serial.println(""Refresh Token: "" + responseJson[""refresh_token""].as<String>());
    Serial.println(""Token Type: "" + responseJson[""token_type""].as<String>());
    Serial.println(""Expires in (seconds): "" + responseJson[""expires_in""].as<String>());
    Serial.println(""ID Token: "" + responseJson[""id_token""].as<String>());
  }
}

void loop() {
    // nothing to do...
}

",sendTime
367,"#include <iostream.h>
#include <conio.h>
#include <fstream.h>
#include <time.h>
#include <stdio.h>
#include <dir.h>

void setDarkBlueColor() {
    textcolor(RED);
    textbackground(BLUE);
}

void resetColor() {
    textcolor(RED);
    textbackground(BLUE);
}

void displayMenu() {
    clrscr();
    setDarkBlueColor();
    cout << ""===| TouchOS CE 4 |===\n"";
    cout << ""1 - Getting Started\n"";
    cout << ""2 - Text\n"";
    cout << ""3 - Clock\n"";
    cout << ""4 - Echo\n"";
    cout << ""5 - Changelog\n"";
    cout << ""6 - Exit\n"";
    cout << ""Enter an option: "";
    resetColor();
}

void openGettingStarted() {
    clrscr();
    ifstream inputFile(""D:\\TOUCHOS\\GETTINGSTARTED.TXT"");
    
    if (inputFile) {
        cout << ""Opening Getting Started document...\n"";
        char data[100];
        while (inputFile.getline(data, 100)) {
            cout << data << ""\n"";
        }
        inputFile.close();
    } else {
        cout << ""Error: Unable to open Getting Started document\n"";
    }
    getch();
}

void displayClock() {
    clrscr();
    time_t now = time(0);
    tm* ltm = localtime(&now);
    cout << ""Date: "" << ltm->tm_mday << ""/"" << 1 + ltm->tm_mon << ""/"" << 1900 + ltm->tm_year << ""\n"";
    cout << ""Time: "" << ltm->tm_hour << "":"" << ltm->tm_min << "":"" << ltm->tm_sec << ""\n"";
    getch();
}

void echoUserInput() {
    clrscr();
    char userInput[100];
    cin.ignore();
    cout << ""Enter text: "";
    cin.getline(userInput, 100);
    cout << ""ECHO-$ "" << userInput << ""\n"";
    getch();
}

void displayChangelog() {
    clrscr();
    cout << ""***| Changelog |***\n"";
    cout << ""- Added Getting Started\n"";
    cout << ""- Improved Text Manager\n"";
    cout << ""- Red text\n"";
    cout << ""- More stable build\n"";
    getch();
}

void displayTextMenu() {
    clrscr();
    setDarkBlueColor();
    cout << ""***| Text |***\n"";
    cout << ""1 - Open Document\n"";
    cout << ""2 - Edit Document\n"";
    cout << ""3 - List Documents\n"";
    cout << ""4 - Rename Document\n"";
    cout << ""5 - Back to Main Menu\n"";
    cout << ""Enter an option: "";
    resetColor();
}

void openDocument() {
    clrscr();
    char filename[100];
    cout << ""Enter document name: "";
    cin >> filename;
    ifstream inputFile((string(""D:\\TOUCHOS\\TEXT\\"") + filename).c_str());

    if (inputFile) {
        cout << ""Opening document...\n"";
        char data[100];
        while (inputFile.getline(data, 100)) {
            cout << data << ""\n"";
        }
        inputFile.close();
    } else {
        cout << ""Error: Unable to open document\n"";
    }
    getch();
}

void editDocument() {
    clrscr();
    char filename[100];
    cout << ""Enter document name: "";
    cin >> filename;
    ofstream  [MASK] ((string(""D:\\TOUCHOS\\TEXT\\"") + filename).c_str(), ios::app);

    if ( [MASK] ) {
        char userData[100];
        cin.ignore();
        cout << ""Enter document contents: "";
        cin.getline(userData, 100);
         [MASK]  << userData << ""\n"";
        cout << ""Saved to document\n"";
         [MASK] .close();
    } else {
        cout << ""Error: Unable to edit document\n"";
    }
    getch();
}

void listDocuments() {
    clrscr();
    cout << ""Listing documents in D:\\TOUCHOS\\TEXT\\...\n"";
    system(""dir D:\\TOUCHOS\\TEXT\\ /b"");
    getch();
}

void renameDocument() {
    clrscr();
    char oldName[100], newName[100];
    cout << ""Enter current document name: "";
    cin >> oldName;
    cout << ""Enter new document name: "";
    cin >> newName;
    if (rename((string(""D:\\TOUCHOS\\TEXT\\"") + oldName).c_str(), (string(""D:\\TOUCHOS\\TEXT\\"") + newName).c_str()) == 0) {
        cout << ""Document renamed successfully\n"";
    } else {
        cout << ""Error: Unable to rename document\n"";
    }
    getch();
}

int main() {
    int choice;
    do {
        displayMenu();
        cin >> choice;
        switch (choice) {
            case 1:
                openGettingStarted();
                break;
            case 2:
                int textChoice;
                do {
                    displayTextMenu();
                    cin >> textChoice;
                    switch (textChoice) {
                        case 1:
                            openDocument();
                            break;
                        case 2:
                            editDocument();
                            break;
                        case 3:
                            listDocuments();
                            break;
                        case 4:
                            renameDocument();
                            break;
                        case 5:
                            break;
                        default:
                            cout << ""Invalid choice. Please try again.\n"";
                            getch();
                    }
                } while (textChoice != 5);
                break;
            case 3:
                displayClock();
                break;
            case 4:
                echoUserInput();
                break;
            case 5:
                displayChangelog();
                break;
            case 6:
                cout << ""Exiting TouchOS CE...\n"";
                break;
            default:
                cout << ""Invalid choice. Please try again.\n"";
                getch();
        }
    } while (choice != 6);
    return 0;
}
",outputFile
368,"#include ""connectdialog.h""
#include ""ui_connectdialog.h""
#include <QSignalMapper>
#include <QString>

ConnectDialog::ConnectDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::ConnectDialog)
{
    ui->setupUi(this);
    QSignalMapper *mapper = new QSignalMapper(this);

    for(int i=0; i<10; i++){
        QPushButton *pBtn = new QPushButton(QString::number(i),this);
        connect(pBtn, SIGNAL(clicked()), mapper, SLOT(map()));
        mapper->setMapping(pBtn, pBtn->text());
        ui->gridLayout_2->addWidget(pBtn,i,0);
    }
    QPushButton *pBtn = new QPushButton(""."",this);
    connect(pBtn, SIGNAL(clicked()), mapper, SLOT(map()));
    mapper->setMapping(pBtn, pBtn->text());
    ui->gridLayout_2->addWidget(pBtn,10,0);
    connect(mapper,SIGNAL(mapped(QString)),this,SLOT(appendtext(QString)));
}

ConnectDialog::~ConnectDialog()
{
    delete ui;

}

void ConnectDialog::on_YesBtn_clicked(){
    QString IP = ui->IPLineEdit->text();
    this->close();
    emit sendData(IP);
}

void ConnectDialog::on_RedoBtn_clicked(){
    ui->IPLineEdit->clear();
}
void ConnectDialog::appendtext(QString a){
    QString  [MASK]  = ui->IPLineEdit->text()+a;
    ui->IPLineEdit->setText( [MASK] );
    repaint();
}
",temp
369,"#include ""encoder_funcs.hpp""
#include <Arduino.h>
namespace enc_f
{
    // Teensy has its own version of pi in its libraries.
    // const int PI = numbers::pi_v;
    /**
     * @brief Get ticks elapsed from an encoder read
     * 
     * @param e Encoder object to read
     * @param d Time to read encoder
     * @return long number of ticks per CPU cycle
     */
    long get_ticks(Encoder& e, int d = 0)
    {
        e.write(0);
        delay(d);
        return e.read();
    }

    /**
     * @brief Report speed of encoder (in in/s)
     * 
     * @param e Encoder object to report
     * @param d Time taken to read encoder (ms)
     * @return float 
     */
    int get_speed_inch(Encoder& e, int d = 50)
    {
        long ticks = get_ticks(e,d);
        int  [MASK]  = floor( ((float) ticks / d) * (float) (25/3) * 1.49606 * PI);
        return  [MASK] ;
    }

    /**
     * @brief Report speed of encoder (in mm/s)
     * 
     * @param e Encoder object
     * @param d Time taken to read encoder (in ms)
     * @return float 
     */
    int get_speed_mm(Encoder& e, int d = 50)
    {
        long ticks = get_ticks(e,d);
        int mm_speed = floor( ((float) ticks / d) * (float) (25/3) * 38.0 * PI);
        return mm_speed;
    }

} // enc_f namespace
",in_speed
370,"//
// Created by zheng on 2020/4/8.
//
#include <unistd.h>
#include <netdb.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <cassert>

#include ""SocketClient.h""

#define SA struct sockaddr

SocketClient::SocketClient(char *addr, int port)
{
    int ret;
    strncpy(this->addr, addr, 99);
    this->port=port;
    msg_size = 0;
    ret = this->connect_to_server();
}

int SocketClient::connect_to_server()
{
    struct sockaddr_in  [MASK] ;

    // socket create and varification
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        printf(""socket creation failed...\n"");
        return -1;
    }
    else
        printf(""Socket successfully created..\n"");
    bzero(& [MASK] , sizeof( [MASK] ));

    // assign IP, PORT
     [MASK] .sin_family = AF_INET;
     [MASK] .sin_addr.s_addr = inet_addr(addr);
     [MASK] .sin_port = htons(port);

    // connect_to_server the client socket to server socket
    if (::connect(sockfd, (SA *) & [MASK] , sizeof( [MASK] )) != 0) {
        printf(""connection with the server failed...\n"");
        return -1;
    }
    else
        printf(""connected to the server..\n"");
    return 0;
}

int SocketClient::send()
{
    assert(msg_size>0);
    ssize_t ret = write(sockfd, buf, msg_size);
    if (ret<msg_size)
    {
        printf(""write %d ret %ld\n"", msg_size, ret);
    }
//    bzero(buf, sizeof(buf));
    msg_size = 0;
    return 0;
}

int
SocketClient::serialize(int rank, unsigned long begin, unsigned long end, const Graph &graph_calc,
                        const Graph &graph_comm, const Graph &graph_io)
{
    Header header = {};
    auto sGraphKey = reinterpret_cast<SGraphKey*>(buf + sizeof(Header));
    header.rank = rank, header.begin = begin, header.end = end;
    int cnt_key=0, cnt_value=0;
    for (const auto &kv:graph_calc)
    {
        // buffer size limit
        if (sizeof(Header) + sizeof(SGraphKey) * (cnt_key + 1) +
            sizeof(SGraphValue) * (cnt_value + kv.second.size()) >= MAXBUFSIZ)
        {
//            fprintf(stderr, ""Send buf truncated. c_k=%d c_v=%d\n"", cnt_key,
//                    cnt_value);
            break;
        }
        sGraphKey[cnt_key].first = kv.first.first;
        sGraphKey[cnt_key].second = kv.first.second;
        sGraphKey[cnt_key].num=kv.second.size();
        cnt_key++;
        cnt_value+=kv.second.size();
    }
    int i_key=0;
    auto *sDataType = reinterpret_cast<SGraphValue *>(buf + sizeof(Header) +
                                                         sizeof(SGraphKey) *
                                                         cnt_key);
    header.n_keys = cnt_key;
    this->msg_size = header.msg_size =
            sizeof(Header) + sizeof(SGraphKey) * cnt_key +
            sizeof(SGraphValue) * cnt_value;

    memcpy(buf, &header, sizeof(Header));
    for (const auto &kv:graph_calc)
    {
        if (i_key >= cnt_key)
        {
            // fprintf(stderr, ""Warning: exceed buf %d/%d\n"", i_key, cnt_key);
            break;
        }
        memcpy(sDataType, kv.second.data(),
               sizeof(DataType) * kv.second.size());
        sDataType += kv.second.size();
        i_key++;
    }
//    fprintf(stderr, ""Msgsize=%d Header rk=%d nkeys=%d nval=%d\n"",
//            this->msg_size, header.rank, header.n_keys, cnt_value);
    return 0;
}

//void SGraphValue::load_from_DataType(const DataType &dataType)
//{
//    this->timestamp=dataType.timestamp;
//    this->elapsed=dataType.elapsed;
//}
",servaddr
371,"#pragma once

#include <string>
#include <fstream>
#include <sstream>
#include <regex>
#include <vector>
#include <unordered_set>
#include <filesystem>

#include ""Logger.h""
#include ""Utility.h""
#include ""Signature.h""

namespace _gem {

	class File {
	public:
		File(std::filesystem::path path, std::string source) :
			path(getRelativePath(path, source)),
			name(path.stem().string()),
			extension(path.extension().string())
		{
			/*
			namespace sf = std::filesystem;
			sf::path dir = std::filesystem::path(Configuration::getSourceDirectory());
			std::string fileName = sf::relative(dir, path).replace_extension("""").string();
			*/
			std::ifstream file(path);
			std::ostringstream ss;
			ss << file.rdbuf();
			content = ss.str();
			file.close();

			Logger::log(Logger::GEM, ""Loading file: "", path.string());

			std::unordered_set<std::string> duplicateChecker;

			std::regex macroRegex(""%%\\[([a-zA-Z][a-zA-Z0-9_/-]*):?([a-zA-Z][a-zA-Z0-9_.-]*)?\\]"");
			std::smatch macroMatches;
			std::string toSearchMacro = content;

			//Get all macros
			while (std::regex_search(toSearchMacro, macroMatches, macroRegex)) {
				auto pair = duplicateChecker.emplace(macroMatches[1].str());
				macros.emplace_back(macroMatches[0].str());
				if (!pair.second) {
					Logger::log(Logger::GEM, ""Macro: "" + macroMatches[1].str() + "" duplicate found in file: "" + path.string(), ""..."");
				}

				toSearchMacro = macroMatches.suffix().str();
			}
			if (duplicateChecker.size() == 0) {
				processFile();
			}

			duplicateChecker.clear();



			std::regex includeRegex(""##\\[([a-zA-Z][a-zA-Z0-9_/-]*):?([a-zA-Z][a-zA-Z0-9_.-]*)?\\]"");
			std::smatch includeMatches;
			std::string  [MASK]  = content;

			//Get all includes
			while (std::regex_search( [MASK] , includeMatches, includeRegex)) {
				auto pair = duplicateChecker.emplace(includeMatches[0].str());
				includes.emplace_back(includeMatches[0].str());
				if (!pair.second) {
					Logger::log(Logger::GEM, ""Include: "" + includeMatches[1].str() + "" duplicate found in file: "" + path.string(), ""..."");
				}
				 [MASK]  = includeMatches.suffix().str();
			}
		}



		template<class... Args>
		size_t processFile(Args... args) {
			std::vector<std::string> arguments({ castToString(args)... });
			std::string processedContent = content;

			for (size_t i = 0; i < macros.size(); i++) {

				processedContent = std::regex_replace(processedContent, sanitizeForRegex(macros[i].signature), arguments[i]);
			}

			processedContents.emplace_back(processedContent);

			return processedContents.size() - 1;
		}


		std::string content;
		std::string path;
		std::string name;
		std::string extension;
		std::vector<Signature> macros;
		std::vector<Signature> includes;
		std::vector<std::string> processedContents;
	};

}",toSearchInclude
372,"/*
 * @lc app=leetcode id=119 lang=cpp
 *
 * [119] Pascal's Triangle II
 *
 * https://leetcode.com/problems/pascals-triangle-ii/description/
 *
 * algorithms
 * Easy (48.78%)
 * Likes:    987
 * Dislikes: 201
 * Total Accepted:    316.3K
 * Total Submissions: 626.2K
 * Testcase Example:  '3'
 *
 * Given a non-negative index k where k ≤ 33, return the k^th index row of the
 * Pascal's triangle.
 * 
 * Note that the row index starts from 0.
 * 
 * 
 * In Pascal's triangle, each number is the sum of the two numbers directly
 * above it.
 * 
 * Example:
 * 
 * 
 * Input: 3
 * Output: [1,3,3,1]
 * 
 * 
 * Follow up:
 * 
 * Could you optimize your algorithm to use only O(k) extra space?
 * 
 */

// @lc code=start
#include <vector>

class Solution {
public:
    std::vector<int> getRow(int  [MASK] ) {
        std::vector<int> row;
        for (int i = 0; i <=  [MASK] ; i++) {
            std::vector<int> nextRow(i + 1, 1);
            for (int j = 1; j < nextRow.size() - 1; j++) {
                nextRow[j] = row[j - 1] + row[j];
            }
            row = nextRow;
        }

        return row;
    }
};
// @lc code=end

",rowIndex
373,"#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <netinet/in.h>
#include <arpa/inet.h>



bool g_continue = true;

int sighandler(int  [MASK] )
{
    (void) [MASK] ;
    g_continue = false;
    return 1;
}

void fatal(const char* msg) 
{
    perror(msg);
    exit(EXIT_FAILURE);
}

int main()
{
    while(1){
    int listener = socket(AF_INET, SOCK_STREAM, 0);
    if (listener == -1)
        fatal(""socket"");

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(8080)
    };
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(listener, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0)
        fatal(""bind"");

    if (listen(listener, SOMAXCONN) < 0)
        fatal(""listen"");

    printf(""Listening on %s:%d\n"", inet_ntoa(addr.sin_addr), 8080);

    struct sockaddr_in client_name;
    socklen_t client_len = sizeof(struct sockaddr_in);
    int client = accept(listener, (struct sockaddr*)&client_name, &client_len);
    if (client == -1)
        fatal(""accept"");

    printf(""Received connection from %s\n"", inet_ntoa(client_name.sin_addr));

    char buffer[8192] = {0};
    while (g_continue)
    {
        int bytes = read(client, buffer, sizeof(buffer));
        if (bytes < 0)
            fatal(""read"");
        else if (bytes == 0)
            break ;
        
        buffer[bytes] = '\0';
        printf(""Received message: %s\n"", buffer);

        write(client, buffer, bytes);
    }

    close(client);
    close(listener);}
    return 0;
}",signum
374,"#pragma once

#ifdef _WIN32

#include ""Core/Platform/Windows/WindowsHandles.h""
#include ""Core/Graphics/GraphicsRenderer.h""
#include ""DX12_Handles.h""

#include <vector>

#ifdef new 
#pragma push_macro(""new"") 
#undef new 
#endif

#pragma warning( push )
#pragma warning( disable : 4244 ) // conversion from 'wchar_t' to 'char', possible loss of data
#pragma warning( disable : 5204 ) // class has virtual functions, but its trivial destructor is not virtual; instances of objects derived from this class may not be destructed correctly
#pragma warning( disable : 4265 ) // class has virtual functions, but its non-trivial destructor is not virtual; instances of this class may not be destructed correctly
#pragma warning( disable : 6387 ) // could be '0' does not adhere to the specification for the function
#pragma warning( disable : 4365 ) // conversion from 'LONG' to 'UINT', signed/unsigned mismatch

// controls whether all the display information is displayed or not
// #define VERBOSE_DISPLAY_INFO

namespace ATGE
{
	using Microsoft::WRL::ComPtr;

	bool GraphicsRenderer::initGraphics(const void* pPlatform)
	{
		Logger::debug(""Starting DirectX12...\n"");

		DXHandles* handles = new DXHandles();
		this->m_pGraphicsHandles = handles;

#pragma region InitDirect3D
		HRESULT result;

#pragma region Enable the D3D12 debug layer.
#ifdef _DEBUG 
		{
			ComPtr<ID3D12Debug> debugController;
			
			result = D3D12GetDebugInterface(IID_PPV_ARGS(&debugController));
			ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to get DebugInterface.\n"");

			debugController->EnableDebugLayer();
		}
#endif
#pragma endregion

#pragma region Try to create hardware device.

		result = CreateDXGIFactory1(IID_PPV_ARGS(&handles->m_dxgiFactory));
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create DXGI Factory.\n"");
		result = D3D12CreateDevice(
								nullptr,					// default adapter
								D3D_FEATURE_LEVEL_12_0,
								IID_PPV_ARGS(&handles->m_d3dDevice));

		// Fallback to WARP device.
		if (FAILED(result))
		{
			ComPtr<IDXGIAdapter> pWarpAdapter;
			result = handles->m_dxgiFactory->EnumWarpAdapter(IID_PPV_ARGS(&pWarpAdapter));			
			ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to init Adapter.\n"");

			result = D3D12CreateDevice(
								pWarpAdapter.Get(),
								D3D_FEATURE_LEVEL_11_0,
								IID_PPV_ARGS(&handles->m_d3dDevice));

			ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to init dx Device.\n"");
		}
#pragma endregion

#pragma region Create Fence
		result = handles->m_d3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&handles->m_Fence));
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create fence.\n"");

		handles->m_RtvDescriptorSize = handles->m_d3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
		handles->m_DsvDescriptorSize = handles->m_d3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
		handles->m_CbvSrvUavDescriptorSize = handles->m_d3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
#pragma endregion

#pragma region Check 4X MSAA quality support for our back buffer format.
		// Check 4X MSAA quality support for our back buffer format.
		// All Direct3D 11 capable devices support 4X MSAA for all render 
		// target formats, so we only need to check quality support.
		D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS msQualityLevels;
		msQualityLevels.Format = handles->m_BackBufferFormat;
		msQualityLevels.SampleCount = 4;
		msQualityLevels.Flags = D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE;
		msQualityLevels.NumQualityLevels = 0;
		result = handles->m_d3dDevice->CheckFeatureSupport(
								D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
								&msQualityLevels,
								sizeof(msQualityLevels));

		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to check feature support"");

		handles->m_4xMsaaQuality = msQualityLevels.NumQualityLevels;
		ATGE_ASSERT_MSG(handles->m_4xMsaaQuality > 0, ""Unexpected MSAA quality level."");
#pragma endregion

#pragma region Log Adapters
#ifdef _DEBUG
		std::vector<IDXGIAdapter*> adapterList;
		{
			UINT i = 0;
			IDXGIAdapter* adapter = nullptr;
			while (handles->m_dxgiFactory->EnumAdapters(i, &adapter) != DXGI_ERROR_NOT_FOUND)
			{
				DXGI_ADAPTER_DESC desc;
				adapter->GetDesc(&desc);

				std::wstring wText = L""***Adapter: "";
				wText += desc.Description;
				wText += L""\n"";

				std::string text = std::string(wText.begin(), wText.end());

				Logger::log(LogLevel::LEVEL_DEBUG, text.c_str());

				adapterList.push_back(adapter);

				++i;
			}

		}

		for (const auto& adapter : adapterList)
		{
			{
				UINT i = 0;
				IDXGIOutput* output = nullptr;
				while (adapter->EnumOutputs(i, &output) != DXGI_ERROR_NOT_FOUND)
				{
					DXGI_OUTPUT_DESC desc;
					output->GetDesc(&desc);
					
					// log device name
					{
						std::wstring wText = L""***Output: "";
						wText += desc.DeviceName;
						wText += L""\n"";
					
						std::string text = std::string(wText.begin(), wText.end());
						Logger::log(LogLevel::LEVEL_DEBUG, text.c_str());
					}

#ifdef VERBOSE_DISPLAY_INFO
					{
						UINT count = 0;
						UINT flags = 0;

						// Call with nullptr to get list count.
						output->GetDisplayModeList(handles->m_BackBufferFormat, flags, &count, nullptr);

						std::vector<DXGI_MODE_DESC> modeList(count);
						output->GetDisplayModeList(handles->m_BackBufferFormat, flags, &count, &modeList[0]);

						for (auto& x : modeList)
						{
							UINT n = x.RefreshRate.Numerator;
							UINT d = x.RefreshRate.Denominator;
							std::wstring wText =
								L""Width = "" + std::to_wstring(x.Width) + L"" "" +
								L""Height = "" + std::to_wstring(x.Height) + L"" "" +
								L""Refresh = "" + std::to_wstring(n) + L""/"" + std::to_wstring(d) +
								L""\n"";

							std::string text = std::string(wText.begin(), wText.end());
							Logger::log(LogLevel::LEVEL_DEBUG, text.c_str());
						}
					}
#endif

					output->Release();
					i++;
				}
			}

			adapter->Release();
		}
#endif
#pragma endregion
		
#pragma region Create Command Objects
		D3D12_COMMAND_QUEUE_DESC queueDesc = {};
		queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
		queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
		result = handles->m_d3dDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&handles->m_CommandQueue));
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create command queue"");

		result = handles->m_d3dDevice->CreateCommandAllocator(
								D3D12_COMMAND_LIST_TYPE_DIRECT,
								IID_PPV_ARGS(handles->m_DirectCmdListAlloc.GetAddressOf()));
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create command allocator"");

		result = handles->m_d3dDevice->CreateCommandList(
								0,
								D3D12_COMMAND_LIST_TYPE_DIRECT,
								handles->m_DirectCmdListAlloc.Get(), // Associated command allocator
								nullptr,                   // Initial PipelineStateObject
								IID_PPV_ARGS(handles->m_CommandList.GetAddressOf()));
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create command list"");

		// Start off in a closed state.  This is because the first time we refer 
		// to the command list we will Reset it, and it needs to be closed before
		// calling Reset.
		handles->m_CommandList->Close();
#pragma endregion

#pragma region Create Swap Chain
		// Release the previous swapchain we will be recreating.
		handles->m_SwapChain.Reset();

		DXGI_SWAP_CHAIN_DESC sd;
		sd.BufferDesc.Width = handles->m_ClientWidth;
		sd.BufferDesc.Height = handles->m_ClientHeight;
		sd.BufferDesc.RefreshRate.Numerator = 60;
		sd.BufferDesc.RefreshRate.Denominator = 1;
		sd.BufferDesc.Format = handles->m_BackBufferFormat;
		sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
		sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
		sd.SampleDesc.Count = handles->m_4xMsaaState ? 4u : 1u;
		sd.SampleDesc.Quality = handles->m_4xMsaaState ? (handles->m_4xMsaaQuality - 1) : 0;
		sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
		sd.BufferCount = DXHandles::SwapChainBufferCount;
		sd.OutputWindow = ((PS_WindowsState*)pPlatform)->hwnd;
		sd.Windowed = true;
		sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
		sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

		// Note: Swap chain uses queue to perform flush.
		result = handles->m_dxgiFactory->CreateSwapChain(
						handles->m_CommandQueue.Get(),
						&sd,
						handles->m_SwapChain.GetAddressOf());

		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create swap chain"");
#pragma endregion

#pragma region Create Rtv And Dsv Descriptor Heaps
		D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc;
		rtvHeapDesc.NumDescriptors = DXHandles::SwapChainBufferCount;
		rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
		rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
		rtvHeapDesc.NodeMask = 0;
		result = handles->m_d3dDevice->CreateDescriptorHeap(
						&rtvHeapDesc, IID_PPV_ARGS(handles->m_RtvHeap.GetAddressOf()));
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create rtv descriptor heap"");

		D3D12_DESCRIPTOR_HEAP_DESC dsvHeapDesc;
		dsvHeapDesc.NumDescriptors = 1;
		dsvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
		dsvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
		dsvHeapDesc.NodeMask = 0;
		result = handles->m_d3dDevice->CreateDescriptorHeap(
						&dsvHeapDesc, IID_PPV_ARGS(handles->m_DsvHeap.GetAddressOf()));
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create dsv descriptor heap"");
#pragma endregion

#pragma endregion

		this->onResize();

		Logger::debug(""DirectX12 Initialized!!\n"");

		return true;
	}
	
	void GraphicsRenderer::shutdown()
	{
		if (((DXHandles*)this->m_pGraphicsHandles)->m_d3dDevice != nullptr)
			this->flush();

		delete this->m_pGraphicsHandles;

		Logger::debug(""DirectX12 Successfully Shutdown!!\n"");
	}

	void GraphicsRenderer::renderFrame()
	{
		DXHandles* handles = static_cast<DXHandles*>(m_pGraphicsHandles);
		HRESULT result = S_OK;

		// Reset the command allocator.
		result = handles->m_DirectCmdListAlloc->Reset();
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to reset command allocator."");

		// Reset the command list; no initial pipeline state object.
		result = handles->m_CommandList->Reset(handles->m_DirectCmdListAlloc.Get(), nullptr);
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to reset command list."");

		// Set the viewport and scissor rectangle.
		handles->m_CommandList->RSSetViewports(1, &handles->m_ScreenViewport);
		handles->m_CommandList->RSSetScissorRects(1, &handles->m_ScissorRect);

		// Get the current back buffer resource.
		ID3D12Resource* currBackBuffer = handles->m_SwapChainBuffer[handles->m_CurrBackBuffer].Get();

		// Transition the back buffer from PRESENT to RENDER_TARGET.
		auto barrier = CD3DX12_RESOURCE_BARRIER::Transition(
						currBackBuffer,
						D3D12_RESOURCE_STATE_PRESENT,
						D3D12_RESOURCE_STATE_RENDER_TARGET);

		handles->m_CommandList->ResourceBarrier(1, &barrier);

		// Obtain the current render target view handle.
		CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(handles->m_RtvHeap->GetCPUDescriptorHandleForHeapStart());
		rtvHandle.Offset(handles->m_CurrBackBuffer, handles->m_RtvDescriptorSize);

		// Clear the render target view with a solid background color.
		const float clearColor[4] = { 0.69f, 0.77f, 0.87f, 1.0f }; // LightSteelBlue.
		handles->m_CommandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr);

		// Clear the depth/stencil view.
		handles->m_CommandList->ClearDepthStencilView(
			handles->m_DsvHeap->GetCPUDescriptorHandleForHeapStart(),
			D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL,
			1.0f,
			0,
			0,
			nullptr);

		// Set the render target.
		auto  [MASK]  = handles->m_DsvHeap->GetCPUDescriptorHandleForHeapStart();
		handles->m_CommandList->OMSetRenderTargets(1, &rtvHandle, true, & [MASK] );

		// [Mesh rendering code would normally go here, but it is omitted for now.]

		// Transition the back buffer from RENDER_TARGET back to PRESENT.
		barrier = CD3DX12_RESOURCE_BARRIER::Transition(
				currBackBuffer,
				D3D12_RESOURCE_STATE_RENDER_TARGET,
				D3D12_RESOURCE_STATE_PRESENT);
		handles->m_CommandList->ResourceBarrier(1, &barrier);

		// Close the command list.
		result = handles->m_CommandList->Close();
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to close command list."");

		// Execute the command list.
		ID3D12CommandList* cmdLists[] = { handles->m_CommandList.Get() };
		handles->m_CommandQueue->ExecuteCommandLists(_countof(cmdLists), cmdLists);

		// Present the swap chain.
		result = handles->m_SwapChain->Present(0, 0);
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to present swap chain."");

		// Update the current back buffer index.
		handles->m_CurrBackBuffer = (handles->m_CurrBackBuffer + 1) % DXHandles::SwapChainBufferCount;

		// Wait until frame commands are complete.
		this->flush();
	}

	void GraphicsRenderer::onResize()
	{
		// Retrieve our DX12 handles.
		DXHandles* handles = static_cast<DXHandles*>(m_pGraphicsHandles);

		ATGE_ASSERT_MSG(handles->m_d3dDevice, ""DirectX device not initialized."");
		ATGE_ASSERT_MSG(handles->m_SwapChain, ""Swap chain not initialized."");
		ATGE_ASSERT_MSG(handles->m_DirectCmdListAlloc, ""Command allocator not initialized."");

		// Flush the GPU queue before changing any resources.
		this->flush();

		HRESULT result = S_OK;

		// Reset the command list to prepare for resource changes.
		result = handles->m_CommandList->Reset(handles->m_DirectCmdListAlloc.Get(), nullptr);
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to reset command list."");

		// Release previous render target resources.
		for (auto& buff : handles->m_SwapChainBuffer)
		{
			buff.Reset();
		}
		handles->m_DepthStencilBuffer.Reset();

		// Resize the swap chain buffers.
		result = handles->m_SwapChain->ResizeBuffers(
			DXHandles::SwapChainBufferCount,
			handles->m_ClientWidth, handles->m_ClientHeight,
			handles->m_BackBufferFormat,
			DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH);
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to resize swap chain buffers."");

		handles->m_CurrBackBuffer = 0;

		// Recreate render target views.
		CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHeapHandle(handles->m_RtvHeap->GetCPUDescriptorHandleForHeapStart());
		for (UINT i = 0; i < DXHandles::SwapChainBufferCount; i++)
		{
			result = handles->m_SwapChain->GetBuffer(i, IID_PPV_ARGS(&handles->m_SwapChainBuffer[i]));
			ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to get swap chain buffer."");
			handles->m_d3dDevice->CreateRenderTargetView(handles->m_SwapChainBuffer[i].Get(), nullptr, rtvHeapHandle);
			rtvHeapHandle.Offset(1, handles->m_RtvDescriptorSize);
		}

		// Set up the depth/stencil buffer description.
		D3D12_RESOURCE_DESC depthStencilDesc = {};
		depthStencilDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
		depthStencilDesc.Alignment = 0;
		depthStencilDesc.Width = handles->m_ClientWidth;
		depthStencilDesc.Height = handles->m_ClientHeight;
		depthStencilDesc.DepthOrArraySize = 1;
		depthStencilDesc.MipLevels = 1;
		// Use a typeless format so that both SRV and DSV can be created.
		depthStencilDesc.Format = DXGI_FORMAT_R24G8_TYPELESS;
		depthStencilDesc.SampleDesc.Count = handles->m_4xMsaaState ? 4 : 1;
		depthStencilDesc.SampleDesc.Quality = handles->m_4xMsaaState ? (handles->m_4xMsaaQuality - 1) : 0;
		depthStencilDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
		depthStencilDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;

		// Set the clear value.
		D3D12_CLEAR_VALUE optClear = {};
		optClear.Format = handles->m_DepthStencilFormat;
		optClear.DepthStencil.Depth = 1.0f;
		optClear.DepthStencil.Stencil = 0;

		CD3DX12_HEAP_PROPERTIES heapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);

		// Create the depth/stencil buffer resource.
		result = handles->m_d3dDevice->CreateCommittedResource(
					&heapProperties,
					D3D12_HEAP_FLAG_NONE,
					&depthStencilDesc,
					D3D12_RESOURCE_STATE_COMMON,
					&optClear,
					IID_PPV_ARGS(handles->m_DepthStencilBuffer.GetAddressOf()));

		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to create depth/stencil buffer resource."");

		// Create the depth/stencil view.
		D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc = {};
		dsvDesc.Flags = D3D12_DSV_FLAG_NONE;
		dsvDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
		dsvDesc.Format = handles->m_DepthStencilFormat;
		dsvDesc.Texture2D.MipSlice = 0;
		handles->m_d3dDevice->CreateDepthStencilView(
			handles->m_DepthStencilBuffer.Get(),
			&dsvDesc,
			handles->m_DsvHeap->GetCPUDescriptorHandleForHeapStart());

		auto barrier = CD3DX12_RESOURCE_BARRIER::Transition(handles->m_DepthStencilBuffer.Get(),
					D3D12_RESOURCE_STATE_COMMON,
					D3D12_RESOURCE_STATE_DEPTH_WRITE);

		// Transition the depth/stencil buffer to a writable state.
		handles->m_CommandList->ResourceBarrier(1, &barrier);

		// Close the command list and execute the resize commands.
		result = handles->m_CommandList->Close();
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to close command list."");
		ID3D12CommandList* cmdLists[] = { handles->m_CommandList.Get() };
		handles->m_CommandQueue->ExecuteCommandLists(_countof(cmdLists), cmdLists);

		// Wait until the GPU has completed the resize operations.
		this->flush();

		// Update the viewport and scissor rectangle to match the new window size.
		handles->m_ScreenViewport.TopLeftX = 0;
		handles->m_ScreenViewport.TopLeftY = 0;
		handles->m_ScreenViewport.Width = static_cast<float>(handles->m_ClientWidth);
		handles->m_ScreenViewport.Height = static_cast<float>(handles->m_ClientHeight);
		handles->m_ScreenViewport.MinDepth = 0.0f;
		handles->m_ScreenViewport.MaxDepth = 1.0f;

		handles->m_ScissorRect = { 0, 0, static_cast<LONG>(handles->m_ClientWidth), static_cast<LONG>(handles->m_ClientHeight) };
	}

	void GraphicsRenderer::flush()
	{
		DXHandles* handles = static_cast<DXHandles*>(m_pGraphicsHandles);
		HRESULT result = S_OK;

		// Advance the fence value to mark commands up to this fence point.
		handles->m_CurrentFence++;

		// Signal the command queue with the new fence value.
		result = handles->m_CommandQueue->Signal(handles->m_Fence.Get(), handles->m_CurrentFence);
		ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to signal fence."");

		// If the GPU hasn't finished processing commands up to this fence point, wait.
		if (handles->m_Fence->GetCompletedValue() < handles->m_CurrentFence)
		{
			HANDLE eventHandle = CreateEventEx(nullptr, 0, 0, EVENT_ALL_ACCESS);
			result = handles->m_Fence->SetEventOnCompletion(handles->m_CurrentFence, eventHandle);
			ATGE_ASSERT_MSG(SUCCEEDED(result), ""Failed to set event on fence completion."");

			// Wait until the GPU has completed processing.
			WaitForSingleObject(eventHandle, INFINITE);
			CloseHandle(eventHandle);
		}
	}
}

#pragma warning( pop ) 
#endif",cpuDesc
375,"//Written by <NAME> and <NAME>
//Created on January 16 at 9:40am PST
//This program has a handful of fun short games to play

#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <random>
#include <string>
#include <vector>

using namespace std;

//vector to store hangman pictographs
const vector<string> hangmanPics = {""\n  +---+\n      |\n      |\n      |\n     ==="", ""\n  +---+\n  O   |\n      |\n      |\n     ==="", ""\n  +---+\n  O   |\n  |   |\n      |\n     ==="", ""\n  +---+\n  O   |\n /|   |\n      |\n     ==="", ""\n  +---+\n  O   |\n /|\\  |\n      |\n     ==="", ""\n  +---+\n  O   |\n /|\\  |\n /    |\n     ==="", ""\n  +---+\n  O   |\n /|\\  |\n / \\  |\n     ===""};

//structure for saving team information
struct teamInfo_t {
    string teamName = """";
    int totalWins = 0;
};

//function to get the teams in the game
vector<teamInfo_t> getTeamNames() {

    int  [MASK]  = 0;
    while (true) {
        cout << ""How many teams will be playing today? "";
        cin >>  [MASK] ;
        //check to make sure only integers are used
        if (cin.fail()) {
            cin.clear();
            cin.ignore();
            cout << ""Enter a valid number! \n"";
        } else {
            break;
        }
    }

    cout << ""Very cool! We have got "" <<  [MASK]  << "" playing today!\nNow how about we get some names?"";
    //create vector to store teams
    vector<teamInfo_t> teamList = {};
    for (int i = 1; i <=  [MASK] ; i++) {
        //as teams are added ask for their names
        cout << ""\nName for Team "" << i << "": "";
        teamInfo_t newTeam;
        string teamInput = """";
        cin >> teamInput;
        newTeam.teamName = teamInput;
        teamList.push_back(newTeam);
    }

    cout << ""So for review, today our competing teams will be "";
    //if only playing one team
    if ( [MASK]  == 1) {
        cout << ""just you!"";
    } else {
        //print for multiple teams 
        for (int i = 0; i < teamList.size(); i++) {
            if (i == (teamList.size() - 1)) {
                cout << ""and "" << teamList.at(teamList.size() - 1).teamName << ""!"";
            } else {
                cout << teamList.at(i).teamName << "", "";
            }
        }
    }
    return teamList;
}

//function to read the wordlist 
vector<string> readHangmanWords() {
    string fileName;
    cout << (""\n\nPlease give the file name that your word list is stored in:  "");
    cin >> fileName;
    ifstream wordlistFile(fileName);

    //check if the file exists, if it doesn't quit the program 
    if (wordlistFile.fail()) {
        cout << ""There is no such file. "";
        exit(EXIT_FAILURE);
    }
    
    //get the wordlist and format it to be all upper case 
    vector<string> wordlist = {};
    string word;
    while (true) {
        getline(wordlistFile, word);
        string upper_word = """";
        for (char x : word) {
            x = toupper(x);
            upper_word += x;
        }
        wordlist.push_back(upper_word);
        if (wordlistFile.fail()) {
            break;
        }
    }

    wordlistFile.close();
    return wordlist;
}

//choosing the random word for the hangman 
string getRandomWord(const vector<string> &wordList) {

    return wordList.at(rand() % wordList.size());
}

//interpreting the inputs of the user 
char getGuess(vector<char> guesses) {
    char guess = ' ';

    while (true) {
        //prompt the user 
        cout << ""\nGuess a letter: "";
        //capitalize the input 
        cin >> guess;
        guess = toupper(guess);
        
        //check if the user is going to guess the entire word 
        if (guess == '!') {
            cout << ""You must now guess the whole word: "";
            return guess;
        //check if that letter has already been guessed 
        } else if (count(guesses.begin(), guesses.end(), guess)) {
            cout << ""\nYou have already guessed that letter."";
        //check if the input is actually a letter 
        } else if (guess < 65 || guess > 132) {
            cout << ""\nPlease enter a LETTER."";
        } else {
        //if it passses through everthing return it 
            return guess;
        }
    }
}

void displayHangman(vector<char> badGuesses, vector<char> guesses, string word, bool &gameDone) {

    //display the hangman picture corresponding to how many incorrect guesses have been made
    cout << hangmanPics.at(badGuesses.size());
    cout << ""\nMissed guesses: "";

    //display all the incorrect guesses
    for (char guess : badGuesses) {
        cout << guess << "", "";
    }

    cout << '\n';

    //display the underlines to show how many letters, but replace them with the letter if it has been guessed
    for (char letter : word) {
        if (count(guesses.begin(), guesses.end(), letter)) {
            cout << letter << ' ';
        } else if (letter == ' ') {
            cout << ' ';
        } else {
            cout << ""_ "";
        }
    }
}

bool hangmanRound(vector<string> &wordBank, vector<teamInfo_t> &teams) {

    //initiate a list for bad guesses and total guesses, including space so the player doesn't have to
    vector<char> badGuesses = {};
    vector<char> guesses = {' '};

    //pick a random word from the word bank
    string word = getRandomWord(wordBank);
    bool gameDone = false;

    for (int turn = (rand() % teams.size());; turn++) {
        //determine the team here
        int currentTeam = turn % teams.size();
        cout << ""\nIt is "" << teams.at(currentTeam).teamName << ""'s turn\n\n"";

        displayHangman(badGuesses, guesses, word, gameDone);

        //get the player's guess
        char guess = getGuess(guesses);
        guesses.push_back(guess);

        //! indicates that a player is ready to guess the whole word
        if (guess == '!') {
            string wholeWord = """";
            cin.ignore();
            //getline the answer (including spaces)
            getline(cin, wholeWord);
            string upper_word = """";
            for (char x : wholeWord) {
                x = toupper(x);
                upper_word += x;
            }
            //if the word is correct, the game is over
            if (upper_word == word) {
                cout << ""Congratulations! The word was "" << word << ""."";
                cout << "" \nThe winner is "" << teams.at(currentTeam).teamName << ""!\n"";
                teams.at(currentTeam).totalWins++;
                return true;
            }
            //if the word is not correct, count it as a bad guess and continue
            else {
                cout << ""\nNo, "" << upper_word << "" is not correct.\n"";
            }
        }

        //if the guess is not in the word, add it to the list of bad guesses
        if (!(count(word.begin(), word.end(), guess))) {
            badGuesses.push_back(guess);
        }

        //check if the players have reached the max amount of guesses
        if (badGuesses.size() == hangmanPics.size()) {
            cout << ""You are out of guesses! The word was "" << word << ""."";
            gameDone = true;
        }

        //check if all letters are present
        bool allLetters = true;
        for (char letter : word) {
            if (!count(guesses.begin(), guesses.end(), letter)) {
                allLetters = false;
                break;
            }
        }
        //if all letters are present, then the game is over
        if (allLetters) {
            gameDone = true;
            displayHangman(badGuesses, guesses, word, gameDone);
            cout << ""\n\nCongratulations! The word was "" << word;
            cout << "" \nThe winner is "" << teams.at(currentTeam).teamName << ""!\n"";
            teams.at(currentTeam).totalWins++;
        }
        //return if the game is done
        if (gameDone) {
            return true;
        }
    }
}

void playHangman() {

    cout << ""Welcome to Hangman!\nYou may supply your own vocabulary by putting words (no punctuation) in a .txt file.\nIf you are ready to guess the whole word, press enter !"";

    //initiate and fill the word bank
    vector<string> wordBank = {};
    wordBank = readHangmanWords();

    //get team names
    vector<teamInfo_t> teams = getTeamNames();

    //play hangman infinitely until the players stop
    while (hangmanRound(wordBank, teams)) {
        cout << ""\nScoreboard\n----------\n"";

        //display scores
        for (teamInfo_t team : teams) {
            cout << team.teamName << "": "" << team.totalWins << ""\n"";
        }

        //prompt them to play again, quit if their answer doesn't start with y
        cout << ""Type yes if you would like to play again: "";
        string answer = "" "";
        cin >> answer;
        if (!(answer.at(0) == 'y' || answer.at(0) == 'Y')) {
            break;
        }

        //ask them to reselect a category
        wordBank = readHangmanWords();
    }
}

int main() {
    //seed the random and start the game
    srand(time(nullptr));
    playHangman();
}",numberOfTeams
376,"//
// Created by  <NAME> on 22.10.2024.
//
#include <iostream>
#include <fstream>
#include ""magma.hpp""

using namespace std;

int main(int argc, const char *argv[]) {
  ifstream envs(""../.env"");
  if (!envs.is_open()) {
    cout << ""Error opening envs file"" << endl;
  }
  auto *key_name = new char[4];
  auto *key = new uint32_t[8];
  envs.read(key_name, 4);
  envs.read(reinterpret_cast<char *>(key), sizeof(key)*4);
  envs.close();

  Magma alg(key);

  cout << ""ENCRYPT"" << endl;
  ifstream inputfile(""../input.txt"", ios::binary);
  ofstream outputfile(""../encrypt.txt"", ios::binary);
  if (inputfile.is_open() && outputfile.is_open()) {
    auto *line = new uint32_t[2];
    uint32_t init_vec[2] {0xffff, 0xffff};
    while (
      inputfile.read(reinterpret_cast<char *>(&line[0]), sizeof(line[0])) &&
      inputfile.read(reinterpret_cast<char *>(&line[1]), sizeof(line[0]))
      )
    {
      cout << ""INP LINE "" << line[0] << "" "" << line[1] << endl;
      line[0] ^= init_vec[0];
      line[1] ^= init_vec[1];
      alg.encrypt_block(line);
      cout << ""ENC LINE "" << line[0] << "" "" << line[1] << endl;
      init_vec[0] = line[0];
      init_vec[1] = line[1];
      outputfile.write(reinterpret_cast<char*>(&line[0]), sizeof(line[0]));
      outputfile.write(reinterpret_cast<char*>(&line[1]), sizeof(line[0]));
    }

    inputfile.close();
    outputfile.close();
    delete[] line;
  }


  cout << ""DECRYPT"" << endl;
  ifstream enc_file(""../encrypt.txt"", ios::binary);
  ofstream  [MASK] (""../decrypt.txt"", ios::binary);
  if (enc_file.is_open() &&  [MASK] .is_open()) {
    auto *line = new uint32_t[2];
    uint32_t init_vec[2] {0xffff, 0xffff};
    uint32_t cbc_vec[2];
    while (
      enc_file.read(reinterpret_cast<char *>(&line[0]), sizeof(line[0])) &&
      enc_file.read(reinterpret_cast<char *>(&line[1]), sizeof(line[0]))
      )
    {
      cout << ""ENC LINE "" << line[0] << "" "" << line[1] << endl;
      cbc_vec[0] = line[0];
      cbc_vec[1] = line[1];
      alg.decrypt_block(line);
      line[0] ^= init_vec[0];
      line[1] ^= init_vec[1];
      init_vec[0] = cbc_vec[0];
      init_vec[1] = cbc_vec[1];
      cout << ""DEC LINE "" << line[0] << "" "" << line[1] << endl;
       [MASK] .write(reinterpret_cast<char*>(&line[0]), sizeof(line[0]));
       [MASK] .write(reinterpret_cast<char*>(&line[1]), sizeof(line[0]));
    }

    delete[] line;
    enc_file.close();
     [MASK] .close();
  }
  delete[] key;
  return 0;
}",dec_file
377,"#include ""ContentBrowserPanel.h""

#include ""Mirage/Definitions/FileExtensions.h""
#include ""Mirage/Definitions/DragnDropPayloads.h""
#include ""Mirage/Definitions/Icons.h""
#include ""ImGui/imgui.h""
#include ""ImGui/imgui_internal.h""
#include ""Mirage/Core/Log.h""
#include ""Mirage/Core/Time.h""
#include ""Mirage/ImGui/Extensions/DrawingAPI.h""
#include ""Mirage/ImGui/Extensions/Splitter.h""

namespace Mirage
{
	// TODO: Change when Project is implemented
	static const std::filesystem::path s_AssetsPath = ""Assets"";
	static Timer s_BrowserUpdateTimer;
	static Timer s_HierarchyUpdateTimer;
	static float s_BrowserUpdateInterval = 1.0f;

	ContentBrowserPanel::ContentBrowserPanel()
		: m_CurrentDirectory(s_AssetsPath)
	{
		MarkUpdateContents();
		m_DirectoryIcon = Texture2D::Create(Icons::Folder);
		m_FileIcon = Texture2D::Create(Icons::File);
		m_MirageIcon = Texture2D::Create(Icons::Mirage);
	}

	void ContentBrowserPanel::OnImGuiRender()
	{
		if(ImGui::Begin(""Content Browser"", nullptr, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse))
		{
			if (!exists(m_CurrentDirectory))
			{
				m_CurrentDirectory = s_AssetsPath;
				MarkUpdateContents();
			}
			UpdateBrowser();

			DrawHeader();

			m_RightPanelSize = ImGui::GetContentRegionAvail().x - m_LeftPanelSize - m_SeparatorThickness;
			ImGui::DrawSplitter(0, m_SeparatorThickness, &m_LeftPanelSize, &m_RightPanelSize, 50.0f, 100.0f);

			DrawDirectoryHierarchy();

			ImGui::SameLine();

			DrawContents();
			DrawStatusBar();

			ImGui::End();
		}
		else
		{
			ImGui::End();
		}
	}

	void ContentBrowserPanel::DrawHeader()
	{
		bool backward = !m_BackWardNavigation.empty();
		bool forward = !m_ForwardNavigation.empty();

		ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 12.0f);
		if (!backward)
		{
			ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
			ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.3f);
		}
		if (ImGui::Button(""<<"", ImVec2{0.0f, 25.0f}) || ImGui::IsMouseClicked(3))
		{
			NavigateBackward();
		}
		if (!backward)
		{
			ImGui::PopItemFlag();
			ImGui::PopStyleVar();
		}


		ImGui::SameLine();


		if (!forward)
		{
			ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
			ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.3f);
		}
		if (ImGui::Button("">>"", ImVec2{0.0f, 25.0f}) || ImGui::IsMouseClicked(4))
		{
			NavigateForward();
		}
		if (!forward)
		{
			ImGui::PopItemFlag();
			ImGui::PopStyleVar();
		}
		ImGui::PopStyleVar();

		ImGui::SameLine();

		static char* pathBuf = new char[512];
		static bool pathBufDirty = false;

		strcpy_s(pathBuf, 512, m_CurrentDirectory.string().c_str());
		ImGui::PushItemWidth(-1);
		pathBufDirty |= ImGui::InputText(""##PathHeader"", pathBuf, 512);
		ImGui::PopItemWidth();
		if (pathBufDirty && !ImGui::IsItemActive())
		{
			std::filesystem::path newPath = pathBuf;
			if (std::filesystem::exists(newPath))
			{
				pathBufDirty = false;
				NavigateTo(pathBuf);
			}
		}
	}

	void ContentBrowserPanel::DrawDirectoryHierarchy()
	{
		ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4{0.12f, 0.12f, 0.12f, 1.0f});
		ImGui::BeginChild(""VerticalView"", ImVec2{m_LeftPanelSize, -1}, false, ImGuiWindowFlags_HorizontalScrollbar);
		DrawDirectoryNode(s_AssetsPath, ""Assets"");
		ImGui::EndChild();
		ImGui::PopStyleColor();
	}

	void ContentBrowserPanel::DrawContents()
	{
		ImGui::BeginGroup();
		auto& style = ImGui::GetStyle();

		ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{0.0f, 0.0f, 0.0f, 0.0f});
		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{m_itemSpacing, style.ItemSpacing.y});
		ImGui::BeginChild(""ContentView"",
		                  ImVec2{
			                  m_RightPanelSize,
			                  ImGui::GetContentRegionAvail().y - ImGui::GetFrameHeight() - style.WindowPadding.y * 2.0f
		                  },
		                  false);

		if (ImGui::IsMouseClicked(0) && ImGui::IsWindowHovered())
			m_SelectedPath = m_CurrentDirectory;

		float cellSize = m_thumbnailSize + (style.ItemSpacing.x + style.FramePadding.x) * 2.0f;

		float panelWidth = ImGui::GetContentRegionAvail().x;
		int  [MASK]  = (int)(panelWidth / cellSize);
		if ( [MASK]  < 1)
			 [MASK]  = 1;

		ImGui::Columns( [MASK] , 0, false);

		int id= 0;
		for (auto& path : m_Entries)
		{
			ImGui::PushID(id++);
			float cellStartX = ImGui::GetCursorPosX();
			float cellWidth = ImGui::GetColumnWidth();
			ImGui::SetCursorPosX(
				cellStartX + (cellWidth - style.FramePadding.x * 2.0f - m_thumbnailSize - style.ItemSpacing.x * 2.0f) /
				2);
			bool isSelected = m_SelectedPath == path;
			if (isSelected)
			{
				ImGui::PushStyleColor(ImGuiCol_Button, m_SelectedBGColor);
			}
			
			if (is_directory(path))
			{
				ImGui::ImageButton((ImTextureID)m_DirectoryIcon->GetRendererID(),
				                   {(float)m_thumbnailSize, (float)m_thumbnailSize},
				                   {0, 1}, {1, 0}, -1, ImVec4{0.0f, 0.0f, 0.0f, 0.0f},
				                   m_DirectoryTintColor);
				if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
				{
					NavigateTo(path);
				}
			}
			else
			{
				ImGui::ImageButton((ImTextureID)SetIcon(path)->GetRendererID(),
				                   {(float)m_thumbnailSize, (float)m_thumbnailSize},
				                   {0, 1}, {1, 0}, -1, ImVec4{0.0f, 0.0f, 0.0f, 0.0f},
				                   m_FileTintColor);
				if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
				{
					MRG_CORE_WARN(""double clicked file"");
					OnFileDoubleClick(path);
				}
			}

			if (isSelected)
			{
				ImGui::PopStyleColor();
			}
			if (ImGui::IsItemClicked())
			{
				m_SelectedPath = path;
			}
			if (ImGui::BeginDragDropSource())
			{
				SetPayload();
				ImGui::BeginTooltip();
				SetTooltip();
				ImGui::EndTooltip();
				ImGui::EndDragDropSource();
			}
			
			std::string fName = path.filename().string();
			float textSize = ImGui::CalcTextSize(fName.c_str()).x;
			float textZoneWidth = cellWidth - style.ItemSpacing.x * 2.0f;
			ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + cellWidth - style.ItemSpacing.x);
			if (textSize < textZoneWidth)
			{
				ImGui::SetCursorPosX(cellStartX + (textZoneWidth - textSize) / 2);
			}
			else
			{
				ImGui::SetCursorPosX(cellStartX - m_itemSpacing + style.ItemSpacing.x / 2);
			}
			if (ImGui::IsItemHovered())
			{
				ImGui::SetTooltip(fName.c_str());
			}

			// Set text max width to cell width - item spacing
			ImGui::Text(fName.c_str());
			ImGui::PopTextWrapPos();

			if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
			{
				// TODO: Rename
			}

			ImGui::PopID();
			ImGui::NextColumn();
		}
		ImGui::Columns(1);

		ImGui::PopStyleVar(1);
		ImGui::PopStyleColor();
		ImGui::EndChild();
	}

	void ContentBrowserPanel::DrawStatusBar()
	{
		auto& style = ImGui::GetStyle();
		float settingsWidth = ImGui::CalcTextSize(""Thumbnail size: "").x + ImGui::CalcTextSize(""Padding: "").x +
			ImGui::GetStyle().ItemSpacing.x * 5.0f + 240.0f;
		float pathWidth = ImGui::GetContentRegionAvail().x - settingsWidth;

		ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4{0.12f, 0.12f, 0.12f, 1.0f});
		ImGui::BeginChild(""StatusSelectedPath"", ImVec2{pathWidth, -1}, false, ImGuiWindowFlags_HorizontalScrollbar);
		ImGui::SetCursorPos(ImVec2{style.WindowPadding.x, style.WindowPadding.y});
		ImGui::Text(m_SelectedPath.string().c_str());
		ImGui::EndChild();
		ImGui::PopStyleColor();

		ImGui::SameLine();

		ImGui::SetCursorPos(ImVec2{
			ImGui::GetCursorPosX() + style.ItemSpacing.x, ImGui::GetCursorPosY() + style.WindowPadding.y
		});
		ImGui::BeginGroup();
		ImGui::AlignTextToFramePadding();
		ImGui::Text(""Thumbnail size: "");
		ImGui::SameLine();
		ImGui::SetCursorPosY(ImGui::GetCursorPosY() + style.WindowPadding.y);
		ImGui::PushItemWidth(120);
		ImGui::SliderInt(""##Thumbnail Size"", &m_thumbnailSize, 16, 512);
		ImGui::PopItemWidth();

		ImGui::SameLine();
		ImGui::SetCursorPosY(ImGui::GetCursorPosY() + style.WindowPadding.y);
		ImGui::Text(""Padding: "");
		ImGui::SameLine();
		ImGui::PushItemWidth(120);
		ImGui::SetCursorPosY(ImGui::GetCursorPosY() + style.WindowPadding.y);
		ImGui::SliderFloat(""##Padding"", &m_itemSpacing, 0, 32);
		ImGui::PopItemWidth();
		ImGui::EndGroup();

		ImGui::EndGroup();
	}

	Ref<Texture2D> ContentBrowserPanel::SetIcon(std::filesystem::path path)
	{
		if (path.extension().string() == Extensions::scene)
		{
			return m_MirageIcon;
		}
		return m_FileIcon;
	}

	void ContentBrowserPanel::DrawDirectoryNode(std::filesystem::path path, const char* filename)
	{
		if (is_directory(path))
		{
			ImGuiTreeNodeFlags flags =
				ImGuiTreeNodeFlags_SpanFullWidth |
				ImGuiTreeNodeFlags_OpenOnArrow;
			bool opened = ImGui::TreeNodeEx(filename, flags);
			if (ImGui::IsItemClicked() && !ImGui::IsItemToggledOpen())
			{
				m_SelectedPath = path;
				NavigateTo(path);
			}
			if (opened)
			{
				if (ImGui::IsItemToggledOpen())
				{
					MarkUpdateTree();
				}
				// std::vector<std::filesystem::path> vec = m_BrowseCache[ImGui::GetID(filename)];
				std::vector<std::filesystem::path> vec = Browse(path);
				
				for (auto& p : vec)
				{
					std::string fStr = p.filename().string();
					DrawDirectoryNode(p, fStr.c_str());
				}

				ImGui::TreePop();
			}
		}
	}

	void ContentBrowserPanel::UpdateBrowser()
	{
		if (s_BrowserUpdateTimer.Elapsed() < s_BrowserUpdateInterval && !m_MarkUpdateContents)
		{
			return;
		}

		unsigned int dirs = 0;
		m_Entries.clear();

		for (auto& directoryEntry : std::filesystem::directory_iterator(m_CurrentDirectory))
		{
			const auto& path = directoryEntry.path();

			if (directoryEntry.is_directory())
			{
				m_Entries.emplace(m_Entries.begin() + dirs++, path);
			}
			else
			{
				m_Entries.emplace_back(path);
			}
		}

		m_MarkUpdateContents = false;
		s_BrowserUpdateTimer.Reset();
	}

	std::vector<std::filesystem::path> ContentBrowserPanel::Browse(const std::filesystem::path& path)
	{
		if (s_HierarchyUpdateTimer.Elapsed() < s_BrowserUpdateInterval && !m_MarkUpdateTree)
		{
			return m_BrowseCache[ImGui::GetID(path.filename().string().c_str())];
		}
		
		std::vector<std::filesystem::path> result;

		for (auto& directoryEntry : std::filesystem::directory_iterator(path))
		{
			const auto& p = directoryEntry.path();

			if (directoryEntry.is_directory())
				result.emplace_back(p);
		}

		m_BrowseCache[ImGui::GetID(path.filename().string().c_str())] = result;
		s_HierarchyUpdateTimer.Reset();

		m_MarkUpdateTree = false;
		return result;
	}

	void ContentBrowserPanel::NavigateTo(const std::filesystem::path& path)
	{
		if (m_CurrentDirectory == path)
			return;

		m_BackWardNavigation.emplace(m_CurrentDirectory);
		m_ForwardNavigation = std::stack<std::filesystem::path>();
		if (is_directory(path))
		{
			m_CurrentDirectory = path;
		}
		else
		{
			std::filesystem::path dir = path.parent_path();
			m_CurrentDirectory = dir;
		}
		m_SelectedPath = path;
		MarkUpdateContents();
	}

	void ContentBrowserPanel::NavigateBackward()
	{
		if (ImGui::IsAnyItemActive())
		{
			ImGui::ClearActiveID();
		}
		
		if (!m_BackWardNavigation.empty())
		{
			m_ForwardNavigation.emplace(m_CurrentDirectory);
			m_CurrentDirectory = m_BackWardNavigation.top();
			m_SelectedPath = m_CurrentDirectory;
			m_BackWardNavigation.pop();
			MarkUpdateContents();
		}
	}

	void ContentBrowserPanel::NavigateForward()
	{
		if (ImGui::IsAnyItemActive())
		{
			ImGui::ClearActiveID();
		}
		
		if (!m_ForwardNavigation.empty())
		{
			m_BackWardNavigation.emplace(m_CurrentDirectory);
			m_CurrentDirectory = m_ForwardNavigation.top();
			m_SelectedPath = m_CurrentDirectory;
			m_ForwardNavigation.pop();
			MarkUpdateContents();
		}
	}

	void ContentBrowserPanel::SetPayload()
	{
		std::string itemPath = m_SelectedPath.string();
		
		const std::string extension = m_SelectedPath.extension().string();

		if ( extension == Extensions::scene)
		{
			ImGui::SetDragDropPayload(Payloads::scene.c_str(), itemPath.c_str(), sizeof(char) * itemPath.size(), ImGuiCond_Once);
		}
		if ( extension == Extensions::texture)
		{
			ImGui::SetDragDropPayload(Payloads::texture.c_str(), itemPath.c_str(), sizeof(char) * itemPath.size());
		}
	}

	void ContentBrowserPanel::SetTooltip()
	{
		bool isDirectory = is_directory(m_SelectedPath);
		const std::string extension = m_SelectedPath.extension().string();
		
		ImGui::Text(""Dragging :"");
		ImGui::Image(
			(isDirectory
				 ? (ImTextureID)m_DirectoryIcon->GetRendererID()
				 : (ImTextureID)m_FileIcon->GetRendererID()), ImVec2{32, 32}, {0, 1}, {1, 0},
			isDirectory ? m_DirectoryTintColor : m_FileTintColor);
		ImGui::SameLine();
		ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 16 - ImGui::GetTextLineHeight() / 2);
		ImGui::Text(""%s"", m_SelectedPath.filename().string().c_str());
	}

	void ContentBrowserPanel::OnFileDoubleClick(std::filesystem::path path)
	{
		const std::string extension = path.extension().string();

		if (extension == Extensions::scene)
		{
			m_RequestedScenePath = path;
			m_IsSceneRequested = true;
		}
	}

}
",columnCount
378,"#include <torch/extension.h>

#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>

std::pair<torch::Tensor, torch::Tensor> select_by_index(
        const torch::Tensor &vertices,
        const torch::Tensor &triangles,
        const std::vector<int64_t> &vertex_indices) {
    std::unordered_map<int64_t, int64_t> new_vertex_map;
    std::vector<int64_t> new_vertex_indices;

    for (size_t i = 0; i < vertex_indices.size(); ++i) {
        int64_t old_index = vertex_indices[i];
        if (new_vertex_map.find(old_index) == new_vertex_map.end()) {
            int64_t new_index = new_vertex_indices.size();
            new_vertex_indices.push_back(old_index);
            new_vertex_map[old_index] = new_index;
        }
    }

    torch::Tensor new_vertices = vertices.index_select(
            0, torch::tensor(new_vertex_indices, torch::kInt64));

    std::vector<int64_t> new_triangle_indices;
    auto triangles_accessor = triangles.accessor<int64_t, 2>();
    for (int64_t i = 0; i < triangles.size(0); ++i) {
        int64_t v0 = triangles_accessor[i][0];
        int64_t v1 = triangles_accessor[i][1];
        int64_t v2 = triangles_accessor[i][2];

        if (new_vertex_map.find(v0) != new_vertex_map.end() &&
            new_vertex_map.find(v1) != new_vertex_map.end() &&
            new_vertex_map.find(v2) != new_vertex_map.end()) {
            new_triangle_indices.push_back(i);
        }
    }

    torch::Tensor new_triangles =
            torch::empty({static_cast<int64_t>(new_triangle_indices.size()), 3},
                         triangles.options());
    auto new_triangles_accessor = new_triangles.accessor<int64_t, 2>();
    for (size_t i = 0; i < new_triangle_indices.size(); ++i) {
        int64_t idx = new_triangle_indices[i];
        new_triangles_accessor[i][0] =
                new_vertex_map[triangles_accessor[idx][0]];
        new_triangles_accessor[i][1] =
                new_vertex_map[triangles_accessor[idx][1]];
        new_triangles_accessor[i][2] =
                new_vertex_map[triangles_accessor[idx][2]];
    }

    return std::make_pair(new_vertices, new_triangles);
}

std::vector<std::pair<torch::Tensor, torch::Tensor>> split_mesh_by_cc(
        const torch::Tensor &vertices, const torch::Tensor &triangles) {
    AT_ASSERT(vertices.dtype() == torch::kFloat32, ""Vertices must be float32"");
    AT_ASSERT(triangles.dtype() == torch::kInt64, ""Triangles must be int64"");

    AT_ASSERT(vertices.dim() == 2 && vertices.size(1) == 3,
              ""Vertices must have a shape of (N, 3)"");
    AT_ASSERT(triangles.dim() == 2 && triangles.size(1) == 3,
              ""Triangles must have a shape of (M, 3)"");

    // Ensure tensors are on CPU
    auto cpu_vertices = vertices.to(torch::kCPU);
    auto  [MASK]  = triangles.to(torch::kCPU);

    auto vertices_accessor = cpu_vertices.accessor<float, 2>();
    auto triangles_accessor =  [MASK] .accessor<int64_t, 2>();

    int64_t n_vertices = cpu_vertices.size(0);
    int64_t n_triangles =  [MASK] .size(0);

    // Build adjacency list
    std::vector<std::unordered_set<int64_t>> adjacency(n_vertices);
    for (int64_t i = 0; i < n_triangles; ++i) {
        adjacency[triangles_accessor[i][0]].insert(triangles_accessor[i][1]);
        adjacency[triangles_accessor[i][1]].insert(triangles_accessor[i][2]);
        adjacency[triangles_accessor[i][2]].insert(triangles_accessor[i][0]);
    }

    // Find connected components using BFS
    std::vector<bool> visited(n_vertices, false);
    std::vector<std::vector<int64_t>> components;
    for (int64_t i = 0; i < n_vertices; ++i) {
        if (!visited[i]) {
            std::vector<int64_t> component;
            std::queue<int64_t> queue;
            queue.push(i);
            visited[i] = true;

            while (!queue.empty()) {
                int64_t v = queue.front();
                queue.pop();
                component.push_back(v);

                for (auto adj_v : adjacency[v]) {
                    if (!visited[adj_v]) {
                        queue.push(adj_v);
                        visited[adj_v] = true;
                    }
                }
            }
            components.push_back(component);
        }
    }

    // Split meshes
    std::vector<std::pair<torch::Tensor, torch::Tensor>> split_meshes;
    for (const auto &comp : components) {
        auto split_mesh = select_by_index(cpu_vertices,  [MASK] , comp);
        split_meshes.push_back(split_mesh);
    }

    return split_meshes;
}
",cpu_triangles
379,"#include ""AdresatMenedzer.h""

Adresat AdresatMenedzer::podajDaneNowegoAdresata() {
    Adresat adresat;

    if (plikZAdresatami.pobierzIdOstatniegoAdresata() == 0 && plikZAdresatami.pobierzIdUsunietegoAdresata() == 0) {
        adresat.ustawId(1);
    } else if (plikZAdresatami.pobierzIdUsunietegoAdresata() == plikZAdresatami.pobierzIdOstatniegoAdresata()) {
        adresat.ustawId(plikZAdresatami.pobierzIdUsunietegoAdresata());
    } else {
        adresat.ustawId(plikZAdresatami.pobierzIdOstatniegoAdresata() + 1);
    }

    adresat.ustawIdUzytkownika(ID_ZALOGOWANEGO_UZYTKOWNIKA);

    cout << ""Podaj imie: "";
    adresat.ustawImie(MetodyPomocnicze::wczytajLinie());
    adresat.ustawImie(zamienPierwszaLitereNaDuzaAPozostaleNaMale(adresat.pobierzImie()));

    cout << ""Podaj nazwisko: "";
    adresat.ustawNazwisko(MetodyPomocnicze::wczytajLinie());
    adresat.ustawNazwisko(zamienPierwszaLitereNaDuzaAPozostaleNaMale(adresat.pobierzNazwisko()));

    cout << ""Podaj numer telefonu: "";
    adresat.ustawNumerTelefonu(MetodyPomocnicze::wczytajLinie());

    cout << ""Podaj email: "";
    adresat.ustawEmail(MetodyPomocnicze::wczytajLinie());

    cout << ""Podaj adres: "";
    adresat.ustawAdres(MetodyPomocnicze::wczytajLinie());

    return adresat;
}

void AdresatMenedzer::dodajAdresata() {
    Adresat adresat;

    system(""cls"");
    cout << "" >>> DODAWANIE NOWEGO ADRESATA <<<"" << endl << endl;
    adresat = podajDaneNowegoAdresata();

    adresaci.push_back(adresat);
    plikZAdresatami.dopiszAdresataDoPliku(adresat);
}

string AdresatMenedzer::zamienPierwszaLitereNaDuzaAPozostaleNaMale(string  [MASK] ) {
    if (! [MASK] .empty()) {
        transform( [MASK] .begin(),  [MASK] .end(),  [MASK] .begin(), ::tolower);
         [MASK] [0] = toupper( [MASK] [0]);
    }
    return  [MASK] ;
}

void AdresatMenedzer::wyswietlWszystkichAdresatow() {
    system(""cls"");
    if (!adresaci.empty()) {
        cout << ""             >>> ADRESACI <<<"" << endl;
        cout << ""-----------------------------------------------"" << endl;

        for (vector<Adresat> :: iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            wyswietlDaneAdresata(*itr);
        }
        cout << endl;
    } else {
        cout << endl << ""Ksiazka adresowa jest pusta."" << endl << endl;
    }
    system(""pause"");
}

void AdresatMenedzer::wyswietlDaneAdresata(Adresat adresat) {
    cout << endl << ""Id:                 "" << adresat.pobierzId() << endl;
    cout << ""Imie:               "" << adresat.pobierzImie() << endl;
    cout << ""Nazwisko:           "" << adresat.pobierzNazwisko() << endl;
    cout << ""Numer telefonu:     "" << adresat.pobierzNumerTelefonu() << endl;
    cout << ""Email:              "" << adresat.pobierzEmail() << endl;
    cout << ""Adres:              "" << adresat.pobierzAdres() << endl;
}

void AdresatMenedzer::wyszukajAdresatowPoImieniu() {
    string imiePoszukiwanegoAdresata = """";
    int iloscAdresatow = 0;

    system(""cls"");
    if (!adresaci.empty()) {
        cout << "">>> WYSZUKIWANIE ADRESATOW O IMIENIU <<<"" << endl << endl;

        cout << ""Wyszukaj adresatow o imieniu: "";
        imiePoszukiwanegoAdresata = MetodyPomocnicze::wczytajLinie();
        imiePoszukiwanegoAdresata = zamienPierwszaLitereNaDuzaAPozostaleNaMale(imiePoszukiwanegoAdresata);

        for (vector <Adresat>::iterator  itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzImie() == imiePoszukiwanegoAdresata) {
                wyswietlDaneAdresata(*itr);
                iloscAdresatow++;
            }
        }
        wyswietlIloscWyszukanychAdresatow(iloscAdresatow);
    } else {
        cout << endl << ""Ksiazka adresowa jest pusta"" << endl << endl;
    }
    cout << endl;
    system(""pause"");
}

void AdresatMenedzer::wyswietlIloscWyszukanychAdresatow(int iloscAdresatow) {
    if (iloscAdresatow == 0)
        cout << endl << ""W ksiazce adresowej nie ma adresatow z tymi danymi."" << endl;
    else
        cout << endl << ""Ilosc adresatow w ksiazce adresowej wynosi: "" << iloscAdresatow << endl << endl;
}

void AdresatMenedzer::wyszukajAdresatowPoNazwisku() {
    string nazwiskoPoszukiwanegoAdresata;
    int iloscAdresatow = 0;

    system(""cls"");
    if (!adresaci.empty()) {
        cout << "">>> WYSZUKIWANIE ADRESATOW O NAZWISKU <<<"" << endl << endl;

        cout << ""Wyszukaj adresatow o nazwisku: "";
        nazwiskoPoszukiwanegoAdresata = MetodyPomocnicze::wczytajLinie();
        nazwiskoPoszukiwanegoAdresata = zamienPierwszaLitereNaDuzaAPozostaleNaMale(nazwiskoPoszukiwanegoAdresata);

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzNazwisko() == nazwiskoPoszukiwanegoAdresata) {
                wyswietlDaneAdresata(*itr);
                iloscAdresatow++;
            }
        }
        wyswietlIloscWyszukanychAdresatow(iloscAdresatow);
    } else {
        cout << endl << ""Ksiazka adresowa jest pusta."" << endl << endl;
    }
    cout << endl;
    system(""pause"");
}

void AdresatMenedzer::usunAdresata() {
    int idUsuwanegoAdresata = 0, brakZgodnosci = 0, dlugoscWektora = adresaci.size();
    string idStr = """";
    char wybor;

    system(""cls"");
    cout << ""     >>> Usun adresata <<<"" << endl << endl;

    if (dlugoscWektora == 0) {
        cout << ""Ksiazka adresowa jest pusta!"" << endl << endl;
    } else {
        cout << ""Podaj numer identyfikacyjny osoby, ktora chcesz usunac: "";

        idStr = MetodyPomocnicze::wczytajLinie();
        idUsuwanegoAdresata = MetodyPomocnicze::konwersjaStringNaInt(idStr);

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzId() == idUsuwanegoAdresata) {
                wyswietlDaneAdresata(*itr);
                cout << endl;
                cout << ""Czy na pewno chcesz usunac dana osobe? [t/n] "";
                wybor = MetodyPomocnicze::wczytajZnak();

                if (wybor == 't') {
                    adresaci.erase(itr);

                    plikZAdresatami.usunAdresataZPliku(idUsuwanegoAdresata);
                    plikZAdresatami.ustawIdUsunietegoAdresata(idUsuwanegoAdresata);

                    cout << endl << ""Usuwanie danych zakonczone powodzeniem!"" << endl << endl;
                    system(""pause"");
                    break;
                } else if (wybor == 'n') {
                    cout << endl << ""Wstrzymano usuwanie danych!"" << endl << endl;
                    system(""pause"");
                    break;
                } else {
                    cout << endl << ""Musisz wpisac tak[t] lub nie[n]!"" << endl << endl;
                    system(""pause"");
                }
            }  else {
                brakZgodnosci++;
            }
        }
        if (brakZgodnosci == dlugoscWektora) {
            cout << endl << ""W ksiazce adresowej nie ma osoby o podanym numerze identyfikacyjnym!"" << endl << endl;
            system(""pause"");
        } else if (adresaci.size() == 0) {
            cout << ""Ksiazka adresowa jest teraz pusta!"" << endl << endl;
            system(""pause"");
        }
    }
}

void AdresatMenedzer::edytujDaneAdresata() {
    string idString = """";
    int idAdresataDoEdycji, brakZgodnosci = 0, dlugoscWektora = adresaci.size();
    char wybor;

    system(""cls"");
    cout << ""      >>> Edytuj dane adresata <<<"" << endl << endl;

    if (dlugoscWektora == 0) {
        cout << ""Ksiazka adresowa jest pusta!"" << endl << endl;
        system(""pause"");
    } else {
        cout << ""Podaj numer identyfikacyjny osoby, ktorej chcesz edytowac dane: "";
        idString = MetodyPomocnicze::wczytajLinie();
        idAdresataDoEdycji = MetodyPomocnicze::konwersjaStringNaInt(idString);

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzId() == idAdresataDoEdycji) {
                wyswietlDaneAdresata(*itr);
                cout << endl;
                cout << ""Czy chcesz edytowac dane podanej osoby? [t/n] "";
                wybor = MetodyPomocnicze::wczytajZnak();

                if (wybor == 't') {
                    wybierzDaneDoEdycji(idAdresataDoEdycji);
                    break;
                } else if (wybor == 'n') {
                    cout << endl << ""Wstrzymano edycje danych!"" << endl << endl;
                    system(""pause"");
                    break;
                } else {
                    cout << endl << ""Musisz wpisac tak[t] lub nie[n]!"" << endl << endl;
                    Sleep(1500);
                }
            }  else {
                brakZgodnosci++;
            }
        }
        if (brakZgodnosci == dlugoscWektora) {
            cout << endl << ""W ksiazce adresowej nie ma osoby o podanym numerze identyfikacyjnym!"" << endl << endl;
            system(""pause"");
        }
    }
}

void AdresatMenedzer::wybierzDaneDoEdycji(int idAdresataDoEdycji) {
    char wybor;
    string imie, nazwisko, numerTelefonu, email, adres;
    vector<string> daneDoEdycji;

    system (""cls"");
    cout << ""  >>> Edytuj dana adresata <<<"" << endl << endl;
    cout << ""Wybierz dane do edycji: "" << endl;
    cout << ""1. Imie"" << endl;
    cout << ""2. Nazwisko"" << endl;
    cout << ""3. Numer telefonu"" << endl;
    cout << ""4. Email"" << endl;
    cout << ""5. Adres"" << endl;
    cout << ""6. Powrot do menu"" << endl;
    cout << endl << ""Twoj wybor: "";
    wybor = MetodyPomocnicze::wczytajZnak();
    cout << endl;

    switch (wybor) {
    case '1':
        system(""cls"");
        cout << ""  > Imie <"" << endl << endl;

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzId() == idAdresataDoEdycji) {
                cout << ""Stare: "" << itr -> Adresat::pobierzImie() << endl;
                cout << ""Nowe: "";
                imie = MetodyPomocnicze::wczytajLinie();
                imie = zamienPierwszaLitereNaDuzaAPozostaleNaMale(imie);

                daneDoEdycji.push_back(itr -> Adresat::pobierzImie());
                daneDoEdycji.push_back(imie);

                itr -> Adresat::ustawImie(imie);
            }
        }
        plikZAdresatami.zmienDaneAdresataWPliku(daneDoEdycji, idAdresataDoEdycji);
        cout << endl << ""Edycja danych zakonczona powodzeniem!"" << endl << endl;
        system(""pause"");
        break;
    case '2':
        system(""cls"");
        cout << ""  > Nazwisko <"" << endl << endl;

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzId() == idAdresataDoEdycji) {
                cout << ""Stare: "" << itr -> Adresat::pobierzNazwisko() << endl;
                cout << ""Nowe: "";
                nazwisko = MetodyPomocnicze::wczytajLinie();
                nazwisko = zamienPierwszaLitereNaDuzaAPozostaleNaMale(nazwisko);

                daneDoEdycji.push_back(itr -> Adresat::pobierzNazwisko());
                daneDoEdycji.push_back(nazwisko);

                itr -> Adresat::ustawNazwisko(nazwisko);
            }
        }
        plikZAdresatami.zmienDaneAdresataWPliku(daneDoEdycji, idAdresataDoEdycji);

        cout << endl << ""Edycja danych zakonczona powodzeniem!"" << endl << endl;
        system(""pause"");
        break;
    case '3':
        system(""cls"");
        cout << ""  > Numer telefonu <"" << endl << endl;

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzId() == idAdresataDoEdycji) {
                cout << ""Stary: "" << itr -> Adresat::pobierzNumerTelefonu() << endl;
                cout << ""Nowy: "";
                numerTelefonu = MetodyPomocnicze::wczytajLinie();

                daneDoEdycji.push_back(itr -> Adresat::pobierzNumerTelefonu());
                daneDoEdycji.push_back(numerTelefonu);

                itr -> Adresat::ustawNumerTelefonu(numerTelefonu);
            }
        }
        plikZAdresatami.zmienDaneAdresataWPliku(daneDoEdycji, idAdresataDoEdycji);

        cout << endl << ""Edycja danych zakonczona powodzeniem!"" << endl << endl;
        system(""pause"");
        break;
    case '4':
        system(""cls"");
        cout << ""  > Email <"" << endl << endl;

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzId() == idAdresataDoEdycji) {
                cout << ""Stary: "" << itr -> Adresat::pobierzEmail() << endl;
                cout << ""Nowy: "";
                email = MetodyPomocnicze::wczytajLinie();

                daneDoEdycji.push_back(itr -> Adresat::pobierzEmail());
                daneDoEdycji.push_back(email);

                itr -> Adresat::ustawEmail(email);
            }
        }
        plikZAdresatami.zmienDaneAdresataWPliku(daneDoEdycji, idAdresataDoEdycji);

        cout << endl << ""Edycja danych zakonczona powodzeniem!"" << endl << endl;
        system(""pause"");
        break;
    case '5':
        system(""cls"");
        cout << ""  > Adres <"" << endl << endl;

        for (vector <Adresat>::iterator itr = adresaci.begin(); itr != adresaci.end(); itr++) {
            if (itr -> Adresat::pobierzId() == idAdresataDoEdycji) {
                cout << ""Stary: "" << itr -> Adresat::pobierzAdres() << endl;
                cout << ""Nowy: "";
                adres = MetodyPomocnicze::wczytajLinie();

                daneDoEdycji.push_back(itr -> Adresat::pobierzAdres());
                daneDoEdycji.push_back(adres);

                itr -> Adresat::ustawAdres(adres);
            }
        }
        plikZAdresatami.zmienDaneAdresataWPliku(daneDoEdycji, idAdresataDoEdycji);

        cout << endl << ""Edycja danych zakonczona powodzeniem!"" << endl << endl;
        system(""pause"");
        break;
    case '6':
        break;
    default:
        cout << ""Musisz wybrac cyfre od 1 do 6!"" << endl;
        Sleep(1500);
        break;
    }
}
",tekst
380,"#include <algorithm>
#include <iostream>
#include <vector>

std::vector<std::vector<unsigned int>> matrixMult2D(const std::vector<std::vector<unsigned int>>& A, const std::vector<std::vector<unsigned int>>& B) {
  // Check if the matrices have compatible dimensions
  if (A[0].size() != B.size()) {
    return {};
  }

  // Create the result matrix
  std::vector<std::vector<unsigned int>> C(A.size(), std::vector<unsigned int>(B[0].size()));

  // Multiply the matrices
  for (int i = 0; i < A.size(); i++) {
    for (int j = 0; j < B[0].size(); j++) {
      for (int k = 0; k < A[0].size(); k++) {
        C[i][j] += A[i][k] * B[k][j];
      }
    }
  }

  return C;
}

std::vector<std::vector<unsigned int>> createFibonacciBasisMatrix() {
    std::vector<std::vector<unsigned int>> fibonacciBasis = {
        {1, 1},
        {1, 0}
    };
    return fibonacciBasis;
}

int main() {
    std::vector<std::vector<unsigned int>>  [MASK]  = createFibonacciBasisMatrix();
    std::vector<std::vector<unsigned int>> fibn_iter = createFibonacciBasisMatrix();
    unsigned int sum = 0;
    while (fibn_iter[0][0] < 4000000) {
        fibn_iter = matrixMult2D( [MASK] , fibn_iter);
        sum += (fibn_iter[0][0]%2 == 0) ? fibn_iter[0][0] : 0;
    }
    std::cout << sum << std::endl;
    return 0;
}
",fibn_basis
381,"// ======================================================================
// \title  Main.cpp
// \brief main program for the F' application.
//
// ======================================================================
// Used to access topology functions
#include <BaremetalReference/Top/BaremetalReferenceTopologyAc.hpp>
#include <BaremetalReference/Top/BaremetalReferenceTopology.hpp>
// Used for Task Runner
#include <fprime-baremetal/Os/TaskRunner/TaskRunner.hpp>

// Used for logging
#include <Fw/Logger/Logger.hpp>
#include <Arduino/Os/Console.hpp>

/**
 * \brief setup the program
 */
void setup()
{
    // Setup Serial
    Serial.begin(115200); //Uart Comm and logging
    static_cast<Os::Arduino::StreamConsoleHandle*>(Os::Console::getSingleton().getHandle())->setStreamHandler(Serial);

    delay(1000);
    Fw::Logger::log(""Program Started\n"");

    // Object for communicating state to the reference topology
    BaremetalReference::TopologyState  [MASK] ;
     [MASK] .uartNumber = 0;
     [MASK] .uartBaud = 115200;

    // Setup, cycle, and teardown topology
    BaremetalReference::setupTopology( [MASK] );
}

void loop() {
#ifdef USE_BASIC_TIMER
    rateDriver.cycle();
#endif
    Os::Baremetal::TaskRunner::getSingleton().run();
}
",inputs
382,"#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>

std::vector<std::string> ip_adress(const std::string& ip_str) {
    std::vector<std::string> ip;
    size_t start = 0;
    size_t end = ip_str.find('.');

    while (end != std::string::npos) {
        ip.push_back(ip_str.substr(start, end - start));
        start = end + 1;
        end = ip_str.find('.', start);
    }
    ip.push_back(ip_str.substr(start));
    return ip;
}

int main() {

    auto  [MASK] =[](const std::vector<std::string> &a, const std::vector<std::string> &b)->bool{
        for(size_t i=0;i<a.size();i++)
        {
            if (std::stoi(a[i]) != std::stoi(b[i])) 
            {
                return std::stoi(a[i]) < std::stoi(b[i]);
            }
        }
        return false;
    };

    std::vector<std::vector<std::string>> ip_list;
    std::string line;

    std::ifstream in(""C:\\proga_sem3\\lab2\\ip_filter.tsv"");

    while (std::getline(in, line)) {
        size_t tabul = line.find('\t');
        std::string ip_str = line.substr(0, tabul);
        ip_list.push_back(ip_adress(ip_str));
    }

    std::sort(ip_list.begin(), ip_list.end(),  [MASK] );
    for(auto ip : ip_list)
    {
        std::cout << ip[0] << ""."" << ip[1] << ""."" << ip[2] << ""."" <<ip[3] << std::endl;
    }


    for(const auto& ip : ip_list) 
    {
        if(ip[0] == ""1"")
        {
            std::cout<<ip[0]<<"".""<<ip[1]<<"".""<<ip[2]<<"".""<<ip[3]<<std::endl;
        }
    }

        for(auto ip : ip_list)
    {
        if(ip[0]==""46""&&ip[1]==""70"")
        {
            std::cout<<ip[0]<<"".""<<ip[1]<<"".""<<ip[2]<<"".""<<ip[3]<<std::endl;
        }
    }

        for(auto ip : ip_list)
    {
        if(ip[0]==""46""||ip[1]==""46""||ip[2]==""46""||ip[3]==""46"")
        {
            std::cout<<ip[0]<<"".""<<ip[1]<<"".""<<ip[2]<<"".""<<ip[3]<<std::endl;
        }
    }
    return 0;
}
",comp
383,"#include ""pcbm.h""

/************************************************************************************************
*                                PCBMotor::PCBMotor                                               *
************************************************************************************************/
PCBMotor::PCBMotor(std::string devname)
{
    bserial = new Boost_serial(devname, 19200,
                               boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none),
                               boost::asio::serial_port_base::character_size(8),
                               boost::asio::serial_port_base::flow_control(boost::asio::serial_port_base::flow_control::none),
                               boost::asio::serial_port_base::stop_bits(boost::asio::serial_port_base::stop_bits::one));
    bserial->setTimeout(boost::posix_time::seconds(5));

    open(devname);
}

/************************************************************************************************
*                                PCBMotor::~PCBMotor                                               *
************************************************************************************************/
PCBMotor::~PCBMotor()
{
    close();
}

/************************************************************************************************
*                                PCBMotor::home                                         *
************************************************************************************************/
void PCBMotor::home(uint8_t mnum)
{ 
    std::string cmd = ""M"" + std::to_string(mnum) + "",s-2880\r"";
    write(cmd.data());
}
void PCBMotor::home(std::vector<uint8_t> mnum)
{ 
    std::string cmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M"" + std::to_string(mnum[i]) + "",s-2880"");
        if (!((i+1)==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::stop                                         *
************************************************************************************************/
void PCBMotor::stop(uint8_t mnum)
{ 
    std::string cmd = ""M"" + std::to_string(mnum) + "",\r"";
    write(cmd.data());
}
void PCBMotor::stop(std::vector<uint8_t> mnum)
{ 
    std::string cmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd = ""M"" + std::to_string(mnum[i]) + "",\r"";
        write(cmd.data());
    }
}

/************************************************************************************************
*                                PCBMotor::info                                         *
************************************************************************************************/
void PCBMotor::info()
{
    write(""i\r"");
}

/************************************************************************************************
*                                PCBMotor::help                                         *
************************************************************************************************/
void PCBMotor::help()
{
    write(""h\r"");
}

/************************************************************************************************
*                            PCBMotor::frequency_sweep                                  *
************************************************************************************************/
void PCBMotor::frequency_sweep(uint8_t mnum)
{
    std::string cmd = ""M"" + std::to_string(mnum) + "",p\r"";
    write(cmd.data());
}
void PCBMotor::frequency_sweep(std::vector<uint8_t> mnum)
{
    std::string cmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M"" + std::to_string(mnum[i]) + "",p"");
        if (!((i+1)==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}
/************************************************************************************************
*                             PCBMotor::micropulse                                       *
************************************************************************************************/
void PCBMotor::micropulse(uint8_t mnum, int32_t nummpulses, std::string edge)
{
    std::transform(edge.begin(), edge.end(), edge.begin(), [](unsigned char c){ return std::tolower(c); });

    std::string basecmd = """";
    if (edge.compare(""p"")) {
        basecmd = ""UP"";
    } else if (edge.compare(""n"")) {
        basecmd = ""UN"";
    } else {
        basecmd = ""U"";
    }
    std::string cmd = ""M""+std::to_string(mnum)+"",""+basecmd+std::to_string(nummpulses)+""\r"";
    write(cmd.data());
}
void PCBMotor::micropulse(std::vector<uint8_t> mnum, std::vector<int32_t> nummpulses, std::vector<std::string> edge)
{
    std::string cmd = """";
    std::string basecmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        std::transform(edge[i].begin(), edge[i].end(), edge[i].begin(), [](unsigned char c){ return std::tolower(c); });
        if (edge[i].compare(""p"")) {
            basecmd = ""UP"";
        } else if (edge[i].compare(""n"")) {
            basecmd = ""UN"";
        } else {
            basecmd = ""U"";
        }
        cmd.append(""M"" + std::to_string(mnum[i]) + "","" + basecmd + std::to_string(nummpulses[i]));
        if (!((i+1)==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                             PCBMotor::sweeppulse                                       *
************************************************************************************************/
void PCBMotor::sweeppulse(uint8_t mnum, int32_t nummpulses, std::string edge)
{
    std::transform(edge.begin(), edge.end(), edge.begin(), [](unsigned char c){ return std::tolower(c); });

    std::string basecmd = """";
    if (edge.compare(""p"")) {
        basecmd = ""UPS"";
    } else if (edge.compare(""n"")) {
        basecmd = ""UNS"";
    } else {
        basecmd = ""US"";
    }
    std::string cmd = ""M""+std::to_string(mnum)+"",""+basecmd+std::to_string(nummpulses)+""\r"";
    write(cmd.data());
}
void PCBMotor::sweeppulse(std::vector<uint8_t> mnum, std::vector<int32_t> nummpulses, std::vector<std::string> edge)
{
    std::string cmd = """";
    std::string basecmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        std::transform(edge[i].begin(), edge[i].end(), edge[i].begin(), [](unsigned char c){ return std::tolower(c); });
        if (edge[i].compare(""p"")) {
            basecmd = ""UPS"";
        } else if (edge[i].compare(""n"")) {
            basecmd = ""UNS"";
        } else {
            basecmd = ""US"";
        }
        cmd.append(""M"" + std::to_string(mnum[i]) + "","" + basecmd + std::to_string(nummpulses[i]));
        if (!((i+1)==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                             PCBMotor::sweepstep                                       *
************************************************************************************************/
void PCBMotor::sweepstep(uint8_t mnum, int32_t numsteps)
{
    std::string cmd = ""M"" + std::to_string(mnum)+"",SW"" + std::to_string(numsteps)+""\r"";
    write(cmd.data());
}
void PCBMotor::sweepstep(std::vector<uint8_t> mnum, std::vector<int32_t> numsteps)
{
    std::string cmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M"" + std::to_string(mnum[i]) + "",SW"" + std::to_string(numsteps[i]));
        if (!((i+1)==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                              PCBMotor::moveabsolute                                       *
************************************************************************************************/
void PCBMotor::moveabsolute(uint8_t mnum, double ang)
{
    if (std::abs(ang > 4096)) {
        throw std::invalid_argument(""angle needs to be < 4096deg"");
    }
    std::string cmd = ""M""+std::to_string(mnum)+"",s-2880,s""+std::to_string(ang*8)+""\r"";
    write(cmd.data());
}

void PCBMotor::moveabsolute(std::vector<uint8_t> mnum, std::vector<double> ang)
{
    if (std::any_of(ang.cbegin(), ang.cend(), [](double i){ return i > 4096; })) {
        throw std::invalid_argument(""angle needs to be < 4096deg"");
    }
    std::string cmd;
    
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",s-2880,s""+std::to_string(ang[i]*8));
        if (!((i+1)==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                              PCBMotor::goto_pos                                       *
************************************************************************************************/
void PCBMotor::goto_pos(uint8_t mnum, double ang, bool restrack)
{
    while (ang > 360) {
        ang -= 360;
    }
    std::string basecmd = restrack ? ""G"" : ""GN"";
    std::string cmd = ""M""+std::to_string(mnum)+"",""+ basecmd+std::to_string(ang*8)+""\r"";
    write(cmd.data());
}

void PCBMotor::goto_pos(std::vector<uint8_t> mnum, std::vector<double> ang, std::vector<bool> restrack)
{
    std::string cmd;
    std::string basecmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        while (ang[i] > 360) {
            ang[i] -= 360;
        }
        basecmd = restrack[i] ? ""G"" : ""GN"";
        cmd.append(""M""+std::to_string(mnum[i])+"",""+basecmd+std::to_string(ang[i]*8));
        if (!((i+1)==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::moverelative                                        *
************************************************************************************************/
void PCBMotor::moverelative(uint8_t mnum, double ang)
{
    if (std::abs(ang > 4096)) {
        throw std::invalid_argument(""angle needs to be < 4096deg"");
    }
    std::string cmd = ""M""+std::to_string(mnum)+"",s""+std::to_string(ang*8)+""\r"";
    write(cmd.data());
}
void PCBMotor::moverelative(std::vector<uint8_t> mnum, std::vector<double> ang)
{
    std::string cmd;
    
    if (std::any_of(ang.cbegin(), ang.cend(), [](double i){ return i > 4096; })) {
        throw std::invalid_argument(""angle needs to be < 4096deg"");
    }
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",s""+std::to_string(ang[i]*8));
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::set_voltage                                        *
************************************************************************************************/
void PCBMotor::set_voltage(uint8_t mnum, uint16_t mV)
{
    if (mV > 5000) {
        throw std::invalid_argument(""Voltage needs to be 0...5000mV"");
    } 
    std::string cmd = ""M""+std::to_string(mnum)+"",V""+std::to_string(mV)+""\r"";
    write(cmd.data());
}
void PCBMotor::set_voltage(std::vector<uint8_t> mnum, std::vector<uint16_t> mV)
{
    for (uint16_t v : mV) {
        if (v > 5000) {
            throw std::invalid_argument(""Voltage needs to be 0...5000mV"");
        } 
    }
    std::string cmd;
    
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",V""+std::to_string(mV[i]));
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::get_voltage                                        *
************************************************************************************************/
uint16_t PCBMotor::get_voltage(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",V\r"";
    write(cmd.data());
    std::string res = read();
    //TODO: process and return result
    uint16_t mV = 0;
    return mV;
}
std::vector<uint16_t> PCBMotor::get_voltage(std::vector<uint8_t> mnum)
{
    std::vector<uint16_t> mV_vec;
    std::string cmd;
    for (uint8_t m : mnum) {
        cmd = ""M""+std::to_string(m)+"",V\r"";
        write(cmd.data());
        std::string res = read();
        //TODO: process and return result
        uint16_t mV = 0;
        mV_vec.push_back(mV);
    }
    return mV_vec;
}

/************************************************************************************************
*                                PCBMotor::set_min_voltage                                        *
************************************************************************************************/
void PCBMotor::set_min_voltage(uint8_t mnum, uint16_t mV)
{
    if (mV > 5000) {
        throw std::invalid_argument(""Voltage needs to be 0...5000mV"");
    } 
    std::string cmd = ""M""+std::to_string(mnum)+"",Vmin""+std::to_string(mV)+""\r"";
    write(cmd.data());
}
void PCBMotor::set_min_voltage(std::vector<uint8_t> mnum, std::vector<uint16_t> mV)
{
    for (uint16_t v : mV) {
        if (v > 5000) {
            throw std::invalid_argument(""Voltage needs to be 0...5000mV"");
        } 
    }
    std::string cmd;
    
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",Vmin""+std::to_string(mV[i]));
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::get_min_voltage                                        *
************************************************************************************************/
uint16_t PCBMotor::get_min_voltage(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",Vmin\r"";
    write(cmd.data());
    std::string res = read();
    //TODO: process and return result
    uint16_t mV = 0;
    return mV;
}
std::vector<uint16_t> PCBMotor::get_min_voltage(std::vector<uint8_t> mnum)
{
    std::vector<uint16_t> mV_vec;
    std::string cmd;
    for (uint8_t m : mnum) {
        cmd = ""M""+std::to_string(m)+"",Vmin\r"";
        write(cmd.data());
        std::string res = read();
        //TODO: process and return result
        uint16_t mV = 0;
        mV_vec.push_back(mV);
    }
    return mV_vec;
}

/************************************************************************************************
*                                PCBMotor::set_max_voltage                                        *
************************************************************************************************/
void PCBMotor::set_max_voltage(uint8_t mnum, uint16_t mV)
{
    if (mV > 5000) {
        throw std::invalid_argument(""Voltage needs to be 0...5000mV"");
    } 
    std::string cmd = ""M""+std::to_string(mnum)+"",Vmax""+std::to_string(mV)+""\r"";
    write(cmd.data());
}
void PCBMotor::set_max_voltage(std::vector<uint8_t> mnum, std::vector<uint16_t> mV)
{
    for (uint16_t v : mV) {
        if (v > 5000) {
            throw std::invalid_argument(""Voltage needs to be 0...5000mV"");
        } 
    }
    std::string cmd;
    
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",Vmax""+std::to_string(mV[i]));
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::get_max_voltage                                        *
************************************************************************************************/
uint16_t PCBMotor::get_max_voltage(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",Vmax\r"";
    write(cmd.data());
    std::string res = read();
    //TODO: process and return result
    uint16_t mV = 0;
    return mV;
}
std::vector<uint16_t> PCBMotor::get_max_voltage(std::vector<uint8_t> mnum)
{
    std::vector<uint16_t> mV_vec;
    std::string cmd;
    for (uint8_t m : mnum) {
        cmd = ""M""+std::to_string(m)+"",Vmax\r"";
        write(cmd.data());
        std::string res = read();
        //TODO: process and return result
        uint16_t mV = 0;
        mV_vec.push_back(mV);
    }
    return mV_vec;
}

/************************************************************************************************
*                                PCBMotor::optimize_sensor_current                                        *
************************************************************************************************/
void PCBMotor::optimize_sensor_current(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",LS\r"";
    write(cmd.data());
}
void PCBMotor::optimize_sensor_current(std::vector<uint8_t> mnum)
{
    std::string cmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",LS"");
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::set_sensor_current                                        *
************************************************************************************************/
void PCBMotor::set_sensor_current(uint8_t mnum, uint8_t cur)
{
    if (cur > 200) {
        throw std::invalid_argument(""Sensor current needs to be 0...200"");
    } 
    std::string cmd = ""M""+std::to_string(mnum)+"",L""+std::to_string(cur)+""\r"";
    write(cmd.data());
}
void PCBMotor::set_sensor_current(std::vector<uint8_t> mnum, std::vector<uint8_t> cur)
{
    for (uint16_t c : cur) {
        if (c > 200) {
            throw std::invalid_argument(""Sensor current needs to be 0...200"");
        } 
    }
    std::string cmd = """";
    
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",L""+std::to_string(cur[i]));
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::get_sensor_current                                        *
************************************************************************************************/
uint8_t PCBMotor::get_sensor_current(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",L\r"";
    write(cmd.data());
    std::string res = read();
    //TODO: process and return result
    uint8_t mV = 0;
    return mV;
}
std::vector<uint8_t> PCBMotor::get_sensor_current(std::vector<uint8_t> mnum)
{
    std::vector<uint8_t>  [MASK] ;
    std::string cmd;
    for (uint8_t m : mnum) {
        cmd = ""M""+std::to_string(m)+"",L\r"";
        write(cmd.data());
        std::string res = read();
        //TODO: process and return result
        uint8_t c = 0;
         [MASK] .push_back(c);
    }
    return  [MASK] ;
}

/************************************************************************************************
*                                PCBMotor::resonance_sweep                                        *
************************************************************************************************/
void PCBMotor::resonance_sweep(uint8_t mnum, std::string mode)
{
    std::string basecmd = ""P"";
    if (mode.compare(""reverse"")) {
        basecmd = ""PR"";
    } else if (mode.compare(""alternating"")) {
        basecmd = ""PA"";
    } 
    
    std::string cmd = ""M""+std::to_string(mnum)+"",""+basecmd+""\r"";
    write(cmd.data());
}
void PCBMotor::resonance_sweep(std::vector<uint8_t> mnum, std::vector<std::string> mode)
{
    std::string cmd = """";
    std::string basecmd = ""P"";
    for (size_t i=0; i<mnum.size(); ++i) {
        if (mode[i].compare(""reverse"")) {
            basecmd = ""PR"";
        } else if (mode[i].compare(""alternating"")) {
            basecmd = ""PA"";
        } 
        cmd.append(""M""+std::to_string(mnum[i])+"",""+basecmd);
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::set_voltage_scaling                                        *
************************************************************************************************/
void PCBMotor::set_voltage_scaling(uint8_t mnum, std::string dir, uint8_t scale)
{
    std::string basecmd = """";
    if (dir.compare(""fwd"")) {
        basecmd = ""CW"";
    } else if (dir.compare(""bwd"")) {
        basecmd = ""CCW"";
    } else {
        throw std::invalid_argument(""direction needs to be fwd or bwd."");
    }
    
    std::string cmd = ""M""+std::to_string(mnum)+"",""+basecmd+std::to_string(scale)+""\r"";
    write(cmd.data());
}
void PCBMotor::set_voltage_scaling(std::vector<uint8_t> mnum, std::vector<std::string> dir, std::vector<uint8_t> scale)
{
    std::string cmd = """";
    std::string basecmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        if (dir[i].compare(""fwd"")) {
            basecmd = ""CW"";
        } else if (dir[i].compare(""bwd"")) {
            basecmd = ""CCW"";
        } else {
            throw std::invalid_argument(""direction needs to be fwd or bwd."");
        }
        cmd.append(""M""+std::to_string(mnum[i])+"",""+basecmd+std::to_string(scale[i]));
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::get_voltage_scaling                                        *
************************************************************************************************/
uint8_t PCBMotor::get_voltage_scaling(uint8_t mnum, std::string dir)
{
        std::string basecmd = """";
    if (dir.compare(""fwd"")) {
        basecmd = ""CW"";
    } else if (dir.compare(""bwd"")) {
        basecmd = ""CCW"";
    } else {
        throw std::invalid_argument(""direction needs to be fwd or bwd."");
    }
    
    std::string cmd = ""M""+std::to_string(mnum)+"",""+basecmd+""\r"";
    write(cmd.data());
    std::string res = read();
    //TODO: process response
    uint8_t scale = 0;
    
    return scale;
}
std::vector<uint8_t> PCBMotor::get_voltage_scaling(std::vector<uint8_t> mnum, std::vector<std::string> dir)
{
    std::string cmd = """";
    std::string basecmd = """";
    std::string res = """";
    uint8_t scale = 0;
    std::vector<uint8_t> scale_vec = std::vector<uint8_t>();
    for (size_t i=0; i<mnum.size(); ++i) {
        if (dir[i].compare(""fwd"")) {
            basecmd = ""CW"";
        } else if (dir[i].compare(""bwd"")) {
            basecmd = ""CCW"";
        } else {
            throw std::invalid_argument(""direction needs to be fwd or bwd."");
        }
        cmd = ""M""+std::to_string(mnum[i])+"",""+basecmd + ""\r"";
        write(cmd.data());
        res = read();
        //TODO: process result
        scale = 0;
        scale_vec.push_back(scale);
    }
    return scale_vec;
}

/************************************************************************************************
*                                PCBMotor::backup_memort                                        *
************************************************************************************************/
void PCBMotor::backup_memory(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",RB\r"";
    write(cmd.data());
}
void PCBMotor::backup_memory(std::vector<uint8_t> mnum)
{
    std::string cmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",RB"");
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::restore_memort                                        *
************************************************************************************************/
void PCBMotor::restore_memory(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",RS\r"";
    write(cmd.data());
}
void PCBMotor::restore_memory(std::vector<uint8_t> mnum)
{
    std::string cmd = """";
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",RS"");
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::set_voltage                                        *
************************************************************************************************/
void PCBMotor::set_vco_freq(uint8_t mnum, uint32_t Hz)
{
    if (Hz > 125000) {
        throw std::invalid_argument(""Frequency needs to be 0...125000Hz"");
    } 
    std::string cmd = ""M""+std::to_string(mnum)+"",F""+std::to_string(Hz)+""\r"";
    write(cmd.data());
}
void PCBMotor::set_vco_freq(std::vector<uint8_t> mnum, std::vector<uint32_t> Hz)
{
    for (uint32_t h : Hz) {
        if (h > 125000) {
            throw std::invalid_argument(""Frequency needs to be 0...125000Hz"");
        } 
    }
    std::string cmd;
    
    for (size_t i=0; i<mnum.size(); ++i) {
        cmd.append(""M""+std::to_string(mnum[i])+"",F""+std::to_string(Hz[i]));
        if (!(i+1==mnum.size())) {
            cmd.append("","");
        }
    }
    cmd.append(""\r"");
    write(cmd.data());
}

/************************************************************************************************
*                                PCBMotor::get_voltage                                        *
************************************************************************************************/
uint32_t PCBMotor::get_vco_freq(uint8_t mnum)
{
    std::string cmd = ""M""+std::to_string(mnum)+"",F\r"";
    write(cmd.data());
    std::string res = read();
    //TODO: process and return result
    uint32_t Hz = 0;
    return Hz;
}
std::vector<uint32_t> PCBMotor::get_vco_freq(std::vector<uint8_t> mnum)
{
    std::vector<uint32_t> Hz_vec;
    std::string cmd;
    for (uint8_t m : mnum) {
        cmd = ""M""+std::to_string(m)+"",F\r"";
        write(cmd.data());
        std::string res = read();
        //TODO: process and return result
        uint32_t Hz = 0;
        Hz_vec.push_back(Hz);
    }
    return Hz_vec;
}
",c_vec
384,"#include <iostream>
#include <vector>
#include <array>
#include <chrono>
#include <random>
#include <algorithm>
#include ""stopwatch.h""


std::uniform_int_distribution<unsigned> ud;
std::default_random_engine re{
    static_cast<unsigned>(std::chrono::steady_clock::now().time_since_epoch().count())
    };

template<typename Container>
void time_container(Container&& cont) noexcept
{
    
}

int main()
{
    constexpr auto count = 50000u;
    constexpr auto  [MASK]  = 100u;
    auto vec = std::vector<unsigned>(count);
    // auto vec = std::array<unsigned, count>{};
    auto sw = Stopwatch{""std::sort"", false};
    auto total = 0u;
    for (unsigned i = 0; i <  [MASK] ; ++i) {
        std::generate(vec.begin(), vec.end(), []{return ud(re);});
        sw.start();
        std::sort(vec.begin(), vec.end());
        total += sw.stop();
    }
    std::cout << ""Performance of std::sort on a vector of "" << count << "" elements,\n""
        << ""measured over "" <<  [MASK]  << "" iterations:\n"";
    std::cout << ""Total time = "" << total << ""ms\n""
        << ""Average = "" << static_cast<double>(total) /  [MASK]  << ""ms\n"";
}
",iters
385,"#include ""MyDatatables.h""

/************************************************
 * @brief My Datatables Constructor.
 * MyDatatables
 ***********************************************/
MyDatatables::MyDatatables(MyLanguageModel *thisLanguageModel, MyConstants *thisConstant, QObject *parent) : QObject(parent), myLanguageModel(thisLanguageModel), myConstants(thisConstant)
{
    mySqlModel = new MySqlDbtModel(thisLanguageModel, thisConstant, this);
    // Create Variable Trackers and Set to Empty
    myProject = new MyProjectClass("""", """", """", """", """", """", """", """", """");
}
/************************************************
 * @brief My Datatables Deconstructor.
 * MyDatatables
 ***********************************************/
MyDatatables::~MyDatatables()
{

}
/************************************************
 * @brief set Debug Message.
 * setDebugMessage
 ***********************************************/
void MyDatatables::setDebugMessage(bool  [MASK] )
{
    isDebugMessage =  [MASK] ;
    setMessage(""setDebugMessage"");
}
/************************************************
 * @brief get Debug Message.
 * getDebugMessage
 ***********************************************/
bool MyDatatables::getDebugMessage()
{
    setMessage(""getDebugMessage"");
    return isDebugMessage;
}
/************************************************
 * @brief set Project Folder.
 * setProjectFolder
 ***********************************************/
void MyDatatables::setProjectFolder(const QString &thisProjectFolder)
{
    setMessage(""setProjectFolder"");
    myProjectFolder = thisProjectFolder;
}
/************************************************
 * @brief get Project Folder.
 * getProjectFolder
 ***********************************************/
QString MyDatatables::getProjectFolder()
{
    setMessage(""getProjectFolder"");
    return myProjectFolder;
}
/************************************************
 * @brief set Project Name.
 * setProjectName
 ***********************************************/
void MyDatatables::setProjectName(const QString &thisProjectName)
{
    setMessage(""setProjectName"");
    myProjectName = thisProjectName;
}
/************************************************
 * @brief get Project Name.
 * getProjectName
 ***********************************************/
QString MyDatatables::getProjectName()
{
    setMessage(""getProjectName"");
    return myProjectName;
}
/************************************************
 * @brief set Project ID.
 * setProjectID
 ***********************************************/
void MyDatatables::setProjectID(const QString &thisProjectID)
{
    setMessage(""setProjectID"");
    myProjectID = thisProjectID;
}
/************************************************
 * @brief get Project ID.
 * getProjectID
 ***********************************************/
QString MyDatatables::getProjectID()
{
    setMessage(""getProjectID"");
    return myProjectID;
}
/************************************************
 * @brief set ComboBox Sql Value.
 * setComboBoxSqlValue
 ***********************************************/
void MyDatatables::setComboBoxSqlValue(const QString &thisComboBoxSqlValue)
{
    setMessage(""setComboBoxSqlValue"");
    myComboBoxSqlValue = thisComboBoxSqlValue;
}
/************************************************
 * @brief get ComboBox Sql Value.
 * getComboBoxSqlValue
 ***********************************************/
QString MyDatatables::getComboBoxSqlValue()
{
    setMessage(""getComboBoxSqlValue"");
    return myComboBoxSqlValue;
}
/************************************************
 * @brief check Database.
 * checkDatabase
 ***********************************************/
bool MyDatatables::checkDatabase()
{
    setMessage(""checkDatabase"");
    #ifdef USE_SQL_FLAG
    // Database
    mySqlModel->setSqlDriver(myComboBoxSqlValue);
    if (!mySqlModel->createDataBaseConnection()) { return false; }
    //
    // Configuration
    //
    if (!mySqlModel->isDbTable(""Projects""))
    {
        /*
         * Table Projects holds the name of the Qt Project
         * id integer PRIMARY KEY autoincrement,
         * id, QtProjectName, QtProjectFolder, SourceFolder, DoxyfileFolder, HelpFolder, SourceLanguage, LanguageIDs, Make
        */
        if (mySqlModel->runQuery(QLatin1String(R""(CREATE TABLE Projects(id integer PRIMARY KEY autoincrement, QtProjectName, QtProjectFolder, SourceFolder, DoxyfileFolder, HelpFolder, SourceLanguage, LanguageIDs, Make))"")))
        {
            QString theQtProjectName    = myConstants->MY_QT_PROJECT_NAME;
            QString theQtProjectFolder  = myConstants->MY_QT_PROJECT_FOLDER;
            QString theSource           = myConstants->MY_SOURCE_FOLDER;
            QString theDoxyfile         = myConstants->MY_DOXYFILE_FOLDER;
            QString theHelpFolder       = myConstants->MY_HELP_FOLDER;
            QString theSourceLanguage   = myConstants->MY_SOURCE_LANGUAGE;
            QString theMake             = myConstants->MY_MAKE;
            QString theLanguageIDs      = myConstants->MY_LANGUAGE_IDs;
            setProject(theQtProjectName, theQtProjectFolder, theSource, theDoxyfile, theHelpFolder, theSourceLanguage, theLanguageIDs, theMake);
            if (insertQtProjects())
            {
                myProjectID = mySqlModel->getRecordID();
                myLanguageModel->mySetting->writeSettings(myConstants->MY_SQL_PROJECT_ID, myProjectID);
            }
            else
            {
                qCritical() << mySqlModel->getSqlDriver() <<  ""  INSERT TABLE Projects error:"";
            }
        }
        //
    } // end if (!isDbTable(""Projects""))
    //
    #endif
    return true;
}
/************************************************
 * @brief insert Qt Projects into SQL Database.
 * insertQtProjects
 ***********************************************/
bool MyDatatables::insertQtProjects()
{
    setMessage(""insertProjects"");
    // QtProjectName, QtProjectFolder, SourceFolder, DoxyfileFolder, HelpFolder, LanguageIDs, Make
    QString theQuery = QLatin1String(R""(INSERT INTO Projects (QtProjectName, QtProjectFolder, SourceFolder, DoxyfileFolder, HelpFolder, SourceLanguage, LanguageIDs, Make) values('%1', '%2', '%3', '%4', '%5', '%6', '%7', '%8'))"").arg(myProject->getQtProjectName(), myProject->getQtProjectFolder(), myProject->getSourceFolder(), myProject->getDoxyfileFolder(), myProject->getHelpFolder(), myProject->getSourceLanguage(), myProject->getLanguageIDs(), myProject->getMake());
    setMessage(""insertProjects: "" + theQuery);
    //
    if (!mySqlModel->runQuery(theQuery))
    {
        qCritical() << ""INSERT Projects error: "" << theQuery;
        return false;
    }
    setProjectID(mySqlModel->getRecordID());
    return true;
}
/************************************************
 * @brief addQtProject Assumes you have ran setProject: QtProjectName, QtProjectFolder, SourceFolder, DoxyfileFolder, HelpFolder, LanguageIDs.
 * addQtProject
 ***********************************************/
bool MyDatatables::addQtProject()
{
    setMessage(""addQtProject"");
    #ifdef USE_SQL_FLAG
    // SELECT id, QtProjectName FROM Projects WHERE QtProject =
    if (isQtProjectNameQuery(myProject->getQtProjectName()))
    {
        myLanguageModel->mySetting->showMessageBox(QObject::tr(""Record found!"").toLocal8Bit(), QString(""%1: %2"").arg(tr(""Not adding: Record found in database""), myProject->getQtProjectName()).toLocal8Bit(), myLanguageModel->mySetting->Warning);
        return false;
    }
    return insertQtProjects();
    #else
    return true;
    #endif
}
/************************************************
 * @brief delete Project.
 * deleteProject
 ***********************************************/
void MyDatatables::deleteQtProject(const QString &thisID)
{
    setMessage(""deleteQtProject"");
    #ifdef USE_SQL_FLAG
    QSqlQuery query; //!< SQL Query
    QString theQuery = QString(""DELETE FROM Projects WHERE id = "").append(thisID);
    setMessage(""thisQuery: "" + theQuery);
    if (!query.exec(theQuery))
    {
        qCritical() << ""SqLite error:"" << query.lastError().text() << "", SqLite error code:"" << query.lastError();
    }
    #endif
}
/************************************************
 * @brief get Qt Project Name Select Query SELECT id, QtProjectName FROM Projects.
 * getQtProjectNameSelectQuery
 ***********************************************/
QString MyDatatables::getQtProjectNameSelectQuery()
{
    setMessage(""getQtProjectNameSelectQuery"");
    return QString(""SELECT id, QtProjectName FROM Projects"");
}
/************************************************
 * @brief get Qt Project Name By Name Query SELECT id, QtProjectName FROM Projects WHERE QtProjectFolder =.
 * getQtProjectNameByNameQuery
 ***********************************************/
QString MyDatatables::getQtProjectNameByNameQuery(const QString &thisProject)
{
    setMessage(""getQtProjectNameByNameQuery"");
    return QString(""SELECT id, QtProjectName FROM Projects WHERE QtProjectName = '%1'"").arg(thisProject);
}
/************************************************
 * @brief is Project Folder Query myAccessSqlDbtModel->isProjectQuery(ui->lineEditSettingsProjectBin->text());.
 * isProjectFolderQuery
 ***********************************************/
bool MyDatatables::isQtProjectNameQuery(const QString &thisProjectName)
{
    setMessage(""isQtProjectNameQuery"");
    #ifdef USE_SQL_FLAG
    QSqlQuery theQuery; //!< SQL Query
    QString theQueryCommand = getQtProjectNameByNameQuery(thisProjectName);
    if (theQuery.exec(theQueryCommand))
    {
        if (theQuery.first()) { return true;  }
        else                  { return false; }
    }
    else
    {
        qCritical() << ""SqLite error isProjectQuery:"" << theQuery.lastError().text() << "", SqLite error code:"" << theQuery.lastError();
    }
    #endif
    return false;
}
/************************************************
 * @brief get Qt Project Full Select Query ID SELECT * FROM Projects WHERE id =.
 * getQtProjectFullSelectQueryID
 ***********************************************/
QString MyDatatables::getQtProjectFullSelectQueryID(const QString &thisWhereID)
{
    setMessage(""getProjectFolderFullSelectQueryID"");
    return QString(""SELECT * FROM Projects WHERE id = "").append(thisWhereID);
}
/************************************************
 * @brief get Qt Project Name Select Query ID  SELECT id, QtProjectName FROM Projects WHERE id.
 * getQtProjectNameSelectQueryID
 ***********************************************/
QString MyDatatables::getQtProjectNameSelectQueryID(const QString &thisWhereID)
{
    setMessage(""getQtProjectNameSelectQueryID"");
    return QString(""SELECT id, QtProjectName FROM Projects WHERE id = "").append(thisWhereID);
}
/************************************************
 * @brief save Project Projects: id, QtProjectName QtProjectFolder, SourceFolder, DoxyfileFolder, HelpFolder, SourceLanguage, LanguageIDs, Make
 * saveProject
 ***********************************************/
void MyDatatables::saveQtProject()
{
    setMessage(""saveProject"");
    #ifdef USE_SQL_FLAG
    QSqlQuery theQuery; //!< SQL Query
    QString theQueryString = QString(""UPDATE Projects set QtProjectName = '%1', QtProjectFolder = '%2', SourceFolder = '%3', DoxyfileFolder = '%4', HelpFolder = '%5', SourceLanguage = '%6', LanguageIDs = '%7', Make = '%8' WHERE id = %9"").arg(myProject->getQtProjectName(), myProject->getQtProjectFolder(), myProject->getSourceFolder(), myProject->getDoxyfileFolder(), myProject->getHelpFolder(), myProject->getSourceLanguage(), myProject->getLanguageIDs(), myProject->getMake(), myProject->getID());
    setMessage(""thisQuery: |"" + theQueryString + ""|  getQtProjectName = "" + myProject->getQtProjectName() + ""|  getQtProjectFolder = "" + myProject->getQtProjectFolder() + ""| getSourceFolder="" + myProject->getSourceFolder() + ""| getDoxyfileFolder="" + myProject->getDoxyfileFolder() + ""| getHelpFolder="" + myProject->getHelpFolder() + ""| getSourceLanguage="" + myProject->getSourceLanguage() + ""| getLanguageIDs="" + myProject->getLanguageIDs() + ""| getMake="" + myProject->getMake() + ""| ID="" + myProject->getID() + ""|"");
    if (!theQuery.exec(theQueryString))
    {
        qCritical() << ""SqLite error saveProject:"" << theQuery.lastError().text() << "", SqLite error code:"" << theQuery.lastError();
    }
    isSaveSettings = false;
    #endif
}
/************************************************
 * @brief set Project Sets all Variables used in the Configuarion Database in one Place:
 *        QtProjectFolder, SourceFolder, DoxyfileFolder, HelpFolder, SourceLanguage, LanguageIDs, Make.
 * setProject
 ***********************************************/
void MyDatatables::setProject(const QString &thisQtProjectName, const QString &thisQtProjectFolder, const QString &thisSourceFolder, const QString &thisDoxyfileFolder,  const QString &thisHelpFolder, const QString &thisSourceLanguage, const QString &thisLanguageIDs, const QString &thisMake)
{
    setMessage(""setProject"");
    myProject->setQtProjectName(thisQtProjectName);
    myProject->setQtProjectFolder(thisQtProjectFolder);
    myProject->setSourceFolder(thisSourceFolder);
    myProject->setDoxyfileFolder(thisDoxyfileFolder);
    myProject->setHelpFolder(thisHelpFolder);
    myProject->setSourceLanguage(thisSourceLanguage);
    myProject->setLanguageIDs(thisLanguageIDs);
    myProject->setMake(thisMake);
}
/************************************************
 * @brief set Message.
 * setMessage
 ***********************************************/
void MyDatatables::setMessage(const QString &thisMessage)
{
    if (isDebugMessage)
    {
        qDebug() << thisMessage;
        //std::cout << thisMessage.toStdString() << std::endl;
    }
}
/*** ************************* End of File ***********************************/
",thisState
386,"#include <ros/ros.h>
#include <tf/transform_broadcaster.h>
#include <nav_msgs/Odometry.h>

int main(int argc, char** argv){
  ros::init(argc, argv, ""odometry_publisher"");

  ros::NodeHandle n;
  ros::Publisher odom_pub = n.advertise<nav_msgs::Odometry>(""odom"", 50);
  tf::TransformBroadcaster odom_broadcaster;							// send message out using ROS and tf respectively

  double x = 0.0;
  double y = 0.0;
  double th = 0.0;														// robot start at the origin of the ""odom"" coordinate frame initially

  double vx = 0.1;														// fake robot move in the odome frame at a rate of 0.1m/s in x, -0.1m/s in y, 
  double vy = -0.1;														// 0.1rad/s in the h direction, which will cause the robot drive in a circle. 
  double  [MASK]  = 0.1;
  
  ros::Time current_time, last_time;
  current_time = ros::Time::now();
  last_time = ros::Time::now();

  ros::Rate r(5);														// publish the odometry information at a rate of 5Hz
  while(n.ok()){

    ros::spinOnce();               // check for incoming messages
    current_time = ros::Time::now();

    // compute odometry in a typical way given the velocities of the robot
    double dt = (current_time - last_time).toSec();
    double delta_x = (vx * cos(th) - vy * sin(th)) * dt;
    double delta_y = (vx * sin(th) + vy * cos(th)) * dt;
    double delta_th =  [MASK]  * dt;
	// A real odometry system would, of course, integrate computed velocities instead.
	
    x += delta_x;
    y += delta_y;
    th += delta_th;

    // since all odometry is 6DOF we'll need a quaternion created from yaw
    geometry_msgs::Quaternion odom_quat = tf::createQuaternionMsgFromYaw(th);

    //first, we'll publish the transform over tf
    geometry_msgs::TransformStamped odom_trans;
    odom_trans.header.stamp = current_time;
    odom_trans.header.frame_id = ""odom"";
    odom_trans.child_frame_id = ""base_link"";

    odom_trans.transform.translation.x = x;
    odom_trans.transform.translation.y = y;
    odom_trans.transform.translation.z = 0.0;
    odom_trans.transform.rotation = odom_quat;

    //send the transform
    odom_broadcaster.sendTransform(odom_trans);

    //next, we'll publish the odometry message over ROS
    nav_msgs::Odometry odom;
    odom.header.stamp = current_time;
    odom.header.frame_id = ""odom"";

    //set the position
    odom.pose.pose.position.x = x;
    odom.pose.pose.position.y = y;
    odom.pose.pose.position.z = 0.0;
    odom.pose.pose.orientation = odom_quat;

    //set the velocity
    odom.child_frame_id = ""base_link"";
    odom.twist.twist.linear.x = vx;
    odom.twist.twist.linear.y = vy;
    odom.twist.twist.angular.z =  [MASK] ;

    //publish the message
    odom_pub.publish(odom);

    last_time = current_time;
    r.sleep();
  }
}
",vth
387,"#include ""recast-sys/include/detour.h""

#include ""recast-sys/src/lib.rs.h""

std::unique_ptr<dtNavMesh> newDtNavMesh() {
    return std::make_unique<dtNavMesh>();
}

std::unique_ptr<dtNavMeshQuery> newDtNavMeshQuery() {
    return std::make_unique<dtNavMeshQuery>();
}

std::unique_ptr<dtQueryFilter> newDtQueryFilter() {
    return std::make_unique<dtQueryFilter>();
}

std::unique_ptr<dtPathCorridor> newDtPathCorridor() {
    return std::make_unique<dtPathCorridor>();
}

bool createNavMeshData(NavMeshCreateParams* params, std::uint8_t **outData, std::int32_t *outDataSize) {
    auto  [MASK]  = dtNavMeshCreateParams();
     [MASK] .verts = params->vertices;
     [MASK] .vertCount = params->num_vertices;
     [MASK] .polys = params->polygons;
     [MASK] .polyFlags = params->polygon_flags;
     [MASK] .polyAreas = params->polygon_areas;
     [MASK] .polyCount = params->num_polys;
     [MASK] .nvp = params->max_vertices_per_poly;
     [MASK] .detailMeshes = params->detail_meshes;
     [MASK] .detailVerts = params->detail_vertices;
     [MASK] .detailVertsCount = params->num_detail_vertices;
     [MASK] .detailTris = params->detail_triangles;
     [MASK] .detailTriCount = params->num_detail_triangles;
     [MASK] .offMeshConVerts = params->off_mesh_conn_vertices;
     [MASK] .offMeshConRad = params->off_mesh_conn_radii;
     [MASK] .offMeshConFlags = params->off_mesh_conn_flags;
     [MASK] .offMeshConAreas = params->off_mesh_conn_areas;
     [MASK] .offMeshConDir = params->off_mesh_conn_dir;
     [MASK] .offMeshConUserID = params->off_mesh_conn_ids;
     [MASK] .offMeshConCount = params->off_mesh_conn_count;
     [MASK] .userId = params->user_id;
     [MASK] .tileX = params->tile_x;
     [MASK] .tileY = params->tile_y;
     [MASK] .tileLayer = params->tile_layer;
    std::copy(params->b_min.begin(), params->b_min.end(),  [MASK] .bmin);
    std::copy(params->b_max.begin(), params->b_max.end(),  [MASK] .bmax);
     [MASK] .walkableHeight = params->walkable_height;
     [MASK] .walkableRadius = params->walkable_radius;
     [MASK] .walkableClimb = params->walkable_climb;
     [MASK] .cs = params->cs;
     [MASK] .ch = params->ch;
     [MASK] .buildBvTree = params->build_bv_tree;

    return dtCreateNavMeshData(& [MASK] , outData, outDataSize);
}
",dtParams
388,"/**
Copyright 2024 Sil3ntStorm https://github.com/sil3ntstorm

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 ""formatters.hpp""

#include <chrono>
#include <optional>

std::string human_time_diff(std::chrono::nanoseconds duration, std::streamsize precision)
{
#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907L
    std::stringstream os;
    using namespace std::chrono;
    auto y = duration_cast<years>(duration);
    duration -= y;
    auto mn = duration_cast<months>(duration);
    duration -= mn;
    auto d = duration_cast<days>(duration);
    duration -= d;
    auto h = duration_cast<hours>(duration);
    duration -= h;
    auto m = duration_cast<minutes>(duration);
    duration -= m;
    auto s = duration_cast<seconds>(duration);
    duration -= s;

    std::optional<decltype(duration)::rep>  [MASK] ;
    if (precision > os.precision()) {
        precision = os.precision();
    }
    if (precision > 6) {
        precision = 9;
    } else if (precision > 3) {
        precision = 6;
    } else if (precision > 0) {
        precision = 3;
    }
    switch (precision) {
        case 9:
             [MASK]  = duration.count();
            break;
        case 6:
             [MASK]  = duration_cast<microseconds>(duration).count();
            break;
        case 3:
             [MASK]  = duration_cast<milliseconds>(duration).count();
            break;
    }

    char fill = os.fill('0');
    if (y.count())
        os << y.count() << "" year"" << (y.count() > 1 ? ""s"" : """") << "" "";
    if (mn.count())
        os << mn.count() << "" month"" << (mn.count() > 1 ? ""s"" : """") << "" "";
    if (y.count() || mn.count() || d.count())
        os << d.count() << ""d "";
    if (y.count() || mn.count() || d.count() || h.count())
        os << std::setw(2) << h.count() << "":"";
    if (y.count() || mn.count() || d.count() || h.count() || m.count())
        os << std::setw(d.count() || h.count() ? 2 : 1) << m.count() << "":"";
    os << std::setw(d.count() || h.count() || m.count() ? 2 : 1) << s.count();
    if ( [MASK] .has_value() &&  [MASK] .value() > 0)
        os << ""."" << std::setw(precision) <<  [MASK] .value();
    if (!d.count() && !h.count() && !m.count())
        os << ""s"";

    os.fill(fill);
    return os.str();
#else
    return {};
#endif
}
",fs_count
389,"//   Copyright 2016 <NAME> <<EMAIL>>
//
//   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.

#define OLED_SCL   13
#define OLED_SDA   12
#define OLED_RES   11
#define OLED_DC    10

#define SPI_fps    12
#define I2C_fps     9
#include <U8glib.h>

unsigned long last_SPI_refresh = 0;
unsigned long last_I2C_refresh = 0;
unsigned long SPI_interval = 1000 / SPI_fps;
unsigned long I2C_interval = 1000 / I2C_fps;
int SPI_angle = 0;
int I2C_angle = 0;

// SPI
// http://www.banggood.com/0_96-Inch-6Pin-12864-SPI-Blue-Yellow-OLED-Display-Module-For-Arduino-p-969145.html
U8GLIB_SSD1306_128X64 u8g_spi(OLED_SCL, OLED_SDA, U8G_PIN_NONE, OLED_DC, OLED_RES);

// I2C
// http://www.banggood.com/0_96-Inch-4Pin-White-IIC-I2C-OLED-Display-Module-12864-LED-For-Arduino-p-958196.html
// SDA = A4
// SCL = A5
U8GLIB_SSD1306_128X64 u8g_i2c(U8G_I2C_OPT_FAST);

void setup() {
}

unsigned int SPI_maxfps = 0;
unsigned int I2C_maxfps = 0;
void loop() {
  // SPI DISPLAY
  if ((unsigned long)(millis() - last_SPI_refresh) >= SPI_interval) {
    SPI_angle -= 6;
    if (SPI_angle <= 0) { SPI_angle = 360 + SPI_angle; }

    last_SPI_refresh = millis();
    u8g_spi.firstPage();  
    do {
      draw(u8g_spi, SPI_angle, SPI_maxfps);
    } while( u8g_spi.nextPage() );
    SPI_maxfps = 1000 / (millis() - last_SPI_refresh);
  }

  // I2C DISPLAY
  if ((unsigned long)(millis() - last_I2C_refresh) >= I2C_interval) {
    I2C_angle -= 6;
    if(I2C_angle <= 0) { I2C_angle = 360 + I2C_angle; }

    last_I2C_refresh = millis();
    u8g_i2c.firstPage();
    do {
      draw(u8g_i2c, I2C_angle, I2C_maxfps);
    } while( u8g_i2c.nextPage() );
    I2C_maxfps = 1000 / (millis() - last_I2C_refresh);
  }
}

const int cx = 64;
const int cy = 42;
const int r = 20;
const int x = cx + 0;
const int y = cy - r + 3;
void draw(U8GLIB u8g, int angle, int maxfps) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 20, ""MAX FPS: "");
  u8g.setPrintPos(70, 20);
  u8g.print(maxfps);
  u8g.drawCircle(cx, cy, r);
  float  [MASK]  = 0.01745329251 * angle;  // Pi/180 * angle
  float c = cos( [MASK] );
  float s = sin( [MASK] );
  int nx = (c * (x - cx)) + (s * (y - cy)) + cx;
  int ny = (c * (y - cy)) - (s * (x - cx)) + cy;
  u8g.drawLine(cx, cy, nx, ny);
}

",radians
390,"/*
  Copyright 2015 Concurrent Computer Corporation

  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 <syslog.h>
#include <czmq.h>

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/agent/mib_modules.h>

#include <vector>

#include ""../util_source/io_rtns.h""
#include ""tcache_agentx.h""
#include ""clientRedirectTable.h""

#define HANDLER_NAME ""clientRedirectTable""

using namespace std;

static vector<clientRedirectTable_t> g_clientRedirectTable;

static Netsnmp_Node_Handler handler;

static netsnmp_variable_list * first_datapt(void ** loop_context,
    void ** data_context, netsnmp_variable_list * put_index_data, 
    netsnmp_iterator_info * data);

static netsnmp_variable_list * next_datapt(void ** loop_context,
    void ** data_context, netsnmp_variable_list * put_index_data,
    netsnmp_iterator_info * data);

static void load_table(void);

static void delayed_response(unsigned int clientreg, void * clientarg);

//********************************************************************************
// Function: init_clientRedirectTable
//
// Description: clientRedirectTable initialization for mib.
//********************************************************************************
bool init_clientRedirectTable(void)
{
    syslog(LOG_DEBUG, ""Enter: %s."", __FUNCTION__); 

    static oid clientRedirectTableOID[] = { 1, 3, 6, 1, 4, 1, 1457, 4, 1, 1, 10 };

    netsnmp_handler_registration * reg{};
    reg = netsnmp_create_handler_registration(HANDLER_NAME,
        handler, clientRedirectTableOID,
        OID_LENGTH(clientRedirectTableOID), HANDLER_CAN_RONLY);

    netsnmp_table_registration_info * table_info{};
    table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
    if(!table_info)
    {
        syslog(LOG_CRIT, ""ERROR: SNMP_MALLOC_TYPEDEF."");
        return false;
    }
    netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, 0);
    table_info->min_column = COLUMN_CLIENT_REDIRECT;
    table_info->max_column = COLUMN_CLIENT_REDIRECT_COUNT;

    netsnmp_iterator_info *iinfo{};
    iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info);
    iinfo->get_first_data_point = (Netsnmp_First_Data_Point *) first_datapt;
    iinfo->get_next_data_point = (Netsnmp_Next_Data_Point *) next_datapt;
    iinfo->table_reginfo = table_info;

    if(netsnmp_register_table_iterator(reg, iinfo) != SNMPERR_SUCCESS)
    {
        syslog(LOG_CRIT, ""ERROR: netsnmp_register_table_iterator."");
        return false;
    }
    syslog(LOG_DEBUG, ""Exit: %s."", __FUNCTION__); 
    return true;
}

//********************************************************************************
// Function: first_datapt
//
// Description: Returns first data point of clientRedirectTable.
//********************************************************************************
static netsnmp_variable_list *
first_datapt(void ** loop_context, void **data_context,
    netsnmp_variable_list * put_index_data, netsnmp_iterator_info * data)
{
    load_table();
    if(!g_clientRedirectTable.size())
    {
        *data_context = (void*) 0;
        *loop_context = (void*) 0;
        return NULL;
    }
    *loop_context = (void*) g_clientRedirectTable.data();
    return next_datapt(loop_context, data_context, put_index_data, data);
}

//********************************************************************************
// Function: next_datapt
//
// Description: Returns next data point of clientRedirectTable.
//********************************************************************************
static netsnmp_variable_list *
next_datapt(void ** loop_context, void ** data_context,
    netsnmp_variable_list * put_index_data, netsnmp_iterator_info * data)
{
    if(!g_clientRedirectTable.size())
        return NULL;

    clientRedirectTable_t *  pd = (clientRedirectTable_t *) *loop_context;
    clientRedirectTable_t * end = g_clientRedirectTable.data();
    end += g_clientRedirectTable.size();
    if(pd == end)
        return NULL;

    netsnmp_variable_list *idx = put_index_data;
    snmp_set_var_typed_integer(idx, ASN_INTEGER, pd->clientRedirectIdx);
    *data_context = (void*) pd;
    *loop_context = (void*) ++pd;
    return put_index_data;
}

//********************************************************************************
// Function: handler
//
// Description: Handle clientRedirectTable get request.
//********************************************************************************
static int handler(netsnmp_mib_handler * handler,
    netsnmp_handler_registration * reginfo, netsnmp_agent_request_info * reqinfo,
    netsnmp_request_info * requests)
{
    syslog(LOG_DEBUG, ""Enter: handler, %s."", HANDLER_NAME); 
    syslog(LOG_DEBUG, ""handler, continuing delayed request, mode = %d."",
        reqinfo->mode);

    requests->delegated = 1;
    snmp_alarm_register(0, 0, delayed_response,
        (void *) netsnmp_create_delegated_cache(handler, reginfo, reqinfo,
        requests, NULL));

    syslog(LOG_DEBUG, ""Exit: handler, %s."", HANDLER_NAME); 
    return SNMP_ERR_NOERROR;
}

//********************************************************************************
// Function: delayed_response
//
// Description: handle table query in callback.
//********************************************************************************
static void delayed_response(unsigned int clientreg, void * clientarg)
{
    syslog(LOG_DEBUG, ""Enter: delayed_response, %s."", HANDLER_NAME); 

    netsnmp_delegated_cache *cache = (netsnmp_delegated_cache *) clientarg;
    if(!netsnmp_handler_check_cache(cache))
    {
        syslog(LOG_ERR, ""%s %s: bad_cache."", HANDLER_NAME, __FUNCTION__);
        return;
    }
    syslog(LOG_DEBUG, ""delayed_instance, continuing delayed request, mode = %d."",
        cache->reqinfo->mode);

    cache->requests->delegated = 0;

    if(cache->reqinfo->mode != MODE_GET && cache->reqinfo->mode != MODE_GETNEXT)
        return;

    for(netsnmp_request_info * request = cache->requests; request;
        request = request->next)
    {
        clientRedirectTable_t * c =
            (clientRedirectTable_t *) netsnmp_extract_iterator_context(request);
        if(!c)
        {
            netsnmp_set_request_error(cache->reqinfo, request, SNMP_NOSUCHINSTANCE);
            g_clientRedirectTable.clear();
            continue;
        }

        netsnmp_table_request_info *table_info = netsnmp_extract_table_info(request);
        if(!table_info)
        {
            syslog(LOG_CRIT, ""ERROR: netsnmp_tdata_extract_table_info"");
            continue;
        }

        switch (table_info->colnum)
        {
            case COLUMN_CLIENT_REDIRECT:
            snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
                (unsigned char*) c->clientRedirect, strlen(c->clientRedirect));
            break;

            case COLUMN_CLIENT_REDIRECT_COUNT:
            snmp_set_var_typed_integer(request->requestvb, ASN_COUNTER,
                c->clientRedirectCount);
            break;

            default:
            netsnmp_set_request_error(cache->reqinfo, request, SNMP_NOSUCHOBJECT);
        }
    }
    netsnmp_free_delegated_cache(cache);

    syslog(LOG_DEBUG, ""Exit: delayed_response, %s."", HANDLER_NAME);
    syslog(LOG_DEBUG,""%s"",
        ""==============================================================="");
    return;
}

//********************************************************************************
// Function: load_table
//
// Description: Pull elements from tcache_plane into clientRedirectTable.
//********************************************************************************
static void load_table(void)
{
    if(g_clientRedirectTable.size())
        return;

    void *context = zmq_ctx_new();
    void *requester = zmq_socket(context, ZMQ_REQ);

    int32_t  [MASK] {};
    zmq_setsockopt(requester, ZMQ_LINGER, (void*) & [MASK] , sizeof( [MASK] ));

    char buffer[64];
    sprintf(buffer, ""tcp://localhost:%d"", TCPLANE_SERVICE);
    zmq_connect(requester, buffer);

    sprintf(buffer, ""%d"", clientRedirectTable);
    zmq_send(requester, buffer, strlen(buffer), 0);

    int idx = 0;
    while(true)
    {
        size_t size = timed_read(requester, buffer, sizeof(buffer), READ_TIMEOUT);
        if(!size)
            break;
        if(strcmp(buffer, ""END"") == 0)
            break;

        char * key, * value;
        key = strtok_r(buffer, ""|"", &value);
        if(value)
        {
            clientRedirectTable_t c;
            c.clientRedirectIdx = idx++;
            strcpy(c.clientRedirect, key);
            c.clientRedirectCount = atoi(value);
            g_clientRedirectTable.push_back(c);
        }
        size = sizeof(size_t);
        int rcvmore{};
        zmq_getsockopt(requester, ZMQ_RCVMORE, (void*) &rcvmore, &size);
        if(!rcvmore)
            break;
    }
    zmq_close(requester);
    zmq_ctx_destroy(context);
    return;
}
",timeo
391,"#include <iostream>
#include ""../include/ptx_builder.h""

// Build a simple AXPY kernel using the PTX builder API.
// The kernel performs: y = a * x + y for a single element.
// This example generates PTX text and prints it to stdout.

std::string build_axpy_kernel() {
    using namespace ptx;
    Builder b;
    Reg rA(""%f0"");
    Reg rX(""%f1"");
    Reg rY(""%f2"");

    // rY = a * x + y
    b.mad(rY, rA, rX, rY);
    b.ret();

    std::ostringstream  [MASK] ;
     [MASK]  << "".version 8.7\n"";
     [MASK]  << "".target sm_80\n"";
     [MASK]  << "".address_size 64\n\n"";
     [MASK]  << "".visible .entry axpy_one(\n"";
     [MASK]  << ""    .param .f32 a,\n"";
     [MASK]  << ""    .param .f32 x,\n"";
     [MASK]  << ""    .param .f32 y\n"";
     [MASK]  << "")\n"";
     [MASK]  << ""{\n"";
     [MASK]  << ""    .reg .f32 %f0, %f1, %f2;\n"";
     [MASK]  << b.str();
     [MASK]  << ""}\n"";
    return  [MASK] .str();
}

int main() {
    std::cout << build_axpy_kernel();
    return 0;
}

",oss
392,"#ifndef _ADX_NET_H_
#define _ADX_NET_H_

#include ""net.h""
#include ""util.h""
#include ""message_types.h""
#include <map>

#define SELLER_IDX 0
#define ALL_BIDDERS -1

// Macro that simplifies writing read_cb() functions
#define PROCESS_REQ(type_name) \
  do { \
    type_name req; \
    ret = parse_message(data, &req); \
    check_ret(ret, ""parse_message()""); \
    process_##type_name(conn_idx, req); \
  } while (0);

struct auction_context {
  uint32_t id;
  std::map<int, uint32_t> bids; // map from conn_idx to bid
  std::map<int, std::string> ad_tags;
  std::pair<int, uint32_t> outcome; // conn_idx and price
};

class adx_server {
 public:
  adx_server() : conn_(), auctions_ctx_() {}
  ~adx_server() {}

  //----- Initialization functions -----//

  // Initialize net objects for seller and bidders
  // Also initializes the connection for the bidders, but not
  // the seller (call init_seller_conn to do that).
  void init_conn(int num, str hosts[], int ports[]);

  // Initializes the connection to the seller.
  void init_seller_conn(str host, int port);
  

  //----- Handle events ------//


  // Handle writing from msgpack structures
  template <typename T>
  void a_write(int conn_idx, uint8_t type, const T &req)
  {
    msgpack::sbuffer buf;
    msgpack::pack(&buf, req);
    
    strbuf  [MASK] ;
     [MASK]  << str((char*) &type, 1) << str(buf.data(), buf.size());

    if (conn_idx == ALL_BIDDERS) {
      for (int i = 1; i < (int) conn_.size(); ++i)
        conn_[i]->a_write( [MASK] );

    } else {
      conn_[conn_idx]->a_write( [MASK] );
    }
  }


  // Read callback
  // conn_idx can be thought of as a ""bidder_id""
  // conn_idx = 0 implies the seller.
  void read_cb(int conn_idx, strbuf data);

  // Handle requests
  void process_a_req(int conn_idx, const a_req &req);
  void process_b_sub(int conn_idx, const b_sub &req);

  // Compute the auction
  std::pair<int, uint32_t> compute_auction(auction_context *ctx);

  // Report the outcome
  void report_outcome(auction_context *ctx);

 private:
  vec<ref<net> > conn_;
  std::map<uint32_t, auction_context> auctions_ctx_;
};

#endif
",send_data
393,"/* Copyright Acrolinx GmbH */

// CheckOptions.cpp : Implementation of CCheckOptions

#include ""stdafx.h""
#include ""CheckOptions.h""

// CCheckOptions

using namespace Acrolinx_Sdk_Sidebar_Util;

STDMETHODIMP CCheckOptions::GetSelection(VARIANT_BOOL* selection)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    ACROASSERT(m_isInstanceCreated == TRUE, ""Initialize Checkoptions object by calling InitInstance() before using it"");

    BOOL  [MASK]  = m_checkOptions.HasMember(_T(""selection"")) ? m_checkOptions[_T(""selection"")].GetBool() : FALSE;

    if(selection == nullptr)
    {
        LOGE <<  ""Create out bool var before calling GetSelection()"";
    }
    else
    {
        *selection = (VARIANT_BOOL) [MASK] ;
    }
    return S_OK;
}


STDMETHODIMP CCheckOptions::InitInstance(BSTR checkOptions)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    if(!Instantiate())
    {
        return S_FALSE;
    }

    ASSERT(checkOptions != nullptr);
    CString jsonString(checkOptions);
    if( jsonString.IsEmpty())
    {
        jsonString = _T(""{}"");
    }
    CJsonUtil::Parse(jsonString, m_checkOptions);

    return S_OK;
}
",retVal
394,"#include""misc.h""
/* for version-control appl'n: binary to hex..
.. ideally would use stdin instead of file

for version control: generate hexdiffs so we don't lose
any special characters, etc. */
int main(int argc, char ** argv){
  str fn;
  str fnf_fn(""./.b2h"");
  str fnf_fnp(fnf_fn + str(""p""));

  unsigned char c;
  const char * f_n;
  size_t i = 0;
  size_t f_p = 0;

  if(argc > 1){
    f_n, fn = argv[1], str(argv[1]);
    ofstream f(fnf_fn); f << fn; f.close();
    ofstream g(fnf_fnp); g << 0; g.close();
  }
  else{
    ifstream g(fnf_fnp); g >> f_p; g.close();
  }

  if(fsize(fnf_fn) == (size_t)0) err(""b2h [file name]"");
  ifstream fnf(fnf_fn); fnf >> fn; fnf.close();
  f_n = fn.c_str();

  FILE * f = fopen(f_n, ""rb"");
  if(!f) err(str(""failed to open file: "") + str(f_n));
  size_t  [MASK]  = size(f);

  if(f_p >=  [MASK]  - 1){
    system((str(""rm -f "") + fnf_fn).c_str());
    system((str(""rm -f "") + fnf_fnp).c_str());
    exit(0);
  }
  printf(""%s%d%s\n\n "", KNRM, f_p, KGRN);
  unsigned long int l_i, c_i;
  l_i = c_i = 0;
  fseek(f, f_p, SEEK_SET);
  for(i = f_p; i <  [MASK] ; i++){
    c = fgetc(f);
    printf(""%.2X"", (unsigned char)c);
    if(++c_i % 32 == 0){
      if(++ l_i > 32) break;
      printf(""\n "");
    }
  }
  ofstream g(fnf_fnp);
  g << string(to_string(++i));
  g.close();

  printf(""\n\n%s%d\n"", KNRM, i);

  return 0;
}",f_s
395,"/*
 * Copyright (C) 2024 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#ifndef __MAINWIN_H__
#define __MAINWIN_H__

#include <egt/ui>
#include <egt/window.h>
#include ""version.h""
#include ""libconfig.h++""
#include ""libuboot.h""

using namespace std;
using namespace egt;
using namespace egt::experimental;

static const std::string EGT_SWUPDATE_VERSION = std::to_string(EGT_SWUPDATE_VERSION_MAJOR) + ""."" + std::to_string(EGT_SWUPDATE_VERSION_MINOR) + ""."" + std::to_string(EGT_SWUPDATE_VERSION_PATCH);
inline static const std::vector<std::string> ubootEnvVars = {""upgrade_available"", ""bootcount"", ""ustate""};
inline static const std::vector<std::string> ustateVal = {""0"", ""1"", ""2"", ""3"", ""4"", ""5"", ""6"", ""7""};

#define HASH_CHUNK_SIZE 4096

typedef enum ubootEnvVars_t {
	ENV_UPGRADE = 0,
	ENV_BOOTCNT,
	ENV_USTATE,
	ENV_MAX,
} ubootEnvVars_t;

typedef enum ustate_t {
	STATE_OK = 0,
	STATE_INSTALLED = 1,
	STATE_TESTING = 2,
	STATE_FAILED = 3,
	STATE_NOT_AVAILABLE = 4,
	STATE_ERROR = 5,
	STATE_WAIT = 6,
	STATE_IN_PROGRESS = 7,
	STATE_LAST = STATE_IN_PROGRESS
} ustate_t;

class RebootWindow : public egt::Popup {
public:
	explicit RebootWindow() : egt::Popup(egt::Application::instance().screen()->size() / 2) {
		colorSwitch = 0;
		this->color(Palette::ColorId::bg, Palette::red);
		rebootCnt = 30;

		rebootWarn = Label(""Update Available! Rebooting in "" + std::to_string(rebootCnt));
		add(egt::center(rebootWarn));

		cancel = Button(""Cancel"");
		cancel.align(egt::AlignFlag::right | egt::AlignFlag::bottom);

		add(cancel);

		cancel.on_click([this](egt::Event&) {
			cout << ""Cancelling reboot..."" << endl;
			rebootTimer.stop();
			this->hide();
		});

		rebootTimer = PeriodicTimer(std::chrono::seconds(1));

		rebootTimer.on_timeout([this]() {
			if (colorSwitch) {
				colorSwitch ^= 1;
				this->color(Palette::ColorId::bg, Palette::red);
			} else {
				colorSwitch ^= 1;
				this->color(Palette::ColorId::bg, Palette::yellow);
			}

			if (rebootCnt-- == 0) {
				system(""/usr/sbin/reboot"");
			} else {
				rebootWarn.text(""Update Available! Rebooting in "" + std::to_string(rebootCnt));
			}
		});
	}

	void startRebootTimer(size_t  [MASK] ) {
		rebootCnt =  [MASK] ;
		rebootWarn.text(""Rebooting in "" + std::to_string(rebootCnt));
		rebootTimer.start();
	}

protected:
	Label rebootWarn;
	Button cancel;
	size_t rebootCnt;
	PeriodicTimer rebootTimer;
	size_t colorSwitch;

private:

};

class MainWindow : public TopWindow {
public:
	MainWindow(std::string const cfg);
	virtual ~MainWindow();

private:
	std::string getTime(void);
	std::string getTime(ssize_t future);

	bool readConfigFile(std::string cfgFile);
	bool getAttrFromCfg(std::string node, std::string attr, std::string& val);
	bool getAttrFromCfg(std::string node, std::string subnode, std::string key, std::string& val);
	void getServerAttrs(void);

	size_t initUbootEnvAccess(void);
	size_t setUbootEnvVar(ubootEnvVars_t var, std::string val);
	size_t writeUbootVarToEnv(ubootEnvVars_t var, std::string val);
	size_t setUpdateAvailableInUbootEnv(void);
	void checkIfUpdated(void);
	bool hashAppData(std::string file, std::string& digest);
	bool pollHawkbitServer(void);
	bool sendMsgToHawkbitServer(void);

	PeriodicTimer cpuTimer;
	CPUMonitorUsage cpuMon;
	std::shared_ptr<Label> timeClock;
	std::shared_ptr<Label> cpuMonLabel;
	std::shared_ptr<Label> pollTime;

	libconfig::Config swupdateCfg;

	bool provisioned;

	struct uboot_ctx *ubootCtx;
	ssize_t ustate;
	bool writeUbootEnv = false;

	PeriodicTimer updatePollTimer;
	ssize_t serverPollTime;
	ssize_t actionId;
	bool updateAvailable;
	bool updateInstalled;

	std::string uri;
	std::string sslkey;
	std::string sslcert;

	std::string appDataFile;
	std::string appDataMd;

	RebootWindow rebootWin;
};

#endif /* __MAINWIN_H__ */
",countdown
396,"#include ""GameChat.h""

#include ""Hooks.h""
#include ""Debug.h""

void (__fastcall *addrChatHandler)(void *This, int EDX, void *MsgObject);

void (__fastcall *origChatHandler)(void *This, int EDX, void *MsgObject);

const char *getMessage(DWORD This) {
	return *(const char **) (This + 20);
}

const char *getFrom(DWORD This) {
	return *(const char **) (This + 12);
}

void __fastcall GameChat::hookChatHandler(void *This, int EDX, void *MsgObject) {
	GameChatType type = GameChatType::Normal;
	const std::string name = getFrom((DWORD) MsgObject);
	const std::string text = getMessage((DWORD) MsgObject);
	for (const GameChatCallback &callback: chatCallbacks) {
		callback(type, name, text);
	}

	origChatHandler(This, EDX, MsgObject);
}

int (__stdcall *origOnChatInput)(void *a1, char *a2, int a3) = nullptr;

int __stdcall GameChat::hookOnChatInput(void *a1, char *msg, int a3) {
	std::string  [MASK]  = msg;
	for (const CommandAndCallback &cb: commandCallbacks) {
		if ( [MASK] .starts_with(std::get<0>(cb))) {
			std::get<1>(cb)( [MASK] .substr(std::get<0>(cb).length()));
			return 1;
		}
	}
	return origOnChatInput(a1, msg, a3);
}

void GameChat::print(const std::string &msg) {
	debugf(""%s"", msg.c_str());
}

void GameChat::install() {
	addrChatHandler = (void (__fastcall *)(void *, int, void *)) Hooks::scanPatternAndHook(""ChatHandler"",
	                                                                                       ""\x6A\xFF\x68\x00\x00\x00\x00\x64\xA1\x00\x00\x00\x00\x50\x64\x89\x25\x00\x00\x00\x00\x83\xEC\x24\x80\x3D\x00\x00\x00\x00\x00\x53\x55\x56\x8B\xD9\x57\x89\x5C\x24\x20\x74\x09\xC6\x05\x00\x00\x00\x00\x00\xEB\x09\x8D\x4C\x24\x18\xE8\x00\x00\x00\x00\xB8\x00\x00\x00\x00\xC7\x44\x24\x00\x00\x00\x00\x00\x66\x39\x05\x00\x00\x00\x00\x75\x11\x68\x00\x00\x00\x00\x6A\x2F\x68\x00\x00\x00\x00\xE8\x00\x00\x00\x00"",
	                                                                                       ""???????xx????xxxx????xxxxx?????xxxxxxxxxxxxxx?????xxxxxxx????x????xxx?????xxx????xxx????xxx????x????"",
	                                                                                       (DWORD *) &hookChatHandler,
	                                                                                       (DWORD *) &origChatHandler);
	Hooks::scanPatternAndHook(""OnChatInput"",
	                          ""\x6A\xFF\x68\x00\x00\x00\x00\x64\xA1\x00\x00\x00\x00\x50\x64\x89\x25\x00\x00\x00\x00\x83\xEC\x08\x56\x8B\x74\x24\x20\x57\x56\x8D\x4C\x24\x10\xE8\x00\x00\x00\x00\xC7\x44\x24\x00\x00\x00\x00\x00\x8D\x4C\x24\x0C\xE8\x00\x00\x00\x00\x8B\x7C\x24\x20\x56\x8B\xCF\xE8\x00\x00\x00\x00\x8B\xF0\x83\xFE\x06\x0F\x87\x00\x00\x00\x00\x0F\xB6\x86\x00\x00\x00\x00\xFF\x24\x85\x00\x00\x00\x00"",
	                          ""???????xx????xxxx????xxxxxxxxxxxxxxx????xxx?????xxxxx????xxxxxxxx????xxxxxxx????xxx????xxx????"",
	                          (DWORD *) &hookOnChatInput,
	                          (DWORD *) &origOnChatInput);
}

bool GameChat::isInGame() {
	return true;
}

void GameChat::registerCommandCallback(std::string command, CommandCallback callback) {
	commandCallbacks.push_back(std::make_tuple(""/"" + command, callback));
}

void GameChat::registerChatCallback(GameChatCallback callback) {
	chatCallbacks.push_back(callback);
}
",msgs
397,"#ifndef DEBUG_HPP
#define DEBUG_HPP

#include <stdio.h>
#include <stdarg.h>
#include <sys/time.h>
#include <assert.h>
#include <random>

#define rand() better_rand()

std::mt19937_64 _rand_gen(0);
int better_rand() {
  static std::uniform_int_distribution<int> dist{0, std::numeric_limits<int>::max()};
  return dist(_rand_gen);
}


#define CHECK_SIGNALS(cmd) ({ if (g_stop_signal != 0 || MyTimer::triggered()) { cmd; } })

struct MyTimer {
  static long long end;

  MyTimer(long long timeout) {
    assert(end == 0);
    struct timeval now;
    gettimeofday(&now, NULL);
    end = now.tv_sec + timeout;
  }

  ~MyTimer() { end = 0; }

  static bool triggered() {
    if (end == 0) return false;
    struct timeval now;
    gettimeofday(&now, NULL);
    return now.tv_sec >= end;
  }

  operator bool() const { return true; }
};
long long MyTimer::end;

#define TIMER(timeout) if (auto _timer = MyTimer(timeout))


#define Assert(cond, ...) do { \
    if (!(cond)) { \
      fprintf(stderr, __VA_ARGS__); \
      assert(0); \
    } \
  } while (0)

#define TIMER_BEGIN \
  do { \
    struct timeval timer_begin; \
    gettimeofday(&timer_begin, NULL); \
    do

#define TIMER_END(...) \
    while (0); \
    struct timeval timer_end; \
    gettimeofday(&timer_end, NULL); \
    double timer = (timer_end.tv_sec - timer_begin.tv_sec) + \
      ((double)(timer_end.tv_usec - timer_begin.tv_usec) / (1000 * 1000)); \
    debug_printf(__VA_ARGS__); \
  } while (0)


bool print_debug = true;

// suppress debug output for a single statement
#define PAUSE_DEBUG \
  for (bool _print_debug_old = print_debug, _end_me = true; \
    (print_debug = (_print_debug_old && !_end_me)), _end_me; _end_me = false)

#ifndef NDEBUG
void
debug_printf(const char *format, ...)
{
   va_list  [MASK] ;

   va_start( [MASK] , format);
   if (print_debug) vfprintf(stderr, format,  [MASK] );
   va_end( [MASK] );
}
#else
#define debug_printf(...) do {} while(0)
#endif

#endif // DEBUG_HPP
",args
398,"/*
 * gCanvas.cpp
 *
 *  Edited on : 16.02.2023
 *  	Author: <NAME>
 */


#include ""gCanvas.h""


gCanvas::gCanvas(gApp* root) : gBaseCanvas(root) {
	this->root = root;
}

gCanvas::~gCanvas() {
	gBulletObj->clean();
}

void gCanvas::setup() {
	gBulletObj = new gipBulletPhysics(gipBulletPhysics::WORLDCOORDINATETYPE::WORLD2D);
	sky.loadImage(""layer-1-sky.png"");
	mountain.loadImage(""layer-2-mountain.png"");
	ground.loadImage(""layer-3-ground.png"");
	ramp.loadImage(""ramp.png"");
	gameIcon.loadImage(""gameicon/icon.png"");

	// create object with image referance
	groundobject   = new gImageGameObject(gBulletObj);
	groundobject->setTag(1); //1 for grouping grounds
	groundobject->setName(""Ground Object"");
	groundobject->setImage(&ground);
	groundobject->setPosition(0.0f, getHeight() - ground.getHeight());
	groundobject->setBounce(0.1f);

	// create object without image referance
	rampobject   = new gImageGameObject(gBulletObj);
	rampobject->setTag(1); //1 for grouping grounds, you can set any integer as you wish
	rampobject->setName(""Ramp Object"");
	rampobject->setColliderSize(200.0f, 40.0f);
	rampobject->setPosition(getWidth() * 0.8f, getHeight() * 0.7f);
	rampobject->setRotation2D(25.0f);
	rampobject->setBounce(0.1f);
	//rampobject->setFriction(100.f);
	//rampobject->setRollingFriction(100.f);
	//rampobject->setSpinningFriction(100.f);

	// create object with image referance
	gameiconobject   = new gImageGameObject(gBulletObj);
	gameiconobject->setTag(2); //2 for grouping non ground statics, you can set any integer as you wish
	gameiconobject->setImage(&gameIcon);
	gameiconobject->setName(""Gameicon Object"");
	gameiconobject->setPosition(0.0f, getHeight() * 0.4f);
	gameiconobject->setObjectLayers(gipBaseGameObject::COLLISIONLAYERS::LAYER4);

	// create object with loading image
	softballobject = new gImageGameObject(gBulletObj);
	softballobject->setTag(3); //3 for balls, you can set any integer as you wish
	softballobject->setName(""Softball Object"");
	softballobject->loadImage(""ball.png"");
	softballobject->setShapeType(gipBaseGameObject::SHAPETYPE::SHAPETYPE_SPHERE);
	softballobject->setPosition(getWidth() - softballobject->getWidth(), getHeight() * 0.1f);
	softballobject->setMass(40.0f);
	softballobject->setBounce(0.4f);
	//softballobject->setOnCollided(std::bind(&gCanvas::onCollidedBall,this, std::placeholders::_1));

	//create object with loading image
	seconballobject = new gImageGameObject(gBulletObj);
	seconballobject->loadImage(""ball.png"");
	//you can set image render size
	//ghostballobject->setObjectSize(400.0f, 400.0f);
	seconballobject->setTag(3); //3 for balls, you can set any integer as you wish
	seconballobject->setName(""Softball Object"");
	//you can lock or unlock size of collider and image
	//ghostballobject->setIsSizeLocked(false);
	seconballobject->setObjectSize(80.0f, 80.0f);
	seconballobject->setColliderSize(120.0f, 120.0f);
	seconballobject->setShapeType(gipBaseGameObject::SHAPETYPE::SHAPETYPE_SPHERE);
	seconballobject->setPosition(0 + seconballobject->getWidth() * 1.2f, getHeight() * 0.1f);
	seconballobject->setMass(400.0f);
	seconballobject->setBounce(10.0f);
	seconballobject->setMaskLayers(gipBaseGameObject::COLLISIONLAYERS::LAYER1 | gipBaseGameObject::COLLISIONLAYERS::LAYER2);
	//ghostballobject->setColliderOffset(100.f, 40.0f);
	//softballobject->setOnCollided(std::bind(&gCanvas::onCollidedBall,this, std::placeholders::_1));


}

void gCanvas::update() {

	// Physics calculations doing here.
	gBulletObj->runPhysicWorldStep();
	// force and impulse methods can call here.
	//ghostballobject->applyTorque(glm::vec3(0.0f, 0.0f, -40.0f));
	//ghostballobject->applyCentralForce(glm::vec3(10.0f, 0.0f, 0.0f));
	//ghostballobject->applyImpulse(glm::vec3(0.0f, 0.0f, -100.0f), glm::vec3(0.0f, 0.0f, 0.0f)); //will add velocity instant
}

void gCanvas::draw() {
	//Draws nimages without colliders
	sky.draw(getWidth() / 2 - sky.getWidth() / 2, getHeight() - sky.getHeight());
	mountain.draw(getWidth() / 2 - mountain.getWidth() / 2, getHeight() - mountain.getHeight() / 2);

	//Draw physic objects
	seconballobject->draw();
	gameiconobject->draw();
	rampobject->draw();
	softballobject->draw();
	groundobject->draw();

	//This line for draw collider, delete or comment this line when get release
	gBulletObj->drawDebug();
}

void gCanvas:: onCollidedBall(gipBaseGameObject* target, glm::vec3 pointa, glm::vec3  [MASK] ) {
	gLogi(""Ball Collison"") << target->getName() <<  [MASK] .x;
}

void gCanvas::keyPressed(int key) {
//	gLogi(""gCanvas"") << ""keyPressed:"" << key;

	if(key == G_KEY_R) {
		ghostbox = new gGhostImageGameObject(gBulletObj);
		ghostbox->setPosition(40.0f, getHeight() * 0.4f);
		ghostbox->setColliderSize(120.0f, 0.0f);
		ghostbox->setOnCollided(std::bind(&gCanvas::onCollidedBall,this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
		gBulletObj->runPhysicWorldStep();
		delete ghostbox;
	}

}

void gCanvas::keyReleased(int key) {
//	gLogi(""gCanvas"") << ""keyReleased:"" << key;
}

void gCanvas::charPressed(unsigned int codepoint) {
//	gLogi(""gCanvas"") << ""charPressed:"" << gCodepointToStr(codepoint);
}

void gCanvas::mouseMoved(int x, int y) {
//	gLogi(""gCanvas"") << ""mouseMoved"" << "", x:"" << x << "", y:"" << y;
}

void gCanvas::mouseDragged(int x, int y, int button) {
//	gLogi(""gCanvas"") << ""mouseDragged"" << "", x:"" << x << "", y:"" << y << "", b:"" << button;
}

void gCanvas::mousePressed(int x, int y, int button) {
//	gLogi(""gCanvas"") << ""mousePressed"" << "", button:"" << button;
}

void gCanvas::mouseReleased(int x, int y, int button) {
//	gLogi(""gCanvas"") << ""mouseReleased"" << "", button:"" << button;
}

void gCanvas::mouseScrolled(int x, int y) {
//	gLogi(""gCanvas"") << ""mouseScrolled"" << "", x:"" << x << "", y:"" << y;
}

void gCanvas::mouseEntered() {
}

void gCanvas::mouseExited() {
}

void gCanvas::windowResized(int w, int h) {
}

void gCanvas::showNotify() {
}

void gCanvas::hideNotify() {
}

void gCanvas::startCleanup() {

}
",pointb
399,"#include <sstream>

#include ""communication_exception.h""

CommunicationException::CommunicationException(const std::string message,
                                               const int result_code,
                                               const char *file_name,
                                               const char *function_name,
                                               const int line_number)
  :message_(message),
   result_code_(result_code),
   file_name_(file_name),
   function_name_(function_name),
   line_number_(line_number)
{
}

CommunicationException::~CommunicationException() throw()
{
}

const char* CommunicationException::what() const throw()
{
  return message_.c_str();
}

const int CommunicationException::getResultCode()
{
  return result_code_;
}

const char* CommunicationException::getFileName()
{
  return file_name_;
}

const char* CommunicationException::getFunctionName()
{
  return function_name_;
}

const int CommunicationException::getLineNumber()
{
  return line_number_;
}

const std::string CommunicationException::toString()
{
  std::ostringstream  [MASK] ;
   [MASK]  << message_.c_str() << "" "";
   [MASK]  << result_code_;
  std::string result =  [MASK] .str();
  return result;
}
",oss
400,"#include ""Adafruit_BMP581.h""
#include ""metadata.h""
#include <Arduino.h>
#include <FIR.h>
#include <Notecard.h>
#include <Wire.h>
#include <floor_tracker.h>

// Uncomment to use a connected SSD1306 Display
// #define USE_DISPLAY

// Uncomment to rotate the connected display 180 degrees
// #define DISPLAY_ROTATE_180

// Uncomment to give the OLED Display power from digital MCU pins.
// Safe for 0.91 Inch I2C OLED Display on Notecarrier-F + Blues Swan.
// UNSAFE if your display takes more amps than your microcontroller can supply.
// #define DISPLAY_POWER_PIN 5
// #define DISPLAY_GROUND_PIN 6

// Uncomment to output the floor sample every second
// #define DEBUG_FLOOR_SAMPLES

#ifdef USE_DISPLAY
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#endif

#define serialDebugOut Serial
// Uncomment to view Note requests from the Host
// #define DEBUG_NOTECARD

// This is the unique Product Identifier for your device
#ifndef PRODUCT_UID
#define PRODUCT_UID """" // ""com.my-company.my-name:my-project""
#pragma message ""PRODUCT_UID is not defined in this example. Please ensure your Notecard has a product identifier set before running this example or define it in code here. More details at https://dev.blues.io/notehub/notehub-walkthrough/#finding-a-productuid""
#endif

#define ENV_POLL_SECS 1
#define IDLE_UPDATE_PERIOD (1000 * 60 * 5)
#define LIVE_UPDATE_PERIOD (1000 * 60 * 1)
#define NO_MOVEMENT_THRESHOLD_SCALE_MS \
  (1000) // No movement threshold given in seconds.
#define FLOOR_SAMPLE_PERIOD (250)
#define FLOOR_FILTER_ORDER (10)
#define FLOOR_OFFSET (0.3)

// Variables for Env Var polling
static unsigned long nextPollMs = 0;
static uint32_t lastModifiedTime = 0;
// Variables for sensor reading period when not in live mode
static unsigned long lastUpdateMs;
static unsigned long updatePeriod;
static unsigned long lastFloorSampleMs;

FIR<double, FLOOR_FILTER_ORDER> floorFilter;

bool setBaselineFloor = false;
applicationState state = {0};

Notecard notecard;

// Forward declarations
void fetchEnvironmentVariables(applicationState &state);
bool pollEnvVars(void);
sensorReadings captureSensorReadings(void);
void sendSensorReadings(const sensorReadings &readings, bool alarm = false);
void displayReadings(const sensorReadings &readings);
bool publishSensorReadings(sensorReadings &readings, uint32_t currentMillis);

#ifdef USE_DISPLAY
Adafruit_SSD1306 display = Adafruit_SSD1306(128, 32, &Wire);
#endif

Adafruit_BMP581 bmp;

void setup()
{
  serialDebugOut.begin(115200);
#ifdef DEBUG_NOTECARD
  notecard.setDebugOutputStream(serialDebugOut);
#endif
  delay(1500);
  serialDebugOut.println(""Floor Level Detector"");
  serialDebugOut.println(""===================="");

  Wire.begin();
  notecard.begin();

#ifdef USE_DISPLAY
#ifdef DISPLAY_POWER_PIN
  pinMode(DISPLAY_POWER_PIN, OUTPUT);
  digitalWrite(DISPLAY_POWER_PIN, HIGH);
#endif
#ifdef DISPLAY_GROUND_PIN
  pinMode(DISPLAY_GROUND_PIN, OUTPUT);
  digitalWrite(DISPLAY_GROUND_PIN, LOW);
#endif
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  serialDebugOut.println(""OLED connected..."");
#endif

  if (!bmp.begin_I2C())
  {
    serialDebugOut.println(
        ""Could not find a valid BMP581 sensor, check wiring!"");
    while (1)
      ;
  }

  serialDebugOut.println(""BMP581 connected..."");

  /* Highest accuracy for stationary devices */
  // bmp.setTemperatureOversampling(BMP5_OVERSAMPLING_8X);
  // bmp.setPressureOversampling(BMP5_OVERSAMPLING_128X);
  // bmp.setIIRFilterCoeff(BMP5_IIR_FILTER_COEFF_127);
  // bmp.setOutputDataRate(BMP5_ODR_10_HZ);

  /* Suggestions from Bosch for devices in motion */
  bmp.setTemperatureOversampling(BMP5_OVERSAMPLING_2X);
  bmp.setPressureOversampling(BMP5_OVERSAMPLING_16X);
  bmp.setIIRFilterCoeff(BMP5_IIR_FILTER_COEFF_3);
  bmp.setOutputDataRate(BMP5_ODR_50_HZ);

  // Throw the first one away
  bmp.performReading();

  double coef[FLOOR_FILTER_ORDER];
  for (int i = 0; i < FLOOR_FILTER_ORDER; i++)
  {
    coef[i] = 1.0; // rolling average
  }
  floorFilter.setFilterCoeffs(coef);

#ifdef USE_DISPLAY
  // Clear the display buffer.
  display.clearDisplay();
  display.display();

  // text display tests
#ifdef DISPLAY_ROTATE_180
  display.setRotation(2);
#endif
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println(""NF1"");
  display.println(""Indoor Floor Level Tracker"");
  display.setCursor(0, 0);
  display.display();
#endif

  J *req = notecard.newRequest(""hub.set"");
  if (req != NULL)
  {
    JAddStringToObject(req, ""product"", PRODUCT_UID);
    JAddStringToObject(req, ""mode"", ""continuous"");
    JAddBoolToObject(req, ""sync"", true);
    notecard.sendRequest(req);
  }

  // Notify Notehub of the current firmware version
  req = notecard.newRequest(""dfu.status"");
  if (req != NULL)
  {
    JAddStringToObject(req, ""version"", firmwareVersion());
    notecard.sendRequest(req);
  }

  // Enable Outboard DFU
  req = notecard.newRequest(""card.dfu"");
  if (req != NULL)
  {
    JAddStringToObject(req, ""name"", ""stm32"");
    JAddBoolToObject(req, ""on"", true);
    notecard.sendRequest(req);
  }

  // Check Environment Variables
  fetchEnvironmentVariables(state);

  delay(2000);

  if (!state.live)
  {
    if (state.floorHeight != 0.0 && state.baselineFloor != 0)
    {
      sensorReadings readings = captureSensorReadings();
      displayReadings(readings);
      sendSensorReadings(readings);
    }
    else
    {
      serialDebugOut.println(
          ""Waiting for Environment Variables from the Notecard"");
    }
  }
  lastUpdateMs = millis();
}

void resetFloorFilter(double floor)
{
  for (int i = 0; i < FLOOR_FILTER_ORDER; i++)
  {
    floorFilter.processReading(floor);
  }
}

void loop()
{
  if (pollEnvVars())
  {
    fetchEnvironmentVariables(state);

    if (state.variablesUpdated)
    {
      serialDebugOut.println(""Environment Variable Updates Received"");

      J *req = notecard.newRequest(""note.add"");
      if (req != NULL)
      {
        JAddStringToObject(req, ""file"", ""notify.qo"");
        JAddBoolToObject(req, ""sync"", true);
        J *body = JCreateObject();
        if (body != NULL)
        {
          JAddStringToObject(body, ""message"",
                             ""environment variable update received"");
          JAddItemToObject(req, ""body"", body);
          notecard.sendRequest(req);
        }
      }
      state.variablesUpdated = false;
    }
  }

  const uint32_t currentMillis = millis();
  if (!state.live)
  {
    if (currentMillis - lastUpdateMs >= updatePeriod)
    {
      if (state.floorHeight != 0.0 && state.baselineFloor != 0)
      {
        sensorReadings readings = captureSensorReadings();
        displayReadings(readings);
        lastUpdateMs = currentMillis;
        sendSensorReadings(readings);
      }
      else
      {
        serialDebugOut.println(
            ""Waiting for Environment Variables from the Notecard"");
      }
    }
  }
  else
  {
    if (state.floorHeight != 0.0 && state.baselineFloor != 0)
    {
      sensorReadings readings = captureSensorReadings();
      if ((currentMillis - lastFloorSampleMs) >= FLOOR_SAMPLE_PERIOD)
      {
        lastFloorSampleMs = currentMillis;
        publishSensorReadings(readings, currentMillis);
      }
    }
    else
    {
      serialDebugOut.println(
          ""Waiting for Environment Variables from the Notecard"");
    }
  }
}

bool publishSensorReadings(sensorReadings &readings, uint32_t currentMillis)
{
  bool send = false;
  bool alarm = false;
  bool floorChange = false;

  // run the floor signal through a FIR low-pass filter
  double  [MASK]  = floorFilter.processReading(readings.floor);
  readings.currentFloor = (int)( [MASK]  + FLOOR_OFFSET);

#ifdef DEBUG_FLOOR_SAMPLES
  serialDebugOut.print(""floor sample: "");
  serialDebugOut.print(readings.floor);
  serialDebugOut.print("", filtered: "");
  serialDebugOut.print( [MASK] );
  serialDebugOut.println();
#endif

  if (state.baselineChanged)
  {
    send = true;
    floorChange = true;
    state.alarmSent = false;
    state.baselineChanged = false;
    serialDebugOut.println(""Baseline changed. Sending a Note."");
  }
  else if (readings.currentFloor != state.lastFloor)
  {
    send = true;
    floorChange = true;
    state.alarmSent = false;
    serialDebugOut.println(""New floor detected. Sending a Note."");
  }
  else if (!state.alarmSent && state.lastFloorChangeAt &&
           state.lastFloorChangeAt < currentMillis &&
           state.noMovementThreshold &&
           ((currentMillis - state.lastFloorChangeAt) >
            (state.noMovementThreshold * NO_MOVEMENT_THRESHOLD_SCALE_MS)))
  {
    serialDebugOut.println(
        ""**ALARM**: No movement between floors detected. Sending a Note."");
    send = true;
    alarm = true;
    state.alarmSent = true;
  }
  else if (currentMillis - lastUpdateMs >= updatePeriod)
  {
    send = true;
    serialDebugOut.println(""Update period elapsed. Sending a Note."");
  }
  if (send)
  {
    displayReadings(readings);
    sendSensorReadings(readings, alarm);
    lastUpdateMs = currentMillis;
  }
  if (floorChange)
  {
    state.lastFloor = readings.currentFloor;
    state.lastFloorChangeAt = currentMillis;
  }
  return send;
}

void fetchEnvironmentVariables(applicationState &vars)
{
  J *req = notecard.newRequest(""env.get"");

  J *names = JAddArrayToObject(req, ""names"");
  JAddItemToArray(names, JCreateString(""live""));
  JAddItemToArray(names, JCreateString(""baseline_floor""));
  JAddItemToArray(names, JCreateString(""floor_height""));
  JAddItemToArray(names, JCreateString(""no_movement_threshold""));

  J *rsp = notecard.requestAndResponse(req);
  if (rsp != NULL)
  {
    if (notecard.responseError(rsp))
    {
      notecard.deleteResponse(rsp);
      return;
    }

    // Get the note's body
    J *body = JGetObject(rsp, ""body"");
    if (body != NULL)
    {
      int newBaselineFloor = atoi(JGetString(body, ""baseline_floor""));
      if (newBaselineFloor != vars.baselineFloor)
      {
        setBaselineFloor = true;
        vars.baselineFloor = newBaselineFloor;
        vars.variablesUpdated = true;
      }

      float floorHeight = atof(JGetString(body, ""floor_height""));
      if (floorHeight != vars.floorHeight)
      {
        vars.floorHeight = floorHeight;
        vars.variablesUpdated = true;
      }

      int noMovementThreshold = atoi(JGetString(body, ""no_movement_threshold""));
      if (noMovementThreshold != vars.noMovementThreshold)
      {
        vars.noMovementThreshold = noMovementThreshold;
        vars.variablesUpdated = true;
      }

      char *liveStr = JGetString(body, ""live"");
      bool wasLive = vars.live;
      vars.live = (strcmp(liveStr, ""true"") == 0 || strcmp(liveStr, ""1"") == 0);
      if (vars.live && vars.live != wasLive)
      {
        // when the device becomes live, calibrate to the floor level given
        setBaselineFloor = true;
      }
      else if (vars.live != wasLive)
      {
        vars.variablesUpdated = true;
      }
      vars.alarmSent = false;
      updatePeriod = state.live ? LIVE_UPDATE_PERIOD : IDLE_UPDATE_PERIOD;

      serialDebugOut.printf(""\nBaseline Floor: %d\n"", vars.baselineFloor);
      serialDebugOut.print(""Floor Height: "");
      serialDebugOut.print(vars.floorHeight);
      serialDebugOut.printf(""\nMovement Threshold: %d\n"",
                            vars.noMovementThreshold);
      serialDebugOut.printf(""Live: %s\n\n"", vars.live ? ""true"" : ""false"");
    }
  }
  notecard.deleteResponse(rsp);
}

bool pollEnvVars()
{
  if (millis() < nextPollMs)
  {
    return false;
  }

  nextPollMs = millis() + (ENV_POLL_SECS * 1000);

  J *rsp = notecard.requestAndResponse(notecard.newRequest(""env.modified""));

  if (rsp == NULL)
  {
    return false;
  }

  uint32_t modifiedTime = JGetInt(rsp, ""time"");
  notecard.deleteResponse(rsp);
  if (lastModifiedTime == modifiedTime)
  {
    return false;
  }

  lastModifiedTime = modifiedTime;

  return true;
}

sensorReadings captureSensorReadings()
{
  sensorReadings readings;

  if (!bmp.performReading())
  {
    serialDebugOut.println(""Failed to perform reading from pressure sensor."");
  }
  readings.readingTimestamp = millis();
  readings.temp = bmp.temperature;
  readings.pressure = bmp.pressure / 100.0;

  if (setBaselineFloor)
  {
    state.baselineChanged = true;
    resetFloorFilter(state.baselineFloor);
    state.baselineFloorPressure = readings.pressure;
    state.lastFloor =
        state.baselineFloor; // forget about the previous floor since this isn't
                             // an actual change in floor/altitude
    state.lastFloorChangeAt = millis();
    state.alarmSent = false;
    setBaselineFloor = false;
    serialDebugOut.println(""Setting baseline floor / pressure"");
    serialDebugOut.print(""baseline floor: "");
    serialDebugOut.println(state.baselineFloor);
    serialDebugOut.print(""baseline pressure:"");
    serialDebugOut.print(state.baselineFloorPressure);
    serialDebugOut.println("" hPa"");
  }

  readings.altitude = bmp.readAltitude(state.baselineFloorPressure);
  readings.floor =
      ((readings.altitude / state.floorHeight)) + state.baselineFloor;

  readings.currentFloor = (int)(readings.floor + FLOOR_OFFSET);

  return readings;
}

void sendSensorReadings(const sensorReadings &readings, bool alarm)
{
  J *req = notecard.newRequest(""note.add"");
  if (req != NULL)
  {
    JAddBoolToObject(req, ""sync"", true);
    JAddStringToObject(req, ""file"", ""floor.qo"");
    J *body = JCreateObject();
    if (body != NULL)
    {
      JAddNumberToObject(body, ""floor"", readings.currentFloor);
      JAddNumberToObject(body, ""prevFloor"", state.lastFloor);
      JAddNumberToObject(body, ""altitude"", readings.altitude);
      JAddNumberToObject(body, ""pressure"", readings.pressure);
      JAddNumberToObject(body, ""temp"", readings.temp);
      JAddNumberToObject(body, ""direction"",
                         readings.currentFloor - state.lastFloor);
      JAddStringToObject(body, ""app"", ""nf1"");
      JAddItemToObject(req, ""body"", body);
      notecard.sendRequest(req);

      serialDebugOut.println(""Sending floor.qo"");
    }
  }

  if (alarm)
  {
    J *req = notecard.newRequest(""note.add"");
    if (req != NULL)
    {
      JAddBoolToObject(req, ""sync"", true);
      JAddStringToObject(req, ""file"", ""alarm.qo"");
      J *body = JCreateObject();
      if (body != NULL)
      {
        JAddBoolToObject(body, ""alarm"", true);
        JAddStringToObject(body, ""app"", ""nf1"");
        JAddItemToObject(req, ""body"", body);
        notecard.sendRequest(req);

        serialDebugOut.println(""Sending alarm.qo"");
      }
    }
  }
}

void displayReadings(const sensorReadings &readings)
{
  serialDebugOut.print(""Temperature = "");
  serialDebugOut.print(readings.temp);
  serialDebugOut.println("" *C"");

  serialDebugOut.print(""Pressure = "");
  serialDebugOut.print(readings.pressure);
  serialDebugOut.println("" hPa"");

  serialDebugOut.print(""Approx. Altitude = "");
  serialDebugOut.print(readings.altitude);
  serialDebugOut.println("" m"");

  serialDebugOut.print(""Previous Floor = "");
  serialDebugOut.println(state.lastFloor);

  serialDebugOut.print(""Floor = "");
  serialDebugOut.println(readings.currentFloor);

  serialDebugOut.print(""Floor = "");
  serialDebugOut.println(readings.floor);

  serialDebugOut.println();

#ifdef USE_DISPLAY
  display.clearDisplay();
  display.setCursor(0, 0);
  display.print(""Press. "");
  display.println(readings.pressure);
  display.print(""Alt.   "");
  display.println(readings.altitude);
  display.print(""Floor: "");
  display.print(readings.currentFloor);
  display.display();
#endif
}

void NoteUserAgentUpdate(J *ua) {
    JAddStringToObject(ua, ""app"", ""nf1"");
}

",filteredFloor
401,"/*
 *  layer.cpp
 *  
 *
 *  Created by <NAME> on Tue Sep 23 2003.
 *  Copyright (c) 2003 <NAME>. All rights reserved.
 *
 */

#include ""layer.h""

Layer::Layer(int _numNeurons, int _numInputs, double _learningRate, Function* _activationFunction) 
    : numNeurons(_numNeurons), numInputs(_numInputs), learningRate(_learningRate),
      activationFunction(_activationFunction)
{
    /** Create weight matrix according to the number of neurons specified */
    /**
     * The number of ""destination neurons"" determine the number of rows
     * whereas the number of sources determine the number of columns.
     * Hagan 2-10
     */
    /* randomize weights matrix at this point? */
    randomizeWeights();
}

/** Layer destructor cleans up any allocation messes we've created manually.
 * The destructor needs to delete at least the weightMatrix that was allocated
 * by the constructor.
 */
Layer::~Layer()
{

}

/** randomizeWeights() : Pseudorandomly generate weights and initialize
 * weightMatrix and biases vector.
 */
int Layer::randomizeWeights()
{
    vector<double> row;
    
    for (int i = 0; i < numNeurons; i++) {
        for (int j = 0; j < numInputs; j++) {
            double randnum = (double)(rand()/((double)(10.0*(RAND_MAX + 1))));
            // cout << ""Random num: "" << randnum << endl;
            row.push_back(randnum);
        }
        weightMatrix.push_back(row);
        row.clear(); // Clear the temporary row holder for generation of next row

        double randbias = (double)(rand()/((double)(10.0*(RAND_MAX + 1))));
        biases.push_back(randbias);
    }

    return 0;
}

/** setLearningRate(...): Set a new learning rate for this layer
 */
int Layer::setLearningRate(double  [MASK] )
{
    learningRate =  [MASK] ;   
    return 0;
}

int Layer::setMomentum(double newMomentum)
{
    return 0;
}

/** forwardPropagate(...): Propagate an input forward through the
 * layer using weightMatrix.
 */ 
vector<double> Layer::forwardPropagate(vector<double> inputVec)
{
    /** Forward propagation of input through network
    *  a^{0} = p
    *  a^{m+1} = f^{m+1}(W^{m+1}a^{m} + b^{m+1}) for m = 0, 1, ..., M - 1
    * a = a^{M}
    */

    int inputLen = inputVec.size();
    currentInput = inputVec; 

    double result = 0.0;

#ifdef DEBUG
    cout << ""input vector: "";
    for (int i = 0; i < inputVec.size(); i++) {
        cout << inputVec[i] << "" "";
    }
    cout << endl;
#endif

    nValues.clear();
    outputValues.clear(); // Erase any junk because we're propagating something new
    for (int i = 0; i < numNeurons; i++) {
        
        result = 0.0;
        
        for (int j = 0; j < inputLen; j++) {
            result += inputVec[j]*weightMatrix[i][j];
        }
        result += biases[i]; //weightMatrix[i][inputLen - 1];
                             // Add in the bias, each neuron has a separate bias
        nValues.push_back(result);
        //cout << ""Result: "" << result << "" "";
        result = activationFunction->evaluate(result);
        //cout << ""Evaluated result: "" << result << endl;
        outputValues.push_back(result);
    }

#ifdef DEBUG
    cout << ""layer output vector: [ "";
    for (int i =0 ; i < numNeurons; i++) {
        cout << outputValues[i] << "" "";
    }
    cout << "" ] "" << endl;
#endif
    return outputValues;  // Return the output values but there is still an
                          // internal copy so we won't have to recompute
}

/** backPropoagate: propagate sensitivities backward through the network.
 *
 */
vector<double> Layer::backPropagate(vector<double> nextLayerWgtSenProd)
{
    int outputlen = outputValues.size();
    
    if (outputlen == 0) {
        cerr << ""Layer::backPropagate() : no sensitivities to backpropagation."" << endl;
        abort();
    } else if (outputlen != numNeurons) {
        cerr << ""Layer::backPropagate() : output vector length does not correspond""
             << "" to number of neurons in the layer."" << endl;
        abort();
    }

    sensitivities.clear(); /* We are calculating fresh sensitivities so
                              hopefully there
                              is no stale data. */

    vector<double> row;
    vector<double> weightMatrixSensitivityProd;
                             /* The matrix-vector product of the present layer's
                                weight matrix and current layer's sensitivity is
                                what the previous layer really needs for
                                backpropagation. */
    int numInputs = weightMatrix.size();
    double dotprod = 0.0;    /* An element of the product of Jacobian for this
                                layer and the weight matrix and sensitivity
                                vector for the next layer over */
    
    
    /** Open code for sensitivity propagation
     * The sensitivity vector s is a # of neurons x 1 vector
     * the weightMatrix W is a # of neurons x # inputs matrix
     * The Jacobian F is a #input x #inputs square matrix
     * The sensitivity of this layer is s = F*W^T*s^(next layer)
     * Consequently, the dimensions of the resulting sensitivity
     * vector is also #neurons x 1.
     * To compute the sensitivity vector of the current layer,
     * iterate through the #neurons and then the #inputs
     * taking the dot products of the next layer sensitivity
     * vector and the matrix product of the Jacobian and
     * transposed weightMatrix. 
     */
    for (int i = 0; i < numInputs; i++) {
        dotprod = 0.0;
        //cout << ""Propagating sensitivity"" << endl;
        for (int j = 0; j < numNeurons; j++) {
            dotprod += (activationFunction->evalDeriv(nValues[i]) *
                                nextLayerWgtSenProd[j]);
            //cout << dotprod << "" "";
            
        }
        //cout << endl; 
        sensitivities.push_back(dotprod);
    }

    
    
    /* dotprod is now an element in the product of this layer's weight matrix
        and this layer's sensitivities */
    for (int i = 0; i < numInputs; i++) {
        dotprod = 0.0;
        for (int j = 0; j <  numNeurons; j++) {
            dotprod += weightMatrix[j][i] * sensitivities[j];
        }
        weightMatrixSensitivityProd.push_back(dotprod);
    }

    updateWeights();    


    
    return weightMatrixSensitivityProd;
}

/** backPropagateError(...): Last layer propagates error via s = -2F(n)(t-a)
 * During the operation of the neural net, this function should only be called
 * once per backpropagation. The bulk of the backpropagation should be handled
 * by the main backPropagation function that deals with all the layers except
 * the last layer. This backPropagateError function handles the last layer
 * where there are no sensitivities in a following layer to propagate. 
 */
vector<double> Layer::backPropagateError(vector<double> targets)
{
    int targetlen = targets.size();

    if (targetlen != numNeurons) {
        cerr << ""Layer::backPropagateError() : target vector length and number of neurons mismatch""
             << endl;
        abort();
    }
    
    sensitivities.clear();

    cout << ""backPropagateError.nValues: [ "";
    for (int i = 0; i < nValues.size(); i++) {
        cout << nValues[i] << "" "";
    }
    cout << "" ] "" << endl;
    
    cout << ""backPropagateError.outputValues: [ "";
    for (int i = 0; i < outputValues.size(); i++) {
        cout << outputValues[i] << "" "";
    }
    cout << "" ] "" << endl;

    cout << ""backPropagateError.targets: [ "";
    for (int i = 0; i < targets.size(); i++) {
        cout << targets[i] << "" "";
    }
    cout << "" ] "" << endl;    
//    cout << ""end sensitivities"" << endl;
    for (int i = 0; i < numNeurons; i++) {
        double newsensitivity =
          -2.0 * (activationFunction->evalDeriv(nValues[i]) *
                                        (targets[i] - outputValues[i]));
        // cout << ""new sensitivity "" << i << "" "" << newsensitivity << "" "";
        sensitivities.push_back(newsensitivity);
    }

    

    vector<double> weightMatrixSensitivityProd;
    double dotprod = 0.0;
    
    /* dotprod is now an element in the product of this layer's weight matrix
        and this layer's sensitivities */
    for (int i = 0; i < numInputs; i++) {
        dotprod = 0.0;
        for (int j = 0; j <  numNeurons; j++) {
            dotprod += weightMatrix[j][i] * sensitivities[j];
        }
        weightMatrixSensitivityProd.push_back(dotprod);
    }

    cout << ""Product: [ "";
    for (int i = 0; i < weightMatrixSensitivityProd.size(); i++) {
        cout << weightMatrixSensitivityProd[i] << "" "";
    }
    cout << "" ] "" << endl;
    
    updateWeights();
    
    return weightMatrixSensitivityProd;
}

/** updateWeights(...): Helper function for backPropagation. Update the weights
 *  using approximate gradient descent.
 */
int Layer::updateWeights()
{
    //cout << ""Old and new weights "" << endl;
    for (int i = 0; i < numNeurons; i++) {
        for (int j = 0; j < numInputs; j++) {
            /* Use gradient descent to compute new weightMatrix entry */
            //cout << weightMatrix[i][j] << "" "";
            weightMatrix[i][j] =
               weightMatrix[i][j] - learningRate *
                                      sensitivities[i] * currentInput[j];

            //cout << weightMatrix[i][j] << "" "";
        }
        /* Use gradient descent to compute new bias */
        //cout << endl << ""Biases: "" << biases[i] << "" "";
        biases[i] = biases[i] - learningRate * sensitivities[i];
        //cout << endl << ""New Bias: "" << biases[i] << "" "";
    }
    //cout << endl;
    return 0;
}
            ",newLearningRate
402,"#include ""cpu/attention.h""
#include ""cpu/math_utils.h""

#include <cassert>


Tensor Attention<BackendType::CPU>::forward(
        const Tensor& input, const Tensor& rope_cost, const Tensor& rope_sint,
        int start_pos, bool mask, Tensor* residual) {
    int batch = input.shape()[0];
    int seqlen = input.shape()[1];
    if (_cachek.shape().empty()) {
        _cachek = Tensor({batch, _maxlen, _dim});
        _cachev = Tensor({batch, _maxlen, _dim});
    }

    Tensor xq({batch, seqlen, _dim});

    for (int b = 0; b < batch; b++) {
        for (int i = 0; i < seqlen; i++) {
            for (int j = 0; j < _dim; j++) {
                float valk = 0;
                float valv = 0;
                float valq = 0;
                for (int k = 0; k < _dim; k++) {
                    valk += input(b, i, k) * _wk(j, k);
                    valv += input(b, i, k) * _wv(j, k);
                    valq += input(b, i, k) * _wq(j, k);
                }
                _cachek.set(valk, b, start_pos + i, j);
                _cachev.set(valv, b, start_pos + i, j);
                xq.set(valq, b, i, j);
            }
        }
    }

    apply_rotary_emb<BackendType::CPU>(&xq, &_cachek, rope_cost, rope_sint, start_pos, seqlen);

    int totlen = start_pos + seqlen;
    float  [MASK]  = std::sqrt(_head_dim);
    std::vector<std::vector<Tensor>> score(batch);
    for (int b = 0; b < batch; b++) {
        for (int h = 0; h < _num_heads; h++) {
            score[b].push_back(Tensor({seqlen, totlen}));
            score[b].back().zero();
            int fill = totlen;
            if (mask) {
                fill = start_pos;
            }
            for (int i = 0;  i < seqlen; i++) {
                if (mask) {
                    fill++;
                    if (fill > totlen) {
                        fill = totlen;
                    }
                }
                float sum = 0;
                for (int j = 0; j < fill; j++) {
                    float tmp = 0;
                    int ptrq = h *_head_dim;
                    int ptrk = h * _head_dim;
                    for (int k = 0; k < _head_dim; k++, ptrk++, ptrq++) {
                        tmp += xq(b, i, ptrq) * _cachek(b, j, ptrk);
                    }
                    tmp = std::exp(tmp /  [MASK] );
                    score[b][h].set(tmp, i, j);
                    sum += tmp;
                }
                for (int j = fill; j < totlen; j++) {
                    score[b][h].set(0, i, j);
                }
                for (int j = 0; j < fill; j++) {
                    score[b][h].set(score[b][h](i, j) / sum, i, j);
                }
            }
        }
    }

    std::vector<std::vector<Tensor>> output(batch);
    for (int b = 0; b < batch; b++) {
        for (int h = 0; h < _num_heads; h++) {
            output[b].push_back(Tensor({seqlen, _head_dim}));
            output[b].back().zero();
            for (int k = 0; k < totlen; k++) {
                for (int i = 0; i < seqlen; i++) {
                    for (int j = 0, ptrv=_head_dim*h; j < _head_dim; j++, ptrv++) {
                        output[b][h].add(score[b][h](i, k) * _cachev(b, k, ptrv), i, j);
                    }
                }
            }
        }
    }

    Tensor result({batch, seqlen, _dim});
    result.zero();
    for (int b = 0; b < batch; b++) {
        for (int l = 0;  l < seqlen; l++) {
            for (int i = 0; i < _dim; i++) {
                int ptr = 0;
                for (int h = 0; h < _num_heads; h++) {
                    for (int j = 0; j < _head_dim; j++, ptr++) {
                        result.add(_wo(i, ptr) * output[b][h](l, j), b, l, i);
                    }
                }
                if (residual) {
                    result.add((*residual)(b, l, i), b, l, i);
                }
            }
        }
    }
    return result;
}
",scale
403,"#include <iostream>
#include <thread>
#include <vector>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>
#include <string.h>
#include <string>
#include <unistd.h>
#include <chrono>
#include <poll.h>
#include <mutex>
#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <stdint.h>

#include ""main.h""
#include ""dgalutility.h""


namespace {
	std::mutex processingLock;
	std::mutex sendingLock;
	std::mutex nodesLock;
}

//Will return true on success, false on failure.
bool setUpListening(int &listenSocket, const char* port){
	struct addrinfo *info, hints;
	memset(&hints, 0, sizeof(struct addrinfo));
	hints.ai_family = AF_INET6;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;
	getaddrinfo(NULL, port, &hints, &info);

	listenSocket = socket(info->ai_family, info->ai_socktype, info->ai_protocol);
	//Ensure we don't tie up the addr and port combination after exit
	int  [MASK]  = 1;
	setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, & [MASK] , sizeof( [MASK] ));
	//Turn off ipv6 only so that we can listen for both v4 and v6 on the same socket
	 [MASK]  = 0;
	setsockopt(listenSocket, SOL_SOCKET, IPV6_V6ONLY, & [MASK] , sizeof( [MASK] ));


	if(listenSocket == -1){
		std::cerr << ""Error listening: "" << errno << "" "" << strerror(errno) << std::endl;
		return false;
	}

	if(bind(listenSocket, info->ai_addr, info->ai_addrlen) != 0){
		std::cerr << ""Error binding to port "" << port << "": "" << errno << "" "" << strerror(errno) << std::endl;
		return false;
	}

	if(listen(listenSocket, 10) != 0){
		std::cerr << ""Error listening "" << errno << "" "" << strerror(errno) << std::endl;
		return false;
	}

	return true;
}

void processMessages(processingArgContainer pC, std::queue<std::pair<int, std::string> >& sendingQueue){
	while(true){
		if(pC.socketsToProcess.size() != 0){
			processingLock.lock();
			int fd = pC.socketsToProcess.front();
			pC.socketsToProcess.pop();
			std::shared_ptr<dgalNode> node = pC.nodesToProcess.front();
			pC.nodesToProcess.pop();
			processingLock.unlock();

			//Create buffer to read in message type as well as size information
			char buf[sizeof(uint8_t) + sizeof(uint64_t)];
			memset(buf, 0, sizeof(buf));
			int res = recv(fd, buf, sizeof(buf), MSG_DONTWAIT);

			if(res > 0){
				uint8_t type = (uint8_t) buf[0]; //No endian worry here only 1 byte


				uint64_t convert;
				memcpy(&convert, &buf[1], sizeof(uint64_t));

				uint64_t length = dgal::ntohll(convert); //Convert to host endianness

				if(type == dgal::HEARTBEAT){
					//Heart beat recieved
					node->recievedHeartBeat();
					std::cout << ""Recieved heart beat from "" << fd << std::endl;
				}else if(type == dgal::BESTMESSAGE){
					//Recieving serialized individuals
					std::cout << ""Recieving population from "" << fd << std::endl;

					//TODO: Add some safety barriers around allocating huge space
					std::string message(length, 0);
					res = recv(fd, &message[0], length, MSG_DONTWAIT);

					if(res > 0 && (uint64_t) res == length){
						//Recieve bests message, schedule to send out to the rest
						sendingLock.lock();
						sendingQueue.push(std::make_pair(fd, message));
						sendingLock.unlock();
					}else{
						std::cerr << ""Error reading message from socket! Supplied size wrong!"" << std::endl;
					}

				}else{
					//Stream error terminate connection
					std::cerr << ""Recieved non conforming message shutting down socket"" << std::endl;
					shutdown(fd, SHUT_RDWR);
				}
			}else if(res == 0){
				//Disconnect
				shutdown(fd, SHUT_RDWR);
			}else if(res == -1){
				//Error reading
				if(errno != EAGAIN){
					std::cerr << ""Error reading socket "" << fd << "": "" << errno << "" "" << strerror(errno) << std::endl;
				}
			}

			processingLock.lock();
			//Release this socket fd to be allowed to be added back into the queue
			pC.queuedSockets.erase(fd);
			processingLock.unlock();
		}
	}
}

/**
 * Thread to process messages that should be sent out to the nodes in the netework
 * @param nodes        list of nodes
 * @param sendingQueue queue that is added to from processMessages when it recieves a list of a nodes bests
 */
void sendMessages(std::unordered_map<int, std::shared_ptr<dgalNode> >& nodes, std::queue<std::pair<int, std::string> >& sendingQueue){
	while(true){
		if(sendingQueue.empty() == false){
			sendingLock.lock();
			std::pair<int, std::string> sendOut = std::move(sendingQueue.front());
			sendingQueue.pop();
			sendingLock.unlock();

			int dontSendTo = sendOut.first;
			std::string message = std::move(sendOut.second);

			std::vector<int> sendToFds;
			std::vector<std::shared_ptr<dgalNode> > sendToNodes;

			//Get a list of all the nodes first so that we aren't holding a lock while possibly on a blocking send call
			nodesLock.lock();
			for(auto itr = nodes.begin(), end = nodes.end(); itr != end; itr++){
				sendToFds.push_back(itr->first);
				sendToNodes.push_back(itr->second);
			}
			nodesLock.unlock();


			//Form the proper character buffer to send out
			uint64_t messageSize = message.length();
			uint64_t networkMessageSize = dgal::htonll(messageSize);

			std::string sendBuffer(sizeof(uint8_t) + sizeof(uint64_t), 0);

			sendBuffer[0] = dgal::BESTMESSAGE;
			memcpy(&sendBuffer[1], &networkMessageSize, sizeof(uint64_t));
			sendBuffer += message;

			//Send to all nodes except the one that sent this message
			for(size_t i = 0; i < sendToFds.size(); i++){
				if(sendToFds[i] == dontSendTo){
					continue;
				}

				send(sendToFds[i], sendBuffer.data(), sendBuffer.size(), 0);
			}

		}
	}
}


void socketWatch(const int listenSocket, std::unordered_map<int, std::shared_ptr<dgalNode> >& nodes){
	std::vector<struct pollfd> socketsToPoll;
	struct pollfd listeningPollFD;

	const short lookForEvents = POLLIN | POLLPRI;

	listeningPollFD.fd = listenSocket;
	listeningPollFD.events = lookForEvents;

	socketsToPoll.push_back(listeningPollFD);

	std::queue<int> socketsToProcess;
	std::queue<std::shared_ptr<dgalNode> > nodesToProcess;
	std::unordered_set<int> queuedSockets;

	
	processingArgContainer args(socketsToProcess, nodesToProcess, queuedSockets);


	std::queue<std::pair<int, std::string> > sendingQueue;


	size_t numThreads = std::thread::hardware_concurrency();
	if(numThreads == 0){
		std::cerr << ""Could not determine number of threads to use. Defaulting to 2"" << std::endl;
		numThreads = 1;
	}else{
		//Take one off to account for this thread
		numThreads--;
	}

	std::vector<std::thread> processingThreads;

	for(size_t i = 0; i < numThreads; i++){
		processingThreads.push_back(std::thread(processMessages, args, std::ref(sendingQueue)));
	}

	std::thread sendingThread(sendMessages, std::ref(nodes), std::ref(sendingQueue));

	while(true){
		//Wait a maximum of 30 seconds if no response than we either have no nodes or they all disconnected
		int res = poll(socketsToPoll.data(), socketsToPoll.size(), 3000);

		if(res > 0){
			//FIXME: Problem when all nodes close socket connection at end, goes through POLLERR 22
			//Only happens when all nodes finished simulation, not if connection is closed before end of sim.
			for(unsigned int i = 0; i < socketsToPoll.size(); i++){
				if(socketsToPoll[i].revents == 0){
					continue;
				}


				if(socketsToPoll[i].fd == listenSocket){
					//We are accepting new connections
					struct pollfd newPollWatch;
					newPollWatch.fd = handleNewConnections(listenSocket, nodes);
					newPollWatch.events = lookForEvents;
					socketsToPoll.push_back(newPollWatch);
					continue;
				}


				bool foundNode = false;
				std::shared_ptr<dgalNode> node;
				nodesLock.lock();
				if(nodes.count(socketsToPoll[i].fd) != 0){
					foundNode = true;
					node = nodes[socketsToPoll[i].fd];
				}
				nodesLock.unlock();


				if(foundNode == false){
					std::cerr << ""Cannot find node for socket "" << socketsToPoll[i].fd << std::endl;
					shutdown(socketsToPoll[i].fd, SHUT_RDWR);
					close(socketsToPoll[i].fd);
					socketsToPoll.erase(socketsToPoll.begin()+i);
					continue;
				}

				if(socketsToPoll[i].revents & POLLERR){
					std::cerr << ""POLLERR "" << errno << "" "" << strerror(errno) << std::endl;
				}else if(socketsToPoll[i].revents & POLLHUP || socketsToPoll[i].revents & POLLRDHUP){
					close(socketsToPoll[i].fd);
					nodesLock.lock();
					nodes.erase(socketsToPoll[i].fd);
					nodesLock.unlock();
					socketsToPoll.erase(socketsToPoll.begin() + i);
				}else if(socketsToPoll[i].revents & POLLIN){
					if(queuedSockets.count(socketsToPoll[i].fd) == 1){
						//we already have processing lined up for this node
						continue;
					}
					processingLock.lock();
					socketsToProcess.push(socketsToPoll[i].fd);
					nodesToProcess.push(node);
					queuedSockets.insert(socketsToPoll[i].fd);
					processingLock.unlock();
				}

			}
		}
	}

	for(size_t i = 0; i < processingThreads.size(); i++){
		processingThreads[i].join();
	}
	sendingThread.join();
}


int handleNewConnections(const int listenSocket, std::unordered_map<int, std::shared_ptr<dgalNode> >& nodes){
	struct sockaddr_storage clientInfo;
	int clientSocket;
	socklen_t sockStoreSize = sizeof(struct sockaddr_storage);

	//Accept new connections and add them to the nodes list
	clientSocket = accept(listenSocket, (struct sockaddr *) &clientInfo, &sockStoreSize);
	if(clientSocket == -1){
		std::cerr << ""Error accepting "" << errno << "" "" << strerror(errno) << std::endl;
		return -1;
	}

	std::shared_ptr<dgalNode> newClientNode(new dgalNode(clientSocket, ""test"", 2));
	nodesLock.lock();
	nodes.insert(std::make_pair(clientSocket, newClientNode));
	nodesLock.unlock();

	return clientSocket;
}



int main(int argc, char *argv[]){
	std::string port;
	if(argc > 1){
		port = argv[1];
	}else{
		port = ""25665"";
	}

	int listeningSocket;
	std::unordered_map<int, std::shared_ptr<dgalNode> > nodes;

	if(setUpListening(listeningSocket, port.c_str()) == false){
		return 1;
	}

	socketWatch(listeningSocket, nodes);


	return 0;
}
",optval
404,"/**********************************
 * FILE NAME: MP1Node.cpp
 *
 * DESCRIPTION: Membership protocol run by this Node.
 * 				Definition of MP1Node class functions.
 **********************************/

#include ""MP1Node.h""

/*
 * Note: You can change/add any functions in MP1Node.{h,cpp}
 */

/**
 * Overloaded Constructor of the MP1Node class
 * You can add new members to the class if you think it
 * is necessary for your logic to work
 */
MP1Node::MP1Node(Member *member, Params *params, EmulNet *emul, Log *log, Address *address) {
	for( int i = 0; i < 6; i++ ) {
		NULLADDR[i] = 0;
	}
	this->memberNode = member;
	this->emulNet = emul;
	this->log = log;
	this->par = params;
	this->memberNode->addr = *address;
}

/**
 * Destructor of the MP1Node class
 */
MP1Node::~MP1Node() {}

/**
 * FUNCTION NAME: recvLoop
 *
 * DESCRIPTION: This function receives message from the network and pushes into the queue
 * 				This function is called by a node to receive messages currently waiting for it
 */
int MP1Node::recvLoop() {
    if ( memberNode->bFailed ) {
    	return false;
    }
    else {
    	return emulNet->ENrecv(&(memberNode->addr), enqueueWrapper, NULL, 1, &(memberNode->mp1q));
    }
}

/**
 * FUNCTION NAME: enqueueWrapper
 *
 * DESCRIPTION: Enqueue the message from Emulnet into the queue
 */
int MP1Node::enqueueWrapper(void *env, char *buff, int size) {
	Queue q;
	return q.enqueue((queue<q_elt> *)env, (void *)buff, size);
}

/**
 * FUNCTION NAME: nodeStart
 *
 * DESCRIPTION: This function bootstraps the node
 * 				All initializations routines for a member.
 * 				Called by the application layer.
 */
void MP1Node::nodeStart(char *servaddrstr, short servport) {
    Address joinaddr;
    joinaddr = getJoinAddress();

    // Self booting routines
    if( initThisNode(&joinaddr) == -1 ) {
#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, ""init_thisnode failed. Exit."");
#endif
        exit(1);
    }

    if( !introduceSelfToGroup(&joinaddr) ) {
        finishUpThisNode();
#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, ""Unable to join self to group. Exiting."");
#endif
        exit(1);
    }

    return;
}

/**
 * FUNCTION NAME: initThisNode
 *
 * DESCRIPTION: Find out who I am and start up
 */
int MP1Node::initThisNode(Address *joinaddr) {
	/*
	 * This function is partially implemented and may require changes
	 */
	int id = *(int*)(&memberNode->addr.addr);
	int port = *(short*)(&memberNode->addr.addr[4]);

	memberNode->bFailed = false;
	memberNode->inited = true;
	memberNode->inGroup = false;
    // node is up!
	memberNode->nnb = 0;
	memberNode->heartbeat = 0;
	memberNode->pingCounter = TFAIL;
	memberNode->timeOutCounter = -1;
    initMemberListTable(memberNode);

    return 0;
}

/**
 * FUNCTION NAME: introduceSelfToGroup
 *
 * DESCRIPTION: Join the distributed system
 */
int MP1Node::introduceSelfToGroup(Address *joinaddr) {
	MessageHdr *msg;
#ifdef DEBUGLOG
    static char s[1024];
#endif

    // Add yourself to your own memlist.
    seedMemList();

    if ( 0 == memcmp((char *)&(memberNode->addr.addr), (char *)&(joinaddr->addr), sizeof(memberNode->addr.addr))) {
        // I am the group booter (first process to join the group). Boot up the group
#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, ""Starting up group..."");
#endif
        memberNode->inGroup = true;
    }
    else {
        size_t msgsize = sizeof(MessageHdr) + sizeof(joinaddr->addr) + sizeof(long) + 1;
        msg = (MessageHdr *) malloc(msgsize * sizeof(char));

        // create JOINREQ message: format of data is {struct Address myaddr}
        msg->msgType = JOINREQ;
        memcpy((char *)(msg+1), &memberNode->addr.addr, sizeof(memberNode->addr.addr));
        memcpy((char *)(msg+1) + 1 + sizeof(memberNode->addr.addr), &memberNode->heartbeat, sizeof(long));

#ifdef DEBUGLOG
        sprintf(s, ""Trying to join..."");
        log->LOG(&memberNode->addr, s);
#endif

        // send JOINREQ message to introducer member
        emulNet->ENsend(&memberNode->addr, joinaddr, (char *)msg, msgsize);

        free(msg);
    }

    return 1;

}

void MP1Node::seedMemList(){
    int id = 0;
    short port;
    memcpy(&id, &memberNode->addr.addr[0], sizeof(int));
    memcpy(&port, &memberNode->addr.addr[4], sizeof(short));
    this->memberNode->memberList.push_back(MemberListEntry(id, port, memberNode->heartbeat, memberNode->heartbeat));
}

void MP1Node::updateMemList(){

}

/**
 * FUNCTION NAME: recvCallBack
 *
 * DESCRIPTION: Message handler for different message types
 */
bool MP1Node::recvCallBack(void *env, char *data, int size ) {
//    MessageHdr* msg = (MessageHdr*) data;
//    Address* add = (Address*)((char*)(msg) + 1);
//    long* ts = (long*)((char*)(add) + 1);
//
//    this->printAddress(add);
//    cout << msg->msgType << "";"" << *ts << endl;

    MessageHdr* res = (MessageHdr*)(data);
    switch(res->msgType) {
        case JOINREQ: {
            joinReqHandler(env, data, size);
            break;
        }
        case JOINREP: {
            joinRepHandler(env, data, size);
            break;
        }
        case GOSSIP: {
            joinGossipHandler(env, data, size);
            break;
        }
        default: {

        }
    }
}

bool MP1Node::joinReqHandler(void *env, char *data, int size) {
    JoinReqMsg* res = (JoinReqMsg*)(data);

    // add yourself to my membership list
    int id = 0;
    short port;
    memcpy(&id, &res->addr.addr[0], sizeof(int));
    memcpy(&port, &res->addr.addr[4], sizeof(short));
    this->memberNode->memberList.push_back(MemberListEntry(id, port, res->ts, memberNode->heartbeat));
    ++this->memberNode->nnb;

    log->logNodeAdd(&memberNode->addr, &res->addr);

    // send a response message with current membership table.
    size_t msgsize = sizeof(MessageHdr) + sizeof(int) + (sizeof(MemberListEntry)*memberNode->memberList.size()) + 1;
    JoinRepMsg* msg = (JoinRepMsg*) malloc(msgsize * sizeof(char));
    msg->msg.msgType = JOINREP;
    msg->len = this->memberNode->nnb;
    memcpy((char *)(msg+1), memberNode->memberList.data(), (sizeof(MemberListEntry)*memberNode->memberList.size()));
    emulNet->ENsend(&memberNode->addr, &res->addr, (char *)msg, msgsize);

    return true;
}

bool MP1Node::joinRepHandler(void *env, char *data, int size) {
    JoinRepMsg* res = (JoinRepMsg*)(data);
    MemberListEntry* mem = (MemberListEntry*)(res + 1);
    updateNeighborList(mem, res->len);
    memberNode->inGroup = true;

    return true;
}

bool MP1Node::joinGossipHandler(void *env, char *data, int size) {
    GossipMsg* res = (GossipMsg*)(data);
    MemberListEntry* mem = (MemberListEntry*)(res + 1);
    updateNeighborList(mem, res->len);

    return true;
}

void MP1Node::updateNeighborList(MemberListEntry* mem, int n) {
    vector<MemberListEntry> newList;

    // update my own list and timestamps
    for(int i=0; i<n; ++i) {
        bool found = false;
        for(int j=0; j<memberNode->memberList.size(); ++j) {
            if(memberNode->memberList[j].id == mem[i].id) {
                // found member, update it if it has higher heartbeat
                if(mem[i].heartbeat > memberNode->memberList[j].heartbeat) {
                    memberNode->memberList[j].settimestamp(memberNode->heartbeat);
                    memberNode->memberList[j].setheartbeat(mem[i].heartbeat);
                }
                found = true;
                break;
            }
        }

        if (!found) {
            MemberListEntry entry = mem[i];
            entry.settimestamp(memberNode->heartbeat);
            newList.push_back(entry);
        }
    }

    for (int i = 0; i < newList.size(); ++i) {
        memberNode->memberList.push_back(newList[i]);
        memberNode->nnb++;

        Address entryAddr;
        memset(&entryAddr, 0, sizeof(Address));
        *(int *)(&entryAddr.addr) = newList[i].id;
        *(short *)(&entryAddr.addr[4]) = newList[i].port;
        log->logNodeAdd(&memberNode->addr, &entryAddr);
    }
}

/**
 * FUNCTION NAME: finishUpThisNode
 *
 * DESCRIPTION: Wind up this node and clean up state
 */
int MP1Node::finishUpThisNode(){
   /*
    * Your code goes here
    */
}

/**
 * FUNCTION NAME: nodeLoop
 *
 * DESCRIPTION: Executed periodically at each member
 * 				Check your messages in queue and perform membership protocol duties
 */
void MP1Node::nodeLoop() {
    if (memberNode->bFailed) {
    	return;
    }

    // Check my messages
    checkMessages();

    // Wait until you're in the group...
    if( !memberNode->inGroup ) {
    	return;
    }

    // ...then jump in and share your responsibilites!
    nodeLoopOps();
    return;
}

/**
 * FUNCTION NAME: checkMessages
 *
 * DESCRIPTION: Check messages in the queue and call the respective message handler
 */
void MP1Node::checkMessages() {
    void *ptr;
    int size;

    // Pop waiting messages from memberNode's mp1q
    while ( !memberNode->mp1q.empty() ) {
    	ptr = memberNode->mp1q.front().elt;
    	size = memberNode->mp1q.front().size;
    	memberNode->mp1q.pop();
    	recvCallBack((void *)memberNode, (char *)ptr, size);
    }
    return;
}

/**
 * FUNCTION NAME: nodeLoopOps
 *
 * DESCRIPTION: Check if any node hasn't responded within a timeout period and then delete
 * 				the nodes
 * 				Propagate your membership list
 */
void MP1Node::nodeLoopOps() {
    memberNode->heartbeat++;

    int id = 0;
    memcpy(&id, &this->memberNode->addr.addr[0], sizeof(int));
//    cout << memberNode->heartbeat << "": my id: "" << id << "", nbs: "";
//    for(int i=0; i<memberNode->memberList.size(); ++i) {
//        cout << memberNode->memberList[i].id << "";"" << memberNode->memberList[i].heartbeat << "";"" << memberNode->memberList[i].timestamp << "","";
//    }
//    cout << endl;

	// set my own heartbeat in message.
    memberNode->memberList[0].settimestamp(memberNode->heartbeat);
    memberNode->memberList[0].setheartbeat(memberNode->heartbeat);

    // check any pre-fail members and remove them (for now)
    vector<MemberListEntry>  [MASK]  = removePreFailMembers();

    // pick a node at random to send out to.
    int n = 0;
    if( [MASK] .size() > 1) {
        n = ((rand() % ( [MASK] .size() - 1)) + 1);
    }

    Address sendAddr;
    memset(&sendAddr, 0, sizeof(Address));
    *(int *)(&sendAddr.addr) =  [MASK] [n].id;
    *(short *)(&sendAddr.addr[4]) =  [MASK] [n].port;

    int id2 = 0;
    memcpy(&id2, & [MASK] [n].id, sizeof(int));
//    cout << ""Sending from: "" << id << "" to "" << id2 << endl;


    // send it out to other nodes.
    size_t msgsize = sizeof(MessageHdr) + sizeof(int) + (sizeof(MemberListEntry)* [MASK] .size()) + 1;
    GossipMsg* msg = (GossipMsg*) malloc(msgsize * sizeof(char));
    msg->msg.msgType = GOSSIP;
    msg->len =  [MASK] .size();
    memcpy((char *)(msg+1),  [MASK] .data(), (sizeof(MemberListEntry)* [MASK] .size()));
    emulNet->ENsend(&memberNode->addr, &sendAddr, (char *)msg, msgsize);
    return;
}

vector<MemberListEntry> MP1Node::removePreFailMembers() {
    vector<MemberListEntry> res;

    // Find the filtered list, if they've not responded in TFAIL seconds
    for (vector<MemberListEntry>::iterator it = memberNode->memberList.begin(); it != memberNode->memberList.end(); /* no increment */) {
        if(memberNode->heartbeat - it->timestamp > TREMOVE) {
//            cout << ""ENTERED;"" << it->timestamp << "";"" << memberNode->heartbeat << endl;

            Address remAddr;
            memset(&remAddr, 0, sizeof(Address));
            *(int *)(&remAddr.addr) = it->id;
            *(short *)(&remAddr.addr[4]) = it->port;
            log->logNodeRemove(&memberNode->addr, &remAddr);

            memberNode->nnb--;
            it = memberNode->memberList.erase(it);
        } else if(memberNode->heartbeat - it->timestamp > TFAIL) {
                // mark as pre-fail in set, and stop sending it out.
            ++it;
        } else {
            res.push_back(*it);
            ++it;
        }
    }
    return res;
}

/**
 * FUNCTION NAME: isNullAddress
 *
 * DESCRIPTION: Function checks if the address is NULL
 */
int MP1Node::isNullAddress(Address *addr) {
	return (memcmp(addr->addr, NULLADDR, 6) == 0 ? 1 : 0);
}

/**
 * FUNCTION NAME: getJoinAddress
 *
 * DESCRIPTION: Returns the Address of the coordinator
 */
Address MP1Node::getJoinAddress() {
    Address joinaddr;

    memset(&joinaddr, 0, sizeof(Address));
    *(int *)(&joinaddr.addr) = 1;
    *(short *)(&joinaddr.addr[4]) = 0;

    return joinaddr;
}

/**
 * FUNCTION NAME: initMemberListTable
 *
 * DESCRIPTION: Initialize the membership list
 */
void MP1Node::initMemberListTable(Member *memberNode) {
	memberNode->memberList.clear();
}

/**
 * FUNCTION NAME: printAddress
 *
 * DESCRIPTION: Print the Address
 */
void MP1Node::printAddress(Address *addr)
{
    printf(""%d.%d.%d.%d:%d \n"",  addr->addr[0],addr->addr[1],addr->addr[2],
                                                       addr->addr[3], *(short*)&addr->addr[4]) ;
}
",gList
405,"#include <Windows.h>
#include <stdio.h>
#include <iostream>
#include <TlHelp32.h>

#include <conio.h>



#define SE_DELEGATE_SESSION_USER_IMPERSONATE_NAME TEXT(""SeDelegateSessionUserImpersonatePrivilege"")
bool EnableDebugPrivilege()
{
    HANDLE hToken;
    LUID sedebugnameValue;
    TOKEN_PRIVILEGES tkp;
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
    {
        return   FALSE;
    }
    if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &sedebugnameValue))
    {
        CloseHandle(hToken);
        return false;
    }
    tkp.PrivilegeCount = 1;
    tkp.Privileges[0].Luid = sedebugnameValue;
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL))
    {
        CloseHandle(hToken);
        return false;
    }
    return true;
}



BOOL SetPrivilege(
    HANDLE hToken,          // access token handle
    LPCTSTR lpszPrivilege,  // name of privilege to enable/disable
    BOOL bEnablePrivilege   // to enable or disable privilege
)
{
    TOKEN_PRIVILEGES tp;
    LUID luid;

    

    if (!LookupPrivilegeValue(
        NULL,            // lookup privilege on local system
        lpszPrivilege,   // privilege to lookup 
        &luid))        // receives LUID of privilege
    {
        printf(""LookupPrivilegeValue error: %u\n"", GetLastError());
        return FALSE;
    }

    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    if (bEnablePrivilege)
        tp.Privileges[0].Attributes = SE_PRIVILEGE_REMOVED;
    else
        tp.Privileges[0].Attributes = SE_PRIVILEGE_REMOVED;


    if (!AdjustTokenPrivileges(
        hToken,
        FALSE,
        &tp,
        sizeof(TOKEN_PRIVILEGES),
        (PTOKEN_PRIVILEGES)NULL,
        (PDWORD)NULL))
    {
        printf(""AdjustTokenPrivileges error: %u\n"", GetLastError());
        return FALSE;
    }

    if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)

    {
        printf(""The token does not have the specified privilege. \n"");
        return FALSE;
    }

    return TRUE;
}


int main()
{
    LUID sedebugnameValue;
    EnableDebugPrivilege();

    

    
    int pid;
    std::cin >> pid;


    printf(""PID %d\n"", pid);
    


    
    HANDLE phandle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);

    if (phandle != INVALID_HANDLE_VALUE) {

        printf(""[*] Opened Target Handle\n"");
    }
    else {
        printf(""[-] Failed to open Process Handle\n"");
    }

   

    HANDLE ptoken;

    BOOL token = OpenProcessToken(phandle, TOKEN_ALL_ACCESS, &ptoken);

    if (token) {
        printf(""[*] Opened Target Token Handle\n"");
    }
    else {
        printf(""[-] Failed to open Token Handle\n"");
    }

    LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &sedebugnameValue);


    TOKEN_PRIVILEGES tkp;

    tkp.PrivilegeCount = 1;
    tkp.Privileges[0].Luid = sedebugnameValue;
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

    if (!AdjustTokenPrivileges(ptoken, FALSE, &tkp, sizeof(tkp), NULL, NULL)) {

        printf(""[-] Failed to Adjust Token's Privileges\n"");
        
    }



    // ALL PRIV
    printf(""[*]Removing All privileges\n"");
    SetPrivilege(ptoken, SE_CREATE_TOKEN_NAME, TRUE);
    SetPrivilege(ptoken, SE_ASSIGNPRIMARYTOKEN_NAME, TRUE);
    SetPrivilege(ptoken, SE_LOCK_MEMORY_NAME, TRUE);
    SetPrivilege(ptoken, SE_INCREASE_QUOTA_NAME, TRUE);
    SetPrivilege(ptoken, SE_UNSOLICITED_INPUT_NAME, TRUE);
    SetPrivilege(ptoken, SE_MACHINE_ACCOUNT_NAME, TRUE);
    SetPrivilege(ptoken, SE_TCB_NAME, TRUE);
    SetPrivilege(ptoken, SE_SECURITY_NAME, TRUE);
    SetPrivilege(ptoken, SE_TAKE_OWNERSHIP_NAME, TRUE);
    SetPrivilege(ptoken, SE_LOAD_DRIVER_NAME, TRUE);
    SetPrivilege(ptoken, SE_SYSTEM_PROFILE_NAME, TRUE);
    SetPrivilege(ptoken, SE_SYSTEMTIME_NAME, TRUE);
    SetPrivilege(ptoken, SE_PROF_SINGLE_PROCESS_NAME, TRUE);
    SetPrivilege(ptoken, SE_INC_BASE_PRIORITY_NAME, TRUE);
    SetPrivilege(ptoken, SE_CREATE_PAGEFILE_NAME, TRUE);
    SetPrivilege(ptoken, SE_CREATE_PERMANENT_NAME, TRUE);
    SetPrivilege(ptoken, SE_BACKUP_NAME, TRUE);
    SetPrivilege(ptoken, SE_RESTORE_NAME, TRUE);
    SetPrivilege(ptoken, SE_SHUTDOWN_NAME, TRUE);
    SetPrivilege(ptoken, SE_DEBUG_NAME, TRUE);
    SetPrivilege(ptoken, SE_AUDIT_NAME, TRUE);
    SetPrivilege(ptoken, SE_SYSTEM_ENVIRONMENT_NAME, TRUE);
    SetPrivilege(ptoken, SE_CHANGE_NOTIFY_NAME, TRUE);
    SetPrivilege(ptoken, SE_REMOTE_SHUTDOWN_NAME, TRUE);
    SetPrivilege(ptoken, SE_UNDOCK_NAME, TRUE);
    SetPrivilege(ptoken, SE_SYNC_AGENT_NAME, TRUE);
    SetPrivilege(ptoken, SE_ENABLE_DELEGATION_NAME, TRUE);
    SetPrivilege(ptoken, SE_MANAGE_VOLUME_NAME, TRUE);
    SetPrivilege(ptoken, SE_IMPERSONATE_NAME, TRUE);
    SetPrivilege(ptoken, SE_CREATE_GLOBAL_NAME, TRUE);
    SetPrivilege(ptoken, SE_TRUSTED_CREDMAN_ACCESS_NAME, TRUE);
    SetPrivilege(ptoken, SE_RELABEL_NAME, TRUE);
    SetPrivilege(ptoken, SE_INC_WORKING_SET_NAME, TRUE);
    SetPrivilege(ptoken, SE_TIME_ZONE_NAME, TRUE);
    SetPrivilege(ptoken, SE_CREATE_SYMBOLIC_LINK_NAME, TRUE);
    SetPrivilege(ptoken, SE_DELEGATE_SESSION_USER_IMPERSONATE_NAME, TRUE);


    printf(""[*]  All Privileges are removed\n"");


    DWORD integrityLevel = SECURITY_MANDATORY_UNTRUSTED_RID;


    SID integrityLevelSid{};
    integrityLevelSid.Revision = SID_REVISION;
    integrityLevelSid.SubAuthorityCount = 1;
    integrityLevelSid.IdentifierAuthority.Value[5] = 16;
    integrityLevelSid.SubAuthority[0] = integrityLevel;

    TOKEN_MANDATORY_LABEL  [MASK]  = {};
     [MASK] .Label.Attributes = SE_GROUP_INTEGRITY;
     [MASK] .Label.Sid = &integrityLevelSid;

    if (!SetTokenInformation(
        ptoken,
        TokenIntegrityLevel,
        & [MASK] ,
        sizeof(TOKEN_MANDATORY_LABEL) + GetLengthSid(&integrityLevelSid)))
    {
        printf(""SetTokenInformation failed\n"");
    }
    else {

        printf(""[*] Token Integrity set to Untrusted\n"");
    }

    CloseHandle(ptoken);
    CloseHandle(phandle);


    system(""PAUSE"");
    return 0;
}
",tokenIntegrityLevel
406,"/*
 * Copyright (C) 2012-2013 <NAME>, ASL, ETH Zurich, Switzerland
 * You can contact the author at <slynen at ethz dot ch>
 * Copyright (C) 2011-2012 <NAME>, ASL, ETH Zurich, Switzerland
 * You can contact the author at <stephan dot weiss at ieee dot org>
 *
 * 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 AGL_SENSORHANDLER_HPP_
#define AGL_SENSORHANDLER_HPP_
#include <msf_core/msf_types.h>
#include <msf_core/eigen_utils.h>
#include <msf_core/gps_conversion.h>


namespace msf_agl_sensor {
template<typename MEASUREMENT_TYPE, typename MANAGER_TYPE>
AglSensorHandler<MEASUREMENT_TYPE, MANAGER_TYPE>::AglSensorHandler(
    MANAGER_TYPE& meas, std::string topic_namespace,
    std::string parameternamespace)
    : SensorHandler<msf_updates::EKFState>(meas, topic_namespace,
                                           parameternamespace),
      n_zp_(0.01),
      delay_(0),
      timestamp_previous_pose_(0)
      {
  ros::NodeHandle pnh(""~/agl_sensor"");
  pnh.param(""agl_use_fixed_covariance"", use_fixed_covariance_, false);
  pnh.param(""agl_absolute_measurements"", provides_absolute_measurements_,
            false);

  MSF_INFO_STREAM_COND(use_fixed_covariance_, ""Agl sensor is using fixed ""
                       ""covariance"");
  MSF_INFO_STREAM_COND(!use_fixed_covariance_, ""Agl sensor is using ""
                       ""covariance from sensor"");

  MSF_INFO_STREAM_COND(provides_absolute_measurements_, ""Agl sensor is ""
                       ""handling measurements as absolute values"");
  MSF_INFO_STREAM_COND(!provides_absolute_measurements_, ""Agl sensor is ""
                       ""handling measurements as relative values"");

  ros::NodeHandle nh(""msf_updates"");

  subAgl_ =
      nh.subscribe<sensor_msgs::Range>
  (""agl_input"", 20, &AglSensorHandler::MeasurementCallback, this);


  z_p_.setZero();

}
  static bool referenceinit = false;  //TODO (slynen): Dynreconf reset reference.

template<typename MEASUREMENT_TYPE, typename MANAGER_TYPE>
void AglSensorHandler<MEASUREMENT_TYPE, MANAGER_TYPE>::SetNoises(
    double n_zp) {
  n_zp_ = n_zp;
}

template<typename MEASUREMENT_TYPE, typename MANAGER_TYPE>
void AglSensorHandler<MEASUREMENT_TYPE, MANAGER_TYPE>::SetDelay(
    double delay) {
  delay_ = delay;
}

template<typename MEASUREMENT_TYPE, typename MANAGER_TYPE>
void AglSensorHandler<MEASUREMENT_TYPE, MANAGER_TYPE>::ProcessAglMeasurement(
    const sensor_msgs::RangeConstPtr& msg) {
  received_first_measurement_ = true;

  // Get the fixed states.
  int fixedstates = 0;
  

  shared_ptr < MEASUREMENT_TYPE
      > meas(
          new MEASUREMENT_TYPE(n_zp_, use_fixed_covariance_,
                               provides_absolute_measurements_, this->sensorID,
                               fixedstates));

  meas->MakeFromSensorReading(msg, msg->header.stamp.toSec() - delay_);

  z_p_ = meas->z_p_;  // Store this for the init procedure.

  this->manager_.msf_core_->AddMeasurement(meas);
}




template<typename MEASUREMENT_TYPE, typename MANAGER_TYPE>
void AglSensorHandler<MEASUREMENT_TYPE, MANAGER_TYPE>::MeasurementCallback(
    const sensor_msgs::RangeConstPtr & msg) {
  this->SequenceWatchDog(msg->header.seq, subAgl_.getTopic());

  MSF_INFO_STREAM_ONCE(
      ""*** agl sensor got first measurement from topic ""
          << this->topic_namespace_ << ""/"" << subAgl_.getTopic()
          << "" ***"");
  double time_now = msg->header.stamp.toSec();
  timestamp_previous_pose_ = time_now;

  sensor_msgs::RangePtr  [MASK] (
      new sensor_msgs::Range);
   [MASK] ->header = msg->header;
   [MASK] ->range = msg->range;

  ProcessAglMeasurement( [MASK] );
}





}  // namespace msf_agl_sensor
#endif  // AGL_SENSORHANDLER_HPP_
",rangemsg
407,"//DYNINST_ROOT = /home/liuweijie/ShadowGuard/thirdparty/dyninst-10.1.0/install
//CFLAGS = -g -O2 -std=c++11
//INC = -I$(DYNINST_ROOT)/include
//LIB = -L$(DYNINST_ROOT)/lib 
//DEP = -linstructionAPI -lelf -ldynDwarf -ldw -lelf -ldynElf -lcommon -lboost_system
//testget: get_instruction_details.cpp
//	g++ $(CFLAGS) $(INC) $(LIB) $< -o $@ $(DEP)
//clean:
//	rm -f testget

#include ""Instruction.h""
#include ""InstructionDecoder.h""
#include ""Register.h""
#include ""Expression.h""

using namespace std;
using namespace Dyninst;
using namespace Dyninst::InstructionAPI;

std::string convertRegSet(std::set<RegisterAST::Ptr> &regs) {
    vector<string>  [MASK] ;
    for (auto r : regs)
         [MASK] .push_back(r->format());
    string ret;
    for (auto s :  [MASK] ) ret += s + "" "";
    return ret;
}

std::string convertExpressionSet(std::set<Expression::Ptr> &exprs) {
    vector<string> exprStr;
    for (auto e : exprs)
        exprStr.push_back(e->format());
    string ret;
    for (auto s : exprStr) ret += s + "" "";
    return ret;
}

int main(int argc, char **argv) {
    unsigned char buf[] = {0xf2, 0x0f, 0x10, 0x05, 0x0f, 0x80, 0x09, 0x00};
    InstructionDecoder dec(buf, sizeof(buf), Arch_x86_64);

    Instruction insn = dec.decode();
    printf(""%s\n"", insn.format().c_str());
    
    printf(""\tInstruction length: %u\n"", insn.size());
    std::set<RegisterAST::Ptr> regsWritten;
    insn.getWriteSet(regsWritten);
    printf(""\tRegister written: %s\n"", convertRegSet(regsWritten).c_str()); 
    std::set<RegisterAST::Ptr> regsRead;
    insn.getReadSet(regsRead);
    printf(""\tRegister read: %s\n"", convertRegSet(regsRead).c_str()); 
    printf(""\tReads memory: %d\n"", insn.readsMemory());
    printf(""\tWrites memory: %d\n"", insn.writesMemory());
        
    std::set<Expression::Ptr> memAccessors;
    insn.getMemoryReadOperands(memAccessors);
    printf(""\tgetMemoryReadOperands: %s\n"", convertExpressionSet(memAccessors).c_str());

    memAccessors.clear();
    insn.getMemoryWriteOperands(memAccessors);
    printf(""\tgetMemoryWriteOperands: %s\n"", convertExpressionSet(memAccessors).c_str());

    string cft;
    if (insn.getControlFlowTarget()) cft = insn.getControlFlowTarget()->format();
    printf(""\tgetControlFlowTarget: %s\n"", cft.c_str());
    printf(""\tallowsFallThrough: %d\n"", insn.allowsFallThrough());
    printf(""\tisValid: %d\n"", insn.isValid());
    printf(""\tisLegalInsn: %d\n"", insn.isLegalInsn());
    printf(""\tgetCategory: %d\n"", insn.getCategory());
    
    vector<Operand> operands;
    insn.getOperands(operands);

    printf(""\tOperands count %d\n"", operands.size());
    for (auto op : operands) {
        printf(""\t\top size %d\n"", op.getValue()->size());
        printf(""\t\top expression format %s\n"", op.getValue()->format().c_str());

        regsRead.clear();
        op.getReadSet(regsRead);
        printf(""\t\top register read: %s\n"", convertRegSet(regsRead).c_str());

        regsWritten.clear();
        op.getWriteSet(regsWritten);
        printf(""\t\top register written: %s\n"", convertRegSet(regsWritten).c_str());
        printf(""\t\top isRead: %d\n"", op.isRead());
        printf(""\t\top isWritten: %d\n"", op.isWritten());
        printf(""\t\top isImplicit: %d\n"", op.isImplicit());
        printf(""\t\top readsMemory: %d\n"", op.readsMemory());
        printf(""\t\top writesMemory: %d\n"", op.writesMemory());
    }
}
",regStr
408,"//*****************************************************************************
//
//	Copyright 2015 Microsoft Corporation
//
//	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 ""pch.h""
#include ""App.h""
#include ""MainPage.h""

using namespace winrt;
using namespace winrt::MediaPlayerCPP::implementation;
using namespace winrt::Windows::ApplicationModel;
using namespace winrt::Windows::ApplicationModel::Activation;
using namespace winrt::Windows::Foundation;
using namespace winrt::Windows::UI::Xaml;
using namespace winrt::Windows::UI::Xaml::Controls;
using namespace winrt::Windows::UI::Xaml::Navigation;
using namespace winrt::Windows::Storage;
using namespace FFmpegInterop;

/// <summary>
/// Initializes the singleton application object.  This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
/// </summary>
App::App()
{
	InitializeComponent();
	Suspending({ this, &App::OnSuspending });

	(void) FFmpegInteropLogging::Log({ &App::Log });

#if defined _DEBUG && !defined DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION
	UnhandledException([this](IInspectable const&, UnhandledExceptionEventArgs const& e)
		{
			if (IsDebuggerPresent())
			{
				auto errorMessage = e.Message();
				__debugbreak();
			}
		});
#endif
}

void App::Log(const IInspectable&, const LogEventArgs& args)
{
	OutputDebugString(args.Message().c_str());
}

/// <summary>
/// Invoked when the application is launched normally by the end user.  Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name=""args"">Details about the launch request and process.</param>
void App::OnLaunched(const LaunchActivatedEventArgs& args)
{
	if (!args.PrelaunchActivated())
	{
		InitRootFrame();
	}
}

void App::OnFileActivated(const FileActivatedEventArgs& args)
{
	auto  [MASK] { args.Files() };
	if ( [MASK] .Size() > 0)
	{
		InitRootFrame();

		Frame rootFrame{ Window::Current().Content().as<Frame>() };
		MediaPlayerCPP::MainPage mainPage{ rootFrame.Content().as<MediaPlayerCPP::MainPage>() };

		mainPage.OnFileActivated( [MASK] .GetAt(0).as<StorageFile>());
	}
}

void App::InitRootFrame()
{
	Frame rootFrame{ Window::Current().Content().as<Frame>() };

	// Do not repeat app initialization when the Window already has content,
	// just ensure that the window is active
	if (rootFrame == nullptr)
	{
		// Create a Frame to act as the navigation context and associate it with
		// a SuspensionManager key
		rootFrame = Frame();

		rootFrame.NavigationFailed({ this, &App::OnNavigationFailed });

		// Place the frame in the current Window
		Window::Current().Content(rootFrame);
	}

	if (rootFrame.Content() == nullptr)
	{
		// When the navigation stack isn't restored navigate to the first page,
		// configuring the new page by passing required information as a navigation
		// parameter
		rootFrame.Navigate(xaml_typename<MediaPlayerCPP::MainPage>());
	}

	// Ensure the current window is active
	Window::Current().Activate();
}

/// <summary>
/// Invoked when application execution is being suspended.  Application state is saved
/// without knowing whether the application will be terminated or resumed with the contents
/// of memory still intact.
/// </summary>
/// <param name=""sender"">The source of the suspend request.</param>
/// <param name=""args"">Details about the suspend request.</param>
void App::OnSuspending(const IInspectable&, const SuspendingEventArgs&)
{
	// Save application state and stop any background activity
}

/// <summary>
/// Invoked when Navigation to a certain page fails
/// </summary>
/// <param name=""sender"">The Frame which failed navigation</param>
/// <param name=""args"">Details about the navigation failure</param>
void App::OnNavigationFailed(const IInspectable&, const NavigationFailedEventArgs& args)
{
	throw hresult_error(E_FAIL, hstring(L""Failed to load Page "") + args.SourcePageType().Name);
}
",files
409,"/*
 * Copyright (c) 2024 Huawei Device Co., Ltd.
 * 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 ""telephony_call_ffi.h""
#include ""telephony_call_impl.h""

using namespace OHOS::FFI;

namespace OHOS {
namespace Telephony {
extern ""C"" {
    bool FfiOHOSTelephonyCallIsRinging(int32_t *errCode)
    {
        return TelephonyCallImpl::IsRinging(errCode);
    }

    char* FfiOHOSTelephonyCallFormatPhoneNumberToE164(char *cPhoneNumber, char *cCountryCode, int32_t *errCode)
    {
        return TelephonyCallImpl::FormatPhoneNumberToE164(cPhoneNumber, cCountryCode, errCode);
    }

    int32_t FfiOHOSTelephonyCallMakeCall(char* number)
    {
        return TelephonyCallImpl::MakeCall(number);
    }

    bool FfiOHOSTelephonyCallIsEmergencyPhoneNumber(char* phoneNumber, int32_t slotId, int32_t* errCode)
    {
        return TelephonyCallImpl::IsEmergencyPhoneNumber(phoneNumber, slotId, errCode);
    }

    bool FfiOHOSTelephonyCallHasCall()
    {
        return TelephonyCallImpl::HasCall();
    }

    int32_t FfiOHOSTelephonyCallGetCallState()
    {
        return TelephonyCallImpl::GetCallState();
    }

    void FfiOHOSTelephonyCallInit()
    {
        return TelephonyCallImpl::Init();
    }

    int32_t FfiOHOSTelephonyCallDialCall(char *phoneNumber, DialCallOptions  [MASK] )
    {
        return TelephonyCallImpl::DialCall(phoneNumber,  [MASK] );
    }

    bool FfiOHOSTelephonyCallHasVoiceCapability()
    {
        return TelephonyCallImpl::HasVoiceCapability();
    }

    char* FfiOHOSTelephonyCallFormatPhoneNumber(char *phoneNumber, char *countryCode, int32_t *errCode)
    {
        return TelephonyCallImpl::FormatPhoneNumber(phoneNumber, countryCode, errCode);
    }
}
}  // namespace Telephony
}  // namespace OHOS
",options
410,"#include ""raylib.h""
#include ""random""
#include ""time.h""
#include <iostream>
#include <string>
#include <vector>

int Clamp(float num, float min, float max) 
{
    if (num > max) {
        return max;
    }
    if (num < min) {
        return min;
    }
    return num;
}

int main() {
    const int screenWidth = 1600;
    const int  [MASK]  = 1000;
    bool RenderFPS = false;


    InitWindow(screenWidth,  [MASK] , ""Raylib Camera Example"");

    Texture2D txt = LoadTexture(""images/parrot.png"");

    typedef struct {
        int x;
        int y;
    } Rock;

    std::vector<Rock> table(556);

    Camera2D cam = { 0 };
    cam.target = { screenWidth / 2.0f,  [MASK]  / 2.0f };
    cam.offset = { screenWidth / 2.0f,  [MASK]  / 2.0f };
    cam.zoom = 1.0f;  
    cam.rotation = 0.0f; 

    float x = 0;
    float timer = 0;
    float y = 500;


    SetTargetFPS(60);
    bool yea = true;
    int Speed = 500;


    while (!WindowShouldClose() && yea) {
        HideCursor();
        float deltaTime = GetFrameTime();

        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(0,  [MASK] );
        int random_number = dis(gen);

        if (IsKeyDown(KEY_W)) {
            y -= Speed * deltaTime;
        }
        if (IsKeyDown(KEY_S)) {
            y += Speed * deltaTime;
        }
        if (IsKeyPressed(KEY_F1)) {
            RenderFPS = !RenderFPS;
        }

        timer += 1;
        if (timer > 10) {
            timer = 0;
            Speed += 1;
            Rock temp = {screenWidth, random_number};
            table.push_back(temp);
        }

        BeginDrawing();
        ClearBackground(RAYWHITE);


        BeginMode2D(cam);

        if (y > 1000.0f) {
            y = 1000.0f;
        };
        if (y < 0.0f) {
            y = 0.0f;
        };

        Rectangle imgRect = {x, y, (float)txt.width * 0.5f, (float)txt.height * 0.5f};
        DrawTextureEx(txt, {x, y}, 0.0f, 0.5f, WHITE);

        if (RenderFPS) {
            DrawFPS(50, 100);
        }

        for (size_t i = 0; i < table.size(); i++) {
            Rock& thing = table[i]; 

            thing.x -= 10;

           
            Rectangle rockRect = { (float)thing.x, (float)thing.y, 50.0f, 50.0f };
            if (CheckCollisionRecs(rockRect, imgRect)) {
              
                yea = false;
                break;
                table.erase(table.begin() + i);
                i--; 
            }

            if (thing.x >= screenWidth) {
                table.erase(table.begin() + i);
                i--;  
            }
        }

        for (size_t i = 0; i < table.size(); i++) {
            Rock thing = table[i];
            DrawRectangle(thing.x, thing.y, 50, 50, RED);
        }

    
        EndMode2D();

        EndDrawing();
    }

    UnloadTexture(txt);
    CloseWindow();

    return 0;
}
",screenHeight
411,"#include <EQLNES_SDCard.h>
#include <Arduino.h>
#include <SdFat.h>
#include <String.h>

void EQLNES_SDCard::begin()
{
    _sd.begin(_csPin, SPI_FULL_SPEED);
}

bool EQLNES_SDCard::writeFile(char *filename, char *data)
{
    if (_file.open(filename, O_RDWR | O_CREAT | O_AT_END))
    {
        _file.println(data);
        _file.close();
        return true;
    }
    else
    {
        return false;
    }
}


bool EQLNES_SDCard::writeFile(char *filename, String data)
{
    if (_file.open(filename, O_RDWR | O_CREAT | O_AT_END))
    {
        _file.println(data);
        _file.close();
        return true;
    }
    else
    {
        return false;
    }
}

String EQLNES_SDCard::readFile(char *filename)
{
    char c;
    String  [MASK]  = """";
    if (_file.open(filename, O_READ))
    {
        while (_file.available())
        {
            c = _file.read();
             [MASK]  += c;
        }
        _file.close();
    }
    return  [MASK] ;
}",buffer
412,"#include ""Battle.h""

/**
* Default Constructor
*/

Battle::Battle() 
{

}


/**
* A new instance of a battle must have a pointer to the current players SharShip and the enemy being engaged
*
* @param *ship a pointer to the current player's StarShip
* @param *enemy a pointer to the PVEEntity currently being engaged
* @return constructor does not have a return type
* @see Battle::getIsWreckPVE
*/

Battle::Battle(StarShip *ship, PVEEntity *enemy)
{
    this->player = ship;
    this->enemy = enemy;

    if(this->enemy->getIsWreckPVE() == false)
    {
        cout <<  endl;
        cout << ""    +------------------------------------------------------------------------------------------+     "" << endl;
        cout << ""    | \033[40;31;1m                                   Battle Transmission                                  \033[0m |     "" << endl;
        cout << ""    +------------------------------------------------------------------------------------------+     "" << endl;
        cout << endl;
        cout << ""                            Incoming transmission from '\033[31;1m"" << enemy->getName() << ""\033[0m' ""  << endl;
        cout << ""                                          We are the Borg                                            "" << endl;
        cout << ""                                      You will be assimilated                                        "" << endl;
        cout << ""             Your biological and technological distinctiveness will be added to our own              "" << endl;
        cout << ""                                       Resistance is futile.                                         "" << endl;
        cout <<  endl;
    }	                                                                                                          
}	


/**
* @return deconstructor does not have a return type
*/

Battle::~Battle() 
{
    // nothing on heap (stacked)
    // http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=/com.ibm.xlcpp8a.doc/language/ref/cplr380.htm
    // You can use a destructor explicitly to destroy objects, although this practice is not recommended.
    // However to destroy an object created with the placement new operator,

    // delete any stuff on the heap (stack is cleared automatically for us )

    cout << endl << ""     \033[36;2m~Deconstructing Battle\033[0m  "" << endl;
}	


/**
* Randomly Performs a enemy move
* returns if the enemy is destroyed
* only performs an action if the enemy have that type of weapon
* seedMicroPrecision decides the action of the switch
*
* @return void
*
* @see Battle::getIsWreckPVE
*
* @see Battle::Phaser
* @see Battle::Phased
* @see Battle::Pulse
* @see Battle::Transphasic
* @see Battle::Chroniton
* @see Battle::Gravimetric
* @see Battle::Spatial
* @see Battle::Tractor
*
* @see seedMicroPrecision
*
* @see PVEEntity::getHasLasers
* @see PVEEntity::getHasPhasedIonCannon
* @see PVEEntity::getHasPulseWeapon
* @see PVEEntity::getHasTransphasicTorpedos
* @see PVEEntity::getHasChronitonTorpedos
* @see PVEEntity::getHasGravimetricTorpedos
* @see PVEEntity::getHasSpatialTorpedos
* @see PVEEntity::getHasTractorLock
*
*/

void Battle::enemyMove()
{
    if(this->enemy->getIsWreckPVE())
        return;

    bool action = false;

    // random move enemy
    seedMicroPrecision();

    int move = 0;

    move = int((double(rand())/RAND_MAX)*7) + 1; // random between 1 & 8

    while(!action)
    {
        switch(move)
        {
            case 1:
                if(this->enemy->getHasLasers())
                {
                    this->Phaser(true);
                    action = true;
                }
                else
                {
                    seedMicroPrecision();
                    move = int((double(rand())/RAND_MAX)*7) + 1;
                }
                break;

            case 2:
                if(this->enemy->getHasPhasedIonCannon())
                {
                    this->Phased(true);
                    action = true;
                }
                else
                {
                    seedMicroPrecision();
                    move = int((double(rand())/RAND_MAX)*7) + 1;
                }
                break;

            case 3:
                if(this->enemy->getHasPulseWeapon())
                {
                    this->Pulse(true);
                    action = true;
                }
                else
                {
                    seedMicroPrecision();
                    move = int((double(rand())/RAND_MAX)*7) + 1;
                }
                break;

            case 4:
                if(this->enemy->getHasTransphasicTorpedos())
                {
                    this->Transphasic(true);
                    action = true;
                }
                else
                {
                    seedMicroPrecision();
                    move = int((double(rand())/RAND_MAX)*7) + 1;
                }
                break;

            case 5:
                if(this->enemy->getHasChronitonTorpedos())
                {
                    this->Chroniton(true);
                    action = true;
                }
                else
                {
                    seedMicroPrecision();
                    move = int((double(rand())/RAND_MAX)*7) + 1;
                }
                break;

            case 6:
                if(this->enemy->getHasGravimetricTorpedos())
                {
                    this->Gravimetric(true);
                    action = true;
                }
                else
                {
                    seedMicroPrecision();
                    move = int((double(rand())/RAND_MAX)*7) + 1;
                }
                break;

            case 7:
                if(this->enemy->getHasSpatialTorpedos())
                {
                    this->Spatial(true);
                    action = true;
                }
                else
                {
                    seedMicroPrecision();
                    move = int((double(rand())/RAND_MAX)*7) + 1;
                }
                break;

            case 8:
                this->Tractor(false, !this->enemy->getHasTractorLock());
                action = true;
                break;
        }
    }
}	


/**
* Updates the enemy or current players shield strength after an attacking action has occurred
* A certain amount of variability is is multiplied by the damage
*
* @param who true = player false = current enemy
* @param damage the damage to inflict on the player / enemy
*
* @return void
*
* @see Battle::getIsWreckPVE
* @see Battle::setArmour
*
* @see StarShip::getShieldStrenght
* @see StarShip::setShieldStrenght
*
* @see seedMicroPrecision
*
* @see PVEEntity::getShieldStrenght
* @see PVEEntity::setShieldStrenghtPVE
*
*/

void Battle::setShielding(bool who, int damage)
{
    // seed the random generator
    seedMicroPrecision();

    // multiple the damage by a random number
    int  [MASK]  = int((double(rand())/RAND_MAX)*75) + 50; // 50  - 125
    damage = (damage *  [MASK] ) / 100;

    int playerShields = this->player->getShieldStrenght();
    int enemyShields = this->enemy->getShieldStrenght();

    // get the damage for the enemy or the current player
    int shieldDamage = who ? (playerShields - damage) : (enemyShields - damage);

    // if the damage is greater than the shields left, set there shield strength to 0
    if(shieldDamage<=0)
    {
        if(who==true)
        {
            this->player->setShieldStrenght(0);
        }
        else
        {
            this->enemy->setShieldStrenghtPVE(0);
        }

        // the damage is greater the the shields left,
        // now starts decreasing the armour
        this->setArmour(who,damage);
        return;
    }

    cout << endl;

    // true player
    // set the players or enemys shield stright to the new value, indicate this to the user
    if(who==true)
    {
        this->player->setShieldStrenght(shieldDamage);
        cout << ""                   '\033[34;1m"" << this->enemy->getName() << ""\033[0m' hit your shileds inflicting '\033[31;1m"" << damage << ""\033[0m' damage"" << endl;
        cout << ""                   '\033[34;1m"" << this->player->getName() << ""'s\033[0m' shields are down to '\033[31;1m"" << this->player->getShieldStrenght() << ""\033[0m'"" << endl;
    }
    else
    {
        this->enemy->setShieldStrenghtPVE(shieldDamage);
        cout << ""                   '\033[34;1m"" << this->player->getName() << ""\033[0m' hit '\033[34;1m"" << this->enemy->getName() << ""\033[0m' inflicting "" << damage << "" damage"" << endl;
        cout << ""                   '\033[34;1m"" << this->enemy->getName() << ""'s\033[0m' shields are down to '\033[31;1m"" << this->enemy->getShieldStrenght() << ""\033[0m'"" << endl;
    }
}	


/**
* Updates the enemy or current players armour after an attacking action has occurred
*
* @param who true = player false = current enemy
* @param damage the damage to inflict on the player / enemy
*
* @return void
*
* @see Battle::setWreck
*
* @see StarShip::getArmour
* @see StarShip::setArmour
*
* @see PVEEntity::getRegenerativeAdaptivePlating
* @see PVEEntity::setArmourPVE
*
*/

void Battle::setArmour(bool who, int damage)
{
    int playerArmour = this->player->getArmour();
    int enemyArmour = this->enemy->getRegenerativeAdaptivePlating();

    // get the damage for the enemy or the current player
    int armourDamage = who ? (playerArmour - damage) : (enemyArmour - damage);

    // if the damage is greater than the players, enemies armour, they are destoryed
    if(armourDamage<=0)
    {
        this->setWreck(who);
        return;
    }

    cout << endl;

    // true player
    // update there player / enemies armour and indicate this to the user
    if(who==true)
    {
        this->player->setArmour(armourDamage);
        cout << ""                   '\033[34;1m"" << this->enemy->getName() << ""\033[0m' hit your armour inflicting '\033[31;1m"" << damage << ""\033[0m' damage"" << endl;
        cout << ""                   '\033[34;1m"" << this->player->getName() << ""'s\033[0m' amour is down to '\033[31;1m"" << this->player->getArmour() << ""\033[0m'"" << endl;
    }
    else
    {
        this->enemy->setArmourPVE(armourDamage);
        cout << ""                   '\033[34;1m"" << this->player->getName() << ""\033[0m' hit '\033[34;1m"" << this->enemy->getName() << ""\033[0m' inflicting '\033[31;1m"" << damage << ""\033[0m' damage"" << endl;
        cout << ""                   '\033[34;1m"" << this->enemy->getName() << ""'s\033[0m' armour is down to '\033[31;1m"" << this->enemy->getRegenerativeAdaptivePlating() << ""\033[0m'"" << endl;
    }
}	


/**
* Sets the enemy or the player as destroyed (wrecked)
* disabled an enemies tractor lock also, to avoid deadlock (player cant escape even though enemy has been destroyed)
*
* @param who true = player false = current enemy
*
* @return void
*
* @see StarShip::setWreck
*
* @see PVEEntity::setWreckPVE
* @see PVEEntity::setHasTractorLockPVE
*
*/

void Battle::setWreck(bool who)
{	
    cout << endl;
    // true player
    if(who==true)
    {
        this->player->setWreck();
        cout << ""                   '\033[31;1m"" << this->player->getName() << ""\033[0m' has been destroyed "" << endl << endl ;
    }
    else
    {
        this->enemy->setWreckPVE();
        this->enemy->setHasTractorLockPVE(false);
        cout << ""                   '\033[31;1m"" << this->enemy->getName() << ""\033[0m' has been destroyed "" << endl << endl;
    }
}	


/**
* enemy or the player fires phasers @ WHO
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Phaser(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""fired phasers at "");
    this->setShielding(who, LASER_DAMAGE);
}	


/**
* enemy or the player fires phased ion cannon @ WHO
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Phased(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""fired phased ion cannon at "");
    this->setShielding(who, PHASED_DAMAGE);
}	


/**
* enemy or the player fires pulse ion cannon @ WHO
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Pulse(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""fired pulse cannon at "");
    this->setShielding(who, PULSE_DAMAGE);
}	


/**
* enemy or the player fires photons @ WHO
* if its the player updates his amount of photons left
*
* @param who true = player false = current enemy
*
* @return void
*
* @see StarShip::getPhotons
* @see StarShip::setPhotons
* @see StarShip::getName
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Photon(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    if(this->player->getPhotons() > 0)
    {
        this->describeAction(who, ""launched photon torpedo at "");
        cout << ""                   '\033[31;1m"" << this->player->getName() << ""\033[0m' has "" << (this->player->getPhotons() - 1) << "" photon torpedos left"";
        this->player->setPhotons(this->player->getPhotons() - 1);
        this->setShielding(who, PHOTON_DAMAGE);
    }
    else
    {
        cout << ""                   '\033[31;1m"" << this->player->getName() << ""\033[0m' has 0 photon torpedos left"";
    }
}	


/**
* enemy or the player fires quantums @ WHO
* if its the player updates his amount of quantums left
*
* @param who true = player false = current enemy
*
* @return void
*
* @see StarShip::getQuantums
* @see StarShip::setQuantums
* @see StarShip::getName
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Quantum(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    if(this->player->getQuantums() > 0)
    {
        this->describeAction(who, ""launched quantum torpedo at "");
        cout << ""                   '\033[31;1m"" << this->player->getName() << ""\033[0m' has "" << (this->player->getQuantums() - 1) << "" quantum torpedos left"";
        this->player->setQuantums(this->player->getQuantums() - 1);
        this->setShielding(who, QUANTUM_DAMAGE);
    }
    else
    {
        cout << ""                   '\033[31;1m"" << this->player->getName() << ""\033[0m' has 0 quantum torpedos left"";
    }
}	


/**
* enemy or the player fires Transphasic torps @ WHO
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Transphasic(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""launched transphasic torpedo at "");
    this->setShielding(who, TRANSPHASIC_DAMAGE);
}	


/**
* enemy or the player fires chroniton torps @ WHO
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Chroniton(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""launched chroniton torpedo at "");
    this->setShielding(who, CHRONITON_DAMAGE);
}	


/**
* enemy or the player fires gravimetric torps @ WHO
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Gravimetric(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""launched gravimetric torpedo at "");
    this->setShielding(who, GRAVIMETRIC_DAMAGE);
}


/**
* enemy or the player fires spatial torps @ WHO
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Spatial(bool who)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""launched spatial torpedo at "");
    this->setShielding(who, SPATIAL_DAMAGE);
}	


/**
* initiates a tractor on player or enemy
*
* @param who true = player false = current enemy
*
* @return void
*
* @see Battle::describeAction
* @see Battle::setShielding
*
* @see StarShip::setHasTractorLock
* @see StarShip::getHasTractorLock
*
* @see PVEEntity::setHasTractorLockPVE
* @see PVEEntity::getIsWreckPVE
*
*/

void Battle::Tractor(bool who, bool tractor)
{
    if(this->enemy->getIsWreckPVE())
        return;

    this->describeAction(who, ""locked tractor beam on "");
    if(who==true)
    {
        this->player->setHasTractorLock(!this->player->getHasTractorLock());
    }
    else
    {
        this->enemy->setHasTractorLockPVE(tractor);
    }
}	


/**
* finds weather the enemy has a tractor on the player
*
* @return bool enemy has a tractor lock
*
* @see PVEEntity::getHasTractorLock
*
*/

bool Battle::enemyHasTractor()
{
    if(this->enemy->getHasTractorLock())
        return true;
    else
        return false;
}	


/**
* returns a pointer to the battles enemy
*
* @return PVEEntity* the enemy
*
*/

PVEEntity* Battle::getEnemy()
{
    return this->enemy;
}


/**
* returns the name of the current enemy
*
* @return string the enemies name
*
* @see PVEEntity::getName
*
*/

string Battle::getEnemyName()
{
    return this->enemy->getName();
}	


/**
* output the action of the attack event
*
* @param who true = player false = current enemy
* @param string string output
*
* @return void
*
* @see StarShip::getName
*
* @see PVEEntity::getName
*
*/

void Battle::describeAction(bool who, string action)
{
    string attacker = who ? this->enemy->getName() : this->player->getName();
    string victim = who ? this->player->getName() : this->enemy->getName();

    cout << endl;
    cout << ""                   '\033[31;1m"" << attacker << ""\033[0m' has "" << action << ""'\033[31;1m"" << victim << ""\033[0m'"" << endl;
}
",randdmg
413,"#include ""pch.h""
#include ""Input.h""
#include ""Application.h""

#include <GLFW/glfw3.h>

namespace Doge
{
	bool Input::IsKeyPressed(int keycode)
	{
		int state = glfwGetKey(Application::GetActiveWindow()->GetNativeWindow(), keycode);
		return state == GLFW_PRESS;
	}

	bool Input::IsKeyReleased(int keycode)
	{
		int state = glfwGetKey(Application::GetActiveWindow()->GetNativeWindow(), keycode);
		return state == GLFW_RELEASE;
	}

	bool Input::IsKeyRepeated(int keycode)
	{
		int state = glfwGetKey(Application::GetActiveWindow()->GetNativeWindow(), keycode);
		return state == GLFW_REPEAT;
	}

	bool Input::IsMouseButtonPressed(int button)
	{
		int state = glfwGetMouseButton(Application::GetActiveWindow()->GetNativeWindow(), button);
		return state == GLFW_PRESS;
	}

	std::pair<float, float> Input::GetMousePos()
	{
		double xpos,  [MASK] ;
		glfwGetCursorPos(Application::GetActiveWindow()->GetNativeWindow(), &xpos, & [MASK] );
		return { static_cast<float>(xpos), static_cast<float>( [MASK] ) };
	}
}",ypos
414,"#include ""MainScene.h""
#include ""SimpleAudioEngine.h""

USING_NS_CC;

Scene* MainScene::createScene()
{
    return MainScene::create();
}

// Print useful error message instead of segfaulting when files are not there.
static void problemLoading(const char* filename)
{
    printf(""Error while loading: %s\n"", filename);
    printf(""Depending on how you compiled you might have to add 'Resources/' in front of filenames in HelloWorldScene.cpp\n"");
}

void MainScene::drawBuilding()
{
	int x = 50;
	for (int i = 0; i < 20; i++) {
		//楼层线
		floor[i] = DrawNode::create();
		floor[i]->retain();
		floor[i]->drawSegment(Vec2(x, i * 45), Vec2(x + 700, i * 45), 1, Color4F::BLACK);
		//楼层号
		floorNumber[i] = Label::createWithSystemFont(String::createWithFormat(""%i"", i + 1)->getCString(), ""Arial"", 18);
		floorNumber[i]->retain();
		floorNumber[i]->setPosition(Vec2(10, i * 45 + 20));
		floorNumber[i]->setColor(Color3B::BLACK);
		//外部呼叫按钮
		floorButton[i][0] = ui::Button::create(""up.png"",""up_sel.png"",""up_sel.png"");
		floorButton[i][1] = ui::Button::create(""down.png"", ""down_sel.png"", ""down_sel.png"");
		floorButton[i][0]->setTag(i * 10);
		floorButton[i][1]->setTag(i * 10 + 1);
		floorButton[i][0]->setPosition(Vec2(floorButton[i][0]->getContentSize().width / 2 + 50,
			floorButton[i][0]->getContentSize().height / 2 + 25 + i * 45));
		floorButton[i][1]->setPosition(Vec2(floorButton[i][1]->getContentSize().width / 2 + 50,
			floorButton[i][1]->getContentSize().height / 2 + 5 + i * 45));
		//呼叫按钮回调函数
		floorButton[i][0]->addClickEventListener([&](Ref* sender) {
			ui::Button *m = (ui::Button *)sender;
			int flag = m->getTag();
			int order = flag % 10 == 1 ? -1 : 1;
			int floor = (flag / 10) + 1;
			m->setEnabled(false);
			Person *person = new Person(floor, order);
			es->callElevator(person);
		});
		floorButton[i][1]->addClickEventListener([&](Ref* sender) {
			ui::Button *m = (ui::Button *)sender;
			int flag = m->getTag();
			int order = flag % 10 == 1 ? -1 : 1;
			int floor = flag / 10 + 1;
			m->setEnabled(false);
			Person *person = new Person(floor, order);
			es->callElevator(person);
		});

		if(i != 19) this->addChild(floorButton[i][0]);
		else floorButton[i][0]->retain();
		if(i != 0) this->addChild(floorButton[i][1]);
		else floorButton[i][1]->retain();
		this->addChild(floorNumber[i]);
		this->addChild(floor[i]);
	}
}

void MainScene::drawElevatorState()
{
	for (int i = 0; i < 5; i++) {
		//电梯显示
		this->addChild(es->elevators[i]);
		es->elevators[i]->retain();
		for (int j = 0; j < 20; j++) {
			//电梯所在楼层
			elevatorNumber[i][j] = Label::createWithSystemFont(String::createWithFormat(""%i"", 1)->getCString(), ""Arial"", 16);
			elevatorNumber[i][j]->setPosition(Vec2(150 + i * 120, 20 + 45 * j));
			elevatorNumber[i][j]->setColor(Color3B::BLACK);
			//电梯向上运行时显示
			elevatorUP[i][j] = Sprite::create();
			elevatorUP[i][j]->initWithFile(""up_sel.png"");
			elevatorUP[i][j]->setPosition(Vec2(170 + i * 120, 20 + 45 * j));
			elevatorUP[i][j]->setVisible(false);
			//电梯向下运行时显示
			elevatorDOWN[i][j] = Sprite::create();
			elevatorDOWN[i][j]->initWithFile(""down_sel.png"");
			elevatorDOWN[i][j]->setPosition(Vec2(170 + i * 120, 20 + 45 * j));
			elevatorDOWN[i][j]->setVisible(false);

			this->addChild(elevatorUP[i][j]);
			this->addChild(elevatorDOWN[i][j]);
			this->addChild(elevatorNumber[i][j]);
		}
	}
}

void MainScene::drawElevator()
{
	for (int i = 0; i < 5; i++) {
		//添加背景板
		bg[i] = LayerColor::create(Color4B::BLACK, 200, 400);
		bg[i]->setPosition(Vec2(755 + i * 210, 250));
		addChild(bg[i]);
		//楼层显示器
		curentfFloor[i] = Label::createWithSystemFont(String::createWithFormat(""%i"", 1)->getCString(), ""Arial"", 60);
		curentfFloor[i]->setColor(Color3B::RED);
		curentfFloor[i]->setPosition(Vec2(800 + i * 210, 530));
		addChild(curentfFloor[i]);
		//运行状态显示器
		for (int j = 0; j < 2; j++) {
			elevatorState[i][j] = DrawNode::create();
			if (j == 0) elevatorState[i][j]->drawTriangle(Vec2(780 + i * 210, 460), Vec2(820 + i * 210, 460),
				Vec2(800 + i * 210, 490), Color4F::RED);
			else  elevatorState[i][j]->drawTriangle(Vec2(780 + i * 210, 440), Vec2(820 + i * 210, 440),
				Vec2(800 + i * 210, 410), Color4F::RED);
			elevatorState[i][j]->setVisible(false);
			this->addChild(elevatorState[i][j]);
		}
		//添加报警按钮
		warning[i] = ui::Button::create(""Warning.png"");
		warning[i]->setPosition(Vec2(840 + i * 210, 275));
		warning[i]->setTag(50 + i);
		warning[i]->addClickEventListener([&](Ref* sender) {
			ui::Button *b = (ui::Button*)sender;
			int tag = b->getTag();
			es->elevators[tag - 50]->hasBroken();
			b->setEnabled(false);
		});
		addChild(warning[i]);
		//添加开关门按钮
		for (int j = 0; j < 2; j++) {
			door[i][j] = ui::Button::create(String::createWithFormat(""door%i.png"", j + 1)->getCString());
			door[i][j]->setPosition(Vec2(780 + i * 210 + j * 30, 275));
			this->addChild(door[i][j]);
		}
		//添加楼层按钮
		for (int j = 0; j < 20 ; j++) {
			floors[i][j] = ui::Button::create(String::createWithFormat(""elevator%i.png"", j + 1)->getCString(),
				String::createWithFormat(""light%i.png"", j + 1)->getCString(),
				String::createWithFormat(""light%i.png"", j + 1)->getCString());
			int x = j / 10;
			int y = j % 10;
			floors[i][j]->setPosition(Vec2(875 + i * 210 + x * 35, 275 + y * 35));
			floors[i][j]->setTag((i + 1) * 100 + j + 1);
			//楼层按钮回调函数
			floors[i][j]->addClickEventListener([&](Ref* sender) {
				ui::Button *b = (ui::Button*)sender;
				int tag = b->getTag();
				int floor = tag % 100;
				int number = tag / 100 - 1;
				if (!es->elevators[number]->getIsBroken()) {
					b->setEnabled(false);
					es->elevators[number]->elevatorLock.lock();
					es->elevators[number]->addArriveList(new Person(floor));
					es->elevators[number]->elevatorLock.unlock();
				}
			});
			addChild(floors[i][j]);
		}
	}
}

bool MainScene::init()
{
    if (!Scene::init() )
    {
        return false;
    }
	auto  [MASK]  = LayerColor::create(Color4B::WHITE);
	this->addChild( [MASK] );
	auto elevatorBG = LayerColor::create(Color4B::GRAY, 1050, 900);
	elevatorBG->setPosition(Vec2(750, 0));
	this->addChild(elevatorBG);
	drawBuilding();
	drawElevatorState();
	drawElevator();
	scheduleUpdate();
    return true;
}

void MainScene::update(float dt)
{
	for (int i = 0; i < 5; i++) {
		int floor = es->elevators[i]->getFloor();
		int state = es->elevators[i]->getWorkState();
		int door = es->elevators[i]->getDoorState();
		//将已完成的楼层呼叫按钮关闭
		if (es->orderElevator[floor][0] == i + 1) {
			floorButton[floor - 1][0]->setEnabled(true);
			es->orderElevator[floor][0] = 0;
		}
		if (es->orderElevator[floor][1] == i + 1) {
			floorButton[floor - 1][1]->setEnabled(true);
			es->orderElevator[floor][1] = 0;
		}
		curentfFloor[i]->setString(String::createWithFormat(""%i"", floor)->getCString());
		//将已完成电梯内部按钮熄灭
		if (es->elevators[i]->arrive[floor] == 1) {
			floors[i][floor - 1]->setEnabled(true);
			es->elevators[i]->arrive[floor] = 0;
		}
		//电梯内部状态显示
		if (es->elevators[i]->getWorkState() == Elevator::WAIT) {
			elevatorState[i][0]->setVisible(false);
			elevatorState[i][1]->setVisible(false);
		}
		else {
			if (state == Elevator::UP) elevatorState[i][0]->setVisible(true);
			else elevatorState[i][1]->setVisible(true);
		}
		//电梯外部状态显示
		for (int j = 0; j < 20; j++) {
			elevatorNumber[i][j]->setString(String::createWithFormat(""%i"", floor)->getCString());
			if (es->elevators[i]->getWorkState() == Elevator::WAIT) {
				elevatorDOWN[i][j]->setVisible(false);
				elevatorUP[i][j]->setVisible(false);
			}
			else {
				if (state == Elevator::UP) elevatorUP[i][j]->setVisible(true);
				else elevatorDOWN[i][j]->setVisible(true);
			}
		}
		//将损坏的电梯的任务重新调度
		if (es->elevators[i]->getIsBroken()) {
			for (int j = 0; j < 20; j++) {
				if (es->orderElevator[j + 1][0] == i + 1) {
					es->callElevator(new Person(j + 1, 1));
					es->orderElevator[j + 1][0] = 0;
				}
				else if (es->orderElevator[j + 1][1] == i + 1) {
					es->callElevator(new Person(j + 1, -1));
					es->orderElevator[j + 1][1] = 0;
				}
			}
		}
	}
}


",backGround
415,"#include <cstdlib>
#include <filesystem>
#include <iostream>

#include <libenvpp/env.hpp>

std::filesystem::path path_parser_and_validator(const std::string_view str)
{
	const auto log_path = std::filesystem::path(str);

	if (!std::filesystem::exists(log_path)) {
		if (!std::filesystem::create_directory(log_path)) {
			throw env::validation_error{""Unable to create log directory""};
		}
	} else if (!std::filesystem::is_directory(log_path)) {
		throw env::validation_error{""Log path is not a directory""};
	}

	return log_path;
}

int main()
{
	auto pre = env::prefix(""CUSTOM_PARSER_AND_VALIDATOR"");

	const auto  [MASK]  = pre.register_required_variable<std::filesystem::path>(""LOG_PATH"", path_parser_and_validator);

	const auto parsed_and_validated_pre = pre.parse_and_validate();

	if (parsed_and_validated_pre.ok()) {
		const auto path = parsed_and_validated_pre.get( [MASK] );

		std::cout << ""Logging directory: "" << path << std::endl;
	} else {
		std::cout << parsed_and_validated_pre.warning_message();
		std::cout << parsed_and_validated_pre.error_message();
	}

	return EXIT_SUCCESS;
}
",path_id
416,"#include ""CRegex.h""

CRegex::CRegex()
	: _state_count(0) {}

CNFA CRegex::compile(std::string regex) {
	if (!regex.size()) {
		throw std::invalid_argument(""Empty regex"");
	}

	auto begin = regex.begin();
	return compileIter(begin, regex.end());
}

CNFA CRegex::compileIter(std::string::iterator &begin, const std::string::iterator &end) {
	std::stack<CNFA> parse_stack;

	for (; begin != end && *begin != ')'; ++begin) {

		if (*begin == '(') {
			auto group_nfa = compileIter(++begin, end); // Parse group

			if (begin == end || *begin != ')') {
				throw std::invalid_argument(""Unclosed parentheses"");
			}

			parse_stack.push(group_nfa);
		}
		else if (*begin == '|') {
			auto alt_nfa = compileIter(++begin, end); // Parse right alternative group

			parse_stack.push(alt_nfa);

			handleAlt(parse_stack);
			--begin; // We decrease iterator, because we've already skipped '|'
		}
		else if (*begin == '*') {
			handleRep(false, parse_stack);
		}
		else if (*begin == '+') {
			handleRep(true, parse_stack);
		}
		else if (*begin == '?') {
			handleQmark(parse_stack);
		}
		else {
			handleChar(*begin, parse_stack);
		}

		// In case we haven't finished and next pattern is a special operator, we don't 
		// concatenate patterns on top so operator could wrap it.
		if (parse_stack.size() > 1) {
			auto next = begin + 1;

			if (next == end 
				|| *next != '*' && *next != '+' && *next != '?') {
				concat(parse_stack);
			}
		}
	}

	if (parse_stack.size() != 1) {
		throw std::invalid_argument(""Invalid regex. Unhandled group or alternative"");
	}

	return parse_stack.top();
}

std::shared_ptr<CState> CRegex::makeState() {
	return std::make_shared<CState>(++_state_count);
}

void CRegex::concat(std::stack<CNFA> &nfas) {
	CNFA next = nfas.top();
	nfas.pop();
	CNFA prev = nfas.top();
	nfas.pop();

	prev.finalState()->addEpsilonTransition(next.startState());

	nfas.push(CNFA(prev.startState(), next.finalState()));
}

void CRegex::handleChar(char character, std::stack<CNFA> &nfas) {
	auto start_state = makeState();
	auto end_state = makeState();

	start_state->addTransition(character, end_state);

	nfas.push(CNFA(start_state, end_state));
}

void CRegex::handleAlt(std::stack<CNFA> &nfas) {
	auto start_state = makeState();
	auto final_state = makeState();

	CNFA  [MASK]  = nfas.top();
	nfas.pop();
	 [MASK] .finalState()->addEpsilonTransition(final_state);

	CNFA alt2 = nfas.top();
	nfas.pop();
	alt2.finalState()->addEpsilonTransition(final_state);

	start_state->addEpsilonTransition( [MASK] .startState());
	start_state->addEpsilonTransition(alt2.startState());
	nfas.push(CNFA(start_state, final_state));
}

void CRegex::handleRep(bool at_least_once, std::stack<CNFA> &nfas) {
	auto underlying_patt = nfas.top();
	nfas.pop();

	auto s0 = makeState();
	s0->addEpsilonTransition(underlying_patt.startState());

	auto s1 = makeState();

	if (!at_least_once) {
		s0->addEpsilonTransition(s1);
	}

	underlying_patt.finalState()->addEpsilonTransition(s1);
	underlying_patt.finalState()->addEpsilonTransition(underlying_patt.startState());

	nfas.push(CNFA(s0, s1));
}

void CRegex::handleQmark(std::stack<CNFA> &nfas) {
	auto underlying_patt = nfas.top();

	underlying_patt.startState()->addEpsilonTransition(underlying_patt.finalState());
}
",alt1
417,"/*********************************************************************
This is a library for Chinese LED matrix displays

Written by <NAME>.
BSD license, check license.txt for more information
*********************************************************************/


#ifndef _PxMATRIX_H
#define _PxMATRIX_H

// This is how many color levels the display shows - the more the slower the update
#ifndef PxMATRIX_COLOR_DEPTH
#define PxMATRIX_COLOR_DEPTH 8
#endif

#ifndef PxMATRIX_MAX_HEIGHT
#define PxMATRIX_MAX_HEIGHT 64
#endif

#ifndef PxMATRIX_MAX_WIDTH
#define PxMATRIX_MAX_WIDTH 64
#endif

//#define double_buffer

#include ""Adafruit_GFX.h""
#include ""Arduino.h""
#include <SPI.h>

#if defined(ARDUINO) && ARDUINO >= 100
#include ""Arduino.h""
#else
#include ""WProgram.h""
#endif

#ifdef __AVR__
#include <util/delay.h>
#endif

#ifndef _BV
#define _BV(x) (1 << (x))
#endif

#include <stdlib.h>

// Sometimes some extra width needs to be passed to Adafruit GFX constructor
// to render text close to the end of the display correctly
#ifndef ADAFRUIT_GFX_EXTRA
#define ADAFRUIT_GFX_EXTRA 0
#endif

// HW SPI PINS
#define SPI_BUS_CLK 14
#define SPI_BUS_MOSI 13
#define SPI_BUS_MISO 12
#define SPI_BUS_SS 4

// Either the panel handles the multiplexing and we feed BINARY to A-E pins
// or we handle the multiplexing and activate one of A-D pins (STRAIGHT)
enum mux_patterns {BINARY, STRAIGHT};

// This is how the scanning is implemented. LINE just scans it left to right,
// ZIGZAG jumps 4 rows after every byte, ZAGGII alse revereses every second byte
enum scan_patterns {LINE, ZIGZAG, ZAGGIZ};

#define max_matrix_pixels PxMATRIX_MAX_HEIGHT * PxMATRIX_MAX_WIDTH
#define color_step 256 / PxMATRIX_COLOR_DEPTH
#define color_half_step int(color_step / 2)
#define color_third_step int(color_step / 3)
#define color_two_third_step int(color_third_step*2)

#define buffer_size max_matrix_pixels * 3 / 8

class PxMATRIX : public Adafruit_GFX {
 public:
  inline PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B);
  inline PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B,uint8_t C);
  inline PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B,uint8_t C,uint8_t D);
  inline PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B,uint8_t C,uint8_t D,uint8_t E);

  inline void begin(uint8_t row_pattern);
  inline void begin();

  inline void clearDisplay(void);

  // Updates the display
  inline void display(uint16_t show_time);

  // Draw pixels
  inline void drawPixelRGB565(int16_t x, int16_t y, uint16_t color);
  inline void drawPixelRGB565(int16_t x, int16_t y, uint16_t color, bool selected_buffer);

  inline void drawPixel(int16_t x, int16_t y, uint16_t color);
  inline void drawPixel(int16_t x, int16_t y, uint16_t color, bool selected_buffer);

  inline void drawPixelRGB888(int16_t x, int16_t y, uint8_t r, uint8_t g,uint8_t b);
  inline void drawPixelRGB888(int16_t x, int16_t y, uint8_t r, uint8_t g,uint8_t b, bool selected_buffer);

  // Does nothing for now
  uint8_t getPixel(int8_t x, int8_t y);

  // Converts RGB888 to RGB565
  uint16_t color565(uint8_t r, uint8_t g, uint8_t b);

  // Helpful for debugging (place in display update loop)
  inline void displayTestPattern(uint16_t showtime);

  // Helpful for debugging (place in display update loop)
  inline void displayTestPixel(uint16_t show_time);

  // FLush the buffer of the display
  inline void flushDisplay();

  // Rotate display
  inline void setRotate(bool rotate);

  // Helps to reduce display update latency on larger displays
  inline void setFastUpdate(bool fast_update);

  // Select active buffer to updare display from
  inline void selectBuffer(bool selected_buffer);

  // Control the minimum color values that result in an active pixel
  inline void setColorOffset(uint8_t r, uint8_t g,uint8_t b);

  // Set the multiplex pattern
  inline void setMuxPattern(mux_patterns mux_pattern);

  // Set the multiplex pattern
  inline void setScanPattern(scan_patterns scan_pattern);

  // Set the number of panels that make up the display area width
  inline void setPanelsWidth(uint8_t panels);

  // Set the number of panels that make up the display area width
  inline void setBrightness(uint8_t brightness);


 private:

 // the display buffer for the LED matrix
#ifdef double_buffer
  uint8_t PxMATRIX_buffer[PxMATRIX_COLOR_DEPTH][2*buffer_size];// = {0x00 };
#else
  uint8_t PxMATRIX_buffer[PxMATRIX_COLOR_DEPTH][buffer_size];// = {0x00 };
#endif

  // GPIO pins
  uint8_t _LATCH_PIN;
  uint8_t _OE_PIN;
  uint8_t _A_PIN;
  uint8_t _B_PIN;
  uint8_t _C_PIN;
  uint8_t _D_PIN;
  uint8_t _E_PIN;
  uint8_t _width;
  uint8_t _height;
  uint8_t _panels_width;
  uint8_t _rows_per_buffer;
  uint8_t _row_sets_per_buffer;
  uint8_t _panel_width_bytes;

  // Color offset
  uint8_t _color_R_offset;
  uint8_t _color_G_offset;
  uint8_t _color_B_offset;

  // Panel Brightness
  uint8_t _brightness;

  // Color pattern that is pushed to the display
  uint8_t _display_color;

  // Holds some pre-computed values for faster pixel drawing
  uint32_t _row_offset[PxMATRIX_MAX_HEIGHT];

  // Holds the display row pattern type
  uint8_t _row_pattern;

  // Number of bytes in one color
  uint8_t _pattern_color_bytes;

  // Total number of bytes that is pushed to the display at a time
  // 3 * _pattern_color_bytes
  uint16_t _send_buffer_size;

  // This is for double buffering
  bool _selected_buffer;
  bool _active_buffer;

  // Hols configuration
  bool _rotate;
  bool _fast_update;

  // Holds multiplex pattern
  mux_patterns _mux_pattern;

  // Holds the scan pattern
  scan_patterns _scan_pattern;

  // Used for test pattern
  uint16_t _test_pixel_counter;
  uint16_t _test_line_counter;
  unsigned long _test_last_call;

  // Generic function that draw one pixel
inline void fillMatrixBuffer(int16_t x, int16_t y, uint8_t r, uint8_t g,uint8_t b, bool selected_buffer);

  // Init code common to both constructors
inline void init(uint8_t width, uint8_t height ,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B);

  // Light up LEDs and hold for show_time microseconds
inline void latch(uint16_t show_time );

  // Set row multiplexer
inline void set_mux(uint8_t value);
};

// Pass 8-bit (each) R,G,B, get back 16-bit packed color
inline uint16_t PxMATRIX::color565(uint8_t r, uint8_t g, uint8_t b) {
  return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

// Init code common to both constructors
inline void PxMATRIX::init(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A, uint8_t B){
  _LATCH_PIN = LATCH;
  _OE_PIN = OE;
  _display_color=0;

  _A_PIN = A;
  _B_PIN = B;

  if (width > PxMATRIX_MAX_WIDTH){
    #ifdef DEBUG_ESP_PORT
      DEBUG_ESP_PORT.print(""[PxMatrix] Width larger than PxMATRIX_MAX_WIDTH.\n"");
    #endif
  }

 if (height > PxMATRIX_MAX_HEIGHT){
    #ifdef DEBUG_ESP_PORT
      DEBUG_ESP_PORT.print(""[PxMatrix] Height larger than PxMATRIX_MAX_HEIGHT.\n"");
    #endif
  }

  _width = width;
  _height = height;
  _brightness=255;
  _panels_width = 1;

  _rows_per_buffer = _height/2;
  _panel_width_bytes = (_width/_panels_width)/8;

  _selected_buffer=false;
  _active_buffer=false;

  _color_R_offset=0;
  _color_G_offset=0;
  _color_B_offset=0;

  _test_last_call=0;
  _test_pixel_counter=0;
  _test_line_counter=0;
  _rotate=0;
  _fast_update=0;

  _row_pattern=BINARY;
  _scan_pattern=LINE;

  clearDisplay();
}

inline void PxMATRIX::setMuxPattern(mux_patterns mux_pattern)
{
  _mux_pattern=mux_pattern;

  // We handle the multiplexing in the library and activate one of for
  // row drivers --> need A,B,C,D pins
  if (_mux_pattern==STRAIGHT)
  {
    pinMode(_C_PIN, OUTPUT);
    pinMode(_D_PIN, OUTPUT);
  }
}

inline void PxMATRIX::setScanPattern(scan_patterns scan_pattern)
{
  _scan_pattern=scan_pattern;
}

inline void PxMATRIX::setPanelsWidth(uint8_t panels) {
  _panels_width=panels;
  _panel_width_bytes = (_width/_panels_width)/8;
}

inline void PxMATRIX::setRotate(bool rotate) {
  _rotate=rotate;
}

inline void PxMATRIX::setFastUpdate(bool fast_update) {
  _fast_update=fast_update;
}

inline void PxMATRIX::setBrightness(uint8_t brightness) {
  _brightness=brightness;
}


inline PxMATRIX::PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B) : Adafruit_GFX(width+ADAFRUIT_GFX_EXTRA, height)
{
  init(width, height, LATCH, OE, A, B);
}

inline PxMATRIX::PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B,uint8_t C) : Adafruit_GFX(width+ADAFRUIT_GFX_EXTRA, height)
{
  _C_PIN = C;
  init(width, height, LATCH, OE, A, B);
}

inline PxMATRIX::PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B,uint8_t C,uint8_t D) : Adafruit_GFX(width+ADAFRUIT_GFX_EXTRA, height)
{
  _C_PIN = C;
  _D_PIN = D;
  init(width, height, LATCH, OE, A, B);
}

inline PxMATRIX::PxMATRIX(uint8_t width, uint8_t height,uint8_t LATCH, uint8_t OE, uint8_t A,uint8_t B,uint8_t C,uint8_t D, uint8_t E) : Adafruit_GFX(width+ADAFRUIT_GFX_EXTRA, height)
{
  _C_PIN = C;
  _D_PIN = D;
  _E_PIN = E;
  init(width, height, LATCH, OE, A, B);
}

inline void PxMATRIX::drawPixel(int16_t x, int16_t y, uint16_t color) {
  drawPixelRGB565( x,  y,  color,0 );
}

inline void PxMATRIX::drawPixel(int16_t x, int16_t y, uint16_t color, bool selected_buffer) {
  drawPixelRGB565( x,  y,  color, selected_buffer);
}

inline void PxMATRIX::selectBuffer(bool selected_buffer)
{

  _selected_buffer=selected_buffer;
}

inline void PxMATRIX::setColorOffset(uint8_t r, uint8_t g,uint8_t b)
{
  if ((color_half_step+r)<0)
    r=-color_half_step;
  if ((color_half_step+r)>255)
      r=255-color_half_step;

  if ((color_half_step+g)<0)
    g=-color_half_step;
  if ((color_half_step+g)>255)
      g=255-color_half_step;

  if ((color_half_step+b)<0)
    b=-color_half_step;
  if ((color_half_step+b)>255)
      b=255-color_half_step;

    _color_R_offset=r;
    _color_G_offset=g;
    _color_B_offset=b;
}

inline void PxMATRIX::fillMatrixBuffer(int16_t x, int16_t y, uint8_t r, uint8_t g, uint8_t b,bool selected_buffer)
{
  if (_rotate){
    uint16_t temp_x=x;
    x=y;
    y=_height-1-temp_x;
  }

  if ((x < 0) || (x >= _width) || (y < 0) || (y >= _height))
  return;
  x =_width - 1 -x;

  uint32_t  [MASK] ;
  uint32_t total_offset_r=0;
  uint32_t total_offset_g=0;
  uint32_t total_offset_b=0;

  // This code sections supports panels that have a row-changin scanning pattern
  // It does support chaining however only of height/pattern=2
  if (_scan_pattern!=LINE)
  {
    // Precomputed row offset values
#ifdef double_buffer
     [MASK] =buffer_size*selected_buffer+_row_offset[y]-(x/8)*2;
#else
     [MASK] =_row_offset[y]-(x/8)*2;
#endif
    uint8_t row_sector=0;
    uint16_t row_sector__offset=_width/4;
    for (uint8_t yy = 0; yy<_height; yy+=2*_row_pattern)
    {
      if ((yy<=y) && (y<yy+_row_pattern))
        total_offset_r= [MASK] -row_sector__offset*row_sector-(_scan_pattern==ZAGGIZ ? 1: 0);
      if ((yy+_row_pattern<=y) && (y<yy+2*_row_pattern))
        total_offset_r= [MASK] -row_sector__offset*row_sector-(_scan_pattern==ZIGZAG ? 1: 0);
      row_sector++;
    }

    total_offset_g=total_offset_r-_pattern_color_bytes;
    total_offset_b=total_offset_g-_pattern_color_bytes;
  }
  else
  {

    if (_panels_width>1)
    {
      // can only be non-zero when _height/(2 inputs per panel)/_row_pattern > 1
      // i.e.: 32x32 panel with 1/8 scan (A/B/C lines) -> 32/2/8 = 2
      uint8_t vert_index_in_buffer = (y%_rows_per_buffer)/_row_pattern; // which set of rows per buffer
      // can only ever be 0/1 since there are only ever 2 separate input sets present for this variety of panels (R1G1B1/R2G2B2)
      uint8_t which_buffer = y/_rows_per_buffer;
      uint8_t x_byte = x/8;
      // assumes panels are only ever chained for more width
      uint8_t which_panel = x_byte/_panel_width_bytes;
      uint8_t in_row_byte_offset = x_byte%_panel_width_bytes;
      // this could be pretty easily extended to vertical stacking as well
      total_offset_r = _row_offset[y] - in_row_byte_offset - _panel_width_bytes*(_row_sets_per_buffer*(_panels_width*which_buffer + which_panel) + vert_index_in_buffer);
#ifdef double_buffer
      total_offset_r += buffer_size*selected_buffer;
#endif
    }
    else
    {
      // Precomputed row offset values
       [MASK] =_row_offset[y]-(x/8);

#ifdef double_buffer
       [MASK] -=buffer_size*selected_buffer;
#endif

      // relies on integer truncation, do not simplify
      uint8_t vert_sector = y/_row_pattern;
      total_offset_r= [MASK] -vert_sector*_width/8;

    }
  }

  total_offset_g=total_offset_r-_pattern_color_bytes;
  total_offset_b=total_offset_g-_pattern_color_bytes;

  uint8_t bit_select = x%8;
  if ((_scan_pattern==ZAGGIZ) && ((y%(_row_pattern*2))<_row_pattern))
      bit_select = 7-bit_select;

  //Color interlacing
  for (int this_color=0; this_color<PxMATRIX_COLOR_DEPTH; this_color++)
  {
    uint8_t color_tresh = this_color*color_step+color_half_step;

    if (r > color_tresh+_color_R_offset)
      PxMATRIX_buffer[this_color][total_offset_r] |=_BV(bit_select);
    else
      PxMATRIX_buffer[this_color][total_offset_r] &= ~_BV(bit_select);

    if (g > color_tresh+_color_G_offset)
      PxMATRIX_buffer[(this_color+color_third_step)%PxMATRIX_COLOR_DEPTH][total_offset_g] |=_BV(bit_select);
    else
      PxMATRIX_buffer[(this_color+color_third_step)%PxMATRIX_COLOR_DEPTH][total_offset_g] &= ~_BV(bit_select);

    if (b > color_tresh+_color_B_offset)
      PxMATRIX_buffer[(this_color+color_two_third_step)%PxMATRIX_COLOR_DEPTH][total_offset_b] |=_BV(bit_select);
    else
      PxMATRIX_buffer[(this_color+color_two_third_step)%PxMATRIX_COLOR_DEPTH][total_offset_b] &= ~_BV(bit_select);
  }
}

inline void PxMATRIX::drawPixelRGB565(int16_t x, int16_t y, uint16_t color, bool selected_buffer) {
  uint8_t r = ((((color >> 11) & 0x1F) * 527) + 23) >> 6;
  uint8_t g = ((((color >> 5) & 0x3F) * 259) + 33) >> 6;
  uint8_t b = (((color & 0x1F) * 527) + 23) >> 6;
  fillMatrixBuffer( x,  y, r, g,b, selected_buffer);
}

inline void PxMATRIX::drawPixelRGB565(int16_t x, int16_t y, uint16_t color) {
  uint8_t r = ((((color >> 11) & 0x1F) * 527) + 23) >> 6;
  uint8_t g = ((((color >> 5) & 0x3F) * 259) + 33) >> 6;
  uint8_t b = (((color & 0x1F) * 527) + 23) >> 6;
  fillMatrixBuffer( x,  y, r, g,b, 0);
}

inline void PxMATRIX::drawPixelRGB888(int16_t x, int16_t y, uint8_t r, uint8_t g,uint8_t b, bool selected_buffer) {
  fillMatrixBuffer(x, y, r, g,b, selected_buffer);
}

inline void PxMATRIX::drawPixelRGB888(int16_t x, int16_t y, uint8_t r, uint8_t g,uint8_t b) {
  fillMatrixBuffer(x, y, r, g,b, 0);
}

// the most basic function, get a single pixel
inline uint8_t PxMATRIX::getPixel(int8_t x, int8_t y) {
  return (0);//PxMATRIX_buffer[x+ (y/8)*LCDWIDTH] >> (y%8)) & 0x1;
}

inline void PxMATRIX::begin()
{
  begin(8);

}

void PxMATRIX::begin(uint8_t row_pattern) {

  _row_pattern=row_pattern;
  if (_row_pattern==4)
    _scan_pattern=ZIGZAG;

  _pattern_color_bytes=(_height/_row_pattern)*(_width/8);
  _row_sets_per_buffer = _rows_per_buffer/_row_pattern;
  _send_buffer_size=_pattern_color_bytes*3;

#ifdef ESP8266
  SPI.begin();
#endif
#ifdef ESP32
  SPI.begin(SPI_BUS_CLK, SPI_BUS_MISO, SPI_BUS_MOSI, SPI_BUS_SS);
#endif

  SPI.setDataMode(SPI_MODE0);
  SPI.setBitOrder(MSBFIRST);
  SPI.setFrequency(20000000);

  pinMode(_OE_PIN, OUTPUT);
  pinMode(_LATCH_PIN, OUTPUT);
  pinMode(_A_PIN, OUTPUT);
  pinMode(_B_PIN, OUTPUT);
  digitalWrite(_A_PIN, LOW);
  digitalWrite(_B_PIN, LOW);
  digitalWrite(_OE_PIN, HIGH);

  if (_row_pattern >=8)
  {
    pinMode(_C_PIN, OUTPUT);
    digitalWrite(_C_PIN, LOW);
  }
  if (_row_pattern >=16)
  {
    pinMode(_D_PIN, OUTPUT);
    digitalWrite(_D_PIN, LOW);
  }
  if (_row_pattern >=32)
  {
    pinMode(_E_PIN, OUTPUT);
    digitalWrite(_E_PIN, LOW);
  }

  // Precompute row offset values
  for (uint8_t yy=0; yy<_height;yy++)
      _row_offset[yy]=((yy)%_row_pattern)*_send_buffer_size+_send_buffer_size-1;

}

void PxMATRIX::set_mux(uint8_t value)
{

  if (_mux_pattern==BINARY)
  {
    if (value & 0x01)
      digitalWrite(_A_PIN,HIGH);
    else
      digitalWrite(_A_PIN,LOW);

    if (value & 0x02)
      digitalWrite(_B_PIN,HIGH);
    else
      digitalWrite(_B_PIN,LOW);

    if (_row_pattern>=8)
    {
      if (value & 0x04)
      digitalWrite(_C_PIN,HIGH);
      else
      digitalWrite(_C_PIN,LOW);
    }

    if (_row_pattern>=16)
    {
      if (value & 0x08)
          digitalWrite(_D_PIN,HIGH);
      else
          digitalWrite(_D_PIN,LOW);
    }

    if (_row_pattern>=32)
    {
      if (value & 0x10)
          digitalWrite(_E_PIN,HIGH);
      else
          digitalWrite(_E_PIN,LOW);
    }
  }

  if (_mux_pattern==STRAIGHT)
  {
    if (value==0)
      digitalWrite(_A_PIN,LOW);
    else
      digitalWrite(_A_PIN,HIGH);

    if (value==1)
      digitalWrite(_B_PIN,LOW);
    else
      digitalWrite(_B_PIN,HIGH);

    if (value==2)
      digitalWrite(_C_PIN,LOW);
    else
      digitalWrite(_C_PIN,HIGH);

    if (value==3)
      digitalWrite(_D_PIN,LOW);
    else
      digitalWrite(_D_PIN,HIGH);
  }
}

void PxMATRIX::latch(uint16_t show_time )
{
  //digitalWrite(_OE_PIN,0); // <<< remove this
  digitalWrite(_LATCH_PIN,HIGH);
  //delayMicroseconds(10);
  digitalWrite(_LATCH_PIN,LOW);
  //delayMicroseconds(10);
 digitalWrite(_OE_PIN,0); //<<<< insert this
  delayMicroseconds(show_time);
  digitalWrite(_OE_PIN,1);
}

void PxMATRIX::display(uint16_t show_time) {
  unsigned long start_time=0;
#ifdef ESP8266
  ESP.wdtFeed();
#endif
  for (uint8_t i=0;i<_row_pattern;i++)
  {
    if (_fast_update && (_brightness==255)){

      // This will clock data into the display while the outputs are still
      // latched (LEDs on). We therefore utilize SPI transfer latency as LED
      // ON time and can reduce the waiting time (show_time). This is rather
      // timing sensitive and may lead to flicker however promises reduced
      // update times and increased brightness

      set_mux((i+_row_pattern-1)%_row_pattern);
      digitalWrite(_LATCH_PIN,HIGH);
      digitalWrite(_OE_PIN,0);
      start_time = micros();
      digitalWrite(_LATCH_PIN,LOW);
      delayMicroseconds(1);

#ifdef double_buffer
      SPI.writeBytes(&PxMATRIX_buffer[_display_color][buffer_size*_active_buffer+i*_send_buffer_size],_send_buffer_size);
#else
      SPI.writeBytes(&PxMATRIX_buffer[_display_color][i*_send_buffer_size],_send_buffer_size);
#endif
      while ((micros()-start_time)<show_time)
        delayMicroseconds(1);
      digitalWrite(_OE_PIN,1);
    }
    else
    {
      set_mux(i);
#ifdef double_buffer
      SPI.writeBytes(&PxMATRIX_buffer[_display_color][buffer_size*_active_buffer+i*_send_buffer_size],_send_buffer_size);
#else
      SPI.writeBytes(&PxMATRIX_buffer[_display_color][i*_send_buffer_size],_send_buffer_size);
#endif
      latch(show_time*(uint16_t)_brightness/255);
    }
  }
  _display_color++;
  if (_display_color>=PxMATRIX_COLOR_DEPTH)
  {
    _display_color=0;
#ifdef double_buffer
    _active_buffer=_selected_buffer;
#endif
  }
}

void PxMATRIX::flushDisplay(void) {
  for (int ii=0;ii<_send_buffer_size;ii++)
    SPI.write(0x00);
}

void PxMATRIX::displayTestPattern(uint16_t show_time) {

  if ((millis()-_test_last_call)>500)
  {
    SPI.write(0xFF);
    _test_last_call=millis();
    _test_pixel_counter++;
  }

  if (_test_pixel_counter>_send_buffer_size)

  {
    _test_pixel_counter=0;
    _test_line_counter++;
    flushDisplay();
  }

  if (_test_line_counter> (_height/2))
        _test_line_counter=0;

  digitalWrite(_A_PIN,HIGH);
  digitalWrite(_B_PIN,HIGH);
  digitalWrite(_C_PIN,HIGH);
  digitalWrite(_D_PIN,HIGH);
  digitalWrite(_E_PIN,HIGH);

  digitalWrite(_A_PIN,LOW);
  digitalWrite(_B_PIN,LOW);
  digitalWrite(_C_PIN,LOW);
  digitalWrite(_D_PIN,LOW);
  digitalWrite(_E_PIN,LOW);

  set_mux(_test_line_counter);

  latch(show_time);
}

void PxMATRIX::displayTestPixel(uint16_t show_time) {

  if ((millis()-_test_last_call)>500)
  {
    flushDisplay();
    uint16_t blanks = _test_pixel_counter/8;
    SPI.write(1<<_test_pixel_counter%8);
    while (blanks){
      SPI.write(0x00);
      blanks--;
    }
    _test_last_call=millis();
    _test_pixel_counter++;
  }

  if (_test_pixel_counter>_send_buffer_size/3*8)

  {
    _test_pixel_counter=0;
    _test_line_counter++;
  }

  if (_test_line_counter> (_height/2))
        _test_line_counter=0;

  digitalWrite(_A_PIN,HIGH);
  digitalWrite(_B_PIN,HIGH);
  digitalWrite(_C_PIN,HIGH);
  digitalWrite(_D_PIN,HIGH);
  digitalWrite(_E_PIN,HIGH);

  digitalWrite(_A_PIN,LOW);
  digitalWrite(_B_PIN,LOW);
  digitalWrite(_C_PIN,LOW);
  digitalWrite(_D_PIN,LOW);
  digitalWrite(_E_PIN,LOW);

  set_mux(_test_line_counter);

  latch(show_time);
}

// clear everything
void PxMATRIX::clearDisplay(void) {
  for(int this_color=0;this_color<PxMATRIX_COLOR_DEPTH;this_color++)
  for (int j=0;j<(_width*_height*3)/8;j++)
    PxMATRIX_buffer[this_color][j]=0;
}
#endif
",base_offset
418,"#include <iostream>
#include ""glad/glad.h""
#include ""GLFW/glfw3.h""
using namespace std;
// 窗口大小改变回调函数
static void window_size_changed(GLFWwindow* window,
    int width,
    int height)
{
    glViewport(0, 0, width, height);
}
// 处理用户输入
static void process_input(GLFWwindow* window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    {
        glfwSetWindowShouldClose(window, true);
    }
}

// 设置一个顶点数据
static const float vertices[] = {
    0.5f,0.5f,0.0f,//右上角
    0.5f,-0.5f,0.0f, //右下角
    -0.5f,-0.5f,0.0f, //左下角
    -0.5f,0.5f,0.0f //左上角
};

//设置一个顶点索引数组
static const unsigned int index_vector[] = {
    // 注意索引从0开始! 
    // 此例的索引(0,1,2,3)就是顶点数组vertices的下标，
    // 这样可以由下标代表顶点组合成矩形
    0,1,3,//第一个三角形
    1,2,3 // 第二个三角形
};
// 检测编译着色器代码是否成功
static bool check_compile_shader_status(GLuint shader_object, std::string& error_msg)
{
    int is_success;
    char sz_error_msg[512];
    glGetShaderiv(shader_object, GL_COMPILE_STATUS, &is_success);
    if (!is_success)
    {
        glGetShaderInfoLog(shader_object, 512, nullptr, sz_error_msg);
        error_msg = sz_error_msg;
        return false;
    }
    return true;
}

// 检测链接着色器程序是否失败
static bool check_link_program_status(GLuint program_object, std::string& error_msg)
{
    int is_success;
    char sz_error_msg[512];
    glGetProgramiv(program_object, GL_LINK_STATUS, &is_success);
    if (!is_success)
    {
        glGetProgramInfoLog(program_object, 512, nullptr, sz_error_msg);
        error_msg = sz_error_msg;
        return false;
    }
    return true;
}


// 顶点着色器 GLSL 源码
const char* vertex_shader_source = ""#version 330 core \n""
""layout (location = 0) in vec3 aPos;\n""
""void main()\n""
""{\n""
""gl_Position = vec4(aPos.x,aPos.y,aPos.z,1.0f);\n""
""}\n"";


// 片段着色器 GLSL 源码
const char* fragment_shader_source = ""#version 330 core \n""
""out vec4 frag_color;\n""
""void main()\n""
""{\n""
""frag_color = vec4(1.0f,0.5f,0.2f,1.0f);\n""
""}\n"";

int main(int argc, char** argv)
{
    // 初始化GLFW
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //设置gl 主版本号
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // 设置gl 次版本号
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    // 使用glfw 创建窗口对象
    GLFWwindow* window = glfwCreateWindow(800,
        600,
        ""study_window"",
        nullptr,
        nullptr);
    if (!window)
    {
        cout << ""create gl window fail"" << endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    // 初始化glad
    if (!gladLoadGLLoader(reinterpret_cast<GLADloadproc>(glfwGetProcAddress)))
    {
        cout << ""init glad fail"" << endl;
        return -1;
    }
    // 在渲染之前必须告知gl 渲染的尺寸大小
    glViewport(0, 0, 800, 600);

    // 为窗口尺寸改变设置回调函数
    glfwSetFramebufferSizeCallback(window,
        window_size_changed);


    // 初始化顶点着色器
    //1、 创建一个顶点着色器对象
    GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);

    //2、将顶点着色器源码附加到这个着色器对象上 然后编译它
    glShaderSource(vertex_shader, 1, &vertex_shader_source, nullptr);

    glCompileShader(vertex_shader);
    std::string error_message;
    if (!check_compile_shader_status(vertex_shader, error_message))
    {
        cout << ""compile shader fail "" << error_message << endl;
        // 清理gl fw
        glfwTerminate();
        return -1;
    }

    // 初始化片段着色器
    //1、创建一个片段着色器对象
    GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);

    //2、将片段着色器源码附加到这个片段着色器对象上 然后编译它
    glShaderSource(fragment_shader, 1, &fragment_shader_source, nullptr);

    glCompileShader(fragment_shader);
    if (!check_compile_shader_status(fragment_shader, error_message))
    {
        cout << ""compile shader fail "" << error_message << endl;
        // 清理gl fw
        glfwTerminate();
        return -1;
    }


    // 将顶点着色器对象与 片段着色器对象 链接到一个用来渲染的着色器程序 中

    // 创建一个着色器程序
    GLuint shader_program = glCreateProgram();

    // 将顶点着色器附加到这个着色器程序上
    glAttachShader(shader_program, vertex_shader);
    //将片段着色器附加到这个着色器程序上
    glAttachShader(shader_program, fragment_shader);

    //链接着色器对象到这个着色器程序中
    glLinkProgram(shader_program);

    if (!check_link_program_status(shader_program, error_message))
    {
        cout << ""link program fail "" << error_message << endl;
        // 清理gl fw
        glfwTerminate();
        return -1;
    }
    // 链接完着色器对象到着色器程序后可以删除这些着色器对象了
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);

    // 生成顶点数组对象
    GLuint VAO;
    glGenVertexArrays(1, &VAO);

    // 绑定顶点数组对象
    glBindVertexArray(VAO);

    // 生成顶点数据缓冲对象ID
    GLuint VBO;
    glGenBuffers(1, &VBO);

    // 生成元素缓冲对象
    GLuint  [MASK] ;
    glGenBuffers(1, & [MASK] );

    //绑定顶点缓冲对象ID 到顶点换成类型上
    glBindBuffer(GL_ARRAY_BUFFER, VBO);

    // 将内存中的顶点缓冲数据复制到 显存中的顶点缓冲区中
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // 绑定元素缓冲对象
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,  [MASK] );

    // 复制内存中的元素缓冲数据到 这个元素缓冲对象中
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(index_vector),
        index_vector, GL_STATIC_DRAW);


    // 链接顶点属性
    glVertexAttribPointer(0,
        3,
        GL_FLOAT,
        GL_FALSE,
        3 * sizeof(float),
        nullptr);

    // 启用顶点属性数组中 指定位置的顶点属性
    glEnableVertexAttribArray(0);
    // 解除当前顶点缓冲对象
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // 解除当前顶点数组对象
    glBindVertexArray(0);
    // 开始渲染循环
    while (!glfwWindowShouldClose(window))
    {
        //处理用户输入
        process_input(window);

        // 处理渲染指令
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // 渲染三角形
        glUseProgram(shader_program);
        glBindVertexArray(VAO);
        //glDrawArrays(GL_TRIANGLES, 0, 3);
        // 由于我们使用了元素缓冲对象 来指定顶点缓冲对象中顶点数据索引的信息 所以我们使用 glDrawElements 绘制
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
        glfwPollEvents();
        // 交换缓冲区
        glfwSwapBuffers(window);

    }

    // 删除顶点数组对象
    glDeleteVertexArrays(1, &VAO);
    // 删除顶点缓冲对象
    glDeleteBuffers(1, &VBO);
    // 删除元素索引对象
    glDeleteBuffers(1, & [MASK] );
    // 删除着色器程序对象
    glDeleteProgram(shader_program);

    // 清理gl fw
    glfwTerminate();
    return 0;
}",EBO
419,"#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085_U.h>
#include <BH1750.h>
#include <DHT.h>
#include <DHT_U.h>
#include <ESP8266WiFi.h>
#include <WebSocketsServer.h>
#include ""arduino_secrets.h"" // Include the header for WiFi credentials

// BMP180
Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085);

// BH1750
BH1750 lightMeter;

// DHT11
#define DHTPIN 14  // Pinul GPIO al plăcii conectat la DATA (OUT) al senzorului
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

// I2C Pins
#define SDA_PIN 4  // SDA conectat la GPIO4 (D2)
#define SCL_PIN 5  // SCL conectat la GPIO5 (D1)

// WiFi and WebSocket Configuration
WebSocketsServer webSocket(81); // WebSocket server on port 81

void connectToWiFi() {
  Serial.print(""Attempting to connect to WiFi: "");
  Serial.println(ssid);
  WiFi.begin(ssid, pass);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(""."");
    delay(1000);
  }
  Serial.println(""\nConnected to WiFi!"");
  Serial.print(""IP Address: "");
  Serial.println(WiFi.localIP());
}

void handleWebSocketMessage(uint8_t num, uint8_t *payload, size_t length) {
  String request = """";
  for (size_t i = 0; i < length; i++) {
    request += (char)payload[i];
  }
  request.trim();

  Serial.print(""Received WebSocket request: "");
  Serial.println(request);

  String  [MASK] ;

  if (request == ""BMP180"") {
    sensors_event_t bmpEvent;
    bmp.getEvent(&bmpEvent);
    if (bmpEvent.pressure) {
      float temperature;
      bmp.getTemperature(&temperature);
       [MASK]  += ""BMP180 Temperature: "";
       [MASK]  += String(temperature);
       [MASK]  += "" \u00B0C\n"";

       [MASK]  += ""BMP180 Pressure: "";
       [MASK]  += String(bmpEvent.pressure);
       [MASK]  += "" hPa\n"";
    }
  } else if (request == ""BH1750"") {
    float lux = lightMeter.readLightLevel();
     [MASK]  += ""BH1750 Luminosity: "";
     [MASK]  += String(lux);
     [MASK]  += "" lx\n"";
  } else if (request == ""DHT11"") {
    float humidity = dht.readHumidity();
    float temperature = dht.readTemperature();

    if (isnan(humidity) || isnan(temperature)) {
       [MASK]  += ""Failed to read from DHT11 sensor!\n"";
    } else {
       [MASK]  += ""DHT11 Humidity: "";
       [MASK]  += String(humidity);
       [MASK]  += "" %\n"";

       [MASK]  += ""DHT11 Temperature: "";
       [MASK]  += String(temperature);
       [MASK]  += "" \u00B0C\n"";
    }
  } else {
     [MASK]  += ""Invalid request. Use BMP180, BH1750, or DHT11.\n"";
  }

  webSocket.sendTXT(num,  [MASK] );
}

void webSocketEvent(uint8_t num, WStype_t type, uint8_t *payload, size_t length) {
  switch (type) {
    case WStype_DISCONNECTED:
      Serial.printf(""[%u] Disconnected!\n"", num);
      break;
    case WStype_CONNECTED:
      {
        IPAddress ip = webSocket.remoteIP(num);
        Serial.printf(""[%u] Connection from "", num);
        Serial.println(ip.toString());
      }
      break;
    case WStype_TEXT:
      handleWebSocketMessage(num, payload, length);
      break;
  }
}

void setup() {
  Serial.begin(115200);
  Serial.println(""Initializing sensors and WiFi..."");

  // Initialize I2C
  Wire.begin(SDA_PIN, SCL_PIN);

  // Initialize BMP180
  if (!bmp.begin()) {
    Serial.println(""BMP180 not detected. Check connections!"");
    while (1);
  }
  Serial.println(""BMP180 initialized successfully."");

  // Initialize BH1750
  if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE, 0x23)) {
    Serial.println(""BH1750 not detected at 0x23. Trying 0x5C..."");
    if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE, 0x5C)) {
      Serial.println(""BH1750 not detected at 0x5C!"");
      while (1);
    }
  }
  Serial.println(""BH1750 initialized successfully."");

  // Initialize DHT11
  dht.begin();
  Serial.println(""DHT11 initialized successfully."");

  // Connect to WiFi
  connectToWiFi();

  // Start WebSocket server
  webSocket.begin();
  webSocket.onEvent(webSocketEvent);
  Serial.println(""WebSocket server started on port 81"");
}

void loop() {
  webSocket.loop();
}
",response
420,"#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <bangtal>
#include <cstdlib>
#include <string>
#include <ctime>

using namespace bangtal;

ObjectPtr rule[6], rule_image[6], start[6];
ObjectPtr challenge_button, practice_button, off, info, back, mode_info;
ScenePtr practice_scene = Scene::create("""", ""Images/prac_back.png"");
ScenePtr main_scene = Scene::create("""", ""Images/main_background.png"");
ScenePtr challenge_show = Scene::create("""", ""Images/chall_back.png"");
ScenePtr prac_end = Scene::create("""", ""Images/back_ground.png"");
ScenePtr com_chall = Scene::create("""", ""Images/com_chall.png"");
ObjectPtr next = Object::create(""Images/next_chall.png"", challenge_show, 500, 550), retry = Object::create(""Images/restart.png"", challenge_show, 500, 550);
ObjectPtr yes_play_song = 0; ObjectPtr no_play_song = 0;
SoundPtr song = 0; SoundPtr song_end = 0;
ObjectPtr flag = Object::create(""Images/red-flag.png"", challenge_show, 1170, 395);


auto challenger = Object::create(""Images/challenger.png"", challenge_show, 0, 100);
int sound_check = 1; //1 on, 0 off
int x[7] = { 0,120,340,460,580,810,1030 };
int y[7] = { 80,80,180,180,180,290,395 };
auto restart_button = Object::create(""Images/restart.png"", prac_end, 520, 350);
auto select = Object::create(""Images/select_game.png"", prac_end, 520, 450);
char introduce_object[70];
int intro_on = 0;
int intro_on_num = 0;
int info_on = 0;
int k;

void song_object()
{
    yes_play_song = Object::create(""Sound/Play_Song_Yes.png"", main_scene, 1160, 480); yes_play_song->setScale(0.5);
    yes_play_song->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->play(true);
        yes_play_song->hide();
        no_play_song->show();
        sound_check = 1;
        return true;
        });
    no_play_song = Object::create(""Sound/Play_Song_No.png"", main_scene, 1160, 480); no_play_song->setScale(0.5);
    no_play_song->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->stop();
        no_play_song->hide();
        yes_play_song->show();
        sound_check = 0;
        return true;
        });
}

void set_end() {
    restart_button->setScale(0.12);
    select->setScale(0.1);
}
bool challenge = false;

void success(int n) {
    k = n + 1;
    challenger->locate(challenge_show, x[n], y[n]);
    auto move_timer = Timer::create(1);
    move_timer->start();
    move_timer->setOnTimerCallback([&](auto)->bool {
        challenger->locate(challenge_show, x[k], y[k]);
        showMessage(""게임을 통과하셨습니다!!"");
        return true;
        });
    next->show();
    next->setScale(0.1);
    retry->hide();
}

void fail(int n) {
    challenger->locate(challenge_show, x[n], y[n]);
    retry->show();
    retry->setScale(0.1);
    next->hide();
}

int choose_index(ObjectPtr o) {
    for (int i = 0; i < 6; i++) {
        if (rule[i] == o) return i;
        else if (start[i] == o) return i;
    }
    return -1;
}

std::string set_explain_image(int index) {
    return ""게임 설명/game_rule_"" + std::to_string(index) + "".png"";
}

///////////////////////////////////////////////////////////////////////////////////////////////// 0번 게임 함수

TimerPtr timer1_0, timer2_0, timer_inst_0;
ScenePtr scene_0;
ObjectPtr start1_0 = 0;
ObjectPtr start2_0 = 0;
ObjectPtr end_0 = 0;
ObjectPtr yes_play_song_0 = 0;
ObjectPtr no_play_song_0 = 0;
ObjectPtr placement_0[12] = { 0, };

int arr_20_0[20] = { 0, }, result_true_0[20] = { 0, }, result_your_0[40] = { 0, };
int trial_0 = 20; int count_0 = 0;
int choose_num_0 = 0; int num_right_0 = 0;

void song_object_0()
{
    yes_play_song_0 = Object::create(""Sound/Play_Song_Yes.png"", scene_0, 1150, 600); yes_play_song_0->setScale(0.5);
    yes_play_song_0->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->play(true);
        yes_play_song_0->hide();
        no_play_song_0->show();
        sound_check = 1;
        return true;
        });
    no_play_song_0 = Object::create(""Sound/Play_Song_No.png"", scene_0, 1150, 600); no_play_song_0->setScale(0.5);
    no_play_song_0->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->stop();
        no_play_song_0->hide();
        yes_play_song_0->show();
        sound_check = 0;
        return true;
        });
}

int index_to_x_0(int index)
{
    return (350 + 150 * (index % 4));
}
int index_to_y_0(int index)
{
    return (450 - 170 * (index / 4));
}

void makearray_start_0()
{
    printf(""\n\n\n"");
    printf(""======================================================================"");
    printf(""\n\n\n"");
    srand((unsigned int)time(NULL));
    for (int i = 0; i < 20; i++)
    {
        arr_20_0[i] = rand() % 12;
        if (i > 3)
        {
            if (choose_num_0 == 2)
            {
                if (arr_20_0[i] % 5 == 0)
                    arr_20_0[i] = arr_20_0[i - 2];
            }
            if (choose_num_0 == 3)
            {
                if (arr_20_0[i] % 5 == 0)
                    arr_20_0[i] = arr_20_0[i - 3];
            }
        }
    }

    trial_0 = 20;
    timer1_0->set(3.0f); timer1_0->start();
}

void makeresult_0()
{
    start1_0->show(); start2_0->show();
    for (int i = 0; i < 20; i++)
    {
        printf(""%d "", arr_20_0[i] + 1);
    }
    printf(""\n\n"");

    if (choose_num_0 == 2)
    {
        num_right_0 = 0;
        printf(""Correct Answer is :\n\n"");
        for (int i = 2; i < 20; i++)
        {
            if (arr_20_0[i] == arr_20_0[i - 2])
                result_true_0[i - 2] = 1;
            else
                result_true_0[i - 2] = 2;
            printf("" %d "", result_true_0[i - 2]);
        } // result_true 에 0~17 값이 저장된다.

        printf(""\nYour Answer is :\n"");
        for (int i = 0; i < 35; i++)
        {
            if (i % 2 == 0)
            {
                printf("" %d "", result_your_0[i]);
            }
        }
        for (int i = 0; i < 18; i++)
        {
            if (result_true_0[i] == result_your_0[2 * i])
            {
                num_right_0++;
            }
        }
        char message_in[100];
        sprintf(message_in, ""Your score is %d out of 18 !!!"", num_right_0);
        showMessage(message_in);
        hideTimer();
        if (challenge) {
            if (num_right_0 > 12) {
                success(0);
                challenge_show->enter();
                next->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                    scene_1->enter();
                    init_game_1();
                    return true;
                    });
            }
            else {
                fail(0);
                challenge_show->enter();
                retry->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                    scene_0->enter();
                    return true;
                    });
            }
        }
        else {
            prac_end->enter();
            set_end();
            select->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                practice_scene->enter();
                return true;
                });
            restart_button->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                scene_0->enter();
                return true;
                });
        }
    }

    if (choose_num_0 == 3)
    {
        num_right_0 = 0;
        printf(""Correct Answer is :\n\n"");
        for (int i = 3; i < 20; i++)
        {
            if (arr_20_0[i] == arr_20_0[i - 3])
                result_true_0[i - 3] = 1;
            else
                result_true_0[i - 3] = 2;
            printf("" %d "", result_true_0[i - 3]);
        } // result_true 에 0~16 값이 저장된다.
        printf(""\nYour Answer is :\n"");
        for (int i = 0; i < 33; i++)
        {
            if (i % 2 == 0)
            {
                printf("" %d "", result_your_0[i]);
            }
        }
        for (int i = 0; i < 17; i++)
        {
            if (result_true_0[i] == result_your_0[2 * i])
            {
                num_right_0++;
            }
        }
        char message_in[100];
        sprintf(message_in, ""Your score is %d out of 17 !!!"", num_right_0);
        showMessage(message_in);
        hideTimer();
        if (challenge) {
            if (num_right_0 > 12) {
                success(0);
                challenge_show->enter();
                next->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                    scene_1->enter();
                    init_game_1();
                    return true;
                    });
            }
            else {
                fail(0);
                challenge_show->enter();
                retry->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                    scene_0->enter();
                    return true;
                    });
            }
        }
        else {
            prac_end->enter();
            set_end();
            select->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                practice_scene->enter();
                return true;
                });
            restart_button->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                scene_0->enter();
                return true;
                });
        }
    }
}

void reset_0()
{
    for (int i = 0; i < 40; i++)
    {
        result_your_0[i] = 0;
    }
    trial_0 = 20; count_0 = 0;
    timer_inst_0 = Timer::create(63.0f);
    timer_inst_0->setOnTimerCallback([&](auto)->bool {
        makeresult_0();
        return true;
        });
}

void init_game_0()
{
    song_object_0();
    if (sound_check == 1)
    {
        yes_play_song_0->hide();
        no_play_song_0->show();
    }
    else
    {
        yes_play_song_0->show();
        no_play_song_0->hide();
    }

    scene_0->setOnKeyboardCallback([&](ScenePtr scene_0, KeyCode key_0, bool pressed)->bool {
        if (count_0 < 40)
        {
            if (key_0 == KeyCode::KEY_LEFT_ARROW)
                result_your_0[count_0] = 1;
            if (key_0 == KeyCode::KEY_RIGHT_ARROW)
                result_your_0[count_0] = 2;
            count_0++;
        }

        return true;
        });

    timer1_0 = Timer::create(3.0f);
    timer1_0->setOnTimerCallback([&](auto)->bool {
        if (trial_0 > 0) {
            timer1_0->set(3.0f);
            timer1_0->start();
            placement_0[arr_20_0[20 - trial_0]]->hide();
            timer2_0->set(1.0f); timer2_0->start();
        }
        trial_0--;
        return true;
        });

    timer2_0 = Timer::create(1.0f);
    timer2_0->setOnTimerCallback([&](auto)->bool {
        placement_0[arr_20_0[20 - trial_0 - 1]]->show();
        return true;
        });

    start1_0 = Object::create(""Images0/2_back_start.png"", scene_0, 30, 130);
    start1_0->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        choose_num_0 = 2; makearray_start_0();
        reset_0(); timer_inst_0->start(); showTimer(timer_inst_0);
        start1_0->hide(); start2_0->hide();
        return true;
        });

    start2_0 = Object::create(""Images0/3_back_start.png"", scene_0, 30, 50);
    start2_0->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        choose_num_0 = 3; makearray_start_0();
        reset_0(); timer_inst_0->start(); showTimer(timer_inst_0);
        start1_0->hide(); start2_0->hide();;
        return true;
        });

    end_0 = Object::create(""Images0/end.png"", scene_0, 1100, 50);
    end_0->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        endGame();
        return true;
        });

    for (int i = 0; i < 12; i++)
    {
        placement_0[i]->show();
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////// 1번 게임 함수

ScenePtr scene_1;
ObjectPtr easy_1, hard_1, button_1[3], board1_1[3][4], board2_1[3][5], restart_1;
ObjectPtr yes_play_song_1 = 0;
ObjectPtr no_play_song_1 = 0;

int mode_1;//4 - easy, 5 - hard
int count_1 = 0, limit_1;//count - 이용자, limit - 최대 이동 가능 횟수
int arr1_1[3][4] = { 0 }, arr2_1[3][5] = { 0 }, order_1[3];//arr - 이동가능한 원반 위치 알려줌, order - 원반이 이동할 때 세로 위치 알려줌
char path_1[50] = { 0 }, result_1[50] = { 0 };
int flag_1 = 0, disk_1 = -1;//flag가 1이라서 원반을 보여줄 때, 보여줘야 할 disk의 위치(= j값 저장용)

void song_object_1()
{
    yes_play_song_1 = Object::create(""Sound/Play_Song_Yes.png"", scene_1, 1150, 600); yes_play_song_1->setScale(0.5);
    yes_play_song_1->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->play(true);
        yes_play_song_1->hide();
        no_play_song_1->show();
        sound_check = 1;
        return true;
        });
    no_play_song_1 = Object::create(""Sound/Play_Song_No.png"", scene_1, 1150, 600); no_play_song_1->setScale(0.5);
    no_play_song_1->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->stop();
        no_play_song_1->hide();
        yes_play_song_1->show();
        sound_check = 0;
        return true;
        });
}

int index_to_x_1(int index) {
    return 215 - (index * 17);
}

int index_to_y_1(int index, int num) {
    if (num == 4) {
        return 440 - (index * 50) - 50;
    }
    else if (num == 5) {
        return 440 - (index * 50);
    }
}

int button_x_1(int index) {
    return (index * 390) + 200;
}

bool check_finish_1(int num) {

    int i_1;
    if (num == 4) {
        for (i_1 = 0; i_1 < num; i_1++) {
            if (arr1_1[2][i_1] == 0) return false;
        }
        if (arr1_1[2][i_1] == 1) return true;//끝까지 다 1이 채워졌으면 성공
    }
    else if (num == 5) {
        for (i_1 = 0; i_1 < num; i_1++) {
            if (arr2_1[2][i_1] == 0) return false;
        }
        if (arr2_1[2][i_1] == 1) return true;//끝까지 다 1이 채워졌으면 성공
    }
}

void start_game_1() {//실제 원반이 이동되는 함수 - 실질적 게임 진행 화면
    restart_1->show();
    restart_1->setScale(0.8f);
    restart_1->setOnMouseCallback([&](auto, auto, auto, auto)->bool {//원반, restart hide + init으로 돌아감 
        for (int i_1 = 0; i_1 < 3; i_1++) {
            if (mode_1 == 4) {
                for (int j_1 = 0; j_1 < 4; j_1++) {
                    board1_1[i_1][j_1]->hide();
                }
            }
            else if (mode_1 == 5) {
                for (int k_1 = 0; k_1 < 5; k_1++) {
                    board2_1[i_1][k_1]->hide();
                }
            }
            button_1[i_1]->hide();
        }
        restart_1->hide();
        init_game_1();
        return true;
        });

    //원반 이동
    for (int i_1 = 0; i_1 < 3; i_1++) {
        button_1[i_1]->setOnMouseCallback([&, i_1](auto, auto, auto, auto)->bool {
            int j_1; int check_1 = -1;

            if (mode_1 == 4) {
                if (flag_1 == 0) {//원반 줍고(hide), 다음 버튼 클릭
                    for (j_1 = 0; j_1 < 4; j_1++) {//최상위에 있는 원반 찾음
                        if (arr1_1[i_1][j_1] == 1) {
                            arr1_1[i_1][j_1] = 0;
                            board1_1[i_1][j_1]->hide();
                            flag_1 = 1; disk_1 = j_1; order_1[i_1] += 1;
                            break;
                        }
                    }
                }
                else if (flag_1 == 1) {//원반 보여줄 차례 - 위에 arr에 이미 1이 있다면 메세지로 옮길 수 없습니다 출력
                    for (j_1 = 0; j_1 < disk_1; j_1++) {
                        if (arr1_1[i_1][j_1] == 1) {//원반을 옮기지 못 하는 경우
                            showMessage(""원반을 옮길 수 없습니다."");
                            break;
                        }
                    }
                    if (arr1_1[i_1][j_1] == 0) {
                        arr1_1[i_1][disk_1] = 1;
                        board1_1[i_1][disk_1]->locate(scene_1, index_to_x_1(disk_1) + 370 * i_1, index_to_y_1(order_1[i_1], 4));
                        board1_1[i_1][disk_1]->show();
                        order_1[i_1] -= 1;//다음에 위치할 축으로 위치 조정
                        flag_1 = 0; disk_1 = -1; count_1++;
                        printf(""\nnow count: %d"", count_1);
                    }
                }
            }

            else if (mode_1 == 5) {
                if (flag_1 == 0) {//원반 줍고(hide), 다음 버튼 클릭
                    for (j_1 = 0; j_1 < 5; j_1++) {//최상위에 있는 원반 찾음

                        if (arr2_1[i_1][j_1] == 1) {
                            arr2_1[i_1][j_1] = 0;
                            board2_1[i_1][j_1]->hide();
                            flag_1 = 1; disk_1 = j_1; order_1[i_1] += 1;
                            break;
                        }
                    }
                }
                else if (flag_1 == 1) {//원반 보여줄 차례 - 위에 arr에 이미 1이 있다면 메세지로 옮길 수 없습니다 출력
                    for (j_1 = 0; j_1 < disk_1; j_1++) {
                        if (arr2_1[i_1][j_1] == 1) {//원반을 옮기지 못 하는 경우
                            showMessage(""원반을 옮길 수 없습니다."");
                            break;
                        }
                    }
                    if (arr2_1[i_1][j_1] == 0) {
                        arr2_1[i_1][disk_1] = 1;
                        board2_1[i_1][disk_1]->locate(scene_1, index_to_x_1(disk_1) + 370 * i_1, index_to_y_1(order_1[i_1], 5));
                        board2_1[i_1][disk_1]->show();
                        order_1[i_1] -= 1;//다음에 위치할 축으로 위치 조정
                        flag_1 = 0; disk_1 = -1; count_1++;
                        printf(""\nnow count: %d"", count_1);
                    }
                }

            }

            if (check_finish_1(4) || check_finish_1(5)) {
                sprintf(result_1, ""성공!(이동횟수: %d)"", count_1);
                printf(""\n\n\n"");
                printf(""======================================================================"");
                printf(""\n\n\n"");
                showMessage(result_1);
                if (challenge) {
                    challenge_show->enter();
                    success(1);
                    next->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        scene_2->enter();
                        init_game_2();
                        return true;
                        });
                }
                else {
                    prac_end->enter();
                    set_end();
                    select->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        for (int i_1 = 0; i_1 < 3; i_1++) {
                            if (mode_1 == 4) {
                                for (int j_1 = 0; j_1 < 4; j_1++) {
                                    board1_1[i_1][j_1]->hide();
                                }
                            }
                            else if (mode_1 == 5) {
                                for (int k_1 = 0; k_1 < 5; k_1++) {
                                    board2_1[i_1][k_1]->hide();
                                }
                            }
                            button_1[i_1]->hide();
                        }
                        restart_1->hide();
                        practice_scene->enter();
                        return true;
                        });
                    restart_button->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        for (int i_1 = 0; i_1 < 3; i_1++) {
                            if (mode_1 == 4) {
                                for (int j_1 = 0; j_1 < 4; j_1++) {
                                    board1_1[i_1][j_1]->hide();
                                }
                            }
                            else if (mode_1 == 5) {
                                for (int k_1 = 0; k_1 < 5; k_1++) {
                                    board2_1[i_1][k_1]->hide();
                                }
                            }
                            button_1[i_1]->hide();
                        }
                        restart_1->hide();
                        init_game_1();
                        return true;
                        });
                }
            }
            if (count_1 > limit_1) {
                sprintf(result_1, ""이동횟수 초과(이동횟수: %d번)"", count_1);
                printf(""\n\n\n"");
                printf(""======================================================================"");
                printf(""\n\n\n"");
                showMessage(result_1);
                if (challenge) {
                    fail(1);
                    challenge_show->enter();
                    retry->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        for (int i_1 = 0; i_1 < 3; i_1++) {
                            if (mode_1 == 4) {
                                for (int j_1 = 0; j_1 < 4; j_1++) {
                                    board1_1[i_1][j_1]->hide();
                                }
                            }
                            else if (mode_1 == 5) {
                                for (int k_1 = 0; k_1 < 5; k_1++) {
                                    board2_1[i_1][k_1]->hide();
                                }
                            }
                            button_1[i_1]->hide();
                        }
                        restart_1->hide();
                        scene_1->enter();
                        init_game_1();
                        return true;
                        });
                }
                else {
                    prac_end->enter();
                    set_end();
                    restart_button->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        for (int i_1 = 0; i_1 < 3; i_1++) {
                            if (mode_1 == 4) {
                                for (int j_1 = 0; j_1 < 4; j_1++) {
                                    board1_1[i_1][j_1]->hide();
                                }
                            }
                            else if (mode_1 == 5) {
                                for (int k_1 = 0; k_1 < 5; k_1++) {
                                    board2_1[i_1][k_1]->hide();
                                }
                            }
                            button_1[i_1]->hide();
                        }
                        restart_1->hide();
                        scene_1->enter();
                        init_game_1();
                        return true;
                        });
                    select->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        for (int i_1 = 0; i_1 < 3; i_1++) {
                            if (mode_1 == 4) {
                                for (int j_1 = 0; j_1 < 4; j_1++) {
                                    board1_1[i_1][j_1]->hide();
                                }
                            }
                            else if (mode_1 == 5) {
                                for (int k_1 = 0; k_1 < 5; k_1++) {
                                    board2_1[i_1][k_1]->hide();
                                }
                            }
                            button_1[i_1]->hide();
                        }
                        restart_1->hide();
                        practice_scene->enter();
                        return true;
                        });
                }
            }
            return true;
            });
    }

}

void init_game_1() {//start_game함수에서 restart를 눌러 초기화 된 상태 - 게임 실행 전 세팅하는 부분
    showMessage(""게임 모드를 선택하세요"");
    song_object_1();
    if (sound_check == 1)
    {
        yes_play_song_1->hide();
        no_play_song_1->show();
    }
    else
    {
        yes_play_song_1->show();
        no_play_song_1->hide();
    }
    //게임에 사용할 변수들 초기화 - restart될 경우까지 생각해서 init_game에서 초기화
    count_1 = 0; flag_1 = 0; disk_1 = -1;
    for (int i_1 = 0; i_1 < 3; i_1++) {//arr1/arr2 싹 다 0으로 채움
        for (int j_1 = 0; j_1 < 4; j_1++) {
            arr1_1[i_1][j_1] = 0;
        }
        for (int k_1 = 0; k_1 < 5; k_1++) {
            arr2_1[i_1][k_1] = 0;
        }
    }

    //easy, hard -> 원반, button 생성 -> 일단 생성하고, start_game에서 보여줌
    for (int i_1 = 0; i_1 < 3; i_1++) {
        sprintf(path_1, ""Images1/버튼%d.jpg"", i_1 + 1);
        button_1[i_1] = Object::create(path_1, scene_1, button_x_1(i_1), 120);
        button_1[i_1]->setScale(1.7f);
        button_1[i_1]->hide();
    }

    easy_1 = Object::create(""Images1/easy.jpg"", scene_1, 140, 250);
    easy_1->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        scene_1->setImage(""Images1/하노이배경.jpg"");
        easy_1->hide(); hard_1->hide();
        mode_1 = 4; limit_1 = 18;
        order_1[0] = -1; order_1[1] = 3; order_1[2] = 3;
        for (int i_1 = 0; i_1 < 3; i_1++) {//일단 arr1 싹 다 0으로 채움
            button_1[i_1]->show();//button 보여주기
        }
        for (int i_1 = 0; i_1 < 4; i_1++) {//배열 첫 번째는 1로 채우고, 두번째/세번째는 0으로
            arr1_1[0][i_1] = 1;
            sprintf(path_1, ""Images1/원반%d.png"", i_1 + 1);
            board1_1[0][i_1] = Object::create(path_1, scene_1, index_to_x_1(i_1), index_to_y_1(i_1, 4));
            board1_1[1][i_1] = Object::create(path_1, scene_1, index_to_x_1(i_1) + 370, index_to_y_1(i_1, 4));
            board1_1[2][i_1] = Object::create(path_1, scene_1, index_to_x_1(i_1) + 740, index_to_y_1(i_1, 4));
            board1_1[1][i_1]->hide(); board1_1[2][i_1]->hide();
        }
        showMessage(""아래 버튼을 클릭해서 원반을 움직이세요(1번에서 3번으로)"");
        printf(""\neasy mode start"");
        start_game_1();
        return true;
        });

    hard_1 = Object::create(""Images1/hard.jpg"", scene_1, 820, 250);
    hard_1->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        scene_1->setImage(""Images1/하노이배경.jpg"");
        easy_1->hide(); hard_1->hide();
        mode_1 = 5; limit_1 = 37;
        order_1[0] = -1; order_1[1] = 4; order_1[2] = 4;
        for (int i_1 = 0; i_1 < 3; i_1++) {//button 보여주기
            button_1[i_1]->show();//button 보여주기
        }
        for (int i_1 = 0; i_1 < 5; i_1++) {//배열 첫 번째는 1로 채우고, 두번째/세번째는 0으로
            arr2_1[0][i_1] = 1;
            sprintf(path_1, ""Images1/원반%d.png"", i_1 + 1);
            board2_1[0][i_1] = Object::create(path_1, scene_1, index_to_x_1(i_1), index_to_y_1(i_1, 5));
            board2_1[1][i_1] = Object::create(path_1, scene_1, index_to_x_1(i_1) + 370, index_to_y_1(i_1, 5));
            board2_1[2][i_1] = Object::create(path_1, scene_1, index_to_x_1(i_1) + 740, index_to_y_1(i_1, 5));
            board2_1[1][i_1]->hide(); board2_1[2][i_1]->hide();
        }
        showMessage(""아래 버튼을 클릭해서 원반을 움직이세요(1번에서 3번으로)"");
        printf(""\nhard mode start"");
        start_game_1();
        return true;
        });

    restart_1 = Object::create(""Images1/restart.png"", scene_1, 900, 600);
    restart_1->setScale(1.2f);
    restart_1->setOnMouseCallback([&](auto, auto, auto, auto)->bool {//원반, restart hide + init으로 돌아감 
        for (int i_1 = 0; i_1 < 3; i_1++) {
            if (mode_1 == 4) {
                for (int j_1 = 0; j_1 < 4; j_1++) {
                    board1_1[i_1][j_1]->hide();
                }
            }
            else if (mode_1 == 5) {
                for (int k_1 = 0; k_1 < 5; k_1++) {
                    board2_1[i_1][k_1]->hide();
                }
            }
            button_1[i_1]->hide();
        }
        restart_1->hide();
        init_game_1();
        return true;
        });
    restart_1->hide();
    scene_1->setImage(""Images1/배경.jpg"");
}

///////////////////////////////////////////////////////////////////////////////////////////////// 2번 게임 함수

TimerPtr timer_finish_2;
ScenePtr scene_2;
ObjectPtr restart_2 = 0;
ObjectPtr end_2 = 0;
ObjectPtr notice_2 = 0;
ObjectPtr placement_2[7][7] = { 0, };
SoundPtr song_2 = 0;
ObjectPtr yes_play_song_2 = 0;
ObjectPtr no_play_song_2 = 0;
int check_start_2 = 0;

void song_object_2()
{
    yes_play_song_2 = Object::create(""Sound/Play_Song_Yes.png"", scene_2, 1150, 600); yes_play_song_2->setScale(0.5);
    yes_play_song_2->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->play(true);
        yes_play_song_2->hide();
        no_play_song_2->show();
        sound_check = 1;
        return true;
        });
    no_play_song_2 = Object::create(""Sound/Play_Song_No.png"", scene_2, 1150, 600); no_play_song_2->setScale(0.5);
    no_play_song_2->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->stop();
        no_play_song_2->hide();
        yes_play_song_2->show();
        sound_check = 0;
        return true;
        });
}

int arr_20_1_2[21][3] = { 0, }, arr_20_2_2[21][3] = { 0, }, result_true_2[21] = { 0, }, result_your_2[45] = { 0, }, result_2[21] = { 0, };
int trial_2 = 20; int count_2 = 0;
int choose_num_2 = 0; int num_right_2 = 0;

void makearray_start_2() {
    printf(""\n\n\n"");
    printf(""======================================================================"");
    printf(""\n\n\n"");

    srand((unsigned int)time(NULL));
    for (int i = 0; i < 21; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            arr_20_1_2[i][j] = rand() % 7;
            arr_20_2_2[i][j] = rand() % 7;
            if (arr_20_1_2[i][j] == arr_20_2_2[i][j])
            {
                arr_20_2_2[i][j] = arr_20_2_2[i][j] + 1;
                arr_20_2_2[i][j] = arr_20_2_2[i][j] % 7;
            }
        }
        if ((rand() % 3) == 0)
        {
            arr_20_1_2[i][0] = arr_20_2_2[i][1];
        }
    }
}


void makeresult_2() {
    check_start_2 = 0;
    printf(""\n\n"");
    num_right_2 = 0;

    for (int i = 0; i < 20; i++)
    {
        if (arr_20_1_2[i][0] == arr_20_2_2[i][1])
        {
            result_true_2[i] = 1;
        }
        else
        {
            result_true_2[i] = 2;
        }

        if (result_true_2[i] == result_your_2[i * 2])
        {
            printf(""O "");
            num_right_2++;
        }
        else
        {
            printf(""X "");
        }
    }
    printf(""\n"");
    for (int i = 0; i < 20; i++)
    {
        printf(""%d "", result_true_2[i]);
    }
    printf(""\n"");
    for (int i = 0; i < 20; i++)
    {
        printf(""%d "", result_your_2[i * 2]);
    }

    char message_in_2[100];
    sprintf(message_in_2, ""Your score is %d out of 20 !!!"", num_right_2);
    showMessage(message_in_2);
    if (challenge) {
        challenge_show->enter();
        if (num_right_2 > 14) {
            success(2);
            next->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                scene_3->enter();
                init_game_3();
                return true;
                });
        }
        else {
            fail(2);
            retry->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                reset_2();
                makearray_start_2();
                placement_2[arr_20_1_2[0][0]][arr_20_1_2[0][1]]->show();
                placement_2[arr_20_1_2[0][0]][arr_20_1_2[0][1]]->locate(scene_2, 200, 250);
                placement_2[arr_20_2_2[0][0]][arr_20_2_2[0][1]]->show();
                placement_2[arr_20_2_2[0][0]][arr_20_2_2[0][1]]->locate(scene_2, 700, 250);
                scene_2->enter();
                restart_2->hide();
                check_start_2 = 1;
                return true;
                });
        }
    }
    else {
        prac_end->enter();
        set_end();
        restart_button->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
            reset_2();
            makearray_start_2();
            placement_2[arr_20_1_2[0][0]][arr_20_1_2[0][1]]->show();
            placement_2[arr_20_1_2[0][0]][arr_20_1_2[0][1]]->locate(scene_2, 200, 250);
            placement_2[arr_20_2_2[0][0]][arr_20_2_2[0][1]]->show();
            placement_2[arr_20_2_2[0][0]][arr_20_2_2[0][1]]->locate(scene_2, 700, 250);
            scene_2->enter();
            restart_2->hide();
            check_start_2 = 1;
            return true;
            });

        select->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
            reset_2();
            practice_scene->enter();
            return true;
            });
    }
}

void reset_2() {
    trial_2 = 20;
    count_2 = 0;
}

void init_game_2()
{
    song_object_2();
    if (sound_check == 1)
    {
        yes_play_song_2->hide();
        no_play_song_2->show();
    }
    else
    {
        yes_play_song_2->show();
        no_play_song_2->hide();
    }
    char path_2[50];
    for (int i = 0; i < 7; i++) {
        for (int j = 0; j < 7; j++)
        {
            sprintf(path_2, ""Images2/%d_%d.png"", i, j);
            placement_2[i][j] = Object::create(path_2, scene_2, 200, 250);
            placement_2[i][j]->setScale(2.0f);
            placement_2[i][j]->hide();
        }
    };

    scene_2->setOnKeyboardCallback([&](ScenePtr scene_2, KeyCode key_2, bool pressed)->bool {
        if (check_start_2 == 1)
        {
            if (count_2 < 40)
            {
                if (key_2 == KeyCode::KEY_LEFT_ARROW)
                {
                    result_your_2[count_2] = 1; //전환 show, hide
                }
                if (key_2 == KeyCode::KEY_RIGHT_ARROW)
                {
                    result_your_2[count_2] = 2; //전환 show, hide
                }
                int input_inst_2 = count_2 / 2 + 1;
                if (count_2 % 2 == 0)
                {
                    if (input_inst_2 >= 1)
                    {
                        placement_2[arr_20_1_2[input_inst_2 - 1][0]][arr_20_1_2[input_inst_2 - 1][1]]->hide();
                        placement_2[arr_20_2_2[input_inst_2 - 1][0]][arr_20_2_2[input_inst_2 - 1][1]]->hide();
                    }

                    placement_2[arr_20_1_2[input_inst_2][0]][arr_20_1_2[input_inst_2][1]]->show();
                    placement_2[arr_20_1_2[input_inst_2][0]][arr_20_1_2[input_inst_2][1]]->locate(scene_2, 200, 250);
                    placement_2[arr_20_2_2[input_inst_2][0]][arr_20_2_2[input_inst_2][1]]->show();
                    placement_2[arr_20_2_2[input_inst_2][0]][arr_20_2_2[input_inst_2][1]]->locate(scene_2, 700, 250);
                }
            }

            count_2++;

            if (count_2 == 39)
            {
                timer_finish_2->set(0.5); timer_finish_2->start();
            }
        }
        return true;
        });

    timer_finish_2 = Timer::create(0.5);
    timer_finish_2->setOnTimerCallback([&](auto)->bool {
        for (int i = 0; i < 7; i++) {
            for (int j = 0; j < 7; j++)
            {
                placement_2[i][j]->hide();
            }
        };
        makeresult_2();
        return true;
        });

    restart_2 = Object::create(""Images2/start.png"", scene_2, 1150, 150); restart_2->setScale(1.2f);
    restart_2->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        reset_2();
        makearray_start_2();
        check_start_2 = 1;
        placement_2[arr_20_1_2[0][0]][arr_20_1_2[0][1]]->show();
        placement_2[arr_20_1_2[0][0]][arr_20_1_2[0][1]]->locate(scene_2, 200, 250);
        placement_2[arr_20_2_2[0][0]][arr_20_2_2[0][1]]->show();
        placement_2[arr_20_2_2[0][0]][arr_20_2_2[0][1]]->locate(scene_2, 700, 250);
        restart_2->hide();
        return true;
        });
    restart_2->show();

    end_2 = Object::create(""Images2/end.png"", scene_2, 1150, 90); end_2->setScale(1.2f);
    end_2->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        endGame();
        return true;
        });
}

///////////////////////////////////////////////////////////////////////////////////////////////// 3번 게임 함수

ObjectPtr yes_play_song_3 = 0;
ObjectPtr no_play_song_3 = 0;
ScenePtr scene_3;

int correct_3 = 0, wrong_3 = 0;
int n_3 = n_3 = rand() % 2, m_3 = rand() % 2, i_3 = 0;
int x_3[2] = { 260,735 };
int y_3[2] = { 160,430 };
int X_3 = x_3[n_3], Y_3 = y_3[m_3];
int count_3 = 0;

void song_object_3()
{
    yes_play_song_3 = Object::create(""Sound/Play_Song_Yes.png"", scene_3, 1150, 600); yes_play_song_3->setScale(0.5);
    yes_play_song_3->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->play(true);
        yes_play_song_3->hide();
        no_play_song_3->show();
        sound_check = 1;
        return true;
        });
    no_play_song_3 = Object::create(""Sound/Play_Song_No.png"", scene_3, 1150, 600); no_play_song_3->setScale(0.5);
    no_play_song_3->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->stop();
        no_play_song_3->hide();
        yes_play_song_3->show();
        sound_check = 0;
        return true;
        });
}

//짝수인지 아닌지 모음인지 아닌지를 판별하는 정보를 가진 오브젝트 클래스
class problem_3 {
    bool even_3;
    bool collection_3;
    ObjectPtr num_3;
    ObjectPtr word_3;
public:
    problem_3() :even_3(false), collection_3(false) {};
    problem_3(bool a, bool b, ObjectPtr c, ObjectPtr d) : even_3(a), collection_3(b), num_3(c), word_3(d) {};
    void set_3(bool a, bool b, ObjectPtr c, ObjectPtr d) {
        even_3 = a; collection_3 = b;
        num_3 = c; word_3 = d;
    }
    void show_3() {
        num_3->show();
        word_3->show();
    }
    void hide_3() {
        num_3->hide();
        word_3->hide();
    }
    void locate_3(ScenePtr scene_3, int x_3, int y_3) {
        num_3->locate(scene_3, x_3, y_3);
        word_3->locate(scene_3, x_3 + 120, y_3);
    }
    bool Is_even_3() { return even_3; }
    bool Is_collection_3() { return collection_3; }
};
problem_3 prob_3[21];

bool Is_correct_3(int X, int Y, problem_3 p) {
    if (X == x_3[0] && Y == y_3[1]) {
        if (p.Is_even_3()) return false;
        else return true;
    }
    else if (X == x_3[0] && Y == y_3[0]) {
        if (p.Is_even_3()) return true;
        else return false;
    }
    else if (X == x_3[1] && Y == y_3[0]) {
        if (p.Is_collection_3()) return true;
        else return false;
    }
    else {
        if (p.Is_collection_3()) return false;
        else return true;
    }
}

void reset_3() {
    correct_3 = 0, wrong_3 = 0, count_3 = 0;
}

std::string returnresult_3(int index) {
    return ""Your score is  "" + std::to_string(index) + "" of 20"";
}

std::string prob_image1(int index) {
    return ""Images3/숫자"" + std::to_string(index) + "".png"";
}

std::string prob_image2(int index) {
    return ""Images3/글자"" + std::to_string(index) + "".png"";
}

void init_game_3() {
    scene_3->enter();
    song_object_3();
    if (sound_check == 1)
    {
        yes_play_song_3->hide();
        no_play_song_3->show();
    }
    else
    {
        yes_play_song_3->show();
        no_play_song_3->hide();
    }
    bool tf_3[2] = { true,false };
    //문제 21개 생성
    ObjectPtr num_3;
    ObjectPtr word_3;
    char path_3[70];
    for (int i_3 = 0; i_3 < 21; i_3++) {
        bool bool1_3, bool2_3;
        bool1_3 = tf_3[rand() % 2];
        bool2_3 = tf_3[rand() % 2];
        int n1_3, n2_3;
        n1_3 = rand() % 14;
        n2_3 = rand() % 5;
        if (bool1_3) {
            num_3 = Object::create(prob_image1(n2_3 + 5), scene_3, 0, 0);
        }
        else {
            num_3 = Object::create(prob_image1(n2_3), scene_3, 0, 0);
        }

        if (bool2_3) {
            word_3 = Object::create(prob_image2(n1_3 + 14), scene_3, 0, 0);
        }
        else {
            word_3 = Object::create(prob_image2(n1_3), scene_3, 0, 0);
        }
        num_3->setScale(0.8f);
        word_3->setScale(0.8f);
        prob_3[i_3].set_3(bool1_3, bool2_3, num_3, word_3);
        prob_3[i_3].hide_3();
    }
    printf(""\n"");
    auto right_button_3 = Object::create(""Images3/같음.png"", scene_3, 10, 50);
    auto wrong_button_3 = Object::create(""Images3/다름.png"", scene_3, 990, 50);

    correct_3 = 0; wrong_3 = 0;
    n_3 = n_3 = rand() % 2; m_3 = rand() % 2, i_3 = 0;
    X_3 = x_3[n_3]; Y_3 = y_3[m_3];
    count_3 = 0;

    prob_3[0].show_3();
    prob_3[0].locate_3(scene_3, X_3, Y_3);
    scene_3->setOnKeyboardCallback([&](ScenePtr scene_3, KeyCode key, bool pressed)->bool {
        if ((count_3 % 2) && (i_3 < 20))
        {
            if (key == KeyCode::KEY_LEFT_ARROW) {
                if (Is_correct_3(X_3, Y_3, prob_3[i_3])) {
                    correct_3++;
                    printf(""%d : 0\n"", i_3 + 1);
                }
                else {
                    wrong_3++;
                    printf(""%d : X\n"", i_3 + 1);
                }
                prob_3[i_3].hide_3();
                i_3++;
                n_3 = rand() % 2;
                m_3 = rand() % 2;
                X_3 = x_3[n_3];
                Y_3 = y_3[m_3];
                prob_3[i_3].show_3();
                prob_3[i_3].locate_3(scene_3, X_3, Y_3);
            }
            else if (key == KeyCode::KEY_RIGHT_ARROW) {
                if (Is_correct_3(X_3, Y_3, prob_3[i_3])) {
                    wrong_3++;
                    printf(""%d : X\n"", i_3 + 1);
                }
                else {
                    correct_3++;
                    printf(""%d : 0\n"", i_3 + 1);
                }
                prob_3[i_3].hide_3();
                i_3++;
                n_3 = rand() % 2;
                m_3 = rand() % 2;
                X_3 = x_3[n_3];
                Y_3 = y_3[m_3];
                prob_3[i_3].show_3();
                prob_3[i_3].locate_3(scene_3, X_3, Y_3);
            }
        }
        if (i_3 == 20) {
            printf(""\n\n\n"");
            printf(""======================================================================"");
            printf(""\n\n\n"");
            printf(""correct : %d, wrong : %d\n"", correct_3, wrong_3);
            printf(""\n\n\n"");
            printf(""======================================================================"");
            printf(""\n\n\n"");
            showMessage(returnresult_3(correct_3));
            prob_3[20].hide_3();
            if (challenge) {
                challenge_show->enter();
                if (correct_3 > 14) {
                    success(3);
                    next->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        scene_4->enter();
                        init_game_4();
                        return true;
                        });
                }
                else {
                    fail(3);
                    retry->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                        reset_3();
                        prob_3[i_3].hide_3();
                        i_3 = 0;
                        init_game_3();
                        return true;
                        });
                }
            }
            else {
                prac_end->enter();
                select->setScale(0.1);
                restart_button->setScale(0.12);
                restart_button->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
                    reset_3();
                    prob_3[i_3].hide_3();
                    i_3 = 0;
                    init_game_3();
                    return true;
                    });
                select->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
                    reset_3();
                    prob_3[i_3].hide_3();
                    i_3 = 0;
                    practice_scene->enter();
                    return true;
                    });
            }
        }
        count_3++;
        return true;
        });

}

///////////////////////////////////////////////////////////////////////////////////////////////// 4번 게임 함수

ScenePtr scene_4; ScenePtr game_4;
ScenePtr scorePage_4 = Scene::create("""", ""Images4/back_ground.png"");
ScenePtr final_4 = Scene::create("""", ""Images4/back_ground.png"");
ObjectPtr yes_play_song_4 = 0;
ObjectPtr no_play_song_4 = 0;

void song_object_4()
{
    yes_play_song_4 = Object::create(""Sound/Play_Song_Yes.png"", game_4, 1150, 400); yes_play_song_4->setScale(0.5);
    yes_play_song_4->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->play(true);
        yes_play_song_4->hide();
        no_play_song_4->show();
        sound_check = 1;
        return true;
        });
    no_play_song_4 = Object::create(""Sound/Play_Song_No.png"", game_4, 1150, 400); no_play_song_4->setScale(0.5);
    no_play_song_4->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->stop();
        no_play_song_4->hide();
        yes_play_song_4->show();
        sound_check = 0;
        return true;
        });
}

ObjectPtr cards_4[28];
int emo_4[28] = { 0, }; // 카드 초기화
int arr_4[28] = { 0, }; // 카드 선택 되었는지 확인하는 배열
int unhappy_4 = rand() % 4 + 1; // 불행카드 갯수 (1~4)

int hscore_4[3] = { 10,20,30 }; // 스마일카드 점수 (셋 중 하나)
int hap_4 = hscore_4[rand() % 3];
int uscore_4[3] = { 250, 500, 750 }; // 불행카드 점수 (셋 중 하나)
int unh_4 = uscore_4[rand() % 3];

int totalScore_4 = 0; // 전체 점수
int roundScore_4 = 0; // 라운드 점수

int r_4 = 1;
int rounds_4[10]; //라운드별 점수 배열

ObjectPtr nextbutton_4 = Object::create(""Images4/arrow.png"", scorePage_4, 520, 255);

std::string indexToImage_4(int index) {
    return ""Images4/emot"" + std::to_string(emo_4[index]) + "".png"";
}

std::string hscImage_4(int hap) {
    if (hap == 10) return ""Images4/hscore0.png"";
    else if (hap == 20) return ""Images4/hscore1.png"";
    else return ""Images4/hscore2.png"";
}

std::string uscImage_4(int unh) {
    if (unh == 250) return ""Images4/uscore0.png"";
    else if (unh == 500) return ""Images4/uscore1.png"";
    else return ""Images4/uscore2.png"";
}

std::string unhImage_4(int unhappy) {
    return ""Images4/unh"" + std::to_string(unhappy) + "".png"";
}

std::string scoreToMes_4(int r, int s) {
    return std::to_string(r) + ""라운드 점수는 "" + std::to_string(s) + ""점 입니다."";
}

void shuffle_4() { // 불행카드 위치 셔플 함수
    srand((unsigned int)time(NULL));

    for (int i = 0; i < 28; i++) {
        emo_4[i] = 0;
    }

    for (int j = 0; j < unhappy_4; j++) {
        if (emo_4[rand() % 28] == 1) --j;
        else emo_4[rand() % 28] = 1;
    }
}

void init_game_4() { // 본 게임 화면
    game_4 = Scene::create("""", ""Images4/back_ground.png"");
    game_4->enter();
    srand((unsigned int)time(NULL));

    auto hsc_4 = Object::create(hscImage_4(hap_4), game_4, 950, 630);
    auto usc_4 = Object::create(uscImage_4(unh_4), game_4, 950, 570);
    auto unhap_4 = Object::create(unhImage_4(unhappy_4), game_4, 950, 510);
    auto next_4 = Object::create(""Images4/next.png"", game_4, 950, 90);
    next_4->setScale(0.4);
    song_object_4();
    if (sound_check == 1)
    {
        yes_play_song_4->hide();
        no_play_song_4->show();
    }
    else
    {
        yes_play_song_4->show();
        no_play_song_4->hide();
    }


    for (int ind = 0; ind < 28; ++ind) {
        cards_4[ind] = Object::create(""Images4/cardback.png"", game_4, 100 + (ind % 7) * (100 + 20), 40 + (ind / 7) * (150 + 20));

        cards_4[ind]->setOnMouseCallback([&, ind](auto, auto, auto, auto)->bool {
            cards_4[ind]->setImage(indexToImage_4(ind));

            if (emo_4[ind] == 0) {
                if (arr_4[ind] == 0) {
                    roundScore_4 += hap_4;
                    arr_4[ind] = 1;
                }
            }
            else {
                roundScore_4 -= unh_4;
                showMessage(""라운드 종료"");
                rounds_4[r_4 - 1] = roundScore_4;
                r_4++;
                totalScore_4 += roundScore_4;

                if (r_4 < 11) {
                    score_init_4();
                }
                else {
                    final_init_4();
                }
            }

            return true;
            });
    }

    next_4->setOnMouseCallback([&](auto, auto, auto, auto)->bool {

        rounds_4[r_4 - 1] = roundScore_4;
        totalScore_4 += roundScore_4;
        r_4++;

        if (r_4 < 11) {
            score_init_4();
        }
        else {
            final_init_4();
        }

        return true;
        });

    shuffle_4();
}

void score_init_4() { // 라운드별 점수 안내 및 다음 라운드로 넘어가기 전 화면
    scorePage_4->enter();

    nextbutton_4->show();

    showMessage(scoreToMes_4(r_4 - 1, rounds_4[r_4 - 2]));

    roundScore_4 = 0;
    hap_4 = hscore_4[rand() % 3];
    unh_4 = uscore_4[rand() % 3];
    unhappy_4 = rand() % 4 + 1;
    for (int i = 0; i < 28; i++) arr_4[i] = 0;


    nextbutton_4->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        init_game_4();
        nextbutton_4->hide();

        return true;
        });
}

std::string finalMes_4(int Total) {
    return ""최종 점수는 "" + std::to_string(Total) + ""점 입니다."";
}

void final_init_4() {  // 최종 점수 화면
    if (challenge) {
        success(4);
        challenge_show->enter();
        next->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
            scene_5->enter();
            init_game_5();
            return true;
            });
    }
    else {
        final_4->enter();

        auto restart_4 = Object::create(""Images4/restart.png"", final_4, 520, 350);
        auto select_4 = Object::create(""Images4/select_game.png"", final_4, 520, 450);
        restart_4->setScale(0.12);
        select_4->setScale(0.1);

        restart_4->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
            roundScore_4 = 0;
            hap_4 = hscore_4[rand() % 3];
            unh_4 = uscore_4[rand() % 3];
            unhappy_4 = rand() % 4 + 1;
            for (int i = 0; i < 28; i++) arr_4[i] = 0;
            r_4 = 1;
            totalScore_4 = 0; // 전체 점수
            roundScore_4 = 0; // 라운드 점수
            for (int i = 0; i < 10; i++) rounds_4[i] = 0;

            init_game_4();

            return true;
            });

        select_4->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
            //게임고르는 화면으로 돌아가는 함수
            roundScore_4 = 0;
            hap_4 = hscore_4[rand() % 3];
            unh_4 = uscore_4[rand() % 3];
            unhappy_4 = rand() % 4 + 1;
            for (int i = 0; i < 28; i++) arr_4[i] = 0;
            r_4 = 1;
            totalScore_4 = 0; // 전체 점수
            roundScore_4 = 0; // 라운드 점수
            for (int i = 0; i < 10; i++) rounds_4[i] = 0;
            practice_scene->enter();
            return true;
            });
    }
    printf(""\n\n\n"");
    printf(""======================================================================"");
    printf(""\n\n\n"");
    showMessage(finalMes_4(totalScore_4));
    printf(""\n\n\n"");
    printf(""======================================================================"");
    printf(""\n\n\n"");
}

///////////////////////////////////////////////////////////////////////////////////////////////// 5번 게임 함수

TimerPtr timer1_5, timer2_5, timer_inst_5, timer_show1_5, timer_show2_5;
ScenePtr scene_5;
ObjectPtr start_5 = 0;
ObjectPtr end_5 = 0;
ObjectPtr yes_play_song_5 = 0;
ObjectPtr no_play_song_5 = 0;
ObjectPtr notice_5 = 0;
ObjectPtr i_long_5 = 0;
ObjectPtr i_short_5 = 0;
SoundPtr song_5 = 0;
int arr_20_5[21] = { 0, }, result_your_5[40] = { 0, };
int trial_5 = 20; int count_5 = 0;
int num_right_5 = 0; int time_inc_5 = 0;

void song_object_5()
{
    yes_play_song_5 = Object::create(""Sound/Play_Song_Yes.png"", scene_5, 1150, 600); yes_play_song_5->setScale(0.5);
    yes_play_song_5->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->play(true);
        yes_play_song_5->hide();
        no_play_song_5->show();
        sound_check = 1;
        return true;
        });
    no_play_song_5 = Object::create(""Sound/Play_Song_No.png"", scene_5, 1150, 600); no_play_song_5->setScale(0.5);
    no_play_song_5->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        song->stop();
        no_play_song_5->hide();
        yes_play_song_5->show();
        sound_check = 0;
        return true;
        });
}

void reset_5() {
    trial_5 = 20; count_5 = 0;
    printf(""\n\n\n"");
    printf(""======================================================================"");
    printf(""\n\n\n"");

    srand((unsigned int)time(NULL));

    for (int i = 0; i < 40; i++)
    {
        result_your_5[i] = 0;
    }
    srand((unsigned int)time(NULL));
    for (int i_5 = 1; i_5 < 21; i_5++)
    {
        arr_20_5[i_5] = rand() % 2 + 1;
    }
    timer_inst_5 = Timer::create(42.0f);
    timer_inst_5->setOnTimerCallback([&](auto)->bool {
        makeresult_5();
        return true;
        });
    timer_inst_5->start();
    time_inc_5 = -1;
    timer1_5->set(1.95f); timer1_5->start();
    timer_show1_5->set(time_inc_5); timer_show1_5->start();
}

void makeresult_5() {
    printf(""\n\n"");
    num_right_5 = 0;
    printf(""Correct Answer is :\n\n"");
    for (int i_5 = 1; i_5 < 21; i_5++)
    {
        printf("" %d"", arr_20_5[i_5]);
    }
    printf(""\n\nYour Answer is :\n\n"");
    for (int i_5 = 0; i_5 < 40; i_5++)
    {
        if ((i_5 % 2) == 0)
        {
            printf("" %d"", result_your_5[i_5]);
        }
    }
    printf(""\n\nwhether your answer is 'o' or 'x'\n\n\n"");
    for (int i_5 = 0; i_5 < 20; i_5++)
    {
        if (arr_20_5[i_5 + 1] == result_your_5[2 * i_5])
        {
            printf("" O"");
            num_right_5++;
        }
        else
        {
            printf("" X"");
        }
    }
    start_5->show(); 
    char message_in_5[100];
    sprintf(message_in_5, ""Your score is %d out of 20 !!!"", num_right_5);
    printf(""\n\n\n"");
    printf(""======================================================================"");
    printf(""\n\n\n"");
    showMessage(message_in_5);
    if (challenge) {
        challenge_show->enter();
        if (num_right_5 > 15) {
            success(5);
            hideTimer();
            next->locate(main_scene, 0, 0);
            auto t = Timer::create(2);
            t->start();
            t->setOnTimerCallback([&](auto)->bool {
                song->stop(); song_end->play();
                showMessage(""축하합니다 모든 게임을 클리어 하셨습니다!!!"");
                com_chall->enter();
                return true;
                });
        }
        else {
            fail(5);
            hideTimer();
            retry->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
                //reset_5();
                scene_5->enter();
                return true;
                });
        }
    }
    else {
        prac_end->enter();
        set_end();
        select->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
            //reset_5();
            timer_show1_5->stop();
            hideTimer();
            practice_scene->enter();
            return true;
            });
        restart_button->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
            //reset_5();
            scene_5->enter();
            return true;
            });
    }
}

void init_game_5()
{
    song_object_5();
    if (sound_check == 1)
    {
        yes_play_song_5->hide();
        no_play_song_5->show();
    }
    else
    {
        yes_play_song_5->show();
        no_play_song_5->hide();
    }
    i_long_5 = Object::create(""Images5/i_long.png"", scene_5, 510, 230); i_long_5->setScale(0.5f); i_long_5->hide();        //0 
    i_short_5 = Object::create(""Images5/i_short.png"", scene_5, 510, 230); i_short_5->setScale(0.5f); i_short_5->hide();    //1

    scene_5->setOnKeyboardCallback([&](ScenePtr scene, KeyCode key, bool pressed)->bool {
        if (count_5 < 40)
        {
            if (key == KeyCode::KEY_LEFT_ARROW)
                result_your_5[count_5] = 1;
            if (key == KeyCode::KEY_RIGHT_ARROW)
                result_your_5[count_5] = 2;
            count_5++;
        }
        return true;
        });

    timer_show1_5 = Timer::create(time_inc_5);
    timer_show1_5->setOnTimerCallback([&](auto)->bool {
        time_inc_5++;
        timer_show2_5->set(1.95f);
        timer_show2_5->start();
        timer_show1_5->set(time_inc_5);
        showTimer(timer_show1_5);
        if (time_inc_5 > 19) {
            timer_show1_5->stop();
        }
        return true;
        });

    timer_show2_5 = Timer::create(1.95f);
    timer_show2_5->setOnTimerCallback([&](auto)->bool {
        timer_show1_5->set(0);
        timer_show1_5->start();
        if (time_inc_5 > 19) {
            timer_show1_5->stop();
        }
        return true;
        });

    timer1_5 = Timer::create(1.95f);
    timer1_5->setOnTimerCallback([&](auto)->bool {
        if (trial_5 > 0) {
            timer2_5->set(1.0f); timer2_5->start();
            timer1_5->set(1.95f);
            timer1_5->start();
        }
        trial_5--;
        i_long_5->hide();
        i_short_5->hide();
        return true;
        });

    timer2_5 = Timer::create(1.0f);
    timer2_5->setOnTimerCallback([&](auto)->bool {
        if (arr_20_5[20 - trial_5] == 1)
        {
            i_long_5->show();
        }
        if (arr_20_5[20 - trial_5] == 2)
        {
            i_short_5->show();
        }
        return true;
        });

    end_5 = Object::create(""Images5/end.png"", scene_5, 1050, 100); end_5->setScale(1.2f);
    end_5->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        endGame();
        return true;
        });
}

///////////////////////////////////////////////////////////////////////////////////////////////// mian 함수

int main()
{
    srand((unsigned int)time(NULL));
    song = Sound::create(""Sound/x-mas.mp3"");
    song_end = Sound::create(""Sound/x-end.mp3"");
    song->play(true);
    song_object();

    //게임 화면, 게임 선택장면 미리 생성
    scene_0 = Scene::create(""N_Back Game"", ""Images0/background.png"");
    scene_1 = Scene::create(""Hanoi Tower"", ""Images1/배경.jpg"");
    scene_2 = Scene::create(""Color_Word"", ""Images2/background.png"");
    scene_3 = Scene::create(""word_num"", ""Images3/배경1.png"");
    scene_4 = Scene::create(""flip_card"", ""Images4/back_ground.png"");
    scene_5 = Scene::create(""Mouth_Len"", ""Images5/background.png"");

    char path_0[50];
    for (int i = 0; i < 12; i++) {
        sprintf(path_0, ""Images0/p_blue_base%d.png"", i + 1);
        placement_0[i] = Object::create(path_0, scene_0, index_to_x_0(i), index_to_y_0(i));
        placement_0[i]->setScale(0.75);
        placement_0[i]->hide();
    };

    //처음화면 생성
    challenge_button = Object::create(""Images/challenge.png"", main_scene, 250, 150);
    challenge_button->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
        challenge = true;
        scene_0->enter();
        init_game_0();
        return true;
        });
    practice_button = Object::create(""Images/practice.png"", main_scene, 750, 150);
    practice_button->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
        challenge = false;
        practice_scene->enter();
        return true;
        });
    off = Object::create(""Images/on-off.png"", main_scene, 1150, 600);
    off->setScale(0.2f);
    off->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
        endGame();
        return true;
        });
    showMessage(""초록색 info 버튼으로 연습모드와 챌린지 모드의 차이를 알아보세요 !"");
    info = Object::create(""Images/info.png"", main_scene, 1150, 50);
    mode_info = Object::create(""Images/mode_info.png"", main_scene, 250, 10);
    mode_info->setScale(0.85f);
    mode_info->hide();
    info->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
        if (info_on == 0) {
            mode_info->show();
            info_on = 1;
        }
        else {
            mode_info->hide();
            info_on = 0;
        }

        return true;
        });
    back = Object::create(""Images/left-arrow.png"", practice_scene, 50, 650);
    back->setScale(0.12f);
    back->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
        if (intro_on == 1)
        {
            rule_image[intro_on_num]->hide();
            intro_on = 0;
        }
        else
        {
            main_scene->enter();
            if (sound_check == 1)
            {
                yes_play_song->hide();
                no_play_song->show();
            }
            else
            {
                yes_play_song->show();
                no_play_song->hide();
            }
        }
        return true;
        });

    for (int i = 0; i < 6; i++) {
        rule[i] = Object::create(""Images/game_rule.png"", practice_scene, 150 + 355 * (i % 3), 400 - 260 * (i / 3));
        start[i] = Object::create(""Images/game_start.png"", practice_scene, 250 + 355 * (i % 3), 400 - 260 * (i / 3));
        rule[i]->setScale(0.8f), start[i]->setScale(0.8f);
        rule[i]->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
            int num = choose_index(object);
            sprintf(introduce_object, ""Images/game_rule_%d.png"", num);
            rule_image[num] = Object::create(introduce_object, practice_scene, 150, 0); rule_image[num]->setScale(0.27f);
            rule_image[num]->show();
            intro_on = 1;
            intro_on_num = num;
            return true;
            });
        start[i]->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
            int num = choose_index(object);
            if (num == 0)
            {
                scene_0->enter();
                init_game_0();
            }
            if (num == 1)
            {
                scene_1->enter();
                init_game_1();
            }
            if (num == 2)
            {
                scene_2->enter();
                init_game_2();

            }
            if (num == 3)
            {
                scene_3->enter();
                init_game_3();
            }
            if (num == 4)
            {
                init_game_4();
            }
            if (num == 5)
            {
                scene_5->enter();
                init_game_5();
            }
            return true;
            });
    }
    start_5 = Object::create(""Images5/start.png"", scene_5, 1050, 150); start_5->setScale(1.2f);
    start_5->setOnMouseCallback([&](auto, auto, auto, auto)->bool {
        reset_5();
        start_5->hide();
        return true;
        });
    setGameOption(GameOption::GAME_OPTION_ROOM_TITLE, false);
    setGameOption(GameOption::GAME_OPTION_INVENTORY_BUTTON, false);
    setGameOption(GameOption::GAME_OPTION_MESSAGE_BOX_BUTTON, false);
    auto  [MASK]  = Object::create(""Images/fin_chall.png"", com_chall, 520, 150);
     [MASK] ->setScale(0.1);
     [MASK] ->setOnMouseCallback([&](ObjectPtr object, int x, int y, MouseAction action)->bool {
        endGame();
        return true;
        });
    flag->setScale(0.2);

    startGame(main_scene);
}
",end_chall
421,"#ifndef STDEX_CONFIG_H_
#define STDEX_CONFIG_H_

#include ""stdex/stdcc.h""
#include ""stdex/string.h""
#include ""stdex/crypt.h""
#include ""stdex/base64.h""
#include ""stdex/file.h""
namespace stdex {

class Config
{
public:
    int load(const string &path, const string &pem="""")
    {
        std::vector<string> lines;
        lines = stdex::file::load_lines(path);

        for (auto &line : lines)
        {
            const char *pos = line.c_str();
            int len;

            len = pass_ws(pos);
            pos += len;

            if (pos[0] != 0 && pos[0] != '#' && pos[0] != ';')
            {
				len = get_key(pos);

				if (pos[len] == '=')
				{
					string key;
					string val;

					key.assign(pos, len);
					key = trim(key);

					pos += len+1;

					len = get_value(pos);
					val.assign(pos, len);
					val = trim(val);

					_items[key] = decrypt(pem, val);
				}
            }
        }

        return 0;
    }

    inline void clear()
    {
    	_items.clear();
    }

    inline const string &get(const string &key, const string &def="""") const
    {
        auto iter = _items.find(key);

        if (iter != _items.end())
            return iter->second;

        return def;
    }

    inline int get(const string &key, int def) const
    {
        auto iter = _items.find(key);

        if (iter != _items.end())
            return std::stoi(iter->second);

        return def;
    }

    inline double get(const string &key, double def) const
    {
        auto iter = _items.find(key);

        if (iter != _items.end())
            return std::stod(iter->second.c_str());

        return def;
    }

    inline std::vector<string> get(const string &key, char  [MASK] ) const
    {
        auto iter = _items.find(key);

        if (iter != _items.end())
            return split(iter->second,  [MASK] );

        return std::vector<string>();
    }

	string decrypt(const string &pem, const string &value)
	{
		if (!pem.empty() && startof(value, ""RSA!""))
		{
#ifdef STDEX_HAS_OPENSSL
			string encrypted = value.substr(4, value.size() - 4);
			string decrypted;
			rsa_pub_decrypt(pem, stdex::Base64::decode(encrypted), decrypted);
			return std::move(decrypted);
#endif
		}

		return value;
	}

private:
    std::map<string, string> _items;

    inline int pass_ws(const char *buf)
    {
        int sum = 0;

        while (*buf != 0 && isspace(*buf))
        {
            ++sum;
            ++buf;
        }

        return sum;
    }

    int get_key(const char *buf)
    {
        int sum = 0;

        while (*buf != 0 && *buf != '=')
        {
            ++sum;
            ++buf;
        }

        return sum;
    }

    int get_value(const char *buf)
    {
        int sum = 0;

        while (*buf != 0 && *buf != '\r' && *buf != '\n')
        {
            ++sum;
            ++buf;
        }

        return sum;
    }

};

}
#endif //STDEX_CONFIG_H_
",sep
422,"/* coding=utf-8
 * Copyright (c) 2023, SUGON CORPORATION.  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 <cuda_fp16.h>
#include <hip/hip_fp16.h>
#include <torch/extension.h>
#include <torch/serialize/tensor.h>
#include <vector>
#include ""type_shim.h""

void RoPE_gpu_launch(int sq, int b, int np, int hn, at::Tensor* Q,
                     at::Tensor* cos, at::Tensor* sin, at::Tensor* q_emb);
void RoPE_backward_gpu_launch(int sq, int b, int np, int hn,
                              at::Tensor* grad_out, at::Tensor* cos,
                              at::Tensor* sin, at::Tensor* res_grad);

at::Tensor RoPE_forward_gpu(int sq, int b, int np, int hn, at::Tensor tensor_q,
                            at::Tensor tensor_cos, at::Tensor tensor_sin) {
    at::Tensor tensor_q_emb =
        at::empty({sq, b, np, hn},
                  at::device(torch::kCUDA).dtype(tensor_cos.scalar_type()));    
               
    RoPE_gpu_launch(sq, b, np, hn, &tensor_q, &tensor_cos, &tensor_sin, &tensor_q_emb);
    return tensor_q_emb;
}

at::Tensor RoPE_backward_gpu(int sq, int b, int np, int hn,
                             at::Tensor  [MASK] , at::Tensor tensor_cos,
                             at::Tensor tensor_sin) {
    at::Tensor tensor_res =
        at::empty({sq, b, np, hn},
                  at::device(torch::kCUDA).dtype(tensor_cos.scalar_type()));
    RoPE_backward_gpu_launch(sq, b, np, hn, & [MASK] , &tensor_cos,
                             &tensor_sin, &tensor_res);
    return tensor_res;
}

PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
    m.def(""forward"", &RoPE_forward_gpu, ""rotary positional embedding forward for gpu"");
    m.def(""backward"", &RoPE_backward_gpu, ""rotary positional embedding backward for gpu"");
}
",tensor_grad_out
423,"#include ""AStar.h""
AStar::AStar(void){
	currentPoint = NULL;
}
AStar::~AStar(void){}

std::list<Point> AStar::GetResultList(){
	return result;
}
void AStar::Init(Map* map){
	m_map = map;
}
void AStar::Calculate(bool isIgnoreCornor){
	//将起点加入open表
	Point start(m_map->x_start,m_map->y_start);
	openlist.push_back(&start);
	Point end(m_map->x_end,m_map->y_end);
	do{
		if(openlist.size() == 0){
			break;
		}else{
			currentPoint = FindMinF(openlist);	//找到open表中F最小的点置为当前点
			closelist.push_back(currentPoint);	//把当前点加入close表
			openlist.remove(currentPoint);		//把当前节点从open表中删除
			std::vector<Point *> surroundPoints = getSurroundPoints(currentPoint,isIgnoreCornor);	//找到当前节点周围的可到达的格子
			for(std::vector<Point *>::iterator iter = surroundPoints.begin(); iter != surroundPoints.end(); iter++){
				if(!isInList(openlist,(*iter))){
					//如果这个节点不在open中则加入open并更新其GHF
					openlist.push_back(*iter);
					Point* p1 = isInList(openlist,*iter);
					p1->G = CalG(currentPoint, p1);
					p1->H = CalH(p1);
					p1->F = CalF(p1);
					p1->parent = currentPoint;
				}else{
					//如果这个节点在open中则计算G的值，如果比原来的大则不作为，否则设置其父节点为当前节点
					int tempG = CalG(currentPoint, *iter);
					Point* p1 = isInList(openlist,*iter);
					if(tempG < p1->G){
						p1->parent = currentPoint;
						p1->G = tempG;
						p1->F = CalF(p1);
					}
				}
			}
		}
	}while(!isInList(openlist,&end) && !openlist.empty());
	//从终点回溯到起点即可得到结果表
	Point* p = NULL;
	for(PointList::iterator iter = openlist.begin(); iter != openlist.end(); iter++){
		if((*iter)->x == m_map->x_end && (*iter)->y == m_map->y_end){
			p = (*iter);
		}
	}
	while(p != NULL){
		result.push_front(*p);
		p = p->parent;
	}
}
Point* AStar::isInList(PointList &plist,Point *point){
	for(std::list<Point*>::iterator iter = plist.begin(); iter != plist.end(); iter++) 
		if((*iter)->x==point->x&&(*iter)->y==point->y) 
			return *iter; 
	return NULL;  
}
Point* AStar::FindMinF(PointList& list){
	if(!openlist.empty()){
		Point* p = *(openlist.begin());
		for(PointList::iterator iter = openlist.begin(); iter != openlist.end(); iter++){
			if((*iter)->F < p->F){
				p = (*iter);
			}
		}
		return p;
	}
	return NULL;
}
std::vector<Point *> AStar::getSurroundPoints(Point *point,bool isIgnoreCorner){
	std::vector<Point *> surroundPoints; 
	for(int x = point->x-1;x <= point->x+1;x++) 
		for(int y = point->y-1;y <= point->y+1;y++) 
			if(isReachable(point,new Point(x,y),isIgnoreCorner)) 
				surroundPoints.push_back(new Point(x,y)); 
	return surroundPoints;  
}
bool AStar::isReachable(Point* p1, Point* p2, bool isIgnoreCornor){
	bool flag;
	if(p2->x < 0 || p2->y < 0 || p2->x > m_map->M-1 || p2->y > m_map->N-1 || m_map->m_maze[p2->x][p2->y] == 1 ||
		isInList(closelist,p2) || p1->x == p2->x && p1->y == p2->y){
		flag = false;
	}else{
		if(abs(p1->x - p2->x) + abs(p1->y - p2->y) == 1){
			flag = true;
		}else{
			if(m_map->m_maze[p2->x][p1->y] == 0 && m_map->m_maze[p1->x][p2->y] == 0){
				flag = true;
			}else{
				flag = isIgnoreCornor;
			}
		}
	}
	return flag;
}
int AStar::CalF(Point* p){
	return p->G + p->H;
}
int AStar::CalG(Point* p1, Point * p2){
	int  [MASK]  = 10;
	int cost2 = 14;
	int extraG = (abs(p2->x - p1->x)+abs(p2->y - p1->y)) == 1 ?  [MASK]  : cost2; 
	int parentG = p1->parent == NULL ? 0 : p1->G; //如果是初始节点，则其父节点是空
	int sum = parentG + extraG + m_map->m_weight[p2->x][p2->y];
	return sum;
}
int AStar::CalH(Point* p){
	float dist = sqrt(pow((float)(p->x - m_map->x_end),2)+pow((float)(p->y - m_map->y_end),2));
	return dist * 10;
}",cost1
424,"//
// Created by <NAME> on 13/08/2024.
//

#include ""gipZstd.h""

#include ""zstd.h""

gipZstd::gipZstd() {
}

gipZstd::~gipZstd() {
}

void gipZstd::update() {

}

std::vector<uint8_t> gipZstd::compressString(const std::string& input, int  [MASK] , bool* outSuccess) {
	size_t maxdistsize = ZSTD_compressBound(input.size());
	std::vector<uint8_t> compresseddata(maxdistsize);

	size_t compressedsize = ZSTD_compress(
			compresseddata.data(),
			maxdistsize,
			input.data(),
			input.size(),
			 [MASK] // compression level
	);

	if (ZSTD_isError(compressedsize)) {
		if (outSuccess) *outSuccess = false;
		return {};
	}

	compresseddata.resize(compressedsize);
	if (outSuccess) *outSuccess = true;
	return compresseddata;
}

std::string gipZstd::decompressString(const std::vector<uint8_t>& compresseddata, size_t originalSize, bool* outSuccess) {
	std::vector<uint8_t> decompresseddata(originalSize);

	size_t decompressedsize = ZSTD_decompress(
			decompresseddata.data(),
			originalSize,
			compresseddata.data(),
			compresseddata.size());

	if (ZSTD_isError(decompressedsize)) {
		if (outSuccess) *outSuccess = false;
		return {};
	}

	if (outSuccess) *outSuccess = true;
	return {decompresseddata.begin(), decompresseddata.end()};
}
",compresssionLevel
425,"// System includes
#include <iostream>
#include <stdexcept>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>

// Personal includes
#include ""../includes/Game.hpp""
#include ""../includes/Constants.hpp""
#include ""../includes/Piece.hpp""

namespace Tetris {

Game::Game() : gameOver{false}, fps{60}, score{0} {
  auto [rows, cols] = this->getsTerminalSize();
  this->termWidth = cols;
  this->termHeight = rows;

  std::cout << Tetris::Constants::HIDECURSOR;

  for (int y = 0; y < Constants::HEIGHT; y++) {
    for (int x = 0; x < Constants::WIDTH; x++) {
      if (this->isFence(x, y)) {
        this->getBoard().at(y).at(x) = 1;
      } else {
        this->getBoard().at(y).at(x) = 0;
      }
    }
  }  
  this->startPiece();
}

void Game::startPiece() {
  while (this->blocks.size() < 5) {
    int type;

    do {
      type = rand() % Tetris::Constants::TYPES;
    } while (!this->blocks.empty() && type == this->blocks.back()->getType());

    this->blocks.push(Tetris::Piece::createPiece(type, Tetris::Constants::WIDTH/2 - 2, 1));
  }

  this->piece = std::move(this->blocks.front());
  this->blocks.pop();

  if (this->collided(0, 0)) { // If it spawns and already collided it's game over
    this->gameOver = !this->gameOver;
    this->showScore();
  } 
}

bool Game::isFence(const int x, const int y) const {
  return x == 0 || x == Tetris::Constants::WIDTH - 1 || y == 0 || y == Tetris::Constants::HEIGHT - 1;
}

bool Game::isABlock(const int pos) const { return 2 <= pos && pos <= 8; }

void Game::rotate() { this->piece->rotate(this->board); }

bool Game::isBlankSpace(const int pos) const { return pos == 0; }

bool Game::collided(const int offx, const int offy) const { return this->piece->collided(this->board, offx, offy); }

bool Game::isInBoard(const int x, const int y) const {
  return (x > 0 && x < Tetris::Constants::WIDTH - 1 && y > 0 && y < Tetris::Constants::HEIGHT - 1);
}

Tetris::Board& Game::getBoard() { return this->board; }

void Game::placePieceOnBoard() {
  for (int y = 0; y < Tetris::Constants::PIECESIZE; y++) {
    for (int x = 0; x < Tetris::Constants::PIECESIZE; x++) {
      if (this->isABlock(this->piece->shape[y][x])) {
        int boardY{this->piece->getY() + y};
        int boardX{this->piece->getX() + x};

        if (this->isInBoard(boardX,  boardY))
          this->getBoard().at(boardY).at(boardX) = this->piece->getType();
      }
    }
  }
}

void Game::removePieceFromBoard() {
  for (int y = 0; y < Tetris::Constants::PIECESIZE; y++) {
    for (int x = 0; x < Tetris::Constants::PIECESIZE; x++) {
      if (this->isABlock(this->piece->getShape().at(y).at(x))) {
        int boardY{this->piece->getY() + y};
        int boardX{this->piece->getX() + x};

        if (this->isInBoard(boardX, boardY))
          this->getBoard().at(boardY).at(boardX) = 0;
      }
    }
  } 
}

void Game::drawBoard() {
  std::cout << Tetris::Constants::CLEARSCREEN; 

  auto [shadowX, shadowY]{this->calculateShadowPosition()};
  this->drawPieceShadow(shadowX, shadowY);
  this->placePieceOnBoard();

  int startX{(this->termWidth - Tetris::Constants::WIDTH) / 2};

  // Moves cursor to half terminal screen
  std::cout << ""\033["" << 2 << "";"" << startX << ""H"";

  for (int y = 0; y < Constants::HEIGHT; y++) {
    std::cout << ""\033["" << (2 + y) << "";"" << startX << ""H"";

    for (int x = 0; x < Constants::WIDTH; x++) {
      if (this->getBoard().at(y).at(x) == 1) {
        std::cout << Tetris::Constants::BLOCK;
      } else if (this->getBoard().at(y).at(x) == 9) {
        std::cout << Tetris::Constants::LIGHTGRAY;
        std::cout << Tetris::Constants::SHADOW << Tetris::Constants::RESET;
      } else if (this->isABlock(this->getBoard().at(y).at(x))) {
        this->piece->draw(this->getBoard().at(y).at(x));
      } else {
        std::cout << Tetris::Constants::EMPTY;
      }
    }
    std::cout << std::endl;
  }

  this->removePieceFromBoard();
  this->removePieceShadow(shadowX, shadowY);
}

void Game::lockPiece() {
  for (int y = 0; y < Tetris::Constants::PIECESIZE; y++) {
    for (int x = 0; x < Tetris::Constants::PIECESIZE; x++) {

      int px{this->piece->getX()};
      int py{this->piece->getY()};

      if (this->isABlock(this->piece->getShape().at(y).at(x))) 
        this->getBoard().at(py + y).at(px + x) = this->piece->getType();
    }
  }
}

void Game::movePiece(const int dx, const int dy) {
  if (!this->collided(dx, dy)) {
    *this->piece += std::make_pair(dx, dy);
  } else if (dy > 0) { // Case when piece collided with last row
    lockPiece();
    this->startPiece();
  }
}

void Game::softDrop() { this->movePiece(0, 1); }

void Game::hardDrop() const { 
  auto [shadowX, shadowY]{this->calculateShadowPosition()};
  this->piece->setX(shadowX);
  this->piece->setY(shadowY);
}

void Game::run() {
  this->drawBoard();
  char key;
  while (!this->gameOver) {
    key = this->getch();
    switch(key) {
      case 'w': this->rotate(); break;
      case 'a': this->movePiece(-1, 0); break;
      case 's': this->softDrop(); break;
      case 'd': this->movePiece( 1, 0); break;
      case 'e': this->hardDrop(); break;
      case 'q': this->gameOver = !this->gameOver; break;
    }

    if (this->gameOver) {
      this->showScore();
      break;
    }

    this->clearFullRows();
    this->movePiece(0, 1);
    this->drawBoard();
    usleep(3500 * 1000 / (this->fps / 4));
  }
}

const std::pair<int, int> Game::calculateShadowPosition() const {
  int sY{this->piece->getY()};
  int sX{this->piece->getX()};

  while (!this->collided(0, sY + 1 - this->piece->getY())) sY++;
  return {sX, sY};
}


void Game::drawPieceShadow(const int shadowX, const int shadowY) {
  for (int y = 0; y < Tetris::Constants::PIECESIZE; y++) {
    for (int x = 0; x < Tetris::Constants::PIECESIZE; x++) {
      if (this->isABlock(this->piece->getShape().at(y).at(x))) {
        int boardY{shadowY + y};
        int boardX{shadowX + x};
        if (this->isInBoard(boardX, boardY)) this->getBoard().at(boardY).at(boardX) = 9;
      }
    }
  }
}

void Game::removePieceShadow(const int shadowX, const int shadowY) {
  for (int y = 0; y < Tetris::Constants::PIECESIZE; y++) {
    for (int x = 0; x < Tetris::Constants::PIECESIZE; x++) {
      if (this->isABlock(this->piece->getShape().at(y).at(x))) {
        int boardY{shadowY + y};
        int boardX{shadowX + x};
        if (this->isInBoard(boardX, boardY)) this->getBoard().at(boardY).at(boardX) = 0;
      }
    }
  } 
}

void Game::pullBlocksDown(const int startRow) {
  for (int y = startRow; y > 0; y--) {
    for (int x = 1; x <= Constants::WIDTH - 2; x++) {
      if (this->isABlock(this->getBoard().at(y).at(x))) {
        this->getBoard().at(y + 1).at(x) = this->getBoard().at(y).at(x);
        this->getBoard().at(y).at(x) = 0;
      }
    }
  } 
}

void Game::clearFullRows() {
  for (int y = Constants::HEIGHT - 2; y > 0; y--) {
    bool full{true};
    for (int x = 1; x < Constants::WIDTH - 2; x++) {
      if (this->isBlankSpace(this->getBoard().at(y).at(x))) {
        full = false;
        break;
      }
    }

    if (full) {
      // Erase the blocks which are in a full row
      for (int x = 1; x <= Constants::WIDTH - 2; x++)
        this->getBoard().at(y).at(x) = 0;
      this->pullBlocksDown(y);
      this->score += 100;
    }
  }
}

void Game::showScore() const {
  std::cout << Tetris::Constants::CLEARSCREEN;
  std::cout << ""Your final score: "" << this->score << std::endl;
  std::cout << Tetris::Constants::SHOWCURSOR;
}

const std::pair<int, int> Game::getsTerminalSize() const {
  struct winsize w;

  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == -1)
    throw std::runtime_error{""Failed to get terminal size""};

  return {w.ws_row, w.ws_col};
}

int Game::getch() const {
  int ch;
  struct termios oldattr, newattr;

  tcgetattr(STDIN_FILENO, &oldattr);
  newattr = oldattr;

  // Set terminal to no buffer or echo mode
  newattr.c_lflag &= ~(ICANON | ECHO);
  tcsetattr(STDIN_FILENO, TCSANOW, &newattr);

  // Minimun number of characters for non-blocking read
  newattr.c_cc[VMIN] = 0;

  // Make reading non-bloking
  int  [MASK]  = fcntl(STDIN_FILENO, F_GETFL, 0);
  fcntl(STDIN_FILENO, F_SETFL,  [MASK]  | O_NONBLOCK);

  // Read input
  int lastChar;
  while ((lastChar = getchar()) != EOF) {
    ch = lastChar;
  }

  return ch; 
}
}
",oldFlags
426,"#include ""../Library/ds3231.hpp""

int main( void ){	   
   WDT->WDT_MR = WDT_MR_WDDIS; //Kill the watch dog

   namespace target = hwlib::target;
   
   const char *states[6] = {""Minutes"", ""Hours"", ""Day"", ""Date"", ""Month"", ""Year""}; //Array with all the states the user can choose to change
   const char *days[7]  = {""Monday"", ""Tuesday"", ""Wednesday"", ""Thursday"", ""Friday"", ""Saturday"", ""Sunday""}; //array of all the days

   auto scl = target::pin_oc( target::pins::scl ); //scl pin
   auto sda = target::pin_oc( target::pins::sda ); //sda pin
   auto i2c_Bus = hwlib::i2c_bus_bit_banged_scl_sda(scl,sda); //i2c bus

   auto oled    = hwlib::glcd_oled( i2c_Bus, 0x3c ); 
   auto font    = hwlib::font_default_8x8();
   auto display = hwlib::terminal_from( oled, font );

   auto leftSw = target::pin_in_out( target::pins::d22 ); //Left switch
   auto oke = target::pin_in_out( target::pins::d33 ); //Oke switch
   auto rightSw = target::pin_in_out( target::pins::d32 ); //Right switch

   ds3231  [MASK]  = (i2c_Bus);

   int state = 0;

    [MASK] .setTime(1,1,1,1,1,1,1); //sets the time

   for(;;){     
   display //Displays the time on the oled
      << ""\f"" <<  [MASK] .getHours() << "":"" <<  [MASK] .getMinutes() << "":"" <<  [MASK] .getSeconds()  
      << ""\n"" << days[ [MASK] .getDay() - 1]
      << ""\t0404"" <<  [MASK] .getDate() << ""-"" <<  [MASK] .getMonth() << ""-"" << ( [MASK] .getYear() + 2000) 
      << ""\t0406"" << states[state]
      << hwlib::flush; 

      if(!leftSw.read()){ //Checks if the left switch is pressed
         if(state <= 0){ //Checks what states it is on  
            state = 5;
         }
         else{
            state -= 1;
         }
      }  
      else if(!oke.read()){ //Checks if the Oke switch is pressed
         hwlib::wait_ms(1000);
         while(true){
            if(state == 0){ //Checks what state it is on and changes the time if needed. This counts for all the states
               if(!rightSw.read()){
                   [MASK] .setMinutes( [MASK] .getMinutes() + 1);
               }
               else if(!leftSw.read()){
                   [MASK] .setMinutes( [MASK] .getMinutes() - 1);
               }
               else if(!oke.read()){
                  break;
               }
            }
            if(state == 1){
               if(!rightSw.read()){
                   [MASK] .setHours( [MASK] .getHours() + 1);
               }
               else if(!leftSw.read()){
                   [MASK] .setHours( [MASK] .getHours() - 1);
               }
               else if(!oke.read()){
                  break;
               }
            }
            if(state == 2){
               if(!rightSw.read()){
                   [MASK] .setDay( [MASK] .getDay() + 1);
               }
               else if(!leftSw.read()){
                   [MASK] .setDay( [MASK] .getDay() - 1);
               }
               else if(!oke.read()){
                  break;
               }
            }
            if(state == 3){
               if(!rightSw.read()){
                   [MASK] .setDate( [MASK] .getDate() + 1);
               }
               else if(!leftSw.read()){
                   [MASK] .setDate( [MASK] .getDate() - 1);
               }
               else if(!oke.read()){
                  break;
               }
            }
            if(state == 4){
               if(!rightSw.read()){
                   [MASK] .setMonth( [MASK] .getMonth() + 1);
               }
               else if(!leftSw.read()){
                   [MASK] .setMonth( [MASK] .getMonth() - 1);
               }
               else if(!oke.read()){
                  break;
               }
            }
            if(state == 5){
               if(!rightSw.read()){
                   [MASK] .setYear( [MASK] .getYear() + 1);
               }
               else if(!leftSw.read()){
                   [MASK] .setYear( [MASK] .getYear() - 1);
               }
               else if(!oke.read()){
                  break;
               }
            }
            
            display //Displays the time
               << ""\f"" <<  [MASK] .getHours() << "":"" <<  [MASK] .getMinutes() << "":"" <<  [MASK] .getSeconds()  
               << ""\n"" << days[ [MASK] .getDay() - 1]
               << ""\t0404"" <<  [MASK] .getDate() << ""-"" <<  [MASK] .getMonth() << ""-"" << ( [MASK] .getYear() + 2000) 
               << ""\t0406"" << states[state]
               << hwlib::flush;
         }
      }

      else if(!rightSw.read()){ //The same as the left switch but with the right switch
         if(state >= 5){ 
            state = 0;
         }
         else{
            state += 1;
         }
      }  
   }  
}",clock
427,"/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * 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 ""device_sm_exporter.h""

#include <cerrno>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <dirent.h>
#include <fcntl.h>
#include <stack>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <vector>

#include ""../common/ability_helper.h""
#include ""../common/common_func.h""
#include ""../common/napi/n_class.h""
#include ""../common/napi/n_func_arg.h""
#include ""../common/napi/n_val.h""
#include ""../common/uni_error.h""
#include ""device_storage_manager.h""

using Uri = OHOS::Uri;
using namespace std;
namespace OHOS {
namespace DistributedFS {
namespace ModuleDSMExpoter {
enum COMMON_NUM {
    ZERO = 0,
    ONE = 1,
    TWO = 2,
    THREE = 3,
};
const int ERROR = 300;
const int NULL_ERROR = 202;

static void ForeachVomInfos(std::vector<std::shared_ptr<OHOS::DS::VolumeInfo>> &infos,
                            napi_env &env,
                            napi_value &getvolumenapi,
                            int32_t &userId) {
    int32_t i = 0;
    
    for (auto vomInfo : infos) {
        NVal objv = NVal::CreateObject(env);
        objv.AddProp(""mId"", NVal::CreateUTF8String(env, vomInfo->GetId()).val_);
        objv.AddProp(""mDiskId"", NVal::CreateUTF8String(env, vomInfo->GetDiskId()).val_);
        objv.AddProp(""mPartGuid"", NVal::CreateUTF8String(env, vomInfo->GetPartGuid()).val_);
        objv.AddProp(""mFsUuid"", NVal::CreateUTF8String(env, vomInfo->GetFsUuid()).val_);
        objv.AddProp(""mType"", NVal::CreateInt64(env, vomInfo->GetType()).val_);
        objv.AddProp(""mMountFlags"", NVal::CreateInt64(env, vomInfo->GetMountFlags()).val_);
        objv.AddProp(""mMountUserId"", NVal::CreateInt64(env, vomInfo->GetMountUserId()).val_);
        objv.AddProp(""mState"", NVal::CreateInt64(env, vomInfo->GetState()).val_);
        objv.AddProp(""mPath"", NVal::CreateUTF8String(env, vomInfo->GetPath()).val_);
        objv.AddProp(""mInternalPath"", NVal::CreateUTF8String(env, vomInfo->GetInternalPath()).val_);
        objv.AddProp(""mFsLabel"", NVal::CreateUTF8String(env, vomInfo->GetFsLabel()).val_);
        objv.AddProp(""IsEmulated"", NVal::CreateBool(env, vomInfo->IsEmulated()).val_);
        objv.AddProp(""IsPrimaryEmulatedForUser"",
                     NVal::CreateBool(env, vomInfo->IsPrimaryEmulatedForUser(userId)).val_);
        objv.AddProp(""IsRemovable"", NVal::CreateBool(env, vomInfo->IsRemovable(userId)).val_);
        objv.AddProp(""IsPrimary"", NVal::CreateBool(env, vomInfo->IsPrimary()).val_);
        objv.AddProp(""Description"", NVal::CreateUTF8String(env, vomInfo->GetDescription()).val_);
        objv.AddProp(""IsVisibleForUser"", NVal::CreateBool(env, vomInfo->IsVisibleForUser(userId)).val_);

        napi_set_property(env, getvolumenapi, NVal::CreateInt32(env, i).val_, objv.val_);
        i++;
    }
}

static void ForeachDsmInfos(std::vector<std::shared_ptr<OHOS::DS::DiskInfo>> &infos, napi_env &env, napi_value &diaknapi) {
    int32_t i = 0;
    
    for (auto dsmInfo : infos) {
        NVal objt = NVal::CreateObject(env);
        objt.AddProp(""mId"", NVal::CreateUTF8String(env, dsmInfo->GetId()).val_);
        objt.AddProp(""mSysPath"", NVal::CreateUTF8String(env, dsmInfo->GetSysPath()).val_);
        objt.AddProp(""mSize"", NVal::CreateInt64(env, dsmInfo->GetSize()).val_);
        objt.AddProp(""mLabel"", NVal::CreateUTF8String(env, dsmInfo->GetLabel()).val_);
        objt.AddProp(""mFlags"", NVal::CreateInt64(env, dsmInfo->GetFlags()).val_);
        objt.AddProp(""IsUsb"", NVal::CreateBool(env, dsmInfo->IsUsb()).val_);
        objt.AddProp(""IsSd"", NVal::CreateBool(env, dsmInfo->IsSd()).val_);
        objt.AddProp(""IsAdoptable"", NVal::CreateBool(env, dsmInfo->IsAdoptable()).val_);
        objt.AddProp(""Description"", NVal::CreateUTF8String(env, dsmInfo->GetDescription()).val_);

        napi_set_property(env, diaknapi, NVal::CreateInt32(env, i).val_, objt.val_);
        i++;
    }
}

void CallBackSuccess(napi_env env, napi_ref successFuncRef, int32_t count, napi_value obj)
{
    napi_value results = nullptr;
    napi_value successFunc = nullptr;
    napi_value global = nullptr;
    napi_get_global(env, &global);
    napi_get_reference_value(env, successFuncRef, &successFunc);
    if (successFunc == nullptr) {
        return;
    }
    napi_call_function(env, global, successFunc, count, &obj, &results);
}
void CallBackError(napi_env env, napi_ref failFuncRef, string errorProp, int errorCode)
{
    napi_value argvFail[2] = { 0 };
    napi_value results = nullptr;
    napi_value failFunc = nullptr;
    napi_value global = nullptr;
    napi_get_global(env, &global);
    argvFail[0] = NVal::CreateUTF8String(env, errorProp).val_;
    argvFail[1] = NVal::CreateInt32(env, errorCode).val_;
    napi_get_reference_value(env, failFuncRef, &failFunc);
    if (failFunc == nullptr) {
        return;
    }
    napi_call_function(env, global, failFunc, COMMON_NUM::TWO, argvFail, &results);
}
void CallComplete(napi_env env, napi_ref  [MASK] )
{
    napi_value completeFunc = nullptr;
    napi_value results = nullptr;
    napi_value global = nullptr;
    napi_get_global(env, &global);
    napi_get_reference_value(env,  [MASK] , &completeFunc);
    if (completeFunc == nullptr) {
        return;
    }
    napi_call_function(env, global, completeFunc, COMMON_NUM::ZERO, nullptr, &results);
}

std::shared_ptr<DeviceStorageManager> dsm = DelayedSingleton<DeviceStorageManager>::GetInstance();
int32_t userId;
napi_value VolumesToNapi(napi_env env, std::vector<std::shared_ptr<DS::VolumeInfo>> infos)
{
    napi_value getvolumenapi;
    napi_create_array(env, &getvolumenapi);
    ForeachVomInfos(infos, env, getvolumenapi, userId);
    return getvolumenapi;
}

void PriVolToEmuVol(napi_env env, NVal a, std::shared_ptr<DS::VolumeInfo> &emuVol)
{
    bool succ = false;

    unique_ptr<char[]> id = nullptr;
    tie(succ, id, ignore) = a.GetProp(""mId"").ToUTF8String();
    string cId = (id == nullptr) ? """" : id.get();
    emuVol->SetId(cId);

    unique_ptr<char[]> diskId = nullptr;
    tie(succ, diskId, ignore) = a.GetProp(""mDiskId"").ToUTF8String();
    emuVol->SetDiskId((diskId == nullptr) ? """" : diskId.get());

    int64_t type = 0;
    tie(succ, type) = a.GetProp(""mType"").ToInt64();
    emuVol->SetType(type);

    unique_ptr<char[]> partGuid = nullptr;
    tie(succ, partGuid, ignore) = a.GetProp(""mPartGuid"").ToUTF8String();
    emuVol->SetPartGuid((partGuid == nullptr) ? """" : partGuid.get());

    int64_t mountFlags = 0;
    tie(succ, mountFlags) = a.GetProp(""mMountFlags"").ToInt64();
    emuVol->SetMountFlags(mountFlags);

    int64_t mountUserId = 0;
    tie(succ, mountUserId) = a.GetProp(""mMountUserId"").ToInt64();
    emuVol->SetMountUserId(mountUserId);

    unique_ptr<char[]> path = nullptr;
    tie(succ, path, ignore) = a.GetProp(""mPath"").ToUTF8String();
    emuVol->SetPath((path == nullptr) ? """" : path.get());

    unique_ptr<char[]> internalPath = nullptr;
    tie(succ, internalPath, ignore) = a.GetProp(""mInternalPath"").ToUTF8String();
    emuVol->SetInternalPath((internalPath == nullptr) ? """" : internalPath.get());

    unique_ptr<char[]> fsType = nullptr;
    tie(succ, fsType, ignore) = a.GetProp(""mFsType"").ToUTF8String();
    emuVol->SetFsUuid((fsType == nullptr) ? """" : fsType.get());

    unique_ptr<char[]> fsUuid = nullptr;
    tie(succ, fsUuid, ignore) = a.GetProp(""mFsUuid"").ToUTF8String();
    emuVol->SetFsUuid((fsUuid == nullptr) ? """" : fsUuid.get());

    unique_ptr<char[]> fsLabel = nullptr;
    tie(succ, fsLabel, ignore) = a.GetProp(""mFsLabel"").ToUTF8String();
    string tId = (fsLabel == nullptr) ? """" : fsLabel.get();
    emuVol->SetFsLabel(tId);

    int64_t state = 0;
    tie(succ, state) = a.GetProp(""mState"").ToInt64();
    emuVol->SetState(state);
}

void EmuVolToPriVol(napi_env env, NVal a, std::shared_ptr<DS::VolumeInfo> &priVol)
{
    bool succ = false;

    unique_ptr<char[]> id = nullptr;
    tie(succ, id, ignore) = a.GetProp(""mId"").ToUTF8String();
    string cId = (id == nullptr) ? """" : id.get();
    priVol->SetId(cId);

    unique_ptr<char[]> diskId = nullptr;
    tie(succ, diskId, ignore) = a.GetProp(""mDiskId"").ToUTF8String();
    priVol->SetDiskId((diskId == nullptr) ? """" : diskId.get());

    int64_t type = 0;
    tie(succ, type) = a.GetProp(""mType"").ToInt64();
    priVol->SetType(type);

    unique_ptr<char[]> partGuid = nullptr;
    tie(succ, partGuid, ignore) = a.GetProp(""mPartGuid"").ToUTF8String();
    priVol->SetPartGuid((partGuid == nullptr) ? """" : partGuid.get());

    int64_t mountFlags = 0;
    tie(succ, mountFlags) = a.GetProp(""mMountFlags"").ToInt64();
    priVol->SetMountFlags(mountFlags);

    int64_t mountUserId = 0;
    tie(succ, mountUserId) = a.GetProp(""mMountUserId"").ToInt64();
    priVol->SetMountUserId(mountUserId);

    unique_ptr<char[]> path = nullptr;
    tie(succ, path, ignore) = a.GetProp(""mPath"").ToUTF8String();
    priVol->SetPath((path == nullptr) ? """" : path.get());

    unique_ptr<char[]> internalPath = nullptr;
    tie(succ, internalPath, ignore) = a.GetProp(""mInternalPath"").ToUTF8String();
    priVol->SetInternalPath((internalPath == nullptr) ? """" : internalPath.get());

    unique_ptr<char[]> fsType = nullptr;
    tie(succ, fsType, ignore) = a.GetProp(""mFsType"").ToUTF8String();
    priVol->SetFsUuid((fsType == nullptr) ? """" : fsType.get());

    unique_ptr<char[]> fsUuid = nullptr;
    tie(succ, fsUuid, ignore) = a.GetProp(""mFsUuid"").ToUTF8String();
    priVol->SetFsUuid((fsUuid == nullptr) ? """" : fsUuid.get());

    unique_ptr<char[]> fsLabel = nullptr;
    tie(succ, fsLabel, ignore) = a.GetProp(""mFsLabel"").ToUTF8String();
    string tId = (fsLabel == nullptr) ? """" : fsLabel.get();
    priVol->SetFsLabel(tId);

    int64_t state = 0;
    tie(succ, state) = a.GetProp(""mState"").ToInt64();
    priVol->SetState(state);
}

void VolToDesCription(napi_env env, NVal a, std::shared_ptr<DS::VolumeInfo> &vol)
{
    bool succ = false;

    unique_ptr<char[]> id = nullptr;
    tie(succ, id, ignore) = a.GetProp(""mId"").ToUTF8String();
    string cId = (id == nullptr) ? """" : id.get();
    vol->SetId(cId);

    unique_ptr<char[]> diskId = nullptr;
    tie(succ, diskId, ignore) = a.GetProp(""mDiskId"").ToUTF8String();
    vol->SetDiskId((diskId == nullptr) ? """" : diskId.get());

    int64_t type = 0;
    tie(succ, type) = a.GetProp(""mType"").ToInt64();
    vol->SetType(type);

    unique_ptr<char[]> partGuid = nullptr;
    tie(succ, partGuid, ignore) = a.GetProp(""mPartGuid"").ToUTF8String();
    vol->SetPartGuid((partGuid == nullptr) ? """" : partGuid.get());

    int64_t mountFlags = 0;
    tie(succ, mountFlags) = a.GetProp(""mMountFlags"").ToInt64();
    vol->SetMountFlags(mountFlags);

    int64_t mountUserId = 0;
    tie(succ, mountUserId) = a.GetProp(""mMountUserId"").ToInt64();
    vol->SetMountUserId(mountUserId);

    unique_ptr<char[]> path = nullptr;
    tie(succ, path, ignore) = a.GetProp(""mPath"").ToUTF8String();
    vol->SetPath((path == nullptr) ? """" : path.get());

    unique_ptr<char[]> internalPath = nullptr;
    tie(succ, internalPath, ignore) = a.GetProp(""mInternalPath"").ToUTF8String();
    vol->SetInternalPath((internalPath == nullptr) ? """" : internalPath.get());

    unique_ptr<char[]> fsType = nullptr;
    tie(succ, fsType, ignore) = a.GetProp(""mFsType"").ToUTF8String();
    vol->SetFsUuid((fsType == nullptr) ? """" : fsType.get());

    unique_ptr<char[]> fsUuid = nullptr;
    tie(succ, fsUuid, ignore) = a.GetProp(""mFsUuid"").ToUTF8String();
    vol->SetFsUuid((fsUuid == nullptr) ? """" : fsUuid.get());

    unique_ptr<char[]> fsLabel = nullptr;
    tie(succ, fsLabel, ignore) = a.GetProp(""mFsLabel"").ToUTF8String();
    string tId = (fsLabel == nullptr) ? """" : fsLabel.get();
    vol->SetFsLabel(tId);

    int64_t state = 0;
    tie(succ, state) = a.GetProp(""mState"").ToInt64();
    vol->SetState(state);
}

napi_value DeviceSMExporter::Mount(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""volId"").ToUTF8String();

    std::string mvId = (deviceId == nullptr) ? """" : deviceId.get();
    if (mvId == """") {
        CallBackError(env, napiFailFun, ""Mount incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    bool s = dsm->Mount(mvId);
    if (s) {
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
    } else {
        CallBackError(env, napiFailFun, ""Mount return value error"", ERROR);
    }
    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::UnMount(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""volId"").ToUTF8String();

    std::string mvId = (deviceId == nullptr) ? """" : deviceId.get();
    if (mvId == """") {
        CallBackError(env, napiFailFun, ""UnMount  incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    bool s = dsm->UnMount(mvId);
    if (s) {
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
    } else {
        CallBackError(env, napiFailFun, ""UnMount return value error"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::Format(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""volId"").ToUTF8String();

    std::string mvId = (deviceId == nullptr) ? """" : deviceId.get();
    if (mvId == """") {
        CallBackError(env, napiFailFun, ""Format incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    bool s = dsm->Format(mvId);
    if (s) {
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
    } else {
        CallBackError(env, napiFailFun, ""Format fail"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::IsEncrypted(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> devfilePath = nullptr;
    tie(succ, devfilePath, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""filePath"").ToUTF8String();

    std::string mFilePath = (devfilePath == nullptr) ? """" : devfilePath.get();
    if (mFilePath == """") {
        CallBackError(env, napiFailFun, ""IsEncrypted incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    bool s = dsm->IsEncrypted(mFilePath);
    if (s) {
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
    } else {
        CallBackError(env, napiFailFun, ""Not A Encrypted Path"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}
napi_value DeviceSMExporter::PartitionPublic(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""diskId"").ToUTF8String();

    std::string dsId = (deviceId == nullptr) ? """" : deviceId.get();
    if (dsId == """") {
        CallBackError(env, napiFailFun, ""PartitionPublic incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    bool s = dsm->PartitionPublic(dsId);
    if (s) {
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
    } else {
        CallBackError(env, napiFailFun, ""PartitionPublic fail"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::PartitionPrivate(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""diskId"").ToUTF8String();

    std::string dsId = (deviceId == nullptr) ? """" : deviceId.get();
    if (dsId == """") {
        CallBackError(env, napiFailFun, ""PartitionPrivate incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    bool s = dsm->PartitionPrivate(dsId);
    if (s) {
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
    } else {
        CallBackError(env, napiFailFun, ""PartitionPrivate fail"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::GetVolumes(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
    bool ret = dsm->GetVolumes(infos);
    if (ret) {
        napi_value getvolumenapi = VolumesToNapi(env, infos);

        NVal objc = NVal::CreateObject(env);
        objc.AddProp(""volumeInfos"", getvolumenapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
    } else {
        CallBackError(env, napiFailFun, ""getvolume not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::GetDisks(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    std::vector<std::shared_ptr<DS::DiskInfo>> infos;
    bool ret = dsm->GetDisks(infos);
    if (ret) {
        napi_value diaknapi;
        napi_create_array(env, &diaknapi);
        ForeachDsmInfos(infos, env, diaknapi);
        NVal objn = NVal::CreateObject(env);
        objn.AddProp(""diskInfos"", diaknapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objn.val_);
    } else {
        CallBackError(env, napiFailFun, ""disk not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::SetPrimaryStorageUuid(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""volumeUuid"").ToUTF8String();
    std::string vuId = (deviceId == nullptr) ? """" : deviceId.get();
    if (vuId == """") {
        CallBackError(env, napiFailFun, ""SetPrimaryStorageUuid incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    bool s = dsm->SetPrimaryStorageUuid(vuId);
    if (s) {
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
    } else {
        CallBackError(env, napiFailFun, ""SetPrimaryStorageUuid fail"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::FindVolumeById(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""volId"").ToUTF8String();

    std::string mvId = (deviceId == nullptr) ? """" : deviceId.get();
    if (mvId == """") {
        CallBackError(env, napiFailFun, ""FindVolumeById incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    std::shared_ptr<DS::VolumeInfo> vol;
    bool ret = dsm->FindVolumeById(vol, mvId);
    if (ret) {
        napi_value getvolumenapi;
        napi_create_array(env, &getvolumenapi);
        std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
        dsm->GetVolumes(infos);
        ForeachVomInfos(infos, env, getvolumenapi, userId);
        NVal objc = NVal::CreateObject(env);
        objc.AddProp(""volumeInfos"", getvolumenapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
    } else {
        CallBackError(env, napiFailFun, ""FindVolumeById not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::FindVolumeByUuid(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""volumeUuid"").ToUTF8String();

    std::string mvmId = (deviceId == nullptr) ? """" : deviceId.get();
    if (mvmId == """") {
        CallBackError(env, napiFailFun, ""FindVolumeByUuid incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    std::shared_ptr<DS::VolumeInfo> vol;
    if (dsm->FindVolumeByUuid(vol, mvmId)) {
        napi_value getvolumenapi;
        napi_create_array(env, &getvolumenapi);
        std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
        dsm->GetVolumes(infos);
        ForeachVomInfos(infos, env, getvolumenapi, userId);
        NVal objc = NVal::CreateObject(env);
        objc.AddProp(""volumeInfos"", getvolumenapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
    } else {
        CallBackError(env, napiFailFun, ""FindVolumeByUuid not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::FindDiskById(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    unique_ptr<char[]> deviceId = nullptr;
    tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""diskId"").ToUTF8String();

    std::string dsId = (deviceId == nullptr) ? """" : deviceId.get();
    if (dsId == """") {
        CallBackError(env, napiFailFun, ""FindDiskById incoming parameter is null"", NULL_ERROR);
        CallComplete(env, napiCompFun);
        napi_delete_reference(env, napiSuccFun);
        napi_delete_reference(env, napiFailFun);
        napi_delete_reference(env, napiCompFun);
        return nullptr;
    }

    std::shared_ptr<DS::DiskInfo> disk;
    if (dsm->FindDiskById(disk, dsId)) {
        napi_value diaknapi;
        napi_create_array(env, &diaknapi);
        std::vector<std::shared_ptr<DS::DiskInfo>> infos;
        dsm->GetDisks(infos);
        ForeachDsmInfos(infos, env, diaknapi);
        NVal objn = NVal::CreateObject(env);
        objn.AddProp(""diskInfos"", diaknapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objn.val_);
    } else {
        CallBackError(env, napiFailFun, ""FindDiskById not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::GetPrimaryStorageUuid(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    std::string primaryUuid;
    bool s = dsm->GetPrimaryStorageUuid(primaryUuid);
    if (s) {
        NVal obj = NVal::CreateObject(env);
        obj.AddProp(""primaryUuid"", NVal::CreateUTF8String(env, primaryUuid).val_);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, obj.val_);
    } else {
        CallBackError(env, napiFailFun, ""GetPrimaryStorageUuid return value error"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::FindPrivateForEmulate(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    std::shared_ptr<DS::VolumeInfo> emuVol = std::make_shared<DS::VolumeInfo>();

    NVal a = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""emuVol"");
    if (a.TypeIs(napi_object)) {
    } else if (a.TypeIs(napi_undefined)) {
    } else if (a.TypeIs(napi_null)) {
    }

    PriVolToEmuVol(env, a, emuVol);
    std::shared_ptr<DS::VolumeInfo> priVol;
    bool ret = dsm->FindPrivateForEmulate(priVol, emuVol);
    if (ret) {
        napi_value getvolumenapi;
        napi_create_array(env, &getvolumenapi);
        std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
        dsm->GetVolumes(infos);
        ForeachVomInfos(infos, env, getvolumenapi, userId);
        NVal objc = NVal::CreateObject(env);
        objc.AddProp(""volumeInfos"", getvolumenapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
    } else {
        CallBackError(env, napiFailFun, ""FindPrivateForEmulate not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::FindEmulateForPrivate(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    std::shared_ptr<DS::VolumeInfo> priVol = std::make_shared<DS::VolumeInfo>();

    NVal a = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""priVol"");
    if (a.TypeIs(napi_object)) {
    } else if (a.TypeIs(napi_undefined)) {
    } else if (a.TypeIs(napi_null)) {
    }

    EmuVolToPriVol(env, a, priVol);
    std::shared_ptr<DS::VolumeInfo> emuVol;
    bool ret = dsm->FindEmulateForPrivate(emuVol, priVol);
    if (ret) {
        napi_value getvolumenapi;
        napi_create_array(env, &getvolumenapi);
        std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
        dsm->GetVolumes(infos);
        ForeachVomInfos(infos, env, getvolumenapi, userId);
        NVal objc = NVal::CreateObject(env);
        objc.AddProp(""volumeInfos"", getvolumenapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
    } else {
        CallBackError(env, napiFailFun, ""FindEmulateForPrivate not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::GetBestVolumeDescription(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    std::shared_ptr<DS::VolumeInfo> vol = std::make_shared<DS::VolumeInfo>();

    NVal a = NVal(env, funcArg[NARG_POS::FIRST]).GetProp(""vol"");
    if (a.TypeIs(napi_object)) {
    } else if (a.TypeIs(napi_undefined)) {
    } else if (a.TypeIs(napi_null)) {
    }

    VolToDesCription(env, a, vol);

    std::string desCription;
    bool s = dsm->GetBestVolumeDescription(vol, desCription);
    if (s) {
        NVal obj = NVal::CreateObject(env);
        obj.AddProp(""desCription"", NVal::CreateUTF8String(env, vol->GetDescription()).val_);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, obj.val_);
    } else {
        CallBackError(env, napiFailFun, ""GetBestVolumeDescription return value error"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

napi_value DeviceSMExporter::GetWritableVolumes(napi_env env, napi_callback_info info)
{
    NFuncArg funcArg(env, info);
    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
        UniError(EINVAL).ThrowErr(env, ""Number of arguments unmatched"");
        return nullptr;
    }
    bool succ = false;
    napi_ref napiSuccFun, napiCompFun, napiFailFun;
    tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
        CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);

    std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
    bool ret = dsm->GetWritableVolumes(infos);
    if (ret) {
        napi_value getvolumenapi;
        napi_create_array(env, &getvolumenapi);
        ForeachVomInfos(infos, env, getvolumenapi, userId);
        NVal objc = NVal::CreateObject(env);
        objc.AddProp(""volumeInfos"", getvolumenapi);
        CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
    } else {
        CallBackError(env, napiFailFun, ""GetWritableVolumes not exist"", ERROR);
    }

    CallComplete(env, napiCompFun);
    napi_delete_reference(env, napiSuccFun);
    napi_delete_reference(env, napiFailFun);
    napi_delete_reference(env, napiCompFun);
    return NVal::CreateUndefined(env).val_;
}

bool DeviceSMExporter::Export()
{
    return exports_.AddProp({
        NVal::DeclareNapiFunction(""mount"", Mount),
        NVal::DeclareNapiFunction(""unMount"", UnMount),
        NVal::DeclareNapiFunction(""format"", Format),
        NVal::DeclareNapiFunction(""partitionPublic"", PartitionPublic),
        NVal::DeclareNapiFunction(""partitionPrivate"", PartitionPrivate),
        NVal::DeclareNapiFunction(""getVolumes"", GetVolumes),
        NVal::DeclareNapiFunction(""getDisks"", GetDisks),
        NVal::DeclareNapiFunction(""setPrimaryStorageUuid"", SetPrimaryStorageUuid),
        NVal::DeclareNapiFunction(""findVolumeById"", FindVolumeById),
        NVal::DeclareNapiFunction(""findVolumeByUuid"", FindVolumeByUuid),
        NVal::DeclareNapiFunction(""findDiskById"", FindDiskById),
        NVal::DeclareNapiFunction(""getPrimaryStorageUuid"", GetPrimaryStorageUuid),
        NVal::DeclareNapiFunction(""findPrivateForEmulate"", FindPrivateForEmulate),
        NVal::DeclareNapiFunction(""findEmulateForPrivate"", FindEmulateForPrivate),
        NVal::DeclareNapiFunction(""getWritableVolumes"", GetWritableVolumes),
        NVal::DeclareNapiFunction(""getBestVolumeDescription"", GetBestVolumeDescription),
        NVal::DeclareNapiFunction(""isEncrypted"", IsEncrypted),
    });
}

string DeviceSMExporter::GetClassName()
{
    return DeviceSMExporter::className_;
}

DeviceSMExporter::DeviceSMExporter(napi_env env, napi_value exports)
    : NExporter(env, exports)
{}

DeviceSMExporter::~DeviceSMExporter() {}
} // namespace ModuleDSMExpoter
} // namespace DistributedFS
} // namespace OHOS
",completeFuncRef
428,"/*  This file is part of distributed Structured Prediction (dSP) - http://www.alexander-schwing.de/
 *
 *  distributed Structured Prediction (dSP) is free software: you can
 *  redistribute it and/or modify it under the terms of the GNU General
 *  Public License as published by the Free Software Foundation, either
 *  version 3 of the License, or (at your option) any later version.
 *
 *  distributed Structured Prediction (dSP) 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with distributed Structured Prediction (dSP).
 *  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Copyright (C) 2010-2013  <NAME>  [http://www.alexander-schwing.de/]
 */

//Author: <NAME>

#ifndef __CPRECISIONTIMER_H__
#define __CPRECISIONTIMER_H__

//#define NO_C11

#ifdef NO_C11
#ifdef _MSC_VER
#include <windows.h>
#else
#include <sys/time.h>
#endif
#else
#include <chrono>
#endif

class CPrecisionTimer
{
#ifdef NO_C11
#ifdef USE_ON_WINDOWS
    LARGE_INTEGER lFreq, lStart;
#else
    timeval lStart;
#endif
#else
    std::chrono::high_resolution_clock::time_point lStart;
#endif

public:
    CPrecisionTimer()
    {
#ifdef NO_C11
#ifdef USE_ON_WINDOWS
        QueryPerformanceFrequency(&lFreq);
#endif
#endif
    }

    inline void Start()
    {
#ifdef NO_C11
#ifdef USE_ON_WINDOWS
        QueryPerformanceCounter(&lStart);
#else
        gettimeofday(&lStart, 0);
#endif
#else
        lStart = std::chrono::high_resolution_clock::now();
#endif
    }

    inline double Stop()
    {
        // Return duration in seconds...
#ifdef NO_C11
#ifdef USE_ON_WINDOWS
        LARGE_INTEGER lEnd;
        QueryPerformanceCounter(&lEnd);
        return (double(lEnd.QuadPart - lStart.QuadPart) / lFreq.QuadPart);
#else
        timeval lFinish;
        gettimeofday(&lFinish, 0);
        return double(lFinish.tv_sec - lStart.tv_sec) + double(lFinish.tv_usec - lStart.tv_usec)/1e6; 
#endif
#else
        std::chrono::high_resolution_clock::time_point lEnd = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double>  [MASK]  = std::chrono::duration_cast<std::chrono::duration<double> >(lEnd - lStart);
        return  [MASK] .count();
#endif
    }
};

#endif
",time_span
429,"// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------

/*!
*  Copyright (C) 2020, SICK AG, Waldkirch
*  Copyright (C) 2020, FZI Forschungszentrum Informatik, Karlsruhe, Germany
*
*
* 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.

*/

// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
/*!
 * \file SickSafetyscannersRos.cpp
 *
 * \author  <NAME> <<EMAIL>>
 * \date    2020-12-08
 */
//----------------------------------------------------------------------

#include <sick_safetyscanners2/SickSafetyscannersRos2.h>

namespace sick {

SickSafetyscannersRos2::SickSafetyscannersRos2()
  : Node(""SickSafetyscannersRos2"")
  , m_time_offset(0.0)
  , m_range_min(0.0)
  , m_range_max(0.0)
  , m_angle_offset(-90.0)
  , m_use_pers_conf(false)
{
  RCLCPP_INFO(this->get_logger(), ""Initializing SickSafetyscannersRos2 Node"");

  // read parameters!
  initialize_parameters();
  load_parameters();
  sick::types::port_t tcp_port{2122};

  // Dynamic Parameter Change client
  m_param_callback = add_on_set_parameters_callback(
    std::bind(&SickSafetyscannersRos2::parametersCallback, this, std::placeholders::_1));

  // TODO reconfigure?
  // TODO diagnostics

  // init publishers and services
  m_laser_scan_publisher = this->create_publisher<sensor_msgs::msg::LaserScan>(m_frame_id, 1);
  m_extended_laser_scan_publisher =
    this->create_publisher<sick_safetyscanners2_interfaces::msg::ExtendedLaserScan>(""extended_scan"",
                                                                                    1);
  m_output_paths_publisher =
    this->create_publisher<sick_safetyscanners2_interfaces::msg::OutputPaths>(""output_paths"", 1);
  m_raw_data_publisher =
    this->create_publisher<sick_safetyscanners2_interfaces::msg::RawMicroScanData>(""raw_data"", 1);

  m_field_data_service = this->create_service<sick_safetyscanners2_interfaces::srv::FieldData>(
    ""field_data"",
    std::bind(
      &SickSafetyscannersRos2::getFieldData, this, std::placeholders::_1, std::placeholders::_2));

  // Bind callback
  std::function<void(const sick::datastructure::Data&)> callback =
    std::bind(&SickSafetyscannersRos2::receiveUDPPaket, this, std::placeholders::_1);


  // Create a sensor instance
  if (m_communications_settings.host_ip.is_multicast())
  {
    m_device = std::make_unique<sick::AsyncSickSafetyScanner>(
      m_sensor_ip, tcp_port, m_communications_settings, m_interface_ip, callback);
  }
  else
  {
    m_device = std::make_unique<sick::AsyncSickSafetyScanner>(
      m_sensor_ip, tcp_port, m_communications_settings, callback);
  }

  RCLCPP_INFO(this->get_logger(), ""Communication to Sensor set up"");

  // Read sensor specific configurations
  readTypeCodeSettings();

  if (m_use_pers_conf)
  {
    readPersistentConfig();
  }

  m_msg_creator = std::make_unique<sick::MessageCreator>(
    m_frame_id, m_time_offset, m_range_min, m_range_max, m_angle_offset, m_min_intensities);

  // Start async receiving and processing of sensor data
  m_device->run();
  m_device->changeSensorSettings(m_communications_settings);

  RCLCPP_INFO(this->get_logger(), ""Node Configured and running"");
}

void SickSafetyscannersRos2::readTypeCodeSettings()
{
  RCLCPP_INFO(this->get_logger(), ""Reading Type code settings"");
  sick::datastructure::TypeCode type_code;
  m_device->requestTypeCode(type_code);
  m_communications_settings.e_interface_type = type_code.getInterfaceType();
  m_range_min                                = 0.1;
  m_range_max                                = type_code.getMaxRange();
}

void SickSafetyscannersRos2::readPersistentConfig()
{
  RCLCPP_INFO(this->get_logger(), ""Reading Persistent Configuration"");
  sick::datastructure::ConfigData  [MASK] ;
  m_device->requestPersistentConfig( [MASK] );
  m_communications_settings.start_angle =  [MASK] .getStartAngle();
  m_communications_settings.end_angle   =  [MASK] .getEndAngle();
}

void SickSafetyscannersRos2::initialize_parameters()
{
  this->declare_parameter<std::string>(""frame_id"", ""scan"");
  this->declare_parameter<std::string>(""sensor_ip"", ""192.168.1.11"");
  this->declare_parameter<std::string>(""host_ip"", ""192.168.1.9"");
  this->declare_parameter<std::string>(""interface_ip"", ""0.0.0.0"");
  this->declare_parameter<int>(""host_udp_port"", 0);
  this->declare_parameter<int>(""channel"", 0);
  this->declare_parameter<bool>(""channel_enabled"", true);
  this->declare_parameter<int>(""skip"", 0);
  this->declare_parameter<double>(""angle_start"", 0.0);
  this->declare_parameter<double>(""angle_end"", 0.0);
  this->declare_parameter<double>(""time_offset"", 0.0); // TODO
  this->declare_parameter<bool>(""general_system_state"", true);
  this->declare_parameter<bool>(""derived_settings"", true);
  this->declare_parameter<bool>(""measurement_data"", true);
  this->declare_parameter<bool>(""intrusion_data"", true);
  this->declare_parameter<bool>(""application_io_data"", true);
  this->declare_parameter<bool>(""use_persistent_config"", false);
  this->declare_parameter<float>(""min_intensities"", 0.f);
}

void SickSafetyscannersRos2::load_parameters()
{
  rclcpp::Logger node_logger = this->get_logger();

  this->get_parameter<std::string>(""frame_id"", m_frame_id);
  RCLCPP_INFO(node_logger, ""frame_id: %s"", m_frame_id.c_str());

  std::string sensor_ip;
  this->get_parameter<std::string>(""sensor_ip"", sensor_ip);
  RCLCPP_INFO(node_logger, ""sensor_ip: %s"", sensor_ip.c_str());
  m_sensor_ip = boost::asio::ip::address_v4::from_string(sensor_ip);

  std::string interface_ip;
  this->get_parameter<std::string>(""interface_ip"", interface_ip);
  RCLCPP_INFO(node_logger, ""interface_ip: %s"", interface_ip.c_str());
  m_interface_ip = boost::asio::ip::address_v4::from_string(interface_ip);

  std::string host_ip;
  this->get_parameter<std::string>(""host_ip"", host_ip);
  RCLCPP_INFO(node_logger, ""host_ip: %s"", host_ip.c_str());
  // TODO check if valid IP?
  m_communications_settings.host_ip = boost::asio::ip::address_v4::from_string(host_ip);

  int host_udp_port;
  this->get_parameter<int>(""host_udp_port"", host_udp_port);
  RCLCPP_INFO(node_logger, ""host_udp_port: %i"", host_udp_port);
  m_communications_settings.host_udp_port = host_udp_port;

  int channel;
  this->get_parameter<int>(""channel"", channel);
  RCLCPP_INFO(node_logger, ""channel: %i"", channel);
  m_communications_settings.channel = channel;

  bool enabled;
  this->get_parameter<bool>(""channel_enabled"", enabled);
  RCLCPP_INFO(node_logger, ""channel_enabled: %s"", btoa(enabled).c_str());
  m_communications_settings.enabled = enabled;

  int skip;
  this->get_parameter<int>(""skip"", skip);
  RCLCPP_INFO(node_logger, ""skip: %i"", skip);
  m_communications_settings.publishing_frequency = skipToPublishFrequency(skip);

  float angle_start;
  this->get_parameter<float>(""angle_start"", angle_start);
  RCLCPP_INFO(node_logger, ""angle_start: %f"", angle_start);

  float angle_end;
  this->get_parameter<float>(""angle_end"", angle_end);
  RCLCPP_INFO(node_logger, ""angle_end: %f"", angle_end);

  // Included check before calculations to prevent rounding errors while calculating
  if (angle_start == angle_end)
  {
    m_communications_settings.start_angle = sick::radToDeg(0);
    m_communications_settings.end_angle   = sick::radToDeg(0);
  }
  else
  {
    m_communications_settings.start_angle = sick::radToDeg(angle_start) - m_angle_offset;
    m_communications_settings.end_angle   = sick::radToDeg(angle_end) - m_angle_offset;
  }


  this->get_parameter<double>(""time_offset"", m_time_offset);
  RCLCPP_INFO(node_logger, ""time_offset: %f"", m_time_offset);

  // Features
  bool general_system_state;
  this->get_parameter<bool>(""general_system_state"", general_system_state);
  RCLCPP_INFO(node_logger, ""general_system_state: %s"", btoa(general_system_state).c_str());

  bool derived_settings;
  this->get_parameter<bool>(""derived_settings"", derived_settings);
  RCLCPP_INFO(node_logger, ""derived_settings: %s"", btoa(derived_settings).c_str());

  bool measurement_data;
  this->get_parameter<bool>(""measurement_data"", measurement_data);
  RCLCPP_INFO(node_logger, ""measurement_data: %s"", btoa(measurement_data).c_str());

  bool intrusion_data;
  this->get_parameter<bool>(""intrusion_data"", intrusion_data);
  RCLCPP_INFO(node_logger, ""intrusion_data: %s"", btoa(intrusion_data).c_str());

  bool application_io_data;
  this->get_parameter<bool>(""application_io_data"", application_io_data);
  RCLCPP_INFO(node_logger, ""application_io_data: %s"", btoa(application_io_data).c_str());

  m_communications_settings.features = sick::SensorDataFeatures::toFeatureFlags(
    general_system_state, derived_settings, measurement_data, intrusion_data, application_io_data);


  this->get_parameter<bool>(""use_persistent_config"", m_use_pers_conf);
  RCLCPP_INFO(node_logger, ""use_persistent_config: %s"", btoa(m_use_pers_conf).c_str());

  this->get_parameter<double>(""min_intensities"", m_min_intensities);
  RCLCPP_INFO(node_logger, ""min_intensities: %f"", m_min_intensities);
}

rcl_interfaces::msg::SetParametersResult
SickSafetyscannersRos2::parametersCallback(std::vector<rclcpp::Parameter> parameters)
{
  rcl_interfaces::msg::SetParametersResult result;
  result.successful         = true;
  result.reason             = """";
  bool update_sensor_config = false;

  for (auto param : parameters)
  {
    {
      std::stringstream ss;
      ss << ""{"" << param.get_name() << "", "" << param.value_to_string() << ""}"";
      RCLCPP_INFO(this->get_logger(), ""Got parameter: '%s'"", ss.str().c_str());

      if (!param.get_name().compare(""frame_id""))
      {
        m_frame_id = param.value_to_string();
      }
      else if (!param.get_name().compare(""host_ip""))
      {
        m_communications_settings.host_ip =
          boost::asio::ip::address_v4::from_string(param.value_to_string());
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""host_udp_port""))
      {
        m_communications_settings.host_udp_port = param.as_int();
        update_sensor_config                    = true;
      }
      else if (!param.get_name().compare(""channel""))
      {
        m_communications_settings.channel = param.as_int();
        update_sensor_config              = true;
      }
      else if (!param.get_name().compare(""channel_enabled""))
      {
        m_communications_settings.enabled = param.as_bool();
        update_sensor_config              = true;
      }
      else if (!param.get_name().compare(""skip""))
      {
        m_communications_settings.publishing_frequency = skipToPublishFrequency(param.as_int());
        update_sensor_config                           = true;
      }
      else if (!param.get_name().compare(""angle_start""))
      {
        // TODO cleanup
        double angle_start = param.as_double();
        double angle_end;
        this->get_parameter<double>(""angle_end"", angle_end);
        if (angle_start == angle_end)
        {
          m_communications_settings.start_angle = sick::radToDeg(0);
          m_communications_settings.end_angle   = sick::radToDeg(0);
        }
        else
        {
          m_communications_settings.start_angle = sick::radToDeg(angle_start) - m_angle_offset;
          m_communications_settings.end_angle   = sick::radToDeg(angle_end) - m_angle_offset;
        }
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""angle_end""))
      {
        // TODO cleanup
        double angle_end = param.as_double();
        double angle_start;
        this->get_parameter<double>(""angle_start"", angle_start);
        if (angle_start == angle_end)
        {
          m_communications_settings.start_angle = sick::radToDeg(0);
          m_communications_settings.end_angle   = sick::radToDeg(0);
        }
        else
        {
          m_communications_settings.start_angle = sick::radToDeg(angle_start) - m_angle_offset;
          m_communications_settings.end_angle   = sick::radToDeg(angle_end) - m_angle_offset;
        }
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""time_offset""))
      {
        m_time_offset = param.as_double();
      }
      else if (!param.get_name().compare(""general_system_state""))
      {
        // TODO improve
        m_communications_settings.features =
          (m_communications_settings.features & ~(1UL << 0)) | (param.as_bool() << 0);
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""derived_settings""))
      {
        m_communications_settings.features =
          (m_communications_settings.features & ~(1UL << 1)) | (param.as_bool() << 1);
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""measurement_data""))
      {
        m_communications_settings.features =
          (m_communications_settings.features & ~(1UL << 2)) | (param.as_bool() << 2);
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""intrusion_data""))
      {
        m_communications_settings.features =
          (m_communications_settings.features & ~(1UL << 3)) | (param.as_bool() << 3);
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""application_io_data""))
      {
        m_communications_settings.features =
          (m_communications_settings.features & ~(1UL << 4)) | (param.as_bool() << 4);
        update_sensor_config = true;
      }
      else if (!param.get_name().compare(""min_intensities""))
      {
        m_min_intensities = param.as_double();
      }
      else
      {
        result.successful = false;
        result.reason     = ""Parameter is not dynamic reconfigurable"";
        RCLCPP_WARN(this->get_logger(),
                    ""Parameter %s not dynamically reconfigurable"",
                    param.get_name().c_str());
      }
    }
  }
  if (update_sensor_config)
  {
    m_device->changeSensorSettings(m_communications_settings);
  }
  m_msg_creator = std::make_unique<sick::MessageCreator>(
    m_frame_id, m_time_offset, m_range_min, m_range_max, m_angle_offset, m_min_intensities);
  return result;
}


void SickSafetyscannersRos2::receiveUDPPaket(const sick::datastructure::Data& data)
{
  if (!m_msg_creator)
  {
    RCLCPP_WARN(get_logger(),
                ""Received UDPP packet before all objects were instantiated, ignoring this packet."");
    return;
  }

  if (!data.getMeasurementDataPtr()->isEmpty() && !data.getDerivedValuesPtr()->isEmpty() &&
      m_msg_creator)
  {
    auto scan = m_msg_creator->createLaserScanMsg(data, this->now());
    m_laser_scan_publisher->publish(scan);

    sick_safetyscanners2_interfaces::msg::ExtendedLaserScan extended_scan =
      m_msg_creator->createExtendedLaserScanMsg(data, this->now());

    m_extended_laser_scan_publisher->publish(extended_scan);

    auto output_paths = m_msg_creator->createOutputPathsMsg(data);
    m_output_paths_publisher->publish(output_paths);
  }

  auto raw_msg = m_msg_creator->createRawDataMsg(data);
  m_raw_data_publisher->publish(raw_msg);
}


bool SickSafetyscannersRos2::getFieldData(
  const std::shared_ptr<sick_safetyscanners2_interfaces::srv::FieldData::Request> request,
  std::shared_ptr<sick_safetyscanners2_interfaces::srv::FieldData::Response> response)
{
  // Suppress warning of unused request variable due to empty request fields
  (void)request;

  std::vector<sick::datastructure::FieldData> fields;
  m_device->requestFieldData(fields);

  for (size_t i = 0; i < fields.size(); i++)
  {
    sick::datastructure::FieldData field = fields.at(i);
    sick_safetyscanners2_interfaces::msg::Field field_msg;

    field_msg.start_angle        = degToRad(field.getStartAngle() + m_angle_offset);
    field_msg.angular_resolution = degToRad(field.getAngularBeamResolution());
    field_msg.protective_field   = field.getIsProtectiveField();

    std::vector<uint16_t> ranges = field.getBeamDistances();
    for (size_t j = 0; j < ranges.size(); j++)
    {
      field_msg.ranges.push_back(static_cast<float>(ranges.at(j)) * 1e-3);
    }

    response->fields.push_back(field_msg);
  }

  datastructure::DeviceName device_name;
  m_device->requestDeviceName(device_name);
  response->device_name = device_name.getDeviceName();


  std::vector<sick::datastructure::MonitoringCaseData> monitoring_cases;
  m_device->requestMonitoringCases(monitoring_cases);

  for (size_t i = 0; i < monitoring_cases.size(); i++)
  {
    sick::datastructure::MonitoringCaseData monitoring_case_data = monitoring_cases.at(i);
    sick_safetyscanners2_interfaces::msg::MonitoringCase monitoring_case_msg;

    monitoring_case_msg.monitoring_case_number = monitoring_case_data.getMonitoringCaseNumber();
    std::vector<uint16_t> mon_fields           = monitoring_case_data.getFieldIndices();
    std::vector<bool> mon_fields_valid         = monitoring_case_data.getFieldsValid();
    for (size_t j = 0; j < mon_fields.size(); j++)
    {
      monitoring_case_msg.fields.push_back(mon_fields.at(j));
      monitoring_case_msg.fields_valid.push_back(mon_fields_valid.at(j));
    }
    response->monitoring_cases.push_back(monitoring_case_msg);
  }

  return true;
}


} // namespace sick
",config_data
430,"#include ""wave7i5.h""
#include <stdio.h>
#include <stdlib.h>
#include ""esp_log.h""
#include ""freertos/task.h""

#define GDEW075T7_PU_DELAY 100

// Constructor
Wave7i5::Wave7i5(EpdSpi &dio) : Adafruit_GFX(GDEW075T7_WIDTH, GDEW075T7_HEIGHT),
                                    Epd(GDEW075T7_WIDTH, GDEW075T7_HEIGHT), IO(dio)
{
  printf(""Wave7i5() constructor injects IO and extends Adafruit_GFX(%d,%d) Pix Buffer[%d]\n"",
         GDEW075T7_WIDTH, GDEW075T7_HEIGHT, GDEW075T7_BUFFER_SIZE);
  printf(""\nAvailable heap after Epd bootstrap:%d\n"", xPortGetFreeHeapSize());
}

//Initialize the display
void Wave7i5::init(bool debug)
{
  debug_enabled = debug;
  if (debug_enabled)
    printf(""Wave7i5::init(debug:%d)\n"", debug);
  //Initialize SPI at 4MHz frequency. true for debug
  IO.init(4, false);
  fillScreen(EPD_WHITE);
}

void Wave7i5::fillScreen(uint16_t color)
{
  uint8_t data = (color == EPD_BLACK) ? GDEW075T7_8PIX_BLACK : GDEW075T7_8PIX_WHITE;
  for (uint16_t x = 0; x < sizeof(_buffer); x++)
  {
    _buffer[x] = data;
  }
}

void Wave7i5::_wakeUp()
{
  IO.reset(10);

  IO.cmd(0x01); 
  IO.data(0x07);
  IO.data(0x07);
  IO.data(0x3f);
  IO.data(0x3f);

  IO.cmd(0x04);
  _waitBusy(""Power on"");
  
  IO.cmd(0X00);			// PANNEL SETTING
  IO.data(0x1F);    // KW-3f   KWR-2F	BWROTP 0f	BWOTP 1f

  IO.cmd(0x61);    	// Tres
  IO.data(0x03);		// source 800
  IO.data(0x20);
  IO.data(0x01);		// gate 480
  IO.data(0xE0);

  IO.cmd(0X15);
  IO.data(0x00);

  IO.cmd(0X50);			// VCOM AND DATA INTERVAL SETTING
  IO.data(0x10);
  IO.data(0x07);

  IO.cmd(0X60);			// TCON SETTING
  IO.data(0x22);
}

void Wave7i5::update()
{
  uint64_t  [MASK]  = esp_timer_get_time();
  _using_partial_mode = false;
  _wakeUp();

  IO.cmd(0x13);
  printf(""Sending a %d bytes buffer via SPI\n"", sizeof(_buffer));

  // v2 SPI optimizing. Check: https://github.com/martinberlin/cale-idf/wiki/About-SPI-optimization
  uint16_t i = 0;
  uint8_t xLineBytes = GDEW075T7_WIDTH / 8;
  uint8_t x1buf[xLineBytes];
  for (uint16_t y = 1; y <= GDEW075T7_HEIGHT; y++)
  {
    for (uint16_t x = 1; x <= xLineBytes; x++)
    {
      uint8_t data = i < sizeof(_buffer) ? _buffer[i] : 0x00;
      x1buf[x - 1] = data;
      if (x == xLineBytes)
      { // Flush the X line buffer to SPI
        IO.data(x1buf, sizeof(x1buf));
      }
      ++i;
    }
  }

  uint64_t endTime = esp_timer_get_time();
  IO.cmd(0x12);
  _waitBusy(""update"");
  uint64_t updateTime = esp_timer_get_time();

  printf(""\n\nSTATS (ms)\n%llu _wakeUp settings+send Buffer\n%llu update \n%llu total time in millis\n"",
         (endTime -  [MASK] ) / 1000, (updateTime - endTime) / 1000, (updateTime -  [MASK] ) / 1000);

  _sleep();
}

void Wave7i5::updateWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h, bool using_rotation)
{
  printf(""updateWindow: Waveshare this is not a good example of partial update. Use Gdew075T7\n"");
  /* if (using_rotation)
    _rotate(x, y, w, h);
  if (x >= GDEW075T7_WIDTH)
    return;
  if (y >= GDEW075T7_HEIGHT)
    return;

  if (!_using_partial_mode)
  _wakeUp();
  _using_partial_mode = true;

  IO.cmd(0x13);
  for (unsigned long j = 0; j < GDEW075T7_HEIGHT; j++) {
    for (unsigned long i = 0; i < GDEW075T7_WIDTH/8; i++) {
        if( (j>=y) && (j<y+h) && (i*8>=x) && (i*8<x+w)){
            IO.data(~ _buffer[i-x/8 + (w)/8*(j-y)] );
        }else {
            IO.data(0x00);
        }
    }
  }
  
  IO.cmd(0x12);
  
  _waitBusy(""updateWindow"");
  
  vTaskDelay(GDEW075T7_PU_DELAY / portTICK_PERIOD_MS); */
}

void Wave7i5::_waitBusy(const char *message)
{
  IO.cmd(0x71); // Not sure if this is needed. In Wave example is on the loop (?)
  if (debug_enabled)
  {
    ESP_LOGI(TAG, ""_waitBusy for %s"", message);
  }
  int64_t time_since_boot = esp_timer_get_time();
  // wait until busy goes High
  while (1)
  {
    if (gpio_get_level((gpio_num_t)CONFIG_EINK_BUSY) == 1)
      break;
    vTaskDelay(1);
    if (esp_timer_get_time() - time_since_boot > 2000000)
    {
      if (debug_enabled)
        ESP_LOGI(TAG, ""Busy Timeout"");
      break;
    }
  }
}

void Wave7i5::_sleep()
{
  IO.cmd(0x02);
  _waitBusy(""power_off"");
  IO.cmd(0x07); // Deep sleep
  IO.data(0xA5);
}

void Wave7i5::_rotate(uint16_t &x, uint16_t &y, uint16_t &w, uint16_t &h)
{
  switch (getRotation())
  {
  case 1:
    swap(x, y);
    swap(w, h);
    x = GDEW075T7_WIDTH - x - w - 1;
    break;
  case 2:
    x = GDEW075T7_WIDTH - x - w - 1;
    y = GDEW075T7_HEIGHT - y - h - 1;
    break;
  case 3:
    swap(x, y);
    swap(w, h);
    y = GDEW075T7_HEIGHT - y - h - 1;
    break;
  }
}

void Wave7i5::drawPixel(int16_t x, int16_t y, uint16_t color)
{
  if ((x < 0) || (x >= width()) || (y < 0) || (y >= height()))
    return;
  switch (getRotation())
  {
  case 1:
    swap(x, y);
    x = GDEW075T7_WIDTH - x - 1;
    break;
  case 2:
    x = GDEW075T7_WIDTH - x - 1;
    y = GDEW075T7_HEIGHT - y - 1;
    break;
  case 3:
    swap(x, y);
    y = GDEW075T7_HEIGHT - y - 1;
    break;
  }
  uint16_t i = x / 8 + y * GDEW075T7_WIDTH / 8;

  if (!color)
  {
    _buffer[i] = (_buffer[i] | (1 << (7 - x % 8)));
  }
  else
  {
    _buffer[i] = (_buffer[i] & (0xFF ^ (1 << (7 - x % 8))));
  }
}

uint16_t Wave7i5::_setPartialRamArea(uint16_t x, uint16_t y, uint16_t xe, uint16_t ye) {
  printf(""Not used in Wave7i5 EPD\n"");
  return 0;
}",startTime
431,"#pragma once

#include ""Vector3.h""
#include ""Ray.h""


class Camera
{
public:
	Camera(Vector3& position, Vector3& lookAt, Vector3& up, float vfov, float aspect)
	{
		Vector3 u, v, w;
		float  [MASK]  = vfov * M_PI / 180;
		float half_height = tan( [MASK]  / 2);
		float half_width = aspect * half_height;
		origin = position;
		w = unit_vector(position - lookAt);
		u = unit_vector(cross(up, w));
		v = cross(w, u);
		//lower_left_corner = Vector3(-half_width, -half_height, -1.0);
		lower_left_corner = origin - half_width * u - half_height*v - w;
		horizontal = 2 * half_width*u;
		vertical = 2 * half_height*v;
	}

	Ray getRay(float u, float v)
	{
		return Ray(origin, lower_left_corner + u* horizontal + v*vertical - origin);
	}
private:
	Vector3 origin;
	Vector3 lower_left_corner;
	Vector3 horizontal;
	Vector3 vertical;
};",theta
432,"/***********************************************************************
Vczh Library++ 3.0
Developer: <NAME>(vczh)
Database::Utility

***********************************************************************/

#ifndef VCZH_DATABASE_UTILITY_COMMON
#define VCZH_DATABASE_UTILITY_COMMON

#include ""../DatabaseVlppReferences.h""

namespace vl
{
	namespace database
	{
		template<typename T, vint Tag>
		struct IdObject
		{
			typedef T			IndexType;
			T					index;

			IdObject()
				:index(~(T)0)
			{
			}

			IdObject(T _index)
				:index(_index)
			{
			}

			bool IsValid()const
			{
				return index != ~(T)0;
			}

			static IdObject Invalid()
			{
				return IdObject();
			}

			bool operator==(IdObject b)const { return index == b.index; }
			bool operator!=(IdObject b)const { return index != b.index; }
			bool operator< (IdObject b)const { return index <  b.index; }
			bool operator<=(IdObject b)const { return index <= b.index; }
			bool operator> (IdObject b)const { return index >  b.index; }
			bool operator>=(IdObject b)const { return index >= b.index; }
		};

		typedef IdObject<vint32_t,	0>	BufferSource;
		typedef IdObject<vuint64_t,	1>	BufferPage;
		typedef IdObject<vuint64_t,	2>	BufferPointer;
		typedef IdObject<vuint64_t,	3>	BufferTransaction;
		typedef IdObject<vint32_t,	4>	BufferTable;

		template<typename T>
		T IntUpperBound(T  [MASK] , T divisor)
		{
			return  [MASK]  + (divisor - ( [MASK]  % divisor)) % divisor;
		}
	}
	
	template<typename T, vint Tag>
	struct POD<database::IdObject<T, Tag>>{static const bool Result = true;}; 
}

#endif
",size
433,"#include<cstdio>
#include<cstring>

using namespace std;

typedef unsigned short int uint16;

/* a=target variable, b=bit number to act upon 0-n */
#define BIT_SET(a,b) ((a) |= (1<<(b)))
#define BIT_CLEAR(a,b) ((a) &= ~(1<<(b)))
#define BIT_CHECK(a,b) (!!((a) & (1<<(b)))) // '!!' to make sure this returns 0 or 1

#define MEMORY_SIZE 0x22 // Memory used (in bytes) in the whole process - highest access on v[0x20] uint16
#define PASSWORD_SIZE 0x16 // Total number of characters in the final password string
#define PLAYER_DATA_SIZE 13 // Number of player related inputs
#define GENERAL_DATA_SIZE 3 // Number of non-player related inputs

void uintSet(unsigned char *v, uint16 x);
uint16 uintFrom(unsigned char *v);

void encodeCurrentPassword(unsigned char *v);

void initializeAValues(uint16 *playerDataA, uint16 *generalDataA);
void initializeInputValues(uint16 *player1Data, uint16 *player2Data, uint16 *generalData);
void initializeMemory(unsigned char *v,
    uint16 *playerDataA, uint16 *generalDataA,
    uint16 *player1Data, uint16 *player2Data, uint16 *generalData);
void initializeVariables(unsigned char *v, uint16 a, uint16 x);
void uintadd(uint16 *a, unsigned char *x, char *carry);
void rotateRight(unsigned char *v, char *carry, int ignoreCarry);
void rotateLeft(unsigned char *v, char *carry, int ignoreCarry);
bool isPlus(uint16 x);
uint16 checksum(uint16 *player1Data, uint16 *player2Data, uint16 *generalData);



int main(){
    unsigned char v[MEMORY_SIZE]; // Memory used for the process
    uint16 playerDataA[PLAYER_DATA_SIZE]; // Constants related to each input
    uint16 generalDataA[GENERAL_DATA_SIZE]; // Constants related to each input
    uint16 playerData[2][PLAYER_DATA_SIZE]; // Variable input
    uint16 generalData[GENERAL_DATA_SIZE]; // Variable input

    initializeAValues(playerDataA, generalDataA);

    initializeInputValues(playerData[0], playerData[1], generalData);
    initializeMemory(v,playerDataA,generalDataA,playerData[0],playerData[1],generalData);
    encodeCurrentPassword(v);
}

// These are the constants used for each input respective A value
// They are put into the A register before each call to $9fd819 subroutine
// The first set is made at $9fd350 and all others happen in the same page
void initializeAValues(uint16 *playerDataA, uint16 *generalDataA){
    memset(playerDataA,0,PLAYER_DATA_SIZE*sizeof(uint16));
    memset(generalDataA,0,GENERAL_DATA_SIZE*sizeof(uint16));

    playerDataA[0]=0x0004;
    playerDataA[1]=0x0004;
    playerDataA[2]=0x0004;
    playerDataA[3]=0x0004;
    playerDataA[4]=0x0004;
    playerDataA[5]=0x0004;
    playerDataA[6]=0x0005;
    playerDataA[7]=0x0005;
    playerDataA[8]=0x0005;
    playerDataA[9]=0x0008;
    playerDataA[10]=0x0002;
    playerDataA[11]=0x000a;
    playerDataA[12]=0x0500;

    generalDataA[0]=0x0003;
    generalDataA[1]=0x0041;
    generalDataA[2]=0x0002;
}

void initializeInputValues(uint16 *player1Data, uint16 *player2Data, uint16 *generalData){
    memset(player1Data,0,PLAYER_DATA_SIZE*sizeof(uint16));
    memset(player2Data,0,PLAYER_DATA_SIZE*sizeof(uint16));
    memset(generalData,0,GENERAL_DATA_SIZE*sizeof(uint16));

    // This section has potential for exploration.
    // As the memory usually holds a lot more space than the usual values, weird things may happen if the values are chosen correctly
    // For instance, choosing everything 0, but the region number 16 will be valid, but freeze the game.

    // Player equipment values are all in the range 0-3
    player1Data[0]=0; // $1d03 - P1 engineLevel
    player2Data[0]=0; // $1d2c - P2 engineLevel

    player1Data[1]=0; // $1d05 - P1 wetTireLevel
    player2Data[1]=0; // $1d2e - P2 wetTireLevel

    player1Data[2]=0; // $1d07 - P1 dryTireLevel
    player2Data[2]=0; // $1d30 - P2 dryTireLevel

    player1Data[3]=0; // $1d09 - P1 gearboxLevel
    player2Data[3]=0; // $1d32 - P2 gearboxLevel

    player1Data[4]=0; // $1d0b - P1 nitroLevel
    player2Data[4]=0; // $1d34 - P2 nitroLevel

    // Thanks rimsky82 for the discovery
    player1Data[5]=0; // $1d0d - P1 Gas Tank
    player2Data[5]=0; // $1d36 - P2 Gas Tank

    player1Data[6]=0; // $1d0f - P1 sideArmorLevel
    player2Data[6]=0; // $1d38 - P2 sideArmorLevel

    player1Data[7]=0; // $1d11 - P1 rearArmorLevel
    player2Data[7]=0; // $1d3a - P2 rearArmorLevel

    player1Data[8]=0; // $1d13 - P1 frontArmorLevel
    player2Data[8]=0; // $1d3c - P2 frontArmorLevel

    // Values: 0-7
    // Red, Blue, White, Yellow, Green, Black, Gray, Purple
    player1Data[9]=0x0000; // $1d15 - P1 color
    player2Data[9]=0x0001; // $1d3e - P2 color

    // Values: 0-1
    // MPH, KPH
    player1Data[10]=0; // $1cff - P1 speedType (MPH/KPH)
    player2Data[10]=0; // $1d28 - P2 speedType (MPH/KPH)

    // Values:
    // Left byte goes from 0-4 on control types
    // Right byte goes:
    // 0x00: Manual
    // 0x80: Automatic
    // Example, automatic with control type 2 would be:
    // 0x8001
    player1Data[11]=0x8000; // $1d01 - P1 gear type and control type
    player2Data[11]=0x8000; // $1d2a - P2 gear type and control type

    // Values: 0-255 (There are 2 bytes here, in theory, we can go up to 0xffff)
    // Anyway, 255 is enough to buy everything
    player1Data[12]=0; // $1d19 - P1 Money (Thousands)
    player2Data[12]=0; // $1d42 - P2 Money (Thousands)

    // Values: 0-2
    // Amateur, Professional, Championship
    generalData[0]=0; // $1cdd - Difficulty

    // Values: 0-15
    // Australasia, Britain, ...
    generalData[1]=0; // $1ce1 - Region Number

    // Values: 0-1
    // 1 player, 2 players
    generalData[2]=0; // $1cdb - Number of players (1 or 2)
}

void initializeMemory(unsigned char *v, 
    uint16 *playerDataA, uint16 *generalDataA,
    uint16 *player1Data, uint16 *player2Data, uint16 *generalData){
    uint16 a, x;

    // Re-setting happens from 9fd33f
    // The only reset 2-bytes are from 0x06 to 0x12
    // Here we reset everything as we won't use any prior or posterior side-effects.
    memset(v,0,MEMORY_SIZE*sizeof(unsigned char));

    // From 9fd34d
    for(int j=0;j<2;j++){
        for(int i=0; i<=10; i++){
            x = j==0 ? player1Data[i]: player2Data[i];
            a = playerDataA[i];
            initializeVariables(v,a,x);
        }

        a = (j==0 ? player1Data[11] : player2Data[11]);
        if(!isPlus(a)){
            a = (a & 0x7fff) + 0x0005;
        }
        x = a;
        a = 0x000a;
        initializeVariables(v,a,x);

        x = (j==0 ? player1Data[12]: player2Data[12]);
        a = playerDataA[12];
        initializeVariables(v,a,x);
    }

    // General data part

    // Difficulty
    x = generalData[0];
    a = generalDataA[0];
    initializeVariables(v,a,x);

    // Region number
    a = generalData[1];
    a = a << 2;
    x = a;
    a = generalDataA[1];
    initializeVariables(v,a,x);

    // Number of players
    x = generalData[2];
    a = generalDataA[2];
    initializeVariables(v,a,x);

    // 9fd46a - Calculate checksum
    a = checksum(player1Data,player2Data, generalData);
    x = a;
    a = 0x006d;
    initializeVariables(v,a,x);

}

void initializeVariables(unsigned char *v, uint16 a, uint16 x){
    uintSet(&v[0x04],a);
    uintSet(&v[0x14],x);

    uintSet(&v[0x16],0x0000);
    uintSet(&v[0x18],0x0000);
    uintSet(&v[0x1a],0x0000);
    uintSet(&v[0x1c],0x0000);
    uintSet(&v[0x1e],0x0000);
    uintSet(&v[0x20],0x0000);

    char carry = 0;
    do
    {
        // 9fd827
        rotateRight(&v[0x04], &carry, 1);
        if(carry!=0){
            a = uintFrom(&v[0x06]);
            carry = 0;
            uintadd(&a,&v[0x14],&carry);
            
            a = uintFrom(&v[0x08]);
            uintadd(&a,&v[0x16],&carry);

            a = uintFrom(&v[0x0a]);
            uintadd(&a,&v[0x18],&carry);

            a = uintFrom(&v[0x0c]);
            uintadd(&a,&v[0x1a],&carry);

            a = uintFrom(&v[0x0e]);
            uintadd(&a,&v[0x1c],&carry);

            a = uintFrom(&v[0x10]);
            uintadd(&a,&v[0x1e],&carry);

            a = uintFrom(&v[0x12]);
            uintadd(&a,&v[0x20],&carry);

        }
        //9fd858
        rotateLeft(&v[0x06], &carry, 1);
        rotateLeft(&v[0x08], &carry, 0);
        rotateLeft(&v[0x0a], &carry, 0);
        rotateLeft(&v[0x0c], &carry, 0);
        rotateLeft(&v[0x0e], &carry, 0);
        rotateLeft(&v[0x10], &carry, 0);
        rotateLeft(&v[0x12], &carry, 0);
        a = uintFrom(&v[0x04]);
    } while (a!=0);

    // 9fd86a
    uintSet(&v[0x06],uintFrom(&v[0x14]));
    uintSet(&v[0x08],uintFrom(&v[0x16]));
    uintSet(&v[0x0a],uintFrom(&v[0x18]));
    uintSet(&v[0x0c],uintFrom(&v[0x1a]));
    uintSet(&v[0x0e],uintFrom(&v[0x1c]));
    uintSet(&v[0x10],uintFrom(&v[0x1e]));
    uintSet(&v[0x12],uintFrom(&v[0x20]));
}

// Creates an uint from the 2 bytes defined by x
// and add a to it
// a is also changed
void uintadd(uint16 *a, unsigned char *x, char *carry){
    uint16 aux = uintFrom(x);
    unsigned int result = aux + *a;
    if(*carry != 0){
        result ++;
    }
    if(result>=(1<<16)){
        *carry = 1;
    }else{
        *carry = 0;
    }
    *a = result;
    uintSet(x,*a);
}

// OUTPUTS
//   $9f1780 == bufferPassword

// Rough transcoding from subroutine in 0x9fd474

// v needs to be initialized from 0x06 to 0x13 prior to calling this function
// v[0x00] to c[0x03] will be overwritten
void encodeCurrentPassword(unsigned char *v)
{
    // CONSTANTS
    //   $9fd7f9 == cryptoTable
    // int cryptoTableSize = 22;
    //                               13,   5,  26,  20,  26,  14,  23,   7,  22,  13,  12,  22,   6,  19,  13,  11,  13,  11,  13,  31,  18,   0
    unsigned char cryptoTable[] = {0x0d,0x05,0x1a,0x14,0x1a,0x0e,0x17,0x07,0x16,0x0d,0x0c,0x16,0x06,0x13,0x0d,0x1b,0x1d,0x1b,0x1d,0x1f,0x12,0x00};
    //   $9fd7d9 == passwordDictionaryArray
    // int passwordDictionaryArraySize = 32;
    // Dictionary of letters, it goes ""BCDF""... as it is shown in the password menu
    unsigned char passwordDictionaryArray[] = { 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x4a, 0x4c, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x54, 0x56, 0x57, 0x59, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x23, 0x3f, 0x28, 0x29, 0x3c, 0x3e };

    // Variables
    uint16 a,x,y;
    uint16 aux;
    char  [MASK] ;
    // v[0x00] is counter
    // v[0x02] is aux
    // v[0x04] is unused
    // v[0x06] to v[0x12] is the data

    // Output
    unsigned char bufferPassword[PASSWORD_SIZE]; memset(bufferPassword,0,PASSWORD_SIZE*sizeof(unsigned char));

    // Make A 16 bits
    a = 0x0016; // should be a=0x16
    uintSet(&v[0x00],a);
    y = 0x0000;
    uintSet(&v[0x02],0x0000);

    do
    {
        a = uintFrom(&v[0x06]);
        x = y; // necessary for the 65816. Could've used y in the next line instead.
        aux = uintFrom(&cryptoTable[x]); a ^= aux;
         [MASK]  = 0;
        aux = uintFrom(&v[0x02]); a += aux;
        a &= 0x001f; // Equivalent to a%=32
        uintSet(&v[0x02],a);
        // everything up to here is equivalent to: 
        // v[$02] = ((v[$06] ^ cryptoTable[x]) + v[$02]) mod 32
        x = a;
        // Make A 8 bits
        a = passwordDictionaryArray[x];
        bufferPassword[y] = a;
        // Make A 16 bits
        // This makes the ror 17-bit rotation
        x = 5;
        do {
            rotateRight(&v[0x12], & [MASK] , 1);
            rotateRight(&v[0x10], & [MASK] , 0);
            rotateRight(&v[0x0e], & [MASK] , 0);
            rotateRight(&v[0x0c], & [MASK] , 0);
            rotateRight(&v[0x0a], & [MASK] , 0);
            rotateRight(&v[0x08], & [MASK] , 0);
            rotateRight(&v[0x06], & [MASK] , 0);
            x--;
        } while (x>0);
        y++;
        v[0x00]--;
    } while (v[0x00]>0);
    // printf(""Final password: %s\n"",bufferPassword);
    printf(""%.4s %.4s %.4s\n%.5s %.5s\n\n"",
    &bufferPassword[0],
    &bufferPassword[4],
    &bufferPassword[8],
    &bufferPassword[12],
    &bufferPassword[17]
    );

}

// At $9fd74f
uint16 checksum(uint16 *player1Data, uint16 *player2Data, uint16 *generalData){
    uint16 response = 0x0000;
    for(int i=0; i<PLAYER_DATA_SIZE; i++){
        response += player1Data[i]; // Always with no carry
        response += player2Data[i]; // Always with no carry
    }
    for(int i=0; i<GENERAL_DATA_SIZE; i++){
        response += generalData[i]; // Always with no carry
    }

    return response % 0x6d; // 0x6d is a prime: 109
}

// CPU functions

// Sets v[0] and v[1] with the value from x using little endian
// Equivalent to STA v in 16-bit mode
void uintSet(unsigned char *v, uint16 a){
    unsigned char lessSignificantByte = a;
    unsigned char mostSignificantByte = a>>8;
    v[0] = lessSignificantByte;
    v[1] = mostSignificantByte;
}

// Gets a uint16 from the values of v[0] and v[1] using little endian
// Equivalent to LDA v in 16-bit mode
uint16 uintFrom(unsigned char *v){
    uint16 resp = v[1] << 8;
    resp |= v[0];
    return resp;
}

// CPU instructions. It comes in 2 formats:
// LSR (Logical Shift Right) will ignore (use zero as) carry input and set carry output
// ROR (Rotate Right) will use the carry input and set carry output
// Here, the option is made by the ""ignoreCarry"" parameter
void rotateRight(unsigned char *v, char *carry, int ignoreCarry){
    unsigned char byte1 = v[0];
    unsigned char byte2 = v[1];
    int byte1Carry = byte2 & 1;
    int byte2Carry = ignoreCarry? 0 : *carry;
    *carry = byte1 & 1;

    // Output first byte:
    byte1 = byte1 >> 1;
    // Set first bit accordingly
    if(byte1Carry == 0){
        BIT_CLEAR(byte1,7);
    } else {
        BIT_SET(byte1,7);
    }
    v[0]=byte1;

    // Output second byte:
    byte2 = byte2 >> 1;
    // Set first bit accordingly
    if(byte2Carry == 0){
        BIT_CLEAR(byte2,7);
    } else {
        BIT_SET(byte2,7);
    }
    v[1]=byte2;
}

// CPU instructions. It comes in 2 formats:
// ASL (Accumulator Shift Left) will ignore (use zero as) carry input and set carry output
// ROL (Rotate Right) will use the carry input and set carry output
// Here, the option is made by the ""ignoreCarry"" parameter
void rotateLeft(unsigned char *v, char *carry, int ignoreCarry){
    unsigned char byte1 = v[0];
    unsigned char byte2 = v[1];
    int byte1Carry = ignoreCarry? 0 : *carry;
    int byte2Carry = byte1>>7 & 1;
    *carry = byte2>>7 & 1;

    // Output first byte:
    byte1 = byte1 << 1;
    // Set first bit accordingly
    if(byte1Carry == 0){
        BIT_CLEAR(byte1,0);
    } else {
        BIT_SET(byte1,0);
    }
    v[0]=byte1;

    // Output second byte:
    byte2 = byte2 << 1;
    // Set first bit accordingly
    if(byte2Carry == 0){
        BIT_CLEAR(byte2,0);
    } else {
        BIT_SET(byte2,0);
    }
    v[1]=byte2;
}

// Equivalent to checking the negative flag, i.e. checking if the MSB is 1
bool isPlus(uint16 a){
    return a>>15 == 0;
}

",CARRY
434,"#define _CRT_SECURE_NO_WARNINGS

#include ""AidMan.h""

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstring>
#include <ctime>
#include <algorithm>

#include ""Menu.h""

namespace sdds
{
    AidMan::AidMan() {
        m_productCount = 0;
        m_filename = nullptr;
    }

    AidMan::AidMan(const char* filename)  {
        m_productCount = 0;
        if (filename != nullptr) {
            m_filename = new char[strlen(filename) + 1];
            strcpy(m_filename, filename);
        }
    }

    AidMan::~AidMan() {
        deallocate();
    }

 	void AidMan::run()
	{
        static bool isFirstExecution = true;
        int choice = -1;
		do
		{
            if (!isFirstExecution) {
                cout << endl;
            }
            cout << ""Aid Management System"" << endl;
            Date currentDate;
            cout << ""Date: "" << currentDate << endl;

            cout << ""Data file: "" << ((m_filename != nullptr) ? m_filename : ""No file"") << endl;
            cout << ""---------------------------------"" << endl;
            Menu menu(""List Items\tAdd Item\tRemove Item\tUpdate Quantity\tSort\tShip Items\tNew/Open Aid Database"");
            
            choice = menu.run(1);
            if (choice != 0) {
                cout << endl;
            }
            
            if (choice != 0 && m_filename == nullptr && choice != 7) {
                choice = 7;
            }

            switch (choice) {
            case 1: {
                cout << ""****List Items****"" << endl;
                int count = list(nullptr);

                cout << ""Enter row number to display details or <ENTER> to continue:"" << endl;
                cout << ""> "";
                cin.ignore();
                char input[0x100] = { 0 };
                cin.getline(input, 0x100);

                if (*input != 0) {
                    int row = atoi(input);
                    if (row > 0 && row <= count) {
                        // Display details for the selected item
                        m_products[row - 1]->linear(false);
                        m_products[row - 1]->display(cout);
                    }
                    else {
                        cout << ""Invalid row number."" << endl;
                    }
                }
                break;
            }
            case 2:
                add();
                break;
            case 3:
                removeItem();
                break;
            case 4:
                updateQuantity();
                break;
            case 5:
                sortItems();
                break;
            case 6:
                shipItems();
                break;
            case 7:
                load();
                break;
            case 0:
                cout << ""Exiting Program!"" << endl;
                save();
                return;
            default:
                cout << endl;
                cout << ""Invalid choice. Please try again."" << endl;
            }

            isFirstExecution = false;
        } while (choice != 0);
       
    }

    void AidMan::shipItems() {
        cout << ""****Ship Items****"" << endl;

        ofstream shipOrderedFile(""shippingOrder.txt"");
        Date currentDate;
        shipOrderedFile << ""Shipping Order, Date: "" << currentDate << endl;
        shipOrderedFile << "" ROW |  SKU  | Description                         | Have | Need |  Price  | Expiry\n"";
        shipOrderedFile << ""-----+-------+-------------------------------------+------+------+---------+-----------"" << endl;
        
        int shippedCount = 0;
        for (int i = 0; i < m_productCount; ++i) {
            iProduct* product = m_products[i];
            if (product->qty() == product->qtyNeeded()) {
                product->linear(true);
                shipOrderedFile.fill(' ');
                shipOrderedFile << std::setw(4) << (++shippedCount) << "" | "" <<  *product << endl;
                remove(i);
                i--;
            }
        }
        shipOrderedFile << ""-----+-------+-------------------------------------+------+------+---------+-----------"" << endl;

        cout << ""Shipping Order for "" << shippedCount << "" times saved!"" << endl;
    }

    void AidMan::sortItems()
    {
        cout << ""****Sort****"" << endl;

        for (int i = 0; i < m_productCount - 1; ++i) {
            for (int j = i + 1; j < m_productCount; ++j) {
                if ((m_products[i]->qtyNeeded() - m_products[i]->qty()) < (m_products[j]->qtyNeeded() - m_products[j]->qty())) {
                    iProduct* t = m_products[i];
                    m_products[i] = m_products[j];
                    m_products[j] = t;
                }
            }
        }

        cout << ""Sort completed!"" << endl;
    }

    void AidMan::updateQuantity()
    {
        cout << ""****Update Quantity****"" << endl;
        cout << ""Item description: "";
        cin.ignore();  // Ignore any previous newline character in the input buffer
        char description[1000] = { 0 };
        cin.getline(description, 1000);

        int matchedCount = list(description);
        if (matchedCount == 0) {
            cout << ""No matches found!"" << endl;
            return;
        }

        cout << ""Enter SKU: "";
        int sku;
        cin >> sku;
        int idx = search(sku);
        if (idx == -1) {
            cout << ""SKU not found!"" << endl;
            return;
        }

        Menu menu(""Add\tReduce"");
        int choice = menu.run(0);
        if (choice == 0) {
            cout << ""Aborted!"" << endl;
            return;
        }

        // Add
        if (choice == 1) {
            if (m_products[idx]->qtyNeeded() <= m_products[idx]->qty()) {
                cout << ""Quantity Needed already fulfilled!"" << endl;
                return;
            }
            else {
                int qty = ut.getint(1, m_products[idx]->qtyNeeded(), ""Quantity to add: "", nullptr);
                *m_products[idx] += qty;
                cout << qty << "" items added!"" << endl;
            }
        }
        // Reduce
        if (choice == 2) {
            if (m_products[idx]->qty() == 0) {
                cout << ""Quantity on hand is zero!"" << endl;
                return;
            }
            else {
                int qty = ut.getint(1, m_products[idx]->qty(), ""Quantity to reduce: "", nullptr);
                *m_products[idx] -= qty;
                cout << qty << "" items removed!"" << endl;
            }
        }
    }

    void AidMan::remove(int idx) {
        if (idx >= m_productCount) {
            return;
        }

        delete m_products[idx];
        m_productCount--;
        for (int i = idx; i < m_productCount; ++i) {
            m_products[i] = m_products[i + 1];
        }        
    }

    void AidMan::removeItem()
    {
        cout << ""****Remove Item****"" << endl;
        cout << ""Item description: "";
        cin.ignore();  
        char description[1000] = { 0 };
        cin.getline(description, 1000);

        int matchedCount = list(description);
        if (matchedCount == 0) {
            cout << ""No matching items found."" << endl;
            return;
        }

        cout << ""Enter SKU: "";
        int sku;
        cin >> sku;

        int idx = search(sku);
        if (idx == -1) {
            cout << ""SKU not found!"" << endl;
            return;
        }
        cout << ""Following item will be removed: "" << endl;
        m_products[idx]->linear(false);
        cout << *m_products[idx] << endl;

        cout << ""Are you sure?"" << endl;
        Menu menu(""Yes!"");
        int choice = menu.run(0);
        if (choice == 1) {
            remove(idx);
            cout << ""Item removed!"" << endl;
        }
        else {
            cout << ""Aborted!"" << endl;
        }
    }

    void AidMan::add() {
        // if number of iProduct Items is not less than sdds_max_num_items, 
        // it will print: ""Database full!""
        if (m_productCount >= sdds_max_num_items) {
            cout << ""Database full!"" << endl;
            return;
        }

        cout << ""****Add Item****"" << endl;
        Menu menu(""Perishable\tNon-Perishable"");
        int choice = menu.run(2);

        Item* newProduct = nullptr;
        int sku = -1;

        // Based on the user's entry a Perishable or Non-Perishable Item is allocated in an iProduct pointer.
        // If the user chooses to exit, the message ""Aborted\n"" is printed.
        switch (choice) {
        case 1: {
            newProduct = new Perishable;
            break;
        }
        case 2: {
            newProduct = new Item;
            break;
        }
        case 0:
            cout << ""Aborted!"" << endl;
            return;
        };

        sku = newProduct->readSku(cin);
        if (search(sku) != -1) {
            cout << ""Sku: "" << sku << "" is already in the system, try updating quantity instead."" << endl;
            delete newProduct;
            return;
        }

        // If the read iProduct is in a good state, 
        // it is added to the next available element of the iProduct Pointers array and 
        // number of iProduct Items is added by one, 
        // otherwise, the allocated Item is displayed and then deleted.
        cin >> *newProduct;
        if (*newProduct) {
            m_products[m_productCount++] = newProduct;
        }
        else {
            cout << *newProduct << endl;
            delete newProduct;
            newProduct = nullptr;
        }
    }
    
    int AidMan::search(int sku) const {
        // Loops through all the iProduct Pointers elements and 
        // if the SKU is a match it will return the index, otherwise it will return -1
        for (int i = 0; i < m_productCount; ++i) {
            if ((*m_products[i]) == sku) {
                return i;
            }
        }
        return -1;
    }

    int AidMan::list(const char* sub_desc/* = nullptr*/) {
        
        cout << "" ROW |  SKU  | Description                         | Have | Need |  Price  | Expiry\n"";
        cout << ""-----+-------+-------------------------------------+------+------+---------+-----------"" << endl;
            
        int  [MASK]  = 0;
        if (sub_desc == nullptr) {
            // if sub_desc is null, print all the items in a linear format.
            for (int i = 0; i < m_productCount; ++i) {
                m_products[i]->linear(true);
                cout.fill(' ');
                cout << std::setw(4) << i + 1 << "" | "";
                m_products[i]->display(cout);
                cout << endl;
            }
             [MASK]  = m_productCount;
        }
        else {
            // if sub_desc is not null, print only the items containing the sub_desc in their description.
            for (int i = 0; i < m_productCount; ++i) {
                if ((*m_products[i]) == sub_desc) {
                    m_products[i]->linear(true);
                    cout.fill(' ');
                    cout << std::setw(4) << i + 1 << "" | "";
                    m_products[i]->display(cout);
                    cout << endl;
                     [MASK] ++;
                }
            }
        }

        cout << ""-----+-------+-------------------------------------+------+------+---------+-----------"" << endl;

        if ( [MASK]  == 0) {
            // if no items are listed, print ""The list is emtpy!"" and go to new line
            cout << ""The list is emtpy!"" << endl;
        }
        
        // returns the number of iProducts printed 
        return  [MASK] ;
    }

    bool AidMan::load() {
        save();
        deallocate();

        cout << ""****New/Open Aid Database****"" << endl;
        cout << ""Enter file name: "";

        char filename[0x100];
        cin >> filename;

        m_filename = new char[strlen(filename) + 1];
        strcpy(m_filename, filename);

        ifstream file(m_filename);
        if (!file) {
            cout << ""Failed to open "" << m_filename << "" for reading!"" << endl;
            cout << ""Would you like to create a new data file?"" << endl;
            Menu newData(""Yes!"");
            int choice = newData.run(true);
            if (choice == 1) {
                ofstream newFile(m_filename);
                newFile.close();
            }
        } else {
            
            while (!file.eof())
            {
                Item* newItem = nullptr;
                int firstChar = file.peek();
                if (firstChar >= '1' && firstChar < '4') {
                    newItem = new Perishable();
                } else if (firstChar >= '4') {
                    newItem = new Item();
                } else {
                    file.setstate(std::ios::failbit);
                }

                if (newItem != nullptr) {
                    newItem->load(file);
                    if (*newItem) {
                        m_products[m_productCount++] = newItem;
                        if (m_productCount >= sdds_max_num_items) {
                            cout << ""Database full!"" << endl;
                            break;
                        }
                    }
                    else {
                        delete newItem;
                    }
                }
            }

            cout << m_productCount << "" records loaded!"" << endl;
            file.close();
        }
        return true;
    }

    void AidMan::save() {
        if (m_filename == nullptr)
            return;

        ofstream ofs(m_filename);
        if (!ofs)
            return;

        for (int i = 0; i < m_productCount; ++i)
        {
            m_products[i]->save(ofs);
            ofs << endl;
        }
    }

    void AidMan::deallocate() {
        for (int i = 0; i < m_productCount; i++) {
            delete m_products[i];
            m_products[i] = nullptr;
        }
        m_productCount = 0;
        delete[] m_filename;
        m_filename = nullptr;
    }
}

",printedCount
435,"// g++ ./c++/error.cc -o ./build/error && ./build/error
#include <iostream>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <utime.h>
#include <sys/time.h>
#include <dirent.h>
#include <stdio.h>
#include <sys/dir.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/types.h>

using namespace std;


int main() {
    long  [MASK]  = 0x2000004;
    long STDOUT = 1;

    long result;
    char* str = ""Hello world"";

    __asm__ __volatile__ (
        ""syscall;\n""
        : ""=a"" (result)
        : ""a"" ( [MASK] ), ""D"" (STDOUT), ""S"" (str), ""d"" (10)
        :
    );

    std::cout << result << endl;

    return 0;
}
",SYS_WRITE
436,"//-------------------------------------------------------------------------------------------
// INCLUDES
//-------------------------------------------------------------------------------------------

// MQTT Includes
#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>

// OLED Includes
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//-------------------------------------------------------------------------------------------
// VARIABLES
//-------------------------------------------------------------------------------------------

// MQTT Constants and objects
const char* ssid = ""Reformat Hard Drive""; // SSID/Password combination
const char* password = ""<PASSWORD>"";
const char* mqtt_server = ""192.168.1.101""; // MQTT Broker IP address
WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

// OLED Constants and Objects
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
int OLEDcount = 0;

// Receive LED
#define ledPin1 2

// Tx State Variables
#define ledPin2 14
String TxState = ""SLEEP"";

// Sample Period 
String SamplePeriod = ""4"";
String NewSamplePeriod;
bool ClearToSend = false;
bool QueuedSample = false;
bool QueuedRestart = false;

// OLED Pins
// SCL -> GPIO22
// SDA -> GPIO21

// Text Extraction Variables
String incomingString;
String sendaddress;
String messagesize;
String Temperature;
String Turbidity;
String Voltage;
String PacketNo;
String rssi;
String snr;

//-------------------------------------------------------------------------------------------
// SETUP BELOW
//-------------------------------------------------------------------------------------------

void setup() {
  Serial.begin(115200);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);

  // LoRa Rx Setup
  Serial.println(""AT+RESET"");
  delay(20);
  Serial.println(""AT+ADDRESS=1"");
  delay(20);
  Serial.println(""AT+NETWORKID=5"");

  // OLED Setup
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C for 128x64
    Serial.println(F(""SSD1306 allocation failed""));
    for(;;);
  }
  delay(2000);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);

  // MQTT Setup
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  PublishSamplePeriod();

}

//-------------------------------------------------------------------------------------------
// CODE BEFORE LOOP
//-------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------
// LOOP BELOW
//-------------------------------------------------------------------------------------------

void loop() {

  // Check that Rx is connected to Broker
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  CheckForMessage();
  CheckClearToSend();

  ScreenSaver();
  
}

//-------------------------------------------------------------------------------------------
// ALL OTHER FUNCTIONS
//-------------------------------------------------------------------------------------------

void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print(""Connecting to "");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  // Print to OLED
  display.setCursor(0, 5);
  display.clearDisplay();
  display.println(""Connecting"");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    // Print to Serial
    Serial.print(""."");    

    // Print to OLED
    display.print(""."");
    display.display(); 
  }

  // Print to OLED
  display.setCursor(0, 5);
  display.clearDisplay();
  display.println(""Connected"");
  display.display(); 

  // Print to Serial
  Serial.println("""");
  Serial.println(""WiFi connected"");
  Serial.println(""IP address: "");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* message, unsigned int length) {
  Serial.print(""Message arrived on topic: "");
  Serial.print(topic);
  Serial.print("". Message: "");
  String messageTemp;
  
  for (int i = 0; i < length; i++) {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();

  // Feel free to add more if statements to control more GPIOs with MQTT

  // If a message is received on the topic esp32/output, you check if the message is either ""on"" or ""off"". 
  // Changes the output state according to the message
  if (String(topic) == ""esp32/output"") {
    Serial.print(""Changing output to "");
    if(messageTemp == ""on""){
      Serial.println(""on"");
      // TxWake();
    }
    else if(messageTemp == ""off""){
      Serial.println(""off"");
      // TxSleep();
    }
  }

  if (String(topic) == ""esp32/SamplePeriod"") {
    // Serial.print(""Changing sample period to "");
    // Serial.println(messageTemp);
    NewSamplePeriod = messageTemp;
    QueuedSample = true;
    Serial.println(""Sample Period changed to "" + NewSamplePeriod + ""s - waiting for Tx to wake"");
    //ChangeSamplePeriod();
  }

  if (String(topic) == ""esp32/restart"") {
    QueuedRestart = true;
      // Serial.println(""+RCV=0,7,RESTART,-125,-31"");
  }
  
}




void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print(""Attempting MQTT connection..."");
    // Attempt to connect
    if (client.connect(""ESP8266Client"")) {
      Serial.println(""connected"");
      // Subscribe
      client.subscribe(""esp32/output"");
      client.subscribe(""esp32/SamplePeriod"");
      client.subscribe(""esp32/restart"");
    } else {
      Serial.print(""failed, rc="");
      Serial.print(client.state());
      Serial.println("" try again in 5 seconds"");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void CheckForMessage(){
  if (Serial.available()>0){

    incomingString = Serial.readString();
  
    if(incomingString.indexOf(""RCV"") > 0){
      // Filter Messages
      // Data
      if(incomingString.indexOf(""DATA"") > 0){
        ExtractData();
        Serial.println(""Data received"");
      }

      // State
      if(incomingString.indexOf(""STATE"") > 0){
        
        if(incomingString.indexOf(""WAKE"") > 0){
          digitalWrite(ledPin2, HIGH);
          TxState = ""WAKE"";
          delay(100);
          Serial.println(""Tx awake"");
        }
        
        if(incomingString.indexOf(""SLEEP"") > 0){
          digitalWrite(ledPin2, LOW);
          TxState = ""SLEEP"";
          delay(100);
          Serial.println(""Tx asleep"");
          ClearToSend = false;
        }
        UpdateTxStateLED();
      }

      //Clear to Send
      if((incomingString.indexOf(""CLEARTOSEND"")) > 0){
        ClearToSend = true;
      }

      //Tx Shutdown
      if((incomingString.indexOf(""SHUTDOWN"")) > 0){
        Serial.println(""Tx Battery drained - Tx shutting down"");
        PublishShutdown();
      }
      
    }
  }
}

void ExtractData(){
  digitalWrite(ledPin1, HIGH);
  Serial.println(incomingString);
  
  // Find Placeholders
  // If message contains commas, could be problematic. So should use better extraction than commas to make more robust
  int  [MASK]  = incomingString.indexOf('=');
  int comma1 = incomingString.indexOf(','); // Find comma - beginning of <Payload Length>
  int comma2 = incomingString.indexOf(',', comma1 + 1); // Find second comma, starting from index after the first comma
  int plus1 = incomingString.indexOf('+', comma2 + 1);
  int plus2 = incomingString.indexOf('+', plus1 + 1);
  int plus3 = incomingString.indexOf('+', plus2 + 1);
  int plus4 = incomingString.indexOf('+', plus3 + 1);
  int comma3 = incomingString.indexOf(',', plus4 + 1);
  int comma4 = incomingString.indexOf(',', comma3 + 1);

  // Extract Sender Address
  sendaddress = incomingString.substring( [MASK] , comma1);
  // Extract Message Size
  messagesize = incomingString.substring(comma1 + 1, comma2); // message size lies between these two indexes
  // Extract Temperature
  Temperature = incomingString.substring(comma2 + 1 + 4, plus1); // message begins at (index after second comma), ends at (index after second comma + message size)
  // Extract Turbidity
  Turbidity = incomingString.substring(plus1 + 1, plus2);
  // Extract Voltage
  Voltage = incomingString.substring(plus2 + 1, plus3);
  // Extract Sample Period
  SamplePeriod = incomingString.substring(plus3 + 1, plus4);
  // Extract Packet Number
  PacketNo = incomingString.substring(plus4 + 1, comma3);
  //Extract RSSI
  rssi = incomingString.substring(comma3 + 1, comma4);
  // Extract SNR
  snr = incomingString.substring(comma4 + 1);

  PrintOLED(Temperature, Turbidity, Voltage, PacketNo, rssi, snr);
  
  PublishTemp(Temperature.toFloat());
  PublishTurb(Turbidity.toFloat());
  PublishVolt(Voltage.toFloat());
  PublishSamplePeriod();
  PublishRSSI(rssi.toFloat());
  PublishSNR(snr.toFloat());

  delay(100);
  digitalWrite(ledPin1, LOW);
}

void PrintOLED(String Temp, String Turb, String Volt, String PN, String rssi, String snr){
  OLEDcount += 1;
  display.setCursor(0, 5);
  display.clearDisplay();
  Volt = Volt.substring(0, Volt.length()-3);
  // Display static text
  display.println(""Last Message:"");
  display.println("" "");
  display.println(""Temperature:  ""+Temp+""*C"");
  display.println(""Turbidity:       ""+Turb);
  display.println(""Battery:         ""+Volt+""%"");
  display.println(""Packet:           ""+PN);
  // display.println(""RSSI:            ""+rssi);
  // display.println(""SNR:             ""+snr);
  // display.println(""Tx State:       ""+TxState);
  display.println(""Sample Period:  ""+SamplePeriod+""min"");
  display.display(); 
}

void PublishTemp(float Temp){
    // Convert the value to a char array
    char tempString[8];
    dtostrf(Temp, 1, 2, tempString);
    client.publish(""esp32/temperature"", tempString);
}

void PublishTurb(float Turb){
    // Convert the value to a char array
    char turbString[8];
    dtostrf(Turb, 1, 2, turbString);
    client.publish(""esp32/turbidity"", turbString);
}

void PublishVolt(float Volt){
    // Convert the value to a char array
    char voltString[8];
    dtostrf(Volt, 1, 2, voltString);
    client.publish(""esp32/battery"", voltString);
}

void PublishRSSI(float rssi_){
    // Convert the value to a char array
    char rssiString[8];
    dtostrf(rssi_, 1, 2, rssiString);
    client.publish(""esp32/rssi"", rssiString);
}

void PublishSNR(float snr_){
    // Convert the value to a char array
    char snrString[8];
    dtostrf(snr_, 1, 2, snrString);
    client.publish(""esp32/snr"", snrString);
}

void PublishShutdown(){
    client.publish(""esp32/shutdown"", ""Tx shutting down"");
}

void UpdateTxStateLED(){
  if(TxState == ""SLEEP""){
    digitalWrite(ledPin2, LOW);
    delay(100);
    client.publish(""esp32/TxState"", ""sleep"");
  }
  if(TxState == ""WAKE""){
    digitalWrite(ledPin2, HIGH);
    delay(100);
    client.publish(""esp32/TxState"", ""wake"");
  } 
}

void ChangeSamplePeriod(){
  Serial.println(""Changing sample period to "" + NewSamplePeriod + "" minutes"");
  delay(2000);
  String Message = ""AT+SEND=0,"" + String(NewSamplePeriod.length()+12) + "",CHANGESAMPLE"" + NewSamplePeriod;
  Serial.println(Message);
  Serial.flush();
  
  // Publish Updated Period
  //PublishSamplePeriod();
}

void PublishSamplePeriod(){
  String SP = SamplePeriod;
  int str_len = SP.length() + 1;
  char char_array[str_len]; //buffer
  //SP.toCharArray(char_array, str_len);
  SP.toCharArray(char_array, str_len);
  client.publish(""esp32/TxSamplePeriod"", char_array);
}


void CheckClearToSend(){
  if (ClearToSend == true){
    if (QueuedSample == true){
      ChangeSamplePeriod();
      QueuedSample = false;
      delay(2000);
    }
    if (QueuedRestart == true){
      Serial.println(""Restarting Tx"");
      delay(2000);
      Serial.println(""AT+SEND=0,7,RESTART"");
      Serial.flush();
      QueuedRestart = false;
      delay(2000);
    }
  }
}

void ScreenSaver(){
    if (OLEDcount == 49){
    testfillrect();
    OLEDcount = 0;
  }
}

void testfillrect(void) {
  display.clearDisplay();

  for(int16_t i=0; i<display.height()/2; i+=3) {
    // The INVERSE color is used so rectangles alternate white/black
    display.fillRect(i, i, display.width()-i*2, display.height()-i*2, INVERSE);
    display.display(); // Update screen with each newly-drawn rectangle
    delay(1);
  }

  delay(2000);
}
",equal
437,"
/* 
 扩展以使用质心偏移检测连续图像中的运动。
 该技术减少了虚假的运动变化：
 -相机噪点，特别是在弱光下
 -微小的运动，例如树叶沙沙作响，下雨
 -短暂的运动，例如鸟类飞过
 -照明水平的变化，例如过云
 图像之间的变化量将取决于帧频。
 更快的帧速率将需要更高的灵敏度
 更改帧大小时，OV2640会输出一些毛刺的帧 
 进行过渡。这些可以解释为虚假运动。

 s60sc 2020
 
*/
#include ""motionDetect.h""
#include ""esp_camera.h""
#include ""esp_jpg_decode.h""
#include <SD_MMC.h>

// 用于校准运动检测的用户配置参数
// user configuration parameters for calibrating motion detection
//改变帧，以确认运动分钟序列
#define MOTION_SEQUENCE 5 // min sequence of changed frames to confirm motion 
//连续黑暗的帧，以避免伪白天/夜晚开关
#define NIGHT_SEQUENCE 10 // frames of sequential darkness to avoid spurious day / night switching
//用于调试，真正加入BMP头，因为没有虚假
#define WANT_BMP false // for debugging, true to add BMP header, false for none

// 常数
// constants
//数每像素的字节
#define RGB888_BYTES 3 // number of bytes per pixel
//大小的BMP标题字节
#define BMP_HEADER 54 // size of BMP header bytes

// 自动换行printf
// auto newline printf
#define showInfo(format, ...) Serial.printf(format ""\n"", ##__VA_ARGS__)
#define showError(format, ...) Serial.printf(""ERROR: "" format ""\n"", ##__VA_ARGS__)
#define showDebug(format, ...) if (debug) Serial.printf(""DEBUG: "" format ""\n"", ##__VA_ARGS__)

/*********声明并初始化以下内容********/
/********* the following must be declared and initialised elsewhere **********/
extern bool debug;
extern uint8_t fsizePtr;
//当前环境光水平
extern uint8_t lightLevel; // Current ambient light level 
//运动灵敏度设置
extern uint8_t motionVal; // motion sensitivity setting

struct frameStruct {
  const char* frameSizeStr;
  const uint16_t frameWidth;
  const uint16_t frameHeight;
  const uint16_t defaultFPS;
  const uint8_t scaleFactor;
  const uint8_t sampleRate;
};
extern const frameStruct frameData[];

/**********************************************************************************/

static bool jpg2rgb(const uint8_t *src, size_t src_len, uint8_t ** out, size_t * out_len, uint8_t scale, uint8_t bmpOffset);

bool motionDetection(camera_fb_t* fb, bool motionStatus) {
  //获取当前帧并计算质心，然后与上一个进行比较
  // get current frame and calculate centre of mass, then compare with previous
  uint32_t mTime = millis();
  //将jpeg转换为缩小的位图
  // convert jpeg to downsized bitmap
  uint8_t* bmpBuf = NULL;
  size_t buf_len = 0;
  // BMP标头的大小（如果需要）
  uint8_t bmpOffset = WANT_BMP ? BMP_HEADER : 0; // size of BMP header if wanted
  bool converted = jpg2rgb((uint8_t*)fb->buf, fb->len, &bmpBuf, &buf_len, frameData[fsizePtr].scaleFactor, bmpOffset);
  if (debug && bmpOffset) { 
    //出于调试目的，以BMP格式存储在SD中，以检查位图格式正确
    // for debug purposes, store on SD as BMP to check that bitmap is properly formed
    File bmpFile = SD_MMC.open(""/test.bmp"", FILE_WRITE);
    bmpFile.write(bmpBuf, buf_len); 
    bmpFile.close(); 
    showDebug(""wrote BMP to SD"");
  }
  
  if (converted) {       
    showDebug(""Jpeg to bitmap conversion time %ums"", millis()-mTime); 
    uint32_t cTime = millis(); 
    static uint16_t motionCnt = 0;
    uint32_t lux = 0;

    //计算样本量的参数
    // calculate parameters for sample size
    uint8_t downsize = pow(2, frameData[fsizePtr].scaleFactor) * frameData[fsizePtr].sampleRate;
    uint8_t numCols = frameData[fsizePtr].frameWidth / downsize;
    uint8_t numRows = frameData[fsizePtr].frameHeight / downsize;
    uint16_t pixelSpan = frameData[fsizePtr].sampleRate * RGB888_BYTES;
    uint16_t bitmapWidth = numCols * frameData[fsizePtr].sampleRate;
    //每列每种颜色的总像素值
    uint32_t col[numCols][RGB888_BYTES] = {0}; // total pixel values per color per column 
    //每行每种颜色的总像素值
    int32_t row[numRows][RGB888_BYTES] = {0}; // total pixel values per color per row
    uint32_t numSamples = numCols * numRows;
    showDebug(""%u samples for %s"", numSamples, frameData[fsizePtr].frameSizeStr);
 
    //获取每种采样像素颜色的质量（像素值）并在行和列中累加
    // get mass (pixel value) of each sampled pixel color and accumulate in row and column
    for (int r=0; r<numRows; r++) {
      for (int c=0; c<numCols; c++) {
        uint32_t pixelPos = bmpOffset+((c+(r*bitmapWidth))*pixelSpan); // within bitmap buffer
        for (uint32_t rgb=0; rgb<RGB888_BYTES; rgb++) {
          //每个像素都有RGB值
          // each pixel has RGB values
          row[r][rgb] += bmpBuf[pixelPos+rgb]; 
          col[c][rgb] += bmpBuf[pixelPos+rgb];
          lux += bmpBuf[pixelPos+rgb];
        }
      }  
    }

    //计算图像的质心
    // calculate image centre of mass
    //每种颜色的列总和
    uint32_t cSum[RGB888_BYTES] = {0}; // total column sum per color
    //每种颜色的总加权列总和（质量）
    float cMass[RGB888_BYTES] = {0};  //  total weighted column sum (mass) per color
    //x轴的质心
    float cCOM[RGB888_BYTES] = {0}; // x axis centre of mass
    //当前和上一个x轴之间的差异
    float cCOMdiff[RGB888_BYTES] = {0}; // difference between current and previous x axis
    //先前的x轴质心
    static float cCOMprev[RGB888_BYTES] = {0}; // previous x axis centre of mass
    //如上所示，对于行/ y轴
    uint32_t rSum[RGB888_BYTES] = {0}; // as above for rows / y axis
    float rMass[RGB888_BYTES] = {0};
    float rCOM[RGB888_BYTES] = {0};
    float rCOMdiff[RGB888_BYTES] = {0};
    static float rCOMprev[RGB888_BYTES] = {0};
    
    for (int rgb=0; rgb<RGB888_BYTES; rgb++) {
      for (int r=0; r<numRows; r++) { 
        // calculate total row sum and total row relative mass per color
        rSum[rgb] += row[r][rgb];
        rMass[rgb] += (row[r][rgb] * (r+1));
      }
      for (int c=0; c<numCols; c++) {
        // calculate total col sum and total col relative mass per color
        cSum[rgb] += col[c][rgb];
        cMass[rgb] += (col[c][rgb] * (c+1));
      }   
      // calculate x and y centre of mass per color and difference to previous
      cCOM[rgb] = cMass[rgb] / cSum[rgb];
      cCOMdiff[rgb] = cCOM[rgb] - cCOMprev[rgb];
      cCOMprev[rgb] = cCOM[rgb];
      rCOM[rgb] = rMass[rgb] / rSum[rgb];
      rCOMdiff[rgb] = rCOM[rgb] - rCOMprev[rgb];
      rCOMprev[rgb] = rCOM[rgb];    
    }
    // get single x & y differences and percent change
    float COMtot = 0;
    float COMtotDiff = 0;
    for (int rgb=0; rgb<RGB888_BYTES; rgb++) {
      COMtot += (abs(cCOM[rgb])+abs(rCOM[rgb]));
      COMtotDiff += (abs(cCOMdiff[rgb])+abs(rCOMdiff[rgb]));
    }
    float diffPcnt = (COMtotDiff*100)/COMtot; // total % difference between frames  
    
    lightLevel = (lux*100)/(numSamples*RGB888_BYTES*255); // light value as a %
    showDebug(""diffPcnt %0.2f%%, lux %u%%, %ums"", diffPcnt, lightLevel, millis()-cTime);

    // determine if movement has occurred
    if (diffPcnt > (float)0.01*pow(2, 10-motionVal)) { //  min % shift to indicate movement
      // sufficient centre of mass shift
      if (!motionStatus) motionCnt += 1;
      showDebug(""### Change detected"");
      // need minimum sequence of changes to signal valid movement
      if (!motionStatus && motionCnt >= MOTION_SEQUENCE) {
        showDebug(""***** Motion - START"");
        motionStatus = true; // motion started
      } 
    } else {
      // insufficient change
      if (motionStatus) {
        motionCnt = 0;
        showDebug(""***** Motion - STOP"");
        motionStatus = false; // motion stopped
      }
    }
    if (motionStatus) showDebug(""*** Motion - ongoing"");
    showDebug(""Total motion processing for frame %ums"", millis()-mTime);
  } else showError(""Image conversion failed"");

  // esp32-cam issue #126
  if (bmpBuf == NULL) showError(""Memory leak, heap now: %u"", xPortGetFreeHeapSize());
  free(bmpBuf);
  bmpBuf = NULL;
  return motionStatus;
}

bool isNight(uint8_t nightSwitch) {
  // check if night time for switching on lamp during recording
  static bool nightTime = false;
  static uint16_t  [MASK]  = 0;
  if (!nightTime && lightLevel < nightSwitch) {
    // dark image
     [MASK]  += 1;
    // only signal night time after given sequence of dark frames
    if ( [MASK]  > NIGHT_SEQUENCE) {
      nightTime = true;     
      showInfo(""Night time""); 
    }
  } 
  if (lightLevel > nightSwitch) {
     [MASK]  = 0;
    if (nightTime) {
      nightTime = false;
      showInfo(""Day time"");
    }
  }  
  return nightTime;
}

/************* copied and modified from esp32-camera/to_bmp.c to access jpg_scale_t *****************/

typedef struct {
  uint16_t width;
  uint16_t height;
  uint16_t data_offset;
  const uint8_t *input;
  uint8_t *output;
} rgb_jpg_decoder;

static bool _rgb_write(void * arg, uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t *data) {
  rgb_jpg_decoder * jpeg = (rgb_jpg_decoder *)arg;
  if (!data){
    if (x == 0 && y == 0) {
      // write start
      jpeg->width = w;
      jpeg->height = h;
      // if output is null, this is BMP
      if (!jpeg->output) {
        jpeg->output = (uint8_t*)ps_malloc((w*h*3)+jpeg->data_offset);
        if (!jpeg->output) return false;
      }
    } 
    return true;
  }

  size_t jw = jpeg->width*3;
  size_t t = y * jw;
  size_t b = t + (h * jw);
  size_t l = x * 3;
  uint8_t *out = jpeg->output+jpeg->data_offset;
  uint8_t *o = out;
  size_t iy, ix;
  w = w * 3;

  for (iy=t; iy<b; iy+=jw) {
    o = out+iy+l;
    for (ix=0; ix<w; ix+=3) {
      o[ix] = data[ix+2];
      o[ix+1] = data[ix+1];
      o[ix+2] = data[ix];
    }
    data+=w;
  }
  return true;
}

static uint32_t _jpg_read(void * arg, size_t index, uint8_t *buf, size_t len) {
  rgb_jpg_decoder * jpeg = (rgb_jpg_decoder *)arg;
  if (buf) memcpy(buf, jpeg->input + index, len);
  return len;
}

typedef struct {
  uint32_t filesize;
  uint32_t reserved;
  uint32_t fileoffset_to_pixelarray;
  uint32_t dibheadersize;
  int32_t width;
  int32_t height;
  uint16_t planes;
  uint16_t bitsperpixel;
  uint32_t compression;
  uint32_t imagesize;
  uint32_t ypixelpermeter;
  uint32_t xpixelpermeter;
  uint32_t numcolorspallette;
  uint32_t mostimpcolor;
} bmp_header_t;

static bool jpg2rgb(const uint8_t *src, size_t src_len, uint8_t ** out, size_t * out_len, uint8_t scale, uint8_t bmpOffset) {
  rgb_jpg_decoder jpeg;
  jpeg.width = 0;
  jpeg.height = 0;
  jpeg.input = src;
  jpeg.output = NULL; 
  jpeg.data_offset = bmpOffset;
  if (esp_jpg_decode(src_len, jpg_scale_t(scale), _jpg_read, _rgb_write, (void*)&jpeg) != ESP_OK) {
    *out = jpeg.output;
    return false;
  }

  size_t output_size = jpeg.width*jpeg.height*3;

  if (WANT_BMP) {
    jpeg.output[0] = 'B';
    jpeg.output[1] = 'M';
    bmp_header_t * bitmap = (bmp_header_t*)&jpeg.output[2];
    bitmap->reserved = 0;
    bitmap->filesize = output_size+bmpOffset;
    bitmap->fileoffset_to_pixelarray = bmpOffset;
    bitmap->dibheadersize = 40;
    bitmap->width = jpeg.width;
    bitmap->height = -jpeg.height; //set negative for top to bottom
    bitmap->planes = 1;
    bitmap->bitsperpixel = 24;
    bitmap->compression = 0;
    bitmap->imagesize = output_size;
    bitmap->ypixelpermeter = 0x0B13 ; //2835 , 72 DPI
    bitmap->xpixelpermeter = 0x0B13 ; //2835 , 72 DPI
    bitmap->numcolorspallette = 0;
    bitmap->mostimpcolor = 0;
  }
  *out = jpeg.output;
  *out_len = output_size+bmpOffset;

  return true;
}
",nightCnt
438,"//
// Created by zhangws on 2024/3/7.
//
#include <android/log.h>


//加载着色器
GLuint LoadShader(GLenum type,const char * shaderSrc){
    GLuint shader;
    GLint  [MASK] ;
    shader=glCreateShader(type);
    if(shader==0){
        return 0;
    }
    glShaderSource(shader,1,&shaderSrc,NULL);
    glCompileShader(shader);
    glGetShaderiv(shader,GL_COMPILE_STATUS,& [MASK] );
    if(! [MASK] )
    {
        GLint infoLen=0;
        glGetShaderiv(shader,GL_INFO_LOG_LENGTH,&infoLen);
        if(infoLen>0)
        {
            char * infoLog=(char*) malloc(sizeof(char)*infoLen);
            glGetShaderInfoLog(shader,infoLen,NULL,infoLog);
            LOGE(""Error compiling shader:[%s]"",infoLog);
            free(infoLog);
        }
        glDeleteShader(shader);
        return 0;
    }
    return shader;
}",compiled
439,"#define TINYGLTF_IMPLEMENTATION
#define TINYGLTF_NO_STB_IMAGE_WRITE
#define TINYGLTF_NO_STB_IMAGE
#define TINYGLTF_NO_EXTERNAL_IMAGE
#include ""tiny_gltf.h""

#include ""Globals.h""
#include ""Model.h""
#include ""Mesh.h""
#include ""Application.h""
#include ""ModuleTexture.h""
#include ""ModuleCamera.h""
#include ""ModuleEditor.h""
#include ""MathGeoLib.h""


/**
 * Constructor for the Model class.
 */
Model::Model() {}

/**
 * Destructor for the Model class.
 * Frees all allocated meshes.
 */
Model::~Model() {
    for (Mesh* mesh : meshes) {
        delete mesh;
    }
}

/**
 * Initializes the model.
 *
 * @return true if initialization is successful.
 */
bool Model::Init() {
    return true;
}

/**
 * Updates the model during the application's update loop.
 *
 * @return The update status.
 */
update_status Model::Update() {
    return UPDATE_CONTINUE;
}

/**
 * Loads a GLTF model from a file.
 *
 * @param assetFileName The path to the GLTF file.
 */
void Model::Load(const char* assetFileName) {
    tinygltf::TinyGLTF gltfContext;
    tinygltf::Model model;
    std::string error, warning;
    int cont = 0;

    if (!gltfContext.LoadASCIIFromFile(&model, &error, &warning, assetFileName)) {
        LOG(""Error loading %s: %s"", assetFileName, error.c_str());
        Clear();
        return;
    }
    else {
        
        LOG(""Model Loaded successfully: %s"", assetFileName);

        LoadMaterials(model); 

        for (const auto& srcMesh : model.meshes) {
            for (const auto& primitive : srcMesh.primitives) {
                cont++;
                LOG(""Mesh number %d"", cont);
                Mesh* mesh = new Mesh;
                mesh->Load(model, srcMesh, primitive);
                mesh->LoadEBO(model, srcMesh, primitive);
                mesh->CreateVAO();
                SaveModelInfo(cont, mesh);
                meshes.push_back(mesh);

            }
        }

        std::string filename(assetFileName);
        if (filename.find(""house"") != std::string::npos || filename.find(""House"") != std::string::npos) {  
            App->GetCamera()->scalefactor = 50.0f;
        }
        else {
            App->GetCamera()->scalefactor = 1.0f;
        }
    }
    

}

/**
 * Loads the textures of the model.
 *
 * @param srcModel The GLTF model containing the materials.
 */
void Model::LoadMaterials(const tinygltf::Model& srcModel) {
    for (const auto& srcMaterial : srcModel.materials) {
        unsigned int textureId = 0;

        if (srcMaterial.pbrMetallicRoughness.baseColorTexture.index >= 0) {
            const tinygltf::Texture& texture = srcModel.textures[srcMaterial.pbrMetallicRoughness.baseColorTexture.index];
            if (texture.source >= 0 && texture.source < srcModel.images.size()) {
                const tinygltf::Image& image = srcModel.images[texture.source];

                DirectX::ScratchImage scratch_image = App->GetTexture()->LoadTexture(""Textures/""+image.uri);
                textureId = App->GetTexture()->CreateTexture(scratch_image);

                scratch_image.Release();
            }
            else {
                LOG(""Invalid texture source index: %d"", texture.source);
            }
        }
        textures.push_back(textureId);
        SaveTextureInfo(textureId);
    }
}

/**
 * Saves texture information for showing in the UI.
 *
 * @param textureId The texture ID.
 */
void Model::SaveTextureInfo(unsigned int textureId)
{
    int width, height;
    glBindTexture(GL_TEXTURE_2D, textureId);
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
    textureInfo.push_back(""Texture Size: "" + std::to_string(width) + ""x"" + std::to_string(height));

    GLint wrapS,  [MASK] ;
    glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &wrapS);
    glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, & [MASK] );
    textureInfo.push_back(""Texture Wrap Mode S: "" + std::to_string(wrapS) + "", T: "" + std::to_string( [MASK] ));

    GLint minFilter, magFilter;
    glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &minFilter);
    glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &magFilter);
    textureInfo.push_back(""Texture Min Filter: "" + std::to_string(minFilter) + "", Max Filter: "" + std::to_string(magFilter));
    glBindTexture(GL_TEXTURE_2D, 0);

    App->GetEditor()->texture_id = textureId;
}

/**
 * Renders all the meshes in the model using the provided shader program.
 *
 * @param program The OpenGL shader program ID.
 */
void Model::RenderModels(unsigned& program) {

    for (size_t i = 0; i < meshes.size(); i++) {
        meshes[i]->Draw(textures, program);
    }

    App->GetEditor()->ModelInformation(modelInfo, textureInfo);
}

/**
 * Sets a new texture for the model.
 *
 * @param textureId The new texture ID.
 */
void Model::SetTexture(unsigned int textureId) {
    textures.clear();
    textureInfo.clear();
    textures.push_back(textureId);
    SaveTextureInfo(textureId);
}

/**
 * Saves information about a mesh for showing in the UI.
 *
 * @param meshIndex The index of the mesh.
 * @param mesh The mesh object.
 */
void Model::SaveModelInfo(const int& meshIndex, Mesh* mesh)
{
    modelInfo.push_back(""Mesh Index: "" + std::to_string(meshIndex));
    modelInfo.push_back(""Vertex number: "" + std::to_string(mesh->vertexCount));
    modelInfo.push_back(""Index Number: "" + std::to_string(mesh->indexCount));

}

/**
 * Calculates the Axis-Aligned Bounding Box (AABB) for the model.
 *
 * @return The calculated AABB.
 */
AABB Model::CalculateAABB() const {
    AABB aabb;
    aabb.SetNegativeInfinity(); 


    for (const Mesh* mesh : meshes) {
        for (size_t i = 0; i < mesh->vertices.size(); i += 3) { 
            float3 vertex = float3(mesh->vertices[i], mesh->vertices[i + 1], mesh->vertices[i + 2]);
            if (!aabb.Contains(vertex)) {
                aabb.Enclose(vertex);
            }
        }
    }

    return aabb;
}

/**
 * Clears the model, releasing all allocated resources.
 */
void Model::Clear() {
    modelInfo.clear();
    textureInfo.clear();

    for (Mesh* mesh : meshes) {
        mesh->Clear(); 
        delete mesh;
    }
    meshes.clear();

    for (unsigned texture : textures) {
        glDeleteTextures(1, &texture);
    }
    textures.clear();

    LOG(""Model cleared."");
}





",wrapT
440,"#include ""mainwindow.h""
#include ""ui_mainwindow.h""
#include <stdlib.h>
#include <time.h>

#include <QMessageBox>

void inicializarListaDeImagenes(ListaCircular<QPixmap> *col) {
    QPixmap pix0(""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(0).ICO"");
    pix0.scaled(25,25,Qt::KeepAspectRatio);
    col->agregar(pix0);
    QPixmap pix1(""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(1).ico"");
    pix1.scaled(25,25,Qt::KeepAspectRatio);
    col->agregar(pix1);
    QPixmap pix2(""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(2).ico"");
    pix2.scaled(25,25,Qt::KeepAspectRatio);
    col->agregar(pix2);
    QPixmap  [MASK] (""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(3).ICO"");
     [MASK] .scaled(25,25,Qt::KeepAspectRatio);
    col->agregar( [MASK] );
    QPixmap pix4(""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(6).ICO"");
    pix4.scaled(25,25,Qt::KeepAspectRatio);
    col->agregar(pix4);
    QPixmap pix5(""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(7).ICO"");
    pix5.scaled(25,25,Qt::KeepAspectRatio);
    col->agregar(pix5);
    QPixmap pix6(""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(8).ICO"");
    pix6.scaled(25,25,Qt::KeepAspectRatio);
    col->agregar(pix6);
    QPixmap pix7(""/home/emanuel/Facultad/programación orientada a objeto/2018/practica/tp14/tragaMonedas/TragaMonedas/img/imagen(9).ICO"");
    pix7.scaled(25,25,Qt::KeepAspectRatio);
    col->agregar(pix7);
}

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    this->col1 = new ListaCircular<QPixmap>();
    this->col2 = new ListaCircular<QPixmap>();
    this->col3 = new ListaCircular<QPixmap>();
    // Inicializar listas
    inicializarListaDeImagenes(this->col1);
    inicializarListaDeImagenes(this->col2);
    inicializarListaDeImagenes(this->col3);

    this->ui->label->setPixmap(this->col1->siguiente());
    this->ui->label_2->setPixmap(this->col1->siguiente());
    this->ui->label_3->setPixmap(this->col1->siguiente());

    this->ui->label_4->setPixmap(this->col2->siguiente());
    this->ui->label_5->setPixmap(this->col2->siguiente());
    this->ui->label_6->setPixmap(this->col2->siguiente());

    this->ui->label_7->setPixmap(this->col3->siguiente());
    this->ui->label_8->setPixmap(this->col3->siguiente());
    this->ui->label_9->setPixmap(this->col3->siguiente());


    connect(this->timer1, SIGNAL(timeout()), this, SLOT(moverCol1()));
    connect(this->timer2, SIGNAL(timeout()), this, SLOT(moverCol2()));
    connect(this->timer3, SIGNAL(timeout()), this, SLOT(moverCol3()));

}



MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_pushButton_clicked()
{
    this->timer1->setInterval(rand() % 30 + 10);
    this->timer1->start();

    this->timer2->setInterval(rand() % 40 + 10);
    this->timer2->start();

    this->timer3->setInterval(rand() % 50 + 10);
    this->timer3->start();
    this->ui->pushButton->setEnabled(false);
}

void MainWindow::moverCol1() {
    this->ui->label->setPixmap(this->col1->siguiente());
    this->ui->label_2->setPixmap(this->col1->siguiente());
    this->ui->label_3->setPixmap(this->col1->siguiente());
    int inter = this->timer1->interval()+this->timer1->interval()*0.1;
    if (inter<200) {
        this->timer1->setInterval(inter);
    } else {
        this->timer1->stop();

        if (!this->timer3->isActive() && !this->timer2->isActive()) {
            if (this->col1->getIndice() == this->col2->getIndice() && this->col2->getIndice() == this->col3->getIndice()) {
                QMessageBox::critical(this, ""Ganaste"", ""Suertudo!!"");
            }
            this->ui->pushButton->setEnabled(true);
        }
    }

}

void MainWindow::moverCol2() {
    this->ui->label_4->setPixmap(this->col2->siguiente());
    this->ui->label_5->setPixmap(this->col2->siguiente());
    this->ui->label_6->setPixmap(this->col2->siguiente());
    int inter = this->timer2->interval()+this->timer2->interval()*0.1;
    if (inter<200) {
        this->timer2->setInterval(inter);
    } else {

        this->timer2->stop();

        if (!this->timer1->isActive() && !this->timer3->isActive()) {
            if (this->col1->getIndice() == this->col2->getIndice() && this->col2->getIndice() == this->col3->getIndice()) {
                QMessageBox::critical(this, ""Ganaste"", ""Suertudo!!"");
            }
            this->ui->pushButton->setEnabled(true);
        }
    }
}

void MainWindow::moverCol3() {
    this->ui->label_7->setPixmap(this->col3->siguiente());
    this->ui->label_8->setPixmap(this->col3->siguiente());
    this->ui->label_9->setPixmap(this->col3->siguiente());
    int inter = this->timer3->interval()+this->timer3->interval()*0.1;
    if (inter<200) {
        this->timer3->setInterval(inter);
    } else {

        this->timer3->stop();

        if (!this->timer1->isActive() && !this->timer2->isActive()) {
            if (this->col1->getIndice() == this->col2->getIndice() && this->col2->getIndice() == this->col3->getIndice()) {
                QMessageBox::critical(this, ""Ganaste"", ""Suertudo!!"");
            }
            this->ui->pushButton->setEnabled(true);
        }
    }
}
",pix3
441,"// Copyright 2024 SkynetScout
//
// 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.

/**
 * @brief This header file includes the declaration for crack detection.
 * @file DetectCrack.cc
 * @date November 19, 2024
 * @version 1.5
 * @author <NAME>, <NAME>
 * @copyright Copyright (c) 2024
 */

#include ""DetectCrack.h""  

/* Constructor for the DetectCrack class */
scout::DetectCrack::DetectCrack() {
  // Initialize the status message for crack detection
  status = skynet_interfaces::msg::AnomalyStatus();
  status.name = ""Concrete Crack"";  // Set the name of the anomaly
  status.message = """";             // Initial empty message
  status.level = skynet_interfaces::msg::AnomalyStatus::OK;  // Set default anomaly level to OK
}

/* Destructor for the DetectCrack class */
scout::DetectCrack::~DetectCrack() {
  // Destructor logic (empty for now)
};

/* Method to process image frames for crack detection */
skynet_interfaces::msg::AnomalyStatus
scout::DetectCrack::processImage(cv::Mat image) {
  // Convert the input image to grayscale
  cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);

  // Apply thresholding to isolate dark pixels (likely representing cracks)
  cv::Mat binary;
  cv::threshold(gray, binary, 15, 255, cv::THRESH_BINARY_INV);  // Inverse binary thresholding for dark pixels (potential cracks)

  // Apply morphological operations to clean up noise
  cv::Mat morphKernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(5, 5));  // Create a rectangular kernel
  cv::morphologyEx(binary, binary, cv::MORPH_CLOSE, morphKernel);  // Perform morphological closing operation

  // Perform connected component analysis on the binary image
  cv::Mat labels, stats, centroids;
  int numComponents = cv::connectedComponentsWithStats(binary, labels, stats, centroids);
  bool  [MASK]  = false;
  // Iterate over each connected component to detect cracks
  for (int i = 1; i < numComponents; i++) {  // Start from 1 to ignore the background (component 0)
  
    int area = stats.at<int>(i, cv::CC_STAT_AREA);  // Area of the connected component
    int x = stats.at<int>(i, cv::CC_STAT_LEFT);    // X-coordinate of the bounding box
    int y = stats.at<int>(i, cv::CC_STAT_TOP);     // Y-coordinate of the bounding box
    int width = stats.at<int>(i, cv::CC_STAT_WIDTH);   // Width of the bounding box
    int height = stats.at<int>(i, cv::CC_STAT_HEIGHT); // Height of the bounding box

    // Filter out small components based on area (ignoring noise or irrelevant small areas)
    if (area > 600) {  // Threshold area to only consider significant components
      cv::Rect boundingBox(x, y, width, height);  // Define the bounding box for the detected crack
       [MASK]  = true;
    }
  }
  // If crack is detected, update the status
  if ( [MASK] ) {
    status.level = skynet_interfaces::msg::AnomalyStatus::CRACK;
    status.message = ""Found cracks"";
  } else {
    // If no misalignment is detected, set status to OK
    status.level = skynet_interfaces::msg::AnomalyStatus::OK;
    status.message = """";
  }
  return status;
}
",isDetected
442,"#include <iostream>
#include <string>
using namespace std;
// Function to calculate grade from marks
char calculateGrade(int marks) {
    if (marks >= 90 && marks <= 100) {
        return 'A';
    } else if (marks >= 80 && marks < 90) {
        return 'B';
    } else if (marks >= 70 && marks < 80) {
        return 'C';
    } else if (marks >= 60 && marks < 70) {
        return 'D';
    } else {
        return 'F';
    }
}
int main() {
    string  [MASK] ;
    int marks;
    cout << ""Enter student name: "";
    getline(cin,  [MASK] );
    cout << ""Enter marks (0-100): "";
    cin >> marks;
    if (marks < 0 || marks > 100) {
        cout << ""Invalid marks entered. Please enter marks between 0 and 100."" << endl;
        return 1;
    }
    char grade = calculateGrade(marks);
    cout << ""\nStudent Name: "" <<  [MASK]  << endl;
    cout << ""Marks Obtained: "" << marks << endl;
    cout << ""Grade: "" << grade << endl;
    return 0;
}
",studentName
443,"#include ""edgeDetectionPendantDrop.h""
#include <fstream>
#include <cmath>
#define TRESHHOLD 120
using namespace std;
vector<Point> readPendantDrop(string FILENAME_INPUT)
{
    vector <Point> coords;
    unsigned char red , green , blue;
    string  [MASK]  = ""res\\pics\\EXP_PROFILES\\"";
    string DER_DIRECTORY = ""res\\pics\\DER_PROFILES\\"";
    bitmap_image image( [MASK]  + FILENAME_INPUT);
    // xBeg , xEnd , yEnd
    int xBeg , xEnd , yEnd;
    //find horizontal and vertical extrema
    xBeg = findXBegP(image);
    xEnd = findXEndP(image);
    yEnd = findYEndP(image);
    //find coordinates
    for(int h = 1 ; h < yEnd ; h ++)
    {
        for(int w = xEnd ; w > (xEnd + xBeg) / 2 ; w --)
        {
            image.get_pixel(w , h , red , green , blue);
            if((int)red <= TRESHHOLD && (int)green <= TRESHHOLD && (int)blue <= TRESHHOLD)
            {
                image.set_pixel(w,h,255,0,0);
                Point tmp(w , h);//creates a temporary point to be inserted in the vector
                coords.push_back(tmp);//temporary point is inserted in the vector
                break;
            }
        }
    }
    image.save_image(DER_DIRECTORY + FILENAME_INPUT);
    //remove unwanted coordinates
    Point tmpPoint = coords.at(0);
    for(auto& it : coords)
    {
        if(abs(tmpPoint.x - it.x) <= 30)
            coords.erase(coords.begin());
        else
            break;
    }

    //reverses the vector
    reverseVector(coords);
    //resizes the coordinates
    for(auto& it : coords)
    {
        it.x = (it.x - ((xEnd + xBeg)/2))*(1.0)/((xEnd - xBeg)/2);
        it.y = (yEnd - it.y)*(1.0)/((xEnd - xBeg)/2);
    }
    coords.insert(coords.begin() , Point(0,0));
    return coords;
}
int findXBegP(bitmap_image image)
{
    unsigned char red , green , blue;
    for(int w = 1 ; w < image.width() ; w ++)
        for(int h = 1 ; h < image.height() ; h ++)
        {
            image.get_pixel(w , h , red , green , blue);
            if((int)red <= TRESHHOLD && (int)green <= TRESHHOLD && (int)blue <= TRESHHOLD)
                return w;
        }
}
int findXEndP(bitmap_image image)
{
    unsigned char red , green , blue;
    for(int w = image.width() - 1 ; w > 0  ; w --)
        for(int h = 1 ; h < image.height() ; h ++)
        {
            image.get_pixel(w , h , red , green , blue);
            if((int)red <= TRESHHOLD && (int)green <= TRESHHOLD && (int)blue <= TRESHHOLD)
                return w;
        }
}
int findYEndP(bitmap_image image)
{
    unsigned char red , green , blue;
    for(int h = image.height() - 1 ; h > 0 ; h --)
    {
        for(int w = 1 ; w < image.width() ; w ++) {
            image.get_pixel(w,h,red,green,blue);
            //image.set_pixel(w,h,0,0,255);
            if((int)red <= TRESHHOLD && (int)green <= TRESHHOLD && (int)blue <= TRESHHOLD)
                return h;
        }
    }
}
void reverseVector(vector<Point> & coords)
{
    vector<Point> tmpVector;
    for(vector<Point>::iterator it = coords.begin() ; it != coords.end() ; it ++)
    {
        if(it == (coords.begin()))
            tmpVector.push_back(*it);
        else
            tmpVector.insert(tmpVector.begin() , *it);
    }
    coords = tmpVector;
}
",EXP_DIRECTORY
444,"#include ""configurephasedialog.h""
#include ""ui_configurephasedialog.h""

#include <QMessageBox>

ConfigurePhaseDialog::ConfigurePhaseDialog(QWidget *parent, heatRampPhase_t* _phase, bool  [MASK] ) : QDialog(parent), ui(new Ui::ConfigurePhaseDialog)
{
    ui->setupUi(this);

    phaseWasDeleted = false;
    phase = _phase;
    isNew =  [MASK] ;

    ui->tempSpinBox->setValue(phase->targetTemp);
    ui->durationSpinBox->setValue(phase->duration);

    ui->deletePhaseButton->setStyleSheet(""QPushButton {color: red;}"");

    if ( isNew ) {
        setWindowTitle(""Add phase"");
        ui->deletePhaseButton->hide();
    }
    else {
        setWindowTitle(""Edit phase"");
        ui->buttonBox->button(QDialogButtonBox::Cancel)->hide();
    }
}

ConfigurePhaseDialog::~ConfigurePhaseDialog()
{
    delete ui;
}

void ConfigurePhaseDialog::on_tempSpinBox_valueChanged(int arg1)
{
    phase->targetTemp = arg1;
}


void ConfigurePhaseDialog::on_durationSpinBox_valueChanged(int arg1)
{
    phase->duration = arg1;
}


void ConfigurePhaseDialog::on_deletePhaseButton_clicked()
{
    QMessageBox::StandardButton reply = QMessageBox::warning(this, ""Delete phase"", QString(""Delete phase?""), QMessageBox::Yes|QMessageBox::No);
    if (reply == QMessageBox::Yes) {
        phaseWasDeleted = true;
        this->close();
    }
}

",_isNew
445,"// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#include ""ngraph/op/scatter_update.hpp""

#include ""bound_evaluate.hpp""
#include ""itt.hpp""
#include ""ngraph/runtime/reference/scatter_update.hpp""
#include ""ngraph/shape.hpp""
#include ""ngraph/type/element_type.hpp""
#include ""ngraph/type/element_type_traits.hpp""
#include ""ngraph/validation_util.hpp""

using namespace std;
using namespace ngraph;

op::v3::ScatterUpdate::ScatterUpdate(const Output<Node>& data,
                                     const Output<Node>& indices,
                                     const Output<Node>& updates,
                                     const Output<Node>& axis)
    : util::ScatterBase(data, indices, updates, axis) {}

shared_ptr<Node> op::v3::ScatterUpdate::clone_with_new_inputs(const OutputVector& new_args) const {
    OV_OP_SCOPE(v3_ScatterUpdate_clone_with_new_inputs);
    check_new_args_count(this, new_args);
    return make_shared<v3::ScatterUpdate>(new_args.at(0), new_args.at(1), new_args.at(2), new_args.at(3));
}

namespace scatter_update {
namespace {
template <element::Type_t ET>
std::vector<int64_t> get_indices(const HostTensorPtr& in) {
    auto data_ptr = in->get_data_ptr<ET>();
    return std::vector<int64_t>(data_ptr, data_ptr + in->get_element_count());
}
}  // namespace
}  // namespace scatter_update

#define GET_INDICES(a, ...)                                                                   \
    case element::Type_t::a: {                                                                \
        OV_OP_SCOPE(OV_PP_CAT3(get_scatter_update_indices, _, a));                            \
        indices_casted_vector = scatter_update::get_indices<element::Type_t::a>(__VA_ARGS__); \
    } break;

bool op::v3::ScatterUpdate::evaluate_scatter_update(const HostTensorVector& outputs,
                                                    const HostTensorVector& inputs) const {
    const auto& data = inputs[0];
    const auto& indices = inputs[1];
    const auto& updates = inputs[2];
    const auto& axis = inputs[3];
    const auto& out = outputs[0];

    const auto elem_size = data->get_element_type().size();
    out->set_shape(data->get_shape());

    NGRAPH_CHECK(axis->get_element_type().is_integral_number(), ""axis element type is not integral data type"");

    int64_t axis_val = host_tensor_2_vector<int64_t>(axis)[0];
    if (axis_val < 0) {
        axis_val = ngraph::normalize_axis(this, axis_val, static_cast<int64_t>(data->get_shape().size()));
    }

    std::vector<int64_t> indices_casted_vector;
    switch (indices->get_element_type()) {
        GET_INDICES(i8, indices);
        GET_INDICES(i16, indices);
        GET_INDICES(i32, indices);
        GET_INDICES(i64, indices);
        GET_INDICES(u8, indices);
        GET_INDICES(u16, indices);
        GET_INDICES(u32, indices);
        GET_INDICES(u64, indices);
    default:
        return false;
    }

    ngraph::runtime::reference::scatter_update(data->get_data_ptr<char>(),
                                               indices_casted_vector.data(),
                                               updates->get_data_ptr<char>(),
                                               axis_val,
                                               out->get_data_ptr<char>(),
                                               elem_size,
                                               data->get_shape(),
                                               indices->get_shape(),
                                               updates->get_shape());

    return true;
}

bool op::v3::ScatterUpdate::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const {
    OV_OP_SCOPE(v3_ScatterUpdate_evaluate);
    return evaluate_scatter_update(outputs, inputs);
}

bool op::v3::ScatterUpdate::evaluate_lower(ov::TensorVector& outputs) const {
    OV_OP_SCOPE(v3_ScatterUpdate_evaluate_lower);
    return get_input_tensor(1).has_and_set_bound() && get_input_tensor(3).has_and_set_bound() &&
           default_lower_bound_evaluator(this, outputs);
}

bool op::v3::ScatterUpdate::evaluate_upper(ov::TensorVector& outputs) const {
    OV_OP_SCOPE(v3_ScatterUpdate_evaluate_upper);
    return get_input_tensor(1).has_and_set_bound() && get_input_tensor(3).has_and_set_bound() &&
           default_upper_bound_evaluator(this, outputs);
}

bool op::v3::ScatterUpdate::has_evaluate() const {
    OV_OP_SCOPE(v3_ScatterUpdate_has_evaluate);

    switch (get_input_element_type(1)) {
    case ngraph::element::i8:
    case ngraph::element::i16:
    case ngraph::element::i32:
    case ngraph::element::i64:
    case ngraph::element::u8:
    case ngraph::element::u16:
    case ngraph::element::u32:
    case ngraph::element::u64:
        return true;
    default:
        break;
    }
    return false;
}

namespace {
bool scatter_label_evaluator(const Node* node, TensorLabelVector& output_labels) {
    const auto& input_values = node->input_values();

    constexpr auto data_in_idx = 0;
    constexpr auto  [MASK]  = 2;
    auto data_labels = input_values[data_in_idx].get_tensor().get_value_label();
    auto updates_labels = input_values[ [MASK] ].get_tensor().get_value_label();

    if (ov::has_no_labels(data_labels) && ov::has_no_labels(updates_labels)) {
        return false;
    }

    ov::TensorVector input_tensors;
    input_tensors.reserve(input_values.size());

    auto make_input_label = [&](const Output<Node>& input, TensorLabel& labels) {
        input_tensors.emplace_back(ov::element::from<ov::label_t>(), input.get_shape());
        labels.resize(shape_size(input.get_shape()));
        memcpy(input_tensors.back().data(), labels.data(), input_tensors.back().get_byte_size());
    };

    for (size_t i = 0; i < input_values.size(); ++i) {
        const auto& input = input_values[i];
        if (i == data_in_idx) {
            make_input_label(input, data_labels);
        } else if (i ==  [MASK] ) {
            make_input_label(input, updates_labels);
        } else {
            input_tensors.push_back(input.get_tensor().get_lower_value());
        }
    }

    ov::TensorVector output_tensors{ov::Tensor(ov::element::from<ov::label_t>(), node->get_output_shape(0))};
    if (node->evaluate(output_tensors, input_tensors)) {
        output_labels[0] = ov::TensorLabel(output_tensors[0].data<ov::label_t>(),
                                           output_tensors[0].data<ov::label_t>() + output_tensors[0].get_size());
        return true;
    }
    return false;
}
}  // namespace

bool op::v3::ScatterUpdate::evaluate_label(TensorLabelVector& output_labels) const {
    OV_OP_SCOPE(v3_ScatterUpdate_evaluate_label);
    if (get_input_partial_shape(0).is_static() && get_input_partial_shape(2).is_static() &&
        get_input_tensor(1).has_and_set_bound() && get_input_tensor(3).has_and_set_bound()) {
        return scatter_label_evaluator(this, output_labels);
    }
    return false;
}
",updates_in_idx
446,"#include <iostream>

class Foo {
  private:
    int m_value;

  public:
    Foo(int value = 0): m_value(value) {}
    ~Foo() {}

    Foo operator+(const Foo& other)
    {
      return Foo(m_value + other.m_value);
    }

    Foo operator-(const Foo& other) 
    {
      return Foo(m_value - other.m_value);
    }

    Foo operator*(const Foo& other)
    {
      return Foo(m_value * other.m_value);
    }

    friend std::ostream& operator<<(std::ostream& out, const Foo& obj)
    {
      return out << ""("" << obj.m_value << "")"";
    }

    friend std::istream& operator>>(std::istream& in, Foo& obj)
    {
      int n;
      in >> n;
      obj.m_value = n;

      return in;
    }
};

int main()
{
  Foo foo1(21);
  Foo foo2(42);

  Foo  [MASK]  = foo1 + foo2;
  Foo foo4 = foo1 - foo2;
  Foo foo5 = foo1 * foo2;

  std::cout << foo1 << "" "" << foo2 << "" "" <<  [MASK]  << std::endl;

  Foo foo6;
  std::cin >> foo6;
  std::cout << foo6 << std::endl;

  return 0;
}
",foo3
447,"#pragma once

#include <cstdint>

namespace Tree {

    // Return pointer to the first item in the tree (the first file on the volume)
    template<class NODE>
    NODE *smallest(NODE *top) {
        if (top == nullptr) return nullptr;
        while (top->smaller_ != nullptr) top = top->smaller_;
        return top;
    }

    // Return pointer to the last item in the tree (the last file on the volume)
    template<class NODE>
    NODE *biggest(NODE *top) {
        if (top == nullptr) return nullptr;
        while (top->bigger_ != nullptr) top = top->bigger_;
        return top;
    }

    enum Direction {
        First,
        Last,
    };

    // If Direction=0 then return a pointer to the first file on the volume,
    // if Direction=1 then the last file.
    template<class NODE>
    NODE *first(NODE *top, Direction direction) {
        return direction == First ? smallest(top) : biggest(top);
    }

    // Return pointer to the previous item in the tree
    template<class NODE>
    NODE *prev(NODE *here) {
        if (here == nullptr) return here;

        if (here->smaller_ != nullptr) {
            here = here->smaller_;

            while (here->bigger_ != nullptr) here = here->bigger_;

            return here;
        }

        NODE *temp;

        do {
            temp = here;
            here = here->parent_;
        } while (here != nullptr && here->smaller_ == temp);

        return here;
    }

    // Return pointer to the next item in the tree
    template<class NODE>
    NODE *next(NODE *here) {
        if (here == nullptr) return nullptr;

        if (here->bigger_ != nullptr) {
            here = here->bigger_;

            while (here->smaller_ != nullptr) here = here->smaller_;

            return here;
        }

        NODE *temp;

        do {
            temp = here;
            here = here->parent_;
        } while (here != nullptr && here->bigger_ == temp);

        return here;
    }

    enum StepDirection {
        StepForward,
        StepBack,
    };

    // If StepDirection=0 then return a pointer to the next file on the volume,
    // if StepDirection=1 then the previous file.
    template<class NODE>
    NODE *next_prev(NODE *here, const StepDirection  [MASK] ) {
        return  [MASK]  == StepForward ? next(here) : prev(here);
    }

    // Insert a record into the tree. The tree is sorted by LCN (Logical Cluster Number)
    template<class NODE>
    void insert(NODE *&root, int &balance_count, NODE *new_item) {
        if (new_item == nullptr) return;

        const auto new_lcn = new_item->get_item_lcn();

        // Locate the place where the record should be inserted
        NODE *here = root;
        NODE *ins = nullptr;
        int found = 1;

        while (here != nullptr) {
            ins = here;
            found = 0;

            if (const uint64_t here_lcn = here->get_item_lcn(); here_lcn > new_lcn) {
                found = 1;
                here = here->smaller_;
            } else {
                if (here_lcn < new_lcn) found = -1;

                here = here->bigger_;
            }
        }

        // Insert the record
        new_item->parent_ = ins;
        new_item->smaller_ = nullptr;
        new_item->bigger_ = nullptr;

        if (ins == nullptr) {
            root = new_item;
        } else {
            if (found > 0) {
                ins->smaller_ = new_item;
            } else {
                ins->bigger_ = new_item;
            }
        }

        // If there have been less than 1000 inserts then return
        balance_count++;

        if (balance_count < 1000) return;

        /* Balance the tree.
        It's difficult to explain what exactly happens here. For an excellent
        tutorial see:
        http://www.stanford.edu/~blp/avl/libavl.html/Balancing-a-BST.html
        */

        balance_count = 0;

        // Convert the tree into a vine
        NODE *a = root;
        NODE *b;
        NODE *c = a;
        long count = 0;

        while (a != nullptr) {
            // If A has no Bigger child then move down the tree
            if (a->bigger_ == nullptr) {
                count = count + 1;
                c = a;
                a = a->smaller_;

                continue;
            }

            // Rotate left at A
            b = a->bigger_;

            if (root == a) root = b;

            a->bigger_ = b->smaller_;

            if (a->bigger_ != nullptr) a->bigger_->parent_ = a;

            b->parent_ = a->parent_;

            if (b->parent_ != nullptr) {
                if (b->parent_->smaller_ == a) {
                    b->parent_->smaller_ = b;
                } else {
                    a->parent_->bigger_ = b;
                }
            }

            b->smaller_ = a;
            a->parent_ = b;

            // Do again
            a = b;
        }

        // Calculate the number of skips
        long skip = 1;

        while (skip < count + 2) skip = skip << 1;

        skip = count + 1 - (skip >> 1);

        // Compress the tree
        while (c != nullptr) {
            if (skip <= 0) c = c->parent_;

            a = c;

            while (a != nullptr) {
                b = a;
                a = a->parent_;

                if (a == nullptr) break;

                // Rotate right at A
                if (root == a) root = b;

                a->smaller_ = b->bigger_;

                if (a->smaller_ != nullptr) a->smaller_->parent_ = a;

                b->parent_ = a->parent_;

                if (b->parent_ != nullptr) {
                    if (b->parent_->smaller_ == a) {
                        b->parent_->smaller_ = b;
                    } else {
                        b->parent_->bigger_ = b;
                    }
                }

                a->parent_ = b;
                b->bigger_ = a;

                // Next item
                a = b->parent_;

                // If there were skips then leave if all done
                skip = skip - 1;
                if (skip == 0) break;
            }
        }
    }

    // Detach (unlink) a record from the tree. The record is not freed().
    // See: http://www.stanford.edu/~blp/avl/libavl.html/Deleting-from-a-BST.html
    template<class NODE>
    void detach(NODE *&root, const NODE *item) {
        // Sanity check
        if (root == nullptr || item == nullptr) return;

        if (item->bigger_ == nullptr) {
            /* It is trivial to delete a node with no Bigger child. We replace
            the pointer leading to the node by it's Smaller child. In
            other words, we replace the deleted node by its Smaller child. */
            if (item->parent_ != nullptr) {
                if (item->parent_->smaller_ == item) {
                    item->parent_->smaller_ = item->smaller_;
                } else {
                    item->parent_->bigger_ = item->smaller_;
                }
            } else {
                root = item->smaller_;
            }

            if (item->smaller_ != nullptr) item->smaller_->parent_ = item->parent_;
        } else if (item->bigger_->smaller_ == nullptr) {
            // The Bigger child has no Smaller child. In this case, we move Bigger
            // into the node's place, attaching the node's Smaller subtree as the
            // new Smaller.
            if (item->parent_ != nullptr) {
                if (item->parent_->smaller_ == item) {
                    item->parent_->smaller_ = item->bigger_;
                } else {
                    item->parent_->bigger_ = item->bigger_;
                }
            } else {
                root = item->bigger_;
            }

            item->bigger_->parent_ = item->parent_;
            item->bigger_->smaller_ = item->smaller_;

            if (item->smaller_ != nullptr) item->smaller_->parent_ = item->bigger_;
        } else {
            /* Replace the node by it's inorder successor, that is, the node with
            the smallest value greater than the node. We know it exists because
            otherwise this would be case 1 or case 2, and it cannot have a Smaller
            value because that would be the node itself. The successor can
            therefore be detached and can be used to replace the node. */

            // Find the inorder successor
            NODE *b = item->bigger_;
            while (b->smaller_ != nullptr) b = b->smaller_;

            // Detach the successor
            if (b->parent_ != nullptr) {
                if (b->parent_->bigger_ == b) {
                    b->parent_->bigger_ = b->bigger_;
                } else {
                    b->parent_->smaller_ = b->bigger_;
                }
            }

            if (b->bigger_ != nullptr) b->bigger_->parent_ = b->parent_;

            // Replace the node with the successor
            if (item->parent_ != nullptr) {
                if (item->parent_->smaller_ == item) {
                    item->parent_->smaller_ = b;
                } else {
                    item->parent_->bigger_ = b;
                }
            } else {
                root = b;
            }

            b->parent_ = item->parent_;
            b->smaller_ = item->smaller_;

            if (b->smaller_ != nullptr) b->smaller_->parent_ = b;

            b->bigger_ = item->bigger_;

            if (b->bigger_ != nullptr) b->bigger_->parent_ = b;
        }
    }

    template<class NODE>
    void delete_node_rec(NODE *top) {
        if (top == nullptr) return;
        delete_node_rec(top->smaller_);
        delete_node_rec(top->bigger_);
        delete top;
    }

    template<class NODE>
    void delete_tree(NODE *&root) {
        delete_node_rec(root);
        root = nullptr;
    }
}
",step_direction
448,"//	//////////////////////////////////////////////////////////////////////////
//	//////////////////////////////////////////////////////////////////////////
//	C++ Support Library Include File
//	//////////////////////////////////////////////////////////////////////////
/*
	File Name			:	%M%

	File Version		:	%I%

	Last Extracted		:	%D%	%T%

	Last Updated		:	%E%	%U%

	File Description	:	Include and implementation file for generalized
								exceptions.

	Revision History	:	1998-04-08 --- Creation.
									<NAME>

		Copyright <NAME> 1998 - 2018.
		Distributed under the Boost Software License, Version 1.0.
		(See accompanying file LICENSE_1_0.txt or copy at
		http://www.boost.org/LICENSE_1_0.txt)

*/
//	//////////////////////////////////////////////////////////////////////////

#ifndef HH__MLB__CPPSupp__ExceptionGeneral_h__HH

#define HH__MLB__CPPSupp__ExceptionGeneral_h__HH	1

//	//////////////////////////////////////////////////////////////////////////
//	//////////////////////////////////////////////////////////////////////////
//	Required include files . . .
//	//////////////////////////////////////////////////////////////////////////

#include <mbcompat.h>

#ifdef _Windows
# pragma warning(disable:4018 4100 4146 4244 4290 4511 4512 4663)
# include <exception>
# include <iostream>
# include <ostream>
# include <sstream>
# include <string>
# pragma warning(default:4018 4100 4146 4244 4290 4511 4512 4663)
#else
# include <exception>
# include <iostream>
# include <ostream>
# include <sstream>
# include <string>
#endif // #ifdef _Windows
//	//////////////////////////////////////////////////////////////////////////

namespace MLB {

namespace CPPSupp {

//	//////////////////////////////////////////////////////////////////////////
template <class CharType = char>
	class ExceptionGeneralType : public std::exception {
	public:
		typedef std::basic_string<CharType>        ThisStringType;
		typedef std::basic_ostringstream<CharType> ThisOStreamType;

		ExceptionGeneralType() throw()
			: std::exception(""Unspecified exception.""),
			except_string(""Unspecified exception."") { }
		ExceptionGeneralType(const CharType *in_except_string) throw()
			: std::exception(in_except_string),
			except_string(in_except_string) { }
		ExceptionGeneralType(const ThisStringType &in_except_string) throw()
			: std::exception(in_except_string.c_str()),
			except_string(in_except_string) { }
		ExceptionGeneralType(const ThisOStreamType &in_except_string) throw()
			: std::exception(in_except_string.str().c_str()),
			except_string(in_except_string.str()) { }
		~ExceptionGeneralType() throw() { }

	private:
		ThisStringType except_string;
};
//	//////////////////////////////////////////////////////////////////////////

//	//////////////////////////////////////////////////////////////////////////
typedef ExceptionGeneralType<char> ExceptionGeneral;
//	//////////////////////////////////////////////////////////////////////////

//	//////////////////////////////////////////////////////////////////////////
template <class CharType = char>
	class ExceptionWithCodeType : public ExceptionGeneralType<CharType> {
	public:
		typedef ExceptionGeneralType<CharType> ParentNick;
		ExceptionWithCodeType() throw() :
			ExceptionGeneralType(GetErrorString()),
			error_code(GetLastErrorCode()) { }

		ExceptionWithCodeType(int in_error_code) throw() :
			ExceptionGeneralType<CharType>(GetErrorString(in_error_code)),
			error_code(in_error_code) { }
		ExceptionWithCodeType(const CharType *in_except_string) throw() :
			ExceptionGeneralType<CharType>(GetErrorString(in_except_string)),
			error_code(GetLastErrorCode()) { }
		ExceptionWithCodeType(const ThisStringType &in_except_string) throw() :
			ExceptionGeneralType<CharType>(GetErrorString(in_except_string.
			c_str())), error_code(GetLastErrorCode()) { }
		ExceptionWithCodeType(const ThisOStreamType &in_except_string) throw() :
			ExceptionGeneralType<CharType>(GetErrorString(in_except_string.str().
			c_str())), error_code(GetLastErrorCode()) { }

		ExceptionWithCodeType(int in_error_code, const CharType *in_except_string)
			throw() :
			ExceptionGeneralType<CharType>(GetErrorString(in_error_code,
			in_except_string)), error_code(in_error_code) { }
		ExceptionWithCodeType(int in_error_code, ThisStringType &in_except_string)
			throw() :
			ExceptionGeneralType<CharType>(GetErrorString(in_error_code,
			in_except_string.c_str())), error_code(in_error_code) { }
		ExceptionWithCodeType(int in_error_code,
			ThisOStreamType  &in_except_string) throw() :
			ExceptionGeneralType<CharType>(GetErrorString(in_error_code,
			in_except_string.str().c_str())), error_code(in_error_code) { }

		~ExceptionWithCodeType() throw() { }

		virtual int GetErrorCode() {
			return(error_code);
		}

	protected:

		virtual int GetLastErrorCode() {
#ifdef _Windows
			return(GetLastError());
#else
# include <errno.h>
			return(errno);	
#endif // #ifdef _Windows
		}

		virtual std::string GetErrorString(const char *error_text = NULL) {
			return(GetErrorString(GetLastErrorCode(), error_text));
		}
		virtual std::string GetErrorString(int error_code,
			const char *error_text = NULL) {
			std::stringstream  [MASK] ;
			if (error_text != NULL)
				 [MASK]  << error_text << "": "";
			 [MASK]  << ""Error code = "" << error_code;
			return( [MASK] .str());
		}

		int error_code;
};
//	//////////////////////////////////////////////////////////////////////////

//	//////////////////////////////////////////////////////////////////////////
typedef ExceptionWithCodeType<char> ExceptionWithCode;
//	//////////////////////////////////////////////////////////////////////////

} // namespace CPPSupp

} // namespace MLB

namespace std {

//	//////////////////////////////////////////////////////////////////////////
template <class CharType>
	inline std::ostream & operator << (std::ostream &o_str,
	const MLB::CPPSupp::ExceptionGeneralType<CharType> &datum) 
{
	return(o_str << datum.what());
}
//	//////////////////////////////////////////////////////////////////////////

//	//////////////////////////////////////////////////////////////////////////
template <class CharType>
	inline std::ostream & operator << (std::ostream &o_str,
	const MLB::CPPSupp::ExceptionWithCodeType<CharType> &datum) 
{
	return(o_str << datum.what());
}
//	//////////////////////////////////////////////////////////////////////////

} // namespace std

#endif // #ifndef HH__MLB__CPPSupp__ExceptionGeneral_h__HH

",out_string
449,"/* Copyright 2018 Intel
 *
 * 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 <fcntl.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <boost/container/flat_set.hpp>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <iostream>
#include <memory>
#include <optional>
#include <phosphor-logging/log.hpp>
#include <sdbusplus/asio/object_server.hpp>
#include <sdbusplus/bus.hpp>
#include <sdbusplus/bus/match.hpp>
#include <sdbusplus/message.hpp>
#include <sdbusplus/timer.hpp>
#include <vector>
#include <xyz/openbmc_project/State/Watchdog/server.hpp>

void handleResponse(const boost::system::error_code &err,
                    std::size_t bytes_transferred);

static int mailboxDevFd = -1;

static boost::asio::io_service io;
static auto conn = std::make_shared<sdbusplus::asio::connection>(io);
boost::asio::ip::tcp::socket mailBoxDevSocket(io);
boost::asio::deadline_timer pollTimer(io);
boost::asio::posix::stream_descriptor inputDevice(io);

// mailbox registre data[0:0] for FRB2 enable bit
boost::asio::streambuf readBuf(1);
std::string dataRead;

// FRB2 watchdog timeout is 6 minutes
static constexpr unsigned int frb2TimerIntervalMs = 360 * 1000;

// mailbox device polling time interval is 2 seconds
static constexpr unsigned int pollMs = 2000;

static constexpr unsigned int frb2Started = 1;
static constexpr unsigned int frb2Stopped = 0;

// FRB2 status
static uint8_t frb2Status = frb2Stopped;

static constexpr const char *mailboxDevName = ""/dev/aspeed-mbox"";

static constexpr const char frb2Bus[] = ""xyz.openbmc_project.FRB2"";
static constexpr const char frb2Obj[] = ""/xyz/openbmc_project/FRB2"";
static constexpr const char frb2Intf[] = ""xyz.openbmc_project.FRB2"";

static constexpr char powerBus[] = ""xyz.openbmc_project.Chassis.Control.Power"";
static constexpr char powerPath[] =
    ""/xyz/openbmc_project/Chassis/Control/Power0"";
static constexpr char powerIntf[] = ""xyz.openbmc_project.Chassis.Control.Power"";

static constexpr char wdBus[] = ""xyz.openbmc_project.Watchdog"";
static constexpr char wdPath[] = ""/xyz/openbmc_project/watchdog/host0"";
static constexpr char wdIntf[] = ""xyz.openbmc_project.State.Watchdog"";
static constexpr char propIntf[] = ""org.freedesktop.DBus.Properties"";

typedef boost::asio::buffers_iterator<boost::asio::const_buffers_1> iterator;

// check if FRB2 bit is 0x1
std::pair<iterator, bool> matchFRB2(iterator  [MASK] , iterator end)
{
    unsigned char ch = 0;
    iterator i =  [MASK] ;

    while (i != end)
    {
        ch = static_cast<unsigned char>(*i);
        if (ch & 0x1)
        {
            return std::make_pair(i, true);
        }
        i++;
    }

    return std::make_pair(i, false);
}

static void startRead()
{
    boost::asio::async_read_until(inputDevice, readBuf, matchFRB2,
                                  [&](const boost::system::error_code &ec,
                                      std::size_t bytes_transferred) {
                                      handleResponse(ec, bytes_transferred);
                                  });
}

template <typename T> void setProperty(const std::string &key, const T &val)
{
    phosphor::logging::log<phosphor::logging::level::DEBUG>(
        ""setProperty"", phosphor::logging::entry(""KEY=%s"", key.c_str()));

    try
    {
        conn->async_method_call(
            [](const boost::system::error_code &err) {
                if (err)
                {
                    phosphor::logging::log<phosphor::logging::level::ERR>(
                        ""async_method_call error!"",
                        phosphor::logging::entry(
                            ""ERROR=%s"",
                            boost::system::system_error(err).what()));
                }
            },
            wdBus, wdPath, propIntf, ""Set"", wdIntf, key,
            sdbusplus::message::variant_ns::variant<T>(val));
    }
    catch (sdbusplus::exception::SdBusError &e)
    {
        phosphor::logging::log<phosphor::logging::level::ERR>(
            ""Dbus error!"", phosphor::logging::entry(""ERROR=%s"", e.what()));
    }
}
void handleResponse(const boost::system::error_code &err,
                    std::size_t bytes_transferred)
{
    std::istream responseStream(&readBuf);
    std::string response;
    int n = 0;
    uint64_t interval = frb2TimerIntervalMs;

    std::getline(responseStream, response);
    responseStream.clear();

    if (err == boost::system::errc::bad_file_descriptor)
    {

        phosphor::logging::log<phosphor::logging::level::DEBUG>(
            ""bad file descriptor"");
        return; // we're being destroyed
    }

    if (!err)
    {
        // FRB2 is set by BIOS
        if (frb2Stopped == frb2Status)
        {
            // start FRB2 watchdog
            frb2Status = frb2Started;
            phosphor::logging::log<phosphor::logging::level::DEBUG>(
                ""FRB2 enable, start FRB2 watchdog"");
            setProperty(
                ""ExpireAction"",
                std::string(
                    ""xyz.openbmc_project.State.Watchdog.Action.HardReset""));
            setProperty(""Interval"", interval);
            setProperty(""TimeRemaining"", interval);
            setProperty(""Initialized"", true);
            setProperty(""Enabled"", true);
        }
    }
    else if (err == boost::asio::error::misc_errors::not_found)
    {
        // FRB2 is clear, stop FRB2 watchdog if it is started
        if (frb2Started == frb2Status)
        {
            frb2Status = frb2Stopped;
            phosphor::logging::log<phosphor::logging::level::DEBUG>(
                ""FRB2 is unset, stop FRB2 watchdog"");
            setProperty(""Enabled"", false);
        }
    }
    else
    {
        phosphor::logging::log<phosphor::logging::level::ERR>(
            ""handleResponse error!"",
            phosphor::logging::entry(""ERROR=%s"",
                                     boost::system::system_error(err).what()));
    }

    pollTimer.expires_from_now(boost::posix_time::milliseconds(pollMs));
    pollTimer.async_wait(
        [](const boost::system::error_code &ec) { startRead(); });
}

int main(int argc, char **argv)
{
    phosphor::logging::log<phosphor::logging::level::DEBUG>(
        ""Monitor FRB2 signal"");

    sdbusplus::bus::match_t biosPostSignal(
        static_cast<sdbusplus::bus::bus &>(*conn),
        sdbusplus::bus::match::rules::type::signal() +
            sdbusplus::bus::match::rules::member(""PostCompleted"") +
            sdbusplus::bus::match::rules::path(powerPath) +
            sdbusplus::bus::match::rules::interface(powerIntf),
        [](sdbusplus::message::message &msg) {
            uint8_t value = 0;
            ssize_t rc = 0;
            phosphor::logging::log<phosphor::logging::level::INFO>(
                ""BIOS post completed signal"");
            // stop FRB2 and clean mailbox
            value = 0;
            rc = ::pwrite(mailboxDevFd, &value, 1, 0);
            if (rc != 1)
            {
                phosphor::logging::log<phosphor::logging::level::ERR>(
                    ""mailbox write error!"");
            }
            setProperty(""Enabled"", false);
            frb2Status = frb2Stopped;
            return;
        });

    conn->request_name(frb2Bus);

    auto server = sdbusplus::asio::object_server(conn);

    std::shared_ptr<sdbusplus::asio::dbus_interface> frb2Iface =
        server.add_interface(frb2Obj, frb2Intf);

    frb2Iface->register_property(""frb2Status"", frb2Status);

    frb2Iface->initialize();

    mailboxDevFd = ::open(mailboxDevName, O_RDWR | O_CLOEXEC);
    if (mailboxDevFd < 0)
    {
        phosphor::logging::log<phosphor::logging::level::ERR>(
            ""mailbox device open fail!"");
        return -1;
    }

    inputDevice.assign(mailboxDevFd);

    startRead();

    io.run();

    ::close(mailboxDevFd);

    return 0;
}
",begin
450,"// SPDX-License-Identifier: Apache-2.0
// Original (Public Domain): https://github.com/espressif/esp-idf/blob/b310c062cd25f249e00dd03dd27baed783921630/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/main/ble_hidd_demo_main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include ""freertos/FreeRTOS.h""
#include ""freertos/task.h""
#include ""freertos/event_groups.h""
#include ""esp_system.h""
#include ""esp_wifi.h""
#include ""esp_event.h""
#include ""esp_log.h""
#include ""nvs_flash.h""
#include ""esp_bt.h""

#include ""esp_hidd_prf_api.h""
#include ""esp_bt_defs.h""
#include ""esp_gap_ble_api.h""
#include ""esp_gatts_api.h""
#include ""esp_gatt_defs.h""
#include ""esp_bt_main.h""
#include ""esp_bt_device.h""
#include ""driver/gpio.h""
#include ""hid_dev.h""

#include ""event.hpp""

/**
 * Brief:
 * This example Implemented BLE HID device profile related functions, in which the HID device
 * has 4 Reports (1 is mouse, 2 is keyboard and LED, 3 is Consumer Devices, 4 is Vendor devices).
 * Users can choose different reports according to their own application scenarios.
 * BLE HID profile inheritance and USB HID class.
 */

/**
 * Note:
 * 1. Win10 does not support vendor report , So SUPPORT_REPORT_VENDOR is always set to FALSE, it defines in hidd_le_prf_int.h
 * 2. Update connection parameters are not allowed during iPhone HID encryption, slave turns
 * off the ability to automatically update connection parameters during encryption.
 * 3. After our HID device is connected, the iPhones write 1 to the Report Characteristic Configuration Descriptor,
 * even if the HID encryption is not completed. This should actually be written 1 after the HID encryption is completed.
 * we modify the permissions of the Report Characteristic Configuration Descriptor to `ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE_ENCRYPTED`.
 * if you got `GATT_INSUF_ENCRYPTION` error, please ignore.
 */

#define BLE_TAG ""BLE""

static uint16_t hid_conn_id = 0;
static bool sec_conn = false;
#define CHAR_DECLARATION_SIZE (sizeof(uint8_t))

static void hidd_event_callback(esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param);

#define HIDD_DEVICE_NAME ""FlickInput""
static uint8_t hidd_service_uuid128[] = {
    /* LSB <--------------------------------------------------------------------------------> MSB */
    //first uuid, 16bit, [12],[13] is the value
    0xfb,
    0x34,
    0x9b,
    0x5f,
    0x80,
    0x00,
    0x00,
    0x80,
    0x00,
    0x10,
    0x00,
    0x00,
    0x12,
    0x18,
    0x00,
    0x00,
};

static esp_ble_adv_data_t hidd_adv_data = {
    .set_scan_rsp = false,
    .include_name = true,
    .include_txpower = true,
    .min_interval = 0x0006, //slave connection min interval, Time = min_interval * 1.25 msec
    .max_interval = 0x0010, //slave connection max interval, Time = max_interval * 1.25 msec
    .appearance = 0x03c1,   //HID Keyboard,
    .manufacturer_len = 0,
    .p_manufacturer_data = nullptr,
    .service_data_len = 0,
    .p_service_data = nullptr,
    .service_uuid_len = sizeof(hidd_service_uuid128),
    .p_service_uuid = hidd_service_uuid128,
    .flag = 0x6,
};

static esp_ble_adv_params_t hidd_adv_params = {
    .adv_int_min = 0x20,
    .adv_int_max = 0x30,
    .adv_type = ADV_TYPE_IND,
    .own_addr_type = BLE_ADDR_TYPE_PUBLIC,
    //.peer_addr            =
    //.peer_addr_type       =
    .channel_map = ADV_CHNL_ALL,
    .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
};

static void hidd_event_callback(esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param)
{
    switch (event)
    {
    case ESP_HIDD_EVENT_REG_FINISH:
    {
        if (param->init_finish.state == ESP_HIDD_INIT_OK)
        {
            //esp_bd_addr_t rand_addr = {0x04,0x11,0x11,0x11,0x11,0x05};
            esp_ble_gap_set_device_name(HIDD_DEVICE_NAME);
            esp_ble_gap_config_adv_data(&hidd_adv_data);
        }
        break;
    }
    case ESP_BAT_EVENT_REG:
    {
        break;
    }
    case ESP_HIDD_EVENT_DEINIT_FINISH:
        break;
    case ESP_HIDD_EVENT_BLE_CONNECT:
    {
        ESP_LOGI(BLE_TAG, ""ESP_HIDD_EVENT_BLE_CONNECT"");
        hid_conn_id = param->connect.conn_id;
        break;
    }
    case ESP_HIDD_EVENT_BLE_DISCONNECT:
    {
        sec_conn = false;
        ESP_LOGI(BLE_TAG, ""ESP_HIDD_EVENT_BLE_DISCONNECT"");
        esp_ble_gap_start_advertising(&hidd_adv_params);
        esp_event_post_to(loop_handle, STATUS_CHANGE_EVENT, STATUS_EVENT_UPDATE_BLE_STATE, &sec_conn, sizeof(bool), 0);
        xEventGroupSetBits(event_group, EVENT_BIT_DRAW_STATUSBAR);
        break;
    }
    case ESP_HIDD_EVENT_BLE_VENDOR_REPORT_WRITE_EVT:
    {
        ESP_LOGI(BLE_TAG, ""%s, ESP_HIDD_EVENT_BLE_VENDOR_REPORT_WRITE_EVT"", __func__);
        ESP_LOG_BUFFER_HEX(BLE_TAG, param->vendor_write.data, param->vendor_write.length);
    }
    default:
        break;
    }
    return;
}

static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
    switch (event)
    {
    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
        esp_ble_gap_start_advertising(&hidd_adv_params);
        break;
    case ESP_GAP_BLE_SEC_REQ_EVT:
        for (size_t i = 0; i < ESP_BD_ADDR_LEN; i++)
        {
            ESP_LOGD(BLE_TAG, ""%x:"", param->ble_security.ble_req.bd_addr[i]);
        }
        esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, true);
        break;
    case ESP_GAP_BLE_AUTH_CMPL_EVT:
        sec_conn = true;
        esp_bd_addr_t bd_addr;
        memcpy(bd_addr, param->ble_security.auth_cmpl.bd_addr, sizeof(esp_bd_addr_t));
        ESP_LOGI(BLE_TAG, ""remote BD_ADDR: %08x%04x"",
                 (bd_addr[0] << 24) + (bd_addr[1] << 16) + (bd_addr[2] << 8) + bd_addr[3],
                 (bd_addr[4] << 8) + bd_addr[5]);
        ESP_LOGI(BLE_TAG, ""address type = %d"", param->ble_security.auth_cmpl.addr_type);
        ESP_LOGI(BLE_TAG, ""pair status = %s"", param->ble_security.auth_cmpl.success ? ""success"" : ""fail"");
        if (!param->ble_security.auth_cmpl.success)
        {
            ESP_LOGE(BLE_TAG, ""fail reason = 0x%x"", param->ble_security.auth_cmpl.fail_reason);
        }
        esp_event_post_to(loop_handle, STATUS_CHANGE_EVENT, STATUS_EVENT_UPDATE_BLE_STATE, &sec_conn, sizeof(bool), 0);
        xEventGroupSetBits(event_group, EVENT_BIT_DRAW_STATUSBAR);
        break;
    default:
        break;
    }
}

void send_key(uint8_t keycode, uint8_t  [MASK] )
{
    ESP_LOGI(BLE_TAG, ""Send key: 0x%02x/0x%02x"", keycode,  [MASK] );
    esp_hidd_send_keyboard_value(hid_conn_id,  [MASK] , &keycode, 1);
    vTaskDelay(10 / portTICK_RATE_MS);
    esp_hidd_send_keyboard_value(hid_conn_id, 0, nullptr, 0);
    vTaskDelay(10 / portTICK_RATE_MS);
}

void start_ble_hid()
{
    esp_err_t ret;

    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret)
    {
        ESP_LOGE(BLE_TAG, ""%s initialize controller failed\n"", __func__);
        return;
    }

    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
    if (ret)
    {
        ESP_LOGE(BLE_TAG, ""%s enable controller failed\n"", __func__);
        return;
    }

    ret = esp_bluedroid_init();
    if (ret)
    {
        ESP_LOGE(BLE_TAG, ""%s init bluedroid failed\n"", __func__);
        return;
    }

    ret = esp_bluedroid_enable();
    if (ret)
    {
        ESP_LOGE(BLE_TAG, ""%s init bluedroid failed\n"", __func__);
        return;
    }

    if ((ret = esp_hidd_profile_init()) != ESP_OK)
    {
        ESP_LOGE(BLE_TAG, ""%s init bluedroid failed\n"", __func__);
    }

    ///register the callback function to the gap module
    esp_ble_gap_register_callback(gap_event_handler);
    esp_hidd_register_callbacks(hidd_event_callback);

    /* set the security iocap & auth_req & key size & init key response key parameters to the stack*/
    esp_ble_auth_req_t auth_req = ESP_LE_AUTH_BOND; //bonding with peer device after authentication
    esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE;       //set the IO capability to No output No input
    uint8_t key_size = 16;                          //the key size should be 7~16 bytes
    uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
    uint8_t rsp_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
    esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t));
    esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t));
    esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t));
    /* If your BLE device act as a Slave, the init_key means you hope which types of key of the master should distribute to you,
    and the response key means which key you can distribute to the Master;
    If your BLE device act as a master, the response key means you hope which types of key of the slave should distribute to you,
    and the init key means which key you can distribute to the slave. */
    esp_ble_gap_set_security_param(ESP_BLE_SM_SET_INIT_KEY, &init_key, sizeof(uint8_t));
    esp_ble_gap_set_security_param(ESP_BLE_SM_SET_RSP_KEY, &rsp_key, sizeof(uint8_t));
}
",modifier
451,"#include ""idocr.h""


using namespace cv;
using namespace std;


string idOCR::cutoutPath = """";



idOCR::idOCR()
{
    tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();
}

idOCR::~idOCR()
{

}


void idOCR::saveImage(string  [MASK] , const Mat & image){
    if ( [MASK] .length() < 1) return;

    imwrite( [MASK] , image);
    cout << ""File saved!"" << endl;
}



void idOCR::fitImage(const Mat& src,Mat& dst, float destWidth, float destHeight) {
    int srcWidth = src.cols;
    int srcHeight = src.rows;

    float srcRatio = (float) srcWidth / (float) srcHeight;

    float widthRatio = destWidth / srcWidth;
    float heightRatio = destHeight / srcHeight;

    float newWidth = 0;
    float newHeight = 0;

    if (srcWidth > srcHeight) {
        destHeight = destWidth / srcRatio;
    } else {
        destWidth = destHeight * srcRatio;
    }
    cv::resize(src, dst,Size((int)round(destWidth), (int)round(destHeight)),0,0);
}




void idOCR::process(Mat & image) {

    // for id filtering, we need only small version of image
        Mat image_vga(Size(640,480),CV_8UC3,Scalar(0));
        fitImage(image, image_vga, 640, 480);

        Mat image_big(Size(1920,1440),CV_8UC3,Scalar(0));
        fitImage(image, image_big, 1920, 1440);

        Mat image_vga_backup = image_vga.clone();

    // filtering
        cv::GaussianBlur(image_vga, image_vga, Size( 7, 7) ,7,7);

        Mat small;
        cv::resize(image_vga, small,Size(320,240),0,0);
        cv::medianBlur(small, small, 9);
        cv::resize(small, image_vga, Size(image_vga.cols,image_vga.rows));

        cv::resize(image_vga, small,Size(320,240),0,0);
        cv::medianBlur(small, small, 9);
        cv::resize(small, image_vga, Size(image_vga.cols,image_vga.rows));

        cv::Mat const shape = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(5, 5));

        cv::dilate(image_vga, image_vga, Mat(), Point(-1, -1), 3, 1, 1);
        cv::erode(image_vga, image_vga, shape, Point(-1,-1), 1);

        cv::dilate(image_vga, image_vga, Mat(), Point(-1, -1), 1, 1, 1);
        cv::erode(image_vga, image_vga, shape, Point(-1,-1), 1);

        cv::dilate(image_vga, image_vga, Mat(), Point(-1, -1), 1, 1, 1);
        cv::erode(image_vga, image_vga, shape, Point(-1,-1), 1);

        cv::GaussianBlur( image_vga, image_vga, Size(3,3), 0, 0, BORDER_DEFAULT );

    // sobel
        Mat grad, src_gray;
        int scale = 1;
        int delta = 0;
        int ddepth = CV_16S;
        /// Convert it to gray
        cvtColor( image_vga, src_gray, COLOR_RGB2GRAY );

        /// Generate grad_x and grad_y
        Mat grad_x, grad_y;
        Mat abs_grad_x, abs_grad_y;

        /// Gradient X
        //Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
        Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
        convertScaleAbs( grad_x, abs_grad_x );

        /// Gradient Y
        //Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
        Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
        convertScaleAbs( grad_y, abs_grad_y );

        /// Total Gradient (approximate)
        addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );

        cvtColor( grad, image_vga, COLOR_GRAY2RGB );

    // now threshold
        cv::cvtColor(image_vga,image_vga, CV_RGB2GRAY);
        cv::threshold(image_vga,image_vga,0,255,THRESH_BINARY + CV_THRESH_OTSU);

        cv::dilate(image_vga, image_vga, Mat(), Point(-1, -1), 3, 1, 1);
        cv::erode(image_vga, image_vga, shape, Point(-1,-1), 1);

        cv::dilate(image_vga, image_vga, Mat(), Point(-1, -1), 1, 1, 1);
        cv::erode(image_vga, image_vga, shape, Point(-1,-1), 1);

        cv::dilate(image_vga, image_vga, Mat(), Point(-1, -1), 1, 1, 1);
        cv::erode(image_vga, image_vga, shape, Point(-1,-1), 1);

    // keep only filled biggest contour in the image to get rid of rest of structures inside
        int largest_area=0;
        int largest_contour_index=0;

        vector<vector<Point>> contours;
        vector<Vec4i> hierarchy;

        findContours( image_vga, contours, hierarchy,CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); // Find the contours in the image

        for( int i = 0; i< contours.size(); i++ )
        {
            double a=contourArea( contours[i],false);
            if(a>largest_area){
                largest_area=a;
                largest_contour_index=i;
            }
        }

        Mat temp(Size(image_vga.cols,image_vga.rows),CV_8UC3,Scalar(0));

        drawContours( temp, contours,largest_contour_index, Scalar(255,0,0), -1, 8, hierarchy, 0);

        image_vga = temp;

        cv::Canny(image_vga, image_vga, 30, 90);
        cv::dilate(image_vga, image_vga, Mat(), Point(1,-1));

        // detect lines in this binary image
        std::vector<cv::Vec4i> lines;
        cv::HoughLinesP(image_vga, lines, 1, CV_PI/360,50,50, 10);

        cvtColor( image_vga, image_vga, COLOR_GRAY2RGB);

        // clusterize lines
            // define lines around image
            std::vector<cv::Vec4i> myLines;

            cv::Vec4i leftLine;leftLine[0] = 0;leftLine[1] = 0;leftLine[2] = 0;leftLine[3] = image_vga.rows;
            myLines.push_back(leftLine);
            cv::Vec4i rightLine;
            rightLine[0] = image_vga.cols;rightLine[1] = 0;rightLine[2] = image_vga.cols;rightLine[3] = image_vga.rows;
            myLines.push_back(rightLine);
            cv::Vec4i topLine;
            topLine[0] = image_vga.cols;topLine[1] = 0;topLine[2] = 0;topLine[3] = 0;
            myLines.push_back(topLine);
            cv::Vec4i bottomLine;
            bottomLine[0] = image_vga.cols;bottomLine[1] = image_vga.rows;bottomLine[2] = 0;bottomLine[3] = image_vga.rows;
            myLines.push_back(bottomLine);

            // expand lines to borders of the image - we will get intersections with image borders easily
            for (int i = 0; i < lines.size(); i++)
            {
                std::vector<cv::Point2f> lineIntersections;
                for (int j = 0; j < myLines.size(); j++)
                {
                    cv::Vec4i v = lines[i];
                    Point2f intersection;

                    bool has_intersection = idOCR::getIntersectionPoint(
                        Point(lines[i][0],lines[i][1]),
                        Point(lines[i][2], lines[i][3]),
                        Point(myLines[j][0],myLines[j][1]),
                        Point(myLines[j][2], myLines[j][3]),
                        intersection);

                    if (has_intersection
                        && intersection.x >= 0
                        && intersection.y >= 0
                        && intersection.x <= image_vga.cols
                        && intersection.y <= image_vga.rows){
                        lineIntersections.push_back(intersection);
                    }
                }

                if (lineIntersections.size() > 0) {
                    lines[i][0] = lineIntersections[0].x;
                    lines[i][1] = lineIntersections[0].y;
                    lines[i][2] = lineIntersections[1].x;
                    lines[i][3] = lineIntersections[1].y;
                }
            }

        if (lines.size() > 3){

        // clusterization params
            int distanceThreshold = round(image.cols/15);
            double angleThreshold = 0.50;

            struct LineCluster {
                int sumX1;
                int sumY1;
                int sumX2;
                int sumY2;
                int count;
            };

            vector<LineCluster> clusters;

            // create first group
            LineCluster cluster;
            cluster.sumX1 = lines[0][0];
            cluster.sumY1 = lines[0][1];
            cluster.sumX2 = lines[0][2];
            cluster.sumY2 = lines[0][3];
            cluster.count = 1;
            clusters.push_back(cluster);

            // loop through rest of groups
            for (int i = 1; i < lines.size(); i++) {
                bool in_some_cluster = false;

                for (int j = 0; j < clusters.size(); j++) {

                     int cluster_x1 = clusters[j].sumX1/clusters[j].count;
                     int cluster_y1 = clusters[j].sumY1/clusters[j].count;
                     int cluster_x2 = clusters[j].sumX2/clusters[j].count;
                     int cluster_y2 = clusters[j].sumY2/clusters[j].count;

                     double angle1 = atan2((double)lines[i][3] - lines[i][1], (double)lines[i][2] - lines[i][0]);
                     double angle2 = atan2((double)cluster_y2 - cluster_y1, (double)cluster_x2 - cluster_x1);
                     float distance_cluster1_to_line1 = sqrt(((cluster_x1 - lines[i][0])*(cluster_x1 - lines[i][0])) + (cluster_y1 - lines[i][1])*(cluster_y1 - lines[i][1]));
                     float distance_cluster1_to_line2 = sqrt(((cluster_x1 - lines[i][2])*(cluster_x1 - lines[i][2])) + (cluster_y1 - lines[i][3])*(cluster_y1 - lines[i][3]));
                     float distance_cluster2_to_line1 = sqrt(((cluster_x2 - lines[i][0])*(cluster_x2 - lines[i][0])) + (cluster_y2 - lines[i][1])*(cluster_y2 - lines[i][1]));
                     float distance_cluster2_to_line2 = sqrt(((cluster_x2 - lines[i][2])*(cluster_x2 - lines[i][2])) + (cluster_y2 - lines[i][3])*(cluster_y2 - lines[i][3]));

                     if (((distance_cluster1_to_line1 < distanceThreshold) &&
                             (distance_cluster2_to_line2 < distanceThreshold || abs(angle1 - angle2) < angleThreshold)) ||
                          ((distance_cluster1_to_line2 < distanceThreshold) &&
                             (distance_cluster2_to_line1 < distanceThreshold || abs(angle1 - angle2) < angleThreshold))){

                             clusters[j].sumX1 += lines[i][0];
                             clusters[j].sumY1 += lines[i][1];
                             clusters[j].sumX2 += lines[i][2];
                             clusters[j].sumY2 += lines[i][3];
                             clusters[j].count += 1;
                             in_some_cluster = true;
                    }
                }
                // if point doesnt fit, create new group for it
                if (in_some_cluster == false){
                    LineCluster cluster;
                    cluster.sumX1 = lines[i][0];
                    cluster.sumY1 = lines[i][1];
                    cluster.sumX2 = lines[i][2];
                    cluster.sumY2 = lines[i][3];
                    cluster.count = 1;
                    clusters.push_back(cluster);
                }
            }

          if (clusters.size() == 4) {

            std::vector<cv::Vec4i> clusteredLines;

            // approx clusters and define clustered lines
            for (int i = 0; i < clusters.size(); i++){
                circle(image_vga, Point(clusters[i].sumX1/clusters[i].count, clusters[i].sumY1/clusters[i].count), 5, Scalar(0,0,255),-1);
                circle(image_vga, Point(clusters[i].sumX2/clusters[i].count, clusters[i].sumY2/clusters[i].count), 5, Scalar(0,0,255),-1);

                cv::line(image_vga, Point(clusters[i].sumX1/clusters[i].count, clusters[i].sumY1/clusters[i].count), Point(clusters[i].sumX2/clusters[i].count, clusters[i].sumY2/clusters[i].count), CV_RGB(255,0,0), 1);

                cv::Vec4i line;
                line[0] = clusters[i].sumX1/clusters[i].count;
                line[1] = clusters[i].sumY1/clusters[i].count;
                line[2] = clusters[i].sumX2/clusters[i].count;
                line[3] = clusters[i].sumY2/clusters[i].count;

                clusteredLines.push_back(line);
            }


            // compute intersections between approximated lines
            std::vector<cv::Point2f> corners;
            for (int i = 0; i < clusteredLines.size(); i++)
            {
                for (int j = i+1; j < clusteredLines.size(); j++)
                {
                    cv::Vec4i v = clusteredLines[i];
                    Point2f intersection;

                    bool has_intersection = idOCR::getIntersectionPoint(
                        Point(clusteredLines[i][0],clusteredLines[i][1]),
                        Point(clusteredLines[i][2], clusteredLines[i][3]),
                        Point(clusteredLines[j][0],clusteredLines[j][1]),
                        Point(clusteredLines[j][2], clusteredLines[j][3]),
                        intersection);

                    if (has_intersection
                        && intersection.x > 0
                        && intersection.y > 0
                        && intersection.x < image_vga.cols
                        && intersection.y < image_vga.rows){
                        corners.push_back(intersection);
                        cv::circle(image_vga, intersection, 3, CV_RGB(0,0,255), 2);
                    }
                }
            }


            if (corners.size() == 4) {

                cv::Point2f center(0,0);

                for (int i = 0; i < corners.size(); i++) {
                    center.x += corners[i].x;
                    center.y += corners[i].y;
                }
                center *= (1. / corners.size());


                for (int i = 0; i < corners.size(); i++) {
                    cv::circle(image_vga, corners[i], 3, CV_RGB(0,0,255), 2);
                }             

                idOCR::sortCorners(corners, center);

                // Define the destination image
                cv::Mat quad = cv::Mat::zeros(510, 800, CV_8UC3);

                // Corners of the destination image
                std::vector<cv::Point2f> quad_pts;
                quad_pts.push_back(cv::Point2f(0, 0));
                quad_pts.push_back(cv::Point2f(quad.cols, 0));
                quad_pts.push_back(cv::Point2f(quad.cols, quad.rows));
                quad_pts.push_back(cv::Point2f(0, quad.rows));

                double ratio_x = round(static_cast<double>(image_big.cols) / image_vga_backup.cols);
                double ratio_y = round(static_cast<double>(image_big.rows) / image_vga_backup.rows);

                for (int i = 0; i < corners.size(); i++) {
                    corners[i].x *= ratio_x;
                    corners[i].y *= ratio_y;
                }

                try {
                    // Get transformation matrix
                    cv::Mat transmtx = cv::getPerspectiveTransform(corners, quad_pts);

                    // Apply perspective transformation
                    cv::warpPerspective(image_big, quad, transmtx, quad.size(),INTER_LINEAR,BORDER_TRANSPARENT);
                }
                catch (cv::Exception e) {
//                    qDebug << ""error in warp"" << endl;
                }


                cv::Mat newImage = cv::Mat::zeros(600, 800, CV_8UC3);
                cv::Mat tempImage = cv::Mat::zeros(600, 800, CV_8UC3);

                quad.copyTo(newImage.rowRange(0,quad.rows).colRange(0,quad.cols));

                cv::GaussianBlur(newImage, tempImage, cv::Size(0, 0),5);
                cv::addWeighted(newImage, 1.5, tempImage, -0.5, 0, newImage);


                image = newImage.clone();
                return;
            }
          }
        }

        double alpha = 0.5; double beta;
        beta = ( 1.0 - alpha );
        addWeighted(image_vga_backup , alpha, image_vga, beta, 0.0, image_vga);

        image = image_vga.clone();
}




bool idOCR::getIntersectionPoint(cv::Point a1, cv::Point a2, cv::Point b1, cv::Point b2, cv::Point2f & intPnt){
    Point p = a1;
    Point q = b1;
    Point r(a2-a1);
    Point s(b2-b1);

    if(cross(r,s) == 0) {return false;}

    double t = cross(q-p,s)/cross(r,s);

    intPnt = p + t*r;
    return true;
}




double idOCR::cross(Point v1,Point v2){

    return v1.x*v2.y - v1.y*v2.x;
}



void idOCR::sortCorners(std::vector<cv::Point2f>& corners,
                 cv::Point2f center)
{
    std::vector<cv::Point2f> top, bot;

    for (int i = 0; i < corners.size(); i++)
    {
        if (corners[i].y < center.y)
            top.push_back(corners[i]);
        else
            bot.push_back(corners[i]);
    }
    corners.clear();

    if (top.size() == 2 && bot.size() == 2){
        cv::Point2f tl = top[0].x > top[1].x ? top[1] : top[0];
        cv::Point2f tr = top[0].x > top[1].x ? top[0] : top[1];
        cv::Point2f bl = bot[0].x > bot[1].x ? bot[1] : bot[0];
        cv::Point2f br = bot[0].x > bot[1].x ? bot[0] : bot[1];


        corners.push_back(tl);
        corners.push_back(tr);
        corners.push_back(br);
        corners.push_back(bl);
    }
}



vector<Rect> idOCR::getRectanglesFromMask(Mat & mask) {
    Mat canny;
    Mat image_gray;
    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;

    cvtColor( mask, image_gray, CV_RGB2GRAY );
    Canny( image_gray, canny, 30, 90);
    findContours( canny, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );


    vector<Rect> boundRect( contours.size() );

    for( int i = 0; i< contours.size(); i++ )
    {
        boundRect[i] = boundingRect( Mat(contours[i]) );
    }

    return boundRect;
}




void idOCR::maskCutOut(Mat & image, string maskFilename) {

    if ( !boost::filesystem::exists( maskFilename ) )
    {
        std::cout << ""Can't find mask file!"" << std::endl;
        boost::filesystem::path full_path( boost::filesystem::current_path() );
        std::cout << ""Current path is : "" << full_path << std::endl;
        return;
    }

    Mat mask = imread(maskFilename);

    fitImage(image, image, 800, 600);

    vector<Rect> rectangles = getRectanglesFromMask(mask);

    for( int i = 0; i< rectangles.size(); i++ )
    {
       Mat roi(image, rectangles[i]);

       cv::cvtColor(roi,roi, CV_RGB2GRAY);
       cv::threshold(roi,roi,0,255,THRESH_BINARY + CV_THRESH_OTSU);
       cv::cvtColor(roi,roi, CV_GRAY2RGB);

       string path = getCutoutPath();
       if (path.length() > 0) {
           path = path + ""/"";
       }

       processField(roi);
       saveImage(path + to_string(i) +  "".jpg"", roi);
    }

    double alpha = 0.5; double beta;
    beta = ( 1.0 - alpha );
    addWeighted(image , alpha, mask, beta, 0.0, image);

}


void idOCR::processField(Mat & image) {
    Mat original = image.clone();

    cv::Mat const shape = cv::getStructuringElement(
                  cv::MORPH_RECT, cv::Size(3, 1));

    cvtColor(image, image, CV_RGB2GRAY);
    cv::erode(image, image, shape);
    cv::GaussianBlur(image, image, Size( 5, 5) ,5,5);
    Size ksize(200,1);

    blur(image, image, ksize,Point(-1,-1) );
//    blur(image, image, ksize,Point(-1,-1) );
//    blur(image, image, ksize,Point(-1,-1) );


//    cv::erode(image, image, shape);
//    cv::dilate(image,image,shape);

    cv::threshold(image,image,250,255,THRESH_BINARY);

//return;

    int largest_area=0;
    int largest_contour_index=0;

    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;

    // invert image
    bitwise_not ( image, image );

    findContours( image, contours, hierarchy,CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE ); // Find the contours in the image


    cvtColor(image, image, CV_GRAY2RGB);


    for( int i = 0; i< contours.size(); i++ )
    {
        double a=contourArea( contours[i],false);

        if(a>largest_area){
            largest_area=a;
            largest_contour_index=i;
        }
    }


    for( int i = 0; i< contours.size(); i++ )
    {
        if (i == largest_contour_index){

            cv::Rect r;
            r = boundingRect(contours[i]);
            r.width = image.cols;

            if (((image.rows - r.y) - r.height) > round(image.rows/2)) {
                r.height = image.rows - r.y;
            }

            if (r.y + r.height > round(image.rows/2)) {
                r.y = 0;
                r.height = r.height + 2;
            }


            Mat mask(image.rows, image.cols, CV_8UC1);
            mask.setTo(0);

            rectangle(mask, r, Scalar(255, 255, 255), -1);

            image.setTo(255);
            original.copyTo(image, mask);
            return;
//            imshow("""", mask);
        }
    }

    image = original.clone();

}



void idOCR::setCutoutPath(string path) {
    cutoutPath = path;
}

string idOCR::getCutoutPath() {
    return cutoutPath;
}
",fileName
452,"#ifndef ALIENS_INVASION__ALIEN_H
#define ALIENS_INVASION__ALIEN_H

#include <memory>
#include <cassert>
#include ""city.h""

namespace aliens_invasion
{
    class Alien : public std::enable_shared_from_this<Alien>
    {
    public:
        explicit Alien(int id, std::shared_ptr<City> position)
            : m_id(id), m_alive(true)
        {
            m_position = std::move(position);
        }

        [[nodiscard]] int GetId() const
        {
            return m_id;
        }
        [[nodiscard]] std::shared_ptr<City> GetCurrentCity() const
        {
            return m_position;
        }
        bool IsTrapped() const
        {
            return m_position->IsIsolated();
        }
        void Kill()
        {
            m_alive = false;
        }
        bool IsAlive() const
        {
            return m_alive;
        }

        bool Move(FightObserver &fightObserver)
        {
            assert(m_position != nullptr);

            std::shared_ptr<City>  [MASK] ;
            if (!m_position->GetRandomDirection( [MASK] ))
            {
                /// the alien is trapped, so it cannot move
                return false;
            }
            m_position->LeaveCity(shared_from_this());
            m_position = std::move( [MASK] );
            m_position->EnterCity(shared_from_this(), fightObserver);
        }

    private:
        int m_id;
        std::shared_ptr<City> m_position;
        bool m_alive;
    };
}

#endif //ALIENS_INVASION__ALIEN_H
",moveTo
453,"#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<cstdio>
#include<stdio.h>
#include<iomanip>
#include<sstream>
using namespace std;

int main();
void Edit();
void edit_item(string);
void is_existed();
void read_all_record();
float netamt,grand_total=0;

float calculate(float  [MASK] ,float tax,float discount,float quantity)
{
    float gross,netamt;
    gross= [MASK] +( [MASK] *(tax/100));
    netamt=quantity*(gross-(gross*(discount/100)));

    return netamt;
}

void genrate_receipt()
{
    system(""cls"");                   // used to clear the screen 

    cout<<""\n\t\t\t*****************"";
    cout<<""\n\t\t\t INVOICE "";
    cout<<""\n\t\t\t*****************\n"";
    cout<<""\n\t""<<setw(25)<<""Item-ID""<< setw(15)<<""NAME""<<setw(5)<<""      QTY""<<setw(5)<<""     PRICE(per)\n\t"";
    ifstream file;
    file.open(""file.txt"");
    string item_no,name,date,cost,tax,discount,quantity,net_amount;
    while(getline(file,item_no,','))
    {
        vector<string> record;
        getline(file,name,',');
        getline(file,date,',');
        getline(file,cost,',');
        getline(file,tax,',');
        getline(file,discount,',');
        getline(file,quantity,'|');
        getline(file,net_amount,'\n');

        record.push_back(item_no);
        record.push_back(name);
        record.push_back(date);
        record.push_back(cost);
        record.push_back(tax);
        record.push_back(discount);
        record.push_back(quantity);
        record.push_back(net_amount);

        cout<<setw(25)<<record[0]<<setw(15)<<record[1]<<setw(5)<<""       ""<<record[6]<<setw(5)<<""       ""<<record[3]<<""\n\t"";

        stringstream s(record[7]);
        float value=0;
        s>>value;
        grand_total=value+grand_total;
    }
    
    cout<<""\n\t\t\t*****************"";
    cout<<""\n\t\t\t Grand-Total :                          ""<<grand_total;
    cout<<""\n\t\t\t*****************\n"";
    cout<<""\t\t\t\t\tThankyou visit again! "";
    grand_total=0;
    cout<<""\n\n\n\n\n\n\t\t\tPress any key to go back to Main Menu..."";
    system(""pause > nul"");                 // if we use this then ""Press any key to continue"" line shows up on the screen
    main();
}


bool is_existed(string item)
{

    ifstream obj(""file.txt"");           // ifstream provides input operation
    string c;
    bool found;
    while(getline(obj,c,','))
    {
        if(c==item)
        {
            found=true;
            return found;
        }

        else
            found=false;

        getline(obj,c,'\n');
    }

    if(found == false)
        return found;

}
 void bill_details(void)
{       
    int m;

    system(""cls"");
    cout<<""\t\t\t\tBill Details"";
    cout<<endl<<""\t\t\t============================\n\n"";
    cout<<""\n\t\t1.All Items\n\n"";
    cout<<""\t\t2.Back to Main menu\n\n"";
    cout<<""\t\tPlease Enter Required Option: "";
    cin>>m;
    switch(m)
    {
        case 1:
            read_all_record();
            break;

        case 2:
            main();
            break;
    }
}

void add_element()
{
    system(""cls"");
    string item_no,name;
    int date;
    float cost,tax,discount,quantity,net_amount;
    fstream obj(""file.txt"",ios::out|ios::app);          //ios::app set the stream position indicator to the end of the stream before each output operation
    cout<<""\n\t\tEnter Item Details\n\t..................................\n\n\n"";
    cout<<""\t\tEnter Item-ID. : "";
    cin>>item_no;
    if(is_existed(item_no)==1)
    {
        cout<<""\n\t\t\tItem is already in your cart...\n"";
        cout<<""\n\t\t\tTo change its quantity you have to go back to the Editor.....\n\n\n\t\tPress any key to go back....."";

        system(""pause>nul"");
        Edit();

    }

    else
    {
        cout<<endl<<""\t\tEnter Item name: "";
        cin>>name;
        cout<<endl<<""\t\tEnter Date: "";
        cin>>date;
        cout<<endl<<""\t\tEnter Item Price: "";
        cin>>cost;
        cout<<endl<<""\t\tEnter Tax applied: "";
        cin>>tax;
        cout<<endl<<""\t\tEnter Discount: "";
        cin>>discount;
        cout<<endl<<""\t\tEnter Quantity: "";
        cin>>quantity;

        net_amount=calculate(cost,tax,discount,quantity);

        obj<<item_no<<"",""<<name<<"",""<<date<<"",""<<cost<<"",""<<tax<<"",""<<discount<<"",""<<quantity<<""|""<<net_amount<<""\n"";
        cout<<""\n\n\t\t\tItem added successfully\n\n\n"";
        obj.close();
        cout<<""\t\tPress any key to go back....."";
        system(""pause>nul"");
        Edit();
    }
}

void delete_item(string item)
{
    vector<string> record;

    ifstream file(""file.txt"");
    ofstream temp(""tmp.txt"",ios::trunc);
    string one,two;
    char old[101]=""file.txt"";
    char name[101]=""tmp.txt"";

   if(is_existed(item)==1)
   {
        while(getline(file,one,','))
        {
            if(one==item)
            {
               getline(file,two,'\n');
            }
            else
            {
                getline(file,two,'\n');
                temp<<one<<"",""<<two<<""\n"";
            }
        }

        file.close();
        temp.close();

        int n=0;
        ofstream obj1;
        obj1.open(""file.txt"",ios::trunc);          //""trunc"" replace the value of its first argument with another value that has a smaller or same precision
        ifstream tmp;
        tmp.open(""tmp.txt"",ios::in);        //""in"" allow you to easily test if an expression matches any value in a list of values

        while(getline(tmp,one,','))
        {
            getline(tmp,two,'\n');
            obj1<<one<<"",""<<two<<""\n"";
            n=1;
        }

        obj1.close();
        tmp.close();
        if(n=1)
        cout<<""\n\n\t\t\t\t\t..Item Deleted.."";

        else
        cout<<""Can't delete item...."";
    }

    else
       cout<<""\n\n\t\t\tItem is not in the list...."";

    system (""pause>nul"");
    system(""cls"");

    cout<<""\n\n\n\t\t\t1.To Edit/Add the element.\n\n\t\t\t2.To go Back to editor..."";
    int s;
    cin>>s;

    if(s==1)
       add_element();

    else
       Edit();

    system (""cls"");
}

void edit_item()
{   
    system(""cls"");

    string one,two,name,item;
    int date,cost,tax,discount,quantity;
    ifstream obj1;
    ofstream obj2;

    cout<<""\n\t\tEnter Item Details\n\t..................................\n\n\n"";
    cout<<""\t\tEnter Item no. : "";
    cin>>item;

    delete_item(item);
}

void Edit()
{
    system(""cls"");
    cout<<""\t\t\t\t\tEditor\n"";
    cout<<""\t\t\t\t======================\n\n"";
    cout<<""\n\t\t1.Add Item Details\n\n"";
    cout<<""\t\t2.Edit Item Details\n\n"";
    cout<<""\t\t3.Delete Item Details\n\n"";
    cout<<""\t\t4.Back to Main Menu ""<<endl;
    cout<<""\n\tPLease enter the value: "";
    int n;
    cin>>n;

    switch(n)
    {
        case 1:
            add_element();
            break;
        case 2:
            edit_item();
            break;

        case 3:
        {
            string c;
            cout<<""\n\t\t\tEnter item no.: "";
            cin>>c;
            delete_item(c);
            break;
            }
        case 4:
        {
            main();
            break;
        }
    }
}

int readrecord(string element )
{
    system(""cls"");
    vector<string> record;

    ifstream file;
    file.open(""file.txt"");

    bool found=false;
    string item_no,name,date,cost,tax,discount,quantity,net_amount;


    while(!found&&getline(file,item_no,','))
    {
        getline(file,name,',');
        getline(file,date,',');
        getline(file,cost,',');
        getline(file,tax,',');
        getline(file,discount,',');
        getline(file,quantity,'|');
        getline(file,net_amount,'\n');


        if(item_no==element)
        {
            cout<<""\t\t\t\t\tITEM\n\t\t\t\t---------------------\n\n"";
            found=true;
            record.push_back(item_no);
            record.push_back(name);
            record.push_back(date);
            record.push_back(cost);
            record.push_back(tax);
            record.push_back(discount);
            record.push_back(quantity);
            record.push_back(net_amount);
            cout<<""\n\tItem-ID        :""<<record[0]<<""\n\tItem name     :""<<record[1]<<""\n\tDate of entry       : ""<<record[2]<<""\n\tPrice      : ""<<record[3]<<""\n\tTax applied       :""<<record[4];
            cout<<""\n\tDiscount applicable       : ""<<record[5]<<""\n\tQuantity       :  ""<<record[6]<<""\n\tNet Amount       :  ""<<record[7]<<""\n\n"";

            cout<<""\n\n\n\t\t\tPress any key to go back to Main Menu... "";
            system(""pause > nul"");
            main();
            return 0;
        }


    }

    if(found==false)
    {
        cout<<""\n\n\t\t\tItem does not exist..\n\nPress enter to go back..."";
        system(""pause>nul"");
        main();
        return 0;
    }
}

void read_all_record()
{

    system(""cls"");
    ifstream file;
    file.open(""file.txt"");
    string item_no,name,date,cost,tax,discount,quantity,net_amount;

    cout<<""\n\n\t\t\t\t\t\t\t Items in the Cart\n\t\t\t\t\t\t-------------------------------------\n\n""<<endl;
    cout<<setw(25)<<""Item-ID""<< setw(20)<<""NAME""<<setw(15)<<""DATE""<<setw(10)<<""PRICE""<<setw(10)<<""TAX(%)""<<setw(15)<<""DISCOUNT(%)""<<setw(15)<<""QUANTITY""<<setw(15)<<""NET AMOUNT""<<""\n\n"";

    while(getline(file,item_no,','))
    {

        vector<string> record;
        getline(file,name,',');
        getline(file,date,',');
        getline(file,cost,',');
        getline(file,tax,',');
        getline(file,discount,',');
        getline(file,quantity,'|');
        getline(file,net_amount,'\n');


        record.push_back(item_no);
        record.push_back(name);
        record.push_back(date);
        record.push_back(cost);
        record.push_back(tax);
        record.push_back(discount);
        record.push_back(quantity);
        record.push_back(net_amount);

        cout<<setw(25)<<record[0]<<setw(20)<<record[1]<<setw(15)<<record[2]<<setw(10)<<record[3]<<setw(10)<<record[4]<<setw(15)<<record[5]<<setw(15)<<record[6]<<setw(15)<<record[7]<<""\n"";

        stringstream s(record[7]);
        float value=0;
        s >> value;
        grand_total=value+grand_total;
    }
    
    cout<<""\n\n\n\t\t\t\t\t\t\tGrand-Total :  ""<<grand_total<<""\n\n\n\t\t\tPress any key to go back to Bill Details..."";
    grand_total=0;
    system(""pause > nul"");
    bill_details();
}

int main()
{
    system(""cls"");
    cout<<""\n\t\t\t************************************"";
    cout<<""\n\t\t\t\tSuper Market Billing "";
    cout<<""\n\n\t\t\t************************************\n\n"";
    cout<<""\n\t\t1.Bill Details\n\n"";
    cout<<""\t\t2.Add/Remove/Edit Item\n\n"";
    cout<<""\t\t3.Show Item Details\n\n"";
    cout<<""\t\t4.Genrate Receipt\n\n"";
    cout<<""\t\t5.Exit\n\n"";
    cout<<""\t\tPlease Enter Required Option: "";
    int n;
    cin>>n;
    switch(n)
    {
        case 1:
            bill_details();
            break;
        
        case 2:
            Edit();
            break;
            
        case 3:
        {
            string b;
            cout<<""\n\t\tPlease enter item number: "";
            cin>>b;
            readrecord(b);
            break;
        }
        
        case 4:
        {
            genrate_receipt();
            break;
        }
        
        case 5:
            cout<<""\n\n\t\t\t\t..Exited..."";
            system(""pause>nul"");
            system(""cls"");
            break;
    }

    return 0;
}


",price
454,"
#include ""common/stdafx.h""
#include ""display/display.h""


Display::Display(Renderer *r) : renderer(r)
{
}


Display::~Display()
{
}

void Display::render()
{
	unsigned int  [MASK] , y_end, x_start, x_end;

	 [MASK]  = (renderer->height / 2) - (144 / 2);
	y_end = (renderer->height / 2) + (144 / 2);
	x_start = (renderer->width / 2) - (160 / 2);
	x_end = (renderer->width / 2) + (160 / 2);

	renderer->set_draw_color(0, 0, 0, 0);
	for (unsigned int y =  [MASK] , i = 0; y < y_end; y++, i++)
	{
		for (unsigned int x = x_start, j = 0; x < x_end; x++, j++)
		{
			switch (screen[i][j])
			{
			case 0: renderer->set_draw_color(155, 188, 15, 255); break;
			case 1: renderer->set_draw_color(139, 172, 15, 255); break;
			case 2: renderer->set_draw_color(48, 98, 48, 255); break;
			case 4: renderer->set_draw_color(15, 56, 15, 255); break;
			case 12: renderer->set_draw_color(15, 56, 15, 255); break;
			}
			renderer->draw_px(x, y);
		}
	}
	renderer->present();
	flush();
}

void Display::render_background(__uint8 *memory, __uint8 scx, __uint8 scy, __uint16 tile_map, __uint16 tile_data)
{
	__uint8 tile_id;
	__uint16 data;

	renderer->set_draw_color(0, 0, 0, 0);
	for (unsigned int y = (renderer->height / 2) - (255 / 2), i = 0; y < (renderer->height / 2) + (255 / 2); y++, i++)
	{
		for (unsigned int x = (renderer->width / 2) - (255 / 2), j = 0; x < (renderer->width / 2) + (255 / 2); x += 8, j += 8)
		{
			tile_id = memory[tile_map + ((i / 8) * 32) + (j / 8)];
			data = *(__uint16 *)&memory[tile_data + (tile_id * 16) + (i % 8) * 2];

			for (unsigned int k = 0, mask = 0x8000, lomask = 0x0080; k < 8; k++, mask >>= 1, lomask >>= 1)
			{
				if (((i == scy || i == scy + 144U) && j + k >= scx && j + k <= scx + 160U)) 
					renderer->set_draw_color(255, 0, 0, 255);
				else if ((i >= scy && i <= scy + 144U) && (j + k == scx || j + k == scx + 160U)) 
					renderer->set_draw_color(255, 0, 0, 255);
				else if (((!!(data & mask)) << 1) | !!(data & (lomask)))
					renderer->set_draw_color(0, 0, 0, 255);
				else
					renderer->set_draw_color(255, 255, 255, 255);
				renderer->draw_px(x + k, y);
			}
		}
	}
	renderer->present();
}

void Display::push_px(__uint8 color)
{
	if (screenx == 160) return;

	screen[screeny][screenx] = color;

	screenx = (screenx + 1);
	if (!screenx) screeny = (screeny + 1) % 144;
}

void Display::flush()
{
	screenx = screeny = 0;
}
",y_start
455,"///////////////////////////////////
////// DO NOT EDIT THIS FILE //////
///////////////////////////////////

//
// Johnny705 robot simulator for TU705 Engineering Computing 2.1
// Written by <NAME> - last updated 17-Oct-2021
// arduino.cpp - mainly simulated Arduino functions
//

#include <thread>
#include ""arduino.h""

// Function prototypes for Arduino functions in robot.cpp
extern void setup();
extern void loop();

Robot::Robot()
{
    int n;
    for (n=0 ; n<8 ; ++n) Ax[n] = 0;
    for (n=0 ; n<13 ; ++n)
    {
        Dmode[n] = INPUT;
        Dx[n] = 1; // float pins high when not driven high or low
    }

    x = 200; y = 200; w = 100; h = 100; angle = 0;
    speedLeft = 1.0; speedRight = 1.0; // as a factor of maxSpeed
    maxSpeed = 50; // pixels per second

    baudrate = 0;

    startClockTime = clock();
}

Robot g_robot;

SerialClass Serial;

bool g_running = 0;

void robot_thread_function()
{
    setup();

    while(g_running)
    {
        // Relinquish control for a few ms to allow other threads to run.
        // Not really sure if this is useful or not!
        std::this_thread::sleep_for(std::chrono::milliseconds(1));

        loop();
    }
}

void pinMode(uint8_t pin, uint8_t mode)
{
    if (pin < 0 || pin >= 13) return;
    g_robot.Dmode[pin] = mode;
    if (mode == INPUT) g_robot.Dx[pin] = 1;
    else g_robot.Dx[pin] = 0;
}

int digitalRead(uint8_t pin)
{
    if (pin < 0 || pin >= 13) return 0;
    return g_robot.Dx[pin];
}

void digitalWrite(uint8_t pin, uint8_t val)
{
    if (pin < 0 || pin >= 13) return;
    g_robot.Dx[pin] = val;
}

int analogRead(uint8_t pin)
{
    if (pin < 0 || pin >= 8) return 0;
    return g_robot.Ax[pin];
}

void analogWrite(uint8_t pin, int val)
{

}

void delay(unsigned long ms)
{
    long end_time = clock() + (ms*CLOCKS_PER_SEC/1000.0);
    while (clock() < end_time)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
}

unsigned long millis()
{
    return (clock() - g_robot.startClockTime)*1000.0/CLOCKS_PER_SEC;
}

unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout)
{
    return 0;
}

long random(long maxval)
{
    return rand() % maxval;
}

long random(long minval, long maxval)
{
    return ((rand() % (maxval-minval)) + minval);
}

void randomSeed(unsigned long  [MASK] )
{
    srand( [MASK] );
}
",seed
456,"// Copyright 2022 ByteDance Ltd. and/or its affiliates.
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 <hercules/pipeline/tx_session.h>
#include <hercules/runtime/utf8_util.h>

#include ""tensorflow/core/framework/op.h""
#include ""tensorflow/core/framework/op_kernel.h""

#include ""tf_utils.h""

namespace {
typedef Eigen::ThreadPoolDevice CPUDevice;
typedef tensorflow::gtl::InlinedVector<tensorflow::int64, 4> ShapeContainer;

class HerculesTFDatasetCallbackOp : public tensorflow::OpKernel {
 private:
  ::hercules::runtime::OpKernel* op_impl_ = nullptr;

  void initAttributes(tensorflow::OpKernelConstruction* context) {
    std::string op_addr_s;
    TF_CHECK_OK(context->GetAttr(""op_addr"", &op_addr_s));
    auto op_addr = std::strtoull(op_addr_s.c_str(), nullptr, 10);
    CHECK(op_addr != 0);
    // TODO: check we need own this ptr
    op_impl_ = static_cast<::hercules::runtime::OpKernel*>((void*)(op_addr));
  }

 public:
  explicit HerculesTFDatasetCallbackOp(tensorflow::OpKernelConstruction* context)
      : tensorflow::OpKernel(context) {
    // Get attr
    initAttributes(context);
  }

  void Compute(tensorflow::OpKernelContext* context) override;
};

template <typename Iterator>
void SetMultiResult(Iterator  [MASK] , Iterator last, tensorflow::OpKernelContext* context) {
  for (int i = 0;  [MASK]  != last; ++ [MASK] , ++i) {
    ::hercules::runtime::tf_utils::ToTFTensor(
         [MASK] ->template As<::hercules::runtime::NDArray>(), context, i);
  }
}

void HerculesTFDatasetCallbackOp::Compute(tensorflow::OpKernelContext* context) {
  // the last input is output shape spec
  const int num_inputs = context->num_inputs();
  std::vector<ShapeContainer> shapes(num_inputs);

  // Prepare op inputs
  std::vector<::hercules::runtime::RTValue> values;
  values.reserve(num_inputs);

  for (int i = 0; i < num_inputs; ++i) {
    // Grab the input tensor
    auto& input_tensor = context->input(i);

    // Create shape container, should keep ref during execution
    shapes[i] = input_tensor.shape().dim_sizes();
    const auto ndims = input_tensor.shape().dims();

    switch (input_tensor.dtype()) {
      case tensorflow::DT_STRING: {
        const auto& flatten = input_tensor.flat<tensorflow::tstring>();
        if (ndims == 0u) {
          auto& value = flatten(0);
          // TODO: zero copy
          // ::hercules::runtime::string_view value_view(value.data(), value.size());
          // values.emplace_back(::hercules::runtime::RTView(value_view));
          values.emplace_back(::hercules::runtime::RTValue(
              ::hercules::runtime::String(value.data(), value.size())));
        } else if (ndims == 1u) {
          size_t sz = input_tensor.dim_size(0);
          auto list = ::hercules::runtime::List();
          list.reserve(sz);
          for (size_t i = 0; i < sz; ++i) {
            auto& value_i = flatten(i);
            list.append(::hercules::runtime::RTValue(
                ::hercules::runtime::String(value_i.data(), value_i.size())));
          }
          values.emplace_back(std::move(list));
        } else {
          context->SetStatus(tensorflow::Status(tensorflow::error::INVALID_ARGUMENT,
                                                ""string tensor only support dim=0/1""));
          return;
        }
      } break;
      case tensorflow::DT_FLOAT: {
        if (ndims == 0u) {
          values.emplace_back(::hercules::runtime::RTValue(input_tensor.scalar<float>()(0)));
        } else {
          auto tx_tensor = ::hercules::runtime::tf_utils::FromTFTensor(input_tensor);
          values.emplace_back(std::move(tx_tensor));
        }
      } break;
      case tensorflow::DT_DOUBLE: {
        if (ndims == 0u) {
          values.emplace_back(::hercules::runtime::RTValue(input_tensor.scalar<double>()(0)));
        } else {
          auto tx_tensor = ::hercules::runtime::tf_utils::FromTFTensor(input_tensor);
          values.emplace_back(std::move(tx_tensor));
        }
      } break;
      case tensorflow::DT_INT32: {
        if (ndims == 0u) {
          int32_t value = input_tensor.scalar<tensorflow::int32>()(0);
          values.emplace_back(::hercules::runtime::RTValue(value));
        } else {
          auto tx_tensor = ::hercules::runtime::tf_utils::FromTFTensor(input_tensor);
          values.emplace_back(std::move(tx_tensor));
        }
      } break;
      case tensorflow::DT_INT64: {
        if (ndims == 0u) {
          int64_t value = input_tensor.scalar<tensorflow::int64>()(0);
          values.emplace_back(::hercules::runtime::RTValue(value));
        } else {
          auto tx_tensor = ::hercules::runtime::tf_utils::FromTFTensor(input_tensor);
          values.emplace_back(std::move(tx_tensor));
        }
      } break;
      default: {
        context->SetStatus(tensorflow::Status(
            tensorflow::error::INVALID_ARGUMENT,
            ""unsupported tensorflow dtype: "" + tensorflow::DataType_Name(input_tensor.dtype())));
        return;
      }
    }
  }

  ::hercules::runtime::RTValue result;
  try {
    result = op_impl_->Process(::hercules::runtime::PyArgs(values.data(), values.size()));
  } catch (std::exception& e) {
    context->SetStatus(tensorflow::Status(tensorflow::error::ABORTED, e.what()));
    return;
  } catch (...) {
    context->SetStatus(
        tensorflow::Status(tensorflow::error::ABORTED, ""run hercules op failed!!!""));
    return;
  }

  // output to tensorflow
  switch (result.type_code()) {
    case ::hercules::runtime::TypeIndex::kRuntimeNDArray: {
      ::hercules::runtime::tf_utils::ToTFTensor(
          result.AsNoCheck<::hercules::runtime::NDArray>(), context, 0);
    } break;
    case ::hercules::runtime::TypeIndex::kRuntimeTuple: {
      auto multi_outputs = result.AsNoCheck<::hercules::runtime::Tuple>();
      SetMultiResult(multi_outputs.begin(), multi_outputs.end(), context);
    } break;
    case ::hercules::runtime::TypeIndex::kRuntimeList: {
      auto multi_outputs = result.AsNoCheck<::hercules::runtime::List>();
      SetMultiResult(multi_outputs.begin(), multi_outputs.end(), context);
    } break;
    default: {
      auto errmsg = ""unsupported hercules result type: "" + result.type_name();
      context->SetStatus(tensorflow::Status(tensorflow::error::INTERNAL,
                                            tensorflow::StringPiece(errmsg.data(), errmsg.size())));
      return;
    } break;
  }
  // end
}

REGISTER_KERNEL_BUILDER(Name(""HerculesTFDatasetCallbackOp"").Device(tensorflow::DEVICE_CPU),
                        HerculesTFDatasetCallbackOp);

REGISTER_OP(""HerculesTFDatasetCallbackOp"")
    .Input(""input_args: ListT"")
    .Attr(""ListT: list({string, float32, float64, int32, int64})"")
    .Output(""output: output_dtype"")
    .Attr(""op_addr: string"")
    .Attr(""output_dtype: list({float32, int32, int64})"");

}  // namespace
",first
457,"
#include <PID_v1.h>
#include <Ultrasonic.h>

const int SERVO_PIN = 9;
const int ULTRASONIC_TRIG_PIN = 10;
const int ULTRASONIC_ECHO_PIN = 11;
const float KP = 2.0;
const float KI = 0.0;
const float KD = 0.0;

// Create the PID controller
PID myPID(&distance, &servoPosition, &setpoint, KP, KI, KD, DIRECT);

float distance = 0.0;
float servoPosition = 90.0;
float setpoint = 90.0;

void setup() {
  Serial.begin(9600);
  pinMode(ULTRASONIC_TRIG_PIN, OUTPUT);
  pinMode(ULTRASONIC_ECHO_PIN, INPUT);
  myPID.SetMode(AUTOMATIC);
  myPID.SetSampleTime(100);
  distance = getDistance();
  servoPosition = 90.0;
  Serial.print(""Distance: "");
  Serial.println(distance);
  Serial.print(""Servo position: "");
  Serial.println(servoPosition);
}
void loop() {
  distance = getDistance();
  float output = myPID.Compute(distance);
  servoPosition += output;
  if (servoPosition < 0) {
    servoPosition = 0;
  } else if (servoPosition > 180) {
    servoPosition = 180;
  }
  analogWrite(SERVO_PIN, servoPosition);
  Serial.print(""Distance: "");
  Serial.println(distance);
  Serial.print(""Servo position: "");
  Serial.println(servoPosition);
  delay(100);
}
float getDistance() {
  digitalWrite(ULTRASONIC_TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(ULTRASONIC_TRIG_PIN, LOW);
  long  [MASK]  = pulseIn(ULTRASONIC_ECHO_PIN, HIGH);
  float distance =  [MASK]  * 0.0343 / 2.0;
  return distance;
}
",echo_time
458,"/*
 * \file Profiler.h
 * \copyright (C) 2021 Special Technological Center Ltd
 * \author : <NAME>.
 * \date : 16.01.2021
 * \time : 20:29
 */

#pragma once

#include <chrono>
#include <fstream>
#include <iomanip>
#include <string>
#include <thread>
#include <mutex>
#include <sstream>

#include <bard/core/logging/Logger.h>
#include ""Singleton.h""

namespace Aux::Profiling
{

using FloatingPointMicroseconds = std::chrono::duration< double, std::micro >;
using Microseconds = std::chrono::microseconds;

constexpr const auto DEFAULT_FILE_NAME = ""profiling_results.json"";

struct ProfileResult
{
    std::string name;

    FloatingPointMicroseconds start;
    Microseconds elapsedTime;
    std::thread::id threadID;
};

struct Session
{
    explicit Session( std::string name ) : name( std::move(name) ) {}
    std::string name;
};

class Profiler : public Aux::Singleton< Profiler >
{
public:
    void BeginSession(const std::string& name, const std::string& filepath = DEFAULT_FILE_NAME )
    {
        std::lock_guard lock(m_mutex);

        if (m_currentSession )
        {
            // If there is already a current session, then close it before beginning new one.
            // Subsequent profiling output meant for the original session will end up in the
            // newly opened session instead.  That's better than having badly formatted
            // profiling output.
            CORE_LOG_ERROR( ""Profiler::BeginSession('{0}') when session '{1}' already open."",
                            name, m_currentSession->name );
            InternalEndSession();
        }

        m_outputStream.open( filepath );
        if( m_outputStream.is_open() )
        {
            m_currentSession = new Session( name );
            WriteHeader();
        }
        else { CORE_LOG_ERROR( ""Profiler could not open results file '{0}'."", filepath ); }
    }

    void EndSession()
    {
        std::lock_guard lock(m_mutex);
        InternalEndSession();
    }

    void WriteProfile(const ProfileResult& result)
    {
        std::stringstream json;

        json << std::setprecision(3) << std::fixed;
        json << "",{"";
        json << ""\""cat\"":\""function\"","";
        json << ""\""dur\"":"" << (result.elapsedTime.count()) << ',';
        json << ""\""name\"":\"""" << result.name << ""\"","";
        json << ""\""ph\"":\""X\"","";
        json << ""\""pid\"":0,"";
        json << ""\""tid\"":"" << result.threadID << "","";
        json << ""\""ts\"":"" << result.start.count();
        json << ""}"";

        std::lock_guard lock(m_mutex);
        if (m_currentSession)
        {
            m_outputStream << json.str();
            m_outputStream.flush();
        }
    }

    ~Profiler() { EndSession(); }

private:
    friend class Aux::Singleton< Profiler >;
    Profiler() : Singleton( nullptr ) {}

    void WriteHeader()
    {
        m_outputStream << R""({""otherData"": {},""traceEvents"":[{})"";
        m_outputStream.flush();
    }

    void WriteFooter()
    {
        m_outputStream << ""]}"";
        m_outputStream.flush();
    }

    // Note: you must already own lock on m_mutex before
    // calling InternalEndSession()
    void InternalEndSession()
    {
        if( m_currentSession )
        {
            WriteFooter();
            m_outputStream.close();
            delete m_currentSession;
            m_currentSession = nullptr;
        }
    }
private:
    std::mutex m_mutex;
    Session * m_currentSession = nullptr;
    std::ofstream m_outputStream;
};

class InstrumentationTimer
{
    using Clock = std::chrono::steady_clock;
    
public:
    explicit InstrumentationTimer( const char * name )
            : m_name( name ),
              m_startTimestamp( Clock::now() ),
              m_stopped( false )
    {
    }

    ~InstrumentationTimer()
    {
        if ( !m_stopped ) { Stop(); }
    }

    void Stop()
    {
        auto  [MASK]  = Clock::now();
        auto highResStart = FloatingPointMicroseconds{ m_startTimestamp.time_since_epoch() };
        auto elapsedTime = std::chrono::time_point_cast< Microseconds >(  [MASK]  ).time_since_epoch()
                           - std::chrono::time_point_cast< Microseconds >( m_startTimestamp ).time_since_epoch();

        Profiler::get().WriteProfile( { m_name, highResStart, elapsedTime, std::this_thread::get_id() } );

        m_stopped = true;
    }
private:
    const char * m_name;
    std::chrono::time_point< Clock > m_startTimestamp;
    bool m_stopped;
};

namespace detail {

template< size_t N >
struct ChangeResult
{
    char data[N];
};

template< size_t N, size_t K >
constexpr auto CleanupOutputString( const char(& expr)[N], const char(& remove)[K] )
{
    ChangeResult< N > result = {};

    size_t srcIndex = 0;
    size_t dstIndex = 0;
    while( srcIndex < N )
    {
        size_t matchIndex = 0;
        while( matchIndex < K - 1 && srcIndex + matchIndex < N - 1 && expr[ srcIndex + matchIndex ] == remove[ matchIndex ] )
        {
            matchIndex++;
        }

        if( matchIndex == K - 1 ) { srcIndex += matchIndex; }

        result.data[ dstIndex++ ] = expr[ srcIndex ] == '""' ? '\'' : expr[ srcIndex ];
        srcIndex++;
    }
    return result;
}
}

}

#ifdef BARD_USE_PROFILER
    // Resolve which function signature macro will be used. Note that this only
	// is resolved when the (pre)compiler starts, so the syntax highlighting
	// could mark the wrong one in your editor!
	#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
		#define FUNC_SIGNATURE __PRETTY_FUNCTION__
	#elif defined(__DMC__) && (__DMC__ >= 0x810)
		#define FUNC_SIGNATURE __PRETTY_FUNCTION__
	#elif (defined(__FUNCSIG__) || (_MSC_VER))
		#define FUNC_SIGNATURE __FUNCSIG__
	#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
		#define FUNC_SIGNATURE __FUNCTION__
	#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
		#define FUNC_SIGNATURE __FUNC__
	#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
		#define FUNC_SIGNATURE __func__
	#elif defined(__cplusplus) && (__cplusplus >= 201103)
		#define FUNC_SIGNATURE __func__
	#else
		#define FUNC_SIGNATURE ""FUNC_SIGNATURE unknown!""
	#endif

	#define BARD_PROFILE_BEGIN_SESSION(name, filepath) Aux::Profiling::Profiler::get().BeginSession(name, filepath)
	#define BARD_PROFILE_END_SESSION() Aux::Profiling::Profiler::get().EndSession()
	#define BARD_PROFILE_SCOPE_LINE2(name, line) constexpr auto fixedName##line = Aux::Profiling::detail::CleanupOutputString(name, ""__cdecl "");\
											   Aux::Profiling::InstrumentationTimer timer##line(fixedName##line.data)
	#define BARD_PROFILE_SCOPE_LINE(name, line) BARD_PROFILE_SCOPE_LINE2(name, line)
	#define BARD_PROFILE_SCOPE(name) BARD_PROFILE_SCOPE_LINE(name, __LINE__)
	#define BARD_PROFILE_FUNCTION() BARD_PROFILE_SCOPE(FUNC_SIGNATURE)
#else
    #define BARD_PROFILE_BEGIN_SESSION(name, filepath)
    #define BARD_PROFILE_END_SESSION()
    #define BARD_PROFILE_SCOPE(name)
    #define BARD_PROFILE_FUNCTION()
#endif",endTimepoint
459,"// Managers.cpp: implementation of the CManagers class.
//
//////////////////////////////////////////////////////////////////////

#include ""stdafx.h""
#include ""Legend.h""
#include ""Managers.h""
#include ""player.h""
#include""People.h""
#include""Sign.h""
#ifdef _DEBUG
#undef THIS_FILE

#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Managers::Managers()
{
	count=0;
	int i,temp;
	int suit1;
	suit1=1;
    for(i=0;i<52;i++)                //生成52张牌 
    {
        if(i%13==0)
            suit1++;                //改变花色 
        card1[i].Suit=suit1;           //保存花色 
        temp=i%13;
        if(temp==0)
            card1[i].Number='A';
        else if(temp==9)
            card1[i].Number='T';
        else if(temp==10)
            card1[i].Number='J';
        else if(temp==11)
            card1[i].Number='Q';
        else if(temp==12)
            card1[i].Number='K';
        else 
            card1[i].Number=temp+'1';//以上没有问题
        if(temp>=9)                      //牌点
            card1[i].Num=0.5;
        else
            card1[i].Num=temp+1.0;
    }

	for(i=0;i<4;i++)
		play[i].add=i;
	Player=0;

}

Managers::~Managers()
{

}



//////////////////////////////////////////////////////////////////////
// Managers Class
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

void Managers::GameStart(){
//	if(ready)
//	{
	Shuffle();
//	Deal();
//	RankShow();

//	}
}

void Managers::Shuffle()               //洗牌
{ 
    int i,j;
    CCard tempcard;
    srand(time(NULL));
    for(i=0;i<52;i++)
    {
        j=rand()%52;              
        tempcard=card1[j];
        card1[j]=card1[i];
        card1[i]=tempcard;        //两两交换卡牌，执行52次，相当于洗牌
    }
}
bool Managers::Deal(){              //按顺序发牌 
	int i,j;
	      //若52张牌没发完就一直发牌
		CSign  [MASK] ;
		 [MASK] .DoModal();           //弹出对话框
		play[0].num= [MASK] .Num;
		j=(count+play[0].num);
		if(j<=52){  //判断一个人要的牌张数超过了剩下的牌张数
			for(i=0;i<play[0].num;i++){
				j=i+count;
				play[0].a[i]=card1[j];
			}
			count=count+play[0].num;
			for(;i<5;i++){
				play[0].a[i].Num =0;
				play[0].a[i].Number='0';
				play[0].a[i].Suit=0;
			}
			play[0].Dian();
		}
		else {
			MessageBox(NULL,TEXT(""牌不够啦，游戏结束了！""),TEXT(""HALF PAST TEN""),MB_OK);//MessageBox(""牌不够啦，游戏结束了！"");
			//MessageBox(NULL,""牌不够啦，游戏结束了！"",""OK"",MB_ABORTRETRYIGNORE);              //牌不够，游戏结束
			int flag=MessageBox(NULL,TEXT(""是否再来一局""),TEXT(""HALF PAST TEN""),MB_OKCANCEL);
			if(flag==IDOK){
				count=0;
				return 1;
				//DoPreparePrinting(pInfo);
			}//此处添加是否重来一局
			else return 0;
		}
		 [MASK] .DoModal();           //弹出对话框
		play[1].num= [MASK] .Num;
		j=(count+play[1].num);
		if(j<=52){
			for(i=0;i<play[1].num;i++){
				j=i+count;
				play[1].a[i]=card1[j];
			}
			count=count+play[1].num;
			for(;i<5;i++){
				play[1].a[i].Num =0;
				play[1].a[i].Number='0';
				play[1].a[i].Suit=0;
			}
			play[1].Dian();

		}
		else {
			MessageBox(NULL,TEXT(""牌不够啦，游戏结束了！""),TEXT(""HALF PAST TEN""),MB_OK);
		//MessageBox(NULL,""牌不够啦，游戏结束了！"",""OK"",MB_ABORTRETRYIGNORE);             //牌不够，游戏结束;
			int flag=MessageBox(NULL,TEXT(""是否再来一局""),TEXT(""HALF PAST TEN""),MB_OKCANCEL);
			if(flag==IDOK){
				count=0;
				return 1;
				//DoPreparePrinting(pInfo);
			}
			//此处添加是否重来一局
			else return 0;
		}

		if(Player>=3){ 		
			 [MASK] .DoModal();           //弹出对话框
			play[2].num= [MASK] .Num;
			j=(count+play[2].num);
			if(j<=52){
				for(i=0;i<play[2].num;i++){
					j=i+count;
					play[2].a[i]=card1[j];
				}
				count=count+play[2].num;
				for(;i<5;i++){
					play[2].a[i].Num =0;
					play[2].a[i].Number='0';
					play[2].a[i].Suit=0;
				}
				play[2].Dian();

			}
			else {
				MessageBox(NULL,TEXT(""牌不够啦，游戏结束了！""),TEXT(""HALF PAST TEN""),MB_OK);
				//MessageBox(NULL,""牌不够啦，游戏结束了！"",""OK"",MB_ABORTRETRYIGNORE);              //牌不够，游戏结束
				int flag=MessageBox(NULL,TEXT(""是否再来一局""),TEXT(""HALF PAST TEN""),MB_OKCANCEL);
				if(flag==IDOK){
					count=0;
					return 1;
					//DoPreparePrinting(pInfo);
				}
				//此处添加是否重来一局
				else return 0;
			}
		}

		if(Player>=4){            
			CSign dlg;                          //弹出对话框
			dlg.DoModal();
			play[3].num=dlg.Num;
			j=(count+play[3].num);
			if(j<=52){
				for(i=0;i<play[3].num;i++){
					j=i+count;
					play[3].a[i]=card1[j];
				}
				count=count+play[3].num;
				for(;i<5;i++){
					play[3].a[i].Num=0;
					play[3].a[i].Number='0';
					play[3].a[i].Suit=0;
				}
				play[3].Dian();
			}
			else {
				MessageBox(NULL,TEXT(""牌不够啦，游戏结束了！""),TEXT(""HALF PAST TEN""),MB_OK);
			//MessageBox(NULL,""牌不够啦，游戏结束了！"",""OK"",MB_ABORTRETRYIGNORE);             //牌不够，游戏结束
				int flag=MessageBox(NULL,TEXT(""是否再来一局""),TEXT(""HALF PAST TEN""),MB_OKCANCEL);
				if(flag==IDOK){
					count=0;
					return 1;
					//DoPreparePrinting(pInfo);
				}
				//此处添加是否重来一局
				else return 0;
			}
		}

		if(count==52)
		{
			MessageBox(NULL,""牌不够啦，游戏结束了！"",""HALF PAST TEN"",MB_OK);              //牌不够，游戏结束
			int flag=MessageBox(NULL,TEXT(""是否再来一局""),TEXT(""HALF PAST TEN""),MB_OKCANCEL);
				if(flag==IDOK){
					count=0;
					return 1;
					//DoPreparePrinting(pInfo);
				}
				//此处添加是否重来一局
				else return 0;
		}
		Calculate();            //每一局都实时计算得分
		//MessageBox(NULL,""显示牌："",""HALF PAST TEN"",MB_OK); 
	//	CardShow();
	//	RankShow();
}
//降序

void Managers::BubbleSort(){                   
	bool noswap;
	int i,j;
	player temp;
	for(i=0;i<Player-1;i++){
		noswap=true;
		for(j=Player-1;j>i;j--){
			if(play[j].Power>play[j-1].Power){
				temp=play[j];
				play[j]=play[j-1];
				play[j-1]=temp;
				noswap=false;
			}
		}
		if(noswap)break;
	}
}

void Managers::Add_BubbleSort(){
	bool noswap;
	int i,j;
	player temp;
	for(i=0;i<Player-1;i++){
		noswap=true;
		for(j=Player-1;j>i;j--){
			if(play[j].add<play[j-1].add){
				temp=play[j];
				play[j]=play[j-1];
				play[j-1]=temp;
				noswap=false;
			}
		}
		if(noswap)break;
	}
}

void Managers::Ranking(){
	int rank1 = 1;	
	//输出第一名 
	play[0].rank=rank1;
	for(int i = 1;i< Player;i++){		
		if( i>=1 && play[i].Power == play[i-1].Power){
			play[i].rank=rank1;
		}
		else{
			rank1 = i+1;
			play[i].rank=rank1;
		}
	} 
}

void Managers::Calculate(){
	if(Player==2){//两个人游戏
		double aa=0,bb=0;
		if(play[1] <10.5&&play[0]<10.5 ){//两方均不足10.5
			if(play[1]  >play[0]  ) { aa =2;bb=1;}
			else if(play[1]==play[0] ) { 
				aa =0.5;
				bb =0.5;
			}
			else  {aa =1;bb=2;}
		}
		else if(play[1]>=10.5&&play[0]<10.5){
			if(play[1]==10.5){aa=3;
			bb=1;}
			else {aa=0;bb=2;}
		}
		if(play[0]>=10.5&&play[1]<10.5){
			if(play[0]==10.5) {bb=3;
			aa=1;}
			else {bb=0;aa=2;}
		}//只有一方不足10.5
		if(play[1].num==5&&play[1]==2.5)
			aa=5;
		if(play[0].num==5&&play[0]==2.5)
			bb=5;
		if(play[1]>10.5&&play[0]>10.5){
			aa=0;
			bb=0;
		}
		if(play[1]==10.5&&play[0]==10.5){
			aa=3;
			bb=3;
		}
		play[1].Power+=aa;
		play[0].Power+=bb;
		play[1].score=aa;
		play[0].score=bb;
	}
	if(Player>=3){
		bool noswap;
		int i,j;
		player temp;
		for(i=0;i<Player;i++)
		{
			if(play[i].dian>10.5)
				play[i].dian=-1;
		}
		for(i=0;i<Player-1;i++){
			noswap=true;
			for(j=Player-1;j>i;j--){
				if(play[j].dian>play[j-1].dian){
					temp=play[j];
					play[j]=play[j-1];
					play[j-1]=temp;
					noswap=false;
				}
			}
			if(noswap)break;
		}

		int rank1 = 1;	
		play[0].rank=rank1;
		for(i = 1;i< Player;i++){
			if( i>=1 && play[i].dian == play[i-1].dian){
				play[i].rank=rank1;
			}
			else{
				rank1 = i+1;
				play[i].rank=rank1;
			}
		} 

	for(i=0;i<Player;i++){
			play[i].score=4-play[i].rank;
			if(play[i].dian==-1){
				play[i].score=0;
			}
			play[i].Power+=play[i].score;
			
		}

		BubbleSort();
		Ranking();
		Add_BubbleSort();
	}
}

",sign
460,"
#include ""object_arena.h""
#include ""../2D_tools/tools.h""
#include <iostream>

using namespace std;

// função que irá criar/ler a arena
void object_arena::ReadArena(GLfloat a_x, GLfloat a_y, GLfloat a_z, GLfloat a_height, GLfloat a_width)
{
    // dimensões
    arena_x = a_x;
    arena_y = a_y;
    arena_z = a_z;
    arena_height = a_height;
    arena_width = a_width;

    /* NÃO UTILIZADO (restante da função do trabalho2)
        //setando a cor da arena
        if (strcmp(a_color.c_str(),""blue"")==0) {
            arena_R = 0;
            arena_G = 0;
            arena_B = 1;
        } else if(strcmp(a_color.c_str(),""red"")==0) {
            arena_R = 1;
            arena_G = 0;
            arena_B = 0;
        } else if (strcmp(a_color.c_str(),""gren"")==0)  {
            arena_R = 0;
            arena_G = 1;
            arena_B = 0;
        }*/
}

/*________________________________________________________________________________________________________________________________
|Função:                                           ReadTexture                                                                    |
|---------------------------------------------------------------------------------------------------------------------------------|
|Comentários:  Adaptação de função passada pelo professor                                                                         |
|---------------------------------------------------------------------------------------------------------------------------------|
|Fonte:  bool meshes::loadTexture(string path){                                                                                   |
|        Função do laboratório  ""codigo- Animacao de Modelos ""linha +-63 do arquivo objloader.cpp""                                |
|                                                                                                                                 |
| ________________________________________________________________________________________________________________________________|*/
void object_arena::ReadTexture()
{
    cout << ""-------------------------- LOADING --------------------------"" << endl
         << endl
         << ""- loading object_arena texture..."" << endl;

    /* texturas possiveis para a arena-> hexagono-cinza,
                                        azul,
                                        preto,
                                        arco-iris,
                                        hexagono-hd,
                                        marca-stok,
                                        mma,
                                        stars1,
                                        earth,
                                        sun1

    */
    arena_textureBase = Tools::TextureTools(""../blender/texture/preto.bmp"");
    cout << ""   arena_textureBase (1/3)"" << endl;
    arena_textureSide = Tools::TextureTools(""../blender/texture/preto.bmp"");
    cout << ""   arena_textureSide (2/3)"" << endl;
    arena_textureSky = Tools::TextureTools(""../blender/texture/preto.bmp"");
    cout << ""   arena_textureSky (3/3)"" << endl;
    cout << ""  object_arena texture ok."" << endl
         << endl;
}

/*________________________________________________________________________________________________________________________________
|Função:                                           DrawArena   / DrawBase / DrawSide                                              |
|---------------------------------------------------------------------------------------------------------------------------------|
|Comentários:  Adaptação de função passada pelo professor                                                                         |
|---------------------------------------------------------------------------------------------------------------------------------|
|Fonte:  void DisplaySun e  void DisplayPlane                                                                                     |
|        Função do laboratório  terra sol ""linha +-126 do arquivo terrasol.cpp""                                                   |
|                                                                                                                                 |
| ________________________________________________________________________________________________________________________________|*/
void object_arena::DrawArena()
{
    glColor3f(arena_color[0], arena_color[1], arena_color[2]);

    glMaterialfv(GL_FRONT, GL_AMBIENT, arena_matAmbient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, arena_matDiffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, arena_matSpecular);
    glMaterialfv(GL_FRONT, GL_EMISSION, arena_matEmission);
    glMaterialfv(GL_FRONT, GL_SHININESS, arena_matShininess);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // X
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Y

    glPushMatrix();
    glTranslatef(arena_x, arena_y, arena_z);
    DrawBase(arena_textureBase, {0, 1, 0}, arena_width, arena_height, 100);

    glTranslatef(arena_width / 2, 0, arena_height / 2);
    glDisable(GL_LIGHTING);
    if (arena_side)
    {
        DrawSide(arena_textureSide, arena_width, arena_height, 100);
    }
    DrawSky(arena_textureSky, arena_height * 2);
    glEnable(GL_LIGHTING);

    glPopMatrix();
}

// baseado na função acima
void object_arena::DrawBase(GLuint a_texture, norm a_normal, GLfloat a_width, GLfloat a_height, int calc)
{
    glBindTexture(GL_TEXTURE_2D, a_texture);

    int i, j;
    GLfloat widthS = a_width / (GLfloat)calc;
    GLfloat heightS = a_height / (GLfloat)calc;
    GLfloat textureS = (GLfloat)3 / calc; // Bigger than 1, repeat
    GLfloat tj,  [MASK] ;
    GLfloat ti, t2i;
    GLfloat h, h2;
    GLfloat w, w2;
    for (i = 0; i < calc; i++)
    {
        for (j = 0; j < calc; j++)
        {
            glBegin(GL_QUADS);
            tj = (GLfloat)j * textureS;
            ti = (GLfloat)i * textureS;
            h = (GLfloat)i * heightS;
            w = (GLfloat)j * widthS;

            t2i = (GLfloat)(i + 1) * textureS;
             [MASK]  = (GLfloat)(j + 1) * textureS;
            h2 = (GLfloat)(i + 1) * heightS;
            w2 = (GLfloat)(j + 1) * widthS;

            Tools::ntvTools(a_normal.x, a_normal.y, a_normal.z, tj, ti, w, 0, h);
            Tools::ntvTools(a_normal.x, a_normal.y, a_normal.z, tj, t2i, w, 0, h2);
            Tools::ntvTools(a_normal.x, a_normal.y, a_normal.z,  [MASK] , t2i, w2, 0, h2);
            Tools::ntvTools(a_normal.x, a_normal.y, a_normal.z,  [MASK] , ti, w2, 0, h);

            glEnd();
        }
    }
}

// baseado na função acima
void object_arena::DrawSide(GLuint a_texture, GLfloat a_width, GLfloat a_height, int calc)
{
    glPushMatrix();

    GLfloat widthS = a_width / (GLfloat)2;
    GLfloat heightS = a_height / (GLfloat)2;
    GLfloat aux_w = -widthS;
    GLfloat aux_h = -heightS;

    GLfloat p = (GLfloat)1.0;
    GLfloat n = (GLfloat)-1.0;

    GLfloat zero = (GLfloat)0.0;

    GLfloat textureS = 2; // Bigger than 1, repeat

    GLfloat no_mat[] = {100, 100, 100, 100};
    glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
    glBindTexture(GL_TEXTURE_2D, a_texture);

    glBegin(GL_QUADS);
    // lado 1/4

    Tools::ntvTools(n, zero, zero, zero, zero, widthS, 0, aux_h);
    Tools::ntvTools(n, zero, zero, textureS, zero, widthS, 0, heightS);
    Tools::ntvTools(n, zero, zero, textureS, p, widthS, 70, heightS);
    Tools::ntvTools(n, zero, zero, zero, p, widthS, 70, aux_h);

    // lado 2/4
    Tools::ntvTools(p, zero, zero, zero, zero, aux_w, 0, aux_h);
    Tools::ntvTools(p, zero, zero, textureS, zero, aux_w, 0, heightS);
    Tools::ntvTools(p, zero, zero, textureS, p, aux_w, 70, heightS);
    Tools::ntvTools(p, zero, zero, zero, p, aux_w, 70, aux_h);

    // lado 3/4
    Tools::ntvTools(zero, zero, n, zero, zero, aux_w, 0, heightS);
    Tools::ntvTools(zero, zero, n, textureS, zero, widthS, 0, heightS);
    Tools::ntvTools(zero, zero, n, textureS, p, widthS, 70, heightS);
    Tools::ntvTools(zero, zero, n, zero, p, aux_w, 70, heightS);

    // lado 4/4
    Tools::ntvTools(zero, zero, p, zero, zero, aux_w, 0, aux_h);
    Tools::ntvTools(zero, zero, p, textureS, zero, widthS, 0, aux_h);
    Tools::ntvTools(zero, zero, p, textureS, p, widthS, 70, aux_h);
    Tools::ntvTools(zero, zero, p, zero, p, aux_w, 70, aux_h);

    glEnd();

    glPopMatrix();
}

// void DisplayPlane (GLuint texture) - terrasol
void object_arena::DrawSky(GLuint a_texture, GLfloat a_size)
{
    glBindTexture(GL_TEXTURE_2D, a_texture);

    glPushMatrix();

    GLfloat aux_s = -a_size;
    GLfloat p = (GLfloat)1.0;
    GLfloat n = (GLfloat)-1.0;
    GLfloat zero = (GLfloat)0.0;
    for (int i = 0; i < 3; i++)
    {
        if (i == 1)
        {
            glRotatef(90, 1, 0, 0);
        }
        else if (i == 2)
        {
            glRotatef(90, 0, 0, 1);
        }
        glBegin(GL_QUADS);

        // lado 1/2
        Tools::ntvTools(zero, p, zero, zero, zero, aux_s, aux_s, aux_s);
        Tools::ntvTools(zero, p, zero, zero, p, aux_s, aux_s, a_size);
        Tools::ntvTools(zero, p, zero, p, p, a_size, aux_s, a_size);
        Tools::ntvTools(zero, p, zero, p, zero, a_size, aux_s, aux_s);

        // lado 2/2
        Tools::ntvTools(zero, n, zero, zero, zero, aux_s, a_size, aux_s);
        Tools::ntvTools(zero, n, zero, zero, p, aux_s, a_size, a_size);
        Tools::ntvTools(zero, n, zero, p, p, a_size, a_size, a_size);
        Tools::ntvTools(zero, n, zero, p, zero, a_size, a_size, aux_s);

        glEnd();
    }

    glPopMatrix();
}
",t2j
461,"#include ""./LinearSystemSolver.hpp""


namespace ConsensusProblem {
	template <typename DT, typename MTRX>
	std::vector<Rule*> LinearSystemSolver<DT, MTRX>::findApplicableRules(
		const std::vector<short> states,
		const short rulesCount,
		Rule* const* rules
	) const {
		std::vector<Rule*> applicableRules;
		for (short i = 0; i < rulesCount; ++i) {
			if (!rules[i]->isApplicable(&states[0])) continue;
			applicableRules.push_back(rules[i]);
		}
		return applicableRules;
	}

	template <typename DT, typename MTRX>
	void LinearSystemSolver<DT, MTRX>::buildRec(
		const std::vector<short> states,
		const short rulesCount,
		Rule* const* rules,
		std::map<std::vector<short>, std::vector<Rule*>>* rulesByStates
	) const {
		std::vector<Rule*> applicableRules = findApplicableRules(states, rulesCount, rules);
		(*rulesByStates)[states] = applicableRules;
		for (short i = 0; i < applicableRules.size(); ++i) {
			Rule* rule = applicableRules[i];
			// copy states
			std::vector<short> newStates = states;
			// apply rule
			rule->apply(&newStates[0]);
			if (rulesByStates->contains(newStates)) continue;
			buildRec(newStates, rulesCount, rules, rulesByStates);
		}
	}

	template <typename DT, typename MTRX>
	DT LinearSystemSolver<DT, MTRX>::solve(
		const short statesCount,
		const short* targetStates,
		const short* startingStates,
		const short rulesCount,
		Rule* const* rules
	) const {
		std::vector<short> targetStatesVec(statesCount);
		std::vector<short> startingStatesVec(statesCount);
		std::copy(targetStates, targetStates + statesCount, targetStatesVec.begin());
		std::copy(startingStates, startingStates + statesCount, startingStatesVec.begin());

		std::map<std::vector<short>, std::vector<Rule*>> rulesByStates;
		int total = 0;
		for (short i = 0; i < statesCount; ++i) {
			total += startingStates[i];
		}
		int contot = total * (total - 1) / 2;
		// will be used to build the linear system

		std::vector<short> states(startingStates, startingStates + statesCount);
		this->buildRec(states, rulesCount, rules, &rulesByStates);
		// std::cout << ""--------- DEBUG ----------"" << std::endl;
		// for (auto it = rulesByStates.begin(); it != rulesByStates.end(); ++it) {
			
		// 	for (short i = 0; i < it->first.size(); ++i) {
		// 		std::cout << it->first[i] << "" "";
		// 	}
		// 	std::cout << "" : "";
		// 	for (short i = 0; i < it->second.size(); ++i) {
		// 		double chance = (it->first[it->second[i]->before[0]]*it->first[it->second[i]->before[1]]) / double(contot);
		// 		std::cout << it->second[i]->before[0] << ',' << it->second[i]->before[1] << "" -> "" << it->second[i]->after[0] << ',' << it->second[i]->after[1] << ""("" << chance << "") |"";
		// 	}
		// 	std::cout << std::endl;
		// }
		// std::cout << ""states: "" << states.size() << std::endl;
		std::vector<std::vector<short>> variableDecoder;
		std::map<std::vector<short>, int> variableEncoder;
		for (auto it = rulesByStates.begin(); it != rulesByStates.end(); ++it) {
			
			variableDecoder.push_back(it->first);
			const int variableId = variableDecoder.size() - 1;
			variableEncoder[it->first] = variableId;
			// std::cout << variableId << "".\t"";
			// for (short i = 0; i < it->first.size(); ++i) {
			// 	std::cout << it->first[i] << "" "";
			// }
			// std::cout << "" : "";
			// for (short i = 0; i < it->second.size(); ++i) {
			// 	double chance = (it->first[it->second[i]->before[0]]*it->first[it->second[i]->before[1]]) / double(contot);
			// 	std::cout << it->second[i]->before[0] << ',' << it->second[i]->before[1] << "" -> "" << it->second[i]->after[0] << ',' << it->second[i]->after[1] << ""("" << chance << "") |"";
			// }
			// std::cout << std::endl;

		}

		const int variablesCount = rulesByStates.size();
		LinearSystem<DT> linearSystem(
			LinearSystemSize(variablesCount, variablesCount),
			MTRX::zero(MatrixSize(variablesCount, variablesCount)),
			new DT[](variablesCount)
		);
		std::fill(linearSystem.constants, linearSystem.constants + variablesCount, 0);
		for (auto it = rulesByStates.begin(); it != rulesByStates.end(); ++it) {
			const std::vector<short>& states = it->first;
			const int mainVariableId = variableEncoder[states];
			(*linearSystem.coefficients)(mainVariableId, mainVariableId) = 1;
			const std::vector<Rule*>& rules = it->second;
			// iterate over all rules
			double chanceLeft = 1;
			for (const Rule* rule : rules) {
				std::vector<short> newStates = states;
				(*rule).apply(&newStates[0]);
				const int newVariableId = variableEncoder[newStates];

				int contot = total * (total - 1) / 2;
				double chance = (states[rule->before[0]]*states[rule->before[1]]) / double(contot);
				chanceLeft -= chance;
				(*linearSystem.coefficients)(mainVariableId, newVariableId) -= chance;

				// (*linearSystem.coefficients)(rule->before[0], rule->before[1]) += 1;
				// (*linearSystem.coefficients)(rule->after[0], rule->after[1]) -= 1;
			}
			if(rules.size()) (*linearSystem.coefficients)(mainVariableId, mainVariableId) -= chanceLeft;
			
		}
		const int targetStatesVariableId = variableEncoder[targetStatesVec];
		const int  [MASK]  = variableEncoder[startingStatesVec];
		linearSystem.constants[targetStatesVariableId] = 1;
		// print the linear system
		// std::cout << ""Linear system:"" << std::endl;
		// std::cout << ""\t"";
		// for (int x = 0; x < variablesCount; ++x) {
		// 	std::cout << ""p"" << variableDecoder[x][0] << variableDecoder[x][2] << ""\t"";
		// }
		// std::cout << std::endl;
		// for (int y = 0; y < variablesCount; ++y) {
		// 	std::cout << ""p"" << variableDecoder[y][0] << variableDecoder[y][2] << ""\t"";
		// 	for (int x = 0; x < variablesCount; ++x) {
		// 		std::cout << (*linearSystem.coefficients)(y, x) << ""\t"";
		// 	}
		// 	std::cout << ""|\t"" << linearSystem.constants[y] << std::endl;
		// }
		// solve the linear system
		DT solution[variablesCount];
		this->solver->solve(linearSystem, solution);
		// std::cout << ""Linear system solved:"" << std::endl;
		// // print the linear system
		// for (int y = 0; y < variablesCount; ++y) {
		// 	for (int x = 0; x < variablesCount; ++x) {
		// 		std::cout << (*linearSystem.coefficients)(y, x) << ""\t"";
		// 	}
		// 	std::cout << ""|\t"" << linearSystem.constants[y] << std::endl;
		// }
		// // print the solution
		// std::cout << ""Solution:"" << std::endl;
		// for (int x = 0; x < variablesCount; ++x) {
		// 	std::cout << ""p"" << variableDecoder[x][0] << variableDecoder[x][2] << "" = "" << solution[x] << std::endl;
		// }

	
		return solution[ [MASK] ];
	}

	template <typename DT, typename MTRX>
	LinearSystemSolver<DT, MTRX>::LinearSystemSolver(
		const Numalg::LinearSystemSolver<DT>* solver
	) :
		solver(solver) {
	}
}
",startingStatesVariableId
462,"#include <cmath>
#include <iostream>

using namespace std;

// Global variables
#define NMAX 100
#define TOLERANCE 0.00001
#define EXACTITUDEC 0.00005

// Actual Function to use
double F(double x) {
    return 3 * pow(x, 3) - 2 * x - 5;
}

/*
* Bisection method 
* a -> lower end
* b -> upper end
* MAXIT -> maximum number of iterations of the algorithm
* TOL -> tolerance of the program to the error
* EX -> exactitude criteria
*/
double bisection(double a, double b, bool  [MASK] ) {
    if (! [MASK] )
        printf(""# iter\t\t x\t\t\t f(x)\t\t\t error\t\t\t \n"");
    int iteration = 1;
    double c;
    double fc;
    while (iteration < NMAX) {
        c = (a + b) / 2;
        fc = F(c);
        if (abs(b - a) < TOLERANCE)
            return c;
        if (abs(fc) < EXACTITUDEC)
            return c;
        if (F(a) * fc < 0)
            b = c;
        if (fc * F(b) < 0)
            a = c;

        if (! [MASK] )
            printf(""%d\t\t\n"", iteration);
        iteration++;
    }
    return c;
}

int main(int argc, char *argv[]) {
    double lowerEnd = 0;
    double upperEnd = 2;
    double result = bisection(lowerEnd, upperEnd, true);
    printf(""The root of the function between [%f, %f] is: %f"", lowerEnd, upperEnd, result);
    return 0;
}",test
463,"#include ""Application.h""

int Application::getEncryptionChoice()
{
	int choice = 0;
	print(""Which cipher do you want now ? "");
	std::cin >> choice;
	if (isWithInTheRange(choice, 1, 7))
	{
		return choice;
	}
	return 0;
}

int Application::getMainMenuChoice()
{
	int choice = 0;
	print(""What are you about to do ? "");
	std::cin >> choice;
	if (isWithInTheRange(choice, 1, 3))
	{
		return choice;
	}
	return 0;
}

int Application::getInputChoice()
{
	int choice = 0;
	print(""How can I get the input ? "");
	std::cin >> choice;
	if (isWithInTheRange(choice, 1, 2))
	{
		return choice;
	}
	return 0;
}

std::string *Application::getInputInfo()
{
	showInputOptions();
	int inputForm = getInputChoice();
	while (inputForm == 0)
	{
		printNextLine();
		println(""Try to give input from the available options."");
		printNextLine();
		showInputOptions();
		inputForm = getInputChoice();
	}
	std::string *input;
	if (inputForm == 1)
	{
		input = new std::string;
		printNextLine();
		println(""Please end your message with a backtick symbol (`) "");
		std::getline(std::cin, *input, '`');
	}
	else
	{
		printNextLine();
		std::string filedir = getFileInfo();
		FileHandler file;
		input = file.readFromFile(filedir);
	}
	return input;
}

std::string Application::getFileInfo()
{
	std::string filedir, filename;
	std::cin.ignore();
	print(""Where do you want to save the file at ? "");
	std::getline(std::cin, filedir, '\n');
	print(""What should be the file name ? "");
	std::getline(std::cin, filename, '\n');
	if (!filedir.empty())
	{
		filedir.push_back('\\');
	}
	filedir.append(filename);
	return filedir;
}

CipherEncryption *Application::getSuitableCipher(int options)
{
	CipherEncryption *cipher;
	switch (options)
	{
	case 1:
		cipher = new BitwiseCipherEncryption;
		break;
	case 2:
	{
		std::string key = ""<&Programming is real fun&/>"";
		cipher = new BlockCipherEncryption(key);
		break;
	}
	case 3:
		cipher = new CaesarCipherEncryption;
		break;
	case 4:
		cipher = new StreamCipherEncryption;
		break;
	case 5:
		cipher = new TransposeCipherEncryption;
		break;
	case 6:
		cipher = new VigenereCipherEncryption;
		break;
	default:
	{
		char key = static_cast<char>(27);
		cipher = new XorCipherEncryption(key);
	}
	}
	return cipher;
}

void Application::showEncryptionOptions()
{
	println(""Types of ciphers available : "");
	println(""1 > Bitwise"");
	println(""2 > Block"");
	println(""3 > Caesar"");
	println(""4 > Stream"");
	println(""5 > Transpose"");
	println(""6 > Vigenere"");
	println(""7 > Xor (Exclusive OR)"");
}

void Application::showMainMenu()
{
	println(""What to do now ?"");
	println(""1 > Encryption"");
	println(""2 > Decryption"");
	println(""3 > Exit"");
}

void Application::showInputOptions()
{
	println(""How are you going to enter the information ?"");
	println(""1 > Type it now"");
	println(""2 > Retrieve it from a existing file"");
}

void Application::showEncryptedMessage(std::string *message)
{
	println(""Here is your encrypted message : "");
	println(message);
}

void Application::showDecryptedCipher(std::string *message)
{
	println(""Here is your decrypted cipher text : "");
	println(message);
}

void Application::saveInfoToFile(std::string *content)
{
	std::string filedir = getFileInfo();
	FileHandler file;
	file.writeToFile(filedir, content);
	print(""Happy to inform you that file is saved at "");
	println(filedir);
}

void Application::manageEncryption()
{
	showEncryptionOptions();
	int encryptionChoice = getEncryptionChoice();
	while (encryptionChoice == 0)
	{
		printNextLine();
		println(""Try to choose an available cipher option."");
		printNextLine();
		showEncryptionOptions();
		encryptionChoice = getEncryptionChoice();
	}
	printNextLine();
	std::string *message = getInputInfo();
	CipherEncryption *cipher = getSuitableCipher(encryptionChoice);
	std::string *encrypted = cipher->encrypt(*message);
	printNextLine();
	char seeEncrypted = 0;
	print(""Do you want to see encrypted message ? (Y/n) "");
	std::cin >> seeEncrypted;
	if (areTheSame(seeEncrypted, 'Y') || areTheSame(seeEncrypted, 'y'))
	{
		printNextLine();
		showEncryptedMessage(encrypted);
	}
	printNextLine();
	char saveEncrypted = 0;
	print(""Do you want to save encrypted message ? (Y/n) "");
	std::cin >> saveEncrypted;
	if (areTheSame(saveEncrypted, 'Y') || areTheSame(saveEncrypted, 'y'))
	{
		printNextLine();
		saveInfoToFile(encrypted);
	}
	delete message;
	delete encrypted;
	delete cipher;
}

void Application::manageDecryption()
{
	std::string *message = getInputInfo();
	std::string key = message->substr(message->size() - 3, 3);
	int type = 0;
	if (areTheSame(&key, std::string(""0x0"")))
	{
		type = 1;
	}
	else if (areTheSame(&key, std::string(""1x1"")))
	{
		type = 2;
	}
	else if (areTheSame(&key, std::string(""2x2"")))
	{
		type = 3;
	}
	else if (areTheSame(&key, std::string(""3x3"")))
	{
		type = 4;
	}
	else if (areTheSame(&key, std::string(""4x4"")))
	{
		type = 5;
	}
	else if (areTheSame(&key, std::string(""5x5"")))
	{
		type = 6;
	}
	else if (areTheSame(&key, std::string(""6x6"")))
	{
		type = 7;
	}
	else
	{
		printNextLine();
		println(""Your cipher text does not match the onces provided by us."");
		printNextLine();
		return;
	}
	*message = message->substr(0, message->size() - 3);
	CipherEncryption *cipher = getSuitableCipher(type);
	std::string *decrypted = cipher->decrypt(*message);
	printNextLine();
	char seeDecrypted = 0;
	print(""Do you want to see decrypted message ? (Y/n) "");
	std::cin >> seeDecrypted;
	if (areTheSame(seeDecrypted, 'Y') || areTheSame(seeDecrypted, 'y'))
	{
		printNextLine();
		showDecryptedCipher(decrypted);
	}
	printNextLine();
	char saveDecrypted = 0;
	print(""Do you want to save decrypted message ? (Y/n) "");
	std::cin >> saveDecrypted;
	if (areTheSame(saveDecrypted, 'Y') || areTheSame(saveDecrypted, 'y'))
	{
		printNextLine();
		saveInfoToFile(decrypted);
	}
	delete cipher;
	delete decrypted;
	delete message;
}

void Application::showEndCredits()
{
	clearScreen();
	std::string title = ""Project done by the following students of XII - A :"";
	std::string decoration(title.size(), '~');
	printHeading(title, decoration);
	printLines(3);
	printcnt(""<NAME>, Roll No : 2"");
	printcnt(""<NAME>, Roll No : 3"");
	printcnt(""<NAME>, Roll No : 20"");
	printcnt(""<NAME>, Roll No : 40"");
	printLines(3);
}

void Application::runApp()
{
	char choice = 0;
	int  [MASK]  = 0;
	bool wantsToContinue = false;
	std::string projectTitle = ""Cipher Encryption"";
	std::string decoration(projectTitle.size(), '*');
	do
	{
		printHeading(projectTitle, decoration);
		printNextLine();
		showMainMenu();
		 [MASK]  = getMainMenuChoice();
		while ( [MASK]  == 0)
		{
			printNextLine();
			println(""Try to follow the given instructions."");
			printNextLine();
			showMainMenu();
			 [MASK]  = getMainMenuChoice();
		}
		printNextLine();
		switch ( [MASK] )
		{
		case 1:
			manageEncryption();
			break;
		case 2:
			manageDecryption();
			break;
		default:
			showEndCredits();
			return;
		}
		printNextLine();
		print(""Do you want to continue ? (Y/n) "");
		std::cin >> choice;
		wantsToContinue = areTheSame(choice, 'Y') || areTheSame(choice, 'y');
		if (wantsToContinue)
		{
			clearScreen();
		}
	} while (wantsToContinue);
	showEndCredits();
}",menuChoice
464,"/*
    opengametools vox file reader/writer/merger - v0.997 - MIT license - <NAME>, Oct 2019

    This is a single-header-file library that provides easy-to-use
    support for reading MagicaVoxel .vox files into structures that
    are easy to dereference and extract information from. It also
    supports writing back out to .vox file from those structures.

    Please see the MIT license information at the end of this file.

    Also, please consider sharing any improvements you make.

    For more information and more tools, visit:
      https://github.com/jpaver/opengametools

    HOW TO COMPILE THIS LIBRARY

    1.  To compile this library, do this in *one* C or C++ file:
        #define OGT_VOX_IMPLEMENTATION
        #include ""ogt_vox.h""

    2. From any other module, it is sufficient to just #include this as usual:
        #include ""ogt_vox.h""

    HOW TO READ A VOX SCENE (See demo_vox.cpp)

    1. load a .vox file off disk into a memory buffer.

    2. construct a scene from the memory buffer:
       ogt_vox_scene* scene = ogt_vox_read_scene(buffer, buffer_size);

    3. use the scene members to extract the information you need. eg.
       printf(""# of layers: %u\n"", scene->num_layers );

    4. destroy the scene:
       ogt_vox_destroy_scene(scene);

    HOW TO MERGE MULTIPLE VOX SCENES (See merge_vox.cpp)

    1. construct multiple scenes from files you want to merge.

        // read buffer1/buffer_size1 from ""test1.vox""
        // read buffer2/buffer_size2 from ""test2.vox""
        // read buffer3/buffer_size3 from ""test3.vox""
        ogt_vox_scene* scene1 = ogt_vox_read_scene(buffer1, buffer_size1);
        ogt_vox_scene* scene2 = ogt_vox_read_scene(buffer2, buffer_size2);
        ogt_vox_scene* scene3 = ogt_vox_read_scene(buffer3, buffer_size3);

    2. construct a merged scene

        const ogt_vox_scene* scenes[] = {scene1, scene2, scene3};
        ogt_vox_scene* merged_scene = ogt_vox_merge_scenes(scenes, 3, NULL, 0);

    3. save out the merged scene

        uint8_t* out_buffer = ogt_vox_write_scene(merged_scene, &out_buffer_size);
        // save out_buffer to disk as a .vox file (it has length out_buffer_size)

    4. destroy the merged scene:

        ogt_vox_destroy_scene(merged_scene);

    EXPLANATION OF SCENE ELEMENTS:

    A ogt_vox_scene comprises primarily a set of instances, models, layers and a palette.

    A ogt_vox_palette contains a set of 256 colors that is used for the scene.
    Each color is represented by a 4-tuple called an ogt_vox_rgba which contains red,
    green, blue and alpha values for the color.

    A ogt_vox_model is a 3-dimensional grid of voxels, where each of those voxels
    is represented by an 8-bit color index. Voxels are arranged in order of increasing
    X then increasing Y then increasing Z.

    Given the x,y,z values for a voxel within the model dimensions, the voxels index
    in the grid can be obtained as follows:

        voxel_index = x + (y * model->size_x) + (z * model->size_x * model->size_y)

    The index is only valid if the coordinate x,y,z satisfy the following conditions:
            0 <= x < model->size_x -AND-
            0 <= y < model->size_y -AND-
            0 <= z < model->size_z

    A voxels color index can be obtained as follows:

        uint8_t color_index = model->voxel_data[voxel_index];

    If color_index == 0, the voxel is not solid and can be skipped,
    If color_index != 0, the voxel is solid and can be used to lookup the color in the palette:

        ogt_vox_rgba color = scene->palette.color[ color_index]

    A ogt_vox_instance is an individual placement of a voxel model within the scene. Each
    instance has a transform that determines its position and orientation within the scene,
    but it also has an index that specifies which model the instance uses for its shape. It
    is expected that there is a many-to-one mapping of instances to models.

    An ogt_vox_layer is used to conceptually group instances. Each instance indexes the
    layer that it belongs to, but the layer itself has its own name and hidden/shown state.

    EXPLANATION OF MERGED SCENES:

    A merged scene contains all the models and all the scene instances from
    each of the scenes that were passed into it.

    The merged scene will have a combined palette of all the source scene
    palettes by trying to match existing colors exactly, and falling back
    to an RGB-distance matched color when all 256 colors in the merged
    scene palette has been allocated.

    You can explicitly control up to 255 merge palette colors by providing
    those colors to ogt_vox_merge_scenes in the required_colors parameters eg.

        const ogt_vox_palette palette;  // load this via .vox or procedurally or whatever
        const ogt_vox_scene* scenes[] = {scene1, scene2, scene3};
        // palette.color[0] is always the empty color which is why we pass 255 colors starting from index 1 only:
        ogt_vox_scene* merged_scene = ogt_vox_merge_scenes(scenes, 3, &palette.color[1], 255);

    EXPLANATION OF MODEL PIVOTS

    If a voxel model grid has dimension size.xyz in terms of number of voxels, the centre pivot
    for that model is located at floor( size.xyz / 2).

    eg. for a 3x4x1 voxel model, the pivot would be at (1,2,0), or the X in the below ascii art.

           4 +-----+-----+-----+
             |  .  |  .  |  .  |
           3 +-----+-----+-----+
             |  .  |  .  |  .  |
           2 +-----X-----+-----+
             |  .  |  .  |  .  |
           1 +-----+-----+-----+
             |  .  |  .  |  .  |
           0 +-----+-----+-----+
             0     1     2     3

     An example model in this grid form factor might look like this:

           4 +-----+-----+-----+
             |  .  |  .  |  .  |
           3 +-----+-----+-----+
                   |  .  |
           2       X-----+
                   |  .  |
           1       +-----+
                   |  .  |
           0       +-----+
             0     1     2     3

     If you were to generate a mesh from this, clearly each vertex and each face would be on an integer
     coordinate eg. 1, 2, 3 etc. while the centre of each grid location (ie. the . in the above diagram)
     will be on a coordinate that is halfway between integer coordinates. eg. 1.5, 2.5, 3.5 etc.

     To ensure your mesh is properly centered such that instance transforms are correctly applied, you
     want the pivot to be treated as if it were (0,0,0) in model space. To achieve this, simply
     subtract the pivot from any geometry that is generated (eg. vertices in a mesh).

     For the 3x4x1 voxel model above, doing this would look like this:

           2 +-----+-----+-----+
             |  .  |  .  |  .  |
           1 +-----+-----+-----+
                   |  .  |
           0       X-----+
                   |  .  |
          -1       +-----+
                   |  .  |
          -2       +-----+
            -1     0     1     2

    To replace asserts within this library with your own implementation, simply #define ogt_assert before defining your implementation
    eg.
        #include ""my_assert.h""
        #define ogt_assert(condition, message_str)    my_assert(condition, message_str)

        #define OGT_VOX_IMPLEMENTATION
        #include ""path/to/ogt_vox.h""

    ogt_vox is little-endian by default, but it does support big-endian if OGT_VOX_BIGENDIAN_SWAP32(x) is #defined
    to a function that can swap byte order within a uint32_t word before the implementation. eg.

        #define OGT_VOX_BIGENDIAN_SWAP32(x)  __builtin_swap32(x)  // linux/gcc
        #define OGT_VOX_IMPLEMENTATION
        #include ""path/to/ogt_vox.h""
*/
#ifndef OGT_VOX_H__
#define OGT_VOX_H__

#if _MSC_VER == 1400
// VS2005 doesn't have inttypes or stdint so we just define what we need here.
typedef unsigned char uint8_t;
typedef signed int    int32_t;
typedef unsigned int  uint32_t;
#ifndef UINT32_MAX
#define UINT32_MAX	((uint32_t)0xFFFFFFFF)
#endif
#ifndef INT32_MAX
#define INT32_MAX	((int32_t)0x7FFFFFFF)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX	((uint8_t)0xFF)
#endif
#elif defined(_MSC_VER)
// general VS*
#include <inttypes.h>
#elif __APPLE__
// general Apple compiler
#include <stdint.h>
#include <limits.h>
#include <stdlib.h> // for size_t
#elif defined(__GNUC__)
// any GCC*
#include <inttypes.h>
#include <stdlib.h> // for size_t
#else
#error some fixup needed for this platform?
#endif

#ifdef OGT_VOX_BIGENDIAN_SWAP32
// host is big-endian, so we byte-swap
#define _vox_htole32(x)  OGT_VOX_BIGENDIAN_SWAP32((x))
#define _vox_le32toh(x)  OGT_VOX_BIGENDIAN_SWAP32((x))
#else
// host is little-endian (default)
#define _vox_htole32(x)  (x)
#define _vox_le32toh(x)  (x)
#endif

    // denotes an invalid group index. Usually this is only applicable to the scene's root group's parent.
static const uint32_t k_invalid_group_index = UINT32_MAX;

// color
typedef struct ogt_vox_rgba
{
    uint8_t r, g, b, a;            // red, green, blue and alpha components of a color.
} ogt_vox_rgba;

// column-major 4x4 matrix
typedef struct ogt_vox_transform
{
    float m00, m01, m02, m03;   // column 0 of 4x4 matrix, 1st three elements = x axis vector, last element always 0.0
    float m10, m11, m12, m13;   // column 1 of 4x4 matrix, 1st three elements = y axis vector, last element always 0.0
    float m20, m21, m22, m23;   // column 2 of 4x4 matrix, 1st three elements = z axis vector, last element always 0.0
    float m30, m31, m32, m33;   // column 3 of 4x4 matrix. 1st three elements = translation vector, last element always 1.0
} ogt_vox_transform;

ogt_vox_transform ogt_vox_transform_get_identity();
ogt_vox_transform ogt_vox_transform_multiply(const ogt_vox_transform& a, const ogt_vox_transform& b);

// a palette of colors
typedef struct ogt_vox_palette
{
    ogt_vox_rgba color[256];      // palette of colors. use the voxel indices to lookup color from the palette.
} ogt_vox_palette;

// Extended Material Chunk MATL types
enum ogt_matl_type
{
    ogt_matl_type_diffuse = 0, // diffuse is default
    ogt_matl_type_metal = 1,
    ogt_matl_type_glass = 2,
    ogt_matl_type_emit = 3,
    ogt_matl_type_blend = 4,
    ogt_matl_type_media = 5,
};

enum ogt_cam_mode
{
    ogt_cam_mode_perspective = 0,
    ogt_cam_mode_free = 1,
    ogt_cam_mode_pano = 2,
    ogt_cam_mode_orthographic = 3,
    ogt_cam_mode_isometric = 4,
    ogt_cam_mode_unknown = 5
};

// Content Flags for ogt_vox_matl values for a given material
static const uint32_t k_ogt_vox_matl_have_metal = 1 << 0;
static const uint32_t k_ogt_vox_matl_have_rough = 1 << 1;
static const uint32_t k_ogt_vox_matl_have_spec = 1 << 2;
static const uint32_t k_ogt_vox_matl_have_ior = 1 << 3;
static const uint32_t k_ogt_vox_matl_have_att = 1 << 4;
static const uint32_t k_ogt_vox_matl_have_flux = 1 << 5;
static const uint32_t k_ogt_vox_matl_have_emit = 1 << 6;
static const uint32_t k_ogt_vox_matl_have_ldr = 1 << 7;
static const uint32_t k_ogt_vox_matl_have_trans = 1 << 8;
static const uint32_t k_ogt_vox_matl_have_alpha = 1 << 9;
static const uint32_t k_ogt_vox_matl_have_d = 1 << 10;
static const uint32_t k_ogt_vox_matl_have_sp = 1 << 11;
static const uint32_t k_ogt_vox_matl_have_g = 1 << 12;
static const uint32_t k_ogt_vox_matl_have_media = 1 << 13;

// Extended Material Chunk MATL information
typedef struct ogt_vox_matl
{
    uint32_t      content_flags; // set of k_ogt_vox_matl_* OR together to denote contents available
    ogt_matl_type type;
    float         metal;
    float         rough;
    float         spec;
    float         ior;
    float         att;
    float         flux;
    float         emit;
    float         ldr;
    float         trans;
    float         alpha;
    float         d;
    float         sp;
    float         g;
    float         media;
} ogt_vox_matl;

// Extended Material Chunk MATL array of materials
typedef struct ogt_vox_matl_array
{
    ogt_vox_matl matl[256];      // extended material information from Material Chunk MATL
} ogt_vox_matl_array;

typedef struct ogt_vox_cam
{
    uint32_t     camera_id;
    ogt_cam_mode mode;
    float        focus[3];    // the target position
    float        angle[3];    // rotation in degree
    int          radius;
    float        frustum;
    int          fov;         // angle in degree
} ogt_vox_cam;

// a 3-dimensional model of voxels
typedef struct ogt_vox_model
{
    uint32_t       size_x;        // number of voxels in the local x dimension
    uint32_t       size_y;        // number of voxels in the local y dimension
    uint32_t       size_z;        // number of voxels in the local z dimension
    uint32_t       voxel_hash;    // hash of the content of the grid.
    const uint8_t* voxel_data;    // grid of voxel data comprising color indices in x -> y -> z order. a color index of 0 means empty, all other indices mean solid and can be used to index the scene's palette to obtain the color for the voxel.
} ogt_vox_model;

// a keyframe for animation of a transform
typedef struct ogt_vox_keyframe_transform {
    uint32_t          frame_index;
    ogt_vox_transform transform;
} ogt_vox_keyframe_transform;

// a keyframe for animation of a model
typedef struct ogt_vox_keyframe_model {
    uint32_t frame_index;
    uint32_t model_index;
} ogt_vox_keyframe_model;

// an animated transform
typedef struct ogt_vox_anim_transform {
    const ogt_vox_keyframe_transform* keyframes;
    uint32_t                          num_keyframes;
    bool                              loop;
} ogt_vox_anim_transform;

// an animated model
typedef struct ogt_vox_anim_model {
    const ogt_vox_keyframe_model* keyframes;
    uint32_t                      num_keyframes;
    bool                          loop;
} ogt_vox_anim_model;

// an instance of a model within the scene
typedef struct ogt_vox_instance
{
    const char* name;                   // name of the instance if there is one, will be NULL otherwise.
    ogt_vox_transform      transform;              // orientation and position of this instance on first frame of the scene. This is relative to its group local transform if group_index is not 0
    uint32_t               model_index;            // index of the model used by this instance on the first frame of the scene. used to lookup the model in the scene's models[] array.
    uint32_t               layer_index;            // index of the layer used by this instance. used to lookup the layer in the scene's layers[] array.
    uint32_t               group_index;            // this will be the index of the group in the scene's groups[] array. If group is zero it will be the scene root group and the instance transform will be a world-space transform, otherwise the transform is relative to the group.
    bool                   hidden;                 // whether this instance is individually hidden or not. Note: the instance can also be hidden when its layer is hidden, or if it belongs to a group that is hidden.
    ogt_vox_anim_transform transform_anim;         // animation for the transform
    ogt_vox_anim_model     model_anim;             // animation for the model_index
} ogt_vox_instance;

// describes a layer within the scene
typedef struct ogt_vox_layer
{
    const char* name;               // name of this layer if there is one, will be NULL otherwise.
    ogt_vox_rgba color;              // color of the layer.
    bool         hidden;             // whether this layer is hidden or not.
} ogt_vox_layer;

// describes a group within the scene
typedef struct ogt_vox_group
{
    const char* name;                    // name of the group if there is one, will be NULL otherwise
    ogt_vox_transform      transform;               // transform of this group relative to its parent group (if any), otherwise this will be relative to world-space.
    uint32_t               parent_group_index;      // if this group is parented to another group, this will be the index of its parent in the scene's groups[] array, otherwise this group will be the scene root group and this value will be k_invalid_group_index
    uint32_t               layer_index;             // which layer this group belongs to. used to lookup the layer in the scene's layers[] array.
    bool                   hidden;                  // whether this group is hidden or not.
    ogt_vox_anim_transform transform_anim;          // animated transform data
} ogt_vox_group;

// the scene parsed from a .vox file.
typedef struct ogt_vox_scene
{
    uint32_t                num_models;     // number of models within the scene.
    uint32_t                num_instances;  // number of instances in the scene (on anim frame 0)
    uint32_t                num_layers;     // number of layers in the scene
    uint32_t                num_groups;     // number of groups in the scene
    const ogt_vox_model** models;         // array of models. size is num_models
    const ogt_vox_instance* instances;      // array of instances. size is num_instances
    const ogt_vox_layer* layers;         // array of layers. size is num_layers
    const ogt_vox_group* groups;         // array of groups. size is num_groups
    ogt_vox_palette         palette;        // the palette for this scene
    ogt_vox_matl_array      materials;      // the extended materials for this scene
    uint32_t                num_cameras;    // number of cameras for this scene
    const ogt_vox_cam* cameras;        // the cameras for this scene
} ogt_vox_scene;

// allocate memory function interface. pass in size, and get a pointer to memory with at least that size available.
typedef void* (*ogt_vox_alloc_func)(size_t size);

// free memory function interface. pass in a pointer previously allocated and it will be released back to the system managing memory.
typedef void  (*ogt_vox_free_func)(void* ptr);

// override the default scene memory allocator if you need to control memory precisely.
void  ogt_vox_set_memory_allocator(ogt_vox_alloc_func alloc_func, ogt_vox_free_func free_func);
void* ogt_vox_malloc(size_t size);
void  ogt_vox_free(void* mem);

// progress feedback function with option to cancel a ogt_vox_write_scene operation. Percentage complete is approximately given by: 100.0f * progress.
typedef bool  (*ogt_vox_progress_callback_func)(float progress, void* user_data);

// set the progress callback function and user data to pass to it
void  ogt_vox_set_progress_callback_func(ogt_vox_progress_callback_func progress_callback_func, void* user_data);


// flags for ogt_vox_read_scene_with_flags
static const uint32_t k_read_scene_flags_groups = 1 << 0; // if not specified, all instance transforms will be flattened into world space. If specified, will read group information and keep all transforms as local transform relative to the group they are in.
static const uint32_t k_read_scene_flags_keyframes = 1 << 1; // if specified, all instances and groups will contain keyframe data.
static const uint32_t k_read_scene_flags_keep_empty_models_instances = 1 << 2; // if specified, all empty models and instances referencing those will be kept rather than culled.
static const uint32_t k_read_scene_flags_keep_duplicate_models = 1 << 3; // if specified, we do not de-duplicate models.

// creates a scene from a vox file within a memory buffer of a given size.
// you can destroy the input buffer once you have the scene as this function will allocate separate memory for the scene objecvt.
const ogt_vox_scene* ogt_vox_read_scene(const uint8_t* buffer, uint32_t buffer_size);

// just like ogt_vox_read_scene, but you can additionally pass a union of k_read_scene_flags
const ogt_vox_scene* ogt_vox_read_scene_with_flags(const uint8_t* buffer, uint32_t buffer_size, uint32_t read_flags);

// destroys a scene object to release its memory.
void ogt_vox_destroy_scene(const ogt_vox_scene* scene);

// writes the scene to a new buffer and returns the buffer size. free the buffer with ogt_vox_free
uint8_t* ogt_vox_write_scene(const ogt_vox_scene* scene, uint32_t* buffer_size);

// merges the specified scenes together to create a bigger scene. Merged scene can be destroyed using ogt_vox_destroy_scene
// If you require specific colors in the merged scene palette, provide up to and including 255 of them via required_colors/required_color_count.
ogt_vox_scene* ogt_vox_merge_scenes(const ogt_vox_scene** scenes, uint32_t scene_count, const ogt_vox_rgba* required_colors, const uint32_t required_color_count);

// sample the model index for a given instance at the given frame
uint32_t          ogt_vox_sample_instance_model(const ogt_vox_instance* instance, uint32_t frame_index);

// samples the transform for an instance at a given frame. 
//   ogt_vox_sample_instance_transform_global returns the transform in world space (aka global)
//   ogt_vox_sample_instance_transform_local returns the transform relative to its parent group
ogt_vox_transform ogt_vox_sample_instance_transform_global(const ogt_vox_instance* instance, uint32_t frame_index, const ogt_vox_scene* scene);
ogt_vox_transform ogt_vox_sample_instance_transform_local(const ogt_vox_instance* instance, uint32_t frame_index);

// sample the transform for a group at a given frame
//  ogt_vox_sample_group_transform_global returns the transform in world space (aka global)
//  ogt_vox_sample_group_transform_local returns the transform relative to its parent group
ogt_vox_transform ogt_vox_sample_group_transform_global(const ogt_vox_group* group, uint32_t frame_index, const ogt_vox_scene* scene);
ogt_vox_transform ogt_vox_sample_group_transform_local(const ogt_vox_group* group, uint32_t frame_index);

#endif // OGT_VOX_H__

//-----------------------------------------------------------------------------------------------------------------
//
// If you're only interested in using this library, everything you need is above this point.
// If you're interested in how this library works, everything you need is below this point.
//
//-----------------------------------------------------------------------------------------------------------------
#ifdef OGT_VOX_IMPLEMENTATION
    // callers can override asserts in ogt_vox by defining their own macro before the implementation
#ifndef ogt_assert
#include <assert.h>
#define ogt_assert(x, msg_str)      do { assert((x) && (msg_str)); } while(0)
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// MAKE_VOX_CHUNK_ID: used to construct a literal to describe a chunk in a .vox file.
#define MAKE_VOX_CHUNK_ID(c0,c1,c2,c3)     ( (c0<<0) | (c1<<8) | (c2<<16) | (c3<<24) )

static const uint32_t CHUNK_ID_VOX_ = MAKE_VOX_CHUNK_ID('V', 'O', 'X', ' ');
static const uint32_t CHUNK_ID_MAIN = MAKE_VOX_CHUNK_ID('M', 'A', 'I', 'N');
static const uint32_t CHUNK_ID_SIZE = MAKE_VOX_CHUNK_ID('S', 'I', 'Z', 'E');
static const uint32_t CHUNK_ID_XYZI = MAKE_VOX_CHUNK_ID('X', 'Y', 'Z', 'I');
static const uint32_t CHUNK_ID_RGBA = MAKE_VOX_CHUNK_ID('R', 'G', 'B', 'A');
static const uint32_t CHUNK_ID_nTRN = MAKE_VOX_CHUNK_ID('n', 'T', 'R', 'N');
static const uint32_t CHUNK_ID_nGRP = MAKE_VOX_CHUNK_ID('n', 'G', 'R', 'P');
static const uint32_t CHUNK_ID_nSHP = MAKE_VOX_CHUNK_ID('n', 'S', 'H', 'P');
static const uint32_t CHUNK_ID_IMAP = MAKE_VOX_CHUNK_ID('I', 'M', 'A', 'P');
static const uint32_t CHUNK_ID_LAYR = MAKE_VOX_CHUNK_ID('L', 'A', 'Y', 'R');
static const uint32_t CHUNK_ID_MATL = MAKE_VOX_CHUNK_ID('M', 'A', 'T', 'L');
static const uint32_t CHUNK_ID_MATT = MAKE_VOX_CHUNK_ID('M', 'A', 'T', 'T');
static const uint32_t CHUNK_ID_rOBJ = MAKE_VOX_CHUNK_ID('r', 'O', 'B', 'J');
static const uint32_t CHUNK_ID_rCAM = MAKE_VOX_CHUNK_ID('r', 'C', 'A', 'M');

static const uint32_t NAME_MAX_LEN = 256;       // max name len = 255 plus 1 for null terminator
static const uint32_t CHUNK_HEADER_LEN = 12;        // 4 bytes for each of: chunk_id, chunk_size, chunk_child_size 

// Some older .vox files will not store a palette, in which case the following palette will be used!
static const uint8_t k_default_vox_palette[256 * 4] = {
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0xff, 0xff, 0xff, 0x99, 0xff, 0xff, 0xff, 0x66, 0xff, 0xff, 0xff, 0x33, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xcc, 0xff, 0xff, 0xff, 0xcc, 0xcc, 0xff,
    0xff, 0xcc, 0x99, 0xff, 0xff, 0xcc, 0x66, 0xff, 0xff, 0xcc, 0x33, 0xff, 0xff, 0xcc, 0x00, 0xff, 0xff, 0x99, 0xff, 0xff, 0xff, 0x99, 0xcc, 0xff, 0xff, 0x99, 0x99, 0xff, 0xff, 0x99, 0x66, 0xff,
    0xff, 0x99, 0x33, 0xff, 0xff, 0x99, 0x00, 0xff, 0xff, 0x66, 0xff, 0xff, 0xff, 0x66, 0xcc, 0xff, 0xff, 0x66, 0x99, 0xff, 0xff, 0x66, 0x66, 0xff, 0xff, 0x66, 0x33, 0xff, 0xff, 0x66, 0x00, 0xff,
    0xff, 0x33, 0xff, 0xff, 0xff, 0x33, 0xcc, 0xff, 0xff, 0x33, 0x99, 0xff, 0xff, 0x33, 0x66, 0xff, 0xff, 0x33, 0x33, 0xff, 0xff, 0x33, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xcc, 0xff,
    0xff, 0x00, 0x99, 0xff, 0xff, 0x00, 0x66, 0xff, 0xff, 0x00, 0x33, 0xff, 0xff, 0x00, 0x00, 0xff, 0xcc, 0xff, 0xff, 0xff, 0xcc, 0xff, 0xcc, 0xff, 0xcc, 0xff, 0x99, 0xff, 0xcc, 0xff, 0x66, 0xff,
    0xcc, 0xff, 0x33, 0xff, 0xcc, 0xff, 0x00, 0xff, 0xcc, 0xcc, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0xff, 0xcc, 0xcc, 0x99, 0xff, 0xcc, 0xcc, 0x66, 0xff, 0xcc, 0xcc, 0x33, 0xff, 0xcc, 0xcc, 0x00, 0xff,
    0xcc, 0x99, 0xff, 0xff, 0xcc, 0x99, 0xcc, 0xff, 0xcc, 0x99, 0x99, 0xff, 0xcc, 0x99, 0x66, 0xff, 0xcc, 0x99, 0x33, 0xff, 0xcc, 0x99, 0x00, 0xff, 0xcc, 0x66, 0xff, 0xff, 0xcc, 0x66, 0xcc, 0xff,
    0xcc, 0x66, 0x99, 0xff, 0xcc, 0x66, 0x66, 0xff, 0xcc, 0x66, 0x33, 0xff, 0xcc, 0x66, 0x00, 0xff, 0xcc, 0x33, 0xff, 0xff, 0xcc, 0x33, 0xcc, 0xff, 0xcc, 0x33, 0x99, 0xff, 0xcc, 0x33, 0x66, 0xff,
    0xcc, 0x33, 0x33, 0xff, 0xcc, 0x33, 0x00, 0xff, 0xcc, 0x00, 0xff, 0xff, 0xcc, 0x00, 0xcc, 0xff, 0xcc, 0x00, 0x99, 0xff, 0xcc, 0x00, 0x66, 0xff, 0xcc, 0x00, 0x33, 0xff, 0xcc, 0x00, 0x00, 0xff,
    0x99, 0xff, 0xff, 0xff, 0x99, 0xff, 0xcc, 0xff, 0x99, 0xff, 0x99, 0xff, 0x99, 0xff, 0x66, 0xff, 0x99, 0xff, 0x33, 0xff, 0x99, 0xff, 0x00, 0xff, 0x99, 0xcc, 0xff, 0xff, 0x99, 0xcc, 0xcc, 0xff,
    0x99, 0xcc, 0x99, 0xff, 0x99, 0xcc, 0x66, 0xff, 0x99, 0xcc, 0x33, 0xff, 0x99, 0xcc, 0x00, 0xff, 0x99, 0x99, 0xff, 0xff, 0x99, 0x99, 0xcc, 0xff, 0x99, 0x99, 0x99, 0xff, 0x99, 0x99, 0x66, 0xff,
    0x99, 0x99, 0x33, 0xff, 0x99, 0x99, 0x00, 0xff, 0x99, 0x66, 0xff, 0xff, 0x99, 0x66, 0xcc, 0xff, 0x99, 0x66, 0x99, 0xff, 0x99, 0x66, 0x66, 0xff, 0x99, 0x66, 0x33, 0xff, 0x99, 0x66, 0x00, 0xff,
    0x99, 0x33, 0xff, 0xff, 0x99, 0x33, 0xcc, 0xff, 0x99, 0x33, 0x99, 0xff, 0x99, 0x33, 0x66, 0xff, 0x99, 0x33, 0x33, 0xff, 0x99, 0x33, 0x00, 0xff, 0x99, 0x00, 0xff, 0xff, 0x99, 0x00, 0xcc, 0xff,
    0x99, 0x00, 0x99, 0xff, 0x99, 0x00, 0x66, 0xff, 0x99, 0x00, 0x33, 0xff, 0x99, 0x00, 0x00, 0xff, 0x66, 0xff, 0xff, 0xff, 0x66, 0xff, 0xcc, 0xff, 0x66, 0xff, 0x99, 0xff, 0x66, 0xff, 0x66, 0xff,
    0x66, 0xff, 0x33, 0xff, 0x66, 0xff, 0x00, 0xff, 0x66, 0xcc, 0xff, 0xff, 0x66, 0xcc, 0xcc, 0xff, 0x66, 0xcc, 0x99, 0xff, 0x66, 0xcc, 0x66, 0xff, 0x66, 0xcc, 0x33, 0xff, 0x66, 0xcc, 0x00, 0xff,
    0x66, 0x99, 0xff, 0xff, 0x66, 0x99, 0xcc, 0xff, 0x66, 0x99, 0x99, 0xff, 0x66, 0x99, 0x66, 0xff, 0x66, 0x99, 0x33, 0xff, 0x66, 0x99, 0x00, 0xff, 0x66, 0x66, 0xff, 0xff, 0x66, 0x66, 0xcc, 0xff,
    0x66, 0x66, 0x99, 0xff, 0x66, 0x66, 0x66, 0xff, 0x66, 0x66, 0x33, 0xff, 0x66, 0x66, 0x00, 0xff, 0x66, 0x33, 0xff, 0xff, 0x66, 0x33, 0xcc, 0xff, 0x66, 0x33, 0x99, 0xff, 0x66, 0x33, 0x66, 0xff,
    0x66, 0x33, 0x33, 0xff, 0x66, 0x33, 0x00, 0xff, 0x66, 0x00, 0xff, 0xff, 0x66, 0x00, 0xcc, 0xff, 0x66, 0x00, 0x99, 0xff, 0x66, 0x00, 0x66, 0xff, 0x66, 0x00, 0x33, 0xff, 0x66, 0x00, 0x00, 0xff,
    0x33, 0xff, 0xff, 0xff, 0x33, 0xff, 0xcc, 0xff, 0x33, 0xff, 0x99, 0xff, 0x33, 0xff, 0x66, 0xff, 0x33, 0xff, 0x33, 0xff, 0x33, 0xff, 0x00, 0xff, 0x33, 0xcc, 0xff, 0xff, 0x33, 0xcc, 0xcc, 0xff,
    0x33, 0xcc, 0x99, 0xff, 0x33, 0xcc, 0x66, 0xff, 0x33, 0xcc, 0x33, 0xff, 0x33, 0xcc, 0x00, 0xff, 0x33, 0x99, 0xff, 0xff, 0x33, 0x99, 0xcc, 0xff, 0x33, 0x99, 0x99, 0xff, 0x33, 0x99, 0x66, 0xff,
    0x33, 0x99, 0x33, 0xff, 0x33, 0x99, 0x00, 0xff, 0x33, 0x66, 0xff, 0xff, 0x33, 0x66, 0xcc, 0xff, 0x33, 0x66, 0x99, 0xff, 0x33, 0x66, 0x66, 0xff, 0x33, 0x66, 0x33, 0xff, 0x33, 0x66, 0x00, 0xff,
    0x33, 0x33, 0xff, 0xff, 0x33, 0x33, 0xcc, 0xff, 0x33, 0x33, 0x99, 0xff, 0x33, 0x33, 0x66, 0xff, 0x33, 0x33, 0x33, 0xff, 0x33, 0x33, 0x00, 0xff, 0x33, 0x00, 0xff, 0xff, 0x33, 0x00, 0xcc, 0xff,
    0x33, 0x00, 0x99, 0xff, 0x33, 0x00, 0x66, 0xff, 0x33, 0x00, 0x33, 0xff, 0x33, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xcc, 0xff, 0x00, 0xff, 0x99, 0xff, 0x00, 0xff, 0x66, 0xff,
    0x00, 0xff, 0x33, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xcc, 0xff, 0xff, 0x00, 0xcc, 0xcc, 0xff, 0x00, 0xcc, 0x99, 0xff, 0x00, 0xcc, 0x66, 0xff, 0x00, 0xcc, 0x33, 0xff, 0x00, 0xcc, 0x00, 0xff,
    0x00, 0x99, 0xff, 0xff, 0x00, 0x99, 0xcc, 0xff, 0x00, 0x99, 0x99, 0xff, 0x00, 0x99, 0x66, 0xff, 0x00, 0x99, 0x33, 0xff, 0x00, 0x99, 0x00, 0xff, 0x00, 0x66, 0xff, 0xff, 0x00, 0x66, 0xcc, 0xff,
    0x00, 0x66, 0x99, 0xff, 0x00, 0x66, 0x66, 0xff, 0x00, 0x66, 0x33, 0xff, 0x00, 0x66, 0x00, 0xff, 0x00, 0x33, 0xff, 0xff, 0x00, 0x33, 0xcc, 0xff, 0x00, 0x33, 0x99, 0xff, 0x00, 0x33, 0x66, 0xff,
    0x00, 0x33, 0x33, 0xff, 0x00, 0x33, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xcc, 0xff, 0x00, 0x00, 0x99, 0xff, 0x00, 0x00, 0x66, 0xff, 0x00, 0x00, 0x33, 0xff, 0xee, 0x00, 0x00, 0xff,
    0xdd, 0x00, 0x00, 0xff, 0xbb, 0x00, 0x00, 0xff, 0xaa, 0x00, 0x00, 0xff, 0x88, 0x00, 0x00, 0xff, 0x77, 0x00, 0x00, 0xff, 0x55, 0x00, 0x00, 0xff, 0x44, 0x00, 0x00, 0xff, 0x22, 0x00, 0x00, 0xff,
    0x11, 0x00, 0x00, 0xff, 0x00, 0xee, 0x00, 0xff, 0x00, 0xdd, 0x00, 0xff, 0x00, 0xbb, 0x00, 0xff, 0x00, 0xaa, 0x00, 0xff, 0x00, 0x88, 0x00, 0xff, 0x00, 0x77, 0x00, 0xff, 0x00, 0x55, 0x00, 0xff,
    0x00, 0x44, 0x00, 0xff, 0x00, 0x22, 0x00, 0xff, 0x00, 0x11, 0x00, 0xff, 0x00, 0x00, 0xee, 0xff, 0x00, 0x00, 0xdd, 0xff, 0x00, 0x00, 0xbb, 0xff, 0x00, 0x00, 0xaa, 0xff, 0x00, 0x00, 0x88, 0xff,
    0x00, 0x00, 0x77, 0xff, 0x00, 0x00, 0x55, 0xff, 0x00, 0x00, 0x44, 0xff, 0x00, 0x00, 0x22, 0xff, 0x00, 0x00, 0x11, 0xff, 0xee, 0xee, 0xee, 0xff, 0xdd, 0xdd, 0xdd, 0xff, 0xbb, 0xbb, 0xbb, 0xff,
    0xaa, 0xaa, 0xaa, 0xff, 0x88, 0x88, 0x88, 0xff, 0x77, 0x77, 0x77, 0xff, 0x55, 0x55, 0x55, 0xff, 0x44, 0x44, 0x44, 0xff, 0x22, 0x22, 0x22, 0xff, 0x11, 0x11, 0x11, 0xff, 0x00, 0x00, 0x00, 0xff,
};

// internal math/helper utilities
static inline uint32_t _vox_max(uint32_t a, uint32_t b) {
    return (a > b) ? a : b;
}
static inline uint32_t _vox_min(uint32_t a, uint32_t b) {
    return (a < b) ? a : b;
}

// string utilities
#ifdef _MSC_VER
#define _vox_str_scanf(str,...)      sscanf_s(str,__VA_ARGS__)
#define _vox_strcasecmp(a,b)         _stricmp(a,b)
#define _vox_strcmp(a,b)             strcmp(a,b)
#define _vox_strlen(a)               strlen(a)
#define _vox_sprintf(str,str_max,fmt,...)    sprintf_s(str, str_max, fmt, __VA_ARGS__)
#else
#define _vox_str_scanf(str,...)      sscanf(str,__VA_ARGS__)
#define _vox_strcasecmp(a,b)         strcasecmp(a,b)
#define _vox_strcmp(a,b)             strcmp(a,b)
#define _vox_strlen(a)               strlen(a)
#define _vox_sprintf(str,str_max,fmt,...)    snprintf(str, str_max, fmt, __VA_ARGS__)
#endif

// Like strcpy, but will only copy the amount of characters from src that can fit in dst.
// Will assert if too many characters are in src.
template <size_t SIZE>
inline void _vox_strcpy_static(char(&dst)[SIZE], const char* src) {
    size_t storage_needed = _vox_strlen(src) + 1; // +1 for zero terminator
    ogt_assert(storage_needed <= SIZE, ""strcpy of src into dst would exceed storage in dst"");
    memcpy(dst, src, storage_needed <= SIZE ? storage_needed : SIZE);
    dst[SIZE - 1] = 0; // make sure we're always zero terminated.
}

// 3d vector utilities
struct vec3 {
    float x, y, z;
};
static inline vec3 vec3_make(float x, float y, float z) { vec3 v; v.x = x; v.y = y; v.z = z; return v; }
static inline vec3 vec3_negate(const vec3& v) { vec3 r; r.x = -v.x;  r.y = -v.y; r.z = -v.z; return r; }

// API for emulating file transactions on an in-memory buffer of data.
struct _vox_file {
    const  uint8_t* buffer;       // source buffer data
    const uint32_t  buffer_size;  // size of the data in the buffer
    uint32_t        offset;       // current offset in the buffer data.
};

static uint32_t _vox_file_bytes_remaining(const _vox_file* fp) {
    if (fp->offset < fp->buffer_size) {
        return fp->buffer_size - fp->offset;
    }
    else {
        return 0;
    }
}

static bool _vox_file_read(_vox_file* fp, void* data, uint32_t data_size) {
    size_t data_to_read = _vox_min(_vox_file_bytes_remaining(fp), data_size);
    memcpy(data, &fp->buffer[fp->offset], data_to_read);
    fp->offset += data_size;
    return data_to_read == data_size;
}

static bool _vox_file_read_uint32(_vox_file* fp, uint32_t* data) {
    bool ret = _vox_file_read(fp, data, sizeof(*data));
    if (ret) {
        *data = _vox_le32toh(*data);
    }
    return ret;
}

static bool _vox_file_read_int32(_vox_file* fp, int32_t* data) {
    bool ret = _vox_file_read(fp, data, sizeof(*data));
    if (ret) {
        *data = _vox_le32toh(*data);
    }
    return ret;
}

static bool _vox_file_read_float(_vox_file* fp, float* data) {
    bool ret = _vox_file_read(fp, data, sizeof(*data));
    if (ret) {
        union {
            uint32_t u;
            float f;
        } bs;
        bs.f = *data;
        bs.u = _vox_le32toh(bs.u);
        *data = bs.f;
    }
    return ret;
}

static void _vox_file_seek_forwards(_vox_file* fp, uint32_t offset) {
    fp->offset += _vox_min(offset, _vox_file_bytes_remaining(fp));
}

static const void* _vox_file_data_pointer(const _vox_file* fp) {
    return &fp->buffer[fp->offset];
}

// hash utilities
static uint32_t _vox_hash(const uint8_t* data, uint32_t data_size) {
    uint32_t hash = 0;
    for (uint32_t i = 0; i < data_size; i++)
        hash = data[i] + (hash * 65559);
    return hash;
}

// memory allocation utils.
static void* _ogt_priv_alloc_default(size_t size) { return malloc(size); }
static void  _ogt_priv_free_default(void* ptr) { free(ptr); }
static ogt_vox_alloc_func g_alloc_func = _ogt_priv_alloc_default; // default function for allocating
static ogt_vox_free_func  g_free_func = _ogt_priv_free_default;   // default  function for freeing.

// set the provided allocate/free functions if they are non-null, otherwise reset to default allocate/free functions
void ogt_vox_set_memory_allocator(ogt_vox_alloc_func alloc_func, ogt_vox_free_func free_func)
{
    ogt_assert((alloc_func && free_func) ||                             // both alloc/free must be non-NULL -OR-
        (!alloc_func && !free_func), ""mixed alloc/free functions"");     // both alloc/free must be NULL. No mixing 'n matching.
    if (alloc_func && free_func) {
        g_alloc_func = alloc_func;
        g_free_func = free_func;
    }
    else {
        // reset to default allocate/free functions.
        g_alloc_func = _ogt_priv_alloc_default;
        g_free_func = _ogt_priv_free_default;
    }
}

static void* _vox_malloc(size_t size) {
    return size ? g_alloc_func(size) : NULL;
}

static void* _vox_calloc(size_t size) {
    void* pMem = _vox_malloc(size);
    if (pMem)
        memset(pMem, 0, size);
    return pMem;
}

static void _vox_free(void* old_ptr) {
    if (old_ptr)
        g_free_func(old_ptr);
}

static void* _vox_realloc(void* old_ptr, size_t old_size, size_t new_size) {
    // early out if new size is non-zero and no resize is required.
    if (new_size && old_size >= new_size)
        return old_ptr;

    // memcpy from the old ptr only if both sides are valid.
    void* new_ptr = _vox_malloc(new_size);
    if (new_ptr) {
        // copy any existing elements over
        if (old_ptr && old_size)
            memcpy(new_ptr, old_ptr, old_size);
        // zero out any new tail elements
        ogt_assert(new_size > old_size, ""_vox_realloc error""); // this should be guaranteed by the _vox_realloc early out case above.
        uintptr_t new_tail_ptr = (uintptr_t)new_ptr + old_size;
        memset((void*)new_tail_ptr, 0, new_size - old_size);
    }
    if (old_ptr)
        _vox_free(old_ptr);
    return new_ptr;
}

// std::vector-style allocator, which use client-provided allocation functions.
template <class T> struct _vox_array {
    _vox_array() : data(NULL), capacity(0), count(0) { }
    ~_vox_array() {
        _vox_free(data);
        data = NULL;
        count = 0;
        capacity = 0;
    }
    void reserve(size_t new_capacity) {
        data = (T*)_vox_realloc(data, capacity * sizeof(T), new_capacity * sizeof(T));
        capacity = new_capacity;
    }
    void grow_to_fit_index(size_t index) {
        if (index >= count)
            resize(index + 1);
    }
    void resize(size_t new_count) {
        if (new_count > capacity)
        {
            size_t new_capacity = capacity ? (capacity * 3) >> 1 : 2;   // grow by 50% each time, otherwise start at 2 elements.
            new_capacity = new_count > new_capacity ? new_count : new_capacity; // ensure fits new_count
            reserve(new_capacity);
            ogt_assert(capacity >= new_count, ""failed to resize array"");
        }
        count = new_count;
    }
    void push_back(const T& new_element) {
        if (count == capacity) {
            size_t new_capacity = capacity ? (capacity * 3) >> 1 : 2;   // grow by 50% each time, otherwise start at 2 elements.
            reserve(new_capacity);
            ogt_assert(capacity > count, ""failed to push_back in array"");
        }
        data[count++] = new_element;
    }
    void pop_back() {
        ogt_assert(count > 0, ""cannot pop_back on empty array"");
        count--;
    }
    const T& peek_back(size_t back_offset = 0) const {
        ogt_assert(back_offset < count, ""can't peek back further than the number of elements in an array"");
        size_t index = count - 1 - back_offset;
        return data[index];
    }

    void push_back_many(const T* new_elements, size_t num_elements) {
        if (count + num_elements > capacity) {
            size_t new_capacity = capacity + num_elements;
            new_capacity = new_capacity ? (new_capacity * 3) >> 1 : 2;   // grow by 50% each time, otherwise start at 2 elements.
            reserve(new_capacity);
            ogt_assert(capacity >= (count + num_elements), ""failed to push_back_many in array"");
        }
        for (size_t i = 0; i < num_elements; i++)
            data[count + i] = new_elements[i];
        count += num_elements;
    }
    T* alloc_many(size_t num_elements) {
        if (count + num_elements > capacity) {
            size_t new_capacity = capacity + num_elements;
            new_capacity = new_capacity ? (new_capacity * 3) >> 1 : 2;   // grow by 50% each time, otherwise start at 2 elements.
            reserve(new_capacity);
            ogt_assert(capacity >= (count + num_elements), ""failed to push_back_many in array"");
        }
        T* ret = &data[count];
        count += num_elements;
        return ret;
    }

    // returns the index that it was inserted at.
    uint32_t insert_unique_sorted(const T& value, uint32_t start_index) {
        for (uint32_t i = start_index; i < (uint32_t)count; i++) {
            if (data[i] == value)
                return i;
            if (data[i] >= value) {
                resize(count + 1);
                for (size_t j = count - 1; j > i; j--)
                    data[j] = data[j - 1];
                data[i] = value;
                return i;
            }
        }
        push_back(value);
        return (uint32_t)(count - 1);
    }

    size_t size() const {
        return count;
    }
    T& operator[](size_t index) {
        ogt_assert(index < count, ""index out of bounds"");
        return data[index];
    }
    const T& operator[](size_t index) const {
        ogt_assert(index < count, ""index out of bounds"");
        return data[index];
    }
    T* data;      // data for the array
    size_t capacity;  // capacity of the array
    size_t count;      // size of the array
};

// a growing array where data is suballocated.
class _vox_suballoc_array {
public:
    _vox_suballoc_array() {
        data.reserve(1024);
        // push a sentinel character into this array. This allows clients to keep an
        // offset rather than a pointer and still allow an offset of 0 to mean invalid.
        data.push_back('X');
    }

    void reserve(size_t new_capacity) {
        data.reserve(new_capacity);
    }

    size_t size() const {
        return data.size();
    }

    // gets the offset of a pointer that was allocated within this array. 
    size_t offset_of(void* ptr) const {
        size_t unaligned_data = (size_t)&data[0];
        size_t unaligned_ptr = (size_t)ptr;
        ogt_assert(unaligned_ptr >= unaligned_data && unaligned_ptr < (unaligned_data + data.size()), ""provided ptr is out of bounds in this array"");
        return unaligned_ptr - unaligned_data;
    }

    // gets a typed pointer given an offset into the block
    template <class T>
    const T* get_ptr(size_t offset) const {
        ogt_assert(0 == offset % sizeof(T), ""offset is not properly aligned for this datatype"");
        return (T*)&data[offset];
    }

    // gets a mutable typed pointer given an offset into the block
    template <class T>
    T* get_ptr(size_t offset) {
        ogt_assert(0 == offset % sizeof(T), ""offset is not properly aligned for this datatype"");
        return (T*)&data[offset];
    }

    // allocates num_bytes of memory with optionally specified base offset alignment.
    void* alloc(size_t num_bytes, size_t align = 0) {
        if (align > 1 && 0 != (data.size() % align)) {
            size_t padding = align - (data.size() % align);
            data.alloc_many(padding);
        }
        return data.alloc_many(num_bytes);
    }

    // allocates and returns a pointer to many elements of the specified type. 
    // if align != 0, will use that alignment, otherwise will align to the size of the type T.
    template <class T>
    T* alloc_many(size_t num_elements, size_t align = 0) {
        // if alignment is specified use that, otherwise default alignment to the size fo the type T
        align = align == 0 ? sizeof(T) : align;
        return (T*)alloc(sizeof(T) * num_elements, align);
    }

    // returns the offset in the memory blob that the data was pushed to.
    template <class T>
    size_t push_back_many(const T* new_elements, size_t num_elements, size_t align = 0) {
        T* mem = alloc_many<T>(num_elements, align);
        if (!mem)
            return 0;
        memcpy(mem, new_elements, sizeof(T) * num_elements);
        return offset_of(mem);
    }

    // returns the offset in the memory blob that the string was pushed to.
    size_t push_string(const char* str) {
        size_t str_size = _vox_strlen(str) + 1; // +1 for terminator
        return push_back_many(str, str_size);
    }

private:
    _vox_array<char> data;
};

// progress callback function.
static ogt_vox_progress_callback_func g_progress_callback_func = NULL;
static void* g_progress_callback_user_data = NULL;

// set the progress callback function.
void  ogt_vox_set_progress_callback_func(ogt_vox_progress_callback_func progress_callback_func, void* user_data)
{
    g_progress_callback_func = progress_callback_func;
    g_progress_callback_user_data = user_data;
}

// matrix utilities
ogt_vox_transform ogt_vox_transform_get_identity() {
    ogt_vox_transform t;
    t.m00 = 1.0f; t.m01 = 0.0f; t.m02 = 0.0f; t.m03 = 0.0f;
    t.m10 = 0.0f; t.m11 = 1.0f; t.m12 = 0.0f; t.m13 = 0.0f;
    t.m20 = 0.0f; t.m21 = 0.0f; t.m22 = 1.0f; t.m23 = 0.0f;
    t.m30 = 0.0f; t.m31 = 0.0f; t.m32 = 0.0f; t.m33 = 1.0f;
    return t;
}

ogt_vox_transform ogt_vox_transform_multiply(const ogt_vox_transform& a, const ogt_vox_transform& b) {
    ogt_vox_transform r;
    r.m00 = (a.m00 * b.m00) + (a.m01 * b.m10) + (a.m02 * b.m20) + (a.m03 * b.m30);
    r.m01 = (a.m00 * b.m01) + (a.m01 * b.m11) + (a.m02 * b.m21) + (a.m03 * b.m31);
    r.m02 = (a.m00 * b.m02) + (a.m01 * b.m12) + (a.m02 * b.m22) + (a.m03 * b.m32);
    r.m03 = (a.m00 * b.m03) + (a.m01 * b.m13) + (a.m02 * b.m23) + (a.m03 * b.m33);
    r.m10 = (a.m10 * b.m00) + (a.m11 * b.m10) + (a.m12 * b.m20) + (a.m13 * b.m30);
    r.m11 = (a.m10 * b.m01) + (a.m11 * b.m11) + (a.m12 * b.m21) + (a.m13 * b.m31);
    r.m12 = (a.m10 * b.m02) + (a.m11 * b.m12) + (a.m12 * b.m22) + (a.m13 * b.m32);
    r.m13 = (a.m10 * b.m03) + (a.m11 * b.m13) + (a.m12 * b.m23) + (a.m13 * b.m33);
    r.m20 = (a.m20 * b.m00) + (a.m21 * b.m10) + (a.m22 * b.m20) + (a.m23 * b.m30);
    r.m21 = (a.m20 * b.m01) + (a.m21 * b.m11) + (a.m22 * b.m21) + (a.m23 * b.m31);
    r.m22 = (a.m20 * b.m02) + (a.m21 * b.m12) + (a.m22 * b.m22) + (a.m23 * b.m32);
    r.m23 = (a.m20 * b.m03) + (a.m21 * b.m13) + (a.m22 * b.m23) + (a.m23 * b.m33);
    r.m30 = (a.m30 * b.m00) + (a.m31 * b.m10) + (a.m32 * b.m20) + (a.m33 * b.m30);
    r.m31 = (a.m30 * b.m01) + (a.m31 * b.m11) + (a.m32 * b.m21) + (a.m33 * b.m31);
    r.m32 = (a.m30 * b.m02) + (a.m31 * b.m12) + (a.m32 * b.m22) + (a.m33 * b.m32);
    r.m33 = (a.m30 * b.m03) + (a.m31 * b.m13) + (a.m32 * b.m23) + (a.m33 * b.m33);
    return r;
}

// dictionary utilities
static const uint32_t k_vox_max_dict_buffer_size = 4096;
static const uint32_t k_vox_max_dict_key_value_pairs = 256;
struct _vox_dictionary {
    const char* keys[k_vox_max_dict_key_value_pairs];
    const char* values[k_vox_max_dict_key_value_pairs];
    uint32_t    num_key_value_pairs;
    char        buffer[k_vox_max_dict_buffer_size + 4];    // max 4096, +4 for safety
    uint32_t    buffer_mem_used;
};

static bool _vox_file_read_dict(_vox_dictionary* dict, _vox_file* fp) {
    uint32_t num_pairs_to_read = 0;
    _vox_file_read_uint32(fp, &num_pairs_to_read);
    ogt_assert(num_pairs_to_read <= k_vox_max_dict_key_value_pairs, ""max key/value pairs exceeded in dictionary"");

    dict->buffer_mem_used = 0;
    dict->num_key_value_pairs = 0;
    for (uint32_t i = 0; i < num_pairs_to_read; i++) {
        // get the size of the key string
        uint32_t key_string_size = 0;
        if (!_vox_file_read_uint32(fp, &key_string_size))
            return false;
        // allocate space for the key, and read it in.
        if (dict->buffer_mem_used + key_string_size > k_vox_max_dict_buffer_size)
            return false;
        char* key = &dict->buffer[dict->buffer_mem_used];
        dict->buffer_mem_used += key_string_size + 1;    // + 1 for zero terminator
        if (!_vox_file_read(fp, key, key_string_size))
            return false;
        key[key_string_size] = 0;    // zero-terminate
        ogt_assert(_vox_strlen(key) == key_string_size, ""key size sanity check failed"");

        // get the size of the value string
        uint32_t value_string_size = 0;
        if (!_vox_file_read_uint32(fp, &value_string_size))
            return false;
        // allocate space for the value, and read it in.
        if (dict->buffer_mem_used + value_string_size > k_vox_max_dict_buffer_size)
            return false;
        char* value = &dict->buffer[dict->buffer_mem_used];
        dict->buffer_mem_used += value_string_size + 1;    // + 1 for zero terminator
        if (!_vox_file_read(fp, value, value_string_size))
            return false;
        value[value_string_size] = 0;    // zero-terminate
        ogt_assert(_vox_strlen(value) == value_string_size, ""value size sanity check failed"");
        // now assign it in the dictionary
        dict->keys[dict->num_key_value_pairs] = key;
        dict->values[dict->num_key_value_pairs] = value;
        dict->num_key_value_pairs++;
    }

    return true;
}

// helper for looking up in the dictionary
static const char* _vox_dict_get_value_as_string(const _vox_dictionary* dict, const char* key_to_find, const char* default_value = NULL) {
    for (uint32_t i = 0; i < dict->num_key_value_pairs; i++)
        if (_vox_strcasecmp(dict->keys[i], key_to_find) == 0)
            return dict->values[i];
    return default_value;
}

static bool _vox_dict_get_value_as_bool(const _vox_dictionary* dict, const char* key_to_find, bool default_value) {
    const char* str = _vox_dict_get_value_as_string(dict, key_to_find, NULL);
    if (!str)
        return default_value;
    return str[0] == '1' ? true : false;
}

static uint32_t _vox_dict_get_value_as_uint32(const _vox_dictionary* dict, const char* key_to_find, uint32_t default_value) {
    const char* str = _vox_dict_get_value_as_string(dict, key_to_find, NULL);
    if (!str)
        return default_value;
    uint32_t value;
    _vox_str_scanf(str, ""%i"", &value);
    return value;
}

// lookup table for _vox_make_transform_from_dict_strings
static const vec3 k_vectors[4] = {
vec3_make(1.0f, 0.0f, 0.0f),
vec3_make(0.0f, 1.0f, 0.0f),
vec3_make(0.0f, 0.0f, 1.0f),
vec3_make(0.0f, 0.0f, 0.0f)    // invalid!
};

// lookup table for _vox_make_transform_from_dict_strings
static const uint32_t k_row2_index[] = { UINT32_MAX, UINT32_MAX, UINT32_MAX, 2, UINT32_MAX, 1, 0, UINT32_MAX };


static ogt_vox_transform _vox_make_transform_from_dict_strings(const char* rotation_string, const char* translation_string) {
    ogt_vox_transform transform = ogt_vox_transform_get_identity();

    if (rotation_string != NULL) {
        // compute the per-row indexes into k_vectors[] array.
        // unpack rotation bits.
        //  bits  : meaning
        //  0 - 1 : index of the non-zero entry in the first row
        //  2 - 3 : index of the non-zero entry in the second row
        uint32_t packed_rotation_bits = atoi(rotation_string);
        uint32_t row0_vec_index = (packed_rotation_bits >> 0) & 3;
        uint32_t row1_vec_index = (packed_rotation_bits >> 2) & 3;
        uint32_t row2_vec_index = k_row2_index[(1 << row0_vec_index) | (1 << row1_vec_index)];    // process of elimination to determine row 2 index based on row0/row1 being one of {0,1,2} choose 2.
        ogt_assert(row2_vec_index != UINT32_MAX, ""invalid packed rotation bits"");

        // unpack rotation bits for vector signs
        //  bits  : meaning
        //  4     : the sign in the first row  (0 : positive; 1 : negative)
        //  5     : the sign in the second row (0 : positive; 1 : negative)
        //  6     : the sign in the third row  (0 : positive; 1 : negative)
        vec3 row0 = k_vectors[row0_vec_index];
        vec3 row1 = k_vectors[row1_vec_index];
        vec3 row2 = k_vectors[row2_vec_index];
        if (packed_rotation_bits & (1 << 4))
            row0 = vec3_negate(row0);
        if (packed_rotation_bits & (1 << 5))
            row1 = vec3_negate(row1);
        if (packed_rotation_bits & (1 << 6))
            row2 = vec3_negate(row2);

        // magicavoxel stores rows, we need columns, so we do the swizzle here into columns
        transform.m00 = row0.x; transform.m01 = row1.x; transform.m02 = row2.x;
        transform.m10 = row0.y; transform.m11 = row1.y; transform.m12 = row2.y;
        transform.m20 = row0.z; transform.m21 = row1.z; transform.m22 = row2.z;
    }

    if (translation_string != NULL) {
        int32_t x = 0;
        int32_t y = 0;
        int32_t z = 0;
        _vox_str_scanf(translation_string, ""%i %i %i"", &x, &y, &z);
        transform.m30 = (float)x;
        transform.m31 = (float)y;
        transform.m32 = (float)z;
    }
    return transform;
}

enum _vox_scene_node_type
{
    k_nodetype_invalid = 0,    // has not been parsed yet.
    k_nodetype_group = 1,
    k_nodetype_transform = 2,
    k_nodetype_shape = 3,
};

struct _vox_keyframe_transform {
    uint32_t          frame_index;
    ogt_vox_transform frame_transform;
};

struct _vox_keyframe_shape {
    uint32_t frame_index;
    uint32_t model_index;
};

struct _vox_scene_node_ {
    _vox_scene_node_type node_type;    // only gets assigned when this has been parsed, otherwise will be k_nodetype_invalid
    union {
        // used only when node_type == k_nodetype_transform
        struct {
            char              name[NAME_MAX_LEN];
            ogt_vox_transform transform;                // root transform (always the first anim frame transform in the case of animated transform)
            uint32_t          child_node_id;
            uint32_t          layer_id;
            bool              hidden;
            uint32_t          num_keyframes;           // number of key frames in this transform
            size_t            keyframe_offset;         // offset in misc_data array where the _vox_keyframe_transform data is stored.
            bool              loop;                    // keyframes are marked as looping
        } transform;
        // used only when node_type == k_nodetype_group
        struct {
            uint32_t first_child_node_id_index; // the index of the first child node ID within the ChildNodeID array
            uint32_t num_child_nodes;           // number of child node IDs starting at the first index
        } group;
        // used only when node_type == k_nodetype_shape
        struct {
            uint32_t model_id;                 // always the first model_id in the case of an animated shape
            uint32_t num_keyframes;            // number of key frames in this transform
            size_t   keyframe_offset;          // offset in misc_data array where the _vox_keyframe_shape data is stored
            bool     loop;                     // keyframes are marked as looping
        } shape;
    } u;
};

static void clear_anim_transform(ogt_vox_anim_transform* anim) {
    anim->num_keyframes = 0;
    anim->keyframes = NULL;
    anim->loop = false;
}

static void clear_anim_model(ogt_vox_anim_model* anim) {
    anim->num_keyframes = 0;
    anim->keyframes = NULL;
    anim->loop = false;
}

static void generate_instances_for_node(
    _vox_array<const _vox_scene_node_*>& stack, const _vox_array<_vox_scene_node_>& nodes, uint32_t node_index, const _vox_array<uint32_t>& child_id_array, const _vox_array<ogt_vox_model*>& model_ptrs,
    _vox_array<ogt_vox_instance>& instances, _vox_suballoc_array& misc_data, _vox_array<ogt_vox_group>& groups, uint32_t group_index, bool generate_keyframes)
{
    const _vox_scene_node_* node = &nodes[node_index];
    switch (node->node_type)
    {
    case k_nodetype_transform:
    {
        stack.push_back(node);
        generate_instances_for_node(stack, nodes, node->u.transform.child_node_id, child_id_array, model_ptrs, instances, misc_data, groups, group_index, generate_keyframes);
        stack.pop_back();
        break;
    }
    case k_nodetype_group:
    {
        // create a new group only if we're generating groups.
        uint32_t next_group_index = 0;
        {
            const _vox_scene_node_* last_transform = stack.peek_back(0);
            ogt_assert(last_transform->node_type == k_nodetype_transform, ""expected transform node prior to group node"");

            next_group_index = (uint32_t)groups.size();
            ogt_vox_group group;
            group.parent_group_index = group_index;
            group.transform = last_transform->u.transform.transform;
            group.hidden = last_transform->u.transform.hidden;
            group.layer_index = last_transform->u.transform.layer_id;
            group.name = 0;
            const char* transform_last_name = last_transform->u.transform.name;
            if (transform_last_name && transform_last_name[0]) {
                group.name = (const char*)misc_data.push_string(transform_last_name);
            }
            clear_anim_transform(&group.transform_anim);
            if (generate_keyframes) {
                group.transform_anim.num_keyframes = last_transform->u.transform.num_keyframes;
                group.transform_anim.keyframes = (const ogt_vox_keyframe_transform*)(last_transform->u.transform.keyframe_offset);
                group.transform_anim.loop = last_transform->u.transform.loop;
            }
            groups.push_back(group);
        }

        stack.push_back(node);
        const uint32_t* child_node_ids = (const uint32_t*)&child_id_array[node->u.group.first_child_node_id_index];
        for (uint32_t i = 0; i < node->u.group.num_child_nodes; i++) {
            generate_instances_for_node(stack, nodes, child_node_ids[i], child_id_array, model_ptrs, instances, misc_data, groups, next_group_index, generate_keyframes);
        }
        stack.pop_back();
        break;
    }
    case k_nodetype_shape:
    {
        ogt_assert(node->u.shape.model_id < model_ptrs.size(), ""unexpected model id for shape node"");
        if (node->u.shape.model_id < model_ptrs.size() &&    // model ID is valid
            model_ptrs[node->u.shape.model_id] != NULL)     // model is non-NULL.
        {
            const _vox_scene_node_* last_transform = stack.peek_back(0);
            const _vox_scene_node_* last_group = stack.peek_back(1);
            (void)last_group;
            ogt_assert(last_transform->node_type == k_nodetype_transform, ""parent node type to a shape node must be a transform node"");
            ogt_assert(last_group->node_type == k_nodetype_group, ""grandparent node type to a shape node must be a group node"");

            ogt_vox_instance new_instance;
            new_instance.model_index = node->u.shape.model_id;
            new_instance.transform = last_transform->u.transform.transform;
            new_instance.layer_index = last_transform->u.transform.layer_id;
            new_instance.group_index = group_index;
            new_instance.hidden = last_transform->u.transform.hidden;
            // if we got a transform name, allocate space in misc_data for it and keep track of the index
            // within string data. This will be patched to a real pointer at the very end.
            new_instance.name = 0;
            const char* transform_last_name = last_transform->u.transform.name;
            if (transform_last_name && transform_last_name[0]) {
                new_instance.name = (const char*)misc_data.push_string(transform_last_name);
            }
            // generate keyframes if necessary.
            clear_anim_transform(&new_instance.transform_anim);
            clear_anim_model(&new_instance.model_anim);
            if (generate_keyframes) {
                new_instance.model_anim.num_keyframes = node->u.shape.num_keyframes;
                new_instance.model_anim.keyframes = (const ogt_vox_keyframe_model*)(node->u.shape.keyframe_offset);
                new_instance.model_anim.loop = node->u.shape.loop;
                new_instance.transform_anim.num_keyframes = last_transform->u.transform.num_keyframes;
                new_instance.transform_anim.keyframes = (const ogt_vox_keyframe_transform*)(last_transform->u.transform.keyframe_offset);
                new_instance.transform_anim.loop = last_transform->u.transform.loop;
            }

            // create the instance
            instances.push_back(new_instance);
        }
        break;
    }
    default:
    {
        ogt_assert(0, ""unhandled node type"");
    }
    }
}

// returns true if the 2 models are content-wise identical.
static bool _vox_models_are_equal(const ogt_vox_model* lhs, const ogt_vox_model* rhs) {
    // early out: if hashes don't match, they can't be equal
    // if hashes match, they might be equal OR there might be a hash collision.
    if (lhs->voxel_hash != rhs->voxel_hash)
        return false;
    // early out: if size of voxels in the model's grid don't match, they can't be equal.
    if (lhs->size_x != rhs->size_x || lhs->size_y != rhs->size_y || lhs->size_z != rhs->size_z)
        return false;
    // Finally, we know their hashes are the same, and their dimensions are the same
    // but they are only equal if they have exactly the same voxel data.
    uint32_t num_voxels_lhs = lhs->size_x * lhs->size_y * lhs->size_z;
    return memcmp(lhs->voxel_data, rhs->voxel_data, num_voxels_lhs) == 0 ? true : false;
}

// wraps the specified frame_index such that it is inclusively between the first and last loop frames
uint32_t compute_looped_frame_index(uint32_t first_loop_frame, uint32_t last_loop_frame, uint32_t frame_index)
{
    uint32_t loop_len = 1 + last_loop_frame - first_loop_frame;
    uint32_t looped_frame_index;
    if (frame_index >= first_loop_frame) {
        uint32_t frames_since_first_frame = frame_index - first_loop_frame;
        looped_frame_index = first_loop_frame + (frames_since_first_frame % loop_len);
    }
    else {
        uint32_t frames_since_first_frame = (first_loop_frame - frame_index - 1);
        looped_frame_index = last_loop_frame - (frames_since_first_frame % loop_len);
    }
    ogt_assert(looped_frame_index >= first_loop_frame && looped_frame_index <= last_loop_frame, ""bug in looping logic!"");
    return looped_frame_index;
}

static ogt_vox_transform sample_keyframe_transform(const ogt_vox_keyframe_transform* keyframes, uint32_t num_keyframes, bool loop, uint32_t frame_index)
{
    ogt_assert(num_keyframes >= 1, ""need at least one keyframe to sample"");
    if (loop) {
        frame_index = compute_looped_frame_index(keyframes[0].frame_index, keyframes[num_keyframes - 1].frame_index, frame_index);
    }
    if (frame_index <= keyframes[0].frame_index)
        return keyframes[0].transform;
    if (frame_index >= keyframes[num_keyframes - 1].frame_index)
        return keyframes[num_keyframes - 1].transform;
    for (int32_t f = (int32_t)num_keyframes - 2; f >= 0; f--) {
        if (frame_index >= keyframes[f].frame_index) {
            // orientation always snaps
            uint32_t next_frame = keyframes[f + 1].frame_index;
            uint32_t curr_frame = keyframes[f + 0].frame_index;
            float t = (frame_index - curr_frame) / (float)(next_frame - curr_frame);
            float t_inv = 1.0f - t;
            // orientation always snaps to the earlier frame
            ogt_vox_transform curr_transform = keyframes[f + 0].transform;
            // position gets interpolated with rounding towards zero - TODO(jpaver) or should it be -INF?
            const ogt_vox_transform& next_transform = keyframes[f + 1].transform;
            curr_transform.m30 = (float)(int32_t)((next_transform.m30 * t) + (curr_transform.m30 * t_inv));
            curr_transform.m31 = (float)(int32_t)((next_transform.m31 * t) + (curr_transform.m31 * t_inv));
            curr_transform.m32 = (float)(int32_t)((next_transform.m32 * t) + (curr_transform.m32 * t_inv));
            return curr_transform;

        }
    }
    ogt_assert(0, ""shouldn't reach here"");
    return keyframes[0].transform;
}

ogt_vox_transform ogt_vox_sample_anim_transform(const ogt_vox_anim_transform* anim, uint32_t frame_index)
{
    return sample_keyframe_transform(anim->keyframes, anim->num_keyframes, anim->loop, frame_index);
}

uint32_t ogt_vox_sample_anim_model(const ogt_vox_anim_model* anim, uint32_t frame_index)
{
    ogt_assert(anim->num_keyframes >= 1, ""need at least one keyframe to sample"");
    if (anim->loop) {
        frame_index = compute_looped_frame_index(anim->keyframes[0].frame_index, anim->keyframes[anim->num_keyframes - 1].frame_index, frame_index);
    }
    if (frame_index <= anim->keyframes[0].frame_index)
        return anim->keyframes[0].model_index;
    if (frame_index >= anim->keyframes[anim->num_keyframes - 1].frame_index)
        return anim->keyframes[anim->num_keyframes - 1].model_index;
    for (int32_t f = (int32_t)anim->num_keyframes - 2; f >= 0; f--) {
        if (frame_index >= anim->keyframes[f].frame_index) {
            return anim->keyframes[f + 0].model_index;
        }
    }
    ogt_assert(0, ""shouldn't reach here"");
    return anim->keyframes[0].model_index;
}

// computes the flattened transform for an instance on a given frame (pass the scene so that group transform hierarchy can also be considered)
ogt_vox_transform ogt_vox_sample_group_transform_global(const ogt_vox_group* group, uint32_t frame_index, const ogt_vox_scene* scene)
{
    ogt_vox_transform flattened_transform = ogt_vox_sample_group_transform_local(group, frame_index);
    uint32_t group_index = group->parent_group_index;
    while (group_index != k_invalid_group_index) {
        group = &scene->groups[group_index];
        ogt_vox_transform group_transform = ogt_vox_sample_group_transform_local(group, frame_index);
        flattened_transform = ogt_vox_transform_multiply(flattened_transform, group_transform);
        group_index = group->parent_group_index;
    }
    return flattened_transform;
}
// computes the global transform of a group on a given frame (global = flattened = world space)
ogt_vox_transform ogt_vox_sample_instance_transform_global(const ogt_vox_instance* instance, uint32_t frame_index, const ogt_vox_scene* scene)
{
    ogt_vox_transform final_transform = ogt_vox_sample_instance_transform_local(instance, frame_index);
    uint32_t group_index = instance->group_index;
    if (group_index == k_invalid_group_index)
        return final_transform;
    const ogt_vox_group* group = &scene->groups[group_index];
    return ogt_vox_transform_multiply(final_transform, ogt_vox_sample_group_transform_global(group, frame_index, scene));
}

uint32_t ogt_vox_sample_instance_model(const ogt_vox_instance* instance, uint32_t frame_index)
{
    return instance->model_anim.num_keyframes ? ogt_vox_sample_anim_model(&instance->model_anim, frame_index) : instance->model_index;
}

ogt_vox_transform ogt_vox_sample_instance_transform_local(const ogt_vox_instance* instance, uint32_t frame_index)
{
    return instance->transform_anim.num_keyframes ? ogt_vox_sample_anim_transform(&instance->transform_anim, frame_index) : instance->transform;
}

ogt_vox_transform ogt_vox_sample_group_transform_local(const ogt_vox_group* group, uint32_t frame_index)
{
    return group->transform_anim.num_keyframes ? ogt_vox_sample_anim_transform(&group->transform_anim, frame_index) : group->transform;
}

const ogt_vox_scene* ogt_vox_read_scene_with_flags(const uint8_t* buffer, uint32_t buffer_size, uint32_t read_flags) {
    _vox_file file = { buffer, buffer_size, 0 };
    _vox_file* fp = &file;

    // parsing state/context
    _vox_array<ogt_vox_model*>   model_ptrs;
    _vox_array<_vox_scene_node_> nodes;
    _vox_array<ogt_vox_instance> instances;
    _vox_array<ogt_vox_cam>      cameras;
    _vox_suballoc_array           misc_data;
    _vox_array<ogt_vox_layer>    layers;
    _vox_array<ogt_vox_group>    groups;
    _vox_array<uint32_t>         child_ids;
    ogt_vox_palette              palette;
    ogt_vox_matl_array           materials;
    _vox_dictionary              dict;
    uint32_t                     size_x = 0;
    uint32_t                     size_y = 0;
    uint32_t                     size_z = 0;
    uint8_t                      index_map[256];
    bool                         found_index_map_chunk = false;

    // size some of our arrays to prevent resizing during the parsing for smallish cases.
    model_ptrs.reserve(64);
    instances.reserve(256);
    cameras.reserve(4);
    child_ids.reserve(256);
    nodes.reserve(16);
    layers.reserve(8);
    groups.reserve(0);
    misc_data.reserve(1024);

    // push a sentinel character into these datastructures. This allows us to keep indexes
    // rather than pointers into data-structures that grow, and still allow an index of 0
    // to means invalid
    child_ids.push_back(UINT32_MAX);

    // copy the default palette into the scene. It may get overwritten by a palette chunk later
    memcpy(&palette, k_default_vox_palette, sizeof(ogt_vox_palette));

    // zero initialize materials (this sets valid defaults)
    memset(&materials, 0, sizeof(materials));

    // load and validate fileheader and file version.
    uint32_t file_header = 0;
    uint32_t file_version = 0;
    _vox_file_read_uint32(fp, &file_header);
    _vox_file_read_uint32(fp, &file_version);
    if (file_header != CHUNK_ID_VOX_ || (file_version != 150 && file_version != 200))
        return NULL;

    // parse chunks until we reach the end of the file/buffer
    while (_vox_file_bytes_remaining(fp) >= sizeof(uint32_t) * 3)
    {
        // read the fields common to all chunks
        uint32_t chunk_id = 0;
        uint32_t chunk_size = 0;
        uint32_t chunk_child_size = 0;
        _vox_file_read_uint32(fp, &chunk_id);
        _vox_file_read_uint32(fp, &chunk_size);
        _vox_file_read_uint32(fp, &chunk_child_size);

        // process the chunk.
        switch (chunk_id)
        {
        case CHUNK_ID_MAIN:
        {
            break;
        }
        case CHUNK_ID_SIZE:
        {
            ogt_assert(chunk_size == CHUNK_HEADER_LEN && chunk_child_size == 0, ""unexpected chunk size for SIZE chunk"");
            _vox_file_read_uint32(fp, &size_x);
            _vox_file_read_uint32(fp, &size_y);
            _vox_file_read_uint32(fp, &size_z);
            ogt_assert(size_x && size_y && size_z, ""SIZE chunk has zero size"");
            break;
        }
        case CHUNK_ID_XYZI:
        {
            ogt_assert(size_x && size_y && size_z, ""expected a SIZE chunk before XYZI chunk"");
            // read the number of voxels to process for this moodel
            uint32_t num_voxels_in_chunk = 0;
            _vox_file_read_uint32(fp, &num_voxels_in_chunk);
            if (num_voxels_in_chunk != 0 || (read_flags & k_read_scene_flags_keep_empty_models_instances)) {
                uint32_t voxel_count = size_x * size_y * size_z;
                ogt_vox_model* model = (ogt_vox_model*)_vox_calloc(sizeof(ogt_vox_model) + voxel_count);        // 1 byte for each voxel
                if (!model)
                    return NULL;
                uint8_t* voxel_data = (uint8_t*)&model[1];

                // insert the model into the model array
                model_ptrs.push_back(model);

                // now setup the model
                model->size_x = size_x;
                model->size_y = size_y;
                model->size_z = size_z;
                model->voxel_data = voxel_data;

                // setup some strides for computing voxel index based on x/y/z
                const uint32_t k_stride_x = 1;
                const uint32_t k_stride_y = size_x;
                const uint32_t k_stride_z = size_x * size_y;

                // read this many voxels and store it in voxel data.
                const uint8_t* packed_voxel_data = (const uint8_t*)_vox_file_data_pointer(fp);
                const uint32_t voxels_to_read = _vox_min(_vox_file_bytes_remaining(fp) / 4, num_voxels_in_chunk);
                for (uint32_t i = 0; i < voxels_to_read; i++) {
                    uint8_t x = packed_voxel_data[i * 4 + 0];
                    uint8_t y = packed_voxel_data[i * 4 + 1];
                    uint8_t z = packed_voxel_data[i * 4 + 2];
                    uint8_t color_index = packed_voxel_data[i * 4 + 3];
                    ogt_assert(x < size_x && y < size_y && z < size_z, ""invalid data in XYZI chunk"");
                    voxel_data[(x * k_stride_x) + (y * k_stride_y) + (z * k_stride_z)] = color_index;
                }
                _vox_file_seek_forwards(fp, num_voxels_in_chunk * 4);
                // compute the hash of the voxels in this model-- used to accelerate duplicate models checking.
                model->voxel_hash = _vox_hash(voxel_data, size_x * size_y * size_z);
            }
            else {
                model_ptrs.push_back(NULL);
            }
            break;
        }
        case CHUNK_ID_RGBA:
        {
            ogt_assert(chunk_size == sizeof(palette), ""unexpected chunk size for RGBA chunk"");
            _vox_file_read(fp, &palette, sizeof(palette));
            break;
        }
        case CHUNK_ID_nTRN:
        {
            uint32_t node_id = 0;
            _vox_file_read_uint32(fp, &node_id);

            // Parse the node dictionary, which can contain:
            //   _name:   string
            //   _hidden: 0/1
            //   _loop:   0/1
            _vox_file_read_dict(&dict, fp);
            char node_name[NAME_MAX_LEN];
            _vox_strcpy_static(node_name, _vox_dict_get_value_as_string(&dict, ""_name"", """"));
            bool hidden = _vox_dict_get_value_as_bool(&dict, ""_hidden"", false);
            bool loop = _vox_dict_get_value_as_bool(&dict, ""_loop"", false);

            // get other properties.
            uint32_t child_node_id = 0, reserved_id = 0, layer_id = 0, num_frames = 0;
            _vox_file_read_uint32(fp, &child_node_id);
            _vox_file_read_uint32(fp, &reserved_id);
            _vox_file_read_uint32(fp, &layer_id);
            _vox_file_read_uint32(fp, &num_frames);
            ogt_assert(reserved_id == UINT32_MAX, ""unexpected values for reserved_id in nTRN chunk"");
            ogt_assert(num_frames > 0, ""must have at least 1 frame in nTRN chunk"");

            // make space in misc_data array for the number of transforms we'll need for this node
            ogt_vox_keyframe_transform* keyframes = misc_data.alloc_many<ogt_vox_keyframe_transform>(num_frames);
            size_t keyframe_offset = misc_data.offset_of(keyframes);

            for (uint32_t i = 0; i < num_frames; i++) {
                // Parse the frame dictionary that contains:
                //   _r : int8 ROTATION (c)
                //   _t : int32x3 translation
                //   _f : uint32_t frame index
                _vox_file_read_dict(&dict, fp);
                const char* rotation_value = _vox_dict_get_value_as_string(&dict, ""_r"");
                const char* translation_value = _vox_dict_get_value_as_string(&dict, ""_t"");
                keyframes[i].transform = _vox_make_transform_from_dict_strings(rotation_value, translation_value);
                keyframes[i].frame_index = _vox_dict_get_value_as_uint32(&dict, ""_f"", 0);
            }
            // setup the transform node.
            {
                nodes.grow_to_fit_index(node_id);
                _vox_scene_node_* transform_node = &nodes[node_id];
                transform_node->node_type = k_nodetype_transform;
                transform_node->u.transform.child_node_id = child_node_id;
                transform_node->u.transform.layer_id = layer_id;
                transform_node->u.transform.transform = keyframes[0].transform;
                transform_node->u.transform.hidden = hidden;
                transform_node->u.transform.num_keyframes = num_frames;
                transform_node->u.transform.keyframe_offset = keyframe_offset;
                transform_node->u.transform.loop = loop;
                _vox_strcpy_static(transform_node->u.transform.name, node_name);
            }
            break;
        }
        case CHUNK_ID_nGRP:
        {
            uint32_t node_id = 0;
            _vox_file_read_uint32(fp, &node_id);

            // parse the node dictionary - data is unused.
            _vox_file_read_dict(&dict, fp);

            // setup the group node
            nodes.grow_to_fit_index(node_id);
            _vox_scene_node_* group_node = &nodes[node_id];
            group_node->node_type = k_nodetype_group;
            group_node->u.group.first_child_node_id_index = 0;
            group_node->u.group.num_child_nodes = 0;

            // setup all child scene nodes to point back to this node.
            uint32_t num_child_nodes = 0;
            _vox_file_read_uint32(fp, &num_child_nodes);

            // allocate space for all the child node IDs
            if (num_child_nodes) {
                size_t prior_size = child_ids.size();
                ogt_assert(prior_size > 0, ""prior_size sanity test failed""); // should be guaranteed by the sentinel we reserved at the very beginning.
                child_ids.resize(prior_size + num_child_nodes);
                for (uint32_t i = 0; i < num_child_nodes; ++i) {
                    _vox_file_read_uint32(fp, &child_ids[prior_size + i]);
                }
                group_node->u.group.first_child_node_id_index = (uint32_t)prior_size;
                group_node->u.group.num_child_nodes = num_child_nodes;
            }
            break;
        }
        case CHUNK_ID_nSHP:
        {
            uint32_t node_id = 0;
            _vox_file_read_uint32(fp, &node_id);

            // parse the node dictionary
            _vox_file_read_dict(&dict, fp);
            bool loop = _vox_dict_get_value_as_bool(&dict, ""_loop"", false);

            uint32_t num_models = 0;
            _vox_file_read_uint32(fp, &num_models);
            ogt_assert(num_models > 0, ""must have at least 1 frame in nSHP chunk""); // must be 1 according to the spec.

            ogt_vox_keyframe_model* keyframes = misc_data.alloc_many<ogt_vox_keyframe_model>(num_models);
            size_t keyframe_offset = misc_data.offset_of(keyframes);

            for (uint32_t i = 0; i < num_models; i++) {
                // read model id
                _vox_file_read_uint32(fp, &keyframes[i].model_index);
                ogt_assert(keyframes[i].model_index < model_ptrs.size(), ""nSHP chunk references model_id that we have not loaded yet"");
                // read frame id
                _vox_file_read_dict(&dict, fp);
                keyframes[i].frame_index = _vox_dict_get_value_as_uint32(&dict, ""_f"", 0);
            }

            // setup the shape node
            nodes.grow_to_fit_index(node_id);
            _vox_scene_node_* shape_node = &nodes[node_id];
            shape_node->node_type = k_nodetype_shape;
            shape_node->u.shape.model_id = keyframes[0].model_index;
            shape_node->u.shape.num_keyframes = num_models;
            shape_node->u.shape.keyframe_offset = keyframe_offset;
            shape_node->u.shape.loop = loop;
            break;
        }
        case CHUNK_ID_IMAP:
        {
            ogt_assert(chunk_size == 256, ""unexpected chunk size for IMAP chunk"");
            _vox_file_read(fp, index_map, 256);
            found_index_map_chunk = true;
            break;
        }
        case CHUNK_ID_LAYR:
        {
            int32_t layer_id = 0;
            int32_t reserved_id = 0;
            _vox_file_read_int32(fp, &layer_id);
            _vox_file_read_dict(&dict, fp);
            _vox_file_read_int32(fp, &reserved_id);
            ogt_assert(reserved_id == -1, ""unexpected value for reserved_id in LAYR chunk"");

            layers.grow_to_fit_index(layer_id);
            layers[layer_id].name = NULL;
            layers[layer_id].color = { 255, 255, 255, 255 };
            layers[layer_id].hidden = false;

            // if we got a layer name from the LAYR dictionary, allocate space in misc_data for it and keep track of the index
            // within string data. This will be patched to a real pointer at the very end.
            const char* name_string = _vox_dict_get_value_as_string(&dict, ""_name"", NULL);
            if (name_string) {
                layers[layer_id].name = (const char*)misc_data.push_string(name_string);
            }
            layers[layer_id].hidden = _vox_dict_get_value_as_bool(&dict, ""_hidden"", false);

            const char* color_string = _vox_dict_get_value_as_string(&dict, ""_color"", NULL);
            if (color_string) {
                uint32_t r, g, b;
                _vox_str_scanf(color_string, ""%u %u %u"", &r, &g, &b);
                layers[layer_id].color.r = (uint8_t)r;
                layers[layer_id].color.g = (uint8_t)g;
                layers[layer_id].color.b = (uint8_t)b;
            }

            break;
        }
        case CHUNK_ID_MATL:
        {
            int32_t material_id = 0;
            _vox_file_read_int32(fp, &material_id);
            material_id = material_id & 0xFF; // incoming material 256 is material 0
            _vox_file_read_dict(&dict, fp);
            const char* type_string = _vox_dict_get_value_as_string(&dict, ""_type"", NULL);
            if (type_string) {
                if (0 == _vox_strcmp(type_string, ""_diffuse"")) {
                    materials.matl[material_id].type = ogt_matl_type_diffuse;
                }
                else if (0 == _vox_strcmp(type_string, ""_metal"")) {
                    materials.matl[material_id].type = ogt_matl_type_metal;
                }
                else if (0 == _vox_strcmp(type_string, ""_glass"")) {
                    materials.matl[material_id].type = ogt_matl_type_glass;
                }
                else if (0 == _vox_strcmp(type_string, ""_emit"")) {
                    materials.matl[material_id].type = ogt_matl_type_emit;
                }
                else if (0 == _vox_strcmp(type_string, ""_blend"")) {
                    materials.matl[material_id].type = ogt_matl_type_blend;
                }
                else if (0 == _vox_strcmp(type_string, ""_media"")) {
                    materials.matl[material_id].type = ogt_matl_type_media;
                }
            }
            const char* metal_string = _vox_dict_get_value_as_string(&dict, ""_metal"", NULL);
            if (metal_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_metal;
                materials.matl[material_id].metal = (float)atof(metal_string);
            }
            const char* rough_string = _vox_dict_get_value_as_string(&dict, ""_rough"", NULL);
            if (rough_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_rough;
                materials.matl[material_id].rough = (float)atof(rough_string);
            }
            const char* spec_string = _vox_dict_get_value_as_string(&dict, ""_spec"", NULL);
            if (spec_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_spec;
                materials.matl[material_id].spec = (float)atof(spec_string);
            }
            const char* ior_string = _vox_dict_get_value_as_string(&dict, ""_ior"", NULL);
            if (ior_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_ior;
                materials.matl[material_id].ior = (float)atof(ior_string);
            }
            const char* att_string = _vox_dict_get_value_as_string(&dict, ""_att"", NULL);
            if (att_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_att;
                materials.matl[material_id].att = (float)atof(att_string);
            }
            const char* flux_string = _vox_dict_get_value_as_string(&dict, ""_flux"", NULL);
            if (flux_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_flux;
                materials.matl[material_id].flux = (float)atof(flux_string);
            }
            const char* emit_string = _vox_dict_get_value_as_string(&dict, ""_emit"", NULL);
            if (emit_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_emit;
                materials.matl[material_id].emit = (float)atof(emit_string);
            }
            const char* ldr_string = _vox_dict_get_value_as_string(&dict, ""_ldr"", NULL);
            if (ldr_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_ldr;
                materials.matl[material_id].ldr = (float)atof(ldr_string);
            }
            const char* trans_string = _vox_dict_get_value_as_string(&dict, ""_trans"", NULL);
            if (trans_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_trans;
                materials.matl[material_id].trans = (float)atof(trans_string);
            }
            const char* alpha_string = _vox_dict_get_value_as_string(&dict, ""_alpha"", NULL);
            if (alpha_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_alpha;
                materials.matl[material_id].alpha = (float)atof(alpha_string);
            }
            const char* d_string = _vox_dict_get_value_as_string(&dict, ""_d"", NULL);
            if (d_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_d;
                materials.matl[material_id].d = (float)atof(d_string);
            }
            const char* sp_string = _vox_dict_get_value_as_string(&dict, ""_sp"", NULL);
            if (sp_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_sp;
                materials.matl[material_id].sp = (float)atof(sp_string);
            }
            const char* g_string = _vox_dict_get_value_as_string(&dict, ""_g"", NULL);
            if (g_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_g;
                materials.matl[material_id].g = (float)atof(g_string);
            }
            const char* media_string = _vox_dict_get_value_as_string(&dict, ""_media"", NULL);
            if (media_string) {
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_media;
                materials.matl[material_id].media = (float)atof(media_string);
            }
            break;
        }
        case CHUNK_ID_MATT:
        {
            int32_t material_id = 0;
            _vox_file_read_int32(fp, &material_id);
            material_id = material_id & 0xFF; // incoming material 256 is material 0

            // 0 : diffuse
            // 1 : metal
            // 2 : glass
            // 3 : emissive
            int32_t material_type = 0;
            _vox_file_read_int32(fp, &material_type);

            // diffuse  : 1.0
            // metal    : (0.0 - 1.0] : blend between metal and diffuse material
            // glass    : (0.0 - 1.0] : blend between glass and diffuse material
            // emissive : (0.0 - 1.0] : self-illuminated material
            float material_weight = 0.0f;
            _vox_file_read_float(fp, &material_weight);

            // bit(0) : Plastic
            // bit(1) : Roughness
            // bit(2) : Specular
            // bit(3) : IOR
            // bit(4) : Attenuation
            // bit(5) : Power
            // bit(6) : Glow
            // bit(7) : isTotalPower (*no value)
            uint32_t property_bits = 0u;
            _vox_file_read_uint32(fp, &property_bits);

            materials.matl[material_id].type = (ogt_matl_type)material_type;
            switch (material_type) {
            case ogt_matl_type_diffuse:
                break;
            case ogt_matl_type_metal:
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_metal;
                materials.matl[material_id].metal = material_weight;
                break;
            case ogt_matl_type_glass:
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_trans;
                materials.matl[material_id].trans = material_weight;
                break;
            case ogt_matl_type_emit:
                materials.matl[material_id].content_flags |= k_ogt_vox_matl_have_emit;
                materials.matl[material_id].emit = material_weight;
                break;
            }

            ogt_assert(chunk_size >= 16u, ""unexpected chunk size for MATT chunk"");
            const uint32_t remaining = chunk_size - 16u;
            _vox_file_seek_forwards(fp, remaining);
            break;
        }
        case CHUNK_ID_rCAM:
        {
            ogt_vox_cam camera;
            memset(&camera, 0, sizeof(camera));
            _vox_file_read_uint32(fp, &camera.camera_id);
            _vox_file_read_dict(&dict, fp);

            camera.mode = ogt_cam_mode_unknown;
            const char* mode_string = _vox_dict_get_value_as_string(&dict, ""_mode"", NULL);
            if (mode_string) {
                if (!_vox_strcmp(mode_string, ""pers"")) {
                    camera.mode = ogt_cam_mode_perspective;
                }
                else if (!_vox_strcmp(mode_string, ""free"")) {
                    camera.mode = ogt_cam_mode_free;
                }
                else if (!_vox_strcmp(mode_string, ""pano"")) {
                    camera.mode = ogt_cam_mode_pano;
                }
                else if (!_vox_strcmp(mode_string, ""iso"")) {
                    camera.mode = ogt_cam_mode_isometric;
                }
                else if (!_vox_strcmp(mode_string, ""orth"")) {
                    camera.mode = ogt_cam_mode_orthographic;
                }
            }
            const char* focus_string = _vox_dict_get_value_as_string(&dict, ""_focus"", NULL);
            if (focus_string) {
                _vox_str_scanf(focus_string, ""%f %f %f"", &camera.focus[0], &camera.focus[1], &camera.focus[2]);
            }
            const char* angle_string = _vox_dict_get_value_as_string(&dict, ""_angle"", NULL);
            if (angle_string) {
                _vox_str_scanf(angle_string, ""%f %f %f"", &camera.angle[0], &camera.angle[1], &camera.angle[2]);
            }
            const char* radius_string = _vox_dict_get_value_as_string(&dict, ""_radius"", NULL);
            if (radius_string) {
                _vox_str_scanf(angle_string, ""%i"", &camera.radius);
            }
            const char* frustum_string = _vox_dict_get_value_as_string(&dict, ""_frustum"", NULL);
            if (frustum_string) {
                _vox_str_scanf(frustum_string, ""%f"", &camera.frustum);
            }
            const char* fov_string = _vox_dict_get_value_as_string(&dict, ""_fov"", NULL);
            if (fov_string) {
                _vox_str_scanf(angle_string, ""%i"", &camera.fov);
            }

            cameras.push_back(camera);
            break;
        }
        // we don't handle rOBJ (just a dict of render settings), so we just skip the chunk payload.
        case CHUNK_ID_rOBJ:
        default:
        {
            _vox_file_seek_forwards(fp, chunk_size);
            break;
        }
        } // end switch

        if (g_progress_callback_func) {
            // we indicate progress as 0.8f * amount of buffer read + 0.2f at end after processing 
            if (!g_progress_callback_func(0.8f * (float)(fp->offset) / (float)(fp->buffer_size), g_progress_callback_user_data))
            {
                return 0;
            }
        }
    }

    // ok, now that we've parsed all scene nodes - walk the scene hierarchy, and generate instances
    // we can't do this while parsing chunks unfortunately because some chunks reference chunks
    // that are later in the file than them.
    if (nodes.size()) {
        bool generate_groups = read_flags & k_read_scene_flags_groups ? true : false;
        bool generate_keyframes = read_flags & k_read_scene_flags_keyframes ? true : false;
        // if we're not reading scene-embedded groups, we generate only one and then flatten all instance transforms.

        _vox_array< const _vox_scene_node_*> stack;
        stack.reserve(64);
        generate_instances_for_node(stack, nodes, 0, child_ids, model_ptrs, instances, misc_data, groups, k_invalid_group_index, generate_keyframes);

        // if caller doesn't want groups, we flatten out transforms for all instances and parent them to a single group
        if (!generate_groups) {
            // flatten all keyframes on instances.
            if (generate_keyframes) {
                _vox_array<uint32_t> frame_indices;
                frame_indices.reserve(256);
                for (uint32_t i = 0; i < instances.size(); i++) {
                    ogt_vox_instance* instance = &instances[i];
                    // populate frame_indices with those that are used by the instance or any parent group of the instance.
                    {
                        frame_indices.resize(0);
                        // first populate frame_indices with the keyframes on the instance itself
                        uint32_t start_index = 0;
                        const ogt_vox_keyframe_transform* instance_keyframes = misc_data.get_ptr<ogt_vox_keyframe_transform>((size_t)instance->transform_anim.keyframes);
                        for (uint32_t f = 0; f < instance->transform_anim.num_keyframes; f++) {
                            start_index = frame_indices.insert_unique_sorted(instance_keyframes[f].frame_index, start_index);
                        }
                        // now populate frame_index with the keyframes on any parent groups.
                        uint32_t group_index = instance->group_index;
                        while (group_index != k_invalid_group_index) {
                            const ogt_vox_group* group = &groups[group_index];
                            const ogt_vox_keyframe_transform* group_keyframes = misc_data.get_ptr<ogt_vox_keyframe_transform>((size_t)group->transform_anim.keyframes);
                            start_index = 0;
                            for (uint32_t f = 0; f < group->transform_anim.num_keyframes; f++) {
                                start_index = frame_indices.insert_unique_sorted(group_keyframes[f].frame_index, start_index);
                            }
                            group_index = group->parent_group_index;
                        }
                    }
                    // use the ordered frame indices to sample the flattened transform from the keyframes from the instance and all its parent groups
                    ogt_vox_keyframe_transform* new_keyframes = misc_data.alloc_many<ogt_vox_keyframe_transform>(frame_indices.size());
                    size_t new_keyframe_offset = misc_data.offset_of(new_keyframes);
                    for (uint32_t f = 0; f < frame_indices.size(); f++) {
                        uint32_t frame_index = frame_indices[f];
                        const ogt_vox_keyframe_transform* instance_keyframes = misc_data.get_ptr<ogt_vox_keyframe_transform>((size_t)instance->transform_anim.keyframes);
                        ogt_vox_transform flattened_transform = sample_keyframe_transform(instance_keyframes, instance->transform_anim.num_keyframes, instance->transform_anim.loop, frame_index);
                        uint32_t group_index = instance->group_index;
                        while (group_index != k_invalid_group_index) {
                            const ogt_vox_group* group = &groups[group_index];
                            const ogt_vox_keyframe_transform* group_keyframes = misc_data.get_ptr<ogt_vox_keyframe_transform>((size_t)group->transform_anim.keyframes);
                            ogt_vox_transform group_transform = sample_keyframe_transform(group_keyframes, group->transform_anim.num_keyframes, group->transform_anim.loop, frame_index);
                            flattened_transform = ogt_vox_transform_multiply(flattened_transform, group_transform);
                            group_index = groups[group_index].parent_group_index;
                        }
                        new_keyframes[f].frame_index = frame_index;
                        new_keyframes[f].transform = flattened_transform;
                    }
                    instance->transform_anim.num_keyframes = (uint32_t)frame_indices.size();
                    instance->transform_anim.keyframes = (ogt_vox_keyframe_transform*)new_keyframe_offset;
                }
            }

            // now flatten instance transforms if there is no group hierarchy
            for (uint32_t i = 0; i < instances.size(); i++) {
                ogt_vox_instance* instance = &instances[i];
                ogt_vox_transform flattened_transform = instance->transform;
                uint32_t group_index = instance->group_index;
                while (group_index != k_invalid_group_index) {
                    flattened_transform = ogt_vox_transform_multiply(flattened_transform, groups[group_index].transform);
                    group_index = groups[group_index].parent_group_index;
                }
                instance->transform = flattened_transform;
                instance->group_index = 0;
            }
            // add just a single parent group.
            groups.resize(0);
            ogt_vox_group root_group;
            root_group.name = 0;
            root_group.transform = ogt_vox_transform_get_identity();
            root_group.parent_group_index = k_invalid_group_index;
            root_group.layer_index = 0;
            root_group.hidden = false;
            clear_anim_transform(&root_group.transform_anim);
            groups.push_back(root_group);
        }
    }
    else if (model_ptrs.size() == 1) {
        // add a single instance
        ogt_vox_instance new_instance;
        new_instance.model_index = 0;
        new_instance.group_index = 0;
        new_instance.transform = ogt_vox_transform_get_identity();
        new_instance.layer_index = 0;
        new_instance.name = 0;
        new_instance.hidden = false;
        clear_anim_transform(&new_instance.transform_anim);
        clear_anim_model(&new_instance.model_anim);
        instances.push_back(new_instance);
        // adds a single group
        ogt_vox_group new_group;
        new_group.hidden = false;
        new_group.layer_index = 0;
        new_group.transform = ogt_vox_transform_get_identity();
        new_group.parent_group_index = k_invalid_group_index;
        clear_anim_transform(&new_group.transform_anim);
        new_group.name = 0;
        groups.push_back(new_group);
    }

    // if we didn't get a layer chunk -- just create a default layer.
    if (layers.size() == 0) {
        // go through all instances and ensure they are only mapped to layer 0
        for (uint32_t i = 0; i < instances.size(); i++)
            instances[i].layer_index = 0;
        // add a single layer
        ogt_vox_layer new_layer;
        new_layer.hidden = false;
        new_layer.name = NULL;
        layers.push_back(new_layer);
    }

    // To support index-level assumptions (eg. artists using top 16 colors for color/palette cycling,
    // other ranges for emissive etc), we must ensure the order of colors that the artist sees in the
    // magicavoxel tool matches the actual index we'll end up using here. Unfortunately, magicavoxel
    // does an unexpected thing when remapping colors in the editor using ctrl+drag within the palette.
    // Instead of remapping all indices in all models, it just keeps track of a display index to actual
    // palette map and uses that to show reordered colors in the palette window. This is how that
    // map works:
    //   displaycolor[k] = paletteColor[imap[k]]
    // To ensure our indices are in the same order as displayed by magicavoxel within the palette
    // window, we apply the mapping from the IMAP chunk both to the color palette and indices within each
    // voxel model.
    if (found_index_map_chunk)
    {
        // the imap chunk maps from display index to actual index.
        // generate an inverse index map (maps from actual index to display index)
        uint8_t index_map_inverse[256];
        for (uint32_t i = 0; i < 256; i++) {
            index_map_inverse[index_map[i]] = (uint8_t)i;
        }

        // reorder colors in the palette so the palette contains colors in display order
        ogt_vox_palette old_palette = palette;
        for (uint32_t i = 0; i < 256; i++) {
            uint32_t remapped_index = (index_map[i] + 255) & 0xFF;
            palette.color[i] = old_palette.color[remapped_index];
        }

        // reorder materials
        ogt_vox_matl_array old_materials = materials;
        for (uint32_t i = 0; i < 256; i++) {
            uint32_t remapped_i = (i + 255) & 0xFF;
            uint32_t remapped_index = index_map[remapped_i];
            materials.matl[i] = old_materials.matl[remapped_index];
        }

        // ensure that all models are remapped so they are using display order palette indices.
        for (uint32_t i = 0; i < model_ptrs.size(); i++) {
            ogt_vox_model* model = model_ptrs[i];
            if (model) {
                uint32_t num_voxels = model->size_x * model->size_y * model->size_z;
                uint8_t* voxels = (uint8_t*)&model[1];
                for (uint32_t j = 0; j < num_voxels; j++)
                    voxels[j] = 1 + index_map_inverse[voxels[j]];
            }
        }
    }

    // rotate the scene palette now so voxel indices can just map straight into the palette
    {
        ogt_vox_rgba last_color = palette.color[255];
        for (uint32_t i = 255; i > 0; i--)
            palette.color[i] = palette.color[i - 1];
        palette.color[0] = last_color;
        palette.color[0].a = 0;  // alpha is zero for the 0th color as that color index represents a transparent voxel.
    }

    // check for models that are identical by doing a pair-wise compare. If we find identical
    // models, we'll end up with NULL gaps in the model_ptrs array, but instances will have
    // been remapped to keep the earlier model.
    if (0 == (read_flags & k_read_scene_flags_keep_duplicate_models)) {
        for (uint32_t i = 0; i < model_ptrs.size(); i++) {
            if (!model_ptrs[i])
                continue;
            for (uint32_t j = i + 1; j < model_ptrs.size(); j++) {
                if (!model_ptrs[j] || !_vox_models_are_equal(model_ptrs[i], model_ptrs[j]))
                    continue;
                // model i and model j are the same, so free model j and keep model i.
                _vox_free(model_ptrs[j]);
                model_ptrs[j] = NULL;
                // remap all instances that were referring to j to now refer to i.
                for (uint32_t k = 0; k < instances.size(); k++) {
                    if (instances[k].model_index == j)
                        instances[k].model_index = i;
                    if (instances[k].model_anim.num_keyframes) {
                        ogt_vox_keyframe_model* keyframes = misc_data.get_ptr<ogt_vox_keyframe_model>((size_t)instances[k].model_anim.keyframes);
                        for (uint32_t f = 0; f < instances[k].model_anim.num_keyframes; f++) {
                            if (keyframes[f].model_index == j)
                                keyframes[f].model_index = i;
                        }
                    }
                }
            }
        }
    }

    // sometimes a model can be created which has no solid voxels within just due to the
    // authoring flow within magicavoxel. We have already have prevented creation of
    // instances that refer to empty models, but here we want to compact the model_ptrs
    // array such that it contains no more NULL models. This also requires we remap the
    // indices for instances so they continue to refer to their correct models.
    if (0 == (read_flags & k_read_scene_flags_keep_empty_models_instances))
    {
        // first, check to see if we find any empty model. No need to do work otherwise.
        bool found_empty_model = false;
        for (uint32_t i = 0; i < model_ptrs.size() && !found_empty_model; i++) {
            if (model_ptrs[i] == NULL)
                found_empty_model = true;
        }
        if (found_empty_model) {
            // build a remap table for all instances and simultaneously compact the model_ptrs array.
            uint32_t* model_remap = (uint32_t*)_vox_malloc(model_ptrs.size() * sizeof(uint32_t));
            uint32_t num_output_models = 0;
            for (uint32_t i = 0; i < model_ptrs.size(); i++) {
                if (model_ptrs[i] != NULL) {
                    model_ptrs[num_output_models] = model_ptrs[i];
                    model_remap[i] = num_output_models;
                    num_output_models++;
                }
                else {
                    model_remap[i] = UINT32_MAX;
                }
            }
            model_ptrs.resize(num_output_models);

            // remap all instances to point to the compacted model index
            for (uint32_t i = 0; i < instances.size(); i++) {
                uint32_t new_model_index = model_remap[instances[i].model_index];
                ogt_assert(new_model_index != UINT32_MAX, ""invalid model index found in instances array""); // we should have suppressed instances already that point to NULL models.
                instances[i].model_index = new_model_index;
            }

            // free remap table
            _vox_free(model_remap);
            model_remap = NULL;
        }
    }

    // finally, construct the output scene..
    size_t scene_size = sizeof(ogt_vox_scene) + misc_data.size();
    ogt_vox_scene* scene = (ogt_vox_scene*)_vox_calloc(scene_size);
    {
        // copy name data into the scene
        char* scene_misc_data = (char*)&scene[1];
        memcpy(scene_misc_data, misc_data.get_ptr<char>(0), sizeof(char) * misc_data.size());

        // copy instances over to scene
        size_t num_scene_instances = instances.size();
        ogt_vox_instance* scene_instances = (ogt_vox_instance*)_vox_malloc(sizeof(ogt_vox_instance) * num_scene_instances);
        if (num_scene_instances) {
            memcpy(scene_instances, &instances[0], sizeof(ogt_vox_instance) * num_scene_instances);
        }
        scene->instances = scene_instances;
        scene->num_instances = (uint32_t)instances.size();

        // copy cameras over to scene
        size_t num_scene_cameras = cameras.size();
        ogt_vox_cam* scene_cameras = (ogt_vox_cam*)_vox_malloc(sizeof(ogt_vox_cam) * num_scene_cameras);
        if (num_scene_cameras) {
            memcpy(scene_cameras, &cameras[0], sizeof(ogt_vox_cam) * num_scene_cameras);
        }
        scene->cameras = scene_cameras;
        scene->num_cameras = (uint32_t)cameras.size();

        // copy model pointers over to the scene,
        size_t num_scene_models = model_ptrs.size();
        ogt_vox_model** scene_models = (ogt_vox_model**)_vox_malloc(sizeof(ogt_vox_model*) * num_scene_models);
        if (num_scene_models)
            memcpy(scene_models, &model_ptrs[0], sizeof(ogt_vox_model*) * num_scene_models);
        scene->models = (const ogt_vox_model**)scene_models;
        scene->num_models = (uint32_t)num_scene_models;

        // copy layer pointers over to the scene
        size_t num_scene_layers = layers.size();
        ogt_vox_layer* scene_layers = (ogt_vox_layer*)_vox_malloc(sizeof(ogt_vox_layer) * num_scene_layers);
        memcpy(scene_layers, &layers[0], sizeof(ogt_vox_layer) * num_scene_layers);
        scene->layers = scene_layers;
        scene->num_layers = (uint32_t)num_scene_layers;

        // copy group pointers over to the scene
        size_t num_scene_groups = groups.size();
        ogt_vox_group* scene_groups = num_scene_groups ? (ogt_vox_group*)_vox_malloc(sizeof(ogt_vox_group) * num_scene_groups) : NULL;
        if (num_scene_groups)
            memcpy(scene_groups, &groups[0], sizeof(ogt_vox_group) * num_scene_groups);
        scene->groups = scene_groups;
        scene->num_groups = (uint32_t)num_scene_groups;

        // now patch up group name pointers to point into the scene string area
        for (uint32_t i = 0; i < num_scene_groups; i++) {
            if (scene_groups[i].name)
                scene_groups[i].name = scene_misc_data + (size_t)scene_groups[i].name;
            if (scene_groups[i].transform_anim.num_keyframes)
                scene_groups[i].transform_anim.keyframes = (const ogt_vox_keyframe_transform*)(scene_misc_data + (size_t)scene_groups[i].transform_anim.keyframes);
        }

        // now patch up instance name pointers to point into the scene string area
        for (uint32_t i = 0; i < num_scene_instances; i++) {
            if (scene_instances[i].name)
                scene_instances[i].name = scene_misc_data + (size_t)scene_instances[i].name;
            if (scene_instances[i].transform_anim.num_keyframes)
                scene_instances[i].transform_anim.keyframes = (const ogt_vox_keyframe_transform*)(scene_misc_data + (size_t)scene_instances[i].transform_anim.keyframes);
            if (scene_instances[i].model_anim.num_keyframes)
                scene_instances[i].model_anim.keyframes = (const ogt_vox_keyframe_model*)(scene_misc_data + (size_t)scene_instances[i].model_anim.keyframes);
        }

        // now patch up layer name pointers to point into the scene string area
        for (uint32_t i = 0; i < num_scene_layers; i++)
            if (scene_layers[i].name)
                scene_layers[i].name = scene_misc_data + (size_t)scene_layers[i].name;

        // copy the palette.
        scene->palette = palette;

        // copy the materials.
        scene->materials = materials;
    }

    if (g_progress_callback_func) {
        // we indicate progress as complete, but don't check for cancel as finished
        g_progress_callback_func(1.0f, g_progress_callback_user_data);
    }
    return scene;
}

const ogt_vox_scene* ogt_vox_read_scene(const uint8_t* buffer, uint32_t buffer_size) {
    return ogt_vox_read_scene_with_flags(buffer, buffer_size, 0);
}

void ogt_vox_destroy_scene(const ogt_vox_scene* _scene) {
    ogt_vox_scene* scene = const_cast<ogt_vox_scene*>(_scene);
    // free models from model array
    for (uint32_t i = 0; i < scene->num_models; i++)
        _vox_free((void*)scene->models[i]);
    // free model array itself
    if (scene->models) {
        _vox_free(scene->models);
        scene->models = NULL;
    }
    // free instance array
    if (scene->instances) {
        _vox_free(const_cast<ogt_vox_instance*>(scene->instances));
        scene->instances = NULL;
    }
    // free cameras array
    if (scene->cameras) {
        _vox_free(const_cast<ogt_vox_cam*>(scene->cameras));
        scene->cameras = NULL;
    }
    // free layer array
    if (scene->layers) {
        _vox_free(const_cast<ogt_vox_layer*>(scene->layers));
        scene->layers = NULL;
    }
    // free groups array
    if (scene->groups) {
        _vox_free(const_cast<ogt_vox_group*>(scene->groups));
        scene->groups = NULL;
    }
    // finally, free the scene.
    _vox_free(scene);
}

// the vector should be a unit vector aligned along one of the cardinal directions exactly. eg. (1,0,0) or (0, 0, -1)
// this function returns the non-zero column index in out_index and the returns whether that entry is negative.
static bool _vox_get_vec3_rotation_bits(const vec3& vec, uint8_t& out_index) {
    const float* f = &vec.x;
    out_index = 3;
    bool is_negative = false;
    for (uint8_t i = 0; i < 3; i++) {
        if (f[i] == 1.0f || f[i] == -1.0f) {
            out_index = i;
            is_negative = f[i] < 0.0f ? true : false;
        }
        else {
            ogt_assert(f[i] == 0.0f, ""rotation vector should contain only 0.0f, 1.0f, or -1.0f"");
        }
    }
    ogt_assert(out_index != 3, ""rotation vector was all zeroes but it should be a cardinal axis vector"");
    return is_negative;
}

static uint8_t _vox_make_packed_rotation_from_transform(const ogt_vox_transform* transform) {
    // magicavoxel stores rows, and we have columns, so we do the swizzle here into rows
    vec3 row0 = vec3_make(transform->m00, transform->m10, transform->m20);
    vec3 row1 = vec3_make(transform->m01, transform->m11, transform->m21);
    vec3 row2 = vec3_make(transform->m02, transform->m12, transform->m22);
    uint8_t row0_index = 3, row1_index = 3, row2_index = 3;
    bool row0_negative = _vox_get_vec3_rotation_bits(row0, row0_index);
    bool row1_negative = _vox_get_vec3_rotation_bits(row1, row1_index);
    bool row2_negative = _vox_get_vec3_rotation_bits(row2, row2_index);
    ogt_assert(((1 << row0_index) | (1 << row1_index) | (1 << row2_index)) == 7, ""non orthogonal rows found in transform""); // check that rows are orthogonal. There must be a non-zero entry in column 0, 1 and 2 across these 3 rows.
    return (row0_index) | (row1_index << 2) | (row0_negative ? 1 << 4 : 0) | (row1_negative ? 1 << 5 : 0) | (row2_negative ? 1 << 6 : 0);
}

struct _vox_file_writeable {
    _vox_array<uint8_t> data;
};

static void _vox_file_writeable_init(_vox_file_writeable* fp) {
    fp->data.reserve(1024);
}
static void _vox_file_write(_vox_file_writeable* fp, const void* data, uint32_t data_size) {
    fp->data.push_back_many((const uint8_t*)data, data_size);
}
static void _vox_file_write_uint32(_vox_file_writeable* fp, uint32_t data) {
    data = _vox_htole32(data);
    _vox_file_write(fp, &data, sizeof(data));
}
static void _vox_file_write_uint8(_vox_file_writeable* fp, uint8_t data) {
    _vox_file_write(fp, &data, sizeof(data));
}
static void _vox_file_write_uint32_at_offset(_vox_file_writeable* fp, uint32_t offset, const uint32_t* data) {
    ogt_assert((offset + sizeof(*data)) <= fp->data.count, ""write at offset must not be an append write"");
    const uint32_t val = _vox_htole32(*data);
    memcpy(&fp->data[offset], &val, sizeof(*data));
}
static uint32_t _vox_file_get_offset(const _vox_file_writeable* fp) {
    return (uint32_t)fp->data.count;
}
static uint8_t* _vox_file_get_data(_vox_file_writeable* fp) {
    return &fp->data[0];
}
static void _vox_file_write_dict_key_value(_vox_file_writeable* fp, const char* key, const char* value) {
    if (key == NULL || value == NULL)
        return;
    uint32_t key_len = (uint32_t)_vox_strlen(key);
    uint32_t value_len = (uint32_t)_vox_strlen(value);
    _vox_file_write_uint32(fp, key_len);
    _vox_file_write(fp, key, key_len);
    _vox_file_write_uint32(fp, value_len);
    _vox_file_write(fp, value, value_len);
}
static void _vox_file_write_dict_key_value_uint32(_vox_file_writeable* fp, const char* key, uint32_t value) {
    char value_str[64];
    _vox_sprintf(value_str, sizeof(value_str), ""%i"", value);
    _vox_file_write_dict_key_value(fp, key, value_str);
}
static void _vox_file_write_dict_key_value_float(_vox_file_writeable* fp, const char* key, float value) {
    char value_str[64];
    _vox_sprintf(value_str, sizeof(value_str), ""%f"", value);
    _vox_file_write_dict_key_value(fp, key, value_str);
}
static void _vox_file_write_dict_transform(_vox_file_writeable* fp, const ogt_vox_transform* transform) {
    char t_string[65];
    char r_string[65];
    t_string[0] = 0;
    r_string[0] = 0;
    uint8_t packed_rotation_bits = _vox_make_packed_rotation_from_transform(transform);
    _vox_sprintf(t_string, sizeof(t_string), ""%i %i %i"", (int32_t)transform->m30, (int32_t)transform->m31, (int32_t)transform->m32);
    _vox_sprintf(r_string, sizeof(r_string), ""%u"", packed_rotation_bits);
    _vox_file_write_dict_key_value(fp, ""_r"", r_string);
    _vox_file_write_dict_key_value(fp, ""_t"", t_string);
}

static void _vox_file_write_chunk_nTRN(_vox_file_writeable* fp, uint32_t node_id, uint32_t child_node_id, const char* name, bool hidden, const ogt_vox_transform* transform, uint32_t layer_id, const ogt_vox_anim_transform* transform_anim)
{
    // obtain dictionary string pointers
    const char* hidden_string = hidden ? ""1"" : NULL;
    const char* loop_string = transform_anim->loop ? ""1"" : NULL;

    uint32_t offset_of_chunk_header = _vox_file_get_offset(fp);

    // write the nTRN header
    _vox_file_write_uint32(fp, CHUNK_ID_nTRN);
    _vox_file_write_uint32(fp, 0); // will get patched up later
    _vox_file_write_uint32(fp, 0);

    // write the nTRN payload
    _vox_file_write_uint32(fp, node_id);

    // write the node dictionary
    uint32_t node_dict_keyvalue_count = (name ? 1 : 0) + (hidden_string ? 1 : 0) + (loop_string ? 1 : 0);
    _vox_file_write_uint32(fp, node_dict_keyvalue_count);  // num key values
    _vox_file_write_dict_key_value(fp, ""_name"", name);
    _vox_file_write_dict_key_value(fp, ""_hidden"", hidden_string);
    _vox_file_write_dict_key_value(fp, ""_loop"", loop_string);

    // write other properties.
    _vox_file_write_uint32(fp, child_node_id);
    _vox_file_write_uint32(fp, UINT32_MAX); // reserved_id must have all bits set.
    _vox_file_write_uint32(fp, layer_id);
    if (transform_anim->num_keyframes == 0) {
        _vox_file_write_uint32(fp, 1);  // num_frames must be 1
        // write the frame dictionary
        _vox_file_write_uint32(fp, 2);  // 2 key values: ""_r"", ""_t""
        _vox_file_write_dict_transform(fp, transform);
    }
    else {
        _vox_file_write_uint32(fp, transform_anim->num_keyframes);          // num_frames must be 1
        for (uint32_t j = 0; j < transform_anim->num_keyframes; j++) {
            _vox_file_write_uint32(fp, 3);  // 3 key values: ""_r"", ""_t"", ""_f""
            _vox_file_write_dict_transform(fp, &transform_anim->keyframes[j].transform);
            _vox_file_write_dict_key_value_uint32(fp, ""_f"", transform_anim->keyframes[j].frame_index);
        }
    }

    // patch up the chunk size in the header
    uint32_t chunk_size = _vox_file_get_offset(fp) - offset_of_chunk_header - CHUNK_HEADER_LEN;
    _vox_file_write_uint32_at_offset(fp, offset_of_chunk_header + 4, &chunk_size);
}

// saves the scene out to a buffer that when saved as a .vox file can be loaded with magicavoxel.
uint8_t* ogt_vox_write_scene(const ogt_vox_scene* scene, uint32_t* buffer_size) {
    _vox_file_writeable file;
    _vox_file_writeable_init(&file);
    _vox_file_writeable* fp = &file;

    // write file header and file version
    _vox_file_write_uint32(fp, CHUNK_ID_VOX_);
    _vox_file_write_uint32(fp, 150);

    // write the main chunk
    _vox_file_write_uint32(fp, CHUNK_ID_MAIN);
    _vox_file_write_uint32(fp, 0);
    _vox_file_write_uint32(fp, 0);  // this main_chunk_child_size will get patched up once everything is written.

    // we need to know how to patch up the main chunk size after we've written everything
    const uint32_t offset_post_main_chunk = _vox_file_get_offset(fp);

    // write out all model chunks
    for (uint32_t i = 0; i < scene->num_models; i++) {
        const ogt_vox_model* model = scene->models[i];
        ogt_assert(model->size_x <= 256 && model->size_y <= 256 && model->size_z <= 256, ""model dimensions exceed the limit of 256x256x256"");
        // count the number of solid voxels in the grid
        uint32_t num_voxels_in_grid = model->size_x * model->size_y * model->size_z;
        uint32_t num_solid_voxels = 0;
        for (uint32_t voxel_index = 0; voxel_index < num_voxels_in_grid; voxel_index++)
            if (model->voxel_data[voxel_index] != 0)
                num_solid_voxels++;
        uint32_t chunk_size_xyzi = sizeof(uint32_t) + 4 * num_solid_voxels;

        // write the SIZE chunk header
        _vox_file_write_uint32(fp, CHUNK_ID_SIZE);
        _vox_file_write_uint32(fp, 12);
        _vox_file_write_uint32(fp, 0);

        // write the SIZE chunk payload
        ogt_assert(model->size_x && model->size_y && model->size_z, ""model has zero size"");
        _vox_file_write_uint32(fp, model->size_x);
        _vox_file_write_uint32(fp, model->size_y);
        _vox_file_write_uint32(fp, model->size_z);

        // write the XYZI chunk header
        _vox_file_write_uint32(fp, CHUNK_ID_XYZI);
        _vox_file_write_uint32(fp, chunk_size_xyzi);
        _vox_file_write_uint32(fp, 0);

        // write out XYZI chunk payload
        _vox_file_write_uint32(fp, num_solid_voxels);
        uint32_t voxel_index = 0;
        for (uint32_t z = 0; z < model->size_z; z++) {
            for (uint32_t y = 0; y < model->size_y; y++) {
                for (uint32_t x = 0; x < model->size_x; x++, voxel_index++) {
                    uint8_t color_index = model->voxel_data[voxel_index];
                    if (color_index != 0) {
                        _vox_file_write_uint8(fp, (uint8_t)x);
                        _vox_file_write_uint8(fp, (uint8_t)y);
                        _vox_file_write_uint8(fp, (uint8_t)z);
                        _vox_file_write_uint8(fp, color_index);
                    }
                }
            }
        }

        if (g_progress_callback_func) {
            // we indicate progress as number of models written, with an extra progress value for ending write
            if (!g_progress_callback_func((float)(i + 1) / (float)(scene->num_models + 1), g_progress_callback_user_data))
            {
                *buffer_size = 0;
                return NULL; // note: fp will be freed in dtor on exit
            }
        }
    }

    // define our node_id ranges.
    ogt_assert(scene->num_groups > 0, ""no groups found in scene"");
    uint32_t first_group_transform_node_id = 0;
    uint32_t first_group_node_id = first_group_transform_node_id + scene->num_groups;
    uint32_t  [MASK]  = first_group_node_id + scene->num_groups;
    uint32_t first_instance_transform_node_id =  [MASK]  + scene->num_instances;

    // write the nTRN nodes for each of the groups in the scene.
    for (uint32_t group_index = 0; group_index < scene->num_groups; group_index++) {
        const ogt_vox_group* group = &scene->groups[group_index];
        _vox_file_write_chunk_nTRN(fp, first_group_transform_node_id + group_index, first_group_node_id + group_index, group->name, group->hidden, &group->transform, group->layer_index, &group->transform_anim);
    }
    // write the group nodes for each of the groups in the scene
    for (uint32_t group_index = 0; group_index < scene->num_groups; group_index++) {
        // count how many childnodes  there are. This is simply the sum of all
        // groups and instances that have this group as its parent
        uint32_t num_child_nodes = 0;
        for (uint32_t child_group_index = 0; child_group_index < scene->num_groups; child_group_index++)
            if (scene->groups[child_group_index].parent_group_index == group_index)
                num_child_nodes++;
        for (uint32_t child_instance_index = 0; child_instance_index < scene->num_instances; child_instance_index++)
            if (scene->instances[child_instance_index].group_index == group_index)
                num_child_nodes++;

        // count number of dictionary items
        const char* hidden_string = scene->groups[group_index].hidden ? ""1"" : NULL;
        uint32_t group_dict_keyvalue_count = (hidden_string ? 1 : 0);

        // compute the chunk size.
        uint32_t offset_of_chunk_header = _vox_file_get_offset(fp);

        // write the nGRP header
        _vox_file_write_uint32(fp, CHUNK_ID_nGRP);
        _vox_file_write_uint32(fp, 0); // chunk_size will get patched up after.
        _vox_file_write_uint32(fp, 0);
        // write the nGRP payload
        _vox_file_write_uint32(fp, first_group_node_id + group_index);       // node_id
        _vox_file_write_uint32(fp, group_dict_keyvalue_count); // num keyvalue pairs in node dictionary
        _vox_file_write_dict_key_value(fp, ""_hidden"", hidden_string);
        _vox_file_write_uint32(fp, num_child_nodes);
        // write the child group transform nodes
        for (uint32_t child_group_index = 0; child_group_index < scene->num_groups; child_group_index++)
            if (scene->groups[child_group_index].parent_group_index == group_index)
                _vox_file_write_uint32(fp, first_group_transform_node_id + child_group_index);
        // write the child instance transform nodes
        for (uint32_t child_instance_index = 0; child_instance_index < scene->num_instances; child_instance_index++)
            if (scene->instances[child_instance_index].group_index == group_index)
                _vox_file_write_uint32(fp, first_instance_transform_node_id + child_instance_index);

        uint32_t chunk_size = _vox_file_get_offset(fp) - offset_of_chunk_header - CHUNK_HEADER_LEN;
        _vox_file_write_uint32_at_offset(fp, offset_of_chunk_header + 4, &chunk_size);
    }

    // write out an nSHP chunk for each of the instances
    for (uint32_t i = 0; i < scene->num_instances; i++) {
        const ogt_vox_instance* instance = &scene->instances[i];

        uint32_t offset_of_chunk_header = _vox_file_get_offset(fp);
        // write the nSHP chunk header
        _vox_file_write_uint32(fp, CHUNK_ID_nSHP);
        _vox_file_write_uint32(fp, 0); // will get patched up at the end
        _vox_file_write_uint32(fp, 0);
        // write the nSHP chunk payload
        _vox_file_write_uint32(fp,  [MASK]  + i);    // node_id

        // write the nSHP node dictionary
        const char* loop_string = instance->model_anim.loop ? ""1"" : NULL;
        uint32_t node_dict_keyvalue_count = (loop_string ? 1 : 0);
        _vox_file_write_uint32(fp, node_dict_keyvalue_count);  // num key values
        _vox_file_write_dict_key_value(fp, ""_loop"", loop_string);

        if (instance->model_anim.num_keyframes == 0) {
            _vox_file_write_uint32(fp, 1);                      // num_models must be 1
            _vox_file_write_uint32(fp, instance->model_index);  // model_id
            _vox_file_write_uint32(fp, 0);                      // num keyvalue pairs in model dictionary
        }
        else {
            _vox_file_write_uint32(fp, instance->model_anim.num_keyframes);
            for (uint32_t j = 0; j < instance->model_anim.num_keyframes; j++) {
                _vox_file_write_uint32(fp, instance->model_anim.keyframes[j].model_index); // model_id
                _vox_file_write_uint32(fp, 1); // num keyvalue pairs in model dictionary
                _vox_file_write_dict_key_value_uint32(fp, ""_f"", instance->model_anim.keyframes[j].frame_index);
            }
        }
        // compute and patch up the chunk size in the chunk header
        uint32_t chunk_size = _vox_file_get_offset(fp) - offset_of_chunk_header - CHUNK_HEADER_LEN;
        _vox_file_write_uint32_at_offset(fp, offset_of_chunk_header + 4, &chunk_size);
    }

    // write out a nTRN chunk for all instances - and make them point to the relevant nSHP chunk
    for (uint32_t i = 0; i < scene->num_instances; i++) {
        const ogt_vox_instance* instance = &scene->instances[i];
        uint32_t node_id = first_instance_transform_node_id + i;
        uint32_t child_node_id =  [MASK]  + i;
        _vox_file_write_chunk_nTRN(fp, node_id, child_node_id, instance->name, instance->hidden, &instance->transform, instance->layer_index, &instance->transform_anim);
    }

    // write out the rCAM chunks
    for (uint32_t i = 0; i < scene->num_cameras; i++) {
        const ogt_vox_cam* camera = &scene->cameras[i];
        char cam_focus[64] = """";
        char cam_angle[64] = """";
        char cam_radius[32] = """";
        char cam_frustum[32] = """";
        char cam_fov[32] = """";
        const char* cam_mode;
        _vox_sprintf(cam_focus, sizeof(cam_focus), ""%.5f %.5f %.5f"", camera->focus[0], camera->focus[1], camera->focus[2]);
        _vox_sprintf(cam_angle, sizeof(cam_angle), ""%.5f %.5f %.5f"", camera->angle[0], camera->angle[1], camera->angle[2]);
        _vox_sprintf(cam_radius, sizeof(cam_radius), ""%i"", camera->radius);
        _vox_sprintf(cam_frustum, sizeof(cam_frustum), ""%.5f"", camera->frustum);
        _vox_sprintf(cam_fov, sizeof(cam_fov), ""%i"", camera->fov);

        switch (camera->mode) {
        case ogt_cam_mode_free:
            cam_mode = ""free"";
            break;
        case ogt_cam_mode_pano:
            cam_mode = ""pano"";
            break;
        case ogt_cam_mode_isometric:
            cam_mode = ""iso"";
            break;
        case ogt_cam_mode_orthographic:
            cam_mode = ""orth"";
            break;
        default:
        case ogt_cam_mode_unknown:
        case ogt_cam_mode_perspective:
            cam_mode = ""pers"";
            break;
        }

        uint32_t offset_of_chunk_header = _vox_file_get_offset(fp);

        // write the rCAM header
        _vox_file_write_uint32(fp, CHUNK_ID_rCAM);
        _vox_file_write_uint32(fp, 0); // chunk_size will get patched up later
        _vox_file_write_uint32(fp, 0);

        _vox_file_write_uint32(fp, camera->camera_id);
        _vox_file_write_uint32(fp, 6);  // num key values
        _vox_file_write_dict_key_value(fp, ""_mode"", cam_mode);
        _vox_file_write_dict_key_value(fp, ""_focus"", cam_focus);
        _vox_file_write_dict_key_value(fp, ""_angle"", cam_angle);
        _vox_file_write_dict_key_value(fp, ""_radius"", cam_radius);
        _vox_file_write_dict_key_value(fp, ""_frustum"", cam_frustum);
        _vox_file_write_dict_key_value(fp, ""_fov"", cam_fov);

        // compute and patch up the chunk size in the chunk header
        uint32_t chunk_size = _vox_file_get_offset(fp) - offset_of_chunk_header - CHUNK_HEADER_LEN;
        _vox_file_write_uint32_at_offset(fp, offset_of_chunk_header + 4, &chunk_size);
    }

    // write out RGBA chunk for the palette
    {
        // .vox stores palette rotated by 1 color index, so do that now.
        ogt_vox_palette rotated_palette;
        for (uint32_t i = 0; i < 256; i++)
            rotated_palette.color[i] = scene->palette.color[(i + 1) & 255];

        // write the palette chunk header
        _vox_file_write_uint32(fp, CHUNK_ID_RGBA);
        _vox_file_write_uint32(fp, sizeof(ogt_vox_palette));
        _vox_file_write_uint32(fp, 0);
        // write the palette chunk payload
        _vox_file_write(fp, &rotated_palette, sizeof(ogt_vox_palette));
    }

    // write out MATL chunk
    {
        // keep in sync with ogt_matl_type
        static const char* type_str[] = { ""_diffuse"", ""_metal"", ""_glass"", ""_emit"", ""_blend"", ""_media"" };

        for (int32_t i = 0; i < 256; ++i) {
            const ogt_vox_matl& matl = scene->materials.matl[i];
            if (matl.content_flags == 0u) {
                continue;
            }
            uint32_t matl_dict_keyvalue_count = 1;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_metal) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_rough) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_spec) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_ior) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_att) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_flux) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_emit) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_ldr) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_trans) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_alpha) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_d) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_sp) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_g) ? 1 : 0;
            matl_dict_keyvalue_count += (matl.content_flags & k_ogt_vox_matl_have_media) ? 1 : 0;

            uint32_t offset_of_chunk_header = _vox_file_get_offset(fp);

            // write the material chunk header
            _vox_file_write_uint32(fp, CHUNK_ID_MATL);
            _vox_file_write_uint32(fp, 0); // chunk_size will get patched up later
            _vox_file_write_uint32(fp, 0);

            _vox_file_write_uint32(fp, i); // material id
            _vox_file_write_uint32(fp, matl_dict_keyvalue_count);
            _vox_file_write_dict_key_value(fp, ""_type"", type_str[matl.type]);
            if (matl.content_flags & k_ogt_vox_matl_have_metal) {
                _vox_file_write_dict_key_value_float(fp, ""_metal"", matl.metal);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_rough) {
                _vox_file_write_dict_key_value_float(fp, ""_rough"", matl.rough);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_spec) {
                _vox_file_write_dict_key_value_float(fp, ""_spec"", matl.spec);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_ior) {
                _vox_file_write_dict_key_value_float(fp, ""_ior"", matl.ior);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_att) {
                _vox_file_write_dict_key_value_float(fp, ""_att"", matl.att);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_flux) {
                _vox_file_write_dict_key_value_float(fp, ""_flux"", matl.flux);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_emit) {
                _vox_file_write_dict_key_value_float(fp, ""_emit"", matl.emit);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_ldr) {
                _vox_file_write_dict_key_value_float(fp, ""_ldr"", matl.ldr);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_trans) {
                _vox_file_write_dict_key_value_float(fp, ""_trans"", matl.trans);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_alpha) {
                _vox_file_write_dict_key_value_float(fp, ""_alpha"", matl.alpha);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_d) {
                _vox_file_write_dict_key_value_float(fp, ""_d"", matl.d);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_sp) {
                _vox_file_write_dict_key_value_float(fp, ""_sp"", matl.sp);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_g) {
                _vox_file_write_dict_key_value_float(fp, ""_g"", matl.g);
            }
            if (matl.content_flags & k_ogt_vox_matl_have_media) {
                _vox_file_write_dict_key_value_float(fp, ""_media"", matl.media);
            }
            // compute and patch up the chunk size in the chunk header
            uint32_t chunk_size = _vox_file_get_offset(fp) - offset_of_chunk_header - CHUNK_HEADER_LEN;
            _vox_file_write_uint32_at_offset(fp, offset_of_chunk_header + 4, &chunk_size);
        }
    }

    // write all layer chunks out.
    for (uint32_t i = 0; i < scene->num_layers; i++) {
        char color_string[64];
        _vox_sprintf(color_string, sizeof(color_string), ""%u %u %u"", scene->layers[i].color.r, scene->layers[i].color.g, scene->layers[i].color.b);
        const char* layer_name_string = scene->layers[i].name;
        const char* hidden_string = scene->layers[i].hidden ? ""1"" : NULL;
        uint32_t layer_dict_keyvalue_count = 0;
        layer_dict_keyvalue_count += (layer_name_string ? 1 : 0);
        layer_dict_keyvalue_count += (hidden_string ? 1 : 0);
        layer_dict_keyvalue_count += 1; // color_string

        uint32_t offset_of_chunk_header = _vox_file_get_offset(fp);

        // write the layer chunk header
        _vox_file_write_uint32(fp, CHUNK_ID_LAYR);
        _vox_file_write_uint32(fp, 0); // chunk_size will get patched up later
        _vox_file_write_uint32(fp, 0);
        // write the layer chunk payload
        _vox_file_write_uint32(fp, i);                          // layer_id
        _vox_file_write_uint32(fp, layer_dict_keyvalue_count);  // num keyvalue pairs in layer dictionary
        _vox_file_write_dict_key_value(fp, ""_name"", layer_name_string);
        _vox_file_write_dict_key_value(fp, ""_hidden"", hidden_string);
        _vox_file_write_dict_key_value(fp, ""_color"", color_string);
        _vox_file_write_uint32(fp, UINT32_MAX);                 // reserved id

        // compute and patch up the chunk size in the chunk header
        uint32_t chunk_size = _vox_file_get_offset(fp) - offset_of_chunk_header - CHUNK_HEADER_LEN;
        _vox_file_write_uint32_at_offset(fp, offset_of_chunk_header + 4, &chunk_size);
    }

    // check that the buffer is not larger than the maximum file size, return nothing if would overflow
    if (fp->data.count > UINT32_MAX || (fp->data.count - offset_post_main_chunk) > UINT32_MAX)
    {
        ogt_assert(0, ""Generated file size exceeded 4GiB, which is too large for Magicavoxel to parse."");
        *buffer_size = 0;
        return NULL;  // note: fp will be freed in dtor on exit
    }

    // we deliberately don't free the fp->data field, just pass the buffer pointer and size out to the caller
    *buffer_size = (uint32_t)fp->data.count;
    uint8_t* buffer_data = _vox_file_get_data(fp);
    // we deliberately clear this pointer so it doesn't get auto-freed on exiting. The caller will own the memory hereafter.
    fp->data.data = NULL;

    // patch up the main chunk's child chunk size now that we've written everything we're going to write.
    {
        uint32_t* main_chunk_child_size = (uint32_t*)&buffer_data[offset_post_main_chunk - sizeof(uint32_t)];
        *main_chunk_child_size = *buffer_size - offset_post_main_chunk;
    }

    if (g_progress_callback_func) {
        // we indicate progress as number of models written, with an extra progress value for ending write
        g_progress_callback_func(1.0f, g_progress_callback_user_data); // we ignore the return as exiting here anyway
    }

    return buffer_data;
}

void* ogt_vox_malloc(size_t size) {
    return _vox_malloc(size);
}

void ogt_vox_free(void* mem) {
    _vox_free(mem);
}

// compute the minimum and maximum x coordinate within the scene.
static void compute_scene_bounding_box_x(const ogt_vox_scene* scene, int32_t& out_min_x, int32_t& out_max_x) {
    if (scene->num_instances && scene->num_models)
    {
        // We don't apply orientation to the model dimensions and compute the exact min/max.
        // Instead we just conservatively use the maximum dimension of the model.
        int32_t scene_min_x = 0x7ffffff;
        int32_t scene_max_x = -0x7ffffff;
        for (uint32_t instance_index = 0; instance_index < scene->num_instances; instance_index++) {
            const ogt_vox_instance* instance = &scene->instances[instance_index];
            // compute the instance transform, taking into account the group hierarchy.
            ogt_vox_transform instance_transform = instance->transform;
            uint32_t parent_group_index = instance->group_index;
            while (parent_group_index != k_invalid_group_index) {
                const ogt_vox_group* group = &scene->groups[parent_group_index];
                instance_transform = ogt_vox_transform_multiply(instance_transform, group->transform);
                parent_group_index = group->parent_group_index;
            }

            const ogt_vox_model* model = scene->models[instance->model_index];
            // the instance_transform can be rotated, so we try to figure out whether the
            // model's local x, y or z size is aligned along the world x axis.
            // One of the column vectors of the transform must have a non-zero in its
            // x field and the dimension associated with that column is the correct choice of rus.
            int32_t max_dim = instance_transform.m00 != 0.0f ? model->size_x :
                instance_transform.m10 != 0.0f ? model->size_y :
                instance_transform.m20 != 0.0f ? model->size_z : model->size_x;
            int32_t half_dim = max_dim / 2;
            int32_t min_x = (int32_t)instance_transform.m30 - half_dim;
            int32_t max_x = (int32_t)instance_transform.m30 + half_dim;
            scene_min_x = min_x < scene_min_x ? min_x : scene_min_x;
            scene_max_x = max_x > scene_max_x ? max_x : scene_max_x;
        }
        // pass out the dimensions.
        out_min_x = scene_min_x;
        out_max_x = scene_max_x;
    }
    else {
        out_min_x = 0;
        out_max_x = 0;
    }
}

// returns a mask of which color indices are used by the specified scene.
// used_mask[0] can be false at the end of this if all models 100% fill their voxel grid with solid voxels, so callers
// should handle that case properly.
static void compute_scene_used_color_index_mask(bool* used_mask, const ogt_vox_scene* scene) {
    memset(used_mask, 0, 256);
    for (uint32_t model_index = 0; model_index < scene->num_models; model_index++) {
        const ogt_vox_model* model = scene->models[model_index];
        uint32_t voxel_count = model->size_x * model->size_y * model->size_z;
        for (uint32_t voxel_index = 0; voxel_index < voxel_count; voxel_index++) {
            uint8_t color_index = model->voxel_data[voxel_index];
            used_mask[color_index] = true;
        }
    }
}

// finds an exact color in the specified palette if it exists, and UINT32_MAX otherwise
static uint32_t find_exact_color_in_palette(const ogt_vox_rgba* palette, uint32_t palette_count, const ogt_vox_rgba color_to_find) {
    for (uint32_t color_index = 1; color_index < palette_count; color_index++) {
        const ogt_vox_rgba color_to_match = palette[color_index];
        // we only try to match r,g,b components exactly.
        if (color_to_match.r == color_to_find.r && color_to_match.g == color_to_find.g && color_to_match.b == color_to_find.b)
            return color_index;
    }
    // no exact color found
    return UINT32_MAX;
}

// finds the index within the specified palette that is closest to the color we want to find
static uint32_t find_closest_color_in_palette(const ogt_vox_rgba* palette, uint32_t palette_count, const ogt_vox_rgba color_to_find) {
    // the lower the score the better, so initialize this to the maximum possible score
    int32_t  best_score = INT32_MAX;
    uint32_t best_index = 1;
    // Here we compute a score based on the pythagorean distance between each color in the palette and the color to find.
    // The distance is in R,G,B space, and we choose the color with the lowest score.
    for (uint32_t color_index = 1; color_index < palette_count; color_index++) {
        int32_t r_diff = (int32_t)color_to_find.r - (int32_t)palette[color_index].r;
        int32_t g_diff = (int32_t)color_to_find.g - (int32_t)palette[color_index].g;
        int32_t b_diff = (int32_t)color_to_find.b - (int32_t)palette[color_index].b;
        // There are 2 aspects of our treatment of color here you may want to experiment with:
        // 1. differences in R, differences in G, differences in B are weighted the same rather than perceptually. Different weightings may be better for you.
        // 2. We treat R,G,B as if they are in a perceptually linear within each channel. eg. the differences between
        //    a value of 5 and 8 in any channel is perceptually the same as the difference between 233 and 236 in the same channel.
        int32_t score = (r_diff * r_diff) + (g_diff * g_diff) + (b_diff * b_diff);
        if (score < best_score) {
            best_score = score;
            best_index = color_index;
        }
    }
    ogt_assert(best_score < INT32_MAX, ""degenerate palette""); // this might indicate a completely degenerate palette.
    return best_index;
}

static void update_master_palette_and_materials_from_scene(ogt_vox_rgba* master_palette, uint32_t& master_palette_count, const ogt_vox_scene* scene, uint32_t* scene_to_master_map, ogt_vox_matl* master_matl) {
    // compute the mask of used colors in the scene.
    bool scene_used_mask[256];
    compute_scene_used_color_index_mask(scene_used_mask, scene);

    // initialize the map that converts from scene color_index to master color_index
    scene_to_master_map[0] = 0;              // zero/empty always maps to zero/empty in the master palette
    for (uint32_t i = 1; i < 256; i++)
        scene_to_master_map[i] = UINT32_MAX; // UINT32_MAX means unassigned

    // for each used color in the scene, now allocate it into the master palette.
    for (uint32_t color_index = 1; color_index < 256; color_index++) {
        if (scene_used_mask[color_index]) {
            const ogt_vox_rgba color = scene->palette.color[color_index];
            const ogt_vox_matl matl = scene->materials.matl[color_index];
            // find the exact color in the master palette. Will be UINT32_MAX if the color doesn't already exist
            uint32_t master_index = find_exact_color_in_palette(master_palette, master_palette_count, color);
            if (master_index == UINT32_MAX) {
                if (master_palette_count < 256) {
                    // master palette capacity hasn't been exceeded so far, allocate the color to it.
                    master_palette[master_palette_count] = color;
                    master_matl[master_palette_count] = matl;
                    master_index = master_palette_count++;
                }
                else {
                    // otherwise, find the color that is perceptually closest to the original color.

                    // TODO(jpaver): It is potentially problematic if we hit this path for a many-scene merge.
                    // Earlier scenes will reserve their colors exactly into the master palette, whereas later
                    // scenes will end up having some of their colors remapped to different colors.

                    // A more holistic approach to color allocation may be necessary here eg.
                    // we might allow the master palette to grow to more than 256 entries, and then use
                    // similarity/frequency metrics to reduce the palette from that down to 256 entries. This
                    // will mean all scenes will have be equally important if they have a high-frequency
                    // usage of a color.
                    master_index = find_closest_color_in_palette(master_palette, master_palette_count, color);
                }
            }
            // caller needs to know how to map its original color index into the master palette
            scene_to_master_map[color_index] = master_index;
        }
    }
}

ogt_vox_scene* ogt_vox_merge_scenes(const ogt_vox_scene** scenes, uint32_t scene_count, const ogt_vox_rgba* required_colors, const uint32_t required_color_count) {
    ogt_assert(required_color_count <= 255, ""too many colors specified""); // can't exceed the maximum colors in the master palette plus the empty slot.

    // initialize the master palette. If required colors are specified, map them into the master palette now.
    ogt_vox_rgba  master_palette[256];
    ogt_vox_matl materials[256];
    uint32_t master_palette_count = 1;          // color_index 0 is reserved for empty color!
    memset(&master_palette, 0, sizeof(master_palette));
    memset(&materials, 0, sizeof(materials));
    for (uint32_t required_index = 0; required_index < required_color_count; required_index++)
        master_palette[master_palette_count++] = required_colors[required_index];

    // count the number of required models, instances in the master scene
    uint32_t max_layers = 1;  // we don't actually merge layers. Every instance will be in layer 0.
    uint32_t max_models = 0;
    uint32_t max_instances = 0;
    uint32_t max_groups = 1;  // we add 1 root global group that everything will ultimately be parented to.
    for (uint32_t scene_index = 0; scene_index < scene_count; scene_index++) {
        if (!scenes[scene_index])
            continue;
        max_instances += scenes[scene_index]->num_instances;
        max_models += scenes[scene_index]->num_models;
        max_groups += scenes[scene_index]->num_groups;
    }

    // allocate the master instances array
    ogt_vox_instance* instances = (ogt_vox_instance*)_vox_malloc(sizeof(ogt_vox_instance) * max_instances);
    ogt_vox_model** models = (ogt_vox_model**)_vox_malloc(sizeof(ogt_vox_model*) * max_models);
    ogt_vox_layer* layers = (ogt_vox_layer*)_vox_malloc(sizeof(ogt_vox_layer) * max_layers);
    ogt_vox_group* groups = (ogt_vox_group*)_vox_malloc(sizeof(ogt_vox_group) * max_groups);
    uint32_t          num_instances = 0;
    uint32_t          num_models = 0;
    uint32_t          num_layers = 0;

    // add a single layer.
    layers[num_layers].hidden = false;
    layers[num_layers].color = { 255, 255, 255, 255 };
    layers[num_layers].name = ""merged"";
    num_layers++;

    // magicavoxel expects exactly 1 root group, so if we have multiple scenes with multiple roots,
    // we must ensure all merged scenes are parented to the same root group. Allocate it now for the
    // merged scene.
    uint32_t global_root_group_index = 0;
    {
        ogt_vox_group root_group;
        root_group.name = NULL;
        root_group.hidden = false;
        root_group.layer_index = 0;
        root_group.parent_group_index = k_invalid_group_index;
        root_group.transform = ogt_vox_transform_get_identity();
        clear_anim_transform(&root_group.transform_anim);
        groups[0] = root_group;
    }
    uint32_t num_groups = 1; // we just wrote the global root group index, so all per-scene groups are allocated after.

    // go ahead and do the merge now!
    _vox_array<uint32_t> per_scene_base_model_index;
    _vox_array<uint32_t> per_scene_base_instance_index;
    size_t misc_data_size = 0;
    int32_t offset_x = 0;
    for (uint32_t scene_index = 0; scene_index < scene_count; scene_index++) {
        const ogt_vox_scene* scene = scenes[scene_index];
        if (!scene)
            continue;

        // update the master palette, and get the map of this scene's color indices into the master palette.
        uint32_t scene_color_index_to_master_map[256];
        update_master_palette_and_materials_from_scene(master_palette, master_palette_count, scene, scene_color_index_to_master_map, materials);

        // cache away the base model index for this scene.
        uint32_t base_model_index = num_models;
        uint32_t base_group_index = num_groups;

        per_scene_base_model_index.push_back(base_model_index);
        per_scene_base_instance_index.push_back(num_instances);

        // create copies of all models that have color indices remapped.
        for (uint32_t model_index = 0; model_index < scene->num_models; model_index++) {
            const ogt_vox_model* model = scene->models[model_index];
            uint32_t voxel_count = model->size_x * model->size_y * model->size_z;
            // clone the model
            ogt_vox_model* override_model = (ogt_vox_model*)_vox_malloc(sizeof(ogt_vox_model) + voxel_count);
            uint8_t* override_voxel_data = (uint8_t*)&override_model[1];

            // remap all color indices in the cloned model so they reference the master palette now!
            for (uint32_t voxel_index = 0; voxel_index < voxel_count; voxel_index++) {
                uint8_t  old_color_index = model->voxel_data[voxel_index];
                uint32_t new_color_index = scene_color_index_to_master_map[old_color_index];
                ogt_assert(new_color_index < 256, ""color index out of bounds"");
                override_voxel_data[voxel_index] = (uint8_t)new_color_index;
            }
            // assign the new model.
            *override_model = *model;
            override_model->voxel_data = override_voxel_data;
            override_model->voxel_hash = _vox_hash(override_voxel_data, voxel_count);

            models[num_models++] = override_model;
        }

        // compute the scene bounding box on x dimension. this is used to offset instances
        // and groups in the merged model along X dimension such that they do not overlap
        // with instances from another scene in the merged model.
        int32_t scene_min_x, scene_max_x;
        compute_scene_bounding_box_x(scene, scene_min_x, scene_max_x);
        float scene_offset_x = (float)(offset_x - scene_min_x);

        // each scene has a root group, and it must the 0th group in its local groups[] array,
        ogt_assert(scene->groups[0].parent_group_index == k_invalid_group_index, ""first group of scene must not be parented to any other group"");
        // create copies of all groups into the merged scene (except the root group from each scene -- which is why we start group_index at 1 here)
        for (uint32_t group_index = 1; group_index < scene->num_groups; group_index++) {
            const ogt_vox_group* src_group = &scene->groups[group_index];
            ogt_assert(src_group->parent_group_index != k_invalid_group_index, ""all groups after the first in the scene must be parented to a valid group""); // there can be only 1 root group per scene and it must be the 0th group.
            ogt_vox_group dst_group = *src_group;
            ogt_assert(dst_group.parent_group_index < scene->num_groups, ""group index is out of bounds"");
            dst_group.layer_index = 0;
            dst_group.parent_group_index = (dst_group.parent_group_index == 0) ? global_root_group_index : base_group_index + (dst_group.parent_group_index - 1);
            if (dst_group.name)
                misc_data_size += _vox_strlen(dst_group.name) + 1; // + 1 for zero terminator
            if (dst_group.transform_anim.num_keyframes)
                misc_data_size += (sizeof(ogt_vox_keyframe_transform) * dst_group.transform_anim.num_keyframes);
            // if this group belongs to the global root group, it must be translated so it doesn't overlap with other scenes.
            if (dst_group.parent_group_index == global_root_group_index)
                dst_group.transform.m30 += scene_offset_x;
            groups[num_groups++] = dst_group;
        }

        // create copies of all instances (and bias them such that minimum on x starts at zero)
        for (uint32_t instance_index = 0; instance_index < scene->num_instances; instance_index++) {
            const ogt_vox_instance* src_instance = &scene->instances[instance_index];
            ogt_assert(src_instance->group_index < scene->num_groups, ""group index is out of bounds"");  // every instance must be mapped to a group.
            ogt_vox_instance* dst_instance = &instances[num_instances++];
            *dst_instance = *src_instance;
            dst_instance->layer_index = 0;
            dst_instance->group_index = (dst_instance->group_index == 0) ? global_root_group_index : base_group_index + (dst_instance->group_index - 1);
            dst_instance->model_index += base_model_index;
            if (dst_instance->name)
                misc_data_size += _vox_strlen(dst_instance->name) + 1; // + 1 for zero terminator
            if (dst_instance->transform_anim.num_keyframes)
                misc_data_size += (sizeof(ogt_vox_keyframe_transform) * dst_instance->transform_anim.num_keyframes);
            if (dst_instance->model_anim.num_keyframes)
                misc_data_size += (sizeof(ogt_vox_keyframe_model) * dst_instance->model_anim.num_keyframes);

            // if this instance belongs to the global root group, it must be translated so it doesn't overlap with other scenes.
            if (dst_instance->group_index == global_root_group_index)
                dst_instance->transform.m30 += scene_offset_x;
        }

        offset_x += (scene_max_x - scene_min_x); // step the width of the scene in x dimension
        offset_x += 4;                           // a margin of this many voxels between scenes
    }

    // fill any unused master palette entries with purple/invalid color.
    const ogt_vox_rgba k_invalid_color = { 255, 0, 255, 255 };  // purple = invalid
    for (uint32_t color_index = master_palette_count; color_index < 256; color_index++)
        master_palette[color_index] = k_invalid_color;

    // assign the master scene on output. misc_data is part of the scene allocation.
    size_t scene_size = sizeof(ogt_vox_scene) + misc_data_size;
    ogt_vox_scene* merged_scene = (ogt_vox_scene*)_vox_calloc(scene_size);

    // copy name and keyframe data into the misc_data section and make instances/groups point to it.
    // This makes the merged model self-contained.
    {
        char* scene_misc_data = (char*)&merged_scene[1];
        for (uint32_t instance_index = 0; instance_index < num_instances; instance_index++) {
            if (instances[instance_index].name) {
                size_t string_len = _vox_strlen(instances[instance_index].name) + 1; // +1 for zero terminator
                memcpy(scene_misc_data, instances[instance_index].name, string_len);
                instances[instance_index].name = scene_misc_data;
                scene_misc_data += string_len;
            }
            if (instances[instance_index].model_anim.num_keyframes) {
                ogt_vox_keyframe_model* model_keyframes = (ogt_vox_keyframe_model*)scene_misc_data;
                uint32_t keyframe_size = sizeof(ogt_vox_keyframe_model) * instances[instance_index].model_anim.num_keyframes;
                memcpy(scene_misc_data, instances[instance_index].model_anim.keyframes, keyframe_size);
                instances[instance_index].model_anim.keyframes = model_keyframes;
                scene_misc_data += keyframe_size;
                // bias the model_index in model_keyframes back into the range for the scene that this instance came from.
                for (int32_t scene_index = (int32_t)(per_scene_base_instance_index.size() - 1); scene_index >= 0; scene_index--) {
                    if (instance_index >= per_scene_base_instance_index[scene_index]) {
                        for (uint32_t j = 0; j < instances[instance_index].model_anim.num_keyframes; j++)
                            model_keyframes[j].model_index += per_scene_base_model_index[scene_index];
                        break;
                    }
                }
            }
            if (instances[instance_index].transform_anim.num_keyframes) {
                uint32_t keyframe_size = sizeof(ogt_vox_keyframe_transform) * instances[instance_index].transform_anim.num_keyframes;
                memcpy(scene_misc_data, instances[instance_index].transform_anim.keyframes, keyframe_size);
                instances[instance_index].transform_anim.keyframes = (ogt_vox_keyframe_transform*)scene_misc_data;
                scene_misc_data += keyframe_size;
            }
        }
        for (uint32_t group_index = 0; group_index < num_groups; group_index++) {
            if (groups[group_index].name) {
                size_t string_len = _vox_strlen(groups[group_index].name) + 1; // +1 for zero terminator
                memcpy(scene_misc_data, groups[group_index].name, string_len);
                groups[group_index].name = scene_misc_data;
                scene_misc_data += string_len;
            }
            if (groups[group_index].transform_anim.num_keyframes) {
                uint32_t keyframe_size = sizeof(ogt_vox_keyframe_transform) * groups[group_index].transform_anim.num_keyframes;
                memcpy(scene_misc_data, groups[group_index].transform_anim.keyframes, keyframe_size);
                groups[group_index].transform_anim.keyframes = (ogt_vox_keyframe_transform*)scene_misc_data;
                scene_misc_data += keyframe_size;
            }
        }

        ogt_assert(scene_misc_data <= ((char*)&merged_scene[1] + misc_data_size), ""misc_data allocation was overrun"");
    }

    ogt_assert(num_groups <= max_groups, ""sanity check failed. we wrote more groups than we allocated"");

    memset(merged_scene, 0, sizeof(ogt_vox_scene));
    merged_scene->instances = instances;
    merged_scene->num_instances = max_instances;
    merged_scene->models = (const ogt_vox_model**)models;
    merged_scene->num_models = max_models;
    merged_scene->layers = layers;
    merged_scene->num_layers = max_layers;
    merged_scene->groups = groups;
    merged_scene->num_groups = num_groups;
    // copy color palette into the merged scene
    for (uint32_t color_index = 0; color_index < 256; color_index++)
        merged_scene->palette.color[color_index] = master_palette[color_index];
    // copy materials into the merged scene
    for (uint32_t color_index = 0; color_index < 256; color_index++)
        merged_scene->materials.matl[color_index] = materials[color_index];

    return merged_scene;
}

void ogt_vox_test()
{
    // frame_index looping tests
    {
        const char* test_message = ""failed compute_looped_frame_index test"";
        (void)test_message;
        // [0,0] = 1 keyframe animation starting at frame 0
        ogt_assert(compute_looped_frame_index(0, 0, 0) == 0, test_message);
        ogt_assert(compute_looped_frame_index(0, 0, 1) == 0, test_message);
        ogt_assert(compute_looped_frame_index(0, 0, 15) == 0, test_message);
        // [1,1] = 1 keyframe animation starting at frame 1
        ogt_assert(compute_looped_frame_index(1, 1, 0) == 1, test_message);
        ogt_assert(compute_looped_frame_index(1, 1, 1) == 1, test_message);
        ogt_assert(compute_looped_frame_index(1, 1, 15) == 1, test_message);
        // [0,9] = 10 keyframe animation starting at frame 0
        ogt_assert(compute_looped_frame_index(0, 9, 0) == 0, test_message);
        ogt_assert(compute_looped_frame_index(0, 9, 4) == 4, test_message);
        ogt_assert(compute_looped_frame_index(0, 9, 9) == 9, test_message);
        ogt_assert(compute_looped_frame_index(0, 9, 10) == 0, test_message);
        ogt_assert(compute_looped_frame_index(0, 9, 11) == 1, test_message);
        ogt_assert(compute_looped_frame_index(0, 9, 14) == 4, test_message);
        ogt_assert(compute_looped_frame_index(0, 9, 19) == 9, test_message);
        ogt_assert(compute_looped_frame_index(0, 9, 21) == 1, test_message);
        // [4,13] = 10 keyframe animation starting at frame 4
        ogt_assert(compute_looped_frame_index(4, 13, 0) == 10, test_message);
        ogt_assert(compute_looped_frame_index(4, 13, 3) == 13, test_message);
        ogt_assert(compute_looped_frame_index(4, 13, 4) == 4, test_message);
        ogt_assert(compute_looped_frame_index(4, 13, 5) == 5, test_message);
        ogt_assert(compute_looped_frame_index(4, 13, 12) == 12, test_message);
        ogt_assert(compute_looped_frame_index(4, 13, 13) == 13, test_message);
        ogt_assert(compute_looped_frame_index(4, 13, 14) == 4, test_message);
        ogt_assert(compute_looped_frame_index(4, 13, 21) == 11, test_message);
    }

}

#endif // #ifdef OGT_VOX_IMPLEMENTATION

/* -------------------------------------------------------------------------------------------------------------------------------------------------

    MIT License

    Copyright (c) 2019 <NAME>

    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""),
    to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
    IN THE SOFTWARE.

------------------------------------------------------------------------------------------------------------------------------------------------- */
",first_shape_node_id
465,"
#include <iostream>
#include <sstream>
#include <memory>
#include <list>

#include ""scheduler.h""
#include ""network.h""
#include ""lattice.h""

#include ""MRMeldBlockCode.h""
#include ""meldInterpretEvents.h""
#include ""meldInterpretMessages.h""
#include ""meldInterpretVM.h""

#include ""trace.h""

using namespace std;
using namespace MultiRobots;
using namespace MeldInterpret;

MRMeldBlockCode::MRMeldBlockCode(MultiRobotsBlock *host): MultiRobotsBlockCode(host) {
	// OUTPUT << ""MRMeldBlockCode constructor"" << endl;
	vm = new MeldInterpretVM(hostBlock);
	hasWork = true; // mode fastest
	polling = false; // mode fastest
	currentLocalDate = 0; // mode fastest
	bb = (MultiRobotsBlock*)hostBlock;
}

MRMeldBlockCode::~MRMeldBlockCode() {
	delete vm;
	// OUTPUT << ""MRMeldBlockCode destructor"" << endl;
}

void MRMeldBlockCode::init() {
	stringstream info;

	if((vm != NULL)) {
		for (BuildingBlock *mrb : static_cast<BCLattice*>(MultiRobots::getWorld()->lattice)->connected) {
			if (mrb->blockId != hostBlock->blockId)
				vm->enqueue_edge(mrb->blockId, 1);
		}

		vm->enqueue_at((meld_int)bb->position.pt[0], (meld_int)bb->position.pt[1],
					   (meld_int)bb->position.pt[2], 1);
		BaseSimulator::getScheduler()->schedule(
			new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));

		if((getScheduler()->getMode() == SCHEDULER_MODE_FASTEST) && !vm->deterministicSet) {
			vm->deterministicSet = true;
			/*SetDeterministicModeVMCommand determinismCommand(c, bb->blockId);
			  vm->sendCommand(determinismCommand);*/
			info << ""deterministic mode set"";
			getScheduler()->trace(info.str(),hostBlock->blockId);
			OUTPUT << ""deterministic mode enable on the VM "" << hostBlock->blockId << endl;
		}

	}
}

void MRMeldBlockCode::startup() {
	stringstream info;

	currentLocalDate = BaseSimulator::getScheduler()->now();
	info << ""  Starting MRMeldBlockCode in block "" << hostBlock->blockId;
	getScheduler()->trace(info.str(),hostBlock->blockId);
	init();
}

void MRMeldBlockCode::handleDeterministicMode(/*VMCommand &command*/){
	currentLocalDate = max(BaseSimulator::getScheduler()->now(), currentLocalDate);
	/*if(!hasWork && (command.getType() != VM_COMMAND_STOP)) {
	  hasWork = true;
	  #ifdef TEST_DETER
	  //cout << hostBlock->blockId << "" has work again at "" << BaseSimulator::getScheduler()->now() << endl;
	  #endif
	  }*/
}

void MRMeldBlockCode::processLocalEvent(EventPtr  [MASK] ) {
	stringstream info;
	assert(vm != NULL);
	info.str("""");
#ifdef TEST_DETER
	cout << bb->blockId << "" processLocalEvent: date: ""<< BaseSimulator::getScheduler()->now() << "" process event "" <<  [MASK] ->getEventName() << ""("" <<  [MASK] ->eventType << "")"" << "", random number : "" <<  [MASK] ->randomNumber << endl;
#endif
	switch ( [MASK] ->eventType) {
	case EVENT_COMPUTE_PREDICATE:
	{
		//Call the VM function to process one rule
		vm->processOneRule();
		//Add another compute event on condition
		//if...
		if(vm->isWaiting()){
			// random delay before recomputing a predicate
			// between 0.1 ms and 1ms
			int delay = (bb->getRandomUint() % (1000 - 100 +1 )) + 100;
			BaseSimulator::getScheduler()->schedule(new ComputePredicateEvent(BaseSimulator::getScheduler()->now()+delay, bb));
		}
		//else info << "" Block is no longer waiting"";
		//info << ""Compute predicate event"";
	}
	break;
	case EVENT_STOP:
	{
		//getDebugger()->sendTerminateMsg(bb->blockId);
		delete vm;
		info << ""VM stopped"";
	}
	break;
	case EVENT_ADD_NEIGHBOR:
	{
		//Should not be used by itself, presence of another block is tested by P2PNetworkInterface
		unsigned int face = (std::static_pointer_cast<AddNeighborEvent>( [MASK] ))->face;
		vm->neighbors[face] = (std::static_pointer_cast<AddNeighborEvent>( [MASK] ))->target;
		vm->enqueue_face(vm->neighbors[face], face, 1);
		BaseSimulator::getScheduler()->schedule(
			new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));
	}
	break;
	case EVENT_REMOVE_NEIGHBOR:
	{
		unsigned int face = (std::static_pointer_cast<AddNeighborEvent>( [MASK] ))->face;
		vm->neighbors[face] = VACANT;
		vm->enqueue_face(vm->neighbors[face], face, -1);
		BaseSimulator::getScheduler()->schedule(
			new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));
	}
	break;
	case EVENT_TAP:
	{
		vm->enqueue_tap();
		BaseSimulator::getScheduler()->schedule(new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));
		info << ""tapped, database dump printed to stderr..."";
		vm->facts_dump();
	}
	break;
	case EVENT_SET_COLOR:
	{
		// bb->getTime();
		//Called by the VM, no need to enqueue things
		Color color = (std::static_pointer_cast<SetColorEvent>( [MASK] ))->color;
		bb->setColor(color);
#ifdef TEST_DETER
		cout << bb->blockId << "" SET_COLOR_EVENT"" << endl;
#endif
		info << ""set color ""<< color;
	}
	break;

	/*The interface being connected is tested in function tuple_send of the MeldInterpVM*/
	case EVENT_SEND_MESSAGE:
	{
		MessagePtr message = (std::static_pointer_cast<VMSendMessageEvent>( [MASK] ))->message;
		P2PNetworkInterface *interface = (std::static_pointer_cast<VMSendMessageEvent>( [MASK] ))->sourceInterface;
		getScheduler()->schedule(
			new NetworkInterfaceEnqueueOutgoingEvent(BaseSimulator::getScheduler()->now(), message, interface));
	}
	break;
	case EVENT_RECEIVE_MESSAGE: /*EVENT_NI_RECEIVE: */
	{
		MessagePtr mes = (std::static_pointer_cast<NetworkInterfaceReceiveEvent>( [MASK] ))->message;
		switch(mes->type){
		case ADD_TUPLE_MSG_ID:
			getScheduler()->schedule(
				new AddTupleEvent(BaseSimulator::getScheduler()->now(), hostBlock,
								  std::static_pointer_cast<AddTupleMessage>(mes)->tuple,
								  bb->getDirection(mes->sourceInterface->connectedInterface)));
			break;
		case REMOVE_TUPLE_MSG_ID:
			getScheduler()->schedule(
				new RemoveTupleEvent(BaseSimulator::getScheduler()->now(), hostBlock,
									 std::static_pointer_cast<RemoveTupleMessage>(mes)->tuple,
									 bb->getDirection(mes->sourceInterface->connectedInterface)));
			break;
		}
#ifdef TEST_DETER
		cout << ""message received from "" << command->sourceInterface->hostBlock->blockId << endl;
#endif
		//info << ""message received at face "" << NeighborDirection::getString(bb->getDirection(mes->sourceInterface->connectedInterface)) << "" from "" << mes->sourceInterface->hostBlock->blockId;
	}
	break;
	case EVENT_ACCEL:
	{
		/*Not written yet, have to check how the vm handle accel (tuple, etc)*/
		info << ""accel"";
	}
	break;
	case EVENT_SHAKE:
	{
		/*Not written yet, same as accel*/

		info << ""shake"";
	}
	break;
	case EVENT_SET_DETERMINISTIC:
	{
		/*Not sure how to handle that with MeldInterp*/
		OUTPUT << ""VM set in deterministic mode "" << hostBlock->blockId << endl;
		info << ""VM set in deterministic mode"";
	}
	break;
	case EVENT_END_POLL:
	{
		polling = false;
		/*Not written yet
		  Need to check what this is for*/
		info << ""Polling time period ended"";
	}
	break;
	case EVENT_ADD_TUPLE:
		this->vm->receive_tuple(1, std::static_pointer_cast<AddTupleEvent>( [MASK] )->tuple,
								std::static_pointer_cast<AddTupleEvent>( [MASK] )->face);
		BaseSimulator::getScheduler()->schedule(
			new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));
		//info << ""Adding tuple"";
		break;
	case EVENT_REMOVE_TUPLE:
		this->vm->receive_tuple(-1, std::static_pointer_cast<RemoveTupleEvent>( [MASK] )->tuple,
								std::static_pointer_cast<RemoveTupleEvent>( [MASK] )->face);
		BaseSimulator::getScheduler()->schedule(
			new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));
		//info << ""Removing tuple"";
		break;
	case EVENT_TRANSLATION_START:
		vm->enqueue_at((meld_int)bb->position.pt[0], (meld_int)bb->position.pt[1],
					   (meld_int)bb->position.pt[2], -1);
		BaseSimulator::getScheduler()->schedule(
			new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));
		break;
	case EVENT_TRANSLATION_END:
		vm->enqueue_at((meld_int)bb->position.pt[0], (meld_int)bb->position.pt[1],
					   (meld_int)bb->position.pt[2], 1);
		BaseSimulator::getScheduler()->schedule(
			new ComputePredicateEvent(BaseSimulator::getScheduler()->now(), bb));
		break;
	case EVENT_SEND_MESSAGE_TO_BLOCK:
	{
        MessagePtr message = (std::static_pointer_cast<VMSendMessageEvent2>( [MASK] ))->message;
		BaseSimulator::BuildingBlock* target =
			(std::static_pointer_cast<VMSendMessageEvent2>( [MASK] ))->target;
        target->scheduleLocalEvent(
			EventPtr(new VMReceiveMessageEvent2(BaseSimulator::getScheduler()->now(), hostBlock, message)));
	}
	break;
	case EVENT_RECEIVE_MESSAGE_FROM_BLOCK: /*EVENT_NI_RECEIVE: */
	{
        MessagePtr mes = (std::static_pointer_cast<NetworkInterfaceReceiveEvent>( [MASK] ))->message;
        switch(mes->type){
		case ADD_TUPLE_MSG_ID:
            getScheduler()->schedule(
				new AddTupleEvent(BaseSimulator::getScheduler()->now(), hostBlock,
								  std::static_pointer_cast<AddTupleMessage>(mes)->tuple, -1));
            break;
		case REMOVE_TUPLE_MSG_ID:
            getScheduler()->schedule(
				new RemoveTupleEvent(BaseSimulator::getScheduler()->now(), hostBlock,
									 std::static_pointer_cast<RemoveTupleMessage>(mes)->tuple, -1));
            break;
        }
	} break;
	default:
		ERRPUT << ""*** ERROR *** : unknown local event"";
		break;
	}
	if(info.str() != """") {
		getScheduler()->trace(info.str(),hostBlock->blockId);
	}
}

BlockCode* MRMeldBlockCode::buildNewBlockCode(BuildingBlock *host) {
	return(new MRMeldBlockCode((MultiRobotsBlock*)host));
}
",pev
466,"/**
 * Copyright 2023 Huawei Technologies Co., Ltd
 *
 * 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 ""backend/common/pass/convert_list_to_tuple.h""
#include <map>
#include <utility>
#include <algorithm>
#include ""include/common/utils/anfalgo.h""
#include ""backend/common/session/anf_runtime_algorithm.h""

namespace mindspore {
namespace opt {
static const std::map<std::string, std::string> kOpListToTupleNames = {{prim::kMakeListNew, prim::kMakeTuple},
                                                                       {prim::kListGetItem, prim::kTupleGetItem},
                                                                       {prim::kListSetItem, prim::kTupleSetItem}};
static const size_t kMaxRecursiveDepth = 6;

const AnfNodePtr ConvertListToTuple::Process(const FuncGraphPtr &, const AnfNodePtr &node, const EquivPtr &) const {
  MS_EXCEPTION_IF_NULL(node);
  // Value list --> Value tuple.
  if (node->isa<ValueNode>()) {
    auto value_node = node->cast<ValueNodePtr>();
    MS_EXCEPTION_IF_NULL(value_node);
    bool need_convert = false;
    auto convert_value = ConvertValueSequenceToValueTuple(value_node->value(), &need_convert);
    if (need_convert) {
      return std::make_shared<ValueNode>(convert_value);
    }
    return nullptr;
  }

  if (!node->isa<CNode>()) {
    return nullptr;
  }
  auto cnode = node->cast<CNodePtr>();
  MS_EXCEPTION_IF_NULL(cnode);

  // List name --> tuple name.
  auto old_full_name = cnode->fullname_with_scope();
  auto  [MASK]  = common::AnfAlgo::GetCNodeName(cnode);
  auto iter = kOpListToTupleNames.find( [MASK] );
  if (iter != kOpListToTupleNames.end()) {
    auto primitive = GetCNodePrimitive(cnode);
    MS_EXCEPTION_IF_NULL(primitive);
    primitive->set_name(iter->second);
    // Reset full scope name.
    cnode->set_fullname_with_scope("""");
    common::AnfAlgo::SetNodeAttr(kAttrOpAdaptationProcessed, MakeValue(true), cnode);
    MS_LOG(DEBUG) << ""Rename op from "" <<  [MASK]  << "" to "" << iter->second << "" for op "" << old_full_name << "" to ""
                  << cnode->fullname_with_scope();
  }

  // List abstract --> tuple abstract.
  auto new_abs = ConvertSequenceAbsToTupleAbs(node->abstract());
  if (new_abs != nullptr) {
    node->set_abstract(new_abs);
    common::AnfAlgo::SetNodeAttr(kAttrAbstractAdaptationProcessed, MakeValue(true), cnode);
    MS_LOG(DEBUG) << ""Convert sequence abstract to tuple abstract for op "" << old_full_name << "", new op name ""
                  << cnode->fullname_with_scope();
  }

  return nullptr;
}

// ValueSequence --> ValueTuple.
ValuePtr ConvertListToTuple::ConvertValueSequenceToValueTuple(const ValuePtr &value, bool *need_convert,
                                                              size_t depth) const {
  MS_EXCEPTION_IF_NULL(need_convert);
  MS_EXCEPTION_IF_NULL(value);
  if (depth > kMaxRecursiveDepth) {
    MS_LOG(EXCEPTION) << ""List nesting is not allowed more than "" << kMaxRecursiveDepth << "" levels."";
  }

  if (value->isa<ValueSequence>()) {
    std::vector<ValuePtr> elements;
    auto value_seq = value->cast<ValueSequencePtr>();
    (void)std::transform(value_seq->value().begin(), value_seq->value().end(), std::back_inserter(elements),
                         [&](const ValuePtr &value) -> ValuePtr {
                           bool is_convert = false;
                           auto convert_value = ConvertValueSequenceToValueTuple(value, &is_convert, depth + 1);
                           *need_convert |= is_convert;
                           return convert_value;
                         });
    *need_convert |= value->isa<ValueList>();
    if (*need_convert) {
      return std::make_shared<ValueTuple>(elements);
    }
  }

  return value;
}

// AbstractSequence --> AbstractTuple.
AbstractBasePtr ConvertListToTuple::ConvertSequenceAbsToTupleAbs(const AbstractBasePtr &abs, size_t depth) const {
  if (abs == nullptr) {
    return nullptr;
  }

  if (depth > kMaxRecursiveDepth) {
    MS_LOG(EXCEPTION) << ""List nesting is not allowed more than "" << kMaxRecursiveDepth << "" levels."";
  }

  auto abs_seq = abs->cast<abstract::AbstractSequencePtr>();
  if (abs_seq != nullptr) {
    // Dynamic length sequence convert by the dynamic abs.
    if (abs_seq->dynamic_len() && abs_seq->isa<abstract::AbstractList>()) {
      auto converted_dynamic_abs_tuple =
        std::make_shared<abstract::AbstractTuple>(abs_seq->elements(), abs_seq->sequence_nodes());
      converted_dynamic_abs_tuple->set_dynamic_len(true);
      converted_dynamic_abs_tuple->set_dynamic_len_element_abs(abs_seq->dynamic_len_element_abs());
      return converted_dynamic_abs_tuple;
    }
    const auto &seq_elements = abs_seq->elements();
    // First we check if elements should be converted,
    // changed_elements maps old element to new element.
    mindspore::HashMap<AbstractBasePtr, AbstractBasePtr> changed_elements;
    for (const auto &element : seq_elements) {
      auto new_element = ConvertSequenceAbsToTupleAbs(element, depth + 1);
      if (new_element != nullptr) {
        (void)changed_elements.emplace(element, new_element);
      }
    }
    if (changed_elements.empty()) {
      if (abs->isa<abstract::AbstractTuple>()) {
        // If no elements changed and it is an AbstractTuple, do not convert.
        return nullptr;
      }
      // If no elements changed but it is not an AbstractTuple, convert it by copy elements.
      return std::make_shared<abstract::AbstractTuple>(seq_elements);
    }
    // Always make new AbstractTuple when elements changed.
    std::vector<AbstractBasePtr> elements;
    elements.reserve(seq_elements.size());
    for (const auto &element : seq_elements) {
      auto iter = changed_elements.find(element);
      if (iter != changed_elements.end()) {
        (void)elements.emplace_back(iter->second);
      } else {
        (void)elements.emplace_back(element);
      }
    }
    return std::make_shared<abstract::AbstractTuple>(std::move(elements));
  }

  return nullptr;
}
}  // namespace opt
}  // namespace mindspore
",old_name
467,"#include ""kspch.h""
#include ""Log.h""
#include ""Application.h""
#include ""Input.h""
#include ""Kenshin/Renderer/Renderer.h""
#include <GLFW/glfw3.h>

namespace Kenshin {

	Application* Application::s_Instance = nullptr;
	Application::Application()
	{
		KS_CORE_ASSET(!s_Instance, ""application has already exits!"");
		s_Instance = this;
		m_Window = std::unique_ptr<Window>(Window::Create());
		m_Window->SetEventCallback(BIND_FN(Application::OnEvent));
		m_ImGuiLayer = new ImGuiLayer(""ImGuiLayer"");
		PushOverLayer(m_ImGuiLayer);

		Renderer::Init();
	}

	Application::~Application() {}

	void Application::Run()
	{
		while (m_IsRunning)
		{
			float time = glfwGetTime();
			Timestep ts = time - m_LastFrametime;
			m_LastFrametime = time;
			if (!m_Minmized)
			{
				for (auto& it : m_LayerStack)
				{
					it->OnUpdate(ts);
				}
			}
			m_ImGuiLayer->Begin();
			for (auto& it : m_LayerStack)
			{
				it->OnImGuiRender();
			}
			m_ImGuiLayer->End();
			m_Window->OnUpdate();
		}
	}

	void Application::Close()
	{
		m_IsRunning = false;
	}

	void Application::PushLayer(Layer* layer)
	{
		m_LayerStack.PushLayer(layer);
	}

	void Application::PushOverLayer(Layer* overlay)
	{
		m_LayerStack.PushOverLay(overlay);
	}

	void Application::OnEvent(Event& e)
	{
		EventDispatcher dispatcher(e);
		dispatcher.Dispatch<WindowCloseEvent>(BIND_FN(Application::OnWindowClose));
		dispatcher.Dispatch<WindowResizeEvent>(BIND_FN(Application::OnWindowResize));
		for (auto it = m_LayerStack.end(); it != m_LayerStack.begin();)
		{
			(*(--it))->OnEvent(e);
			if (e.IsHandled())
			{
				break;
			}
		}
	}

	bool Application::OnWindowClose(WindowCloseEvent& e)
	{
		m_IsRunning = false;
		return true;

	}

	bool Application::OnWindowResize(WindowResizeEvent& e)
	{
		uint32_t  [MASK]   = e.GetWidth();
		uint32_t height = e.GetHeight();
		if ( [MASK]  == 0 || height == 0)
		{
			m_Minmized = true;
			return false;
		}
		m_Minmized = false;
		Renderer::OnWindowResize( [MASK] , height);
		return false;
	}
}",width
468,"#pragma once

#include <GL/glew.h>

#include <span>

namespace GlWrapper
{

template <class T>
class Buffer
{
public:
  Buffer(const std::span<T> buffer)
  {
    // check lib types match inbuilt types
    static_assert(sizeof(uint32_t) == sizeof(GLuint), ""GLuint is expected to be 32bits in size"");

    glGenBuffers(1, &id_);
    bind();
    glBufferData(
      GL_SHADER_STORAGE_BUFFER, buffer.size() * sizeof(T), buffer.data(), GL_DYNAMIC_DRAW);
  }

  Buffer(const T & buffer)
  {
    // check lib types match inbuilt types
    static_assert(sizeof(uint32_t) == sizeof(GLuint), ""GLuint is expected to be 32bits in size"");

    glGenBuffers(1, &id_);
    bind();
    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(T), &buffer, GL_DYNAMIC_DRAW);
  }

  ~Buffer() { glDeleteBuffers(1, &id_); }
  void bind() const { glBindBuffer(GL_SHADER_STORAGE_BUFFER, id_); }
  void set_binding_base(int32_t  [MASK] )
  {
    glBindBufferBase(GL_SHADER_STORAGE_BUFFER,  [MASK] , id_);
  }
  void unbind() const { glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); }

private:
  uint32_t id_;
};

};  // namespace GlWrapper
",location
469,"#include ""Particles.h""

/************************************************************/
ParticleSystem::ParticleSystem(sf::Vector2u canvasSize)
    : m_dissolve(false), m_particleSpeed(50.0f), m_transparent(sf::Color(0, 0, 0, 0)),
      m_dissolutionRate(4), m_shape(Shape::CIRCLE), m_gravity(sf::Vector2f(0.0f, 0.0f)),
      m_canvasSize(canvasSize) {
  m_startPos =
      sf::Vector2f(static_cast<float>(canvasSize.x) / 2, static_cast<float>(canvasSize.y) / 2);
}

/************************************************************/
ParticleSystem::~ParticleSystem(void) {
  /* Clear vector */
  m_particles.clear();
}

/************************************************************/
void ParticleSystem::draw(sf::RenderTarget &target, sf::RenderStates states) const {
  for (const auto &item : m_particles) {
    sf::Vertex g1 = item.get()->drawVertex;
    sf::Vertex g2 = item.get()->drawVertex;
    sf::Vertex g3 = item.get()->drawVertex;
    sf::Vertex g4 = item.get()->drawVertex;

    g2.position += sf::Vector2f(2, 0);
    g3.position += sf::Vector2f(1, 1);
    g4.position += sf::Vector2f(1, -1);

    sf::Vertex tri[] = {g1, g2, g3, g4};

    // target.draw(&item.get()->drawVertex, 1, sf::Points);
    target.draw(&tri[0], 4, sf::Lines);
  }
  return;
}

/************************************************************/
void ParticleSystem::fuel(int particles, sf::Vector2f ySpawnRange, sf::Vector2f xSpawnRange) {
  for (int i = 0; i < particles; i++) {

    /* Randomizer initialization */
    std::random_device rd;
    std::mt19937 gen(rd());

    UniRealDist yposition(ySpawnRange.x, ySpawnRange.y);
    UniRealDist xposition(xSpawnRange.x, xSpawnRange.y);
    UniRealDist yspeed(10.0f, 40.0f);
    m_particleSpeed = yspeed(gen);
    /* Generate a new particle and put it at the generation point */
    Particle *particle;
    particle = new Particle();
    particle->drawVertex.position.x = xposition(gen);
    particle->drawVertex.position.y = yposition(gen);
    particle->vel.x = 0.0f;
    particle->vel.y = 1.0f;
    /*
        switch (m_shape) {
        case Shape::CIRCLE: {
          // Generate a random angle
          UniRealDist randomAngle(0.0f, (2.0f * 3.14159265));
          float angle = randomAngle(gen);

          // Use the random angle as a thrust vector for the particle
          // UniRealDist randomAngleCos(0.0f, cos(angle));
          // UniRealDist randomAngleSin(0.0f, sin(angle));
          particle->vel.x = (float)(rand() % 100) * 0.01f; // randomAngleCos(gen);
          particle->vel.y = (float)(rand() % 100) * 0.01f; // randomAngleSin(gen);

          break;
        }
        case Shape::SQUARE: {
          // Square generation
          UniRealDist randomSide(-1.0f, 1.0f);
          particle->vel.x = randomSide(gen);
          particle->vel.y = randomSide(gen);

          break;
        }
        default: {
          particle->vel.x = 0.5f; // Easily detected
          particle->vel.y = 0.5f; // Easily detected
        }
        }
    */

    // We don't want lame particles. Reject, start over.
    if (particle->vel.x == 0.0f && particle->vel.y == 0.0f) {
      delete particle;
      continue;
    }

    /* Randomly change the colors of the particles */
    const auto a = (((m_particleSpeed - 10.0f) / 30.0f) * 255.0f) + 0;
    particle->drawVertex.color.r = 255;
    particle->drawVertex.color.g = 255 - a;
    particle->drawVertex.color.b = 255 - a;
    particle->drawVertex.color.a = 255;

    m_particles.push_back(ParticlePtr(particle));
  }

  return;
}

/************************************************************/
const std::string ParticleSystem::getNumberOfParticlesString(void) const {
  std::ostringstream oss;
  oss << m_particles.size();
  return oss.str();
}

/************************************************************/
void ParticleSystem::update(float  [MASK] ) {
  /* Run through each particle and apply our system to it */
  for (auto it = m_particles.begin(); it != m_particles.end(); it++) {
    /* Apply Gravity */
    (*it)->vel.x += m_gravity.x *  [MASK] ;
    (*it)->vel.y += m_gravity.y *  [MASK] ;

    /* Apply thrust */
    (*it)->drawVertex.position.x += (*it)->vel.x *  [MASK]  * m_particleSpeed;
    (*it)->drawVertex.position.y += (*it)->vel.y *  [MASK]  * m_particleSpeed;

    //(*it)->drawVertex.position.x = round((*it)->drawVertex.position.x);
    //(*it)->drawVertex.position.y = round((*it)->drawVertex.position.y);

    /* If they are set to disolve, disolve */
    // if (m_dissolve)
    // (*it)->drawVertex.color.a -= m_dissolutionRate;

    if ((*it)->drawVertex.position.x > m_canvasSize.x || (*it)->drawVertex.position.x < 0 ||
        (*it)->drawVertex.position.y > m_canvasSize.y || (*it)->drawVertex.position.y < 0 ||
        (*it)->drawVertex.color.a < 10) {
      it = m_particles.erase(it);
      if (it == m_particles.end())
        return;
    }
  }

  return;
}",deltaTime
470,"//
// Created by hanm on 22-6-15.
//

#include ""KDLineTree.h""

Point KDLineTree::max_point() {
    Point tmpPoint;
    float max_distance = 0;
    for(const auto& bucket : KDNode_list){
        if(bucket->max_point.dis > max_distance){
            max_distance = bucket->max_point.dis;
            tmpPoint = bucket->max_point;
        }
    }
    return tmpPoint;
}

void KDLineTree::update_distance(const Point &ref_point) {
    for(const auto& bucket : KDNode_list){
        bucket->send_delay_point(ref_point);
        bucket->update_distance(memory_ops, mult_ops);
    }
}

void KDLineTree::sample(const int sample_num) {
    Point ref_point;
#ifdef METRICS
    int  [MASK]  = 0;
#endif
    for (int i = 1; i < sample_num; i++) {
        ref_point = max_point();
        sample_points[i] = ref_point;
        update_distance(ref_point);
#ifdef LOG
	printf(""Next Iteration\n"");
#endif
#ifdef METRICS
	printf(""%d:%d\n"", i, memory_ops -  [MASK] );
	 [MASK]  = memory_ops;
#endif	
    }
}

bool KDLineTree::leftNode(int high, int count) {
    return high == high_ || count == 1;
}

KDLineTree::KDLineTree(KDTreeBase::Points &data, int pointSize, int treeHigh,KDTreeBase::Points &samplePoints) : KDTreeBase(data,pointSize, samplePoints),high_(treeHigh) {
    KDNode_list.clear();
}

KDLineTree::~KDLineTree(){
    KDNode_list.clear();
}

void KDLineTree::addNode(KDTreeBase::NodePtr p) {
    int nodeIdx = KDNode_list.size();
    p->idx = nodeIdx;
    KDNode_list.push_back(p);
}
",pre_memory_ops
471,"//Copyright 2021 KonstantIMP
//
//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 ""password_generator.hpp""
#include ""defines.hpp""
#include ""kitty.hpp""

#include <fstream>
#include <list>

int main(int argc, char * argv[]) {
    print_hello(std::cout);

    bool debug = false, f_out = false;
    unsigned char opt = 0b00001111;
    std::size_t length = 16;
    std::size_t num = 1;

    std::fstream  [MASK] ;

    for(std::size_t i{1}; i < static_cast<std::size_t>(argc); i++) {
        if(std::string(argv[i]) == ""-h"") {
            print_help(std::cout);
            return 0;
        }
        if(std::string(argv[i]) == ""-v"") {
            std::cout << ""Version : "" << str_version << ""\n"";
            return 0;
        }
        if(std::string(argv[i]) == ""-d"") {
            if(debug) {
                std::cout << ""[ERROR #130] Incorrect command line argument and logical errors\n"";
                std::cout << ""\twhat() : twice \'-d\' flag\n"";
                return 130;
            }
            debug = true;
            continue;
        }
        if(std::string(argv[i]) == ""-l"") {
            if((i + 1) == static_cast<std::size_t>(argc)) {
                std::cout << ""[ERROR #13] Incorrect command line arguments\n"";
                std::cout << ""\twhat() : too few arguments\n"";
                return 13;
            }

            try {
                length = static_cast<std::size_t>(std::stoi(argv[i + 1]));
            }  catch (std::invalid_argument& e) {
                std::cout << ""[ERROR #10] Incorrect command line arguments\n"";
                std::cout << ""\twhat() : "" << e.what() << "" [can't translate string to number]\n"";
                return 10;
            }  catch (std::out_of_range& e) {
                std::cout << ""[ERROR #20] Incorrect command line argument\n"";
                std::cout << ""\twhat() : "" << e.what() << "" [number is too big]\n"";
                return 20;
            }

            i++; continue;
        }
        if(std::string(argv[i]) == ""-o"") {
            if((i + 1) == static_cast<std::size_t>(argc)) {
                std::cout << ""[ERROR #14] Incorrect command line arguments\n"";
                std::cout << ""\twhat() : too few arguments\n"";
                return 14;
            }

            if(f_out) {
                std::cout << ""[ERROR #131] Incorrect command line argument and logical errors\n"";
                std::cout << ""\twhat() : you can use only one output file\n"";
                return 131;
            }

            try {
                 [MASK] .open(std::string(argv[i + 1]), std::ios_base::out | std::ios_base::app);
                if(! [MASK] .is_open()) throw std::ios_base::failure(""std::ofstream::open"");
            }  catch (std::ios_base::failure& e) {
                std::cout << ""[ERROR #40] Runtime error\n"";
                std::cout << ""\twhat() : "" << e.what() << "" [can't open or create \'"" << std::string(argv[i + 1]) << ""\']\n"";
                return 40;
            }

            f_out = true; i++;
            continue;
        }
        if(std::string(argv[i]) == ""-c"") {
            if(num != 1) {
                std::cout << ""[ERROR #132] Incorrect command line argument and logical errors\n"";
                std::cout << ""\twhat() : twice \'-c\' option\n"";
                return 132;
            }
            if((i + 1) == static_cast<std::size_t>(argc)) {
                std::cout << ""[ERROR #15] Incorrect command line arguments\n"";
                std::cout << ""\twhat() : too few arguments\n"";
                return 15;
            }

            try {
                num = static_cast<std::size_t>(std::stoi(argv[i + 1]));
            }  catch (std::invalid_argument& e) {
                std::cout << ""[ERROR #11] Incorrect command line argument\n"";
                std::cout << ""\twhat() : "" << e.what() << "" [can't translate string to number]\n"";
                return 11;
            }  catch (std::out_of_range& e) {
                std::cout << ""[ERROR #21] Incorrect command line argument\n"";
                std::cout << ""\twhat() : "" << e.what() << "" [number is too big]\n"";
                return 21;
            }

            i++; continue;
        }
        if(std::string(argv[i]) == ""-p"") {
            if(opt != 0b00001111) {
                std::cout << ""[ERROR #133] Incorrect command line argument and logical errors\n"";
                std::cout << ""\twhat() : twice \'-p\' option\n"";
                return 133;
            }
            if((i + 1) == static_cast<std::size_t>(argc)) {
                std::cout << ""[ERROR #16] Incorrect command line arguments\n"";
                std::cout << ""\twhat() : too few arguments\n"";
                return 16;
            }

            try {
                opt = static_cast<unsigned char>(std::stoi(argv[i + 1], 0, 2));
            }  catch (std::invalid_argument& e) {
                std::cout << ""[ERROR #12] Incorrect command line argument\n"";
                std::cout << ""\twhat() : "" << e.what() << "" [can't translate string to number]\n"";
                return 12;
            }  catch (std::out_of_range& e) {
                std::cout << ""[ERROR #22] Incorrect command line argument\n"";
                std::cout << ""\twhat() : "" << e.what() << "" [number is too big]\n"";
                return 22;
            }

            i++; continue;
        }
    }

    password_generator gen;

    try {
        gen.set_length(length);
        gen.set_options(opt);
    }  catch (std::invalid_argument& e) {
        std::cout << ""[ERROR #134] Incorrect command line argument and logical errors\n"";
        std::cout << ""\twhat() : "" << e.what() << '\n';
        return 134;
    }

    std::list<std::string> passwords;

    for(std::size_t i{0}; i < num; i++) {
        gen.gen_passwd(debug);
        try {
            passwords.push_back(gen.get_passwd());
        }  catch (std::bad_alloc& e) {
            std::cout << ""[ERROR #41] Runtime error\n"";
            std::cout << ""\twhat() : "" << e.what() << "" [can't allocate memory foe password storage]\n"";
            return 41;
        }  catch (std::runtime_error& e) {
            std::cout << ""[ERROR #42] Runtime error\n"";
            std::cout << ""\twhat() : "" << e.what() << '\n';
            return 42;
        }
    }

    std::cout << ""Result passwords :\n"";

    for(auto iter : passwords) {
        std::cout << '\t' << iter << '\n';
        if(f_out)  [MASK]  << iter << '\n';
    }

    if(f_out)  [MASK] .close();

    return 0;
}
",fout
472,"#include <iostream>
#include <fstream>
#include <cstring>
#include <cstdlib>
#include <locale.h>
//AD SOYAD:<NAME> NO:2412721029 KONU:HEDİYELİK EŞYA OTOMASYONU
using namespace std;

struct HediyelikEya {
    char ad[80];
    char kategori[50];
    float fiyat;
    int miktar;
};

void urunEkle();
void urunListele();
void urunGuncelle();
void urunSil();
void urunAra();

int main() {
    setlocale(LC_ALL, ""Turkish"");
    char secim;
    do {
        system(""cls"");
        cout << ""|------- Hediyelik Eşya Otomasyonu -------|"" << endl;
        cout << ""| 1 - Ürün Ekle                          |"" << endl;
        cout << ""| 2 - Ürün Listele                       |"" << endl;
        cout << ""| 3 - Ürün Güncelle                      |"" << endl;
        cout << ""| 4 - Ürün Sil                           |"" << endl;
        cout << ""| 5 - Ürün Ara                           |"" << endl;
        cout << ""| Çıkmak için 'q' tuşuna basın.          |"" << endl;
        cout << ""|----------------------------------------|"" << endl;
        cin >> secim;

        switch (secim) {
        case '1': urunEkle(); break;
        case '2': urunListele(); break;
        case '3': urunGuncelle(); break;
        case '4': urunSil(); break;
        case '5': urunAra(); break;
        case 'q': break;
        default: cout << ""Geçersiz seçenek!"" << endl;
        }

        cout << ""Ana menüye dönmek için 'a', çıkmak için 'q' basın: "";
        cin >> secim;
    } while (secim != 'q');

    return 0;
}

void urunEkle() {
    HediyelikEya urun;
    ofstream  [MASK] (""urunler.dat"", ios::binary | ios::app);

    char secim;
    do {
        cout << ""Ürün Adı: "";
        cin >> urun.ad;
        cout << ""Ürün Kategorisi: "";
        cin >> urun.kategori;
        cout << ""Ürün Fiyatı: "";
        cin >> urun.fiyat;
        cout << ""Ürün Miktarı: "";
        cin >> urun.miktar;

         [MASK] .write((char*)&urun, sizeof(urun));
        cout << ""Başka ürün eklemek ister misiniz? (E/H): "";
        cin >> secim;
    } while (secim == 'e' || secim == 'E');

     [MASK] .close();
}

void urunListele() {
    ifstream oku(""urunler.dat"", ios::binary);

    if (!oku) {
        cout << ""Veritabanı bulunamadı!"" << endl;
        return;
    }

    HediyelikEya urun;
    int i = 1;
    while (oku.read((char*)&urun, sizeof(urun))) {
        cout << i++ << "". Ürün Adı: "" << urun.ad << "", Kategori: "" << urun.kategori
            << "", Fiyat: "" << urun.fiyat << "" TL, Miktar: "" << urun.miktar << endl;
    }

    oku.close();
}

void urunGuncelle() {
    ifstream oku(""urunler.dat"", ios::binary);
    ofstream gecici(""gecici.dat"", ios::binary);

    if (!oku) {
        cout << ""Veritabanı bulunamadı!"" << endl;
        return;
    }

    char urunAd[80];
    cout << ""Güncellemek istediğiniz ürünün adını girin: "";
    cin >> urunAd;

    HediyelikEya urun;
    bool bulundu = false;

    while (oku.read((char*)&urun, sizeof(urun))) {
        if (strcmp(urun.ad, urunAd) == 0) {
            bulundu = true;
            cout << ""Ürün Bulundu!"" << endl;
            cout << ""Yeni Fiyatı: "";
            cin >> urun.fiyat;
            cout << ""Yeni Miktarı: "";
            cin >> urun.miktar;
            cout << ""Ürün güncellendi!"" << endl;
        }
        gecici.write((char*)&urun, sizeof(urun));
    }

    oku.close();
    gecici.close();

    if (bulundu) {
        remove(""urunler.dat"");
        rename(""gecici.dat"", ""urunler.dat"");
    }
    else {
        remove(""gecici.dat"");
        cout << ""Ürün bulunamadı!"" << endl;
    }
}

void urunSil() {
    ifstream oku(""urunler.dat"", ios::binary);
    ofstream gecici(""gecici.dat"", ios::binary);

    if (!oku) {
        cout << ""Veritabanı bulunamadı!"" << endl;
        return;
    }

    char urunAd[80];
    cout << ""Silmek istediğiniz ürünün adını girin: "";
    cin >> urunAd;

    HediyelikEya urun;
    bool bulundu = false;

    while (oku.read((char*)&urun, sizeof(urun))) {
        if (strcmp(urun.ad, urunAd) != 0) {
            gecici.write((char*)&urun, sizeof(urun));
        }
        else {
            bulundu = true;
            cout << ""Ürün Silindi!"" << endl;
        }
    }

    oku.close();
    gecici.close();

    if (bulundu) {
        remove(""urunler.dat"");
        rename(""gecici.dat"", ""urunler.dat"");
    }
    else {
        remove(""gecici.dat"");
        cout << ""Ürün bulunamadı!"" << endl;
    }
}

void urunAra() {
    ifstream oku(""urunler.dat"", ios::binary);

    if (!oku) {
        cout << ""Veritabanı bulunamadı!"" << endl;
        return;
    }

    char urunAd[80];
    cout << ""Aramak istediğiniz ürün adını girin: "";
    cin >> urunAd;

    HediyelikEya urun;
    bool bulundu = false;

    while (oku.read((char*)&urun, sizeof(urun))) {
        if (strcmp(urun.ad, urunAd) == 0) {
            bulundu = true;
            cout << ""Ürün Bulundu!"" << endl;
            cout << ""Ürün Adı: "" << urun.ad << "", Kategori: "" << urun.kategori
                << "", Fiyat: "" << urun.fiyat << "" TL, Miktar: "" << urun.miktar << endl;
        }
    }

    if (!bulundu) {
        cout << ""Ürün bulunamadı!"" << endl;
    }

    oku.close();
}
",yaz
473,"#include <LiquidCrystal_I2C.h>
#include <Servo.h>

Servo myServo;  // Objek servo pertama
Servo myServo2; // Objek servo kedua

// Initialize the LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Define the pin connected to the sensor
const int sensorPin = A4; // Analog pin A0

void setup() {
  Serial.begin(9600);
  pinMode(sensorPin, INPUT);
  lcd.init();
  lcd.backlight();
  
  myServo.attach(4); // Servo pertama terpasang pada pin 4
  myServo2.attach(3); // Servo kedua terpasang pada pin 3
}

void loop() {
  int sensorValue = analogRead(sensorPin);
  // Konversi nilai sensor ke persentase
  int  [MASK]  = map(sensorValue, 0, 1023, 0, 100);

  // Menampilkan nilai kelembaban pada LCD
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(""Kandungan air:"");
  lcd.print( [MASK] );
  lcd.print(""%"");
  delay(2000);
    delay(2000); // Tunggu dua detik

  lcd.setCursor(0, 1); // Setel kursor ke awal baris kedua
  // Menentukan status kelembaban berdasarkan persentase
  if ( [MASK]  == 13) {
    lcd.print(""normal"");
  } else if ( [MASK]  < 13) {
    lcd.print(""kering"");
  } else {
    lcd.print(""Basah"");
  }

  delay(2000); // Beri waktu untuk membaca teks
   // Tunggu dua detik untuk membaca nilai pada LCD

  // Logika untuk mengontrol servo berdasarkan kelembaban
  if ( [MASK]  > 80) {
    // Servo pada pin 3 berputar ke 45 derajat
    myServo2.write(45);
    delay(3000); // Tunggu 3 detik
    // Kembalikan servo pada pin 3 ke posisi awal
    myServo2.write(0);
    delay(5000); // Tunggu 5 detik sebelum menggerakkan servo berikutnya
    // Servo pada pin 4 berputar ke 45 derajat
    myServo.write(45);
    delay(3000); // Tunggu 3 detik
    // Kembalikan servo pada pin 4 ke posisi awal
    myServo.write(0);
  }
  
  delay(2000); // Tunggu dua detik sebelum loop berikutnya dimulai
}
",moisturePercentage
474,"/*Given an array arr[] of size N of positive integers which may have duplicates.
The task is to find the maximum and second maximum from the array, 
and both of them should be distinct, so If no second max exists, then the second max will be -1.

Constraints:
1 <= T <= 100
1 <= N <= 106
1 <= arr[i] <= 106

Example:
Input:
3
5
1 2 3 4 5
3
2 1 2
2
5 5

Output:
5 4
2 1
5 -1*/

#include<bits/stdc++.h>
#define ll long long int
using namespace std;
void findLargest(vector<int>&v,int n){
	ll max= INT_MIN;
	ll  [MASK] = INT_MIN;
	if(v.size()<2)
	{
		max= v[0];
		 [MASK]  =-1;
	}
	else{
		for(int i=0;i<n;i++){
			if(max<=v[i]){
				 [MASK] = max;
				max= v[i];
			}
            else if(v[i]> [MASK] ){
            	 [MASK] = v[i];
            }
            else{
                [MASK] = -1;
               max= v[i];
            }
			}
		}
		cout<<max<<"" ""<< [MASK] <<endl;
	}

int main()
{
    int t;
    ll n;
    cin>>t;
    while(t--){
       cin>>n;
       vector<int>v(n);
       for(ll i=0;i<n;i++){
       	cin>>v[i];
       }
       findLargest(v,n);       
    }

}",smax
475,"#include <cstdio>
#include <cstring>
#include <pthread.h>

#include ""IThread.hpp""

#define INVALID_TID     0UL
#define THREAD_NAME_LEN 16

namespace alf
{
struct IThread::ThreadImpl
{
    pthread_mutex_t state_mutex;

    pthread_mutex_t event_mutex;
    pthread_cond_t signal_cond;

    ThreadImpl()
        : state_mutex(PTHREAD_MUTEX_INITIALIZER), event_mutex(PTHREAD_MUTEX_INITIALIZER), signal_cond(PTHREAD_COND_INITIALIZER)
    {
    }
};

IThread::IThread(std::string name, IMessageQueue* queue)
    : mRunning(false), mThreadName(name), mThreadId(INVALID_TID), mSignals(0), mMsgQue(queue)
{
    mImpl = new ThreadImpl;
}

IThread::~IThread()
{
    join();

    delete mImpl;
    delete mMsgQue;
}

void IThread::start()
{
    pthread_mutex_lock(&mImpl->state_mutex);

    if (mThreadId == INVALID_TID)
    {
        int err = pthread_create((pthread_t*)&mThreadId, NULL, &threadFunc, (void*)this);
        if (err == 0)
        {
            // Set the name of the created thread
            if (!mThreadName.empty())
            {
                char name[THREAD_NAME_LEN];

                strncpy(name, mThreadName.c_str(), THREAD_NAME_LEN - 1);
                name[THREAD_NAME_LEN - 1] = '\0';
                pthread_setname_np((pthread_t)mThreadId, name);
            }
        }
        else
        {
            perror(""pthread_create"");
        }
    }

    pthread_mutex_unlock(&mImpl->state_mutex);
}

void IThread::join()
{
    pthread_mutex_lock(&mImpl->state_mutex);

    if (mThreadId != INVALID_TID)
    {
        if (pthread_join((pthread_t)mThreadId, NULL) != 0)
        {
            perror(""pthread_join"");
        }
        mThreadId = INVALID_TID;
    }

    pthread_mutex_unlock(&mImpl->state_mutex);
}

bool IThread::isRunning() const
{
    return mRunning;
}

std::string IThread::getName() const
{
    return mThreadName;
}

ThreadIdType IThread::getId() const
{
    return mThreadId;
}

void IThread::postSignal(SignalBits  [MASK] )
{
    pthread_mutex_lock(&mImpl->event_mutex);
    mSignals |=  [MASK] ;
    pthread_cond_signal(&mImpl->signal_cond);
    pthread_mutex_unlock(&mImpl->event_mutex);
}

SignalBits IThread::waitSignal()
{
    SignalBits signals;

    pthread_mutex_lock(&mImpl->event_mutex);

    while (mSignals == 0)
    {
        pthread_cond_wait(&mImpl->signal_cond, &mImpl->event_mutex);
    }

    signals = mSignals;
    mSignals = 0;
    pthread_mutex_unlock(&mImpl->event_mutex);

    return signals;
}

void IThread::postMessage(const void* msg)
{
    if (mMsgQue == NULL)
    {
        return;
    }

    pthread_mutex_lock(&mImpl->event_mutex);
    mMsgQue->push(msg);
    mSignals |= SIGNAL_MSG;
    pthread_cond_signal(&mImpl->signal_cond);
    pthread_mutex_unlock(&mImpl->event_mutex);
}

bool IThread::getMessage(void* msg)
{
    if (mMsgQue == NULL)
    {
        return false;
    }

    bool result;

    pthread_mutex_lock(&mImpl->event_mutex);
    result = mMsgQue->pop(msg);
    pthread_mutex_unlock(&mImpl->event_mutex);

    return result;
}

void* IThread::threadFunc(void* threadObj)
{
    // Get the thread instance
    IThread *thread = (IThread*)threadObj;

    printf(""tid(%lx) %s started\n"", thread->getId(), thread->getName().c_str());

    thread->mRunning = true;

    thread->run();

    thread->mRunning = false;

    printf(""tid(%lx) %s exit\n"", thread->getId(), thread->getName().c_str());

    return NULL;
}

} //namespace alf
",newSignal
476,"// Copyright 2015, <NAME> and the FunctionalPlus contributors.
// https://github.com/Dobiasd/FunctionalPlus
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

#include <fplus/fplus.hpp>

#include <atomic>
#include <cassert>
#include <chrono>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <stdexcept>
#include <string>
#include <vector>

bool is_odd_int(int x) { return x % 2 == 1; }

void Test_example_KeepIf()
{
    typedef std::vector<int> Ints;
    Ints numbers = { 24, 11, 65, 44, 80, 18, 73, 90, 69, 18 };

    { // Version 1: hand written range based for loop
        Ints odds;
        for (int x : numbers)
            if (is_odd_int(x))
                odds.push_back(x);
    }

    { // Version 2: STL
        Ints odds;
        std::copy_if(std::begin(numbers), std::end(numbers),
                std::back_inserter(odds), is_odd_int);
    }

    { // Version : FunctionalPlus
        auto odds = fplus::keep_if(is_odd_int, numbers);
    }
}

void run_n_times(std::function<std::vector<int>(std::vector<int>)> f,
    std::size_t n, const std::string& name, const std::vector<int>& inList)
{
    typedef std::chrono::time_point<std::chrono::system_clock> Time;
    Time startTime = std::chrono::system_clock::now();
    std::size_t lengthSum = 0;
    for (std::size_t i = 0; i < n; ++i)
    {
        lengthSum += f(inList).size();
    }
    Time endTime = std::chrono::system_clock::now();
    std::chrono::duration<double> elapsed_seconds = endTime - startTime;
    std::cout << name << ""(check: "" << lengthSum << ""), elapsed time: "" << elapsed_seconds.count() << ""s\n"";
}

void Test_example_KeepIf_performance()
{
    using namespace fplus;

    typedef std::vector<int> Ints;
    auto run_loop = [&](const Ints numbers)
    {
        Ints odds;
        for (int x : numbers)
            if (is_odd_int(x))
                odds.push_back(x);
        return odds;
    };
    auto run_stl = [&](const Ints numbers)
    {
        Ints odds;
        std::copy_if(std::begin(numbers), std::end(numbers),
                std::back_inserter(odds), is_odd_int);
        return odds;
    };
    auto run_FunctionalPlus = [&](const Ints numbers)
        { return keep_if(is_odd_int, numbers); };

    // make debug runs faster
#if defined NDEBUG || defined _DEBUG
    std::size_t numRuns = 10;
#else
    std::size_t numRuns = 20000;
#endif

    Ints numbers = generate<Ints>(rand, 5000);
    run_n_times(run_loop, numRuns, ""Hand-written for loop"", numbers);
    run_n_times(run_stl, numRuns, ""std::copy_if"", numbers);
    run_n_times(run_FunctionalPlus, numRuns, ""FunctionalPlus::keep_if"", numbers);
}


void Test_example_SameOldSameOld()
{
    std::list<std::string> things = {""same old"", ""same old""};
    if (fplus::all_the_same(things))
        std::cout << ""All things being equal."" << std::endl;
}

void Test_example_IInTeam()
{
    std::string team = ""Our team is great. I love everybody I work with."";
    std::cout << ""There actually are this many 'I's in team: "" <<
        fplus::count(""I"", fplus::split_words(false, team)) << std::endl;
}

struct Entity
{
    Entity() : calm_(true), bright_(true) {}
    bool calm_;
    bool bright_;
};

void Test_example_AllIsCalmAndBright()
{
    auto isCalm = [](const Entity& e) { return e.calm_; };
    auto isBright = [](const Entity& e) { return e.bright_; };
    std::vector<Entity> entities(4);
    if (fplus::all_by(fplus::logical_and(isCalm, isBright), entities))
        std::cout << ""Silent night."" << std::endl;
}

struct cat
{
    std::string name_;
    double softness_;
    double temperature_;
    double size_;
    double roundness_;
    double fur_amount_;
};

void Test_example_TheCutestCat()
{
    auto  [MASK]  = [](const cat& c) -> double
    {
        return c.softness_ * c.temperature_ * c.roundness_ *
            c.fur_amount_ - c.size_;
    };
    std::vector<cat> cats = {
        {""Tigger"",   5, 5, 5, 5, 5},
        {""Simba"",    2, 9, 9, 2, 7},
        {""Muffin"",   9, 4, 2, 8, 6},
        {""Garfield"", 6, 5, 7, 9, 5}};

    auto cutest_cat = fplus::maximum_on( [MASK] , cats);

    std::cout << cutest_cat.name_ <<
        "" is happy and sleepy. *purr* *purr* *purr*"" << std::endl;
}

std::list<int> collatz_seq(int x)
{
    std::list<int> result;
    while (x > 1)
    {
        result.push_back(x);
        if (x % 2 == 0)
            x = x / 2;
        else
            x = 3 * x + 1;
    }
    result.push_back(x);
    return result;
}

void Test_example_CollatzSequence()
{
    typedef std::list<int> Ints;

    // [1, 2, 3 ... 29]
    auto numbers = fplus::generate_range<Ints>(1, 30);

    // A function that does [1, 2, 3, 4, 5] -> ""[1 => 2 => 3 => 4 => 5]""
    auto show_ints = fplus::bind_1st_of_2(fplus::show_cont_with<Ints>, "" => "");

    // A composed function that calculates a Collatz sequence and shows it.
    auto show_collats_seq = fplus::compose(collatz_seq, show_ints);

    // Associate the numbers with the string representation of their sequences.
    auto collatz_dict = fplus::create_map_with(show_collats_seq, numbers);

    // Print some of the sequences.
    std::cout << collatz_dict[13] << std::endl;
    std::cout << collatz_dict[17] << std::endl;
}

std::string gemstone_count(const std::string& input)
{
    using namespace fplus;

    typedef std::set<std::string::value_type> character_set;

    const auto lines = split_lines(false, input);

    const auto sets = transform(
        convert_container<character_set, std::string>,
        lines);

    const auto gem_elements = fold_left_1(
        set_intersection<character_set>, sets);

    return show(size_of_cont(gem_elements));
}

std::string gemstone_count_fwd_apply(const std::string& input)
{
    using namespace fplus;
    typedef std::set<std::string::value_type> character_set;
    return fwd::apply(
        input
        , fwd::split_lines(false)
        , fwd::transform(convert_container<character_set, std::string>)
        , fwd::fold_left_1(set_intersection<character_set>)
        , fwd::size_of_cont()
        , fwd::show()
    );
}

using namespace fplus;
typedef std::set<std::string::value_type> character_set;
const auto gemstone_count_fwd_compose = fwd::compose(
    fwd::split_lines(false),
    fwd::transform(convert_container<character_set, std::string>),
    fwd::fold_left_1(set_intersection<character_set>),
    fwd::size_of_cont(),
    fwd::show()
);

void Test_example_fwd_style()
{
    const std::string input =
        ""Lorem ipsum\ndolor sit amet,\nconsectetur,\nadipisci velit"";
    const auto result = gemstone_count(input);
    const auto result_fwd_apply = gemstone_count_fwd_apply(input);
    const auto result_fwd_compose = gemstone_count_fwd_compose(input);
}

int main()
{
    std::cout << ""Testing Applications."" << std::endl;
    Test_example_KeepIf();
    Test_example_KeepIf_performance();
    Test_example_SameOldSameOld();
    Test_example_IInTeam();
    Test_example_AllIsCalmAndBright();
    Test_example_TheCutestCat();
    Test_example_CollatzSequence();
    Test_example_fwd_style();
    std::cout << ""-------"" << std::endl;
    std::cout << ""Applications OK."" << std::endl;
    std::cout << ""======="" << std::endl;
}
",cuteness
477,"/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * 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 ""pin_auth.h""

#include <memory>
#include <string>

#include ""dm_constants.h""
#include ""dm_log.h""
#include ""nlohmann/json.hpp""

namespace OHOS {
namespace DistributedHardware {
const int32_t MAX_VERIFY_TIMES = 3;
PinAuth::PinAuth()
{
    pinAuthUi_ = std::make_shared<PinAuthUi>();
    LOGI(""PinAuth constructor"");
}

PinAuth::~PinAuth()
{
}

int32_t PinAuth::ShowAuthInfo(std::string &authToken, std::shared_ptr<DmAuthManager> authManager)
{
    nlohmann::json jsonObject = nlohmann::json::parse(authToken, nullptr, false);
    if (jsonObject.is_discarded()) {
        LOGE(""DecodeRequestAuth jsonStr error"");
        return ERR_DM_FAILED;
    }
    if (!jsonObject.contains(PIN_CODE_KEY)) {
        LOGE(""err json string, first time"");
        return ERR_DM_FAILED;
    }
    return pinAuthUi_->ShowPinDialog(jsonObject[PIN_CODE_KEY], authManager);
}

int32_t PinAuth::StartAuth(std::string &authToken, std::shared_ptr<DmAuthManager> authManager)
{
    return pinAuthUi_->InputPinDialog(authManager);
}

int32_t PinAuth::VerifyAuthentication(std::string &authToken, const std::string &authParam)
{
    times_ += 1;
    if (authParam.length() == 1) {
        if (authParam == EVENT_CONFIRM_CODE) {
            return DM_OK;
        }
        LOGE(""Peer rejection"");
        return ERR_DM_FAILED;
    }
    nlohmann::json authParamJson = nlohmann::json::parse(authParam, nullptr, false);
    if (authParamJson.is_discarded()) {
        LOGE(""DecodeRequestAuth jsonStr error"");
        return ERR_DM_FAILED;
    }
    nlohmann::json authTokenJson = nlohmann::json::parse(authToken, nullptr, false);
    if (authTokenJson.is_discarded()) {
        LOGE(""DecodeRequestAuth jsonStr error"");
        return ERR_DM_FAILED;
    }
    if (!authParamJson.contains(PIN_CODE_KEY) || !authParamJson.contains(PIN_TOKEN)
        || !authTokenJson.contains(PIN_CODE_KEY) || !authTokenJson.contains(PIN_TOKEN)) {
        LOGE(""err json string, first time"");
        return ERR_DM_FAILED;
    }
    int32_t code = authTokenJson[PIN_CODE_KEY];
    std::string  [MASK]  = authTokenJson[PIN_TOKEN];
    int32_t inputPinCode = authParamJson[PIN_CODE_KEY];
    std::string inputPinToken = authParamJson[PIN_TOKEN];
    if (code == inputPinCode &&  [MASK]  == inputPinToken) {
        return DM_OK;
    } else if (code != inputPinCode && times_ < MAX_VERIFY_TIMES) {
        return ERR_DM_INPUT_PARAMETER_EMPTY;
    } else {
        return ERR_DM_FAILED;
    }
}

int32_t PinAuth::CloseAuthInfo(const int32_t &pageId, std::shared_ptr<DmAuthManager> authManager)
{
    return pinAuthUi_->ClosePage(pageId, authManager);
}

int32_t PinAuth::UpdateAuthInfo(const int32_t &pageId)
{
    return pinAuthUi_->UpdatePinDialog(pageId);
}

extern ""C"" IAuthentication *CreatePinAuthObject(void)
{
    return new PinAuth;
}
} // namespace DistributedHardware
} // namespace OHOS
",pinToken
478,"/* ###
 * IP: GHIDRA
 *
 * 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 ""double.hh""

namespace ghidra {

/// Internally, the \b lo and \b hi Varnodes are set to null, and the \b val field
/// holds the constant value.
/// \param sz is the size in bytes of the constant
/// \param v is the constant value
SplitVarnode::SplitVarnode(int4 sz,uintb v)

{
  val = v;
  wholesize = sz;
  lo = (Varnode *)0;
  hi = (Varnode *)0;
  whole = (Varnode *)0;
  defpoint = (PcodeOp *)0;
  defblock = (BlockBasic *)0;
}

/// \param sz is the size of the constant in bytes
/// \param v is the constant value
void SplitVarnode::initPartial(int4 sz,uintb v)

{
  val = v;
  wholesize = sz;
  lo = (Varnode *)0;
  hi = (Varnode *)0;
  whole = (Varnode *)0;
  defpoint = (PcodeOp *)0;
  defblock = (BlockBasic *)0;
}

/// The Varnode pieces can be constant, in which case a constant SplitVarnode is initialized and
/// a constant value is built from the pieces.  The given most significant piece can be null, indicating
/// that the most significant piece of the whole is an implied zero.
/// \param sz is the size of the logical whole in bytes
/// \param l is the given (least significant) Varnode piece
/// \param h is the given (most significant) Varnode piece
void SplitVarnode::initPartial(int4 sz,Varnode *l,Varnode *h)

{
  if (h == (Varnode *)0) {	// hi is an implied zero
    hi = (Varnode *)0;
    if (l->isConstant()) {
      val = l->getOffset();	// Assume l is a constant
      lo = (Varnode *)0;
    }
    else
      lo = l;
  }
  else {
    if (l->isConstant() && h->isConstant()) {
      val = h->getOffset();
      val <<= (l->getSize()*8);
      val |= l->getOffset();
      lo = (Varnode *)0;
      hi = (Varnode *)0;
    }
    else {
      lo = l;
      hi = h;
    }
  }
  wholesize = sz;
  whole = (Varnode *)0;
  defpoint = (PcodeOp *)0;
  defblock = (BlockBasic *)0;
}

/// The \b lo, \b hi, and \b whole fields are filled in.  The definition point remains uninitialized.
/// \param w is the given whole Varnode
/// \param l is the given (least significant) Varnode piece
/// \param h is the given (most significant) Varnode piece
void SplitVarnode::initAll(Varnode *w,Varnode *l,Varnode *h)

{
  wholesize = w->getSize();
  lo = l;
  hi = h;
  whole = w;
  defpoint = (PcodeOp *)0;
  defblock = (BlockBasic *)0;
}

/// Verify that the given most significant piece is formed via CPUI_SUBPIECE and search
/// for the least significant piece being formed as a CPUI_SUBPIECE of the same whole.
/// \param h is the given (most significant) Varnode piece
/// \return \b true if the matching \b whole and least significant piece is found
bool SplitVarnode::inHandHi(Varnode *h)

{
  if (!h->isPrecisHi()) return false; // Check for mark, in order to have quick -false- in most cases
  // Search for the companion
  if (h->isWritten()) {
    PcodeOp *op = h->getDef();
    // We could check for double loads here
    if (op->code() == CPUI_SUBPIECE) {
      Varnode *w = op->getIn(0);
      if (op->getIn(1)->getOffset() != (uintb)(w->getSize()-h->getSize())) return false;
      list<PcodeOp *>::const_iterator iter,enditer;
      iter = w->beginDescend();
      enditer = w->endDescend();
      while(iter != enditer) {
	PcodeOp *tmpop = *iter;
	++iter;
	if (tmpop->code() != CPUI_SUBPIECE) continue;
	Varnode *tmplo = tmpop->getOut();
	if (!tmplo->isPrecisLo()) continue;
	if (tmplo->getSize() + h->getSize() != w->getSize()) continue;
	if (tmpop->getIn(1)->getOffset() != 0) continue;
	// There could conceivably be more than one, but this shouldn't happen with CSE
	initAll(w,tmplo,h);
	return true;
      }
    }
  }
  return false;
}

/// Verify that the given least significant piece is formed via CPUI_SUBPIECE and search
/// for the most significant piece being formed as a CPUI_SUBPIECE of the same whole.
/// \param l is the given (least significant) Varnode piece
/// \return \b true if the matching \b whole and most significant piece is found
bool SplitVarnode::inHandLo(Varnode *l)

{
  if (!l->isPrecisLo()) return false; // Check for mark, in order to have quick -false- in most cases
  // Search for the companion
  if (l->isWritten()) {
    PcodeOp *op = l->getDef();
    // We could check for double loads here
    if (op->code() == CPUI_SUBPIECE) {
      Varnode *w = op->getIn(0);
      if (op->getIn(1)->getOffset() != 0) return false;
      list<PcodeOp *>::const_iterator iter,enditer;
      iter = w->beginDescend();
      enditer = w->endDescend();
      while(iter != enditer) {
	PcodeOp *tmpop = *iter;
	++iter;
	if (tmpop->code() != CPUI_SUBPIECE) continue;
	Varnode *tmphi = tmpop->getOut();
	if (!tmphi->isPrecisHi()) continue;
	if (tmphi->getSize() + l->getSize() != w->getSize()) continue;
	if (tmpop->getIn(1)->getOffset() != (uintb)l->getSize()) continue;
	// There could conceivably be more than one, but this shouldn't happen with CSE
	initAll(w,l,tmphi);
	return true;
      }
    }
  }
  return false;
}

/// The given least significant Varnode must already be marked as a piece.
/// Initialize the SplitVarnode with the given piece and the \b whole that it came from.
/// If a matching most significant piece can be found, as another CPUI_SUBPIECE off of the same
/// \b whole, initialize that as well.  Otherwise leave the most significant piece as null.
/// \param l is the given (least significant) Varnode piece
/// \return \b true if the SplitVarnode is successfully initialized
bool SplitVarnode::inHandLoNoHi(Varnode *l)

{
  if (!l->isPrecisLo()) return false;
  if (!l->isWritten()) return false;
  PcodeOp *op = l->getDef();
  if (op->code() != CPUI_SUBPIECE) return false;
  if (op->getIn(1)->getOffset() != 0) return false;
  Varnode *w = op->getIn(0);

  list<PcodeOp *>::const_iterator iter,enditer;
  iter = w->beginDescend();
  enditer = w->endDescend();
  while(iter != enditer) {
    PcodeOp *tmpop = *iter;
    ++iter;
    if (tmpop->code() != CPUI_SUBPIECE) continue;
    Varnode *tmphi = tmpop->getOut();
    if (!tmphi->isPrecisHi()) continue;
    if (tmphi->getSize() + l->getSize() != w->getSize()) continue;
    if (tmpop->getIn(1)->getOffset() != (uintb)l->getSize()) continue;
    // There could conceivably be more than one, but this shouldn't happen with CSE
    initAll(w,l,tmphi);
    return true;
  }
  initAll(w,l,(Varnode *)0);
  return true;
}

/// Initialize the SplitVarnode given the most significant piece, if it is concatenated together
/// immediately with is least significant piece.  The CPUI_PIECE and the matching least significant
/// piece must be unique.  If these are found, \b hi, \b lo, and \b whole are all filled in.
/// \param h is the given (most significant) piece
/// \return \b true if initialization was successful and the least significant piece was found
bool SplitVarnode::inHandHiOut(Varnode *h)

{
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = h->beginDescend();
  enditer = h->endDescend();
  Varnode *loTmp = (Varnode *)0;
  Varnode *outvn = (Varnode *)0;
  while(iter != enditer) {
    PcodeOp *pieceop = *iter;
    ++iter;
    if (pieceop->code() != CPUI_PIECE) continue;
    if (pieceop->getIn(0) != h) continue;
    Varnode *l = pieceop->getIn(1);
    if (!l->isPrecisLo()) continue;
    if (loTmp != (Varnode *)0) return false; // Whole is not unique
    loTmp = l;
    outvn = pieceop->getOut();
  }
  if (loTmp != (Varnode *)0) {
    initAll(outvn,loTmp,h);
    return true;
  }
  return false;
}

/// Initialize the SplitVarnode given the least significant piece, if it is concatenated together
/// immediately with is nost significant piece.  The CPUI_PIECE and the matching most significant
/// piece must be unique.  If these are found, \b hi, \b lo, and \b whole are all filled in.
/// \param l is the given (least significant) piece
/// \return \b true if initialization was successful and the most significant piece was found
bool SplitVarnode::inHandLoOut(Varnode *l)

{
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = l->beginDescend();
  enditer = l->endDescend();
  Varnode *hiTmp = (Varnode *)0;
  Varnode *outvn = (Varnode *)0;
  while(iter != enditer) {
    PcodeOp *pieceop = *iter;
    ++iter;
    if (pieceop->code() != CPUI_PIECE) continue;
    if (pieceop->getIn(1) != l) continue;
    Varnode *h = pieceop->getIn(0);
    if (!h->isPrecisHi()) continue;
    if (hiTmp != (Varnode *)0) return false; // Whole is not unique
    hiTmp = h;
    outvn = pieceop->getOut();
  }
  if (hiTmp != (Varnode *)0) {
    initAll(outvn,l,hiTmp);
    return true;
  }
  return false;
}

/// Look for CPUI_SUBPIECE operations off of a common Varnode.
/// The \b whole field is set to this Varnode if found; the definition point and block are
/// filled in and \b true is returned.  Otherwise \b false is returned.
/// \return \b true if the \b whole Varnode is found
bool SplitVarnode::findWholeSplitToPieces(void)

{
  if (whole == (Varnode*)0) {
    if (hi == (Varnode*)0) return false;
    if (lo == (Varnode*)0) return false;
    if (!hi->isWritten()) return false;
    PcodeOp *subhi = hi->getDef();
    if (subhi->code() == CPUI_COPY) { // Go thru one level of copy, if the piece is addrtied
      Varnode *otherhi = subhi->getIn(0);
      if (!otherhi->isWritten()) return false;
      subhi = otherhi->getDef();
    }
    if (subhi->code() != CPUI_SUBPIECE) return false;
    if (subhi->getIn(1)->getOffset() != wholesize - hi->getSize()) return false;
    whole = subhi->getIn(0);
    if (!lo->isWritten()) return false;
    PcodeOp *sublo = lo->getDef();
    if (sublo->code() == CPUI_COPY) { // Go thru one level of copy, if the piece is addrtied
      Varnode *otherlo = sublo->getIn(0);
      if (!otherlo->isWritten()) return false;
      sublo = otherlo->getDef();
    }
    if (sublo->code() != CPUI_SUBPIECE) return false;
    Varnode *res = sublo->getIn(0);
    if (whole == (Varnode*)0)
      whole = res;
    else if (whole != res)
      return false;		// Doesn't match between pieces
    if (sublo->getIn(1)->getOffset() != 0)
      return false;
    if (whole == (Varnode*)0) return false;
  }

  if (whole->isWritten()) {
    defpoint = whole->getDef();
    defblock = defpoint->getParent();
  }
  else if (whole->isInput()) {
    defpoint = (PcodeOp *)0;
    defblock = (BlockBasic *)0;
  }
  return true;
}

/// Set the basic block, \b defblock, and PcodeOp, \b defpoint, where they are defined.
/// Its possible that \b lo and \b hi are \e input Varnodes with no natural defining PcodeOp,
/// in which case \b defpoint is set to null and \b defblock is set to the function entry block.
/// The method returns \b true, if the definition point is found, which amounts to returning
/// \b false if the SplitVarnode is only half constant or half input.
/// \return \b true if the definition point is located
bool SplitVarnode::findDefinitionPoint(void)

{
  PcodeOp *lastop;
  if (hi != (Varnode *)0 && hi->isConstant()) return false; // If one but not both is constant
  if (lo->isConstant()) return false;
  if (hi == (Varnode *)0) {	// Implied zero extension
    if (lo->isInput()) {
      defblock = (BlockBasic *)0;
      defpoint = (PcodeOp *)0;
    }
    else if (lo->isWritten()) {
      defpoint = lo->getDef();
      defblock = defpoint->getParent();
    }
    else
      return false;
  }
  else if (hi->isWritten()) {
    if (!lo->isWritten()) return false;		// Do not allow mixed input/non-input pairs
    lastop = hi->getDef();
    defblock = lastop->getParent();
    PcodeOp *lastop2 = lo->getDef();
    BlockBasic *otherblock = lastop2->getParent();
    if (defblock != otherblock) {
      defpoint = lastop;
      FlowBlock *curbl = defblock;
      while(curbl != (FlowBlock *)0) { // Make sure defblock dominated by otherblock
	curbl = curbl->getImmedDom();
	if (curbl == otherblock) return true;
      }
      defblock = otherblock;		// Try lo as final defining location
      otherblock = lastop->getParent();
      defpoint = lastop2;
      curbl = defblock;
      while(curbl != (FlowBlock *)0) {
	curbl = curbl->getImmedDom();
	if (curbl == otherblock) return true;
      }
      defblock = (BlockBasic *)0;
      return false;		// Not defined in same basic block
    }
    if (lastop2->getSeqNum().getOrder() > lastop->getSeqNum().getOrder())
      lastop = lastop2;
    defpoint = lastop;
  }
  else if (hi->isInput()) {
    if (!lo->isInput())
      return false;		// Do not allow mixed input/non-input pairs
    defblock = (BlockBasic *)0;
    defpoint = (PcodeOp *)0;
  }
  return true;
}

/// If both \b lo and \b hi pieces are written, the earlier of the two defining PcodeOps
/// is returned.  Otherwise null is returned.
/// \return the earlier of the two defining PcodeOps or null
PcodeOp *SplitVarnode::findEarliestSplitPoint(void)

{
  if (!hi->isWritten()) return (PcodeOp *)0;
  if (!lo->isWritten()) return (PcodeOp *)0;
  PcodeOp *hiop = hi->getDef();
  PcodeOp *loop = lo->getDef();
  if (loop->getParent() != hiop->getParent())
    return (PcodeOp *)0;
  return (loop->getSeqNum().getOrder() < hiop->getSeqNum().getOrder()) ? loop : hiop;
}
 
/// We scan for concatenations formed out of \b hi and \b lo, in the correct significance order.
/// We assume \b hi and \b lo are defined in the same basic block (or  are both inputs) and that
/// the concatenation is also in this block. If such a concatenation is found, \b whole is set to the
/// concatenated Varnode, the defining block and PcodeOp is filled in, and \b true is returned.
/// \return \b true if a \b whole concatenated from \b hi and \b lo is found
bool SplitVarnode::findWholeBuiltFromPieces(void)

{
  if (hi==(Varnode *)0) return false;
  if (lo==(Varnode *)0) return false;
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = lo->beginDescend();
  enditer = lo->endDescend();
  PcodeOp *res = (PcodeOp *)0;
  BlockBasic *bb;
  if (lo->isWritten())
    bb = lo->getDef()->getParent();
  else if (lo->isInput())
    bb = (BlockBasic *)0;
  else
    throw LowlevelError(""Trying to find whole on free varnode"");
  while(iter != enditer) {
    PcodeOp *op = *iter;
    ++iter;
    if (op->code() != CPUI_PIECE) continue;
    if (op->getIn(0) != hi) continue;
    if (bb != (BlockBasic *)0) {
      if (op->getParent() != bb) continue; // Not defined in earliest block
    }
    else if (!op->getParent()->isEntryPoint())
      continue;
    if (res == (PcodeOp *)0)
      res = op;
    else {
      if (op->getSeqNum().getOrder() < res->getSeqNum().getOrder()) // Find ""earliest"" whole
	res = op;
    }
  }

  if (res == (PcodeOp *)0)
    whole = (Varnode *)0;
  else {
    defpoint = res;
    defblock = defpoint->getParent();
    whole = res->getOut();
  }
  return (whole!=(Varnode *)0);
}

/// The whole Varnode must be defined or definable \e before the given PcodeOp.
/// This is checked by comparing the given PcodeOp to the defining PcodeOp and block for \b this,
/// which are filled in if they weren't before.
/// \param existop is the given PcodeOp
/// \return \b true if a whole Varnode exists or can be defined before the given PcodeOp
bool SplitVarnode::isWholeFeasible(PcodeOp *existop)

{
  if (isConstant()) return true;
  if ((lo!=(Varnode *)0)&&(hi!=(Varnode *)0))
    if (lo->isConstant() != hi->isConstant()) return false; // Mixed constant/non-constant
  if (!findWholeSplitToPieces()) {
    if (!findWholeBuiltFromPieces()) {
      if (!findDefinitionPoint())
	return false;
    }
  }
  if (defblock == (BlockBasic *)0) return true;
  FlowBlock *curbl = existop->getParent();
  if (curbl == defblock)	// If defined in same block as -existop- check PcodeOp ordering
    return (defpoint->getSeqNum().getOrder() <= existop->getSeqNum().getOrder());
  while(curbl != (FlowBlock *)0) { // Make sure defbock dominates block containing -existop-
    curbl = curbl->getImmedDom();
    if (curbl == defblock) return true;
  }
  return false;
}

/// This is similar to isWholeFeasible(), but the \b whole must be defined before the end of the given
/// basic block.
/// \param bl is the given basic block
/// \return \b true if a whole Varnode exists or can be defined before the end of the given basic block
bool SplitVarnode::isWholePhiFeasible(FlowBlock *bl)

{
  if (isConstant()) return false;
  if (!findWholeSplitToPieces()) {
    if (!findWholeBuiltFromPieces()) {
      if (!findDefinitionPoint())
	return false;
    }
  }
  if (defblock == (BlockBasic *)0) return true;
  if (bl == defblock)	// If defined in same block
    return true;
  while(bl != (FlowBlock *)0) { // Make sure defblock dominates block containing -existop-
    bl = bl->getImmedDom();
    if (bl == defblock) return true;
  }
  return false;
}

/// This method assumes isWholeFeasible has been called and returned \b true.
/// If the \b whole didn't already exist, it is created as the concatenation of its two pieces.
/// If the pieces were constant, a constant whole Varnode is created.
/// If the \b hi piece was null, the whole is created as a CPUI_ZEXT of the \b lo.
/// \param data is the function owning the Varnode pieces
void SplitVarnode::findCreateWhole(Funcdata &data)

{
  if (isConstant()) {
    whole = data.newConstant(wholesize,val);
    return;
  }
  else {
    if (lo != (Varnode *)0)
      lo->setPrecisLo();		// Mark the pieces
    if (hi != (Varnode *)0)
      hi->setPrecisHi();
  }

  if (whole != (Varnode *)0) return; // Already found the whole
  PcodeOp *concatop;
  Address addr;
  BlockBasic *topblock = (BlockBasic *)0;

  if (defblock != (BlockBasic *)0)
    addr = defpoint->getAddr();
  else {
    topblock = (BlockBasic *)data.getBasicBlocks().getStartBlock();
    addr = topblock->getStart();
  }

  if (hi != (Varnode*)0) {
    concatop = data.newOp(2,addr);
    // Do we need to pick something other than a unique????
    whole = data.newUniqueOut(wholesize,concatop);
    data.opSetOpcode(concatop,CPUI_PIECE);
    data.opSetOutput(concatop,whole);
    data.opSetInput(concatop,hi,0);
    data.opSetInput(concatop,lo,1);
  }
  else {
    concatop = data.newOp(1,addr);
    whole = data.newUniqueOut(wholesize,concatop);
    data.opSetOpcode(concatop,CPUI_INT_ZEXT);
    data.opSetOutput(concatop,whole);
    data.opSetInput(concatop,lo,0);
  }

  if (defblock != (BlockBasic *)0)
    data.opInsertAfter(concatop,defpoint);
  else
    data.opInsertBegin(concatop,topblock);

  defpoint = concatop;
  defblock = concatop->getParent();
}

/// If the \b whole does not already exist, it is created as a \e unique register.
/// The new Varnode must later be set explicitly as the output of some PcodeOp.
/// \param data is the function owning the Varnode pieces
void SplitVarnode::findCreateOutputWhole(Funcdata &data)

{ // Create the actual -whole- varnode
  lo->setPrecisLo();		// Mark the pieces
  hi->setPrecisHi();
  if (whole != (Varnode *)0) return;
  whole = data.newUnique(wholesize);
}

/// If the pieces can be treated as a contiguous whole, use the same storage location to construct the \b whole,
/// otherwise use a \b join address for storage.
/// \param data is the function owning the pieces
void SplitVarnode::createJoinedWhole(Funcdata &data)

{
  lo->setPrecisLo();
  hi->setPrecisHi();
  if (whole != (Varnode *)0) return;
  Address newaddr;
  if (!isAddrTiedContiguous(lo,hi,newaddr)) {
    newaddr = data.getArch()->constructJoinAddress(data.getArch()->translate,hi->getAddr(),hi->getSize(),
									    lo->getAddr(),lo->getSize());
  }
  whole = data.newVarnode(wholesize,newaddr);
  whole->setWriteMask();
}

/// Assume \b lo was initially defined in some other way but now needs to be defined as a split from
/// a new \b whole Varnode.  The original PcodeOp defining \b lo is transformed into a CPUI_SUBPIECE.
/// The method findCreateOutputWhole() must already have been called on \b this.
void SplitVarnode::buildLoFromWhole(Funcdata &data)

{
  PcodeOp *loop = lo->getDef();
  if (loop == (PcodeOp *)0)
    throw LowlevelError(""Building low piece that was originally undefined"");

  vector<Varnode *> inlist;
  inlist.push_back(whole);
  inlist.push_back(data.newConstant(4,0));
  if (loop->code() == CPUI_MULTIEQUAL) {
    // When converting the MULTIEQUAL to a SUBPIECE, we need to reinsert the op so that we don't
    // get a break in the sequence of MULTIEQUALs at the beginning of the block
    BlockBasic *bl = loop->getParent();
    data.opUninsert(loop);
    data.opSetOpcode(loop,CPUI_SUBPIECE);
    data.opSetAllInput(loop,inlist);
    data.opInsertBegin(loop,bl);
  }
  else if (loop->code() == CPUI_INDIRECT) {
    // When converting an INDIRECT to a SUBPIECE, we need to reinsert the op AFTER the affector
    PcodeOp *affector = PcodeOp::getOpFromConst(loop->getIn(1)->getAddr());
    if (!affector->isDead())
      data.opUninsert(loop);
    data.opSetOpcode(loop,CPUI_SUBPIECE);
    data.opSetAllInput(loop,inlist);
    if (!affector->isDead())
      data.opInsertAfter(loop,affector);
  }
  else {
    data.opSetOpcode(loop,CPUI_SUBPIECE);
    data.opSetAllInput(loop,inlist);
  }
}

/// Assume \b hi was initially defined in some other way but now needs to be defined as a split from
/// a new \b whole Varnode.  The original PcodeOp defining \b hi is transformed into a CPUI_SUBPIECE.
/// The method findCreateOutputWhole() must already have been called on \b this.
void SplitVarnode::buildHiFromWhole(Funcdata &data)

{
  PcodeOp *hiop = hi->getDef();
  if (hiop == (PcodeOp *)0)
    throw LowlevelError(""Building low piece that was originally undefined"");

  vector<Varnode *> inlist;
  inlist.push_back(whole);
  inlist.push_back(data.newConstant(4,lo->getSize()));
  if (hiop->code() == CPUI_MULTIEQUAL) {
    // When converting the MULTIEQUAL to a SUBPIECE, we need to reinsert the op so that we don't
    // get a break in the sequence of MULTIEQUALs at the beginning of the block
    BlockBasic *bl = hiop->getParent();
    data.opUninsert(hiop);
    data.opSetOpcode(hiop,CPUI_SUBPIECE);
    data.opSetAllInput(hiop,inlist);
    data.opInsertBegin(hiop,bl);
  }
  else if (hiop->code() == CPUI_INDIRECT) {
    // When converting the INDIRECT to a SUBPIECE, we need to reinsert AFTER the affector
    PcodeOp *affector = PcodeOp::getOpFromConst(hiop->getIn(1)->getAddr());
    if (!affector->isDead())
      data.opUninsert(hiop);
    data.opSetOpcode(hiop,CPUI_SUBPIECE);
    data.opSetAllInput(hiop,inlist);
    if (!affector->isDead())
      data.opInsertAfter(hiop,affector);
  }
  else {
    data.opSetOpcode(hiop,CPUI_SUBPIECE);
    data.opSetAllInput(hiop,inlist);
  }
}

// void SplitVarnode::buildHiFromLoHalf(Funcdata &data,SplitVarnode &oldin,PcodeOp *newwholeop)

// { // Only the lo half of the new logical whole is explicitly constructed, the old input high
//   // is recycled for the hi half of the output, define the new hi half as a SUBPIECE and scan
//   // through the uses of the old hi half to see which should be switch to the new hi half
//   PcodeOp *newhiop = data.newOp(2,newwholeop->getAddr());
//   data.opSetOpcode(newhiop,CPUI_SUBPIECE);
//   data.opSetOutput(newhiop,hi);	// hi was not defined previously
//   data.opSetInput(newhiop,whole,0);
//   data.opSetInput(newhiop,data.newConstant(4,lo->getSize()),1);
//   data.opInsertAfter(newhiop,newwholeop);

//   Varnode *oldhi = oldin.getHi();
//   list<PcodeOp *>::const_iterator iter,enditer;
//   iter = oldhi->beginDescend();
//   enditer = oldhi->endDescend();
//   while(iter != enditer) {
//     PcodeOp *testop = *iter;
//     ++iter;
//     int4 ord = testop->compareOrder(newhiop);
//     if (ord == 1) { 		// newhiop executes earlier than testop
//       int4 slot = testop->getSlot(oldhi);
//       data.opSetInput(testop,hi,slot);
//     }
//   }
// }

/// Its assumed that \b this is the output of the double precision operation being performed.
/// The \b whole Varnode may not yet exist.  This method returns the first PcodeOp where the \b whole
/// needs to exist.  If no such PcodeOp exists, null is returned.
/// \return the first PcodeOp where the \b whole needs to exist or null
PcodeOp *SplitVarnode::findOutExist(void)

{
  if (findWholeBuiltFromPieces()) {
    return defpoint;
  }
  return findEarliestSplitPoint();
}

/// \brief Check if the values in the given Varnodes differ by the given size
///
/// Return \b true, if the (possibly dynamic) value represented by the given \b vn1 plus \b size1
/// produces the value in the given \b vn2. For constants, the values can be computed directly, but
/// otherwise \b vn1 and \b vn2 must be defined by INT_ADD operations from a common ancestor.
/// \param vn1 is the first given Varnode
/// \param vn2 is the second given Varnode
/// \param size1 is the given size to add to \b vn1
/// \return \b true if the values in \b vn1 and \b vn2 are related by the given size
bool SplitVarnode::adjacentOffsets(Varnode *vn1,Varnode *vn2,uintb size1)

{
  if (vn1->isConstant()) {
    if (!vn2->isConstant()) return false;
    return ((vn1->getOffset() + size1) == vn2->getOffset());
  }

  if (!vn2->isWritten()) return false;
  PcodeOp *op2 = vn2->getDef();
  if (op2->code() != CPUI_INT_ADD) return false;
  if (!op2->getIn(1)->isConstant()) return false;
  uintb c2 = op2->getIn(1)->getOffset();

  if (op2->getIn(0) == vn1)
    return (size1 == c2);

  if (!vn1->isWritten()) return false;
  PcodeOp *op1 = vn1->getDef();
  if (op1->code() != CPUI_INT_ADD) return false;
  if (!op1->getIn(1)->isConstant()) return false;
  uintb c1 = op1->getIn(1)->getOffset();

  if (op1->getIn(0) != op2->getIn(0)) return false;
  return ((c1 + size1) == c2);
}

/// \brief Verify that the pointers into the given LOAD/STORE PcodeOps address contiguous memory
///
/// The two given PcodeOps must either both be LOADs or both be STOREs. The pointer for the
/// first PcodeOp is labeled as the most significant piece of the contiguous whole, the
/// second PcodeOp is labeled as the least significant piece. The p-code defining the pointers is examined
/// to determine if the two memory regions being pointed at really form one contiguous region.
/// If the regions are contiguous and the pointer labeling is valid, \b true is returned, the PcodeOps are sorted
/// into \b first and \b second based on Address, and the address space of the memory region is passed back.
/// \param most is the given LOAD/STORE PcodeOp referring to the most significant region
/// \param least is the given LOAD/STORE PcodeOp referring to the least significant region
/// \param first is used to pass back the earliest of the address sorted PcodeOps
/// \param second is used to pass back the latest of the address sorted PcodeOps
/// \param spc is used to pass back the LOAD address space
/// \param sizeres is used to pass back the combined LOAD size
/// \return true if the given PcodeOps are contiguous LOADs
bool SplitVarnode::testContiguousPointers(PcodeOp *most,PcodeOp *least,PcodeOp *&first,PcodeOp *&second,AddrSpace *&spc)

{
  spc = least->getIn(0)->getSpaceFromConst();
  if (most->getIn(0)->getSpaceFromConst() != spc) return false;

  if (spc->isBigEndian()) {	// Convert significance order to address order
    first = most;
    second = least;
  }
  else {
    first = least;
    second = most;
  }
  Varnode *firstptr = first->getIn(1);
  if (firstptr->isFree()) return false;
  int4 sizeres;
  if (first->code() == CPUI_LOAD)
    sizeres = first->getOut()->getSize(); // # of bytes read by lowest address load
  else		// CPUI_STORE
    sizeres = first->getIn(2)->getSize();

  // Check if the loads are adjacent to each other
  return adjacentOffsets(first->getIn(1),second->getIn(1),(uintb)sizeres);
}

/// \brief Return \b true if the given pieces can be melded into a contiguous storage location
///
/// The given Varnodes must be \e address \e tied, and their storage must line up, respecting their
/// significance as pieces.
/// \param lo is the given least significant piece
/// \param hi is the given most significant piece
/// \param res is used to pass back the starting address of the contigous range
/// \return \b true if the pieces are address tied and form a contiguous range
bool SplitVarnode::isAddrTiedContiguous(Varnode *lo,Varnode *hi,Address &res)

{
  if (!lo->isAddrTied()) return false;
  if (!hi->isAddrTied()) return false;

  // Make sure there is no explicit symbol that would prevent the pieces from being joined
  SymbolEntry *entry = lo->getSymbolEntry();
  if ((entry != (SymbolEntry *)0)&&(entry->getOffset()==0)) return false;
  entry = hi->getSymbolEntry();
  if ((entry != (SymbolEntry *)0)&&(entry->getOffset()==0)) return false;
  AddrSpace *spc = lo->getSpace();
  if (spc != hi->getSpace()) return false;
  uintb  [MASK]  = lo->getOffset();
  uintb hioffset = hi->getOffset();
  if (spc->isBigEndian()) {
    if (hioffset >=  [MASK] ) return false;
    if (hioffset + hi->getSize() !=  [MASK] ) return false;
    res = hi->getAddr();
  }
  else {
    if ( [MASK]  >= hioffset) return false;
    if ( [MASK]  + lo->getSize() != hioffset) return false;
    res = lo->getAddr();
  }
  return true;
}

/// \brief Create a list of all the possible pairs that contain the same logical value as the given Varnode
///
/// The given Varnode is assumed to be the logical whole that is being used in a double precision calculation.
/// At least one of the most or least significant pieces must be extracted from the whole and must be
/// marked as a double precision piece.
/// \param w is the given Varnode whole
/// \param splitvec is the container for holding any discovered SplitVarnodes
void SplitVarnode::wholeList(Varnode *w,vector<SplitVarnode> &splitvec)

{
  SplitVarnode basic;

  basic.whole = w;
  basic.hi = (Varnode *)0;
  basic.lo = (Varnode *)0;
  basic.wholesize = w->getSize();
  list<PcodeOp *>::const_iterator iter,enditer;

  iter = basic.whole->beginDescend();
  enditer = basic.whole->endDescend();
  int4 res = 0;
  while(iter != enditer) {
    PcodeOp *subop = *iter;
    ++iter;
    if (subop->code() != CPUI_SUBPIECE) continue;
    Varnode *vn = subop->getOut();
    if (vn->isPrecisHi()) {
      if (subop->getIn(1)->getOffset() != basic.wholesize - vn->getSize()) continue;
      basic.hi = vn;
      res |= 2;
    }
    else if (vn->isPrecisLo()) {
      if (subop->getIn(1)->getOffset() != 0) continue;
      basic.lo = vn;
      res |= 1;
    }
  }
  if (res==0) return;
  if (res == 3 && (basic.lo->getSize() + basic.hi->getSize() != basic.wholesize))
    return;

  splitvec.push_back(basic);
  findCopies(basic,splitvec);
}

/// \brief Find copies from (the pieces of) the given SplitVarnode
///
/// Scan for each piece being used as input to COPY operations.  If the each piece is
/// copied within the same basic block to contiguous storage locations, create a new
/// SplitVarnode from COPY outputs and add it to the list.
/// \param in is the given SplitVarnode
/// \param splitvec is the container for holding SplitVarnode copies
void SplitVarnode::findCopies(const SplitVarnode &in,vector<SplitVarnode> &splitvec)

{
  if (!in.hasBothPieces()) return;
  list<PcodeOp *>::const_iterator iter,enditer;

  iter = in.getLo()->beginDescend();
  enditer = in.getLo()->endDescend();
  while(iter != enditer) {
    PcodeOp *loop = *iter;
    ++iter;
    if (loop->code() != CPUI_COPY) continue;
    Varnode *locpy = loop->getOut();
    Address addr = locpy->getAddr(); // Calculate address of hi part
    if (addr.isBigEndian())
      addr = addr - (in.getHi()->getSize());
    else
      addr = addr + locpy->getSize();
    list<PcodeOp *>::const_iterator iter2,enditer2;
    iter2 = in.getHi()->beginDescend();
    enditer2 = in.getHi()->endDescend();
    while(iter2 != enditer2) {
      PcodeOp *hiop = *iter2;
      ++iter2;
      if (hiop->code() != CPUI_COPY) continue;
      Varnode *hicpy = hiop->getOut();
      if (hicpy->getAddr() != addr) continue;
      if (hiop->getParent() != loop->getParent()) continue;
      SplitVarnode newsplit;
      newsplit.initAll(in.getWhole(),locpy,hicpy);
      splitvec.push_back(newsplit);
    }
  }
}

/// \brief For the given CBRANCH PcodeOp, pass back the \b true and \b false basic blocks
///
/// The result depends on the \e boolean \e flip property of the CBRANCH, and the user can
/// also flip the meaning of the branches.
/// \param boolop is the given CBRANCH PcodeOp
/// \param flip is \b true if the caller wants to flip the meaning of the blocks
/// \param trueout is used to pass back the true fall-through block
/// \param falseout is used to pass back the false fall-through block
void SplitVarnode::getTrueFalse(PcodeOp *boolop,bool flip,BlockBasic *&trueout,BlockBasic *&falseout)

{
  BlockBasic *parent = boolop->getParent();
  BlockBasic *trueblock = (BlockBasic *)parent->getTrueOut();
  BlockBasic *falseblock =(BlockBasic *)parent->getFalseOut();
  if (boolop->isBooleanFlip() != flip) {
    trueout = falseblock;
    falseout = trueblock;
  }
  else {
    trueout = trueblock;
    falseout = falseblock;
  }
}

/// \brief Return \b true if the basic block containing the given CBRANCH PcodeOp performs no other operation.
///
/// The basic block can contain the CBRANCH and the one PcodeOp producing the boolean value.
/// Otherwise \b false is returned.
/// \param branchop is the given CBRANCH
/// \return \b true if the parent basic block performs only the branch operation
bool SplitVarnode::otherwiseEmpty(PcodeOp *branchop)

{
  BlockBasic *bl = branchop->getParent();
  if (bl->sizeIn() != 1) return false;
  PcodeOp *otherop = (PcodeOp *)0;
  Varnode *vn = branchop->getIn(1);
  if (vn->isWritten())
    otherop = vn->getDef();
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = bl->beginOp();
  enditer = bl->endOp();
  while(iter != enditer) {
    PcodeOp *op = *iter;
    ++iter;
    if (op == otherop) continue;
    if (op == branchop) continue;
    return false;
  }
  return true;
}

/// \brief Verify that the given PcodeOp is a CPUI_INT_MULT by -1
///
/// The PcodeOp must be a CPUI_INT_MULT and the second operand must be a constant -1.
/// \param op is the given PcodeOp
/// \return \b true if the PcodeOp is a multiple by -1
bool SplitVarnode::verifyMultNegOne(PcodeOp *op)

{
  if (op->code() != CPUI_INT_MULT) return false;
  Varnode *in1 = op->getIn(1);
  if (!in1->isConstant()) return false;
  if (in1->getOffset() != calc_mask(in1->getSize())) return false;
  return true;
}

/// \brief Check that the logical version of a (generic) binary double-precision operation can be created
///
/// This checks only the most generic aspects of the calculation.  The input and output whole Varnodes
/// must already exist or be creatable.  The point where the output Varnode must exist is identified
/// and returned.  If the binary operation cannot be created, null is returned.
/// \param out is the output of the binary operation
/// \param in1 is the first input of the binary operation
/// \param in2 is the second input of the binary operation
/// \return the first PcodeOp where the output whole must exist
PcodeOp *SplitVarnode::prepareBinaryOp(SplitVarnode &out,SplitVarnode &in1,SplitVarnode &in2)

{
  PcodeOp *existop = out.findOutExist(); // Find point where output whole needs to exist
  if (existop == (PcodeOp *)0) return existop; // If we can find no such point return false;
  if (!in1.isWholeFeasible(existop)) return (PcodeOp *)0;
  if (!in2.isWholeFeasible(existop)) return (PcodeOp *)0;
  return existop;
}

/// \brief Rewrite a double precision binary operation by replacing the pieces with unified Varnodes
///
/// This assumes that we have checked that the transformation is possible via the various
/// verify and prepare methods.  After this method is called, the logical inputs and output of
/// the calculation will exist as real Varnodes.
/// \param data is the function owning the operation
/// \param out is the output of the binary operation
/// \param in1 is the first input to the binary operation
/// \param in2 is the second input to the binary operation
/// \param existop is the precalculated PcodeOp where the output whole Varnode must exist
/// \param opc is the opcode of the operation
void SplitVarnode::createBinaryOp(Funcdata &data,SplitVarnode &out,SplitVarnode &in1,SplitVarnode &in2,
				  PcodeOp *existop,OpCode opc)

{
  out.findCreateOutputWhole(data);
  in1.findCreateWhole(data);
  in2.findCreateWhole(data);
  if (existop->code() != CPUI_PIECE) { // If the output whole didn't previously exist
    PcodeOp *newop = data.newOp(2,existop->getAddr()); // new op which creates the output whole
    data.opSetOpcode(newop,opc);
    data.opSetOutput(newop,out.getWhole());
    data.opSetInput(newop,in1.getWhole(),0);
    data.opSetInput(newop,in2.getWhole(),1);
    data.opInsertBefore(newop,existop);
    out.buildLoFromWhole(data);
    out.buildHiFromWhole(data);
  }
  else {			// The whole previously existed
    data.opSetOpcode(existop,opc); // our new op replaces the op previously defining the output whole
    data.opSetInput(existop,in1.getWhole(),0);
    data.opSetInput(existop,in2.getWhole(),1);
  }
}

/// \brief Make sure input and output operands of a double precision shift operation are compatible
///
/// Do generic testing that the input and output whole Varnodes can be created.  Calculate the
/// PcodeOp where the output whole must exist and return it.  If logical operation cannot be created,
/// return null.
/// \param out is the output of the double precision shift operation
/// \param in is the (first) input operand of the double precision shift operation
/// \return the PcodeOp where output whole must exist or null
PcodeOp *SplitVarnode::prepareShiftOp(SplitVarnode &out,SplitVarnode &in)

{
  PcodeOp *existop = out.findOutExist(); // Find point where output whole needs to exist
  if (existop == (PcodeOp *)0) return existop;
  if (!in.isWholeFeasible(existop)) return (PcodeOp *)0;
  return existop;
}

/// \brief Rewrite a double precision shift by replacing hi/lo pieces with unified Varnodes
///
/// This assumes that we have checked that the transformation is possible by calling the appropriate
/// verify and prepare methods. After this method is called, the logical inputs and output of
/// the calculation will exist as real Varnodes.  The \e shift \e amount is not treated as a double
/// precision variable.
/// \param data is the function owning the operation
/// \param out is the output of the double precision operation
/// \param in is the first input of the operation
/// \param sa is the Varnode indicating the \e shift \e amount for the operation
/// \param existop is the first PcodeOp where the output whole needs to exist
/// \param opc is the opcode of the particular shift operation
void SplitVarnode::createShiftOp(Funcdata &data,SplitVarnode &out,SplitVarnode &in,Varnode *sa,
				 PcodeOp *existop,OpCode opc)

{
  out.findCreateOutputWhole(data);
  in.findCreateWhole(data);
  if (sa->isConstant())
    sa = data.newConstant(sa->getSize(),sa->getOffset());
  if (existop->code() != CPUI_PIECE) { // If the output whole didn't previously exist
    PcodeOp *newop = data.newOp(2,existop->getAddr());
    data.opSetOpcode(newop,opc);
    data.opSetOutput(newop,out.getWhole());
    data.opSetInput(newop,in.getWhole(),0);
    data.opSetInput(newop,sa,1);
    data.opInsertBefore(newop,existop);
    out.buildLoFromWhole(data);
    out.buildHiFromWhole(data);
  }
  else {			// The whole previously existed, we remake the defining op
    data.opSetOpcode(existop,opc);
    data.opSetInput(existop,in.getWhole(),0);
    data.opSetInput(existop,sa,1);
  }
}

/// \brief Try to perform one transform on a logical double precision operation given a specific input
///
/// All the various double precision forms are lined up against the input.  The first one that matches
/// has its associated transform performed and then 1 is returned.  If no form matches, 0 is returned.
/// \param in is the given double precision input
/// \param data is the function owning the Varnodes
/// \return a count of the number of transforms applied, 0 or 1
int4 SplitVarnode::applyRuleIn(SplitVarnode &in,Funcdata &data)

{
  for(int4 i=0;i<2;++i) {
    Varnode *vn;
    vn = (i==0) ? in.getHi() : in.getLo();
    if (vn == (Varnode *)0) continue;
    bool workishi = (i==0);
    list<PcodeOp *>::const_iterator iter,enditer;
    iter = vn->beginDescend();
    enditer = vn->endDescend();
    while(iter != enditer) {
      PcodeOp *workop = *iter;
      ++iter;
      switch(workop->code()) {
      case CPUI_INT_ADD:
	{
	  AddForm addform;
	  if (addform.applyRule(in,workop,workishi,data))
	    return 1;
	  SubForm subform;
	  if (subform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_AND:
	{
	  Equal3Form equal3form;
	  if (equal3form.applyRule(in,workop,workishi,data))
	    return 1;
	  LogicalForm logicalform;
	  if (logicalform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_OR:
	{
	  Equal2Form equal2form;
	  if (equal2form.applyRule(in,workop,workishi,data))
	    return 1;
	  LogicalForm logicalform;
	  if (logicalform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_XOR:
	{
	  Equal2Form equal2form;
	  if (equal2form.applyRule(in,workop,workishi,data))
	    return 1;
	  LogicalForm logicalform;
	  if (logicalform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_EQUAL:
      case CPUI_INT_NOTEQUAL:
	{
	  LessThreeWay lessthreeway;
	  if (lessthreeway.applyRule(in,workop,workishi,data))
	    return 1;
	  Equal1Form equal1form;
	  if (equal1form.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_LESS:
      case CPUI_INT_LESSEQUAL:
	{
	  LessThreeWay lessthreeway;
	  if (lessthreeway.applyRule(in,workop,workishi,data))
	    return 1;
	  LessConstForm lessconstform;
	  if (lessconstform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_SLESS:
	{
	  LessConstForm lessconstform;
	  if (lessconstform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_SLESSEQUAL:
	{
	  LessConstForm lessconstform;
	  if (lessconstform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_LEFT:
	{
	  ShiftForm shiftform;
	  if (shiftform.applyRuleLeft(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_RIGHT:
	{
	  ShiftForm shiftform;
	  if (shiftform.applyRuleRight(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_SRIGHT:
	{
	  ShiftForm shiftform;
	  if (shiftform.applyRuleRight(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INT_MULT:
	{
	  MultForm multform;
	  if (multform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_MULTIEQUAL:
	{
	  PhiForm phiform;
	  if (phiform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      case CPUI_INDIRECT:
	{
	  IndirectForm indform;
	  if (indform.applyRule(in,workop,workishi,data))
	    return 1;
	}
	break;
      default:
	break;
      }
    }
  }
  return 0;
}

/// \brief Make sure input operands of a double precision compare operation are compatible
///
/// Do generic testing that the input whole Varnodes can be created.  If they can be created, return \b true.
/// \param in1 is the first input operand of the double precision compare operation
/// \param in2 is the second input operand of the double precision compare operation
/// \return \b true if the logical transformation can be performed
bool SplitVarnode::prepareBoolOp(SplitVarnode &in1,SplitVarnode &in2,PcodeOp *testop)

{
  if (!in1.isWholeFeasible(testop)) return false;
  if (!in2.isWholeFeasible(testop)) return false;
  return true;
}

/// \brief Rewrite a double precision boolean operation by replacing the input pieces with unified Varnodes
///
/// This assumes we checked that the transformation is possible by calling the various verify and prepare
/// methods. The inputs to the given PcodeOp producing the final boolean value are replaced with new
/// logical Varnodes, and the opcode is updated.  The output Varnode is not affected.
/// \param data is the function owning the operation
/// \param boolop is the given PcodeOp producing the final boolean value
/// \param in1 is the first input to the operation
/// \param in2 is the second input to the operation
/// \param opc is the opcode of the operation
void SplitVarnode::replaceBoolOp(Funcdata &data,PcodeOp *boolop,SplitVarnode &in1,SplitVarnode &in2,
				 OpCode opc)

{
  in1.findCreateWhole(data);
  in2.findCreateWhole(data);
  data.opSetOpcode(boolop,opc);
  data.opSetInput(boolop,in1.getWhole(),0);
  data.opSetInput(boolop,in2.getWhole(),1);
}

/// \brief Create a new compare PcodeOp, replacing the boolean Varnode taken as input by the given CBRANCH
///
/// The inputs to the new compare operation are Varnodes representing the logical whole of the double precision
/// pieces.
/// \param data is the function owning the operation
/// \param cbranch is the given CBRANCH PcodeOp
/// \param in1 is the first input to the compare operation
/// \param in2 is the second input to the compare operation
/// \param opc is the opcode of the compare operation
void SplitVarnode::createBoolOp(Funcdata &data,PcodeOp *cbranch,SplitVarnode &in1,SplitVarnode &in2,
				OpCode opc)

{
  PcodeOp *addrop = cbranch;
  Varnode *boolvn = cbranch->getIn(1);
  if (boolvn->isWritten())
    addrop = boolvn->getDef();	// Use the address of the comparison operator
  in1.findCreateWhole(data);
  in2.findCreateWhole(data);
  PcodeOp *newop = data.newOp(2,addrop->getAddr());
  data.opSetOpcode(newop,opc);
  Varnode *newbool = data.newUniqueOut(1,newop);
  data.opSetInput(newop,in1.getWhole(),0);
  data.opSetInput(newop,in2.getWhole(),1);
  data.opInsertBefore(newop,cbranch);
  data.opSetInput(cbranch,newbool,1); // CBRANCH now determined by new compare
}

/// \brief Check that the logical version of a CPUI_MULTIEQUAL operation can be created
///
/// This checks only the most generic aspects of the calculation.  The input and output whole Varnodes
/// must already exist or be creatable.  The point where the output Varnode must exist is identified
/// and returned.  If the MULTIEQUAL operation cannot be created, null is returned.
/// \param out is the output of the MULTIEQUAL operation
/// \param inlist is a vector of the input operands to the MULTIEQUAL
/// \return the first PcodeOp where the output whole must exist
PcodeOp *SplitVarnode::preparePhiOp(SplitVarnode &out,vector<SplitVarnode> &inlist)

{
  PcodeOp *existop = out.findEarliestSplitPoint(); // Point where output whole needs to exist
  if (existop == (PcodeOp *)0) return existop;
  // existop should always be a MULTIEQUAL defining one of the pieces
  if (existop->code() != CPUI_MULTIEQUAL)
    throw LowlevelError(""Trying to create phi-node double precision op with phi-node pieces"");
  BlockBasic *bl = existop->getParent();
  int4 numin = inlist.size();
  for(int4 i=0;i<numin;++i)
    if (!inlist[i].isWholePhiFeasible(bl->getIn(i)))
      return (PcodeOp *)0;
  return existop;
}

/// \brief Rewrite a double precision MULTIEQUAL operation by replacing the pieces with unified Varnodes
///
/// This assumes that we have checked that the transformation is possible via the various
/// verify and prepare methods.  After this method is called, the logical inputs and output of
/// the calculation will exist as real Varnodes.
/// \param data is the function owning the operation
/// \param out is the output of the MULTIEQUAL operation
/// \param inlist is the list of input operands to the MULTIEQUAL
/// \param existop is the precalculated PcodeOp where the output whole Varnode must exist
void SplitVarnode::createPhiOp(Funcdata &data,SplitVarnode &out,vector<SplitVarnode> &inlist,
			       PcodeOp  *existop)

{
  // Unlike replaceBoolOp, we MUST create a newop even if the output whole already exists
  // because the MULTIEQUAL has a lot of placement constraints on it
  out.findCreateOutputWhole(data);
  int4 numin = inlist.size();
  for(int4 i=0;i<numin;++i)
    inlist[i].findCreateWhole(data);

  PcodeOp *newop = data.newOp(numin,existop->getAddr());
  data.opSetOpcode(newop,CPUI_MULTIEQUAL);
  data.opSetOutput(newop,out.getWhole());
  for(int4 i=0;i<numin;++i)
    data.opSetInput(newop,inlist[i].getWhole(),i);
  data.opInsertBefore(newop,existop);
  out.buildLoFromWhole(data);
  out.buildHiFromWhole(data);
}

/// \brief Check that the logical version of a CPUI_INDIRECT operation can be created
///
/// This checks only the most generic aspects of the calculation.  The input whole Varnode
/// must already exist or be creatable.  If the INDIRECT operation cannot be created, \b false is returned.
/// \param in is the (first) input operand of the INDIRECT
/// \return \b true if the logical version of the CPUI_INDIRECT can be created
bool SplitVarnode::prepareIndirectOp(SplitVarnode &in,PcodeOp *affector)

{
  // We already have the exist point, -indop-
  if (!in.isWholeFeasible(affector))
    return false;
  return true;
}

/// \brief Rewrite a double precision INDIRECT operation by replacing the pieces with unified Varnodes
///
/// This assumes that we have checked that the transformation is possible via the various
/// verify and prepare methods.  After this method is called, the logical input and output of
/// the calculation will exist as real Varnodes.
/// \param data is the function owning the operation
/// \param out is the output of the INDIRECT operation
/// \param in is the (first) operand of the INDIRECT
/// \param affector is the second operand to the indirect, the PcodeOp producing the indirect affect
void SplitVarnode::replaceIndirectOp(Funcdata &data,SplitVarnode &out,SplitVarnode &in,PcodeOp *affector)

{
  out.createJoinedWhole(data);

  in.findCreateWhole(data);
  PcodeOp *newop = data.newOp(2,affector->getAddr());
  data.opSetOpcode(newop,CPUI_INDIRECT);
  data.opSetOutput(newop,out.getWhole());
  data.opSetInput(newop,in.getWhole(),0);
  data.opSetInput(newop,data.newVarnodeIop(affector),1);
  data.opInsertBefore(newop,affector);
  out.buildLoFromWhole(data);
  out.buildHiFromWhole(data);
}

bool AddForm::checkForCarry(PcodeOp *op)

{ // If -op- matches a CARRY construction based on lo1 (i.e. CARRY(x,lo1) )
  //    set lo1 (and negconst if lo1 is a constant) to be the corresponding part of the carry
  //    and return true
  if (op->code() != CPUI_INT_ZEXT) return false;
  if (!op->getIn(0)->isWritten()) return false;
  
  PcodeOp *carryop = op->getIn(0)->getDef();
  if (carryop->code() == CPUI_INT_CARRY) { // Normal CARRY form
    if (carryop->getIn(0) == lo1)
      lo2 = carryop->getIn(1);
    else if (carryop->getIn(1) == lo1)
      lo2 = carryop->getIn(0);
    else
      return false;
    if (lo2->isConstant()) return false;
    return true;
  }
  if (carryop->code() == CPUI_INT_LESS) { // Possible CARRY
    Varnode *tmpvn = carryop->getIn(0);
    if (tmpvn->isConstant()) {
      if (carryop->getIn(1) != lo1) return false;
      negconst = tmpvn->getOffset();
      // In constant forms, the <= will get converted to a <
      // Note the lessthan to less conversion adds 1 then the 2's complement subtracts 1 and negates
      // So all we really need to do is negate
      negconst = (~negconst) & calc_mask(lo1->getSize());
      lo2 = (Varnode *)0;
      return true;
    }
    else if (tmpvn->isWritten()) {	// Calculate CARRY relative to result of loadd
      PcodeOp *loadd_op = tmpvn->getDef();	// This is the putative loadd
      if (loadd_op->code() != CPUI_INT_ADD) return false;
      Varnode *othervn;
      if (loadd_op->getIn(0)==lo1)
	othervn = loadd_op->getIn(1);
      else if (loadd_op->getIn(1)==lo1)
	othervn = loadd_op->getIn(0);
      else
	return false;			// One side of the add must be lo1
      if (othervn->isConstant()) {
	negconst = othervn->getOffset();
	lo2 = (Varnode *)0;
	Varnode *relvn = carryop->getIn(1);
	if (relvn == lo1) return true;	// Comparison can be relative to lo1
	if (!relvn->isConstant()) return false;
	if (relvn->getOffset() != negconst) return false;	// Otherwise must be relative to (constant)lo2
	return true;
      }
      else {
	lo2 = othervn;		// Other side of putative loadd must be lo2
	Varnode *compvn = carryop->getIn(1);
	if ((compvn == lo2)||(compvn == lo1))
	  return true;
      }
    }
    return false;
  }
  if (carryop->code() == CPUI_INT_NOTEQUAL) { // Possible CARRY against -1
    if (!carryop->getIn(1)->isConstant()) return false;
    if (carryop->getIn(0) != lo1) return false;
    if (carryop->getIn(1)->getOffset() != 0) return false;
    negconst = calc_mask(lo1->getSize()); // Original CARRY constant must have been -1
    lo2 = (Varnode *)0;
    return true;
  }
  return false;
}

// Given a known double precision input, look for a double precision add,
// recovering the other double input and the double output
//
// Assume hi1, lo1 is a known double precision pair, we look for
//   reshi = hi1 + hi2 + hizext             (2 variants here)
//   hizext = zext(bool)
//   {                                       (2 variants)
//     bool = (-lo1 <= lo2)     OR
//     bool = (-lo2 <= lo1)                  (multiple ways to calculate negation)
//   }
//   reslo = lo1 + lo2

bool AddForm::verify(Varnode *h,Varnode *l,PcodeOp *op)

{
  hi1 = h;
  lo1 = l;
  slot1 = op->getSlot(hi1);
  for(int4 i=0;i<3;++i) {
    if (i==0) {		// Assume we have to descend one more add
      add2 = op->getOut()->loneDescend();
      if (add2 == (PcodeOp *)0) continue;
      if (add2->code() != CPUI_INT_ADD) continue;
      reshi = add2->getOut();
      hizext1 = op->getIn(1-slot1);
      hizext2 = add2->getIn(1-add2->getSlot(op->getOut()));
    }
    else if (i==1) {		// Assume we are at the bottom most of two adds
      Varnode *tmpvn = op->getIn(1-slot1);
      if (!tmpvn->isWritten()) continue;
      add2 = tmpvn->getDef();
      if (add2->code() != CPUI_INT_ADD) continue;
      reshi = op->getOut();
      hizext1 = add2->getIn(0);
      hizext2 = add2->getIn(1);
    }
    else {			// Assume there is only one add, with second implied add by 0
      reshi = op->getOut();
      hizext1 = op->getIn(1-slot1);
      hizext2 = (Varnode *)0;
    }
    for(int4 j=0;j<2;++j) {
      if (i==2) {		// hi2 is an implied 0
	if (!hizext1->isWritten()) continue;
	zextop = hizext1->getDef();
	hi2 = (Varnode *)0;
      }
      else if (j==0) {
	if (!hizext1->isWritten()) continue;
	zextop = hizext1->getDef();
	hi2 = hizext2;
      }
      else {
	if (!hizext2->isWritten()) continue;
	zextop = hizext2->getDef();
	hi2 = hizext1;
      }
      if (!checkForCarry(zextop)) continue; // Calculate lo2 and negconst

      list<PcodeOp *>::const_iterator iter2,enditer2;
      iter2 = lo1->beginDescend();
      enditer2 = lo1->endDescend();
      while(iter2 != enditer2) {
	loadd = *iter2;
	++iter2;
	if (loadd->code() != CPUI_INT_ADD) continue;
	Varnode *tmpvn = loadd->getIn(1-loadd->getSlot(lo1));
	if (lo2 == (Varnode *)0) {
	  if (!tmpvn->isConstant()) continue;
	  if (tmpvn->getOffset() != negconst) continue;	// Must add same constant used to calculate CARRY
	  lo2 = tmpvn;
	}
	else if (lo2->isConstant()) {
	  if (!tmpvn->isConstant()) continue;
	  if (lo2->getOffset() != tmpvn->getOffset()) continue;
	}
	else if (loadd->getIn(1-loadd->getSlot(lo1)) != lo2) // Must add same value used to calculate CARRY
	  continue;
	reslo = loadd->getOut();
	return true;
      }
    }
  }
  return false;
}

bool AddForm::applyRule(SplitVarnode &i,PcodeOp *op,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;
  if (!verify(in.getHi(),in.getLo(),op))
    return false;

  indoub.initPartial(in.getSize(),lo2,hi2);
  outdoub.initPartial(in.getSize(),reslo,reshi);
  existop = SplitVarnode::prepareBinaryOp(outdoub,in,indoub);
  if (existop == (PcodeOp *)0)
    return false;
  SplitVarnode::createBinaryOp(data,outdoub,in,indoub,existop,CPUI_INT_ADD);
  return true;
}

// Given a known double precision input, look for a double precision subtraction,
// recovering the other double input and the double output
//
// Assume hi1, lo1 is a known double precision pair, we look for
//   reshi = hi1 + -hi2 + - zext(lo1 < lo2)
//   reslo = lo1 + -lo2

bool SubForm::verify(Varnode *h,Varnode *l,PcodeOp *op)

{
  list<PcodeOp *>::const_iterator iter2,enditer2;
  hi1 = h;
  lo1 = l;
  slot1 = op->getSlot(hi1);
  for(int4 i=0;i<2;++i) {
    if (i==0) {		// Assume we have to descend one more add
      add2 = op->getOut()->loneDescend();
      if (add2 == (PcodeOp *)0) continue;
      if (add2->code() != CPUI_INT_ADD) continue;
      reshi = add2->getOut();
      hineg1 = op->getIn(1-slot1);
      hineg2 = add2->getIn(1-add2->getSlot(op->getOut()));
    }
    else {
      Varnode *tmpvn = op->getIn(1-slot1);
      if (!tmpvn->isWritten()) continue;
      add2 = tmpvn->getDef();
      if (add2->code() != CPUI_INT_ADD) continue;
      reshi = op->getOut();
      hineg1 = add2->getIn(0);
      hineg2 = add2->getIn(1);
    }
    if (!hineg1->isWritten()) continue;
    if (!hineg2->isWritten()) continue;
    if (!SplitVarnode::verifyMultNegOne(hineg1->getDef())) continue;
    if (!SplitVarnode::verifyMultNegOne(hineg2->getDef())) continue;
    hizext1 = hineg1->getDef()->getIn(0);
    hizext2 = hineg2->getDef()->getIn(0);
    for(int4 j=0;j<2;++j) {
      if (j==0) {
	if (!hizext1->isWritten()) continue;
	zextop = hizext1->getDef();
	hi2 = hizext2;
      }
      else {
	if (!hizext2->isWritten()) continue;
	zextop = hizext2->getDef();
	hi2 = hizext1;
      }
      if (zextop->code() != CPUI_INT_ZEXT) continue;
      if (!zextop->getIn(0)->isWritten()) continue;
      lessop = zextop->getIn(0)->getDef();
      if (lessop->code() != CPUI_INT_LESS) continue;
      if (lessop->getIn(0) != lo1) continue;
      lo2 = lessop->getIn(1);
      iter2 = lo1->beginDescend();
      enditer2 = lo1->endDescend();
      while(iter2 != enditer2) {
	loadd = *iter2;
	++iter2;
	if (loadd->code() != CPUI_INT_ADD) continue;
	Varnode *tmpvn = loadd->getIn(1-loadd->getSlot(lo1));
	if (!tmpvn->isWritten()) continue;
	negop = tmpvn->getDef();
	if (!SplitVarnode::verifyMultNegOne(negop)) continue;
	if (negop->getIn(0) != lo2) continue;
	reslo = loadd->getOut();
	return true;
      }
    }
  }
  return false;
}

bool SubForm::applyRule(SplitVarnode &i,PcodeOp *op,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;

  if (!verify(in.getHi(),in.getLo(),op))
    return false;

  indoub.initPartial(in.getSize(),lo2,hi2);
  outdoub.initPartial(in.getSize(),reslo,reshi);
  existop = SplitVarnode::prepareBinaryOp(outdoub,in,indoub);
  if (existop == (PcodeOp *)0)
    return false;
  SplitVarnode::createBinaryOp(data,outdoub,in,indoub,existop,CPUI_INT_SUB);
  return true;
}

int4 LogicalForm::findHiMatch(void)

{ // Look for the op computing the most significant part of the result for which -loop- computes
  // the least significant part,  look for a known double precis out, then look for known double
  // precis in.  If the other input is constant, look for a unique op that might be computing the high,
  // Return 0 if we found an op, return -1, if we can't find an op, return -2 if no op exists
  Varnode *lo1Tmp = in.getLo();
  Varnode *vn2 = loop->getIn( 1-loop->getSlot( lo1Tmp ) );
  
  SplitVarnode out;
  if (out.inHandLoOut(lo1Tmp)) {	// If we already know what the double precision output looks like
    Varnode *hi = out.getHi();
    if (hi->isWritten()) {	// Just look at construction of hi precisi
      PcodeOp *maybeop = hi->getDef();
      if (maybeop->code() == loop->code()) {
	if (maybeop->getIn(0) == hi1) {
	  if (maybeop->getIn(1)->isConstant() == vn2->isConstant()) {
	    hiop = maybeop;
	    return 0;
	  }
	}
	else if (maybeop->getIn(1) == hi1) {
	  if (maybeop->getIn(0)->isConstant() == vn2->isConstant()) {
	    hiop = maybeop;
	    return 0;
	  }
	}
      }
    }
  }

  if (!vn2->isConstant()) {
    SplitVarnode in2;
    if (in2.inHandLo(vn2)) {	// If we already know what the other double precision input looks like
      list<PcodeOp *>::const_iterator iter,enditer;
      iter = in2.getHi()->beginDescend();
      enditer = in2.getHi()->endDescend();
      while(iter != enditer) {
	PcodeOp *maybeop = *iter;
	++iter;
	if (maybeop->code() == loop->code()) {
	  if ((maybeop->getIn(0) == hi1)||(maybeop->getIn(1) == hi1)) {
	    hiop = maybeop;
	    return 0;
	  }
	}
      }
    }
    return -1;
  }
  else {
    list<PcodeOp *>::const_iterator iter,enditer;
    iter = hi1->beginDescend();
    enditer = hi1->endDescend();
    int4 count = 0;
    PcodeOp *lastop = (PcodeOp *)0;
    while(iter != enditer) {
      PcodeOp *maybeop = *iter;
      ++iter;
      if (maybeop->code() == loop->code()) {
	if (maybeop->getIn(1)->isConstant()) {
	  count += 1;
	  if (count > 1) break;
	  lastop = maybeop;
	}
      }
    }
    if (count == 1) {
      hiop = lastop;
      return 0;
    }
    if (count >1)
      return -1;		// Couldn't distinguish between multiple possibilities
  }
  return -2;
}

// Given a known double precision input, look for a double precision logical operation
// recovering the other double input and the double output
//
// Assume hi1, lo1 is a known double precision pair, we look for
// reshi = hi1 & hi2
// reslo = lo1 & lo2
bool LogicalForm::verify(Varnode *h,Varnode *l,PcodeOp *lop)

{
  loop = lop;
  lo1 = l;
  hi1 = h;
  int4 res = findHiMatch();

  if (res == 0) {		// We found a matching lo presis operation
    lo2 = loop->getIn(1-loop->getSlot(lo1));
    hi2 = hiop->getIn(1-hiop->getSlot(hi1));
    if ((lo2==lo1)||(lo2==hi1)||(hi2==hi1)||(hi2==lo1)) return false; // No manipulation of itself
    if (lo2 == hi2) return false;
    return true;
  }
  return false;
}

bool LogicalForm::applyRule(SplitVarnode &i,PcodeOp *lop,bool workishi,Funcdata &data)

{
  if (workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;

  if (!verify(in.getHi(),in.getLo(),lop))
    return false;

  outdoub.initPartial(in.getSize(),loop->getOut(),hiop->getOut());
  indoub.initPartial(in.getSize(),lo2,hi2);
  existop = SplitVarnode::prepareBinaryOp(outdoub,in,indoub);
  if (existop == (PcodeOp *)0)
    return false;

  SplitVarnode::createBinaryOp(data,outdoub,in,indoub,existop,loop->code());
  return true;
}

// Given a known double precis input, look for double precision compares of the form
//   a == b,  a != b
//
// We look for
//     hibool = hi1 == hi2
//     lobool = lo1 == lo2
// each of the bools induces a CBRANCH
//               if (hibool) blocksecond else blockfalse
// blocksecond:  if (lobool) blocktrue else blockfalse
bool Equal1Form::applyRule(SplitVarnode &i,PcodeOp *hop,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in1 = i;

  hiop = hop;
  hi1 = in1.getHi();
  lo1 = in1.getLo();
  hi1slot = hiop->getSlot(hi1);
  hi2 = hiop->getIn(1-hi1slot);
  notequalformhi = (hiop->code() == CPUI_INT_NOTEQUAL);

  list<PcodeOp *>::const_iterator iter,enditer;
  list<PcodeOp *>::const_iterator iter2,enditer2;
  list<PcodeOp *>::const_iterator iter3,enditer3;
  iter = lo1->beginDescend();
  enditer = lo1->endDescend();
  while(iter != enditer) {
    loop = *iter;
    ++iter;
    if (loop->code() == CPUI_INT_EQUAL)
      notequalformlo = false;
    else if (loop->code() == CPUI_INT_NOTEQUAL)
      notequalformlo = true;
    else
      continue;
    lo1slot = loop->getSlot(lo1);
    lo2 = loop->getIn(1-lo1slot);

    iter2 = hiop->getOut()->beginDescend();
    enditer2 = hiop->getOut()->endDescend();
    while(iter2 != enditer2) {
      hibool = *iter2;
      ++iter2;
      iter3 = loop->getOut()->beginDescend();
      enditer3 = loop->getOut()->endDescend();
      while(iter3 != enditer3) {
	lobool = *iter3;
	++iter3;

	in2.initPartial(in1.getSize(),lo2,hi2);
	
	if ((hibool->code() == CPUI_CBRANCH)&&(lobool->code()==CPUI_CBRANCH)) {
	  // Branching form of the equal operation
	  BlockBasic *hibooltrue,*hiboolfalse;
	  BlockBasic *lobooltrue,*loboolfalse;
	  SplitVarnode::getTrueFalse(hibool,notequalformhi,hibooltrue,hiboolfalse);
	  SplitVarnode::getTrueFalse(lobool,notequalformlo,lobooltrue,loboolfalse);
	  
	  if ((hibooltrue == lobool->getParent())&&	// hi is checked first then lo
	      (hiboolfalse == loboolfalse)&&
	      SplitVarnode::otherwiseEmpty(lobool)) {
	    if (SplitVarnode::prepareBoolOp(in1,in2,hibool)) {
	      setonlow = true;
	      SplitVarnode::createBoolOp(data,hibool,in1,in2,notequalformhi ? CPUI_INT_NOTEQUAL : CPUI_INT_EQUAL);
	  // We change lobool so that it always goes to the original TRUE block
	      data.opSetInput(lobool,data.newConstant(1,notequalformlo ? 0 : 1),1);
	      return true;
	    }
	  }
	  else if ((lobooltrue == hibool->getParent())&& // lo is checked first then hi
		   (hiboolfalse == loboolfalse)&&
		   SplitVarnode::otherwiseEmpty(hibool)) {
	    if (SplitVarnode::prepareBoolOp(in1,in2,lobool)) {
	      setonlow = false;
	      SplitVarnode::createBoolOp(data,lobool,in1,in2,notequalformlo ? CPUI_INT_NOTEQUAL : CPUI_INT_EQUAL);
	      // We change hibool so that it always goes to the original TRUE block
	      data.opSetInput(hibool,data.newConstant(1,notequalformhi ? 0 : 1),1);
	      return true;
	    }
	  }
	}
      }
    }
  }
  return false;
}

bool Equal2Form::checkLoForm(void)

{ // Assuming we have equal <- or <- xor <- hi1, verify if we have the full equal form
  Varnode *orvnin = orop->getIn(1-orhislot);
  if (orvnin == lo1) {		// lo2 is an implied 0
    loxor = (PcodeOp *)0;
    lo2 = (Varnode *)0;
    return true;
  }
  if (!orvnin->isWritten()) return false;
  loxor = orvnin->getDef();
  if (loxor->code() != CPUI_INT_XOR) return false;
  if (loxor->getIn(0) == lo1) {
    lo2 = loxor->getIn(1);
    return true;
  }
  else if (loxor->getIn(1) == lo1) {
    lo2 = loxor->getIn(0);
    return true;
  }
  return false;
}

bool Equal2Form::fillOutFromOr(Funcdata &data)

{ // We have filled in either or <- xor <- hi1,  OR,  or <- hi1
  // Now try to fill in the rest of the form
  Varnode *outvn = orop->getOut();
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = outvn->beginDescend();
  enditer = outvn->endDescend();
  while(iter != enditer) {
    equalop = *iter;
    ++iter;
    if ((equalop->code() != CPUI_INT_EQUAL)&&(equalop->code() != CPUI_INT_NOTEQUAL)) continue;
    if (!equalop->getIn(1)->isConstant()) continue;
    if (equalop->getIn(1)->getOffset() != 0) continue;

    if (!checkLoForm()) continue;
    if (!replace(data)) continue;
    return true;
  }
  return false;
}

bool Equal2Form::replace(Funcdata &data)

{
  if ((hi2==(Varnode *)0)&&(lo2==(Varnode *)0)) {
    param2.initPartial(in.getSize(),0); // Double precis zero constant
    return SplitVarnode::prepareBoolOp(in,param2,equalop);
  }
  if ((hi2==(Varnode *)0)&&(lo2->isConstant())) {
    param2.initPartial(in.getSize(),lo2->getOffset());
    return SplitVarnode::prepareBoolOp(in,param2,equalop);
  }
  if ((lo2==(Varnode *)0)&&(hi2->isConstant())) {
    param2.initPartial(in.getSize(),hi2->getOffset() << 8*lo1->getSize());
    return SplitVarnode::prepareBoolOp(in,param2,equalop);
  }
  if (lo2 == (Varnode *)0) {
    // Equal to a zero extended and shifted var
    return false;
  }
  if (hi2 == (Varnode *)0) {
    // Equal to a zero extended var
    return false;
  }
  if (hi2->isConstant()&&lo2->isConstant()) {
    uintb val = hi2->getOffset();
    val <<= 8*lo1->getSize();
    val |= lo2->getOffset();
    param2.initPartial(in.getSize(),val);
    return SplitVarnode::prepareBoolOp(in,param2,equalop);
  }
  if (hi2->isConstant()||lo2->isConstant()) {
    // Some kind of mixed form
    return false;
  }
  param2.initPartial(in.getSize(),lo2,hi2);
  return SplitVarnode::prepareBoolOp(in,param2,equalop);
}

// Given a known double precis input, look for double precision compares of the form
//   a == b,  a != b
//
// We look for
//     res = ((hi1 ^ hi2) | (lo1 ^ lo2) == 0)
//  where hi2 or lo2 may be zero, and optimized out
bool Equal2Form::applyRule(SplitVarnode &i,PcodeOp *op,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;
  hi1 = in.getHi();
  lo1 = in.getLo();

  if (op->code() == CPUI_INT_OR) {
    orop = op;
    orhislot = op->getSlot(hi1);
    hixor = (PcodeOp *)0;
    hi2 = (Varnode *)0;
    if (fillOutFromOr(data)) {
      SplitVarnode::replaceBoolOp(data,equalop,in,param2,equalop->code());
      return true;
    }
  }
  else {			// We see an XOR
    hixor = op;
    xorhislot = hixor->getSlot(hi1);
    hi2 = hixor->getIn(1-xorhislot);
    Varnode *vn = op->getOut();
    list<PcodeOp *>::const_iterator iter,enditer;
    iter = vn->beginDescend();
    enditer = vn->endDescend();
    while(iter != enditer) {
      orop = *iter;
      ++iter;
      if (orop->code() != CPUI_INT_OR) continue;
      orhislot = orop->getSlot(vn);
      if (fillOutFromOr(data)) {
	SplitVarnode::replaceBoolOp(data,equalop,in,param2,equalop->code());
	return true;
      }
    }
  }

  return false;
}

bool Equal3Form::verify(Varnode *h,Varnode *l,PcodeOp *aop)

{
  if (aop->code() != CPUI_INT_AND) return false;
  hi = h;
  lo = l;
  andop = aop;
  int4 hislot = andop->getSlot(hi);
  if (andop->getIn(1-hislot) != lo) return false;	// hi and lo must be ANDed together
  compareop = andop->getOut()->loneDescend();
  if (compareop == (PcodeOp *)0) return false;
  if ((compareop->code()!=CPUI_INT_EQUAL)&&(compareop->code()!=CPUI_INT_NOTEQUAL))
    return false;
  uintb allonesval = calc_mask(lo->getSize());
  smallc = compareop->getIn(1);
  if (!smallc->isConstant()) return false;
  if (smallc->getOffset() != allonesval) return false;
  return true;
}

// Given a known double precis input, look for double precision compares of the form
//   a == -1,  a != -1
//
// We look for
//     hi & lo == -1
bool Equal3Form::applyRule(SplitVarnode &i,PcodeOp *op,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;
  if (!verify(in.getHi(),in.getLo(),op))
    return false;

  SplitVarnode in2(in.getSize(),calc_mask(in.getSize()));	// Create the -1 value
  if (!SplitVarnode::prepareBoolOp(in,in2,compareop)) return false;
  SplitVarnode::replaceBoolOp(data,compareop,in,in2,compareop->code());
  return true;
}

bool LessThreeWay::mapBlocksFromLow(BlockBasic *lobl)

{ // Assuming -lobl- is the block containing the low precision test of a double precision lessthan
  // Map out all the blocks if possible, otherwise return false
  lolessbl = lobl;
  if (lolessbl->sizeIn() != 1) return false;
  if (lolessbl->sizeOut() != 2) return false;
  hieqbl = (BlockBasic *)lolessbl->getIn(0);
  if (hieqbl->sizeIn() != 1) return false;
  if (hieqbl->sizeOut() != 2) return false;
  hilessbl = (BlockBasic *)hieqbl->getIn(0);
  if (hilessbl->sizeOut() != 2) return false;
  return true;
}

bool LessThreeWay::mapOpsFromBlocks(void)

{
  lolessbool = lolessbl->lastOp();
  if (lolessbool == (PcodeOp *)0) return false;
  if (lolessbool->code() != CPUI_CBRANCH) return false;
  hieqbool = hieqbl->lastOp();
  if (hieqbool == (PcodeOp *)0) return false;
  if (hieqbool->code() != CPUI_CBRANCH) return false;
  hilessbool = hilessbl->lastOp();
  if (hilessbool == (PcodeOp *)0) return false;
  if (hilessbool->code() != CPUI_CBRANCH) return false;

  Varnode *vn;

  hiflip = false;
  equalflip = false;
  loflip = false;
  midlessform = false;
  lolessiszerocomp = false;

  vn = hieqbool->getIn(1);
  if (!vn->isWritten()) return false;
  hiequal = vn->getDef();
  switch(hiequal->code()) {
  case CPUI_INT_EQUAL:
    midlessform = false;
    break;
  case CPUI_INT_NOTEQUAL:
    midlessform = false;
    break;
  case CPUI_INT_LESS:
    midlessequal = false;
    midsigncompare = false;
    midlessform = true;
    break;
  case CPUI_INT_LESSEQUAL:
    midlessequal = true;
    midsigncompare = false;
    midlessform = true;
    break;
  case CPUI_INT_SLESS:
    midlessequal = false;
    midsigncompare = true;
    midlessform = true;
    break;
  case CPUI_INT_SLESSEQUAL:
    midlessequal = true;
    midsigncompare = true;
    midlessform = true;
    break;
  default:
    return false;
  }

  vn = lolessbool->getIn(1);
  if (!vn->isWritten()) return false;
  loless = vn->getDef();
  switch(loless->code()) {	// Only unsigned forms
  case CPUI_INT_LESS:
    lolessequalform = false;
    break;
  case CPUI_INT_LESSEQUAL:
    lolessequalform = true;
    break;
  case CPUI_INT_EQUAL:
    if (!loless->getIn(1)->isConstant()) return false;
    if (loless->getIn(1)->getOffset()!=0) return false;
    lolessiszerocomp = true;
    lolessequalform = true;
    break;
  case CPUI_INT_NOTEQUAL:
    if (!loless->getIn(1)->isConstant()) return false;
    if (loless->getIn(1)->getOffset()!=0) return false;
    lolessiszerocomp = true;
    lolessequalform = false;
    break;
  default:
    return false;
  }

  vn = hilessbool->getIn(1);
  if (!vn->isWritten()) return false;
  hiless = vn->getDef();
  switch(hiless->code()){
  case CPUI_INT_LESS:
    hilessequalform = false;
    signcompare = false;
    break;
  case CPUI_INT_LESSEQUAL:
    hilessequalform = true;
    signcompare = false;
    break;
  case CPUI_INT_SLESS:
    hilessequalform = false;
    signcompare = true;
    break;
  case CPUI_INT_SLESSEQUAL:
    hilessequalform = true;
    signcompare = true;
    break;
  default:
    return false;
  }
  return true;
}

bool LessThreeWay::checkSignedness(void)

{
  if (midlessform) {
    if (midsigncompare != signcompare) return false;
  }
  return true;
}

bool LessThreeWay::normalizeHi(void)

{
  Varnode *tmpvn;
  vnhil1 = hiless->getIn(0);
  vnhil2 = hiless->getIn(1);
  if (vnhil1->isConstant()) {	// Start with constant on the right
    hiflip = !hiflip;
    hilessequalform = !hilessequalform;
    tmpvn = vnhil1;
    vnhil1 = vnhil2;
    vnhil2 = tmpvn;
  }
  hiconstform = false;
  if (vnhil2->isConstant()) {
    hiconstform = true;
    hival = vnhil2->getOffset();
    SplitVarnode::getTrueFalse(hilessbool,hiflip,hilesstrue,hilessfalse);
    int4 inc = 1;
    if (hilessfalse != hieqbl) {	// Make sure the hiless false branch goes to the hieq block
      hiflip = !hiflip;
      hilessequalform = !hilessequalform;
      tmpvn = vnhil1;
      vnhil1 = vnhil2;
      vnhil2 = tmpvn;
      inc = -1;
    }
    if (hilessequalform) {	// Make sure to normalize lessequal to less
      hival += inc;
      hival &= calc_mask(in.getSize());
      hilessequalform = false;
    }
    hival >>= in.getLo()->getSize() * 8;
  }
  else {
    if (hilessequalform) {	// Make sure the false branch contains the equal case
      hilessequalform = false;
      hiflip = !hiflip;
      tmpvn = vnhil1;
      vnhil1 = vnhil2;
      vnhil2 = tmpvn;
    }
  }
  return true;
}

bool LessThreeWay::normalizeMid(void)

{
  Varnode *tmpvn;
  vnhie1 = hiequal->getIn(0);
  vnhie2 = hiequal->getIn(1);
  if (vnhie1->isConstant()) {	// Make sure constant is on the right
    tmpvn = vnhie1;
    vnhie1 = vnhie2;
    vnhie2 = tmpvn;
    if (midlessform) {
      equalflip = !equalflip;
      midlessequal = !midlessequal;
    }
  }
  midconstform = false;
  if (vnhie2->isConstant()) {
    if (!hiconstform) return false;	// If mid is constant, both mid and hi must be constant
    midconstform = true;
    midval = vnhie2->getOffset();
    if (vnhie2->getSize() == in.getSize()) {
      // Convert to comparison on high part
      uintb lopart = midval & calc_mask(in.getLo()->getSize());
      midval >>= in.getLo()->getSize()*8;
      if (midlessform) {
	if (midlessequal) {
	  if (lopart!=calc_mask(in.getLo()->getSize())) return false;
	}
	else {
	  if (lopart != 0) return false;
	}
      }
      else
	return false;		// Compare is forcing restriction on lo part
    }
    if (midval != hival) {	// If the mid and hi don't match
      if (!midlessform) return false;
      midval += (midlessequal) ? 1 : -1; // We may just be one off
      midval &= calc_mask(in.getLo()->getSize());
      midlessequal = !midlessequal;
      if (midval != hival) return false; // Last chance
    }
  }
  if (midlessform) {		// Normalize to EQUAL
    
    if (!midlessequal) {
      equalflip = !equalflip;
    }
  }
  else {
    if (hiequal->code() == CPUI_INT_NOTEQUAL) {
      equalflip = !equalflip;
    }
  }
  return true;
}

bool LessThreeWay::normalizeLo(void)

{ // This is basically identical to normalizeHi
  Varnode *tmpvn;
  vnlo1 = loless->getIn(0);
  vnlo2 = loless->getIn(1);
  if (lolessiszerocomp) {
    loconstform = true;
    if (lolessequalform) {	// Treat as if we see vnlo1 <= 0
      loval = 1;
      lolessequalform = false;
    }
    else {			// Treat as if we see 0 < vnlo1
      loflip = !loflip;
      loval = 1;
    }
    return true;
  }
  if (vnlo1->isConstant()) {	// Make sure constant is on the right
    loflip = !loflip;
    lolessequalform = !lolessequalform;
    tmpvn = vnlo1;
    vnlo1 = vnlo2;
    vnlo2 = tmpvn;
  }
  loconstform = false;
  if (vnlo2->isConstant()) {	// Make sure normalize lessequal to less
    loconstform = true;
    loval = vnlo2->getOffset();
    if (lolessequalform) {
      loval += 1;
      loval &= calc_mask(vnlo2->getSize());
      lolessequalform = false;
    }
  }
  else {
    if (lolessequalform) {
      lolessequalform = false;
      loflip = !loflip;
      tmpvn = vnlo1;
      vnlo1 = vnlo2;
      vnlo2 = tmpvn;
    }
  }
  return true;
}

bool LessThreeWay::checkBlockForm(void)

{
  SplitVarnode::getTrueFalse(hilessbool,hiflip,hilesstrue,hilessfalse);
  SplitVarnode::getTrueFalse(lolessbool,loflip,lolesstrue,lolessfalse);
  SplitVarnode::getTrueFalse(hieqbool,equalflip,hieqtrue,hieqfalse);
  if ((hilesstrue == lolesstrue)&&
      (hieqfalse == lolessfalse)&&
      (hilessfalse == hieqbl)&&
      (hieqtrue == lolessbl)) {
    if (SplitVarnode::otherwiseEmpty(hieqbool)&&SplitVarnode::otherwiseEmpty(lolessbool))
      return true;
  }
  //  else if ((hilessfalse == lolessfalse)&&
  //	   (hieqfalse == lolesstrue)&&
  //	   (hilesstrue == hieqbl)&&
  //	   (hieqtrue == lolessbl)) {
  //    if (SplitVarnode::otherwiseEmpty(hieqbool)&&SplitVarnode::otherwiseEmpty(lolessbool))
  //      return true;
  //  }
  return false;
}

bool LessThreeWay::checkOpForm(void)

{
  lo = in.getLo();
  hi = in.getHi();

  if (midconstform) {
    if (!hiconstform) return false;
    if (vnhie2->getSize() == in.getSize()) {
      if ((vnhie1!=vnhil1)&&(vnhie1!=vnhil2)) return false;
    }
    else {
      if (vnhie1!=in.getHi()) return false;
    }
    // normalizeMid checks that midval == hival
  }
  else {
    // hi and hi2 must appear as inputs in both -hiless- and -hiequal-
    if ((vnhil1!=vnhie1)&&(vnhil1!=vnhie2)) return false;
    if ((vnhil2!=vnhie1)&&(vnhil2!=vnhie2)) return false;
  }
  if ((hi!=(Varnode *)0)&&(hi == vnhil1)) {
    if (hiconstform) return false;
    hislot = 0;
    hi2 = vnhil2;
    if (vnlo1 != lo) { // Pieces must be on the same side
      Varnode *tmpvn = vnlo1;
      vnlo1 = vnlo2;
      vnlo2 = tmpvn;
      if (vnlo1 != lo) return false;
      loflip = !loflip;
      lolessequalform = !lolessequalform;
    }
    lo2 = vnlo2;
  }
  else if ((hi!=(Varnode *)0)&&(hi == vnhil2)) {
    if (hiconstform) return false;
    hislot = 1;
    hi2 = vnhil1;
    if (vnlo2 != lo) {
      Varnode *tmpvn = vnlo1;
      vnlo1 = vnlo2;
      vnlo2 = tmpvn;
      if (vnlo2 != lo) return false;
      loflip = !loflip;
      lolessequalform = !lolessequalform;
    }
    lo2 = vnlo1;
  }
  else if (in.getWhole() == vnhil1) {
    if (!hiconstform) return false;
    if (!loconstform) return false;
    if (vnlo1 != lo) return false;
    hislot = 0;
  }
  else if (in.getWhole() == vnhil2) { // Whole constant appears on the left
    if (!hiconstform) return false;
    if (!loconstform) return false;
    if (vnlo2 != lo) {
      loflip = !loflip;
      loval -= 1;
      loval &= calc_mask(lo->getSize());
      if (vnlo1 != lo) return false;
    }
    hislot = 1;
  }
  else
    return false;

  return true;
}

void LessThreeWay::setOpCode(void)

{ // Decide on the opcode of the final double precision compare
  if (lolessequalform != hiflip)
    finalopc = signcompare ? CPUI_INT_SLESSEQUAL : CPUI_INT_LESSEQUAL;
  else
    finalopc = signcompare ? CPUI_INT_SLESS : CPUI_INT_LESS;
  if (hiflip) {
    hislot = 1-hislot;
    hiflip = false;
  }
}

bool LessThreeWay::setBoolOp(void)

{ // Make changes to the threeway branch so that it becomes a single double precision branch
  if (hislot==0) {
    if (SplitVarnode::prepareBoolOp(in,in2,hilessbool))
      return true;
  }
  else {
    if (SplitVarnode::prepareBoolOp(in2,in,hilessbool))
      return true;
  }
  return false;
}

bool LessThreeWay::mapFromLow(PcodeOp *op)

{ // Given the less than comparison for the lo piece and an input varnode explicitly marked as isPrecisLo
  // try to map out the threeway lessthan form
  PcodeOp *loop = op->getOut()->loneDescend();
  if (loop == (PcodeOp *)0) return false;
  if (!mapBlocksFromLow(loop->getParent())) return false;
  if (!mapOpsFromBlocks()) return false;
  if (!checkSignedness()) return false;
  if (!normalizeHi()) return false;
  if (!normalizeMid()) return false;
  if (!normalizeLo()) return false;
  if (!checkOpForm()) return false;
  if (!checkBlockForm()) return false;
  return true;
}

bool LessThreeWay::testReplace(void)

{
  setOpCode();
  if (hiconstform) {
    in2.initPartial(in.getSize(),(hival<<(8*in.getLo()->getSize()))|loval);
    if (!setBoolOp()) return false;
  }
  else {
    in2.initPartial(in.getSize(), lo2,hi2);
    if (!setBoolOp()) return false;
  }
  return true;
}

// Given a known double precis input, look for double precision less than forms, i.e.
//    a < b,   a s< b,  a <= b,   a s<= b
//
// In this form we look for three separate comparison ops
//     hiless  = hi1 LESS hi2                   where LESS is in { <, s<, <=, s<= }
//     hiequal = hi1 == hi2
//     loless  = lo1 < lo2  OR  lo1 <= lo2      where the comparison is unsigned
//
// This boolean values are either combined in the following formula:
//     resbool = hiless || (hiequal && loless)
// OR each of the three initial comparison induces a CBRANCH
//                  if (hiless)  blocktrue  else  blocksecond
//     blocksecond: if (hiequal) blockthird else  blockfalse
//     blockthird:  if (loless) blocktrue else blockfalse
bool LessThreeWay::applyRule(SplitVarnode &i,PcodeOp *loop,bool workishi,Funcdata &data)

{
  if (workishi) return false;
  if (i.getLo() == (Varnode *)0) return false; // Doesn't necessarily need the hi
  in = i;
  if (!mapFromLow(loop)) return false;
  bool res = testReplace();
  if (res) {
    if (hislot==0)
      SplitVarnode::createBoolOp(data,hilessbool,in,in2,finalopc);
    else
      SplitVarnode::createBoolOp(data,hilessbool,in2,in,finalopc);
    // We change hieqbool so that it always goes to the original FALSE block
    data.opSetInput(hieqbool,data.newConstant(1,equalflip ? 1 : 0),1);
    // The lolessbool block now becomes unreachable and is eventually removed
  }
  return res;
}

// Sometimes double precision compares only involve the high portion of the value
// The canonical example being determining whether val > 0, where we only have to
// calculate (hi > 0).  This rule takes
//    hi COMPARE #const
// and transforms it to 
//    whole COMPARE #constextend
// where #constextend is built from #const by postpending either all 0 bits or 1 bits
bool LessConstForm::applyRule(SplitVarnode &i,PcodeOp *op,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (i.getHi()==(Varnode *)0) return false; // We don't necessarily need the lo part
  in = i;
  vn = in.getHi();
  inslot = op->getSlot(vn);
  cvn = op->getIn(1-inslot);
  int4 losize = in.getSize() - vn->getSize();

  if (!cvn->isConstant()) return false;

  signcompare = ((op->code()==CPUI_INT_SLESSEQUAL)||(op->code()==CPUI_INT_SLESS));
  hilessequalform = ((op->code()==CPUI_INT_SLESSEQUAL)||(op->code()==CPUI_INT_LESSEQUAL));

  uintb val = cvn->getOffset() << 8*losize;
  if (hilessequalform != (inslot==1))
    val |= calc_mask(losize);

  // This rule can apply and mess up less,equal rules, so we only apply it if it directly affects a branch
  PcodeOp *desc = op->getOut()->loneDescend();
  if (desc == (PcodeOp *)0) return false;
  if (desc->code() != CPUI_CBRANCH) return false;

  constin.initPartial(in.getSize(),val);

  if (inslot==0) {
    if (SplitVarnode::prepareBoolOp(in,constin,op)) {
      SplitVarnode::replaceBoolOp(data,op,in,constin,op->code());
      return true;
    }
  }
  else {
    if (SplitVarnode::prepareBoolOp(constin,in,op)) {
      SplitVarnode::replaceBoolOp(data,op,constin,in,op->code());
      return true;
    }
  }
  
  return false;
}

bool ShiftForm::mapLeft(void)

{ // Assume reshi, reslo are filled in, fill in other ops and varnodes
  if (!reslo->isWritten()) return false;
  if (!reshi->isWritten()) return false;
  loshift = reslo->getDef();
  opc = loshift->code();
  if (opc != CPUI_INT_LEFT) return false;
  orop = reshi->getDef();
  if ((orop->code() != CPUI_INT_OR)&&(orop->code() != CPUI_INT_XOR)&&(orop->code() != CPUI_INT_ADD))
    return false;
  midlo = orop->getIn(0);
  midhi = orop->getIn(1);
  if (!midlo->isWritten()) return false;
  if (!midhi->isWritten()) return false;
  if (midhi->getDef()->code() != CPUI_INT_LEFT) {
    Varnode *tmpvn = midhi;
    midhi = midlo;
    midlo = tmpvn;
  }
  midshift = midlo->getDef();
  if (midshift->code() != CPUI_INT_RIGHT) return false;	// Must be unsigned RIGHT
  hishift = midhi->getDef();
  if (hishift->code() != CPUI_INT_LEFT) return false;

  if (lo != loshift->getIn(0)) return false;
  if (hi != hishift->getIn(0)) return false;
  if (lo != midshift->getIn(0)) return false;
  salo = loshift->getIn(1);
  sahi = hishift->getIn(1);
  samid = midshift->getIn(1);
  return true;
}

bool ShiftForm::mapRight(void)

{ // Assume reshi, reslo are filled in, fill in other ops and varnodes
  if (!reslo->isWritten()) return false;
  if (!reshi->isWritten()) return false;
  hishift = reshi->getDef();
  opc = hishift->code();
  if ((opc != CPUI_INT_RIGHT)&&(opc != CPUI_INT_SRIGHT)) return false;
  orop = reslo->getDef();
  if ((orop->code() != CPUI_INT_OR)&&(orop->code() != CPUI_INT_XOR)&&(orop->code() != CPUI_INT_ADD))
    return false;
  midlo = orop->getIn(0);
  midhi = orop->getIn(1);
  if (!midlo->isWritten()) return false;
  if (!midhi->isWritten()) return false;
  if (midlo->getDef()->code() != CPUI_INT_RIGHT) { // Must be unsigned RIGHT
    Varnode *tmpvn = midhi;
    midhi = midlo;
    midlo = tmpvn;
  }
  midshift = midhi->getDef();
  if (midshift->code() != CPUI_INT_LEFT) return false;
  loshift = midlo->getDef();
  if (loshift->code() != CPUI_INT_RIGHT) return false; // Must be unsigned RIGHT

  if (lo != loshift->getIn(0)) return false;
  if (hi != hishift->getIn(0)) return false;
  if (hi != midshift->getIn(0)) return false;
  salo = loshift->getIn(1);
  sahi = hishift->getIn(1);
  samid = midshift->getIn(1);
  return true;
}

bool ShiftForm::verifyShiftAmount(void)

{ // Make sure all the shift amount varnodes are consistent
  if (!salo->isConstant()) return false;
  if (!samid->isConstant()) return false;
  if (!sahi->isConstant()) return false;
  uintb val = salo->getOffset();
  if (val != sahi->getOffset()) return false;
  if (val >= 8*lo->getSize()) return false; // If shift amount is so big, we would not use this form
  val = 8*lo->getSize() - val;
  if (samid->getOffset() != val) return false;
  return true;
}

bool ShiftForm::verifyLeft(Varnode *h,Varnode *l,PcodeOp *loop)

{
  hi = h;
  lo = l;

  loshift = loop;
  reslo = loshift->getOut();
  
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = hi->beginDescend();
  enditer = hi->endDescend();
  while(iter != enditer) {
    hishift = *iter;
    ++iter;
    if (hishift->code() != CPUI_INT_LEFT) continue;
    Varnode *outvn = hishift->getOut();
    list<PcodeOp *>::const_iterator iter2,enditer2;
    iter2 = outvn->beginDescend();
    enditer2 = outvn->endDescend();
    while(iter2 != enditer2) {
      midshift = *iter2;
      ++iter2;
      Varnode *tmpvn = midshift->getOut();
      if (tmpvn == (Varnode *)0) continue;
      reshi = tmpvn;
      if (!mapLeft()) continue;
      if (!verifyShiftAmount()) continue;
      return true;
    }
  }
  return false;
}

bool ShiftForm::verifyRight(Varnode *h,Varnode *l,PcodeOp *hiop)

{
  hi = h;
  lo = l;
  hishift = hiop;
  reshi = hiop->getOut();
  
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = lo->beginDescend();
  enditer = lo->endDescend();
  while(iter != enditer) {
    loshift = *iter;
    ++iter;
    if (loshift->code() != CPUI_INT_RIGHT) continue;
    Varnode *outvn = loshift->getOut();
    list<PcodeOp *>::const_iterator iter2,enditer2;
    iter2 = outvn->beginDescend();
    enditer2 = outvn->endDescend();
    while(iter2 != enditer2) {
      midshift = *iter2;
      ++iter2;
      Varnode *tmpvn = midshift->getOut();
      if (tmpvn == (Varnode *)0) continue;
      reslo = tmpvn;
      if (!mapRight()) continue;
      if (!verifyShiftAmount()) continue;
      return true;
    }
  }
  return false;
}

bool ShiftForm::applyRuleLeft(SplitVarnode &i,PcodeOp *loop,bool workishi,Funcdata &data)

{
  if (workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;

  if (!verifyLeft(in.getHi(),in.getLo(),loop))
    return false;

  out.initPartial(in.getSize(),reslo,reshi);
  existop = SplitVarnode::prepareShiftOp(out,in);
  if (existop == (PcodeOp *)0)
    return false;
  SplitVarnode::createShiftOp(data,out,in,salo,existop,opc);
  return true;
}

bool ShiftForm::applyRuleRight(SplitVarnode &i,PcodeOp *hiop,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;

  if (!verifyRight(in.getHi(),in.getLo(),hiop))
    return false;

  out.initPartial(in.getSize(),reslo,reshi);
  existop = SplitVarnode::prepareShiftOp(out,in);
  if (existop == (PcodeOp *)0)
    return false;
  SplitVarnode::createShiftOp(data,out,in,salo,existop,opc);
  return true;
}

bool MultForm::mapResHiSmallConst(Varnode *rhi)

{ // find reshi=hi1*lo2 + (tmp>>32)
  reshi = rhi;
  if (!reshi->isWritten()) return false;
  add1 = reshi->getDef();
  if (add1->code() != CPUI_INT_ADD) return false;
  Varnode *ad1,*ad2;
  ad1 = add1->getIn(0);
  ad2 = add1->getIn(1);
  if (!ad1->isWritten()) return false;
  if (!ad2->isWritten()) return false;
  multhi1 = ad1->getDef();
  if (multhi1->code() != CPUI_INT_MULT) {
    subhi = multhi1;
    multhi1 = ad2->getDef();
  }
  else
    subhi = ad2->getDef();
  if (multhi1->code() != CPUI_INT_MULT) return false;
  if (subhi->code() != CPUI_SUBPIECE) return false;
  midtmp = subhi->getIn(0);
  if (!midtmp->isWritten()) return false;
  multlo = midtmp->getDef();
  if (multlo->code() != CPUI_INT_MULT) return false;
  lo1zext = multlo->getIn(0);
  lo2zext = multlo->getIn(1);
  return true;
}
  
bool MultForm::mapResHi(Varnode *rhi)

{ // Find reshi=hi1*lo2 + hi2*lo1 + (tmp>>32)
  reshi = rhi;
  if (!reshi->isWritten()) return false;
  add1 = reshi->getDef();
  if (add1->code() != CPUI_INT_ADD) return false;
  Varnode *ad1,*ad2,*ad3;
  ad1 = add1->getIn(0);
  ad2 = add1->getIn(1);
  if (!ad1->isWritten()) return false;
  if (!ad2->isWritten()) return false;
  add2 = ad1->getDef();
  if (add2->code() == CPUI_INT_ADD) {
    ad1 = add2->getIn(0);
    ad3 = add2->getIn(1);
  }
  else {
    add2 = ad2->getDef();
    if (add2->code() != CPUI_INT_ADD) return false;
    ad2 = add2->getIn(0);
    ad3 = add2->getIn(1);
  }
  if (!ad1->isWritten()) return false;
  if (!ad2->isWritten()) return false;
  if (!ad3->isWritten()) return false;
  subhi = ad1->getDef();
  if (subhi->code() == CPUI_SUBPIECE) {
    multhi1 = ad2->getDef();
    multhi2 = ad3->getDef();
  }
  else {
    subhi = ad2->getDef();
    if (subhi->code() == CPUI_SUBPIECE) {
      multhi1 = ad1->getDef();
      multhi2 = ad3->getDef();
    }
    else {
      subhi = ad3->getDef();
      if (subhi->code() == CPUI_SUBPIECE) {
	multhi1 = ad1->getDef();
	multhi2 = ad2->getDef();
      }
      else
	return false;
    }
  }
  if (multhi1->code() != CPUI_INT_MULT) return false;
  if (multhi2->code() != CPUI_INT_MULT) return false;

  midtmp = subhi->getIn(0);
  if (!midtmp->isWritten()) return false;
  multlo = midtmp->getDef();
  if (multlo->code() != CPUI_INT_MULT) return false;
  lo1zext = multlo->getIn(0);
  lo2zext = multlo->getIn(1);
  return true;
}

bool MultForm::findLoFromInSmallConst(void)

{ // Assuming we have -multhi1-, -lo1-, and -hi1- in hand, try to label -lo2-
  Varnode *vn1 = multhi1->getIn(0);
  Varnode *vn2 = multhi1->getIn(1);
  if (vn1 == hi1)
    lo2 = vn2;
  else if (vn2 == hi1)
    lo2 = vn1;
  else
    return false;
  if (!lo2->isConstant()) return false;
  hi2 = (Varnode *)0;		// hi2 is an implied zero in this case
  return true;
}

bool MultForm::findLoFromIn(void)

{ // Assuming we have -multhi1-, -multhi2-, -lo1-, and -hi1- in hand, try to label lo2/hi2 pair
  Varnode *vn1 = multhi1->getIn(0);
  Varnode *vn2 = multhi1->getIn(1);
  if ((vn1 != lo1)&&(vn2!=lo1)) { // Try to normalize so multhi1 contains lo1
    PcodeOp *tmpop = multhi1;
    multhi1 = multhi2;
    multhi2 = tmpop;
    vn1 = multhi1->getIn(0);
    vn2 = multhi1->getIn(1);
  }
  if (vn1 == lo1)
    hi2 = vn2;
  else if (vn2 == lo1)
    hi2 = vn1;
  else
    return false;
  vn1 = multhi2->getIn(0);	// multhi2 should contain hi1 and lo2
  vn2 = multhi2->getIn(1);
  if (vn1 == hi1)
    lo2 = vn2;
  else if (vn2 == hi1)
    lo2 = vn1;
  else
    return false;

  return true;
}

bool MultForm::zextOf(Varnode *big,Varnode *small)

{ // Verify that big is (some form of) a zero extension of small
  PcodeOp *op;
  if (small->isConstant()) {
    if (!big->isConstant()) return false;
    if (big->getOffset() == small->getOffset()) return true;
    return false;
  }
  if (!big->isWritten()) return false;
  op = big->getDef();
  if (op->code() == CPUI_INT_ZEXT)
    return (op->getIn(0) == small);
  if (op->code() == CPUI_INT_AND) {
    if (!op->getIn(1)->isConstant()) return false;
    if (op->getIn(1)->getOffset() != calc_mask(small->getSize())) return false;
    Varnode *whole = op->getIn(0);
    if (!small->isWritten()) return false;
    PcodeOp *sub = small->getDef();
    if (sub->code() != CPUI_SUBPIECE) return false;
    return (sub->getIn(0) == whole);
  }
  return false;
}

bool MultForm::verifyLo(void)

{ // Given we have labelled lo1/hi1 lo2/hi2, make sure midtmp is formed properly
  // This also works for the small constant model  lo1/hi1 and lo2 const.
  if (subhi->getIn(1)->getOffset() != lo1->getSize()) return false;
  if (zextOf(lo1zext,lo1)) {
    if (zextOf(lo2zext,lo2))
      return true;
  }
  else if (zextOf(lo1zext,lo2)) {
    if (zextOf(lo2zext,lo1))
      return true;
  }
  return false;
}

bool MultForm::findResLo(void)

{ // Assuming we found -midtmp-, find potential reslo
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = midtmp->beginDescend();
  enditer = midtmp->endDescend();
  while(iter != enditer) {
    PcodeOp *op = *iter;
    ++iter;
    if (op->code() != CPUI_SUBPIECE) continue;
    if (op->getIn(1)->getOffset() != 0) continue; // Must grab low bytes
    reslo = op->getOut();
    if (reslo->getSize() != lo1->getSize()) continue;
    return true;
  }
  // If we reach here, it may be that separate multiplies of lo1*lo2 were used for reshi and reslo
  iter = lo1->beginDescend();
  enditer = lo1->endDescend();
  while(iter != enditer) {
    PcodeOp *op = *iter;
    ++iter;
    if (op->code() != CPUI_INT_MULT) continue;
    Varnode *vn1 = op->getIn(0);
    Varnode *vn2 = op->getIn(1);
    if (lo2->isConstant()) {
      if ((!vn1->isConstant() || (vn1->getOffset() != lo2->getOffset())) &&
	  (!vn2->isConstant() || (vn2->getOffset() != lo2->getOffset())))
	continue;
    }
    else 
      if ((op->getIn(0)!=lo2)&&(op->getIn(1)!=lo2)) continue;
    reslo = op->getOut();
    return true;
  }
  return false;
}

bool MultForm::mapFromInSmallConst(Varnode *rhi)

{
  if (!mapResHiSmallConst(rhi)) return false;
  if (!findLoFromInSmallConst()) return false;
  if (!verifyLo()) return false;
  if (!findResLo()) return false;
  return true;
}

bool MultForm::mapFromIn(Varnode *rhi)

{ // Try to do full mapping from -in- given a putative reshi
  if (!mapResHi(rhi)) return false;
  if (!findLoFromIn()) return false;
  if (!verifyLo()) return false;
  if (!findResLo()) return false;
  return true;
}

bool MultForm::replace(Funcdata &data)

{ // We have matched a double precision multiply, now transform to logical variables
  outdoub.initPartial(in.getSize(),reslo,reshi);
  in2.initPartial(in.getSize(),lo2,hi2);
  existop = SplitVarnode::prepareBinaryOp(outdoub,in,in2);
  if (existop == (PcodeOp *)0)
    return false;
  SplitVarnode::createBinaryOp(data,outdoub,in,in2,existop,CPUI_INT_MULT);
  return true;
}

bool MultForm::verify(Varnode *h,Varnode *l,PcodeOp *hop)

{
  hi1 = h;
  lo1 = l;
  list<PcodeOp *>::const_iterator iter,enditer;
  iter = hop->getOut()->beginDescend();
  enditer = hop->getOut()->endDescend();
  while(iter != enditer) {
    add1 = *iter;
    ++iter;
    if (add1->code() != CPUI_INT_ADD) continue;
    list<PcodeOp *>::const_iterator iter2,enditer2;
    iter2 = add1->getOut()->beginDescend();
    enditer2 = add1->getOut()->endDescend();
    while(iter2 != enditer2) {
      add2 = *iter2;
      ++iter2;
      if (add2->code() != CPUI_INT_ADD) continue;
      if (mapFromIn(add2->getOut()))
	return true;
    }
    if (mapFromIn(add1->getOut()))
      return true;
    if (mapFromInSmallConst(add1->getOut()))
      return true;
  }
  return false;
}

bool MultForm::applyRule(SplitVarnode &i,PcodeOp *hop,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;

  if (!verify(in.getHi(),in.getLo(),hop))
    return false;

  if (replace(data)) return true;
  return false;
}

// Given a known double precis coming together with two other pieces (via phi-nodes)
// Create a double precision phi-node
bool PhiForm::verify(Varnode *h,Varnode *l,PcodeOp *hphi)

{
  hibase = h;
  lobase = l;
  hiphi = hphi;

  inslot = hiphi->getSlot(hibase);

  if (hiphi->getOut()->hasNoDescend()) return false;
  blbase = hiphi->getParent();

  list<PcodeOp *>::const_iterator iter,enditer;
  iter = lobase->beginDescend();
  enditer = lobase->endDescend();
  while(iter != enditer) {
    lophi = *iter;
    ++iter;
    if (lophi->code() != CPUI_MULTIEQUAL) continue;
    if (lophi->getParent() != blbase) continue;
    if (lophi->getIn(inslot) != lobase) continue;
    return true;
  }
  return false;
}

bool PhiForm::applyRule(SplitVarnode &i,PcodeOp *hphi,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;

  if (!verify(in.getHi(),in.getLo(),hphi))
    return false;

  int4 numin = hiphi->numInput();
  vector<SplitVarnode> inlist;
  for(int4 j=0;j<numin;++j) {
    Varnode *vhi = hiphi->getIn(j);
    Varnode *vlo = lophi->getIn(j);
    inlist.push_back(SplitVarnode(vlo,vhi));
  }
  outvn.initPartial(in.getSize(),lophi->getOut(),hiphi->getOut());
  existop = SplitVarnode::preparePhiOp(outvn,inlist);
  if (existop != (PcodeOp *)0) {
    SplitVarnode::createPhiOp(data,outvn,inlist,existop);
    return true;
  }
  return false;
}

bool IndirectForm::verify(Varnode *h,Varnode *l,PcodeOp *ind)

{  // Verify the basic double precision indirect form and fill out the pieces
  hi = h;
  lo = l;
  indhi = ind;
  if (indhi->getIn(1)->getSpace()->getType()!=IPTR_IOP) return false;
  affector = PcodeOp::getOpFromConst(indhi->getIn(1)->getAddr());
  if (affector->isDead()) return false;
  reshi = indhi->getOut();
  if (reshi->getSpace()->getType() == IPTR_INTERNAL) return false;		// Indirect must not be through a temporary

  list<PcodeOp *>::const_iterator iter,enditer;
  iter = lo->beginDescend();
  enditer = lo->endDescend();
  while(iter != enditer) {
    indlo = *iter;
    ++iter;
    if (indlo->code() != CPUI_INDIRECT) continue;
    if (indlo->getIn(1)->getSpace()->getType()!=IPTR_IOP) continue;
    if (affector != PcodeOp::getOpFromConst(indlo->getIn(1)->getAddr())) continue;	// hi and lo must be affected by same op
    reslo = indlo->getOut();
    if (reslo->getSpace()->getType() == IPTR_INTERNAL) return false;		// Indirect must not be through a temporary
    return true;
  }
  return false;
}

bool IndirectForm::applyRule(SplitVarnode &i,PcodeOp *ind,bool workishi,Funcdata &data)

{
  if (!workishi) return false;
  if (!i.hasBothPieces()) return false;
  in = i;
  if (!verify(in.getHi(),in.getLo(),ind))
    return false;

  outvn.initPartial(in.getSize(),reslo,reshi);

  if (!SplitVarnode::prepareIndirectOp(in,affector))
    return false;
  SplitVarnode::replaceIndirectOp(data,outvn,in,affector);
  return true;
}

void RuleDoubleIn::reset(Funcdata &data)

{
  data.setDoublePrecisRecovery(true); // Mark that we are doing double precision recovery
}

void RuleDoubleIn::getOpList(vector<uint4> &oplist) const

{
  oplist.push_back(CPUI_SUBPIECE);
}

/// \brief Determine if the given Varnode from a SUBPIECE should be marked as a double precision piece
///
/// If the given Varnode looks like the most significant piece, there is another SUBPIECE that looks
/// like the least significant piece, and the whole is from an operation that produces a logical whole,
/// then mark the Varnode (and its companion) as double precision pieces and return 1.
/// \param data is the function owning the Varnode
/// \param vn is the given Varnode
/// \param subpieceOp is the SUBPIECE PcodeOp producing the Varnode
int4 RuleDoubleIn::attemptMarking(Funcdata &data,Varnode *vn,PcodeOp *subpieceOp)

{
  Varnode *whole = subpieceOp->getIn(0);
  int4 offset = (int4)subpieceOp->getIn(1)->getOffset();
  if (offset != vn->getSize()) return 0;
  if (offset * 2 != whole->getSize()) return 0;		// Truncate exactly half
  if (whole->isInput()) {
    if (!whole->isTypeLock()) return 0;
  }
  else if (!whole->isWritten()) {
    return 0;
  }
  else {
    // Categorize opcodes as ""producing a logical whole""
    switch(whole->getDef()->code()) {
      case CPUI_INT_ADD:
	// Its hard to tell if the bit operators are really being used to act on the ""logical whole""
//      case CPUI_INT_AND:
//      case CPUI_INT_OR:
//      case CPUI_INT_XOR:
//      case CPUI_INT_NEGATE:
      case CPUI_INT_MULT:
      case CPUI_INT_DIV:
      case CPUI_INT_SDIV:
      case CPUI_INT_REM:
      case CPUI_INT_SREM:
      case CPUI_INT_2COMP:
      case CPUI_FLOAT_ADD:
      case CPUI_FLOAT_DIV:
      case CPUI_FLOAT_MULT:
      case CPUI_FLOAT_SUB:
      case CPUI_FLOAT_NEG:
      case CPUI_FLOAT_ABS:
      case CPUI_FLOAT_SQRT:
      case CPUI_FLOAT_INT2FLOAT:
      case CPUI_FLOAT_FLOAT2FLOAT:
      case CPUI_FLOAT_TRUNC:
      case CPUI_FLOAT_CEIL:
      case CPUI_FLOAT_FLOOR:
      case CPUI_FLOAT_ROUND:
	break;
      default:
	return 0;
    }
  }
  Varnode *vnLo = (Varnode *)0;
  list<PcodeOp *>::const_iterator iter;
  for(iter=whole->beginDescend();iter!=whole->endDescend();++iter) {
    PcodeOp *op = *iter;
    if (op->code() != CPUI_SUBPIECE) continue;
    if (op->getIn(1)->getOffset() != 0) continue;
    if (op->getOut()->getSize() == vn->getSize()) {
      vnLo = op->getOut();
      break;
    }
  }
  if (vnLo == (Varnode *)0) return 0;
  vnLo->setPrecisLo();
  vn->setPrecisHi();
  return 1;
}

int4 RuleDoubleIn::applyOp(PcodeOp *op,Funcdata &data)

{ // Try to push double precision object ""down"" one level from input
  Varnode *outvn = op->getOut();
  if (!outvn->isPrecisLo()) {
    if (outvn->isPrecisHi()) return 0;
    return attemptMarking(data, outvn, op);
  }
  if (data.hasUnreachableBlocks()) return 0;

  vector<SplitVarnode> splitvec;
  SplitVarnode::wholeList(op->getIn(0),splitvec);
  if (splitvec.empty()) return 0;
  for(int4 i=0;i<splitvec.size();++i) {
    SplitVarnode &in(splitvec[i]);
    int4 res = SplitVarnode::applyRuleIn(in,data);
    if (res != 0)
      return res;
  }
  return 0;
}

/// \brief Scan for conflicts between two LOADs or STOREs that would prevent them from being combined
///
/// The PcodeOps must be in the same basic block.  Each PcodeOp that falls in between is examined
/// to determine if it writes to the same address space as the LOADs or STOREs, which indicates that
/// combining isn't possible.  If the LOADs and STOREs can be combined, the later of the two PcodeOps
/// is returned, otherwise null is returned.
///
/// In the case of STORE ops, an extra container for INDIRECT PcodeOps is passed in.  INDIRECTs that
/// are caused by the STORE ops themselves are collected in the container.
/// \param op1 is a given LOAD or STORE
/// \param op2 is the other given LOAD or STORE
/// \param spc is the address space referred to by the LOAD/STOREs
/// \param indirects if non-null is used to collect INDIRECTs caused by STOREs
PcodeOp *RuleDoubleLoad::noWriteConflict(PcodeOp *op1,PcodeOp *op2,AddrSpace *spc,vector<PcodeOp *> *indirects)

{
  const BlockBasic *bb = op1->getParent();

  // Force the two ops to be in the same basic block
  if (bb != op2->getParent()) return (PcodeOp *)0;
  if (op2->getSeqNum().getOrder() < op1->getSeqNum().getOrder()) {
    PcodeOp *tmp = op2;
    op2 = op1;
    op1 = tmp;
  }
  PcodeOp *startop = op1;
  if (op1->code() == CPUI_STORE) {
    // Extend the range of PcodeOps to include any CPUI_INDIRECTs associated with the initial STORE
    PcodeOp *tmpOp = startop->previousOp();
    while(tmpOp != (PcodeOp *)0 && tmpOp->code() == CPUI_INDIRECT) {
      startop = tmpOp;
      tmpOp = tmpOp->previousOp();
    }
  }
  list<PcodeOp *>::iterator iter = startop->getBasicIter();
  list<PcodeOp *>::iterator enditer = op2->getBasicIter();

  while(iter != enditer) {
    PcodeOp *curop = *iter;
    Varnode *outvn;
    PcodeOp *affector;
    ++iter;
    if (curop == op1) continue;
    switch(curop->code()) {
    case CPUI_STORE:
      if (curop->getIn(0)->getSpaceFromConst() == spc)
	return (PcodeOp *)0;	// Don't go any further trying to resolve alias
      break;
    case CPUI_INDIRECT:
      affector = PcodeOp::getOpFromConst(curop->getIn(1)->getAddr());
      if (affector == op1 || affector == op2) {
	if (indirects != (vector<PcodeOp *> *)0)
	  indirects->push_back(curop);
      }
      else {
	if (curop->getOut()->getSpace() == spc)
	  return (PcodeOp *)0;
      }
      break;
    case CPUI_CALL:
    case CPUI_CALLIND:
    case CPUI_CALLOTHER:
    case CPUI_RETURN:
    case CPUI_BRANCH:
    case CPUI_CBRANCH:
    case CPUI_BRANCHIND:
      return (PcodeOp *)0;
    default:
      outvn = curop->getOut();
      if (outvn != (Varnode *)0) {
	if (outvn->getSpace() == spc)
	  return (PcodeOp *)0;
      }
      break;
    }
  }
  return op2;
}

void RuleDoubleLoad::getOpList(vector<uint4> &oplist) const

{
  oplist.push_back(CPUI_PIECE);
}

int4 RuleDoubleLoad::applyOp(PcodeOp *op,Funcdata &data)

{
  PcodeOp *loadlo,*loadhi;	// Load from lowest address, highest (NOT significance)
  AddrSpace *spc;
  int4 size;

  Varnode *piece0 = op->getIn(0);
  Varnode *piece1 = op->getIn(1);
  if (!piece0->isWritten()) return 0;
  if (!piece1->isWritten()) return 0;
  if (piece0->getDef()->code() != CPUI_LOAD) return false;
  if (piece1->getDef()->code() != CPUI_LOAD) return false;
  if (!SplitVarnode::testContiguousPointers(piece0->getDef(),piece1->getDef(),loadlo,loadhi,spc))
    return 0;

  size = piece0->getSize() + piece1->getSize();
  PcodeOp *latest = noWriteConflict(loadlo,loadhi,spc,(vector<PcodeOp *> *)0);
  if (latest == (PcodeOp *)0) return 0; // There was a conflict

  // Create new load op that combines the two smaller loads
  PcodeOp *newload = data.newOp(2,latest->getAddr());
  Varnode *vnout = data.newUniqueOut(size,newload);
  Varnode *spcvn = data.newVarnodeSpace(spc);
  data.opSetOpcode(newload,CPUI_LOAD);
  data.opSetInput(newload,spcvn,0);
  Varnode *addrvn = loadlo->getIn(1);
  if (addrvn->isConstant())
    addrvn = data.newConstant(addrvn->getSize(),addrvn->getOffset());
  data.opSetInput(newload,addrvn,1);
  // We need to guarantee that -newload- reads -addrvn- after
  // it has been defined. So insert it after the latest.
  data.opInsertAfter(newload,latest);

  // Change the concatenation to a copy from the big load
  data.opRemoveInput(op,1);
  data.opSetOpcode(op,CPUI_COPY);
  data.opSetInput(op,vnout,0);

  return 1;
}

void RuleDoubleStore::getOpList(vector<uint4> &oplist) const

{
  oplist.push_back(CPUI_STORE);
}

int4 RuleDoubleStore::applyOp(PcodeOp *op,Funcdata &data)

{
  PcodeOp *storelo,*storehi;
  AddrSpace *spc;

  Varnode *vnlo = op->getIn(2);
  if (!vnlo->isPrecisLo()) return 0;
  if (!vnlo->isWritten()) return 0;
  PcodeOp *subpieceOpLo = vnlo->getDef();
  if (subpieceOpLo->code() != CPUI_SUBPIECE) return 0;
  if (subpieceOpLo->getIn(1)->getOffset() != 0) return 0;
  Varnode *whole = subpieceOpLo->getIn(0);
  if (whole->isFree()) return 0;
  list<PcodeOp *>::const_iterator iter;
  for(iter=whole->beginDescend();iter!=whole->endDescend();++iter) {
    PcodeOp *subpieceOpHi = *iter;
    if (subpieceOpHi->code() != CPUI_SUBPIECE) continue;
    if (subpieceOpHi == subpieceOpLo) continue;
    int4 offset = (int4)subpieceOpHi->getIn(1)->getOffset();
    if (offset != vnlo->getSize()) continue;
    Varnode *vnhi = subpieceOpHi->getOut();
    if (!vnhi->isPrecisHi()) continue;
    if (vnhi->getSize() != whole->getSize() - offset) continue;
    list<PcodeOp *>::const_iterator iter2;
    for(iter2=vnhi->beginDescend();iter2!=vnhi->endDescend();++iter2) {
      PcodeOp *storeOp2 = *iter2;
      if (storeOp2->code() != CPUI_STORE) continue;
      if (storeOp2->getIn(2) != vnhi) continue;
      if (SplitVarnode::testContiguousPointers(storeOp2, op, storelo, storehi, spc)) {
	vector<PcodeOp *> indirects;
	PcodeOp *latest = RuleDoubleLoad::noWriteConflict(storelo,storehi,spc,&indirects);
	if (latest == (PcodeOp *)0) continue;	// There was a conflict
	if (!testIndirectUse(storelo, storehi, indirects)) continue;
	// Create new STORE op that combines the two smaller STOREs
	PcodeOp *newstore = data.newOp(3,latest->getAddr());
	Varnode *spcvn = data.newVarnodeSpace(spc);
	data.opSetOpcode(newstore,CPUI_STORE);
	data.opSetInput(newstore,spcvn,0);
	Varnode *addrvn = storelo->getIn(1);
	if (addrvn->isConstant())
	  addrvn = data.newConstant(addrvn->getSize(),addrvn->getOffset());
	data.opSetInput(newstore,addrvn,1);
	data.opSetInput(newstore,whole,2);
	// We need to guarantee that -newstore- reads -addrvn- after
	// it has been defined. So insert it after the latest.
	data.opInsertAfter(newstore,latest);
	data.opDestroy(op);		// Get rid of the original STOREs
	data.opDestroy(storeOp2);
	reassignIndirects(data, newstore, indirects);
	return 1;
      }
    }
  }
  return 0;
}

/// \brief Test if output Varnodes from a list of PcodeOps are used anywhere within a range of PcodeOps
///
/// The range of PcodeOps bounded by given starting and ending PcodeOps.  An output Varnode is
/// used within the range if there is a PcodeOp in the range that takes the Varnode as input.
/// \param op1 is the given starting PcodeOp of the range
/// \param op2 is the given ending PcodeOp of the range
/// \param indirects is the list of PcodesOps whose output are tested
/// \return \b true if no output in the list is used in the range
bool RuleDoubleStore::testIndirectUse(PcodeOp *op1,PcodeOp *op2,const vector<PcodeOp *> &indirects)

{
  if (op2->getSeqNum().getOrder() < op1->getSeqNum().getOrder()) {
    PcodeOp *tmp = op2;
    op2 = op1;
    op1 = tmp;
  }
  for(int4 i=0;i<indirects.size();++i) {
    Varnode *outvn = indirects[i]->getOut();
    list<PcodeOp *>::const_iterator iter;
    int4 usecount = 0;
    int4 usebyop2 = 0;
    for(iter=outvn->beginDescend();iter!=outvn->endDescend();++iter) {
      PcodeOp *op = *iter;
      usecount += 1;
      if (op->getParent() != op1->getParent()) continue;
      if (op->getSeqNum().getOrder() < op1->getSeqNum().getOrder()) continue;
      if (op->getSeqNum().getOrder() > op2->getSeqNum().getOrder()) continue;
      // Its likely that INDIRECTs from the first STORE feed INDIRECTs for the second STORE
      if (op->code() == CPUI_INDIRECT && op2 == PcodeOp::getOpFromConst(op->getIn(1)->getAddr())) {
	usebyop2 += 1;	// Note this pairing
	continue;
      }
      return false;
    }
    // As an INDIRECT whose output Varnode feeds into later INDIRECTs must be removed, we need the following test.
    // If some uses of the output feed into later INDIRECTs, but not ALL do, then return false
    if (usebyop2 > 0 && usecount != usebyop2)
      return false;
    if (usebyop2 > 1)
      return false;
  }
  return true;
}

/// \brief Reassign INDIRECTs to a new given STORE
///
/// The INDIRECTs are associated with old STOREs that are being removed.
/// Each INDIRECT is moved from its position near the old STORE to be near the new STORE and
/// the affect iop operand is set to point at the new STORE.
/// \param data is the function owning the INDIRECTs
/// \param newStore is the given new STORE PcodeOp
/// \param indirects is the list of INDIRECT PcodeOps to reassign
void RuleDoubleStore::reassignIndirects(Funcdata &data,PcodeOp *newStore,const vector<PcodeOp *> &indirects)

{
  // Search for INDIRECT pairs.  The earlier is deleted.  The later gains the earlier's input.
  for(int4 i=0;i<indirects.size();++i) {
    PcodeOp *op = indirects[i];
    op->setMark();
    Varnode *vn = op->getIn(0);
    if (!vn->isWritten()) continue;
    PcodeOp *earlyop = vn->getDef();
    if (earlyop->isMark()) {
      data.opSetInput(op,earlyop->getIn(0),0);	// Grab the earlier op's input, replacing the use of its output
      data.opDestroy(earlyop);
    }
  }
  for(int4 i=0;i<indirects.size();++i) {
    PcodeOp *op = indirects[i];
    op->clearMark();
    if (op->isDead()) continue;
    data.opUninsert(op);
    data.opInsertBefore(op,newStore);		// Move the INDIRECT to the new STORE
    data.opSetInput(op,data.newVarnodeIop(newStore),1);	// Assign the INDIRECT to the new STORE
  }
}

} // End namespace ghidra
",looffset
479,"#include <pch.h>

#include ""Renderer.h""
#include ""VertexBuffer.h""
#include ""VertexBufferLayout.h""
#include ""VertexArray.h""
#include ""IndexBuffer.h""
#include ""Shader.h""
#include ""Texture.h""

#include ""CPU.h""

#include ""UI/RenderControls.h""


	int main() {
		GLFWwindow* window;

		if (!glfwInit()) {
			std::cout << ""[-] There was an error while initializing GLFW\n"";
			return -1;
		}

		glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
		glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
		glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

		int  [MASK]  = 700;
		int windowHeight = 700;

		window = glfwCreateWindow( [MASK] , windowHeight, ""16 Bit CPU"", NULL, NULL);
		if (!window) {
			std::cout << ""[-] There was an error while creating the window\n"";
			glfwTerminate();
			return -1;
		}

		glfwMakeContextCurrent(window);

		if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
			std::cout << ""[-] There was an error while initializing GLAD\n"";
			return -1;
		}
		
		{
			float vertecies[] = {
					// Positions       /  Texture coordiantes//
				 -0.5f, -0.5f,                -0.5f, -0.5f,
				  0.5f, -0.0f,                 0.5f, -0.0f,
				  0.5f,  0.0f,                 0.5f,  0.0f,
				 -0.5f,  0.0f,                -0.5f,  0.0f,
				};


			unsigned int indicies[] = {
				0, 1, 2,
				0, 2, 3
			};

			GLCall(glEnable(GL_DEPTH_TEST));

			GLCall(glEnable(GL_BLEND));
			GLCall(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));


			VertexArray va;
			VertexBuffer vb(vertecies, sizeof(vertecies));

			VertexBufferLayout layout;
			layout.Push<float>(2); // Positions
			layout.Push<float>(2); // TexCoords
			va.AddBuffer(vb, layout);

			IndexBuffer ib(indicies, sizeof(indicies)/sizeof(unsigned int));

			Shader shader(""res/shaders/basic.vert"", ""res/shaders/basic.frag"");
			shader.Bind();

			Renderer renderer;

			bool VSync = false;

			int width, height = 0;

			va.Unbind();
			vb.Unbind();
			ib.Unbind();
			shader.Unbind();

			CPU cpu;

			ImGui::CreateContext();

			ImGui_ImplGlfw_InitForOpenGL(window, true);
			ImGui_ImplOpenGL3_Init();
			ImGui::StyleColorsDark();

			ImGuiIO& io = ImGui::GetIO();

			while (!glfwWindowShouldClose(window)) {
				
				renderer.ClearColor(1.0f, 1.0f, 1.0f, 1.0f);
				GLCall(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));

				cpu.Step(1);

				GLCall(glfwSwapInterval((int)VSync));

				glfwGetFramebufferSize(window, &width, &height);
				GLCall(glViewport(0, 0, width, height));

				float ratio = (float)width / height;

				shader.Bind();

				shader.SetUniform1i(""u_Texture"", 0);

				glm::mat4 Model = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
				glm::mat4 View = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
				glm::mat4 Projection = glm::ortho(0.0f, (float) [MASK] , 0.0f, (float)windowHeight, 0.0f, 1.0f);

				renderer.Draw(va, ib, shader);				

				ImGui_ImplOpenGL3_NewFrame();
				ImGui_ImplGlfw_NewFrame();
				ImGui::NewFrame();

				ImGui::Begin(""Panel"");

				ImGui::Text(""Application average %.3f ms/frame (%.1f FPS)"", 1000.0f / io.Framerate, io.Framerate);
				
				ImGui::Text(""Enable V-Sync"");
				ImGui::SameLine();
				ImGui::Checkbox(""##vsync"", &VSync);

				ImGui::End();

				ImGui::Render();
				ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

				glfwSwapBuffers(window);
				glfwPollEvents();
			}
		}

		ImGui_ImplOpenGL3_Shutdown();
		ImGui_ImplGlfw_Shutdown();
		ImGui::DestroyContext();
		glfwTerminate();
		return 0;
	}",windowWidth
480,"#include ""buffer/stream_buffer.h""

#include <algorithm>
#include <cstdint>
#include <stdexcept>

using namespace std;

StreamBuffer::StreamBuffer(uint64_t capacity) : capacity_(capacity) {}

void Writer::push(string  [MASK] ) {
  const auto write_num = min(available_capacity(),  [MASK] .size());
  if (!write_num) {
    return;
  }

  if ( [MASK] .size() > write_num) {
     [MASK]  =  [MASK] .substr(0, write_num);
  }
  _buffer.push(std::move( [MASK] ));
  if (_buffer.size() == 1) {
    _front_view = _buffer.front();
  }
  _bytes_pushed += write_num;
  _bytes_buffered += write_num;
}

void Writer::close() { _closed = true; }

void Writer::set_error() { _error = true; }

bool Writer::is_closed() const { return _closed; }

uint64_t Writer::available_capacity() const {
  return capacity_ - _bytes_buffered;
}

uint64_t Writer::bytes_pushed() const { return _bytes_pushed; }

string_view Reader::peek() const { return _front_view; }

bool Reader::is_finished() const {
  return writer().is_closed() && !bytes_buffered();
}

bool Reader::has_error() const { return _error; }

void Reader::pop(uint64_t len) {
  auto pop_num = min(len, _bytes_buffered);

  while (len && !_buffer.empty()) {
    const size_t firstsize = _front_view.size();
    if (len >= firstsize) {
      _buffer.pop();
      if (!_buffer.empty()) {
        _front_view = _buffer.front();
      }
      len -= firstsize;
      continue;
    }
    _front_view.remove_prefix(pop_num);
    len = 0;
  }
  _bytes_popped += pop_num;
  _bytes_buffered -= pop_num;
}

uint64_t Reader::bytes_buffered() const { return _bytes_buffered; }

uint64_t Reader::bytes_popped() const { return _bytes_popped; }

void read(Reader& reader, uint64_t len, std::string& out) {
  out.clear();

  while (reader.bytes_buffered() and out.size() < len) {
    auto view = reader.peek();

    if (view.empty()) {
      throw std::runtime_error(""Reader::peek() returned empty string_view"");
    }

    view = view.substr(0, len - out.size());
    out += view;
    reader.pop(view.size());
  }
}

Reader& StreamBuffer::reader() {
  static_assert(sizeof(Reader) == sizeof(StreamBuffer),
                ""Please add member variables to the StreamBuffer base, not the ""
                ""StreamBuffer Reader."");

  return static_cast<Reader&>(*this);  // NOLINT(*-downcast)
}

const Reader& StreamBuffer::reader() const {
  static_assert(sizeof(Reader) == sizeof(StreamBuffer),
                ""Please add member variables to the StreamBuffer base, not the ""
                ""StreamBuffer Reader."");

  return static_cast<const Reader&>(*this);  // NOLINT(*-downcast)
}

Writer& StreamBuffer::writer() {
  static_assert(sizeof(Writer) == sizeof(StreamBuffer),
                ""Please add member variables to the StreamBuffer base, not the ""
                ""StreamBuffer Writer."");

  return static_cast<Writer&>(*this);  // NOLINT(*-downcast)
}

const Writer& StreamBuffer::writer() const {
  static_assert(sizeof(Writer) == sizeof(StreamBuffer),
                ""Please add member variables to the StreamBuffer base, not the ""
                ""StreamBuffer Writer."");

  return static_cast<const Writer&>(*this);  // NOLINT(*-downcast)
}
",data
481,"#include <cassert>
#include <iostream>
#include <string>

#include ""libseqiter/seqiter.h""

using namespace std::literals;

bool test1() {
  auto  [MASK]  = std::array{3,1,4,1,5};
  auto in2 = std::array{9,2,6,5};
  auto in3 = std::array{3,5,8};
  auto in = sequential_iterators<int const &>(it_pair{ [MASK] }, it_pair{in2}, it_pair{in3});
  auto out = std::array<int, 12>{};
  std::copy(in, in.end(), out.begin());
  return out == std::array{3,1,4,1,5,9,2,6,5,3,5,8};
}

int main(int, char **) {
  assert(test1);

  auto s = ""hello world\n""s;
  auto seq = sequential_iterators<char const &>(it_pair{s.begin(), s.end()},
                                                it_pair{s});
  auto mut_seq =
      sequential_iterators<char &>(it_pair{s.begin(), s.end()}, it_pair{s});
  for (auto x : seq) {
    std::cout << x;
  }
  for (auto &x : mut_seq) {
    x = 'q';
  }
  for (auto x : seq) {
    std::cout << x;
  }
  assert(seq.begin() == seq.begin());
  assert(seq.begin() != ++seq.begin());

  auto const s2 = ""hello world\n""s;
  auto mut_seq2 = sequential_iterators<char const &>(
      it_pair{s2.begin(), s2.end()}, it_pair{s2});
  for (auto x : mut_seq2) {
    std::cout << x;
  }

  return 0;
}
",in1
482,"#include <iostream>
#include ""myclasses.h""

using namespace std;


int main() {
    // Создаем переменную myClass типа класса MyClass,
    // она будет автоматически удалена при завершении программы
    // И так лучше не создавать объекты !!!
    MyClass myClass;

    cout << myClass.get_time() << endl;
    cout << myClass.getLastTime() << endl;
    cout << myClass.sum(12, 12) << endl;
    cout << myClass.sum(12.5, 12.5) << endl;
    //delete &myClass; // Нельзя так удалить автоматически созданный объект

    // Создаем переменную myClass2 через конструктор с параметром
    MyClass *myClass2 = new MyClass(""TSN"");
    cout << myClass2->getLastTime() << endl; // Теперь вместо точки нужно использовать ->
    delete myClass2;                         // Удаляем сами созданный нами объект

    MyClass2  [MASK] ;
    cout << myClass.get_time() << endl; // Вызов метода предка
     [MASK] .myPrint();                 // Вызов собственного метода класса

    cout << ""xxxx"";

    return 0;
}
",myClass3
483,"#include ""Bus.h""
#include ""cartridge.h""

Bus::Bus()
{
	//clear ram content on startup
	for (auto& loc : ram) loc = 0x00;

	//connect cpu to bus
	cpu.connectBus(this);
}

Bus::~Bus()
{

}

void Bus::CpuWrite(uint16_t addr, uint8_t data)
{
	if (_currentCart->CpuWrite(addr, data)) {
		//when bus is written to the cpu the cartridge gets to decide if its forthe cartridge or not if not ppu or ram does not get updated
		//TODO we can change this to normal address bounds
	}
	//check if addr falls into device range
	else if(addr >= 0x0000 && addr <= 0xFFFF) //RAM range
		ram[addr & 0x7FF] = data; //also mirroring binary MODULO to determine RAM quadrant
	else if (addr >= 0x2000 && addr <= 0x3FFF) { //PPU write also uses mirroring  8 bits
		PictureProccessingUnit.PPUWrite(addr & 0x007, data); //https://wiki.nesdev.com/w/index.php/PPU_registers
	}
}

uint8_t Bus::CpuRead(uint16_t addr, bool  [MASK]  /*= false*/)
{
	uint8_t data = 0x00;

	if (_currentCart->CpuRead(addr, data)) {
		//when bus is written to the cpu the cartridge gets to decide if its forthe cartridge or not if not ppu or ram does not get updated
		//TODO we can change this to normal address bounds
	}
	//check if addr falls into device range
	if (addr >= 0x0000 && addr <= 0x1FFF) { //see if adress is in 8k adressable RAM memory
		//do mirroring (physically only 2K RAM on hardware but 8k is adressable so 4 adresses lead to the same data)
			return ram[addr & 0x7FF]; //Get memory from the different quarants depending using binary MODULO(%)  because there is only 2K of REAL MEMORY
	}
	else if (addr >= 0x2000 && addr <= 0x3FFF) { //PPU READ also uses mirroring is mirrored in every 8 bits
		return PictureProccessingUnit.PPURead(addr & 0x007,  [MASK] ); //https://wiki.nesdev.com/w/index.php/PPU_registers
	}
	else	
		return data;


	//implement mirroring
}

void Bus::insertCartridge(Cartridge* newCart)
{
	_currentCart = newCart; //connect bus to cartridge
	PictureProccessingUnit.SetCartridge(newCart); //connect ppu to cartridge so it access 

}

void Bus::reset()
{
	cpu.reset();
	_systemClockCounter = 0;
}

void Bus::clock()
{
	PictureProccessingUnit.clock();
	//cpu clock runs 3 times slower than ppu clock

	if(_systemClockCounter % 3 == 0)
		cpu.clock();

	_systemClockCounter++;
}

",readOnly
484,"#include ""DNAData.h""

TypeHandle DNAData::_type_handle;

DNAData::DNAData(const std::string& name) : DNAGroup(m_name) {
    m_cur_store = nullptr;
    cord_system = get_default_coordinate_system();
}

DNAData::~DNAData() {
    
}

void DNAData::pre_write() {
    
}

void DNAData::set_coordinate_system(CoordinateSystem &system) {
    if (!system) {
        cord_system = get_default_coordinate_system();
        return;
    }
    cord_system = system;
}

void DNAData::set_dna_filename(Filename &file) {
    dna_filename = file;
}

void DNAData::set_dna_storage(DNAStorage &storage) {
    m_cur_store = &storage;
}

bool DNAData::resolve_dna_filename(Filename file, DSearchPath s_path) {
    VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
    std::string extension = ""dna"";
    ConfigVariableSearchPath model_path = get_model_path();
    if (vfs->resolve_filename(file, s_path, extension)) {
        auto file_found = vfs->get_file(file, 1);
        return (file_found != NULL && file_found != nullptr);
    } else if (vfs->resolve_filename(file, model_path.get_value(), extension)) {
        auto file_found = vfs->get_file(file, 1);
        return (file_found != NULL && file_found != nullptr);
    } else {
        return false;
    }
}

bool DNAData::read(istream &file_stream, ostream &notify_stream) {
    return false;
}

CoordinateSystem DNAData::get_coordinate_system() {
    return cord_system;
}

Filename DNAData::get_dna_filename() {
    return dna_filename;
}

DNAStorage *DNAData::get_dna_storage() {
    if (m_cur_store == NULL || m_cur_store == nullptr) {
        DNAStorage *new_storage = new DNAStorage;
        return new_storage;
    }
    return m_cur_store;
}

DNAData *DNAData::make_copy() {
    DNAData *copy = new DNAData(m_name);
    copy->set_coordinate_system(cord_system);
    copy->set_dna_filename(Filename(dna_filename));
    if (m_cur_store == NULL || m_cur_store == nullptr) {
        DNAStorage *new_storage = new DNAStorage;
        copy->set_dna_storage(*new_storage);
    } else {
        copy->set_dna_storage(*m_cur_store);
    }
    
    return copy;
}

void DNAData::write(std::ostream& out, DNAStorage *store, unsigned int  [MASK] ) {
    store->write(out,  [MASK] );
    out << std::endl;
}",nbyte
485,"#ifndef PINGCAP_MUTEX_H
#define PINGCAP_MUTEX_H

#include <pthread.h>
#include <assert.h>
#include ""PingCAP_define.h""

namespace pingcap
{
  namespace common
  {
    class PingCAPMutex
    {
      public:
        PingCAPMutex()
        {
          const int  [MASK]  = pthread_mutex_init(&mutex_, NULL);
          (void)  [MASK] ;
          assert(  [MASK]  == 0 );
        }
    
        ~PingCAPMutex()
        {
          pthread_mutex_destroy(&mutex_);
        }
        
        void lock ()
        {
          pthread_mutex_lock(&mutex_);
        }
    
        int trylock ()
        {
          return pthread_mutex_trylock(&mutex_);
        }
    
        void unlock()
        {
          pthread_mutex_unlock(&mutex_);
        }
    
    protected:
        pthread_mutex_t mutex_;
    };
  }
}

#endif // PINGCAP_MUTEX_H
",iRet
486,"#include ""widget.h""
#include ""./ui_widget.h""

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    ui->copyName->setVisible(false);
    QStandardItemModel* model = new QStandardItemModel(ui->treeView);
    model->setHorizontalHeaderLabels(QStringList()<<""名称""<<""类型"");

    QMap<QString,QIcon> m_publicIconMap;
    m_publicIconMap[QStringLiteral(""treeItem_Computer"")] =QIcon(QStringLiteral("":/Icon/Image/Computer.png""));
    m_publicIconMap[QStringLiteral(""treeItem_Disk"")] =QIcon(QStringLiteral("":/Icon/Image/Disk.png""));
    m_publicIconMap[QStringLiteral(""treeItem_Project"")] =QIcon(QStringLiteral("":/Icon/Image/Project.png""));
    m_publicIconMap[QStringLiteral(""treeItem_Unknownfile"")] =QIcon(QStringLiteral("":/Icon/Image/Unknownfile.png""));
    m_publicIconMap[QStringLiteral(""treeItem_txt"")] =QIcon(QStringLiteral("":/Icon/Image/txt.png""));


    QVector<QString>  [MASK] ={""C盘"",""D盘"",""E盘""};

    QStandardItem* myComputer = new QStandardItem(m_publicIconMap[QStringLiteral(""treeItem_Computer"")],QStringLiteral(""我的电脑""));
    model->appendRow(myComputer);
    model->setItem(0,1,new QStandardItem(QStringLiteral(""system"")));


    for(int i=0;i< [MASK] .size();i++){
        QStandardItem* myDisk = new QStandardItem(m_publicIconMap[QStringLiteral(""treeItem_Disk"")], [MASK] [i]);
        myComputer->appendRow(myDisk);
        myComputer->setChild(i,1,new QStandardItem(QStringLiteral(""驱动器"")));
        for(int j=1;j<3;j++){
            QStandardItem* myProject = new QStandardItem(m_publicIconMap[QStringLiteral(""treeItem_Project"")],QStringLiteral(""文件夹"")+QString(""%1"").arg(j));
            myDisk->appendRow(myProject);
            myDisk->setChild(j-1,1,new QStandardItem(QStringLiteral(""文件夹"")));

            QString fileName=""文件.txt"";
            QStringList strList = fileName.split(""."");
            if(strList.size()<2||strList[1]!=""txt""){
                QStandardItem* myFile = new QStandardItem(m_publicIconMap[QStringLiteral(""treeItem_file"")],fileName);
                myProject->appendRow(myFile);
                myProject->setChild(0,1,new QStandardItem(""未知文件""));
            }else{
                QStandardItem* myFile = new QStandardItem(m_publicIconMap[QStringLiteral(""treeItem_txt"")],fileName);
                myProject->appendRow(myFile);
                myProject->setChild(0,1,new QStandardItem(strList[1]+QStringLiteral(""文件"")));
            }
        }
    }



    ui->treeView->setModel(model);
    ui->treeView->header()->resizeSection(0,300);
    //ui->treeView->expandAll();

    //右键菜单
    ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);



}


//析构函数
Widget::~Widget()
{
    delete ui;
}

//鼠标点击事件
void Widget::on_treeView_clicked(const QModelIndex &index)
{
    show_path();
}

//显示当前路径
QString Widget::show_path(){
    QModelIndex index = ui->treeView->currentIndex();
    QString name,info;
    if(index.column() == 0)
        {
            name = index.data().toString();
            info = index.sibling(index.row(),1).data().toString();
        }
        else
        {
            name = index.sibling(index.row(),0).data().toString();
            info = index.data().toString();
        }
    QString currentPath = """";
    if(info==""system""||info==""驱动器""||info==""文件夹""){
        currentPath = QStringLiteral(""%1"").arg(index.data().toString()); //当前路径
        while(index.parent().isValid()){
            index=index.parent();
            currentPath=QStringLiteral(""%1"").arg(index.data().toString())+""/""+currentPath;
        }
    }else{
        while(index.parent().isValid()){
            index=index.parent();
            currentPath=QStringLiteral(""%1"").arg(index.data().toString())+""/""+currentPath;
        }
    }
    ui->label->setText(currentPath);
    return info;
}

//右键菜单
void Widget::on_treeView_customContextMenuRequested(const QPoint &pos)
{

    QString copyFile = ui->copyName->text();
    if(show_path()==""system""||show_path()==""驱动器""||show_path()==""""){

    }else if(show_path()==""文件夹""){
        //右键菜单
              QMenu *menu = new QMenu(ui->treeView);
              menu->addAction(""新建文件夹"",this,&Widget::new_project);
              menu->addAction(""新建文件"",this,&Widget::new_file);
              menu->addAction(""删除"",this,&Widget::delete_project);
              if(copyFile==""已复制文件"")
                menu->addAction(""粘贴"")->setEnabled(false);
              else
                menu->addAction(""粘贴"",this,&Widget::paste_file)->setEnabled(true);
              menu->exec(ui->treeView->mapToGlobal(pos));

    }else{
        QMenu *menu = new QMenu(ui->treeView);
        menu->addAction(""新建文件夹"",this,&Widget::new_project);
        menu->addAction(""新建文件"",this,&Widget::new_file);
        menu->addAction(""删除"",this,&Widget::delete_file);
        menu->addAction(""复制"",this,&Widget::copy_file);
        if(copyFile==""已复制文件"")
          menu->addAction(""粘贴"")->setEnabled(false);
        else
          menu->addAction(""粘贴"",this,&Widget::paste_file)->setEnabled(true);
        menu->exec(ui->treeView->mapToGlobal(pos));
    }

}

//新建文件夹
void Widget::new_project(){
    qint64 timestamp = QDateTime::currentSecsSinceEpoch();
    QString time=tr(""%1"").arg(timestamp);
    QStandardItem* myProject = new QStandardItem(QIcon(QStringLiteral("":/Icon/Image/Project.png"")),QStringLiteral(""新建文件夹"")+time);
    QStandardItemModel*   model  =   static_cast< QStandardItemModel*>( ui-> treeView-> model());
    QModelIndex   currentIndex  =   ui-> treeView-> currentIndex();
    QStandardItem*   currentItem  =   model-> itemFromIndex( currentIndex.parent() );
    currentItem->appendRow(myProject);
    currentItem->setChild(myProject->index().row(),1,new QStandardItem(QStringLiteral(""文件夹"")));
    ui->treeView->setCurrentIndex(myProject->index());
}

//新建文件
void Widget::new_file(){
    qint64 timestamp = QDateTime::currentSecsSinceEpoch();
    QString time=tr(""%1"").arg(timestamp);
    QStandardItem* myFile = new QStandardItem(QIcon(QStringLiteral("":/Icon/Image/txt.png"")),""新建文件""+time+"".txt"");
    QStandardItemModel*   model  =   static_cast< QStandardItemModel*>( ui-> treeView-> model());
    QModelIndex   currentIndex  =   ui-> treeView-> currentIndex();
    QStandardItem*   currentItem  =   model-> itemFromIndex( currentIndex );
    if(show_path()!=""文件夹""){
        currentItem  =   model-> itemFromIndex( currentIndex.parent() );
    }
    currentItem->appendRow(myFile);
    currentItem->setChild(myFile->index().row(),1,new QStandardItem(QStringLiteral(""txt文件"")));
    //ui->treeView->setExpanded(currentIndex,1);
    ui->treeView->setCurrentIndex(myFile->index());
}

//删除文件夹
void Widget::delete_project(){
    QStandardItemModel*   model  =   static_cast< QStandardItemModel*>( ui-> treeView-> model());
    QModelIndex   currentIndex  =   ui-> treeView-> currentIndex();
    QStandardItem*   currentItem  =   model-> itemFromIndex( currentIndex.parent() );
    currentItem->removeRow(currentIndex.row());
}

//删除文件
void Widget::delete_file(){
    QStandardItemModel*   model  =   static_cast< QStandardItemModel*>( ui-> treeView-> model());
    QModelIndex   currentIndex  =   ui-> treeView-> currentIndex();
    QStandardItem*   currentItem  =   model-> itemFromIndex( currentIndex.parent() );
    currentItem->removeRow(currentIndex.row());
}

//复制文件
void Widget::copy_file(){
    QModelIndex   currentIndex  =   ui-> treeView-> currentIndex();
    ui->copyName->setText( QStringLiteral(""%1"").arg(currentIndex.data().toString()));
}

//粘贴文件
void Widget::paste_file(){
    qint64 timestamp = QDateTime::currentSecsSinceEpoch();
    QString time=tr(""%1"").arg(timestamp);
    QStandardItem* myFile = new QStandardItem(QIcon(QStringLiteral("":/Icon/Image/txt.png"")),ui->copyName->text());
    QStandardItemModel*   model  =   static_cast< QStandardItemModel*>( ui-> treeView-> model());
    QModelIndex   currentIndex  =   ui-> treeView-> currentIndex();
    QStandardItem*   currentItem  =   model-> itemFromIndex( currentIndex );
    if(show_path()!=""文件夹""){
        currentItem  =   model-> itemFromIndex( currentIndex.parent() );
    }
    currentItem->appendRow(myFile);
    currentItem->setChild(myFile->index().row(),1,new QStandardItem(QStringLiteral(""txt文件"")));
    //ui->treeView->setExpanded(currentIndex,1);
    ui->copyName->setText(""已复制文件"");
    ui->treeView->setCurrentIndex(myFile->index());
}
",myDisks
487,"#include <iostream>
#include <fstream>
#include <string>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <ctime>
#include <iomanip>

using namespace std;

// Utility Functions
void printDivider() {
    cout << ""-------------------------------------------\n"";
}

string getCurrentTimestamp() {
    time_t now = time(0);
    tm* localtm = localtime(&now);
    stringstream ss;
    ss << put_time(localtm, ""%Y-%m-%d %H:%M:%S"");
    return ss.str();
}

// Function to preprocess the bad character table for Boyer-Moore algorithm
unordered_map<char, int> preprocessBadCharacterTable(const string& pattern) {
    unordered_map<char, int> badCharTable;
    int m = pattern.size();
    for (int i = 0; i < m; i++) {
        badCharTable[pattern[i]] = i;
    }
    return badCharTable;
}

// Boyer-Moore String Matching Algorithm
int boyerMooreSearch(const string& text, const string& pattern) {
    int n = text.size();
    int m = pattern.size();

    if (m > n) return -1;  // Pattern longer than text, impossible match

    unordered_map<char, int> badCharTable = preprocessBadCharacterTable(pattern);
    int shift = 0;

    while (shift <= (n - m)) {
        int j = m - 1;

        while (j >= 0 && pattern[j] == text[shift + j]) {
            j--;
        }

        if (j < 0) {
            return shift;  // Match found
        } else {
            char mismatchChar = text[shift + j];
            int badCharShift = (badCharTable.find(mismatchChar) != badCharTable.end())
                ? j - badCharTable[mismatchChar]
                : j + 1;
            shift += max(1, badCharShift);
        }
    }

    return -1;  // No match found
}

// Item Tracker Class
class ItemTracker {
private:
    vector<string> belongings; // List of items being tracked
    string environment;        // Simulated environment where the search happens

    // Function to log actions to the console
    void logAction(const string& action) const {
        cout << ""[LOG "" << getCurrentTimestamp() << ""] "" << action << endl;
    }

    // Save items to a file
    void saveToFile() const {
        ofstream file(""tracked_items.txt"");
        if (file.is_open()) {
            for (const auto& item : belongings) {
                file << item << endl;
            }
            file.close();
            logAction(""Tracked items saved to file."");
        } else {
            logAction(""Error: Unable to save items to file."");
        }
    }

    // Load items from a file
    void loadFromFile() {
        ifstream file(""tracked_items.txt"");
        if (file.is_open()) {
            belongings.clear();
            string item;
            while (getline(file, item)) {
                belongings.push_back(item);
            }
            file.close();
            logAction(""Tracked items loaded from file."");
        } else {
            logAction(""No previous data found. Starting fresh."");
        }
    }

public:
    // Constructor to initialize the environment
    ItemTracker(const string& env) : environment(env) {
        loadFromFile();
    }

    // Add an item to the list of belongings
    void addItem(const string& item) {
        if (find(belongings.begin(), belongings.end(), item) != belongings.end()) {
            logAction(""Item \"""" + item + ""\"" is already being tracked."");
            return;
        }
        belongings.push_back(item);
        logAction(""Added item: "" + item);
        saveToFile();
    }

    // Remove an item from the list of belongings
    void removeItem(const string& item) {
        auto it = find(belongings.begin(), belongings.end(), item);
        if (it != belongings.end()) {
            belongings.erase(it);
            logAction(""Removed item: "" + item);
            saveToFile();
        } else {
            logAction(""Item \"""" + item + ""\"" not found in the tracker."");
        }
    }

    // Display all items being tracked
    void displayItems() const {
        cout << ""\nItems being tracked:\n"";
        printDivider();
        if (belongings.empty()) {
            cout << ""No items are currently being tracked.\n"";
            return;
        }
        for (const auto& item : belongings) {
            cout << ""- "" << item << endl;
        }
        printDivider();
    }

    // Update the environment with new simulated data
    void updateEnvironment(const string& newEnv) {
        environment = newEnv;
        logAction(""Environment updated."");
    }

    // Search for an item in the environment
    void searchItem(const string& item) {
        cout << ""\nSearching for item: "" << item << ""...\n"";
        printDivider();
        int position = boyerMooreSearch(environment, item);
        if (position != -1) {
            cout << ""Item \"""" << item << ""\"" found at position "" << position << "" in the environment.\n"";
        } else {
            cout << ""Item \"""" << item << ""\"" not found in the environment.\n"";
        }
        printDivider();
    }

    // Simulate searching for all tracked items in the environment
    void searchAllItems() {
        cout << ""\nStarting search for all tracked items...\n"";
        printDivider();
        if (belongings.empty()) {
            cout << ""No items are currently being tracked. Add items to start tracking.\n"";
            return;
        }
        for (const auto& item : belongings) {
            searchItem(item);
        }
        printDivider();
    }

    // Display the current environment
    void displayEnvironment() const {
        cout << ""\nCurrent Environment:\n"";
        printDivider();
        cout << environment << ""\n"";
        printDivider();
    }
};

int main() {
    // Initialize the simulated environment
    string simulatedEnvironment = ""Backpack contains keys, wallet, and phone. Desk has a laptop and notebook."";
    ItemTracker tracker(simulatedEnvironment);

    int choice;
    string  [MASK] ;
    string newEnvironment;

    while (true) {
        // Menu options for the tracker system
        cout << ""\n--- Smart Tracker Menu ---\n"";
        cout << ""1. Add an item\n"";
        cout << ""2. Remove an item\n"";
        cout << ""3. Display tracked items\n"";
        cout << ""4. Search for an item\n"";
        cout << ""5. Search for all tracked items\n"";
        cout << ""6. Update the environment\n"";
        cout << ""7. Display the current environment\n"";
        cout << ""8. Exit\n"";
        cout << ""Enter your choice: "";
        cin >> choice;

        switch (choice) {
            case 1:  // Add an item
                cout << ""Enter the name of the item to add: "";
                cin.ignore();
                getline(cin,  [MASK] );
                tracker.addItem( [MASK] );
                break;
            case 2:  // Remove an item
                cout << ""Enter the name of the item to remove: "";
                cin.ignore();
                getline(cin,  [MASK] );
                tracker.removeItem( [MASK] );
                break;
            case 3:  // Display tracked items
                tracker.displayItems();
                break;
            case 4:  // Search for a specific item
                cout << ""Enter the name of the item to search: "";
                cin.ignore();
                getline(cin,  [MASK] );
                tracker.searchItem( [MASK] );
                break;
            case 5:  // Search for all items
                tracker.searchAllItems();
                break;
            case 6:  // Update the environment
                cout << ""Enter the new environment description: "";
                cin.ignore();
                getline(cin, newEnvironment);
                tracker.updateEnvironment(newEnvironment);
                break;
            case 7:  // Display the current environment
                tracker.displayEnvironment();
                break;
            case 8:  // Exit
                cout << ""Exiting Smart Tracker. Goodbye!\n"";
                return 0;
            default:
                cout << ""Invalid choice. Please try again.\n"";
        }
    }
}
",inputItem
488,"#include ""ButtonTest.h""

volatile bool bt_ButtonHit;

void bt_ButtonInterrupt() {
  bt_ButtonHit = true;
}

void ButtonTest::begin(Adafruit_RGBLCDShield _lcd) {
  this->lcd = _lcd;
  bt_ButtonHit = false;
}

void ButtonTest::RunTest() {
  int Button_Wait = 10000;
  long timer = 0;
  uint8_t  [MASK]  = 0;

  digitalWrite(LED_START, HIGH);
  digitalWrite(LED_SELECT, HIGH);
  
  lcd.clear();
  lcd.home();
  lcd.print(""Test all buttons"");
  delay(2000);  

  lcd.home();
  lcd.print(""Press lit button"");
  lcd.setCursor(0, 1);
  lcd.print(""Select to skip  "");
  delay(1000);

  /////////////////////////////////////////
  // Test Interrupts
  /////////////////////////////////////////
  for (int b = 0; b < NumTargets; b++) {
    attachInterrupt(digitalPinToInterrupt(INT_PIN1), bt_ButtonInterrupt, FALLING);
    attachInterrupt(digitalPinToInterrupt(INT_PIN2), bt_ButtonInterrupt, FALLING);
    delay(100);
     [MASK]  = 0;
    lcd.setCursor(0, 1);
    lcd.print(""Enable Button "");
    lcd.print(Targets[b].LedEnable);
    lcd.print(""  "");
    timer = millis();
    digitalWrite(Targets[b].LedEnable, LOW);
    digitalWrite(Targets[b].SwitchEnable, LOW);
    bt_ButtonHit = false;
    while ((bt_ButtonHit == false) 
            && ((millis() - timer) < Button_Wait)
            && !(( [MASK]  = lcd.readButtons()) & BUTTON_SELECT)) {
      delay(5);
    }
    detachInterrupt(digitalPinToInterrupt(INT_PIN1));
    detachInterrupt(digitalPinToInterrupt(INT_PIN2));
    delay(50);
    lcd.setCursor(0, 1);
    if ( [MASK]  & BUTTON_SELECT) {
      lcd.print(""Skipped         "");
      delay(1000);
    }
    else if (bt_ButtonHit) {
      lcd.print(""Button hit!    "");
      lcd.write(SMILEY);
      delay(1000);
    }
    else {
      lcd.print(""No button hit  "");
      lcd.write(FROWNIE);
      delay(1000);
    }
    bt_ButtonHit = false;
    delay(DEBOUNCE);
    digitalWrite(Targets[b].LedEnable, HIGH);    
    digitalWrite(Targets[b].SwitchEnable, HIGH);    
  }

  /////////////////////////////////////////
  // Test Random Input
  /////////////////////////////////////////
  lcd.clear();
  lcd.home();
  lcd.print(s_AnyKey);
  for (int b = 0; b < NumTargets; b++) {
    digitalWrite(Targets[b].SwitchEnable, LOW);
  }
  
  while (!(( [MASK]  = lcd.readButtons()) & BUTTON_SELECT)) {
    lcd.setCursor(0, 1);
     [MASK]  = ReadAllButtons();
    for (int t = 0; t < NumTargets; t++) {
      if (bitRead( [MASK] , t))
        lcd.print(t+1);
      else
        lcd.print("" "");
    }
    lcd.print("" "");
    lcd.print(LcdButtons(lcd));
    delay(5);
  }
  lcd.setCursor(0, 1);
  lcd.print(""Done.           "");
  delay(1000);

  for (int b = 0; b < NumTargets; b++) {
    digitalWrite(Targets[b].SwitchEnable, HIGH);
  }

  digitalWrite(LED_START, LOW);
  digitalWrite(LED_SELECT, LOW);
}



",btns
489,"#include ""Graph.h""
#include ""Line.h""
#include <cmath>
#include ""Global.h""

namespace ui {

	Graph::Graph(const std::string& id)
		: UIObject(id)
		, m_pos(0, 0)
		, m_size(100, 100)
		, m_backColor(sf::Color::White)
		, m_axisColor({ 10, 10, 10 })
		, m_axisWidth(2)
		, m_gridWidth(1)
	{

	}

	void Graph::SetPosition(const ui::Vec2f& pos)
	{
		m_pos = pos;
	}

	void Graph::SetSize(const ui::Vec2f& size)
	{
		m_size = size;
	}

	void Graph::SetRange(const ui::Vec2f& xRange, const ui::Vec2f& yRange)
	{
		m_xRange = xRange;
		m_yRange = yRange;
	}

	void Graph::SetXRange(const ui::Vec2f& range)
	{
		m_xRange = range;
	}

	void Graph::SetYRange(const ui::Vec2f& range)
	{
		m_yRange = range;
	}

	void Graph::SetBackgrowndColor(const sf::Color& color)
	{
		m_backColor = color;
	}

	void Graph::SetAxisColor(const sf::Color& color)
	{
		m_axisColor = color;
	}

	void Graph::SetAxisWidth(const float& width)
	{
		m_axisWidth = width;
	}

	ui::Vec2f Graph::MapPosToCoords(const ui::Vec2f& pos)
	{
		return ui::Vec2f
		(
			map(pos.x, m_xRange.min, m_xRange.max, 0, m_size.x),
			map(pos.y, m_yRange.min, m_yRange.max, m_size.y, 0)
		) + m_pos;
	}

	ui::Vec2f Graph::MapCoordsToPos(const ui::Vec2f& coords)
	{
		return
		{
			map(coords.x - m_pos.x, 0, m_size.x, m_xRange.min, m_xRange.max),
			map(coords.y - m_pos.y, m_size.y, 0, m_yRange.min, m_yRange.max)
		};
	}

	void Graph::ClearAll()
	{
		m_plots.clear();
		m_arrows.clear();
	}

	void Graph::ClearArrows()
	{
		m_arrows.clear();
	}

	void Graph::ClearPlots()
	{
		m_plots.clear();
	}

	void Graph::Scatter(const std::vector<ui::Vec2f>& data, const ScatterDef& props)
	{
		m_scatters.push_back({ data, props });
	}

	void Graph::Plot(const std::vector<ui::Vec2f>& data, const PlotDef& props)
	{
		m_plots.push_back({ data, props });
	}

	void Graph::Arrow(const ui::Vec2f& pos, const ui::Vec2f& size, const ArrowDef& props)
	{
		m_arrows.push_back({ { pos, size }, props });
	}

	void Graph::Fit(const float& margin)
	{
		ui::Vec2f xRange = { INFINITY, -INFINITY };
		ui::Vec2f yRange = { INFINITY, -INFINITY };

		for (auto& [scatter, prop] : m_scatters)
		{
			for (const ui::Vec2f& p : scatter)
			{
				xRange.min = std::min(xRange.min, p.x);
				xRange.max = std::max(xRange.max, p.x);

				yRange.min = std::min(yRange.min, p.y);
				yRange.max = std::max(yRange.max, p.y);
			}
		}

		for (auto& [plot, prop] : m_plots)
		{
			for (const ui::Vec2f& p : plot)
			{
				xRange.min = std::min(xRange.min, p.x);
				xRange.max = std::max(xRange.max, p.x);

				yRange.min = std::min(yRange.min, p.y);
				yRange.max = std::max(yRange.max, p.y);
			}
		}

		for (auto& [arrow, prop] : m_arrows)
		{
			auto& [p, size] = arrow;

			xRange.min = std::min(xRange.min, p.x);
			xRange.max = std::max(xRange.max, p.x);

			yRange.min = std::min(yRange.min, p.y);
			yRange.max = std::max(yRange.max, p.y);
		}

		float xMargin = (xRange.max - xRange.min) * margin;
		float yMargin = (yRange.max - yRange.min) * margin;

		xRange.min -= xMargin;
		xRange.max += xMargin;

		yRange.min -= yMargin;
		yRange.max += yMargin;

		SetRange(xRange, yRange);
	}

	ui::Vec2f Graph::CalculateAxisStep()
	{
		ui::Vec2f n(1, 1);
		ui::Vec2f e(1, 1);
		float xDelta = n.x * powf(10.f, e.x);
		float yDelta = n.y * powf(10.f, e.y);
		while (true)
		{
			if (MapPosToCoords({ xDelta, 0 }).x - MapPosToCoords({ 0, 0 }).x < 100)
			{
				switch ((int)n.x)
				{
				case 1:
					n.x = 2;
					break;
				case 2:
					n.x = 5;
					break;
				case 5:
					n.x = 1;
					e.x += 1;
				}

				xDelta = n.x * powf(10, e.x);
			}
			else if (MapPosToCoords({ xDelta, 0 }).x - MapPosToCoords({ 0, 0 }).x > 500)
			{
				switch ((int)n.x)
				{
				case 1:
					n.x = 5;
					e.x -= 1;
					break;
				case 2:
					n.x = 1;
					break;
				case 5:
					n.x = 2;
				}

				xDelta = n.x * powf(10, e.x);
			}
			else
				break;
		}
		while (true)
		{
			if (MapPosToCoords({ 0, yDelta }).y - MapPosToCoords({ 0, 0 }).y > -100)
			{
				switch ((int)n.y)
				{
				case 1:
					n.y = 2;
					break;
				case 2:
					n.y = 5;
					break;
				case 5:
					n.y = 1;
					e.y += 1;
				}

				yDelta = n.y * powf(10, e.y);
			}
			else if (MapPosToCoords({ 0, yDelta }).y - MapPosToCoords({ 0, 0 }).y < -500)
			{
				switch ((int)n.y)
				{
				case 1:
					n.y = 5;
					e.y -= 1;
					break;
				case 2:
					n.y = 1;
					break;
				case 5:
					n.y = 2;
				}

				yDelta = n.y * powf(10, e.y);
			}
			else
				break;
		}

		return { xDelta, yDelta };
	}

	void Graph::Draw(sf::RenderWindow& window)
	{
		sf::RectangleShape back;
		back.setSize(m_size);
		back.setPosition(m_pos);
		back.setFillColor(m_backColor);
		window.draw(back);

		// Calculate steps
		ui::Vec2f delta = CalculateAxisStep();

		// Draw grid
		for (float x = snap(m_xRange.min, delta.x); x < m_xRange.max; x += delta.x)
		{
			ui::Vec2f p0 = MapPosToCoords({ x, m_yRange.min });
			ui::Vec2f p1 = MapPosToCoords({ x, m_yRange.max });

			ui::Line h(""h"", p0, p1);
			h.SetColor({ 150, 150, 150 });
			h.SetWidth(m_gridWidth);

			h.Draw(window);
		}
		for (float y = snap(m_yRange.min, delta.y); y < m_yRange.max; y += delta.y)
		{
			ui::Vec2f p0 = MapPosToCoords({ m_xRange.min, y });
			ui::Vec2f p1 = MapPosToCoords({ m_xRange.max, y });

			ui::Line v(""v"", p0, p1);
			v.SetColor({ 150, 150, 150 });
			v.SetWidth(m_gridWidth);

			v.Draw(window);
		}

		// X axis
		ui::Vec2f  [MASK]  = MapPosToCoords({ m_xRange.min, 0 });
		ui::Vec2f axisX2 = MapPosToCoords({ m_xRange.max, 0 });

		ui::Line x(""x"",  [MASK] , axisX2);
		x.SetColor(m_axisColor);
		x.SetWidth(m_axisWidth);
		x.Draw(window);

		// Y axis
		ui::Vec2f axisY1 = MapPosToCoords({ 0, m_yRange.min });
		ui::Vec2f axisY2 = MapPosToCoords({ 0, m_yRange.max });

		ui::Line y(""y"", axisY1, axisY2);
		y.SetColor(m_axisColor);
		y.SetWidth(m_axisWidth);
		y.Draw(window);

		// Draw scatters
		for (auto& [scatter, prop] : m_scatters)
		{
			//ui::Vec2f prevPos = MapPosToCoords(scatter[0]);
			for (int i = 0; i < scatter.size(); i++)
			{
				//ui::Vec2f newPos = MapPosToCoords(scatter[i]);
				//ui::Vec2f delta = newPos - prevPos;
				ui::Vec2f pos = scatter[i];

				//if (delta.Length() > 100)
				if (!(pos.x < m_xRange.min || pos.x > m_xRange.max || pos.y < m_yRange.min || pos.y > m_yRange.max))
				{
					sf::CircleShape shape;
					shape.setRadius(prop.radius);
					shape.setOrigin(prop.radius, prop.radius);
					shape.setPosition(pos);
					shape.setFillColor(prop.color);

					window.draw(shape);

					//prevPos = newPos;
				}
			}
		}

		// Draw plots
		for (auto&[plot, prop] : m_plots)
		{
			ui::Vec2f prevPos = MapPosToCoords(plot[0]);
			for (uint i = 1; i < plot.size(); i++)
			{
				ui::Vec2f newPos = MapPosToCoords(plot[i]);

				ui::Vec2f delta = newPos - prevPos;

				if (delta.Length() > 5.f || prop.optimize)
				{
					if (!((prevPos.x - m_pos.x < 0 || prevPos.x - m_pos.x > m_size.x || prevPos.y - m_pos.y < 0 || prevPos.y - m_pos.y > m_size.y) &&
						  (newPos.x - m_pos.x < 0 || newPos.x - m_pos.x > m_size.x || newPos.y - m_pos.y < 0 || newPos.y - m_pos.y > m_size.y)))
					{
						ui::Line l(""l"", prevPos, newPos);
						l.SetWidth(prop.width);
						l.SetColor(prop.color);

						l.Draw(window);
					}

					prevPos = newPos;
				}
			}

			if (prop.cyclic)
			{
				ui::Line l(""l"", prevPos, MapPosToCoords(plot[0]));
				l.SetWidth(prop.width);
				l.SetColor(prop.color);

				l.Draw(window);
			}
		}

		// Draw arrows
		for (auto&[arrow, prop] : m_arrows)
		{
			auto& [pos, size] = arrow;

			ui::Vec2f iPos = MapPosToCoords(pos);
			ui::Vec2f fPos = MapPosToCoords(pos + size);

			ui::Line l(""l"", iPos, fPos);
			l.SetWidth(prop.width);
			l.SetColor(prop.color);

			l.Draw(window);
		}
	}


	Graph::~Graph()
	{

	}

}",axisX1
490,"/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2008-12 Stanford University and the Authors.        *
 * Authors: <NAME>                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * 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 ""SimTKcommon/Scalar.h""

#include ""SimTKcommon/internal/MatrixCharacteristics.h""

#include <iostream>

namespace SimTK {


//  ------------------------------ MatrixStructure -----------------------------
const char* 
MatrixStructure::name(Structure structure) {
    switch (structure) {
      case NoStructure:        return ""No Structure"";
      case Matrix1d:           return ""Matrix1d"";
      case Zero:               return ""Zero"";
      case Identity:           return ""Identity"";
      case Permutation:        return ""Permutation"";
      case RepeatedDiagonal:   return ""RepeatedDiagonal"";
      case Diagonal:           return ""Diagonal"";
      case BiDiagonal:         return ""BiDiagonal"";
      case TriDiagonal:        return ""TriDiagonal"";
      case BandedSymmetric:    return ""BandedSymmetric"";
      case BandedHermitian:    return ""BandedHermitian"";
      case Banded:             return ""Banded"";
      case Triangular:         return ""Triangular"";
      case QuasiTriangular:    return ""QuasiTriangular"";
      case Hessenberg:         return ""Hessenberg"";
      case Symmetric:          return ""Symmetric"";
      case Hermitian:          return ""Hermitian"";
      case SkewSymmetric:      return ""SkewSymmetric"";
      case SkewHermitian:      return ""SkewHermitian"";
      case Full:               return ""Full"";
      default: return ""INVALID MatrixStructure::Structure"";
    };
}

const char*
MatrixStructure::name(Position position) {
    switch (position) {
      case NoPosition:  return ""No Position"";
      case Upper:       return ""Upper"";
      case Lower:       return ""Lower"";
      default: return ""INVALID MatrixStructure::Position"";
    };
}

const char*
MatrixStructure::name(DiagValue  [MASK] ) {
    switch ( [MASK] ) {
      case NoDiagValue: return ""No DiagValue"";
      case StoredDiag:  return ""StoredDiag"";
      case ZeroDiag:    return ""ZeroDiag"";
      case UnitDiag:    return ""UnitDiag"";
      default: return ""INVALID MatrixStructure::DiagValue"";
    };
}

MatrixStructure::Mask
MatrixStructure::mask() const {
    return Mask(calcStructureMask(getStructure()),
                calcPositionMask(getStructure()),
                calcDiagValueMask(getStructure()));
}

MatrixStructure::StructureMask
MatrixStructure::calcStructureMask(Structure structure) {
    switch (structure) {
      case NoStructure:        return UncommittedStructure;
      case Matrix1d:           return Matrix1d;
      case Zero:               return Zero;
      case Identity:           return Identity;
      case Permutation:        return Permutation | calcStructureMask(Identity);
      case RepeatedDiagonal:   return RepeatedDiagonal | calcStructureMask(Identity)
                                                       | calcStructureMask(Zero);
      case Diagonal:           return Diagonal    | calcStructureMask(RepeatedDiagonal);
      case BiDiagonal:         return BiDiagonal  | calcStructureMask(Diagonal);
      case TriDiagonal:        return TriDiagonal | calcStructureMask(BiDiagonal);
      case BandedSymmetric:    return BandedSymmetric | calcStructureMask(Diagonal);
      case BandedHermitian:    return BandedHermitian | calcStructureMask(Diagonal);
      case Banded:             return Banded | calcStructureMask(BandedHermitian)
                                             | calcStructureMask(BandedSymmetric)
                                             | calcStructureMask(TriDiagonal);
      case Triangular:         return Triangular      | calcStructureMask(BiDiagonal);
      case QuasiTriangular:    return QuasiTriangular | calcStructureMask(Triangular);
      case Hessenberg:         return Hessenberg | calcStructureMask(QuasiTriangular)
                                                 | calcStructureMask(TriDiagonal);
      case Symmetric:          return Symmetric | calcStructureMask(BandedSymmetric);
      case Hermitian:          return Hermitian | calcStructureMask(BandedHermitian);
      case SkewSymmetric:      return SkewSymmetric;
      case SkewHermitian:      return SkewHermitian;
      case Full:               return Full | calcStructureMask(Hermitian) | calcStructureMask(SkewHermitian)
                                           | calcStructureMask(Symmetric) | calcStructureMask(SkewSymmetric)
                                           | calcStructureMask(Hessenberg) 
                                           | calcStructureMask(Banded)
                                           | calcStructureMask(Permutation)
                                           | calcStructureMask(Matrix1d);

      default: SimTK_ASSERT1_ALWAYS(!""invalid MatrixStructure::Structure"",
                   ""MatrixStructure::mask(): value 0x%x is invalid."", (unsigned)structure);
               return NoStructure;
    };
}

MatrixStructure::PositionMask
MatrixStructure::calcPositionMask(Structure structure) {
    switch (structure) {
      case BiDiagonal:
      case Triangular:
      case QuasiTriangular:
      case Hessenberg:
        return AnyPosition; // i.e., upper or lower
      default:
        return NoPosition;
    };
}

MatrixStructure::DiagValueMask
MatrixStructure::calcDiagValueMask(Structure structure) {
    switch (structure) {
      case Triangular:
      case Symmetric:
      case Hermitian:
        return AnyDiagValue;

      default:
        return StoredDiag;
    };
}


// ------------------------------ MatrixStorage --------------------------------
const char*
MatrixStorage::name(Packing p) {
    switch (p) {
      case NoPacking: return ""No Packing"";
      case Full:      return ""Full"";
      case TriInFull: return ""TriInFull"";
      case TriPacked: return ""TriPacked"";
      case Banded:    return ""Banded"";
      case Vector:    return ""Vector"";
      case Scalar:    return ""Scalar"";
      case Permutation: return ""Permutation"";
      default: return ""INVALID Packing"";
    };
}
const char*
MatrixStorage::name(Placement p) {
    switch (p) {
      case NoPlacement: return ""No Placement"";
      case Lower:       return ""Lower"";
      case Upper:       return ""Upper"";
      default: return ""INVALID Placement"";
    };
}
const char*
MatrixStorage::name(Order o) {
    switch (o) {
      case NoOrder:     return ""No Order"";
      case ColumnOrder: return ""ColumnOrder"";
      case RowOrder:    return ""RowOrder"";
      default: return ""INVALID Order"";
    };
}
const char*
MatrixStorage::name(Diagonal d) {
    switch (d) {
      case NoDiag:      return ""No Diag"";
      case StoredDiag:  return ""StoredDiag"";
      case AssumedDiag: return ""AssumedDiag"";
      default: return ""INVALID Diagonal"";
    };
}

MatrixStorage 
MatrixStorage::calcDefaultStorage(const MatrixStructure& structure,
                                  const MatrixOutline&   outline) 
{
    // Just to be nice we'll default to Lower storage for lower-triangular
    // matrices and Upper storage for upper-triangular ones. (There is no
    // real necessity to do that, it's just more pleasant.)
    Placement placement = Lower;
    if (structure.getPosition()==MatrixStructure::Upper) placement = Upper;

    // Default order is Lapack-standard column order except for rows.
    // TODO: probably should use row order for ""Wide"" outlines too, but need
    // to check if that will limit us too much with Lapack.
    MatrixStorage::Order order = ColumnOrder;
    if (outline.getOutline()==MatrixOutline::Row) 
        order = RowOrder;

    Diagonal diagonal = StoredDiag;
    if (structure.getDiagValue() && structure.getDiagValue()!=MatrixStructure::StoredDiag)
        diagonal = AssumedDiag;

    switch (structure.getStructure()) {
      case MatrixStructure::NoStructure:        return MatrixStorage();
      case MatrixStructure::Matrix1d:           return MatrixStorage(Vector, NoPlacement, order, NoDiag);
      case MatrixStructure::Zero:               return MatrixStorage(Scalar); // don't specify anything else
      case MatrixStructure::Identity:           return MatrixStorage(Scalar);
      case MatrixStructure::Permutation:        return MatrixStorage(Permutation);
      case MatrixStructure::RepeatedDiagonal:   return MatrixStorage(Scalar);
      case MatrixStructure::Diagonal:           return MatrixStorage(Vector);
      case MatrixStructure::BiDiagonal:         return MatrixStorage(Banded);
      case MatrixStructure::TriDiagonal:        return MatrixStorage(Banded);
      case MatrixStructure::BandedSymmetric:    return MatrixStorage(Banded, placement);
      case MatrixStructure::BandedHermitian:    return MatrixStorage(Banded, placement);
      case MatrixStructure::Banded:             return MatrixStorage(Banded);
      case MatrixStructure::Triangular:         return MatrixStorage(TriInFull, placement, order, diagonal);
      case MatrixStructure::QuasiTriangular:    return MatrixStorage(Full, NoPlacement, order, NoDiag);
      case MatrixStructure::Hessenberg:         return MatrixStorage(Full, NoPlacement, order, NoDiag);
      case MatrixStructure::Symmetric:          return MatrixStorage(TriInFull, placement, order, diagonal);
      case MatrixStructure::Hermitian:          return MatrixStorage(TriInFull, placement, order, diagonal);
      case MatrixStructure::SkewSymmetric:      return MatrixStorage(TriInFull, placement, order, diagonal);
      case MatrixStructure::SkewHermitian:      return MatrixStorage(TriInFull, placement, order, diagonal);
      case MatrixStructure::Full:               return MatrixStorage(Full, NoPlacement, order, NoDiag);
      default: SimTK_ASSERT1_ALWAYS(!""invalid MatrixStructure::Structure"",
                   ""MatrixStorage::getDefaultStorage(): value 0x%x is invalid."", structure.getStructure());
               return MatrixStorage();
    };
}


// ------------------------------- MatrixOutline -------------------------------
const char* 
MatrixOutline::name(Outline a) {
    switch(a) {
      case NoOutline:   return ""No Outline"";
      case Scalar:      return ""Scalar"";
      case Column:      return ""Column"";
      case Row:         return ""Row"";
      case Square:      return ""Square"";
      case Wide:        return ""Wide"";
      case Tall:        return ""Tall"";
      case Rectangular: return ""Rectangular"";
      default:          return ""INVALID MatrixOutline::Outline"";
    };
}


MatrixOutline::OutlineMask 
MatrixOutline::calcMask(Outline outline) {
    switch(outline) {
      case NoOutline:   return UncommittedOutline;
      case Scalar:      return Scalar;
      case Column:      return Column       | calcMask(Scalar);
      case Row:         return Row          | calcMask(Scalar);
      case Square:      return Square       | calcMask(Scalar);
      case Wide:        return Wide         | calcMask(Square)  | calcMask(Row);
      case Tall:        return Tall         | calcMask(Square)  | calcMask(Column);
      case Rectangular: return Rectangular  | calcMask(Wide)    | calcMask(Tall);
      default: SimTK_ASSERT1_ALWAYS(!""invalid MatrixOutline::Outline"",
                   ""MatrixOutline::calcMask(): value 0x%x is invalid."", outline);
          return NoOutline;
    };
}

bool 
MatrixOutline::isSizeOK(int m, int n) const {
    SimTK_ASSERT2(m>=0 && n>=0,
        ""MatrixOutline::isSizeOK(): sizes must be non-negative; got %dx%d"", m, n);
    switch(getOutline()) {
      case Scalar:      return m==1 && n==1;
      case Column:      return n==1;
      case Row:         return m==1;
      case Square:      return m==n;
      case Wide:        return m<=n;
      case Tall:        return m>=n;
      case Rectangular: return true;
      default: SimTK_ASSERT1_ALWAYS(!""invalid MatrixOutline::Outline"",
                   ""MatrixOutline::isSizeOK(): value 0x%x is invalid."", getOutline());
               return false;
    };
}

void 
MatrixOutline::getMinimumSize(int& m, int& n) const {
         if (outline==Scalar) m=n=1;
    else if (outline==Column) m=0, n=1;
    else if (outline==Row)    m=1, n=0;
    else                      m=n=0;
}

MatrixOutline
MatrixOutline::calcFromSize(int m, int n) {
    Outline outline;

         if (m==1) outline = n==1 ? Scalar : Row;
    else if (n==1) outline = Column; // m!=1
    else if (m==n) outline = Square;
    else if (m<n)  outline = Wide;
    else           outline = Tall;

    return MatrixOutline(outline);
}


// ----------------------------- MatrixCondition -------------------------------
const char* 
MatrixCondition::name(Condition c) {
    switch(c) {
      case UnknownCondition:    return ""UnknownCondition"";
      case Orthogonal:          return ""Orthogonal"";
      case PositiveDefinite:    return ""PositiveDefinite"";
      case WellConditioned:     return ""WellConditioned"";
      case FullRank:            return ""FullRank"";
      case Singular:            return ""Singular"";
      default: return ""INVALID MatrixCondition::Condition"";
    };
}

MatrixCondition::ConditionMask 
MatrixCondition::calcMask(Condition c) {
    switch(c) {
      case UnknownCondition:    return UncommittedCondition;
      case Orthogonal:          return Orthogonal;
      case PositiveDefinite:    return PositiveDefinite;
      case WellConditioned:     return WellConditioned
                                       | calcMask(PositiveDefinite)
                                       | calcMask(Orthogonal);
      case FullRank:            return FullRank
                                       | calcMask(WellConditioned);
      case Singular:            return UncommittedCondition; // can't get worse than this
      default: SimTK_ASSERT1_ALWAYS(!""invalid MatrixCondition::Condition"",
                   ""MatrixCondition::calcMask(Condition): value 0x%x is invalid."", c);
          return UnknownCondition;
    };
}

const char* 
MatrixCondition::name(Diagonal d) {
    switch(d) {
      case UnknownDiagonal:     return ""UnknownDiagonal"";
      case ZeroDiagonal:        return ""ZeroDiagonal"";
      case OneDiagonal:         return ""OneDiagonal"";
      case RealDiagonal:        return ""RealDiagonal"";
      case ImaginaryDiagonal:   return ""ImaginaryDiagonal"";
      default: return ""INVALID MatrixCondition::Diagonal"";
    };
}

MatrixCondition::DiagonalMask 
MatrixCondition::calcMask(Diagonal d) {
    switch(d) {
      case UnknownDiagonal:     return UncommittedDiagonal;
      case ZeroDiagonal:        return ZeroDiagonal;
      case OneDiagonal:         return OneDiagonal;
      case RealDiagonal:        return RealDiagonal
                                       | calcMask(ZeroDiagonal)
                                       | calcMask(OneDiagonal);
      case ImaginaryDiagonal:   return ImaginaryDiagonal
                                       | calcMask(ZeroDiagonal);
      default: SimTK_ASSERT1_ALWAYS(!""invalid MatrixCondition::Diagonal"",
                   ""MatrixCondition::calcMask(Diagonal): value 0x%x is invalid."", d);
          return UnknownDiagonal;
    };
}


// ----------------------------- MatrixCharacter -------------------------------
std::ostream& operator<<(std::ostream& o, const MatrixCharacter& actual) {
    o << ""MatrixCharacter:"";
    o << ""\n  size="" << actual.nrow() << ""x"" << actual.ncol();
    o << ""\n  structure="" << actual.getStructure().name();
    o << ""\n  outline="" << actual.getOutline().name();
    o << ""\n  storage="" << actual.getStorage().name();
    o << ""\n  condition="" << actual.getCondition().name();
    return o << std::endl;
}


// ----------------------------- MatrixCommitment ------------------------------
MatrixCharacter
MatrixCommitment::calcDefaultCharacter(int m, int n) const {
    MatrixCharacter actual; // nothing specified yet

    // Work on the size first.
    int nr, nc;
    outline.getMinimumSize(nr, nc);

    nr = std::max(nr, getDefaultNumRows());
    nc = std::max(nc, getDefaultNumCols());

    nr = std::max(nr, m);
    nc = std::max(nc, n);

    actual.setActualSize(nr,nc);  // calculate outline also

    SimTK_ERRCHK3(isOutlineOK(actual.getOutline()) && isSizeOK(actual.getSize()),
        ""MatrixCommitment::calcDefaultCharacter()"",
        ""Outline commitment %s and required initial size %d x %d were inconsistent."",
        outline.name().c_str(), nr, nc);

    // Size and outline are now set in actual.

    if (isStructureCommitted()) 
        actual.setStructure(structure);
    else {
        switch (getOutlineCommitment().getOutline()) {
          case MatrixOutline::Scalar: 
            actual.setStructure(MatrixStructure::RepeatedDiagonal);
            break;
          case MatrixOutline::Column:
          case MatrixOutline::Row:
            actual.setStructure(MatrixStructure::Matrix1d);
            break;
          default:
            actual.setStructure(MatrixStructure::Full);
        };
    }
    actual.updStructure().setMissingAttributes();
    const MatrixStructure& astruct = actual.getStructure();
    const MatrixOutline&   aoutline = actual.getOutline();

    // Size, outline, and structure are now set in actual.

    if (isStorageCommitted()) 
        actual.setStorage(storage);
    else {
        // Default storage format depends on structure type and outline.
        actual.setStorage(MatrixStorage::calcDefaultStorage(astruct, aoutline));
    }
    actual.updStorage().setMissingAttributes();

    // We don't expect condition to be set as a commitment usually.
    if (isConditionCommitted()) actual.setCondition(condition);
    else actual.setCondition(MatrixCondition());

    return actual;
}


std::ostream& operator<<(std::ostream& o, const MatrixCommitment& commit) {
    const MatrixCharacter::Mask::SizeMask Uncommitted = MatrixCharacter::Mask::SizeUncommitted;
    o << ""MatrixCommitment:"";
    o << ""\n  size="";
    if (commit.getNumRowsMask()==Uncommitted) o << ""Any"";
    else o << commit.getNumRowsMask();
    o << "" x "";
    if (commit.getNumColsMask()==Uncommitted) o << ""Any"";
    else o << commit.getNumColsMask();
    o << ""\n  structure="" << commit.getStructureCommitment().name();
    o << ""\n  outline=""   << commit.getOutlineCommitment().name();
    o << ""\n  storage=""   << commit.getStorageCommitment().name();
    o << ""\n  condition="" << commit.getConditionCommitment().name();
    return o << std::endl;
}


} // namespace SimTK   
",diagValue
491,"#pragma once

#include ""Utils.h""
#include <SFML/Graphics.hpp>
#include ""../../../library/src/header/LoadImage.h""
#include ""player/MainCharacter.h""
#include ""game/GameMap.h""

using namespace sf;

class App
{

#define WindowX 800
#define WindowY 500

public:
    App()
    {
        mLoadImage = new LoadImage();
        currentScreen = splash;
        lvlUnlocked = 1;
        mCharacter = mLoadImage->loadSpriteFromTexture(""c00a_01idle_00"", png);
        mMainCharacter = new MainCharacter;
        mGameMap = new GameMap;
        mNewGameLvl = false;
    }

    ~App()
    {

    }

public:
    screen getCurrentScreen()
    {
        return currentScreen;
    }

    void setCurrentScreen(screen screenChose)
    {
        currentScreen = screenChose;
        if (screenChose == game)
        {
            mNewGameLvl = true;
            mMainCharacter->reset(mLvlSelected);
        }
    }

    int getCharacterLives()
    {
        return lives;
    }

    void decreaseLives()
    {
        if (lives > 0)
        {
            lives--;
        }
    }

    void increaseLives()
    {
        lives++;
    }

    void resetLives()
    {
        lives = 3;
    }

    int getLevelsUnlocked()
    {
        return lvlUnlocked;
    }

    void increaseLevelsUnlocked()
    {
        if (lvlUnlocked < 4)
        {
            lvlUnlocked++;
        }
    }

    bool isNewGame()
    {
        bool isNewGame = mNewGameLvl;
        if (mNewGameLvl)
        {
            mNewGameLvl = false;
        }
        return isNewGame;
    }

    int getGameOffsetY()
    {
        return mMainCharacter->getGameOffsetY();
    }

    void setLvl(int mLvl)
    {
        this->mLvlSelected = mLvl;
    }

    int getLvlSelected()
    {
        return mLvlSelected;
    }

    Event getEvent()
    {
        return event;
    }

    void setEvent(Event  [MASK] )
    {
        event =  [MASK] ;
    }

    Sprite getCharacterSprite()
    {
        return mCharacter;
    }

    Sprite getBullet1Sprite()
    {
        return mLoadImage->loadSpriteFromTexture(""bullet1"", png);
    }

    Sprite getBullet2Sprite()
    {
        return mLoadImage->loadSpriteFromTexture(""bullet2"", png);
    }

    MainCharacter *getMainCharacter()
    {
        return mMainCharacter;
    }

    GameMap *getGameMap()
    {
        return mGameMap;
    }

    LoadImage *getImageLoader()
    {
        return mLoadImage;
    }

private:
    screen currentScreen;
    Event event;
    int lvlUnlocked;
    Sprite mCharacter;
    MainCharacter *mMainCharacter;
    GameMap *mGameMap;
    LoadImage *mLoadImage;
    int mLvlSelected;
    int mCharacterLives;
    bool mNewGameLvl;
    int lives;

};",eventN
492,"#pragma once

#include <async/completes_synchronously.hpp>
#include <async/completion_tags.hpp>
#include <async/compose.hpp>
#include <async/concepts.hpp>
#include <async/debug.hpp>
#include <async/env.hpp>
#include <async/schedulers/get_expiration.hpp>
#include <async/schedulers/timer_manager_interface.hpp>
#include <async/type_traits.hpp>

#include <stdx/concepts.hpp>
#include <stdx/ct_string.hpp>
#include <stdx/functional.hpp>

#include <boost/mp11/algorithm.hpp>

#include <algorithm>
#include <concepts>
#include <optional>
#include <type_traits>
#include <utility>
#include <variant>

namespace async {
namespace _periodic {
template <typename Ops> struct first_expiration_provider {
    using time_point_t = typename Ops::time_point_t;
    Ops *ops;

    template <typename Hal>
    [[nodiscard]] auto compute_expiration() const -> time_point_t {
        ops->tp = Hal::now() + ops->d;
        return ops->tp;
    }
};

template <typename Ops> struct unsafe_nth_expiration_provider {
    using time_point_t = typename Ops::time_point_t;
    Ops *ops;

    template <typename Hal>
    [[nodiscard]] auto compute_expiration() const -> time_point_t {
        ops->tp += ops->d;
        return ops->tp;
    }
};

template <typename Ops> struct safe_immediate_nth_expiration_provider {
    using time_point_t = typename Ops::time_point_t;
    Ops *ops;

    template <typename Hal>
    [[nodiscard]] auto compute_expiration() const -> time_point_t {
        ops->tp += ops->d;
        ops->tp = std::max(ops->tp, Hal::now());
        return ops->tp;
    }
};

template <typename Ops> struct safe_quantized_nth_expiration_provider {
    using time_point_t = typename Ops::time_point_t;
    Ops *ops;

    template <typename Hal>
    [[nodiscard]] auto compute_expiration() const -> time_point_t {
        ops->tp += ops->d;
        if (auto now = Hal::now(); ops->tp < now) {
            auto diff = --(now - ops->tp);
            auto num_ticks = (diff / ops->d) + 1;
            ops->tp += ops->d * num_ticks;
        }
        return ops->tp;
    }
};

template <typename Ops, template <typename> typename Expiry> struct receiver {
    using is_receiver = void;

    Ops *ops;

    template <typename... Args>
    auto set_value(Args &&...args) const && -> void {
        ops->repeat(std::forward<Args>(args)...);
    }
    template <typename... Args>
    auto set_error(Args &&...args) const && -> void {
        ops->template passthrough<set_error_t>(std::forward<Args>(args)...);
    }
    auto set_stopped() const && -> void {
        ops->template passthrough<set_stopped_t>();
    }

    [[nodiscard]] constexpr auto query(get_env_t) const
        -> overriding_env<timer_mgr::get_expiration_t, Expiry<Ops>,
                          typename Ops::downstream_receiver_t> {
        return override_env_with<timer_mgr::get_expiration_t>(
            Expiry<Ops>{this->ops}, this->ops->get_receiver());
    }
};

constexpr auto never_stop = [](auto &&...) { return false; };

template <typename Pred, typename Sig, typename = void>
struct is_callable : std::false_type {};
template <typename Pred, typename... Args>
struct is_callable<Pred, set_value_t(Args...),
                   std::void_t<std::invoke_result_t<Pred, Args...>>>
    : std::true_type {};

template <typename Pred> struct callable_with {
    template <typename Sig> using fn = is_callable<Pred, Sig>;
};

template <template <typename> typename Expiry> struct expiry_wrapper {
    template <typename T> using fn = Expiry<T>;
};

template <stdx::ct_string Name, typename Expiry, typename Sndr, typename Rcvr,
          typename Duration, stdx::callable Pred>
// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
struct op_state {
    using downstream_receiver_t = Rcvr;
    using time_point_t = timer_mgr::time_point_for_t<Duration>;

    using first_receiver_t = receiver<op_state, first_expiration_provider>;
    using nth_receiver_t = receiver<op_state, Expiry::template fn>;

    using value_completions =
        value_signatures_of_t<Sndr, env_of_t<nth_receiver_t>>;
    static_assert(
        boost::mp11::mp_all_of_q<value_completions, callable_with<Pred>>::value,
        ""Predicate is not callable with value completions of sender"");

    using first_state_t = async::connect_result_t<Sndr &, first_receiver_t>;
    using nth_state_t = async::connect_result_t<Sndr &, nth_receiver_t>;

    template <stdx::same_as_unqualified<Sndr> S,
              stdx::same_as_unqualified<Rcvr> R,
              stdx::same_as_unqualified<Pred> P>
    // NOLINTNEXTLINE(bugprone-forwarding-reference-overload)
    constexpr op_state(S &&s, R &&r, Duration  [MASK] , P &&p)
        : sndr{std::forward<S>(s)}, rcvr{std::forward<R>(r)}, d{ [MASK] },
          pred{std::forward<P>(p)} {}
    constexpr op_state(op_state &&) = delete;

    constexpr auto start() & -> void {
        static_assert(not synchronous<first_state_t>,
                      ""periodic doesn't make sense with synchronous senders"");

        state.template emplace<1>(stdx::with_result_of{
            [&] { return connect(sndr, first_receiver_t{this}); }});
        debug_signal<""start"", debug::erased_context_for<op_state>>(
            get_env(rcvr));
        async::start(std::get<1>(state));
    }

    constexpr auto restart() & -> void {
        if constexpr (not stoppable_sender<Sndr, env_of_t<Rcvr>>) {
            if (get_stop_token(get_env(rcvr)).stop_requested()) {
                passthrough<set_stopped_t>();
                return;
            }
        }

        state.template emplace<2>(stdx::with_result_of{
            [&] { return connect(sndr, nth_receiver_t{this}); }});
        debug_signal<""start"", debug::erased_context_for<op_state>>(
            get_env(rcvr));
        async::start(std::get<2>(state));
    }

    template <typename... Args> auto repeat(Args &&...args) -> void {
        if constexpr (not std::same_as<
                          Pred, std::remove_cvref_t<decltype(never_stop)>>) {
            debug_signal<""eval_predicate"", debug::erased_context_for<op_state>>(
                get_env(rcvr));
            if (pred(args...)) {
                passthrough<set_value_t>(std::forward<Args>(args)...);
                return;
            }
        }
        restart();
    }

    template <channel_tag Tag, typename... Args>
    auto passthrough(Args &&...args) -> void {
        debug_signal<Tag::name, debug::erased_context_for<op_state>>(
            get_env(rcvr));
        Tag{}(std::move(rcvr), std::forward<Args>(args)...);
        state.template emplace<0>();
    }

    [[nodiscard]] auto get_receiver() const -> Rcvr const & { return rcvr; }

    [[no_unique_address]] Sndr sndr;
    [[no_unique_address]] Rcvr rcvr;
    Duration d;
    [[no_unique_address]] Pred pred;
    time_point_t tp{};
    std::variant<std::monostate, first_state_t, nth_state_t> state{};
};

template <stdx::ct_string Name, typename Expiry, typename Sndr,
          typename Duration, typename Pred>
struct sender {
    using is_sender = void;
    [[no_unique_address]] Sndr sndr;
    Duration d;
    [[no_unique_address]] Pred p;

    [[nodiscard]] constexpr auto query(async::get_env_t) const {
        return forward_env_of(sndr);
    }

    template <typename...> using signatures = completion_signatures<>;

    template <typename Env>
    [[nodiscard]] constexpr static auto get_completion_signatures(Env const &) {
        if constexpr (std::same_as<Pred,
                                   std::remove_cvref_t<decltype(never_stop)>>) {
            return transform_completion_signatures_of<
                Sndr, Env, completion_signatures<>, signatures>{};
        } else {
            return completion_signatures_of_t<Sndr, Env>{};
        }
    }

    template <async::receiver R>
        requires multishot_sender<
            Sndr, typename op_state<Name, Expiry, Sndr, std::remove_cvref_t<R>,
                                    Duration, Pred>::nth_receiver_t>
    [[nodiscard]] constexpr auto
    connect(R &&r) const & -> op_state<Name, Expiry, Sndr,
                                       std::remove_cvref_t<R>, Duration, Pred> {
        return {sndr, std::forward<R>(r), d, p};
    }
};

template <stdx::ct_string Name, typename Expiry, typename Duration,
          stdx::callable Pred>
struct pipeable {
    Duration d;
    Pred p;

  private:
    template <async::sender S, stdx::same_as_unqualified<pipeable> Self>
    friend constexpr auto operator|(S &&s, Self &&self) -> async::sender auto {
        return sender<Name, Expiry, std::remove_cvref_t<S>, Duration, Pred>{
            std::forward<S>(s), std::forward<Self>(self).d,
            std::forward<Self>(self).p};
    }
};
} // namespace _periodic

using safe_immediate_expiry = _periodic::expiry_wrapper<
    _periodic::safe_immediate_nth_expiration_provider>;
using safe_quantized_expiry = _periodic::expiry_wrapper<
    _periodic::safe_quantized_nth_expiration_provider>;
using unsafe_expiry =
    _periodic::expiry_wrapper<_periodic::unsafe_nth_expiration_provider>;

template <stdx::ct_string Name = ""periodic_until"",
          typename Expiry = safe_immediate_expiry, typename Duration,
          typename P>
[[nodiscard]] constexpr auto periodic_until(Duration d, P &&p)
    -> _periodic::pipeable<Name, Expiry, Duration, std::remove_cvref_t<P>> {
    return {d, std::forward<P>(p)};
}

template <stdx::ct_string Name = ""periodic_until"",
          typename Expiry = safe_immediate_expiry, sender S, typename Duration,
          typename P>
[[nodiscard]] auto periodic_until(S &&s, Duration d, P &&p) {
    return std::forward<S>(s) |
           periodic_until<Name, Expiry>(d, std::forward<P>(p));
}

template <stdx::ct_string Name = ""periodic"",
          typename Expiry = safe_immediate_expiry, typename Duration>
[[nodiscard]] constexpr auto periodic(Duration d) {
    return periodic_until<Name, Expiry>(d, _periodic::never_stop);
}

template <stdx::ct_string Name = ""periodic"",
          typename Expiry = safe_immediate_expiry, sender S, typename Duration>
[[nodiscard]] auto periodic(S &&s, Duration d) {
    return std::forward<S>(s) | periodic<Name, Expiry>(d);
}

template <stdx::ct_string Name = ""periodic_n"",
          typename Expiry = safe_immediate_expiry, typename Duration>
[[nodiscard]] constexpr auto periodic_n(Duration d, unsigned int n) {
    return periodic_until<Name, Expiry>(
        d, [n](auto &&...) mutable { return n-- == 0; });
}

template <stdx::ct_string Name = ""periodic_n"",
          typename Expiry = safe_immediate_expiry, sender S, typename Duration>
[[nodiscard]] auto periodic_n(S &&s, Duration d, unsigned int n) {
    return std::forward<S>(s) | periodic_n<Name, Expiry>(d, n);
}

struct periodic_t;

template <stdx::ct_string Name, typename Expiry, typename... Ts>
struct debug::context_for<_periodic::op_state<Name, Expiry, Ts...>> {
    using tag = periodic_t;
    constexpr static auto name = Name;
    using type = _periodic::op_state<Name, Expiry, Ts...>;
    using children = stdx::type_list<
        debug::erased_context_for<typename type::first_state_t>>;
};
} // namespace async
",dur
493,"#include ""connection.h""

unsigned int Connection::counter = 0;

Connection::Connection(int descriptor, QObject *parent) :
    QTcpSocket(parent), key(0), descriptor(descriptor)/*, socket(tcpSocket)*/
{
    /* First we havet to set the descriptor for socket.
     * It is very important because we are reaching to socketEngine
     * where the address many parameters are set ie. peer port and address;
     *
     * see here: http://download.froglogic.com/public/qt5-squishcoco-report/QtBase/source_480_preprocessed.html
     */

    qDebug() << ""Creating descriptor "" << descriptor;
    this->setSocketDescriptor(descriptor);

    counter += 1;
    key = rsHash(this->peerAddress(),
                 this->peerPort());

}

unsigned int Connection::getKey()
{
    return key;
}

unsigned int
Connection::rsHash(const QHostAddress &address, const quint16 port)
{
    unsigned int b    = 378551;
    unsigned int a    = 63689;
    unsigned int  [MASK]  = 0;
    int i    = 0;
    QString key(address.toString() + QString(port) + QString(counter));

    auto len = key.size();

    for (i = 0; i < len; i++)
    {
         [MASK]  =  [MASK]  * a + key.at(i).toAscii();
        a = a * b;
    }

    return  [MASK] ;
}
",hash
494,"#include <iostream>
#include <iomanip>
#include <ctime>
#include <cstdlib>
#include <stdlib.h>
#include <cstring>
using namespace std;

int boardsize = 6;
char temp[11][10];
void WelcomeMessage()
{
    // show welcome message
    cout << ""________                        __________.__                 __       ________                       "" << endl;
    cout << ""\\______ \\_______  ____ ______   \\______   \\  |   ____   ____ |  | __  /  _____/_____    _____   ____  "" << endl;
    cout << "" |    |  \\_  __ \\/  _ \\\\____ \\   |    |  _/  |  /  _ \\_/ ___\\|  |/ / /   \\  ___\\__  \\  /     \\_/ __ \\ "" << endl;
    cout << "" |    `   \\  | \\(  <_> )  |_> >  |    |   \\  |_(  <_> )  \\___|    <  \\    \\_\\  \\/ __ \\|  Y Y  \\  ___/ "" << endl;
    cout << ""/_______  /__|   \\____/|   __/   |______  /____/\\____/ \\___  >__|_ \\  \\______  (____  /__|_|  /\\___  >"" << endl;
    cout << ""        \\/             |__|             \\/                 \\/     \\/         \\/     \\/      \\/     \\/ "" << endl;
    cout << endl;
    cout << setw(78) << "" +-------------+ +---+ +-------+ +---------+ +-------+"" << endl;
    cout << setw(78) << "" |W e l c o m e| |t o| |D r o p| |B l o c k| |G a m e|"" << endl;
    cout << setw(78) << "" +-------------+ +---+ +-------+ +---------+ +-------+"" << endl;
}


class board {
public:
    void ChangeBoardSize()
    {
        int num = 0;
        cout << ""----------------------------------------------"" << endl;
        cout << ""[1] Change Board Size"" << endl; //test only, del after finishing the code
        cout << ""You can change board size here."" << endl;
        cout << ""Please enter a size (6-10): "";
        cin >> num;
        if (num >= 6 && num <= 10)
        {
            boardsize = num;
            cout << ""You have changed the Board Size to "" << boardsize << endl;
            cout << ""----------------------------------------------"" << endl;
        } else {
            cout << ""You can only enter 6-10! "" << endl;
            cout << ""----------------------------------------------"" << endl;
            ChangeBoardSize();
        }
        system(""pause"");
    }
    void reset() {
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 10; j++) {
                temp[i][j] = 0;
            }
        }
    }
    //function used for printing +------+
    void printrow() {
        cout << ""  "";
        int count = 0;
        for (int i = 0; i < 2; i++) {
            cout << ""+"";
            if (count < 1) {
                for (int i = 0; i < (boardsize * 2 + 1); i++)
                    cout << ""-"";
            }
            count++;
        }
        cout << endl;
    }
    void printArray() {
        printboard();
        printrow();
        for (int i = 0; i < boardsize; i++) {

            char k = 'A';
            k += i;
            cout << (char)k << "" |"";
            for (int j = 0; j < boardsize; j++) {
                cout << "" "" << (char)temp[i + 1][j];

            }
            cout << "" |"" << endl;
        }
        printrow();

    }
    void anticlock() {
        for (int x = 0; x * 2 < boardsize; x++) {
            for (int y = x; y < boardsize - x - 1; y++) {
                int t = temp[x + 1][y];
                temp[x + 1][y] = temp[y + 1][boardsize - 1 - x];
                temp[y + 1][boardsize - x - 1] = temp[boardsize - x][boardsize - 1 - y];
                temp[boardsize - x][boardsize - 1 - y] = temp[boardsize - y][x];
                temp[boardsize - y][x] = t;
            }
        }
        printArray();
    }
    void dropblocks(int a, char c, char d, int& dp1, int& dp2) {
        int t = 0;
        board board;
        dp1 = 0, dp2 = 0;
        for (int i = 0; i < boardsize; i++) {
            temp[0][a] = c;
            temp[0][a + 1] = d;
            if (temp[i + 1][a] == 0 && temp[i + 1][a + 1] == 0)
            {
                temp[i + 1][a] = temp[i][a];
                temp[i + 1][a + 1] = temp[i][a + 1];
                temp[i][a] = t;
                temp[i][a + 1] = t;
                temp[0][a] = 0;
                temp[0][a + 1] = 0;
                dp1 += 1;
                dp2 += 1;
                system(""cls"");
                cout << ""Dropping..."";
                board.printArray();
                system(""pause"");
            } else if (temp[i + 1][a] == 0)
            {
                temp[i + 1][a] = temp[i][a];
                temp[i][a] = t;
                temp[0][a] = 0;
                temp[0][a + 1] = 0;
                dp1 += 1;
                system(""cls"");
                board.printArray();
            } else if (temp[i + 1][a + 1] == 0) {
                temp[i + 1][a + 1] = temp[i][a + 1];
                temp[i][a + 1] = t;
                temp[0][a] = 0;
                temp[0][a + 1] = 0;
                system(""cls"");
                dp2 += 1;
                board.printArray();
            }

        }
        score += 20;


    }
    bool checkFilled() {
        int cnt = 0;
        for (int i = 0; i < boardsize; i++) {
            if (temp[1][i] == 0) cnt++; else cnt = 0;
            if (cnt == 2) return false;
        }
        return true;
    }
    bool checkDropable(int a) {
        return (temp[1][a] == 0 && temp[1][a + 1] == 0);
    }
    void mergeblock(int a, char c, char d, int dp1, int dp2) {

        int mercounter = 0, vert = 0, left = 0, right = 0, lp = 0, rp = 0, mp = 0;//mergecounters
        bool stop = false;

        mercounter = 0, vert = 0, left = 0, right = 0, lp = 0, rp = 0, mp = 0;
        if (temp[dp1][a] == temp[dp1 + 1][a] && temp[dp1][a] != 0) {
            mp += 1;
            if (temp[dp1][a] == temp[dp1][a - 1] && temp[dp1][a] != 0)
                lp = mp;
            if (temp[dp1][a] == temp[dp1][a + 1] && temp[dp1][a] != 0)
                rp = mp;
            if (temp[dp1][a] == temp[dp1 + 2][a] && temp[dp1][a] != 0)
                vert += 1;
            vert += 1;

        }
        if (temp[dp1][a] == temp[dp1 + rp][a + 1] && temp[dp1][a] != 0) {
            if (temp[dp1][a] == temp[dp1 + rp][a + 2] && temp[dp1][a] != 0)
                right += 1;
            right += 1;
        }
        if (temp[dp1][a] == temp[dp1 + lp][a - 1] && temp[dp1][a] != 0) {
            if (temp[dp1][a] == temp[dp1 + lp][a - 2] && temp[dp1][a] != 0)
                left += 1;
            left += 1;
        }
        mercounter = left + right + vert;
        if (mercounter >= 2)

        {
            //cout << mercounter;
            for (int i = 0; i <= right; i++) {
                if (rp != mp)
                    temp[dp1 + rp][a + i] = 0;
            }
            for (int i = 1; i <= left; i++)
                if (lp != mp)
                    temp[dp1 + lp][a - i] = 0;
            for (int i = 0; i <= vert; i++) {
                if (mp = 0 && left >= 1)
                    temp[dp1][a] = 0;
                else if (dp1 + i != dp1 + vert) temp[dp1 + i][a] = 0;
            }
        }
        if (mercounter >= 2) score += 100 * pow(2, mercounter - 2);
        
        mercounter = 0, vert = 0, left = 0, right = 0, lp = 0, rp = 0, mp = 0;
        a += 1;
        if (temp[dp2][a] == temp[dp2 + 1][a] && temp[dp2][a] != 0) {
            mp += 1;
            if (temp[dp2][a] == temp[dp2][a - 1] && temp[dp2][a] != 0)
                lp = mp;
            if (temp[dp2][a] == temp[dp2][a + 1] && temp[dp2][a] != 0)
                rp = mp;
            if (temp[dp2][a] == temp[dp2 + 2][a] && temp[dp2][a] != 0)
                vert += 1;
            vert += 1;

        }
        if (temp[dp2][a] == temp[dp2 + rp][a + 1] && temp[dp2][a] != 0) {
            if (temp[dp2][a] == temp[dp2 + rp][a + 2] && temp[dp2][a] != 0)
                right += 1;
            right += 1;
        }
        if (temp[dp2][a] == temp[dp2 + lp][a - 1] && temp[dp2][a] != 0) {
            if (temp[dp2][a] == temp[dp2 + lp][a - 2] && temp[dp2][a] != 0)
                left += 1;
            left += 1;
        }
        mercounter = left + right + vert;
        if (mercounter >= 2)

        {
            //cout << mercounter;
            for (int i = 0; i <= right; i++) {
                if (rp != mp)
                    temp[dp2 + rp][a + i] = 0;
            }
            for (int i = 1; i <= left; i++)
                if (lp != mp)
                    temp[dp2 + lp][a - i] = 0;
            for (int i = 0; i <= vert; i++) {
                if (mp = 0 && left >= 1)
                    temp[dp2][a] = 0;
                else if (dp2 + i != dp2 + vert)temp[dp2 + i][a] = 0;
            }
        }
        if (mercounter >= 2) score += 100 * pow(2, mercounter - 2);
    }
    void printboard() {

        cout << endl;

        //print 0 1 2 3 4 ...
        cout << ""   "";
        for (int i = 0; i < boardsize; i++) {
            cout << "" "" << i;
        }
        cout << endl;
    }
    void printScoreAndInstruction() {
        cout << ""Scores: "" << score << endl;
        cout << ""Enter command: "";
    }
    void printGameOver() {
        cout << ""Oh! The board has been filled!"" << endl;
        cout << ""GAME OVER"" << endl;
        cout << ""Final Score: "" << score << endl;
    }
private:
    int score = 0;
    int lastmerge = 0;
};
class block {
public:
    char gen() {

        r = 1 + rand() % 4;
        switch (r) {
            case 1: r = 'X'; break;
            case 2: r = 'O'; break;
            case 3: r = '#'; break;
            case 4: r = '$'; break;

            default:
                cout << ""System error"" << endl;
                break;
        }
        return r;
    }
    void print() {
        cout << r;
    }
private:
    char r = 0;
};
void StartGame()
{
    char a = 0, b = 0, input;
    char i[5];
    int convert = 0;
    int dp1 = 0, dp2 = 0; //droppoints
    cout << endl;
    cout << ""StartGame"" << endl;
    system(""cls"");
    board board;
    board.reset();
    block leftblock, rightblock;
    int  [MASK]  = 0;
    bool iserror = false, shouldGenerate = true;
    do {
        system(""cls"");
        if (shouldGenerate) {
            a = leftblock.gen();
            b = rightblock.gen();
        }
        cout << ""Next blocks: "";
        leftblock.print();
        cout << "" "";
        rightblock.print();
        shouldGenerate = true;
        board.printArray();
        board.printScoreAndInstruction();
        cin >> i;
        input = i[0];
        if (strcmp(i, ""quit"") == 0) {
            char check = 'd';
            bool shouldQuit = false;
            while (check != 'Y' && check != 'N' && check != 'y' && check != 'n') {
                cout << ""Are you sure you want quit?(Y/N)"" << endl;
                cin >> check;
                if (check == 'Y' || check == 'y') {
                    shouldQuit = true;
                } else if (check == 'N' || check == 'n') {
                    shouldQuit = false;
                } else {
                    cout << ""Please input Y/y or N/n only!"";
                }
            }
            if (shouldQuit) break; else continue;
        }
        do {
             [MASK]  = 0;
            iserror = false;
            for (int counter = 0; i[counter] != '\0'; counter++) {
                if (i[counter] >= '0' && i[counter] <= '9')
                {
                     [MASK] ++;
                    continue;
                } else if (i[counter] == 'r')
                    break;
                else if (i[counter] == 'R')
                    break;
                else
                    iserror = true;
                continue;
            }
            if ( [MASK]  > 1 || iserror) {
                cout << ""Out of range. Please input again\nEnter command: "";
                cin >> i;
            }
        } while ( [MASK]  > 1 || iserror);

        for (int counter = 0; i[counter] != '\0'; counter++) {
            if (i[counter] >= '0' && i[counter] < '9' + 1) {
                convert = i[counter] - '0';
                system(""cls"");
                if (convert < boardsize - 1) {
                    if (!board.checkDropable(convert)) {
                        board.printArray();
                        cout << ""Blocks are not droppable in this position\n"";
                        system(""pause"");
                        shouldGenerate = false;
                        continue;
                    }
                    board.dropblocks(convert, a, b, dp1, dp2);
                    board.mergeblock(convert, a, b, dp1, dp2);
                    break;
                } else
                {
                    board.printArray();
                    cout << ""Invaild Input!\n"";
                    shouldGenerate = false;
                    system(""pause"");
                    continue;
                }
            }
            /*else if (i[counter] == 'R' || i[counter] == 'r') {
                board.anticlock();
                system(""cls"");
                board.printArray();
                break;
            }*/
        }
        if (board.checkFilled()) {
            board.printGameOver();
            system(""pause"");
            break;
        }
    } while (input != 'q');
}
void Settings()
{
    // Code for setting
    int choice;
    board board;
    cout << endl << endl;
    cout << ""*** Settings Menu ***"" << endl;
    cout << ""[1] Change Board Size"" << endl;
    cout << ""[2] Return to Game Menu"" << endl;
    cout << ""*********************"" << endl;
    cout << ""Option (1 - 2): "";
    cin >> choice;
    cout << endl;
    switch (choice)
    {
        case 1: board.ChangeBoardSize(); break;
        case 2: break;
        default:
            cout << ""Option (1 - 2) only!""; break;
    }
}
void Instructions()
{
    // Insert instructions code here
    cout << ""Instructions:"" << endl; //test only, del after finishing the code
    cout << ""Use keyboard to play this EXCITING and INTERESTING drop block game"" << endl;
    cout << ""Input 'r' or 'R' to rotate the blocks, each rotation can change the segment 90° clockwise."" << endl;
    cout << ""You can input 'r' up to 3 times, which means at most you can rotate the segment 270°"" << endl;
    cout << ""Input the NUMBER key to change the drop position"" << endl;
    cout << ""vvv Drop position and corresponding NUMBERs will show like this vvv"" << endl;
    cout << ""     v v v v v v  INPUT THIS NUMBERS!!"" << endl;
    cout << ""     0 1 2 3 4 5 "" << endl;
    cout << ""   +-------------+"" << endl;
    cout << "" A |             |"" << endl;
    cout << "" B |             |"" << endl;
    cout << "" C |             |"" << endl;
    cout << "" D |             |"" << endl;
    cout << "" E |             |"" << endl;
    cout << "" F |             |"" << endl;
    cout << ""   +-------------+"" << endl;
    cout << ""You should input ALL you command in ONE time."" << endl;
    cout << ""e.g. 'rrr4', 'R3', '5'"" << endl << endl;
    cout << setw(50) << ""GOOD LUCK, HAVE FUN."" << endl;
    system(""pause"");
}
void Credits()
{
    //Insert Credits code here
    cout << ""~~~~~~~Credits~~~~~~~~"" << endl;
    cout << ""~~~~~~Group members:~~~~~~"" << endl;
    cout << ""<NAME>-17167572     <NAME> Lam-17169147A"" << endl;
    cout << ""L<NAME> Lok-17065440A       <NAME>-17073402A"" << endl;
    cout << ""<NAME>-17024850A   <NAME>-17109777A"" << endl;
    cout << ""  "" << endl;
    cout << ""      Class : CCN2042 Computer Programming      "" << endl;
    cout << ""  "" << endl;
    cout << ""      Tutoial group 202   Group 7      "" << endl;
    system(""pause"");


}

int exit() {
    char check = 'd';
    while (check != 'Y' && check != 'N' && check != 'y' && check != 'n') {
        cout << ""Are you sure you want to leave?(Y/N)"" << endl;
        cin >> check;
        if (check == 'Y' || check == 'y') {
            return 1;
        } else if (check == 'N' || check == 'n') {
            return 0;
        } else {
            cout << ""Please input Y/y or N/n only!"";
        }
    }
}

int main() {
    int choice;
    srand(time(0));
    do { //Back to menu after choice option
        system(""cls"");
        WelcomeMessage();
        cout << endl;
        cout << ""*** Game Menu ***"" << endl;
        cout << ""[1] Start Game"" << endl;
        cout << ""[2] Settings"" << endl;
        cout << ""[3] Instructions"" << endl;
        cout << ""[4] Credits"" << endl;
        cout << ""[5] Exit"" << endl;
        cout << ""*****************"" << endl;
        cout << ""Option (1 - 5): "";
        cin >> choice;
        switch (choice) {
            case 1: StartGame(); break;
            case 2: Settings(); break;
            case 3: Instructions(); break;
            case 4: Credits(); break;
            case 5: if (!exit()) choice = 1; break;
            default:
                cout << ""Option (1-5) only!"" << endl;
                break;
        }
    } while (choice != 5);
    cout << ""Good bye."" << endl;
    return 0;
}
",dbcount
495,"#ifndef COSTMAP_TOOLS_H_
#define COSTMAP_TOOLS_H_

#include <costmap_2d/costmap_2d.h>
#include <geometry_msgs/PointStamped.h>
#include <geometry_msgs/PolygonStamped.h>
#include <ros/ros.h>

namespace frontier_exploration {

    /**
     * @brief Determine 4-connected neighbourhood of an input cell, checking for map edges
     * @param idx input cell index
     * @param costmap Reference to map data
     * @return neighbour cell indexes
     */


    std::vector<size_t> nhood4(size_t idx, const costmap_2d::Costmap2D& costmap)
    {
        // get 4-connected neighbourhood indexes, check for edge of map
        std::vector<size_t> out;

        size_t sizeX = costmap.getSizeInCellsX(), sizeY = costmap.getSizeInCellsY();
        //ROS_INFO(""Costmap size x = %lu \n"",sizeX);
        //ROS_INFO(""Costmap size y = %lu \n"",sizeY);

        if (idx > sizeX * sizeY - 1)
        {
            ROS_WARN(""Searching neighbourhood for off-map point"");
            return out;
        }

        if (idx % sizeX > 0)
        {
            out.push_back(idx - 1);
        }
        if (idx % sizeX < sizeX - 1)
        {
            out.push_back(idx + 1);
        }
        if (idx >= sizeX)
        {
            out.push_back(idx - sizeX);
        }
        if (idx < sizeX * (sizeY - 1))
        {
            out.push_back(idx + sizeX);
        }


        return out;
    }
    /**
     * @brief Determine 8-connected neighbourhood of an input cell, checking for map edges
     * @param idx input cell index
     * @param costmap Reference to map data
     * @return neighbour cell indexes
     */


    std::vector<size_t> nhood8(size_t idx, const costmap_2d::Costmap2D& costmap)
    {
        // get 8-connected neighbourhood indexes, check for edge of map
        std::vector<size_t> out = nhood4(idx, costmap);

        size_t sizeX = costmap.getSizeInCellsX(), sizeY = costmap.getSizeInCellsY();

        if (idx > sizeX * sizeY - 1)
        {
            return out;
        }

        if (idx % sizeX > 0 && idx >= sizeX)
        {
            out.push_back(idx - 1 - sizeX);
        }
        if (idx % sizeX > 0 && idx < sizeX * (sizeY - 1))
        {
            out.push_back(idx - 1 + sizeX);
        }
        if (idx % sizeX < sizeX - 1 && idx >= sizeX)
        {
            out.push_back(idx + 1 - sizeX);
        }
        if (idx % sizeX < sizeX - 1 && idx < sizeX * (sizeY - 1))
        {
            out.push_back(idx + 1 + sizeX);
        }

        return out;
    }

    /**
     * @brief Find nearest cell of a specified value
     * @param outResult Index of located cell
     * @param start Index initial cell to search from
     * @param val Specified value to search for
     * @param costmap Reference to map data
     * @return True if a cell with the requested value was found
     */

    bool nearestCell(size_t& outResult, size_t start, uint8_t val,
                     const costmap_2d::Costmap2D& costmap)
    {
        const uint8_t* map = costmap.getCharMap();
        const size_t sizeX = costmap.getSizeInCellsX(), sizeY = costmap.getSizeInCellsY();

        if (start >= sizeX * sizeY)
        {
            return false;
        }

        // initialize breadth first search
        std::queue<size_t>  [MASK] ;
        std::vector<bool> visited(sizeX * sizeY, false);// create a vector of sizeX*sizeY, value

        // push initial cell
         [MASK] .push(start);
        visited[start] = true;

        // search for neighbouring cell matching value
        while (! [MASK] .empty())
        {
            size_t idx =  [MASK] .front();
             [MASK] .pop();

            // return if cell of correct value is found
            if (map[idx] == val)
            {
                outResult = idx;
                return true;
            }

            // iterate over all adjacent unvisited cells
            for (auto nbr : nhood8(idx, costmap))
            {
                if (!visited[nbr])
                {
                     [MASK] .push(nbr);
                    visited[nbr] = true;
                }
            }
        }
        return false;
    }
} // namespace frontier_exploration
#endif
",bfs
496,"// Copyright (c) 2016-2017 Anyar, Inc.
// 
// 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 ""gnugraph/GnuGraph.h""

using namespace std;

inline void pressEnter(void)
{
   cout << ""Press ENTER to continue . . ."" << '\n';
   cin.get();
}

void test1()
{
   GnuGraph graph;
   string output = graph.plot(""1 1\n2 4\n3 9\n4 16\n5 25\n6 36\n7 49\n8 64\n9 81\n10 100\n"");
   cout << ""Test1:\n"" << output << '\n';
   pressEnter();
}

void test2()
{
   GnuGraph graph;

   vector<double> x, y;
   for (size_t i = 0; i < 200; ++i)
   {
      x.push_back(double(i));
      y.push_back(sqrt(x[i]));
   }

   string output = graph.plot(x, y, ""y = sqrt(x)"");
   //string output = graph.animate(x, y);
   cout << ""Test2:\n"" << output << '\n';
   pressEnter();
}

void test3()
{
   GnuGraph graph;

   vector<vector<double>> vec;
   vec.push_back({ 1.0, 1.0, 1.0 });
   vec.push_back({ 2.0, 2.0, 2.0 });
   vec.push_back({ 3.0, 4.0, 4.0 });
   vec.push_back({ 4.0, 8.0, 8.0 });
   vec.push_back({ 5.0, 16.0, 16.0 });
   vec.push_back({ 5.0, 32.0, 32.0 });
   cout << ""Test3:\n"" << graph.plotLine3D(vec) << '\n';
   pressEnter();
}

void test4()
{
   GnuGraph graph;

   vector<double> x0, y0, x1, y1;
   for (size_t i = 0; i < 200; ++i)
   {
      x0.push_back(double(i));
      y0.push_back(sqrt(x0[i]));

      x1.push_back(double(i));
      y1.push_back(pow(x1[i], 1.0 / 3.0));
   }

   graph.addPlot(x0, y0, ""y = sqrt(x)"");
   graph.addPlot(x1, y1, ""y = x^(1/3)"");
   string output = graph.plot();
   cout << ""Test4:\n"" << output << '\n';
   pressEnter();
}

void test5()
{
   GnuGraph graph;

   vector<vector<double>> vec;
   vec.push_back({ 1.0, 1.0, 1.0 });
   vec.push_back({ 2.0, 2.0, 2.0 });
   vec.push_back({ 3.0, 4.0, 4.0 });
   vec.push_back({ 4.0, 8.0, 8.0 });
   vec.push_back({ 5.0, 16.0, 16.0 });
   vec.push_back({ 5.0, 32.0, 32.0 });

   graph.addLine3D(vec);

   const vector<double> start{ 1.0, 1.0, 1.0 };
   const vector<double>  [MASK] { 1.0, 0.0, 0.0 };

   graph.addVector3D(start,  [MASK] );

   cout << ""Test5:\n"" << graph.plot3D() << '\n';
   pressEnter();
}

void test6()
{
   GnuGraph graph;

   const size_t n = 200;
   vector<vector<double>> vec(n);
   for (size_t i = 0; i < n; ++i)
   {
      vec[i] = { cos(i / 20.0), sin(i / 30.0), cos(i / 50.0) };
   }

   graph.addLine3D(vec);
   cout << graph.plot3D() << '\n';
   pressEnter();
}

int main(int argc, char* argv[])
{
   test1();
   test2();
   test3();
   test4();
   test5();
   test6();

   return 0;
}",direction
497,"// SPDX-FileCopyrightText: 2023 <NAME> <<EMAIL>>
// SPDX-License-Identifier:  Apache-2.0

#include <chrono>
#include <iostream>
#include <memory>
#include <utility>
#include <yaml-cpp/yaml.h>

#include ""ament_index_cpp/get_package_share_directory.hpp""
#include ""rclcpp/node_impl.hpp""
#include ""rclcpp/rclcpp.hpp""
#include ""rosbag2_transport/qos.hpp""

#include ""raspicat_speak2/raspicat_speak2.hpp""

using namespace std::chrono_literals;

namespace raspicat_speak2 {

RaspicatSpeak2::RaspicatSpeak2(const std::string &node_name,
                               const std::string &yaml_path)
    : Node(node_name) {
  setParam();
  getParam();
  speak_list_ = parseYaml(yaml_path);
  for (const auto &topic_name : speak_list_) {
    topic_list_.push_back(topic_name.first);
  }
  topic_list_.push_back(""/speak"");
  initTimer();
}

void RaspicatSpeak2::setParam() {
  declare_parameter(""voice_config.additional_half_tone"", 1.0);
  declare_parameter(""voice_config.all_pass_constant"", 0.55);
  declare_parameter(""voice_config.speech_speed_rate"", 1.0);
  declare_parameter(""voice_config.voice_interval"", 1.0);
  declare_parameter(""voice_config.voice_model"", ""mei_normal.htsvoice"");
}

void RaspicatSpeak2::getParam() {
  voc_.additional_half_tone =
      get_parameter(""voice_config.additional_half_tone"").as_double();
  voc_.all_pass_constant =
      get_parameter(""voice_config.all_pass_constant"").as_double();
  voc_.speech_speed_rate =
      get_parameter(""voice_config.speech_speed_rate"").as_double();
  voc_.voice_model = get_parameter(""voice_config.voice_model"").as_string();
}

std::unordered_map<std::string, std::string>
RaspicatSpeak2::parseYaml(const std::string &yaml_path) {

  std::unordered_map<std::string, std::string> speak_list;

  YAML::Node config = YAML::LoadFile(yaml_path);

  const YAML::Node &topics = config[""/**""][""ros__parameters""][""topics""];
  for (const YAML::Node &topic : topics)
    speak_list[topic[""topic""].as<std::string>()] =
        topic[""sentence""].as<std::string>();

  return speak_list;
}

void RaspicatSpeak2::initTimer() {
  timer_ = create_wall_timer(0.1s, std::bind(&RaspicatSpeak2::on_timer, this));
}

void RaspicatSpeak2::on_timer() { subscribe_topic(); }

void RaspicatSpeak2::subscribe_topic() {
  auto all_topics = getTopicsNameType();
  auto  [MASK]  = filterTopics(all_topics);

  if ( [MASK] .size()) {
    for (const auto &unsub_topic :  [MASK] ) {
      auto rclcpp_qos = rosbag2_transport::Rosbag2QoS::adapt_request_to_offers(
          unsub_topic.first, get_publishers_info_by_topic(unsub_topic.first));

      if (hasNameInTopic(all_topics, topic_list_)) {
        auto subscription = createSubscription(unsub_topic.first,
                                               unsub_topic.second, rclcpp_qos);

        subscriptions_.emplace(unsub_topic.first, subscription);
      }
    }
  }
}

std::shared_ptr<rclcpp::GenericSubscription>
RaspicatSpeak2::createSubscription(const std::string &topic_name,
                                   const std::string &topic_type,
                                   const rclcpp::QoS &qos) {

  auto subscription = create_generic_subscription(
      topic_name, topic_type, qos,
      [topic_name, topic_type,
       this](std::shared_ptr<const rclcpp::SerializedMessage> message) {
        if (topic_name == ""/speak"") {
          std::string speak_str;
          std::string serialized_data(
              reinterpret_cast<const char *>(
                  message->get_rcl_serialized_message().buffer),
              message->get_rcl_serialized_message().buffer_length);
          for (char c : serialized_data)
            if (!std::iscntrl(c))
              speak_str.push_back(c);
          speak(speak_str);
        } else {
          if (speak_list_.find(topic_name) != speak_list_.end())
            speak(speak_list_[topic_name]);
        }
      });
  return subscription;
}

std::unordered_map<std::string, std::string> RaspicatSpeak2::filterTopics(
    std::unordered_map<std::string, std::string> all_topics) {
  std::unordered_map<std::string, std::string> filter_topics;

  for (const auto &topic : all_topics)
    if (not isSubscribed(topic.first)) {
      filter_topics.insert(topic);
      subscribed_topics_.emplace_back(topic.first);
    }

  return filter_topics;
}

bool RaspicatSpeak2::isSubscribed(std::string topic_name) {
  return subscriptions_.find(topic_name) != subscriptions_.end();
}

std::unordered_map<std::string, std::string>
RaspicatSpeak2::getTopicsNameType() {
  auto get_topics = this->get_topic_names_and_types();

  std::unordered_map<std::string, std::string> all_topics;
  for (const auto &[topic_name, topic_types] : get_topics)
    all_topics.insert(std::make_pair(topic_name, topic_types[0]));

  return all_topics;
}

bool RaspicatSpeak2::hasNameInTopic(
    const std::unordered_map<std::string, std::string> all_topics,
    const std::vector<std::string> topic_list) {
  for (const std::string &n : topic_list)
    if (all_topics.find(n) != all_topics.end())
      return true;

  return false;
}

void RaspicatSpeak2::speak(const std::string speak_str) {
  std::string open_jtalk =
      ""echo "" + speak_str + "" | open_jtalk -x "" +
      ""/var/lib/mecab/dic/open-jtalk/naist-jdic -m "" +
      ament_index_cpp::get_package_share_directory(""raspicat_speak2"") +
      ""/voice_model/"" + voc_.voice_model + "" -r "" +
      std::to_string(voc_.speech_speed_rate) + "" -fm "" +
      std::to_string(voc_.additional_half_tone) + "" -a "" +
      std::to_string(voc_.all_pass_constant) + "" -ow /dev/stdout | aplay & "";
  if (system(open_jtalk.c_str()))
    RCLCPP_ERROR(get_logger(), ""shell is not available on the system!"");
}

} // namespace raspicat_speak2
",unsub_topics
498,"#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <string>


DWORD GetProcessIdByName(const std::wstring& processName) {
    DWORD processId = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot == INVALID_HANDLE_VALUE) {
        std::wcerr << L""Fehler beim Erstellen des Snapshots.\n"";
        return 0;
    }

    PROCESSENTRY32W processEntry = { 0 };
    processEntry.dwSize = sizeof(PROCESSENTRY32W);

    if (Process32FirstW(snapshot, &processEntry)) {
        do {
            if (processName == std::wstring(processEntry.szExeFile)) {
                processId = processEntry.th32ProcessID;
                break;
            }
        } while (Process32NextW(snapshot, &processEntry));
    }

    CloseHandle(snapshot);
    return processId;
}

int main() {
    const std::wstring targetProcessName = L""test.exe""; // Dein Prozess
    DWORD processId = GetProcessIdByName(targetProcessName);

    if (processId == 0) {
        std::wcerr << L""Prozess \"""" << targetProcessName << L""\"" nicht gefunden.\n"";
        return 1;
    }

    std::wcout << L""Prozess gefunden! Prozess-ID: "" << processId << L""\n"";

    
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
    if (!hProcess) {
        std::wcerr << L""Fehler beim Öffnen des Prozesses.\n"";
        return 1;
    }


    uintptr_t  [MASK]  = 0x1BEF88FC3C0; //Deine Adresse angeben und herrausfinden(CheatEngine oder so)
    int newValue = 20; //dein neuer wert


    if (!WriteProcessMemory(hProcess, (LPVOID) [MASK] , &newValue, sizeof(newValue), nullptr)) {
        std::wcerr << L""Fehler beim Schreiben in den Speicher des Prozesses.\n"";
        CloseHandle(hProcess);
        return 1;
    }

    std::wcout << L""Zahl erfolgreich auf "" << newValue << L"" gesetzt!\n"";

    
    CloseHandle(hProcess);
    return 0;
}
",targetAddress
499,"/*All right reserved © copyrighted code by bytecoders. Complied by Nirmalram @ Pineapplem3 Inc.
 * the code is open source you can make any changes according to your wish. This code only for
 * educational purpose. copying of this code in any means is strictly prohibited without prior
 * permission of developers.
 * 
 *powered by team bytecoders 



*/
float value;
float sensor;
const float vpp = 0.0048875855327468;
float r1 = 30000;
float r2 = 7500;
float voltage;   // for volatge
float current;  // for current
float credit;    // for credit unchanged
float power;    // for power
float unit;    // for unit of current recieved
int myclock;   // check measure time at which circuit was in on stages.
float check;   // check wheather the credit is getting over.
float addcredit;   // add up the credit when check conditon pass as fixed constant over the range.
int light = 13; // pinmode of light systems is 13
float price;

void printbill(float cp, float vp , float pp , float up, float rs)
// printing the original bill
{
  Serial.println(""======CONSUMPTION TABLE==========="");
  float originalcurrent = cp;
  Serial.print(originalcurrent);
  Serial.println(""   A   The current [realtime]  "");

  float originalvoltage = vp;
  Serial.print(originalvoltage);
  Serial.println(""   V   The voltage  [realtime]  "");

  float originalpower = pp;
  Serial.print(originalpower);
  Serial.println(""  W   The power consumed [realtime]  "");

  float originalunit = up;
  Serial.print(originalunit);
  Serial.println(""  KWH   The unit consumed [realtime]  "");

  float  [MASK]  = rs;
  Serial.print( [MASK] );
  Serial.println(""  Rs   The amount deducted [realtime]  "");
Serial.println(""===================================="");

Serial.println("""");
}
void storetemp(float c, float v, float p , float u, float r )
{
  //storing my temporary value of bill
  float tempcurrent = c;
  float tempvoltage = v;
  float temppower = p;
  float tempunit = u;
  float temprs = r;
}
void setup() {
  pinMode(13, OUTPUT);
  Serial.begin(9600);
  Serial.println(""Enter the amount you need to set as limit : "");


}

void loop() {
  if (Serial.available())
  {

    float s = Serial.read();
    credit = s;
    int  flag = 1;
    price = 3.10;
    if (credit != 0)
    {
      check = 0;
      while (check <= credit)
      {
        digitalWrite(13, HIGH);
        myclock = myclock + 1;
        current = analogRead(A0);  // for current
        current=current-510.50;
        voltage = analogRead(A1);  // for voltage
        power = current * voltage;
        unit = (power * myclock) / (1000 * 3600);
        printbill(current, voltage, power, unit, price);

        delay(10000);
        myclock = myclock + 4;
        if ((unit > 0) && (unit < 51))
        {

          price = 3.10;
          Serial.println(""price is "" );
          Serial.println(price);
          printbill(current, voltage, power, unit, price);
          if (flag == 1)
          {
            credit = credit - 3.10;
            flag = 0;
          }
          else if ((unit > 51) && (unit < 101))
          {
            price = 4.10;
            Serial.println(""price is "" );
            Serial.println(price);
            printbill(current, voltage, power, unit, price);
            if (flag == 1)
            {
              credit = credit - 1;
              flag = 0;
            }
          }
          else if ((unit > 101) && (unit < 201))
          {
            price = 4.80;
            Serial.println(""price is "");
            Serial.println(price);
            printbill(current, voltage, power, unit, price);
            if (flag == 1)
            {
              credit = credit - 0.7;
              flag = 0;
            }

          }

          else if ((unit > 200) && (unit < 301))
          {
            price = 6.80 + .01;
            Serial.println(""price is "");
            Serial.println(price);
            credit = credit - 1.7;
            printbill(current, voltage, power, unit, price);

          }

        }

      }
    }

    else
    {
      digitalWrite(light, LOW);
    }
  }
}





",originalrs
500,"#include <iostream>
#include <boost/asio/io_context.hpp>
#include <boost/asio/strand.hpp>
#include <boost/asio/write.hpp>
#include <boost/asio/random_access_file.hpp>

int main() {
    boost::asio::io_context io_context;
    boost::asio::random_access_file file(io_context); 

    file.open(""test.txt"", 
            boost::asio::random_access_file::read_write|
            boost::asio::random_access_file::create); 

    if (!file.is_open()) {
        std::cout << ""Failed to open file!"" << std::endl;
        return 1;
    }

    char buffer[64] = ""hello"";
    boost::asio::const_buffer buf(buffer, 5);

    boost::asio::async_write(file, buf,
        [&file](boost::system::error_code ec, std::size_t  [MASK] ) {
            if (!ec) {
                std::cout << ""Write complete: "" <<  [MASK]  << "" bytes."" << std::endl;
            } else {
                std::cout << ""Error during write operation: "" << ec.message() << std::endl;
            }
            file.close();
        });

    io_context.run();
    std::remove(""test.txt"");
    return 0;
}
",length
501,"// Copyright <NAME>, 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include ""meridian/core/event_source_registry.hpp""

namespace meridian {
namespace core {

event_source_registry::event_source_registry(size_t  [MASK] )
    : buckets_{ new bucket_type[ [MASK] ] }
    , event_sources_{ bucket_traits(buckets_.get(),  [MASK] ) }
{
}


event_source_registry::event_source_registry(event_source_registry && registry)
    : buckets_(std::move(registry.buckets_))
    , event_sources_(std::move(registry.event_sources_))
{
}


void event_source_registry::register_read_callback(event_source & source, event_source::event_callback callback)
{
    if (!source.is_linked()) {
        event_sources_.insert(source);
    }

    source.set_read_callback(callback);
}


void event_source_registry::register_write_callback(event_source & source, event_source::event_callback callback)
{
    if (!source.is_linked()) {
        event_sources_.insert(source);
    }

    source.set_write_callback(callback);
}


void event_source_registry::register_except_callback(event_source & source, event_source::event_callback callback)
{
    if (!source.is_linked()) {
        event_sources_.insert(source);
    }

    source.set_except_callback(callback);
}


void event_source_registry::remove_read_callback(event_source & source)
{
    assert(source.is_linked());
    source.remove_read_callback();
    erase_source_without_callback(source);
}


void event_source_registry::remove_write_callback(event_source & source)
{
    assert(source.is_linked());
    source.remove_write_callback();
    erase_source_without_callback(source);
}


void event_source_registry::remove_except_callback(event_source & source)
{
    assert(source.is_linked());
    source.remove_except_callback();
    erase_source_without_callback(source);
}

} // namespace core
} // namespace meridian
",bucket_count
502,"#include ""user_api.hpp""

#include <glm/gtc/matrix_inverse.hpp>
#include <imgui.h>
#include <stdio.h>

constexpr vec4 RED = { 1, 0, 0, 1 };
constexpr vec4 GREEN = {0, 1, 0, 1};
constexpr vec4 BLUE = {0, 0, 1, 1};

struct Vert_pos_normal { glm::vec3 pos, normal; };

void createCylinderMeshData(u32& numVerts, u32& numInds, Vert_pos_normal* verts, u32* inds,
    float radius, float minY, float maxY, u32  [MASK] )
{
    assert( [MASK]  >= 3);
    numVerts = 4 *  [MASK] ;
    numInds = 2*3 * ( [MASK]  - 2) +  [MASK]  * 6;

    if(verts)
    {
        // bottom cap
        for(int i = 0; i <  [MASK] ; i++) {
            const float alpha = (2*PI * i) /  [MASK] ;
            const float x = sin(alpha);
            const float z = cos(alpha);
            verts[i] = {vec3{x, minY, z}, vec3{0, -1, 0}};
        }
        // top cap
        for(int i = 0; i <  [MASK] ; i++) {
            vec3 pos = verts[i].pos;
            pos.y = maxY;
            verts[ [MASK]  + i] = {pos, {0, +1, 0}};
        }
        // sides
        for(int i = 0; i <  [MASK] ; i++) {
            const vec3 normal = {verts[i].pos.x, 0, verts[i].pos.z};
            verts[2* [MASK]  + 2*i + 0] = {verts[i].pos, normal};
            verts[2* [MASK]  + 2*i + 1] = {verts[ [MASK] +i].pos, normal};
        }
        for(int i = 0; i < 4* [MASK] ; i++) {
            verts[i].pos.x *= radius;
            verts[i].pos.z *= radius;
        }
    }

    if(inds)
    {
        // bottom cap
        for(int i = 0; i <  [MASK] -2; i++) {
            inds[3*i + 0] = 0;
            inds[3*i + 1] = i+2;
            inds[3*i + 2] = i+1;
        }
        // top cap
        int offset = 3 * ( [MASK] -2);
        for(int i = 0; i <  [MASK] -2; i++) {
            inds[offset + 3*i + 0] =  [MASK]  + 0;
            inds[offset + 3*i + 1] =  [MASK]  + i+1;
            inds[offset + 3*i + 2] =  [MASK]  + i+2;
        }
        // sides
        offset += offset;
        for(int i = 0; i <  [MASK] ; i++) {
            const int a0 = i;
            const int a1 = (i+1) %  [MASK] ;
            const int b0 =  [MASK]  + i;
            const int b1 =  [MASK]  + (i+1) %  [MASK] ;
            inds[offset + 6*i + 0] = a0;
            inds[offset + 6*i + 1] = a1;
            inds[offset + 6*i + 2] = b1;
            inds[offset + 6*i + 3] = a0;
            inds[offset + 6*i + 4] = b1;
            inds[offset + 6*i + 5] = b0;
        }
    }
}

static bool wireframe;
static u32 numVerts;
static u32 numInds;
static Vert_pos_normal verts[1<<20];
static u32 inds[1<<20];

void userInit()
{
    createCylinderMeshData(numVerts, numInds, verts, inds, 0.1, 0, 0.2, 8);
}

void drawGui()
{
    ImGui::Begin(""user"");
    ImGui::Checkbox(""wireframe"", &wireframe);
    ImGui::End();
}

void userDraws(float dt)
{
    drawGui();

    pushColor(RED);

    /*for(int i = 0; i < numVerts; i++)
    {
        drawPoint(verts[subDivs][i]);
    }*/

    for(int i = 0; i < numInds; i+=3)
    {
        vec3 p0 = verts[inds[i]].pos;
        vec3 p1 = verts[inds[i+1]].pos;
        vec3 p2 = verts[inds[i+2]].pos;
            
        if(wireframe) {
            drawLine(p0, p1);
            drawLine(p1, p2);
            drawLine(p2, p0);
        }
        else {
            drawTriangle(p0, p1, p2);
        }
    }
    popColor();

    pushColor(BLUE);
    for(int i = 0; i < numVerts; i++)
    {
        const vec3 p = verts[i].pos;
        const vec3 n = 0.05f * verts[i].normal;
        drawLine(p, p+n);
    }

    popColor();
}",resolution
503,"/* SPDX-License-Identifier: Apache-2.0 */

/*
 * Copyright 2023 XIA LLC, 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.
 */

/** @file swaggy_crows.cpp
 * @brief The main file for a REST API implemented w/ Swagger UI.
 */
#include <crow.h>

int main(int argc, char** argv) {
    crow::SimpleApp app;

    CROW_ROUTE(app, ""/"")([]() { return ""Welcome to a Crow implementation w/ Swagger UI""; });

    crow::Blueprint swag(""swagger"", ""docs/swagger/static"", ""docs/swagger/templates"");
    CROW_BP_ROUTE(swag, ""/"")
    ([]() {
        auto  [MASK]  = crow::mustache::load(""swagger.html"");
        return  [MASK] .render();
    });
    app.register_blueprint(swag);

    app.port(18080).multithreaded().run();
}",page
504,"// EchoAnonymousePipe.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include ""stdafx.h""

#include <stdio.h>
#include <Windows.h>

//------------------------------------------------------------------------------
// 전역 상수 정의
//------------------------------------------------------------------------------
static const int MAX_LINE = 1024;

//------------------------------------------------------------------------------
// 엔트리 포인트
//------------------------------------------------------------------------------
int wmain(int argc, wchar_t* argv[])
{
    SECURITY_ATTRIBUTES SecurityAttribute;
    SecurityAttribute.nLength = sizeof(SECURITY_ATTRIBUTES);
    SecurityAttribute.lpSecurityDescriptor = NULL;
    SecurityAttribute.bInheritHandle = TRUE;

    HANDLE ReadPipe = NULL;
    HANDLE WritePipe = NULL;

    BOOL ResultPipe = CreatePipe(&ReadPipe, 
                                 &WritePipe,
                                 &SecurityAttribute, 
                                 0);
    if(ResultPipe != TRUE)
    {
        wprintf_s(L""Pipe create failed!\n"");
        return SEVERITY_ERROR;
    }

    wchar_t Directory[MAX_PATH] = { 0 };
    GetCurrentDirectoryW(MAX_PATH, Directory);

    wchar_t CommandLine[256] = { 0 };
    _snwprintf_s(CommandLine, 
                 _countof(CommandLine), 
                 L""..\\..\\Output\\IPC\\EchoAnonymousePipeClient.exe %d"",
                 //L""E:\\MyWork\\Study\\NetworkStudy\\FirstNetwork\\Output\\IPC\\EchoAnonymousePipeClient.exe %d"",
                 (HANDLE)ReadPipe);

    STARTUPINFO  [MASK] ;
    memset(& [MASK] , 0, sizeof(STARTUPINFO));
     [MASK] .cb = sizeof( [MASK] );

    PROCESS_INFORMATION ProcessInformation;

    int ResultProcess = CreateProcessW(NULL,
                                       CommandLine,
                                       NULL,
                                       NULL,
                                       TRUE,
                                       CREATE_NEW_CONSOLE,
                                       NULL,
                                       NULL,
                                       & [MASK] ,
                                       &ProcessInformation);
    if(ResultProcess != TRUE)
    {
        wprintf_s(L""Error! %d\n"", GetLastError());
        return SEVERITY_ERROR;
    }

    //char Buffer[MAX_LINE] = { 0 };
    wchar_t Buffer[MAX_LINE] = { 0 };
    while(true)
    {
        wprintf_s(L""> "");
        //fgets(Buffer, MAX_LINE, stdin);
        fgetws(Buffer, MAX_LINE, stdin);
        //if(strncmp(Buffer, ""Quit\n"", 5) == 0)
        if(wcsncmp(Buffer, L""Quit\n"", 5) == 0)
        {
            break;
        }

        DWORD NumberOfBytesWritten = 0;
        WriteFile(WritePipe, 
                  reinterpret_cast<LPCVOID>(Buffer),
                  sizeof(wchar_t) * wcslen(Buffer), /*strlen(Buffer),*/
                  &NumberOfBytesWritten, 
                  NULL);
    }

    return SEVERITY_SUCCESS;
}

",StartupInfo
505,"#include<iostream>
//#include<vector>
//#include<string>
#include<cstdio>
#include<cmath>
using namespace std;

//HDU 2001


int main()
{
    double x_1, [MASK] ,x_2,y_2;
    while(cin>>x_1>> [MASK] >>x_2>>y_2)
    {
        printf(""%.2f\n"",sqrt(pow((x_1-x_2),2)+pow(( [MASK] -y_2),2)));
    }
    return 0;
}


// void input(vector<string> &vint){
//     string b;
//     while(getline(cin,b))
//     {
//         vint.push_back(b);
//     }
// }
    
// void cpe(vector<string> &vint)
// {
//     int i=0,eof=vint.size();
//     for(i=0;i!=eof;++i)
//     {
//         //读取信息
//         printf(""%.2f\n"",sqrt((vint[i][0]-vint[i][2])*(vint[i][0]-vint[i][2])+(vint[i][4]-vint[i][6])*(vint[i][4]-vint[i][6])));

//     }
// }

// int main()
// {
//     vector<string> vint;
//     //输入
//     input(vint);
//     //输出
//     cpe(vint);
//     return 0;
// }",y_1
506,"#include <iostream>
#include<opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include ""add_frame.h""
#include <QtCore>
#include <QWidget>

using namespace std;
using namespace cv;

Mat QImage2cvMatframe(QImage image) {
    cv::Mat mat;
    cv::Mat dst;

    switch(image.format())
    {
    case QImage::Format_ARGB32:
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32_Premultiplied:

        image = image.convertToFormat(QImage::Format_RGB888);
        mat = cv::Mat(image.height(), image.width(), CV_8UC3, (void*)image.constBits(), image.bytesPerLine());
        cv::cvtColor(mat, dst, COLOR_BGR2RGB);
        break;
    case QImage::Format_RGB888:
        mat = cv::Mat(image.height(), image.width(), CV_8UC3, (void*)image.constBits(), image.bytesPerLine());
        cv::cvtColor(mat, dst, COLOR_BGR2RGB);
        break;
    case QImage::Format_Indexed8:
        mat = cv::Mat(image.height(), image.width(), CV_8UC1, (void*)image.constBits(), image.bytesPerLine());
        break;
    }
    return dst;

}




Mat addframe(Mat img, int frame_num){

   // Mat frame1, frame2, frame3, frame4;

    int  [MASK]  = 10;
    if (frame_num == 1)
    {
         [MASK]  = 10;
        QImage *frameImage1;
        frameImage1 = new QImage("":/images/heart.jpg"");
        frame = QImage2cvMatframe(*frameImage1);
    }

    if (frame_num == 2)
    {
         [MASK]  = 30;
        QImage *frameImage2;
        frameImage2 = new QImage("":/images/Gauty.jpg"");
        frame = QImage2cvMatframe(*frameImage2);
    }

    if (frame_num == 3)
    {
         [MASK]  = 10;
        QImage *frameImage3;
        frameImage3 = new QImage("":/images/COCOa.jpg"");
        frame = QImage2cvMatframe(*frameImage3);
    }

    if (frame_num == 4)
    {
         [MASK]  = 100;
        QImage *frameImage4;
        frameImage4 = new QImage("":/images/Vintage.jpg"");
        frame = QImage2cvMatframe(*frameImage4);
    }

    resize(frame, frame, Size(img.cols,img.rows), 0, 0, INTER_LINEAR);
    cvtColor(frame,mask,COLOR_BGR2GRAY);
    bitwise_not(mask, mask);
    threshold(mask, mask,  [MASK] , 255, THRESH_BINARY);
    frame.copyTo(img,mask);
    return img.clone();
}


Mat addframe_cv(Mat img, int mode){
    top = int (0.15*img.rows);
    bottom = static_cast<int> (0.15*img.rows);
    int left = static_cast<int> (0.15*img.cols);
    int right = static_cast<int> (0.15*img.cols);

    //边缘模糊
    if(mode == 1){
    borderType=BORDER_REPLICATE;
    copyMakeBorder( img, dst, top, bottom, left, right, borderType);
    }
    //边缘翻转
    if (mode==2){
    borderType=BORDER_REFLECT_101;
    copyMakeBorder( img, dst, top, bottom, left, right, borderType);
    }
    //黑边框
    if(mode == 3){
    Scalar value(0 ,0, 0);
    borderType=BORDER_CONSTANT;
    copyMakeBorder( img, dst, top, bottom, left, right, borderType,value);

    }
    //白边框
    if(mode == 4){
    Scalar value2(255,255,255);
    borderType=BORDER_CONSTANT;
    copyMakeBorder( img, dst, top, bottom, left, right, borderType,value2);

    }
    return dst;
}
",parameter
507,"#include ""external/ppp2code/file/std_lib_facilities.h""

int main()
{
  string  [MASK]  = """";
  string recipient_name = ""???"";
  string friend_name = ""???"";
  char friend_gender = 0;
  int recipient_age = -1;

  cout << ""Enter your name"" << endl;
  cin >>  [MASK] ;
  cout << ""Enter the name of the person you want to write to"" << endl;
  cin >> recipient_name;
  cout << ""Enter a name of your friend"" << endl;
  cin >> friend_name;

  while (friend_gender != 'f' && friend_gender != 'm')
  {
    cout << ""Enter the gender of the freind (f or m)"" << endl;
    cin >> friend_gender;
  }

  cout << ""Enter the age of the recipient"" << endl;
  cin >> recipient_age;

  if (recipient_age <= 0 || recipient_age >= 110)
  {
    simple_error(""you're kidding!"");
  }

  cout << ""Dear "" << recipient_name << "","";
  cout << ""How are you? I am fine. I miss you."" << endl;

  cout << ""Have you seen "" << friend_name << "" lately?"";
  cout << "" If you see "" << friend_name << "" please ask "" << (friend_gender == 'f' ? ""her"" : ""him"") << "" to call me."" << endl;

  cout << ""I hear you just had a birthday and you are "" << recipient_age << "" years old."";

  if (recipient_age < 12)
  {
    cout << "" Next year you will be "" << recipient_age + 1 << ""."";
  }
  else if (recipient_age == 17)
  {
    cout << "" Next year you will be able to vote."";
  }
  else if (recipient_age >= 70)
  {
    cout << "" I hope you are enjoying retirement."";
  }

  cout << endl;
  cout << ""Yours sincerely"" << endl;
  cout << endl << endl;

  cout <<  [MASK]  << endl;
  return 0;
}
",writer_name
508,"//Nome completo: <NAME>
//Matrícula: UC20100728
//Curso: Engenharia de Software

#include <stdio.h> //BIBLIOTECA PARA SCANF, PRINTF...
#include <locale.h> //BIBLIOTECA PARA PRINTAR CARACTERES ESPECIAIS
#include <stdlib.h> //BIBLIOTECA PARA O SYSTEM(""CLS"")
#include <string.h> //BIBLIOTECA PARA STRING
#include<windows.h> //BIBLIOTECA PARA AS CORES

 enum DOS_COLORS{ //DECLARAÇÃO DAS CORES
 preto, azul, verde, CYAN, vermelho, MAGENTA, castanho,
 cizento_claro, cizento_escuro, azul_claro, verde_claro, CYAN_claro,
 vermelho_claro, MAGENTA_claro, amarelo, branco
 };


 void textcolor(int  [MASK] ){
 HANDLE hl = GetStdHandle(STD_OUTPUT_HANDLE);
 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
 BOOL b = GetConsoleScreenBufferInfo(hl, &bufferInfo);
 bufferInfo.wAttributes &= 0x00F0;
 SetConsoleTextAttribute (hl, bufferInfo.wAttributes |=  [MASK] );
 }
int main(void){ //INICIO DO ALGORITMO
	 setlocale(LC_ALL, ""Portuguese"");
	 char destino[20], confirmarReserva[2]; //DECLARAÇÃO DAS VARIÁVEIS
	 int assentos, menu, reserva, passagemCliente[500], idadeCliente[500], passagem, teste, contador, i, id, j, k, local[10][20];
	 int reservaTotal, confirmadoTotal, disponivelTotal, montanteTotal;
	 char letra[10][20];
	 
	 k=0;
	 j=0;
	 contador=0;
     i=0;
	 assentos=0;
	 menu=0;
	 idadeCliente[500]=0;
	 passagem=0;
	 passagemCliente[500]=0;
	 reservaTotal=0;
	 confirmadoTotal=0;
	 disponivelTotal=0;
	 montanteTotal=0;
	 
	 printf(""\n===========Bem Vindo ao controle de passagens da SALUMAR LINHAS AEREAS===========\n"");
	 printf(""\nPara prosseguir digite o nome do destino do voo: "");
	 fgets(destino, 20, stdin);
	 fflush(stdin);
	 while (strcmp(destino, ""\n"") == 0 || strcmp(destino, ""vazio\n"") == 0 || destino[0]==' ' ){ //WHILE PARA O NOME DO DESTINO NÃO SER NULO
	  	printf(""Digite um destino válido: "");
	  	fgets(destino, 40, stdin);
	  	fflush(stdin);
	 }
	 
	 printf(""\nDigite a quantidade de assentos existentes para o avião: "");
	 scanf(""%d"", &assentos);
	 fflush(stdin);
	 while (assentos<90 || assentos>200){ //WHILE PARA O NÚMERO DE ASSENTOS SER MAIOR IGUAL A 90 E MENOR IGUAL A 200
	 	printf(""\nDigite uma quantidade entre 90 e 200 assentos: "");
	 	scanf(""%d"", &assentos);
	 	fflush(stdin);
	 }
	    printf(""\nDigite o valor cheio da passagem: "");
	    scanf(""%d"", &passagem);
	    fflush(stdin);
	    system(""cls"");
	    
	    while (passagem>=1){ //WHILE PARA O MENU PRINCIPAL
	    	
	 system(""cls""); //FUNÇÃO PARA LIMPAR A TELA	
	 printf(""\n=========== MENU DE RESERVAS ===========\n"");
	 printf(""\n[1]=== Consultar o mapa do avião\n"");
	 printf(""\n[2]=== Efetuar uma reserva\n"");
	 printf(""\n[3]=== Confirmar uma reserva\n"");
	 printf(""\n[4]=== Cancelar uma reserva\n"");
	 printf(""\n[5]=== Relatório de reservas\n"");
	 printf(""\n=========== MENU DE RESERVAS ===========\n"");
	 printf(""\nDigite a opção que deseja realizar: "");
	 scanf(""%d"", &menu);
	 fflush(stdin);
	 
	 switch(menu){ //SWITCH CASE PARA AS OPÇÕES DO MENU

case 1: //CASE PARA CONSULTAR O MAPA

  system(""cls"");
            for ( k = 0; k < 10; k++)
            {
            for ( j = 0; j < 20; j++)
            {
            contador++;
            local[k][j]=contador;
            }
            }
            for ( k = 0; k < 10; k++)
            {
            for ( j = 0; j < 20; j++)
            {
            if (local[k][j] <= assentos)
            {
            letra[k][j] = 'D';
            }
            }
            }
  
        printf(""\n=========== MAPA DE RESERVAS ===========\n"");
        textcolor(amarelo);
        printf(""Lugares disponiveis\n"");
        for(j=0;j<20;j++){
        for(k=0;k<10;k++){
            if(local[k][j]<=contador && (letra[k][j]=='D' || letra[k][j]=='R' || letra[k][j]=='C')){
                if (letra[k][j]=='R')
                {
                    textcolor(vermelho);
                    printf(""%.3d "", local[k][j]);
                    printf(""%c "", letra[k][j]);
                    textcolor(verde_claro);
                } else if (letra[k][j]=='D'){
                    textcolor(verde_claro);
                    printf(""%.3d "", local[k][j]);
                    printf(""%c "", letra[k][j]);
                    textcolor(branco);
                } else if (letra[k][j]=='C')
                {
                    textcolor(azul);
                    printf(""%.3d "", local[k][j]);
                    printf(""%c "", letra[k][j]);
                    textcolor(amarelo);
                }

                } 
            } 
        printf(""\n"");
        }
        k=0;
        j=0;
        printf(""\n"");
        textcolor(vermelho);
        printf(""reservado  "");
        textcolor(azul);
        printf(""confirmado  "");
        textcolor(verde);
        printf(""disponivel  \n"");
        textcolor(amarelo);

        system(""pause""); //FUNÇÃO ENTER PARA CONTINUAR
        
  
    break;
    
case 2: //CASE PARA EFETUAR UMA RESERVA
	if (i<assentos){
	    i++;
  	    system(""cls"");
  	  	printf(""\n=========== RESERVAR ASSENTOS ===========\n"");
  		printf(""\nQual a idade do cliente?: "");
		scanf(""%d"", &idadeCliente[500]);
		fflush(stdin);   
		printf(""\nSeu id de reserva é: %d\n\n"", i);	    
		printf(""=========== RESERVAR ASSENTOS ===========\n\n"");
		reservaTotal++;
		system(""\npause"");
	}
	else {
		printf(""\n===========================================================\n"");
		printf(""===========TODOS OS ASSENTOS JÁ FORAM RESERVADOS===========\n"");
		printf(""===========================================================\n\n"");
		system(""\npause"");
	}
		break;        
		            
case 3: //CASE PARA CONFIRMAR UMA RESERVA
        system(""cls"");
        printf(""\n=========== CONFIRMAR RESERVA ===========\n\n"");
        printf(""Você quer confirmar a reserva de qual id?: "");
        scanf(""%d"", &id);
		fflush(stdin); 
		  
		while (id>i){
			printf(""Digite um id válido: "");
			scanf(""%d"", &id);
		    fflush(stdin); 
	     	}
		     
			 if (idadeCliente[id]<5){
		         passagemCliente[id] = passagem * 0.5;
			 }
		     else {
		     	 passagemCliente[id] = passagem;
			 }
			  
		     printf(""\nO valor total da passagem será de R$%d"", passagemCliente[id]);
  			 printf(""\nDeseja CONFIRMAR a reserva? (USE [S] PARA CONFIRMAR): "");
  			 fgets(confirmarReserva, 2, stdin);
  			 fflush(stdin);
  			 system(""cls"");
  				if (strcmp(confirmarReserva, ""s"") == 0 || strcmp(confirmarReserva, ""S"") == 0 ){	
					printf(""\n=========== RESERVA CONFIRMADA ===========\n"");
					printf(""\nValor total da passagem: %d\n"", passagemCliente[id]);
					printf(""\n=========== RESERVA CONFIRMADA ===========\n""); 
					reservaTotal = reservaTotal - 1;
					confirmadoTotal++;
					disponivelTotal = assentos - (reservaTotal + confirmadoTotal);
					montanteTotal = montanteTotal + passagemCliente[id]; 		
					system(""pause"");
				    }
  					else {
					printf(""\n=========== RESERVA NÃO CONFIRMADA ===========\n"");
  					printf(""\n============= REFAÇA A RESERVA =============\n"");
					system(""pause"");
		            }
					break;
case 4: //CASE PARA CANCELAR UMA RESERVA
	         system(""cls"");
	         printf(""\n=========== CANCELAMENTO DE RESERVA ===========\n\n"");
             printf(""\nDigite o id da sua reserva para o CANCELAMENTO: "");
             scanf(""%d"", id);
             fflush(stdin);
             printf(""Você tem certeza que deseja a reserva: \n"");
             printf(""id: %d"", id);
             printf(""idade: %d"", idadeCliente[id]);
             printf(""Valor: %d"", passagemCliente[id]);
             system(""cls"");			 
			 printf(""\nSua reserva já foi confirmada?(Use S para SIM, ou qualquer letra para NÃO): "");
  			 fgets(confirmarReserva, 2, stdin);
  			 fflush(stdin);
  			 system(""cls"");
  				if (strcmp(confirmarReserva, ""s"") == 0 || strcmp(confirmarReserva, ""S"") == 0 ){	//IF PARA RESERVAS JÁ CONFIRMADAS
					printf(""\n=========== RESERVA CANCELADA ===========\n"");
                    printf(""=========== RESERVA CANCELADA ===========""); 
					printf(""\n=========== RESERVA CANCELADA ===========\n""); 
					confirmadoTotal = confirmadoTotal - 1;
					disponivelTotal = assentos + 1;
					montanteTotal = montanteTotal - passagemCliente[id]; 		
					system(""pause"");
				    }
  					else {
				    printf(""\n=========== RESERVA CANCELADA ===========\n"");
                    printf(""=========== RESERVA CANCELADA ===========""); 
					printf(""\n=========== RESERVA CANCELADA ===========\n""); 
					reservaTotal = reservaTotal - 1;
					disponivelTotal = assentos + 1;
					montanteTotal = montanteTotal - passagemCliente[id]; 		
					system(""pause"");
					system(""pause"");
		            }
			 
					break;
					
case 5: //CASE PARA VER O RELATÓRIO DE RESERVAS    
             system(""cls"");
             printf(""\n=========== RELATÓRIO ===========\n\n"");
             printf(""Total de RESERVAS: %d\n"", reservaTotal);
             printf(""Total de reservas CONFIRMADAS: %d\n"", confirmadoTotal);
             printf(""Total de assentos DISPONÍVEIS: %d\n"", disponivelTotal);
             printf(""Total arrecadado: %d\n"", montanteTotal);
             printf(""\n=========== RELATÓRIO ===========\n"");
			 system(""pause"");
					
					break;
					
					
					
	}}		 		        
	 return 0;
}
",iColor
509,"#pragma once

#include ""Engine3D.h""

#include <glm\glm.hpp>
#include <glm\gtc\matrix_transform.hpp>
#include <glm\gtc\quaternion.hpp>
#include <glm\gtx\quaternion.hpp>

namespace E3D
{
	class Player : public ScriptableEntity
	{
	public:
		glm::quat GetOrientation()
		{
			return glm::normalize(glm::angleAxis(GetComponent<TransformComponent>().Rotation.y, glm::vec3(0.0f, 1.0f, 0.0f)) *
				glm::angleAxis(GetComponent<TransformComponent>().Rotation.z, glm::vec3(1.0f, 0.0f, 0.0f)));
		}
		glm::vec3 GetUp()
		{
			return glm::normalize(GetOrientation() * glm::vec3(0.0f, 1.0f, 0.0f));
		}

		glm::vec3 GetRight()
		{
			return glm::normalize(GetOrientation() * glm::vec3(1.0f, 0.0f, 0.0f));
		}

		glm::vec3 GetFront()
		{
			return glm::normalize(GetOrientation() * glm::vec3(0.0f, 0.0f, -1.0f));
		}

		virtual void OnCreate() override
		{

		}

		virtual void OnUpdate(Timestep ts) override
		{
			auto& tc = GetComponent<TransformComponent>();
			float speed = 50.0f;
			float  [MASK]  = 180.0f;

			glm::vec3 forward = { 0.0f, 0.0f, -1.0f };
			glm::vec3 up = { 0.0f, 1.0f, 0.0f };
			glm::vec3 right = { 1.0f, 0.0f, 0.0f };

			if (Input::IsKeyPressed(E3D_KEY_UP))
			{
				tc.Translation += GetFront() * speed * (float)ts;
				tc.Translation += GetUp() * speed * (float)ts * sin(GetComponent<TransformComponent>().Rotation.x);
			}
			else if (Input::IsKeyPressed(E3D_KEY_DOWN))
			{
				tc.Translation -= GetFront() * speed * (float)ts;
				tc.Translation -= GetUp() * speed * (float)ts * sin(GetComponent<TransformComponent>().Rotation.x);
			}
			if (Input::IsKeyPressed(E3D_KEY_LEFT))
			{
				tc.Rotation.y += glm::radians( [MASK]  * ts);
			}
			else if (Input::IsKeyPressed(E3D_KEY_RIGHT))
			{
				tc.Rotation.y -= glm::radians( [MASK]  * ts);
			}
			if (Input::IsKeyPressed(E3D_KEY_I))
			{
				tc.Rotation.x += glm::radians( [MASK]  * ts);
			}
			else if (Input::IsKeyPressed(E3D_KEY_K))
			{
				tc.Rotation.x -= glm::radians( [MASK]  * ts);
			}
		}

		virtual void OnDestroy() override
		{

		}
	};
}",rotation
510,"// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0

// This testbench offers partial testing of the simumated memory controller
// response banks:
//  * Response integrity.
//  * Response ordering per AXI identifier.
//
// The testbench is divided into 2 parts:
//  * Definition of the RspBankTestbench class, which is the interface with
//  the design under
//    test.
//  * Definition of a manual and a randomized testbench. The randomized
//  testbench randomly applies
//    inputs and observe output delays and contents.

#include ""Vsimmem_rsp_bank.h""
#include ""verilated.h""
#include <cassert>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <stdlib.h>
#include <vector>
#include <verilated_fst_c.h>

// Choose whether to display all the transactions
const bool kTransactionsVerbose = false;
// Choose whether to display all (input,output) pairs in the end of each
// execution.
const bool kPairsVerbose = true;

// Length of the reset signal.
const int kResetLength = 5;  // Cycles
// Depth of the trace.
const int kTraceLevel = 6;

// These must match with the IDWidth and XRespWidth defined in rtl/simmem_pkg.sv
const int kIdWidth = 2;   // AXI identifier width
const int kRspWidth = 4;  // Whole response width

// Testbench choice.
typedef enum { MANUAL_TEST, RANDOMIZED_TEST } test_strategy_e;
const test_strategy_e kTestStrategy = RANDOMIZED_TEST;

// Determines the number of independent testbenches are performed in the
// randomized testbench. Set to 1 to proceed with wave analysis.
const size_t kNumRandomTestRounds = 100;

// Determines the number of steps per randomized testbench round.
const size_t kNumRandomTestSteps = 1000;

// Determines the number of AXI identifiers involved in the randomized
// testbench.
const size_t kNumIdentifiers = 2;

typedef Vsimmem_rsp_bank Module;
typedef std::map<uint32_t, std::queue<uint32_t>> queue_map_t;

// This class implements elementary interaction with the design under test.
class RspBankTestbench {
 public:
  /**
   * @param record_trace set to false to skip trace recording
   */
  RspBankTestbench(bool record_trace = true,
                   const std::string &trace_filename = ""sim.fst"")
      : tick_count_(0l), record_trace_(record_trace), module_(new Module) {
    if (record_trace) {
      trace_ = new VerilatedFstC;
      module_->trace(trace_, kTraceLevel);
      trace_->open(trace_filename.c_str());
    }

    // Puts ones at the fields' places
    id_mask_ = ~((1 << 31) >> (31 - kIdWidth));
    content_mask_ = ~((1 << 31) >> (31 - kRspWidth)) & ~id_mask_;

    // The delay bank is supposedly always ready to receive address requests.
    module_->delay_calc_ready_i = 1;
  }

  ~RspBankTestbench(void) { simmem_close_trace(); }

  void simmem_reset(void) {
    module_->rst_ni = 0;
    this->simmem_tick(kResetLength);
    module_->rst_ni = 1;
  }

  void simmem_close_trace(void) { trace_->close(); }

  /**
   * Performs one or multiple clock cycles.
   *
   * @param num_ticks the number of ticks to perform at once
   */
  void simmem_tick(int num_ticks = 1) {
    for (size_t i = 0; i < num_ticks; i++) {
      tick_count_++;

      module_->clk_i = 0;
      module_->eval();

      if (record_trace_) {
        trace_->dump(5 * tick_count_ - 1);
      }
      module_->clk_i = 1;
      module_->eval();

      if (record_trace_) {
        trace_->dump(5 * tick_count_);
      }
      module_->clk_i = 0;
      module_->eval();

      if (record_trace_) {
        trace_->dump(5 * tick_count_ + 2);
        trace_->flush();
      }
    }
  }

  /**
   * Sets the reservation request signal to one and the reservation request
   * identifier to the right value.
   *
   * @param axi_id the AXI identifier to reserve
   */
  void simmem_reservation_start(uint32_t axi_id) {
    module_->rsv_valid_i = 1;
    module_->rsv_req_id_onehot_i = 1 << axi_id;

    // Must be not larger than MaxBurstLenField
    module_->rsv_burst_len_i = 2;
  }

  /**
   * Sets the reservation request signal to zero.
   */
  void simmem_reservation_stop(void) { module_->rsv_valid_i = 0; }

  /**
   * Applies valid input data.
   *
   * @param identifier the AXI identifier of the incoming data
   * @param rsp the rest (rsp) of the incoming data
   *
   * @return the data as seen by the design under test instance
   */
  uint32_t simmem_input_rsp_apply(uint32_t identifier, uint32_t rsp) {
    // Checks if the given values are not too big
    assert(!(rsp >> kRspWidth));
    assert(!(identifier >> kIdWidth));

    uint32_t in_rsp = rsp << kIdWidth | identifier;
    module_->rsp_i = in_rsp;
    module_->in_rsp_valid_i = 1;
    return in_rsp;
  }

  /**
   * Gets the newly reserved address as offered by the DUT.
   */
  uint32_t simmem_reservation_get_address(void) { return module_->rsv_iid_o; }

  /**
   * Checks whether the input data has been accepted by checking the ready
   * output signal.
   */
  bool simmem_input_rsp_check(void) {
    module_->eval();
    return (bool)(module_->in_rsp_ready_o);
  }

  /**
   * Checks whether the reservation request has been accepted.
   */
  bool simmem_reservation_check(void) {
    module_->eval();
    return (bool)(module_->rsv_ready_o);
  }

  /**
   * Stops applying data to the DUT instance.
   */
  void simmem_input_rsp_stop(void) { module_->in_rsp_valid_i = 0; }

  /**
   * Allows all the data output from a releaser module standpoint.
   */
  void simmem_output_rsp_allow(void) { module_->release_en_i = -1; }

  /**
   * Forbids all the data output from a releaser module standpoint.
   */
  void simmem_output_rsp_forbid(void) { module_->release_en_i = 0; }

  /**
   * Sets the ready signal to one on the output side.
   */
  void simmem_output_rsp_request(void) { module_->out_rsp_ready_i = 1; }

  /**
   * Tries to fetch output data. Requires the ready signal to be one at the DUT
   * output.
   *
   * @param out_rsp the output data from the DUT
   *
   * @return true iff the data is valid
   */
  bool simmem_output_rsp_fetch(uint32_t &out_rsp) {
    module_->eval();
    assert(module_->out_rsp_ready_i);

    out_rsp = (uint32_t)module_->rsp_o;
    return (bool)(module_->out_rsp_valid_o);
  }

  /**
   * Sets the ready signal to zero on the output side.
   */
  void simmem_output_rsp_stop(void) { module_->out_rsp_ready_i = 0; }

  /**
   * Getters.
   */
  uint32_t simmem_get_content_mask(void) { return content_mask_; }
  uint32_t simmem_get_identifier_mask(void) { return id_mask_; }

 private:
  vluint32_t tick_count_;
  bool record_trace_;
  std::unique_ptr<Module> module_;
  VerilatedFstC *trace_;

  // Masks that contain ones in the corresponding fields.
  uint32_t id_mask_;
  uint32_t content_mask_;
};

/**
 * Performs a basic test as a temporally disjoint sequence of reservation, data
 * input and data output.
 *
 * @param tb a pointer to a fresh testbench instance
 */
void manual_test(RspBankTestbench *tb) {
  tb->simmem_reset();

  // Apply reservation requests for 4 ticks
  tb->simmem_reservation_start(
      3);  // Start issuing reservation requests for AXI ID 3
  tb->simmem_tick(4);
  tb->simmem_reservation_stop();  // Stop issuing reservation requests

  tb->simmem_tick(4);

  // Apply inputs for 6 ticks
  tb->simmem_input_rsp_apply(3, 2);
  tb->simmem_tick(7);
  tb->simmem_input_rsp_stop();

  tb->simmem_tick(4);

  // Enable data toutput
  tb->simmem_output_rsp_allow();
  tb->simmem_tick(5);

  tb->simmem_output_rsp_request();
  tb->simmem_tick(10);
  tb->simmem_output_rsp_stop();

  tb->simmem_tick(100);
}

/**
 * This function implements a more complete, randomized and automatic testbench.
 *
 * @param tb A pointer the the already contructed RspBankTestbench object.
 * @param num_ids The number of AXI identifiers to involve. Must be at
 * least 1, and lower than 1 << kIdWidth.
 * @param seed The seed for the randomized test.
 * @param num_cycles The number of simulated clock cycles.
 */
size_t randomized_testbench(RspBankTestbench *tb, size_t num_ids,
                            unsigned int seed, size_t num_cycles) {
  srand(seed);
  assert(num_ids < (1 << kIdWidth));

  // The AXI identifiers. During the testbench, we will always use the
  // [0,..,num_ids) ids.
  std::vector<uint32_t> ids;
  for (size_t i = 0; i < num_ids; i++) {
    ids.push_back(i);
  }

  // These structures will store the input and output data, for comparison
  // purposes.
  queue_map_t input_queues;
  queue_map_t output_queues;

  for (size_t i = 0; i < num_ids; i++) {
    input_queues.insert(std::pair<uint32_t, std::queue<uint32_t>>(
        ids[i], std::queue<uint32_t>()));
    output_queues.insert(std::pair<uint32_t, std::queue<uint32_t>>(
        ids[i], std::queue<uint32_t>()));
  }

  // Signal whether some input is applied to the simmem.
  bool reserve;
  bool apply_input;
  bool request_output_rsp;

  bool  [MASK] ;  // Variable only used for display purposes.

  // Initialization of the next messages that will be supplied.
  uint32_t current_input_id = ids[rand() % num_ids];
  uint32_t current_content =
      (uint32_t)((rand() & tb->simmem_get_content_mask()) >> kIdWidth);
  uint32_t current_reservation_id = ids[rand() % num_ids];
  uint32_t current_input;
  uint32_t current_output;

  //////////////////////
  // Simulation start //
  //////////////////////

  tb->simmem_reset();

  // The ready signal is always 1 for the simmem output.
  tb->simmem_output_rsp_allow();

  for (size_t i = 0; i < num_cycles; i++) {
     [MASK]  = false;

    // Setting a new input identifier prevents the deadlock situation where all
    // the RAM extended cells are reserved for AXI IDs different from the
    // identifier of the input. This deadlock situation is not representative of
    // real operation, where deadlocks are prevented by the reservation
    // mechanism.
    current_input_id = ids[rand() % num_ids];

    // Randomize the boolean signals deciding which interactions will happen in
    // this cycle.
    reserve = (bool)(rand() & 1);
    apply_input = (bool)(rand() & 1);
    request_output_rsp = (bool)(rand() & 1);

    if (reserve) {
      // Apply the reservation request.
      tb->simmem_reservation_start(current_reservation_id);
    }
    if (apply_input) {
      // Apply the input response.
      current_input =
          tb->simmem_input_rsp_apply(current_input_id, current_content);
    }
    if (request_output_rsp) {
      // Fetch an output if the handshake is successful.
      tb->simmem_output_rsp_request();
    }

    // Only perform the evaluation once all the inputs have been applied
    if (reserve && tb->simmem_reservation_check()) {
      if (kTransactionsVerbose) {
        if (! [MASK] ) {
           [MASK]  = true;
          std::cout << std::endl << ""Step "" << std::dec << i << std::endl;
        }
        std::cout << current_reservation_id << "" reserves ""
                  << tb->simmem_reservation_get_address() << std::endl;
      }

      // Renew the reservation identifier if the reservation is successful.
      current_reservation_id = ids[rand() % num_ids];
    }
    if (tb->simmem_input_rsp_check()) {
      // If the input handshake is successful, then add the input into the
      // corresponding queue.
      input_queues[current_input_id].push(current_input);
      if (kTransactionsVerbose) {
        if (! [MASK] ) {
           [MASK]  = true;
          std::cout << std::endl << ""Step "" << std::dec << i << std::endl;
        }
        std::cout << std::dec << current_input_id << "" inputs "" << std::hex
                  << current_input << std::endl;
      }

      // Renew the input data if the input handshake is successful
      current_content =
          (uint32_t)((rand() & tb->simmem_get_content_mask()) >> kIdWidth);
    }
    if (request_output_rsp) {
      // If the output handshake is successful, then add the output to the
      // corresponding queue
      if (tb->simmem_output_rsp_fetch(current_output)) {
        output_queues[ids[(current_output & tb->simmem_get_identifier_mask())]]
            .push(current_output);

        if (kTransactionsVerbose) {
          if (! [MASK] ) {
             [MASK]  = true;
            std::cout << std::endl << ""Step "" << std::dec << i << std::endl;
          }
          std::cout << std::dec
                    << (uint32_t)(current_output &
                                  tb->simmem_get_identifier_mask())
                    << "" outputs "" << std::hex << current_output << std::endl;
        }
      }
    }

    tb->simmem_tick();

    // Reset all signals after tick (they may be set again before the next DUT
    // evaluation during the beginning of the next iteration)
    if (reserve) {
      tb->simmem_reservation_stop();
    }
    if (apply_input) {
      tb->simmem_input_rsp_stop();
    }
    if (request_output_rsp) {
      tb->simmem_output_rsp_stop();
    }
  }

  tb->simmem_tick(100);

  // Check the input and output queues for mismatches.
  size_t num_mismatches = 0;
  for (size_t i = 0; i < num_ids; i++) {
    if (kPairsVerbose) {
      std::cout << std::dec << ""--- AXI ID: "" << i << "" ---"" << std::endl;
    }
    while (!input_queues[i].empty() && !output_queues[i].empty()) {
      current_input = input_queues[i].front();
      current_output = output_queues[i].front();

      input_queues[i].pop();
      output_queues[i].pop();
      if (kPairsVerbose) {
        std::cout << std::hex << current_input << "" - "" << current_output
                  << std::endl;
      }
      num_mismatches += (size_t)(current_input != current_output);
    }
  }
  return num_mismatches;
}

int main(int argc, char **argv, char **env) {
  Verilated::commandArgs(argc, argv);
  Verilated::traceEverOn(true);

  // Counts the number of mismatches during the whole test
  size_t total_num_mismatches = 0;

  for (unsigned int seed = 0; seed < kNumRandomTestRounds; seed++) {
    // Counts the number of mismatches during the loop iteration
    size_t local_num_mismatches;

    // Instantiate the DUT instance
    RspBankTestbench *tb = new RspBankTestbench(true, ""rsp_bank.fst"");

    // Perform one test for the given seed
    if (kTestStrategy == MANUAL_TEST) {
      manual_test(tb);
      break;
    } else if (kTestStrategy == RANDOMIZED_TEST) {
      local_num_mismatches =
          randomized_testbench(tb, kNumIdentifiers, seed, kNumRandomTestSteps);
    }

    total_num_mismatches += local_num_mismatches;
    std::cout << ""Mismatches for seed "" << std::dec << seed << "": ""
              << local_num_mismatches << std::hex << std::endl;
    delete tb;
  }

  std::cout << ""Testbench complete!"" << std::endl;

  exit(0);
}
",iteration_announced
511,"/****************************************************************************
 * Copyright (C) 2021 <NAME>.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at https://mozilla.org/MPL/2.0/.
 ****************************************************************************/

#include <ros/ros.h>
#include <nav_msgs/Path.h>
#include <geometry_msgs/Twist.h>
#include <geometry_msgs/TransformStamped.h>
#include <tf/transform_broadcaster.h>
#include <tf/transform_listener.h>
#include <visualization_msgs/Marker.h>

class PathFollower
{
private:
    ros::NodeHandle nh;
    ros::Subscriber path_sub;
    ros::Publisher cmd_pub, twist_pub, target_point_marker_pub;
    std::string map_frame, base_link_frame;
    std::string input_path_topic_name, output_cmd_topic_name;
    nav_msgs::Path path;
    tf::TransformListener tf_listener;
    double look_ahead_dist, max_linear_vel, max_angular_vel;
    double bvz, bvyaw, pgz, dgz, pgyaw, dgyaw;
    double cmd_publish_hz, displacement_threshold, path_target_marker_size;
    bool iterate_following, publish_twist;
    int nearest_path_index, prev_nearest_path_index;

public:
    PathFollower();
    ~PathFollower() {};
    void path_callback(const nav_msgs::Path::ConstPtr& msg);
    void spin(void);
    double check_velocity(double v, double vmax);
};

PathFollower::PathFollower():
    nh(""~""),
    map_frame(""/map""),
    base_link_frame(""/base_link2""),
    input_path_topic_name(""/target_path""),
    output_cmd_topic_name(""/cmd_vel_path_follow""),
    look_ahead_dist(0.05),
    max_linear_vel(0.1),
    max_angular_vel(0.1),
    bvz(1.0),
    bvyaw(1.0),
    pgz(0.4),
    dgz(0.05),
    pgyaw(0.25),
    dgyaw(0.05),
    cmd_publish_hz(20.0),
    path_target_marker_size(0.1),
    displacement_threshold(1.0),
    prev_nearest_path_index(-1),
    iterate_following(false),
    publish_twist(false),
    tf_listener()
{
    // read parameters
    nh.param(""map_frame"", map_frame, map_frame);
    nh.param(""base_link_frame"", base_link_frame, base_link_frame);
    nh.param(""input_path_topic_name"", input_path_topic_name, input_path_topic_name);
    nh.param(""output_cmd_topic_name"", output_cmd_topic_name, output_cmd_topic_name);
    nh.param(""look_ahead_dist"", look_ahead_dist, look_ahead_dist);
    nh.param(""max_linear_vel"", max_linear_vel, max_linear_vel);
    nh.param(""max_angular_vel"", max_angular_vel, max_angular_vel);
    nh.param(""bvz"", bvz, bvz);
    nh.param(""bvyaw"", bvyaw, bvyaw);
    nh.param(""pgz"", pgz, pgz);
    nh.param(""dgz"", dgz, dgz);
    nh.param(""pgyaw"", pgyaw, pgyaw);
    nh.param(""dgyaw"", dgyaw, dgyaw);
    nh.param(""cmd_publish_hz"", cmd_publish_hz, cmd_publish_hz);
    nh.param(""displacement_threshold"", displacement_threshold, displacement_threshold);
    nh.param(""iterate_following"", iterate_following, iterate_following);
    nh.param(""publish_twist"", publish_twist, publish_twist);
    nh.param(""path_target_marker_size"", path_target_marker_size, path_target_marker_size);
    // subscriber
    path_sub = nh.subscribe(input_path_topic_name, 1, &PathFollower::path_callback, this);
    // publisher
    cmd_pub = nh.advertise<geometry_msgs::TransformStamped>(output_cmd_topic_name, 10);
    target_point_marker_pub = nh.advertise<visualization_msgs::Marker>(""/path_following_target_point"", 10);
    if (publish_twist)
        twist_pub = nh.advertise<geometry_msgs::Twist>(""/bebop/cmd_vel"", 10);
}

void PathFollower::path_callback(const nav_msgs::Path::ConstPtr& msg)
{
    path = *msg;
//    prev_nearest_path_index = -1;
}

void PathFollower::spin(void)
{
    prev_nearest_path_index = 0;
    double ezo = 0.0,  [MASK]  = 0.0;
    ros::Rate loop_rate(cmd_publish_hz);
    while (ros::ok())
    {
        ros::spinOnce();
        // read robot pose (base_link_frame) from tf tree in map_frame
        ros::Time now = ros::Time::now();
        tf::StampedTransform map2base_link;
        try
        {
            tf_listener.waitForTransform(map_frame, base_link_frame, now, ros::Duration(1.0));
            tf_listener.lookupTransform(map_frame, base_link_frame, now, map2base_link);
        }
        catch (tf::TransformException ex)
        {
            // publish zero velocities
            geometry_msgs::TransformStamped cmd_vel;
            geometry_msgs::Twist twist_cmd;
            cmd_vel.header.stamp = ros::Time::now();
            twist_cmd.linear.x = cmd_vel.transform.translation.x = 0.0;
            twist_cmd.linear.y = cmd_vel.transform.translation.y = 0.0;
            twist_cmd.linear.z = cmd_vel.transform.translation.z = 0.0;
            twist_cmd.angular.x = cmd_vel.transform.rotation.x = 0.0;
            twist_cmd.angular.y = cmd_vel.transform.rotation.y = 0.0;
            twist_cmd.angular.z = cmd_vel.transform.rotation.z = 0.0;
            cmd_vel.transform.rotation.w = 0.0; // this is used as priority
            cmd_pub.publish(cmd_vel);
            if (publish_twist)
                twist_pub.publish(twist_cmd);
            ezo =  [MASK]  = 0.0;
            ROS_WARN(""%s cannot be read from the tf tree. Published zero velocities."", base_link_frame.c_str());
            ROS_ERROR(""%s"", ex.what());
            continue;
        }
        // 3d robot pose
        double x = map2base_link.getOrigin().x();
        double y = map2base_link.getOrigin().y();
        double z = map2base_link.getOrigin().z();
        tf::Quaternion q(map2base_link.getRotation().x(),
            map2base_link.getRotation().y(),
            map2base_link.getRotation().z(),
            map2base_link.getRotation().w());
        double roll, pitch, yaw;
        tf::Matrix3x3 m(q);
        m.getRPY(roll, pitch, yaw);
        // search the nearest path point
        double min_dist;
        int i0, i1;
        if (prev_nearest_path_index < 0)
        {
            i0 = 1;
            i1 = path.poses.size();
        }
        else
        {
            i0 = prev_nearest_path_index + 0;
            i1 = prev_nearest_path_index + 10;
            if (i0 < 1)
                i0 = 1;
            if (i1 >= path.poses.size())
                i1 = path.poses.size();
        }
        for (int i = i0; i < i1; i++)
        {
            double dx = path.poses[i].pose.position.x - x;
            double dy = path.poses[i].pose.position.y - y;
            double dz = path.poses[i].pose.position.z - z;
            double dl = sqrt(dx * dx + dy * dy + dz * dz);
            if (i == i0)
            {
                nearest_path_index = i;
                min_dist = dl;
            }
            else if (dl < min_dist)
            {
                nearest_path_index = i;
                min_dist = dl;
            }
        }
        prev_nearest_path_index = nearest_path_index;
        // search the target path point
        int target_path_index = -1;
//        for (int i = nearest_path_index; i < path.poses.size(); i++)
        for (int i = nearest_path_index; i < path.poses.size(); i++)
        {
            double dx = path.poses[i].pose.position.x - x;
            double dy = path.poses[i].pose.position.y - y;
            double dz = path.poses[i].pose.position.z - z;
            double dl = sqrt(dx * dx + dy * dy + dz * dz);
            if (dl >= look_ahead_dist)
            {
                target_path_index = i;
                break;
            }
        }
        // calculate the control input
        geometry_msgs::TransformStamped cmd_vel;
        geometry_msgs::Twist twist_cmd;
        bool stop;
        nh.getParam(""/path_follower/stop"", stop);
        if (target_path_index < 0 || path.poses.size() == 0 || stop)
        {
            // reach at the goal point or no path data
            cmd_vel.header.stamp = ros::Time::now();
            twist_cmd.linear.x = cmd_vel.transform.translation.x = 0.0;
            twist_cmd.linear.y = cmd_vel.transform.translation.y = 0.0;
            twist_cmd.linear.z = cmd_vel.transform.translation.z = 0.0;
            twist_cmd.angular.x = cmd_vel.transform.rotation.x = 0.0;
            twist_cmd.angular.y = cmd_vel.transform.rotation.y = 0.0;
            twist_cmd.angular.z = cmd_vel.transform.rotation.z = 0.0;
            cmd_vel.transform.rotation.w = 0.0; // this is used as priority
            ezo =  [MASK]  = 0.0;
        }
        else
        {
            // compute deviation from the path and determine the control input based on PD control
            tf::Quaternion pq(path.poses[target_path_index].pose.orientation.x,
                path.poses[target_path_index].pose.orientation.y,
                path.poses[target_path_index].pose.orientation.z,
                path.poses[target_path_index].pose.orientation.w);
            double proll, ppitch, pyaw;
            tf::Matrix3x3 pm(pq);
            pm.getRPY(proll, ppitch, pyaw);
            double dx = path.poses[target_path_index].pose.position.x - x;
            double dy = path.poses[target_path_index].pose.position.y - y;
            double dz = path.poses[target_path_index].pose.position.z - z;
            double dl = sqrt(dx * dx + dy * dy + dz * dz);
            double dyaw = atan2(dy, dx);
            // double ex = dx * cos(pyaw) + dy * sin(pyaw);
            // double ey = -dx * sin(pyaw) + dy * cos(pyaw);
            double ez = dz;
            double eyaw = pyaw - yaw;
            if (eyaw < -M_PI)
                eyaw += 2.0 * M_PI;
            if (eyaw > M_PI)
                eyaw -= 2.0 * M_PI;
            double v = max_linear_vel - bvz * fabs(ez) - bvyaw * fabs(eyaw);
            if (v < 0.0)
                v = 0.0;
            double vx = v * cos(dyaw);
            double vy = v * sin(dyaw);
            double vz = pgz * ez + dgz * ezo;
            double wz = pgyaw * eyaw + dgyaw *  [MASK] ;
            vx = check_velocity(vx, max_linear_vel);
            vy = check_velocity(vy, max_linear_vel);
            vz = check_velocity(vz, max_linear_vel);
            wz = check_velocity(wz, max_angular_vel);
            if (dl > displacement_threshold) {
                vx = vy = vz = wz = 0.0;
                ROS_WARN(""The displacement for the path following exceeds the threshold (%.5lf [m])"",
                    displacement_threshold);
            }
            cmd_vel.header.stamp = ros::Time::now();
            twist_cmd.linear.x = cmd_vel.transform.translation.x = vx;
            twist_cmd.linear.y = cmd_vel.transform.translation.y = vy;
            twist_cmd.linear.z = cmd_vel.transform.translation.z = vz;
            twist_cmd.angular.x = cmd_vel.transform.rotation.x = 0.0;
            twist_cmd.angular.y = cmd_vel.transform.rotation.y = 0.0;
            twist_cmd.angular.z = cmd_vel.transform.rotation.z = wz;
            cmd_vel.transform.rotation.w = 5.0; // this is used as priority
            ezo = ez;
             [MASK]  = eyaw;
        }
        // publish commands
        cmd_pub.publish(cmd_vel);
        if (publish_twist)
            twist_pub.publish(twist_cmd);
        // publish target point marger
        if (target_path_index >= 0)
        {
            visualization_msgs::Marker marker;
            marker.header.frame_id = map_frame;
            marker.header.stamp = ros::Time::now();
            marker.ns = ""basic_shapes"";
            marker.id = 0;
            marker.type = visualization_msgs::Marker::SPHERE;
            marker.action = visualization_msgs::Marker::ADD;
            marker.lifetime = ros::Duration();
            marker.scale.x = path_target_marker_size;
            marker.scale.y = path_target_marker_size;
            marker.scale.z = path_target_marker_size;
            marker.pose.position.x = path.poses[target_path_index].pose.position.x;
            marker.pose.position.y = path.poses[target_path_index].pose.position.y;
            marker.pose.position.z = path.poses[target_path_index].pose.position.z;
            marker.pose.orientation.x = 0.0;
            marker.pose.orientation.y = 0.0;
            marker.pose.orientation.z = 0.0;
            marker.pose.orientation.w = 1.0;
            marker.color.r = 0.0f;
            marker.color.g = 1.0f;
            marker.color.b = 0.0f;
            marker.color.a = 1.0f;
            target_point_marker_pub.publish(marker);
        }
        // print debug message
        if (target_path_index >= 0)
        {
            printf(""robot pose: x = %.3lf [m], y = %.3lf [m], z = %.3lf, yaw = %.3lf [deg]\n"", x, y, z, yaw * 180.0 / M_PI);
            printf(""target path point: x = %.3lf [m], y = %.3lf [m], z = %.3lf [m]\n"",
                path.poses[target_path_index].pose.position.x, path.poses[target_path_index].pose.position.y, path.poses[target_path_index].pose.position.z);
            printf(""target path index = %d, path point num = %d\n"", target_path_index, (int)path.poses.size());
            printf(""twist command: x = %.3lf [m/sec], y = %.3lf [m/sec], z = %.3lf [m/sec], ang_vel = %.3lf [rad/sec], priority = %.1f\n"",
                twist_cmd.linear.x, twist_cmd.linear.y, twist_cmd.linear.z, twist_cmd.angular.z, cmd_vel.transform.rotation.w);
            printf(""param: stop = %d, iterate_following = %d, publish_twist = %d\n"", stop, iterate_following, publish_twist);
            printf(""\n"");
        }
        else
        {
            printf(""arrived at the end of the path.\n"");
            printf(""robot pose: x = %.3lf [m], y = %.3lf [m], z = %.3lf, yaw = %.3lf [deg]\n"", x, y, z, yaw * 180.0 / M_PI);
            printf(""param: stop = %d, iterate_following = %d, publish_twist = %d\n"", stop, iterate_following, publish_twist);
            printf(""\n"");
        }
        // check iteration for path following
        nh.getParam(""/path_follower/iterate_following"", iterate_following);
        if (target_path_index < 0 && (int)path.poses.size() != 0 && iterate_following)
            prev_nearest_path_index = 0;
        // sleep
        loop_rate.sleep();
    }
}

double PathFollower::check_velocity(double v, double vmax)
{
    if (std::isnan(v)) {
        ROS_WARN(""nan velocity command is detected."");
        return 0.0;
    }
    if (v > vmax)
        v = vmax;
    if (v < -vmax)
        v = -vmax;
    return v;
}


int main(int argc, char** argv)
{
    ros::init(argc, argv, ""path_follower"");
    PathFollower node;
    node.spin();
    return 0;
}
",eyawo
512,"// vim: sta:et:sw=4:ts=4:sts=4
// https://www.seeedstudio.com/Seeeduino-Lotus-V1-1-ATMega328-Board-with-Grove-Interface.html
// Seeeduino Lotus V1.1
#include <Arduino.h>
// https://github.com/GreyGnome/EnableInterrupt/wiki/Usage#Fast_Start
// https://github.com/ppedro74/Arduino-SerialCommands

//#define EI_NOTPORTB
//#define EI_NOTPORTC
#define EI_NOTEXTERNAL
#include <EnableInterrupt.h>
#include <TimeLib.h>
#include <SerialCommands.h>

/*
 * /dev/ttyS1 on BeagleBone Black
 * Arduino TX: BB: UART1_RX – Pin26
 *         RX: BB: UART1_TX – Pin24
 */
const int N_IRQ = 20;

/*
 * https://docs.arduino.cc/hardware/uno-rev3
 D0  RX
 D1  TX

 D4  RX_LED
 D5  TX_LED
 PB5 13 LED_BUILTIN
 */
const int relayPin = 2; // PD2
const int M_PIN = 3;  // PD3 

const int TRT_PIN = 6; // PD6 Yellow Sensor
const int HRT_PIN = 7;

const int TRB_PIN = A0; // PC0 Yellow Sensor
const int HRB_PIN = A1;
const int TLT_PIN = A2; //A2; // PC2 Yellow Sensor. NOT Used
const int HLT_PIN = A3; //A3; // PC3 Blue
const int HAD_PIN = A2; // PC2

const int T0_PIN = SCL; //  PC5/A5
const int H0_PIN = SDA; //  PC4/A4 Blue wire on sensor


bool relayState = false;

unsigned long ena_irq,  ena_sensor_irq;  // in millis()

unsigned long prev_time_h0, prev_time_t0, prd_t0, prd_h0;
unsigned long cnt_t0=0, cnt_h0=0, cnt_m=0;

volatile unsigned long prev_time_hlt, prev_time_tlt, prd_tlt, prd_hlt,
         cnt_hlt, cnt_tlt;
unsigned long prev_time_hrb, prev_time_trb, prd_trb, prd_hrb,
         cnt_hrb, cnt_trb;
unsigned long prev_time_hrt, prev_time_trt, prd_hrt, prd_trt,
              cnt_hrt, cnt_trt;
bool t0, hlt, tlt, hrb, trb, hrt, trt;

const int irq_sleep = 1000UL; // 1 sec
const int WATER_AUTO = 60UL; // in sec. Auto water/ day

time_t stop_valve = 0, next_water = 0;

// Funtion Prototype
void print_loop(unsigned long now_ms);

void printDigits(int digits){
    // utility function for digital clock display: prints preceding colon and leading 0
    Serial.print("":"");
    if(digits < 10)
        Serial.print('0');
    Serial.print(digits);
}

void digitalClockPrint(){
    // digital clock display of the time
    Serial.print(day());
    Serial.print(""-"");
    Serial.print(month());
    Serial.print(""-"");
    Serial.print(year()); 
    Serial.print("" "");
    Serial.print(hour());
    printDigits(minute());
    printDigits(second());
}

char serial_command_buffer_[32];
SerialCommands serial_commands_(&Serial, serial_command_buffer_, sizeof(serial_command_buffer_), ""\r\n"", "" "");

//This is the default handler, and gets called when no other command matches.
void cmd_unrecognized(SerialCommands* sender, const char* cmd) {
    sender->GetSerial()->print(""Unrecognized command ["");
    sender->GetSerial()->print(cmd);
    sender->GetSerial()->println(""]"");
}
//expects one single parameter
void cmd_datetime_set(SerialCommands* sender) {
    //Note: Every call to Next moves the pointer to next parameter
    // Use date +%s to get Linux Timestamp

    char* ts_str = sender->Next();
    if (ts_str == NULL) {
        sender->GetSerial()->println(""ERROR NO_TS"");
        return;
    }

    time_t ts = strtoul(ts_str, NULL, 0); //atoi(ts_str);
    setTime(ts);
    time_t t = now();
    next_water = t + 24UL * 3600UL; // wait one day
    stop_valve = 0; // 
    sender->GetSerial()->print(F(""My time now is: ""));
    sender->GetSerial()->println(t);
}

//called for ON command
void cmd_relay_on(SerialCommands* sender) {
    const time_t water_interval = 24UL * 3600UL; // in sec
    char * min_str = sender->Next();
    if (min_str == NULL) {
        sender->GetSerial()->println(""ERROR Minute Arg"");
        return;
    }
    int min = atoi(min_str);
    stop_valve = now() + 60UL * min;
    next_water  = now() + water_interval; // 24 * 3600; // Next day, same hour
    relayState = true;
    digitalWrite(relayPin, relayState);
    sender->GetSerial()->print(F(""Relay is on for: ""));
    sender->GetSerial()->println(min);
}

//called for OFF command
void cmd_relay_off(SerialCommands* sender) {
    relayState = false;
    digitalWrite(relayPin, relayState);
    sender->GetSerial()->println(""relay is off"");
}

void cmd_print(SerialCommands* sender) {
    unsigned long now_ms = millis();	
    print_loop(now_ms);
    //sender->GetSerial()->println(""off"");
}

//Note: Commands are case sensitive
SerialCommand cmd_relay_on_(""ON"", cmd_relay_on); // requires one argument
SerialCommand cmd_relay_off_(""OFF"", cmd_relay_off);
SerialCommand cmd_datetime_set_(""TS"", cmd_datetime_set); // requires one argument
/// Add one_key commands 
SerialCommand cmd_print_(""p"", cmd_print, true);

// IRQ Funtion 
void t0_falling() {
    unsigned long us;
    if(cnt_t0++ > N_IRQ) {
        disableInterrupt(T0_PIN);
        us = micros();
        prd_t0 = us - prev_time_t0;
        cnt_t0 = 0;
    };
}
void h0_falling() {
    unsigned long us;
    if(cnt_h0++ > N_IRQ) {
        disableInterrupt(H0_PIN);
        us = micros();
        prd_h0 = us - prev_time_h0;
        cnt_h0 = 0;
    };
}
void hlt_falling() {
    if(cnt_hlt++ > N_IRQ) {
        disableInterrupt(HLT_PIN);
        prd_hlt = micros() - prev_time_hlt;
        cnt_hlt = 0;
    };
}
void tlt_falling() {
    if(cnt_tlt++ > N_IRQ) {
        disableInterrupt(TLT_PIN);
        prd_tlt = micros() - prev_time_tlt;
        cnt_tlt = 0;
    };
}
void hrb_falling() {
    if(cnt_hrb++ > N_IRQ) {
        disableInterrupt(HRB_PIN);
        prd_hrb = micros() - prev_time_hrb;
        cnt_hrb = 0;
    };
}
void trb_falling() {
    if(cnt_trb++ > N_IRQ) {
        disableInterrupt(TRB_PIN);
        prd_trb = micros()- prev_time_trb;
        cnt_trb = 0;
    };
}
void hrt_falling() {
    if(cnt_hrt++ > N_IRQ) {
        disableInterrupt(HRT_PIN);
        prd_hrt = micros() - prev_time_hrt;
        cnt_hrt = 0;
    };
}
void trt_falling() {
    if(cnt_trt++ > N_IRQ) {
        disableInterrupt(TRT_PIN);
        prd_trt = micros() - prev_time_trt;
        cnt_trt = 0;
    };
}

void m_falling() {
    disableInterrupt(M_PIN);
    ena_irq = millis() + irq_sleep; // Debouncing reed sensor
    cnt_m++;
}

void setup() {
    Serial.begin(115200);
    pinMode(H0_PIN, INPUT_PULLUP);
    pinMode(T0_PIN, INPUT_PULLUP);
//    pinMode(HLT_PIN, INPUT_PULLUP);
//    pinMode(TLT_PIN, INPUT_PULLUP);
    pinMode(HRB_PIN, INPUT_PULLUP);
    pinMode(TRB_PIN, INPUT_PULLUP);
    pinMode(HRT_PIN, INPUT_PULLUP);
    pinMode(TRT_PIN, INPUT_PULLUP);
    pinMode(M_PIN, INPUT_PULLUP);

    pinMode(LED_BUILTIN, OUTPUT);

    pinMode(relayPin, OUTPUT);
    relayState = false;
    digitalWrite(relayPin, relayState);

    serial_commands_.SetDefaultHandler(cmd_unrecognized);
    serial_commands_.AddCommand(&cmd_relay_on_);
    serial_commands_.AddCommand(&cmd_relay_off_);
    serial_commands_.AddCommand(&cmd_datetime_set_);
    serial_commands_.AddCommand(&cmd_print_);

    Serial.print(F(""Hello, now is ""));

    //setTime(hr,min,sec,day,month,yr); // Another way to set
    setTime(00,10,1,1,11,2022); 
    time_t t = now(); // Store the current time in time (UTC)
                      // get Linux date : date +%s
    Serial.println(t);
    Serial.println(F(""timestamp,sec,Hum_0,Temp_0,Hum_LT,Temp_LT,Hum_RB,Temp_RB,Hum_RT,Temp_RT,H20_Meas,H2O_Pump,H_ADC""));

    enableInterrupt(H0_PIN, h0_falling, FALLING);
    enableInterrupt(M_PIN, m_falling, FALLING);
    next_water = t + 48UL * 3600UL; // wait two days on Starting
    stop_valve = 0; // in sec
    ena_sensor_irq= millis();
}

void print_loop(unsigned long now_ms) {
    int sensorA6Value = 0;

    digitalClockPrint();
    Serial.print(F("", "")); Serial.print(now_ms/1000);
    float hval = ((float) prd_h0 );
    hval = hval / N_IRQ;
    prd_h0 = 0; cnt_h0 = 0;
    Serial.print(F("", "")); Serial.print(hval);
    float tval = (float) prd_t0; 
    tval = tval / N_IRQ;
    Serial.print(F("", "")); Serial.print(tval);

    hval = (float) prd_hlt;
    hval = 0; //hval / N_IRQ;
    Serial.print(F("", "")); Serial.print(hval);
    tval = (float) prd_tlt;
    tval = 0; // tval / N_IRQ;
    Serial.print(F("", "")); Serial.print(tval);

    hval = (float) prd_hrb;
    hval = hval / N_IRQ;
    Serial.print(F("", "")); Serial.print(hval);
    tval = (float) prd_trb;
    tval = tval / N_IRQ;
    Serial.print(F("", "")); Serial.print(tval);

    hval = (float) prd_hrt;
    hval = hval / N_IRQ;
    Serial.print(F("", "")); Serial.print(hval);
    tval = (float) prd_trt;
    tval = tval / N_IRQ;
    Serial.print(F("", "")); Serial.print(tval);

    Serial.print(F("", "")); Serial.print(cnt_m);

    Serial.print(F("", "")); Serial.print(relayState);

    sensorA6Value = analogRead(HAD_PIN);
    Serial.print(F("", "")); Serial.println(sensorA6Value);

}

const int T0_WAIT =  400UL; 
const int HLT_WAIT =  T0_WAIT + 100UL; 
const int TLT_WAIT =  HLT_WAIT + 100UL; 
const int HRB_WAIT =  TLT_WAIT + 100UL; 
const int TRB_WAIT =  HRB_WAIT + 400UL; 
const int HRT_WAIT =  TRB_WAIT + 100UL; 
const int TRT_WAIT =  HRT_WAIT + 400UL; 

void loop(){
    static unsigned long  [MASK]  = 0;
    const long print_interval = 30 * 1000UL; // in millis
    static bool led_state = false;

    unsigned long now_ms = millis();	
    if (now_ms > ena_irq){  // debouncing 
        enableInterrupt(M_PIN, m_falling, FALLING);
        ena_irq += 1000000UL; // run once until next interrupt.  ~ 1000 s
    }

    time_t now_ts = now();
    if (now_ts > next_water){
	next_water += 24UL * 3600UL; // repeat next day
        relayState = true;
        digitalWrite(relayPin, relayState);
        stop_valve = now_ts + WATER_AUTO;
    }
    if (now_ts > stop_valve){
        relayState = false;
        digitalWrite(relayPin, relayState);
    }

    unsigned long us = micros();
    if ((now_ms > ena_sensor_irq + T0_WAIT) && t0){
        prev_time_t0 = us;
        enableInterrupt(T0_PIN, t0_falling, FALLING);
        t0 = false;
    }
    if ((now_ms > ena_sensor_irq + HLT_WAIT) && hlt){
        prev_time_hlt = us;
        enableInterrupt(HLT_PIN, hlt_falling, FALLING);
        hlt = false;
    }
    if ((now_ms > ena_sensor_irq + TLT_WAIT) && tlt){
        prev_time_tlt = us;
        enableInterrupt(TLT_PIN, tlt_falling, FALLING);
        tlt = false;
    }
    if ((now_ms > ena_sensor_irq + HRB_WAIT) && hrb){
        prev_time_hrb = us;
        enableInterrupt(HRB_PIN, hrb_falling, FALLING);
        hrb = false;
    }
    if ((now_ms > ena_sensor_irq + TRB_WAIT) && trb){
        prev_time_trb = us;
        enableInterrupt(TRB_PIN, trb_falling, FALLING);
        trb = false;
    }
    if ((now_ms > ena_sensor_irq + HRT_WAIT) && hrt){
        prev_time_hrt = us;
        enableInterrupt(HRT_PIN, hrt_falling, FALLING);
        hrt = false;
    }
    if ((now_ms > ena_sensor_irq + TRT_WAIT) && trt){
        prev_time_trt = us;
        enableInterrupt(TRT_PIN, trt_falling, FALLING);
        trt = false;
    }
    serial_commands_.ReadSerial();
    if ( now_ms >  [MASK]  ) {
         [MASK]  = now_ms + print_interval;
	digitalWrite(LED_BUILTIN, led_state);
	led_state = not led_state;
	prev_time_h0 = micros();
	enableInterrupt(H0_PIN, h0_falling, FALLING);
	ena_sensor_irq = millis(); // start Interrupt Cycle
	t0 = true; hlt = false; tlt = false; hrb = true; trb = true; hrt = true; trt = true;  // enable irq flags
    //t0 = true; hlt = true; tlt = true; hrb = true; trb = true; hrt = true; trt = true;  // enable irq flags
	if ((hour(now_ts) < 1) || (hour(now_ts) > 8))  // Do no print 1AM -> 8AM
	    print_loop(now_ms);
    }
}

",nextPtime
513,"// Copyright (C) 2019 Moxa Inc. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

#include <iothinx/iothinxio.h>

#include ""util/logging/ConsoleLogSystem.hpp""
#include ""util/logging/Logging.hpp""
#include ""util/logging/LogMacros.hpp""

#include ""ConfigCommon.hpp""
#include ""OpenSSLConnection.hpp""
#include ""moxa_sample_mqtt.hpp""

#define LOG_TAG_MOXA_SAMPLE             ""[Sample - MoxaSampleMqtt]""
#define MOXA_SAMPLE_TOPIC               ""sdk/test/cpp""
#define DEVICEID_KEY                    ""DeviceId""
#define DEVICEID_VAL                    ""ioThinx""
#define DI_VALUES_KEY                   ""DI_Values""
#define DO_VALUES_KEY                   ""DO_Values""
#define DO_SETVALUES_KEY                ""DO_SetValues""
#define SHADOW_DOCUMENT_STRING_SEND     \
    ""{""                                 \
        ""\""DeviceId\"":\""ioThinx\"",""     \
        ""\""DI_Values\"":0,""              \
        ""\""DO_Values\"":0""               \
    ""}""

namespace awsiotsdk {
    namespace samples {
        ResponseCode MoxaSampleMqtt::SubscribeCallback(util::String topic_name,
                                                       util::String payload,
                                                       std::shared_ptr<mqtt::SubscriptionHandlerContextData> p_app_handler_data)
        {
            ResponseCode aws_rc = ResponseCode::SUCCESS;
            int io_rc = 0;
            util::String DeviceId;
            util::JsonDocument recv;
            uint32_t slot = 1;
            uint32_t do_values = 0;

            aws_rc = util::JsonParser::InitializeFromJsonString(recv, payload);
            if (aws_rc != ResponseCode::SUCCESS)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""InitializeFromJsonString() = %s"",
                              ResponseHelper::ToString(aws_rc).c_str());
                return aws_rc;
            }

            std::cout << ""****************************************"" << std::endl
                      << ""Subscribe : "" << topic_name << std::endl
                      << ""Recv Data : "" << payload << std::endl
                      << ""****************************************"" << std::endl;

            aws_rc = util::JsonParser::GetStringValue(recv, DEVICEID_KEY, DeviceId);
            if (aws_rc != ResponseCode::SUCCESS)
            {
                return aws_rc;
            }

            if (DeviceId.compare(DEVICEID_VAL) != 0)
            {
                return ResponseCode::FAILURE;
            }

            aws_rc = util::JsonParser::GetUint32Value(recv, DO_SETVALUES_KEY, do_values);
            if (aws_rc != ResponseCode::SUCCESS)
            {
                return aws_rc;
            }

            io_rc = ioThinx_DO_SetValues(slot, do_values);
            if (io_rc != IOTHINX_ERR_OK)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""ioThinx_DO_SetValues() = %d"",
                              io_rc);
                return ResponseCode::FAILURE;
            }

            std::cout << DO_SETVALUES_KEY << "" : SUCCESS."" << std::endl;

            return ResponseCode::SUCCESS;
        }

        ResponseCode MoxaSampleMqtt::DisconnectCallback(util::String client_id,
                                                        std::shared_ptr<DisconnectCallbackContextData> p_app_handler_data)
        {
            std::cout << ""****************************************"" << std::endl
                      << client_id << "" Disconnected!"" << std::endl
                      << ""****************************************"" << std::endl;
            return ResponseCode::SUCCESS;
        }

        ResponseCode MoxaSampleMqtt::ReconnectCallback(util::String client_id,
                                                       std::shared_ptr<ReconnectCallbackContextData> p_app_handler_data,
                                                       ResponseCode reconnect_result)
        {
            std::cout << ""****************************************"" << std::endl
                      << client_id << "" Reconnect Attempted. Result "" << ResponseHelper::ToString(reconnect_result) << std::endl
                      << ""****************************************"" << std::endl;
            return ResponseCode::SUCCESS;
        }

        ResponseCode MoxaSampleMqtt::ResubscribeCallback(util::String client_id,
                                                         std::shared_ptr<ResubscribeCallbackContextData> p_app_handler_data,
                                                         ResponseCode resubscribe_result)
        {
            std::cout << ""****************************************"" << std::endl
                      << client_id << "" Resubscribe Attempted. Result "" << ResponseHelper::ToString(resubscribe_result) << std::endl
                      << ""****************************************"" << std::endl;
            return ResponseCode::SUCCESS;
        }

        ResponseCode MoxaSampleMqtt::PublishMqtt(util::String &payload,
                                                 uint16_t &packet_id)
        {
            ResponseCode rc = ResponseCode::SUCCESS;
            util::String p_topic_name_str = MOXA_SAMPLE_TOPIC;
            std::unique_ptr<Utf8String> p_topic_name = Utf8String::Create(p_topic_name_str);

            rc = p_iot_client_->PublishAsync(std::move(p_topic_name), false, false,
                                             mqtt::QoS::QOS1, payload, nullptr, packet_id);
            if (rc != ResponseCode::ACTION_QUEUE_FULL)
            {
                return rc;
            }

            std::this_thread::sleep_for(std::chrono::seconds(1));

            return rc;
        }

        ResponseCode MoxaSampleMqtt::UnsubscribeMqtt(void)
        {
            util::String p_topic_name_str = MOXA_SAMPLE_TOPIC;
            std::unique_ptr<Utf8String> p_topic_name = Utf8String::Create(p_topic_name_str);
            util::Vector<std::unique_ptr<Utf8String>> topic_vector;
            topic_vector.push_back(std::move(p_topic_name));

            return p_iot_client_->Unsubscribe(std::move(topic_vector), ConfigCommon::mqtt_command_timeout_);
        }

        ResponseCode MoxaSampleMqtt::SubscribeMqtt(void)
        {
            util::String p_topic_name_str = MOXA_SAMPLE_TOPIC;
            std::unique_ptr<Utf8String> p_topic_name = Utf8String::Create(p_topic_name_str);
            util::Vector<std::shared_ptr<mqtt::Subscription>> topic_vector;

            mqtt::Subscription::ApplicationCallbackHandlerPtr
                 [MASK]  = std::bind(&MoxaSampleMqtt::SubscribeCallback,
                                          this,
                                          std::placeholders::_1,
                                          std::placeholders::_2,
                                          std::placeholders::_3);
            std::shared_ptr<mqtt::Subscription>
                p_subscription = mqtt::Subscription::Create(std::move(p_topic_name), mqtt::QoS::QOS0,  [MASK] , nullptr);
            topic_vector.push_back(p_subscription);

            return p_iot_client_->Subscribe(topic_vector, ConfigCommon::mqtt_command_timeout_);
        }

        ResponseCode MoxaSampleMqtt::DisconnectMqtt(void)
        {
            return p_iot_client_->Disconnect(ConfigCommon::mqtt_command_timeout_);
        }

        ResponseCode MoxaSampleMqtt::ConnectMqtt(void)
        {
            ResponseCode rc = ResponseCode::SUCCESS;

            std::unique_ptr<Utf8String>
                p_client_id = Utf8String::Create(ConfigCommon::base_client_id_);

            rc = p_iot_client_->Connect(ConfigCommon::mqtt_command_timeout_, ConfigCommon::is_clean_session_,
                                        mqtt::Version::MQTT_3_1_1, ConfigCommon::keep_alive_timeout_secs_,
                                        std::move(p_client_id), nullptr, nullptr, nullptr);
            if (rc != ResponseCode::MQTT_CONNACK_CONNECTION_ACCEPTED)
            {
                return rc;
            }

            return ResponseCode::SUCCESS;
        }

        ResponseCode MoxaSampleMqtt::CreateMqtt(void)
        {
            ClientCoreState::ApplicationDisconnectCallbackPtr
                p_disconnect_handler = std::bind(&MoxaSampleMqtt::DisconnectCallback,
                                                 this,
                                                 std::placeholders::_1,
                                                 std::placeholders::_2);

            ClientCoreState::ApplicationReconnectCallbackPtr
                p_reconnect_handler = std::bind(&MoxaSampleMqtt::ReconnectCallback,
                                                this,
                                                std::placeholders::_1,
                                                std::placeholders::_2,
                                                std::placeholders::_3);

            ClientCoreState::ApplicationResubscribeCallbackPtr
                p_resubscribe_handler = std::bind(&MoxaSampleMqtt::ResubscribeCallback,
                                                  this,
                                                  std::placeholders::_1,
                                                  std::placeholders::_2,
                                                  std::placeholders::_3);

            p_iot_client_ = std::shared_ptr<MqttClient>(MqttClient::Create(p_network_connection_,
                                                                           ConfigCommon::mqtt_command_timeout_,
                                                                           p_disconnect_handler, nullptr,
                                                                           p_reconnect_handler, nullptr,
                                                                           p_resubscribe_handler, nullptr));
            if (p_iot_client_ == nullptr)
            {
                return ResponseCode::FAILURE;
            }

            return ResponseCode::SUCCESS;
        }

        ResponseCode MoxaSampleMqtt::InitializeNetwork(void)
        {
            ResponseCode rc = ResponseCode::SUCCESS;

            std::shared_ptr<network::OpenSSLConnection>
                p_network_connection = std::make_shared<network::OpenSSLConnection>(ConfigCommon::endpoint_,
                                                                                    ConfigCommon::endpoint_mqtt_port_,
                                                                                    ConfigCommon::root_ca_path_,
                                                                                    ConfigCommon::client_cert_path_,
                                                                                    ConfigCommon::client_key_path_,
                                                                                    ConfigCommon::tls_handshake_timeout_,
                                                                                    ConfigCommon::tls_read_timeout_,
                                                                                    ConfigCommon::tls_write_timeout_, true);

            rc = p_network_connection->Initialize();
            if (rc != ResponseCode::SUCCESS)
            {
                return rc;
            }

            p_network_connection_ = std::dynamic_pointer_cast<NetworkConnection>(p_network_connection);

            return ResponseCode::SUCCESS;
        }

        ResponseCode MoxaSampleMqtt::RunSample(void)
        {
            ResponseCode aws_rc = ResponseCode::SUCCESS;
            int io_rc = 0;
            uint16_t packet_id = 0;
            uint32_t slot = 1;
            uint32_t di_values = 0;
            uint32_t do_values = 0;
            uint32_t DI_Values = 0;
            uint32_t DO_Values = 0;
            util::String payload;
            util::JsonDocument send;

            io_rc = ioThinx_IO_Client_Init();
            if (io_rc != IOTHINX_ERR_OK)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""ioThinx_IO_Client_Init() = %d"",
                              io_rc);
                return ResponseCode::FAILURE;
            }

            aws_rc = util::JsonParser::InitializeFromJsonString(send, SHADOW_DOCUMENT_STRING_SEND);
            if (aws_rc != ResponseCode::SUCCESS)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""InitializeFromJsonString() = %s"",
                              ResponseHelper::ToString(aws_rc).c_str());
                return aws_rc;
            }

            aws_rc = InitializeNetwork();
            if (aws_rc != ResponseCode::SUCCESS)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""InitializeNetwork() = %s"",
                              ResponseHelper::ToString(aws_rc).c_str());
                return aws_rc;
            }

            aws_rc = CreateMqtt();
            if (aws_rc != ResponseCode::SUCCESS)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""CreateMqtt() = %s"",
                              ResponseHelper::ToString(aws_rc).c_str());
                return aws_rc;
            }

            aws_rc = ConnectMqtt();
            if (aws_rc != ResponseCode::SUCCESS)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""ConnectMqtt() = %s"",
                              ResponseHelper::ToString(aws_rc).c_str());
                return aws_rc;
            }

            aws_rc = SubscribeMqtt();
            if (aws_rc != ResponseCode::SUCCESS)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""SubscribeMqtt() = %s"",
                              ResponseHelper::ToString(aws_rc).c_str());
                DisconnectMqtt();
                return aws_rc;
            }

            io_rc = ioThinx_DI_GetValues(slot, &di_values);
            if (io_rc != IOTHINX_ERR_OK)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""ioThinx_DI_GetValues() = %d"",
                              io_rc);
                UnsubscribeMqtt();
                DisconnectMqtt();
                return ResponseCode::FAILURE;
            }

            io_rc = ioThinx_DO_GetValues(slot, &do_values);
            if (io_rc != IOTHINX_ERR_OK)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""ioThinx_DO_GetValues() = %d"",
                              io_rc);
                UnsubscribeMqtt();
                DisconnectMqtt();
                return ResponseCode::FAILURE;
            }

            send[DI_VALUES_KEY] = di_values;
            send[DO_VALUES_KEY] = do_values;
            payload = util::JsonParser::ToString(send);

            aws_rc = PublishMqtt(payload, packet_id);
            if (aws_rc != ResponseCode::SUCCESS && aws_rc != ResponseCode::ACTION_QUEUE_FULL)
            {
                AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                              ""PublishMqtt() = %s"",
                              ResponseHelper::ToString(aws_rc).c_str());
                UnsubscribeMqtt();
                DisconnectMqtt();
                return aws_rc;
            }

            std::cout << packet_id << "" Send "" << ResponseHelper::ToString(aws_rc) << std::endl;

            while (true)
            {
                std::this_thread::sleep_for(std::chrono::seconds(1));

                io_rc = ioThinx_DI_GetValues(slot, &di_values);
                if (io_rc != IOTHINX_ERR_OK)
                {
                    AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                                  ""ioThinx_DI_GetValues() = %d"",
                                  io_rc);
                    UnsubscribeMqtt();
                    DisconnectMqtt();
                    return ResponseCode::FAILURE;
                }

                io_rc = ioThinx_DO_GetValues(slot, &do_values);
                if (io_rc != IOTHINX_ERR_OK)
                {
                    AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                                  ""ioThinx_DO_GetValues() = %d"",
                                  io_rc);
                    UnsubscribeMqtt();
                    DisconnectMqtt();
                    return ResponseCode::FAILURE;
                }

                aws_rc = util::JsonParser::GetUint32Value(send, DI_VALUES_KEY, DI_Values);
                if (aws_rc != ResponseCode::SUCCESS)
                {
                    AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                                  ""GetUint32Value() = %s"",
                                  ResponseHelper::ToString(aws_rc).c_str());
                    UnsubscribeMqtt();
                    DisconnectMqtt();
                    return aws_rc;
                }

                aws_rc = util::JsonParser::GetUint32Value(send, DO_VALUES_KEY, DO_Values);
                if (aws_rc != ResponseCode::SUCCESS)
                {
                    AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                                  ""GetUint32Value() = %s"",
                                  ResponseHelper::ToString(aws_rc).c_str());
                    UnsubscribeMqtt();
                    DisconnectMqtt();
                    return aws_rc;
                }

                if (DI_Values == di_values && DO_Values == do_values)
                {
                    continue;
                }

                send[DI_VALUES_KEY] = di_values;
                send[DO_VALUES_KEY] = do_values;
                payload = util::JsonParser::ToString(send);

                aws_rc = PublishMqtt(payload, packet_id);
                if (aws_rc != ResponseCode::SUCCESS && aws_rc != ResponseCode::ACTION_QUEUE_FULL)
                {
                    AWS_LOG_ERROR(LOG_TAG_MOXA_SAMPLE,
                                  ""PublishMqtt() = %s"",
                                  ResponseHelper::ToString(aws_rc).c_str());
                    UnsubscribeMqtt();
                    DisconnectMqtt();
                    return aws_rc;
                }

                std::cout << packet_id << "" Send "" << ResponseHelper::ToString(aws_rc) << std::endl;
            }

            UnsubscribeMqtt();
            DisconnectMqtt();
            return ResponseCode::SUCCESS;
        }
    }
}

int main(int argc, char const *argv[])
{
    awsiotsdk::ResponseCode rc = awsiotsdk::ResponseCode::SUCCESS;

    std::shared_ptr<awsiotsdk::util::Logging::ConsoleLogSystem>
        p_log_system = std::make_shared<awsiotsdk::util::Logging::ConsoleLogSystem>(awsiotsdk::util::Logging::LogLevel::Info);

    awsiotsdk::util::Logging::InitializeAWSLogging(p_log_system);

    std::unique_ptr<awsiotsdk::samples::MoxaSampleMqtt>
        moxa_sample_mqtt = std::unique_ptr<awsiotsdk::samples::MoxaSampleMqtt>(new awsiotsdk::samples::MoxaSampleMqtt());

    rc = awsiotsdk::ConfigCommon::InitializeCommon(""config/SampleConfig.json"");
    if (rc != awsiotsdk::ResponseCode::SUCCESS)
    {
        awsiotsdk::util::Logging::ShutdownAWSLogging();
        return static_cast<int>(rc);
    }

    rc = moxa_sample_mqtt->RunSample();
    awsiotsdk::util::Logging::ShutdownAWSLogging();
    return static_cast<int>(rc);
}
",p_sub_handler
514,"#include ""plugin.hpp""

struct Bypass : Module {
  /* START GENERATED - DO NOT EDIT: Enums */
  enum InputIds {
    IN1,
    IN2,
    IN3,
    IN4,
    IN5,
    IN6,
    IN7,
    RETURN1,
    RETURN2,
    RETURN3,
    RETURN4,
    RETURN5,
    RETURN6,
    RETURN7,
    RETURN8,

  NUM_INPUTS
};

  enum OutputIds {
    OUT1,
    OUT2,
    OUT3,
    OUT4,
    OUT5,
    OUT6,
    OUT7,
    OUT8,
    SEND1,
    SEND2,
    SEND3,
    SEND4,
    SEND5,
    SEND6,
    SEND7,

  NUM_OUTPUTS
};

  enum ParamIds {
    BUTTON1,
    BUTTON2,
    BUTTON3,
    BUTTON5,
    BUTTON7,

  NUM_PARAMS
};

  enum LightIds {
    LIGHT1,
    LIGHT2,
    LIGHT3,
    LIGHT5,
    LIGHT7,

  NUM_LIGHTS
};
  /* END GENERATED: Enums */

  Bypass() {
    config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);
    /* START GENERATED - PARAMS EDITABLE: Param Config */
    configSwitch(BUTTON1, 0.f, 1.f, 0.f, ""#1"", {""Bypass"", ""Send""});
    configSwitch(BUTTON2, 0.f, 1.f, 0.f, ""#2"", {""Bypass"", ""Send""});
    configSwitch(BUTTON3, 0.f, 1.f, 0.f, ""#3"", {""Bypass"", ""Send""});
    configSwitch(BUTTON5, 0.f, 1.f, 0.f, ""#4"", {""Bypass"", ""Send""});
    configSwitch(BUTTON7, 0.f, 1.f, 0.f, ""#5"", {""Bypass"", ""Send""});
    /* END GENERATED: Param Config */
    configInput(IN1, ""#1"");
    configInput(IN2, ""#2"");
    configInput(IN3, ""#3 L"");
    configInput(IN4, ""#3 R"");
    configInput(IN5, ""#4 L"");
    configInput(IN6, ""#4 R"");
    configInput(IN7, ""#5"");
    configOutput(SEND1, ""#1"");
    configOutput(SEND2, ""#2"");
    configOutput(SEND3, ""#3 L"");
    configOutput(SEND4, ""#3 R"");
    configOutput(SEND5, ""#4 L"");
    configOutput(SEND6, ""#4 R"");
    configOutput(SEND7, ""#5"");
    configInput(RETURN1, ""#1 return"");
    configInput(RETURN2, ""#2 return"");
    configInput(RETURN3, ""#3 L return"");
    configInput(RETURN4, ""#3 R return"");
    configInput(RETURN5, ""#4 L return"");
    configInput(RETURN6, ""#4 R return"");
    configInput(RETURN7, ""#5 L return"");
    configInput(RETURN8, ""#5 R return"");
    configOutput(OUT1, ""#1"");
    configOutput(OUT2, ""#2"");
    configOutput(OUT3, ""#3 L"");
    configOutput(OUT4, ""#3 R"");
    configOutput(OUT5, ""#4 L"");
    configOutput(OUT6, ""#4 R"");
    configOutput(OUT7, ""#5 L"");
    configOutput(OUT8, ""#5 R"");
    configBypass(IN1, OUT1);
    configBypass(IN2, OUT2);
    configBypass(IN3, OUT3);
    configBypass(IN4, OUT4);
    configBypass(IN5, OUT5);
    configBypass(IN6, OUT6);
    configBypass(IN7, OUT7);
    onReset();
  }

	bool state[NUM_PARAMS];

  void route(int input, int output, float multiplier = 1.0) {
    assert(input < NUM_INPUTS);
    assert(output < NUM_OUTPUTS);
    if (inputs[input].isConnected() && outputs[output].isConnected()) {
      int channels = inputs[input].getChannels();
      for (int c = 0; c < channels; c += 4) {
        simd::float_4 out = simd::float_4::load(inputs[input].getVoltages(c));

        outputs[output].setVoltageSimd(out * multiplier, c);
      }
    } else {
      if (outputs[output].isConnected()) {
        outputs[output].clearVoltages();
      }
    }
  }

  void process(const ProcessArgs &args) override {
    int  [MASK]  = 8;
    int returnButtonMapping[8] = { 0, 1, 2, 2, 3, 3, 4, 4};

    for (int i = 0; i < NUM_PARAMS; i++) {
      assert(BUTTON1 + i < NUM_PARAMS);
      state[i] = params[BUTTON1 + i].getValue() > 0.f;

      lights[LIGHT1+i].setBrightness(state[i] ? 1.0 : 0.0f);
    }

    for (int i = 0; i < 8; i++) {
      assert(i <  [MASK] );
      assert(returnButtonMapping[i] < NUM_PARAMS);
      if (state[returnButtonMapping[i]]) {
        if (i < 7) {
          route(IN1+i, SEND1+i);
        }
        route(RETURN1+i, OUT1+i);
      } else {
        if (i == 6) {
          // Mono -> Stereo case
          // 0.71 = sin(45deg)
          // This keeps overall combined power of output signal constant.
          route(IN1+i, OUT1+i, 0.71);
          route(IN1+i, OUT1+i+1, 0.71);
        } else if (i == 7) {
          // Ignore, was handled by previous loop
        } else {
          route(IN1+i, OUT1+i);
        }

        // Clear send. Ignore i == 7 because handled by previous loop.
        if (i < 7) {
          assert(SEND1+i < NUM_OUTPUTS);
          if (outputs[SEND1+i].isConnected()) {
            outputs[SEND1+i].clearVoltages();
          }
        }
      }

      int channels = 1;
      if (i < 7) {
        assert(IN1+i < NUM_INPUTS);
        assert(SEND1+i < NUM_OUTPUTS);
        channels = inputs[IN1+i].getChannels();
        outputs[SEND1+i].setChannels(channels);
      } else {
        assert(IN1+6 < NUM_INPUTS);
        channels = inputs[IN1+6].getChannels();
      }

      assert(i <  [MASK] );
      assert(returnButtonMapping[i] < NUM_PARAMS);
      if (state[returnButtonMapping[i]]) {
        assert(RETURN1+i < NUM_INPUTS);
        assert(OUT1+i < NUM_OUTPUTS);
        channels = inputs[RETURN1+i].getChannels();
        outputs[OUT1+i].setChannels(channels);
      } else {
        assert(OUT1+i < NUM_OUTPUTS);
        outputs[OUT1+i].setChannels(channels);
      }
    }
  }

	void onReset() override {
		for (int i = 0; i < NUM_PARAMS; i++) {
			state[i] = false;
		}
	}

	void onRandomize() override {
		for (int i = 0; i < NUM_PARAMS; i++) {
			state[i] = (random::uniform() < 0.5f);
		}
	}

	json_t *dataToJson() override {
		json_t *rootJ = json_object();

		// states
		json_t *statesJ = json_array();
		for (int i = 0; i < NUM_PARAMS; i++) {
			json_t *stateJ = json_boolean(state[i]);
			json_array_append_new(statesJ, stateJ);
		}
		json_object_set_new(rootJ, ""states"", statesJ);

		return rootJ;
	}

	void dataFromJson(json_t *rootJ) override {
		// states
		json_t *statesJ = json_object_get(rootJ, ""states"");
		if (statesJ) {
			for (int i = 0; i < NUM_PARAMS; i++) {
				json_t *stateJ = json_array_get(statesJ, i);
				if (stateJ)
					state[i] = json_boolean_value(stateJ);
			}
		}
	}
};

template <typename BASE>
struct MuteLight : BASE {
	MuteLight() {
		this->box.size = mm2px(Vec(4.f, 4.f));
	}
};

static const NVGcolor RETRO_RED = nvgRGB(0xf0, 0x59, 0x2d);

struct RetroLight : app::ModuleLightWidget {
  RetroLight() {
		bgColor = nvgRGB(0xfd, 0xf0, 0xc4);
		borderColor = nvgRGB(0x9b, 0x5a, 0x49);
    addBaseColor(RETRO_RED);
	}
};

struct RetroButton : app::SvgSwitch {
	app::ModuleLightWidget* light;

  RetroButton() {
    momentary = false;
		this->box.size = mm2px(Vec(4.f, 4.f));
    addFrame(APP->window->loadSvg(asset::plugin(pluginInstance, ""res/LEDBezel.svg"")));
		light = new LEDBezelLight<RetroLight>;
		light->box.pos = box.size.div(2).minus(light->box.size.div(2));
		addChild(light);
  }
  app::ModuleLightWidget* getLight() { return light; }
};

struct BypassWidget : ModuleWidget {
  BypassWidget(Bypass *module) {
    setModule(module);
    setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, ""res/Bypass.svg"")));

		addChild(createWidget<ScrewSilver>(Vec(15, 0)));
		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 30, 0)));
		addChild(createWidget<ScrewSilver>(Vec(15, 365)));
		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 30, 365)));

    /* START GENERATED - DO NOT EDIT: Add Components */
    addParam(createLightParamCentered<RetroButton>(mm2px(Vec(33.020000, 39.109344)), module, Bypass::BUTTON1, Bypass::LIGHT1));
    addParam(createLightParamCentered<RetroButton>(mm2px(Vec(33.020000, 49.843910)), module, Bypass::BUTTON2, Bypass::LIGHT2));
    addParam(createLightParamCentered<RetroButton>(mm2px(Vec(32.953182, 65.945671)), module, Bypass::BUTTON3, Bypass::LIGHT3));
    addParam(createLightParamCentered<RetroButton>(mm2px(Vec(32.831013, 87.414726)), module, Bypass::BUTTON5, Bypass::LIGHT5));
    addParam(createLightParamCentered<RetroButton>(mm2px(Vec(32.831013, 108.883780)), module, Bypass::BUTTON7, Bypass::LIGHT7));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.237754, 39.109362)), module, Bypass::IN1));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.237754, 49.843886)), module, Bypass::IN2));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.237754, 60.578420)), module, Bypass::IN3));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.237754, 71.312945)), module, Bypass::IN4));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.237754, 82.047476)), module, Bypass::IN5));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.237754, 92.782001)), module, Bypass::IN6));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(6.237754, 103.516534)), module, Bypass::IN7));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 39.109362)), module, Bypass::OUT1));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 49.843886)), module, Bypass::OUT2));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 60.578420)), module, Bypass::OUT3));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 71.312945)), module, Bypass::OUT4));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 82.047476)), module, Bypass::OUT5));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 92.782001)), module, Bypass::OUT6));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 103.516534)), module, Bypass::OUT7));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(56.812223, 114.251060)), module, Bypass::OUT8));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 39.109362)), module, Bypass::RETURN1));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 49.843886)), module, Bypass::RETURN2));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 60.578420)), module, Bypass::RETURN3));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 71.312945)), module, Bypass::RETURN4));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 82.047476)), module, Bypass::RETURN5));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 92.782001)), module, Bypass::RETURN6));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 103.516534)), module, Bypass::RETURN7));
    addInput(createInputCentered<PJ301MPort>(mm2px(Vec(43.110273, 114.251060)), module, Bypass::RETURN8));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.939704, 39.109362)), module, Bypass::SEND1));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.939704, 49.843886)), module, Bypass::SEND2));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.939704, 60.578420)), module, Bypass::SEND3));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.939704, 71.312945)), module, Bypass::SEND4));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.939704, 82.047476)), module, Bypass::SEND5));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.939704, 92.782001)), module, Bypass::SEND6));
    addOutput(createOutputCentered<PJ301MPort>(mm2px(Vec(19.939704, 103.516534)), module, Bypass::SEND7));
    /* END GENERATED: Add Components */
  }
};

Model *modelBypass = createModel<Bypass, BypassWidget>(""Bypass"");
",NUM_RETURN_BUTTON_MAPPING
515,"/*
 HITIComm examples:  Grove / 4_Grove_SmartPlantCareKit

 This sketch shows how to use HITIPanel to:
   => control and monitor a plant watering system based on sensors feedback

 - Grove OLED Display 0.96""       I2C
 - Grove Sunlight Sensor v1.0     I2C
 - Grove Water flow sensor        on pin 2
 - Grove Encoder                  on pin 3-4
 - Grove Button                   on pin 5
 - Grove Relay                    on pin 6
 - Grove temperature & humidity sensor   on pin A0
 - Grove Moisture sensor          on pin A1

 Copyright © 2021 <NAME>
 MIT License
*/

#include <HITIComm.h>

#include <DHT.h>
#include <Encoder.h>
#include <SI114X.h>
//#include <U8g2lib.h> // this library eats at least 1200 bytes of Sram


// -----------------------------------------------------------------------------
// Global Variables ------------------------------------------------------------
// -----------------------------------------------------------------------------


// Pins and devices ********************************************************

// Pins assignment
const byte pin_flow      = 2;
const byte pin_encoder_A = 3;
const byte pin_encoder_B = 4;
const byte pin_button    = 5;
const byte pin_relay     = 6;
const byte pin_tempHumid = A0;
const byte pin_moisture  = A1;

// Analog Data assignment
const byte ad_watering_state              = 0; // metric (machine state)
const byte ad_encoder                     = 1; // metric (in counts)
const byte ad_moisture_min                = 3; // metric (in %)
const byte ad_moisture                    = 4; // metric (in %)
const byte ad_wateringTime                = 5; // setpoint (in s)
const byte ad_absorptionTime              = 6; // setpoint (in s). Absorption time following watering
const byte ad_flow_lmin                   = 7; // metric (in L/min)
const byte ad_dispensedWaterVolume        = 8; // metric (in L)
const byte ad_dispensedWaterVolume_perDay = 9; // metric (in L)

const byte ad_temperature_min      = 10; // setpoint (in °C)
const byte ad_temperature_max      = 11; // setpoint (in °C)
const byte ad_temperature          = 12; // metric (in °C)
const byte ad_humidity_min         = 13; // setpoint (in %)
const byte ad_humidity_max         = 14; // setpoint (in %)
const byte ad_humidity             = 15; // metric (in %)
const byte ad_sunlight_UVIndex_max = 16; // setpoint (in UV index)
const byte ad_sunlight_UVIndex     = 17; // metric (in UV index)
const byte ad_sunlight_Visible     = 18; // metric (visible intensity)
const byte ad_sunlight_IR          = 19; // metric (IR intensity)

// Digital Data assignment
const byte dd_warning_temperature_low  = 0;  // indicator
const byte dd_warning_temperature_high = 1;  // indicator
const byte dd_warning_humidity_low     = 2;  // indicator
const byte dd_warning_humidity_high    = 3;  // indicator
const byte dd_warning_UVIndex_high     = 4;  // indicator
const byte dd_warning_moisture_low     = 5;  // indicator
const byte dd_warning_noWater          = 6;  // indicator
const byte dd_warning                  = 7;  // indicator
const byte dd_resetWarning_noWater     = 9;  // virtual button
const byte dd_saveSettings             = 10; // virtual button
const byte dd_loadSettings             = 11; // virtual button
const byte dd_enableWatering           = 12; // virtual switch
const byte dd_water                    = 13; // virtual button
const byte dd_isWatering               = 14; // indicator


// temperature & humidity sensor DHT 11
//#define DHTTYPE DHT11
DHT dht(pin_tempHumid, DHT11);
float temperature     = 0;
float humidity = 0;

// DHT 11 functions are blocking functions which blocks program during 500ms (measured loop cycle time)
// => solution: prevent it from executing every cycle. Since it's a slow sensor (2s response time), it is 
//    enough execute it only every 2s
HC_Timer timer_dht;


// Soil moisture sensor
float moisture = 0;


// Encoder
Encoder encoder(pin_encoder_A, pin_encoder_B);
long encoder_variation = 0;


// Sunlight sensor (SI1145)
SI114X sunlight;
float sunlight_UVIndex = 0;
float sunlight_Visible = 0;
float sunlight_IR = 0;

// Flow sensor
volatile int flow_count = 0;
float flow_lhour = 0;   // in l/hour
float flow_lmin = 0;    // in l/min
float flow_lsec = 0;    // in l/s
float dispensedWaterVolume = 0;
float dispensedWaterVolume_perDay = 0;
HC_Timer timer_flow;


// OLED display 0.96 inch
/*#ifdef U8X8_HAVE_HW_SPI
    #include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
    #include <Wire.h>
#endif*/
//U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); // SSD1306 and SSD1308Z are compatible
//HC_Timer timer_oled;


// Process ***********************************************************

// Watering
enum WateringState
{
    state_init           = 0,
    state_start          = 1,
    state_watering       = 2,
    state_absorption     = 3,
    state_finish         = 4,
    state_retry          = 5,
    state_noWaterWarning = 6
};
WateringState state = state_init;
bool watering_request_flag = false;
bool watering_ongoing_flag = false;
HC_Timer timer_watering;
HC_Timer timer_absorption;

// Warning flags
bool warning_noWater_flag = false;
bool warning_moistureLow_flag = false;


// Eeprom ************************************************************

// Settings (saved in eeprom, Float Space)
// index
const byte FloatIndex_settings_temperature_min = 0;
const byte FloatIndex_settings_temperature_max = 1;
const byte FloatIndex_settings_humidity_min    = 2;
const byte FloatIndex_settings_humidity_max    = 3;
const byte FloatIndex_settings_UVIndex_max     = 4;
const byte FloatIndex_settings_moisture_min    = 5;
const byte FloatIndex_settings_wateringTime    = 6;
const byte FloatIndex_settings_absorptionTime  = 7;
// value
float settings_temperature_min = 0;    // in °C
float settings_temperature_max = 30;   // in °C
float settings_humidity_min    = 0;    // in %
float settings_humidity_max    = 60;   // in %
float settings_UVIndex_max     = 9;    
float settings_moisture_min    = 100;  // in %
float settings_wateringTime    = 2;    // in s
float settings_absorptionTime  = 5;    // in s

// Settings (save in eeprom, Boolean Space)
// index
const byte BooleanIndex_settingsDetected         = 0; // flag: true if settings already saved once 
const byte BooleanIndex_settings_wateringEnabled = 1;
// value
bool settings_wateringEnabled = true;



// -----------------------------------------------------------------------------
// Setup (called once at power on) ---------------------------------------------
// -----------------------------------------------------------------------------

void setup()
{
    // initialize library
    HC_begin();

    // initialize DHT 11 sensor
    Wire.begin();
    dht.begin();

    // initialize SI1145 sensor
    while(!sunlight.Begin())
        delay(1000);

    // initialize flow measurement: revolution counting
    attachInterrupt(digitalPinToInterrupt(2), flow_counter_interrupt, RISING);

    // pins mode
    pinMode(pin_button, INPUT);
    pinMode(pin_flow,   INPUT);
    pinMode(pin_relay,  OUTPUT);

    // settings reading from eeprom
    if(isSettingsDetected())
        loadSettings();
}



// -----------------------------------------------------------------------------
// Loop (called at each cycle) -------------------------------------------------
// -----------------------------------------------------------------------------

void loop()
{
    // communicate with HITIPanel
    HC_communicate();

    // measure all sensors
    measureAll();

    // read settings from HITIPanel
    readSettingsFromHITIPanel();

    // manage virtual switches
    manageVirtualButtons();

    // manage watering
    manageWatering();
    
    // display data in HITIPanel
    sendDataToHITIPanel();
}



// -----------------------------------------------------------------------------
// Methods ---------------------------------------------------------------------
// -----------------------------------------------------------------------------

// temperature & humidity sensor (DHT 11) *******************************

// measure
void measureTempAndHumidity()
{
    float temperature_hum_val[2] = {0};
    
    // blocking function: blocks program during 500ms
    if(!dht.readTempAndHumidity(temperature_hum_val))
    {
        humidity    = temperature_hum_val[0];  
        temperature = temperature_hum_val[1];  
    }
}


// encoder **************************************************************

// measure
void measureEncoder()
{
    encoder_variation = encoder.readAndReset();
}


// flow sensor (YF-S402) ************************************************

// count rotor revolution
void flow_counter_interrupt()
{
    ++flow_count;
}

// measure water flow and Volume
void measureWaterFlowAndDispensedVolume()
{
    static byte  [MASK]  = 0;   // for counting daily volume
    static long seconds_counter = 0; // for counting seconds
    
    // every second
    if(timer_flow.delay(1000))
    {
        // flow calculation (flow sensor YF-S402) -------------------
        // pulse frequency (Hz) = 73*Q, with Q in L/min
        flow_lmin  = (float) flow_count / 73; // L/min
        flow_lsec  = flow_lmin / 60.0;         // L/sec
     
        // reset revolution counter
        flow_count = 0;

        // dispensed water volume calculation -----------------------
        dispensedWaterVolume += flow_lsec; // this variable is reset at each watering
         [MASK]  += flow_lsec;

        // every day
        if(seconds_counter++ > 86399)
        {
            dispensedWaterVolume_perDay =  [MASK] ; // record volume per day
             [MASK]  = 0;   // reset variable
            seconds_counter = 0; // reset counter
        }
    }
}


// water pump (Desun Pump DS2500) ***************************************

void waterPumpOn()
{
    digitalWrite(pin_relay, HIGH);
}

void waterPumpOff()
{
    digitalWrite(pin_relay, LOW);
}


// measurement **********************************************************

void measureAll()
{
    // measure temperature & humidity every 2s (except when watering)
    if(timer_dht.delay(2000) && !watering_ongoing_flag)
        measureTempAndHumidity();

    // measure sunlight
    sunlight_UVIndex = (float)sunlight.ReadUV()/100.0;
    sunlight_Visible = sunlight.ReadVisible();
    sunlight_IR      = sunlight.ReadIR();

    // measure soil moisture
    moisture = (float)analogRead(pin_moisture)/7;
    if(moisture > 100)
        moisture = 100;

    // measure water flow and dispensed volume
    measureWaterFlowAndDispensedVolume();
    
    // measure encoder count
    measureEncoder();
}


// warnings *************************************************************

// temperature
bool isWarningDetected_temperature_low() { return temperature < settings_temperature_min; }
bool isWarningDetected_temperature_high(){ return temperature > settings_temperature_max; }

// humidity
bool isWarningDetected_humidity_low()    { return humidity < settings_humidity_min; }
bool isWarningDetected_humidity_high()   { return humidity > settings_humidity_max; }

// UV index
bool isWarningDetected_UVIndex_high()    { return sunlight_UVIndex > settings_UVIndex_max; }

// Soil moisture
bool isWarningDetected_moisture_low()    { return moisture < settings_moisture_min; }

// No water
bool isWarningDetected_noWater()         { return warning_noWater_flag; }


// read settings from HITIPanel ****************************************

void readSettingsFromHITIPanel()
{
    // temperature
    settings_temperature_min = HC_analogDataRead(ad_temperature_min);
    settings_temperature_max = HC_analogDataRead(ad_temperature_max);

    // humidity
    settings_humidity_min = HC_analogDataRead(ad_humidity_min);  
    settings_humidity_max = HC_analogDataRead(ad_humidity_max);  
     
    // sunlight
    settings_UVIndex_max = HC_analogDataRead(ad_sunlight_UVIndex_max);

    // soil moisture
    settings_moisture_min = HC_analogDataRead(ad_moisture_min);

    // watering
    settings_wateringTime   = HC_analogDataRead(ad_wateringTime);
    settings_absorptionTime = HC_analogDataRead(ad_absorptionTime);
    settings_wateringEnabled = HC_digitalDataRead(dd_enableWatering);
}


// send data to HITIPanel *********************************************

void sendDataToHITIPanel()
{
    // temperature
    HC_analogDataWrite(ad_temperature_min, settings_temperature_min);
    HC_analogDataWrite(ad_temperature_max, settings_temperature_max);
    HC_analogDataWrite(ad_temperature,     temperature);

    // humidity
    HC_analogDataWrite(ad_humidity_min,    settings_humidity_min);  
    HC_analogDataWrite(ad_humidity_max,    settings_humidity_max);  
    HC_analogDataWrite(ad_humidity,        humidity);  
     
    // sunlight
    HC_analogDataWrite(ad_sunlight_UVIndex_max, settings_UVIndex_max);
    HC_analogDataWrite(ad_sunlight_UVIndex,     sunlight_UVIndex);
    HC_analogDataWrite(ad_sunlight_Visible,     sunlight_Visible);
    HC_analogDataWrite(ad_sunlight_IR,          sunlight_IR);

    // soil moisture
    HC_analogDataWrite(ad_moisture_min, settings_moisture_min);
    HC_analogDataWrite(ad_moisture,     moisture);

    // watering, water flow and dispensed volume
    HC_analogDataWrite(ad_wateringTime,                settings_wateringTime);
    HC_analogDataWrite(ad_absorptionTime,              settings_absorptionTime);
    HC_analogDataWrite(ad_flow_lmin,                   flow_lmin);
    HC_analogDataWrite(ad_dispensedWaterVolume,        dispensedWaterVolume);
    HC_analogDataWrite(ad_dispensedWaterVolume_perDay, dispensedWaterVolume_perDay);
    //HC_analogDataWrite(ad_watering_state,              state);
    HC_digitalDataWrite(dd_enableWatering,             settings_wateringEnabled);
    HC_digitalDataWrite(dd_isWatering,                 watering_ongoing_flag);    

    // encoder
    HC_analogDataWrite(ad_encoder, encoder_variation);

    // warnings
    bool warning = isWarningDetected_temperature_low() || isWarningDetected_temperature_high() ||
                   isWarningDetected_humidity_low()    || isWarningDetected_humidity_high()    ||
                   isWarningDetected_UVIndex_high()    || isWarningDetected_moisture_low()     ||
                   isWarningDetected_noWater();

    HC_digitalDataWrite(dd_warning_temperature_low,  isWarningDetected_temperature_low());
    HC_digitalDataWrite(dd_warning_temperature_high, isWarningDetected_temperature_high());
    HC_digitalDataWrite(dd_warning_humidity_low,     isWarningDetected_humidity_low());
    HC_digitalDataWrite(dd_warning_humidity_high,    isWarningDetected_humidity_high());
    HC_digitalDataWrite(dd_warning_UVIndex_high,     isWarningDetected_UVIndex_high());
    HC_digitalDataWrite(dd_warning_moisture_low,     isWarningDetected_moisture_low());
    HC_digitalDataWrite(dd_warning_noWater,          isWarningDetected_noWater());
    HC_digitalDataWrite(dd_warning,                  warning);
}


// Eeprom management ***************************************************

void saveSettings()
{
    HC_eeprom.writeFloat(FloatIndex_settings_temperature_min, settings_temperature_min);
    HC_eeprom.writeFloat(FloatIndex_settings_temperature_max, settings_temperature_max);
    HC_eeprom.writeFloat(FloatIndex_settings_humidity_min,    settings_humidity_min);
    HC_eeprom.writeFloat(FloatIndex_settings_humidity_max,    settings_humidity_max);
    HC_eeprom.writeFloat(FloatIndex_settings_UVIndex_max,     settings_UVIndex_max);
    HC_eeprom.writeFloat(FloatIndex_settings_moisture_min,    settings_moisture_min);
    HC_eeprom.writeFloat(FloatIndex_settings_wateringTime,    settings_wateringTime);
    HC_eeprom.writeFloat(FloatIndex_settings_absorptionTime,  settings_absorptionTime);
    
    HC_eeprom.writeBoolean(BooleanIndex_settings_wateringEnabled,  settings_wateringEnabled);

    // set flag => settings saved at least once
    HC_eeprom.writeBoolean(BooleanIndex_settingsDetected, true);
}

void loadSettings()
{
    settings_temperature_min = HC_eeprom.readFloat(FloatIndex_settings_temperature_min);
    settings_temperature_max = HC_eeprom.readFloat(FloatIndex_settings_temperature_max);
    settings_humidity_min    = HC_eeprom.readFloat(FloatIndex_settings_humidity_min);
    settings_humidity_max    = HC_eeprom.readFloat(FloatIndex_settings_humidity_max);
    settings_UVIndex_max     = HC_eeprom.readFloat(FloatIndex_settings_UVIndex_max);
    settings_moisture_min    = HC_eeprom.readFloat(FloatIndex_settings_moisture_min);
    settings_wateringTime    = HC_eeprom.readFloat(FloatIndex_settings_wateringTime);
    settings_absorptionTime  = HC_eeprom.readFloat(FloatIndex_settings_absorptionTime);
    
    settings_wateringEnabled = HC_eeprom.readBoolean(BooleanIndex_settings_wateringEnabled);

    // display loaded data in HITIPanel
    sendDataToHITIPanel();
}

bool isSettingsDetected()
{
    return HC_eeprom.readBoolean(BooleanIndex_settingsDetected);
}


// Virtual Buttons ****************************************************

void manageVirtualButtons()
{
    manageVirtualButton_saveSettings();
    manageVirtualButton_loadSettings();
    manageVirtualButton_watering();
    manageVirtualButton_resetWarning_noWater();
}

// Settings
void manageVirtualButton_saveSettings()
{
    if(HC_digitalDataRead_click(dd_saveSettings))
        saveSettings();
}
void manageVirtualButton_loadSettings()
{
    if(HC_digitalDataRead_click(dd_loadSettings))
        loadSettings();
}

// Watering
void manageVirtualButton_watering()
{
    if(HC_digitalDataRead_click(dd_water))
        watering_request_flag = true; // set request flag
}

// Reset warning: No water
void manageVirtualButton_resetWarning_noWater()
{
    if(HC_digitalDataRead_click(dd_resetWarning_noWater))
        warning_noWater_flag = false; // reset warning flag
}


// Watering ************************************************************

void manageWatering()
{
    static byte retry = 0;

    // if watering is disabled
    if(!settings_wateringEnabled)
    {
        // reset flags
        watering_ongoing_flag = 0;
        watering_request_flag = 0;

        // pump OFF
        waterPumpOff();

        state = state_init;
    }
    // if watering is enabled
    else
    {
        switch(state)
        {
            // 0: check if watering is required and possible
            case state_init: 
                // is there water?
                // is watering required? (request OR dry soil)
                if(!warning_noWater_flag && (watering_request_flag || isWarningDetected_moisture_low()))
                    state = state_start;
                break;
    
            // 1: start
            case state_start:
                // set flags
                watering_ongoing_flag = 1;
                retry = 0;
    
                // reset dispensed water volume    
                dispensedWaterVolume = 0;
                    
                state = state_watering;
                break;
    
            // 2: watering
            case state_watering:
                // pump ON
                waterPumpOn();
                
                // water during 2s
                if(timer_watering.delay(settings_wateringTime*1000))
                    state = (flow_lsec < 0.005) ? state_retry : state_absorption; 
                break;
    
            // 3: water absorption
            case state_absorption:
                // pump OFF
                waterPumpOff();
            
                // absorption during 5s
                if(timer_absorption.delay(settings_absorptionTime*1000))
                    state =  isWarningDetected_moisture_low() ? state_watering : state_finish;             
                break;
    
            // 4: finish
            case state_finish:
                // reset flags
                watering_ongoing_flag = 0;
                watering_request_flag = 0;
        
                state = state_init;
                break;
    
            // 5: no water => retry pumping x5
            case state_retry:
                state = (retry ++ < 5) ? state_watering : state_noWaterWarning;
                break;
    
            // 6: no water => warning
            case state_noWaterWarning:
                // pump OFF
                waterPumpOff();

                // set warning flag
                warning_noWater_flag = true; 
                
                state = state_finish;
                break;
        }
    }
}
",volume_perDay
516,"// Fill out your copyright notice in the Description page of Project Settings.


#include ""Widgets/EnhancedBoundActionBar.h""

#include ""CommonUITypes.h""
#include ""Input/CommonUIActionRouterBase.h""
#include ""Utilities/EnhancedActionBarSubsystem.h""
#include ""Widgets/EnhancedBoundActionButton.h""

void UEnhancedBoundActionBar::OnWidgetRebuilt()
{
	Super::OnWidgetRebuilt();

	if (const UGameInstance* GameInstance = GetGameInstance())
	{
		for (const ULocalPlayer* LocalPlayer : GameInstance->GetLocalPlayers())
		{
			if (UEnhancedActionBarSubsystem* EnhancedActionBarSubsystem = UEnhancedActionBarSubsystem::Get(LocalPlayer))
			{
				EnhancedActionBarSubsystem->OnActionsUpdated().AddUObject(this, &UEnhancedBoundActionBar::HandleOnActionsUpdated);
			}
		}
	}
}

void UEnhancedBoundActionBar::ReleaseSlateResources(bool  [MASK] )
{
	Super::ReleaseSlateResources( [MASK] );

	if (const UGameInstance* GameInstance = GetGameInstance())
	{
		for (const ULocalPlayer* LocalPlayer : GameInstance->GetLocalPlayers())
		{
			if (UEnhancedActionBarSubsystem* EnhancedActionBarSubsystem = UEnhancedActionBarSubsystem::Get(LocalPlayer))
			{
				EnhancedActionBarSubsystem->OnActionsUpdated().RemoveAll(this);
			}
		}
	}
}

void UEnhancedBoundActionBar::ActionBarUpdateBeginImpl()
{
	Super::ActionBarUpdateBeginImpl();

	// Be aware that here will remove all action buttons
}

void UEnhancedBoundActionBar::ActionBarUpdateEndImpl()
{
	Super::ActionBarUpdateEndImpl();

	// After the legacy action buttons are built, we can build the enhanced ones
	NativeOnEnhancedActionsUpdated();
}

void UEnhancedBoundActionBar::NativeOnEnhancedActionsUpdated()
{
	UEnhancedActionBarSubsystem* EnhancedActionBarSubsystem = UEnhancedActionBarSubsystem::Get(GetOwningLocalPlayer());
	if (EnhancedActionBarSubsystem)
	{
		TArray<const UInputAction*> Actions = EnhancedActionBarSubsystem->GatherAllActions();

		auto GetNavBarPriority = [](const UInputAction* InputAction)
		{
			if (InputAction)
			{
				if (TObjectPtr<const UCommonInputMetadata> InputActionMetadata = CommonUI::GetEnhancedInputActionMetadata(InputAction))
				{
					return InputActionMetadata->NavBarPriority;
				}
			}

			return 0;
		};

		Algo::Sort(Actions, [GetNavBarPriority](const UInputAction* A, const UInputAction* B)
		{
			return GetNavBarPriority(A) < GetNavBarPriority(B);
		});

		for (const UInputAction* Action : Actions)
		{
			if (Action)
			{
				if (UEnhancedBoundActionButton* Button = Cast<UEnhancedBoundActionButton>(CreateActionButton(FUIActionBindingHandle())) )
				{
					Button->SetRepresentEnhancedAction(Action);
					NativeOnActionButtonCreated(Button, FUIActionBindingHandle());
				}
			}
		}
	}
}

void UEnhancedBoundActionBar::HandleOnActionsUpdated()
{
	if (!bIsPendingRefresh)
	{
		bIsPendingRefresh = true;

		FTSTicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateWeakLambda(this, [WeakThis = MakeWeakObjectPtr(this)](float InDelta)
		{
			if (WeakThis.IsValid())
			{
				/***
				 * This is a hacky way to force the action bar to update itself.
				 * We can't override HandleDeferredDisplayUpdate without modifying the source code.
				 */
				if (UCommonUIActionRouterBase* ActionRouter = UCommonUIActionRouterBase::Get(*WeakThis))
				{
					ActionRouter->OnBoundActionsUpdated().Broadcast();
				}
			}

			return false;
		}), 0.1f);
	}
}
",bReleaseChildren
517,"// This file is part of The New Aspell
// Copyright (C) 2001 by <NAME> under the GNU LGPL license
// version 2.0 or 2.1.  You should have received a copy of the LGPL
// license along with this library if you did not you can find
// it at http://www.gnu.org/.

#ifndef autil__block_slist_t_hh
#define autil__block_slist_t_hh

#include <cstdlib>
#include <cassert>

#include ""block_slist.hpp""

namespace acommon {

  template <typename T>
  void BlockSList<T>::add_block(unsigned int  [MASK] ) 
  {
    assert (reinterpret_cast<const char *>(&(first_available->next))
	    == 
	    reinterpret_cast<const char *>(first_available));
    const unsigned int ptr_offset = 
      reinterpret_cast<const char *>(&(first_available->data)) 
      - reinterpret_cast<const char *>(&(first_available->next));
    void * block = malloc( ptr_offset + sizeof(Node) *  [MASK]  );
    *reinterpret_cast<void **>(block) = first_block;
    first_block = block;
    Node * first = reinterpret_cast<Node *>(reinterpret_cast<char *>(block) + ptr_offset);
    Node * i = first;
    Node * last = i +  [MASK] ;
    while (i + 1 != last) {
      i->next = i + 1;
      i = i + 1;
    }
    i->next = 0;
    first_available = first;  
  }

  template <typename T>
  void BlockSList<T>::clear()
  {
    void * i = first_block;
    while (i != 0) {
      void * n = *reinterpret_cast<void **>(i);
      free(i);
      i = n;
    }
    first_block = 0;
    first_available = 0;
  }

}

#endif
",num
518,"/* z80stb.c
 * Zilog Z80 processor emulator in C. Modified to be API compliant with Neil
 * Bradley's MZ80 (for ported projects)
 * Ported to 'C' by <NAME>; original copyright follows:
 *
 * Abstract:
 *   Internal declarations for Zilog Z80 emulator.
 *
 * Revisions:
 *   18-Apr-97 EAM Created
 *   ??-???-97 EAM Released in MageX 0.5
 *   26-Jul-97 EAM Fixed Time Pilot slowdown bug and
 *      Gyruss hiscore bugs (opcode 0xC3)
 *
 * Original copyright (C) 1997 <NAME>
 */

 //This is a rework in progress.

#include ""cpu_z80.h""
#include <assert.h>
#include ""log.h""
#include <stdlib.h>


#pragma warning( disable : 4244) //16 bit to 8 bit port return

// Precomputed parity table.
static uint8_t ZSTable[256] =
{
64,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
,128,128,128,128,128,128,128,128,128,128,128,128
};

// Precomputed parity, sign and zero flags table.
static uint8_t ZSPTable[256] =
{
68,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4
,0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0
,0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0
,4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4
,0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0
,4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4
,4,0,0,4,0,4,4,0,0,4,4,0,4,0,0,4
,0,4,4,0,4,0,0,4,4,0,0,4,0,4,4,0
,128,132,132,128,132,128,128,132,132,128,128,132,128,132,132,128
,132,128,128,132,128,132,132,128,128,132,132,128,132,128,128,132
,132,128,128,132,128,132,132,128,128,132,132,128,132,128,128,132
,128,132,132,128,132,128,128,132,132,128,128,132,128,132,132,128
,132,128,128,132,128,132,132,128,128,132,132,128,132,128,128,132
,128,132,132,128,132,128,128,132,132,128,128,132,128,132,132,128
,128,132,132,128,132,128,128,132,132,128,128,132,128,132,132,128
,132,128,128,132,128,132,132,128,128,132,132,128,132,128,128,132
};

void cpu_z80::mz80reset()
{
	m_fPendingInterrupt = false;
	m_rgbOpcodeBase = m_rgbMemory;
	/* m_rgbMemory = */
	m_rgbStackBase = m_rgbMemory;

	m_regAF = 0;
	m_regBC = 0;
	m_regDE = 0;
	m_regHL = 0;
	m_regAF2 = 0;
	m_regBC2 = 0;
	m_regDE2 = 0;
	m_regHL2 = 0;
	m_regR = rand();
	m_regI = 0;
	m_regF |= Z_FLAG;
	m_fHalt = false;
	m_nIM = 0;
	m_regIX = 0xffff;		// Yes, this intentional, and the way a Z80 comes
	m_regIY = 0xffff;		// up in power-on state!
	m_iff1 = 0;
	m_iff2 = 0;
	iff_delay = 0;
	irq_vector = 0xff;
	z80intAddr = 0x38;
	z80nmiAddr = 0x66;
	pending_int = 0;        // Added for int strobe
	previous_opcode = 0;    // added for Sega Vector decryption since get PPC wasn't working and I gave up.
	SetPC(0x0000);
	SetSP(0x0000);
	z80pc = 0;
	cCycles = 0;
	dwElapsedTicks = 0;
}

cpu_z80::cpu_z80(uint8_t* MEM, MemoryReadByte* read_mem, MemoryWriteByte* write_mem, z80PortRead* port_read, z80PortWrite* port_write, uint16_t addr, int num)
{
	cpu_num = num;
	m_rgbMemory = MEM;
	z80MemoryRead = read_mem;
	z80MemoryWrite = write_mem;
	z80IoRead = port_read;
	z80IoWrite = port_write;
	mz80reset();
}

//ADDRESSING OPCODES

uint8_t cpu_z80::ImmedByte()
{
	return *m_rgbOpcode++;
}

UINT16 cpu_z80::ImmedWord()
{
	uint16_t w = *(uint16_t*)m_rgbOpcode; //Have to convert AND dereference!
	m_rgbOpcode += 2;
	return w;
}

uint8_t  cpu_z80::GetLastOpcode()
{
	return previous_opcode;
}

uint16_t cpu_z80::GetPC()
{
	return (uint16_t)(m_rgbOpcode - m_rgbOpcodeBase);
}

void cpu_z80::SetPC(uint16_t wAddr)
{
	m_rgbOpcode = &m_rgbOpcodeBase[wAddr];
}

void cpu_z80::AdjustPC(int8_t cb)
{
	m_rgbOpcode += cb;
}

void cpu_z80::Push(uint16_t wArg)
{
	MemWriteByte(--m_rgbStack - m_rgbStackBase, (wArg >> 8));
	MemWriteByte(--m_rgbStack - m_rgbStackBase, (wArg & 0xFF));
}

uint16_t cpu_z80::Pop()
{
	uint16_t wAddr = 0;

	wAddr = MemReadByte(m_rgbStack++ - m_rgbStackBase);
	wAddr |= (MemReadByte(m_rgbStack++ - m_rgbStackBase) << 8);

	return(wAddr);
}

uint16_t cpu_z80::GetSP()
{
	return (uint16_t)(m_rgbStack - m_rgbStackBase);
}

void cpu_z80::SetSP(uint16_t wAddr)
{
	m_rgbStack = &m_rgbStackBase[wAddr];
}

//Memory and IP Accesses


UINT8 cpu_z80::mz80GetMemory(uint16_t addr)
{
	MemoryReadByte* MemRead = z80MemoryRead;

	z80pc = GetPC(); /* for some of the platforms */

	while (MemRead->lowAddr != 0xffffffff)
	{
		if (addr >= MemRead->lowAddr && addr <= MemRead->highAddr)
		{
			z80pc = GetPC();
			return (MemRead->memoryCall(addr - MemRead->lowAddr, MemRead));
		}

		++MemRead;
	}

	return (m_rgbMemory[addr]);
}

void cpu_z80::mz80PutMemory(uint16_t addr, uint8_t byte)
{
	MemoryWriteByte* MemWrite = z80MemoryWrite;

	while (MemWrite->lowAddr != 0xffffffff)
	{
		if (addr >= MemWrite->lowAddr && addr <= MemWrite->highAddr)
		{
			z80pc = GetPC();
			MemWrite->memoryCall(addr - MemWrite->lowAddr, byte, MemWrite);
			return;
		}
		MemWrite++;
	}

	m_rgbMemory[addr] = byte;
}

uint8_t cpu_z80::In(uint8_t bPort)
{
	uint8_t bVal = 0xff;

	struct z80PortRead* mr = z80IoRead;

	z80pc = GetPC(); /* for some of the platforms */

	while (mr->lowIoAddr != 0xffff) {
		if (bPort >= mr->lowIoAddr && bPort <= mr->highIoAddr) {
			bVal = mr->IOCall(bPort, mr);
			break;
		}
		mr++;
	}

	m_regF = (m_regF & C_FLAG) | ZSPTable[bVal];

	return bVal;
}

uint8_t cpu_z80::InRaw(uint8_t bPort)
{
	uint8_t bVal = 0xff;

	struct z80PortRead* mr = z80IoRead;

	z80pc = GetPC(); /* for some of the platforms */

	while (mr->lowIoAddr != 0xffff) {
		if (bPort >= mr->lowIoAddr && bPort <= mr->highIoAddr) {
			bVal = mr->IOCall(bPort, mr);
			break;
		}
		mr++;
	}

	m_regF = (m_regF & C_FLAG) | ZSPTable[bVal];
	return bVal;
}

void cpu_z80::Out(uint8_t bPort, uint8_t bVal)
{
	struct z80PortWrite* mr = z80IoWrite;

	z80pc = GetPC(); /* for some of the platforms */

	while (mr->lowIoAddr != 0xffff) {
		if (bPort >= mr->lowIoAddr && bPort <= mr->highIoAddr) {
			mr->IOCall(bPort, bVal, mr);
			return;
		}
		mr++;
	}
}

void cpu_z80::MemWriteWord(UINT16 wAddr, UINT16  [MASK] )
{
	MemWriteByte(wAddr++, ( [MASK]  & 0xFF));
	MemWriteByte(wAddr, ( [MASK]  >> 8));
}

void cpu_z80::MemWriteByte(UINT16 wAddr, UINT8 bVal)
{
	mz80PutMemory(wAddr, bVal);
}

UINT8 cpu_z80::MemReadByte(UINT16 wAddr)
{
	return (mz80GetMemory(wAddr));
}

UINT16 cpu_z80::MemReadWord(UINT16 wAddr)
{
	UINT8 op1;
	UINT8 op2;

	op1 = MemReadByte(wAddr++);
	op2 = MemReadByte(wAddr);
	return  (op1 | (op2 << 8));//   (MAKEWORD(op1, op2));
}

/* ***************************************************************************
 * Z80  opcodes
 * ***************************************************************************
 */

void cpu_z80::Daa() {
	int result = m_regA;
	int tmp = 0;
	if (m_regF & N_FLAG)
	{
		tmp = m_regF & (C_FLAG | N_FLAG | H_FLAG);
		if ((m_regF & C_FLAG) != 0 || m_regA > 0x99)
		{
			result -= 0x160;
		}

		if ((m_regF & H_FLAG) || (m_regA & 0x0f) > 9)
		{
			if ((m_regA & 0x0F) > 5)
			{
				tmp &= ~H_FLAG;
			}
			result = (result & 0xFF00) | ((result - 6) & 0xFF);
		}
	}
	else
	{
		tmp = (m_regF & 0x01) | (((m_regA & 0x0F) > 9) ? 0x10 : 0x00); // 0x10: H_FLAG
		if (((tmp | m_regF) & 0x10) != 0)
		{
			result += 6;
		}

		if (((m_regF & C_FLAG) != 0) || ((result & 0x1F0) > 0x90))
		{
			result += 0x60;
		}
	}

	m_regA = (UINT8)(result & 0xff);
	m_regF = (UINT8)(ZSPTable[m_regA] | tmp | ((result >> 8) & 0x01));
}

int cpu_z80::Ret0(int f)
{
	if (f)
	{
		SetPC(Pop());
		return 6;
	}
	else
	{
		return 0;
	}
}

int cpu_z80::Ret1(int f)
{
	if (f)
	{
		return 0;
	}
	else
	{
		SetPC(Pop());
		return 6;
	}
}

uint16_t cpu_z80::Adc_2(uint16_t wArg1, uint16_t wArg2)
{
	int q = wArg1 + wArg2 + (m_regF & C_FLAG);
	m_regF = (((wArg1 ^ q ^ wArg2) & 0x1000) >> 8) | ((q >> 16) & 1) | ((q & 0x8000) >> 8) | ((q & 65535) ? 0 : Z_FLAG) | (((wArg2 ^ wArg1 ^ 0x8000) & (wArg2 ^ q) & 0x8000) >> 13);
	return q;
}

uint16_t cpu_z80::Sbc_2(uint16_t wArg1, uint16_t wArg2)
{
	int q = wArg1 - wArg2 - (m_regF & C_FLAG);

	m_regF = (((wArg1 ^ q ^ wArg2) & 0x1000) >> 8) | ((q >> 16) & 1) | ((q & 0x8000) >> 8) |
		((q & 65535) ? 0 : Z_FLAG) | (((wArg1 ^ wArg2) & (wArg1 ^ q) & 0x8000) >> 13) | N_FLAG;

	return q;
}

uint16_t cpu_z80::Add_2(uint16_t wArg1, uint16_t wArg2)
{
	int q = wArg1 + wArg2;
	m_regF = (m_regF & (S_FLAG | Z_FLAG | V_FLAG)) | (((wArg1 ^ q ^ wArg2) & 0x1000) >> 8) | ((q >> 16) & 1);
	return q;
}

void cpu_z80::Add_1(uint8_t bArg)
{
	int q = m_regA + bArg;
	m_regF = ZSTable[q & 255] | ((q & 256) >> 8) | ((m_regA ^ q ^ bArg) & H_FLAG) | (((bArg ^ m_regA ^ 0x80) & (bArg ^ q) & 0x80) >> 5);
	m_regA = q;
}

void cpu_z80::Adc_1(uint8_t bArg)
{
	int q = m_regA + bArg + (m_regF & C_FLAG);
	m_regF = ZSTable[q & 255] | ((q & 256) >> 8) | ((m_regA ^ q ^ bArg) & H_FLAG) | (((bArg ^ m_regA ^ 0x80) & (bArg ^ q) & 0x80) >> 5);
	m_regA = q;
}

void cpu_z80::Sub_1(uint8_t bArg)
{
	int q = m_regA - bArg;
	m_regF = ZSTable[q & 255] | ((q & 256) >> 8) | N_FLAG | ((m_regA ^ q ^ bArg) & H_FLAG) | (((bArg ^ m_regA) & (m_regA ^ q) & 0x80) >> 5);
	m_regA = q;
}

void cpu_z80::Sbc_1(uint8_t bArg)
{
	int q = m_regA - bArg - (m_regF & C_FLAG);
	m_regF = ZSTable[q & 255] | ((q & 256) >> 8) | N_FLAG | ((m_regA ^ q ^ bArg) & H_FLAG) | (((bArg ^ m_regA) & (bArg ^ q) & 0x80) >> 5);
	m_regA = q;
}

void cpu_z80::And(uint8_t bArg)
{
	m_regF = ZSPTable[m_regA &= bArg] | H_FLAG;
}

void cpu_z80::Or(uint8_t bArg)
{
	m_regF = ZSPTable[m_regA |= bArg];
}

void cpu_z80::Xor(uint8_t bArg)
{
	m_regF = ZSPTable[m_regA ^= bArg];
}

void cpu_z80::Cp(uint8_t bArg)
{
	int q = m_regA - bArg;
	m_regF = ZSTable[q & 255] | ((q & 256) >> 8) | N_FLAG | ((m_regA ^ q ^ bArg) & H_FLAG) | (((bArg ^ m_regA) & (bArg ^ q) & 0x80) >> 5);
}

uint8_t cpu_z80::Inc(uint8_t bArg)
{
	bArg++;
	m_regF = (m_regF & C_FLAG) | ZSTable[bArg] | ((bArg == 0x80) ? V_FLAG : 0) | ((bArg & 0x0F) ? 0 : H_FLAG);
	return bArg;
}

uint8_t cpu_z80::Dec(uint8_t bArg)
{
	m_regF = (m_regF & C_FLAG) | N_FLAG |
		((bArg == 0x80) ? V_FLAG : 0) | ((bArg & 0x0F) ? 0 : H_FLAG);

	m_regF |= ZSTable[--bArg];

	return bArg;
}

uint8_t cpu_z80::Set(uint8_t bArg, int nBit)
{
	return (bArg | (1 << nBit));
}

uint8_t cpu_z80::Res(uint8_t bArg, int nBit)
{
	return (bArg & ~(1 << nBit));
}

void cpu_z80::Bit(uint8_t bArg, int nBit)
{
	m_regF = (m_regF & C_FLAG) | H_FLAG | ((bArg & (1 << nBit)) ? ((nBit == 7) ? S_FLAG : 0) : Z_FLAG);
}

uint8_t cpu_z80::Rlc(uint8_t bArg)
{
	int q = bArg >> 7;
	bArg = (bArg << 1) | q;
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

uint8_t cpu_z80::Rrc(uint8_t bArg)
{
	int q = bArg & 1;
	bArg = (bArg >> 1) | (q << 7);
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

uint8_t cpu_z80::Rl(uint8_t bArg)
{
	int q = bArg >> 7;
	bArg = (bArg << 1) | (m_regF & 1);
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

uint8_t cpu_z80::Rr(uint8_t bArg)
{
	int q = bArg & 1;
	bArg = (bArg >> 1) | (m_regF << 7);
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

uint8_t cpu_z80::Sll(uint8_t bArg)
{
	int q = bArg >> 7;
	bArg = (bArg << 1) | 1;
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

uint8_t cpu_z80::Srl(uint8_t bArg)
{
	int q = bArg & 1;
	bArg >>= 1;
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

uint8_t cpu_z80::Sla(uint8_t bArg)
{
	int q = bArg >> 7;
	bArg <<= 1;
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

uint8_t cpu_z80::Sra(uint8_t bArg)
{
	int q = bArg & 1;
	bArg = (bArg >> 1) | (bArg & 0x80);
	m_regF = ZSPTable[bArg] | q;
	return bArg;
}

/* ***************************************************************************
 * Edwards Z80 Utilities
 * ***************************************************************************
 */

 //#define swap(b1,b2) swap_variable = b1; b1 = b2; b2 = swap_variable;
void cpu_z80::swap(uint16_t& b1, uint16_t& b2)
{
	uint16_t b = b1;
	b1 = b2;
	b2 = b;
}

void cpu_z80::Rlca()
{
	m_regA = (m_regA << 1) | ((m_regA & 0x80) >> 7);
	m_regF = (m_regF & 0xEC) | (m_regA & C_FLAG);
}

void cpu_z80::Rrca()
{
	m_regF = (m_regF & 0xEC) | (m_regA & 0x01);
	m_regA = (m_regA >> 1) | (m_regA << 7);
}

void cpu_z80::Rla()
{
	int i = m_regF & C_FLAG;
	m_regF = (m_regF & 0xEC) | ((m_regA & 0x80) >> 7);
	m_regA = (m_regA << 1) | i;
}

void cpu_z80::Rra()
{
	int i = m_regF & C_FLAG;
	m_regF = (m_regF & 0xEC) | (m_regA & 0x01);
	m_regA = (m_regA >> 1) | (i << 7);
}

/*---------------------------------------------------------------------------

	Exec

	Executes the specified number of t-states.  Returns the actual number of
	t-states executed.  If a halt instruction is encountered, the execution
	loop exits.  If the processor is currently in a halted state this
	function immediately returns 0.

---------------------------------------------------------------------------*/

unsigned long int cpu_z80::mz80exec(unsigned long int cCyclesArg)
{
	UINT32 origElapsedTicks = dwElapsedTicks;

	cCycles = cCyclesArg;

	while (cCycles > 0)
	{
		int prev_cycles = cCycles;
		// Note: Fix this nonsense. Move the main loop out. Make the cycle counting positive to make it easier. 
		if (m_fHalt)
		{
			m_regR++;
			cCycles -= 4;
			previous_opcode = 0x76;
		}
		else
		{
		const uint8_t bOpcode = ImmedByte();
		m_regR++;
		z80pc = GetPC(); /* for some of the platforms */
		previous_opcode = bOpcode;

		switch (bOpcode)
		{
		case 0x00: // nop
			cCycles -= 4;
			break;

		case 0x01: // ld_bc_word
			cCycles -= 10;
			m_regBC = ImmedWord();
			break;

		case 0x02: // ld_xbc_a
			cCycles -= 7;
			MemWriteByte(m_regBC, m_regA);
			break;

		case 0x03: // inc_bc
			cCycles -= 6;
			m_regBC++;
			break;

		case 0x04: // inc_b
			cCycles -= 4;
			m_regB = Inc(m_regB);
			break;

		case 0x05: // dec_b
			cCycles -= 4;
			m_regB = Dec(m_regB);
			break;

		case 0x06: // ld_b_byte
			cCycles -= 7;
			m_regB = ImmedByte();
			break;

		case 0x07: // rlca
			cCycles -= 4;
			Rlca();
			break;

		case 0x08: // ex_af_af
			cCycles -= 4;
			swap(m_regAF, m_regAF2);
			break;

		case 0x09: // add_hl_bc
			cCycles -= 11;
			m_regHL = Add_2(m_regHL, m_regBC);
			break;

		case 0x0A: // ld_a_xbc
			cCycles -= 7;
			m_regA = MemReadByte(m_regBC);
			break;

		case 0x0B: // dec_bc
			cCycles -= 6;
			m_regBC--;
			break;

		case 0x0C: // inc_c
			cCycles -= 4;
			m_regC = Inc(m_regC);
			break;

		case 0x0D: // dec_c
			cCycles -= 4;
			m_regC = Dec(m_regC);
			break;

		case 0x0E: // ld_c_byte
			cCycles -= 7;
			m_regC = ImmedByte();
			break;

		case 0x0F: // rrca
			cCycles -= 4;
			Rrca();
			break;

		case 0x10: // djnz
			cCycles -= 8;
			cCycles -= Jr0(--m_regB);
			break;

		case 0x11: // ld_de_word
			cCycles -= 10;
			m_regDE = ImmedWord();
			break;

		case 0x12: // ld_xde_a
			cCycles -= 7;
			MemWriteByte(m_regDE, m_regA);
			break;

		case 0x13: // inc_de
			cCycles -= 6;
			m_regDE++;
			break;

		case 0x14: // inc_d
			cCycles -= 4;
			m_regD = Inc(m_regD);
			break;

		case 0x15: // dec_d
			cCycles -= 4;
			m_regD = Dec(m_regD);
			break;

		case 0x16: // ld_d_byte
			cCycles -= 7;
			m_regD = ImmedByte();
			break;

		case 0x17: // rla
			cCycles -= 4;
			Rla();
			break;

		case 0x18: // jr
			cCycles -= Jr0(1);
			break;

		case 0x19: // add_hl_de
			cCycles -= 11;
			m_regHL = Add_2(m_regHL, m_regDE);
			break;

		case 0x1A: // ld_a_xde
			cCycles -= 7;
			m_regA = MemReadByte(m_regDE);
			break;

		case 0x1B: // dec_de
			cCycles -= 6;
			m_regDE--;
			break;

		case 0x1C: // inc_e
			cCycles -= 4;
			m_regE = Inc(m_regE);
			break;

		case 0x1D: // dec_e
			cCycles -= 4;
			m_regE = Dec(m_regE);
			break;

		case 0x1E: // ld_e_byte
			cCycles -= 7;
			m_regE = ImmedByte();
			break;

		case 0x1F: // rra
			cCycles -= 4;
			Rra();
			break;

		case 0x20: // jr_nz
			cCycles -= 7;
			cCycles -= Jr1(m_regF & Z_FLAG);
			break;

		case 0x21: // ld_hl_word
			cCycles -= 10;
			m_regHL = ImmedWord();
			break;

		case 0x22: // ld_xword_hl
			cCycles -= 16;
			MemWriteWord(ImmedWord(), m_regHL);
			break;

		case 0x23: // inc_hl
			cCycles -= 6;
			m_regHL++;
			break;

		case 0x24: // inc_h
			cCycles -= 4;
			m_regH = Inc(m_regH);
			break;

		case 0x25: // dec_h
			cCycles -= 4;
			m_regH = Dec(m_regH);
			break;

		case 0x26: // ld_h_byte
			cCycles -= 7;
			m_regH = ImmedByte();
			break;

		case 0x27: // daa
		{
			cCycles -= 4;
			Daa();
			break;
		}

		case 0x28: // jr_z
			cCycles -= 7;
			cCycles -= Jr0(m_regF & Z_FLAG);
			break;

		case 0x29: // add_hl_hl
			cCycles -= 11;
			m_regHL = Add_2(m_regHL, m_regHL);
			break;

		case 0x2A: // ld_hl_xword
			cCycles -= 16;
			m_regHL = MemReadWord(ImmedWord());
			break;

		case 0x2B: // dec_hl
			cCycles -= 6;
			m_regHL--;
			break;

		case 0x2C: // inc_l
			cCycles -= 4;
			m_regL = Inc(m_regL);
			break;

		case 0x2D: // dec_l
			cCycles -= 4;
			m_regL = Dec(m_regL);
			break;

		case 0x2E: // ld_l_byte
			cCycles -= 7;
			m_regL = ImmedByte();
			break;

		case 0x2F: // cpl
			cCycles -= 4;
			m_regA ^= 0xFF;
			m_regF |= (H_FLAG | N_FLAG);
			break;

		case 0x30: // jr_nc
			cCycles -= 7;
			cCycles -= Jr1(m_regF & C_FLAG);
			break;

		case 0x31: // ld_sp_word
			cCycles -= 10;
			SetSP(ImmedWord());
			break;

		case 0x32: // ld_xbyte_a
			cCycles -= 13;
			MemWriteByte(ImmedWord(), m_regA);
			break;

		case 0x33: // inc_sp
			cCycles -= 6;
			SetSP(GetSP() + 1);
			break;

		case 0x34: // inc_xhl
			cCycles -= 11;
			MemWriteByte(m_regHL, Inc(MemReadByte(m_regHL)));
			break;

		case 0x35: // dec_xhl
			cCycles -= 11;
			MemWriteByte(m_regHL, Dec(MemReadByte(m_regHL)));
			break;

		case 0x36: // ld_xhl_byte
			cCycles -= 10;
			MemWriteByte(m_regHL, ImmedByte());
			break;

		case 0x37: // scf
			cCycles -= 4;
			m_regF = (m_regF & 0xEC) | C_FLAG;
			break;

		case 0x38: // jr_c
			cCycles -= 7;
			cCycles -= Jr0(m_regF & C_FLAG);
			break;

		case 0x39: // add_hl_sp
			cCycles -= 11;
			m_regHL = Add_2(m_regHL, GetSP());
			break;

		case 0x3A: // ld_a_xbyte
			cCycles -= 13;
			m_regA = MemReadByte(ImmedWord());
			break;

		case 0x3B: // dec_sp
			cCycles -= 6;
			SetSP(GetSP() - 1);
			break;

		case 0x3C: // inc_a
			cCycles -= 4;
			m_regA = Inc(m_regA);
			break;

		case 0x3D: // dec_a
			cCycles -= 4;
			m_regA = Dec(m_regA);
			break;

		case 0x3E: // ld_a_byte
			cCycles -= 7;
			m_regA = ImmedByte();
			break;

		case 0x3F: // ccf
			cCycles -= 4;
			m_regF = ((m_regF & 0xED) | ((m_regF & 1) << 4)) ^ 1;
			break;

		case 0x40: // ld_b_b
			cCycles -= 4;
			m_regB = m_regB;
			break;

		case 0x41: // ld_b_c
			cCycles -= 4;
			m_regB = m_regC;
			break;

		case 0x42: // ld_b_d
			cCycles -= 4;
			m_regB = m_regD;
			break;

		case 0x43: // ld_b_e
			cCycles -= 4;
			m_regB = m_regE;
			break;

		case 0x44: // ld_b_h
			cCycles -= 4;
			m_regB = m_regH;
			break;

		case 0x45: // ld_b_l
			cCycles -= 4;
			m_regB = m_regL;
			break;

		case 0x46: // ld_b_xhl
			cCycles -= 7;
			m_regB = MemReadByte(m_regHL);
			break;

		case 0x47: // ld_b_a
			cCycles -= 4;
			m_regB = m_regA;
			break;

		case 0x48: // ld_c_b
			cCycles -= 4;
			m_regC = m_regB;
			break;

		case 0x49: // ld_c_c
			cCycles -= 4;
			m_regC = m_regC;
			break;

		case 0x4A: // ld_c_d
			cCycles -= 4;
			m_regC = m_regD;
			break;

		case 0x4B: // ld_c_e
			cCycles -= 4;
			m_regC = m_regE;
			break;

		case 0x4C: // ld_c_h
			cCycles -= 4;
			m_regC = m_regH;
			break;

		case 0x4D: // ld_c_l
			cCycles -= 4;
			m_regC = m_regL;
			break;

		case 0x4E: // ld_c_xhl
			cCycles -= 7;
			m_regC = MemReadByte(m_regHL);
			break;

		case 0x4F: // ld_c_a
			cCycles -= 4;
			m_regC = m_regA;
			break;

		case 0x50: // ld_d_b
			cCycles -= 4;
			m_regD = m_regB;
			break;

		case 0x51: // ld_d_c
			cCycles -= 4;
			m_regD = m_regC;
			break;

		case 0x52: // ld_d_d
			cCycles -= 4;
			m_regD = m_regD;
			break;

		case 0x53: // ld_d_e
			cCycles -= 4;
			m_regD = m_regE;
			break;

		case 0x54: // ld_d_h
			cCycles -= 4;
			m_regD = m_regH;
			break;

		case 0x55: // ld_d_l
			cCycles -= 4;
			m_regD = m_regL;
			break;

		case 0x56: // ld_d_xhl
			cCycles -= 7;
			m_regD = MemReadByte(m_regHL);
			break;

		case 0x57: // ld_d_a
			cCycles -= 4;
			m_regD = m_regA;
			break;

		case 0x58: // ld_e_b
			cCycles -= 4;
			m_regE = m_regB;
			break;

		case 0x59: // ld_e_c
			cCycles -= 4;
			m_regE = m_regC;
			break;

		case 0x5A: // ld_e_d
			cCycles -= 4;
			m_regE = m_regD;
			break;

		case 0x5B: // ld_e_e
			cCycles -= 4;
			m_regE = m_regE;
			break;

		case 0x5C: // ld_e_h
			cCycles -= 4;
			m_regE = m_regH;
			break;

		case 0x5D: // ld_e_l
			cCycles -= 4;
			m_regE = m_regL;
			break;

		case 0x5E: // ld_e_xhl
			cCycles -= 7;
			m_regE = MemReadByte(m_regHL);
			break;

		case 0x5F: // ld_e_a
			cCycles -= 4;
			m_regE = m_regA;
			break;

		case 0x60: // ld_h_b
			cCycles -= 4;
			m_regH = m_regB;
			break;

		case 0x61: // ld_h_c
			cCycles -= 4;
			m_regH = m_regC;
			break;

		case 0x62: // ld_h_d
			cCycles -= 4;
			m_regH = m_regD;
			break;

		case 0x63: // ld_h_e
			cCycles -= 4;
			m_regH = m_regE;
			break;

		case 0x64: // ld_h_h
			cCycles -= 4;
			m_regH = m_regH;
			break;

		case 0x65: // ld_h_l
			cCycles -= 4;
			m_regH = m_regL;
			break;

		case 0x66: // ld_h_xhl
			cCycles -= 7;
			m_regH = MemReadByte(m_regHL);
			break;

		case 0x67: // ld_h_a
			cCycles -= 4;
			m_regH = m_regA;
			break;

		case 0x68: // ld_l_b
			cCycles -= 4;
			m_regL = m_regB;
			break;

		case 0x69: // ld_l_c
			cCycles -= 4;
			m_regL = m_regC;
			break;

		case 0x6A: // ld_l_d
			cCycles -= 4;
			m_regL = m_regD;
			break;

		case 0x6B: // ld_l_e
			cCycles -= 4;
			m_regL = m_regE;
			break;

		case 0x6C: // ld_l_h
			cCycles -= 4;
			m_regL = m_regH;
			break;

		case 0x6D: // ld_l_l
			cCycles -= 4;
			m_regL = m_regL;
			break;

		case 0x6E: // ld_l_xhl
			cCycles -= 7;
			m_regL = MemReadByte(m_regHL);
			break;

		case 0x6F: // ld_l_a
			cCycles -= 4;
			m_regL = m_regA;
			break;

		case 0x70: // ld_xhl_b
			cCycles -= 7;
			MemWriteByte(m_regHL, m_regB);
			break;

		case 0x71: // ld_xhl_c
			cCycles -= 7;
			MemWriteByte(m_regHL, m_regC);
			break;

		case 0x72: // ld_xhl_d
			cCycles -= 7;
			MemWriteByte(m_regHL, m_regD);
			break;

		case 0x73: // ld_xhl_e
			cCycles -= 7;
			MemWriteByte(m_regHL, m_regE);
			break;

		case 0x74: // ld_xhl_h
			cCycles -= 7;
			MemWriteByte(m_regHL, m_regH);
			break;

		case 0x75: // ld_xhl_l
			cCycles -= 7;
			MemWriteByte(m_regHL, m_regL);
			break;

		case 0x76: // halt
			cCycles -= 4;
			m_fHalt = 1;
		
		case 0x77: // ld_xhl_a
			cCycles -= 7;
			MemWriteByte(m_regHL, m_regA);
			break;

		case 0x78: // ld_a_b
			cCycles -= 4;
			m_regA = m_regB;
			break;

		case 0x79: // ld_a_c
			cCycles -= 4;
			m_regA = m_regC;
			break;

		case 0x7A: // ld_a_d
			cCycles -= 4;
			m_regA = m_regD;
			break;

		case 0x7B: // ld_a_e
			cCycles -= 4;
			m_regA = m_regE;
			break;

		case 0x7C: // ld_a_h
			cCycles -= 4;
			m_regA = m_regH;
			break;

		case 0x7D: // ld_a_l
			cCycles -= 4;
			m_regA = m_regL;
			break;

		case 0x7E: // ld_a_xhl
			cCycles -= 7;
			m_regA = MemReadByte(m_regHL);
			break;

		case 0x7F: // ld_a_a
			cCycles -= 4;
			m_regA = m_regA;
			break;

		case 0x80: // add_a_b
			cCycles -= 4;
			Add_1(m_regB);
			break;

		case 0x81: // add_a_c
			cCycles -= 4;
			Add_1(m_regC);
			break;

		case 0x82: // add_a_d
			cCycles -= 4;
			Add_1(m_regD);
			break;

		case 0x83: // add_a_e
			cCycles -= 4;
			Add_1(m_regE);
			break;

		case 0x84: // add_a_h
			cCycles -= 4;
			Add_1(m_regH);
			break;

		case 0x85: // add_a_l
			cCycles -= 4;
			Add_1(m_regL);
			break;

		case 0x86: // add_a_xhl
			cCycles -= 7;
			Add_1(MemReadByte(m_regHL));
			break;

		case 0x87: // add_a_a
			cCycles -= 4;
			Add_1(m_regA);
			break;

		case 0x88: // adc_a_b
			cCycles -= 4;
			Adc_1(m_regB);
			break;

		case 0x89: // adc_a_c
			cCycles -= 4;
			Adc_1(m_regC);
			break;

		case 0x8A: // adc_a_d
			cCycles -= 4;
			Adc_1(m_regD);
			break;

		case 0x8B: // adc_a_e
			cCycles -= 4;
			Adc_1(m_regE);
			break;

		case 0x8C: // adc_a_h
			cCycles -= 4;
			Adc_1(m_regH);
			break;

		case 0x8D: // adc_a_l
			cCycles -= 4;
			Adc_1(m_regL);
			break;

		case 0x8E: // adc_a_xhl
			cCycles -= 7;
			Adc_1(MemReadByte(m_regHL));
			break;

		case 0x8F: // adc_a_a
			cCycles -= 4;
			Adc_1(m_regA);
			break;

		case 0x90: // sub_b
			cCycles -= 4;
			Sub_1(m_regB);
			break;

		case 0x91: // sub_c
			cCycles -= 4;
			Sub_1(m_regC);
			break;

		case 0x92: // sub_d
			cCycles -= 4;
			Sub_1(m_regD);
			break;

		case 0x93: // sub_e
			cCycles -= 4;
			Sub_1(m_regE);
			break;

		case 0x94: // sub_h
			cCycles -= 4;
			Sub_1(m_regH);
			break;

		case 0x95: // sub_l
			cCycles -= 4;
			Sub_1(m_regL);
			break;

		case 0x96: // sub_xhl
			cCycles -= 7;
			Sub_1(MemReadByte(m_regHL));
			break;

		case 0x97: // sub_a
			cCycles -= 4;
			Sub_1(m_regA);
			break;

		case 0x98: // sbc_a_b
			cCycles -= 4;
			Sbc_1(m_regB);
			break;

		case 0x99: // sbc_a_c
			cCycles -= 4;
			Sbc_1(m_regC);
			break;

		case 0x9A: // sbc_a_d
			cCycles -= 4;
			Sbc_1(m_regD);
			break;

		case 0x9B: // sbc_a_e
			cCycles -= 4;
			Sbc_1(m_regE);
			break;

		case 0x9C: // sbc_a_h
			cCycles -= 4;
			Sbc_1(m_regH);
			break;

		case 0x9D: // sbc_a_l
			cCycles -= 4;
			Sbc_1(m_regL);
			break;

		case 0x9E: // sbc_a_xhl
			cCycles -= 7;
			Sbc_1(MemReadByte(m_regHL));
			break;

		case 0x9F: // sbc_a_a
			cCycles -= 4;
			Sbc_1(m_regA);
			break;

		case 0xA0: // and_b
			cCycles -= 4;
			And(m_regB);
			break;

		case 0xA1: // and_c
			cCycles -= 4;
			And(m_regC);
			break;

		case 0xA2: // and_d
			cCycles -= 4;
			And(m_regD);
			break;

		case 0xA3: // and_e
			cCycles -= 4;
			And(m_regE);
			break;

		case 0xA4: // and_h
			cCycles -= 4;
			And(m_regH);
			break;

		case 0xA5: // and_l
			cCycles -= 4;
			And(m_regL);
			break;

		case 0xA6: // and_xhl
			cCycles -= 7;
			And(MemReadByte(m_regHL));
			break;

		case 0xA7: // and_a
			cCycles -= 4;
			And(m_regA);
			break;

		case 0xA8: // xor_b
			cCycles -= 4;
			Xor(m_regB);
			break;

		case 0xA9: // xor_c
			cCycles -= 4;
			Xor(m_regC);
			break;

		case 0xAA: // xor_d
			cCycles -= 4;
			Xor(m_regD);
			break;

		case 0xAB: // xor_e
			cCycles -= 4;
			Xor(m_regE);
			break;

		case 0xAC: // xor_h
			cCycles -= 4;
			Xor(m_regH);
			break;

		case 0xAD: // xor_l
			cCycles -= 4;
			Xor(m_regL);
			break;

		case 0xAE: // xor_xhl
			cCycles -= 7;
			Xor(MemReadByte(m_regHL));
			break;

		case 0xAF: // xor_a
			cCycles -= 4;
			Xor(m_regA);
			break;

		case 0xB0: // or_b
			cCycles -= 4;
			Or(m_regB);
			break;

		case 0xB1: // or_c
			cCycles -= 4;
			Or(m_regC);
			break;

		case 0xB2: // or_d
			cCycles -= 4;
			Or(m_regD);
			break;

		case 0xB3: // or_e
			cCycles -= 4;
			Or(m_regE);
			break;

		case 0xB4: // or_h
			cCycles -= 4;
			Or(m_regH);
			break;

		case 0xB5: // or_l
			cCycles -= 4;
			Or(m_regL);
			break;

		case 0xB6: // or_xhl
			cCycles -= 7;
			Or(MemReadByte(m_regHL));
			break;

		case 0xB7: // or_a
			cCycles -= 4;
			Or(m_regA);
			break;

		case 0xB8: // cp_b
			cCycles -= 4;
			Cp(m_regB);
			break;

		case 0xB9: // cp_c
			cCycles -= 4;
			Cp(m_regC);
			break;

		case 0xBA: // cp_d
			cCycles -= 4;
			Cp(m_regD);
			break;

		case 0xBB: // cp_e
			cCycles -= 4;
			Cp(m_regE);
			break;

		case 0xBC: // cp_h
			cCycles -= 4;
			Cp(m_regH);
			break;

		case 0xBD: // cp_l
			cCycles -= 4;
			Cp(m_regL);
			break;

		case 0xBE: // cp_xhl
			cCycles -= 7;
			Cp(MemReadByte(m_regHL));
			break;

		case 0xBF: // cp_a
			cCycles -= 4;
			Cp(m_regA);
			break;

		case 0xC0: // ret_nz
			cCycles -= 5;
			cCycles -= Ret1(m_regF & Z_FLAG);
			break;

		case 0xC1: // pop_bc
			cCycles -= 10;
			m_regBC = Pop();
			break;

		case 0xC2: // jp_nz
			cCycles -= 10;
			cCycles -= Jp1(m_regF & Z_FLAG);
			break;

		case 0xC3: // jp
			cCycles -= 10;
			Jp0(1);
			break;

		case 0xC4: // call_nz
			cCycles -= 10;
			cCycles -= Call1(m_regF & Z_FLAG);
			break;

		case 0xC5: // push_bc
			cCycles -= 11;
			Push(m_regBC);
			break;

		case 0xC6: // add_a_byte
			cCycles -= 7;
			Add_1(ImmedByte());
			break;

		case 0xC7: // rst_00
			cCycles -= 11;
			Rst(0x00);
			break;

		case 0xC8: // ret_z
			cCycles -= 5;
			cCycles -= Ret0(m_regF & Z_FLAG);
			break;

		case 0xC9: // ret
			cCycles -= 4;
			cCycles -= Ret0(1);
			break;

		case 0xCA: // jp_z
			cCycles -= 10;
			cCycles -= Jp0(m_regF & Z_FLAG);
			break;

		case 0xCB: // cb
			cCycles -= HandleCB();
			break;

		case 0xCC: // call_z
			cCycles -= 10;
			cCycles -= Call0(m_regF & Z_FLAG);
			break;

		case 0xCD: // call
			cCycles -= 10;
			cCycles -= Call0(1);
			break;

		case 0xCE: // adc_a_byte
			cCycles -= 7;
			Adc_1(ImmedByte());
			break;

		case 0xCF: // rst_08
			cCycles -= 11;
			Rst(0x08);
			break;

		case 0xD0: // ret_nc
			cCycles -= 5;
			cCycles -= Ret1(m_regF & C_FLAG);
			break;

		case 0xD1: // pop_de
			cCycles -= 10;
			m_regDE = Pop();
			break;

		case 0xD2: // jp_nc
			cCycles -= 10;
			cCycles -= Jp1(m_regF & C_FLAG);
			break;

		case 0xD3: // out_byte_a
			cCycles -= 11;
			Out(ImmedByte(), m_regA);
			break;

		case 0xD4: // call_nc
			cCycles -= 10;
			cCycles -= Call1(m_regF & C_FLAG);
			break;

		case 0xD5: // push_de
			cCycles -= 11;
			Push(m_regDE);
			break;

		case 0xD6: // sub_byte
			cCycles -= 7;
			Sub_1(ImmedByte());
			break;

		case 0xD7: // rst_10
			cCycles -= 11;
			Rst(0x10);
			break;

		case 0xD8: // ret_c
			cCycles -= 5;
			cCycles -= Ret0(m_regF & C_FLAG);
			break;

		case 0xD9: // exx
			cCycles -= 4;
			Exx();
			break;

		case 0xDA: // jp_c
			cCycles -= 10;
			cCycles -= Jp0(m_regF & C_FLAG);
			break;

		case 0xDB: // in_a_byte
		{
			uint8_t bPort = ImmedByte();
			cCycles -= 11;
			m_regA = InRaw(bPort);
			break;
		}

		case 0xDC: // call_c
			cCycles -= 10;
			cCycles -= Call0(m_regF & C_FLAG);
			break;

		case 0xDD: // dd
			cCycles -= HandleDD();
			break;

		case 0xDE: // sbc_a_byte
			cCycles -= 7;
			Sbc_1(ImmedByte());
			break;

		case 0xDF: // rst_18
			cCycles -= 11;
			Rst(0x18);
			break;

		case 0xE0: // ret_po
			cCycles -= 5;
			cCycles -= Ret1(m_regF & V_FLAG);
			break;

		case 0xE1: // pop_hl
			cCycles -= 10;
			m_regHL = Pop();
			break;

		case 0xE2: // jp_po
			cCycles -= 10;
			cCycles -= Jp1(m_regF & V_FLAG);
			break;

		case 0xE3: // ex_xsp_hl
			cCycles -= 19;
			{
				int i = MemReadWord(GetSP());
				MemWriteWord(GetSP(), m_regHL);
				m_regHL = i;
				break;
			}

		case 0xE4: // call_po
			cCycles -= 10;
			cCycles -= Call1(m_regF & V_FLAG);
			break;

		case 0xE5: // push_hl
			cCycles -= 11;
			Push(m_regHL);
			break;

		case 0xE6: // and_byte
			cCycles -= 7;
			And(ImmedByte());
			break;

		case 0xE7: // rst_20
			cCycles -= 11;
			Rst(0x20);
			break;

		case 0xE8: // ret_pe
			cCycles -= 5;
			cCycles -= Ret0(m_regF & V_FLAG);
			break;

		case 0xE9: // jp_hl
			cCycles -= 4;
			SetPC(m_regHL);
			break;

		case 0xEA: // jp_pe
			cCycles -= 10;
			cCycles -= Jp0(m_regF & V_FLAG);
			break;

		case 0xEB: // ex_de_hl
			cCycles -= 4;
			swap(m_regDE, m_regHL);
			break;

		case 0xEC: // call_pe
			cCycles -= 10;
			cCycles -= Call0(m_regF & V_FLAG);
			break;

		case 0xED: // ed
			HandleED();
			break;

		case 0xEE: // xor_byte
			cCycles -= 7;
			Xor(ImmedByte());
			break;

		case 0xEF: // rst_28
			cCycles -= 11;
			Rst(0x28);
			break;

		case 0xF0: // ret_p
			cCycles -= 5;
			cCycles -= Ret1(m_regF & S_FLAG);
			break;

		case 0xF1: // pop_af
			cCycles -= 10;
			m_regAF = Pop();
			break;

		case 0xF2: // jp_p
			cCycles -= 10;
			cCycles -= Jp1(m_regF & S_FLAG);
			break;

		case 0xF3: // di
			cCycles -= 4;
			Di();
			break;

		case 0xF4: // call_p
			cCycles -= 10;
			cCycles -= Call1(m_regF & S_FLAG);
			break;

		case 0xF5: // push_af
			cCycles -= 11;
			Push(m_regAF);
			break;

		case 0xF6: // or_byte
			cCycles -= 7;
			Or(ImmedByte());
			break;

		case 0xF7: // rst_30
			cCycles -= 11;
			Rst(0x30);
			break;

		case 0xF8: // ret_m
			cCycles -= 5;
			cCycles -= Ret0(m_regF & S_FLAG);
			break;

		case 0xF9: // ld_sp_hl
			cCycles -= 6;
			SetSP(m_regHL);
			break;

		case 0xFA: // jp_m
			cCycles -= 10;
			cCycles -= Jp0(m_regF & S_FLAG);
			break;

		case 0xFB: // ei
			cCycles -= 4;
			cCycles -= Ei();
			break;

		case 0xFC: // call_m
			cCycles -= 10;
			cCycles -= Call0(m_regF & S_FLAG);
			break;

		case 0xFD: // fd
			cCycles -= HandleFD();
			break;

		case 0xFE: // cp_byte
			cCycles -= 7;
			Cp(ImmedByte());
			break;

		case 0xFF: // rst_38
			cCycles -= 11;
			Rst(0x38);
			break;

		default:
			assert(false);
			break;
		}

		if (pending_int && !m_fHalt)
		{
			mz80int(irq_vector);
		}
		}
		dwElapsedTicks += (prev_cycles - cCycles);
		
	}

	z80pc = GetPC(); /* for some of the platforms */
	//dwElapsedTicks = origElapsedTicks + (cCyclesArg - cCycles);

	//return (dwElapsedTicks);//0x80000000);
	return (0x80000000);
}

int cpu_z80::Ei()
{
	/* fprintf ( stderr, ""Enable Interrupt\n"" ); */
	m_iff2 = 1;

	if (m_iff1 != 0)
		return 0;

	m_iff1 = 1;

	return(0);
}

void cpu_z80::Di()
{
	/* fprintf ( stderr, ""Disable Interrupt\n"" ); */
	m_iff1 = 0;
	m_iff2 = 0;
}

UINT32 cpu_z80::mz80int(UINT32 bVal)
{
	irq_vector = bVal;
	
	// Note: When I enable this, everything breaks. 
	// ""When an EI instruction is executed, any pending interrupt request
	// is not accepted until after the instruction following EI is executed.""
   /*
	   if (iff_delay > 0) {
		   iff_delay -= 1;
		   if (iff_delay == 0) { //Ei(); instead?
			   m_iff1 = 1;
			   m_iff2 = 1;
		   }
		   return 0;
	   }
   */
		
	if (m_iff1)
	{
		m_iff1 = 0;
		m_fHalt = false;

		switch (m_nIM)
		{
		case 0:
			cCycles -= 11;
			// Subtract C7 from the Opcode to get the memory vector. 
			// Or fancy shifting as seen below, the fancy way.
			//Rst(irq_vector - 0xC7);
			Rst(((irq_vector >> 3) & 7) << 3);
			//wrlog(""Interrupt Mode 0 Taken"");
			pending_int = 0;
			break;

		case 1:
			cCycles -= 13;
			Rst(z80intAddr);
			//wrlog(""Interrupt Mode 1 Taken"");
			pending_int = 0;
			break;

		case 2:
			cCycles -= 19;
			pending_int = 0;
			//wrlog(""Interrupt Mode 2 Taken"");
			Push(GetPC());
			SetPC(MemReadWord(irq_vector | (m_regI << 8)));
			break;

		default:
			wrlog(""unsupported interrupt mode % d\n"", m_nIM);
			break;
		}
	}
	else
	{
		pending_int = 1;        // Set Interrupt Pending.
		return 0xffffffff;		// Interrupt not taken!
	}
	return(0);
}

UINT32 cpu_z80::mz80nmi()
{
	m_iff1 = 0;
	m_fHalt = false;
    cCycles -= 11;
	Rst(z80nmiAddr);
	return(0);
}

void cpu_z80::mz80ClearPendingInterrupt()
{
	pending_int = 0;
}

/* ***************************************************************************
 * Flow of Control
 * ***************************************************************************
 */

int cpu_z80::Jr0(int f) {
	if (f)
	{
		AdjustPC((signed char)ImmedByte());
		return 5;
	}
	else
	{
		AdjustPC(1);
		return 0;
	}
}

int cpu_z80::Jr1(int f)
{
	if (f)
	{
		AdjustPC(1);
		return 0;
	}
	else
	{
		AdjustPC((signed char)ImmedByte());
		return 5;
	}
}

int cpu_z80::Call0(int f)
{
	//char string[150];

	if (f)
	{
		uint16_t wAddr = ImmedWord();
		Push(GetPC());
		SetPC(wAddr);
		return 7;
	}
	else
	{
		AdjustPC(2);
		return 0;
	}
}

int cpu_z80::Call1(int f)
{
	if (f)
	{
		AdjustPC(2);
		return 0;
	}
	else
	{
		uint16_t wAddr = ImmedWord();
		Push(GetPC());
		SetPC(wAddr);
		return 7;
	}
}

int cpu_z80::Jp0(int f)
{
	if (f)
	{
		SetPC(ImmedWord());
		return 0; // ????????????????
	}
	else
	{
		AdjustPC(2);
		return 0;
	}
}

int cpu_z80::Jp1(int f)
{
	if (f)
	{
		AdjustPC(2);
		return 0;
	}
	else
	{
		SetPC(ImmedWord());
		return 0; // ????????????????
	}
}

void cpu_z80::Rst(uint16_t wAddr)
{
	Push(GetPC());
	SetPC(wAddr);
}

/* ***************************************************************************
 * CB prefixed instructions
 * ***************************************************************************
 */

int cpu_z80::HandleCB() {
	const uint8_t bOpcode = ImmedByte();
	m_regR++;

	switch (bOpcode)
	{
	case 0x00: // rlc_b
		m_regB = Rlc(m_regB);
		return 8;

	case 0x01: // rlc_c
		m_regC = Rlc(m_regC);
		return 8;

	case 0x02: // rlc_d
		m_regD = Rlc(m_regD);
		return 8;

	case 0x03: // rlc_e
		m_regE = Rlc(m_regE);
		return 8;

	case 0x04: // rlc_h
		m_regH = Rlc(m_regH);
		return 8;

	case 0x05: // rlc_l
		m_regL = Rlc(m_regL);
		return 8;

	case 0x06: // rlc_xhl
		MemWriteByte(m_regHL, Rlc(MemReadByte(m_regHL)));
		return 15;

	case 0x07: // rlc_a
		m_regA = Rlc(m_regA);
		return 8;

	case 0x08: // rrc_b
		m_regB = Rrc(m_regB);
		return 8;

	case 0x09: // rrc_c
		m_regC = Rrc(m_regC);
		return 8;

	case 0x0A: // rrc_d
		m_regD = Rrc(m_regD);
		return 8;

	case 0x0B: // rrc_e
		m_regE = Rrc(m_regE);
		return 8;

	case 0x0C: // rrc_h
		m_regH = Rrc(m_regH);
		return 8;

	case 0x0D: // rrc_l
		m_regL = Rrc(m_regL);
		return 8;

	case 0x0E: // rrc_xhl
		MemWriteByte(m_regHL, Rrc(MemReadByte(m_regHL)));
		return 15;

	case 0x0F: // rrc_a
		m_regA = Rrc(m_regA);
		return 8;

	case 0x10: // rl_b
		m_regB = Rl(m_regB);
		return 8;

	case 0x11: // rl_c
		m_regC = Rl(m_regC);
		return 8;

	case 0x12: // rl_d
		m_regD = Rl(m_regD);
		return 8;

	case 0x13: // rl_e
		m_regE = Rl(m_regE);
		return 8;

	case 0x14: // rl_h
		m_regH = Rl(m_regH);
		return 8;

	case 0x15: // rl_l
		m_regL = Rl(m_regL);
		return 8;

	case 0x16: // rl_xhl
		MemWriteByte(m_regHL, Rl(MemReadByte(m_regHL)));
		return 15;

	case 0x17: // rl_a
		m_regA = Rl(m_regA);
		return 8;

	case 0x18: // rr_b
		m_regB = Rr(m_regB);
		return 8;

	case 0x19: // rr_c
		m_regC = Rr(m_regC);
		return 8;

	case 0x1A: // rr_d
		m_regD = Rr(m_regD);
		return 8;

	case 0x1B: // rr_e
		m_regE = Rr(m_regE);
		return 8;

	case 0x1C: // rr_h
		m_regH = Rr(m_regH);
		return 8;

	case 0x1D: // rr_l
		m_regL = Rr(m_regL);
		return 8;

	case 0x1E: // rr_xhl
		MemWriteByte(m_regHL, Rr(MemReadByte(m_regHL)));
		return 15;

	case 0x1F: // rr_a
		m_regA = Rr(m_regA);
		return 8;

	case 0x20: // sla_b
		m_regB = Sla(m_regB);
		return 8;

	case 0x21: // sla_c
		m_regC = Sla(m_regC);
		return 8;

	case 0x22: // sla_d
		m_regD = Sla(m_regD);
		return 8;

	case 0x23: // sla_e
		m_regE = Sla(m_regE);
		return 8;

	case 0x24: // sla_h
		m_regH = Sla(m_regH);
		return 8;

	case 0x25: // sla_l
		m_regL = Sla(m_regL);
		return 8;

	case 0x26: // sla_xhl
		MemWriteByte(m_regHL, Sla(MemReadByte(m_regHL)));
		return 15;

	case 0x27: // sla_a
		m_regA = Sla(m_regA);
		return 8;

	case 0x28: // sra_b
		m_regB = Sra(m_regB);
		return 8;

	case 0x29: // sra_c
		m_regC = Sra(m_regC);
		return 8;

	case 0x2A: // sra_d
		m_regD = Sra(m_regD);
		return 8;

	case 0x2B: // sra_e
		m_regE = Sra(m_regE);
		return 8;

	case 0x2C: // sra_h
		m_regH = Sra(m_regH);
		return 8;

	case 0x2D: // sra_l
		m_regL = Sra(m_regL);
		return 8;

	case 0x2E: // sra_xhl
		MemWriteByte(m_regHL, Sra(MemReadByte(m_regHL)));
		return 15;

	case 0x2F: // sra_a
		m_regA = Sra(m_regA);
		return 8;

	case 0x30: // sll_b
		m_regB = Sll(m_regB);
		return 8;

	case 0x31: // sll_c
		m_regC = Sll(m_regC);
		return 8;

	case 0x32: // sll_d
		m_regD = Sll(m_regD);
		return 8;

	case 0x33: // sll_e
		m_regE = Sll(m_regE);
		return 8;

	case 0x34: // sll_h
		m_regH = Sll(m_regH);
		return 8;

	case 0x35: // sll_l
		m_regL = Sll(m_regL);
		return 8;

	case 0x36: // sll_xhl
		MemWriteByte(m_regHL, Sll(MemReadByte(m_regHL)));
		return 15;

	case 0x37: // sll_a
		m_regA = Sll(m_regA);
		return 8;

	case 0x38: // srl_b
		m_regB = Srl(m_regB);
		return 8;

	case 0x39: // srl_c
		m_regC = Srl(m_regC);
		return 8;

	case 0x3A: // srl_d
		m_regD = Srl(m_regD);
		return 8;

	case 0x3B: // srl_e
		m_regE = Srl(m_regE);
		return 8;

	case 0x3C: // srl_h
		m_regH = Srl(m_regH);
		return 8;

	case 0x3D: // srl_l
		m_regL = Srl(m_regL);
		return 8;

	case 0x3E: // srl_xhl
		MemWriteByte(m_regHL, Srl(MemReadByte(m_regHL)));
		return 15;

	case 0x3F: // srl_a
		m_regA = Srl(m_regA);
		return 8;

	case 0x40: // bit_0_b
		Bit(m_regB, 0);
		return 8;

	case 0x41: // bit_0_c
		Bit(m_regC, 0);
		return 8;

	case 0x42: // bit_0_d
		Bit(m_regD, 0);
		return 8;

	case 0x43: // bit_0_e
		Bit(m_regE, 0);
		return 8;

	case 0x44: // bit_0_h
		Bit(m_regH, 0);
		return 8;

	case 0x45: // bit_0_l
		Bit(m_regL, 0);
		return 8;

	case 0x46: // bit_0_xhl
		Bit(MemReadByte(m_regHL), 0);
		return 12;

	case 0x47: // bit_0_a
		Bit(m_regA, 0);
		return 8;

	case 0x48: // bit_1_b
		Bit(m_regB, 1);
		return 8;

	case 0x49: // bit_1_c
		Bit(m_regC, 1);
		return 8;

	case 0x4A: // bit_1_d
		Bit(m_regD, 1);
		return 8;

	case 0x4B: // bit_1_e
		Bit(m_regE, 1);
		return 8;

	case 0x4C: // bit_1_h
		Bit(m_regH, 1);
		return 8;

	case 0x4D: // bit_1_l
		Bit(m_regL, 1);
		return 8;

	case 0x4E: // bit_1_xhl
		Bit(MemReadByte(m_regHL), 1);
		return 12;

	case 0x4F: // bit_1_a
		Bit(m_regA, 1);
		return 8;

	case 0x50: // bit_2_b
		Bit(m_regB, 2);
		return 8;

	case 0x51: // bit_2_c
		Bit(m_regC, 2);
		return 8;

	case 0x52: // bit_2_d
		Bit(m_regD, 2);
		return 8;

	case 0x53: // bit_2_e
		Bit(m_regE, 2);
		return 8;

	case 0x54: // bit_2_h
		Bit(m_regH, 2);
		return 8;

	case 0x55: // bit_2_l
		Bit(m_regL, 2);
		return 8;

	case 0x56: // bit_2_xhl
		Bit(MemReadByte(m_regHL), 2);
		return 12;

	case 0x57: // bit_2_a
		Bit(m_regA, 2);
		return 8;

	case 0x58: // bit_3_b
		Bit(m_regB, 3);
		return 8;

	case 0x59: // bit_3_c
		Bit(m_regC, 3);
		return 8;

	case 0x5A: // bit_3_d
		Bit(m_regD, 3);
		return 8;

	case 0x5B: // bit_3_e
		Bit(m_regE, 3);
		return 8;

	case 0x5C: // bit_3_h
		Bit(m_regH, 3);
		return 8;

	case 0x5D: // bit_3_l
		Bit(m_regL, 3);
		return 8;

	case 0x5E: // bit_3_xhl
		Bit(MemReadByte(m_regHL), 3);
		return 12;

	case 0x5F: // bit_3_a
		Bit(m_regA, 3);
		return 8;

	case 0x60: // bit_4_b
		Bit(m_regB, 4);
		return 8;

	case 0x61: // bit_4_c
		Bit(m_regC, 4);
		return 8;

	case 0x62: // bit_4_d
		Bit(m_regD, 4);
		return 8;

	case 0x63: // bit_4_e
		Bit(m_regE, 4);
		return 8;

	case 0x64: // bit_4_h
		Bit(m_regH, 4);
		return 8;

	case 0x65: // bit_4_l
		Bit(m_regL, 4);
		return 8;

	case 0x66: // bit_4_xhl
		Bit(MemReadByte(m_regHL), 4);
		return 12;

	case 0x67: // bit_4_a
		Bit(m_regA, 4);
		return 8;

	case 0x68: // bit_5_b
		Bit(m_regB, 5);
		return 8;

	case 0x69: // bit_5_c
		Bit(m_regC, 5);
		return 8;

	case 0x6A: // bit_5_d
		Bit(m_regD, 5);
		return 8;

	case 0x6B: // bit_5_e
		Bit(m_regE, 5);
		return 8;

	case 0x6C: // bit_5_h
		Bit(m_regH, 5);
		return 8;

	case 0x6D: // bit_5_l
		Bit(m_regL, 5);
		return 8;

	case 0x6E: // bit_5_xhl
		Bit(MemReadByte(m_regHL), 5);
		return 12;

	case 0x6F: // bit_5_a
		Bit(m_regA, 5);
		return 8;

	case 0x70: // bit_6_b
		Bit(m_regB, 6);
		return 8;

	case 0x71: // bit_6_c
		Bit(m_regC, 6);
		return 8;

	case 0x72: // bit_6_d
		Bit(m_regD, 6);
		return 8;

	case 0x73: // bit_6_e
		Bit(m_regE, 6);
		return 8;

	case 0x74: // bit_6_h
		Bit(m_regH, 6);
		return 8;

	case 0x75: // bit_6_l
		Bit(m_regL, 6);
		return 8;

	case 0x76: // bit_6_xhl
		Bit(MemReadByte(m_regHL), 6);
		return 12;

	case 0x77: // bit_6_a
		Bit(m_regA, 6);
		return 8;

	case 0x78: // bit_7_b
		Bit(m_regB, 7);
		return 8;

	case 0x79: // bit_7_c
		Bit(m_regC, 7);
		return 8;

	case 0x7A: // bit_7_d
		Bit(m_regD, 7);
		return 8;

	case 0x7B: // bit_7_e
		Bit(m_regE, 7);
		return 8;

	case 0x7C: // bit_7_h
		Bit(m_regH, 7);
		return 8;

	case 0x7D: // bit_7_l
		Bit(m_regL, 7);
		return 8;

	case 0x7E: // bit_7_xhl
		Bit(MemReadByte(m_regHL), 7);
		return 12;

	case 0x7F: // bit_7_a
		Bit(m_regA, 7);
		return 8;

	case 0x80: // res_0_b
		m_regB = Res(m_regB, 0);
		return 8;

	case 0x81: // res_0_c
		m_regC = Res(m_regC, 0);
		return 8;

	case 0x82: // res_0_d
		m_regD = Res(m_regD, 0);
		return 8;

	case 0x83: // res_0_e
		m_regE = Res(m_regE, 0);
		return 8;

	case 0x84: // res_0_h
		m_regH = Res(m_regH, 0);
		return 8;

	case 0x85: // res_0_l
		m_regL = Res(m_regL, 0);
		return 8;

	case 0x86: // res_0_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 0));
		return 15;

	case 0x87: // res_0_a
		m_regA = Res(m_regA, 0);
		return 8;

	case 0x88: // res_1_b
		m_regB = Res(m_regB, 1);
		return 8;

	case 0x89: // res_1_c
		m_regC = Res(m_regC, 1);
		return 8;

	case 0x8A: // res_1_d
		m_regD = Res(m_regD, 1);
		return 8;

	case 0x8B: // res_1_e
		m_regE = Res(m_regE, 1);
		return 8;

	case 0x8C: // res_1_h
		m_regH = Res(m_regH, 1);
		return 8;

	case 0x8D: // res_1_l
		m_regL = Res(m_regL, 1);
		return 8;

	case 0x8E: // res_1_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 1));
		return 15;

	case 0x8F: // res_1_a
		m_regA = Res(m_regA, 1);
		return 8;

	case 0x90: // res_2_b
		m_regB = Res(m_regB, 2);
		return 8;

	case 0x91: // res_2_c
		m_regC = Res(m_regC, 2);
		return 8;

	case 0x92: // res_2_d
		m_regD = Res(m_regD, 2);
		return 8;

	case 0x93: // res_2_e
		m_regE = Res(m_regE, 2);
		return 8;

	case 0x94: // res_2_h
		m_regH = Res(m_regH, 2);
		return 8;

	case 0x95: // res_2_l
		m_regL = Res(m_regL, 2);
		return 8;

	case 0x96: // res_2_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 2));
		return 15;

	case 0x97: // res_2_a
		m_regA = Res(m_regA, 2);
		return 8;

	case 0x98: // res_3_b
		m_regB = Res(m_regB, 3);
		return 8;

	case 0x99: // res_3_c
		m_regC = Res(m_regC, 3);
		return 8;

	case 0x9A: // res_3_d
		m_regD = Res(m_regD, 3);
		return 8;

	case 0x9B: // res_3_e
		m_regE = Res(m_regE, 3);
		return 8;

	case 0x9C: // res_3_h
		m_regH = Res(m_regH, 3);
		return 8;

	case 0x9D: // res_3_l
		m_regL = Res(m_regL, 3);
		return 8;

	case 0x9E: // res_3_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 3));
		return 15;

	case 0x9F: // res_3_a
		m_regA = Res(m_regA, 3);
		return 8;

	case 0xA0: // res_4_b
		m_regB = Res(m_regB, 4);
		return 8;

	case 0xA1: // res_4_c
		m_regC = Res(m_regC, 4);
		return 8;

	case 0xA2: // res_4_d
		m_regD = Res(m_regD, 4);
		return 8;

	case 0xA3: // res_4_e
		m_regE = Res(m_regE, 4);
		return 8;

	case 0xA4: // res_4_h
		m_regH = Res(m_regH, 4);
		return 8;

	case 0xA5: // res_4_l
		m_regL = Res(m_regL, 4);
		return 8;

	case 0xA6: // res_4_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 4));
		return 15;

	case 0xA7: // res_4_a
		m_regA = Res(m_regA, 4);
		return 8;

	case 0xA8: // res_5_b
		m_regB = Res(m_regB, 5);
		return 8;

	case 0xA9: // res_5_c
		m_regC = Res(m_regC, 5);
		return 8;

	case 0xAA: // res_5_d
		m_regD = Res(m_regD, 5);
		return 8;

	case 0xAB: // res_5_e
		m_regE = Res(m_regE, 5);
		return 8;

	case 0xAC: // res_5_h
		m_regH = Res(m_regH, 5);
		return 8;

	case 0xAD: // res_5_l
		m_regL = Res(m_regL, 5);
		return 8;

	case 0xAE: // res_5_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 5));
		return 15;

	case 0xAF: // res_5_a
		m_regA = Res(m_regA, 5);
		return 8;

	case 0xB0: // res_6_b
		m_regB = Res(m_regB, 6);
		return 8;

	case 0xB1: // res_6_c
		m_regC = Res(m_regC, 6);
		return 8;

	case 0xB2: // res_6_d
		m_regD = Res(m_regD, 6);
		return 8;

	case 0xB3: // res_6_e
		m_regE = Res(m_regE, 6);
		return 8;

	case 0xB4: // res_6_h
		m_regH = Res(m_regH, 6);
		return 8;

	case 0xB5: // res_6_l
		m_regL = Res(m_regL, 6);
		return 8;

	case 0xB6: // res_6_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 6));
		return 15;

	case 0xB7: // res_6_a
		m_regA = Res(m_regA, 6);
		return 8;

	case 0xB8: // res_7_b
		m_regB = Res(m_regB, 7);
		return 8;

	case 0xB9: // res_7_c
		m_regC = Res(m_regC, 7);
		return 8;

	case 0xBA: // res_7_d
		m_regD = Res(m_regD, 7);
		return 8;

	case 0xBB: // res_7_e
		m_regE = Res(m_regE, 7);
		return 8;

	case 0xBC: // res_7_h
		m_regH = Res(m_regH, 7);
		return 8;

	case 0xBD: // res_7_l
		m_regL = Res(m_regL, 7);
		return 8;

	case 0xBE: // res_7_xhl
		MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 7));
		return 15;

	case 0xBF: // res_7_a
		m_regA = Res(m_regA, 7);
		return 8;

	case 0xC0: // set_0_b
		m_regB = Set(m_regB, 0);
		return 8;

	case 0xC1: // set_0_c
		m_regC = Set(m_regC, 0);
		return 8;

	case 0xC2: // set_0_d
		m_regD = Set(m_regD, 0);
		return 8;

	case 0xC3: // set_0_e
		m_regE = Set(m_regE, 0);
		return 8;

	case 0xC4: // set_0_h
		m_regH = Set(m_regH, 0);
		return 8;

	case 0xC5: // set_0_l
		m_regL = Set(m_regL, 0);
		return 8;

	case 0xC6: // set_0_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 0));
		return 15;

	case 0xC7: // set_0_a
		m_regA = Set(m_regA, 0);
		return 8;

	case 0xC8: // set_1_b
		m_regB = Set(m_regB, 1);
		return 8;

	case 0xC9: // set_1_c
		m_regC = Set(m_regC, 1);
		return 8;

	case 0xCA: // set_1_d
		m_regD = Set(m_regD, 1);
		return 8;

	case 0xCB: // set_1_e
		m_regE = Set(m_regE, 1);
		return 8;

	case 0xCC: // set_1_h
		m_regH = Set(m_regH, 1);
		return 8;

	case 0xCD: // set_1_l
		m_regL = Set(m_regL, 1);
		return 8;

	case 0xCE: // set_1_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 1));
		return 15;

	case 0xCF: // set_1_a
		m_regA = Set(m_regA, 1);
		return 8;

	case 0xD0: // set_2_b
		m_regB = Set(m_regB, 2);
		return 8;

	case 0xD1: // set_2_c
		m_regC = Set(m_regC, 2);
		return 8;

	case 0xD2: // set_2_d
		m_regD = Set(m_regD, 2);
		return 8;

	case 0xD3: // set_2_e
		m_regE = Set(m_regE, 2);
		return 8;

	case 0xD4: // set_2_h
		m_regH = Set(m_regH, 2);
		return 8;

	case 0xD5: // set_2_l
		m_regL = Set(m_regL, 2);
		return 8;

	case 0xD6: // set_2_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 2));
		return 15;

	case 0xD7: // set_2_a
		m_regA = Set(m_regA, 2);
		return 8;

	case 0xD8: // set_3_b
		m_regB = Set(m_regB, 3);
		return 8;

	case 0xD9: // set_3_c
		m_regC = Set(m_regC, 3);
		return 8;

	case 0xDA: // set_3_d
		m_regD = Set(m_regD, 3);
		return 8;

	case 0xDB: // set_3_e
		m_regE = Set(m_regE, 3);
		return 8;

	case 0xDC: // set_3_h
		m_regH = Set(m_regH, 3);
		return 8;

	case 0xDD: // set_3_l
		m_regL = Set(m_regL, 3);
		return 8;

	case 0xDE: // set_3_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 3));
		return 15;

	case 0xDF: // set_3_a
		m_regA = Set(m_regA, 3);
		return 8;

	case 0xE0: // set_4_b
		m_regB = Set(m_regB, 4);
		return 8;

	case 0xE1: // set_4_c
		m_regC = Set(m_regC, 4);
		return 8;

	case 0xE2: // set_4_d
		m_regD = Set(m_regD, 4);
		return 8;

	case 0xE3: // set_4_e
		m_regE = Set(m_regE, 4);
		return 8;

	case 0xE4: // set_4_h
		m_regH = Set(m_regH, 4);
		return 8;

	case 0xE5: // set_4_l
		m_regL = Set(m_regL, 4);
		return 8;

	case 0xE6: // set_4_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 4));
		return 15;

	case 0xE7: // set_4_a
		m_regA = Set(m_regA, 4);
		return 8;

	case 0xE8: // set_5_b
		m_regB = Set(m_regB, 5);
		return 8;

	case 0xE9: // set_5_c
		m_regC = Set(m_regC, 5);
		return 8;

	case 0xEA: // set_5_d
		m_regD = Set(m_regD, 5);
		return 8;

	case 0xEB: // set_5_e
		m_regE = Set(m_regE, 5);
		return 8;

	case 0xEC: // set_5_h
		m_regH = Set(m_regH, 5);
		return 8;

	case 0xED: // set_5_l
		m_regL = Set(m_regL, 5);
		return 8;

	case 0xEE: // set_5_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 5));
		return 15;

	case 0xEF: // set_5_a
		m_regA = Set(m_regA, 5);
		return 8;

	case 0xF0: // set_6_b
		m_regB = Set(m_regB, 6);
		return 8;

	case 0xF1: // set_6_c
		m_regC = Set(m_regC, 6);
		return 8;

	case 0xF2: // set_6_d
		m_regD = Set(m_regD, 6);
		return 8;

	case 0xF3: // set_6_e
		m_regE = Set(m_regE, 6);
		return 8;

	case 0xF4: // set_6_h
		m_regH = Set(m_regH, 6);
		return 8;

	case 0xF5: // set_6_l
		m_regL = Set(m_regL, 6);
		return 8;

	case 0xF6: // set_6_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 6));
		return 15;

	case 0xF7: // set_6_a
		m_regA = Set(m_regA, 6);
		return 8;

	case 0xF8: // set_7_b
		m_regB = Set(m_regB, 7);
		return 8;

	case 0xF9: // set_7_c
		m_regC = Set(m_regC, 7);
		return 8;

	case 0xFA: // set_7_d
		m_regD = Set(m_regD, 7);
		return 8;

	case 0xFB: // set_7_e
		m_regE = Set(m_regE, 7);
		return 8;

	case 0xFC: // set_7_h
		m_regH = Set(m_regH, 7);
		return 8;

	case 0xFD: // set_7_l
		m_regL = Set(m_regL, 7);
		return 8;

	case 0xFE: // set_7_xhl
		MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 7));
		return 15;

	case 0xFF: // set_7_a
		m_regA = Set(m_regA, 7);
		return 8;

	default:
		assert(false);
		return 0;
	}
}

void cpu_z80::Exx()
{
	swap(m_regBC, m_regBC2);
	swap(m_regDE, m_regDE2);
	swap(m_regHL, m_regHL2);
}

/* ***************************************************************************
 * DD prefixed opcodes
 * ***************************************************************************
 */
uint16_t cpu_z80::IndirectIX()
{
	return m_regIX + (signed char)ImmedByte();
}

int cpu_z80::HandleDD()
{
	uint16_t wAddr;
	uint16_t wTemp;

	const uint8_t bOpcode = ImmedByte();

	m_regR++;

	switch (bOpcode)
	{
	case 0x00: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x01: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x02: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x03: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x04: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x05: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x06: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x07: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x08: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x09: // add_ix_bc
		m_regIX = Add_2(m_regIX, m_regBC);
		return 15;

	case 0x0A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0C: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0D: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0E: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x10: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x11: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x12: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x13: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x14: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x15: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x16: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x17: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x18: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x19: // add_ix_de
		m_regIX = Add_2(m_regIX, m_regDE);
		return 15;

	case 0x1A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1C: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1D: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1E: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x20: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x21: // ld_ix_word
		m_regIX = ImmedWord();
		return 14;

	case 0x22: // ld_xword_ix
		MemWriteWord(ImmedWord(), m_regIX);
		return 20;

	case 0x23: // inc_ix
		m_regIX++;
		return 10;

	case 0x24: // inc_ixh
		m_regIXh = Inc(m_regIXh);
		return 9;

	case 0x25: // dec_ixh
		m_regIXh = Dec(m_regIXh);
		return 9;

	case 0x26: // ld_ixh_byte
		m_regIXh = ImmedByte();
		return 9;

	case 0x27: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x28: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x29: // add_ix_ix
		m_regIX = Add_2(m_regIX, m_regIX);
		return 15;

	case 0x2A: // ld_ix_xword
		m_regIX = MemReadWord(ImmedWord());
		return 20;

	case 0x2B: // dec_ix
		m_regIX--;
		return 10;

	case 0x2C: // inc_ixl
		m_regIXl = Inc(m_regIXl);
		return 9;

	case 0x2D: // dec_ixl
		m_regIXl = Dec(m_regIXl);
		return 9;

	case 0x2E: // ld_ixl_byte
		m_regIXl = ImmedByte();
		return 9;

	case 0x2F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x30: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x31: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x32: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x33: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x34: // inc_xix
		wAddr = IndirectIX();
		MemWriteByte(wAddr, Inc(MemReadByte(wAddr)));
		return 23;

	case 0x35: // dec_xix
		wAddr = IndirectIX();
		MemWriteByte(wAddr, Dec(MemReadByte(wAddr)));
		return 23;

	case 0x36: // ld_xix_byte
		wAddr = IndirectIX();
		MemWriteByte(wAddr, ImmedByte());
		return 19;

	case 0x37: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x38: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x39: // add_ix_sp
		m_regIX = Add_2(m_regIX, GetSP());
		return 15;

	case 0x3A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3C: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3D: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3E: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x40: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x41: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x42: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x43: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x44: // ld_b_ixh
		m_regB = m_regIXh;
		return 9;

	case 0x45: // ld_b_ixl
		m_regB = m_regIXl;
		return 9;

	case 0x46: // ld_b_xix
		m_regB = MemReadByte(IndirectIX());
		return 19;

	case 0x47: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x48: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x49: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x4A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x4B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x4C: // ld_c_ixh
		m_regC = m_regIXh;
		return 9;

	case 0x4D: // ld_c_ixl
		m_regC = m_regIXl;
		return 9;

	case 0x4E: // ld_c_xix
		m_regC = MemReadByte(IndirectIX());
		return 19;

	case 0x4F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x50: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x51: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x52: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x53: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x54: // ld_d_ixh
		m_regD = m_regIXh;
		return 9;

	case 0x55: // ld_d_ixl
		m_regD = m_regIXl;
		return 9;

	case 0x56: // ld_d_xix
		m_regD = MemReadByte(IndirectIX());
		return 19;

	case 0x57: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x58: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x59: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x5A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x5B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x5C: // ld_e_ixh
		m_regE = m_regIXh;
		return 9;

	case 0x5D: // ld_e_ixl
		m_regE = m_regIXl;
		return 9;

	case 0x5E: // ld_e_xix
		m_regE = MemReadByte(IndirectIX());
		return 19;

	case 0x5F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x60: // ld_ixh_b
		m_regIXh = m_regB;
		return 9;

	case 0x61: // ld_ixh_c
		m_regIXh = m_regC;
		return 9;

	case 0x62: // ld_ixh_d
		m_regIXh = m_regD;
		return 9;

	case 0x63: // ld_ixh_e
		m_regIXh = m_regE;
		return 9;

	case 0x64: // ld_ixh_h
		m_regIXh = m_regH;
		return 9;

	case 0x65: // ld_ixh_l
		m_regIXh = m_regL;
		return 9;

	case 0x66: // ld_h_xix
		m_regH = MemReadByte(IndirectIX());
		return 9;

	case 0x67: // ld_ixh_a
		m_regIXh = m_regA;
		return 9;

	case 0x68: // ld_ixl_b
		m_regIXl = m_regB;
		return 9;

	case 0x69: // ld_ixl_c
		m_regIXl = m_regC;
		return 9;

	case 0x6A: // ld_ixl_d
		m_regIXl = m_regD;
		return 9;

	case 0x6B: // ld_ixl_e
		m_regIXl = m_regE;
		return 9;

	case 0x6C: // ld_ixl_h
		m_regIXl = m_regH;
		return 9;

	case 0x6D: // ld_ixl_l
		m_regIXl = m_regL;
		return 9;

	case 0x6E: // ld_l_xix
		m_regL = MemReadByte(IndirectIX());
		return 9;

	case 0x6F: // ld_ixl_a
		m_regIXl = m_regA;
		return 9;

	case 0x70: // ld_xix_b
		MemWriteByte(IndirectIX(), m_regB);
		return 19;

	case 0x71: // ld_xix_c
		MemWriteByte(IndirectIX(), m_regC);
		return 19;

	case 0x72: // ld_xix_d
		MemWriteByte(IndirectIX(), m_regD);
		return 19;

	case 0x73: // ld_xix_e
		MemWriteByte(IndirectIX(), m_regE);
		return 19;

	case 0x74: // ld_xix_h
		MemWriteByte(IndirectIX(), m_regH);
		return 19;

	case 0x75: // ld_xix_l
		MemWriteByte(IndirectIX(), m_regL);
		return 19;

	case 0x76: // no_op
		SetPC(GetPC() - 1);
		return 19;

	case 0x77: // ld_xix_a
		MemWriteByte(IndirectIX(), m_regA);
		return 19;

	case 0x78: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x79: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x7A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x7B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x7C: // ld_a_ixh
		m_regA = m_regIXh;
		return 9;

	case 0x7D: // ld_a_ixl
		m_regA = m_regIXl;
		return 9;

	case 0x7E: // ld_a_xix
		m_regA = MemReadByte(IndirectIX());
		return 19;

	case 0x7F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x80: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x81: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x82: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x83: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x84: // add_a_ixh
		Add_1(m_regIXh);
		return 9;

	case 0x85: // add_a_ixl
		Add_1(m_regIXl);
		return 9;

	case 0x86: // add_a_xix
		Add_1(MemReadByte(IndirectIX()));
		return 19;

	case 0x87: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x88: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x89: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x8A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x8B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x8C: // adc_a_ixh
		Adc_1(m_regIXh);
		return 9;

	case 0x8D: // adc_a_ixl
		Adc_1(m_regIXl);
		return 9;

	case 0x8E: // adc_a_xix
		Adc_1(MemReadByte(IndirectIX()));
		return 19;

	case 0x8F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x90: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x91: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x92: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x93: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x94: // sub_ixh
		Sub_1(m_regIXh);
		return 9;

	case 0x95: // sub_ixl
		Sub_1(m_regIXl);
		return 9;

	case 0x96: // sub_xix
		Sub_1(MemReadByte(IndirectIX()));
		return 19;

	case 0x97: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x98: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x99: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x9A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x9B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x9C: // sbc_a_ixh
		Sbc_1(m_regIXh);
		return 9;

	case 0x9D: // sbc_a_ixl
		Sbc_1(m_regIXl);
		return 9;

	case 0x9E: // sbc_a_xix
		Sbc_1(MemReadByte(IndirectIX()));
		return 19;

	case 0x9F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA4: // and_ixh
		And(m_regIXh);
		return 9;

	case 0xA5: // and_ixl
		And(m_regIXl);
		return 9;

	case 0xA6: // and_xix
		And(MemReadByte(IndirectIX()));
		return 19;

	case 0xA7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xAA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xAB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xAC: // xor_ixh
		Xor(m_regIXh);
		return 9;

	case 0xAD: // xor_ixl
		Xor(m_regIXl);
		return 9;

	case 0xAE: // xor_xix
		Xor(MemReadByte(IndirectIX()));
		return 19;

	case 0xAF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB4: // or_ixh
		Or(m_regIXh);
		return 9;

	case 0xB5: // or_ixl
		Or(m_regIXl);
		return 9;

	case 0xB6: // or_xix
		Or(MemReadByte(IndirectIX()));
		return 19;

	case 0xB7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xBA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xBB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xBC: // cp_ixh
		Cp(m_regIXh);
		return 9;

	case 0xBD: // cp_ixl
		Cp(m_regIXl);
		return 9;

	case 0xBE: // cp_xix
		Cp(MemReadByte(IndirectIX()));
		return 19;

	case 0xBF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC5: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCB: // dd_cb
		return HandleDDCB();
		break;

	case 0xCC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCD: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD5: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDD: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE1: // pop_ix
		m_regIX = Pop();
		return 14;

	case 0xE2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE3: // ex_xsp_ix
		wTemp = MemReadWord(GetSP());
		MemWriteWord(GetSP(), m_regIX);
		m_regIX = wTemp;
		return 23;

	case 0xE4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE5: // push_ix
		Push(m_regIX);
		return 15;

	case 0xE6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE9: // jp_ix
		SetPC(m_regIX);
		return 8;

	case 0xEA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xED: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF5: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF9: // ld_sp_ix
		SetSP(m_regIX);
		return 10;

	case 0xFA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFD: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	default:
		return 0;
	}
}

/* ***************************************************************************
 * ED prefixed opcodes
 * ***************************************************************************
 */
void cpu_z80::HandleED() {
	const uint8_t bOpcode = ImmedByte();
	m_regR++;

	switch (bOpcode)
	{
	case 0x00: // nop
		cCycles -= 0;
		break;

	case 0x01: // nop
		cCycles -= 0;
		break;

	case 0x02: // nop
		cCycles -= 0;
		break;

	case 0x03: // nop
		cCycles -= 0;
		break;

	case 0x04: // nop
		cCycles -= 0;
		break;

	case 0x05: // nop
		cCycles -= 0;
		break;

	case 0x06: // nop
		cCycles -= 0;
		break;

	case 0x07: // nop
		cCycles -= 0;
		break;

	case 0x08: // nop
		cCycles -= 0;
		break;

	case 0x09: // nop
		cCycles -= 0;
		break;

	case 0x0A: // nop
		cCycles -= 0;
		break;

	case 0x0B: // nop
		cCycles -= 0;
		break;

	case 0x0C: // nop
		cCycles -= 0;
		break;

	case 0x0D: // nop
		cCycles -= 0;
		break;

	case 0x0E: // nop
		cCycles -= 0;
		break;

	case 0x0F: // nop
		cCycles -= 0;
		break;

	case 0x10: // nop
		cCycles -= 0;
		break;

	case 0x11: // nop
		cCycles -= 0;
		break;

	case 0x12: // nop
		cCycles -= 0;
		break;

	case 0x13: // nop
		cCycles -= 0;
		break;

	case 0x14: // nop
		cCycles -= 0;
		break;

	case 0x15: // nop
		cCycles -= 0;
		break;

	case 0x16: // nop
		cCycles -= 0;
		break;

	case 0x17: // nop
		cCycles -= 0;
		break;

	case 0x18: // nop
		cCycles -= 0;
		break;

	case 0x19: // nop
		cCycles -= 0;
		break;

	case 0x1A: // nop
		cCycles -= 0;
		break;

	case 0x1B: // nop
		cCycles -= 0;
		break;

	case 0x1C: // nop
		cCycles -= 0;
		break;

	case 0x1D: // nop
		cCycles -= 0;
		break;

	case 0x1E: // nop
		cCycles -= 0;
		break;

	case 0x1F: // nop
		cCycles -= 0;
		break;

	case 0x20: // nop
		cCycles -= 0;
		break;

	case 0x21: // nop
		cCycles -= 0;
		break;

	case 0x22: // nop
		cCycles -= 0;
		break;

	case 0x23: // nop
		cCycles -= 0;
		break;

	case 0x24: // nop
		cCycles -= 0;
		break;

	case 0x25: // nop
		cCycles -= 0;
		break;

	case 0x26: // nop
		cCycles -= 0;
		break;

	case 0x27: // nop
		cCycles -= 0;
		break;

	case 0x28: // nop
		cCycles -= 0;
		break;

	case 0x29: // nop
		cCycles -= 0;
		break;

	case 0x2A: // nop
		cCycles -= 0;
		break;

	case 0x2B: // nop
		cCycles -= 0;
		break;

	case 0x2C: // nop
		cCycles -= 0;
		break;

	case 0x2D: // nop
		cCycles -= 0;
		break;

	case 0x2E: // nop
		cCycles -= 0;
		break;

	case 0x2F: // nop
		cCycles -= 0;
		break;

	case 0x30: // nop
		cCycles -= 0;
		break;

	case 0x31: // nop
		cCycles -= 0;
		break;

	case 0x32: // nop
		cCycles -= 0;
		break;

	case 0x33: // nop
		cCycles -= 0;
		break;

	case 0x34: // nop
		cCycles -= 0;
		break;

	case 0x35: // nop
		cCycles -= 0;
		break;

	case 0x36: // nop
		cCycles -= 0;
		break;

	case 0x37: // nop
		cCycles -= 0;
		break;

	case 0x38: // nop
		cCycles -= 0;
		break;

	case 0x39: // nop
		cCycles -= 0;
		break;

	case 0x3A: // nop
		cCycles -= 0;
		break;

	case 0x3B: // nop
		cCycles -= 0;
		break;

	case 0x3C: // nop
		cCycles -= 0;
		break;

	case 0x3D: // nop
		cCycles -= 0;
		break;

	case 0x3E: // nop
		cCycles -= 0;
		break;

	case 0x3F: // nop
		cCycles -= 0;
		break;

	case 0x40: // in_b_c
		cCycles -= 12;
		m_regB = In(m_regC);
		break;

	case 0x41: // out_c_b
		cCycles -= 12;
		Out(m_regC, m_regB);
		break;

	case 0x42: // sbc_hl_bc
		cCycles -= 15;
		m_regHL = Sbc_2(m_regHL, m_regBC);
		break;

	case 0x43: // ld_xword_bc
		cCycles -= 20;
		MemWriteWord(ImmedWord(), m_regBC);
		break;

	case 0x44: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x45: // retn
		cCycles -= 8;
		m_iff1 = m_iff2;
		cCycles -= Ret0(1);
		break;

	case 0x46: // im_0
		cCycles -= 8;
		m_nIM = 0;
		break;

	case 0x47: // ld_i_a
		cCycles -= 9;
		m_regI = m_regA;
		break;

	case 0x48: // in_c_c
		cCycles -= 12;
		m_regC = In(m_regC);
		break;

	case 0x49: // out_c_c
		cCycles -= 12;
		Out(m_regC, m_regC);
		break;

	case 0x4A: // adc_hl_bc
		cCycles -= 15;
		m_regHL = Adc_2(m_regHL, m_regBC);
		break;

	case 0x4B: // ld_bc_xword
		cCycles -= 20;
		m_regBC = MemReadWord(ImmedWord());
		break;

	case 0x4C: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x4D: // reti
		cCycles -= 8;
		cCycles -= Ret0(1);
		break;

	case 0x4E: // im_0
		cCycles -= 8;
		m_nIM = 0;
		break;

	case 0x4F: // ld_r_a
		cCycles -= 9;
		m_regR = m_regA;
		//			m_regR2 = m_regA;
		break;

	case 0x50: // in_d_c
		cCycles -= 12;
		m_regD = In(m_regC);
		break;

	case 0x51: // out_c_d
		cCycles -= 12;
		Out(m_regC, m_regD);
		break;

	case 0x52: // sbc_hl_de
		cCycles -= 15;
		m_regHL = Sbc_2(m_regHL, m_regDE);
		break;

	case 0x53: // ld_xword_de
		cCycles -= 20;
		MemWriteWord(ImmedWord(), m_regDE);
		break;

	case 0x54: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x55: // retn
		cCycles -= 8;
		m_iff1 = m_iff2;
		cCycles -= Ret0(1);
		break;

	case 0x56: // im_1
		cCycles -= 8;
		m_nIM = 1;
		break;

	case 0x57: // ld_a_i
		cCycles -= 9;
		m_regA = m_regI;
		m_regF = (m_regF & C_FLAG) | ZSTable[m_regI] | (m_iff2 << 2);
		break;

	case 0x58: // in_e_c
		cCycles -= 12;
		m_regE = In(m_regC);
		break;

	case 0x59: // out_c_e
		cCycles -= 12;
		Out(m_regC, m_regE);
		break;

	case 0x5A: // adc_hl_de
		cCycles -= 15;
		m_regHL = Adc_2(m_regHL, m_regDE);
		break;

	case 0x5B: // ld_de_xword
		cCycles -= 20;
		m_regDE = MemReadWord(ImmedWord());
		break;

	case 0x5C: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x5D: // reti
		cCycles -= 8;
		cCycles -= Ret0(1);
		break;

	case 0x5E: // im_2
		cCycles -= 8;
		m_nIM = 2;
		break;

	case 0x5F: // ld_a_r
		cCycles -= 9;
		m_regA = (m_regR & 0x7F); /////////////////////////////////////// | (m_regR2 & 0x80);
		m_regF = (m_regF & C_FLAG) | ZSTable[m_regA] | (m_iff2 << 2);
		break;

	case 0x60: // in_h_c
		cCycles -= 12;
		m_regH = In(m_regC);
		break;

	case 0x61: // out_c_h
		cCycles -= 12;
		Out(m_regC, m_regH);
		break;

	case 0x62: // sbc_hl_hl
		cCycles -= 15;
		m_regHL = Sbc_2(m_regHL, m_regHL);
		break;

	case 0x63: // ld_xword_hl
		cCycles -= 20;
		MemWriteWord(ImmedWord(), m_regHL);
		break;

	case 0x64: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x65: // retn
		cCycles -= 8;
		m_iff1 = m_iff2;
		cCycles -= Ret0(1);
		break;

	case 0x66: // im_0
		cCycles -= 8;
		m_nIM = 0;
		break;

	case 0x67: // rrd
		cCycles -= 18;
		{
			uint8_t i = MemReadByte(m_regHL);
			MemWriteByte(m_regHL, (i >> 4) | (m_regA << 4));
			m_regA = (m_regA & 0xF0) | (i & 0x0F);
			m_regF = (m_regF & C_FLAG) | ZSPTable[m_regA];
			break;
		}

	case 0x68: // in_l_c
		cCycles -= 12;
		m_regL = In(m_regC);
		break;

	case 0x69: // out_c_l
		cCycles -= 12;
		Out(m_regC, m_regL);
		break;

	case 0x6A: // adc_hl_hl
		cCycles -= 15;
		m_regHL = Adc_2(m_regHL, m_regHL);
		break;

	case 0x6B: // ld_hl_xword
		cCycles -= 20;
		m_regHL = MemReadWord(ImmedWord());
		break;

	case 0x6C: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x6D: // reti
		cCycles -= 8;
		cCycles -= Ret0(1);
		break;

	case 0x6E: // im_0
		cCycles -= 8;
		m_nIM = 0;
		break;

	case 0x6F: // rld
		cCycles -= 18;
		{
			uint8_t i;
			i = MemReadByte(m_regHL);
			MemWriteByte(m_regHL, (i << 4) | (m_regA & 0x0F));
			m_regA = (m_regA & 0xF0) | (i >> 4);
			m_regF = (m_regF & C_FLAG) | ZSPTable[m_regA];
			break;
		}

	case 0x70: // in_0_c
		cCycles -= 12;
		In(m_regC);
		break;

	case 0x71: // out_c_0
		cCycles -= 12;
		Out(m_regC, 0);
		break;

	case 0x72: // sbc_hl_sp
		cCycles -= 15;
		m_regHL = Sbc_2(m_regHL, GetSP());
		break;

	case 0x73: // ld_xword_sp
		cCycles -= 20;
		MemWriteWord(ImmedWord(), GetSP());
		break;

	case 0x74: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x75: // retn
		cCycles -= 8;
		m_iff1 = m_iff2;
		cCycles -= Ret0(1);
		break;

	case 0x76: // im_1
		cCycles -= 8;
		m_nIM = 1;
		break;

	case 0x77: // nop
		cCycles -= 0;
		break;

	case 0x78: // in_a_c
		cCycles -= 12;
		m_regA = In(m_regC);
		break;

	case 0x79: // out_c_a
		cCycles -= 12;
		Out(m_regC, m_regA);
		break;

	case 0x7A: // adc_hl_sp
		cCycles -= 15;
		m_regHL = Adc_2(m_regHL, GetSP());
		break;

	case 0x7B: // ld_sp_xword
		cCycles -= 20;
		SetSP(MemReadWord(ImmedWord()));
		break;

	case 0x7C: // neg
		cCycles -= 8;
		{
			uint8_t b = m_regA;
			m_regA = 0;
			Sub_1(b);
			break;
		}

	case 0x7D: // reti
		cCycles -= 8;
		cCycles -= Ret0(1);
		break;

	case 0x7E: // im_2
		cCycles -= 8;
		m_nIM = 2;
		break;

	case 0x7F: // nop
		cCycles -= 0;
		break;

	case 0x80: // nop
		cCycles -= 0;
		break;

	case 0x81: // nop
		cCycles -= 0;
		break;

	case 0x82: // nop
		cCycles -= 0;
		break;

	case 0x83: // nop
		cCycles -= 0;
		break;

	case 0x84: // nop
		cCycles -= 0;
		break;

	case 0x85: // nop
		cCycles -= 0;
		break;

	case 0x86: // nop
		cCycles -= 0;
		break;

	case 0x87: // nop
		cCycles -= 0;
		break;

	case 0x88: // nop
		cCycles -= 0;
		break;

	case 0x89: // nop
		cCycles -= 0;
		break;

	case 0x8A: // nop
		cCycles -= 0;
		break;

	case 0x8B: // nop
		cCycles -= 0;
		break;

	case 0x8C: // nop
		cCycles -= 0;
		break;

	case 0x8D: // nop
		cCycles -= 0;
		break;

	case 0x8E: // nop
		cCycles -= 0;
		break;

	case 0x8F: // nop
		cCycles -= 0;
		break;

	case 0x90: // nop
		cCycles -= 0;
		break;

	case 0x91: // nop
		cCycles -= 0;
		break;

	case 0x92: // nop
		cCycles -= 0;
		break;

	case 0x93: // nop
		cCycles -= 0;
		break;

	case 0x94: // nop
		cCycles -= 0;
		break;

	case 0x95: // nop
		cCycles -= 0;
		break;

	case 0x96: // nop
		cCycles -= 0;
		break;

	case 0x97: // nop
		cCycles -= 0;
		break;

	case 0x98: // nop
		cCycles -= 0;
		break;

	case 0x99: // nop
		cCycles -= 0;
		break;

	case 0x9A: // nop
		cCycles -= 0;
		break;

	case 0x9B: // nop
		cCycles -= 0;
		break;

	case 0x9C: // nop
		cCycles -= 0;
		break;

	case 0x9D: // nop
		cCycles -= 0;
		break;

	case 0x9E: // nop
		cCycles -= 0;
		break;

	case 0x9F: // nop
		cCycles -= 0;
		break;

	case 0xA0: // ldi
		cCycles -= 16;
		{
			MemWriteByte(m_regDE++, MemReadByte(m_regHL++));
			m_regBC--;
			m_regF = (m_regF & 0xE9) | (m_regBC ? V_FLAG : 0); // Verified Correct
			break;
		}

	case 0xA1: // cpi
		cCycles -= 16;
		{
			uint8_t i, j;
			i = MemReadByte(m_regHL);
			j = m_regA - i;
			++m_regHL;
			--m_regBC;
			m_regF = (m_regF & C_FLAG) | ZSTable[j] |
				((m_regA ^ i ^ j) & H_FLAG) | (m_regBC ? V_FLAG : 0) | N_FLAG;
			break;
		}

	case 0xA2: // ini  //Review
		cCycles -= 16;
		{
			MemWriteByte(m_regHL, In(m_regC));
			++m_regHL;
			--m_regB;
			m_regF = (m_regB) ? N_FLAG : (N_FLAG | Z_FLAG);
			break;
		}

	case 0xA3: // outi
		cCycles -= 16;
		{
			Out(m_regC, MemReadByte(m_regHL));
			++m_regHL;
			--m_regB;
			m_regF = (m_regB) ? N_FLAG : (Z_FLAG | N_FLAG);
			break;
		}

	case 0xA4: // nop
		cCycles -= 0;
		break;

	case 0xA5: // nop
		cCycles -= 0;
		break;

	case 0xA6: // nop
		cCycles -= 0;
		break;

	case 0xA7: // nop
		cCycles -= 0;
		break;

	case 0xA8: // ldd
		cCycles -= 16;
		{
			MemWriteByte(m_regDE, MemReadByte(m_regHL));
			--m_regDE;
			--m_regHL;
			--m_regBC;
			m_regF = (m_regF & 0xE9) | (m_regBC ? V_FLAG : 0);
			break;
		}

	case 0xA9: // cpd
		cCycles -= 16;
		{
			uint8_t i, j;
			i = MemReadByte(m_regHL);
			j = m_regA - i;
			--m_regHL;
			--m_regBC;
			m_regF = (m_regF & C_FLAG) | ZSTable[j] |
				((m_regA ^ i ^ j) & H_FLAG) | (m_regBC ? V_FLAG : 0) | N_FLAG;
			break;
		}

	case 0xAA: // ind //Review
		cCycles -= 16;
		{
			MemWriteByte(m_regHL, In(m_regC));
			--m_regHL;
			--m_regB;
			m_regF = (m_regB) ? N_FLAG : (N_FLAG | Z_FLAG);
			break;
			/*
				tmp: = ((c)), (hl) : = tmp, hl -= 1,
				b -= 1 = > flags, nf : = tmp.7,
				tmp2 = tmp + [[c - 1]AND 0xff],
				pf : = parity of [[tmp2 AND 0x07]XOR b],
				hf : = cf : = tmp2 > 255
			*/
		}

	case 0xAB: // outd
		cCycles -= 16;
		{
			Out(m_regC, MemReadByte(m_regHL));
			--m_regHL;
			--m_regB;
			m_regF = (m_regB) ? N_FLAG : (Z_FLAG | N_FLAG);
			break;
		}

	case 0xAC: // nop
		cCycles -= 0;
		break;

	case 0xAD: // nop
		cCycles -= 0;
		break;

	case 0xAE: // nop
		cCycles -= 0;
		break;

	case 0xAF: // nop
		cCycles -= 0;
		break;

	case 0xB0: // ldir
	{
		MemWriteByte(m_regDE, MemReadByte(m_regHL));
		cCycles -= 0x16;

		++m_regDE;
		++m_regHL;
		--m_regBC;

		m_regF = (m_regF & 0xE9) | (m_regBC ? V_FLAG : 0);  //E9 just equals the N Flag?

		if (m_regBC)
		{
			AdjustPC(-2);
			cCycles -= 5;
			m_regF |= V_FLAG;
		}
		break;
	}

	case 0xB1: // cpir
	{
		uint8_t i, j;

		i = MemReadByte(m_regHL);
		j = m_regA - i;
		++m_regHL;
		--m_regBC;
		cCycles -= 16;

		m_regF = (m_regF & C_FLAG) | ZSTable[j] |
			((m_regA ^ i ^ j) & H_FLAG) | (m_regBC ? V_FLAG : 0) | N_FLAG;
		if (m_regBC && j)
		{
			AdjustPC(-2);
			cCycles -= 5;
		}
		break;
	}

	case 0xB2: // inir //Review
	{
		MemWriteByte(m_regHL, In(m_regC));
		++m_regHL;
		--m_regB;
		cCycles -= 16;

		m_regF = (m_regB) ? N_FLAG : (N_FLAG | Z_FLAG);
		if (m_regB)
		{
			AdjustPC(-2);
			cCycles -= 5;
		}
		break;

		/*	ini, if b <> 0 then pc -= 2*/
	}

	case 0xB3: // otir
	{
		Out(m_regC, MemReadByte(m_regHL));
		++m_regHL;
		--m_regB;
		cCycles -= 16;

		m_regF = (m_regB) ? N_FLAG : (Z_FLAG | N_FLAG);
		if (m_regB)
		{
			AdjustPC(-2);
			cCycles -= 5;
		}
	}
	break;

	case 0xB4: // nop
		cCycles -= 0;
		break;

	case 0xB5: // nop
		cCycles -= 0;
		break;

	case 0xB6: // nop
		cCycles -= 0;
		break;

	case 0xB7: // nop
		cCycles -= 0;
		break;

	case 0xB8: // lddr
	{
		MemWriteByte(m_regDE, MemReadByte(m_regHL));
		--m_regDE;
		--m_regHL;
		--m_regBC;
		cCycles -= 16;

		m_regF = (m_regF & 0xE9) | (m_regBC ? V_FLAG : 0);
		if (m_regBC)
		{
			AdjustPC(-2);
			cCycles -= 5;
		}
		break;
	}

	case 0xB9: // cpdr
		cCycles -= 0;
		{
			uint8_t i, j;

			i = MemReadByte(m_regHL);
			j = m_regA - i;
			--m_regHL;
			--m_regBC;
			cCycles -= 16;

			m_regF = (m_regF & C_FLAG) | ZSTable[j] |
				((m_regA ^ i ^ j) & H_FLAG) | (m_regBC ? V_FLAG : 0) | N_FLAG;
			if (m_regBC && j)
			{
				AdjustPC(-2);
				cCycles -= 5;
			}
			break;
		}

	case 0xBA: // indr
		cCycles -= 0;
		{
			MemWriteByte(m_regHL, In(m_regC));
			--m_regHL;
			--m_regB;
			cCycles -= 16;

			m_regF = (m_regB) ? N_FLAG : (N_FLAG | Z_FLAG);
			if (m_regB)
			{
				AdjustPC(-2);
				cCycles -= 5;
			}
			break;
		}

	case 0xBB: // otdr
		cCycles -= 0;
		{
			Out(m_regC, MemReadByte(m_regHL));
			--m_regHL;
			--m_regB;
			cCycles -= 16;

			m_regF = (m_regB) ? N_FLAG : (Z_FLAG | N_FLAG);
			if (m_regB)
			{
				AdjustPC(-2);
				cCycles -= 5;
			}
			break;
		}

	case 0xBC: // nop
		cCycles -= 0;
		break;

	case 0xBD: // nop
		cCycles -= 0;
		break;

	case 0xBE: // nop
		cCycles -= 0;
		break;

	case 0xBF: // nop
		cCycles -= 0;
		break;

	case 0xC0: // nop
		cCycles -= 0;
		break;

	case 0xC1: // nop
		cCycles -= 0;
		break;

	case 0xC2: // nop
		cCycles -= 0;
		break;

	case 0xC3: // nop
		cCycles -= 0;
		break;

	case 0xC4: // nop
		cCycles -= 0;
		break;

	case 0xC5: // nop
		cCycles -= 0;
		break;

	case 0xC6: // nop
		cCycles -= 0;
		break;

	case 0xC7: // nop
		cCycles -= 0;
		break;

	case 0xC8: // nop
		cCycles -= 0;
		break;

	case 0xC9: // nop
		cCycles -= 0;
		break;

	case 0xCA: // nop
		cCycles -= 0;
		break;

	case 0xCB: // nop
		cCycles -= 0;
		break;

	case 0xCC: // nop
		cCycles -= 0;
		break;

	case 0xCD: // nop
		cCycles -= 0;
		break;

	case 0xCE: // nop
		cCycles -= 0;
		break;

	case 0xCF: // nop
		cCycles -= 0;
		break;

	case 0xD0: // nop
		cCycles -= 0;
		break;

	case 0xD1: // nop
		cCycles -= 0;
		break;

	case 0xD2: // nop
		cCycles -= 0;
		break;

	case 0xD3: // nop
		cCycles -= 0;
		break;

	case 0xD4: // nop
		cCycles -= 0;
		break;

	case 0xD5: // nop
		cCycles -= 0;
		break;

	case 0xD6: // nop
		cCycles -= 0;
		break;

	case 0xD7: // nop
		cCycles -= 0;
		break;

	case 0xD8: // nop
		cCycles -= 0;
		break;

	case 0xD9: // nop
		cCycles -= 0;
		break;

	case 0xDA: // nop
		cCycles -= 0;
		break;

	case 0xDB: // nop
		cCycles -= 0;
		break;

	case 0xDC: // nop
		cCycles -= 0;
		break;

	case 0xDD: // nop
		cCycles -= 0;
		break;

	case 0xDE: // nop
		cCycles -= 0;
		break;

	case 0xDF: // nop
		cCycles -= 0;
		break;

	case 0xE0: // nop
		cCycles -= 0;
		break;

	case 0xE1: // nop
		cCycles -= 0;
		break;

	case 0xE2: // nop
		cCycles -= 0;
		break;

	case 0xE3: // nop
		cCycles -= 0;
		break;

	case 0xE4: // nop
		cCycles -= 0;
		break;

	case 0xE5: // nop
		cCycles -= 0;
		break;

	case 0xE6: // nop
		cCycles -= 0;
		break;

	case 0xE7: // nop
		cCycles -= 0;
		break;

	case 0xE8: // nop
		cCycles -= 0;
		break;

	case 0xE9: // nop
		cCycles -= 0;
		break;

	case 0xEA: // nop
		cCycles -= 0;
		break;

	case 0xEB: // nop
		cCycles -= 0;
		break;

	case 0xEC: // nop
		cCycles -= 0;
		break;

	case 0xED: // nop
		cCycles -= 0;
		break;

	case 0xEE: // nop
		cCycles -= 0;
		break;

	case 0xEF: // nop
		cCycles -= 0;
		break;

	case 0xF0: // nop
		cCycles -= 0;
		break;

	case 0xF1: // nop
		cCycles -= 0;
		break;

	case 0xF2: // nop
		cCycles -= 0;
		break;

	case 0xF3: // nop
		cCycles -= 0;
		break;

	case 0xF4: // nop
		cCycles -= 0;
		break;

	case 0xF5: // nop
		cCycles -= 0;
		break;

	case 0xF6: // nop
		cCycles -= 0;
		break;

	case 0xF7: // nop
		cCycles -= 0;
		break;

	case 0xF8: // nop
		cCycles -= 0;
		break;

	case 0xF9: // nop
		cCycles -= 0;
		break;

	case 0xFA: // nop
		cCycles -= 0;
		break;

	case 0xFB: // nop
		cCycles -= 0;
		break;

	case 0xFC: // nop
		cCycles -= 0;
		break;

	case 0xFD: // nop
		cCycles -= 0;
		break;

	case 0xFE: // patch
		cCycles -= 0;
		break;

	case 0xFF: // nop
		cCycles -= 0;
		break;

	default:
		assert(false);
		break;
	}
}

/* ***************************************************************************
 * FD prefixed opcodes
 * ***************************************************************************
 */
uint16_t cpu_z80::IndirectIY()
{
	return m_regIY + (signed char)ImmedByte();
}

int cpu_z80::HandleFD() {
	uint16_t wAddr;
	uint16_t wTemp;
	const uint8_t bOpcode = ImmedByte();

	m_regR++;

	switch (bOpcode)
	{
	case 0x00: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x01: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x02: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x03: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x04: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x05: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x06: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x07: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x08: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x09: // add_iy_bc
		m_regIY = Add_2(m_regIY, m_regBC);
		return 15;

	case 0x0A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0C: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0D: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0E: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x0F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x10: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x11: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x12: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x13: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x14: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x15: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x16: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x17: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x18: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x19: // add_iy_de
		m_regIY = Add_2(m_regIY, m_regDE);
		return 15;

	case 0x1A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1C: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1D: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1E: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x1F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x20: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x21: // ld_iy_word
		m_regIY = ImmedWord();
		return 14;

	case 0x22: // ld_xword_iy
		MemWriteWord(ImmedWord(), m_regIY);
		return 20;

	case 0x23: // inc_iy
		m_regIY++;
		return 10;

	case 0x24: // inc_iyh
		m_regIYh = Inc(m_regIYh);
		return 9;

	case 0x25: // dec_iyh
		m_regIYh = Dec(m_regIYh);
		return 9;

	case 0x26: // ld_iyh_byte
		m_regIYh = ImmedByte();
		return 9;

	case 0x27: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x28: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x29: // add_iy_iy
		m_regIY = Add_2(m_regIY, m_regIY);
		return 15;

	case 0x2A: // ld_iy_xword
		m_regIY = MemReadWord(ImmedWord());
		return 20;

	case 0x2B: // dec_iy
		m_regIY--;
		return 10;

	case 0x2C: // inc_iyl
		m_regIYl = Inc(m_regIYl);
		return 9;

	case 0x2D: // dec_iyl
		m_regIYl = Dec(m_regIYl);
		return 9;

	case 0x2E: // ld_iyl_byte
		m_regIYl = ImmedByte();
		return 9;

	case 0x2F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x30: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x31: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x32: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x33: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x34: // inc_xiy
		wAddr = IndirectIY();
		MemWriteByte(wAddr, Inc(MemReadByte(wAddr)));
		return 23;

	case 0x35: // dec_xiy
		wAddr = IndirectIY();
		MemWriteByte(wAddr, Dec(MemReadByte(wAddr)));
		return 23;

	case 0x36: // ld_xiy_byte
		wAddr = IndirectIY();
		MemWriteByte(wAddr, ImmedByte());
		return 19;

	case 0x37: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x38: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x39: // add_iy_sp
		m_regIY = Add_2(m_regIY, GetSP());
		return 15;

	case 0x3A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3C: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3D: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3E: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x3F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x40: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x41: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x42: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x43: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x44: // ld_b_iyh
		m_regB = m_regIYh;
		return 9;

	case 0x45: // ld_b_iyl
		m_regB = m_regIYl;
		return 9;

	case 0x46: // ld_b_xiy
		m_regB = MemReadByte(IndirectIY());
		return 19;

	case 0x47: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x48: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x49: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x4A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x4B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x4C: // ld_c_iyh
		m_regC = m_regIYh;
		return 9;

	case 0x4D: // ld_c_iyl
		m_regC = m_regIYl;
		return 9;

	case 0x4E: // ld_c_xiy
		m_regC = MemReadByte(IndirectIY());
		return 19;

	case 0x4F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x50: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x51: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x52: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x53: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x54: // ld_d_iyh
		m_regD = m_regIYh;
		return 9;

	case 0x55: // ld_d_iyl
		m_regD = m_regIYl;
		return 9;

	case 0x56: // ld_d_xiy
		m_regD = MemReadByte(IndirectIY());
		return 19;

	case 0x57: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x58: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x59: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x5A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x5B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x5C: // ld_e_iyh
		m_regE = m_regIYh;
		return 9;

	case 0x5D: // ld_e_iyl
		m_regE = m_regIYl;
		return 9;

	case 0x5E: // ld_e_xiy
		m_regE = MemReadByte(IndirectIY());
		return 19;

	case 0x5F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x60: // ld_iyh_b
		m_regIYh = m_regB;
		return 9;

	case 0x61: // ld_iyh_c
		m_regIYh = m_regC;
		return 9;

	case 0x62: // ld_iyh_d
		m_regIYh = m_regD;
		return 9;

	case 0x63: // ld_iyh_e
		m_regIYh = m_regE;
		return 9;

	case 0x64: // ld_iyh_h
		m_regIYh = m_regH;
		return 9;

	case 0x65: // ld_iyh_l
		m_regIYh = m_regL;
		return 9;

	case 0x66: // ld_h_xiy
		m_regH = MemReadByte(IndirectIY());
		return 9;

	case 0x67: // ld_iyh_a
		m_regIYh = m_regA;
		return 9;

	case 0x68: // ld_iyl_b
		m_regIYl = m_regB;
		return 9;

	case 0x69: // ld_iyl_c
		m_regIYl = m_regC;
		return 9;

	case 0x6A: // ld_iyl_d
		m_regIYl = m_regD;
		return 9;

	case 0x6B: // ld_iyl_e
		m_regIYl = m_regE;
		return 9;

	case 0x6C: // ld_iyl_h
		m_regIYl = m_regH;
		return 9;

	case 0x6D: // ld_iyl_l
		m_regIYl = m_regL;
		return 9;

	case 0x6E: // ld_l_xiy
		m_regL = MemReadByte(IndirectIY());
		return 9;

	case 0x6F: // ld_iyl_a
		m_regIYl = m_regA;
		return 9;

	case 0x70: // ld_xiy_b
		MemWriteByte(IndirectIY(), m_regB);
		return 19;

	case 0x71: // ld_xiy_c
		MemWriteByte(IndirectIY(), m_regC);
		return 19;

	case 0x72: // ld_xiy_d
		MemWriteByte(IndirectIY(), m_regD);
		return 19;

	case 0x73: // ld_xiy_e
		MemWriteByte(IndirectIY(), m_regE);
		return 19;

	case 0x74: // ld_xiy_h
		MemWriteByte(IndirectIY(), m_regH);
		return 19;

	case 0x75: // ld_xiy_l
		MemWriteByte(IndirectIY(), m_regL);
		return 19;

	case 0x76: // no_op
		SetPC(GetPC() - 1);
		return 19;

	case 0x77: // ld_xiy_a
		MemWriteByte(IndirectIY(), m_regA);
		return 19;

	case 0x78: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x79: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x7A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x7B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x7C: // ld_a_iyh
		m_regA = m_regIYh;
		return 9;

	case 0x7D: // ld_a_iyl
		m_regA = m_regIYl;
		return 9;

	case 0x7E: // ld_a_xiy
		m_regA = MemReadByte(IndirectIY());
		return 19;

	case 0x7F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x80: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x81: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x82: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x83: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x84: // add_a_iyh
		Add_1(m_regIYh);
		return 9;

	case 0x85: // add_a_iyl
		Add_1(m_regIYl);
		return 9;

	case 0x86: // add_a_xiy
		Add_1(MemReadByte(IndirectIY()));
		return 19;

	case 0x87: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x88: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x89: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x8A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x8B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x8C: // adc_a_iyh
		Adc_1(m_regIYh);
		return 9;

	case 0x8D: // adc_a_iyl
		Adc_1(m_regIYl);
		return 9;

	case 0x8E: // adc_a_xiy
		Adc_1(MemReadByte(IndirectIY()));
		return 19;

	case 0x8F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x90: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x91: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x92: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x93: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x94: // sub_iyh
		Sub_1(m_regIYh);
		return 9;

	case 0x95: // sub_iyl
		Sub_1(m_regIYl);
		return 9;

	case 0x96: // sub_xiy
		Sub_1(MemReadByte(IndirectIY()));
		return 19;

	case 0x97: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x98: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x99: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x9A: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x9B: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0x9C: // sbc_a_iyh
		Sbc_1(m_regIYh);
		return 9;

	case 0x9D: // sbc_a_iyl
		Sbc_1(m_regIYl);
		return 9;

	case 0x9E: // sbc_a_xiy
		Sbc_1(MemReadByte(IndirectIY()));
		return 19;

	case 0x9F: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA4: // and_iyh
		And(m_regIYh);
		return 9;

	case 0xA5: // and_iyl
		And(m_regIYl);
		return 9;

	case 0xA6: // and_xiy
		And(MemReadByte(IndirectIY()));
		return 19;

	case 0xA7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xA9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xAA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xAB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xAC: // xor_iyh
		Xor(m_regIYh);
		return 9;

	case 0xAD: // xor_iyl
		Xor(m_regIYl);
		return 9;

	case 0xAE: // xor_xiy
		Xor(MemReadByte(IndirectIY()));
		return 19;

	case 0xAF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB4: // or_iyh
		Or(m_regIYh);
		return 9;

	case 0xB5: // or_iyl
		Or(m_regIYl);
		return 9;

	case 0xB6: // or_xiy
		Or(MemReadByte(IndirectIY()));
		return 19;

	case 0xB7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xB9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xBA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xBB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xBC: // cp_iyh
		Cp(m_regIYh);
		return 9;

	case 0xBD: // cp_iyl
		Cp(m_regIYl);
		return 9;

	case 0xBE: // cp_xiy
		Cp(MemReadByte(IndirectIY()));
		return 19;

	case 0xBF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC5: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xC9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCB: // fd_cb
		return HandleFDCB();

	case 0xCC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCD: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xCF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD5: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xD9: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDD: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xDF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE1: // pop_iy
		m_regIY = Pop();
		return 14;

	case 0xE2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE3: // ex_xsp_iy
		wTemp = MemReadWord(GetSP());
		MemWriteWord(GetSP(), m_regIY);
		m_regIY = wTemp;
		return 23;

	case 0xE4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE5: // push_iy
		Push(m_regIY);
		return 15;

	case 0xE6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xE9: // jp_iy
		SetPC(m_regIY);
		return 8;

	case 0xEA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xED: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xEF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF0: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF1: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF2: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF3: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF4: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF5: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF6: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF7: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF8: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xF9: // ld_sp_iy
		SetSP(m_regIY);
		return 10;

	case 0xFA: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFB: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFC: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFD: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFE: // no_op
		SetPC(GetPC() - 1);
		return 0;

	case 0xFF: // no_op
		SetPC(GetPC() - 1);
		return 0;

	default:
		assert(false);
		return 0;
	}
}

/* ***************************************************************************
 * FDCD prefixed opcodes
 * ***************************************************************************
 */

int cpu_z80::HandleFDCB() {
	const uint16_t wAddr = m_regIY + (signed char)ImmedByte();
	const uint8_t bOpcode = ImmedByte();

	switch (bOpcode)
	{
	case 0x00: // no_op_xx
		return 0;

	case 0x01: // no_op_xx
		return 0;

	case 0x02: // no_op_xx
		return 0;

	case 0x03: // no_op_xx
		return 0;

	case 0x04: // no_op_xx
		return 0;

	case 0x05: // no_op_xx
		return 0;

	case 0x06: // rlc_xiy
		MemWriteByte(wAddr, Rlc(MemReadByte(wAddr)));
		return 23;

	case 0x07: // no_op_xx
		return 0;

	case 0x08: // no_op_xx
		return 0;

	case 0x09: // no_op_xx
		return 0;

	case 0x0A: // no_op_xx
		return 0;

	case 0x0B: // no_op_xx
		return 0;

	case 0x0C: // no_op_xx
		return 0;

	case 0x0D: // no_op_xx
		return 0;

	case 0x0E: // rrc_xiy
		MemWriteByte(wAddr, Rrc(MemReadByte(wAddr)));
		return 23;

	case 0x0F: // no_op_xx
		return 0;

	case 0x10: // no_op_xx
		return 0;

	case 0x11: // no_op_xx
		return 0;

	case 0x12: // no_op_xx
		return 0;

	case 0x13: // no_op_xx
		return 0;

	case 0x14: // no_op_xx
		return 0;

	case 0x15: // no_op_xx
		return 0;

	case 0x16: // rl_xiy
		MemWriteByte(wAddr, Rl(MemReadByte(wAddr)));
		return 23;

	case 0x17: // no_op_xx
		return 0;

	case 0x18: // no_op_xx
		return 0;

	case 0x19: // no_op_xx
		return 0;

	case 0x1A: // no_op_xx
		return 0;

	case 0x1B: // no_op_xx
		return 0;

	case 0x1C: // no_op_xx
		return 0;

	case 0x1D: // no_op_xx
		return 0;

	case 0x1E: // rr_xiy
		MemWriteByte(wAddr, Rr(MemReadByte(wAddr)));
		return 23;

	case 0x1F: // no_op_xx
		return 0;

	case 0x20: // no_op_xx
		return 0;

	case 0x21: // no_op_xx
		return 0;

	case 0x22: // no_op_xx
		return 0;

	case 0x23: // no_op_xx
		return 0;

	case 0x24: // no_op_xx
		return 0;

	case 0x25: // no_op_xx
		return 0;

	case 0x26: // sla_xiy
		MemWriteByte(wAddr, Sla(MemReadByte(wAddr)));
		return 23;

	case 0x27: // no_op_xx
		return 0;

	case 0x28: // no_op_xx
		return 0;

	case 0x29: // no_op_xx
		return 0;

	case 0x2A: // no_op_xx
		return 0;

	case 0x2B: // no_op_xx
		return 0;

	case 0x2C: // no_op_xx
		return 0;

	case 0x2D: // no_op_xx
		return 0;

	case 0x2E: // sra_xiy
		MemWriteByte(wAddr, Sra(MemReadByte(wAddr)));
		return 23;

	case 0x2F: // no_op_xx
		return 0;

	case 0x30: // no_op_xx
		return 0;

	case 0x31: // no_op_xx
		return 0;

	case 0x32: // no_op_xx
		return 0;

	case 0x33: // no_op_xx
		return 0;

	case 0x34: // no_op_xx
		return 0;

	case 0x35: // no_op_xx
		return 0;

	case 0x36: // sll_xiy
		MemWriteByte(wAddr, Sll(MemReadByte(wAddr)));
		return 23;

	case 0x37: // no_op_xx
		return 0;

	case 0x38: // no_op_xx
		return 0;

	case 0x39: // no_op_xx
		return 0;

	case 0x3A: // no_op_xx
		return 0;

	case 0x3B: // no_op_xx
		return 0;

	case 0x3C: // no_op_xx
		return 0;

	case 0x3D: // no_op_xx
		return 0;

	case 0x3E: // srl_xiy
		MemWriteByte(wAddr, Srl(MemReadByte(wAddr)));
		return 23;

	case 0x3F: // no_op_xx
		return 0;

	case 0x40: // bit_0_xiy
	case 0x41: // bit_0_xiy
	case 0x42: // bit_0_xiy
	case 0x43: // bit_0_xiy
	case 0x44: // bit_0_xiy
	case 0x45: // bit_0_xiy
	case 0x46: // bit_0_xiy
	case 0x47: // bit_0_xiy
		Bit(MemReadByte(wAddr), 0);
		return 20;

	case 0x48: // bit_1_xiy
	case 0x49: // bit_1_xiy
	case 0x4A: // bit_1_xiy
	case 0x4B: // bit_1_xiy
	case 0x4C: // bit_1_xiy
	case 0x4D: // bit_1_xiy
	case 0x4E: // bit_1_xiy
	case 0x4F: // bit_1_xiy
		Bit(MemReadByte(wAddr), 1);
		return 20;

	case 0x50: // bit_2_xiy
	case 0x51: // bit_2_xiy
	case 0x52: // bit_2_xiy
	case 0x53: // bit_2_xiy
	case 0x54: // bit_2_xiy
	case 0x55: // bit_2_xiy
	case 0x56: // bit_2_xiy
	case 0x57: // bit_2_xiy
		Bit(MemReadByte(wAddr), 2);
		return 20;

	case 0x58: // bit_3_xiy
	case 0x59: // bit_3_xiy
	case 0x5A: // bit_3_xiy
	case 0x5B: // bit_3_xiy
	case 0x5C: // bit_3_xiy
	case 0x5D: // bit_3_xiy
	case 0x5E: // bit_3_xiy
	case 0x5F: // bit_3_xiy
		Bit(MemReadByte(wAddr), 3);
		return 20;

	case 0x60: // bit_4_xiy
	case 0x61: // bit_4_xiy
	case 0x62: // bit_4_xiy
	case 0x63: // bit_4_xiy
	case 0x64: // bit_4_xiy
	case 0x65: // bit_4_xiy
	case 0x66: // bit_4_xiy
	case 0x67: // bit_4_xiy
		Bit(MemReadByte(wAddr), 4);
		return 20;

	case 0x68: // bit_5_xiy
	case 0x69: // bit_5_xiy
	case 0x6A: // bit_5_xiy
	case 0x6B: // bit_5_xiy
	case 0x6C: // bit_5_xiy
	case 0x6D: // bit_5_xiy
	case 0x6E: // bit_5_xiy
	case 0x6F: // bit_5_xiy
		Bit(MemReadByte(wAddr), 5);
		return 20;

	case 0x70: // bit_6_xiy
	case 0x71: // bit_6_xiy
	case 0x72: // bit_6_xiy
	case 0x73: // bit_6_xiy
	case 0x74: // bit_6_xiy
	case 0x75: // bit_6_xiy
	case 0x76: // bit_6_xiy
	case 0x77: // bit_6_xiy
		Bit(MemReadByte(wAddr), 6);
		return 20;

	case 0x78: // bit_7_xiy
	case 0x79: // bit_7_xiy
	case 0x7A: // bit_7_xiy
	case 0x7B: // bit_7_xiy
	case 0x7C: // bit_7_xiy
	case 0x7D: // bit_7_xiy
	case 0x7E: // bit_7_xiy
	case 0x7F: // bit_7_xiy
		Bit(MemReadByte(wAddr), 7);
		return 20;

	case 0x80: // no_op_xx
		return 0;

	case 0x81: // no_op_xx
		return 0;

	case 0x82: // no_op_xx
		return 0;

	case 0x83: // no_op_xx
		return 0;

	case 0x84: // no_op_xx
		return 0;

	case 0x85: // no_op_xx
		return 0;

	case 0x86: // res_0_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 0));
		return 23;

	case 0x87: // no_op_xx
		return 0;

	case 0x88: // no_op_xx
		return 0;

	case 0x89: // no_op_xx
		return 0;

	case 0x8A: // no_op_xx
		return 0;

	case 0x8B: // no_op_xx
		return 0;

	case 0x8C: // no_op_xx
		return 0;

	case 0x8D: // no_op_xx
		return 0;

	case 0x8E: // res_1_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 1));
		return 23;

	case 0x8F: // no_op_xx
		return 0;

	case 0x90: // no_op_xx
		return 0;

	case 0x91: // no_op_xx
		return 0;

	case 0x92: // no_op_xx
		return 0;

	case 0x93: // no_op_xx
		return 0;

	case 0x94: // no_op_xx
		return 0;

	case 0x95: // no_op_xx
		return 0;

	case 0x96: // res_2_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 2));
		return 23;

	case 0x97: // no_op_xx
		return 0;

	case 0x98: // no_op_xx
		return 0;

	case 0x99: // no_op_xx
		return 0;

	case 0x9A: // no_op_xx
		return 0;

	case 0x9B: // no_op_xx
		return 0;

	case 0x9C: // no_op_xx
		return 0;

	case 0x9D: // no_op_xx
		return 0;

	case 0x9E: // res_3_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 3));
		return 23;

	case 0x9F: // no_op_xx
		return 0;

	case 0xA0: // no_op_xx
		return 0;

	case 0xA1: // no_op_xx
		return 0;

	case 0xA2: // no_op_xx
		return 0;

	case 0xA3: // no_op_xx
		return 0;

	case 0xA4: // no_op_xx
		return 0;

	case 0xA5: // no_op_xx
		return 0;

	case 0xA6: // res_4_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 4));
		return 23;

	case 0xA7: // no_op_xx
		return 0;

	case 0xA8: // no_op_xx
		return 0;

	case 0xA9: // no_op_xx
		return 0;

	case 0xAA: // no_op_xx
		return 0;

	case 0xAB: // no_op_xx
		return 0;

	case 0xAC: // no_op_xx
		return 0;

	case 0xAD: // no_op_xx
		return 0;

	case 0xAE: // res_5_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 5));
		return 23;

	case 0xAF: // no_op_xx
		return 0;

	case 0xB0: // no_op_xx
		return 0;

	case 0xB1: // no_op_xx
		return 0;

	case 0xB2: // no_op_xx
		return 0;

	case 0xB3: // no_op_xx
		return 0;

	case 0xB4: // no_op_xx
		return 0;

	case 0xB5: // no_op_xx
		return 0;

	case 0xB6: // res_6_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 6));
		return 23;

	case 0xB7: // no_op_xx
		return 0;

	case 0xB8: // no_op_xx
		return 0;

	case 0xB9: // no_op_xx
		return 0;

	case 0xBA: // no_op_xx
		return 0;

	case 0xBB: // no_op_xx
		return 0;

	case 0xBC: // no_op_xx
		return 0;

	case 0xBD: // no_op_xx
		return 0;

	case 0xBE: // res_7_xiy
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 7));
		return 23;

	case 0xBF: // no_op_xx
		return 0;

	case 0xC0: // no_op_xx
		return 0;

	case 0xC1: // no_op_xx
		return 0;

	case 0xC2: // no_op_xx
		return 0;

	case 0xC3: // no_op_xx
		return 0;

	case 0xC4: // no_op_xx
		return 0;

	case 0xC5: // no_op_xx
		return 0;

	case 0xC6: // set_0_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 0));
		return 23;

	case 0xC7: // no_op_xx
		return 0;

	case 0xC8: // no_op_xx
		return 0;

	case 0xC9: // no_op_xx
		return 0;

	case 0xCA: // no_op_xx
		return 0;

	case 0xCB: // no_op_xx
		return 0;

	case 0xCC: // no_op_xx
		return 0;

	case 0xCD: // no_op_xx
		return 0;

	case 0xCE: // set_1_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 1));
		return 23;

	case 0xCF: // no_op_xx
		return 0;

	case 0xD0: // no_op_xx
		return 0;

	case 0xD1: // no_op_xx
		return 0;

	case 0xD2: // no_op_xx
		return 0;

	case 0xD3: // no_op_xx
		return 0;

	case 0xD4: // no_op_xx
		return 0;

	case 0xD5: // no_op_xx
		return 0;

	case 0xD6: // set_2_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 2));
		return 23;

	case 0xD7: // no_op_xx
		return 0;

	case 0xD8: // no_op_xx
		return 0;

	case 0xD9: // no_op_xx
		return 0;

	case 0xDA: // no_op_xx
		return 0;

	case 0xDB: // no_op_xx
		return 0;

	case 0xDC: // no_op_xx
		return 0;

	case 0xDD: // no_op_xx
		return 0;

	case 0xDE: // set_3_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 3));
		return 23;

	case 0xDF: // no_op_xx
		return 0;

	case 0xE0: // no_op_xx
		return 0;

	case 0xE1: // no_op_xx
		return 0;

	case 0xE2: // no_op_xx
		return 0;

	case 0xE3: // no_op_xx
		return 0;

	case 0xE4: // no_op_xx
		return 0;

	case 0xE5: // no_op_xx
		return 0;

	case 0xE6: // set_4_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 4));
		return 23;

	case 0xE7: // no_op_xx
		return 0;

	case 0xE8: // no_op_xx
		return 0;

	case 0xE9: // no_op_xx
		return 0;

	case 0xEA: // no_op_xx
		return 0;

	case 0xEB: // no_op_xx
		return 0;

	case 0xEC: // no_op_xx
		return 0;

	case 0xED: // no_op_xx
		return 0;

	case 0xEE: // set_5_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 5));
		return 23;

	case 0xEF: // no_op_xx
		return 0;

	case 0xF0: // no_op_xx
		return 0;

	case 0xF1: // no_op_xx
		return 0;

	case 0xF2: // no_op_xx
		return 0;

	case 0xF3: // no_op_xx
		return 0;

	case 0xF4: // no_op_xx
		return 0;

	case 0xF5: // no_op_xx
		return 0;

	case 0xF6: // set_6_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 6));
		return 23;

	case 0xF7: // no_op_xx
		return 0;

	case 0xF8: // no_op_xx
		return 0;

	case 0xF9: // no_op_xx
		return 0;

	case 0xFA: // no_op_xx
		return 0;

	case 0xFB: // no_op_xx
		return 0;

	case 0xFC: // no_op_xx
		return 0;

	case 0xFD: // no_op_xx
		return 0;

	case 0xFE: // set_7_xiy
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 7));
		return 23;

	case 0xFF: // no_op_x
		return 0;

	default:
		assert(false);
		return 0;
	}
}

/* ***************************************************************************
 * DDCB prefixed opcodes
 * ***************************************************************************
 */

int cpu_z80::HandleDDCB() {
	const uint16_t wAddr = m_regIX + (signed char)ImmedByte();
	const uint8_t bOpcode = ImmedByte();

	switch (bOpcode)
	{
	case 0x00: // no_op_xx
		return 0;

	case 0x01: // no_op_xx
		return 0;

	case 0x02: // no_op_xx
		return 0;

	case 0x03: // no_op_xx
		return 0;

	case 0x04: // no_op_xx
		return 0;

	case 0x05: // no_op_xx
		return 0;

	case 0x06: // rlc_xix
		MemWriteByte(wAddr, Rlc(MemReadByte(wAddr)));
		return 23;

	case 0x07: // no_op_xx
		return 0;

	case 0x08: // no_op_xx
		return 0;

	case 0x09: // no_op_xx
		return 0;

	case 0x0A: // no_op_xx
		return 0;

	case 0x0B: // no_op_xx
		return 0;

	case 0x0C: // no_op_xx
		return 0;

	case 0x0D: // no_op_xx
		return 0;

	case 0x0E: // rrc_xix
		MemWriteByte(wAddr, Rrc(MemReadByte(wAddr)));
		return 23;

	case 0x0F: // no_op_xx
		return 0;

	case 0x10: // no_op_xx
		return 0;

	case 0x11: // no_op_xx
		return 0;

	case 0x12: // no_op_xx
		return 0;

	case 0x13: // no_op_xx
		return 0;

	case 0x14: // no_op_xx
		return 0;

	case 0x15: // no_op_xx
		return 0;

	case 0x16: // rl_xix
		MemWriteByte(wAddr, Rl(MemReadByte(wAddr)));
		return 23;

	case 0x17: // no_op_xx
		return 0;

	case 0x18: // no_op_xx
		return 0;

	case 0x19: // no_op_xx
		return 0;

	case 0x1A: // no_op_xx
		return 0;

	case 0x1B: // no_op_xx
		return 0;

	case 0x1C: // no_op_xx
		return 0;

	case 0x1D: // no_op_xx
		return 0;

	case 0x1E: // rr_xix
		MemWriteByte(wAddr, Rr(MemReadByte(wAddr)));
		return 23;

	case 0x1F: // no_op_xx
		return 0;

	case 0x20: // no_op_xx
		return 0;

	case 0x21: // no_op_xx
		return 0;

	case 0x22: // no_op_xx
		return 0;

	case 0x23: // no_op_xx
		return 0;

	case 0x24: // no_op_xx
		return 0;

	case 0x25: // no_op_xx
		return 0;

	case 0x26: // sla_xix
		MemWriteByte(wAddr, Sla(MemReadByte(wAddr)));
		return 23;

	case 0x27: // no_op_xx
		return 0;

	case 0x28: // no_op_xx
		return 0;

	case 0x29: // no_op_xx
		return 0;

	case 0x2A: // no_op_xx
		return 0;

	case 0x2B: // no_op_xx
		return 0;

	case 0x2C: // no_op_xx
		return 0;

	case 0x2D: // no_op_xx
		return 0;

	case 0x2E: // sra_xix
		MemWriteByte(wAddr, Sra(MemReadByte(wAddr)));
		return 23;

	case 0x2F: // no_op_xx
		return 0;

	case 0x30: // no_op_xx
		return 0;

	case 0x31: // no_op_xx
		return 0;

	case 0x32: // no_op_xx
		return 0;

	case 0x33: // no_op_xx
		return 0;

	case 0x34: // no_op_xx
		return 0;

	case 0x35: // no_op_xx
		return 0;

	case 0x36: // sll_xix
		MemWriteByte(wAddr, Sll(MemReadByte(wAddr)));
		return 23;

	case 0x37: // no_op_xx
		return 0;

	case 0x38: // no_op_xx
		return 0;

	case 0x39: // no_op_xx
		return 0;

	case 0x3A: // no_op_xx
		return 0;

	case 0x3B: // no_op_xx
		return 0;

	case 0x3C: // no_op_xx
		return 0;

	case 0x3D: // no_op_xx
		return 0;

	case 0x3E: // srl_xix
		MemWriteByte(wAddr, Srl(MemReadByte(wAddr)));
		return 23;

	case 0x3F: // no_op_xx
		return 0;

	case 0x40: // bit_0_xix
	case 0x41: // bit_0_xix
	case 0x42: // bit_0_xix
	case 0x43: // bit_0_xix
	case 0x44: // bit_0_xix
	case 0x45: // bit_0_xix
	case 0x46: // bit_0_xix
	case 0x47: // bit_0_xix
		Bit(MemReadByte(wAddr), 0);
		return 20;

	case 0x48: // bit_1_xix
	case 0x49: // bit_1_xix
	case 0x4A: // bit_1_xix
	case 0x4B: // bit_1_xix
	case 0x4C: // bit_1_xix
	case 0x4D: // bit_1_xix
	case 0x4E: // bit_1_xix
	case 0x4F: // bit_1_xix
		Bit(MemReadByte(wAddr), 1);
		return 20;

	case 0x50: // bit_2_xix
	case 0x51: // bit_2_xix
	case 0x52: // bit_2_xix
	case 0x53: // bit_2_xix
	case 0x54: // bit_2_xix
	case 0x55: // bit_2_xix
	case 0x56: // bit_2_xix
	case 0x57: // bit_2_xix
		Bit(MemReadByte(wAddr), 2);
		return 20;

	case 0x58: // bit_3_xix
	case 0x59: // bit_3_xix
	case 0x5A: // bit_3_xix
	case 0x5B: // bit_3_xix
	case 0x5C: // bit_3_xix
	case 0x5D: // bit_3_xix
	case 0x5E: // bit_3_xix
	case 0x5F: // bit_3_xix
		Bit(MemReadByte(wAddr), 3);
		return 20;

	case 0x60: // bit_4_xix
	case 0x61: // bit_4_xix
	case 0x62: // bit_4_xix
	case 0x63: // bit_4_xix
	case 0x64: // bit_4_xix
	case 0x65: // bit_4_xix
	case 0x66: // bit_4_xix
	case 0x67: // bit_4_xix
		Bit(MemReadByte(wAddr), 4);
		return 20;

	case 0x68: // bit_5_xix
	case 0x69: // bit_5_xix
	case 0x6A: // bit_5_xix
	case 0x6B: // bit_5_xix
	case 0x6C: // bit_5_xix
	case 0x6D: // bit_5_xix
	case 0x6E: // bit_5_xix
	case 0x6F: // bit_5_xix
		Bit(MemReadByte(wAddr), 5);
		return 20;

	case 0x70: // bit_6_xix
	case 0x71: // bit_6_xix
	case 0x72: // bit_6_xix
	case 0x73: // bit_6_xix
	case 0x74: // bit_6_xix
	case 0x75: // bit_6_xix
	case 0x76: // bit_6_xix
	case 0x77: // bit_6_xix
		Bit(MemReadByte(wAddr), 6);
		return 20;

	case 0x78: // bit_7_xix
	case 0x79: // bit_7_xix
	case 0x7A: // bit_7_xix
	case 0x7B: // bit_7_xix
	case 0x7C: // bit_7_xix
	case 0x7D: // bit_7_xix
	case 0x7E: // bit_7_xix
	case 0x7F: // bit_7_xix
		Bit(MemReadByte(wAddr), 7);
		return 20;

	case 0x80: // no_op_xx
		return 0;

	case 0x81: // no_op_xx
		return 0;

	case 0x82: // no_op_xx
		return 0;

	case 0x83: // no_op_xx
		return 0;

	case 0x84: // no_op_xx
		return 0;

	case 0x85: // no_op_xx
		return 0;

	case 0x86: // res_0_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 0));
		return 23;

	case 0x87: // no_op_xx
		return 0;

	case 0x88: // no_op_xx
		return 0;

	case 0x89: // no_op_xx
		return 0;

	case 0x8A: // no_op_xx
		return 0;

	case 0x8B: // no_op_xx
		return 0;

	case 0x8C: // no_op_xx
		return 0;

	case 0x8D: // no_op_xx
		return 0;

	case 0x8E: // res_1_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 1));
		return 23;

	case 0x8F: // no_op_xx
		return 0;

	case 0x90: // no_op_xx
		return 0;

	case 0x91: // no_op_xx
		return 0;

	case 0x92: // no_op_xx
		return 0;

	case 0x93: // no_op_xx
		return 0;

	case 0x94: // no_op_xx
		return 0;

	case 0x95: // no_op_xx
		return 0;

	case 0x96: // res_2_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 2));
		return 23;

	case 0x97: // no_op_xx
		return 0;

	case 0x98: // no_op_xx
		return 0;

	case 0x99: // no_op_xx
		return 0;

	case 0x9A: // no_op_xx
		return 0;

	case 0x9B: // no_op_xx
		return 0;

	case 0x9C: // no_op_xx
		return 0;

	case 0x9D: // no_op_xx
		return 0;

	case 0x9E: // res_3_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 3));
		return 23;

	case 0x9F: // no_op_xx
		return 0;

	case 0xA0: // no_op_xx
		return 0;

	case 0xA1: // no_op_xx
		return 0;

	case 0xA2: // no_op_xx
		return 0;

	case 0xA3: // no_op_xx
		return 0;

	case 0xA4: // no_op_xx
		return 0;

	case 0xA5: // no_op_xx
		return 0;

	case 0xA6: // res_4_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 4));
		return 23;

	case 0xA7: // no_op_xx
		return 0;

	case 0xA8: // no_op_xx
		return 0;

	case 0xA9: // no_op_xx
		return 0;

	case 0xAA: // no_op_xx
		return 0;

	case 0xAB: // no_op_xx
		return 0;

	case 0xAC: // no_op_xx
		return 0;

	case 0xAD: // no_op_xx
		return 0;

	case 0xAE: // res_5_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 5));
		return 23;

	case 0xAF: // no_op_xx
		return 0;

	case 0xB0: // no_op_xx
		return 0;

	case 0xB1: // no_op_xx
		return 0;

	case 0xB2: // no_op_xx
		return 0;

	case 0xB3: // no_op_xx
		return 0;

	case 0xB4: // no_op_xx
		return 0;

	case 0xB5: // no_op_xx
		return 0;

	case 0xB6: // res_6_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 6));
		return 23;

	case 0xB7: // no_op_xx
		return 0;

	case 0xB8: // no_op_xx
		return 0;

	case 0xB9: // no_op_xx
		return 0;

	case 0xBA: // no_op_xx
		return 0;

	case 0xBB: // no_op_xx
		return 0;

	case 0xBC: // no_op_xx
		return 0;

	case 0xBD: // no_op_xx
		return 0;

	case 0xBE: // res_7_xix
		MemWriteByte(wAddr, Res(MemReadByte(wAddr), 7));
		return 23;

	case 0xBF: // no_op_xx
		return 0;

	case 0xC0: // no_op_xx
		return 0;

	case 0xC1: // no_op_xx
		return 0;

	case 0xC2: // no_op_xx
		return 0;

	case 0xC3: // no_op_xx
		return 0;

	case 0xC4: // no_op_xx
		return 0;

	case 0xC5: // no_op_xx
		return 0;

	case 0xC6: // set_0_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 0));
		return 23;

	case 0xC7: // no_op_xx
		return 0;

	case 0xC8: // no_op_xx
		return 0;

	case 0xC9: // no_op_xx
		return 0;

	case 0xCA: // no_op_xx
		return 0;

	case 0xCB: // no_op_xx
		return 0;

	case 0xCC: // no_op_xx
		return 0;

	case 0xCD: // no_op_xx
		return 0;

	case 0xCE: // set_1_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 1));
		return 23;

	case 0xCF: // no_op_xx
		return 0;

	case 0xD0: // no_op_xx
		return 0;

	case 0xD1: // no_op_xx
		return 0;

	case 0xD2: // no_op_xx
		return 0;

	case 0xD3: // no_op_xx
		return 0;

	case 0xD4: // no_op_xx
		return 0;

	case 0xD5: // no_op_xx
		return 0;

	case 0xD6: // set_2_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 2));
		return 23;

	case 0xD7: // no_op_xx
		return 0;

	case 0xD8: // no_op_xx
		return 0;

	case 0xD9: // no_op_xx
		return 0;

	case 0xDA: // no_op_xx
		return 0;

	case 0xDB: // no_op_xx
		return 0;

	case 0xDC: // no_op_xx
		return 0;

	case 0xDD: // no_op_xx
		return 0;

	case 0xDE: // set_3_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 3));
		return 23;

	case 0xDF: // no_op_xx
		return 0;

	case 0xE0: // no_op_xx
		return 0;

	case 0xE1: // no_op_xx
		return 0;

	case 0xE2: // no_op_xx
		return 0;

	case 0xE3: // no_op_xx
		return 0;

	case 0xE4: // no_op_xx
		return 0;

	case 0xE5: // no_op_xx
		return 0;

	case 0xE6: // set_4_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 4));
		return 23;

	case 0xE7: // no_op_xx
		return 0;

	case 0xE8: // no_op_xx
		return 0;

	case 0xE9: // no_op_xx
		return 0;

	case 0xEA: // no_op_xx
		return 0;

	case 0xEB: // no_op_xx
		return 0;

	case 0xEC: // no_op_xx
		return 0;

	case 0xED: // no_op_xx
		return 0;

	case 0xEE: // set_5_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 5));
		return 23;

	case 0xEF: // no_op_xx
		return 0;

	case 0xF0: // no_op_xx
		return 0;

	case 0xF1: // no_op_xx
		return 0;

	case 0xF2: // no_op_xx
		return 0;

	case 0xF3: // no_op_xx
		return 0;

	case 0xF4: // no_op_xx
		return 0;

	case 0xF5: // no_op_xx
		return 0;

	case 0xF6: // set_6_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 6));
		return 23;

	case 0xF7: // no_op_xx
		return 0;

	case 0xF8: // no_op_xx
		return 0;

	case 0xF9: // no_op_xx
		return 0;

	case 0xFA: // no_op_xx
		return 0;

	case 0xFB: // no_op_xx
		return 0;

	case 0xFC: // no_op_xx
		return 0;

	case 0xFD: // no_op_xx
		return 0;

	case 0xFE: // set_7_xix
		MemWriteByte(wAddr, Set(MemReadByte(wAddr), 7));
		return 23;

	case 0xFF: // no_op_x
		return 0;

	default:
		assert(false);
		return 0;
	}
}

cpu_z80::~cpu_z80()
{
}

UINT32 cpu_z80::mz80GetElapsedTicks(UINT32 dwClearIt)
{
	UINT32 dwTempVar = 0;

	dwTempVar = dwElapsedTicks;
	if (dwClearIt)
		dwElapsedTicks = 0;
	return(dwTempVar);
}

void cpu_z80::mz80ReleaseTimeslice()
{
	cCycles = 0;
}

/*
* alt daa pseudocode
tmp: = a,
if nf then
if hf or [a AND 0x0f > 9] then tmp -= 0x06
if cf or [a > 0x99] then tmp -= 0x60
else
if hf or [a AND 0x0f > 9] then tmp += 0x06
if cf or [a > 0x99] then tmp += 0x60
endif,
tmp = > flags, cf : = cf OR[a > 0x99],
hf : = a.4 XOR tmp.4, a : = tmp
*/
",wVal
519,"//=================================================================================================
//								1. ФУНКЦИЯ ПОЛУЧЕНИЯ ИМЕН ПИНОВ (ESP8266,ESP32 и др.)
//=================================================================================================
String getNamePin(uint8_t pin){									//==Возвращает номера пина в текстовой форме (с учетом ESP8266, STM32);
#if !defined(RT_HM_COREM)				//==Резервирование для многоядерных контроллеров;
  uint8_t  i,j;
  char      [MASK] ;
#endif
(void)i; (void)j; (void) [MASK] ; 
//-------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------
#if   defined(RT_HW_CORE_ESP8266)	
if(pin==16) {return String(F(""D0""));}
if(pin== 5) {return String(F(""D1""));}
if(pin== 4) {return String(F(""D2""));}
if(pin== 0) {return String(F(""D3""));}
if(pin== 2) {return String(F(""D4""));}
if(pin==14) {return String(F(""D5""));}
if(pin==12) {return String(F(""D6""));}
if(pin==13) {return String(F(""D7""));}
if(pin==15) {return String(F(""D8""));}
if(pin== 3) {return String(F(""D9""));}
if(pin== 1) {return String(F(""D10""));}
if(pin==17) {return String(F(""A0""));}
if(pin==3)	{return String(F(""RX""));}
if(pin==1)  {return String(F(""TX""));}
if(pin==3)	{return String(F(""RX""));}
if(pin==1)	{return String(F(""TX""));}
if(pin==2)	{return String(F(""TX1""));}
if(pin==13) {return String(F(""RX2""));}
if(pin==15) {return String(F(""TX2""));}
if(pin>=255){return String(F("" * ""));}
return (String(F(""*""))+String(pin));		 
#endif
//-------------------------------------------------------------------------------------------------
#if defined(RT_HW_CORE_STM32)				 
if(pin>=254) {                     mess.str=String(' '); mess.str+=String('*'); 						return mess.str;}	
for(i=0; i<=8; i++){ [MASK] =char(((uint8_t)'A')+i); for(j=0; j<16; j++){
 if(getNumPinSTM32( [MASK] ,j)==pin) {mess.str=String('P'); mess.str+=String( [MASK] ); mess.str+=String(j); 	return mess.str;}}
                                 mess.str=String('P'); mess.str+=String('='); mess.str+=String(pin);	return mess.str;}
return (String(F(""P=""))+String(pin));
#endif
//-------------------------------------------------------------------------------------------------
return String(pin);		
};
//=================================================================================================
//							2. ФУНКЦИЯ ПОЛУЧЕНИЯ НОМЕРОВ ПИНОВ  (STM32)
//=================================================================================================
uint8_t getNumPinSTM32(char reg, uint8_t num){ 	//==Возвращает номер пина по регистру reg(A,B,C,D,E,F,G) и номеру num(0-15). Если отсутствует, возвращает -1;                                       
#if defined(RT_HW_CORE_STM32)	
//===============================================
if(reg=='A'){
//-----------------------------------------------
if(num==0){
#if defined(PA0)
return PA0;
#endif
}//----------------------------------------------
if(num==1){
#if defined(PA1)
return PA1;
#endif
}//----------------------------------------------
if(num==2){
#if defined(PA2)
return PA2; 
#endif
}//----------------------------------------------
if(num==3){
#if defined(PA3)
return PA3; 
#endif
}//-----------------------------------------------
if(num==4){
#if defined(PA4)
return PA4; 
#endif
}//-----------------------------------------------
if(num==5){
#if defined(PA5)
return PA5; 
#endif
}//-----------------------------------------------
if(num==6){
#if defined(PA6)
return PA6; 
#endif
}//-----------------------------------------------
if(num==7){
#if defined(PA7)
return PA7; 
#endif
}//----------------------------------------------
if(num==8){
#if defined(PA8)
return PA8;
#endif
}//----------------------------------------------
if(num==9){
#if defined(PA9)
return PA9;
#endif
}//----------------------------------------------
if(num==10){
#if defined(PA10)
return PA10; 
#endif
}//----------------------------------------------
if(num==11){
#if defined(PA11)
return PA11; 
#endif
}//-----------------------------------------------
if(num==12){
#if defined(PA12)
return PA12; 
#endif
}//-----------------------------------------------
if(num==13){
#if defined(PA13)
return PA13; 
#endif
}//-----------------------------------------------
if(num==14){
#if defined(PA14)
return PA14; 
#endif
}//-----------------------------------------------
if(num==15){
#if defined(PA15)
return PA15; 
#endif
}
} // END PA ---и т.д. 0-15;
//===============================================
if(reg=='B'){
//-----------------------------------------------
if(num==0){
#if defined(PB0)
return PB0;
#endif
}//----------------------------------------------
if(num==1){
#if defined(PB1)
return PB1;
#endif
}//----------------------------------------------
if(num==2){
#if defined(PB2)
return PB2; 
#endif
}//----------------------------------------------
if(num==3){
#if defined(PB3)
return PB3; 
#endif
}//-----------------------------------------------
if(num==4){
#if defined(PB4)
return PB4; 
#endif
}//-----------------------------------------------
if(num==5){
#if defined(PB5)
return PB5; 
#endif
}//-----------------------------------------------
if(num==6){
#if defined(PB6)
return PB6; 
#endif
}//-----------------------------------------------
if(num==7){
#if defined(PB7)
return PB7; 
#endif
}//----------------------------------------------
if(num==8){
#if defined(PB8)
return PB8;
#endif
}//----------------------------------------------
if(num==9){
#if defined(PB9)
return PB9;
#endif
}//----------------------------------------------
if(num==10){
#if defined(PB10)
return PB10; 
#endif
}//----------------------------------------------
if(num==11){
#if defined(PB11)
return PB11; 
#endif
}//-----------------------------------------------
if(num==12){
#if defined(PB12)
return PB12; 
#endif
}//-----------------------------------------------
if(num==13){
#if defined(PB13)
return PB13; 
#endif
}//-----------------------------------------------
if(num==14){
#if defined(PB14)
return PB14; 
#endif
}//-----------------------------------------------
if(num==15){
#if defined(PB15)
return PB15; 
#endif
}
}	// END PB ---и т.д. 0-15;
//===============================================
if(reg=='C'){
//-----------------------------------------------
if(num==0){
#if defined(PC0)
return PC0;
#endif
}//----------------------------------------------
if(num==1){
#if defined(PC1)
return PC1;
#endif
}//----------------------------------------------
if(num==2){
#if defined(PC2)
return PC2; 
#endif
}//----------------------------------------------
if(num==3){
#if defined(PC3)
return PC3; 
#endif
}//-----------------------------------------------
if(num==4){
#if defined(PC4)
return PC4; 
#endif
}//-----------------------------------------------
if(num==5){
#if defined(PC5)
return PC5; 
#endif
}//-----------------------------------------------
if(num==6){
#if defined(PC6)
return PC6; 
#endif
}//-----------------------------------------------
if(num==7){
#if defined(PC7)
return PC7; 
#endif
}//----------------------------------------------
if(num==8){
#if defined(PC8)
return PC8;
#endif
}//----------------------------------------------
if(num==9){
#if defined(PC9)
return PC9;
#endif
}//----------------------------------------------
if(num==10){
#if defined(PC10)
return PC10; 
#endif
}//----------------------------------------------
if(num==11){
#if defined(PC11)
return PC11; 
#endif
}//-----------------------------------------------
if(num==12){
#if defined(PC12)
return PC12; 
#endif
}//-----------------------------------------------
if(num==13){
#if defined(PC13)
return PC13; 
#endif
}//-----------------------------------------------
if(num==14){
#if defined(PC14)
return PC14; 
#endif
}//-----------------------------------------------
if(num==15){
#if defined(PC15)
return PC15; 
#endif
}}// END PC ---и т.д. 0-15;
//===============================================
if(reg=='D'){
//-----------------------------------------------
if(num==0){
#if defined(PD0)
return PD0;
#endif
}//----------------------------------------------
if(num==1){
#if defined(PD1)
return PD1;
#endif
}//----------------------------------------------
if(num==2){
#if defined(PD2)
return PD2; 
#endif
}//----------------------------------------------
if(num==3){
#if defined(PD3)
return PD3; 
#endif
}//-----------------------------------------------
if(num==4){
#if defined(PD4)
return PD4; 
#endif
}//-----------------------------------------------
if(num==5){
#if defined(PD5)
return PD5; 
#endif
}//-----------------------------------------------
if(num==6){
#if defined(PD6)
return PD6; 
#endif
}//-----------------------------------------------
if(num==7){
#if defined(PD7)
return PD7; 
#endif
}//----------------------------------------------
if(num==8){
#if defined(PD8)
return PD8;
#endif
}//----------------------------------------------
if(num==9){
#if defined(PD9)
return PD9;
#endif
}//----------------------------------------------
if(num==10){
#if defined(PD10)
return PD10; 
#endif
}//----------------------------------------------
if(num==11){
#if defined(PD11)
return PD11; 
#endif
}//-----------------------------------------------
if(num==12){
#if defined(PD12)
return PD12; 
#endif
}//-----------------------------------------------
if(num==13){
#if defined(PD13)
return PD13; 
#endif
}//-----------------------------------------------
if(num==14){
#if defined(PD14)
return PD14; 
#endif
}//-----------------------------------------------
if(num==15){
#if defined(PD15)
return PD15; 
#endif
}}// END PD ---и т.д. 0-15;
//===============================================
if(reg=='E'){
//-----------------------------------------------
if(num==0){
#if defined(PE0)
return PE0;
#endif
}//----------------------------------------------
if(num==1){
#if defined(PE1)
return PE1;
#endif
}//----------------------------------------------
if(num==2){
#if defined(PE2)
return PE2; 
#endif
}//----------------------------------------------
if(num==3){
#if defined(PE3)
return PE3; 
#endif
}//-----------------------------------------------
if(num==4){
#if defined(PE4)
return PE4; 
#endif
}//-----------------------------------------------
if(num==5){
#if defined(PE5)
return PE5; 
#endif
}//-----------------------------------------------
if(num==6){
#if defined(PE6)
return PE6; 
#endif
}//-----------------------------------------------
if(num==7){
#if defined(PE7)
return PE7; 
#endif
}//----------------------------------------------
if(num==8){
#if defined(PE8)
return PE8;
#endif
}//----------------------------------------------
if(num==9){
#if defined(PE9)
return PE9;
#endif
}//----------------------------------------------
if(num==10){
#if defined(PE10)
return PE10; 
#endif
}//----------------------------------------------
if(num==11){
#if defined(PE11)
return PE11; 
#endif
}//-----------------------------------------------
if(num==12){
#if defined(PE12)
return PE12; 
#endif
}//-----------------------------------------------
if(num==13){
#if defined(PE13)
return PE13; 
#endif
}//-----------------------------------------------
if(num==14){
#if defined(PE14)
return PE14; 
#endif
}//-----------------------------------------------
if(num==15){
#if defined(PE15)
return PE15; 
#endif
}}	//--END PE ---и т.д. 0-15;
//===============================================
if(reg=='F'){
//-----------------------------------------------
if(num==0){
#if defined(PF0)
return PF0;
#endif
}//----------------------------------------------
if(num==1){
#if defined(PF1)
return PF1;
#endif
}//----------------------------------------------
if(num==2){
#if defined(PF2)
return PF2; 
#endif
}//----------------------------------------------
if(num==3){
#if defined(PF3)
return PF3; 
#endif
}//-----------------------------------------------
if(num==4){
#if defined(PF4)
return PF4; 
#endif
}//-----------------------------------------------
if(num==5){
#if defined(PF5)
return PF5; 
#endif
}//-----------------------------------------------
if(num==6){
#if defined(PF6)
return PF6; 
#endif
}//-----------------------------------------------
if(num==7){
#if defined(PF7)
return PF7; 
#endif
}//----------------------------------------------
if(num==8){
#if defined(PF8)
return PF8;
#endif
}//----------------------------------------------
if(num==9){
#if defined(PF9)
return PF9;
#endif
}//----------------------------------------------
if(num==10){
#if defined(PF10)
return PF10; 
#endif
}//----------------------------------------------
if(num==11){
#if defined(PF11)
return PF11; 
#endif
}//-----------------------------------------------
if(num==12){
#if defined(PF12)
return PF12; 
#endif
}//-----------------------------------------------
if(num==13){
#if defined(PF13)
return PF13; 
#endif
}//-----------------------------------------------
if(num==14){
#if defined(PF14)
return PF14; 
#endif
}//-----------------------------------------------
if(num==15){
#if defined(PF15)
return PF15; 
#endif
}}	//--END PF ---и т.д. 0-15;
//===============================================
if(reg=='G'){
//-----------------------------------------------
if(num==0){
#if defined(PG0)
return PG0;
#endif
}//----------------------------------------------
if(num==1){
#if defined(PG1)
return PG1;
#endif
}//----------------------------------------------
if(num==2){
#if defined(PG2)
return PG2; 
#endif
}//----------------------------------------------
if(num==3){
#if defined(PG3)
return PG3; 
#endif
}//-----------------------------------------------
if(num==4){
#if defined(PG4)
return PG4; 
#endif
}//-----------------------------------------------
if(num==5){
#if defined(PG5)
return PG5; 
#endif
}//-----------------------------------------------
if(num==6){
#if defined(PG6)
return PG6; 
#endif
}//-----------------------------------------------
if(num==7){
#if defined(PG7)
return PG7; 
#endif
}//----------------------------------------------
if(num==8){
#if defined(PG8)
return PG8;
#endif
}//----------------------------------------------
if(num==9){
#if defined(PG9)
return PG9;
#endif
}//----------------------------------------------
if(num==10){
#if defined(PG10)
return PG10; 
#endif
}//----------------------------------------------
if(num==11){
#if defined(PG11)
return PG11; 
#endif
}//-----------------------------------------------
if(num==12){
#if defined(PG12)
return PG12; 
#endif
}//-----------------------------------------------
if(num==13){
#if defined(PG13)
return PG13; 
#endif
}//-----------------------------------------------
if(num==14){
#if defined(PG14)
return PG14; 
#endif
}//-----------------------------------------------
if(num==15){
#if defined(PG15)
return PG15; 
#endif
}}	//--END PG ---и т.д. 0-15;
#endif   		//--END #if defined(RT_HW_ARCH_STM32DUINO) 
//================================================
if((reg>'G') || (num>15)) {return 255;}	//--Защита от предупреждений компилятора;
return 255;};	//--END getNumPinSTM32(char reg, uint8_t num)
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
",chr
520,"#include <numbers>
#include <cmath>
#include <complex>
#include <boost/multiprecision/mpc.hpp>
#include <boost/math/distributions/normal.hpp>
#include <algorithm>
using namespace boost::multiprecision;
using namespace boost::math::constants;
namespace zeta
{
    mpc_complex zetafast(mpc_complex s, mpfr_float accuracy);
    mpc_complex zetaAMTCT(mpc_complex s, int d);
    mpc_complex zetaNA(mpc_complex s, int d, int m, int j);
}
namespace utils
{
    inline mpc_complex compute_sum(std::function<mpc_complex(int n)> function, mpfr_float  [MASK] )
    {
      int n = 1;
      mpc_complex computed_sum;
      mpc_complex previous_sum;
      while ((abs(computed_sum-previous_sum).real() >  [MASK]  and abs(computed_sum-previous_sum).imag() >  [MASK] ) or n == 1)
      {
        previous_sum = computed_sum;
        computed_sum += function(n);
        n=n+1;
      }
      return computed_sum;
    }
    inline mpc_complex computeBinomialCoefficient(mpc_complex n, int k) {
        if (n == k || k == 0) {
            return 1;
        }
        mpc_complex out = n - k + 1;
        for (int i = 1; i < k; ++i) {
            out = out * (n - k + 1 + i) / (i + 1);
        }
        return out;
    }
    static const int g=7;
    static const double p[g+2] = {0.99999999999980993, 676.5203681218851,
    -1259.1392167224028, 771.32342877765313, -176.61502916214059,
    12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6,
    1.5056327351493116e-7};

    inline mpc_complex gamma(mpc_complex s)
    {
        if ( s.real()<0.5 ) {
            return pi<mpf_float>() / (sin(pi<mpf_float>()* s)*gamma(1.0-s));
        }
        s--;
        mpc_complex x = p[0];
        for (int i=1; i<g+2; i++) {
            x += p[i]/(s+mpc_complex(i,0));
        }
        mpc_complex t = s + (g + 0.5);
            return sqrt(2*pi<mpf_float>()) * pow(t,s + 0.5) * exp(-t) * x;
    }
}",tolerance
521,"/*
 * Copyright 2015-2019 Autoware Foundation. 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 <ros/ros.h>
#include <autoware_msgs/LaneArray.h>
#include ""waypoint_replanner.h""

namespace waypoint_maker
{
#define __APP_NAME__ ""waypoint_replanner""
class WaypointReplannerNode
{
public:
  WaypointReplannerNode();
private:
  ros::NodeHandle nh_;
  ros::NodeHandle pnh_;
  ros::Publisher lane_pub_;
  ros::Subscriber lane_sub_, config_sub_;
  bool replanning_mode_, realtime_tuning_mode_;
  bool is_first_publish_;
  WaypointReplanner replanner_;
  autoware_msgs::LaneArray lane_array_;
  void replan(autoware_msgs::LaneArray &lane_array);
  void publishLaneArray();
  void laneCallback(const autoware_msgs::LaneArray::ConstPtr& lane_array);
  void configCallback(const autoware_config_msgs::ConfigWaypointReplanner::ConstPtr& conf);
  autoware_config_msgs::ConfigWaypointReplanner startup_config;
  bool use_decision_maker_;
};

WaypointReplannerNode::WaypointReplannerNode() : pnh_(""~""), is_first_publish_(true)
{
ROS_INFO(""[%s] --> WaypointReplannerNode constructor"", __APP_NAME__);
  WaypointReplannerConfig temp_config;

  double  [MASK] , velocity_min_kph;

  pnh_.param<bool>(""replanning_mode"", replanning_mode_, false);
  pnh_.param<bool>(""realtime_tuning_mode"", realtime_tuning_mode_, true);
  pnh_.param<double>(""velocity_max"",  [MASK] , 0.0);
  pnh_.param<double>(""velocity_min"", velocity_min_kph, 0.0);
  pnh_.param<double>(""accel_limit"", temp_config.accel_limit, 0.0);
  pnh_.param<double>(""decel_limit"", temp_config.decel_limit, 0.0);
  pnh_.param<double>(""lateral_accel_limit"", temp_config.lateral_accel_limit, 0.0);
  pnh_.param<double>(""radius_min"", temp_config.radius_min, 0.0);
  pnh_.param<bool>(""resample_mode"", temp_config.resample_mode, false);
  pnh_.param<double>(""resample_interval"", temp_config.resample_interval, 0.0);
  pnh_.param<bool>(""replan_curve_mode"", temp_config.replan_curve_mode, false);
  pnh_.param<bool>(""replan_endpoint_mode"", temp_config.replan_endpoint_mode, false);
  pnh_.param<bool>(""use_decision_maker"", use_decision_maker_, false);

  temp_config.velocity_max = kmph2mps( [MASK] );
  temp_config.velocity_min = kmph2mps(velocity_min_kph);

  replanner_.updateConfig(temp_config);

  if (use_decision_maker_)
  {
    lane_pub_ = nh_.advertise<autoware_msgs::LaneArray>(""/based/lane_waypoints_array"", 10, true);
  }
  else
  {
    lane_pub_ = nh_.advertise<autoware_msgs::LaneArray>(""/lane_waypoints_array"", 10, true);
  }

  lane_sub_ = nh_.subscribe(""/based/lane_waypoints_raw"", 1, &WaypointReplannerNode::laneCallback, this);
  config_sub_ = nh_.subscribe(""/config/waypoint_replanner"", 1, &WaypointReplannerNode::configCallback, this);
ROS_INFO(""[%s] <-- WaypointReplannerNode constructor"", __APP_NAME__);
}

void WaypointReplannerNode::replan(autoware_msgs::LaneArray& lane_array)
{
ROS_INFO(""[%s] --> WaypointReplannerNode replan"", __APP_NAME__);
  for (auto &el : lane_array.lanes)
  {
    replanner_.replanLaneWaypointVel(el);
  }
ROS_INFO(""[%s] <-- WaypointReplannerNode replan"", __APP_NAME__);
}

void WaypointReplannerNode::publishLaneArray()
{
ROS_INFO(""[%s] --> WaypointReplannerNode publishLaneArray"", __APP_NAME__);
  autoware_msgs::LaneArray array(lane_array_);

  if (replanning_mode_)
  {
    replan(array);
  }    

  lane_pub_.publish(array);
  is_first_publish_ = false;
ROS_INFO(""[%s] <-- WaypointReplannerNode publishLaneArray"", __APP_NAME__);
}

void WaypointReplannerNode::laneCallback(const autoware_msgs::LaneArray::ConstPtr& lane_array)
{
ROS_INFO(""[%s] --> WaypointReplannerNode laneCallback"", __APP_NAME__);
  lane_array_ = *lane_array;
  publishLaneArray();
ROS_INFO(""[%s] <-- WaypointReplannerNode laneCallback"", __APP_NAME__);
}

void WaypointReplannerNode::configCallback(const autoware_config_msgs::ConfigWaypointReplanner::ConstPtr& conf)
{
ROS_INFO(""[%s] --> WaypointReplannerNode configCallback"", __APP_NAME__);
  replanning_mode_ = conf->replanning_mode;
  realtime_tuning_mode_ = conf->realtime_tuning_mode;
  use_decision_maker_ = conf->use_decision_maker;
  replanner_.initParameter(conf);
  if (!lane_array_.lanes.empty() && (is_first_publish_ || realtime_tuning_mode_))
  {
    publishLaneArray();
  }
ROS_INFO(""[%s] <-- WaypointReplannerNode configCallback"", __APP_NAME__);
}

}

int main(int argc, char** argv)
{
ROS_INFO(""[%s] ros::init"", __APP_NAME__);
  ros::init(argc, argv, ""waypoint_replanner"");
ROS_INFO(""[%s] WaypointReplannerNode construct"", __APP_NAME__);
  waypoint_maker::WaypointReplannerNode wr;
ROS_INFO(""[%s] ros::spin"", __APP_NAME__);
  ros::spin();

  return 0;
}
",velocity_max_kph
522,"#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

// constant
const char* ssid = ""WiFi's Name"";
const char* password = ""<PASSWORD>"";
const char* mqtt_server = ""betterlight.local"";
const int mqtt_port = 1883;
const char* mqtt_username = """";
const char* mqtt_password = """";
const char* client_name = ""esp32"";
const char* main_topic = ""betterlight"";
WiFiClient client;
PubSubClient mqtt(client);

const unsigned int debounceDelay = 50;
const unsigned int analogDelay = 50;
const unsigned int analogIgnoreRange = 100;
const int cap = JSON_ARRAY_SIZE(7) + 7*JSON_OBJECT_SIZE(5);

// variable
StaticJsonDocument<cap> doc;

unsigned int button1_pressTime = 0;
unsigned int button2_pressTime = 0;
unsigned int button3_pressTime = 0;
unsigned int button4_pressTime = 0;
unsigned int slider1_slideTime = 0;
unsigned int slider2_slideTime = 0;
unsigned int slider3_slideTime = 0;

void setup() {
  Serial.begin(115200);

  // Set up JSON
  doc[0][""type""] = ""Button 1"";
  doc[0][""pin""] = 18;
  doc[0][""current""] = 0;
  doc[0][""prev""] = 0;
  doc[0][""mode""] = 0;

  doc[1][""type""] = ""Button 2"";
  doc[1][""pin""] = 23;
  doc[1][""current""] = 0;
  doc[1][""prev""] = 0;
  doc[1][""mode""] = 0;

  doc[2][""type""] = ""Button 3"";
  doc[2][""pin""] = 19;
  doc[2][""current""] = 0;
  doc[2][""prev""] = 0;
  doc[2][""mode""] = 0;

  doc[3][""type""] = ""Button 4"";
  doc[3][""pin""] = 22;
  doc[3][""current""] = 0;
  doc[3][""prev""] = 0;
  doc[3][""mode""] = 0;

  doc[4][""type""] = ""Slider 1"";
  doc[4][""pin""] = 25;
  doc[4][""current""] = 0;
  doc[4][""prev""] = 0;
  doc[4][""mode""] = 0;

  doc[5][""type""] = ""Slider 2"";
  doc[5][""pin""] = 33;
  doc[5][""current""] = 0;
  doc[5][""prev""] = 0;
  doc[5][""mode""] = 0;

  doc[6][""type""] = ""Slider 3"";
  doc[6][""pin""] = 32;
  doc[6][""current""] = 0;
  doc[6][""prev""] = 0;
  doc[6][""mode""] = 0;
  
  // Set up PIN
  pinMode(doc[0][""pin""].as<int>(), INPUT_PULLUP);
  pinMode(doc[1][""pin""].as<int>(), INPUT_PULLUP);
  pinMode(doc[2][""pin""].as<int>(), INPUT_PULLUP);
  pinMode(doc[3][""pin""].as<int>(), INPUT_PULLUP);
  pinMode(doc[4][""pin""].as<int>(), INPUT);
  pinMode(doc[5][""pin""].as<int>(), INPUT);
  pinMode(doc[6][""pin""].as<int>(), INPUT);

  // Set up Time
  button1_pressTime = millis();
  button2_pressTime = millis();
  button3_pressTime = millis();
  button4_pressTime = millis();
  slider1_slideTime = millis();
  slider2_slideTime = millis();
  slider3_slideTime = millis();
  
  WiFi_connect();
  MQTTBroker_connect();
}

void WiFi_connect() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(""."");
    delay(100);
  }

  Serial.println(""\nConnected to WiFi"");
  Serial.print(""IP Address: "");
  Serial.println(WiFi.localIP());
}

void MQTTBroker_connect() {
  Serial.println(""Start MQTT Connection Procedure."");
  mqtt.setServer(mqtt_server, mqtt_port);
  mqtt.setCallback(callback);
  mqtt.connect(client_name, mqtt_username, mqtt_password);

  if (mqtt.connected()) {
    Serial.println(""Connect to MQTT Broker."");
  }
  while (!mqtt.connected()) {
    Serial.println(""Connecting to MQTT Broker..."");
    if (mqtt.connect(client_name)) {
      Serial.println(""Connect to MQTT Broker."");
    }
    else {
      Serial.print(""Failed with state "");
      Serial.print(mqtt.state());
      Serial.print("" "");
      delay(2000);
    }
  }

  for (int i = 0; i < 7; i++) {
    mqtt.subscribe(
      (String(main_topic) + ""/"" + String(doc[i][""type""].as<const char*>())).c_str()
    );
  }
  Serial.println(""End MQTT Connection Procedure."");
}

void callback(char* topic, byte* payload, unsigned int length) {
  StaticJsonDocument<cap>  [MASK] ;
  deserializeJson( [MASK] , payload, length);
}

void loop() {
  if (!mqtt.connected()) {
    MQTTBroker_connect();
  }
  if (WiFi.status() != WL_CONNECTED) {
    WiFi_connect();
  }

  // button1
  doc[0][""current""] = digitalRead(doc[0][""pin""].as<int>());
  if (doc[0][""current""].as<int>() != doc[0][""prev""].as<int>()) {
    if (millis() - button1_pressTime > debounceDelay) {
      if (doc[0][""current""].as<int>() == 1 and doc[0][""prev""].as<int>() == 0) {
        doc[0][""mode""] = 1 - doc[0][""mode""].as<int>();
      }
      serializeJson(doc[0], Serial);
      if (mqtt.connect(client_name, mqtt_username, mqtt_password)) {
        char buffer[256];
        size_t n = serializeJson(doc[0], buffer);
        mqtt.publish(
          (String(main_topic) + ""/"" + String(doc[0][""type""].as<const char*>())).c_str(), buffer, n
        );
      }
      Serial.print(""\n"");
      doc[0][""prev""] = doc[0][""current""].as<int>();
      button1_pressTime = millis();
    }
  }

  // button2
  doc[1][""current""] = digitalRead(doc[1][""pin""].as<int>());
  if (doc[1][""current""].as<int>() != doc[1][""prev""].as<int>()) {
    if (millis() - button2_pressTime > debounceDelay) {
      if (doc[1][""current""].as<int>() == 1 and doc[1][""prev""].as<int>() == 0) {
        doc[1][""mode""] = 1 - doc[1][""mode""].as<int>();
      }
      serializeJson(doc[1], Serial);
      if (mqtt.connect(client_name, mqtt_username, mqtt_password)) {
        char buffer[256];
        size_t n = serializeJson(doc[1], buffer);
        mqtt.publish(
          (String(main_topic) + ""/"" + String(doc[1][""type""].as<const char*>())).c_str(), buffer, n
        );
      }
      Serial.print(""\n"");
      doc[1][""prev""] = doc[1][""current""].as<int>();
      button2_pressTime = millis();
    }
  }

  // button3
  doc[2][""current""] = digitalRead(doc[2][""pin""].as<int>());
  if (doc[2][""current""].as<int>() != doc[2][""prev""].as<int>()) {
    if (millis() - button3_pressTime > debounceDelay) {
      if (doc[2][""current""].as<int>() == 1 and doc[2][""prev""].as<int>() == 0) {
        doc[2][""mode""] = 1 - doc[2][""mode""].as<int>();
      }
      serializeJson(doc[2], Serial);
      if (mqtt.connect(client_name, mqtt_username, mqtt_password)) {
        char buffer[256];
        size_t n = serializeJson(doc[2], buffer);
        mqtt.publish(
          (String(main_topic) + ""/"" + String(doc[2][""type""].as<const char*>())).c_str(), buffer, n
        );
      }
      Serial.print(""\n"");
      doc[2][""prev""] = doc[2][""current""].as<int>();
      button3_pressTime = millis();
    }
  }

  // button4
  doc[3][""current""] = digitalRead(doc[3][""pin""].as<int>());
  if (doc[3][""current""].as<int>() != doc[3][""prev""].as<int>()) {
    if (millis() - button4_pressTime > debounceDelay) {
      if (doc[3][""current""].as<int>() == 1 and doc[3][""prev""].as<int>() == 0) {
        doc[3][""mode""] = 1 - doc[3][""mode""].as<int>();
      }
      serializeJson(doc[3], Serial);
      if (mqtt.connect(client_name, mqtt_username, mqtt_password)) {
        char buffer[256];
        size_t n = serializeJson(doc[3], buffer);
        mqtt.publish(
          (String(main_topic) + ""/"" + String(doc[3][""type""].as<const char*>())).c_str(), buffer, n
        );
      }
      Serial.print(""\n"");
      doc[3][""prev""] = doc[3][""current""].as<int>();
      button4_pressTime = millis();
    }
  }

  //slider1
  doc[4][""current""] = analogRead(doc[4][""pin""].as<int>());
  if (abs(doc[4][""current""].as<int>() - doc[4][""prev""].as<int>()) > analogIgnoreRange) {
    if (millis() - slider1_slideTime > analogDelay) {
      if (doc[4][""current""].as<int>() - doc[4][""prev""].as<int>() > 0) {
        doc[4][""mode""] = 1;
      }
      else {
        doc[4][""mode""] = 0;
      }
      serializeJson(doc[4], Serial);
      if (mqtt.connect(client_name, mqtt_username, mqtt_password)) {
        char buffer[256];
        size_t n = serializeJson(doc[4], buffer);
        mqtt.publish(
          (String(main_topic) + ""/"" + String(doc[4][""type""].as<const char*>())).c_str(), buffer, n
        );
      }
      Serial.print(""\n"");
      doc[4][""prev""] = doc[4][""current""].as<int>();
      slider1_slideTime = millis();
    }
  }

  //slider2
  doc[5][""current""] = analogRead(doc[5][""pin""].as<int>());
  if (abs(doc[5][""current""].as<int>() - doc[5][""prev""].as<int>()) > analogIgnoreRange) {
    if (millis() - slider2_slideTime > analogDelay) {
      if (doc[5][""current""].as<int>() - doc[5][""prev""].as<int>() > 0) {
        doc[5][""mode""] = 1;
      }
      else {
        doc[5][""mode""] = 0;
      }
      serializeJson(doc[5], Serial);
      if (mqtt.connect(client_name, mqtt_username, mqtt_password)) {
        char buffer[256];
        size_t n = serializeJson(doc[5], buffer);
        mqtt.publish(
          (String(main_topic) + ""/"" + String(doc[5][""type""].as<const char*>())).c_str(), buffer, n
        );
      }
      Serial.print(""\n"");
      doc[5][""prev""] = doc[5][""current""].as<int>();
      slider2_slideTime = millis();
    }
  }

  //slider3
  doc[6][""current""] = analogRead(doc[6][""pin""].as<int>());
  if (abs(doc[6][""current""].as<int>() - doc[6][""prev""].as<int>()) > analogIgnoreRange) {
    if (millis() - slider3_slideTime > analogDelay) {
      if (doc[6][""current""].as<int>() - doc[6][""prev""].as<int>() > 0) {
        doc[6][""mode""] = 1;
      }
      else {
        doc[6][""mode""] = 0;
      }
      serializeJson(doc[6], Serial);
      if (mqtt.connect(client_name, mqtt_username, mqtt_password)) {
        char buffer[256];
        size_t n = serializeJson(doc[6], buffer);
        mqtt.publish(
          (String(main_topic) + ""/"" + String(doc[6][""type""].as<const char*>())).c_str(), buffer, n
        );
      }
      Serial.print(""\n"");
      doc[6][""prev""] = doc[6][""current""].as<int>();
      slider3_slideTime = millis();
    }
  }

  mqtt.loop();
}
",json_doc
523,"#include ""mlp/mlp.h""
#include ""mlp/activation.h""
#include ""genetic/individual.h""
#include ""genetic/genetic.h""
#include ""utils/utils.h""
#include ""utils/point2d.h""
#include <vector>
#include <iostream>
#include <thread>
#include <random>
#include <algorithm>

#include <GL/gl.h>
#include <GL/freeglut.h>
#include <omp.h>

#include <fstream>
#include <string.h>
#include <limits>
#include <map>

int width = 500, height = 500;
bool display = false;
bool step = false;
std::string simulationName = """";
Genetic *genetic = NULL;
std::map<std::string, std::function<Genetic*(const std::string&)>> factory = 
{
   {
        ""follow"", 
        [](const std::string &fileName)
        {
            return new Genetic(
                500,
                fileName,
                []()
                {
                    Mlp* mlp = MlpBuilder::withInputs(6)
                            ->withLayer(7)
                            ->withActivation(activation::tanH)
                            ->withLayer(3)
                            ->withActivation(activation::tanH)
                            ->build();
                            
                    int elements = mlp->getNumWeights();
                    std::vector<double> y(elements);    
                    for(int j = 0; j<elements;j++)
                    {
                        y[j] = randomNumber(-1.0, 1.0); 
                    }
                    mlp->setWeights(y);
                    
                    std::vector<bool> x(elements);    
                    for(int j = 0; j<elements;j++)
                    {
                        x[j] = randomNumber(0.0, 1.0) >= 0.75; 
                    }
                    mlp->setConnections(x);   
                    
                    return new FollowIndividual(mlp, Point2d(randomNumber(0.0, width), randomNumber(0.0, height)));
                },
                new FollowSimulation(500, width, height, 2));
        }
   }
};

void resizeSimulation(GLsizei w, GLsizei h) 
{
    width = w;
    height = h;
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, width, 0, height, 0, 100);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void resizeNetwork(GLsizei w, GLsizei h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, w, 0, h, 0, 100);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void displaySimulation(void)
{
    double start = omp_get_wtime();
    if(!step && genetic->generation > 0 && genetic->generation % 100 != 0)
        while(genetic->generation % 100 != 0)
            genetic->updateAndEvolve();
    else
        genetic->updateAndEvolve();
    double updateTime = omp_get_wtime() - start;
    
    start = omp_get_wtime();
    glClearColor(0,0,0, 1);
    glClear(GL_COLOR_BUFFER_BIT);
    
    double xScale = width / (double)genetic->simulation->width;
    double yScale = height / (double)genetic->simulation->height;
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glScalef(xScale, yScale, 1);
    genetic->simulation->display();
    glPopMatrix();
    
    glFlush();
    glutSwapBuffers();
    glutPostRedisplay();
    std::cout<<""Update time: ""<<updateTime<<"" Display time: ""<<omp_get_wtime() - start<<std::endl;
}

void displayNetwork(void)
{
    glClearColor(1,1,1,1);
    glClear(GL_COLOR_BUFFER_BIT);
    static int index = 0;
    
    int xOffset = width/3;
    int yOffset = height/3;
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glScalef(1.0/3.0, 1.0/3.0, 1);
    for(int i=0;i<3;i++)
    {
        glPushMatrix();
        for(int j=0;j<3;j++)
        {
            MlpDisplay::display(genetic->individuals[i*3 + j]->mlp, width, height);
            glTranslatef(0, height, 0);
        }
        glPopMatrix();
        glTranslatef(width, 0, 0);
    }
    glPopMatrix();
    
    glFlush();
    glutSwapBuffers();
    glutPostRedisplay();
}

bool processArgs(int argc, char** argv, std::string &simulationName, bool &step)
{
    bool  [MASK]  = false;
    if(argc <= 1)
    {
        std::cout<<""No simulation specified""<<std::endl;
         [MASK]  = true;
    }
    else if(argc == 2)
    {
        step = false;
        simulationName = argv[1];
    }
    else if(argc == 3)
    {
        if(std::string(argv[1]) == ""-s"")
        {
            step = true;
            simulationName = argv[2];
        }
        else if(std::string(argv[2]) == ""-s"")
        {
            step = true;
            simulationName = argv[1];
        }
        else
        {
             [MASK]  = true;
            std::cout<<""Invalid argument specified: ""<<argv[1]<<"" ""<<argv[2]<<std::endl;
            std::cout<<""Usage: evolution simulationName [-s]""<<std::endl;
            std::cout<<""\t-s:\t If specified, all generations are displayed, otherwise, only the generations multiple of 100 are displayed.""<<std::endl;
        }
    }
    
    if( [MASK]  || factory.find(simulationName) == factory.end())
    {
        if(! [MASK] )
            std::cout<<""There is no simulation called ""<<simulationName<<std::endl;
        std::cout<<""\tValid simulation names are:""<<std::endl;
        for(std::map<std::string, std::function<Genetic*(const std::string&)>>::iterator it = factory.begin();it != factory.end();it++)
            std::cout<<""\t""<<it->first<<std::endl;
            
        return false;
    }
    
    return true;
}

int main(int argc, char** argv)
{
    if(!processArgs(argc, argv, simulationName, step))
    {
        return 0;
    }
    
    genetic = factory[simulationName](simulationName);
    genetic->initialize();

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(width, height);
    glutInitWindowPosition(100, 100);
    glutCreateWindow(argv[1]);
    glutDisplayFunc(displaySimulation);
    glutReshapeFunc(resizeSimulation);
    
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(width, height);
    glutInitWindowPosition(600, 100);
    glutCreateWindow(""network"");
    glutDisplayFunc(displayNetwork);
    glutReshapeFunc(resizeNetwork);
    
    glutMainLoop();
    
    return 0;
}
",error
524,"/*
 * Copyright (C) 2024 RealAhani - All Rights Reserved
 * You may use, distribute and modify this code under the
 * terms of the MIT license, which unfortunately won't be
 * written for another century.
 * You should have received a copy of the MIT license with
 * this file.
 */

int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
{
    std::println(""hello c++23 "");
    // benchmark is activate from presets and with PROFILE or
    // PROFILE_SCOP macro`s .
    // PROFILE();
    using namespace std::string_literals;
    using namespace myproject::cmake;
// __________ Project Informations __________
#if (MYOS == 1)                                      // OS is Windows
    mloge::print(""WIN""s);
#elif (MYOS == 2)                                    // OS is GNU/Linux
    mloge::print(""LINUX""s);
#elif (MYOS == 3)                                    // OS is OSX
    mloge::print(""MAC""s);
#endif

    mloge::print(myproject::cmake::projectName);     // Project-name!

    mloge::print(myproject::cmake::projectVersion);  // Project-version!
    // __________ Project Informations __________

    // Raylib window init
    SetConfigFlags(FLAG_MSAA_4X_HINT | FLAG_WINDOW_HIGHDPI | FLAG_VSYNC_HINT |
                   FLAG_FULLSCREEN_MODE);
    InitWindow(0, 0, myproject::cmake::projectName.c_str());

    // Window properties
    [[maybe_unused]]
    int const width  = {GetScreenWidth()};
    int const height = {GetScreenHeight()};
    bool      isQuit = {false};

    // Physics related values for box2d (box2d-related)
    float const squerWidth  = {50.f};
    float const squerHeight = {50.f};
    float const squerX      = {800.f};
    float const squerY      = {(height / 2.f) - 500.f};
    float const rectWidth   = {5000.f};
    float const rectHeight  = {50.f};
    float const rectX       = {0.f};
    float const rectY       = {(height / 2.f)};
    float const rectDec     = {10.f};

    // box2d init of the world of the game (box2d-related)
    b2WorldDef   worldDef = {b2DefaultWorldDef()};
    b2Vec2 const gravity  = {-5.f, -10.f};
    worldDef.gravity      = gravity;
    b2WorldId worldID     = {b2CreateWorld(&worldDef)};
    worldDef.enableSleep  = false;

    // Creatig a ground (box2d-related)
    b2BodyDef groundDef = {b2DefaultBodyDef()};
    groundDef.position  = b2Vec2 {-rectX, -rectY};
    groundDef.type      = b2_staticBody;
    groundDef.rotation  = b2MakeRot(rectDec * DEG2RAD);

    b2BodyId const  groundBodyId   = {b2CreateBody(worldID, &groundDef)};
    b2Polygon const groundShape    = {b2MakeBox(rectWidth / 2.f, rectHeight / 2.f)};
    b2ShapeDef      groundShapeDef = {b2DefaultShapeDef()};
    // Mass is not need for static object
    // groundShapeDef.friction    = 0.3f;
    // groundShapeDef.restitution = 0.7f;
    b2CreatePolygonShape(groundBodyId, &groundShapeDef, &groundShape);

    // Ground 2 (box2d-related)
    b2BodyDef  [MASK]  = {b2DefaultBodyDef()};
     [MASK] .position  = b2Vec2 {-(rectX + 1400), -(rectY - 300)};
     [MASK] .type      = b2_staticBody;
     [MASK] .rotation  = b2MakeRot(75.f * DEG2RAD);

    b2BodyId const  groundBodyId2   = {b2CreateBody(worldID, & [MASK] )};
    b2Polygon const groundShape2    = {b2MakeBox(rectWidth / 2.f, rectHeight / 2.f)};
    b2ShapeDef      groundShapeDef2 = {b2DefaultShapeDef()};
    // Mass is not need for static object
    // groundShapeDef2.friction    = 0.3f;
    // groundShapeDef2.restitution = 0.7f;
    b2CreatePolygonShape(groundBodyId2, &groundShapeDef2, &groundShape2);

    // Create a dynamic box (box2d-related)
    b2BodyDef boxDef = {b2DefaultBodyDef()};
    boxDef.position  = b2Vec2 {-squerX, -squerY};
    boxDef.type      = b2_dynamicBody;
    boxDef.rotation  = b2MakeRot(30.f * DEG2RAD);

    b2BodyId const  boxBodyId   = {b2CreateBody(worldID, &boxDef)};
    b2Polygon const boxShape    = {b2MakeBox(squerWidth / 2.f, squerHeight / 2.f)};
    b2ShapeDef      boxShapeDef = {b2DefaultShapeDef()};
    boxShapeDef.density         = 1.f;
    // boxShapeDef.friction        = 0.7f;
    b2CreatePolygonShape(boxBodyId, &boxShapeDef, &boxShape);

    // Simulating setting (box2d-related)
    SetTargetFPS(GetMonitorRefreshRate(0));
    float const  timeStep     = {1.f / 15.f};  // 60HZ
    int8_t const subStepCount = {3};

    [[maybe_unused]]
    bool const fex = FileExists(""resource/TEST.txt"");
    // we have crash here bc of path finding of assets abs with Asan or Ubisan
    std::string const str {LoadFileText(""resource/TEST.txt"")};

    // Main loop
    while (!WindowShouldClose() && !isQuit)
    {
        // PROFILE_SCOPE(""LOOP"");
        // Input managment with raylib
        if (IsKeyPressed(KEY_ESCAPE)) [[unlikely]]
        {
            isQuit = true;
        }
        if (IsKeyPressed(KEY_BACK))
        {
            // TODO: clean up then leave
            break;
        }
        // Update world state (box2d-related)
        b2World_Step(worldID, timeStep, subStepCount);

        // Rendering
        ClearBackground(BLACK);
        BeginDrawing();
        DrawFPS(0, 10);
        b2Vec2 const boxPos {b2Body_GetPosition(boxBodyId)};
        b2Vec2 const groundPos {b2Body_GetPosition(groundBodyId)};
        b2Vec2 const groundPos2 {b2Body_GetPosition(groundBodyId2)};

        // Draw a dynamic box
        DrawRectanglePro(Rectangle {.x      = -boxPos.x,
                                    .y      = -boxPos.y,
                                    .width  = squerWidth,
                                    .height = squerHeight},
                         Vector2 {.x = (squerWidth / 2.f), .y = (squerHeight / 2.f)},
                         b2Rot_GetAngle(b2Body_GetRotation(boxBodyId)) * RAD2DEG,
                         RED);

        // Draw the ground as a box
        DrawRectanglePro(Rectangle {.x      = -groundPos.x,
                                    .y      = -groundPos.y,
                                    .width  = rectWidth,
                                    .height = rectHeight},
                         Vector2 {.x = (rectWidth / 2), .y = (rectHeight / 2)},
                         b2Rot_GetAngle(b2Body_GetRotation(groundBodyId)) * RAD2DEG,
                         GREEN);

        // Draw the second ground
        DrawRectanglePro(Rectangle {.x      = -groundPos2.x,
                                    .y      = -groundPos2.y,
                                    .width  = rectWidth,
                                    .height = rectHeight},
                         Vector2 {.x = (rectWidth / 2), .y = (rectHeight / 2)},
                         b2Rot_GetAngle(b2Body_GetRotation(groundBodyId2)) * RAD2DEG,
                         GREEN);


        DrawText(str.c_str(), width / 2, height / 2, 44, RAYWHITE);

        EndDrawing();
    }
    // Cleaning up and bye
    b2DestroyWorld(worldID);
    worldID = b2_nullWorldId;
    CloseWindow();
    return 0;
}

// // If this is a window app and WinMain is needed
// #if defined(_WIN32)
// #define NOGDI   // All GDI defines and routines
// #define NOUSER  // All USER defines and routines
// #endif
// // or any library that uses Windows.h
// #include <windows.h>
// #if defined(_WIN32)  // raylib uses these names as function parameters
// #undef near
// #undef far
// #endif
// auto WINAPI WinMain([[maybe_unused]] HINSTANCE hInstance,
//                     [[maybe_unused]] HINSTANCE hPrevInstance,
//                     [[maybe_unused]] LPSTR     lpCmdLine,
//                     [[maybe_unused]] int       nCmdShow) -> int
// {
//     // MessageBox(nullptr, ""Hello, World!"", ""My First WinMain"", MB_OK);

//     return 0;
// }",groundDef2
525,"#ifndef CURVES_HPP
#define CURVES_HPP

template<typename T1, typename T2> constexpr T1 Linear(T1 first, T1 last, T2 t)
{
    return (last - first) * t + first;
}

template<typename T1, typename T2> T1 Overshoot(
    T1 first, T1 last, T2  [MASK] , T2 t)
{
    auto difference = last - first;

    return
        difference * t + first - sin(t * tau<T2>()) *  [MASK]  * difference;
}

template<typename T1, typename T2> T1 SCurve(T1 first, T1 last, T2 t)
{
    auto difference = last - first;
    auto tt = (T2(1) - cos(t * pi<T2>())) * T2(0.5);
    return difference * tt + first;
}

template<typename T1, typename T2> T1 Boomerang(T1 first, T1 last, T2 t)
{
    auto tt = sin(t * pi<T2>());
    return Linear(first, last, tt);
}

template <typename T, int N> struct ControlPoints
{
    T points[N];
};

template <typename Ta, int N, typename Tb>
Ta Interpolate(ControlPoints<Ta, N> control, Tb t)
{
    for (int i = N; i > 0; --i)
    {
        for (int j = 1; j < i; ++j)
        {
            control.points[j - 1] =
                Linear(control.points[j - 1], control.points[j], t);
        }
    }

    return control.points[0];
}

#endif

",magnitude
526,"//
//  main.cpp
//  yt8m_add_pred
//

#include <iostream>
#include <thread>
#include ""pred.hpp""
#include ""utils.hpp""

int main(int argc, const char * argv[]) {
   
    std::string fn1, fn2, fn3,  [MASK]  = ""/tmp/combo.csv"";
    double w1=0.333, w2=0.334, w3 =0.333;
    if (argc < 4) {
        std::cout<<""Usage:\n ""<<argv[0]<<"" in_file1 in_file2 in_file3 [w1 w2 w3 [out_file]]\n"";
        std::cout<<""\n default values: w1 = 0.333\n"";
        std::cout<<""                 w2 = 0.334\n"";
        std::cout<<""                 w3 = 0.333\n"";
        std::cout<<""           out_file = \""tmp/combo.csv\""\n"";
        exit(1);
    }
    
    fn1=argv[1];
    fn2=argv[2];
    fn3=argv[3];
    
    
    if (argc >= 7) {
        w1 = std::stod(argv[4]);
        w2 = std::stod(argv[5]);
        w3 = std::stod(argv[6]);
    }
    
    if (argc == 8)
         [MASK]  = argv[7];
    
    std::cout<<currentDateTime()<<"": Starting...\n"";
    
    std::vector<prediction> v1, v2, v3;
    std::thread t1 {[&]{ v1 = file2preds(fn1); } };
    std::thread t2 {[&]{ v2 = file2preds(fn2); } };
    std::thread t3 {[&]{ v3 = file2preds(fn3); } };

    t1.join();
    std::cout<<currentDateTime()<<"": Read file: ""<<fn1<<'\n';
    t2.join();
    std::cout<<currentDateTime()<<"": Read file: ""<<fn2<<'\n';
    t3.join();
    std::cout<<currentDateTime()<<"": Read file: ""<<fn3<<'\n';
    
    std::vector<prediction> c1 = add_pred_vecs(v1, v2, w1, w2);
    std::cout<<currentDateTime()<<"": Added two predictions with (w1, w2) = (""<<w1<<"", ""<<w2<<"")\n"";
    std::vector<prediction> c2 = add_pred_vecs(c1, v3, 1.0, w3);
    std::cout<<currentDateTime()<<"": Added the third prediction with w3 = ""<<w3<<'\n';
    
    preds2file(c2,  [MASK] );
    std::cout<<currentDateTime()<<"": Saved data to ""<< [MASK] <<""\n"";
    
    return 0;
}
",fout
527,"
#pragma once

#include ""global.hpp""

class Tank
{
private:
    const double levelSensorHeight = 70.0;
    const int index;
    double volume;
    bool wasBelowLevelSensor = false;

public:
    Tank(int index)
        : index(index), volume(this->levelSensorHeight)
    {}

    double canFill(double  [MASK] ) const
    {
        return levelSensors[this->index].read() || this->volume >=  [MASK] ;
    }

    bool checkLevel()
    {
        if (!this->wasBelowLevelSensor && !levelSensors[this->index].read())
        {
            this->volume = this->levelSensorHeight;
            this->wasBelowLevelSensor = true;
            return true;
        }

        return false;
    }

    bool isVolumeKnown() const
    {
        return this->volume <= this->levelSensorHeight;
    }

    void serve(double volume)
    {
        this->volume -= volume;
    }

    double getVolume() const
    {
        return this->volume;
    }
};
",desiredVolume
528,"#include ""pch.h""
#include ""TicTacToe/AI.h""

#include ""TicTacToe/Board.h""


namespace TicTacToe {

	Difficulty AI::s_Difficulty = Difficulty::Impossible;
	
	void AI::SetDifficulty(Difficulty difficulty)
	{
		s_Difficulty = difficulty;
	}

	Board AI::MakeMove(Board board, Team playingTeam)
	{
		switch (s_Difficulty)
		{
			case Difficulty::Easy:
			{
				board = MakeMove_Random(board, playingTeam);
				break;
			}
			case Difficulty::Medium:
			{
				if (Random::Float() <= 0.5f)
					board = MakeMove_Random(board, playingTeam);
				else
					board = MakeMove_MiniMax(board, playingTeam);

				break;
			}
			case Difficulty::Hard:
			{
				if (Random::Float() <= 0.1f)
					board = MakeMove_Random(board, playingTeam);
				else
					board = MakeMove_MiniMax(board, playingTeam);

				break;
			}
			case Difficulty::Impossible:
			{
				board = MakeMove_MiniMax(board, playingTeam);
				break;
			}
		}

		return board;
	}

	Board AI::MakeMove_Random(Board board, Team playingTeam)
	{
		while (true)
		{
			uint8_t cellIndex = (uint8_t)Random::UInt16(0, 8);

			// Is cell clear
			if (board.IsEmptyCell(cellIndex))
			{
				board.SetCell(cellIndex, playingTeam);
				break;
			}
		}

		return board;
	}

	Board AI::MakeMove_MiniMax(Board board, Team playingTeam)
	{
		float bestBoardValue = -2.0f;
		Board bestBoard;

		for (uint8_t cellIndex = 0; cellIndex < 9; cellIndex++)
		{
			// Skip moves that can not be made
			if (!board.IsEmptyCell(cellIndex))
				continue;

			Board tempBoard(board);
			tempBoard.SetCell(cellIndex, playingTeam);

			float boardValue = MiniMax(tempBoard, playingTeam, -1.0f, 1.0f, false);

			if (boardValue > bestBoardValue)
			{
				bestBoardValue = boardValue;
				bestBoard = tempBoard;
			}
		}

		return bestBoard;
	}

	float AI::MiniMax(Board board, Team playingTeam, float  [MASK] , float beta, bool maximizingPlayer)
	{
		// Other player wins
		if (board.Evaluate((Team)!(bool)playingTeam))
			return -1.0f;

		// Active plater wins ( This is what we want )
		if (board.Evaluate(playingTeam))
			return 1.0f;

		if (board.IsFull())
			return 0;

		if (maximizingPlayer)
		{
			float maxValue = -1.0f;

			for (uint8_t cellIndex = 0; cellIndex < 9; cellIndex++)
			{
				// Skip moves that can not be made
				if (!board.IsEmptyCell(cellIndex))
					continue;

				Board tempBoard(board);
				tempBoard.SetCell(cellIndex, playingTeam);

				float value = MiniMax(tempBoard, playingTeam,  [MASK] , beta, false);
				maxValue = glm::max(maxValue, value);

				 [MASK]  = glm::max( [MASK] , value);
				if (beta <=  [MASK] )
					break;
			}

			return maxValue;
		}
		else
		{
			float minValue = 1.0f;

			for (uint8_t cellIndex = 0; cellIndex < 9; cellIndex++)
			{
				// Skip moves that can not be made
				if (!board.IsEmptyCell(cellIndex))
					continue;

				Board tempBoard(board);
				tempBoard.SetCell(cellIndex, (Team)!(bool)playingTeam);

				float value = MiniMax(tempBoard, playingTeam,  [MASK] , beta, true);
				minValue = glm::min(minValue, value);

				beta = glm::min(beta, value);
				if (beta <=  [MASK] )
					break;
			}

			return minValue;
		}
	}

}
",alpha
529,"// Copyright 2017 Google Inc. 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.

// Ensures each implementation of HighwayHash returns consistent and unchanging
// hash values.

#include ""highwayhash/highwayhash_target.h""

#include <cstdio>
#include <cstdlib>

#ifdef HH_GOOGLETEST
#include ""testing/base/public/gunit.h""
#endif

// Define to nonzero in order to print the (new) golden outputs.
#define PRINT_RESULTS 0

namespace highwayhash {
namespace {

// Known-good outputs are verified for all lengths in [0, 64].
const size_t kMaxSize = 64;

#if PRINT_RESULTS
void Print(const HHResult64 result) { printf(""0x%016llXull,\n"", result); }

// For HHResult128/256.
template <int kNumLanes>
void Print(const HHResult64 (&result)[kNumLanes]) {
  printf(""{ "");
  for (int i = 0; i < kNumLanes; ++i) {
    if (i != 0) {
      printf("", "");
    }
    printf(""0x%016llXull"", result[i]);
  }
  printf(""},\n"");
}
#endif  // PRINT_RESULTS

// Verifies every combination of implementation and input size.
template <typename Result>
void VerifyImplementations(const Result (&known_good)[kMaxSize + 1], bool* ok) {
  const HHKey  [MASK]  = {0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL,
                     0x1716151413121110ULL, 0x1F1E1D1C1B1A1918ULL};

  // For each test input: empty string, 00, 00 01, ...
  char in[kMaxSize + 1] = {0};
  for (uint64_t size = 0; size <= kMaxSize; ++size) {
    in[size] = static_cast<char>(size);
#if PRINT_RESULTS
    Result actual;
    InstructionSets::Run<HighwayHash>( [MASK] , in, size, &actual, 0);
    Print(actual);
#else
    const Result* expected = &known_good[size];
    InstructionSets::RunAll<HighwayHashTest>( [MASK] , in, size, expected, ok);
#endif
  }
}

const HHResult64 kExpected64[kMaxSize + 1] = {
    0x907A56DE22C26E53ull, 0x7EAB43AAC7CDDD78ull, 0xB8D0569AB0B53D62ull,
    0x5C6BEFAB8A463D80ull, 0xF205A46893007EDAull, 0x2B8A1668E4A94541ull,
    0xBD4CCC325BEFCA6Full, 0x4D02AE1738F59482ull, 0xE1205108E55F3171ull,
    0x32D2644EC77A1584ull, 0xF6E10ACDB103A90Bull, 0xC3BBF4615B415C15ull,
    0x243CC2040063FA9Cull, 0xA89A58CE65E641FFull, 0x24B031A348455A23ull,
    0x40793F86A449F33Bull, 0xCFAB3489F97EB832ull, 0x19FE67D2C8C5C0E2ull,
    0x04DD90A69C565CC2ull, 0x75D9518E2371C504ull, 0x38AD9B1141D3DD16ull,
    0x0264432CCD8A70E0ull, 0xA9DB5A6288683390ull, 0xD7B05492003F028Cull,
    0x205F615AEA59E51Eull, 0xEEE0C89621052884ull, 0x1BFC1A93A7284F4Full,
    0x512175B5B70DA91Dull, 0xF71F8976A0A2C639ull, 0xAE093FEF1F84E3E7ull,
    0x22CA92B01161860Full, 0x9FC7007CCF035A68ull, 0xA0C964D9ECD580FCull,
    0x2C90F73CA03181FCull, 0x185CF84E5691EB9Eull, 0x4FC1F5EF2752AA9Bull,
    0xF5B7391A5E0A33EBull, 0xB9B84B83B4E96C9Cull, 0x5E42FE712A5CD9B4ull,
    0xA150F2F90C3F97DCull, 0x7FA522D75E2D637Dull, 0x181AD0CC0DFFD32Bull,
    0x3889ED981E854028ull, 0xFB4297E8C586EE2Dull, 0x6D064A45BB28059Cull,
    0x90563609B3EC860Cull, 0x7AA4FCE94097C666ull, 0x1326BAC06B911E08ull,
    0xB926168D2B154F34ull, 0x9919848945B1948Dull, 0xA2A98FC534825EBEull,
    0xE9809095213EF0B6ull, 0x582E5483707BC0E9ull, 0x086E9414A88A6AF5ull,
    0xEE86B98D20F6743Dull, 0xF89B7FF609B1C0A7ull, 0x4C7D9CC19E22C3E8ull,
    0x9A97005024562A6Full, 0x5DD41CF423E6EBEFull, 0xDF13609C0468E227ull,
    0x6E0DA4F64188155Aull, 0xB755BA4B50D7D4A1ull, 0x887A3484647479BDull,
    0xAB8EEBE9BF2139A0ull, 0x75542C5D4CD2A6FFull};

const HHResult128 kExpected128[kMaxSize + 1] = {
    {0x0679D1E884C28A7Cull, 0x2BCA2547F904748Dull},
    {0x7F3A39BCC2D897B9ull, 0x4A7E113CA064D91Full},
    {0x6AB34B92C5AB85BFull, 0xED7AC546689D76C2ull},
    {0xAC6AF8405A4A7DBEull, 0xD78FB7953256C3E1ull},
    {0x5A6E8CF789B86448ull, 0x834EF47C1BEDC218ull},
    {0x8EBFE0B573F425A3ull, 0xBCFCC410CB84325Aull},
    {0xA1E19717CAB8F1D6ull, 0x2AA50671881F877Dull},
    {0x0B595302950DA1ECull, 0x46932DE27204B388ull},
    {0x02FB033F200F89D4ull, 0xFEC3D7BB3B421F92ull},
    {0x0A5479D46CC1EADEull, 0x0C16A2D5A0F1C3DEull},
    {0xF759E41DDD621106ull, 0xB43D70116E004750ull},
    {0x980010BC36A4E98Full, 0x27479317AE00BBD1ull},
    {0x3BABF3B23761A379ull, 0xACCDC28E0256F326ull},
    {0x5780CD04269E142Eull, 0xBB70EE3F23BDEDA9ull},
    {0x4A401F1937E99EC3ull, 0x4B3D1385D6B4E214ull},
    {0x045C6EDE080E2CB0ull, 0x7327B45D2132DC89ull},
    {0x97E1624BEB1C1756ull, 0xB7137E1B69D45024ull},
    {0x31DBA8E3DB0BF012ull, 0x3E66E6A78A729B16ull},
    {0x34D6DF1B5D8AF2A7ull, 0x4F1A47FCBC39EB55ull},
    {0xE2C6BE2D47E5DCBCull, 0xD2FF85284E307C1Full},
    {0xDA681E06098EC892ull, 0x71AD98355019FED1ull},
    {0xC4FBD72B1F2FC30Bull, 0x327549B6C9FDEDD5ull},
    {0x14F429D1C20F0EB5ull, 0x228B40C92F3FA369ull},
    {0xF5C9535333206D01ull, 0xB6FC46FCCA65F9CCull},
    {0x3049FAD9DB729D2Dull, 0xB84C931C45F781EAull},
    {0x7C6FFE6F3706DC04ull, 0x4F94583806AE3C62ull},
    {0x9EF95EB28BE1CCE0ull, 0xAD9D5B96A0D15BFEull},
    {0x63D0ED54AF2985E6ull, 0xDFAFB1B6485C1B01ull},
    {0xA46C8A2FE498D46Cull, 0xF4DBAEC0FF03BAD6ull},
    {0xED978A0FBB3E5158ull, 0x060D144D57FBE6FDull},
    {0x53F1D80C8922E4E5ull, 0x1324880D932140C9ull},
    {0xDD363B03563870CEull, 0x0DFDB79F4F34184Bull},
    {0x4E702701AE65DB38ull, 0x1B67E0A2E2DBFB04ull},
    {0x240DA388551D0822ull, 0x2FF1BB584AC4BD61ull},
    {0x3FAFB8B7C26499ABull, 0x072516308E889132ull},
    {0x0AB452339406AB22ull, 0x751DBB7FF9472D42ull},
    {0x83BA782DB6EB1186ull, 0x4391544D9318DC29ull},
    {0x25077ECDAAB201E8ull, 0x695E0E95446D63A2ull},
    {0x1AF0BF12F91F17D4ull, 0x5BB8FF299368D22Cull},
    {0x338C09CBAF701E38ull, 0xA7D24D5E7C06DC78ull},
    {0x5AB58D6555D28B56ull, 0xE781413A9AE1310Full},
    {0xB0281CD10BCA7B89ull, 0xF49873B45C0F7274ull},
    {0x67EEBD6D71E57B06ull, 0x9421CB1DB54EEDDFull},
    {0x00DAB867E37EDA65ull, 0x6477E454191E213Full},
    {0x9AF9C4817C24C82Eull, 0xAE3A73522F311EEBull},
    {0xD8A334E30D23C6E6ull, 0xAF57EF86CCCF12FFull},
    {0x0353A48FC9E139DDull, 0x27D5626170A7DD0Full},
    {0x0DA12E888EB61876ull, 0x67B17DF10CB365CDull},
    {0x967CD764883A5E85ull, 0x570D7C9A774A6AB4ull},
    {0xA8DF13980C81E533ull, 0x9C33FE4797F87F1Aull},
    {0xCABB59F53AE75FF2ull, 0x6D25512E77172E7Aull},
    {0xB24E7F0C7DA62BE7ull, 0x2442F94890F57D89ull},
    {0x7DCBA0A5B9689BBDull, 0x700FC8D13DA4CC60ull},
    {0x1E8E014B97A9F828ull, 0xF858EFCA33E8A502ull},
    {0x4DAF4E31F34D10C7ull, 0x47E382D0A5A8C613ull},
    {0x577CAB4EF626BB28ull, 0xF6ED27E594C5795Full},
    {0x989188C958586C96ull, 0x8B3A2CB0D5B48FD9ull},
    {0x13CC58F5A076C088ull, 0x932A0FD21D4B422Cull},
    {0xD067380DAD885647ull, 0xC1020E396B31BB4Aull},
    {0x47D05A73072758D0ull, 0x5CF6075A0AEB5D78ull},
    {0x54441D7AE94E2D4Eull, 0x3B4F67953ABD3EA4ull},
    {0xEDD4250C3733EEBCull, 0x26E365AA1167C723ull},
    {0x92D02D2A641DA598ull, 0x3DAF5EB24A0C2A94ull},
    {0xAE6CF7FE2D76CA56ull, 0xC7918532A42D2F5Dull},
    {0xAD24762A08D96F1Bull, 0x729083EC59FA8DF7ull}};

const HHResult256 kExpected256[kMaxSize + 1] = {
    {0xC6DC0C823434863Full, 0x6A42CCB644CBFAD9ull, 0x18DEF6A60EA5D873ull,
     0x3596F663D00D1225ull},
    {0x00518B3D2BD22424ull, 0xE5791619BF612E97ull, 0xF4DAF07017FAF99Dull,
     0xE36AE62C5509B5D6ull},
    {0x81021CC5067D8526ull, 0xBEEFC1BC87A6911Aull, 0xE2AEC605F80657FEull,
     0x3C6576B5DF982327ull},
    {0x118D72C0B5DB2C70ull, 0x0BE2E64BF538CA74ull, 0x667B33FE41DDAA74ull,
     0xB6199539303E13E1ull},
    {0x4AC9B8B2E4FD873Bull, 0xDE0FE265A45FFC97ull, 0x1FC1476F896ADA3Bull,
     0x7680B4AE30B371E7ull},
    {0x518ABC6B5E88214Full, 0xFD62A05B2B06026Bull, 0x9C978E8B38DBE795ull,
     0x41412401886FF054ull},
    {0x2DEDEF0832BEA7D9ull, 0x44EFE0AEAB7944FCull, 0x09AA7C9374A1E980ull,
     0x714DB8B507C507FBull},
    {0x6FA2135DE3D3D3AAull, 0xC0EEA9A890E36156ull, 0xFAC1DB8C817DB095ull,
     0x7B42789096836327ull},
    {0x27257C518B1FFC5Cull, 0x26CC8E669DA1AB0Full, 0xCD7B17C661A0A680ull,
     0x31D0A7EC0AA3B9BFull},
    {0xB91869900A1AF26Cull, 0x95B0D74B7FF20B43ull, 0x2A6CABF6F931B575ull,
     0x69734DC9E66A1965ull},
    {0xDD7DA31F5C4DD30Full, 0x08940D249A0A7B69ull, 0xAE7D3AD1C5EA81F2ull,
     0x96701DB5C6602B21ull},
    {0x2E4A230847E64687ull, 0xF96176C38E48B038ull, 0x9ED0B88A3026E1BCull,
     0x9AAB5DCA46FCFE19ull},
    {0x3E5CF04BFBAC2642ull, 0x591A3581001709DFull, 0xA0288F5FA63C10A2ull,
     0x85B94D3641A2C108ull},
    {0x454A95FAD8901350ull, 0x5546E8E75D2AC833ull, 0xCF5FF2ACB4B5F2C1ull,
     0x14F314318028D62Eull},
    {0x0DED251FB81F34A9ull, 0xC42111DB31618AA6ull, 0xC1C3352B70B00C5Dull,
     0xDC8947DBC398F0C2ull},
    {0xC591A100AB4E9E72ull, 0x4CCFD2A7B0D8D911ull, 0x6FEDFDDE1BA3F770ull,
     0x03E5C5A2F6E708A1ull},
    {0x537C42CC5E7B448Aull, 0xA7343E04249B2231ull, 0x2CB51D697EFE9B6Dull,
     0x589D83141A699A97ull},
    {0x3F7E6EA60343B870ull, 0x4E27E907E296D4D7ull, 0x87525BF1AABBF794ull,
     0x6B03C4DC206EC628ull},
    {0x741BA4D7A856E03Cull, 0x3798422CB64C9AFAull, 0xB1D89C9720D33FDDull,
     0x08DE607FC4E3B5C3ull},
    {0x77D77342C85BA466ull, 0xA01C603C58F6D97Eull, 0x342AF0A7309EA4EAull,
     0x9C958EB3F6A64B94ull},
    {0x9EDCADDD1FFC763Full, 0xBD9BAA6E9BE936EFull, 0xAAB0F78F1A4A94F7ull,
     0xE71D9CA601DA4C02ull},
    {0xE3AA0D0A422BF888ull, 0x07734C8173411035ull, 0x8A085019DE545AF6ull,
     0xBC3C520B1221A779ull},
    {0x16170C02C5E5439Dull, 0x45C6004513BFC174ull, 0x35CF3AD65D225EC8ull,
     0xE10BAA702D37C90Eull},
    {0x6BD63B47EA43ABC6ull, 0xCC08BE8A651E24C0ull, 0xB564F0FC6FF8998Aull,
     0x3EE409A34232E589ull},
    {0xD6CEE5574355BB81ull, 0x8E31FF40B271A16Dull, 0xC3ECEDBEEACCCAE9ull,
     0x19386CD3A23B92E9ull},
    {0x32475E05D248DBB1ull, 0xF2396A122830E72Cull, 0xB88395678C0DB899ull,
     0x8BD410A22A247066ull},
    {0x0BFA3B3C4775EB43ull, 0x496596C36FB2A200ull, 0xA00F533EF150D7DDull,
     0xB5D70BBCABB572C4ull},
    {0x932B0ED33ED691B1ull, 0xB58394EDCEA3C53Dull, 0xB935E0786B132755ull,
     0x3E0998322B3F74BAull},
    {0xE21F2CE1BDD156A7ull, 0x764518A56E1363B5ull, 0x461251D3EC39B93Full,
     0x33C1FE46C9664CC4ull},
    {0x8ABD3F6184C9CD7Dull, 0x8195816637017FC0ull, 0x284B3E93524765DEull,
     0x56147BDBA9362D0Eull},
    {0x1F050672342807B6ull, 0x9B0AD1091A83910Dull, 0xF23AD4A58C3B1E21ull,
     0xCC986EC0BEA16781ull},
    {0x053164DEF96B10CEull, 0x1D5ADA15E36D8F6Cull, 0x06FB43534C0472EFull,
     0x021C0ED1FDEA0948ull},
    {0xF62BA4C5A665E602ull, 0x490D89FD89430C56ull, 0x18F423BE8A9B7E3Cull,
     0x769E5DDA4DCAC619ull},
    {0xDABD25FAF07A6684ull, 0xACA85CD21536B927ull, 0xAC05E050B4E3D3D1ull,
     0xBE427B2475CCD981ull},
    {0x89A2B35A34F89F8Cull, 0x1A0E51B2875D34E6ull, 0xBA573CF45E123919ull,
     0x1C50815B08F1138Aull},
    {0x3390CCBE60F2AFF7ull, 0xD9E2D245643E79C2ull, 0x1104A78F85D3CDF5ull,
     0x7E55F38F9C53A58Full},
    {0xC189AE1A9D456C0Eull, 0x06AA4C3D4204A40Full, 0x4B383405A9D451A9ull,
     0x7EA34CBCAEF0C31Eull},
    {0xB45FA7CC19AE4DDFull, 0x306C418E9BA67420ull, 0xDF16D80D4D48C096ull,
     0xD3169E50BC8D75CCull},
    {0x5894367013710C89ull, 0xD39EE6D584E76AF3ull, 0x5C55A414BCDDE505ull,
     0x8FA97D561CB174BFull},
    {0x87355749D59F39DDull, 0x26B8B311E72C50F4ull, 0x1911A8CBCE53E37Bull,
     0x5C256452C39B95F6ull},
    {0x8B9E87C9ABC82821ull, 0x12A5FC06B69CDC2Dull, 0xF95104FF805E5E1Dull,
     0xE5D4D2257AD5592Eull},
    {0x5A89242B02E1E048ull, 0x771602AAD1880A7Eull, 0x0F34507608387843ull,
     0x7AFB45F3EA4F0F24ull},
    {0x3BE3800150FDDE00ull, 0x7871908FF91AD81Aull, 0xA00E07F351BB15C1ull,
     0x429658E7FD10D11Aull},
    {0x2B2B1A6CD1BA454Cull, 0xF19E8CA5C022308Aull, 0xAEFA0EB6F7C3CF74ull,
     0x21F4330A5258E7C7ull},
    {0xD1C806622910A9BEull, 0xFE224EF598F541B1ull, 0xB95A435AEC4DD849ull,
     0xD942A277AB57E68Eull},
    {0x16BF7116E8D2B328ull, 0xB37DC98EA931FC13ull, 0x18E8859A592C8C11ull,
     0x11590F16C4C61716ull},
    {0xD046122D4C7B24AEull, 0xBD0899DFD7345611ull, 0x91AAECB50DE6DFF9ull,
     0x6EDC4896BAA90FFAull},
    {0x2FE97B8135EA956Dull, 0xFBA50900FB4EF23Cull, 0x0BC907363F7EA368ull,
     0xA5C982D3094BCEE2ull},
    {0x247BFB5BA3A0F245ull, 0x6ACBDD4AFFDB03EBull, 0xA4237427D373B619ull,
     0xFA9C041D302B728Cull},
    {0xF93109909D6B80EFull, 0xD1321A6BEE302794ull, 0xD63E1E7985C458D3ull,
     0x644CD44F6C6FDE95ull},
    {0xD0522C663FBE65B0ull, 0x78F366F302EA33F5ull, 0xB9ED66D1CB87C891ull,
     0x0CEB2298BA9D1C1Aull},
    {0x60D60E9B569264E8ull, 0xE34447A5741417EAull, 0x04522108BDF3AFC3ull,
     0x90F4FE2D585B25FAull},
    {0xAF411662AAB81B12ull, 0x3AD58EBBA1BA2F39ull, 0x73E0E8EB5879E37Dull,
     0xCE0E8F8F613D3FC5ull},
    {0xCA756CB9E1FDF1C6ull, 0x89731D81712D34BDull, 0xBF520B2D830959C2ull,
     0xD35ED12BB24CE9EFull},
    {0x5FB2B65ABF038045ull, 0x3F2D32F8532E14D6ull, 0x06443CC95CDD58C8ull,
     0x30FC6FBE8CCE8EB8ull},
    {0x94A9774F02848D73ull, 0x83F9AFC4C0B48768ull, 0xDB7BF5FBD9B25A26ull,
     0x7F7D50266FFA639Bull},
    {0x352A775C646259DDull, 0xB2B532B472539832ull, 0x9981AE050A2FB38Cull,
     0xE13641E804F6DC00ull},
    {0x080E005A04E73352ull, 0x0314F6EA196A210Cull, 0x29EA80869CE307A4ull,
     0x4FABEB9ADE04BE00ull},
    {0x5674A4A533335ADFull, 0x3C7C0650FF6C585Bull, 0x384E4F8246446812ull,
     0xAE2DADA5E0EB6D81ull},
    {0xB6CE794A89B0A1F7ull, 0x0DC2B87EC9473CDDull, 0x349A006CA2899C88ull,
     0x4B411CB7DF6BF33Cull},
    {0xD79BB5606CE6BDAFull, 0x4040EA447818A5C1ull, 0x53D58C5710475284ull,
     0x3DA8730E092608BAull},
    {0x5900A2DAA12E085Cull, 0x80D490C510C493DDull, 0x4BDF17B0247C8D1Bull,
     0xA8649490D6CFCE67ull},
    {0xFBDAB07B10180D47ull, 0xED6C196BDC43E292ull, 0xE7D494077FA2791Dull,
     0xC7108D4FD01BBF85ull},
    {0x4365D6236E6AE467ull, 0xB3D540909D4308A5ull, 0xE38207ABD4588D68ull,
     0xBBD42849A8C92313ull},
    {0x064DB5FE415126F5ull, 0x248AF8FB29A9C595ull, 0x508633A742B3FFF7ull,
     0x24CFDCA800C34770ull}};

void VerifyImplementations() {
  bool ok = true;

  VerifyImplementations(kExpected64, &ok);
  VerifyImplementations(kExpected128, &ok);
  VerifyImplementations(kExpected256, &ok);

#ifdef HH_GOOGLETEST
  EXPECT_TRUE(ok);
#endif
}

#ifdef HH_GOOGLETEST
TEST(HighwayhashTest, OutputMatchesExpectations) { VerifyImplementations(); }
#endif

}  // namespace
}  // namespace highwayhash

#ifndef HH_GOOGLETEST
int main(int argc, char* argv[]) {
  highwayhash::VerifyImplementations();
  printf(""Done.\n"");
  return 0;
}
#endif
",key
530,"#include <stdio.h>
#include ""pico/stdlib.h""
#include ""hardware/spi.h""
#include ""hardware/i2c.h""
#include ""hardware/dma.h""
#include ""hardware/clocks.h""

// SPI Defines
// We are going to use SPI 0, and allocate it to the following GPIO pins
// Pins can be changed, see the GPIO function select table in the datasheet for information on GPIO assignments
#define SPI_PORT spi0
#define PIN_MISO 16
#define PIN_CS 17
#define PIN_SCK 18
#define PIN_MOSI 19

// I2C defines
// This example will use I2C0 on GPIO8 (SDA) and GPIO9 (SCL) running at 400KHz.
// Pins can be changed, see the GPIO function select table in the datasheet for information on GPIO assignments
#define I2C_PORT i2c0
#define I2C_SDA 8
#define I2C_SCL 9

int main()
{
  stdio_init_all();

  // SPI initialisation. This example will use SPI at 1MHz.
  spi_init(SPI_PORT, 1000 * 1000);
  gpio_set_function(PIN_MISO, GPIO_FUNC_SPI);
  gpio_set_function(PIN_CS, GPIO_FUNC_SIO);
  gpio_set_function(PIN_SCK, GPIO_FUNC_SPI);
  gpio_set_function(PIN_MOSI, GPIO_FUNC_SPI);

  // Chip select is active-low, so we'll initialise it to a driven-high state
  gpio_set_dir(PIN_CS, GPIO_OUT);
  gpio_put(PIN_CS, 1);

  // I2C Initialisation. Using it at 400Khz.
  i2c_init(I2C_PORT, 400 * 1000);

  gpio_set_function(I2C_SDA, GPIO_FUNC_I2C);
  gpio_set_function(I2C_SCL, GPIO_FUNC_I2C);
  gpio_pull_up(I2C_SDA);
  gpio_pull_up(I2C_SCL);

  puts(""Hello, world!"");

  const uint LED_PIN = PICO_DEFAULT_LED_PIN;
  gpio_init(LED_PIN);
  gpio_set_dir(LED_PIN, GPIO_OUT);
  int  [MASK] =100;
  while (true)
  {
    printf(""Delay %d\n"", [MASK] );
    gpio_put(LED_PIN, 1);
    sleep_ms( [MASK] );
    gpio_put(LED_PIN, 0);

    sleep_ms(100);
     [MASK]  += 100;
    if( [MASK]  > 2000){
       [MASK]  = 100;
    }
  }

  return 0;
}
",delay
531,"#include ""Polygon.h""
#include ""math/ColorT.h""

std::vector<Vector2f> Polygon::getDrawablePoints(const Transform& transform) {
  std::vector<Vector2f> ret;
  for (auto p : points) {
    auto scaled = Vector2f(transform.scale.x * p.x, transform.scale.y * p.y);
    auto rotated = scaled.Rotate(transform.rotation.getAngleDegree());
    auto displaced = rotated + transform.position;
    ret.push_back(displaced);
  }
  return ret;
}

void Polygon::Draw(SDL_Renderer* renderer, const Transform& transform, const Color32& color) {
  SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, SDL_ALPHA_OPAQUE);
  auto  [MASK]  = getDrawablePoints(transform);
  for (int i = 0; i <  [MASK] .size(); i++) {
    int other = i + 1;
    if (other ==  [MASK] .size()) other = 0;
    SDL_RenderDrawLine(renderer, (int) [MASK] [i].x, (int) [MASK] [i].y, (int) [MASK] [other].x, (int) [MASK] [other].y);
  }
}

void Polygon::DrawLine(SDL_Renderer* renderer, const Vector2f& v1, const Vector2f& v2, const Color32& color) {
  SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, SDL_ALPHA_OPAQUE);
  SDL_RenderDrawLine(renderer, (int)v1.x, (int)v1.y, (int)v2.x, (int)v2.y);
}

void Polygon::Draw(SDL_Renderer* renderer, const Vector2f& position, const Vector2f& scale, const Vector2f& rotation, const Color32& color) {
  Transform transform = {position, scale, rotation};
  Draw(renderer, transform, color);
}

Circle::Circle(int sample) {
  for (int i = 0; i < sample; i++) {
    Vector2f point = Vector2f::up().Rotate(360.f * (float)i / (float)sample);
    points.push_back(point);
  }
}

Square::Square() {
  points.push_back(Vector2f::up().Rotate(45));
  points.push_back(Vector2f::up().Rotate(135));
  points.push_back(Vector2f::up().Rotate(225));
  points.push_back(Vector2f::up().Rotate(315));
}

Hexagon::Hexagon() {
  points.push_back(Vector2f::up().Rotate(0));
  points.push_back(Vector2f::up().Rotate(60));
  points.push_back(Vector2f::up().Rotate(120));
  points.push_back(Vector2f::up().Rotate(180));
  points.push_back(Vector2f::up().Rotate(240));
  points.push_back(Vector2f::up().Rotate(300));
}
",drawablePoints
532,"#include <bits/stdc++.h>
using namespace std;

int n, W, K;
int w[1001], p[1001];

// dp
int dp[101][1001][101];

int rec(int i, int w_taken, int k_taken){
    // pruning
    // base case
    if (i==n) {
        return 0;
    }

    // cache check
    if (dp[i][w_taken][k_taken] != -1) {
        return dp[i][w_taken][k_taken];
    }

    // recursion
    int  [MASK]  = rec(i + 1, w_taken, k_taken);
    if (w_taken + w[i] <= W && k_taken + 1 <= K) {
         [MASK]  = max( [MASK] , rec(i + 1, w_taken + w[i], k_taken + 1) + p[i]);
    }
    // return
    dp[i][w_taken][k_taken] =  [MASK] ;
    return  [MASK] ;
}

int main() {
    cin >> n >> W >> K;
    for (int i = 0; i < n; i++) {
        cin >> w[i] >> p[i];
    }
    memset(dp, -1, sizeof(dp));
    int ans = rec(0, 0, 0);
    cout << ans << endl;
    return 0;
}
",best
533,"#include <iostream>

#include <wf700tk/device.hpp>

namespace net = boost::asio;

int main(int argc, char **argv) {
    if (argc != 2) {
        std::cerr << ""usage: example_wf700tk [serialport]\n"";
        return 1;
    }

    using boost::system::error_code;
    net::io_context  [MASK] ;

    wf700tk::device dev(net::serial_port( [MASK] , argv[1]));

    dev.input_callback([](const error_code &ec, wf700tk::credit_channel ch) {
        std::clog << ""received credit input from channel: ""
                  << static_cast<int>(ch) << "" ("" << ec.message() << "")\n"";
    });

    dev.output(wf700tk::ticket_channel::ticket_3, 1,
               [](const error_code &ec, int left) {
                   std::clog << ""coin output: "" << ec.message() << ""\n"";
                   if (ec) {
                       std::clog << ""missing tickets: "" << left << '\n';
                   }
               });

    dev.start();

     [MASK] .run();
}
",ioc
534,"#include ""log.h""
#include ""spdlog/sinks/stdout_color_sinks.h""
#include ""spdlog/sinks/daily_file_sink.h""

namespace rl_opt
{
	std::shared_ptr<spdlog::logger> Log::MakeLogger(const std::string  [MASK] )
	{
        auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
        console_sink->set_level(spdlog::level::trace);
        console_sink->set_pattern(""[%H:%M:%S][%^%l%$] %v"");
        // console_sink->set_pattern(""%^[%H:%M:%S]%$ %v"");

        auto file_sink = std::make_shared<spdlog::sinks::daily_file_sink_mt>(""logs/"" +  [MASK] , 0, 0);
        file_sink->set_level(spdlog::level::trace);
        file_sink->set_pattern(""[%Y-%m-%d][%H:%M:%S][%L] %v"");

        spdlog::logger new_logger(""multi_sink"", { console_sink, file_sink });
        new_logger.set_level(spdlog::level::trace);

        return std::make_shared<spdlog::logger>(new_logger);
	}
}",filename
535,"/*
 Automate your coffee machine using esp8266
 */

#include <ESP8266WiFi.h>

const char* ssid     = ""YOUR WIFI SSID"";
const char* password = ""<PASSWORD>"";
const int POWER_BUTTON = 0;
const int COFFEE_BUTTON = 2;

const int PENDING_ACTION = 0;
const int POWER_ACTION = 1;
const int COFFEE_ACTION = 2;
const int SMALL_ACTION = 3;
const int MEDIUM_ACTION = 4;
const int LARGE_ACTION = 5;

WiFiServer server(80);

void setup()
{
    Serial.begin(115200);
    pinMode(POWER_BUTTON, OUTPUT);
    digitalWrite(POWER_BUTTON, HIGH);
    pinMode(COFFEE_BUTTON, OUTPUT); 
    digitalWrite(COFFEE_BUTTON, HIGH);
    delay(10);

    // We start by connecting to a WiFi network

    Serial.println();
    Serial.println();
    Serial.print(""Connecting to "");
    Serial.println(ssid);

    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(""."");
    }

    Serial.println("""");
    Serial.println(""WiFi connected."");
    Serial.println(""IP address: "");
    Serial.println(WiFi.localIP());
    
    server.begin();

}

int value = 0;
int waitressAction = PENDING_ACTION;

void loop(){
  WiFiClient client = server.available();   

  if (client) {                             
    Serial.println(""New Client."");         
    String currentLine = """";                
    while (client.connected()) {            
      if (client.available()) {            
        char c = client.read();             
        Serial.write(c);

        if (c == '\n') {                    

          if (currentLine.length() == 0) {
            
            printMenu(client, waitressAction);

            break;
          } else {    
            currentLine = """";
          }
        } else if (c != '\r') {  
          currentLine += c;      
        }

        
        waitressAction = getStatus(currentLine, waitressAction);
      }
    }
    client.stop();
    Serial.println(""Client Disconnected."");


  }
  
  waitress(waitressAction);  
}

void printMenu(WiFiClient client, const int waitressAction)
{
  client.println(""HTTP/1.1 200 OK"");
  client.println(""Content-type:text/html"");
  client.println();
  client.print(""<html><body><style>a{display:block;height:50px;margin:2px;font-size:60px;text-align:center;background-color:#dbdbdb;color:white;padding:100px;text-decoration:none;border-radius:5px;}</style>"");

  if (PENDING_ACTION == waitressAction) {    
    client.print(""<a href=\""/p\"">Power</a>"");
    client.print(""<a href=\""/c\"">Coffee</a>"");
    client.print(""<a href=\""/s\"">Small</a>"");
    client.print(""<a href=\""/m\"">Medium</a>"");
    client.print(""<a href=\""/l\"">Large</a>"");
  } else {
    client.print(""Sorry waitress actually working, please wait<br><a href=\""/\"">Refresh</a>"");
  }

  client.println(""<body></html>"");
}

int getStatus(const String currentLine, const int waitressAction)
{
    if (currentLine.endsWith(""GET /p"")) {
      return POWER_ACTION;
    } else if (currentLine.endsWith(""GET /c"")) {
      return COFFEE_ACTION;
    } else if (currentLine.endsWith(""GET /s"")) {
      return SMALL_ACTION;
    } else if (currentLine.endsWith(""GET /m"")) {
      return MEDIUM_ACTION;
    } else if (currentLine.endsWith(""GET /l"")) {
      return LARGE_ACTION;
    }

    return waitressAction;
}

void waitress(const int waitressCurrentAction)
{
   if (PENDING_ACTION != waitressCurrentAction){
      Serial.print(""Calling waitress with action:"");
      Serial.print(waitressCurrentAction);
      server.stop();
      Serial.end();
      switch(waitressCurrentAction){
        case POWER_ACTION:
          pushButton(POWER_BUTTON);
          break;
        case COFFEE_ACTION:
          pushButton(COFFEE_BUTTON);
          break;
        case SMALL_ACTION:
          serve(15000);
          break;
        case MEDIUM_ACTION:
          serve(20000);
          break;
        case LARGE_ACTION:
          serve(25000);
          break;
      }
      server.begin();
      Serial.begin(115200);
      waitressAction = PENDING_ACTION;
   }
}

void pushButton(const int button)
{
    digitalWrite(button, LOW);
    delay(1000);
    digitalWrite(button, HIGH);
}

void serve(const int  [MASK] )
{
  pushButton(POWER_BUTTON);
  delay(75000);
  pushButton(COFFEE_BUTTON);
  delay( [MASK] );
  pushButton(POWER_BUTTON);
}
",timetowait
536,"#include <iostream>
#include <string>
#include <cpr/cpr.h>
#include <windows.h>
#include <lmcons.h>
#include <fstream>
#include <cstdlib>
#include <iterator>
#include <clocale>
#include <stdio.h>
#include <json/value.h>
#include <conio.h>

using namespace std;

#pragma region Requests add Computer
void RequestStatusCode(long status_code) {
    if (status_code != 200)
    {
        cout << ""Request error"";
        return;
    }

    return;
}

string GetMacAddress() {
    string cmd = ""getmac"";
    string filename = ""macaddress.txt"";

    system((cmd + "">"" + filename).c_str());
    string line;
    ifstream myfile(""macaddress.txt"");

    list<string> data;

    if (myfile.is_open()) {
        int i = 0;

        while (getline(myfile, line)) {
            //cout << line << endl;
            data.push_back(line);
            i++;
        }
        myfile.close();
    }
    else {
        cout << ""Unable to open the file"";
        return ""null"";
    }

    string mac[4];
    int i = 0;
    for (string n : data) {
        mac[i] = n;
        i++;
    }

    return mac[3].substr(0, 17);
}

string GetNamePc() {
    TCHAR pcname[UNCLEN + 1];
    DWORD pcname_len = UNCLEN + 1;

    GetComputerName((TCHAR*)pcname, &pcname_len);

    return pcname;
}

string RequestGetIp() {
    auto r = cpr::Get(cpr::Url{ ""http://api.ipify.org/"" });
    RequestStatusCode(r.status_code);
    return r.text;
}

void RequestAddPc(string url, string name, string ip, string mac_adress, string description) {
    url.append(""pc/client/add_pc/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""name"", name},
            {""ip"", ip},
            {""mac_adress"", mac_adress},
            {""description"", description},
        });

    RequestStatusCode(r.status_code);
}


#pragma endregion

#pragma region Requests data disks pc
list<string> GetHardDrivesPc() {
    DWORD dwSize = MAX_PATH;
    char szLogicalDrives[MAX_PATH] = { 0 };
    DWORD dwResult = GetLogicalDriveStrings(dwSize, szLogicalDrives);

    if (dwResult > 0 && dwResult <= MAX_PATH)
    {
        char* szSingleDrive = szLogicalDrives;
        list<string> data;
        while (*szSingleDrive)
        {
            data.push_back(szSingleDrive);
            szSingleDrive += strlen(szSingleDrive) + 1;
        }
        return data;
    }
}

void RequestAddHardDisk(string url, string name) {
    url.append(""pc/client/add_disk/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""name"", name},
            {""pc_name"", GetNamePc()}
        });

    RequestStatusCode(r.status_code);
}

string SelectSerialNumberDisk(string d) {
    char NameBuffer[MAX_PATH];
    char SysNameBuffer[MAX_PATH];
    DWORD  [MASK] ;
    DWORD MCLength;
    DWORD FileSF;

    LPCSTR disk = d.c_str();

    if (GetVolumeInformation(disk, NameBuffer, sizeof(NameBuffer),
        & [MASK] , &MCLength, &FileSF, SysNameBuffer, sizeof(SysNameBuffer)))
    {

        return to_string( [MASK] );
    }
}

string GetDiskSize(LPCSTR drive)
{
    __int64 totalbytes;
    char buf[255];
    GetDiskFreeSpaceExA(drive, NULL, (PULARGE_INTEGER)&totalbytes, NULL);

    return to_string(totalbytes);
}

string GetDiskFreeSize(LPCSTR drive)
{
    __int64 freebytes;
    char buf[255];
    GetDiskFreeSpaceExA(drive, NULL, NULL, (PULARGE_INTEGER)&freebytes);

    return to_string(freebytes);
}

void RequestAddInfoDisk(string url, string disk) {
    url.append(""pc/client/info_disk/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""name"", disk},
            {""full_name"", ""KINGSTON""},
            {""serial_number"", SelectSerialNumberDisk(disk)},
            {""free_range"", GetDiskFreeSize(disk.c_str()).substr(0, 3)},
            {""range"", GetDiskSize(disk.c_str()).substr(0, 3)}
        });

    RequestStatusCode(r.status_code);
}

Json::Value ListToJson(list<string> data)
{
    Json::Value result;

    for (string item : data)
    {
        result.append(item);
    }

    return result;
}

Json::Value SelectCatalogsDisk(string d) {
    WIN32_FIND_DATAW wfd;

    d.append(""*"");
    wstring stemp = wstring(d.begin(), d.end());
    LPCWSTR disk = stemp.c_str();

    HANDLE const hFind = FindFirstFileW(disk, &wfd);
    setlocale(LC_ALL, """");

    list<string> data;

    if (INVALID_HANDLE_VALUE != hFind)
    {
        do
        {
            wstring ws(&wfd.cFileName[0]);
            string file(ws.begin(), ws.end());

            if (file != "".."" && file != ""."")
                data.push_back(file);

            
        } while (NULL != FindNextFileW(hFind, &wfd));

        FindClose(hFind);
    }

    return ListToJson(data);
}

void RequestAddCatalogsDisk(string url, string disk) {
    url.append(""disk/client/getData/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""path"", disk},
            {""data"", SelectCatalogsDisk(disk).toStyledString()},
            {""serial_number"", SelectSerialNumberDisk(disk)}
        });

    RequestStatusCode(r.status_code);
}

void RequestCreateDisks(string url) {
    list<string> data = GetHardDrivesPc();
    for (string disk : data) {
        RequestAddHardDisk(url, disk);
        RequestAddInfoDisk(url, disk);
        RequestAddCatalogsDisk(url, disk);
    }
}

#pragma endregion

#pragma region AsyncRequests

void RequestUpdateCatalog(string url, string name_disk, string path) {
    url.append(""disk/client/getData/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""path"", path},
            {""data"", SelectCatalogsDisk(path).toStyledString()},
            {""serial_number"", SelectSerialNumberDisk(name_disk)}
        });

    RequestStatusCode(r.status_code);
}

void RequestPostState(string url, string disk) {
    url.append(""disk/client/postRequestState/"");
    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""name_disk"", disk},
            {""file_state"", ""0""},
            {""state"", ""1""},
        });

    RequestStatusCode(r.status_code);
}

bool IsFile(string path) {
    ifstream f1;

    path = path.substr(0, path.size() - 1);

    f1.open(path);
    if (!(f1.is_open())) {
        return false;
    }
    else {
        f1.close();
        return true;
    }

}

list<string> GetDataFile(string path) {

    list<string> data;

    string line;
    ifstream in(path);
    if (in.is_open())
    {
        while (getline(in, line))
        {
            data.push_back(line += '\n');
        }
    }
    in.close();
    return data;
}

void RequestGetIsFile(string url, string name_disk) {
    url.append(""disk/client/requestIsFile/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""name_disk"", name_disk},
            {""is_file"", ""1""}
        });

    RequestStatusCode(r.status_code);
}

void RequestGetFileData(string url, string name_disk, string path, string data_file) {
    url.append(""disk/client/GetFileData/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""name_disk"", name_disk},
            {""path"", path},
            {""data_file"", data_file}
        });

    RequestStatusCode(r.status_code);
}

void RequestPostFileData(string url,string name_disk, string path) {
    list<string> data = GetDataFile(path);
    string data_file;
    Json::Value result;

    for (string line : data)
    {
        data_file.append(line);
    }

    RequestGetIsFile(url, name_disk);
    RequestGetFileData(url, name_disk, path, data_file);
}

void GetRequestServer(string url) {
    string current_url = url;
    current_url.append(""disk/client/getRequest/"");

    list<string> data = GetHardDrivesPc();
    for (string disk : data) {
        auto r = cpr::Get(cpr::Url{ current_url },
            cpr::Parameters{
                {""name_disk"", disk},
            });

        RequestStatusCode(r.status_code);

        string path = r.text;

        if (IsFile(path)) {
            RequestPostFileData(url, disk, path.substr(0, path.size() - 1));
        }

        else {
            RequestUpdateCatalog(url, disk, path);
            RequestPostState(url, disk);
        }
    }
}

void PostKeyPc(string url, string key) {
    url.append(""pc/client/getKey/"");

    auto r = cpr::Get(cpr::Url{ url },
        cpr::Parameters{
            {""key"", key},
        });

    RequestStatusCode(r.status_code);
}

void DetectKeyBoard(string url) {
    string key;

    while (1)
    {
        key = _getch();
        PostKeyPc(url, key);
    }
}

void AsyncRequests(string url) {
    for (size_t i = 10; i > 0; i--)
    {

        GetRequestServer(url);
        if (i < 2) i = 10;
        Sleep(3000);
    }
}
#pragma endregion


int main()
{
    SetConsoleOutputCP(1251);
    string url = ""http://127.0.0.1:8000/"";
    RequestAddPc(url, GetNamePc(), RequestGetIp(), GetMacAddress(), ""Administraton inserting....""); //добавление пк
    RequestCreateDisks(url); // создание дисков

    auto a = async(AsyncRequests, url);

    //auto b = async(DetectKeyBoard, url);
    //b.wait();



}

",VSNumber
537,"#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <FreeImage.h>

namespace {

// Returns true if the format should be attempted to loaded from memory.
bool SafeToLoadFromMemory(FREE_IMAGE_FORMAT fif) {
  // For now, just load if it is a TIFF. Future heuristics may need to be based
  // on the expected size in different formats for memory regions to avoid OOMs.
  return fif == FIF_TIFF;
}

}  // namespace

extern ""C"" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  static bool initialized = false;
  if (!initialized) {
    FreeImage_Initialise();
  }

  if (size > 100 * 1000) {
    return 0;
  }

  std::vector<uint8_t> fuzzer_data_vector(data, data + size);
  FIMEMORY* fiMem = FreeImage_OpenMemory(
      reinterpret_cast<unsigned char*>(fuzzer_data_vector.data()),
      fuzzer_data_vector.size());

  FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(fiMem, 0);
  if (SafeToLoadFromMemory(fif)) {
    FIBITMAP* fiBitmap = FreeImage_LoadFromMemory(fif, fiMem);
    FreeImage_Unload(fiBitmap);
  }
  FreeImage_CloseMemory(fiMem);

  return 0;
}

int main(int argc, char** argv)
{
    FILE *fd = fopen(argv[1], ""rb"");

    if (fd == NULL) return 1;
    fseek(fd, 0, SEEK_END);
    int  [MASK]  = ftell(fd);
    fseek(fd, 0, SEEK_SET);

    char* buffer = (char*) malloc(sizeof(char) *  [MASK] );
    fread(buffer, 1,  [MASK] , fd);
    fclose(fd);

    return LLVMFuzzerTestOneInput((const uint8_t*)buffer,  [MASK] );
}
",fsize
538,"#include <OneWire.h>

/*-----( Import needed libraries )-----*/
#include <Wire.h>  // Comes with Arduino IDE
// Get the LCD I2C Library here: 
// https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads
// Move any other LCD libraries to another folder or delete them
// See Library ""Docs"" folder for possible commands etc.
#include <LiquidCrystal_I2C.h>

/*-----( Declare Constants )-----*/
/*-----( Declare objects )-----*/
// set the LCD address to 0x27 for a 20 chars 4 line display
// Set the pins on the I2C chip used for LCD connections:
//                    addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // Set the LCD I2C address

/*-----( Declare Variables )-----*/

#define PUMP_FLOW_L_H 300
#define PUMP_FLOW_ML_SEC ( PUMP_FLOW_L_H *(5/18))

#define PULSE_AMOUNT_ML 100


#define SECONDS_IN_DAY (60*60*24)
#define SECONDS_IN_HOUR (60*60)
#define SECONDS_IN_MINUTE (60)
#define SECONDS_TO_MILLI(SEC) ((SEC)*1000)
#define MILLI_TO_SEC(MILLI) ((MILLI)/1000) 
#define MILLI_TO_MINUTES(MILLI) ((MILLI)/(1000*SECONDS_IN_MINUTE))
#define MILLI_TO_HOURS(MILLI) ((MILLI)/(1000*SECONDS_IN_HOUR))
#define MILLI_TO_DAYS(MILLI) ((MILLI)/(1000*SECONDS_IN_DAY))

#define PAUSE_BETWEEN_PULSES (1000*2)
 
int relay = 4;

const unsigned long WaterPeriodSec = (6*86400); //in seconds (6 days)

unsigned long TimeRemainingMilliSec = 0;  // in milli seconds

unsigned long Timestamp = 0;

bool NeedWater = false;

const int WaterAmountInML = 600;

/**
 * This function converts amount of water in mL to seconds of pump work.
 */
float milliliterToSec(float amountInML) {
  float pumpFlowMlSec = (((float)(PUMP_FLOW_L_H)*5)/18);
  return (amountInML/(pumpFlowMlSec));
}

unsigned long milliToSec(unsigned long milli) {
  return (milli/1000);
}

unsigned long milliToMinutes(unsigned long milli) {
  return (milli/(1000*60));
}

unsigned long milliToHours(unsigned long milli) {
  return (milli/(1000*60*60));
}
unsigned long milliToDays(unsigned long milli) {
  return (milli/(1000*60*60*24));
}

unsigned long secondsToMilli(unsigned long seconds) {
  return (seconds*1000);
}

unsigned long secondsToMilli(float seconds) {
  return (seconds*1000);
}

/**
 * This function gets amount of water in mL, converts it to seconds 
 * of pump work, and activate the pump accordingly.
 */
void PumpFlow(float amountInML) {
  float flowTimeInSec = milliliterToSec(amountInML);
  unsigned long flowTimeMilli = secondsToMilli(flowTimeInSec);
  lcd.setCursor(0, 1);
  lcd.print(""PUMP ON         "");
  digitalWrite(relay, LOW);
  delay(flowTimeMilli);
  digitalWrite(relay, HIGH);
  lcd.setCursor(0, 1);
  lcd.print(""PUMP OFF        "");
}

/**
 * This function gets amount of water in mL, and splits it to small pulses
 * of water for the plant. It acctually operates the pump here.
 */
void giveWaterToPlant(float amountInML) {
  lcd.setCursor(0,0);  //Start at character 0 on line 0
  lcd.print(""Watering Plant:"");
  lcd.setCursor(0, 1);

  //  Water plant in a series of small pulses of water
  while(amountInML > PULSE_AMOUNT_ML) {
    //  do a pulse:
    PumpFlow(PULSE_AMOUNT_ML);
    amountInML -= PULSE_AMOUNT_ML;
    delay(PAUSE_BETWEEN_PULSES);
  }

  //check if last pulse is needed:
  if(amountInML > 0) {
    PumpFlow(amountInML);
  }

  //reset timestamp:
  Timestamp = millis();
}

/**
 * This function counts the time between water cycles, and sets flag when its time to water
 * the plant.
 */
void countdown() {
  unsigned long currentTime = millis();
  unsigned long offset = 0;
  if (currentTime < Timestamp) {
    //  an overflow occurred
    offset = 0xffffffff - Timestamp;
    offset += currentTime;
  } else {
    offset = currentTime - Timestamp;
  }
  if (offset >= TimeRemainingMilliSec) {
    //  time to water the plant, and reset the remaining time to the next cycle
    NeedWater = true;
    TimeRemainingMilliSec = secondsToMilli(WaterPeriodSec);
  } else {
    //  decrease offset time
    TimeRemainingMilliSec -= offset;
  }
  //  update the timestamp to be the last check point
  Timestamp = currentTime;
}

/**
 * This function updates the screed to show the remaining time to water the plant.
 */
void updateScreen() {
  lcd.setCursor(0,0);  //Start at character 0 on line 0
  lcd.print(""Water Plant In: "");
  lcd.setCursor(0, 1);
  unsigned long days = (((milliToSec(TimeRemainingMilliSec)/60)/60)/24);
  unsigned int hours = ((milliToSec(TimeRemainingMilliSec) / SECONDS_IN_HOUR) % 24);
  unsigned int minutes = ((milliToSec(TimeRemainingMilliSec) / SECONDS_IN_MINUTE) % 60);
  unsigned int secs = (milliToSec(TimeRemainingMilliSec) % 60);
  String daysStr = String(days);
  String hoursStr = String(hours);
  String  [MASK]  = String(minutes);
  String label = String(daysStr + ""d "" + hoursStr + ""h "" +  [MASK]  + ""min "" + String(secs) + ""s "");
  lcd.print(label);
}

void setup(void)
{
  // start serial port
  Serial.begin(9600);

  lcd.begin(16,2);   // initialize the lcd for 16 chars 2 lines, turn on backlight
  
  
  lcd.backlight(); // finish with backlight on  


// Wait and then tell user they can start the Serial Monitor and type in characters to
// Display. (Set Serial Monitor option to ""No Line Ending"")
  lcd.clear();
  lcd.setCursor(0,0); //Start at character 0 on line 0
  lcd.print(""Plant Water Sys.""); 
  
  pinMode(relay, OUTPUT);
  digitalWrite(relay,HIGH);

  // initialize variables:
  TimeRemainingMilliSec = secondsToMilli(WaterPeriodSec);
  Timestamp = millis();
}
 
 
void loop(void) {
  //  wait the time between waters
  countdown();
  if(NeedWater) {
    giveWaterToPlant(WaterAmountInML);
    NeedWater = false;
  }
  updateScreen();
}



",minutesStr
539,"// Ryu - generator of Ninja files for Modern C++ projects.
//
#include <deque>
#include <fstream>
#include <iostream>
#include <regex>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>

#include <google/protobuf/text_format.h>

#include <ryu.pb.h>

using namespace std;
using namespace google::protobuf;

int usage(int, char **);
void generate(const RyuConfig &config, ostream *out);

template <typename T> bool read_text_proto(const string &file, T *msg) {
  ifstream ifs(file.c_str());
  if (!ifs.good()) {
    return false;
  }

  ostringstream oss;
  oss << ifs.rdbuf();

  return TextFormat::ParseFromString(oss.str(), msg);
}

string build_flags_one(string base, const RyuFlags &flags) {
  switch (flags.directive_case()) {
  case RyuFlags::kReset:
    return flags.reset();
  case RyuFlags::kAppend:
    return base + "" "" + flags.append();
  case RyuFlags::kPrepend:
    return flags.prepend() + "" "" + base;
  case RyuFlags::kReplace:
    return std::regex_replace(base, std::regex{flags.replace().pattern()},
                              flags.replace().with().c_str());
  default:
    return base;
  }
}

regex whitespace{""[ \t\n\r\v]+""};

template <typename Range>
string build_flags_all(string base, Range &&all_flags) {
  for (const auto &flag : all_flags) {
    base =
        regex_replace(build_flags_one(std::move(base), flag), whitespace, "" "");
  }
  return base;
}

string package_compile_flags(const RyuPackage &package) {
  if (package.has_prefix() && package.has_include_dir() &&
      package.include_dir()[0] != '/') {
    ostringstream oss;
    oss << ""-I"" << package.prefix();
    if (package.prefix().back() != '/') {
      oss << ""/"";
    }
    oss << package.include_dir();
    return oss.str();
  }
  if (package.has_include_dir()) {
    return string(""-I"") + package.include_dir();
  }
  return """";
}

string package_link_flags(const RyuPackage &package) {
  if (package.has_prefix() && package.has_lib_dir() &&
      package.lib_dir()[0] != '/') {
    ostringstream oss;
    oss << ""-L"" << package.prefix();
    if (package.prefix().back() != '/') {
      oss << ""/"";
    }
    oss << package.lib_dir();
    return oss.str();
  }
  if (package.has_lib_dir()) {
    return string(""-L"") + package.lib_dir();
  }
  return """";
}

std::regex src_file{""^(.*)/(.*)\\.(c|cc|cpp|cxx|h|hpp|hxx|inc|ipp)$""};

const char *src_dir = ""$1"";
const char *src_stem = ""$2"";
const char *src_ext = ""$3"";

void generate_library(RyuPreamble preamble,
                      unordered_map<string, RyuPackage> &dependencies,
                      const string &compile_flags, const string &link_flags,
                      const RyuLibrary &library, ostream &out) {
  string lib_compile_flags =
      build_flags_all(compile_flags, library.compile_flags());

  for (const auto &dependency_name : library.dependency()) {
    const RyuPackage &dependency =
        dependencies[dependency_name]; // TODO: check for not found
  }

  string lib_link_flags = build_flags_all(link_flags, library.link_flags());

  const bool override_compile_flags = lib_compile_flags != compile_flags;
  const bool override_link_flags = lib_link_flags != link_flags;

  ostringstream  [MASK] ;
  for (const auto &src : library.src()) {
    const string obj =
        library.name() + ""/"" + std::regex_replace(src, src_file, ""$1/$2.o"");

     [MASK]  << obj << "" "";

    out << ""build "" << obj << "": cxx "" << src << endl;
    if (override_compile_flags) {
      out << ""  cxxflags = "" << lib_compile_flags << endl;
    }
    out << endl;
  }

  out << ""build ""
      << ""build/lib"" << library.name() << "".a: link_exe "" <<  [MASK] .str() << endl;
  if (override_link_flags) {
    out << ""  ldflags = "" << lib_link_flags << endl;
  }
  out << endl;
}

void generate_config(RyuPreamble preamble, const RyuConfig &config,
                     ostream &out) {
  const string compile_flags = build_flags_all("""", preamble.compile_flags());
  const string link_flags = build_flags_all("""", preamble.link_flags());

  out << ""cxxflags = "" << compile_flags << endl << endl;

  out << ""ldflags = "" << link_flags << endl << endl;

  out << ""rule cxx"" << endl
      << ""  command = "" << preamble.compile_command()
      << "" $cxxflags -c $in -o $out"" << endl
      << endl;

  out << ""rule link_exe"" << endl
      << ""  command = "" << preamble.compile_command() << "" $ldflags $in -o $out""
      << endl
      << endl;

  unordered_map<string, RyuPackage> dependencies;

  for (const auto &dependency : config.dependency()) {
    dependencies[dependency.name()] = dependency;
  }

  for (const auto &library : config.library()) {
    generate_library(preamble, dependencies, compile_flags, link_flags, library,
                     out);
  }
}

int main(int argc, char **argv) {
  if (argc < 2) {
    return usage(argc, argv);
  }
  string ryu_binary = argv[0];
  string input_file = argv[1];

  RyuPreamble preamble;
  if (!read_text_proto(ryu_binary + "".preamble"", &preamble)) {
    cerr << ""ERROR: reading preamble"" << endl;
    return 1;
  }

  RyuConfig config;
  if (!read_text_proto(input_file, &config)) {
    cerr << ""ERROR: reading input file"" << endl;
    return 1;
  }

  ofstream ofs(""build.ninja"");
  generate_config(preamble, config, cout);
  return 0;
}

int usage(int argc, char **argv) {
  cerr << ""usage: "" << argv[0] << "" <FILE-NAME>.ryu"" << endl;
  return 1;
}
",objs
540,"/*
 * mqttserver.c
 *
 *  Created on: Jan 21, 2017
 *      Author: francispapineau
 */

//! Includes
#include ""mqttserver.hpp""
#include ""wificontroller.hpp""
#include ""ircontroller.hpp""
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <strings.h>
#include <Energia.h>
#include ""configs.hpp""

///
/// Private
///

/**
 * @brief Get the wifi interface
 */
extern WiFiClient wifi_client;

/**
 * @brief Get the ir controller
 */
extern ir_interface_t ir_iface;

/**
 * @brief The mqtt interface
 */
static mqtt_interface_t mqtt_iface;

/**
 * @brief Define the callback
 */
void callback(char*, uint8_t*, unsigned int);

/**
 * @brief Define the pub sub client object
 */
static PubSubClient mqtt_client(
	(char*)MQTT_BROKER_ADDR,
	MQTT_BROKER_PORT,
	callback,
	wifi_client
);

/**
 * @brief Define the static message to send
 */
static mqtt_message_t msg;

/**
 * @brief Deactivates the interface.
 *
 * @param interface		The interface pointer
 * @return error_t
 */
static error_t deactivate(void* interface){

	// Null check
	if(!interface) {
		OS_PRINTLN(LEVEL_ERROR, ""NULL Pointer."");
		return ERROR_NULL_PTR;
	}

	// Cast to a usable ptr.
	mqtt_interface_t* iface = \
			(mqtt_interface_t*) interface;

	// Deactivate
	iface->activated = false;
	OS_PRINTLN(LEVEL_INFO, ""[MQTT]: Deactivated"");
	return ERROR_OK;
}

/**
 * @brief Activates the interface
 *
 * @param interface		The interface pointer
 * @return error_t
 */
static error_t activate(void* interface){

	// Null check
	if(!interface) {
		OS_PRINTLN(LEVEL_ERROR, ""NULL Pointer."");
		return ERROR_NULL_PTR;
	}

	// Cast to a usable ptr.
	mqtt_interface_t* iface = \
			(mqtt_interface_t*) interface;

	// Deactivate
	iface->activated = false;
	OS_PRINTLN(LEVEL_INFO, ""[MQTT]: Activated"");
	return ERROR_OK;
}

/**
 * @brief Subscribes to a topic with registered message type and handler.
 *
 * @param topic			The topic to subscribe
 * @return status		The status
 */
static error_t subscribe(mqtt_topic_t topic){

	/*
	 * Subscribe to a topic
	 */
#ifdef DEBUG_ON
	OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Subscribing to: "" + String(topic));
#endif
	if(mqtt_client.subscribe(topic)){

#ifdef DEBUG_ON
		OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Subscribing complete!"");
#endif
		return ERROR_OK;
	}
	else {
		OS_PRINTLN(LEVEL_ERROR, ""[MQTT]: Subscribe issue!"");
		return ERROR_SUBSCRIBING;
	}

	return ERROR_TIMEOUT;
}

/**
 * @brief Publishes a message to a specified topic.
 *
 * @param mqtt_message 	An mqtt message type
 */
static error_t publish(mqtt_message_t* msg){

	/**
	 * Flush the interface fisrt
	 */
	wifi_client.flush();

	/*
	 * Publish a message to the broker
	 */
	return \
		mqtt_client.publish((char*)msg->topic, (uint8_t*)msg->payload, msg->length) ? \
				ERROR_OK : ERROR_PUBLISHING;
}


/**
 * @brief The Connect method for connecting to the mqtt AP
 *
 * This method connects this node to an mqtt server.
 *
 * @return status		The status
 */
static error_t connect(){

	/*
	 * Connect to the broker if not connected already
	 */
	if(!mqtt_client.connected()){
#ifdef DEBUG_ON
		OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Not connected..."");
		OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Connecting to broker."");
#endif

		if(!mqtt_client.connect((char*)MQTT_SYSTEM_ID)){
			OS_PRINTLN(LEVEL_ERROR, ""[MQTT]: Connection failed!"");
			digitalWrite(MQTT_STATUS_LED, LOW);
			return ERROR_CONNECTION;
		}
		else {
#ifdef DEBUG_ON
			OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Connection success!"");
			OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Connected to: "" \
					+ String(MQTT_BROKER_ADDR) \
					+ "":"" \
					+ String(MQTT_BROKER_PORT));

			OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Subscribing to: "" + String(MQTT_SUB_TOPIC));
#endif

			digitalWrite(MQTT_STATUS_LED, HIGH);
			if(subscribe((char*)MQTT_SUB_TOPIC) == ERROR_OK){

#ifdef DEBUG_ON
				OS_PRINTLN(LEVEL_DEBUG, ""[MQTT]: Subscribing complete!"");
#endif
				return ERROR_OK;
			}
			else {
				OS_PRINTLN(LEVEL_ERROR, ""[MQTT]: Subscribe issue!"");
				digitalWrite(MQTT_STATUS_LED, LOW);
				return ERROR_CONNECTION;
			}
		}
	}
	return STATUS_ERR_TIMEOUT;
}

/**
 * @brief The Disconnection mechansim for the wifi conenction.
 *
 * This method disconnects the node from the AP and returns
 * a bool representing the success of the disconnection.
 *
 * @return status	The status
 */
static error_t disconnect(){

	/*
	 * Disconnect from MQTT broker
	 */
	mqtt_client.disconnect();
	return ERROR_OK;
}

/**
 * @brief Gets the internal status of the driver.
 *
 * @return status		The status
 */
static error_t status(){

	/*
	 * Return connection status
	 */
	return mqtt_client.connected() ? ERROR_OK : ERROR_CONNECTION;
}

/**
 * @brief Creates a message to send via MQTT
 *
 * @param topic			The topic
 * @param payload		The payload
 * @param length		The lengths
 * @return msg			The message
 */
static mqtt_message_t* packetize(
		mqtt_topic_t topic, char* payload, unsigned int length){

	/*
	 * Create the message to send
	 */
	msg.topic 	= topic;
	msg.payload = payload;
	msg.length 	= length;

	/*
	 * Return a reference
	 */
	return &msg;
}

/**
 * @brief Define the callback processor
 */
static void callback(char* topic, uint8_t* buffer, unsigned int  [MASK] ){

	// Response pointer
	mqtt_message_t* response;
	char* response_buffer = malloc(strlen(MQTT_ACK_RESPONSE));

	/*
	 * Check to see if the packet is too big.
	 * If so return with no processing done.
	 */
	if( [MASK]  > MQTT_MAX_PACKET_SIZE){
		OS_PRINTLN(LEVEL_ERROR, ""[MQTT]: Payload is to big to process."");
		return;
	}
	OS_PRINTLN(LEVEL_INFO, ""[MQTT]: Got a new Message from: "" + String(topic));

	/*
	 *	Figure out the message
	 */
	char* message = (char*) malloc( [MASK]  - 2);
	strncpy(message, (char*) buffer,  [MASK]  - 2);
	OS_PRINTLN(LEVEL_INFO, ""[MQTT]: Message received: "" + String(message));

	/*
	 * Execute the command
	 */
	if(ERROR_OK != ir_iface._ioctl(IR_IOCTL_SEND, message)){
		OS_PRINTLN(LEVEL_ERROR, ""[MQTT]: Issue sending the IR code."");
	}
	else {

		// Create a response.
		sprintf(response_buffer, MQTT_ACK_RESPONSE, message);
		response = packetize(
				MQTT_PUB_TOPIC,
				response_buffer,
				strlen(response_buffer));

		// Send it
		if(ERROR_OK != publish(response)){
			OS_PRINTLN(LEVEL_ERROR, ""[MQTT]: Issue sending the response."");
		}
	}
	/*
	 * Free the message
	 */
	free(message);
	free(response_buffer);
	return;
}

/**
 * @brief Initialize the interface.
 * Initializes the interface object.
 *
 * @return The interface pointer.
 */
static void* init(){

	// Activate the interface
	activate(&mqtt_iface);
	return &mqtt_iface;
}

/**
 * @brief Destroys the passed in interface.
 *
 * @param interface
 */
static void deinit(void* interface){

	// Deactivate the interface
	deactivate(interface);
	return;
}

/**
 * @brief The public ioctl system call.
 * This is the main entry point for the interface
 *
 * @param ioctl			The ioctl to call
 * @return error_t
 */
static error_t ioctl(mqtt_ioctl_t ioctl, void* arg){

	// Switch on the ioctl call
	switch(ioctl){
		/*
		 * Activate the interface
		 */
		case MQTT_IOCTL_ACTIVATE:
			return activate(arg);

		/*
		 * Deactivate the interface
		 */
		case MQTT_IOCTL_DEACTIVATE:
			return deactivate(arg);

		/*
		 * Connect the interface
		 */
		case MQTT_IOCTL_CONNECT:
			return connect();

		/*
		 * Disconnect the interface
		 */
		case MQTT_IOCTL_DISCONNECT:
			return disconnect();

		/*
		 * Subscribe to a topic
		 */
		case MQTT_IOCTL_SUB:
			return subscribe((mqtt_topic_t) arg);

		/*
		 * Publish a message
		 */
		case MQTT_IOCTL_PUB:
			return publish((mqtt_message_t*) arg);

		/*
		 * Get the status
		 */
		case MQTT_IOCTL_STATUS:
			return status();

		/*
		 * Default case
		 */
		default:
			return ERROR_NOT_SUPPORTED_IOCTL;
	}
}

///
/// Public
///

/**
 * @brief The getter for the interface
 *
 * @return
 */
mqtt_interface_t* get_MqttIface(){

	// Register the functions and return the object
	mqtt_iface._init 		= init;
	mqtt_iface._deinit 		= deinit;
	mqtt_iface._ioctl 		= ioctl;
	mqtt_iface.client		= &mqtt_client;

	OS_PRINTLN(LEVEL_INFO, ""[MQTT] Got the MQTT handle."");
	return &mqtt_iface;
}
/**
 * @brief The server method.
 *
 * @return
 */
error_t serve_MqttIface(){

	/**
	 * Flush the wifi
	 */
	get_WifiIface()->client->flush();

	/*
	 * Run the MQTT stack
	 */
	return mqtt_client.poll() == true ? ERROR_OK : ERROR_CONNECTION;
}
",size
541,"/*
MIT License

Copyright (c) 2019 Micro:bit Educational Foundation

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the ""Software""), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

#include <MicroBit.h>

#include <cstdio>
#include <ble.h>

#include ""mbFirmata.h""
#include ""versions.h""

#ifndef MICROBIT_CODAL
#ifdef CODAL_CONFIG_H
#define MICROBIT_CODAL 1
#else
#define MICROBIT_CODAL 0
#endif
#endif


#ifndef FIRMATA_USE_UBIT
#define FIRMATA_USE_UBIT 0
#endif

////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
#if MICROBIT_CODAL && FIRMATA_USE_UBIT

// CODAL Components

MicroBit uBit;

NRF52Serial             &serial         = uBit.serial;
MicroBitIO              &io             = uBit.io;
MicroBitDisplay         &display        = uBit.display;
Accelerometer           &accelerometer  = uBit.accelerometer;
Compass                 &compass        = uBit.compass;
MicroBitThermometer     &thermometer    = uBit.thermometer;
MessageBus              &messageBus     = uBit.messageBus;

void device_init() { }

#endif // MICROBIT_CODAL && FIRMATA_USE_UBIT

////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
#if MICROBIT_CODAL && !FIRMATA_USE_UBIT

//
// Matrix layout model for LED Matrix
//
static const MatrixPoint ledMatrixPositions[5*5] =
{
	{0,0},{0,1},{0,2},{0,3},{0,4},
	{1,0},{1,1},{1,2},{1,3},{1,4},
	{2,0},{2,1},{2,2},{2,3},{2,4},
	{3,0},{3,1},{3,2},{3,3},{3,4},
	{4,0},{4,1},{4,2},{4,3},{4,4}
};

NRFLowLevelTimer          systemTimer(NRF_TIMER1, TIMER1_IRQn);
NRFLowLevelTimer          adcTimer(NRF_TIMER2, TIMER2_IRQn);
NRFLowLevelTimer          capTouchTimer(NRF_TIMER3, TIMER3_IRQn);
Timer                     timer(systemTimer);
MessageBus                messageBus;
NRF52ADC                  adc(adcTimer, 91);
NRF52TouchSensor          touchSensor(capTouchTimer);
MicroBitIO                io(adc, touchSensor);
NRF52Serial               serial(io.usbTx, io.usbRx, NRF_UARTE0);
MicroBitI2C               _i2c(io.sda, io.scl);
NRF52Pin*                 ledRowPins[5] = {&io.row1, &io.row2, &io.row3, &io.row4, &io.row5};
NRF52Pin*                 ledColPins[5] = {&io.col1, &io.col2, &io.col3, &io.col4, &io.col5};
const MatrixMap           ledMatrixMap  = { 5, 5, 5, 5, (Pin**)ledRowPins, (Pin**)ledColPins, ledMatrixPositions};
MicroBitDisplay           display(ledMatrixMap);
Button                    buttonA(io.P5, DEVICE_ID_BUTTON_A, DEVICE_BUTTON_ALL_EVENTS, ACTIVE_LOW);
Button                    buttonB(io.P11, DEVICE_ID_BUTTON_B, DEVICE_BUTTON_ALL_EVENTS, ACTIVE_LOW);
MicroBitThermometer       thermometer;
Accelerometer&            accelerometer(MicroBitAccelerometer::autoDetect(_i2c));
Compass&                  compass(MicroBitCompass::autoDetect(_i2c));

void device_init()
{ 
	// From MicroBit::MicroBit()

	// Add pullup resisitor to IRQ line (it's floating ACTIVE LO)
	io.irq1.getDigitalValue();
	io.irq1.setPull(PullMode::Up);
	io.irq1.setActiveLo();

	_i2c.setFrequency(400000);

	// Bring up our display pins as high drive.
	for (NRF52Pin *p : ledRowPins)
		p->setHighDrive(true);

	for (NRF52Pin *p : ledColPins)
		p->setHighDrive(true);
}

#endif //MICROBIT_CODAL && !FIRMATA_USE_UBIT

////////////////////////////////////////////////////////////////
#if MICROBIT_CODAL

static uint32_t now() { return system_timer_current_time(); }

#define DAL_VERSION DEVICE_DAL_VERSION

#define MBED_LIBRARY_VERSION 0

#define PullUp    PullMode::None
#define PullDown  PullMode::Down
#define PullNone  PullMode::Up

void serial_setBaud(int baudrate) { serial.setBaud(baudrate); }

static void analogDisable() { }

#endif  // MICROBIT_CODAL

////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
#if !MICROBIT_CODAL && FIRMATA_USE_UBIT

// DAL Components

#include <mbed.h>

MicroBit uBit;

MicroBitSerial          &serial         = uBit.serial;
MicroBitIO              &io             = uBit.io;
MicroBitDisplay         &display        = uBit.display;
MicroBitAccelerometer   &accelerometer  = uBit.accelerometer;
MicroBitCompass         &compass        = uBit.compass;
MicroBitThermometer     &thermometer    = uBit.thermometer;
MicroBitMessageBus      &messageBus     = uBit.messageBus;

void device_init() { }

#endif  // !MICROBIT_CODAL && FIRMATA_USE_UBIT

////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
#if !MICROBIT_CODAL && !FIRMATA_USE_UBIT

// The DAL scheduler imposes a minimum sampling interval of 5 milliseconds (even if it set to
// a lower value), limiting sensor sampling to a maximum of 200 samples/second. Without the
// scheduler, when connected to a computer than can handle high incoming data rates, Firmata
// can stream a single sensor channel at 1000 samples/sec. That could be useful for high-
// speed data collection when instrumenting a science experiment. To avoid running under the
// scheduler, Firmata instantiates the individual DAL components it needs rather than using
// the MicroBit object.

MicroBitI2C i2c(I2C_SDA0, I2C_SCL0);
MicroBitMessageBus messageBus;
MicroBitSerial serial(USBTX, USBRX);
MicroBitStorage storage;

MicroBitAccelerometer &accelerometer = MicroBitAccelerometer::autoDetect(i2c);
MicroBitButton buttonA(MICROBIT_PIN_BUTTON_A, MICROBIT_ID_BUTTON_A);
MicroBitButton buttonB(MICROBIT_PIN_BUTTON_B, MICROBIT_ID_BUTTON_B);
MicroBitCompass &compass = MicroBitCompass::autoDetect(i2c);
MicroBitDisplay display;
MicroBitThermometer thermometer(storage);

MicroBitIO io(
	MICROBIT_PIN_P0, MICROBIT_PIN_P1, MICROBIT_PIN_P2, MICROBIT_PIN_P3,
	MICROBIT_PIN_P4, MICROBIT_PIN_P5, MICROBIT_PIN_P6, MICROBIT_PIN_P7,
	MICROBIT_PIN_P8, MICROBIT_PIN_P9, MICROBIT_PIN_P10, MICROBIT_PIN_P11,
	MICROBIT_PIN_P12, MICROBIT_PIN_P13, MICROBIT_PIN_P14, MICROBIT_PIN_P15,
	MICROBIT_PIN_P16, /* 17-18 */ MICROBIT_PIN_P19, MICROBIT_PIN_P20);

void device_init() { }

#endif // !MICROBIT_CODAL && !FIRMATA_USE_UBIT

////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
#if !MICROBIT_CODAL

#define DAL_VERSION microbit_dal_version()

static uint32_t now() { return us_ticker_read() / 1000L; }

void serial_setBaud(int baudrate) { serial.baud(baudrate); }

static void analogDisable() {
	/* Comment from DAL MicroBitLightSensor.cpp:
	*
	* Forcibly disable AnalogIn, otherwise it will remain in possession of the GPIO channel
	* it is using, meaning that the display will not be able to use a channel (COL).
	*
	* This is required as per PAN 3, details of which can be found here:
	*
	* https://www.nordicsemi.com/eng/nordic/download_resource/24634/5/88440387
	*/

	NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Disabled;
	NRF_ADC->CONFIG =
		(ADC_CONFIG_RES_8bit		<< ADC_CONFIG_RES_Pos) |
		(ADC_CONFIG_INPSEL_SupplyTwoThirdsPrescaling << ADC_CONFIG_INPSEL_Pos) |
		(ADC_CONFIG_REFSEL_VBG		<< ADC_CONFIG_REFSEL_Pos) |
		(ADC_CONFIG_PSEL_Disabled	<< ADC_CONFIG_PSEL_Pos) |
		(ADC_CONFIG_EXTREFSEL_None	<< ADC_CONFIG_EXTREFSEL_Pos);
}

#endif // !MICROBIT_CODAL

////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////

// Variables

#define IN_BUF_SIZE 250
static uint8_t inbuf[IN_BUF_SIZE];
static int inbufCount = 0;

#define MAX_SCROLLING_STRING 200 // room for 100 2-byte UTF-8 characters (probably overkill)
static char scrollingString[MAX_SCROLLING_STRING];

#define PIN_COUNT 21
#define UNKNOWN_PIN_MODE 0x0E
#define UNKNOWN_PIN_STATE 55555
static uint8_t firmataPinMode[PIN_COUNT];
static uint16_t firmataPinState[PIN_COUNT];

static uint8_t isStreamingChannel[16];
static uint8_t isStreamingPort[16];

static uint8_t displayEnabled = true;
static uint8_t lightSensorEnabled = false;

static int samplingInterval = 100;
static int lastSampleTime = 0;

// Serial I/O

static void receiveData() {
	while (inbufCount < IN_BUF_SIZE) {
		int byte = serial.read(ASYNC);
		if (byte < 0) return;
		inbuf[inbufCount++] = byte;
	}
}

static void sendByte(uint8_t b) {
	serial.sendChar(b, ASYNC);
}

static void send2Bytes(uint8_t b1, uint8_t b2) {
	serial.sendChar(b1, ASYNC);
	serial.sendChar(b2, ASYNC);
}

static void send3Bytes(uint8_t b1, uint8_t b2, uint8_t b3) {
	serial.sendChar(b1, ASYNC);
	serial.sendChar(b2, ASYNC);
	serial.sendChar(b3, ASYNC);
}

// Debugging

static void sendStringData(const char *s) {
	// Append the given 8-bit string data to the output buffer.
	// Two seven-bit data bytes are appended for each byte of the string.
	while (*s) {
		uint8_t b = (uint8_t) *s++;
		send2Bytes(b & 0x7F, (b >> 7) & 1);
	}
}

static void DEBUG(const char *s) {
	// Send a 7-bit ASCII string for use in debugging.

	send2Bytes(SYSEX_START, MB_DEBUG_STRING); // seven-bit ascii string
	char *ptr = (char *) s;
	while (*ptr) sendByte(*ptr++ & 0x7F);
	sendByte(SYSEX_END);
}

// System Commands

static void reportFirmataVersion() {
	// Send Firmata protocol version.

	send3Bytes(FIRMATA_VERSION, 0x02, 0x06); // Firmata protocol 2.6
}

static void reportFirmwareVersion() {
	// Send firmware version plus DAL, mbed library, and softdevice version info.
	// The softdevice version can be found by looking up the firmward ID (FWID) here:
	// https://devzone.nordicsemi.com/f/nordic-q-a/1171/how-do-i-access-softdevice-version-string

	// Unfortunately, for v2 without bringing the entire bluetooth stack up, the calls to check
	// softdevice seem to fail, so we're dropping back to using the SD_VARIANT_ID and friends in
	// nrf_shm.h instead, as these give us similar resolution on API changes.

	// Some Event IDs changed between firmware 1.0 (DAL <= 2.1.1) and 1.1 (DAL >= 2.2.0-rc6 and CODAL)
	// MICROBIT_ID_DISPLAY/GESTURE/IO_P0/IO_P1/IO_P2
	int major = FIRMATA_VERSION_MAJOR;
	int minor = FIRMATA_VERSION_MINOR;
	char s[256] = {0};

	#if MICROBIT_CODAL==1
		// Need to check both variables to support building against older versions of CODAL
		#if SOFTDEVICE_PRESENT==1 || DEVICE_BLE==1
			sprintf(s,
				""[%s;softdeviceFWID=%d.%d.%d~%d] micro:bit Firmata"",
				CODAL_FIRMATA_VERSION_STRING,
				SD_MAJOR_VERSION,
				SD_MINOR_VERSION,
				SD_BUGFIX_VERSION,
				SD_VARIANT_ID
			);
		#else
			sprintf(s,
				""[%s] micro:bit Firmata"",
				CODAL_FIRMATA_VERSION_STRING
			);
		#endif
	#else
		ble_version_t bleInfo;
		sd_ble_version_get(&bleInfo);

		sprintf(s, ""[based on DAL %s; mbed %d; softdeviceFWID %d] micro:bit Firmata %d.%d"",
			DAL_VERSION, MBED_LIBRARY_VERSION, bleInfo.subversion_number, major, minor);
	#endif

	send2Bytes(SYSEX_START, REPORT_FIRMWARE);
	send2Bytes(major, minor); // firmware version (vs. Firmata protocol version)
	sendStringData((const char *) s);
	sendByte(SYSEX_END);
}

static void systemReset() {
	memset(firmataPinMode, UNKNOWN_PIN_MODE, sizeof(firmataPinMode));
	memset(firmataPinState, UNKNOWN_PIN_STATE, sizeof(firmataPinState));
	memset(isStreamingChannel, false, sizeof(isStreamingChannel));
	memset(isStreamingPort, false, sizeof(isStreamingPort));
	samplingInterval = 100;
}

static void calibrateCompass() {
	compass.calibrate();
}

// Pin Commands

static void reportAnalogMapping() {
	// Report that the analog iput pins are P0-P4 and P10.

	send2Bytes(SYSEX_START, ANALOG_MAPPING_RESPONSE);
	for (int i = 0; i <= 15; i++) sendByte(i);
	sendByte(SYSEX_END);
}

static void reportPinCapabilities() {
	// Send pin capabilities report.

	send2Bytes(SYSEX_START, CAPABILITY_RESPONSE);
	for (int p = 0; p < PIN_COUNT; p++) {
		// send a sequence of (pin mode, resolution) pairs
		if ((p < 6) || (11 == p)) { // analog pins + light sensor channel
			send2Bytes(DIGITAL_INPUT, 1);
			send2Bytes(DIGITAL_OUTPUT, 1);
			send2Bytes(ANALOG_INPUT, 10);
			send2Bytes(PWM, 10);
			send2Bytes(INPUT_PULLUP, 1);
		} else if ((17 != p) && (18 != p)) { // pins 17-18 are 3.3v
			send2Bytes(DIGITAL_INPUT, 1);
			send2Bytes(DIGITAL_OUTPUT, 1);
			send2Bytes(PWM, 10);
			send2Bytes(INPUT_PULLUP, 1);
		}
		if (p < (PIN_COUNT - 1)) sendByte(0x7F); // send pin separator
	}
	sendByte(SYSEX_END);
}

static void reportPinState(int pin) {
	if ((pin < 0) || (pin >= PIN_COUNT)) return;
	int state = firmataPinState[pin];
	send2Bytes(SYSEX_START, PIN_STATE_RESPONSE);
	send2Bytes(pin, firmataPinMode[pin]);
	send2Bytes(state & 0x7F, (state >> 7) & 0x7F);
	sendByte(SYSEX_END);
}

static void setPinMode(int pin, int mode) {
	if ((pin < 0) || (pin >= PIN_COUNT)) return;
	if (!((DIGITAL_INPUT == mode) || (INPUT_PULLUP == mode) || (INPUT_PULLDOWN == mode) ||
		  (DIGITAL_OUTPUT == mode) || (ANALOG_INPUT == mode) || (PWM == mode))) {
		return;
	}
	if (ANALOG_INPUT == mode) {
		if (11 == pin) lightSensorEnabled = true; // enable the light sensor
		if ((pin > 4) && (pin != 10)) return; // pin is not analog capable
	}

	if (displayEnabled && (pin > 2)) return; // display uses most pins except 0-2

	firmataPinMode[pin] = mode;
	firmataPinState[pin] = UNKNOWN_PIN_STATE;

	// set actual pin mode
	if (DIGITAL_OUTPUT == mode) {
		firmataPinState[pin] = 0;
		io.pin[pin].setDigitalValue(0);
	} else if (PWM == mode) {
		firmataPinState[pin] = 0;
		io.pin[pin].setAnalogValue(0);
	} else if (INPUT_PULLUP == mode) {
		io.pin[pin].getDigitalValue();
		io.pin[pin].setPull(PullUp);
	} else if (INPUT_PULLDOWN == mode) {
		io.pin[pin].getDigitalValue();
		io.pin[pin].setPull(PullDown);
	} else {
		io.pin[pin].getDigitalValue();
		io.pin[pin].setPull(PullNone);
	}
}

static void setDigitalPin(int pin, int value) {
	// Set the given digital pin to the given value.
	// Do nothing if the pin is not in digital output mode.

	if ((pin < 0) || (pin >= PIN_COUNT)) return;
	if (DIGITAL_OUTPUT != firmataPinMode[pin]) return;
	if (displayEnabled && (pin > 2)) return; // display uses most pins except 0-2

	firmataPinState[pin] = value ? 1 : 0;

	// set actual pin output
	io.pin[pin].setDigitalValue(firmataPinState[pin]);
}

static void setDigitalPort(int port, int pinMask) {
	// Handle an incoming digital I/O message (0x90).
	// Only pins in digital output mode will only be changed.

	if (port > 2) return;
	int basePin = 8 * port;
	for (int i = 0; i < 8; i++) {
		int isOn = (pinMask & (1 << i)) ? 1 : 0;
		setDigitalPin(basePin + i, isOn);
	}
}

static void setAnalogPin(int pin, int value) {
	if ((pin < 0) || (pin >= PIN_COUNT)) return;
	if (PWM != firmataPinMode[pin]) return;
	firmataPinState[pin] = value;

	// set actual pin output
	io.pin[pin].setAnalogValue(value);
}

static void extendedAnalogWrite(int sysexStart, int argBytes) {
	int pin = inbuf[sysexStart + 1];
	int b0 = inbuf[sysexStart + 2];
	int b1 = inbuf[sysexStart + 3];
	int b2 = inbuf[sysexStart + 4];
	int value = 0;
	if (2 == argBytes) {
		value = b0;
	} else if (3 == argBytes) {
		value = (b1 << 7) | b0;
	} else if (4 == argBytes) {
		value = (b2 << 14) | (b1 << 7) | b0;
	}
	setAnalogPin(pin, value);
}

// Streaming Control Commands

static void streamAnalogChannel(uint8_t chan, uint8_t isOn) {
	// Turn streaming of the given analog channel on or off.

	if (chan > 15) return;
	isStreamingChannel[chan] = isOn;
	if (chan < 6) {
		int pin = (5 == chan) ? 10 : chan; // channels 0-4 are pins 0-4; channel 5 is pin 10
		if (displayEnabled && (pin > 2)) { // display uses pins 3-5
			isStreamingChannel[chan] = false;
			return;
		}
		io.pin[pin].getDigitalValue(); // put in digital read mode
		io.pin[pin].setPull(PullNone); // turn off pullup/down
		if (isOn) io.pin[pin].getAnalogValue();
	}
}

static void streamDigitalPort(uint8_t port, uint8_t isOn) {
	// Turn streaming of the given digital port on or off.

	if (port < 16) isStreamingPort[port] = isOn;
}

static void setSamplingInterval(int msecs) {
	samplingInterval = (msecs < 1) ? 1 : msecs;
}

// Display Commands

static void display_clear() {
	display.stopAnimation();
	display.clear();
}

static void display_show(int sysexStart, int argBytes) {
	if (argBytes < 26) return;
	int isGrayscale = inbuf[sysexStart + 1];
	if (isGrayscale) {
		display.setDisplayMode(DISPLAY_MODE_GREYSCALE);
	} else {
		display.setDisplayMode(DISPLAY_MODE_BLACK_AND_WHITE);
	}
	for (int y = 0; y < 5; y++) {
		for (int x = 0; x < 5; x++) {
			int i = (5 * y) + x;
			int level = inbuf[sysexStart + i + 2];
			level = (127 == level) ? 255 : (2 * level); // covert from 7 to 8 bit range
			display.image.setPixelValue(x, y, level);
		}
	}
}

static void display_plot(int sysexStart, int argBytes) {
	if (argBytes < 3) return;
	int x = inbuf[sysexStart + 1];
	int y = inbuf[sysexStart + 2];
	int level = inbuf[sysexStart + 3];
	level = (127 == level) ? 255 : (2 * level); // covert from 7 to 8 bit range
	if ((level > 0) && (level < 255)) {
		display.setDisplayMode(DISPLAY_MODE_GREYSCALE);
	}
	display.image.setPixelValue(x, y, level);
}

static void sendScrollDoneEvent() {
	// Used to send an animation_complete event (i.e. scrolling done)
	// when a scrolling operation is invoked when the display is disabled.

	const int source_id = MICROBIT_ID_DISPLAY; // display
	const int event_id = MICROBIT_DISPLAY_EVT_ANIMATION_COMPLETE; // animation_complete
	send2Bytes(SYSEX_START, MB_REPORT_EVENT);
	send3Bytes(source_id & 0x7F, (source_id >> 7) & 0x7F, (source_id >> 14) & 0x7F);
	send3Bytes(event_id & 0x7F, (event_id >> 7) & 0x7F, (event_id >> 14) & 0x7F);
	sendByte(SYSEX_END);
}

static void scrollString(int sysexStart, int argBytes) {
	if (argBytes < 1) return;
	int scrollSpeed = inbuf[sysexStart + 1];
	if (!displayEnabled) sendScrollDoneEvent();
	display.stopAnimation();
	int utf8Bytecount = (argBytes - 1) / 2;
	if (utf8Bytecount > MAX_SCROLLING_STRING) utf8Bytecount = MAX_SCROLLING_STRING;
	int srcIndex = sysexStart + 2;
	for (int i = 0; i < utf8Bytecount; i ++) {
		scrollingString[i] = inbuf[srcIndex] | (inbuf[srcIndex + 1] << 7);
		srcIndex += 2;
	}
	scrollingString[utf8Bytecount] = 0; // null terminator
	display.scrollAsync(scrollingString, scrollSpeed);
}

static void scrollNumber(int sysexStart, int argBytes) {
	if (argBytes < 2) return;
	int scrollSpeed = inbuf[sysexStart + 1];
	int n = inbuf[sysexStart + 2];
	n |= inbuf[sysexStart + 3] << 7;
	n |= inbuf[sysexStart + 4] << 14;
	n |= inbuf[sysexStart + 5] << 21;
	n |= inbuf[sysexStart + 6] << 28;
	if (!displayEnabled) sendScrollDoneEvent();
	display.stopAnimation();
	sprintf(scrollingString, ""%d"", n);
	display.scrollAsync(scrollingString, scrollSpeed);
}

static void setTouchMode(int sysexStart, int argBytes) {
	// Turn touch mode on/off for a pin. Touch mode is only supported for pins 0-2).
	// When touch mode is on, the pin generates events as if it were a button.

	if (argBytes < 2) return;
	int pin = inbuf[sysexStart + 1];
	int touchModeOn = (inbuf[sysexStart + 2] != 0);
	if (pin < 3) {
		if (touchModeOn) {
			io.pin[pin].isTouched();
		} else {
			// Note: disableEvents() is a private method in the DAL. Thus, there does not seem
			// to be any way to disable touch events once a pin has been put into touch mode
			// (except via hardware reset, of course).
			// io.pin[pin].disableEvents();
		}
	}
}

static void setDisplayEnable(int isEnabled) {
	// Disable or re-enable the display. (The display is initially enabled at startup.)
	// When the display is disabled, pins 0-5 can be used for other purposes.
	// Re-enabling the display (even when already enabled) turns off light sensing
	// until the next time a light sensor value is requested.

	// turn off display
	display.stopAnimation();
	display.clear();
	display.disable();

	// disable light sensing
	display.setDisplayMode(DISPLAY_MODE_BLACK_AND_WHITE);
	analogDisable(); // in case light sensor was in use
	lightSensorEnabled = false; // can reenable by setting analog channel 11 to analog input

	// re-enable if isEnabled is true
	displayEnabled = isEnabled;
	if (displayEnabled) display.enable();
}

static void enableDisplay(int sysexStart, int argBytes) {
	if (argBytes < 1) return;
	int isEnabled = (inbuf[sysexStart + 1] != 0);
	setDisplayEnable(isEnabled);
}

// MIDI parsing

static void dispatchSysexCommand(int sysexStart, int argBytes) {
	uint8_t sysexCmd = inbuf[sysexStart];
	switch (sysexCmd) {
	case MB_DISPLAY_CLEAR:
		display_clear();
		break;
	case MB_DISPLAY_SHOW:
		display_show(sysexStart, argBytes);
		break;
	case MB_DISPLAY_PLOT:
		display_plot(sysexStart, argBytes);
		break;
	case MB_SCROLL_STRING:
		scrollString(sysexStart, argBytes);
		break;
	case MB_SCROLL_INTEGER:
		scrollNumber(sysexStart, argBytes);
		break;
	case MB_SET_TOUCH_MODE:
		setTouchMode(sysexStart, argBytes);
		break;
	case MB_DISPLAY_ENABLE:
		enableDisplay(sysexStart, argBytes);
		break;
	case ANALOG_MAPPING_QUERY:
		reportAnalogMapping();
		break;
	case CAPABILITY_QUERY:
		reportPinCapabilities();
		break;
	case PIN_STATE_QUERY:
		reportPinState(inbuf[sysexStart + 1]);
		break;
	case EXTENDED_ANALOG_WRITE:
		extendedAnalogWrite(sysexStart, argBytes);
		break;
	case REPORT_FIRMWARE:
		reportFirmwareVersion();
		break;
	case SAMPLING_INTERVAL:
		setSamplingInterval((inbuf[sysexStart + 2] << 7) | inbuf[sysexStart + 1]);
		break;
	case MB_COMPASS_CALIBRATE:
		calibrateCompass();
		break;
	}
}

static int findCmdByte(int startIndex) {
	for (int i = startIndex; i < inbufCount; i++) {
		if (inbuf[i] & 0x80) return i;
	}
	return -1;
}

static int processCommandAt(int cmdStart) {
	// Attempt to process the command starting at the given index in inbuf.
	// If the command is incomplete, return -1.
	// Otherwise, process it and return the number of bytes in the entire command.

	uint8_t cmdByte = inbuf[cmdStart];
	uint8_t chanCmd = cmdByte & 0xF0;
	int argBytes = 0;
	int nextCmdIndex = findCmdByte(cmdStart + 1);
	if (nextCmdIndex < 0) { // no next command; current command may not be complete
		if (SYSEX_START == cmdByte) return -1; // incomplete sysex
		argBytes = inbufCount - (cmdStart + 1);
		int argsNeeded = 2;
		if ((0xF9 == cmdByte) || (0xFF == cmdByte)) argsNeeded = 0;
		if ((0xC0 == chanCmd) || (0xD0 == chanCmd)) argsNeeded = 1;
		if (argBytes < argsNeeded) return -1;
	} else {
		argBytes = nextCmdIndex - (cmdStart + 1);
	}

	if (SYSEX_START == cmdByte) { // system exclusive message: SYSEX_START ...data ... SYSEX_END
		if (SYSEX_END != inbuf[cmdStart + argBytes + 1]) {
			// error: last byte is not SYSEX_END; skip this message
			return argBytes + 1; // skip cmd + argBytes
		}
		dispatchSysexCommand(cmdStart + 1, argBytes - 1);
		return argBytes + 2; // skip cmd, arg bytes, and final SYSEX_END
	}

	uint8_t chan = cmdByte & 0xF;
	uint8_t arg1 = (argBytes > 0) ? inbuf[cmdStart + 1] : 0;
	uint8_t  [MASK]  = (argBytes > 1) ? inbuf[cmdStart + 2] : 0;

	if (DIGITAL_UPDATE == chanCmd) setDigitalPort(chan, (arg1 | ( [MASK]  << 7)));
	if (ANALOG_UPDATE == chanCmd) setAnalogPin(chan, (arg1 | ( [MASK]  << 7)));
	if (STREAM_ANALOG == chanCmd) streamAnalogChannel(chan, arg1);
	if (STREAM_DIGITAL == chanCmd) streamDigitalPort(chan, arg1);

	if (SET_PIN_MODE == cmdByte) setPinMode(arg1,  [MASK] );
	if (SET_DIGITAL_PIN == cmdByte) setDigitalPin(arg1,  [MASK] );
	if (FIRMATA_VERSION == cmdByte) reportFirmataVersion();
	if (SYSTEM_RESET == cmdByte) systemReset();

	return argBytes + 1;
}

static void processCommands() {
	// Process and remove all complete commands in inbuf.

	receiveData();
	if (!inbufCount) return; // nothing received

	int cmdStart = 0;
	while (true) {
		cmdStart = findCmdByte(cmdStart);
		if (cmdStart < 0) { // no more commands
			inbufCount = 0;
			return;
		}
		int skipBytes = processCommandAt(cmdStart);
		if (skipBytes < 0) {
			// command at cmdStart is incomplete: remove processed commands and exit
			if (0 == cmdStart) return; // cmd is already at start of inbuf
			int remainingBytes = inbufCount - cmdStart;
			memmove(inbuf, &inbuf[cmdStart], remainingBytes);
			inbufCount = remainingBytes;
			return;
		}
		cmdStart += skipBytes;
	}
}

static void streamDigitalPins() {
	// Send an update for ports we are streaming if they include an input pin that has changed.

	for (int port = 0; port < 3; port++) {
		if (isStreamingPort[port]) {
			int portChanged = false;
			int bitMask = 0;
			for (int i = 0; i < 8; i++) {
				int pin = (8 * port) + i;
				if (pin < PIN_COUNT) {
					int mode = firmataPinMode[pin];
					if ((DIGITAL_INPUT == mode) ||
						(INPUT_PULLUP == mode) ||
						(INPUT_PULLDOWN == mode)) {
							int oldState = firmataPinState[pin];
							int newState = io.pin[pin].getDigitalValue();
							if (newState != oldState) portChanged = true;
							firmataPinState[pin] = newState;
							if (newState) bitMask |= (1 << i);
					}
				}
			}
			if (portChanged) {
				send3Bytes(DIGITAL_UPDATE | port, bitMask & 0x7F, (bitMask >> 7) & 0x7F);
			}
		}
	}
}

static int analogChannelValue(uint8_t chan) {
	// Return the value for the given analog channel (0-15).
	// For the micro:bit, sensors such as the accelerometer are mapped to analog channels.

	if (chan > 15) return 0;
	if (chan < 6) {
		if (displayEnabled && (chan > 2)) return 0; // display uses most pins except 0-2
		int pin = (5 == chan) ? 10 : chan; // channels 0-4 are pins 0-4; channel 5 is pin 10
		if (ANALOG_INPUT != firmataPinMode[pin]) return 0;
		return io.pin[pin].getAnalogValue();
	}
	if (6 == chan) return 0;
	if (7 == chan) return 0;
	if (8 == chan) return accelerometer.getX(); // accelerometer x
	if (9 == chan) return accelerometer.getY(); // accelerometer y
	if (10 == chan) return accelerometer.getZ(); // accelerometer z
	if (11 == chan) {
		// When enabled, the light sensor monopolizes the A/D converter, preventing correct
		// analog values from being read from input pins. Thus, the light sensor is disabled
		// at startup and must be enabled by setting channel 11 to analog input mode. It can
		// be disabled again by invoking the setDisplayEnable command. (Any change to the
		// display enabled state disables the light sensor until it explicitly re-enabled.)

		return (displayEnabled && lightSensorEnabled) ? display.readLightLevel() : 0;
	}
	if (12 == chan) return thermometer.getTemperature(); // temperature sensor
	if (13 == chan) return compass.getX() >> 5; // compass x
	if (14 == chan) return compass.getY() >> 5; // compass y
	if (15 == chan) return compass.getZ() >> 5; // compass z

	return 0;
}

static void streamSensors() {
	// Send updates for all currently streaming sensor channels if samplingInterval msecs
	// have elapsed since the last updates were sent.

	int elapsed = now() - lastSampleTime;
	if ((elapsed >= 0) && (elapsed < samplingInterval)) return;

	for (int chan = 0; chan < 16; chan++) {
		if (isStreamingChannel[chan]) {
			if (chan < 6) { // analog pin
				int pin = (chan == 5) ? 10 : chan;
				if (firmataPinMode[pin] != ANALOG_INPUT) continue; // pin not in analog mode
			}
			int analogValue = analogChannelValue(chan);
			send3Bytes(ANALOG_UPDATE | chan, analogValue & 0x7F, (analogValue >> 7) & 0x7F);
		}
	}
	lastSampleTime = now();
}

// Events

static void onEvent(MicroBitEvent evt) {
	int source_id = evt.source;
	int event_id = evt.value;
	send2Bytes(SYSEX_START, MB_REPORT_EVENT);
	send3Bytes(source_id & 0x7F, (source_id >> 7) & 0x7F, (source_id >> 14) & 0x7F);
	send3Bytes(event_id & 0x7F, (event_id >> 7) & 0x7F, (event_id >> 14) & 0x7F);
	sendByte(SYSEX_END);
}

static void registerEventListeners() {
	// button events
	messageBus.listen(MICROBIT_ID_BUTTON_A, MICROBIT_EVT_ANY, onEvent);
	messageBus.listen(MICROBIT_ID_BUTTON_B, MICROBIT_EVT_ANY, onEvent);

	// accelerometer gesture events (e.g. shake)
	messageBus.listen(MICROBIT_ID_GESTURE, MICROBIT_EVT_ANY, onEvent);

	// touch pin events
	messageBus.listen(MICROBIT_ID_IO_P0, MICROBIT_EVT_ANY, onEvent);
	messageBus.listen(MICROBIT_ID_IO_P1, MICROBIT_EVT_ANY, onEvent);
	messageBus.listen(MICROBIT_ID_IO_P2, MICROBIT_EVT_ANY, onEvent);

	// scrolling/animation complete event
	messageBus.listen(MICROBIT_ID_DISPLAY, MICROBIT_DISPLAY_EVT_ANIMATION_COMPLETE, onEvent);
}

// Entry Points

void initFirmata() {
	device_init();
	serial_setBaud(57600);
	serial.setRxBufferSize(249);
	serial.setTxBufferSize(249);

	systemReset();
	registerEventListeners();
	reportFirmataVersion();
}

void stepFirmata() {
	processCommands();
	streamDigitalPins();
	streamSensors();

	// Note: The following code is essential to avoid overrunning the serial line
	// and losing or corrupting data, A fixed delay works, too, but a delay
	// long enough to handle the worst case (streaming 16 channels of analog data
	// and three digital ports, a total of 3 * 19 = 57 bytes) reduces the maximum
	// sampling rate for a single channel. The code below is like a bulk SYNC_SPINWAIT
	// for all serial data queued by the last call to stepFirmata().

	while (serial.txBufferedSize() > 0) /* wait for all bytes to be sent */;
}
",arg2
542,"#include ""d3d11_decoder_configurator.hpp""

#include <d3d11.h>
#include <d3d9.h>
#include <dxva2api.h>
#include <iostream>

#include ""size.hpp""


D3D11DecoderConfigurator::D3D11DecoderConfigurator(
    DXGI_FORMAT  [MASK] ,
    GUID decoder_guid,
    Size coded_size,
    bool supports_swap_chain)
    : dxgi_format_( [MASK] ),
    decoder_guid_(decoder_guid),
    supports_swap_chain_(supports_swap_chain) {
    SetUpDecoderDescriptor(coded_size);
    SetUpTextureDescriptor();
}

// static
std::unique_ptr<D3D11DecoderConfigurator> D3D11DecoderConfigurator::Create(
    Size coded_size,
    uint8_t bit_depth,
    bool use_shared_handle) {
    // Decoder swap chains do not support shared resources. More info in
    // https://crbug.com/911847. To enable Kaby Lake+ systems for using shared
    // handle, we disable decode swap chain support if shared handle is enabled.
    const bool supports_nv12_decode_swap_chain =
        //gl::DirectCompositionSurfaceWin::IsDecodeSwapChainSupported() &&
        !use_shared_handle;
    const auto decoder_dxgi_format = 
        bit_depth == 8 ? DXGI_FORMAT_NV12 : DXGI_FORMAT_P010;
    GUID decoder_guid = {};
    decoder_guid = D3D11_DECODER_PROFILE_H264_VLD_NOFGT;
    
    return std::make_unique<D3D11DecoderConfigurator>(
        decoder_dxgi_format, decoder_guid, coded_size, supports_nv12_decode_swap_chain);
}

bool D3D11DecoderConfigurator::SupportsDevice(
    ComD3D11VideoDevice video_device) {
    for (UINT i = video_device->GetVideoDecoderProfileCount(); i--;) {
        GUID profile = {};
        if (SUCCEEDED(video_device->GetVideoDecoderProfile(i, &profile))) {
            if (profile == decoder_guid_)
                return true;
        }
    }
    return false;
}

ComD3D11Texture2D D3D11DecoderConfigurator::CreateOutputTexture(
    ComD3D11Device device,
    Size size,
    uint32_t array_size,
    bool use_shared_handle) {
    output_texture_desc_.Width = size.width();
    output_texture_desc_.Height = size.height();
    output_texture_desc_.ArraySize = array_size;

    if (use_shared_handle) {
        // Update the decoder output texture usage to support shared handle and
        // keyed_mutex if required. SwapChain should be disabled and the frame
        // shouldn't be encrypted.
        output_texture_desc_.MiscFlags = 0;
           // D3D11_RESOURCE_MISC_SHARED_NTHANDLE | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
    }
    else if (supports_swap_chain_) {
        // Decode swap chains do not support shared resources.
        // TODO(sunnyps): Find a workaround for when the decoder moves to its own
        // thread and D3D device.  See https://crbug.com/911847
        // TODO(liberato): This depends on the configuration of the TextureSelector,
        // to some degree. We should unset the flag only if it's binding and the
        // decode swap chain is supported, as Intel driver is buggy on Gen9 and
        // older devices without the flag. See https://crbug.com/1107403
        output_texture_desc_.MiscFlags = 0;
    }
    else {
        // Create non-shareable texture for d3d11 video decoder.
        output_texture_desc_.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
    }
    //output_texture_desc_.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    ComD3D11Texture2D texture;
    HRESULT hr =
        device->CreateTexture2D(&output_texture_desc_, nullptr, &texture);
    if (FAILED(hr)) {
        return nullptr;
    }
    
    return texture;
}

// private
void D3D11DecoderConfigurator::SetUpDecoderDescriptor(
    const Size& coded_size) {
    decoder_desc_ = {};
    decoder_desc_.Guid = decoder_guid_;
    decoder_desc_.SampleWidth = coded_size.width();
    decoder_desc_.SampleHeight = coded_size.height();
    decoder_desc_.OutputFormat = dxgi_format_;
}

// private
void D3D11DecoderConfigurator::SetUpTextureDescriptor() {
    output_texture_desc_ = {};
    output_texture_desc_.MipLevels = 1;
    output_texture_desc_.Format = dxgi_format_;
    output_texture_desc_.SampleDesc.Count = 1;
    output_texture_desc_.Usage = D3D11_USAGE_DEFAULT;
    output_texture_desc_.BindFlags = D3D11_BIND_DECODER | D3D11_BIND_SHADER_RESOURCE;
}",decoder_output_dxgifmt
543,"#include ""SPI.h""
#include ""Arduino.h""
#include ""DriverControl.h""

DriverControl::DriverControl(){}

DriverControl::DriverControl(ShiftRegister* reg, uint8_t  [MASK] , uint8_t enable, uint8_t stepPin, uint8_t dirPin){
  this->_reg = reg;
  this->_cs =  [MASK] ;
  this->_en = enable;
  this->_stepPin = stepPin;
  this->_dirPin = dirPin;
}

uint8_t DriverControl::writeRegister(uint8_t reg, uint32_t data){
  uint8_t s;

  //digitalWrite(_cs, LOW);
  _reg->setPin(_cs, LOW);
  _reg->update();

  s = SPI.transfer(reg);
  SPI.transfer((data>>24UL)&0xFF)&0xFF;
  SPI.transfer((data>>16UL)&0xFF)&0xFF;
  SPI.transfer((data>> 8UL)&0xFF)&0xFF;
  SPI.transfer((data>> 0UL)&0xFF)&0xFF;

  //digitalWrite(_cs, HIGH);
  _reg->setPin(_cs, HIGH);
  _reg->update();

  return s;
}

uint8_t DriverControl::readRegister(uint8_t reg, uint32_t *data){
  uint8_t s;

  this->writeRegister(reg, 0UL);

  _reg->setPin(_cs, LOW);
  _reg->update();

  s = SPI.transfer(reg);
  *data  = SPI.transfer(0x00)&0xFF;
  *data <<=8;
  *data |= SPI.transfer(0x00)&0xFF;
  *data <<=8;
  *data |= SPI.transfer(0x00)&0xFF;
  *data <<=8;
  *data |= SPI.transfer(0x00)&0xFF;

  _reg->setPin(_cs, HIGH);
  _reg->update();

  return s;
}

void DriverControl::setEnabled(bool enabled){
  _reg->setPin(_en, !enabled);
  _reg->update();
}

bool DriverControl::setRate(double theRate, uint16_t steps){
  this->_rate = theRate;
  this->_stepsToDo = steps;
  this->_stepProgress = 0;
  return theRate < 0;
}

bool DriverControl::makeStep(){
  if(this->_stepsToDo < 1){
    return false;
  } else {
    this->_stepProgress += this->_rate;
    
    if(_stepProgress >= 1){
      _stepsToDo --;
      _stepProgress -= 1;
    } else if (_stepProgress <= -1){
      _stepsToDo --;
      _stepProgress += 1;
    }

    return true;
  }
}

bool DriverControl::getDir(){
  return this->_rate < 0;
}

uint8_t DriverControl::getStepPin(){
  return this->_stepPin;
}

uint8_t DriverControl::getDirPin(){
  return this->_dirPin;
}
",chipSelect
544,"#include ""DiabloUI/art.h""

#include <cstddef>
#include <cstdint>
#include <memory>

#include ""storm/storm.h""
#include ""utils/display.h""
#include ""utils/log.hpp""
#include ""utils/sdl_compat.h""

namespace devilution {
namespace {
constexpr unsigned PcxHeaderSize = 128;
constexpr unsigned NumPaletteColors = 256;
constexpr unsigned PcxPaletteSize = 1 + NumPaletteColors * 3;

bool LoadPcxMeta(HANDLE handle, int &width, int &height, std::uint8_t &bpp)
{
	PCXHeader pcxhdr;
	if (!SFileReadFileThreadSafe(handle, &pcxhdr, PcxHeaderSize)) {
		return false;
	}
	width = SDL_SwapLE16(pcxhdr.Xmax) - SDL_SwapLE16(pcxhdr.Xmin) + 1;
	height = SDL_SwapLE16(pcxhdr.Ymax) - SDL_SwapLE16(pcxhdr.Ymin) + 1;
	bpp = pcxhdr.BitsPerPixel;
	return true;
}

bool LoadPcxPixelsAndPalette(HANDLE handle, int width, int height, std::uint8_t bpp,
    BYTE *buffer, std::size_t bufferPitch, SDL_Color *palette)
{
	const bool has256ColorPalette = palette != nullptr && bpp == 8;
	std::uint32_t pixelDataSize = SFileGetFileSize(handle);
	if (pixelDataSize == static_cast<std::uint32_t>(-1)) {
		return false;
	}
	pixelDataSize -= PcxHeaderSize + (has256ColorPalette ? PcxPaletteSize : 0);

	// We read 1 extra byte because it delimits the palette.
	const unsigned readSize = pixelDataSize + (has256ColorPalette ? PcxPaletteSize : 0);
	std::unique_ptr<BYTE[]> fileBuffer { new BYTE[readSize] };
	if (!SFileReadFileThreadSafe(handle, fileBuffer.get(), readSize)) {
		return false;
	}
	const unsigned  [MASK]  = bufferPitch - width;
	BYTE *dataPtr = fileBuffer.get();
	for (int j = 0; j < height; j++) {
		for (int x = 0; x < width;) {
			constexpr std::uint8_t PcxMaxSinglePixel = 0xBF;
			const std::uint8_t byte = *dataPtr++;
			if (byte <= PcxMaxSinglePixel) {
				*buffer++ = byte;
				++x;
				continue;
			}
			constexpr std::uint8_t PcxRunLengthMask = 0x3F;
			const std::uint8_t runLength = (byte & PcxRunLengthMask);
			std::memset(buffer, *dataPtr++, runLength);
			buffer += runLength;
			x += runLength;
		}
		buffer +=  [MASK] ;
	}

	if (has256ColorPalette) {
		[[maybe_unused]] constexpr unsigned PcxPaletteSeparator = 0x0C;
		assert(*dataPtr == PcxPaletteSeparator);
		++dataPtr;

		auto *out = palette;
		for (unsigned i = 0; i < NumPaletteColors; ++i) {
			out->r = *dataPtr++;
			out->g = *dataPtr++;
			out->b = *dataPtr++;
#ifndef USE_SDL1
			out->a = SDL_ALPHA_OPAQUE;
#endif
			++out;
		}
	}
	return true;
}

Uint32 GetPcxSdlPixelFormat(unsigned bpp)
{
	switch (bpp) {
	case 8: // NOLINT(readability-magic-numbers)
		return SDL_PIXELFORMAT_INDEX8;
	case 24: // NOLINT(readability-magic-numbers)
		return SDL_PIXELFORMAT_RGB888;
	case 32: // NOLINT(readability-magic-numbers)
		return SDL_PIXELFORMAT_RGBA8888;
	default:
		return 0;
	}
}

} // namespace

void LoadArt(const char *pszFile, Art *art, int frames, SDL_Color *pPalette)
{
	if (art == nullptr || art->surface != nullptr)
		return;

	art->frames = frames;

	HANDLE handle;
	int width;
	int height;
	std::uint8_t bpp;
	if (!SFileOpenFile(pszFile, &handle)) {
		return;
	}

	if (!LoadPcxMeta(handle, width, height, bpp)) {
		Log(""LoadArt(\""{}\""): LoadPcxMeta failed with code {}"", pszFile, SErrGetLastError());
		SFileCloseFileThreadSafe(handle);
		return;
	}

	SDLSurfaceUniquePtr artSurface { SDL_CreateRGBSurfaceWithFormat(SDL_SWSURFACE, width, height, bpp, GetPcxSdlPixelFormat(bpp)) };
	if (!LoadPcxPixelsAndPalette(handle, width, height, bpp, static_cast<BYTE *>(artSurface->pixels),
	        artSurface->pitch, pPalette)) {
		Log(""LoadArt(\""{}\""): LoadPcxPixelsAndPalette failed with code {}"", pszFile, SErrGetLastError());
		SFileCloseFileThreadSafe(handle);
		return;
	}
	SFileCloseFileThreadSafe(handle);

	art->logical_width = artSurface->w;
	art->frame_height = height / frames;

	art->surface = ScaleSurfaceToOutput(std::move(artSurface));
}

void LoadMaskedArt(const char *pszFile, Art *art, int frames, int mask)
{
	LoadArt(pszFile, art, frames);
	if (art->surface != nullptr)
		SDLC_SetColorKey(art->surface.get(), mask);
}

void LoadArt(Art *art, const std::uint8_t *artData, int w, int h, int frames)
{
	constexpr int DefaultArtBpp = 8;
	constexpr int DefaultArtFormat = SDL_PIXELFORMAT_INDEX8;
	art->frames = frames;
	art->surface = ScaleSurfaceToOutput(SDLSurfaceUniquePtr { SDL_CreateRGBSurfaceWithFormatFrom(
	    const_cast<std::uint8_t *>(artData), w, h, DefaultArtBpp, w, DefaultArtFormat) });
	art->logical_width = w;
	art->frame_height = h / frames;
}

} // namespace devilution
",xSkip
545,"//FILE: Assignment 4.cpp
//PROGRAMMER: <NAME>
//PURPOSE: Allows user to buy tickets, by picking a seat directly, or by ticket price

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

// globar variables
const int NUM_ROW = 11;			// number of rows in price array
const int NUM_AISLE = 11;		// number of aisles in price array

// function prototypes
void displaySeats(int price[NUM_ROW][NUM_AISLE]);
void chooseMethod(int price[NUM_ROW][NUM_AISLE]);
void pickBySeat(int price[NUM_ROW][NUM_AISLE]);
void pickByPrice(int price[NUM_ROW][NUM_AISLE]);

int main()
{
	// initialize array, NUM_ROW & NUM_AISLE values at 0 are filler
	int price[NUM_ROW][NUM_AISLE] = {   { 0, 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0 },			
										{ 0, 30, 40, 50, 50, 50, 50, 50, 50, 40, 30 },
										{ 0, 30, 40, 50, 50, 50, 50, 50, 50, 40, 30 },
										{ 0, 20, 30, 30, 40, 50, 50, 40, 30, 30, 20 },
										{ 0, 20, 20, 30, 30, 40, 40, 30, 30, 20, 20 },
										{ 0, 10, 10, 20, 20, 20, 20, 20, 20, 10, 10 },
										{ 0, 10, 10, 20, 20, 20, 20, 20, 20, 10, 10 },
										{ 0, 10, 10, 20, 20, 20, 20, 20, 20, 10, 10 },
										{ 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 },
										{ 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 },
										{ 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 } };
	
	char again;							// variable to hold if user wants to buy another ticket


	do
	{
		displaySeats(price);						// function call - display seating/price chart

		chooseMethod(price);						// function call - choose by seat or price?

		cout << endl << ""Do you want to purchase another ticket? (Y/N) "";		// does user want to buy another ticket?
		cin >> again;
		cout << endl << endl;

	} while (again == 'Y' || again == 'y');					// while post-test loop for repeating program

	cout << ""<<Thank you, and enjoy the show!>>"" << endl << endl << endl;

return 0;
}



//*********************************************************************************************
// Function displaySeats - displays seating chart with prices				                  *
//*********************************************************************************************

void displaySeats(int price[NUM_ROW][NUM_AISLE])
{
	// display seats, with headings
	cout << endl;
	cout << left << setw(5) << ""<AISLE> "" << setw(5) << ""1"" << setw(5) << ""2"" << setw(5) << ""3"" << setw(5) << ""4"";
	cout << setw(5) << ""5"" << setw(5) << ""6"" << setw(5) << ""7"" << setw(5) << ""8"" << setw(5) << ""9"" << setw(5) << ""10"" << endl;
	cout << ""<ROW>   "" << ""_____________________________________________________"" << endl << endl;
	for (int rowIndex = 1; rowIndex < NUM_ROW; rowIndex++)					// rowIndex and aisleIndex start at 1, values at 0 are filler
	{										
		cout << setw(8) << rowIndex;
		
		for (int aisleIndex = 1; aisleIndex < NUM_AISLE; aisleIndex++)
		{
			cout << setw(5) << left << price[rowIndex][aisleIndex];
		}
		cout << endl << endl;
	}
}

//*********************************************************************************************
// Function chooseMethod - pick by seat or price?							                  *
//*********************************************************************************************
void chooseMethod(int price[NUM_ROW][NUM_AISLE])
{
	// menu choice constants
	const int METHOD_SEAT = 1;		// pick by seat
	const int METHOD_PRICE = 2;		// pick by price
	const int METHOD_EXIT = 3;		// exit
	int methodChoice;				// variable to hold user's choice input

	// menu
	cout << ""<Buy a ticket>"" << endl;
	cout << ""1. [Pick by seat]"" << endl;
	cout << ""2. [Pick by price]"" << endl;
	cout << ""3. [Exit]"" << endl << endl;

	cout << ""Enter your choice: "";
	cin >> methodChoice;
	cout << endl;

	while (methodChoice != 1 && methodChoice != 2 && methodChoice != 3)					// input validation
	{
		cout << ""You have entered an invalid choice. Please enter 1, 2 or 3: "";
		cin >> methodChoice;
		cout << endl;
	}

	if (methodChoice == METHOD_SEAT)									
	{
		cout << ""You have chosen [pick by seat]."" << endl << endl;
		pickBySeat(price);									// function call - pick by seat
	}
		

	else if (methodChoice == METHOD_PRICE)
	{
		cout << ""You have chosen [pick by price]."" << endl << endl;
		pickByPrice(price);					// function call - pick by price

	}

	else if (methodChoice == METHOD_EXIT)
	{
		cout << ""You have chosen to [Exit]."" << endl << endl;
	}

}

//*********************************************************************************************
// Function pickBySeat - pick by seat										                  *
//*********************************************************************************************
void pickBySeat(int price[NUM_ROW][NUM_AISLE])
{
	int seatRow;			// variable to hold user's row choice
	int seatAisle;			// variable to hold user's aisle choice

	cout << ""Please pick row number: "";
	cin >> seatRow;

	while (seatRow < 1 || seatRow > 10)		// input validation 
	{
		cout << ""That is an invalid row. Please enter a number from 1 - 10: "";
		cin >> seatRow;
	}

	cout << ""Please pick aisle number: "";
	cin >> seatAisle;

	while (seatAisle < 1 || seatAisle > 10)		// input validation
	{
		cout << ""That is an invalid aisle. Please enter a number from 1 - 10: "";
		cin >> seatAisle;
	}

	if (price[seatRow][seatAisle] == 0)			// seats with value of 0 are considered taken
			cout << endl << ""This seat is not available. "" << endl;

	else
	{
		cout << endl << ""You have picked a seat at row "" << seatRow << "" aisle "" << seatAisle << ""."" << endl;
		cout << ""Your total is $"" << price[seatRow][seatAisle] << ""."" << endl;
		price[seatRow][seatAisle] = 0;			// seat bought by user is changed to 0, to show it is no longer available
	}
}

//*********************************************************************************************
// Function pickByPrice - pick by price												          *
//*********************************************************************************************
void pickByPrice(int price[NUM_ROW][NUM_AISLE])
{
	int  [MASK] ;		// variable to hold user's price choice

	cout << ""Seats are available at <$10>, <$20>, <$30>, <$40>, <$50>."" << endl;
	cout << ""Please enter a price: $"";
	cin >>  [MASK] ;

	while ( [MASK]  != 10 &&  [MASK]  != 20 &&  [MASK]  != 30 &&  [MASK]  != 40 &&  [MASK]  != 50) // input validation 
	{
		cout << ""That is not a valid price."" << endl << endl;
		cout << ""Seats are available at <$10>, <$20>, <$30>, <$40>, <$50>."" << endl;
		cout << ""Please enter a price: $"";
		cin >>  [MASK] ;
	}

	int rowIndex = 0;					// subscript index for row
	int aisleIndex = 0;					// subscript index for aisle			
	bool found = false;					// flag to indicate if seat is found
	char buy;							// variable to hold if user wants to buy the ticket offered

	do {
		while (rowIndex <= NUM_ROW && !found)
		{
			while (aisleIndex <= NUM_AISLE && !found)
			{
				if (price[rowIndex][aisleIndex] ==  [MASK] )
				{
					found = true;

					cout << endl;
					cout << ""Seat is at row "" << rowIndex << "" aisle "" << aisleIndex << ""."" << endl;
					cout << ""Do you want to purchase this seat? (Y/N) "";		 	//does user want to buy this seat?
					cin >> buy;

					if (buy == 'N' || buy == 'n')
					{
						found = false;					// set found back to false, so search will continue where it left off
					}

					if (buy == 'Y' || buy == 'y')
					{
						price[rowIndex][aisleIndex] = 0;		// set value to 0, to show that seat is no longer available
					}
				}
				aisleIndex++;					// go to next aisle
			}
			rowIndex++;							// go to next row
			aisleIndex = 0;						// set to 0, so aisle search can begin again for new row
		}

		if (!found)							// if seats are not found
		{
			cout << endl << ""There are no more seats available at this price."" << endl;
			break;							// break back out to main
		}

	} while (buy == 'N' || buy == 'n');		// post-test loop - does user want to buy another ticket?
}
",seatPrice
546,"//version for openTank
#include <IBusBM.h>   //https://github.com/bmellink/IBusBM
#include ""GyverPWM.h"" //https://alexgyver.ru/gyverpwm/

#define LEFT_MOTOR 0
#define RIGHT_MOTOR 1

IBusBM IBus; // IBus object

int LeftValue = 0; //left motor
int RightValue = 0; //right motor

void setMotors(int leftMotorValue, int  [MASK] )
{
    if (LeftValue != leftMotorValue)
    {
        LeftValue = leftMotorValue;
        setMotorPWM(LEFT_MOTOR, LeftValue);
    }
    if (RightValue !=  [MASK] )
    {
        RightValue =  [MASK] ;
        setMotorPWM(RIGHT_MOTOR, RightValue);
    }
}

void setMotorPWM(int motorNumber, int channelValue)
{
    int motorFrontPWM, motorBackPWM = 0;

    if (motorNumber == LEFT_MOTOR) //Left motor
    {
        if (channelValue > 1500) //forward
        {
            motorFrontPWM = map(channelValue, 1500, 2000, 0, 255); //255 => 8 bit timer
        }
        else if (channelValue < 1500) //backward
        {
            motorBackPWM = map(channelValue, 1500, 1000, 0, 255); //255 => 8 bit timer
        }

        PWM_16KHZ_D3(motorFrontPWM);
        PWM_16KHZ_D5(motorBackPWM);
    }
    else if (motorNumber == RIGHT_MOTOR) //Right motor
    {
        if (channelValue > 1500) //forward
        {
            motorFrontPWM = map(channelValue, 1500, 2000, 0, 1023); //1023 => 10 bit timer
        }
        else if (channelValue < 1500) //backward
        {
            motorBackPWM = map(channelValue, 1500, 1000, 0, 1023); //1023 => 10 bit timer
        }

        PWM_16KHZ_D9(motorFrontPWM);
        PWM_16KHZ_D10(motorBackPWM);
    }
}

void setup()
{
    // iBUS object connected to serial0 RX pin (rx0)
    IBus.begin(Serial);

    //ToDo
    // *Wait IBus until connect
    // *Create arming function

    pinMode(3, OUTPUT);
    pinMode(5, OUTPUT);
    pinMode(9, OUTPUT);
    pinMode(10, OUTPUT);

    PWM_16KHZ_D3(0);
    PWM_16KHZ_D5(0);
    PWM_16KHZ_D9(0);
    PWM_16KHZ_D10(0);

    delay(100);
}

void loop()
{
    //channel values has range 1000..2000 1000 is minimum, 2000is maximum, 1500 equals center
    uint16_t ch_1 = IBus.readChannel(1); //left stick Y
    uint16_t ch_2 = IBus.readChannel(2); //right stick Y

    setMotors(ch_1, ch_2);
}
",rightMotorValue
547,"#include ""MemoryBlock.h""

namespace Core
{
	MemoryBlock::MemoryBlock() :
		data(nullptr),
		usedSize(0),
		totalSize(0),
		isInited(false)
	{

	}

	MemoryBlock::~MemoryBlock()
	{
		clean();
	}

	bool MemoryBlock::canAllocate(const Core::uint64& requiredSize)
	{
		ASSERT(isInited);

		if (!isInited)
		{
			return false;
		}
#ifdef BUILD_DEBUG
		std::cout << ""free="" << std::fixed << toMB(getFreeSize()) << "" MB"" << std::endl;
#endif
		bool  [MASK]  = requiredSize <= getFreeSize();
		return  [MASK] ;
	}

	Core::uint64 MemoryBlock::init(const Core::uint64& requestedTotalSizeInBytes)
	{

		ASSERT(!isInited);

		if (isInited)
		{
			return 0;
		}

		ASSERT(requestedTotalSizeInBytes > 0);
		if (requestedTotalSizeInBytes == 0)
		{
			return 0;
		}

		clean();


		Core::uint64 allocateSize = requestedTotalSizeInBytes;
		bool isHigherThanOSLimit = allocateSize > MAX_ALLOCATE_SIZE;
		if (isHigherThanOSLimit)
		{
			allocateSize = MAX_ALLOCATE_SIZE;
		}

		Data availableData = nullptr;
		while (availableData == nullptr)
		{
			availableData = (Data)malloc(allocateSize);
			if (availableData)
			{
				memset(availableData, 0, sizeof(allocateSize));
				break;
			}
			// make it half
			allocateSize = allocateSize >> 1;

			// could not allocate
			if (allocateSize < MIN_ALLOCATE_SIZE)
			{
				return 0;
			}
		}
		data = availableData;
		totalSize = allocateSize;

		isInited = true;
		return allocateSize;
	}

	void MemoryBlock::clean()
	{
		if (!isInited)
		{
			return;
		}

		if (data)
		{
			free(data);
			data = nullptr;
		}
		totalSize = 0;
		usedSize = 0;
		isInited = false;
	}

	const bool& MemoryBlock::getIsInited() const
	{
		return isInited;
	}

	const Core::uint64& MemoryBlock::getTotalSize() const
	{
		return totalSize;
	}

	const Core::uint64& MemoryBlock::getUsedSize() const
	{
		return  usedSize;
	}

	const Core::uint64& MemoryBlock::getFreeSize() const
	{
		return getTotalSize() - getUsedSize();
	}

}",isThereAvailableSize
548,"#include <SFML/Graphics.hpp>
#include <iostream>
#include <stdexcept>
#include <iomanip>  // std::setprecision
#include <iostream> // std::cout, std::fixed
#include <sstream>
#include <string>

using namespace sf;
using namespace std;

template <typename T>
std::string toStrDecPt(const uint16_t& dp, const T& i) {
  std::stringstream stream;
  stream << std::fixed << std::setprecision(dp) << i;
  return stream.str();
}

Texture texture;
Sprite sprite;
RenderWindow* _window;
void Load() {
  if (!texture.loadFromFile(""res/img/spaceship1.png"")) {
    throw std::invalid_argument(""Loading error!"");
  }
}

float frametimes[256] = {};
uint8_t ftc = 0;

void Update() {
  static sf::Clock  [MASK] ;
  float dt =  [MASK] .restart().asSeconds();

  {
    frametimes[++ftc] = dt;
    static string avg = "" Astral Insanity FPS:"";
    if (ftc % 60 == 0) {
      double davg = 0;
      for (const auto t : frametimes) {
        davg += t;
      }
      davg = 1.0 / (davg / 255.0);
      _window->setTitle(avg + toStrDecPt(2, davg));
    }
  }

  Vector2f move;
  if (Keyboard::isKeyPressed(Keyboard::Left)) {
    move.x--;
  }
  if (Keyboard::isKeyPressed(Keyboard::Right)) {
    move.x++;
  }
  sprite.move(move*300.0f*dt);
}

void Render(RenderWindow &window) { window.draw(sprite); }

int main() {
  RenderWindow window(VideoMode(400, 400), ""SFML works!"");
  _window = &window;
  window.setVerticalSyncEnabled(true);
  try {
    Load();
  } catch (const std::exception &) {
    std::cerr << ""Load error"" << std::endl;
    return 1;
  }

  sprite.setTexture(texture);
  sprite.setScale(Vector2f(2.f, 2.f));

  while (window.isOpen()) {

    Event event;
    while (window.pollEvent(event)) {
      if (event.type == Event::Closed){
        window.close();
      }
    }
    if (Keyboard::isKeyPressed(Keyboard::Escape)) {
      window.close();
    }

    window.clear();
    Update();
    Render(window);
    window.display();
  }

  return 0;
}",clock
549,"/**
 * Copyright 2013-2022 Software Radio Systems Limited
 *
 * This file is part of srsRAN.
 *
 * srsRAN is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * srsRAN 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 Affero General Public License for more details.
 *
 * A copy of the GNU Affero General Public License can be found in
 * the LICENSE file in the top-level directory of this distribution
 * and at http://www.gnu.org/licenses/.
 *
 */

#include <assert.h>
#include <math.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/time.h>
#include <unistd.h>
#include <complex.h>

#include ""srsran/common/crash_handler.h""
#include ""srsran/common/gen_mch_tables.h""
#include ""srsran/phy/io/filesink.h""
#include ""srsran/srsran.h""

#define ENABLE_AGC_DEFAULT

#ifndef DISABLE_RF

extern ""C""
{
#include ""srsran/phy/rf/rf.h""
#include ""srsran/phy/rf/rf_utils.h""
}

#include ""srsran/asn1/rrc.h""
#include ""srsran/asn1/rrc/bcch_msg.h""

cell_search_cfg_t cell_detect_config = {.max_frames_pbch      = SRSRAN_DEFAULT_MAX_FRAMES_PBCH,
                                        .max_frames_pss       = SRSRAN_DEFAULT_MAX_FRAMES_PSS,
                                        .nof_valid_pss_frames = SRSRAN_DEFAULT_NOF_VALID_PSS_FRAMES,
                                        .init_agc             = 0,
                                        .force_tdd            = false};

#else
#pragma message ""Compiling pdsch_ue with no RF support""
#endif

//#define STDOUT_COMPACT

#ifdef ENABLE_GUI

#include ""srsgui/srsgui.h""

void init_plots();

pthread_t plot_thread;
sem_t     plot_sem;
uint32_t  plot_sf_idx       = 0;
bool      plot_track        = true;
bool      enable_mbsfn_plot = false;
#endif /* ENABLE_GUI */
char* output_file_name;
//#define PRINT_CHANGE_SCHEDULING

//#define CORRECT_SAMPLE_OFFSET

/**********************************************************************
 *  Program arguments processing
 ***********************************************************************/
typedef struct {
  int      nof_subframes;
  int      cpu_affinity;
  bool     disable_plots;
  bool     disable_plots_except_constellation;
  bool     disable_cfo;
  uint32_t time_offset;
  int      force_N_id_2;
  uint16_t rnti;
  char*    input_file_name;
  int      file_offset_time;
  float    file_offset_freq;
  uint32_t file_nof_prb;
  uint32_t file_nof_ports;
  uint32_t file_cell_id;
  bool     enable_cfo_ref;
  char*    estimator_alg;
  char*    rf_dev;
  char*    rf_args;
  uint32_t rf_nof_rx_ant;
  double   rf_freq;
  float    rf_gain;
  int      net_port;
  char*    net_address;
  int      net_port_signal;
  char*    net_address_signal;
  int      decimate;
  int32_t  mbsfn_area_id;
  uint8_t  non_mbsfn_region;
  uint8_t  mbsfn_sf_mask;
  int      tdd_special_sf;
  int      sf_config;
  int      verbose;
  bool     enable_256qam;
  bool     use_standard_lte_rate;
} prog_args_t;

void args_default(prog_args_t* args)
{
  args->disable_plots                      = false;
  args->disable_plots_except_constellation = false;
  args->nof_subframes                      = -1;
  args->rnti                               = SRSRAN_SIRNTI;
  args->force_N_id_2                       = -1; // Pick the best
  args->tdd_special_sf                     = -1;
  args->sf_config                          = -1;
  args->input_file_name                    = NULL;
  args->disable_cfo                        = false;
  args->time_offset                        = 0;
  args->file_nof_prb                       = 25;
  args->file_nof_ports                     = 1;
  args->file_cell_id                       = 0;
  args->file_offset_time                   = 0;
  args->file_offset_freq                   = 0;
  args->rf_dev                             = (char*)"""";
  args->rf_args                            = (char*)"""";
  args->rf_freq                            = -1.0;
  args->rf_nof_rx_ant                      = 1;
  args->enable_cfo_ref                     = false;
  args->estimator_alg                      = (char*)""interpolate"";
  args->enable_256qam                      = false;
#ifdef ENABLE_AGC_DEFAULT
  args->rf_gain = -1.0;
#else
  args->rf_gain = 50.0;
#endif
  args->net_port           = -1;
  args->net_address        = (char*)""127.0.0.1"";
  args->net_port_signal    = -1;
  args->net_address_signal = (char*)""127.0.0.1"";
  args->decimate           = 0;
  args->cpu_affinity       = -1;
  args->mbsfn_area_id      = -1;
  args->non_mbsfn_region   = 2;
  args->mbsfn_sf_mask      = 32;
}

void usage(prog_args_t* args, char* prog)
{
  printf(""Usage: %s [adgpPoOcildFRDnruMNvTG] -f rx_frequency (in Hz) | -i input_file\n"", prog);
#ifndef DISABLE_RF
  printf(""\t-I RF dev [Default %s]\n"", args->rf_dev);
  printf(""\t-a RF args [Default %s]\n"", args->rf_args);
  printf(""\t-A Number of RX antennas [Default %d]\n"", args->rf_nof_rx_ant);
#ifdef ENABLE_AGC_DEFAULT
  printf(""\t-g RF fix RX gain [Default AGC]\n"");
#else
  printf(""\t-g Set RX gain [Default %.1f dB]\n"", args->rf_gain);
#endif
#else
  printf(""\t   RF is disabled.\n"");
#endif
  printf(""\t-i input_file [Default use RF board]\n"");
  printf(""\t-o offset frequency correction (in Hz) for input file [Default %.1f Hz]\n"", args->file_offset_freq);
  printf(""\t-O offset samples for input file [Default %d]\n"", args->file_offset_time);
  printf(""\t-p nof_prb for input file [Default %d]\n"", args->file_nof_prb);
  printf(""\t-P nof_ports for input file [Default %d]\n"", args->file_nof_ports);
  printf(""\t-c cell_id for input file [Default %d]\n"", args->file_cell_id);
  printf(""\t-r RNTI in Hex [Default 0x%x]\n"", args->rnti);
  printf(""\t-l Force N_id_2 [Default best]\n"");
  printf(""\t-C Disable CFO correction [Default %s]\n"", args->disable_cfo ? ""Disabled"" : ""Enabled"");
  printf(""\t-F Enable RS-based CFO correction [Default %s]\n"", !args->enable_cfo_ref ? ""Disabled"" : ""Enabled"");
  printf(""\t-R Channel estimates algorithm (average, interpolate, wiener) [Default %s]\n"", args->estimator_alg);
  printf(""\t-t Add time offset [Default %d]\n"", args->time_offset);
  printf(""\t-T Set TDD special subframe configuration [Default %d]\n"", args->tdd_special_sf);
  printf(""\t-G Set TDD uplink/downlink configuration [Default %d]\n"", args->sf_config);
#ifdef ENABLE_GUI
  printf(""\t-d disable plots [Default enabled]\n"");
  printf(""\t-D disable all but constellation plots [Default enabled]\n"");
#else  /* ENABLE_GUI */
  printf(""\t plots are disabled. Graphics library not available\n"");
#endif /* ENABLE_GUI */
  printf(""\t-y set the cpu affinity mask [Default %d] \n  "", args->cpu_affinity);
  printf(""\t-n nof_subframes [Default %d]\n"", args->nof_subframes);
  printf(""\t-s remote UDP port to send input signal (-1 does nothing with it) [Default %d]\n"", args->net_port_signal);
  printf(""\t-S remote UDP address to send input signal [Default %s]\n"", args->net_address_signal);
  printf(""\t-u remote TCP port to send data (-1 does nothing with it) [Default %d]\n"", args->net_port);
  printf(""\t-U remote TCP address to send data [Default %s]\n"", args->net_address);
  printf(""\t-M MBSFN area id [Default %d]\n"", args->mbsfn_area_id);
  printf(""\t-N Non-MBSFN region [Default %d]\n"", args->non_mbsfn_region);
  printf(""\t-q Enable/Disable 256QAM modulation (default %s)\n"", args->enable_256qam ? ""enabled"" : ""disabled"");
  printf(""\t-Q Use standard LTE sample rates (default %s)\n"", args->use_standard_lte_rate ? ""enabled"" : ""disabled"");
  printf(""\t-v [set srsran_verbose to debug, default none]\n"");
}

void parse_args(prog_args_t* args, int argc, char** argv)
{
  int opt;
  args_default(args);

  while ((opt = getopt(argc, argv, ""adAogliIpPcOCtdDFRqnvrfuUsSZyWMNBTGQ"")) != -1) {
    switch (opt) {
      case 'i':
        args->input_file_name = argv[optind];
        break;
      case 'p':
        args->file_nof_prb = (uint32_t)strtol(argv[optind], NULL, 10);
        break;
      case 'P':
        args->file_nof_ports = (uint32_t)strtol(argv[optind], NULL, 10);
        break;
      case 'o':
        args->file_offset_freq = strtof(argv[optind], NULL);
        break;
      case 'O':
        args->file_offset_time = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'c':
        args->file_cell_id = (uint32_t)strtol(argv[optind], NULL, 10);
        break;
      case 'I':
        args->rf_dev = argv[optind];
        break;
      case 'a':
        args->rf_args = argv[optind];
        break;
      case 'A':
        args->rf_nof_rx_ant = (uint32_t)strtol(argv[optind], NULL, 10);
        break;
      case 'g':
        args->rf_gain = strtof(argv[optind], NULL);
        break;
      case 'C':
        args->disable_cfo = true;
        break;
      case 'F':
        args->enable_cfo_ref = true;
        break;
      case 'R':
        args->estimator_alg = argv[optind];
        break;
      case 't':
        args->time_offset = (uint32_t)strtol(argv[optind], NULL, 10);
        break;
      case 'f':
        args->rf_freq = strtod(argv[optind], NULL);
        break;
      case 'T':
        args->tdd_special_sf = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'G':
        args->sf_config = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'n':
        args->nof_subframes = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'r':
        args->rnti = strtol(argv[optind], NULL, 16);
        break;
      case 'l':
        args->force_N_id_2 = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'u':
        args->net_port = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'U':
        args->net_address = argv[optind];
        break;
      case 's':
        args->net_port_signal = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'S':
        args->net_address_signal = argv[optind];
        break;
      case 'd':
        args->disable_plots = true;
        break;
      case 'D':
        args->disable_plots_except_constellation = true;
        break;
      case 'v':
        increase_srsran_verbose_level();
        args->verbose = get_srsran_verbose_level();
        break;
      case 'Z':
        args->decimate = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'y':
        args->cpu_affinity = (int)strtol(argv[optind], NULL, 10);
        break;
      case 'W':
        output_file_name = argv[optind];
        break;
      case 'M':
        args->mbsfn_area_id = (int32_t)strtol(argv[optind], NULL, 10);
        break;
      case 'N':
        args->non_mbsfn_region = (uint8_t)strtol(argv[optind], NULL, 10);
        break;
      case 'B':
        args->mbsfn_sf_mask = (uint8_t)strtol(argv[optind], NULL, 10);
        break;
      case 'q':
        args->enable_256qam ^= true;
        break;
      case 'Q':
        args->use_standard_lte_rate ^= true;
        break;
      default:
        usage(args, argv[0]);
        exit(-1);
    }
  }
  if (args->rf_freq < 0 && args->input_file_name == NULL) {
    usage(args, argv[0]);
    exit(-1);
  }
}

/**********************************************************************/

uint8_t* data[SRSRAN_MAX_CODEWORDS];

bool go_exit = false;

void sig_int_handler(int signo)
{
  printf(""SIGINT received. Exiting...\n"");
  if (signo == SIGINT) {
    go_exit = true;
  } else if (signo == SIGSEGV) {
    exit(1);
  }
}

cf_t* sf_buffer[SRSRAN_MAX_PORTS] = {NULL};

#ifndef DISABLE_RF

int srsran_rf_recv_wrapper(void* h, cf_t* data_[SRSRAN_MAX_PORTS], uint32_t nsamples, srsran_timestamp_t* t)
{
  DEBUG("" ----  Receive %d samples  ----"", nsamples);
  void* ptr[SRSRAN_MAX_PORTS];
  for (int i = 0; i < SRSRAN_MAX_PORTS; i++) {
    ptr[i] = data_[i];
  }
  return srsran_rf_recv_with_time_multi((srsran_rf_t*)h, ptr, nsamples, true, NULL, NULL);
}

static SRSRAN_AGC_CALLBACK(srsran_rf_set_rx_gain_th_wrapper_)
{
  srsran_rf_set_rx_gain_th((srsran_rf_t*)h, gain_db);
}

#endif

extern float mean_exec_time;

enum receiver_state { DECODE_MIB, DECODE_PDSCH } state;
int sib_decoded = 0;

srsran_cell_t      cell;
srsran_ue_dl_t     ue_dl;
srsran_ue_dl_cfg_t ue_dl_cfg;
srsran_dl_sf_cfg_t dl_sf;
srsran_pdsch_cfg_t pdsch_cfg;
srsran_ue_sync_t   ue_sync;
prog_args_t        prog_args;

uint32_t pkt_errors = 0, pkt_total = 0, nof_detected = 0, pmch_pkt_errors = 0, pmch_pkt_total = 0, nof_trials = 0;

srsran_netsink_t net_sink, net_sink_signal;
/* Useful macros for printing lines which will disappear */

#define PRINT_LINE_INIT()                                                                                              \
  int        this_nof_lines = 0;                                                                                       \
  static int prev_nof_lines = 0
#define PRINT_LINE(_fmt, ...)                                                                                          \
  printf(""\033[K"" _fmt ""\n"", ##__VA_ARGS__);                                                                           \
  this_nof_lines++
#define PRINT_LINE_RESET_CURSOR()                                                                                      \
  printf(""\033[%dA"", this_nof_lines);                                                                                  \
  prev_nof_lines = this_nof_lines
#define PRINT_LINE_ADVANCE_CURSOR() printf(""\033[%dB"", prev_nof_lines + 1)

int main(int argc, char** argv)
{
  int ret;

#ifndef DISABLE_RF
  srsran_rf_t rf;
#endif

  srsran_debug_handle_crash(argc, argv);

  parse_args(&prog_args, argc, argv);

  srsran_use_standard_symbol_size(prog_args.use_standard_lte_rate);

#ifdef ENABLE_GUI
  if (prog_args.mbsfn_area_id > -1) {
    enable_mbsfn_plot = true;
  }
#endif /* ENABLE_GUI */

  for (int i = 0; i < SRSRAN_MAX_CODEWORDS; i++) {
    data[i] = srsran_vec_u8_malloc(2000 * 8);
    if (!data[i]) {
      ERROR(""Allocating data"");
      go_exit = true;
    }
  }

  uint8_t mch_table[10];
  bzero(&mch_table[0], sizeof(uint8_t) * 10);
  if (prog_args.mbsfn_area_id > -1) {
    generate_mcch_table(mch_table, prog_args.mbsfn_sf_mask);
  }
  if (prog_args.cpu_affinity > -1) {
    cpu_set_t cpuset;
    pthread_t thread;

    thread = pthread_self();
    for (int i = 0; i < 8; i++) {
      if (((prog_args.cpu_affinity >> i) & 0x01) == 1) {
        printf(""Setting pdsch_ue with affinity to core %d\n"", i);
        CPU_SET((size_t)i, &cpuset);
      }
      if (pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset)) {
        ERROR(""Error setting main thread affinity to %d"", prog_args.cpu_affinity);
        exit(-1);
      }
    }
  }

  if (prog_args.net_port > 0) {
    if (srsran_netsink_init(&net_sink, prog_args.net_address, prog_args.net_port, SRSRAN_NETSINK_UDP)) {
      ERROR(""Error initiating UDP socket to %s:%d"", prog_args.net_address, prog_args.net_port);
      exit(-1);
    }
    srsran_netsink_set_nonblocking(&net_sink);
  }
  if (prog_args.net_port_signal > 0) {
    if (srsran_netsink_init(
            &net_sink_signal, prog_args.net_address_signal, prog_args.net_port_signal, SRSRAN_NETSINK_UDP)) {
      ERROR(""Error initiating UDP socket to %s:%d"", prog_args.net_address_signal, prog_args.net_port_signal);
      exit(-1);
    }
    srsran_netsink_set_nonblocking(&net_sink_signal);
  }

  float search_cell_cfo = 0;

#ifndef DISABLE_RF
  if (!prog_args.input_file_name) {
    printf(""Opening RF device with %d RX antennas...\n"", prog_args.rf_nof_rx_ant);
    if (srsran_rf_open_devname(&rf, prog_args.rf_dev, prog_args.rf_args, prog_args.rf_nof_rx_ant)) {
      fprintf(stderr, ""Error opening rf\n"");
      exit(-1);
    }
    /* Set receiver gain */
    if (prog_args.rf_gain > 0) {
      srsran_rf_set_rx_gain(&rf, prog_args.rf_gain);
    } else {
      printf(""Starting AGC thread...\n"");
      if (srsran_rf_start_gain_thread(&rf, false)) {
        ERROR(""Error opening rf"");
        exit(-1);
      }
      srsran_rf_set_rx_gain(&rf, srsran_rf_get_rx_gain(&rf));
      cell_detect_config.init_agc = srsran_rf_get_rx_gain(&rf);
    }

    sigset_t sigset;
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGINT);
    sigprocmask(SIG_UNBLOCK, &sigset, NULL);
    signal(SIGINT, sig_int_handler);

    /* set receiver frequency */
    printf(""Tunning receiver to %.3f MHz\n"", (prog_args.rf_freq + prog_args.file_offset_freq) / 1000000);
    srsran_rf_set_rx_freq(&rf, prog_args.rf_nof_rx_ant, prog_args.rf_freq + prog_args.file_offset_freq);

    uint32_t ntrial = 0;
    do {
      ret = rf_search_and_decode_mib(
          &rf, prog_args.rf_nof_rx_ant, &cell_detect_config, prog_args.force_N_id_2, &cell, &search_cell_cfo);
      if (ret < 0) {
        ERROR(""Error searching for cell"");
        exit(-1);
      } else if (ret == 0 && !go_exit) {
        printf(""Cell not found after %d trials. Trying again (Press Ctrl+C to exit)\n"", ntrial++);
      }
    } while (ret == 0 && !go_exit);

    if (go_exit) {
      srsran_rf_close(&rf);
      exit(0);
    }

    /* set sampling frequency */
    int srate = srsran_sampling_freq_hz(cell.nof_prb);
    if (srate != -1) {
      printf(""Setting sampling rate %.2f MHz\n"", (float)srate / 1000000);
      float srate_rf = srsran_rf_set_rx_srate(&rf, (double)srate);
      if (srate_rf != srate) {
        ERROR(""Could not set sampling rate"");
        exit(-1);
      }
    } else {
      ERROR(""Invalid number of PRB %d"", cell.nof_prb);
      exit(-1);
    }

    INFO(""Stopping RF and flushing buffer...\r"");
  }
#endif

  /* If reading from file, go straight to PDSCH decoding. Otherwise, decode MIB first */
  if (prog_args.input_file_name) {
    /* preset cell configuration */
    cell.id              = prog_args.file_cell_id;
    cell.cp              = SRSRAN_CP_NORM;
    cell.phich_length    = SRSRAN_PHICH_NORM;
    cell.phich_resources = SRSRAN_PHICH_R_1;
    cell.nof_ports       = prog_args.file_nof_ports;
    cell.nof_prb         = prog_args.file_nof_prb;

    if (srsran_ue_sync_init_file_multi(&ue_sync,
                                       prog_args.file_nof_prb,
                                       prog_args.input_file_name,
                                       prog_args.file_offset_time,
                                       prog_args.file_offset_freq,
                                       prog_args.rf_nof_rx_ant)) {
      ERROR(""Error initiating ue_sync"");
      exit(-1);
    }

  } else {
#ifndef DISABLE_RF
    int decimate = 0;
    if (prog_args.decimate) {
      if (prog_args.decimate > 4 || prog_args.decimate < 0) {
        printf(""Invalid decimation factor, setting to 1 \n"");
      } else {
        decimate = prog_args.decimate;
      }
    }
    if (srsran_ue_sync_init_multi_decim(&ue_sync,
                                        cell.nof_prb,
                                        cell.id == 1000,
                                        srsran_rf_recv_wrapper,
                                        prog_args.rf_nof_rx_ant,
                                        (void*)&rf,
                                        decimate)) {
      ERROR(""Error initiating ue_sync"");
      exit(-1);
    }
    if (srsran_ue_sync_set_cell(&ue_sync, cell)) {
      ERROR(""Error initiating ue_sync"");
      exit(-1);
    }
#endif
  }

  uint32_t  [MASK]  = 3 * SRSRAN_SF_LEN_PRB(cell.nof_prb); /// Length in complex samples
  for (uint32_t i = 0; i < prog_args.rf_nof_rx_ant; i++) {
    sf_buffer[i] = srsran_vec_cf_malloc( [MASK] );
  }
  srsran_ue_mib_t ue_mib;
  if (srsran_ue_mib_init(&ue_mib, sf_buffer[0], cell.nof_prb)) {
    ERROR(""Error initaiting UE MIB decoder"");
    exit(-1);
  }
  if (srsran_ue_mib_set_cell(&ue_mib, cell)) {
    ERROR(""Error initaiting UE MIB decoder"");
    exit(-1);
  }

  if (srsran_ue_dl_init(&ue_dl, sf_buffer, cell.nof_prb, prog_args.rf_nof_rx_ant)) {
    ERROR(""Error initiating UE downlink processing module"");
    exit(-1);
  }
  if (srsran_ue_dl_set_cell(&ue_dl, cell)) {
    ERROR(""Error initiating UE downlink processing module"");
    exit(-1);
  }

  // Disable CP based CFO estimation during find
  ue_sync.cfo_current_value       = search_cell_cfo / 15000;
  ue_sync.cfo_is_copied           = true;
  ue_sync.cfo_correct_enable_find = true;
  srsran_sync_set_cfo_cp_enable(&ue_sync.sfind, false, 0);

  ZERO_OBJECT(ue_dl_cfg);
  ZERO_OBJECT(dl_sf);
  ZERO_OBJECT(pdsch_cfg);

  pdsch_cfg.meas_evm_en = true;

  if (cell.frame_type == SRSRAN_TDD && prog_args.tdd_special_sf >= 0 && prog_args.sf_config >= 0) {
    dl_sf.tdd_config.ss_config  = prog_args.tdd_special_sf;
    dl_sf.tdd_config.sf_config  = prog_args.sf_config;
    dl_sf.tdd_config.configured = true;
  }

  srsran_chest_dl_cfg_t chest_pdsch_cfg = {};
  chest_pdsch_cfg.cfo_estimate_enable   = prog_args.enable_cfo_ref;
  chest_pdsch_cfg.cfo_estimate_sf_mask  = 1023;
  chest_pdsch_cfg.estimator_alg         = srsran_chest_dl_str2estimator_alg(prog_args.estimator_alg);
  chest_pdsch_cfg.sync_error_enable     = true;

  // Special configuration for MBSFN channel estimation
  srsran_chest_dl_cfg_t chest_mbsfn_cfg = {};
  chest_mbsfn_cfg.filter_type           = SRSRAN_CHEST_FILTER_TRIANGLE;
  chest_mbsfn_cfg.filter_coef[0]        = 0.1;
  chest_mbsfn_cfg.estimator_alg         = SRSRAN_ESTIMATOR_ALG_INTERPOLATE;
  chest_mbsfn_cfg.noise_alg             = SRSRAN_NOISE_ALG_PSS;

  // Allocate softbuffer buffers
  srsran_softbuffer_rx_t rx_softbuffers[SRSRAN_MAX_CODEWORDS];
  for (uint32_t i = 0; i < SRSRAN_MAX_CODEWORDS; i++) {
    pdsch_cfg.softbuffers.rx[i] = &rx_softbuffers[i];
    srsran_softbuffer_rx_init(pdsch_cfg.softbuffers.rx[i], cell.nof_prb);
  }

  pdsch_cfg.rnti = prog_args.rnti;

  /* Configure MBSFN area id and non-MBSFN Region */
  if (prog_args.mbsfn_area_id > -1) {
    srsran_ue_dl_set_mbsfn_area_id(&ue_dl, prog_args.mbsfn_area_id);
    srsran_ue_dl_set_non_mbsfn_region(&ue_dl, prog_args.non_mbsfn_region);
  }

#ifdef ENABLE_GUI
  if (!prog_args.disable_plots) {
    init_plots();
    sleep(1);
  }
#endif /* ENABLE_GUI */

#ifndef DISABLE_RF
  if (!prog_args.input_file_name) {
    srsran_rf_start_rx_stream(&rf, false);
  }
#endif

#ifndef DISABLE_RF
  if (prog_args.rf_gain < 0 && !prog_args.input_file_name) {
    srsran_rf_info_t* rf_info = srsran_rf_get_info(&rf);
    srsran_ue_sync_start_agc(&ue_sync,
                             srsran_rf_set_rx_gain_th_wrapper_,
                             rf_info->min_rx_gain,
                             rf_info->max_rx_gain,
                             cell_detect_config.init_agc);
  }
#endif
#ifdef PRINT_CHANGE_SCHEDULING
  srsran_ra_dl_grant_t old_dl_dci;
  bzero(&old_dl_dci, sizeof(srsran_ra_dl_grant_t));
#endif

  ue_sync.cfo_correct_enable_track = !prog_args.disable_cfo;

  srsran_pbch_decode_reset(&ue_mib.pbch);

  INFO(""\nEntering main loop..."");

  // Variables for measurements
  uint32_t nframes = 0;
  float    rsrp0 = 0.0, rsrp1 = 0.0, rsrq = 0.0, snr = 0.0, enodebrate = 0.0, uerate = 0.0, procrate = 0.0,
        sinr[SRSRAN_MAX_LAYERS][SRSRAN_MAX_CODEBOOKS] = {}, sync_err[SRSRAN_MAX_PORTS][SRSRAN_MAX_PORTS] = {};
  bool decode_pdsch = false;

  for (int i = 0; i < SRSRAN_MAX_LAYERS; i++) {
    srsran_vec_f_zero(sinr[i], SRSRAN_MAX_CODEBOOKS);
  }

  /* Main loop */
  int sf_cnt          = 0;
  uint32_t sfn             = 0;
  uint32_t last_decoded_tm = 0;
  while (!go_exit && (sf_cnt < prog_args.nof_subframes || prog_args.nof_subframes == -1)) {
    char input[128];
    PRINT_LINE_INIT();

    fd_set set;
    FD_ZERO(&set);
    FD_SET(0, &set);

    struct timeval to;
    to.tv_sec  = 0;
    to.tv_usec = 0;

    /* Set default verbose level */
    set_srsran_verbose_level(prog_args.verbose);
    int n = select(1, &set, NULL, NULL, &to);
    if (n == 1) {
      /* If a new line is detected set verbose level to Debug */
      if (fgets(input, sizeof(input), stdin)) {
        set_srsran_verbose_level(SRSRAN_VERBOSE_DEBUG);
        pkt_errors   = 0;
        pkt_total    = 0;
        nof_detected = 0;
        nof_trials   = 0;
      }
    }

    cf_t* buffers[SRSRAN_MAX_CHANNELS] = {};
    for (int p = 0; p < SRSRAN_MAX_PORTS; p++) {
      buffers[p] = sf_buffer[p];
    }
    ret = srsran_ue_sync_zerocopy(&ue_sync, buffers,  [MASK] );
    if (ret < 0) {
      ERROR(""Error calling srsran_ue_sync_work()"");
    }

#ifdef CORRECT_SAMPLE_OFFSET
    float sample_offset =
        (float)srsran_ue_sync_get_last_sample_offset(&ue_sync) + srsran_ue_sync_get_sfo(&ue_sync) / 1000;
    srsran_ue_dl_set_sample_offset(&ue_dl, sample_offset);
#endif

    /* srsran_ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
    if (ret == 1) {
      bool           acks[SRSRAN_MAX_CODEWORDS] = {false};
      struct timeval t[3];

      uint32_t sf_idx = srsran_ue_sync_get_sfidx(&ue_sync);

      switch (state) {
        case DECODE_MIB:
          if (sf_idx == 0) {
            uint8_t bch_payload[SRSRAN_BCH_PAYLOAD_LEN];
            int     sfn_offset;
            n = srsran_ue_mib_decode(&ue_mib, bch_payload, NULL, &sfn_offset);
            if (n < 0) {
              ERROR(""Error decoding UE MIB"");
              exit(-1);
            } else if (n == SRSRAN_UE_MIB_FOUND) {
              srsran_pbch_mib_unpack(bch_payload, &cell, &sfn);
              srsran_cell_fprint(stdout, &cell, sfn);
              printf(""Decoded MIB. SFN: %d, offset: %d\n"", sfn, sfn_offset);
              sfn   = (sfn + sfn_offset) % 1024;
              state = DECODE_PDSCH;
            }
          }
          break;
        case DECODE_PDSCH:

          if (prog_args.rnti != SRSRAN_SIRNTI) {
            decode_pdsch = true;
            if (srsran_sfidx_tdd_type(dl_sf.tdd_config, sf_idx) == SRSRAN_TDD_SF_U) {
              decode_pdsch = false;
            }
          } else {
            /* We are looking for SIB1 Blocks, search only in appropiate places */
            if ((sf_idx == 5 && (sfn % 2) == 0) || mch_table[sf_idx] == 1) {
              decode_pdsch = true;
            } else {
              decode_pdsch = false;
            }
          }

          uint32_t tti = sfn * 10 + sf_idx;

          gettimeofday(&t[1], NULL);
          if (decode_pdsch) {
            srsran_sf_t sf_type;
            if (mch_table[sf_idx] == 0 || prog_args.mbsfn_area_id < 0) { // Not an MBSFN subframe
              sf_type = SRSRAN_SF_NORM;

              // Set PDSCH channel estimation
              ue_dl_cfg.chest_cfg = chest_pdsch_cfg;
            } else {
              sf_type = SRSRAN_SF_MBSFN;

              // Set MBSFN channel estimation
              ue_dl_cfg.chest_cfg = chest_mbsfn_cfg;
            }

            n = 0;
            for (uint32_t tm = 0; tm < 4 && !n; tm++) {
              dl_sf.tti                             = tti;
              dl_sf.sf_type                         = sf_type;
              ue_dl_cfg.cfg.tm                      = (srsran_tm_t)tm;
              ue_dl_cfg.cfg.pdsch.use_tbs_index_alt = prog_args.enable_256qam;

              if ((ue_dl_cfg.cfg.tm == SRSRAN_TM1 && cell.nof_ports == 1) ||
                  (ue_dl_cfg.cfg.tm > SRSRAN_TM1 && cell.nof_ports > 1)) {
                n = srsran_ue_dl_find_and_decode(&ue_dl, &dl_sf, &ue_dl_cfg, &pdsch_cfg, data, acks);
                if (n > 0) {
                  if (! sib_decoded) {
                    for (uint32_t tb = 0; tb < SRSRAN_MAX_CODEWORDS; tb++) {
                      if (pdsch_cfg.grant.tb[tb].enabled) {
                        asn1::cbit_ref bref{data[tb], (uint32_t)(1 + (pdsch_cfg.grant.tb[tb].tbs - 1) / 8)};
                        asn1::rrc::bcch_dl_sch_msg_s dlsch_msg;
                        dlsch_msg.unpack(bref);
                        if (dlsch_msg.msg.c1().type() == asn1::rrc::bcch_dl_sch_msg_type_c::c1_c_::types::sib_type1) {
                          //printf(""Decoded SIB1. Payload: "");
                          //srsran_vec_fprint_byte(stdout, data[tb], 1 + (pdsch_cfg.grant.tb[tb].tbs - 1) / 8);
                          //asn1::json_writer json_writer;
                          //dlsch_msg.msg.c1().sib_type1().to_json(json_writer);
                          //printf(""%s"", json_writer.to_string().c_str());
                          asn1::rrc::sib_type1_s & sib1 (dlsch_msg.msg.c1().sib_type1());
                          printf(""Decoded SIB1."");
                          for (const auto& e : sib1.cell_access_related_info.plmn_id_list) {
                            if (e.plmn_id.mcc_present) {
                              printf(""  MCC: "");
                              for (const auto& d : e.plmn_id.mcc) { printf(""%d"", d); }
                            }
                            printf(""  MNC: "");
                            for (const auto& d : e.plmn_id.mnc) { printf(""%d"", d); }
                          }
                          printf(""  TAC: %lu"", sib1.cell_access_related_info.tac.to_number());
                          printf(""  CellId: %lu"", sib1.cell_access_related_info.cell_id.to_number());
                          printf(""\n"");
                          sib_decoded = 1;
                        }
                      }
                    }
                  }
                  nof_detected++;
                  last_decoded_tm = tm;
                  for (uint32_t tb = 0; tb < SRSRAN_MAX_CODEWORDS; tb++) {
                    if (pdsch_cfg.grant.tb[tb].enabled) {
                      if (!acks[tb]) {
                        if (sf_type == SRSRAN_SF_NORM) {
                          pkt_errors++;
                        } else {
                          pmch_pkt_errors++;
                        }
                      }
                      if (sf_type == SRSRAN_SF_NORM) {
                        pkt_total++;
                      } else {
                        pmch_pkt_total++;
                      }
                    }
                  }
                }
              }
            }
            // Feed-back ue_sync with chest_dl CFO estimation
            if (sf_idx == 5 && prog_args.enable_cfo_ref) {
              srsran_ue_sync_set_cfo_ref(&ue_sync, ue_dl.chest_res.cfo);
            }

            gettimeofday(&t[2], NULL);
            get_time_interval(t);

            if (n > 0) {
              /* Send data if socket active */
              if (prog_args.net_port > 0) {
                if (sf_idx == 1) {
                  srsran_netsink_write(&net_sink, data[0], 1 + (n - 1) / 8);
                } else {
                  // TODO: UDP Data transmission does not work
                  for (uint32_t tb = 0; tb < SRSRAN_MAX_CODEWORDS; tb++) {
                    if (pdsch_cfg.grant.tb[tb].enabled) {
                      srsran_netsink_write(&net_sink, data[tb], 1 + (pdsch_cfg.grant.tb[tb].tbs - 1) / 8);
                    }
                  }
                }
              }
#ifdef PRINT_CHANGE_SCHEDULING
              if (pdsch_cfg.dci.cw[0].mcs_idx != old_dl_dci.cw[0].mcs_idx ||
                  memcmp(&pdsch_cfg.dci.type0_alloc, &old_dl_dci.type0_alloc, sizeof(srsran_ra_type0_t)) ||
                  memcmp(&pdsch_cfg.dci.type1_alloc, &old_dl_dci.type1_alloc, sizeof(srsran_ra_type1_t)) ||
                  memcmp(&pdsch_cfg.dci.type2_alloc, &old_dl_dci.type2_alloc, sizeof(srsran_ra_type2_t))) {
                old_dl_dci = pdsch_cfg.dci;
                fflush(stdout);
                printf(""DCI %s\n"", srsran_dci_format_string(pdsch_cfg.dci.dci_format));
                srsran_ra_pdsch_fprint(stdout, &old_dl_dci, cell.nof_prb);
              }
#endif
            }

            nof_trials++;

            uint32_t enb_bits = ((pdsch_cfg.grant.tb[0].enabled ? pdsch_cfg.grant.tb[0].tbs : 0) +
                                 (pdsch_cfg.grant.tb[1].enabled ? pdsch_cfg.grant.tb[1].tbs : 0));
            uint32_t ue_bits  = ((acks[0] ? pdsch_cfg.grant.tb[0].tbs : 0) + (acks[1] ? pdsch_cfg.grant.tb[1].tbs : 0));
            rsrq              = SRSRAN_VEC_EMA(ue_dl.chest_res.rsrp_dbm, rsrq, 0.1f);
            rsrp0             = SRSRAN_VEC_EMA(ue_dl.chest_res.rsrp_port_dbm[0], rsrp0, 0.05f);
            rsrp1             = SRSRAN_VEC_EMA(ue_dl.chest_res.rsrp_port_dbm[1], rsrp1, 0.05f);
            snr               = SRSRAN_VEC_EMA(ue_dl.chest_res.snr_db, snr, 0.05f);
            enodebrate        = SRSRAN_VEC_EMA(enb_bits / 1000.0f, enodebrate, 0.05f);
            uerate            = SRSRAN_VEC_EMA(ue_bits / 1000.0f, uerate, 0.001f);
            if (chest_pdsch_cfg.sync_error_enable) {
              for (uint32_t i = 0; i < cell.nof_ports; i++) {
                for (uint32_t j = 0; j < prog_args.rf_nof_rx_ant; j++) {
                  sync_err[i][j] = SRSRAN_VEC_EMA(ue_dl.chest.sync_err[i][j], sync_err[i][j], 0.001f);
                  if (!isnormal(sync_err[i][j])) {
                    sync_err[i][j] = 0.0f;
                  }
                }
              }
            }
            float elapsed = (float)t[0].tv_usec + t[0].tv_sec * 1.0e+6f;
            if (elapsed != 0.0f) {
              procrate = SRSRAN_VEC_EMA(ue_bits / elapsed, procrate, 0.01f);
            }

            nframes++;
            if (isnan(rsrq)) {
              rsrq = 0;
            }
            if (isnan(snr)) {
              snr = 0;
            }
            if (isnan(rsrp0)) {
              rsrp0 = 0;
            }
            if (isnan(rsrp1)) {
              rsrp1 = 0;
            }
          }

          // Plot and Printf
          if (sf_idx == 5) {
            float gain = prog_args.rf_gain;
            if (gain < 0) {
              gain = srsran_convert_power_to_dB(srsran_agc_get_gain(&ue_sync.agc));
            }

            /* Print transmission scheme */

            /* Print basic Parameters */
            PRINT_LINE(""          CFO: %+7.2f Hz"", srsran_ue_sync_get_cfo(&ue_sync));
            PRINT_LINE(""         RSRP: %+5.1f dBm | %+5.1f dBm"", rsrp0, rsrp1);
            PRINT_LINE(""          SNR: %+5.1f dB"", snr);
            PRINT_LINE(""           TM: %d"", last_decoded_tm + 1);
            PRINT_LINE(
                ""           Rb: %6.2f / %6.2f / %6.2f Mbps (net/maximum/processing)"", uerate, enodebrate, procrate);
            PRINT_LINE(""   PDCCH-Miss: %5.2f%%"", 100 * (1 - (float)nof_detected / nof_trials));
            PRINT_LINE(""   PDSCH-BLER: %5.2f%%"", (float)100 * pkt_errors / pkt_total);
            PRINT_LINE(""   PDSCH-EVM: %5.2f%%"", ue_dl.pdsch.avg_evm);

            if (prog_args.mbsfn_area_id > -1) {
              PRINT_LINE(""   PMCH-BLER: %5.2f%%"", (float)100 * pkt_errors / pmch_pkt_total);
            }

            PRINT_LINE(""         TB 0: mcs=%d; tbs=%d"", pdsch_cfg.grant.tb[0].mcs_idx, pdsch_cfg.grant.tb[0].tbs);
            PRINT_LINE(""         TB 1: mcs=%d; tbs=%d"", pdsch_cfg.grant.tb[1].mcs_idx, pdsch_cfg.grant.tb[1].tbs);

            /* MIMO: if tx and rx antennas are bigger than 1 */
            if (cell.nof_ports > 1 && ue_dl.pdsch.nof_rx_antennas > 1) {
              uint32_t ri = 0;
              float    cn = 0;
              /* Compute condition number */
              if (srsran_ue_dl_select_ri(&ue_dl, &ri, &cn)) {
                /* Condition number calculation is not supported for the number of tx & rx antennas*/
                PRINT_LINE(""            κ: NA"");
              } else {
                /* Print condition number */
                PRINT_LINE(""            κ: %.1f dB, RI=%d (Condition number, 0 dB => Best)"", cn, ri);
              }
              PRINT_LINE("""");
            }
            if (chest_pdsch_cfg.sync_error_enable) {
              for (uint32_t i = 0; i < cell.nof_ports; i++) {
                for (uint32_t j = 0; j < prog_args.rf_nof_rx_ant; j++) {
                  PRINT_LINE(""sync_err[%d][%d]=%f"", i, j, sync_err[i][j]);
                }
              }
            }
            PRINT_LINE(""Press enter maximum printing debug log of 1 subframe."");
            PRINT_LINE("""");
            PRINT_LINE_RESET_CURSOR();
          }
          break;
      }
      if (sf_idx == 9) {
        sfn++;
        if (sfn == 1024) {
          sfn = 0;
          PRINT_LINE_ADVANCE_CURSOR();
          pkt_errors      = 0;
          pkt_total       = 0;
          pmch_pkt_errors = 0;
          pmch_pkt_total  = 0;
        }
      }

#ifdef ENABLE_GUI
      if (!prog_args.disable_plots) {
        if ((sfn % 3) == 0 && decode_pdsch) {
          plot_sf_idx = sf_idx;
          plot_track  = true;
          sem_post(&plot_sem);
        }
      }
#endif /* ENABLE_GUI */
    } else if (ret == 0) {
      printf(""Finding PSS... Peak: %8.1f, FrameCnt: %d, State: %d\r"",
             srsran_sync_get_peak_value(&ue_sync.sfind),
             ue_sync.frame_total_cnt,
             ue_sync.state);
#ifdef ENABLE_GUI
      if (!prog_args.disable_plots) {
        plot_sf_idx = srsran_ue_sync_get_sfidx(&ue_sync);
        plot_track  = false;
        sem_post(&plot_sem);
      }
#endif /* ENABLE_GUI */
    }

    sf_cnt++;
  } // Main loop

#ifdef ENABLE_GUI
  if (!prog_args.disable_plots) {
    if (!pthread_kill(plot_thread, 0)) {
      pthread_kill(plot_thread, SIGHUP);
      pthread_join(plot_thread, NULL);
    }
  }
#endif
  srsran_ue_dl_free(&ue_dl);
  srsran_ue_sync_free(&ue_sync);
  for (int i = 0; i < SRSRAN_MAX_CODEWORDS; i++) {
    if (data[i]) {
      free(data[i]);
    }
  }
  for (uint32_t i = 0; i < prog_args.rf_nof_rx_ant; i++) {
    if (sf_buffer[i]) {
      free(sf_buffer[i]);
    }
  }

#ifndef DISABLE_RF
  if (!prog_args.input_file_name) {
    srsran_ue_mib_free(&ue_mib);
    srsran_rf_close(&rf);
  }
#endif

  printf(""\nBye\n"");
  exit(0);
}

/**********************************************************************
 *  Plotting Functions
 ***********************************************************************/
#ifdef ENABLE_GUI

plot_real_t    p_sync, pce;
plot_scatter_t pscatequal, pscatequal_pdcch, pscatequal_pmch;

static float tmp_plot[110 * 15 * 2048];
static float tmp_plot2[110 * 15 * 2048];

void* plot_thread_run(void* arg)
{
  uint32_t i;
  uint32_t nof_re = SRSRAN_SF_LEN_RE(ue_dl.cell.nof_prb, ue_dl.cell.cp);

  sdrgui_init();

  plot_scatter_init(&pscatequal);
  plot_scatter_setTitle(&pscatequal, (char *)""PDSCH - Equalized Symbols"");
  plot_scatter_setXAxisScale(&pscatequal, -4, 4);
  plot_scatter_setYAxisScale(&pscatequal, -4, 4);

  plot_scatter_addToWindowGrid(&pscatequal, (char*)""pdsch_ue"", 0, 0);

  if (enable_mbsfn_plot) {
    plot_scatter_init(&pscatequal_pmch);
    plot_scatter_setTitle(&pscatequal_pmch, (char *)""PMCH - Equalized Symbols"");
    plot_scatter_setXAxisScale(&pscatequal_pmch, -4, 4);
    plot_scatter_setYAxisScale(&pscatequal_pmch, -4, 4);
    plot_scatter_addToWindowGrid(&pscatequal_pmch, (char*)""pdsch_ue"", 0, 1);
  }

  if (!prog_args.disable_plots_except_constellation) {
    plot_real_init(&pce);
    plot_real_setTitle(&pce, (char *)""Channel Response - Magnitude"");
    plot_real_setLabels(&pce, (char *)""Index"", (char *)""dB"");
    plot_real_setYAxisScale(&pce, -40, 40);

    plot_real_init(&p_sync);
    plot_real_setTitle(&p_sync, (char *)""PSS Cross-Corr abs value"");
    plot_real_setYAxisScale(&p_sync, 0, 1);

    plot_scatter_init(&pscatequal_pdcch);
    plot_scatter_setTitle(&pscatequal_pdcch, (char *)""PDCCH - Equalized Symbols"");
    plot_scatter_setXAxisScale(&pscatequal_pdcch, -4, 4);
    plot_scatter_setYAxisScale(&pscatequal_pdcch, -4, 4);

    plot_real_addToWindowGrid(&pce, (char*)""pdsch_ue"", 0, (enable_mbsfn_plot) ? 2 : 1);
    plot_real_addToWindowGrid(&pscatequal_pdcch, (char*)""pdsch_ue"", 1, 0);
    plot_real_addToWindowGrid(&p_sync, (char*)""pdsch_ue"", 1, 1);
  }

  while (1) {
    sem_wait(&plot_sem);

    uint32_t nof_symbols = pdsch_cfg.grant.nof_re;
    if (!prog_args.disable_plots_except_constellation) {
      for (i = 0; i < nof_re; i++) {
        tmp_plot[i] = srsran_convert_amplitude_to_dB(std::abs(std::complex<float>(ue_dl.sf_symbols[0][i])));
        if (isinf(tmp_plot[i])) {
          tmp_plot[i] = -80;
        }
      }
      int sz = srsran_symbol_sz(ue_dl.cell.nof_prb);
      if (sz > 0) {
        srsran_vec_f_zero(tmp_plot2, sz);
      }
      int g = (sz - 12 * ue_dl.cell.nof_prb) / 2;
      for (i = 0; i < 12 * ue_dl.cell.nof_prb; i++) {
        tmp_plot2[g + i] = srsran_convert_amplitude_to_dB(std::abs(std::complex<float>(ue_dl.chest_res.ce[0][0][i])));
        if (isinf(tmp_plot2[g + i])) {
          tmp_plot2[g + i] = -80;
        }
      }
      plot_real_setNewData(&pce, tmp_plot2, sz);

      if (!prog_args.input_file_name) {
        if (plot_track) {
          srsran_pss_t* pss_obj = srsran_sync_get_cur_pss_obj(&ue_sync.strack);
          int           max = srsran_vec_max_fi(pss_obj->conv_output_avg, pss_obj->frame_size + pss_obj->fft_size - 1);
          srsran_vec_sc_prod_fff(pss_obj->conv_output_avg,
                                 1 / pss_obj->conv_output_avg[max],
                                 tmp_plot2,
                                 pss_obj->frame_size + pss_obj->fft_size - 1);
          plot_real_setNewData(&p_sync, tmp_plot2, pss_obj->frame_size);
        } else {
          int max = srsran_vec_max_fi(ue_sync.sfind.pss.conv_output_avg,
                                      ue_sync.sfind.pss.frame_size + ue_sync.sfind.pss.fft_size - 1);
          srsran_vec_sc_prod_fff(ue_sync.sfind.pss.conv_output_avg,
                                 1 / ue_sync.sfind.pss.conv_output_avg[max],
                                 tmp_plot2,
                                 ue_sync.sfind.pss.frame_size + ue_sync.sfind.pss.fft_size - 1);
          plot_real_setNewData(&p_sync, tmp_plot2, ue_sync.sfind.pss.frame_size);
        }
      }

      plot_scatter_setNewData(&pscatequal_pdcch, ue_dl.pdcch.d, 36 * ue_dl.pdcch.nof_cce[0]);
    }

    plot_scatter_setNewData(&pscatequal, ue_dl.pdsch.d[0], nof_symbols);

    if (enable_mbsfn_plot) {
      plot_scatter_setNewData(&pscatequal_pmch, ue_dl.pmch.d, nof_symbols);
    }

    if (plot_sf_idx == 1) {
      if (prog_args.net_port_signal > 0) {
        srsran_netsink_write(
            &net_sink_signal, &sf_buffer[srsran_ue_sync_sf_len(&ue_sync) / 7], srsran_ue_sync_sf_len(&ue_sync));
      }
    }
  }
  return NULL;
}

void init_plots()
{
  if (sem_init(&plot_sem, 0, 0)) {
    perror(""sem_init"");
    exit(-1);
  }

  pthread_attr_t     attr;
  struct sched_param param;
  param.sched_priority = 0;
  pthread_attr_init(&attr);
  pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
  pthread_attr_setschedparam(&attr, &param);
  if (pthread_create(&plot_thread, NULL, plot_thread_run, NULL)) {
    perror(""pthread_create"");
    exit(-1);
  }
}

#endif /* ENABLE_GUI */
",max_num_samples
550,"#include <fstream>
#include <iostream>
#include <signal.h>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <assert.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <map>
#include ""tiny_opengl3_app.h""
#include ""tiny_clock.h""
#include ""tiny_chrome_trace_util.h""
#include ""tiny_logging.h""
#include <iostream>
#include ""imgui.h""
#include ""opengl3/imgui_impl_opengl3.h""
#include ""imnodes.h""
#include ""imgui.h""
#include <iostream>





#ifdef _WIN32
#include ""win32_shared_memory.h""
using namespace visdebug;
#else
#include ""posix_shared_memory.h""
#endif

using namespace visdebug;

int key = SHARED_MEMORY_KEY;
int size = sizeof(SharedMemoryBlock);


#ifndef _WIN32
#include <signal.h>
#include <err.h>
#include <unistd.h>

static bool interrupted = false;

PosixSharedMemory shmem;
static void cleanup(int signo)
{
        if (!interrupted)
        {  // this is the second time, we're hanging somewhere
                std::cout << ""Aborting and deleting SharedMemoryCommon object"" << std::endl;
                shmem.release(key, size);
                sleep(1);
                std::cout << EXIT_FAILURE << "" aborted example on signal "" << signo << std::endl;
        }
        else
        {
                std::cout << ""no action"" << std::endl;
                exit(EXIT_FAILURE);
        }
        interrupted = true;
        warnx(""caught signal %d"", signo);
}


#endif // _WIN32




bool keep_running = true;


#ifndef IMGUI_DEFINE_MATH_OPERATORS
#define IMGUI_DEFINE_MATH_OPERATORS
#endif
#include ""imgui_internal.h""


bool releasedA = false;
TinyKeyboardCallback default_keyboard_callback = 0;

TinyMouseMoveCallback default_mouse_move_callback = 0;
TinyMouseButtonCallback default_mouse_button_callback = 0;

float g_MouseWheel = 0;
float gMouseX = 0;
float gMouseY = 0;
int g_MousePressed[3] = { 0,0,0 };

void MyMouseMoveCallback(float x, float y)
{
    gMouseX = x;
    gMouseY = y;
    if (default_mouse_move_callback)
        default_mouse_move_callback(x, y);
}
void MyMouseButtonCallback(int button, int state, float x, float y)
{
    gMouseX = x;
    gMouseY = y;
    g_MousePressed[button] = state;
    if (default_mouse_button_callback)
        default_mouse_button_callback(button, state, x, y);
}


float noteToFreq(int note) {
    float a = 440.; // frequency of A (coomon value is 440Hz)
    return (a / 3.) * pow(2., ((note - 9.) / 12.));
}
std::map<char, int> key2note = {
    {'a',0},
        {'w',1},
    {'s',2},
        {'e',3},
    {'d',4},
    {'f',5},
        {'t',6},
    {'g',7},
        {'y',8},
    {'h',9},
        {'u',10},
    {'j',11},
    {'k',12},
};

int octave = 1;

void MyKeyboardCallback(int  [MASK] , int state)
{

    if (( [MASK]  == 'a') && (state == 0))
    {
        releasedA = true;
    }

    ImGuiIO& io = ImGui::GetIO();
    if (state == 1)
        io.KeysDown[ [MASK] ] = true;
    if (state == 0)
        io.KeysDown[ [MASK] ] = false;

    if (state==1 &&
        (
            ( [MASK]  >= 'a' &&  [MASK]  <= 'z') ||
            ( [MASK]  >= '0' &&  [MASK]  <= '9') ||
            ( [MASK]  == ' ') ||
            ( [MASK]  == '!') || ( [MASK]  == '@') || ( [MASK]  == '#') || ( [MASK]  == '$') || ( [MASK]  == '%') || ( [MASK]  == '.') ||
            ( [MASK]  == ',') || ( [MASK]  == '\""') || ( [MASK]  == '\'') || ( [MASK]  == '~') || ( [MASK]  == '-') || ( [MASK]  == '=') ||
            ( [MASK]  == '+') || ( [MASK]  == '[') || ( [MASK]  == ']') || ( [MASK]  == '?') || ( [MASK]  == '*') || ( [MASK]  == '(') ||
            ( [MASK]  == ')') || ( [MASK]  == '^') || ( [MASK]  == '&')
        )
       )
    {
        io.AddInputCharacter( [MASK] );
    }
    // Modifiers are not reliable across systems
    if ( [MASK]  == TINY_KEY_ALT)
        io.KeyAlt = state;
    if ( [MASK]  == TINY_KEY_CONTROL)
        io.KeyCtrl = state;
    if ( [MASK]  == TINY_KEY_SHIFT)
        io.KeyShift = state;

//#ifdef _WIN32
    io.KeySuper = false;
//#else
//    io.KeySuper = io.KeysDown[GLFW_KEY_LEFT_SUPER] || io.KeysDown[GLFW_KEY_RIGHT_SUPER];
//#endif

    if (default_keyboard_callback)
    {
        default_keyboard_callback( [MASK] , state);
    }

}


std::vector<float> wav_data;


int main(int argc, char* argv[]) {

//in case the application terminates early, we still need to clean up
//shared memory, so install a handler

#ifdef _WIN32

    if (!SetConsoleCtrlHandler(consoleHandler, TRUE)) {
        printf(""\nERROR: Could not set control handler"");
        return 1;
    }

    Win32SharedMemory shmem;
#else

    struct sigaction action;
    memset(&action, 0x0, sizeof(action));
    action.sa_handler = cleanup;
    static const int signos[] = {SIGHUP, SIGINT, SIGQUIT, SIGABRT, SIGSEGV, SIGPIPE, SIGTERM};
    for (int ii(0); ii < sizeof(signos) / sizeof(*signos); ++ii)
    {
            if (0 != sigaction(signos[ii], &action, NULL))
            {
                    err(EXIT_FAILURE, ""signal %d"", signos[ii]);
            }
    }
#endif // _WIN32
	//only the server initializes the shared memory!
	bool allowCreation = true;

	SharedMemoryBlock* shared_mem_block = static_cast<SharedMemoryBlock*>(shmem.allocate(key, size, allowCreation));
	if (shared_mem_block)
	{
		std::cout << ""server"" << std::endl;
		//make sure there isn't already a shared memory server running
		if (shared_mem_block->version_number_ == SHARED_MEMORY_VERSION_NUMBER)
		{
			std::cout << ""shared memory server is already running, terminating"" << std::endl;
		} else
		{
			shared_mem_block->num_client_commands_ = 0;
			shared_mem_block->num_processed_client_commands_ = 0;
			shared_mem_block->num_server_status_ = 0;
			shared_mem_block->num_processed_server_status_ = 0;
			shared_mem_block->version_number_ = SHARED_MEMORY_VERSION_NUMBER;

            TinyOpenGL3App app(""visual debugger"", 1024, 768);

            //TinyChromeUtilsStartTimings();

            TinyClock clock;
            clock.reset();
            double prev_time = clock.get_time_seconds();

            app.set_up_axis(2);

            default_mouse_move_callback = app.m_window->get_mouse_move_callback();
            app.m_window->set_mouse_move_callback(MyMouseMoveCallback);
            default_mouse_button_callback = app.m_window->get_mouse_button_callback();
            app.m_window->set_mouse_button_callback(MyMouseButtonCallback);
            default_keyboard_callback = app.m_window->get_keyboard_callback();
            app.m_window->set_keyboard_callback(MyKeyboardCallback);

            IMGUI_CHECKVERSION();
            ImGui::CreateContext();
            ImGuiIO& io = ImGui::GetIO(); (void)io;

            //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
            io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
            io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;

            io.KeyMap[ImGuiKey_Tab] = TINY_KEY_TAB;
            io.KeyMap[ImGuiKey_LeftArrow] = TINY_KEY_LEFT_ARROW;
            io.KeyMap[ImGuiKey_RightArrow] = TINY_KEY_RIGHT_ARROW;
            io.KeyMap[ImGuiKey_UpArrow] = TINY_KEY_UP_ARROW;
            io.KeyMap[ImGuiKey_DownArrow] = TINY_KEY_DOWN_ARROW;
            io.KeyMap[ImGuiKey_PageUp] = TINY_KEY_PAGE_UP;
            io.KeyMap[ImGuiKey_PageDown] = TINY_KEY_PAGE_DOWN;
            io.KeyMap[ImGuiKey_Home] = TINY_KEY_HOME;
            io.KeyMap[ImGuiKey_End] = TINY_KEY_END;
            io.KeyMap[ImGuiKey_Insert] = TINY_KEY_INSERT;
            io.KeyMap[ImGuiKey_Delete] = TINY_KEY_DELETE;
            io.KeyMap[ImGuiKey_Backspace] = TINY_KEY_BACKSPACE;
            io.KeyMap[ImGuiKey_Space] = '`';// ' ';
            io.KeyMap[ImGuiKey_Enter] = TINY_KEY_RETURN;
            io.KeyMap[ImGuiKey_Escape] = TINY_KEY_ESCAPE;
            io.KeyMap[ImGuiKey_KeyPadEnter] = 0;

            io.KeyMap[ImGuiKey_A] = 'a';
            io.KeyMap[ImGuiKey_C] = 'c';
            io.KeyMap[ImGuiKey_V] = 'v';
            io.KeyMap[ImGuiKey_X] = 'x';
            io.KeyMap[ImGuiKey_Y] = 'y';
            io.KeyMap[ImGuiKey_Z] = 'z';


            // Setup Dear ImGui style
            ImGui::StyleColorsDark();
            if (1)
            {
              float SCALE = 2.0f;
              ImFontConfig cfg;
              cfg.SizePixels = 13 * SCALE;
              ImGui::GetIO().Fonts->AddFontDefault(&cfg)->DisplayOffset.y = SCALE;
              ImGui::GetStyle().ScaleAllSizes(SCALE);
            }
            //ImGui::StyleColorsClassic();
            const char* glsl_version = ""#version 330"";

            // Setup Platform/Renderer bindings
            ImGui_ImplOpenGL3_Init(glsl_version);
            bool res = ImGui_ImplOpenGL3_CreateDeviceObjects();

            imnodes::Initialize();
            //imnodes::SetNodeGridSpacePos(1, ImVec2(200.0f, 200.0f));

            // Setup style

            imnodes::StyleColorsDark();
            //imnodes::StyleColorsClassic();



            while (!app.m_window->requested_exit() && keep_running)
            {
                B3_PROFILE(""mainloop"");
				//check if there is any unprocessed commands
				if (shared_mem_block->num_client_commands_ > shared_mem_block->num_processed_client_commands_)
				{
					//process command
					const SharedMemoryCommand& client_cmd = shared_mem_block->client_command_;
					switch (client_cmd.type)
					{
						case CMD_DEBUG_AUDIO:
						{
							int num_float_values = client_cmd.debugArguments.num_float_values;

							std::cout << ""received audio data: "" << num_float_values << "" float values"" << std::endl;
                            wav_data.resize(num_float_values);
                            for (int i=0;i<num_float_values;i++)
                            {
                                wav_data[i] = shared_mem_block->float_values_[i];
                            }

							shared_mem_block->server_status_.status_code = STAT_DEBUG_AUDIO_COMPLETED;
							shared_mem_block->num_server_status_++;
							break;
						}
						case CMD_TERMINATE_SERVER:
						{
							std::cout << ""terminate server command received"" << std::endl;
							shared_mem_block->server_status_.status_code = STAT_TERMINATE_SERVER_COMPLETED;
							shared_mem_block->num_server_status_++;
							keep_running = false;
							break;
						};
						default:
						{
							std::cout << ""Unknown command"" << std::endl;
						}
					};

					shared_mem_block->num_processed_client_commands_++;
				}

                int upAxis = 2;

                DrawGridData data;
                data.upAxis = 2;

                float width = (float)app.m_window->get_width();
                float height = (float)app.m_window->get_height();

                io.DisplaySize = ImVec2((float)width, (float)height);
                io.DisplayFramebufferScale = ImVec2(app.m_window->get_retina_scale(), app.m_window->get_retina_scale());
                double t = clock.get_time_seconds();
                float dt = t - prev_time;
                prev_time = t;
                io.DeltaTime = (float)dt;
                io.MousePos = ImVec2((float)gMouseX, (float)gMouseY);
                io.RenderDrawListsFn = ImGui_ImplOpenGL3_RenderDrawData;// ImGui_ImplBullet_RenderDrawLists;

                for (int i = 0; i < 3; i++)
                {
                    io.MouseDown[i] = g_MousePressed[i];
                }
                io.MouseWheel = g_MouseWheel;

                ImGui::NewFrame();

                ImGui::SetNextWindowSize(ImVec2(800,300));
                if(ImGui::Begin(""wave window""))
                {
                    //ImGui::Checkbox(""Animate"",&animate);

                    // Plots can display overlay texts
                    // (in this example, we will display an average value)
                    if (wav_data.size())
                    {
                        float average = 0.0f;
                        int arrlen = (int)wav_data.size();
                        for(int n = 0; n < arrlen; n++)
                            average += wav_data[n];
                        average /= (float)arrlen;
                        char overlay[32];
                        sprintf(overlay,""len %d"",arrlen);
                        //ImGui::PlotLines(""Lines"",wav_data,arrlen,0,overlay,-1.0f,1.0f,ImVec2(0,180.0f));
                        ImGui::PlotLines("""",&wav_data[0],arrlen,0,overlay,-1.0f,1.0f,ImVec2(0,180.0f));
                    } else
                    {
                        ImGui::Text(""No Data Received"");
                    }

                }
                ImGui::End();

                ImGui::Render();
                ImGui::EndFrame();
                {
                    app.swap_buffer();
                }
            }

		}

	} else
	{
		std::cout << ""Cannot create shared memory"" << std::endl;
	}

	std::cout << ""Releasing shared memory"" << std::endl;
	shmem.release(key, size);


#if 0
    int num_samples = 1024;
    wav_data.resize(num_samples);
    for (int i=0;i<num_samples;i++)
    {
        wav_data[i] = 0.8*sin(3.14*2*float(i)/1024);
    }
#endif


  //TinyChromeUtilsStopTimingsAndWriteJsonFile(""performance_profile.json"");

  return 0;
}

",keycode
551,"#ifndef _STOCKREPOSITORY_H
#define _STOCKREPOSITORY_H

#include <string>
#include <Wt/Json/Array>
#include <Wt/Json/Parser>
#include <Wt/Json/Serializer>
#include <Wt/Json/Object>
#include <Wt/WDateTime>

#include ""../webApiAccess/StockWebApiAccess.h""
#include ""../../common/StringHelper.h""
//#include ""../../common/model/Stock.h""
#include ""../../common/model/Models.h""

class StockRepository : public StockWebApiAccess
{
public:
	StockRepository(const std::string& baseWebApiUr)
		: StockWebApiAccess(baseWebApiUr)
	{
	}

	// get the list with details of stocks
	// - int limit = how much itens you want
	std::vector<Stock> getListStock(int limit)
	{
		std::vector<Stock> retVector;
		// execute the method to criate and execute the webapi call
		getStockList(limit);
		if (this->getErrorLevel() != this->REQUEST_SUCCESS)
			return retVector;

		Wt::Json::Value resultValue;
		Wt::Json::Array  [MASK] ;
		Wt::Json::parse(this->getResponseValue(), resultValue);
		 [MASK]  = resultValue;
		for (Wt::Json::Array::iterator it =  [MASK] .begin(); it !=  [MASK] .end(); ++it)
		{
			Wt::Json::Object obj = *it;

			// Convert the date
			std::string date = obj.get(""lastUpdate"").toString();
			Wt::WDateTime dt = Wt::WDateTime(toPosixDate(date, ""%d%m%y""));

			Stock stk;
			stk.setStockId((int)obj.get(""stockid""));
			stk.setStockCode(obj.get(""stockcode"").toString());
			stk.setCompanyName(obj.get(""companyName"").toString());
			stk.setCountry(obj.get(""country"").toString());
			stk.setLastUpdate(dt);
			stk.setLastSalePrice((double)(obj.get(""lastSalePrice"").toNumber()));
			stk.setPriceVolume((double)(obj.get(""priceVolume"").toNumber()));
			stk.setValueChange((double)(obj.get(""valueChange"").toNumber()));
			stk.setChangePercent((double)(obj.get(""changePercent"").toNumber()));
			retVector.push_back(stk);
		}

		return retVector;
	}
};

#endif",resultArray
552,"#ifndef OGRREADER_H
#define OGRREADER_H

#include <vector>
#include <iostream>
#include <list>

#include <ogrsf_frmts.h>

#include ""VectorLayerShapeType.h""
#include ""ComponentNT.h""
#include ""stringsplit.h""

#ifndef LOG4CPLUS_ERROR
#define LOG4CPLUS_ERROR(L,M) std::cout << ""ERROR: "" << M << std::endl;
#endif

#ifndef LOG4CPLUS_INFO
#define LOG4CPLUS_INFO(L,M) std::cout << ""INFO: "" << M << std::endl;
#endif

static std::vector<VectorLayerShapeType> geom2shapes(OGRGeometry *const geom)
{
    std::vector<VectorLayerShapeType> shapes;
    VectorLayerShapeType shape;

    //wkbPoint = 1,           /**< 0-dimensional geometric object, standard WKB */
    //wkbLineString = 2,      /**< 1-dimensional geometric object with linear
    //                         *   interpolation between Points, standard WKB */
    //wkbPolygon = 3,         /**< planar 2-dimensional geometric object defined
    //                         *   by 1 exterior boundary and 0 or more interior
    //                         *   boundaries, standard WKB */
    //wkbMultiPoint = 4,      /**< GeometryCollection of Points, standard WKB */
    //wkbMultiLineString = 5, /**< GeometryCollection of LineStrings, standard WKB */
    //wkbMultiPolygon = 6,    /**< GeometryCollection of Polygons, standard WKB */
    //wkbGeometryCollection = 7

    if (wkbFlatten(geom->getGeometryType()) == wkbPoint )
    {
        OGRPoint *pnt = (OGRPoint *)geom;
        shape.points.clear();
        shape.min.x = pnt->getX();
        shape.min.y = pnt->getY();
        shape.max = shape.min;
        shape.geomType = VectorLayerShapeType::GeometryType::Point;
        shape.shapeKind = VectorLayerShapeType::GeoShapeKind::OTHER;
        shape.coordType = VectorLayerShapeType::CoordinateType::PLANAR;
        if (geom->getSpatialReference())
            shape.coordType = VectorLayerShapeType::CoordinateType::GEO;;
        shapes.push_back(shape);
    }
    else if (wkbFlatten(geom->getGeometryType()) == wkbPolygon)
    {
        OGRPolygon *polygon = (OGRPolygon *)geom;

        int int_rings = polygon->getNumInteriorRings();

        for (int r = -1; r < int_rings; ++r)
        {
            OGRLinearRing *ring = r >= 0 ? polygon->getInteriorRing(r) : polygon->getExteriorRing();
            OGRPoint pnt;

            const int num_points = ring->getNumPoints();
            shape.points.resize(num_points);
            shape.min.x = DBL_MAX;
            shape.min.y = DBL_MAX;
            shape.max.x = -DBL_MAX;
            shape.max.y = -DBL_MAX;
            for (int p = 0; p < num_points; ++p)
            {
                ring->getPoint(p, &pnt);
                const double x = pnt.getX();
                const double y = pnt.getY();
                shape.points[p] = component2d{x, y};
                shape.min.x = std::min(shape.points[p].x, shape.min.x);
                shape.min.y = std::min(shape.points[p].y, shape.min.y);
                shape.max.x = std::max(shape.points[p].x, shape.max.x);
                shape.max.y = std::max(shape.points[p].y, shape.max.y);
            }
            shape.geomType = VectorLayerShapeType::GeometryType::Polygon;
            shape.shapeKind = VectorLayerShapeType::GeoShapeKind::OTHER;
            shape.coordType = VectorLayerShapeType::CoordinateType::PLANAR;
            if (geom->getSpatialReference())
                shape.coordType = VectorLayerShapeType::CoordinateType::GEO;;
            shapes.push_back(shape);
        }
    }
    else if (wkbFlatten(geom->getGeometryType()) == wkbMultiPoint )
    {
        OGRMultiPoint *mpnt = (OGRMultiPoint *)geom;
        const int ngeom = mpnt->getNumGeometries();
        std::vector<VectorLayerShapeType> addshapes;
        for (int i = 0; i < ngeom; ++i)
        {
            addshapes = geom2shapes(mpnt->getGeometryRef(i));
            shapes.reserve(shapes.size() + addshapes.size());
            shapes.insert(shapes.end(), addshapes.begin(), addshapes.end());
        }
    }
    else if (wkbFlatten(geom->getGeometryType()) == wkbLineString )
    {
        OGRLineString *line = (OGRLineString *)geom;
        OGRPoint pnt;
        const int num_points = line->getNumPoints();
        shape.points.resize(num_points);
        shape.min.x = DBL_MAX;
        shape.min.y = DBL_MAX;
        shape.max.x = -DBL_MAX;
        shape.max.y = -DBL_MAX;
        for (int p = 0; p < num_points; ++p)
        {
            line->getPoint(p, &pnt);
            const double x = pnt.getX();
            const double y = pnt.getY();
            shape.points[p] = component2d{x, y};
            shape.min.x = std::min(shape.points[p].x, shape.min.x);
            shape.min.y = std::min(shape.points[p].y, shape.min.y);
            shape.max.x = std::max(shape.points[p].x, shape.max.x);
            shape.max.y = std::max(shape.points[p].y, shape.max.y);
        }
        shape.geomType = VectorLayerShapeType::GeometryType::LineString;
        shape.shapeKind = VectorLayerShapeType::GeoShapeKind::OTHER;
        shape.coordType = VectorLayerShapeType::CoordinateType::PLANAR;
        if (geom->getSpatialReference())
            shape.coordType = VectorLayerShapeType::CoordinateType::GEO;;
        shapes.push_back(shape);
    }
    else if (wkbFlatten(geom->getGeometryType()) == wkbMultiLineString )
    {
        OGRMultiLineString *mline = (OGRMultiLineString *)geom;
        const int ngeom = mline->getNumGeometries();
        std::vector<VectorLayerShapeType> addshapes;
        for (int i = 0; i < ngeom; ++i)
        {
            addshapes = geom2shapes(mline->getGeometryRef(i));
            shapes.reserve(shapes.size() + addshapes.size());
            shapes.insert(shapes.end(), addshapes.begin(), addshapes.end());
        }
    }
    else if (wkbFlatten(geom->getGeometryType()) == wkbMultiPolygon )
    {
        OGRMultiPolygon *mpolygon = (OGRMultiPolygon *)geom;
        const int ngeom = mpolygon->getNumGeometries();
        std::vector<VectorLayerShapeType> addshapes;
        for (int i = 0; i < ngeom; ++i)
        {
            addshapes = geom2shapes(mpolygon->getGeometryRef(i));
            shapes.reserve(shapes.size() + addshapes.size());
            shapes.insert(shapes.end(), addshapes.begin(), addshapes.end());
        }
    }
    else if (wkbFlatten(geom->getGeometryType()) == wkbGeometryCollection )
    {
        OGRGeometryCollection *mgeom = (OGRGeometryCollection *)geom;
        const int ngeom = mgeom->getNumGeometries();
        std::vector<VectorLayerShapeType> addshapes;
        for (int i = 0; i < ngeom; ++i)
        {
            addshapes = geom2shapes(mgeom->getGeometryRef(i));
            shapes.reserve(shapes.size() + addshapes.size());
            shapes.insert(shapes.end(), addshapes.begin(), addshapes.end());
        }
    }
    else
    {
        std::cout << ""skip unknown: "" << wkbFlatten(geom->getGeometryType()) << std::endl;
        shape.points.clear();
    }
    return shapes;
}

static std::vector<VectorLayerShapeType> ReadOGRDataSourceToShapesFromFile(const char *const filepath)
{
    std::vector<VectorLayerShapeType> shapes;
    GDALAllRegister();
    GDALDataset *const poDS = (GDALDataset*)GDALOpenEx( filepath, GDAL_OF_VECTOR, NULL, NULL, NULL );
    if( poDS == NULL )
    {
        LOG4CPLUS_ERROR(logger, ""GDALOpenEx(  ) == NULL: "" << CPLGetLastErrorMsg());
        return shapes;
    }
    shapes.reserve(poDS->GetLayerCount()*16);
    OGRSpatialReference wgs84;
    wgs84.importFromEPSG(4326);
    for (int l = 0; l < poDS->GetLayerCount(); ++l)
    {
        OGRLayer* poLayer = poDS->GetLayer(l);
        OGRFeature *poFeature;
        poLayer->ResetReading();
        LOG4CPLUS_INFO(logger, ""Layer ""<<(poLayer->GetName())<<"" has ""<<(poLayer->GetFeatureCount())<<"" features"");
        while( (poFeature = poLayer->GetNextFeature()) != NULL )
        {
            OGRGeometry *geom = poFeature->GetGeometryRef();
            if( geom != NULL)
            {
                geom->transformTo(&wgs84);
                std::vector<VectorLayerShapeType> geom_shapes = geom2shapes(geom);
                for (auto it = geom_shapes.begin(); it != geom_shapes.end(); ++it)
                    shapes.push_back(std::move(*it));
            }
            OGRFeature::DestroyFeature( poFeature );
        }
    }
    GDALClose(poDS);
    return shapes;
}

static std::vector<VectorLayerShapeType> ReadOGRDataSourceToShapesFromWkt(const char *const wkt)
{
    std::vector<VectorLayerShapeType> shapes;
    // first check if we have srid (from postgis SRID=XXX;WKT-itself)
    std::vector<std::string> nswkt = split(wkt, ';'); //not-so-well-known-text
    if (nswkt.empty())
    {
        std::cout << ""WKT is empty"" << std::endl;
        return shapes;
    }
    int  [MASK]  = 0;
    for (size_t i = 0; i < nswkt.size(); ++i)
    {
        if (0 == strncmp(nswkt[i].c_str(), ""SRID="", sizeof(""SRID="")-1))
        {
             [MASK]  = atoi(nswkt[i].c_str() + sizeof(""SRID="")-1);
        }
        else
        {
            // nowhere stated, that OGRGeometryFactory::createFromWkt grabs srs, and not uses just it's pointer
            // so we'll init it for each iteration again, to be safe
            // P.S looks like it grabbed,  getSpatialReference() returns another pointer and deletion is safe
            OGRSpatialReference *srs = NULL;
            if ( [MASK]  > 0)
            {
                srs = new OGRSpatialReference;
                if (OGRERR_NONE != srs->importFromEPSG( [MASK] ))
                {
                    delete srs;
                    srs = NULL;
                }
            }
            // http://www.gdal.org/classOGRGeometryFactory.html#a9418f71bcfb1e334173882c38d89d070
            // cast because OGR_G_CreateFromWkt will move the pointer
            char* pszWkt = (char*)nswkt[i].c_str();
            OGRGeometry *geom;
            OGRErr err = OGRGeometryFactory::createFromWkt(&pszWkt, srs, &geom); // srs can be null
            if (err == OGRERR_NONE)
            {
                if (!geom->getSpatialReference())
                {
                    std::cout << ""WARNING: WKT geometry spatial reference is unknown"" << std::endl;
                }
                else if (4326 != geom->getSpatialReference()->GetEPSGGeogCS())
                {
                    OGRSpatialReference wgs84;
                    wgs84.importFromEPSG(4326);
                    geom->transformTo(&wgs84);
                }

                std::vector<VectorLayerShapeType> geom_shapes = geom2shapes(geom);
                for (auto it = geom_shapes.begin(); it != geom_shapes.end(); ++it)
                {
                    if (VectorLayerShapeType::GeometryType::Point != it->geomType)
                        shapes.push_back(std::move(*it));
                }

                OGRGeometryFactory::destroyGeometry(geom);
                delete srs;
            }
            else
            {
                std::cout << ""failed to read geometry from WKT"" << std::endl;
                // we may have encounter some more shaeps
            }
        }
    }
    return shapes;
}

static std::string getPresetValue(std::string preset)
{
    if (preset == ""example"")
        return ""wkt://SRID=4326;POLYGON ((-40 73,-39 73,-39 74,-40 74,-40 73))"";
    else if (preset == ""world"")
        return ""wkt://SRID=4326;POLYGON ((-179 -89,179 -89,179 89,-179 89,-179 -89))"";
    else if (preset == ""norv_sea"")
        return ""wkt://SRID=4326;MULTIPOLYGON (((5.897592 59.453594, -15.743695 64.412255, 15.617894 77.781198, 27.955703 70.515584, 5.897592 59.453594)), ((145.933452 43, 151.670932 43, 151.670932 39, 145.933452 39, 145.933452 43)))"";
    return """";
}

static std::vector<VectorLayerShapeType> ReadOGRDataSourceToShapes(const char *const uri)
{
    //const char uri[] = ""wkt://SRID=4326;POLYGON ((-24 -18,-24 -8,-20 -8,-20 -28,-24 -28))"";

    if (0==strncmp(uri, ""preset://"", sizeof(""preset://"")-1))
        return ReadOGRDataSourceToShapes(getPresetValue(uri+sizeof(""preset://"")-1).c_str());
    else if (0==strncmp(uri, ""wkt://"", sizeof(""wkt://"")-1))
        return ReadOGRDataSourceToShapesFromWkt(uri+sizeof(""wkt://"")-1);
    else if (0==strncmp(uri, ""file://"", sizeof(""file://"")))
        return ReadOGRDataSourceToShapesFromFile(uri+sizeof(""file://""));
    return std::vector<VectorLayerShapeType>();
}

#endif // OGRREADER_H
",epsg
553,"//
// Copyright <NAME> (<EMAIL>), <NAME> (<EMAIL>) 2014-2021
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include ""td/telegram/MessageEntity.h""

#include ""td/telegram/ContactsManager.h""
#include ""td/telegram/Dependencies.h""
#include ""td/telegram/LinkManager.h""
#include ""td/telegram/misc.h""
#include ""td/telegram/SecretChatLayer.h""

#include ""td/utils/algorithm.h""
#include ""td/utils/format.h""
#include ""td/utils/logging.h""
#include ""td/utils/misc.h""
#include ""td/utils/SliceBuilder.h""
#include ""td/utils/unicode.h""
#include ""td/utils/utf8.h""

#include <algorithm>
#include <cstring>
#include <limits>
#include <tuple>
#include <unordered_set>

namespace td {

int MessageEntity::get_type_priority(Type type) {
  static const int types[] = {50, 50, 50, 50, 50, 90, 91, 20, 11, 10, 49, 49, 50, 50, 92, 93, 0, 50, 50};
  static_assert(sizeof(types) / sizeof(types[0]) == static_cast<size_t>(MessageEntity::Type::Size), """");
  return types[static_cast<int32>(type)];
}

StringBuilder &operator<<(StringBuilder &string_builder, const MessageEntity::Type &message_entity_type) {
  switch (message_entity_type) {
    case MessageEntity::Type::Mention:
      return string_builder << ""Mention"";
    case MessageEntity::Type::Hashtag:
      return string_builder << ""Hashtag"";
    case MessageEntity::Type::BotCommand:
      return string_builder << ""BotCommand"";
    case MessageEntity::Type::Url:
      return string_builder << ""Url"";
    case MessageEntity::Type::EmailAddress:
      return string_builder << ""EmailAddress"";
    case MessageEntity::Type::Bold:
      return string_builder << ""Bold"";
    case MessageEntity::Type::Italic:
      return string_builder << ""Italic"";
    case MessageEntity::Type::Underline:
      return string_builder << ""Underline"";
    case MessageEntity::Type::Strikethrough:
      return string_builder << ""Strikethrough"";
    case MessageEntity::Type::BlockQuote:
      return string_builder << ""BlockQuote"";
    case MessageEntity::Type::Code:
      return string_builder << ""Code"";
    case MessageEntity::Type::Pre:
      return string_builder << ""Pre"";
    case MessageEntity::Type::PreCode:
      return string_builder << ""PreCode"";
    case MessageEntity::Type::TextUrl:
      return string_builder << ""TextUrl"";
    case MessageEntity::Type::MentionName:
      return string_builder << ""MentionName"";
    case MessageEntity::Type::Cashtag:
      return string_builder << ""Cashtag"";
    case MessageEntity::Type::PhoneNumber:
      return string_builder << ""PhoneNumber"";
    case MessageEntity::Type::BankCardNumber:
      return string_builder << ""BankCardNumber"";
    case MessageEntity::Type::MediaTimestamp:
      return string_builder << ""MediaTimestamp"";
    default:
      UNREACHABLE();
      return string_builder << ""Impossible"";
  }
}

StringBuilder &operator<<(StringBuilder &string_builder, const MessageEntity &message_entity) {
  string_builder << '[' << message_entity.type << "", offset = "" << message_entity.offset
                 << "", length = "" << message_entity.length;
  if (message_entity.media_timestamp >= 0) {
    string_builder << "", media_timestamp = \"""" << message_entity.media_timestamp << ""\"""";
  }
  if (!message_entity.argument.empty()) {
    string_builder << "", argument = \"""" << message_entity.argument << ""\"""";
  }
  if (message_entity.user_id.is_valid()) {
    string_builder << "", "" << message_entity.user_id;
  }
  string_builder << ']';
  return string_builder;
}

tl_object_ptr<td_api::TextEntityType> MessageEntity::get_text_entity_type_object() const {
  switch (type) {
    case MessageEntity::Type::Mention:
      return make_tl_object<td_api::textEntityTypeMention>();
    case MessageEntity::Type::Hashtag:
      return make_tl_object<td_api::textEntityTypeHashtag>();
    case MessageEntity::Type::BotCommand:
      return make_tl_object<td_api::textEntityTypeBotCommand>();
    case MessageEntity::Type::Url:
      return make_tl_object<td_api::textEntityTypeUrl>();
    case MessageEntity::Type::EmailAddress:
      return make_tl_object<td_api::textEntityTypeEmailAddress>();
    case MessageEntity::Type::Bold:
      return make_tl_object<td_api::textEntityTypeBold>();
    case MessageEntity::Type::Italic:
      return make_tl_object<td_api::textEntityTypeItalic>();
    case MessageEntity::Type::Underline:
      return make_tl_object<td_api::textEntityTypeUnderline>();
    case MessageEntity::Type::Strikethrough:
      return make_tl_object<td_api::textEntityTypeStrikethrough>();
    case MessageEntity::Type::BlockQuote:
      return nullptr;
    case MessageEntity::Type::Code:
      return make_tl_object<td_api::textEntityTypeCode>();
    case MessageEntity::Type::Pre:
      return make_tl_object<td_api::textEntityTypePre>();
    case MessageEntity::Type::PreCode:
      return make_tl_object<td_api::textEntityTypePreCode>(argument);
    case MessageEntity::Type::TextUrl:
      return make_tl_object<td_api::textEntityTypeTextUrl>(argument);
    case MessageEntity::Type::MentionName:
      // can't use contacts_manager, because can be called from a static request
      return make_tl_object<td_api::textEntityTypeMentionName>(user_id.get());
    case MessageEntity::Type::Cashtag:
      return make_tl_object<td_api::textEntityTypeCashtag>();
    case MessageEntity::Type::PhoneNumber:
      return make_tl_object<td_api::textEntityTypePhoneNumber>();
    case MessageEntity::Type::BankCardNumber:
      return make_tl_object<td_api::textEntityTypeBankCardNumber>();
    case MessageEntity::Type::MediaTimestamp:
      return make_tl_object<td_api::textEntityTypeMediaTimestamp>(media_timestamp);
    default:
      UNREACHABLE();
      return nullptr;
  }
}

tl_object_ptr<td_api::textEntity> MessageEntity::get_text_entity_object() const {
  return make_tl_object<td_api::textEntity>(offset, length, get_text_entity_type_object());
}

vector<tl_object_ptr<td_api::textEntity>> get_text_entities_object(const vector<MessageEntity> &entities,
                                                                   bool skip_bot_commands, int32 max_media_timestamp) {
  vector<tl_object_ptr<td_api::textEntity>> result;
  result.reserve(entities.size());

  for (auto &entity : entities) {
    if (skip_bot_commands && entity.type == MessageEntity::Type::BotCommand) {
      continue;
    }
    if (entity.type == MessageEntity::Type::MediaTimestamp && max_media_timestamp < entity.media_timestamp) {
      continue;
    }
    auto entity_object = entity.get_text_entity_object();
    if (entity_object->type_ != nullptr) {
      result.push_back(std::move(entity_object));
    }
  }

  return result;
}

StringBuilder &operator<<(StringBuilder &string_builder, const FormattedText &text) {
  return string_builder << '""' << text.text << ""\"" with entities "" << text.entities;
}

td_api::object_ptr<td_api::formattedText> get_formatted_text_object(const FormattedText &text, bool skip_bot_commands,
                                                                    int32 max_media_timestamp) {
  return td_api::make_object<td_api::formattedText>(
      text.text, get_text_entities_object(text.entities, skip_bot_commands, max_media_timestamp));
}

static bool is_word_character(uint32 code) {
  switch (get_unicode_simple_category(code)) {
    case UnicodeSimpleCategory::Letter:
    case UnicodeSimpleCategory::DecimalNumber:
    case UnicodeSimpleCategory::Number:
      return true;
    default:
      return code == '_';
  }
}

/*
static bool is_word_boundary(uint32 a, uint32 b) {
  return is_word_character(a) ^ is_word_character(b);
}
*/

static bool is_alpha_digit(uint32 code) {
  return ('0' <= code && code <= '9') || ('a' <= code && code <= 'z') || ('A' <= code && code <= 'Z');
}

static bool is_alpha_digit_or_underscore(uint32 code) {
  return is_alpha_digit(code) || code == '_';
}

static bool is_alpha_digit_or_underscore_or_minus(uint32 code) {
  return is_alpha_digit_or_underscore(code) || code == '-';
}

// This functions just implements corresponding regexps
// All other fixes will be in other functions
static vector<Slice> match_mentions(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();
  const unsigned char *ptr = begin;

  // '/(?<=\B)@([a-zA-Z0-9_]{2,32})(?=\b)/u'

  while (true) {
    ptr = static_cast<const unsigned char *>(std::memchr(ptr, '@', narrow_cast<int32>(end - ptr)));
    if (ptr == nullptr) {
      break;
    }

    if (ptr != begin) {
      uint32 prev;
      next_utf8_unsafe(prev_utf8_unsafe(ptr), &prev, ""match_mentions"");

      if (is_word_character(prev)) {
        ptr++;
        continue;
      }
    }
    auto mention_begin = ++ptr;
    while (ptr != end && is_alpha_digit_or_underscore(*ptr)) {
      ptr++;
    }
    auto mention_end = ptr;
    auto mention_size = mention_end - mention_begin;
    if (mention_size < 2 || mention_size > 32) {
      continue;
    }
    uint32 next = 0;
    if (ptr != end) {
      next_utf8_unsafe(ptr, &next, ""match_mentions 2"");
    }
    if (is_word_character(next)) {
      continue;
    }
    result.emplace_back(mention_begin - 1, mention_end);
  }
  return result;
}

static vector<Slice> match_bot_commands(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();
  const unsigned char *ptr = begin;

  // '/(?<!\b|[\/<>])\/([a-zA-Z0-9_]{1,64})(?:@([a-zA-Z0-9_]{3,32}))?(?!\B|[\/<>])/u'

  while (true) {
    ptr = static_cast<const unsigned char *>(std::memchr(ptr, '/', narrow_cast<int32>(end - ptr)));
    if (ptr == nullptr) {
      break;
    }

    if (ptr != begin) {
      uint32 prev;
      next_utf8_unsafe(prev_utf8_unsafe(ptr), &prev, ""match_bot_commands"");

      if (is_word_character(prev) || prev == '/' || prev == '<' || prev == '>') {
        ptr++;
        continue;
      }
    }

    auto command_begin = ++ptr;
    while (ptr != end && is_alpha_digit_or_underscore(*ptr)) {
      ptr++;
    }
    auto command_end = ptr;
    auto command_size = command_end - command_begin;
    if (command_size < 1 || command_size > 64) {
      continue;
    }

    if (ptr != end && *ptr == '@') {
      auto mention_begin = ++ptr;
      while (ptr != end && is_alpha_digit_or_underscore(*ptr)) {
        ptr++;
      }
      auto mention_end = ptr;
      auto mention_size = mention_end - mention_begin;
      if (mention_size < 3 || mention_size > 32) {
        continue;
      }
      command_end = ptr;
    }

    uint32 next = 0;
    if (ptr != end) {
      next_utf8_unsafe(ptr, &next, ""match_bot_commands 2"");
    }
    if (is_word_character(next) || next == '/' || next == '<' || next == '>') {
      continue;
    }
    result.emplace_back(command_begin - 1, command_end);
  }
  return result;
}

static bool is_hashtag_letter(uint32 c, UnicodeSimpleCategory &category) {
  category = get_unicode_simple_category(c);
  if (c == '_' || c == 0x200c) {
    return true;
  }
  switch (category) {
    case UnicodeSimpleCategory::DecimalNumber:
    case UnicodeSimpleCategory::Letter:
      return true;
    default:
      return false;
  }
}

static vector<Slice> match_hashtags(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();
  const unsigned char *ptr = begin;

  // '/(?<=^|[^\d_\pL\x{200c}])#([\d_\pL\x{200c}]{1,256})(?![\d_\pL\x{200c}]*#)/u'
  // and at least one letter

  UnicodeSimpleCategory category;

  while (true) {
    ptr = static_cast<const unsigned char *>(std::memchr(ptr, '#', narrow_cast<int32>(end - ptr)));
    if (ptr == nullptr) {
      break;
    }

    if (ptr != begin) {
      uint32 prev;
      next_utf8_unsafe(prev_utf8_unsafe(ptr), &prev, ""match_hashtags"");

      if (is_hashtag_letter(prev, category)) {
        ptr++;
        continue;
      }
    }
    auto hashtag_begin = ++ptr;
    size_t hashtag_size = 0;
    const unsigned char *hashtag_end = nullptr;
    bool was_letter = false;
    while (ptr != end) {
      uint32 code;
      auto next_ptr = next_utf8_unsafe(ptr, &code, ""match_hashtags 2"");
      if (!is_hashtag_letter(code, category)) {
        break;
      }
      ptr = next_ptr;

      if (hashtag_size == 255) {
        hashtag_end = ptr;
      }
      if (hashtag_size != 256) {
        was_letter |= category == UnicodeSimpleCategory::Letter;
        hashtag_size++;
      }
    }
    if (!hashtag_end) {
      hashtag_end = ptr;
    }
    if (hashtag_size < 1) {
      continue;
    }
    if (ptr != end && ptr[0] == '#') {
      continue;
    }
    if (!was_letter) {
      continue;
    }
    result.emplace_back(hashtag_begin - 1, hashtag_end);
  }
  return result;
}

static vector<Slice> match_cashtags(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();
  const unsigned char *ptr = begin;

  // '/(?<=^|[^$\d_\pL\x{200c}])\$(1INCH|[A-Z]{1,8})(?![$\d_\pL\x{200c}])/u'

  UnicodeSimpleCategory category;
  while (true) {
    ptr = static_cast<const unsigned char *>(std::memchr(ptr, '$', narrow_cast<int32>(end - ptr)));
    if (ptr == nullptr) {
      break;
    }

    if (ptr != begin) {
      uint32 prev;
      next_utf8_unsafe(prev_utf8_unsafe(ptr), &prev, ""match_cashtags"");

      if (is_hashtag_letter(prev, category) || prev == '$') {
        ptr++;
        continue;
      }
    }

    auto cashtag_begin = ++ptr;
    if (end - ptr >= 5 && Slice(ptr, ptr + 5) == Slice(""1INCH"")) {
      ptr += 5;
    } else {
      while (ptr != end && 'Z' >= *ptr && *ptr >= 'A') {
        ptr++;
      }
    }
    auto cashtag_end = ptr;
    auto cashtag_size = cashtag_end - cashtag_begin;
    if (cashtag_size < 1 || cashtag_size > 8) {
      continue;
    }

    if (cashtag_end != end) {
      uint32 code;
      next_utf8_unsafe(ptr, &code, ""match_cashtags 2"");
      if (is_hashtag_letter(code, category) || code == '$') {
        continue;
      }
    }

    result.emplace_back(cashtag_begin - 1, cashtag_end);
  }
  return result;
}

static vector<Slice> match_media_timestamps(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();
  const unsigned char *ptr = begin;

  while (true) {
    ptr = static_cast<const unsigned char *>(std::memchr(ptr, ':', narrow_cast<int32>(end - ptr)));
    if (ptr == nullptr) {
      break;
    }

    auto media_timestamp_begin = ptr;
    while (media_timestamp_begin != begin &&
           (media_timestamp_begin[-1] == ':' || is_digit(media_timestamp_begin[-1]))) {
      media_timestamp_begin--;
    }
    auto media_timestamp_end = ptr;
    while (media_timestamp_end + 1 != end && (media_timestamp_end[1] == ':' || is_digit(media_timestamp_end[1]))) {
      media_timestamp_end++;
    }
    media_timestamp_end++;

    if (media_timestamp_begin != ptr && media_timestamp_end != ptr + 1 && is_digit(ptr[1])) {
      ptr = media_timestamp_end;

      if (media_timestamp_begin != begin) {
        uint32 prev;
        next_utf8_unsafe(prev_utf8_unsafe(media_timestamp_begin), &prev, ""match_media_timestamps 1"");

        if (is_word_character(prev)) {
          continue;
        }
      }
      if (media_timestamp_end != end) {
        uint32 next;
        next_utf8_unsafe(media_timestamp_end, &next, ""match_media_timestamps 2"");

        if (is_word_character(next)) {
          continue;
        }
      }

      result.emplace_back(media_timestamp_begin, media_timestamp_end);
    } else {
      ptr = media_timestamp_end;
    }
  }
  return result;
}

static vector<Slice> match_bank_card_numbers(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();
  const unsigned char *ptr = begin;

  // '/(?<=^|[^+_\pL\d-.,])[\d -]{13,}([^_\pL\d-]|$)/'

  while (true) {
    while (ptr != end && !is_digit(*ptr)) {
      ptr++;
    }
    if (ptr == end) {
      break;
    }
    if (ptr != begin) {
      uint32 prev;
      next_utf8_unsafe(prev_utf8_unsafe(ptr), &prev, ""match_bank_card_numbers"");

      if (prev == '.' || prev == ',' || prev == '+' || prev == '-' || prev == '_' ||
          get_unicode_simple_category(prev) == UnicodeSimpleCategory::Letter) {
        while (ptr != end && (is_digit(*ptr) || *ptr == ' ' || *ptr == '-')) {
          ptr++;
        }
        continue;
      }
    }

    auto card_number_begin = ptr;
    size_t digit_count = 0;
    while (ptr != end && (is_digit(*ptr) || *ptr == ' ' || *ptr == '-')) {
      if (*ptr == ' ' && digit_count >= 16 && digit_count <= 19 &&
          digit_count == static_cast<size_t>(ptr - card_number_begin)) {
        // continuous card number
        break;
      }
      digit_count += static_cast<size_t>(is_digit(*ptr));
      ptr++;
    }
    if (digit_count < 13 || digit_count > 19) {
      continue;
    }

    auto card_number_end = ptr;
    while (!is_digit(card_number_end[-1])) {
      card_number_end--;
    }
    auto card_number_size = static_cast<size_t>(card_number_end - card_number_begin);
    if (card_number_size > 2 * digit_count - 1) {
      continue;
    }
    if (card_number_end != end) {
      uint32 next;
      next_utf8_unsafe(card_number_end, &next, ""match_bank_card_numbers 2"");
      if (next == '-' || next == '_' || get_unicode_simple_category(next) == UnicodeSimpleCategory::Letter) {
        continue;
      }
    }

    result.emplace_back(card_number_begin, card_number_end);
  }
  return result;
}

static bool is_url_unicode_symbol(uint32 c) {
  if (0x2000 <= c && c <= 0x206f) {  // General Punctuation
    // Zero Width Non-Joiner/Joiner and various dashes
    return c == 0x200c || c == 0x200d || (0x2010 <= c && c <= 0x2015);
  }
  return get_unicode_simple_category(c) != UnicodeSimpleCategory::Separator;
}

static bool is_url_path_symbol(uint32 c) {
  switch (c) {
    case '\n':
    case '<':
    case '>':
    case '""':
    case 0xab:  // «
    case 0xbb:  // »
      return false;
    default:
      return is_url_unicode_symbol(c);
  }
}

static vector<Slice> match_tg_urls(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();
  const unsigned char *ptr = begin;

  // '(tg|ton)://[a-z0-9_-]{1,253}([/?#][^\s\x{2000}-\x{200b}\x{200e}-\x{200f}\x{2016}-\x{206f}<>«»""]*)?'

  Slice bad_path_end_chars("".:;,('?!`"");

  while (end - ptr > 5) {
    ptr = static_cast<const unsigned char *>(std::memchr(ptr, ':', narrow_cast<int32>(end - ptr)));
    if (ptr == nullptr) {
      break;
    }

    const unsigned char *url_begin = nullptr;
    if (end - ptr >= 3 && ptr[1] == '/' && ptr[2] == '/') {
      if (ptr - begin >= 2 && to_lower(ptr[-2]) == 't' && to_lower(ptr[-1]) == 'g') {
        url_begin = ptr - 2;
      } else if (ptr - begin >= 3 && to_lower(ptr[-3]) == 't' && to_lower(ptr[-2]) == 'o' && to_lower(ptr[-1]) == 'n') {
        url_begin = ptr - 3;
      }
    }
    if (url_begin == nullptr) {
      ++ptr;
      continue;
    }

    ptr += 3;
    auto domain_begin = ptr;
    while (ptr != end && ptr - domain_begin != 253 && is_alpha_digit_or_underscore_or_minus(*ptr)) {
      ptr++;
    }
    if (ptr == domain_begin) {
      continue;
    }

    if (ptr != end && (*ptr == '/' || *ptr == '?' || *ptr == '#')) {
      auto path_end_ptr = ptr + 1;
      while (path_end_ptr != end) {
        uint32 code = 0;
        auto next_ptr = next_utf8_unsafe(path_end_ptr, &code, ""match_tg_urls"");
        if (!is_url_path_symbol(code)) {
          break;
        }
        path_end_ptr = next_ptr;
      }
      while (path_end_ptr > ptr + 1 && bad_path_end_chars.find(path_end_ptr[-1]) < bad_path_end_chars.size()) {
        path_end_ptr--;
      }
      if (ptr[0] == '/' || path_end_ptr > ptr + 1) {
        ptr = path_end_ptr;
      }
    }

    result.emplace_back(url_begin, ptr);
  }
  return result;
}

static vector<Slice> match_urls(Slice str) {
  vector<Slice> result;
  const unsigned char *begin = str.ubegin();
  const unsigned char *end = str.uend();

  const auto &is_protocol_symbol = [](uint32 c) {
    if (c < 0x80) {
      // do not allow dots in the protocol
      return is_alpha_digit(c) || c == '+' || c == '-';
    }
    // add unicode letters and digits to later discard protocol as invalid
    return get_unicode_simple_category(c) != UnicodeSimpleCategory::Separator;
  };

  const auto &is_user_data_symbol = [](uint32 c) {
    switch (c) {
      case '\n':
      case '/':
      case '[':
      case ']':
      case '{':
      case '}':
      case '(':
      case ')':
      case '\'':
      case '`':
      case '<':
      case '>':
      case '""':
      case '@':
      case 0xab:  // «
      case 0xbb:  // »
        return false;
      default:
        return is_url_unicode_symbol(c);
    }
  };

  const auto &is_domain_symbol = [](uint32 c) {
    if (c < 0xc0) {
      return c == '.' || is_alpha_digit_or_underscore_or_minus(c) || c == '~';
    }
    return is_url_unicode_symbol(c);
  };

  Slice bad_path_end_chars("".:;,('?!`"");

  while (true) {
    auto dot_pos = str.find('.');
    if (dot_pos > str.size() || dot_pos + 1 == str.size()) {
      break;
    }
    if (str[dot_pos + 1] == ' ') {
      // fast path
      str = str.substr(dot_pos + 2);
      begin = str.ubegin();
      continue;
    }

    const unsigned char *domain_begin_ptr = begin + dot_pos;
    while (domain_begin_ptr != begin) {
      domain_begin_ptr = prev_utf8_unsafe(domain_begin_ptr);
      uint32 code = 0;
      auto next_ptr = next_utf8_unsafe(domain_begin_ptr, &code, ""match_urls 0"");
      if (!is_domain_symbol(code)) {
        domain_begin_ptr = next_ptr;
        break;
      }
    }

    const unsigned char *last_at_ptr = nullptr;
    const unsigned char *domain_end_ptr = begin + dot_pos;
    if (domain_begin_ptr == begin || domain_begin_ptr[-1] != '@') {
      // try to find '@' to the right if there is no '@' to the left
      while (domain_end_ptr != end) {
        uint32 code = 0;
        auto next_ptr = next_utf8_unsafe(domain_end_ptr, &code, ""match_urls"");
        if (code == '@') {
          last_at_ptr = domain_end_ptr;
        }
        if (!is_user_data_symbol(code)) {
          break;
        }
        domain_end_ptr = next_ptr;
      }
      domain_end_ptr = last_at_ptr == nullptr ? begin + dot_pos : last_at_ptr + 1;
    }
    while (domain_end_ptr != end) {
      uint32 code = 0;
      auto next_ptr = next_utf8_unsafe(domain_end_ptr, &code, ""match_urls 2"");
      if (!is_domain_symbol(code)) {
        break;
      }
      domain_end_ptr = next_ptr;
    }

    if (last_at_ptr != nullptr) {
      while (domain_begin_ptr != begin) {
        domain_begin_ptr = prev_utf8_unsafe(domain_begin_ptr);
        uint32 code = 0;
        auto next_ptr = next_utf8_unsafe(domain_begin_ptr, &code, ""match_urls 3"");
        if (!is_user_data_symbol(code)) {
          domain_begin_ptr = next_ptr;
          break;
        }
      }
    }
    // LOG(ERROR) << ""Domain: "" << Slice(domain_begin_ptr, domain_end_ptr);

    const unsigned char *url_end_ptr = domain_end_ptr;
    if (url_end_ptr != end && url_end_ptr[0] == ':') {
      auto port_end_ptr = url_end_ptr + 1;

      while (port_end_ptr != end && is_digit(port_end_ptr[0])) {
        port_end_ptr++;
      }

      auto port_begin_ptr = url_end_ptr + 1;
      while (port_begin_ptr != port_end_ptr && *port_begin_ptr == '0') {
        port_begin_ptr++;
      }
      if (port_begin_ptr != port_end_ptr && narrow_cast<int>(port_end_ptr - port_begin_ptr) <= 5 &&
          to_integer<uint32>(Slice(port_begin_ptr, port_end_ptr)) <= 65535) {
        url_end_ptr = port_end_ptr;
      }
    }
    // LOG(ERROR) << ""Domain_port: "" << Slice(domain_begin_ptr, url_end_ptr);

    if (url_end_ptr != end && (url_end_ptr[0] == '/' || url_end_ptr[0] == '?' || url_end_ptr[0] == '#')) {
      auto path_end_ptr = url_end_ptr + 1;
      while (path_end_ptr != end) {
        uint32 code = 0;
        auto next_ptr = next_utf8_unsafe(path_end_ptr, &code, ""match_urls 4"");
        if (!is_url_path_symbol(code)) {
          break;
        }
        path_end_ptr = next_ptr;
      }
      while (path_end_ptr > url_end_ptr + 1 && bad_path_end_chars.find(path_end_ptr[-1]) < bad_path_end_chars.size()) {
        path_end_ptr--;
      }
      if (url_end_ptr[0] == '/' || path_end_ptr > url_end_ptr + 1) {
        url_end_ptr = path_end_ptr;
      }
    }
    while (url_end_ptr > begin + dot_pos + 1 && url_end_ptr[-1] == '.') {
      url_end_ptr--;
    }
    // LOG(ERROR) << ""Domain_port_path: "" << Slice(domain_begin_ptr, url_end_ptr);

    bool is_bad = false;
    const unsigned char *url_begin_ptr = domain_begin_ptr;
    if (url_begin_ptr != begin && url_begin_ptr[-1] == '@') {
      if (last_at_ptr != nullptr) {
        is_bad = true;
      }
      auto user_data_begin_ptr = url_begin_ptr - 1;
      while (user_data_begin_ptr != begin) {
        user_data_begin_ptr = prev_utf8_unsafe(user_data_begin_ptr);
        uint32 code = 0;
        auto next_ptr = next_utf8_unsafe(user_data_begin_ptr, &code, ""match_urls 5"");
        if (!is_user_data_symbol(code)) {
          user_data_begin_ptr = next_ptr;
          break;
        }
      }
      if (user_data_begin_ptr == url_begin_ptr - 1) {
        is_bad = true;
      }
      url_begin_ptr = user_data_begin_ptr;
    }
    // LOG(ERROR) << ""User_data_port_path: "" << Slice(url_begin_ptr, url_end_ptr);

    if (url_begin_ptr != begin) {
      Slice prefix(begin, url_begin_ptr);
      if (prefix.size() >= 6 && ends_with(prefix, ""://"")) {
        auto protocol_begin_ptr = url_begin_ptr - 3;
        while (protocol_begin_ptr != begin) {
          protocol_begin_ptr = prev_utf8_unsafe(protocol_begin_ptr);
          uint32 code = 0;
          auto next_ptr = next_utf8_unsafe(protocol_begin_ptr, &code, ""match_urls 6"");
          if (!is_protocol_symbol(code)) {
            protocol_begin_ptr = next_ptr;
            break;
          }
        }
        auto protocol = to_lower(Slice(protocol_begin_ptr, url_begin_ptr - 3));
        if (ends_with(protocol, ""http"") && protocol != ""shttp"") {
          url_begin_ptr = url_begin_ptr - 7;
        } else if (ends_with(protocol, ""https"")) {
          url_begin_ptr = url_begin_ptr - 8;
        } else if (ends_with(protocol, ""ftp"") && protocol != ""tftp"" && protocol != ""sftp"") {
          url_begin_ptr = url_begin_ptr - 6;
        } else {
          is_bad = true;
        }
      } else {
        auto prefix_end = prefix.uend();
        auto prefix_back = prev_utf8_unsafe(prefix_end);
        uint32 code = 0;
        next_utf8_unsafe(prefix_back, &code, ""match_urls 7"");
        if (is_word_character(code) || code == '/' || code == '#' || code == '@') {
          is_bad = true;
        }
      }
    }
    // LOG(ERROR) << ""Full: "" << Slice(url_begin_ptr, url_end_ptr) << "" "" << is_bad;

    if (!is_bad) {
      if (url_end_ptr > begin + dot_pos + 1) {
        result.emplace_back(url_begin_ptr, url_end_ptr);
      }
      while (url_end_ptr != end && url_end_ptr[0] == '.') {
        url_end_ptr++;
      }
    } else {
      while (url_end_ptr[-1] != '.') {
        url_end_ptr--;
      }
    }

    if (url_end_ptr <= begin + dot_pos) {
      url_end_ptr = begin + dot_pos + 1;
    }
    str = str.substr(url_end_ptr - begin);
    begin = url_end_ptr;
  }

  return result;
}

static bool is_valid_bank_card(Slice str) {
  const size_t MIN_CARD_LENGTH = 13;
  const size_t MAX_CARD_LENGTH = 19;
  char digits[MAX_CARD_LENGTH];
  size_t digit_count = 0;
  for (auto c : str) {
    if (is_digit(c)) {
      CHECK(digit_count < MAX_CARD_LENGTH);
      digits[digit_count++] = c;
    }
  }
  CHECK(digit_count >= MIN_CARD_LENGTH);

  // Luhn algorithm
  int32 sum = 0;
  for (size_t i = digit_count; i > 0; i--) {
    int32 digit = digits[i - 1] - '0';
    if ((digit_count - i) % 2 == 0) {
      sum += digit;
    } else {
      sum += (digit < 5 ? 2 * digit : 2 * digit - 9);
    }
  }
  if (sum % 10 != 0) {
    return false;
  }

  int32 prefix1 = (digits[0] - '0');
  int32 prefix2 = prefix1 * 10 + (digits[1] - '0');
  int32 prefix3 = prefix2 * 10 + (digits[2] - '0');
  int32 prefix4 = prefix3 * 10 + (digits[3] - '0');
  if (prefix1 == 4) {
    // Visa
    return digit_count == 13 || digit_count == 16 || digit_count == 18 || digit_count == 19;
  }
  if ((51 <= prefix2 && prefix2 <= 55) || (2221 <= prefix4 && prefix4 <= 2720)) {
    // mastercard
    return digit_count == 16;
  }
  if (prefix2 == 34 || prefix2 == 37) {
    // American Express
    return digit_count == 15;
  }
  if (prefix2 == 62 || prefix2 == 81) {
    // UnionPay
    return digit_count >= 16;
  }
  if (2200 <= prefix4 && prefix4 <= 2204) {
    // MIR
    return digit_count == 16;
  }
  return true;  // skip length check
}

bool is_email_address(Slice str) {
  // /^([a-z0-9_-]{0,26}[.+]){0,10}[a-z0-9_-]{1,35}@(([a-z0-9][a-z0-9_-]{0,28})?[a-z0-9][.]){1,6}[a-z]{2,6}$/i
  Slice userdata;
  Slice domain;
  std::tie(userdata, domain) = split(str, '@');
  vector<Slice> userdata_parts;
  size_t prev = 0;
  for (size_t i = 0; i < userdata.size(); i++) {
    if (userdata[i] == '.' || userdata[i] == '+') {
      userdata_parts.push_back(userdata.substr(prev, i - prev));
      prev = i + 1;
    }
  }
  userdata_parts.push_back(userdata.substr(prev));
  if (userdata_parts.size() >= 12) {
    return false;
  }
  for (auto &part : userdata_parts) {
    for (auto c : part) {
      if (!is_alpha_digit_or_underscore_or_minus(c)) {
        return false;
      }
    }
  }
  if (userdata_parts.back().empty() || userdata_parts.back().size() >= 36) {
    return false;
  }
  userdata_parts.pop_back();
  for (auto &part : userdata_parts) {
    if (part.size() >= 27) {
      return false;
    }
  }

  vector<Slice> domain_parts = full_split(domain, '.');
  if (domain_parts.size() <= 1 || domain_parts.size() > 7) {
    return false;
  }
  if (domain_parts.back().size() <= 1 || domain_parts.back().size() >= 7) {
    return false;
  }
  for (auto c : domain_parts.back()) {
    if (!is_alpha(c)) {
      return false;
    }
  }
  domain_parts.pop_back();
  for (auto &part : domain_parts) {
    if (part.empty() || part.size() >= 31) {
      return false;
    }
    for (auto c : part) {
      if (!is_alpha_digit_or_underscore_or_minus(c)) {
        return false;
      }
    }
    if (!is_alpha_digit(part[0])) {
      return false;
    }
    if (!is_alpha_digit(part.back())) {
      return false;
    }
  }

  return true;
}

static bool is_common_tld(Slice str) {
  static const std::unordered_set<Slice, SliceHash> tlds(
      {""aaa"", ""aarp"", ""abarth"", ""abb"", ""abbott"", ""abbvie"", ""abc"", ""able"", ""abogado"", ""abudhabi"", ""ac"", ""academy"",
       ""accenture"", ""accountant"", ""accountants"", ""aco"", ""active"", ""actor"", ""ad"", ""adac"", ""ads"", ""adult"", ""ae"", ""aeg"",
       ""aero"", ""aetna"", ""af"", ""afamilycompany"", ""afl"", ""africa"", ""ag"", ""agakhan"", ""agency"", ""ai"", ""aig"", ""aigo"",
       ""airbus"", ""airforce"", ""airtel"", ""akdn"", ""al"", ""alfaromeo"", ""alibaba"", ""alipay"", ""allfinanz"", ""allstate"", ""ally"",
       ""alsace"", ""alstom"", ""am"", ""americanexpress"", ""americanfamily"", ""amex"", ""amfam"", ""amica"", ""amsterdam"",
       ""analytics"", ""android"", ""anquan"", ""anz"", ""ao"", ""aol"", ""apartments"", ""app"", ""apple"", ""aq"", ""aquarelle"", ""ar"",
       ""arab"", ""aramco"", ""archi"", ""army"", ""arpa"", ""art"", ""arte"", ""as"", ""asda"", ""asia"", ""associates"", ""at"", ""athleta"",
       ""attorney"", ""au"", ""auction"", ""audi"", ""audible"", ""audio"", ""auspost"", ""author"", ""auto"", ""autos"", ""avianca"", ""aw"",
       ""aws"", ""ax"", ""axa"", ""az"", ""azure"", ""ba"", ""baby"", ""baidu"", ""banamex"", ""bananarepublic"", ""band"", ""bank"", ""bar"",
       ""barcelona"", ""barclaycard"", ""barclays"", ""barefoot"", ""bargains"", ""baseball"", ""basketball"", ""bauhaus"", ""bayern"",
       ""bb"", ""bbc"", ""bbt"", ""bbva"", ""bcg"", ""bcn"", ""bd"", ""be"", ""beats"", ""beauty"", ""beer"", ""bentley"", ""berlin"", ""best"",
       ""bestbuy"", ""bet"", ""bf"", ""bg"", ""bh"", ""bharti"", ""bi"", ""bible"", ""bid"", ""bike"", ""bing"", ""bingo"", ""bio"", ""biz"", ""bj"",
       ""black"", ""blackfriday"", ""blanco"", ""blockbuster"", ""blog"", ""bloomberg"", ""blue"", ""bm"", ""bms"", ""bmw"", ""bn"", ""bnl"",
       ""bnpparibas"", ""bo"", ""boats"", ""boehringer"", ""bofa"", ""bom"", ""bond"", ""boo"", ""book"", ""booking"", ""boots"", ""bosch"",
       ""bostik"", ""boston"", ""bot"", ""boutique"", ""box"", ""br"", ""bradesco"", ""bridgestone"", ""broadway"", ""broker"", ""brother"",
       ""brussels"", ""bs"", ""bt"", ""budapest"", ""bugatti"", ""build"", ""builders"", ""business"", ""buy"", ""buzz"", ""bv"", ""bw"", ""by"",
       ""bz"", ""bzh"", ""ca"", ""cab"", ""cafe"", ""cal"", ""call"", ""calvinklein"", ""cam"", ""camera"", ""camp"", ""cancerresearch"",
       ""canon"", ""capetown"", ""capital"", ""capitalone"", ""car"", ""caravan"", ""cards"", ""care"", ""career"", ""careers"", ""cars"",
       ""cartier"", ""casa"", ""case"", ""caseih"", ""cash"", ""casino"", ""cat"", ""catering"", ""catholic"", ""cba"", ""cbn"", ""cbre"",
       ""cbs"", ""cc"", ""cd"", ""ceb"", ""center"", ""ceo"", ""cern"", ""cf"", ""cfa"", ""cfd"", ""cg"", ""ch"", ""chanel"", ""channel"", ""chase"",
       ""chat"", ""cheap"", ""chintai"", ""christmas"", ""chrome"", ""chrysler"", ""church"", ""ci"", ""cipriani"", ""circle"", ""cisco"",
       ""citadel"", ""citi"", ""citic"", ""city"", ""cityeats"", ""ck"", ""cl"", ""claims"", ""cleaning"", ""click"", ""clinic"", ""clinique"",
       ""clothing"", ""cloud"", ""club"", ""clubmed"", ""cm"", ""cn"", ""co"", ""coach"", ""codes"", ""coffee"", ""college"", ""cologne"",
       ""com"", ""comcast"", ""commbank"", ""community"", ""company"", ""compare"", ""computer"", ""comsec"", ""condos"", ""construction"",
       ""consulting"", ""contact"", ""contractors"", ""cooking"", ""cookingchannel"", ""cool"", ""coop"", ""corsica"", ""country"",
       ""coupon"", ""coupons"", ""courses"", ""cr"", ""credit"", ""creditcard"", ""creditunion"", ""cricket"", ""crown"", ""crs"", ""cruise"",
       ""cruises"", ""csc"", ""cu"", ""cuisinella"", ""cv"", ""cw"", ""cx"", ""cy"", ""cymru"", ""cyou"", ""cz"", ""dabur"", ""dad"", ""dance"",
       ""data"", ""date"", ""dating"", ""datsun"", ""day"", ""dclk"", ""dds"", ""de"", ""deal"", ""dealer"", ""deals"", ""degree"", ""delivery"",
       ""dell"", ""deloitte"", ""delta"", ""democrat"", ""dental"", ""dentist"", ""desi"", ""design"", ""dev"", ""dhl"", ""diamonds"", ""diet"",
       ""digital"", ""direct"", ""directory"", ""discount"", ""discover"", ""dish"", ""diy"", ""dj"", ""dk"", ""dm"", ""dnp"", ""do"", ""docs"",
       ""doctor"", ""dodge"", ""dog"", ""doha"", ""domains"", ""dot"", ""download"", ""drive"", ""dtv"", ""dubai"", ""duck"", ""dunlop"",
       ""duns"", ""dupont"", ""durban"", ""dvag"", ""dvr"", ""dz"", ""earth"", ""eat"", ""ec"", ""eco"", ""edeka"", ""edu"", ""education"", ""ee"",
       ""eg"", ""email"", ""emerck"", ""energy"", ""engineer"", ""engineering"", ""enterprises"", ""epost"", ""epson"", ""equipment"", ""er"",
       ""ericsson"", ""erni"", ""es"", ""esq"", ""estate"", ""esurance"", ""et"", ""etisalat"", ""eu"", ""eurovision"", ""eus"", ""events"",
       ""everbank"", ""exchange"", ""expert"", ""exposed"", ""express"", ""extraspace"", ""fage"", ""fail"", ""fairwinds"", ""faith"",
       ""family"", ""fan"", ""fans"", ""farm"", ""farmers"", ""fashion"", ""fast"", ""fedex"", ""feedback"", ""ferrari"", ""ferrero"", ""fi"",
       ""fiat"", ""fidelity"", ""fido"", ""film"", ""final"", ""finance"", ""financial"", ""fire"", ""firestone"", ""firmdale"", ""fish"",
       ""fishing"", ""fit"", ""fitness"", ""fj"", ""fk"", ""flickr"", ""flights"", ""flir"", ""florist"", ""flowers"", ""fly"", ""fm"", ""fo"",
       ""foo"", ""food"", ""foodnetwork"", ""football"", ""ford"", ""forex"", ""forsale"", ""forum"", ""foundation"", ""fox"", ""fr"", ""free"",
       ""fresenius"", ""frl"", ""frogans"", ""frontdoor"", ""frontier"", ""ftr"", ""fujitsu"", ""fujixerox"", ""fun"", ""fund"",
       ""furniture"", ""futbol"", ""fyi"", ""ga"", ""gal"", ""gallery"", ""gallo"", ""gallup"", ""game"", ""games"", ""gap"", ""garden"", ""gb"",
       ""gbiz"", ""gd"", ""gdn"", ""ge"", ""gea"", ""gent"", ""genting"", ""george"", ""gf"", ""gg"", ""ggee"", ""gh"", ""gi"", ""gift"", ""gifts"",
       ""gives"", ""giving"", ""gl"", ""glade"", ""glass"", ""gle"", ""global"", ""globo"", ""gm"", ""gmail"", ""gmbh"", ""gmo"", ""gmx"", ""gn"",
       ""godaddy"", ""gold"", ""goldpoint"", ""golf"", ""goo"", ""goodhands"", ""goodyear"", ""goog"", ""google"", ""gop"", ""got"", ""gov"",
       ""gp"", ""gq"", ""gr"", ""grainger"", ""graphics"", ""gratis"", ""green"", ""gripe"", ""grocery"", ""group"", ""gs"", ""gt"", ""gu"",
       ""guardian"", ""gucci"", ""guge"", ""guide"", ""guitars"", ""guru"", ""gw"", ""gy"", ""hair"", ""hamburg"", ""hangout"", ""haus"", ""hbo"",
       ""hdfc"", ""hdfcbank"", ""health"", ""healthcare"", ""help"", ""helsinki"", ""here"", ""hermes"", ""hgtv"", ""hiphop"", ""hisamitsu"",
       ""hitachi"", ""hiv"", ""hk"", ""hkt"", ""hm"", ""hn"", ""hockey"", ""holdings"", ""holiday"", ""homedepot"", ""homegoods"", ""homes"",
       ""homesense"", ""honda"", ""honeywell"", ""horse"", ""hospital"", ""host"", ""hosting"", ""hot"", ""hoteles"", ""hotels"", ""hotmail"",
       ""house"", ""how"", ""hr"", ""hsbc"", ""ht"", ""hu"", ""hughes"", ""hyatt"", ""hyundai"", ""ibm"", ""icbc"", ""ice"", ""icu"", ""id"", ""ie"",
       ""ieee"", ""ifm"", ""ikano"", ""il"", ""im"", ""imamat"", ""imdb"", ""immo"", ""immobilien"", ""in"", ""industries"", ""infiniti"",
       ""info"", ""ing"", ""ink"", ""institute"", ""insurance"", ""insure"", ""int"", ""intel"", ""international"", ""intuit"",
       ""investments"", ""io"", ""ipiranga"", ""iq"", ""ir"", ""irish"", ""is"", ""iselect"", ""ismaili"", ""ist"", ""istanbul"", ""it"",
       ""itau"", ""itv"", ""iveco"", ""iwc"", ""jaguar"", ""java"", ""jcb"", ""jcp"", ""je"", ""jeep"", ""jetzt"", ""jewelry"", ""jio"", ""jlc"",
       ""jll"", ""jm"", ""jmp"", ""jnj"", ""jo"", ""jobs"", ""joburg"", ""jot"", ""joy"", ""jp"", ""jpmorgan"", ""jprs"", ""juegos"", ""juniper"",
       ""kaufen"", ""kddi"", ""ke"", ""kerryhotels"", ""kerrylogistics"", ""kerryproperties"", ""kfh"", ""kg"", ""kh"", ""ki"", ""kia"",
       ""kim"", ""kinder"", ""kindle"", ""kitchen"", ""kiwi"", ""km"", ""kn"", ""koeln"", ""komatsu"", ""kosher"", ""kp"", ""kpmg"", ""kpn"",
       ""kr"", ""krd"", ""kred"", ""kuokgroup"", ""kw"", ""ky"", ""kyoto"", ""kz"", ""la"", ""lacaixa"", ""ladbrokes"", ""lamborghini"",
       ""lamer"", ""lancaster"", ""lancia"", ""lancome"", ""land"", ""landrover"", ""lanxess"", ""lasalle"", ""lat"", ""latino"", ""latrobe"",
       ""law"", ""lawyer"", ""lb"", ""lc"", ""lds"", ""lease"", ""leclerc"", ""lefrak"", ""legal"", ""lego"", ""lexus"", ""lgbt"", ""li"",
       ""liaison"", ""lidl"", ""life"", ""lifeinsurance"", ""lifestyle"", ""lighting"", ""like"", ""lilly"", ""limited"", ""limo"",
       ""lincoln"", ""linde"", ""link"", ""lipsy"", ""live"", ""living"", ""lixil"", ""lk"", ""loan"", ""loans"", ""locker"", ""locus"", ""loft"",
       ""lol"", ""london"", ""lotte"", ""lotto"", ""love"", ""lpl"", ""lplfinancial"", ""lr"", ""ls"", ""lt"", ""ltd"", ""ltda"", ""lu"",
       ""lundbeck"", ""lupin"", ""luxe"", ""luxury"", ""lv"", ""ly"", ""ma"", ""macys"", ""madrid"", ""maif"", ""maison"", ""makeup"", ""man"",
       ""management"", ""mango"", ""map"", ""market"", ""marketing"", ""markets"", ""marriott"", ""marshalls"", ""maserati"", ""mattel"",
       ""mba"", ""mc"", ""mckinsey"", ""md"", ""me"", ""med"", ""media"", ""meet"", ""melbourne"", ""meme"", ""memorial"", ""men"", ""menu"",
       ""meo"", ""merckmsd"", ""metlife"", ""mg"", ""mh"", ""miami"", ""microsoft"", ""mil"", ""mini"", ""mint"", ""mit"", ""mitsubishi"", ""mk"",
       ""ml"", ""mlb"", ""mls"", ""mm"", ""mma"", ""mn"", ""mo"", ""mobi"", ""mobile"", ""mobily"", ""moda"", ""moe"", ""moi"", ""mom"", ""monash"",
       ""money"", ""monster"", ""mopar"", ""mormon"", ""mortgage"", ""moscow"", ""moto"", ""motorcycles"", ""mov"", ""movie"", ""movistar"",
       ""mp"", ""mq"", ""mr"", ""ms"", ""msd"", ""mt"", ""mtn"", ""mtr"", ""mu"", ""museum"", ""mutual"", ""mv"", ""mw"", ""mx"", ""my"", ""mz"", ""na"",
       ""nab"", ""nadex"", ""nagoya"", ""name"", ""nationwide"", ""natura"", ""navy"", ""nba"", ""nc"", ""ne"", ""nec"", ""net"", ""netbank"",
       ""netflix"", ""network"", ""neustar"", ""new"", ""newholland"", ""news"", ""next"", ""nextdirect"", ""nexus"", ""nf"", ""nfl"", ""ng"",
       ""ngo"", ""nhk"", ""ni"", ""nico"", ""nike"", ""nikon"", ""ninja"", ""nissan"", ""nissay"", ""nl"", ""no"", ""nokia"",
       ""northwesternmutual"", ""norton"", ""now"", ""nowruz"", ""nowtv"", ""np"", ""nr"", ""nra"", ""nrw"", ""ntt"", ""nu"", ""nyc"", ""nz"",
       ""obi"", ""observer"", ""off"", ""office"", ""okinawa"", ""olayan"", ""olayangroup"", ""oldnavy"", ""ollo"", ""om"", ""omega"", ""one"",
       ""ong"", ""onion"", ""onl"", ""online"", ""onyourside"", ""ooo"", ""open"", ""oracle"", ""orange"", ""org"", ""organic"", ""origins"",
       ""osaka"", ""otsuka"", ""ott"", ""ovh"", ""pa"", ""page"", ""panasonic"", ""panerai"", ""paris"", ""pars"", ""partners"", ""parts"",
       ""party"", ""passagens"", ""pay"", ""pccw"", ""pe"", ""pet"", ""pf"", ""pfizer"", ""pg"", ""ph"", ""pharmacy"", ""phd"", ""philips"",
       ""phone"", ""photo"", ""photography"", ""photos"", ""physio"", ""piaget"", ""pics"", ""pictet"", ""pictures"", ""pid"", ""pin"",
       ""ping"", ""pink"", ""pioneer"", ""pizza"", ""pk"", ""pl"", ""place"", ""play"", ""playstation"", ""plumbing"", ""plus"", ""pm"", ""pn"",
       ""pnc"", ""pohl"", ""poker"", ""politie"", ""porn"", ""post"", ""pr"", ""pramerica"", ""praxi"", ""press"", ""prime"", ""pro"", ""prod"",
       ""productions"", ""prof"", ""progressive"", ""promo"", ""properties"", ""property"", ""protection"", ""pru"", ""prudential"", ""ps"",
       ""pt"", ""pub"", ""pw"", ""pwc"", ""py"", ""qa"", ""qpon"", ""quebec"", ""quest"", ""qvc"", ""racing"", ""radio"", ""raid"", ""re"", ""read"",
       ""realestate"", ""realtor"", ""realty"", ""recipes"", ""red"", ""redstone"", ""redumbrella"", ""rehab"", ""reise"", ""reisen"",
       ""reit"", ""reliance"", ""ren"", ""rent"", ""rentals"", ""repair"", ""report"", ""republican"", ""rest"", ""restaurant"", ""review"",
       ""reviews"", ""rexroth"", ""rich"", ""richardli"", ""ricoh"", ""rightathome"", ""ril"", ""rio"", ""rip"", ""rmit"", ""ro"", ""rocher"",
       ""rocks"", ""rodeo"", ""rogers"", ""room"", ""rs"", ""rsvp"", ""ru"", ""rugby"", ""ruhr"", ""run"", ""rw"", ""rwe"", ""ryukyu"", ""sa"",
       ""saarland"", ""safe"", ""safety"", ""sakura"", ""sale"", ""salon"", ""samsclub"", ""samsung"", ""sandvik"", ""sandvikcoromant"",
       ""sanofi"", ""sap"", ""sapo"", ""sarl"", ""sas"", ""save"", ""saxo"", ""sb"", ""sbi"", ""sbs"", ""sc"", ""sca"", ""scb"", ""schaeffler"",
       ""schmidt"", ""scholarships"", ""school"", ""schule"", ""schwarz"", ""science"", ""scjohnson"", ""scor"", ""scot"", ""sd"", ""se"",
       ""search"", ""seat"", ""secure"", ""security"", ""seek"", ""select"", ""sener"", ""services"", ""ses"", ""seven"", ""sew"", ""sex"",
       ""sexy"", ""sfr"", ""sg"", ""sh"", ""shangrila"", ""sharp"", ""shaw"", ""shell"", ""shia"", ""shiksha"", ""shoes"", ""shop"", ""shopping"",
       ""shouji"", ""show"", ""showtime"", ""shriram"", ""si"", ""silk"", ""sina"", ""singles"", ""site"", ""sj"", ""sk"", ""ski"", ""skin"",
       ""sky"", ""skype"", ""sl"", ""sling"", ""sm"", ""smart"", ""smile"", ""sn"", ""sncf"", ""so"", ""soccer"", ""social"", ""softbank"",
       ""software"", ""sohu"", ""solar"", ""solutions"", ""song"", ""sony"", ""soy"", ""space"", ""spiegel"", ""sport"", ""spot"",
       ""spreadbetting"", ""sr"", ""srl"", ""srt"", ""st"", ""stada"", ""staples"", ""star"", ""starhub"", ""statebank"", ""statefarm"",
       ""statoil"", ""stc"", ""stcgroup"", ""stockholm"", ""storage"", ""store"", ""stream"", ""studio"", ""study"", ""style"", ""su"",
       ""sucks"", ""supplies"", ""supply"", ""support"", ""surf"", ""surgery"", ""suzuki"", ""sv"", ""swatch"", ""swiftcover"", ""swiss"",
       ""sx"", ""sy"", ""sydney"", ""symantec"", ""systems"", ""sz"", ""tab"", ""taipei"", ""talk"", ""taobao"", ""target"", ""tatamotors"",
       ""tatar"", ""tattoo"", ""tax"", ""taxi"", ""tc"", ""tci"", ""td"", ""tdk"", ""team"", ""tech"", ""technology"", ""tel"", ""telecity"",
       ""telefonica"", ""temasek"", ""tennis"", ""teva"", ""tf"", ""tg"", ""th"", ""thd"", ""theater"", ""theatre"", ""tiaa"", ""tickets"",
       ""tienda"", ""tiffany"", ""tips"", ""tires"", ""tirol"", ""tj"", ""tjmaxx"", ""tjx"", ""tk"", ""tkmaxx"", ""tl"", ""tm"", ""tmall"", ""tn"",
       ""to"", ""today"", ""tokyo"", ""tools"", ""top"", ""toray"", ""toshiba"", ""total"", ""tours"", ""town"", ""toyota"", ""toys"", ""tr"",
       ""trade"", ""trading"", ""training"", ""travel"", ""travelchannel"", ""travelers"", ""travelersinsurance"", ""trust"", ""trv"",
       ""tt"", ""tube"", ""tui"", ""tunes"", ""tushu"", ""tv"", ""tvs"", ""tw"", ""tz"", ""ua"", ""ubank"", ""ubs"", ""uconnect"", ""ug"", ""uk"",
       ""unicom"", ""university"", ""uno"", ""uol"", ""ups"", ""us"", ""uy"", ""uz"", ""va"", ""vacations"", ""vana"", ""vanguard"", ""vc"", ""ve"",
       ""vegas"", ""ventures"", ""verisign"", ""versicherung"", ""vet"", ""vg"", ""vi"", ""viajes"", ""video"", ""vig"", ""viking"", ""villas"",
       ""vin"", ""vip"", ""virgin"", ""visa"", ""vision"", ""vista"", ""vistaprint"", ""viva"", ""vivo"", ""vlaanderen"", ""vn"", ""vodka"",
       ""volkswagen"", ""volvo"", ""vote"", ""voting"", ""voto"", ""voyage"", ""vu"", ""vuelos"", ""wales"", ""walmart"", ""walter"", ""wang"",
       ""wanggou"", ""warman"", ""watch"", ""watches"", ""weather"", ""weatherchannel"", ""webcam"", ""weber"", ""website"", ""wed"",
       ""wedding"", ""weibo"", ""weir"", ""wf"", ""whoswho"", ""wien"", ""wiki"", ""williamhill"", ""win"", ""windows"", ""wine"", ""winners"",
       ""wme"", ""wolterskluwer"", ""woodside"", ""work"", ""works"", ""world"", ""wow"", ""ws"", ""wtc"", ""wtf"", ""xbox"", ""xerox"",
       ""xfinity"", ""xihuan"", ""xin"", ""कॉम"", ""セール"", ""佛山"", ""ಭಾರತ"", ""慈善"", ""集团"", ""在线"", ""한국"", ""ଭାରତ"", ""大众汽车"",
       ""点看"", ""คอม"", ""ভাৰত"", ""ভারত"", ""八卦"", ""موقع"", ""বাংলা"", ""公益"", ""公司"", ""香格里拉"", ""网站"", ""移动"", ""我爱你"",
       ""москва"", ""қаз"", ""католик"", ""онлайн"", ""сайт"", ""联通"", ""срб"", ""бг"", ""бел"", ""קום"", ""时尚"", ""微博"", ""淡马锡"",
       ""ファッション"", ""орг"", ""नेट"", ""ストア"", ""삼성"", ""சிங்கப்பூர்"", ""商标"", ""商店"", ""商城"", ""дети"", ""мкд"", ""ею"",
       ""ポイント"", ""新闻"", ""工行"", ""家電"", ""كوم"", ""中文网"", ""中信"", ""中国"", ""中國"", ""娱乐"", ""谷歌"", ""భారత్"", ""ලංකා"",
       ""電訊盈科"", ""购物"", ""クラウド"", ""ભારત"", ""通販"", ""भारतम्"", ""भारत"", ""भारोत"", ""网店"", ""संगठन"", ""餐厅"", ""网络"", ""ком"",
       ""укр"", ""香港"", ""诺基亚"", ""食品"", ""飞利浦"", ""台湾"", ""台灣"", ""手表"", ""手机"", ""мон"", ""الجزائر"", ""عمان"", ""ارامكو"",
       ""ایران"", ""العليان"", ""اتصالات"", ""امارات"", ""بازار"", ""پاکستان"", ""الاردن"", ""موبايلي"", ""بارت"", ""بھارت"", ""المغرب"",
       ""ابوظبي"", ""السعودية"", ""ڀارت"", ""كاثوليك"", ""سودان"", ""همراه"", ""عراق"", ""مليسيا"", ""澳門"", ""닷컴"", ""政府"", ""شبكة"",
       ""بيتك"", ""عرب"", ""გე"", ""机构"", ""组织机构"", ""健康"", ""ไทย"", ""سورية"", ""招聘"", ""рус"", ""рф"", ""珠宝"", ""تونس"", ""大拿"",
       ""みんな"", ""グーグル"", ""ελ"", ""世界"", ""書籍"", ""ഭാരതം"", ""ਭਾਰਤ"", ""网址"", ""닷넷"", ""コム"", ""天主教"", ""游戏"",
       ""vermögensberater"", ""vermögensberatung"", ""企业"", ""信息"", ""嘉里大酒店"", ""嘉里"", ""مصر"", ""قطر"", ""广东"", ""இலங்கை"",
       ""இந்தியா"", ""հայ"", ""新加坡"", ""فلسطين"", ""政务"", ""xperia"", ""xxx"", ""xyz"", ""yachts"", ""yahoo"", ""yamaxun"", ""yandex"",
       ""ye"", ""yodobashi"", ""yoga"", ""yokohama"", ""you"", ""youtube"", ""yt"", ""yun"", ""za"", ""zappos"", ""zara"", ""zero"", ""zip"",
       ""zippo"", ""zm"", ""zone"", ""zuerich"",
       // comment for clang-format to prevent it from placing all strings on separate lines
       ""zw""});
  string str_lower = utf8_to_lower(str);
  if (str_lower != str && utf8_substr(Slice(str_lower), 1) == utf8_substr(str, 1)) {
    return false;
  }
  return tlds.count(str_lower) > 0;
}

static Slice fix_url(Slice str) {
  auto full_url = str;

  bool has_protocol = false;
  auto str_begin = to_lower(str.substr(0, 8));
  if (begins_with(str_begin, ""http://"") || begins_with(str_begin, ""https://"") || begins_with(str_begin, ""ftp://"")) {
    auto pos = str.find(':');
    str = str.substr(pos + 3);
    has_protocol = true;
  }
  auto domain_end = std::min({str.size(), str.find('/'), str.find('?'), str.find('#')});  // TODO server: str.find('#')
  auto domain = str.substr(0, domain_end);
  auto path = str.substr(domain_end);

  auto at_pos = domain.find('@');
  if (at_pos < domain.size()) {
    domain.remove_prefix(at_pos + 1);
  }
  domain.truncate(domain.rfind(':'));

  string domain_lower = domain.str();
  to_lower_inplace(domain_lower);
  if (domain_lower == ""teiegram.org"") {
    return Slice();
  }

  int32 balance[3] = {0, 0, 0};
  size_t path_pos;
  for (path_pos = 0; path_pos < path.size(); path_pos++) {
    switch (path[path_pos]) {
      case '(':
        balance[0]++;
        break;
      case '[':
        balance[1]++;
        break;
      case '{':
        balance[2]++;
        break;
      case ')':
        balance[0]--;
        break;
      case ']':
        balance[1]--;
        break;
      case '}':
        balance[2]--;
        break;
    }
    if (balance[0] < 0 || balance[1] < 0 || balance[2] < 0) {
      break;
    }
  }
  Slice bad_path_end_chars("".:;,('?!`"");
  while (path_pos > 0 && bad_path_end_chars.find(path[path_pos - 1]) < bad_path_end_chars.size()) {
    path_pos--;
  }
  full_url.remove_suffix(path.size() - path_pos);

  vector<Slice> domain_parts = full_split(domain, '.');
  if (domain_parts.size() <= 1) {
    return Slice();
  }

  bool is_ipv4 = domain_parts.size() == 4;
  bool has_non_digit = false;
  for (auto &part : domain_parts) {
    if (part.empty() || part.size() >= 64) {
      return Slice();
    }
    if (part.back() == '-') {
      return Slice();
    }

    if (!has_non_digit) {
      if (part.size() > 3) {
        is_ipv4 = false;
      }
      for (auto c : part) {
        if (!is_digit(c)) {
          is_ipv4 = false;
          has_non_digit = true;
        }
      }
      if (part.size() == 3 &&
          (part[0] >= '3' || (part[0] == '2' && (part[1] >= '6' || (part[1] == '5' && part[2] >= '6'))))) {
        is_ipv4 = false;
      }
      if (part[0] == '0' && part.size() >= 2) {
        is_ipv4 = false;
      }
    }
  }

  if (is_ipv4) {
    return full_url;
  }

  if (!has_non_digit) {
    return Slice();
  }

  auto tld = domain_parts.back();
  if (utf8_length(tld) <= 1) {
    return Slice();
  }

  if (begins_with(tld, ""xn--"")) {
    if (tld.size() <= 5) {
      return Slice();
    }
    for (auto c : tld.substr(4)) {
      if (!is_alpha_digit(c)) {
        return Slice();
      }
    }
  } else {
    if (tld.find('_') < tld.size()) {
      return Slice();
    }
    if (tld.find('-') < tld.size()) {
      return Slice();
    }

    if (!has_protocol && !is_common_tld(tld)) {
      return Slice();
    }
  }

  domain_parts.pop_back();
  if (domain_parts.back().find('_') < domain_parts.back().size()) {
    return Slice();
  }

  return full_url;
}

const std::unordered_set<Slice, SliceHash> &get_valid_short_usernames() {
  static const std::unordered_set<Slice, SliceHash> valid_usernames{""gif"",  ""wiki"", ""vid"",  ""bing"", ""pic"",
                                                                    ""bold"", ""imdb"", ""coub"", ""like"", ""vote""};
  return valid_usernames;
}

vector<Slice> find_mentions(Slice str) {
  auto mentions = match_mentions(str);
  td::remove_if(mentions, [](Slice mention) {
    mention.remove_prefix(1);
    if (mention.size() >= 5) {
      return false;
    }
    auto lowered_mention = to_lower(mention);
    return get_valid_short_usernames().count(lowered_mention) == 0;
  });
  return mentions;
}

vector<Slice> find_bot_commands(Slice str) {
  return match_bot_commands(str);
}

vector<Slice> find_hashtags(Slice str) {
  return match_hashtags(str);
}

vector<Slice> find_cashtags(Slice str) {
  return match_cashtags(str);
}

vector<Slice> find_bank_card_numbers(Slice str) {
  vector<Slice> result;
  for (auto bank_card : match_bank_card_numbers(str)) {
    if (is_valid_bank_card(bank_card)) {
      result.emplace_back(bank_card);
    }
  }
  return result;
}

vector<Slice> find_tg_urls(Slice str) {
  return match_tg_urls(str);
}

vector<std::pair<Slice, bool>> find_urls(Slice str) {
  vector<std::pair<Slice, bool>> result;
  for (auto url : match_urls(str)) {
    if (is_email_address(url)) {
      result.emplace_back(url, true);
    } else if (begins_with(url, ""mailto:"") && is_email_address(url.substr(7))) {
      result.emplace_back(url.substr(7), true);
    } else {
      url = fix_url(url);
      if (!url.empty()) {
        result.emplace_back(url, false);
      }
    }
  }
  return result;
}

vector<std::pair<Slice, int32>> find_media_timestamps(Slice str) {
  vector<std::pair<Slice, int32>> result;
  for (auto media_timestamp : match_media_timestamps(str)) {
    vector<Slice> parts = full_split(media_timestamp, ':');
    CHECK(parts.size() >= 2);
    if (parts.size() > 3 || parts.back().size() != 2) {
      continue;
    }
    auto seconds = to_integer<int32>(parts.back());
    if (seconds >= 60) {
      continue;
    }
    if (parts.size() == 2) {
      if (parts[0].size() > 4 || parts[0].empty()) {
        continue;
      }

      auto minutes = to_integer<int32>(parts[0]);
      result.emplace_back(media_timestamp, minutes * 60 + seconds);
      continue;
    } else {
      if (parts[0].size() > 2 || parts[1].size() > 2 || parts[0].empty() || parts[1].empty()) {
        continue;
      }

      auto minutes = to_integer<int32>(parts[1]);
      if (minutes >= 60) {
        continue;
      }
      auto hours = to_integer<int32>(parts[0]);
      result.emplace_back(media_timestamp, hours * 3600 + minutes * 60 + seconds);
    }
  }
  return result;
}

static int32 text_length(Slice text) {
  return narrow_cast<int32>(utf8_utf16_length(text));
}

static void sort_entities(vector<MessageEntity> &entities) {
  if (std::is_sorted(entities.begin(), entities.end())) {
    return;
  }

  std::sort(entities.begin(), entities.end());
}

#define check_is_sorted(entities) check_is_sorted_impl(entities, __LINE__)
static void check_is_sorted_impl(const vector<MessageEntity> &entities, int line) {
  LOG_CHECK(std::is_sorted(entities.begin(), entities.end())) << line << "" "" << entities;
}

#define check_non_intersecting(entities) check_non_intersecting_impl(entities, __LINE__)
static void check_non_intersecting_impl(const vector<MessageEntity> &entities, int line) {
  for (size_t i = 0; i + 1 < entities.size(); i++) {
    LOG_CHECK(entities[i].offset + entities[i].length <= entities[i + 1].offset) << line << "" "" << entities;
  }
}

static constexpr int32 get_entity_type_mask(MessageEntity::Type type) {
  return 1 << static_cast<int32>(type);
}

static constexpr int32 get_splittable_entities_mask() {
  return get_entity_type_mask(MessageEntity::Type::Bold) | get_entity_type_mask(MessageEntity::Type::Italic) |
         get_entity_type_mask(MessageEntity::Type::Underline) |
         get_entity_type_mask(MessageEntity::Type::Strikethrough);
}

static constexpr int32 get_blockquote_entities_mask() {
  return get_entity_type_mask(MessageEntity::Type::BlockQuote);
}

static constexpr int32 get_continuous_entities_mask() {
  return get_entity_type_mask(MessageEntity::Type::Mention) | get_entity_type_mask(MessageEntity::Type::Hashtag) |
         get_entity_type_mask(MessageEntity::Type::BotCommand) | get_entity_type_mask(MessageEntity::Type::Url) |
         get_entity_type_mask(MessageEntity::Type::EmailAddress) | get_entity_type_mask(MessageEntity::Type::TextUrl) |
         get_entity_type_mask(MessageEntity::Type::MentionName) | get_entity_type_mask(MessageEntity::Type::Cashtag) |
         get_entity_type_mask(MessageEntity::Type::PhoneNumber) |
         get_entity_type_mask(MessageEntity::Type::BankCardNumber) |
         get_entity_type_mask(MessageEntity::Type::MediaTimestamp);
}

static constexpr int32 get_pre_entities_mask() {
  return get_entity_type_mask(MessageEntity::Type::Pre) | get_entity_type_mask(MessageEntity::Type::Code) |
         get_entity_type_mask(MessageEntity::Type::PreCode);
}

static constexpr int32 get_user_entities_mask() {
  return get_splittable_entities_mask() | get_blockquote_entities_mask() |
         get_entity_type_mask(MessageEntity::Type::TextUrl) | get_entity_type_mask(MessageEntity::Type::MentionName) |
         get_pre_entities_mask();
}

static int32 is_splittable_entity(MessageEntity::Type type) {
  return (get_entity_type_mask(type) & get_splittable_entities_mask()) != 0;
}

static int32 is_blockquote_entity(MessageEntity::Type type) {
  return type == MessageEntity::Type::BlockQuote;
}

static int32 is_continuous_entity(MessageEntity::Type type) {
  return (get_entity_type_mask(type) & get_continuous_entities_mask()) != 0;
}

static int32 is_pre_entity(MessageEntity::Type type) {
  return (get_entity_type_mask(type) & get_pre_entities_mask()) != 0;
}

static int32 is_user_entity(MessageEntity::Type type) {
  return (get_entity_type_mask(type) & get_user_entities_mask()) != 0;
}

static int32 is_hidden_data_entity(MessageEntity::Type type) {
  return (get_entity_type_mask(type) &
          (get_entity_type_mask(MessageEntity::Type::TextUrl) | get_entity_type_mask(MessageEntity::Type::MentionName) |
           get_pre_entities_mask())) != 0;
}

static constexpr size_t SPLITTABLE_ENTITY_TYPE_COUNT = 4;

static size_t get_splittable_entity_type_index(MessageEntity::Type type) {
  if (static_cast<int32>(type) <= static_cast<int32>(MessageEntity::Type::Bold) + 1) {
    // Bold or Italic
    return static_cast<int32>(type) - static_cast<int32>(MessageEntity::Type::Bold);
  } else {
    // Underline or Strikethrough
    return static_cast<int32>(type) - static_cast<int32>(MessageEntity::Type::Underline) + 2;
  }
}

static bool are_entities_valid(const vector<MessageEntity> &entities) {
  if (entities.empty()) {
    return true;
  }
  check_is_sorted(entities);

  int32 end_pos[SPLITTABLE_ENTITY_TYPE_COUNT];
  std::fill_n(end_pos, SPLITTABLE_ENTITY_TYPE_COUNT, -1);
  vector<const MessageEntity *> nested_entities_stack;
  int32 nested_entity_type_mask = 0;
  for (auto &entity : entities) {
    while (!nested_entities_stack.empty() &&
           entity.offset >= nested_entities_stack.back()->offset + nested_entities_stack.back()->length) {
      // remove non-intersecting entities from the stack
      nested_entity_type_mask -= get_entity_type_mask(nested_entities_stack.back()->type);
      nested_entities_stack.pop_back();
    }

    if (!nested_entities_stack.empty()) {
      if (entity.offset + entity.length > nested_entities_stack.back()->offset + nested_entities_stack.back()->length) {
        // entity intersects some previous entity
        return false;
      }
      if ((nested_entity_type_mask & get_entity_type_mask(entity.type)) != 0) {
        // entity has the same type as one of the previous nested
        return false;
      }
      auto parent_type = nested_entities_stack.back()->type;
      if (is_pre_entity(parent_type)) {
        // Pre and Code can't contain nested entities
        return false;
      }
      // parents are not pre after this point
      if (is_pre_entity(entity.type) && (nested_entity_type_mask & ~get_blockquote_entities_mask()) != 0) {
        // Pre and Code can't be contained in other entities, except blockquote
        return false;
      }
      if ((is_continuous_entity(entity.type) || is_blockquote_entity(entity.type)) &&
          (nested_entity_type_mask & get_continuous_entities_mask()) != 0) {
        // continuous and blockquote can't be contained in continuous
        return false;
      }
      if ((nested_entity_type_mask & get_splittable_entities_mask()) != 0) {
        // the previous nested entity may be needed to splitted for consistency
        // alternatively, better entity merging needs to be implemented
        return false;
      }
    }

    if (is_splittable_entity(entity.type)) {
      auto index = get_splittable_entity_type_index(entity.type);
      if (end_pos[index] >= entity.offset) {
        // the entities can be merged
        return false;
      }
      end_pos[index] = entity.offset + entity.length;
    }
    nested_entities_stack.push_back(&entity);
    nested_entity_type_mask += get_entity_type_mask(entity.type);
  }
  return true;
}

// removes all intersecting entities, including nested
static void remove_intersecting_entities(vector<MessageEntity> &entities) {
  check_is_sorted(entities);
  int32 last_entity_end = 0;
  size_t left_entities = 0;
  for (size_t i = 0; i < entities.size(); i++) {
    CHECK(entities[i].length > 0);
    if (entities[i].offset >= last_entity_end) {
      last_entity_end = entities[i].offset + entities[i].length;
      if (i != left_entities) {
        entities[left_entities] = std::move(entities[i]);
      }
      left_entities++;
    }
  }
  entities.erase(entities.begin() + left_entities, entities.end());
}

// continuous_entities and blockquote_entities must be pre-sorted and non-overlapping
static void remove_entities_intersecting_blockquote(vector<MessageEntity> &entities,
                                                    const vector<MessageEntity> &blockquote_entities) {
  check_non_intersecting(entities);
  check_non_intersecting(blockquote_entities);
  if (blockquote_entities.empty()) {
    // fast path
    return;
  }

  auto blockquote_it = blockquote_entities.begin();
  size_t left_entities = 0;
  for (size_t i = 0; i < entities.size(); i++) {
    while (blockquote_it != blockquote_entities.end() &&
           (blockquote_it->type != MessageEntity::Type::BlockQuote ||
            blockquote_it->offset + blockquote_it->length <= entities[i].offset)) {
      ++blockquote_it;
    }
    if (blockquote_it != blockquote_entities.end() &&
        (blockquote_it->offset + blockquote_it->length < entities[i].offset + entities[i].length ||
         (entities[i].offset < blockquote_it->offset &&
          blockquote_it->offset < entities[i].offset + entities[i].length))) {
      continue;
    }
    if (i != left_entities) {
      entities[left_entities] = std::move(entities[i]);
    }
    left_entities++;
  }
  entities.erase(entities.begin() + left_entities, entities.end());
}

// keeps only non-intersecting entities
// fixes entity offsets from UTF-8 to UTF-16 offsets
static void fix_entity_offsets(Slice text, vector<MessageEntity> &entities) {
  if (entities.empty()) {
    return;
  }

  sort_entities(entities);

  remove_intersecting_entities(entities);

  const unsigned char *begin = text.ubegin();
  const unsigned char *ptr = begin;
  const unsigned char *end = text.uend();

  int32 utf16_pos = 0;
  for (auto &entity : entities) {
    int cnt = 2;
    auto entity_begin = entity.offset;
    auto entity_end = entity.offset + entity.length;

    int32 pos = static_cast<int32>(ptr - begin);
    if (entity_begin == pos) {
      cnt--;
      entity.offset = utf16_pos;
    }

    while (ptr != end && cnt > 0) {
      unsigned char c = ptr[0];
      utf16_pos += 1 + (c >= 0xf0);
      ptr = next_utf8_unsafe(ptr, nullptr, ""fix_entity_offsets"");

      pos = static_cast<int32>(ptr - begin);
      if (entity_begin == pos) {
        cnt--;
        entity.offset = utf16_pos;
      } else if (entity_end == pos) {
        cnt--;
        entity.length = utf16_pos - entity.offset;
      }
    }
    CHECK(cnt == 0);
  }
}

vector<MessageEntity> find_entities(Slice text, bool skip_bot_commands, bool skip_media_timestamps) {
  vector<MessageEntity> entities;

  auto add_entities = [&entities, &text](MessageEntity::Type type, vector<Slice> (*find_entities_f)(Slice)) mutable {
    auto new_entities = find_entities_f(text);
    for (auto &entity : new_entities) {
      auto offset = narrow_cast<int32>(entity.begin() - text.begin());
      auto length = narrow_cast<int32>(entity.size());
      entities.emplace_back(type, offset, length);
    }
  };
  add_entities(MessageEntity::Type::Mention, find_mentions);
  if (!skip_bot_commands) {
    add_entities(MessageEntity::Type::BotCommand, find_bot_commands);
  }
  add_entities(MessageEntity::Type::Hashtag, find_hashtags);
  add_entities(MessageEntity::Type::Cashtag, find_cashtags);
  // TODO find_phone_numbers
  add_entities(MessageEntity::Type::BankCardNumber, find_bank_card_numbers);
  add_entities(MessageEntity::Type::Url, find_tg_urls);

  auto urls = find_urls(text);
  for (auto &url : urls) {
    auto type = url.second ? MessageEntity::Type::EmailAddress : MessageEntity::Type::Url;
    auto offset = narrow_cast<int32>(url.first.begin() - text.begin());
    auto length = narrow_cast<int32>(url.first.size());
    entities.emplace_back(type, offset, length);
  }

  if (!skip_media_timestamps) {
    auto media_timestamps = find_media_timestamps(text);
    for (auto &entity : media_timestamps) {
      auto offset = narrow_cast<int32>(entity.first.begin() - text.begin());
      auto length = narrow_cast<int32>(entity.first.size());
      entities.emplace_back(MessageEntity::Type::MediaTimestamp, offset, length, entity.second);
    }
  }

  fix_entity_offsets(text, entities);

  return entities;
}

static vector<MessageEntity> find_media_timestamp_entities(Slice text) {
  vector<MessageEntity> entities;

  auto media_timestamps = find_media_timestamps(text);
  for (auto &entity : media_timestamps) {
    auto offset = narrow_cast<int32>(entity.first.begin() - text.begin());
    auto length = narrow_cast<int32>(entity.first.size());
    entities.emplace_back(MessageEntity::Type::MediaTimestamp, offset, length, entity.second);
  }

  fix_entity_offsets(text, entities);

  return entities;
}

static vector<MessageEntity> merge_entities(vector<MessageEntity> old_entities, vector<MessageEntity> new_entities) {
  if (new_entities.empty()) {
    return old_entities;
  }
  if (old_entities.empty()) {
    return new_entities;
  }

  vector<MessageEntity> result;
  result.reserve(old_entities.size() + new_entities.size());

  auto new_it = new_entities.begin();
  auto new_end = new_entities.end();
  for (auto &old_entity : old_entities) {
    while (new_it != new_end && new_it->offset + new_it->length <= old_entity.offset) {
      result.push_back(std::move(*new_it));
      ++new_it;
    }
    auto old_entity_end = old_entity.offset + old_entity.length;
    result.push_back(std::move(old_entity));
    while (new_it != new_end && new_it->offset < old_entity_end) {
      ++new_it;
    }
  }
  while (new_it != new_end) {
    result.push_back(std::move(*new_it));
    ++new_it;
  }

  return result;
}

static bool is_plain_domain(Slice url) {
  return url.find('/') >= url.size() && url.find('?') >= url.size() && url.find('#') >= url.size();
}

string get_first_url(Slice text, const vector<MessageEntity> &entities) {
  for (auto &entity : entities) {
    switch (entity.type) {
      case MessageEntity::Type::Mention:
        break;
      case MessageEntity::Type::Hashtag:
        break;
      case MessageEntity::Type::BotCommand:
        break;
      case MessageEntity::Type::Url: {
        Slice url = utf8_utf16_substr(text, entity.offset, entity.length);
        string scheme = to_lower(url.substr(0, 4));
        if (scheme == ""ton:"" || begins_with(scheme, ""tg:"") || scheme == ""ftp:"" || is_plain_domain(url)) {
          continue;
        }
        return url.str();
      }
      case MessageEntity::Type::EmailAddress:
        break;
      case MessageEntity::Type::Bold:
        break;
      case MessageEntity::Type::Italic:
        break;
      case MessageEntity::Type::Underline:
        break;
      case MessageEntity::Type::Strikethrough:
        break;
      case MessageEntity::Type::BlockQuote:
        break;
      case MessageEntity::Type::Code:
        break;
      case MessageEntity::Type::Pre:
        break;
      case MessageEntity::Type::PreCode:
        break;
      case MessageEntity::Type::TextUrl: {
        Slice url = entity.argument;
        if (begins_with(url, ""ton:"") || begins_with(url, ""tg:"") || begins_with(url, ""ftp:"")) {
          continue;
        }
        return url.str();
      }
      case MessageEntity::Type::MentionName:
        break;
      case MessageEntity::Type::Cashtag:
        break;
      case MessageEntity::Type::PhoneNumber:
        break;
      case MessageEntity::Type::BankCardNumber:
        break;
      case MessageEntity::Type::MediaTimestamp:
        break;
      default:
        UNREACHABLE();
    }
  }

  return string();
}

static UserId get_link_user_id(Slice url) {
  string lower_cased_url = to_lower(url);
  url = lower_cased_url;

  Slice link_scheme(""tg:"");
  if (!begins_with(url, link_scheme)) {
    return UserId();
  }
  url.remove_prefix(link_scheme.size());
  if (begins_with(url, ""//"")) {
    url.remove_prefix(2);
  }

  Slice host(""user"");
  if (!begins_with(url, host)) {
    return UserId();
  }
  url.remove_prefix(host.size());
  if (begins_with(url, ""/"")) {
    url.remove_prefix(1);
  }
  if (!begins_with(url, ""?"")) {
    return UserId();
  }
  url.remove_prefix(1);
  url.truncate(url.find('#'));

  for (auto parameter : full_split(url, '&')) {
    Slice key;
    Slice value;
    std::tie(key, value) = split(parameter, '=');
    if (key == Slice(""id"")) {
      auto r_user_id = to_integer_safe<int64>(value);
      if (r_user_id.is_error()) {
        return UserId();
      }
      return UserId(r_user_id.ok());
    }
  }
  return UserId();
}

Result<vector<MessageEntity>> parse_markdown(string &text) {
  string result;
  vector<MessageEntity> entities;
  size_t size = text.size();
  int32 utf16_offset = 0;
  for (size_t i = 0; i < size; i++) {
    auto c = static_cast<unsigned char>(text[i]);
    if (c == '\\' && (text[i + 1] == '_' || text[i + 1] == '*' || text[i + 1] == '`' || text[i + 1] == '[')) {
      i++;
      result.push_back(text[i]);
      utf16_offset++;
      continue;
    }
    if (c != '_' && c != '*' && c != '`' && c != '[') {
      if (is_utf8_character_first_code_unit(c)) {
        utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
      }
      result.push_back(text[i]);
      continue;
    }

    // we are at begin of the entity
    size_t begin_pos = i;
    char end_character = text[i];
    bool is_pre = false;
    if (c == '[') {
      end_character = ']';
    }

    i++;

    string language;
    if (c == '`' && text[i] == '`' && text[i + 1] == '`') {
      i += 2;
      is_pre = true;
      size_t language_end = i;
      while (!is_space(text[language_end]) && text[language_end] != '`') {
        language_end++;
      }
      if (i != language_end && language_end < size && text[language_end] != '`') {
        language.assign(text, i, language_end - i);
        i = language_end;
      }
      // skip one new line in the beginning of the text
      if (text[i] == '\n' || text[i] == '\r') {
        if ((text[i + 1] == '\n' || text[i + 1] == '\r') && text[i] != text[i + 1]) {
          i += 2;
        } else {
          i++;
        }
      }
    }

    int32 entity_offset = utf16_offset;
    while (i < size && (text[i] != end_character || (is_pre && !(text[i + 1] == '`' && text[i + 2] == '`')))) {
      auto cur_ch = static_cast<unsigned char>(text[i]);
      if (is_utf8_character_first_code_unit(cur_ch)) {
        utf16_offset += 1 + (cur_ch >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
      }
      result.push_back(text[i++]);
    }
    if (i == size) {
      return Status::Error(400, PSLICE() << ""Can't find end of the entity starting at byte offset "" << begin_pos);
    }

    if (entity_offset != utf16_offset) {
      auto entity_length = utf16_offset - entity_offset;
      switch (c) {
        case '_':
          entities.emplace_back(MessageEntity::Type::Italic, entity_offset, entity_length);
          break;
        case '*':
          entities.emplace_back(MessageEntity::Type::Bold, entity_offset, entity_length);
          break;
        case '[': {
          string url;
          if (text[i + 1] != '(') {
            // use text as a URL
            url.assign(text, begin_pos + 1, i - begin_pos - 1);
          } else {
            i += 2;
            while (i < size && text[i] != ')') {
              url.push_back(text[i++]);
            }
          }
          auto user_id = get_link_user_id(url);
          if (user_id.is_valid()) {
            entities.emplace_back(entity_offset, entity_length, user_id);
          } else {
            auto r_url = LinkManager::check_link(url);
            if (r_url.is_ok()) {
              entities.emplace_back(MessageEntity::Type::TextUrl, entity_offset, entity_length, r_url.move_as_ok());
            }
          }
          break;
        }
        case '`':
          if (is_pre) {
            if (language.empty()) {
              entities.emplace_back(MessageEntity::Type::Pre, entity_offset, entity_length);
            } else {
              entities.emplace_back(MessageEntity::Type::PreCode, entity_offset, entity_length, language);
            }
          } else {
            entities.emplace_back(MessageEntity::Type::Code, entity_offset, entity_length);
          }
          break;
        default:
          UNREACHABLE();
      }
    }
    if (is_pre) {
      i += 2;
    }
  }
  text = result;
  return entities;
}

static Result<vector<MessageEntity>> do_parse_markdown_v2(CSlice text, string &result) {
  vector<MessageEntity> entities;
  int32 utf16_offset = 0;

  struct EntityInfo {
    MessageEntity::Type type;
    string argument;
    int32 entity_offset;
    size_t entity_byte_offset;
    size_t entity_begin_pos;

    EntityInfo(MessageEntity::Type type, string argument, int32 entity_offset, size_t entity_byte_offset,
               size_t entity_begin_pos)
        : type(type)
        , argument(std::move(argument))
        , entity_offset(entity_offset)
        , entity_byte_offset(entity_byte_offset)
        , entity_begin_pos(entity_begin_pos) {
    }
  };
  std::vector<EntityInfo> nested_entities;

  for (size_t i = 0; i < text.size(); i++) {
    auto c = static_cast<unsigned char>(text[i]);
    if (c == '\\' && text[i + 1] > 0 && text[i + 1] <= 126) {
      i++;
      utf16_offset += 1;
      result += text[i];
      continue;
    }

    Slice reserved_characters(""_*[]()~`>#+-=|{}.!"");
    if (!nested_entities.empty()) {
      switch (nested_entities.back().type) {
        case MessageEntity::Type::Code:
        case MessageEntity::Type::Pre:
        case MessageEntity::Type::PreCode:
          reserved_characters = Slice(""`"");
          break;
        default:
          break;
      }
    }

    if (reserved_characters.find(text[i]) == Slice::npos) {
      if (is_utf8_character_first_code_unit(c)) {
        utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
      }
      result.push_back(text[i]);
      continue;
    }

    bool is_end_of_an_entity = false;
    if (!nested_entities.empty()) {
      is_end_of_an_entity = [&] {
        switch (nested_entities.back().type) {
          case MessageEntity::Type::Bold:
            return c == '*';
          case MessageEntity::Type::Italic:
            return c == '_' && text[i + 1] != '_';
          case MessageEntity::Type::Code:
            return c == '`';
          case MessageEntity::Type::Pre:
          case MessageEntity::Type::PreCode:
            return c == '`' && text[i + 1] == '`' && text[i + 2] == '`';
          case MessageEntity::Type::TextUrl:
            return c == ']';
          case MessageEntity::Type::Underline:
            return c == '_' && text[i + 1] == '_';
          case MessageEntity::Type::Strikethrough:
            return c == '~';
          default:
            UNREACHABLE();
            return false;
        }
      }();
    }

    if (!is_end_of_an_entity) {
      // begin of an entity
      MessageEntity::Type type;
      string argument;
      auto entity_byte_offset = i;
      switch (c) {
        case '_':
          if (text[i + 1] == '_') {
            type = MessageEntity::Type::Underline;
            i++;
          } else {
            type = MessageEntity::Type::Italic;
          }
          break;
        case '*':
          type = MessageEntity::Type::Bold;
          break;
        case '~':
          type = MessageEntity::Type::Strikethrough;
          break;
        case '[':
          type = MessageEntity::Type::TextUrl;
          break;
        case '`':
          if (text[i + 1] == '`' && text[i + 2] == '`') {
            i += 3;
            type = MessageEntity::Type::Pre;
            size_t language_end = i;
            while (!is_space(text[language_end]) && text[language_end] != '`') {
              language_end++;
            }
            if (i != language_end && language_end < text.size() && text[language_end] != '`') {
              type = MessageEntity::Type::PreCode;
              argument = text.substr(i, language_end - i).str();
              i = language_end;
            }
            // skip one new line in the beginning of the text
            if (text[i] == '\n' || text[i] == '\r') {
              if ((text[i + 1] == '\n' || text[i + 1] == '\r') && text[i] != text[i + 1]) {
                i += 2;
              } else {
                i++;
              }
            }

            i--;
          } else {
            type = MessageEntity::Type::Code;
          }
          break;
        default:
          return Status::Error(
              400, PSLICE() << ""Character '"" << text[i] << ""' is reserved and must be escaped with the preceding '\\'"");
      }
      nested_entities.emplace_back(type, std::move(argument), utf16_offset, entity_byte_offset, result.size());
    } else {
      // end of an entity
      auto type = nested_entities.back().type;
      auto argument = std::move(nested_entities.back().argument);
      UserId user_id;
      bool skip_entity = utf16_offset == nested_entities.back().entity_offset;
      switch (type) {
        case MessageEntity::Type::Bold:
        case MessageEntity::Type::Italic:
        case MessageEntity::Type::Code:
        case MessageEntity::Type::Strikethrough:
          break;
        case MessageEntity::Type::Underline:
          i++;
          break;
        case MessageEntity::Type::Pre:
        case MessageEntity::Type::PreCode:
          i += 2;
          break;
        case MessageEntity::Type::TextUrl: {
          string url;
          if (text[i + 1] != '(') {
            // use text as a URL
            url = result.substr(nested_entities.back().entity_begin_pos);
          } else {
            i += 2;
            auto url_begin_pos = i;
            while (i < text.size() && text[i] != ')') {
              if (text[i] == '\\' && text[i + 1] > 0 && text[i + 1] <= 126) {
                url += text[i + 1];
                i += 2;
                continue;
              }
              url += text[i++];
            }
            if (text[i] != ')') {
              return Status::Error(400, PSLICE() << ""Can't find end of a URL at byte offset "" << url_begin_pos);
            }
          }
          user_id = get_link_user_id(url);
          if (!user_id.is_valid()) {
            auto r_url = LinkManager::check_link(url);
            if (r_url.is_error()) {
              skip_entity = true;
            } else {
              argument = r_url.move_as_ok();
            }
          }
          break;
        }
        default:
          UNREACHABLE();
          return false;
      }

      if (!skip_entity) {
        auto entity_offset = nested_entities.back().entity_offset;
        auto entity_length = utf16_offset - entity_offset;
        if (user_id.is_valid()) {
          entities.emplace_back(entity_offset, entity_length, user_id);
        } else {
          entities.emplace_back(type, entity_offset, entity_length, std::move(argument));
        }
      }
      nested_entities.pop_back();
    }
  }
  if (!nested_entities.empty()) {
    return Status::Error(400, PSLICE() << ""Can't find end of "" << nested_entities.back().type
                                       << "" entity at byte offset "" << nested_entities.back().entity_byte_offset);
  }

  sort_entities(entities);

  return entities;
}

Result<vector<MessageEntity>> parse_markdown_v2(string &text) {
  string result;
  TRY_RESULT(entities, do_parse_markdown_v2(text, result));
  text = result;
  return entities;
}

static vector<Slice> find_text_url_entities_v3(Slice text) {
  vector<Slice> result;
  size_t size = text.size();
  for (size_t i = 0; i < size; i++) {
    if (text[i] != '[') {
      continue;
    }

    auto text_begin = i;
    auto text_end = text_begin + 1;
    while (text_end < size && text[text_end] != ']') {
      text_end++;
    }

    i = text_end;  // prevent quadratic asymptotic

    if (text_end == size || text_end == text_begin + 1) {
      continue;
    }

    auto url_begin = text_end + 1;
    if (url_begin == size || text[url_begin] != '(') {
      continue;
    }

    size_t url_end = url_begin + 1;
    while (url_end < size && text[url_end] != ')') {
      url_end++;
    }

    i = url_end;  // prevent quadratic asymptotic, disallows [a](b[c](t.me)

    if (url_end < size) {
      Slice url = text.substr(url_begin + 1, url_end - url_begin - 1);
      if (LinkManager::check_link(url).is_ok()) {
        result.push_back(text.substr(text_begin, text_end - text_begin + 1));
        result.push_back(text.substr(url_begin, url_end - url_begin + 1));
      }
    }
  }
  return result;
}

// entities must be valid for the text
static FormattedText parse_text_url_entities_v3(Slice text, const vector<MessageEntity> &entities) {
  // continuous entities can't intersect TextUrl entities,
  // so try to find new TextUrl entities only between the predetermined continuous entities

  Slice debug_initial_text = text;

  FormattedText result;
  int32 result_text_utf16_length = 0;
  vector<MessageEntity> part_entities;
  vector<MessageEntity> part_splittable_entities[SPLITTABLE_ENTITY_TYPE_COUNT];
  int32 part_begin = 0;
  int32 max_end = 0;
  int32 skipped_length = 0;
  auto add_part = [&](int32 part_end) {
    // we have [part_begin, max_end) kept part and [max_end, part_end) part to parse text_url entities

    if (max_end != part_begin) {
      // add all entities from the kept part
      auto kept_part_text = utf8_utf16_substr(text, 0, max_end - part_begin);
      text = text.substr(kept_part_text.size());

      result.text.append(kept_part_text.begin(), kept_part_text.size());
      append(result.entities, std::move(part_entities));
      part_entities.clear();
      result_text_utf16_length += max_end - part_begin;
    }

    size_t splittable_entity_pos[SPLITTABLE_ENTITY_TYPE_COUNT] = {};
    for (size_t index = 0; index < SPLITTABLE_ENTITY_TYPE_COUNT; index++) {
      check_non_intersecting(part_splittable_entities[index]);
    }
    if (part_end != max_end) {
      // try to find text_url entities in the left part
      auto parsed_part_text = utf8_utf16_substr(text, 0, part_end - max_end);
      text = text.substr(parsed_part_text.size());

      vector<Slice> text_urls = find_text_url_entities_v3(parsed_part_text);

      int32 text_utf16_offset = max_end;
      size_t prev_pos = 0;
      for (size_t i = 0; i < text_urls.size(); i += 2) {
        auto text_begin_pos = static_cast<size_t>(text_urls[i].begin() - parsed_part_text.begin());
        auto text_end_pos = text_begin_pos + text_urls[i].size() - 1;
        auto url_begin_pos = static_cast<size_t>(text_urls[i + 1].begin() - parsed_part_text.begin());
        auto url_end_pos = url_begin_pos + text_urls[i + 1].size() - 1;
        CHECK(parsed_part_text[text_begin_pos] == '[');
        CHECK(parsed_part_text[text_end_pos] == ']');
        CHECK(url_begin_pos == text_end_pos + 1);
        CHECK(parsed_part_text[url_begin_pos] == '(');
        CHECK(parsed_part_text[url_end_pos] == ')');

        Slice before_text_url = parsed_part_text.substr(prev_pos, text_begin_pos - prev_pos);
        auto before_text_url_utf16_length = text_length(before_text_url);
        result_text_utf16_length += before_text_url_utf16_length;
        result.text.append(before_text_url.begin(), before_text_url.size());
        text_utf16_offset += before_text_url_utf16_length;

        Slice text_url = parsed_part_text.substr(text_begin_pos + 1, text_end_pos - text_begin_pos - 1);
        auto text_url_utf16_length = text_length(text_url);
        Slice url = parsed_part_text.substr(url_begin_pos + 1, url_end_pos - url_begin_pos - 1);
        auto url_utf16_length = text_length(url);
        result.entities.emplace_back(MessageEntity::Type::TextUrl, result_text_utf16_length, text_url_utf16_length,
                                     LinkManager::check_link(url).move_as_ok());
        result.text.append(text_url.begin(), text_url.size());
        result_text_utf16_length += text_url_utf16_length;

        auto initial_utf16_length = 1 + text_url_utf16_length + 1 + 1 + url_utf16_length + 1;

        // adjust splittable entities, removing deleted parts from them
        // in the segment [text_utf16_offset, text_utf16_offset + initial_utf16_length)
        // the first character and the last (url_utf16_length + 3) characters are deleted
        for (size_t index = 0; index < SPLITTABLE_ENTITY_TYPE_COUNT; index++) {
          auto &pos = splittable_entity_pos[index];
          auto &splittable_entities = part_splittable_entities[index];
          while (pos < splittable_entities.size() &&
                 splittable_entities[pos].offset < text_utf16_offset + initial_utf16_length) {
            auto offset = splittable_entities[pos].offset;
            auto length = splittable_entities[pos].length;
            if (offset + length > text_utf16_offset + 1 + text_url_utf16_length) {
              // ends after last removed part; truncate length
              length = text_utf16_offset + 1 + text_url_utf16_length - offset;
            }
            if (offset >= text_utf16_offset + 1) {
              offset--;
            } else if (offset + length >= text_utf16_offset + 1) {
              length--;
            }
            if (length > 0) {
              CHECK(offset >= skipped_length);
              CHECK(offset - skipped_length + length <= result_text_utf16_length);
              if (offset < text_utf16_offset && offset + length > text_utf16_offset) {
                // entity intersects start on the new text_url entity; split it
                result.entities.emplace_back(splittable_entities[pos].type, offset - skipped_length,
                                             text_utf16_offset - offset);
                length -= text_utf16_offset - offset;
                offset = text_utf16_offset;
              }
              result.entities.emplace_back(splittable_entities[pos].type, offset - skipped_length, length);
            }
            if (splittable_entities[pos].offset + splittable_entities[pos].length >
                text_utf16_offset + initial_utf16_length) {
              // begins before end of the segment, but ends after it
              // need to keep the entity for future segments, so split the entity
              splittable_entities[pos].length = splittable_entities[pos].offset + splittable_entities[pos].length -
                                                (text_utf16_offset + initial_utf16_length);
              splittable_entities[pos].offset = text_utf16_offset + initial_utf16_length;
            } else {
              pos++;
            }
          }
        }
        text_utf16_offset += initial_utf16_length;

        skipped_length += 2 + 2 + url_utf16_length;
        prev_pos = url_end_pos + 1;
      }

      result.text.append(parsed_part_text.begin() + prev_pos, parsed_part_text.size() - prev_pos);
      result_text_utf16_length += part_end - text_utf16_offset;
    }

    // now add all left splittable entities from [part_begin, part_end)
    for (size_t index = 0; index < SPLITTABLE_ENTITY_TYPE_COUNT; index++) {
      auto &pos = splittable_entity_pos[index];
      auto &splittable_entities = part_splittable_entities[index];
      while (pos < splittable_entities.size() && splittable_entities[pos].offset < part_end) {
        if (splittable_entities[pos].offset + splittable_entities[pos].length > part_end) {
          // begins before end of the segment, but ends after it
          // need to keep the entity for future segments, so split the entity
          // entities don't intersect each other, so there can be at most one such entity
          result.entities.emplace_back(splittable_entities[pos].type, splittable_entities[pos].offset - skipped_length,
                                       part_end - splittable_entities[pos].offset);

          splittable_entities[pos].length =
              splittable_entities[pos].offset + splittable_entities[pos].length - part_end;
          splittable_entities[pos].offset = part_end;
        } else {
          result.entities.emplace_back(splittable_entities[pos].type, splittable_entities[pos].offset - skipped_length,
                                       splittable_entities[pos].length);
          pos++;
        }
      }
      if (pos == splittable_entities.size()) {
        splittable_entities.clear();
      } else {
        CHECK(pos == splittable_entities.size() - 1);
        LOG_CHECK(!text.empty()) << '""' << debug_initial_text << ""\"" "" << entities;
        splittable_entities[0] = std::move(splittable_entities.back());
        splittable_entities.resize(1);
      }
    }

    part_begin = part_end;
  };

  for (const auto &entity : entities) {
    if (is_splittable_entity(entity.type)) {
      auto index = get_splittable_entity_type_index(entity.type);
      part_splittable_entities[index].push_back(entity);
      continue;
    }
    CHECK(is_continuous_entity(entity.type));

    if (entity.offset > max_end) {
      // found a gap from max_end to entity.offset between predetermined entities
      add_part(entity.offset);
    } else {
      CHECK(entity.offset == max_end);
    }

    max_end = entity.offset + entity.length;
    part_entities.push_back(entity);
    part_entities.back().offset -= skipped_length;
  }
  add_part(part_begin + text_length(text));

  return result;
}

static vector<MessageEntity> find_splittable_entities_v3(Slice text, const vector<MessageEntity> &entities) {
  std::unordered_set<size_t> unallowed_boundaries;
  for (auto &entity : entities) {
    unallowed_boundaries.insert(entity.offset);
    unallowed_boundaries.insert(entity.offset + entity.length);
    if (entity.type == MessageEntity::Type::Mention || entity.type == MessageEntity::Type::Hashtag ||
        entity.type == MessageEntity::Type::BotCommand || entity.type == MessageEntity::Type::Cashtag ||
        entity.type == MessageEntity::Type::PhoneNumber || entity.type == MessageEntity::Type::BankCardNumber) {
      for (int32 i = 1; i < entity.length; i++) {
        unallowed_boundaries.insert(entity.offset + i);
      }
    }
  }

  auto found_entities = find_entities(text, false, true);
  td::remove_if(found_entities, [](const auto &entity) {
    return entity.type == MessageEntity::Type::EmailAddress || entity.type == MessageEntity::Type::Url;
  });
  for (auto &entity : found_entities) {
    for (int32 i = 0; i <= entity.length; i++) {
      unallowed_boundaries.insert(entity.offset + i);
    }
  }

  vector<MessageEntity> result;
  int32 splittable_entity_offset[SPLITTABLE_ENTITY_TYPE_COUNT] = {};
  int32 utf16_offset = 0;
  for (size_t i = 0; i + 1 < text.size(); i++) {
    auto c = static_cast<unsigned char>(text[i]);
    if (is_utf8_character_first_code_unit(c)) {
      utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
    }
    if ((c == '_' || c == '*' || c == '~') && text[i] == text[i + 1] && unallowed_boundaries.count(utf16_offset) == 0) {
      auto j = i + 2;
      while (j != text.size() && text[j] == text[i] && unallowed_boundaries.count(utf16_offset + j - i - 1) == 0) {
        j++;
      }
      if (j == i + 2) {
        auto type = c == '_' ? MessageEntity::Type::Italic
                             : (c == '*' ? MessageEntity::Type::Bold : MessageEntity::Type::Strikethrough);
        auto index = get_splittable_entity_type_index(type);
        if (splittable_entity_offset[index] != 0) {
          auto length = utf16_offset - splittable_entity_offset[index] - 1;
          if (length > 0) {
            result.emplace_back(type, splittable_entity_offset[index], length);
          }
          splittable_entity_offset[index] = 0;
        } else {
          splittable_entity_offset[index] = utf16_offset + 1;
        }
      }
      utf16_offset += narrow_cast<int32>(j - i - 1);
      i = j - 1;
    }
  }
  return result;
}

// entities must be valid and can contain only splittable and continuous entities
// __italic__ ~~strikethrough~~ **bold** and [text_url](telegram.org) entities are left to be parsed
static FormattedText parse_markdown_v3_without_pre(Slice text, vector<MessageEntity> entities) {
  check_is_sorted(entities);

  FormattedText parsed_text_url_text;
  if (text.find('[') != string::npos) {
    parsed_text_url_text = parse_text_url_entities_v3(text, entities);
    text = parsed_text_url_text.text;
    entities = std::move(parsed_text_url_text.entities);
  }
  // splittable entities are sorted only within a fixed type now

  bool have_splittable_entities = false;
  for (size_t i = 0; i + 1 < text.size(); i++) {
    if ((text[i] == '_' || text[i] == '*' || text[i] == '~') && text[i] == text[i + 1]) {
      have_splittable_entities = true;
      break;
    }
  }
  if (!have_splittable_entities) {
    // fast path
    sort_entities(entities);
    return {text.str(), std::move(entities)};
  }

  auto found_splittable_entities = find_splittable_entities_v3(text, entities);
  vector<int32> removed_pos;
  for (auto &entity : found_splittable_entities) {
    removed_pos.push_back(entity.offset - 1);
    removed_pos.push_back(entity.offset + entity.length + 1);
  }
  std::sort(removed_pos.begin(), removed_pos.end());

  string  [MASK] ;
  CHECK(text.size() >= 2 * removed_pos.size());
   [MASK] .reserve(text.size() - 2 * removed_pos.size());
  size_t j = 0;
  int32 utf16_offset = 0;
  for (size_t i = 0; i < text.size(); i++) {
    auto c = static_cast<unsigned char>(text[i]);
    if (is_utf8_character_first_code_unit(c)) {
      utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
    }
    if (j < removed_pos.size() && utf16_offset == removed_pos[j]) {
      i++;
      utf16_offset++;
      CHECK(j + 1 == removed_pos.size() || removed_pos[j + 1] >= removed_pos[j] + 2);
      j++;
    } else {
       [MASK]  += text[i];
    }
  }
  CHECK(j == removed_pos.size());
  combine(entities, std::move(found_splittable_entities));
  for (auto &entity : entities) {
    auto removed_before_begin = narrow_cast<int32>(
        std::upper_bound(removed_pos.begin(), removed_pos.end(), entity.offset) - removed_pos.begin());
    auto removed_before_end = narrow_cast<int32>(
        std::upper_bound(removed_pos.begin(), removed_pos.end(), entity.offset + entity.length) - removed_pos.begin());
    entity.length -= 2 * (removed_before_end - removed_before_begin);
    entity.offset -= 2 * removed_before_begin;
    CHECK(entity.offset >= 0);
    CHECK(entity.length >= 0);
    CHECK(entity.offset + entity.length <= utf16_offset);
  }

  td::remove_if(entities, [](const auto &entity) { return entity.length == 0; });

  sort_entities(entities);
  return {std::move( [MASK] ), std::move(entities)};
}

static FormattedText parse_pre_entities_v3(Slice text) {
  string result;
  vector<MessageEntity> entities;
  size_t size = text.size();
  int32 utf16_offset = 0;
  for (size_t i = 0; i < size; i++) {
    auto c = static_cast<unsigned char>(text[i]);
    if (c != '`') {
      if (is_utf8_character_first_code_unit(c)) {
        utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
      }
      result.push_back(text[i]);
      continue;
    }

    size_t j = i + 1;
    while (j < size && text[j] == '`') {
      j++;
    }

    if (j - i == 1 || j - i == 3) {
      // trying to find end of the entity
      int32 entity_length = 0;
      bool is_found = false;
      for (size_t end_tag_begin = j; end_tag_begin < size; end_tag_begin++) {
        auto cur_c = static_cast<unsigned char>(text[end_tag_begin]);
        if (cur_c == '`') {
          // possible end tag
          size_t end_tag_end = end_tag_begin + 1;
          while (end_tag_end < size && text[end_tag_end] == '`') {
            end_tag_end++;
          }
          if (end_tag_end - end_tag_begin == j - i) {
            // end tag found
            CHECK(entity_length > 0);
            entities.emplace_back(j - i == 3 ? MessageEntity::Type::Pre : MessageEntity::Type::Code, utf16_offset,
                                  entity_length);
            result.append(text.begin() + j, end_tag_begin - j);
            utf16_offset += entity_length;
            i = end_tag_end - 1;
            is_found = true;
            break;
          } else {
            // not an end tag, skip
            entity_length += narrow_cast<int32>(end_tag_end - end_tag_begin);
            end_tag_begin = end_tag_end - 1;
          }
        } else if (is_utf8_character_first_code_unit(cur_c)) {
          entity_length += 1 + (cur_c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
        }
      }
      if (is_found) {
        continue;
      }
    }

    result.append(text.begin() + i, j - i);
    utf16_offset += narrow_cast<int32>(j - i);
    i = j - 1;
  }
  return {std::move(result), std::move(entities)};
}

// entities must be valid for the text
static FormattedText parse_pre_entities_v3(Slice text, vector<MessageEntity> entities) {
  // nothing can intersect pre entities, so ignore all '`' inside the predetermined entities
  // and try to find new pre entities only between the predetermined entities

  FormattedText result;
  int32 result_text_utf16_length = 0;
  int32 part_begin = 0;
  int32 max_end = 0;
  int32 skipped_length = 0;

  auto add_part = [&](int32 part_end) {
    // we have [part_begin, max_end) kept part and [max_end, part_end) part to parse pre entities
    CHECK(part_begin == result_text_utf16_length + skipped_length);

    if (max_end != part_begin) {
      // add the kept part
      auto kept_part_text = utf8_utf16_substr(text, 0, max_end - part_begin);
      text = text.substr(kept_part_text.size());

      result.text.append(kept_part_text.begin(), kept_part_text.size());
      result_text_utf16_length += max_end - part_begin;
    }

    if (part_end != max_end) {
      // try to find pre entities in the left part
      auto parsed_part_text = utf8_utf16_substr(text, 0, part_end - max_end);
      text = text.substr(parsed_part_text.size());

      if (parsed_part_text.find('`') == string::npos) {
        // fast path, no pre entities; just append the text
        result.text.append(parsed_part_text.begin(), parsed_part_text.size());
        result_text_utf16_length += part_end - max_end;
      } else {
        FormattedText parsed_text = parse_pre_entities_v3(parsed_part_text);
        int32 new_skipped_length = 0;
        for (auto &entity : parsed_text.entities) {
          new_skipped_length += (entity.type == MessageEntity::Type::Pre ? 6 : 2);
        }
        CHECK(new_skipped_length < part_end - max_end);
        result.text += parsed_text.text;
        for (auto &entity : parsed_text.entities) {
          entity.offset += result_text_utf16_length;
        }
        append(result.entities, std::move(parsed_text.entities));
        result_text_utf16_length += part_end - max_end - new_skipped_length;
        skipped_length += new_skipped_length;
      }
    }

    part_begin = part_end;
  };

  for (auto &entity : entities) {
    if (entity.offset > max_end) {
      // found a gap from max_end to entity.offset between predetermined entities
      add_part(entity.offset);
    }

    max_end = td::max(max_end, entity.offset + entity.length);
    result.entities.push_back(std::move(entity));
    result.entities.back().offset -= skipped_length;
  }
  add_part(part_begin + text_length(text));

  return result;
}

// text entities must be valid
// returned entities must be resplitted and fixed
FormattedText parse_markdown_v3(FormattedText text) {
  if (text.text.find('`') != string::npos) {
    text = parse_pre_entities_v3(text.text, std::move(text.entities));
    check_is_sorted(text.entities);
  }

  bool have_pre = false;
  for (auto &entity : text.entities) {
    if (is_pre_entity(entity.type)) {
      have_pre = true;
      break;
    }
  }
  if (!have_pre) {
    // fast path
    return parse_markdown_v3_without_pre(text.text, std::move(text.entities));
  }

  FormattedText result;
  int32 result_text_utf16_length = 0;
  vector<MessageEntity> part_entities;
  int32 part_begin = 0;
  int32 max_end = 0;
  Slice left_text = text.text;

  auto add_part = [&](int32 part_end) {
    auto part_text = utf8_utf16_substr(left_text, 0, part_end - part_begin);
    left_text = left_text.substr(part_text.size());

    FormattedText part = parse_markdown_v3_without_pre(part_text, std::move(part_entities));
    part_entities.clear();

    result.text += part.text;
    for (auto &entity : part.entities) {
      entity.offset += result_text_utf16_length;
    }
    append(result.entities, std::move(part.entities));
    result_text_utf16_length += text_length(part.text);
    part_begin = part_end;
  };

  for (size_t i = 0; i < text.entities.size(); i++) {
    auto &entity = text.entities[i];
    CHECK(is_splittable_entity(entity.type) || is_pre_entity(entity.type) || is_continuous_entity(entity.type));
    if (is_pre_entity(entity.type)) {
      CHECK(entity.offset >= max_end);
      CHECK(i + 1 == text.entities.size() || text.entities[i + 1].offset >= entity.offset + entity.length);

      add_part(entity.offset);

      auto part_text = utf8_utf16_substr(left_text, 0, entity.length);
      left_text = left_text.substr(part_text.size());

      result.text.append(part_text.begin(), part_text.size());
      result.entities.push_back(entity);
      result.entities.back().offset = result_text_utf16_length;
      result_text_utf16_length += entity.length;
      part_begin = entity.offset + entity.length;
    } else {
      part_entities.push_back(entity);
      part_entities.back().offset -= part_begin;
    }

    max_end = td::max(max_end, entity.offset + entity.length);
  }
  add_part(part_begin + text_length(left_text));

  return result;
}

// text entities must be valid
FormattedText get_markdown_v3(FormattedText text) {
  if (text.entities.empty()) {
    return text;
  }

  check_is_sorted(text.entities);
  for (auto &entity : text.entities) {
    if (!is_user_entity(entity.type)) {
      return text;
    }
  }

  FormattedText result;
  struct EntityInfo {
    const MessageEntity *entity;
    int32 utf16_added_before;

    EntityInfo(MessageEntity *entity, int32 utf16_added_before)
        : entity(entity), utf16_added_before(utf16_added_before) {
    }
  };
  vector<EntityInfo> nested_entities_stack;
  size_t current_entity = 0;

  int32 utf16_offset = 0;
  int32 utf16_added = 0;

  for (size_t pos = 0; pos <= text.text.size(); pos++) {
    auto c = static_cast<unsigned char>(text.text[pos]);
    if (is_utf8_character_first_code_unit(c)) {
      while (!nested_entities_stack.empty()) {
        const auto *entity = nested_entities_stack.back().entity;
        auto entity_end = entity->offset + entity->length;
        if (utf16_offset < entity_end) {
          break;
        }

        CHECK(utf16_offset == entity_end);

        switch (entity->type) {
          case MessageEntity::Type::Italic:
            result.text += ""__"";
            utf16_added += 2;
            break;
          case MessageEntity::Type::Bold:
            result.text += ""**"";
            utf16_added += 2;
            break;
          case MessageEntity::Type::Strikethrough:
            result.text += ""~~"";
            utf16_added += 2;
            break;
          case MessageEntity::Type::TextUrl:
            result.text += ""]("";
            result.text += entity->argument;
            result.text += ')';
            utf16_added += narrow_cast<int32>(3 + entity->argument.size());
            break;
          case MessageEntity::Type::Code:
            result.text += '`';
            utf16_added++;
            break;
          case MessageEntity::Type::Pre:
            result.text += ""```"";
            utf16_added += 3;
            break;
          default:
            result.entities.push_back(*entity);
            result.entities.back().offset += nested_entities_stack.back().utf16_added_before;
            result.entities.back().length += utf16_added - nested_entities_stack.back().utf16_added_before;
            break;
        }
        nested_entities_stack.pop_back();
      }

      while (current_entity < text.entities.size() && utf16_offset >= text.entities[current_entity].offset) {
        CHECK(utf16_offset == text.entities[current_entity].offset);
        switch (text.entities[current_entity].type) {
          case MessageEntity::Type::Italic:
            result.text += ""__"";
            utf16_added += 2;
            break;
          case MessageEntity::Type::Bold:
            result.text += ""**"";
            utf16_added += 2;
            break;
          case MessageEntity::Type::Strikethrough:
            result.text += ""~~"";
            utf16_added += 2;
            break;
          case MessageEntity::Type::TextUrl:
            result.text += '[';
            utf16_added++;
            break;
          case MessageEntity::Type::Code:
            result.text += '`';
            utf16_added++;
            break;
          case MessageEntity::Type::Pre:
            result.text += ""```"";
            utf16_added += 3;
            break;
          default:
            // keep as is
            break;
        }
        nested_entities_stack.emplace_back(&text.entities[current_entity++], utf16_added);
      }
      utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
    }
    if (pos == text.text.size()) {
      break;
    }

    result.text.push_back(text.text[pos]);
  }

  sort_entities(result.entities);
  if (parse_markdown_v3(result) != text) {
    return text;
  }
  return result;
}

static uint32 decode_html_entity(CSlice text, size_t &pos) {
  auto c = static_cast<unsigned char>(text[pos]);
  if (c != '&') {
    return 0;
  }

  size_t end_pos = pos + 1;
  uint32 res = 0;
  if (text[pos + 1] == '#') {
    // numeric character reference
    end_pos++;
    if (text[pos + 2] == 'x') {
      // hexadecimal numeric character reference
      end_pos++;
      while (is_hex_digit(text[end_pos])) {
        res = res * 16 + hex_to_int(text[end_pos++]);
      }
    } else {
      // decimal numeric character reference
      while (is_digit(text[end_pos])) {
        res = res * 10 + text[end_pos++] - '0';
      }
    }
    if (res == 0 || res >= 0x10ffff || end_pos - pos >= 10) {
      return 0;
    }
  } else {
    while (is_alpha(text[end_pos])) {
      end_pos++;
    }
    Slice entity = text.substr(pos + 1, end_pos - pos - 1);
    if (entity == Slice(""lt"")) {
      res = static_cast<uint32>('<');
    } else if (entity == Slice(""gt"")) {
      res = static_cast<uint32>('>');
    } else if (entity == Slice(""amp"")) {
      res = static_cast<uint32>('&');
    } else if (entity == Slice(""quot"")) {
      res = static_cast<uint32>('""');
    } else {
      // unsupported literal entity
      return 0;
    }
  }

  if (text[end_pos] == ';') {
    pos = end_pos + 1;
  } else {
    pos = end_pos;
  }
  return res;
}

static Result<vector<MessageEntity>> do_parse_html(CSlice text, string &result) {
  vector<MessageEntity> entities;
  int32 utf16_offset = 0;

  struct EntityInfo {
    string tag_name;
    string argument;
    int32 entity_offset;
    size_t entity_begin_pos;

    EntityInfo(string tag_name, string argument, int32 entity_offset, size_t entity_begin_pos)
        : tag_name(std::move(tag_name))
        , argument(std::move(argument))
        , entity_offset(entity_offset)
        , entity_begin_pos(entity_begin_pos) {
    }
  };
  std::vector<EntityInfo> nested_entities;

  for (size_t i = 0; i < text.size(); i++) {
    auto c = static_cast<unsigned char>(text[i]);
    if (c == '&') {
      auto ch = decode_html_entity(text, i);
      if (ch != 0) {
        i--;  // i will be incremented in for
        utf16_offset += 1 + (ch > 0xffff);
        append_utf8_character(result, ch);
        continue;
      }
    }
    if (c != '<') {
      if (is_utf8_character_first_code_unit(c)) {
        utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
      }
      result.push_back(text[i]);
      continue;
    }

    auto begin_pos = i++;
    if (text[i] != '/') {
      // begin of an entity
      while (!is_space(text[i]) && text[i] != '>') {
        i++;
      }
      if (text[i] == 0) {
        return Status::Error(400, PSLICE() << ""Unclosed start tag at byte offset "" << begin_pos);
      }

      string tag_name = to_lower(text.substr(begin_pos + 1, i - begin_pos - 1));
      if (tag_name != ""a"" && tag_name != ""b"" && tag_name != ""strong"" && tag_name != ""i"" && tag_name != ""em"" &&
          tag_name != ""s"" && tag_name != ""strike"" && tag_name != ""del"" && tag_name != ""u"" && tag_name != ""ins"" &&
          tag_name != ""pre"" && tag_name != ""code"") {
        return Status::Error(400, PSLICE()
                                      << ""Unsupported start tag \"""" << tag_name << ""\"" at byte offset "" << begin_pos);
      }

      string argument;
      while (text[i] != '>') {
        while (text[i] != 0 && is_space(text[i])) {
          i++;
        }
        if (text[i] == '>') {
          break;
        }
        auto attribute_begin_pos = i;
        while (!is_space(text[i]) && text[i] != '=') {
          i++;
        }
        Slice attribute_name = text.substr(attribute_begin_pos, i - attribute_begin_pos);
        if (attribute_name.empty()) {
          return Status::Error(
              400, PSLICE() << ""Empty attribute name in the tag \"""" << tag_name << ""\"" at byte offset "" << begin_pos);
        }
        while (text[i] != 0 && is_space(text[i])) {
          i++;
        }
        if (text[i] != '=') {
          return Status::Error(400, PSLICE() << ""Expected equal sign in declaration of an attribute of the tag \""""
                                             << tag_name << ""\"" at byte offset "" << begin_pos);
        }
        i++;
        while (text[i] != 0 && is_space(text[i])) {
          i++;
        }
        if (text[i] == 0) {
          return Status::Error(400, PSLICE()
                                        << ""Unclosed start tag \"""" << tag_name << ""\"" at byte offset "" << begin_pos);
        }

        string attribute_value;
        if (text[i] != '\'' && text[i] != '""') {
          // A name token (a sequence of letters, digits, periods, or hyphens). Name tokens are not case sensitive.
          auto token_begin_pos = i;
          while (is_alnum(text[i]) || text[i] == '.' || text[i] == '-') {
            i++;
          }
          attribute_value = to_lower(text.substr(token_begin_pos, i - token_begin_pos));

          if (!is_space(text[i]) && text[i] != '>') {
            return Status::Error(400, PSLICE() << ""Unexpected end of name token at byte offset "" << token_begin_pos);
          }
        } else {
          // A string literal
          char end_character = text[i++];
          while (text[i] != end_character && text[i] != 0) {
            if (text[i] == '&') {
              auto ch = decode_html_entity(text, i);
              if (ch != 0) {
                append_utf8_character(attribute_value, ch);
                continue;
              }
            }
            attribute_value.push_back(text[i++]);
          }
          if (text[i] == end_character) {
            i++;
          }
        }
        if (text[i] == 0) {
          return Status::Error(400, PSLICE() << ""Unclosed start tag at byte offset "" << begin_pos);
        }

        if (tag_name == ""a"" && attribute_name == Slice(""href"")) {
          argument = std::move(attribute_value);
        } else if (tag_name == ""code"" && attribute_name == Slice(""class"") &&
                   begins_with(attribute_value, ""language-"")) {
          argument = attribute_value.substr(9);
        }
      }

      nested_entities.emplace_back(std::move(tag_name), std::move(argument), utf16_offset, result.size());
    } else {
      // end of an entity
      if (nested_entities.empty()) {
        return Status::Error(400, PSLICE() << ""Unexpected end tag at byte offset "" << begin_pos);
      }

      while (!is_space(text[i]) && text[i] != '>') {
        i++;
      }
      string end_tag_name = to_lower(text.substr(begin_pos + 2, i - begin_pos - 2));
      while (is_space(text[i]) && text[i] != 0) {
        i++;
      }
      if (text[i] != '>') {
        return Status::Error(400, PSLICE() << ""Unclosed end tag at byte offset "" << begin_pos);
      }

      string tag_name = std::move(nested_entities.back().tag_name);
      if (!end_tag_name.empty() && end_tag_name != tag_name) {
        return Status::Error(400, PSLICE() << ""Unmatched end tag at byte offset "" << begin_pos << "", expected \""</""
                                           << tag_name << "">\"", found \""</"" << end_tag_name << "">\"""");
      }

      if (utf16_offset > nested_entities.back().entity_offset) {
        auto entity_offset = nested_entities.back().entity_offset;
        auto entity_length = utf16_offset - entity_offset;
        if (tag_name == ""i"" || tag_name == ""em"") {
          entities.emplace_back(MessageEntity::Type::Italic, entity_offset, entity_length);
        } else if (tag_name == ""b"" || tag_name == ""strong"") {
          entities.emplace_back(MessageEntity::Type::Bold, entity_offset, entity_length);
        } else if (tag_name == ""s"" || tag_name == ""strike"" || tag_name == ""del"") {
          entities.emplace_back(MessageEntity::Type::Strikethrough, entity_offset, entity_length);
        } else if (tag_name == ""u"" || tag_name == ""ins"") {
          entities.emplace_back(MessageEntity::Type::Underline, entity_offset, entity_length);
        } else if (tag_name == ""a"") {
          auto url = std::move(nested_entities.back().argument);
          if (url.empty()) {
            url = result.substr(nested_entities.back().entity_begin_pos);
          }
          auto user_id = get_link_user_id(url);
          if (user_id.is_valid()) {
            entities.emplace_back(entity_offset, entity_length, user_id);
          } else {
            auto r_url = LinkManager::check_link(url);
            if (r_url.is_ok()) {
              entities.emplace_back(MessageEntity::Type::TextUrl, entity_offset, entity_length, r_url.move_as_ok());
            }
          }
        } else if (tag_name == ""pre"") {
          if (!entities.empty() && entities.back().type == MessageEntity::Type::Code &&
              entities.back().offset == entity_offset && entities.back().length == entity_length &&
              !entities.back().argument.empty()) {
            entities.back().type = MessageEntity::Type::PreCode;
          } else {
            entities.emplace_back(MessageEntity::Type::Pre, entity_offset, entity_length);
          }
        } else if (tag_name == ""code"") {
          if (!entities.empty() && entities.back().type == MessageEntity::Type::Pre &&
              entities.back().offset == entity_offset && entities.back().length == entity_length &&
              !nested_entities.back().argument.empty()) {
            entities.back().type = MessageEntity::Type::PreCode;
            entities.back().argument = std::move(nested_entities.back().argument);
          } else {
            entities.emplace_back(MessageEntity::Type::Code, entity_offset, entity_length,
                                  nested_entities.back().argument);
          }
        } else {
          UNREACHABLE();
        }
      }
      nested_entities.pop_back();
    }
  }
  if (!nested_entities.empty()) {
    return Status::Error(
        400, PSLICE() << ""Can't find end tag corresponding to start tag "" << nested_entities.back().tag_name);
  }

  for (auto &entity : entities) {
    if (entity.type == MessageEntity::Type::Code && !entity.argument.empty()) {
      entity.argument.clear();
    }
  }

  sort_entities(entities);

  return entities;
}

Result<vector<MessageEntity>> parse_html(string &text) {
  string result;
  TRY_RESULT(entities, do_parse_html(text, result));
  if (!check_utf8(result)) {
    return Status::Error(400,
                         ""Text contains invalid Unicode characters after decoding HTML entities, check for unmatched ""
                         ""surrogate code units"");
  }
  text = result;
  return entities;
}

vector<tl_object_ptr<secret_api::MessageEntity>> get_input_secret_message_entities(
    const vector<MessageEntity> &entities, int32 layer) {
  vector<tl_object_ptr<secret_api::MessageEntity>> result;
  for (auto &entity : entities) {
    switch (entity.type) {
      case MessageEntity::Type::Mention:
        result.push_back(make_tl_object<secret_api::messageEntityMention>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Hashtag:
        result.push_back(make_tl_object<secret_api::messageEntityHashtag>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Cashtag:
        break;
      case MessageEntity::Type::BotCommand:
        break;
      case MessageEntity::Type::PhoneNumber:
        break;
      case MessageEntity::Type::BankCardNumber:
        break;
      case MessageEntity::Type::Url:
        result.push_back(make_tl_object<secret_api::messageEntityUrl>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::EmailAddress:
        result.push_back(make_tl_object<secret_api::messageEntityEmail>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Bold:
        result.push_back(make_tl_object<secret_api::messageEntityBold>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Italic:
        result.push_back(make_tl_object<secret_api::messageEntityItalic>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Underline:
        if (layer >= static_cast<int32>(SecretChatLayer::NewEntities)) {
          result.push_back(make_tl_object<secret_api::messageEntityUnderline>(entity.offset, entity.length));
        }
        break;
      case MessageEntity::Type::Strikethrough:
        if (layer >= static_cast<int32>(SecretChatLayer::NewEntities)) {
          result.push_back(make_tl_object<secret_api::messageEntityStrike>(entity.offset, entity.length));
        }
        break;
      case MessageEntity::Type::BlockQuote:
        if (layer >= static_cast<int32>(SecretChatLayer::NewEntities)) {
          result.push_back(make_tl_object<secret_api::messageEntityBlockquote>(entity.offset, entity.length));
        }
        break;
      case MessageEntity::Type::Code:
        result.push_back(make_tl_object<secret_api::messageEntityCode>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Pre:
        result.push_back(make_tl_object<secret_api::messageEntityPre>(entity.offset, entity.length, string()));
        break;
      case MessageEntity::Type::PreCode:
        result.push_back(make_tl_object<secret_api::messageEntityPre>(entity.offset, entity.length, entity.argument));
        break;
      case MessageEntity::Type::TextUrl:
        result.push_back(
            make_tl_object<secret_api::messageEntityTextUrl>(entity.offset, entity.length, entity.argument));
        break;
      case MessageEntity::Type::MentionName:
        break;
      case MessageEntity::Type::MediaTimestamp:
        break;
      default:
        UNREACHABLE();
    }
  }

  return result;
}

Result<vector<MessageEntity>> get_message_entities(const ContactsManager *contacts_manager,
                                                   vector<tl_object_ptr<td_api::textEntity>> &&input_entities,
                                                   bool allow_all) {
  vector<MessageEntity> entities;
  entities.reserve(input_entities.size());
  for (auto &entity : input_entities) {
    if (entity == nullptr || entity->type_ == nullptr) {
      continue;
    }

    switch (entity->type_->get_id()) {
      case td_api::textEntityTypeMention::ID:
        entities.emplace_back(MessageEntity::Type::Mention, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeHashtag::ID:
        entities.emplace_back(MessageEntity::Type::Hashtag, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeBotCommand::ID:
        entities.emplace_back(MessageEntity::Type::BotCommand, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeUrl::ID:
        entities.emplace_back(MessageEntity::Type::Url, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeEmailAddress::ID:
        entities.emplace_back(MessageEntity::Type::EmailAddress, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeCashtag::ID:
        entities.emplace_back(MessageEntity::Type::Cashtag, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypePhoneNumber::ID:
        entities.emplace_back(MessageEntity::Type::PhoneNumber, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeBankCardNumber::ID:
        entities.emplace_back(MessageEntity::Type::BankCardNumber, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeBold::ID:
        entities.emplace_back(MessageEntity::Type::Bold, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeItalic::ID:
        entities.emplace_back(MessageEntity::Type::Italic, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeUnderline::ID:
        entities.emplace_back(MessageEntity::Type::Underline, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeStrikethrough::ID:
        entities.emplace_back(MessageEntity::Type::Strikethrough, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypeCode::ID:
        entities.emplace_back(MessageEntity::Type::Code, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypePre::ID:
        entities.emplace_back(MessageEntity::Type::Pre, entity->offset_, entity->length_);
        break;
      case td_api::textEntityTypePreCode::ID: {
        auto entity_pre_code = static_cast<td_api::textEntityTypePreCode *>(entity->type_.get());
        if (!clean_input_string(entity_pre_code->language_)) {
          return Status::Error(400, ""MessageEntityPreCode.language must be encoded in UTF-8"");
        }
        entities.emplace_back(MessageEntity::Type::PreCode, entity->offset_, entity->length_,
                              entity_pre_code->language_);
        break;
      }
      case td_api::textEntityTypeTextUrl::ID: {
        auto entity_text_url = static_cast<td_api::textEntityTypeTextUrl *>(entity->type_.get());
        if (!clean_input_string(entity_text_url->url_)) {
          return Status::Error(400, ""MessageEntityTextUrl.url must be encoded in UTF-8"");
        }
        auto r_url = LinkManager::check_link(entity_text_url->url_);
        if (r_url.is_error()) {
          return Status::Error(400, PSTRING() << ""Wrong message entity: "" << r_url.error().message());
        }
        entities.emplace_back(MessageEntity::Type::TextUrl, entity->offset_, entity->length_, r_url.move_as_ok());
        break;
      }
      case td_api::textEntityTypeMentionName::ID: {
        auto entity_mention_name = static_cast<td_api::textEntityTypeMentionName *>(entity->type_.get());
        UserId user_id(entity_mention_name->user_id_);
        if (contacts_manager != nullptr && !contacts_manager->have_input_user(user_id)) {
          return Status::Error(400, ""Have no access to the user"");
        }
        entities.emplace_back(entity->offset_, entity->length_, user_id);
        break;
      }
      case td_api::textEntityTypeMediaTimestamp::ID: {
        auto entity_media_timestamp = static_cast<td_api::textEntityTypeMediaTimestamp *>(entity->type_.get());
        if (entity_media_timestamp->media_timestamp_ < 0) {
          return Status::Error(400, ""Invalid media timestamp specified"");
        }
        entities.emplace_back(MessageEntity::Type::MediaTimestamp, entity->offset_, entity->length_,
                              entity_media_timestamp->media_timestamp_);
        break;
      }
      default:
        UNREACHABLE();
    }
    CHECK(!entities.empty());
    if (!allow_all && !is_user_entity(entities.back().type)) {
      entities.pop_back();
    }
  }
  return entities;
}

vector<MessageEntity> get_message_entities(const ContactsManager *contacts_manager,
                                           vector<tl_object_ptr<telegram_api::MessageEntity>> &&server_entities,
                                           const char *source) {
  vector<MessageEntity> entities;
  entities.reserve(server_entities.size());
  for (auto &entity : server_entities) {
    switch (entity->get_id()) {
      case telegram_api::messageEntityUnknown::ID:
        break;
      case telegram_api::messageEntityMention::ID: {
        auto entity_mention = static_cast<const telegram_api::messageEntityMention *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Mention, entity_mention->offset_, entity_mention->length_);
        break;
      }
      case telegram_api::messageEntityHashtag::ID: {
        auto entity_hashtag = static_cast<const telegram_api::messageEntityHashtag *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Hashtag, entity_hashtag->offset_, entity_hashtag->length_);
        break;
      }
      case telegram_api::messageEntityCashtag::ID: {
        auto entity_cashtag = static_cast<const telegram_api::messageEntityCashtag *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Cashtag, entity_cashtag->offset_, entity_cashtag->length_);
        break;
      }
      case telegram_api::messageEntityPhone::ID: {
        auto entity_phone = static_cast<const telegram_api::messageEntityPhone *>(entity.get());
        entities.emplace_back(MessageEntity::Type::PhoneNumber, entity_phone->offset_, entity_phone->length_);
        break;
      }
      case telegram_api::messageEntityBotCommand::ID: {
        auto entity_bot_command = static_cast<const telegram_api::messageEntityBotCommand *>(entity.get());
        entities.emplace_back(MessageEntity::Type::BotCommand, entity_bot_command->offset_,
                              entity_bot_command->length_);
        break;
      }
      case telegram_api::messageEntityBankCard::ID: {
        auto entity_bank_card = static_cast<const telegram_api::messageEntityBankCard *>(entity.get());
        entities.emplace_back(MessageEntity::Type::BankCardNumber, entity_bank_card->offset_,
                              entity_bank_card->length_);
        break;
      }
      case telegram_api::messageEntityUrl::ID: {
        auto entity_url = static_cast<const telegram_api::messageEntityUrl *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Url, entity_url->offset_, entity_url->length_);
        break;
      }
      case telegram_api::messageEntityEmail::ID: {
        auto entity_email = static_cast<const telegram_api::messageEntityEmail *>(entity.get());
        entities.emplace_back(MessageEntity::Type::EmailAddress, entity_email->offset_, entity_email->length_);
        break;
      }
      case telegram_api::messageEntityBold::ID: {
        auto entity_bold = static_cast<const telegram_api::messageEntityBold *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Bold, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case telegram_api::messageEntityItalic::ID: {
        auto entity_italic = static_cast<const telegram_api::messageEntityItalic *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Italic, entity_italic->offset_, entity_italic->length_);
        break;
      }
      case telegram_api::messageEntityUnderline::ID: {
        auto entity_bold = static_cast<const telegram_api::messageEntityUnderline *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Underline, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case telegram_api::messageEntityStrike::ID: {
        auto entity_bold = static_cast<const telegram_api::messageEntityStrike *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Strikethrough, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case telegram_api::messageEntityBlockquote::ID: {
        auto entity_bold = static_cast<const telegram_api::messageEntityBlockquote *>(entity.get());
        entities.emplace_back(MessageEntity::Type::BlockQuote, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case telegram_api::messageEntityCode::ID: {
        auto entity_code = static_cast<const telegram_api::messageEntityCode *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Code, entity_code->offset_, entity_code->length_);
        break;
      }
      case telegram_api::messageEntityPre::ID: {
        auto entity_pre = static_cast<telegram_api::messageEntityPre *>(entity.get());
        if (entity_pre->language_.empty()) {
          entities.emplace_back(MessageEntity::Type::Pre, entity_pre->offset_, entity_pre->length_);
        } else {
          entities.emplace_back(MessageEntity::Type::PreCode, entity_pre->offset_, entity_pre->length_,
                                std::move(entity_pre->language_));
        }
        break;
      }
      case telegram_api::messageEntityTextUrl::ID: {
        auto entity_text_url = static_cast<const telegram_api::messageEntityTextUrl *>(entity.get());
        auto r_url = LinkManager::check_link(entity_text_url->url_);
        if (r_url.is_error()) {
          LOG(ERROR) << ""Wrong URL entity: \"""" << entity_text_url->url_ << ""\"": "" << r_url.error().message() << "" from ""
                     << source;
          continue;
        }
        entities.emplace_back(MessageEntity::Type::TextUrl, entity_text_url->offset_, entity_text_url->length_,
                              r_url.move_as_ok());
        break;
      }
      case telegram_api::messageEntityMentionName::ID: {
        auto entity_mention_name = static_cast<const telegram_api::messageEntityMentionName *>(entity.get());
        UserId user_id(entity_mention_name->user_id_);
        if (!user_id.is_valid()) {
          LOG(ERROR) << ""Receive invalid "" << user_id << "" in MentionName from "" << source;
          continue;
        }
        if (contacts_manager == nullptr || !contacts_manager->have_user(user_id)) {
          LOG(ERROR) << ""Receive unknown "" << user_id << "" in MentionName from "" << source;
          continue;
        }
        if (!contacts_manager->have_input_user(user_id)) {
          LOG(ERROR) << ""Receive inaccessible "" << user_id << "" in MentionName from "" << source;
          continue;
        }
        entities.emplace_back(entity_mention_name->offset_, entity_mention_name->length_, user_id);
        break;
      }
      default:
        UNREACHABLE();
    }
  }
  return entities;
}

vector<MessageEntity> get_message_entities(vector<tl_object_ptr<secret_api::MessageEntity>> &&secret_entities) {
  vector<MessageEntity> entities;
  entities.reserve(secret_entities.size());
  for (auto &entity : secret_entities) {
    switch (entity->get_id()) {
      case secret_api::messageEntityUnknown::ID:
        break;
      case secret_api::messageEntityMention::ID:
        // skip, will find it ourselves
        break;
      case secret_api::messageEntityHashtag::ID:
        // skip, will find it ourselves
        break;
      case secret_api::messageEntityCashtag::ID:
        // skip, will find it ourselves
        break;
      case secret_api::messageEntityPhone::ID:
        // skip, will find it ourselves
        break;
      case secret_api::messageEntityBotCommand::ID:
        // skip all bot commands in secret chats
        break;
      case secret_api::messageEntityBankCard::ID:
        // skip, will find it ourselves
        break;
      case secret_api::messageEntityUrl::ID: {
        auto entity_url = static_cast<const secret_api::messageEntityUrl *>(entity.get());
        // TODO skip URL when find_urls will be better
        entities.emplace_back(MessageEntity::Type::Url, entity_url->offset_, entity_url->length_);
        break;
      }
      case secret_api::messageEntityEmail::ID: {
        auto entity_email = static_cast<const secret_api::messageEntityEmail *>(entity.get());
        // TODO skip emails when find_urls will be better
        entities.emplace_back(MessageEntity::Type::EmailAddress, entity_email->offset_, entity_email->length_);
        break;
      }
      case secret_api::messageEntityBold::ID: {
        auto entity_bold = static_cast<const secret_api::messageEntityBold *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Bold, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case secret_api::messageEntityItalic::ID: {
        auto entity_italic = static_cast<const secret_api::messageEntityItalic *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Italic, entity_italic->offset_, entity_italic->length_);
        break;
      }
      case secret_api::messageEntityUnderline::ID: {
        auto entity_bold = static_cast<const secret_api::messageEntityUnderline *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Underline, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case secret_api::messageEntityStrike::ID: {
        auto entity_bold = static_cast<const secret_api::messageEntityStrike *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Strikethrough, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case secret_api::messageEntityBlockquote::ID: {
        auto entity_bold = static_cast<const secret_api::messageEntityBlockquote *>(entity.get());
        entities.emplace_back(MessageEntity::Type::BlockQuote, entity_bold->offset_, entity_bold->length_);
        break;
      }
      case secret_api::messageEntityCode::ID: {
        auto entity_code = static_cast<const secret_api::messageEntityCode *>(entity.get());
        entities.emplace_back(MessageEntity::Type::Code, entity_code->offset_, entity_code->length_);
        break;
      }
      case secret_api::messageEntityPre::ID: {
        auto entity_pre = static_cast<secret_api::messageEntityPre *>(entity.get());
        if (!clean_input_string(entity_pre->language_)) {
          LOG(WARNING) << ""Wrong language in entity: \"""" << entity_pre->language_ << '""';
          entity_pre->language_.clear();
        }
        if (entity_pre->language_.empty()) {
          entities.emplace_back(MessageEntity::Type::Pre, entity_pre->offset_, entity_pre->length_);
        } else {
          entities.emplace_back(MessageEntity::Type::PreCode, entity_pre->offset_, entity_pre->length_,
                                std::move(entity_pre->language_));
        }
        break;
      }
      case secret_api::messageEntityTextUrl::ID: {
        auto entity_text_url = static_cast<secret_api::messageEntityTextUrl *>(entity.get());
        if (!clean_input_string(entity_text_url->url_)) {
          LOG(WARNING) << ""Wrong URL entity: \"""" << entity_text_url->url_ << '""';
          continue;
        }
        auto r_url = LinkManager::check_link(entity_text_url->url_);
        if (r_url.is_error()) {
          LOG(WARNING) << ""Wrong URL entity: \"""" << entity_text_url->url_ << ""\"": "" << r_url.error().message();
          continue;
        }
        entities.emplace_back(MessageEntity::Type::TextUrl, entity_text_url->offset_, entity_text_url->length_,
                              r_url.move_as_ok());
        break;
      }
      case secret_api::messageEntityMentionName::ID:
        // skip all name mentions in secret chats
        break;
      default:
        UNREACHABLE();
    }
  }
  return entities;
}

// like clean_input_string but also fixes entities
// entities must be sorted, can be nested, but must not intersect each other
static Result<string> clean_input_string_with_entities(const string &text, vector<MessageEntity> &entities) {
  check_is_sorted(entities);

  struct EntityInfo {
    MessageEntity *entity;
    int32 utf16_skipped_before;

    EntityInfo(MessageEntity *entity, int32 utf16_skipped_before)
        : entity(entity), utf16_skipped_before(utf16_skipped_before) {
    }
  };
  vector<EntityInfo> nested_entities_stack;
  size_t current_entity = 0;

  int32 utf16_offset = 0;
  int32 utf16_skipped = 0;

  size_t text_size = text.size();

  string result;
  result.reserve(text_size);
  for (size_t pos = 0; pos <= text_size; pos++) {
    auto c = static_cast<unsigned char>(text[pos]);
    bool is_utf8_character_begin = is_utf8_character_first_code_unit(c);
    if (is_utf8_character_begin) {
      while (!nested_entities_stack.empty()) {
        auto *entity = nested_entities_stack.back().entity;
        auto entity_end = entity->offset + entity->length;
        if (utf16_offset < entity_end) {
          break;
        }

        if (utf16_offset != entity_end) {
          CHECK(utf16_offset == entity_end + 1);
          return Status::Error(400, PSLICE() << ""Entity beginning at UTF-16 offset "" << entity->offset
                                             << "" ends in a middle of a UTF-16 symbol at byte offset "" << pos);
        }

        auto skipped_before_current_entity = nested_entities_stack.back().utf16_skipped_before;
        entity->offset -= skipped_before_current_entity;
        entity->length -= utf16_skipped - skipped_before_current_entity;
        nested_entities_stack.pop_back();
      }
      while (current_entity < entities.size() && utf16_offset >= entities[current_entity].offset) {
        if (utf16_offset != entities[current_entity].offset) {
          CHECK(utf16_offset == entities[current_entity].offset + 1);
          return Status::Error(400, PSLICE() << ""Entity begins in a middle of a UTF-16 symbol at byte offset "" << pos);
        }
        nested_entities_stack.emplace_back(&entities[current_entity++], utf16_skipped);
      }
    }
    if (pos == text_size) {
      break;
    }

    switch (c) {
      // remove control characters
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      // allow '\n'
      case 11:
      case 12:
      // ignore '\r'
      case 14:
      case 15:
      case 16:
      case 17:
      case 18:
      case 19:
      case 20:
      case 21:
      case 22:
      case 23:
      case 24:
      case 25:
      case 26:
      case 27:
      case 28:
      case 29:
      case 30:
      case 31:
      case 32:
        result.push_back(' ');
        utf16_offset++;
        break;
      case '\r':
        // skip
        utf16_offset++;
        utf16_skipped++;
        break;
      default:
        if (is_utf8_character_begin) {
          utf16_offset += 1 + (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
        }
        if (c == 0xe2 && pos + 2 < text_size) {
          unsigned char next = static_cast<unsigned char>(text[pos + 1]);
          if (next == 0x80) {
            next = static_cast<unsigned char>(text[pos + 2]);
            if (0xa8 <= next && next <= 0xae) {
              pos += 2;
              utf16_skipped++;
              break;
            }
          }
        }
        if (c == 0xcc && pos + 1 < text_size) {
          unsigned char next = static_cast<unsigned char>(text[pos + 1]);
          // remove vertical lines
          if (next == 0xb3 || next == 0xbf || next == 0x8a) {
            pos++;
            utf16_skipped++;
            break;
          }
        }

        result.push_back(text[pos]);
        break;
    }
  }

  if (current_entity != entities.size()) {
    return Status::Error(400, PSLICE() << ""Entity begins after the end of the text at UTF-16 offset ""
                                       << entities[current_entity].offset);
  }
  if (!nested_entities_stack.empty()) {
    auto *entity = nested_entities_stack.back().entity;
    return Status::Error(400, PSLICE() << ""Entity beginning at UTF-16 offset "" << entity->offset
                                       << "" ends after the end of the text at UTF-16 offset ""
                                       << entity->offset + entity->length);
  }

  replace_offending_characters(result);

  return result;
}

// removes entities containing whitespaces only
// entities must be sorted by offset and length, but not necessary by type
// returns {last_non_whitespace_pos, last_non_whitespace_utf16_offset}
static std::pair<size_t, int32> remove_invalid_entities(const string &text, vector<MessageEntity> &entities) {
  if (entities.empty()) {
    // fast path
    for (size_t pos = 0; pos < text.size(); pos++) {
      auto back_pos = text.size() - pos - 1;
      auto c = text[back_pos];
      if (c != '\n' && c != ' ') {
        return {back_pos, 0 /*unused*/};
      }
    }

    return {text.size(), -1};
  }

  // check_is_sorted(entities);
  vector<MessageEntity *> nested_entities_stack;
  size_t current_entity = 0;

  size_t last_non_whitespace_pos = text.size();

  int32 utf16_offset = 0;
  int32 last_non_whitespace_utf16_offset = -1;

  td::remove_if(entities, [](const auto &entity) { return entity.length == 0; });

  for (size_t pos = 0; pos <= text.size(); pos++) {
    while (!nested_entities_stack.empty()) {
      auto *entity = nested_entities_stack.back();
      auto entity_end = entity->offset + entity->length;
      if (utf16_offset < entity_end) {
        break;
      }

      if (last_non_whitespace_utf16_offset >= entity->offset || is_hidden_data_entity(entity->type)) {
        // keep entity
        // TODO check entity for validness, for example, that mentions, hashtags, cashtags and URLs are valid
      } else {
        entity->length = 0;
      }

      nested_entities_stack.pop_back();
    }
    while (current_entity < entities.size() && utf16_offset >= entities[current_entity].offset) {
      nested_entities_stack.push_back(&entities[current_entity++]);
    }

    if (pos == text.size()) {
      break;
    }

    if (!nested_entities_stack.empty() && nested_entities_stack.back()->offset == utf16_offset &&
        (text[pos] == '\n' || text[pos] == ' ')) {
      // entities was fixed, so there can't be more than one splittable entity of each type, one blockquote and
      // one continuous entity for the given offset
      for (size_t i = nested_entities_stack.size(); i > 0; i--) {
        auto *entity = nested_entities_stack[i - 1];
        if (entity->offset != utf16_offset || is_hidden_data_entity(entity->type)) {
          break;
        }
        entity->offset++;
        entity->length--;
        if (entity->length == 0) {
          CHECK(i == nested_entities_stack.size());
          nested_entities_stack.pop_back();
        }
      }
    }

    auto c = static_cast<unsigned char>(text[pos]);
    switch (c) {
      case '\n':
      case 32:
        break;
      default:
        while (!is_utf8_character_first_code_unit(static_cast<unsigned char>(text[pos + 1]))) {
          pos++;
        }
        utf16_offset += (c >= 0xf0);  // >= 4 bytes in symbol => surrogate pair
        last_non_whitespace_pos = pos;
        last_non_whitespace_utf16_offset = utf16_offset;
        break;
    }

    utf16_offset++;
  }
  CHECK(nested_entities_stack.empty());
  CHECK(current_entity == entities.size());

  td::remove_if(entities, [](const auto &entity) { return entity.length == 0; });

  return {last_non_whitespace_pos, last_non_whitespace_utf16_offset};
}

// enitities must contain only splittable entities
static void split_entities(vector<MessageEntity> &entities, const vector<MessageEntity> &other_entities) {
  check_is_sorted(entities);
  check_is_sorted(other_entities);

  int32 begin_pos[SPLITTABLE_ENTITY_TYPE_COUNT] = {};
  int32 end_pos[SPLITTABLE_ENTITY_TYPE_COUNT] = {};
  auto it = entities.begin();
  vector<MessageEntity> result;
  auto add_entities = [&](int32 end_offset) {
    auto flush_entities = [&](int32 offset) {
      for (auto type : {MessageEntity::Type::Bold, MessageEntity::Type::Italic, MessageEntity::Type::Underline,
                        MessageEntity::Type::Strikethrough}) {
        auto index = get_splittable_entity_type_index(type);
        if (end_pos[index] != 0 && begin_pos[index] < offset) {
          if (end_pos[index] <= offset) {
            result.emplace_back(type, begin_pos[index], end_pos[index] - begin_pos[index]);
            begin_pos[index] = 0;
            end_pos[index] = 0;
          } else {
            result.emplace_back(type, begin_pos[index], offset - begin_pos[index]);
            begin_pos[index] = offset;
          }
        }
      }
    };

    while (it != entities.end()) {
      if (it->offset >= end_offset) {
        break;
      }
      CHECK(is_splittable_entity(it->type));
      auto index = get_splittable_entity_type_index(it->type);
      if (it->offset <= end_pos[index] && end_pos[index] != 0) {
        if (it->offset + it->length > end_pos[index]) {
          end_pos[index] = it->offset + it->length;
        }
      } else {
        flush_entities(it->offset);
        begin_pos[index] = it->offset;
        end_pos[index] = it->offset + it->length;
      }
      ++it;
    }
    flush_entities(end_offset);
  };

  vector<const MessageEntity *> nested_entities_stack;
  auto add_offset = [&](int32 offset) {
    while (!nested_entities_stack.empty() &&
           offset >= nested_entities_stack.back()->offset + nested_entities_stack.back()->length) {
      // remove non-intersecting entities from the stack
      auto old_size = result.size();
      add_entities(nested_entities_stack.back()->offset + nested_entities_stack.back()->length);
      if (is_pre_entity(nested_entities_stack.back()->type)) {
        result.resize(old_size);
      }
      nested_entities_stack.pop_back();
    }

    add_entities(offset);
  };
  for (auto &other_entity : other_entities) {
    add_offset(other_entity.offset);
    nested_entities_stack.push_back(&other_entity);
  }
  add_offset(std::numeric_limits<int32>::max());

  entities = std::move(result);

  // entities are sorted only by offset now, re-sort if needed
  sort_entities(entities);
}

static vector<MessageEntity> resplit_entities(vector<MessageEntity> &&splittable_entities,
                                              vector<MessageEntity> &&entities) {
  if (!splittable_entities.empty()) {
    split_entities(splittable_entities, entities);  // can merge some entities

    if (entities.empty()) {
      return std::move(splittable_entities);
    }

    combine(entities, std::move(splittable_entities));
    sort_entities(entities);
  }
  return std::move(entities);
}

static void fix_entities(vector<MessageEntity> &entities) {
  sort_entities(entities);

  if (are_entities_valid(entities)) {
    // fast path
    return;
  }

  vector<MessageEntity> continuous_entities;
  vector<MessageEntity> blockquote_entities;
  vector<MessageEntity> splittable_entities;
  for (auto &entity : entities) {
    if (is_splittable_entity(entity.type)) {
      splittable_entities.push_back(std::move(entity));
    } else if (is_blockquote_entity(entity.type)) {
      blockquote_entities.push_back(std::move(entity));
    } else {
      continuous_entities.push_back(std::move(entity));
    }
  }
  remove_intersecting_entities(continuous_entities);  // continuous entities can't intersect each other

  if (!blockquote_entities.empty()) {
    remove_intersecting_entities(blockquote_entities);  // blockquote entities can't intersect each other

    // blockquote entities can contain continuous entities, but can't intersect them in the other ways
    remove_entities_intersecting_blockquote(continuous_entities, blockquote_entities);

    combine(continuous_entities, std::move(blockquote_entities));
    sort_entities(continuous_entities);
  }

  // must be called once to not merge some adjacent entities
  entities = resplit_entities(std::move(splittable_entities), std::move(continuous_entities));
  check_is_sorted(entities);
}

static void merge_new_entities(vector<MessageEntity> &entities, vector<MessageEntity> new_entities) {
  check_is_sorted(entities);
  if (new_entities.empty()) {
    // fast path
    return;
  }

  check_non_intersecting(new_entities);

  vector<MessageEntity> continuous_entities;
  vector<MessageEntity> blockquote_entities;
  vector<MessageEntity> splittable_entities;
  for (auto &entity : entities) {
    if (is_splittable_entity(entity.type)) {
      splittable_entities.push_back(std::move(entity));
    } else if (is_blockquote_entity(entity.type)) {
      blockquote_entities.push_back(std::move(entity));
    } else {
      continuous_entities.push_back(std::move(entity));
    }
  }

  remove_entities_intersecting_blockquote(new_entities, blockquote_entities);

  // merge before combining with blockquote entities
  continuous_entities = merge_entities(std::move(continuous_entities), std::move(new_entities));

  if (!blockquote_entities.empty()) {
    combine(continuous_entities, std::move(blockquote_entities));
    sort_entities(continuous_entities);
  }

  // must be called once to not merge some adjacent entities
  entities = resplit_entities(std::move(splittable_entities), std::move(continuous_entities));
  check_is_sorted(entities);
}

Status fix_formatted_text(string &text, vector<MessageEntity> &entities, bool allow_empty, bool skip_new_entities,
                          bool skip_bot_commands, bool skip_media_timestamps, bool for_draft) {
  string result;
  if (entities.empty()) {
    // fast path
    if (!clean_input_string(text)) {
      return Status::Error(400, ""Strings must be encoded in UTF-8"");
    }
    result = std::move(text);
  } else {
    if (!check_utf8(text)) {
      return Status::Error(400, ""Strings must be encoded in UTF-8"");
    }

    for (auto &entity : entities) {
      if (entity.offset < 0 || entity.offset > 1000000) {
        return Status::Error(400, PSLICE() << ""Receive an entity with incorrect offset "" << entity.offset);
      }
      if (entity.length < 0 || entity.length > 1000000) {
        return Status::Error(400, PSLICE() << ""Receive an entity with incorrect length "" << entity.length);
      }
    }
    td::remove_if(entities, [](const MessageEntity &entity) { return entity.length == 0; });

    fix_entities(entities);

    TRY_RESULT_ASSIGN(result, clean_input_string_with_entities(text, entities));
  }

  // now entities are still sorted by offset and length, but not type,
  // because some characters could be deleted and after that some entities begin to share a common end

  size_t last_non_whitespace_pos;
  int32 last_non_whitespace_utf16_offset;
  std::tie(last_non_whitespace_pos, last_non_whitespace_utf16_offset) = remove_invalid_entities(result, entities);
  if (last_non_whitespace_utf16_offset == -1) {
    if (allow_empty) {
      text.clear();
      entities.clear();
      return Status::OK();
    }
    return Status::Error(400, ""Message must be non-empty"");
  }

  // re-fix entities if needed after removal of some characters
  // the sort order can be incorrect by type
  // some splittable entities may be needed to be concatenated
  fix_entities(entities);

  if (for_draft) {
    text = std::move(result);
  } else {
    // rtrim
    CHECK(last_non_whitespace_pos < result.size());
    result.resize(last_non_whitespace_pos + 1);
    while (!entities.empty() && entities.back().offset > last_non_whitespace_utf16_offset) {
      CHECK(is_hidden_data_entity(entities.back().type));
      entities.pop_back();
    }
    bool need_sort = false;
    for (auto &entity : entities) {
      if (entity.offset + entity.length > last_non_whitespace_utf16_offset + 1) {
        entity.length = last_non_whitespace_utf16_offset + 1 - entity.offset;
        need_sort = true;
        CHECK(entity.length > 0);
      }
    }
    if (need_sort) {
      sort_entities(entities);
    }

    // ltrim
    size_t first_non_whitespaces_pos = 0;
    size_t first_entity_begin_pos = entities.empty() ? result.size() : entities[0].offset;
    while (first_non_whitespaces_pos < first_entity_begin_pos &&
           (result[first_non_whitespaces_pos] == ' ' || result[first_non_whitespaces_pos] == '\n')) {
      first_non_whitespaces_pos++;
    }
    if (first_non_whitespaces_pos > 0) {
      int32 offset = narrow_cast<int32>(first_non_whitespaces_pos);
      text = result.substr(first_non_whitespaces_pos);
      for (auto &entity : entities) {
        entity.offset -= offset;
        CHECK(entity.offset >= 0);
      }
    } else {
      text = std::move(result);
    }
  }
  LOG_CHECK(check_utf8(text)) << text;

  if (!allow_empty && is_empty_string(text)) {
    return Status::Error(400, ""Message must be non-empty"");
  }

  constexpr size_t LENGTH_LIMIT = 35000;  // server side limit
  if (text.size() > LENGTH_LIMIT) {
    size_t new_size = LENGTH_LIMIT;
    while (!is_utf8_character_first_code_unit(text[new_size])) {
      new_size--;
    }
    text.resize(new_size);

    td::remove_if(entities, [text_utf16_length = text_length(text)](const auto &entity) {
      return entity.offset + entity.length > text_utf16_length;
    });
  }

  if (!skip_new_entities) {
    merge_new_entities(entities, find_entities(text, skip_bot_commands, skip_media_timestamps));
  } else if (!skip_media_timestamps) {
    merge_new_entities(entities, find_media_timestamp_entities(text));
  }

  // new whitespace-only entities could be added after splitting of entities
  remove_invalid_entities(text, entities);

  // TODO MAX_MESSAGE_LENGTH and MAX_CAPTION_LENGTH

  return Status::OK();
}

FormattedText get_message_text(const ContactsManager *contacts_manager, string message_text,
                               vector<tl_object_ptr<telegram_api::MessageEntity>> &&server_entities,
                               bool skip_new_entities, bool skip_media_timestamps, int32 send_date, bool from_album,
                               const char *source) {
  auto entities = get_message_entities(contacts_manager, std::move(server_entities), source);
  auto debug_message_text = message_text;
  auto debug_entities = entities;
  auto status = fix_formatted_text(message_text, entities, true, skip_new_entities, true, skip_media_timestamps, false);
  if (status.is_error()) {
    // message entities in media albums can be wrong because of a long time ago fixed server-side bug
    if (!from_album && (send_date == 0 || send_date > 1600340000)) {  // approximate fix date
      LOG(ERROR) << ""Receive error "" << status << "" while parsing message text from "" << source << "" sent at ""
                 << send_date << "" with content \"""" << debug_message_text << ""\"" -> \"""" << message_text
                 << ""\"" with entities "" << format::as_array(debug_entities) << "" -> "" << format::as_array(entities);
    }
    if (!clean_input_string(message_text)) {
      message_text.clear();
    }
    entities = find_entities(message_text, false, skip_media_timestamps);
  }
  return FormattedText{std::move(message_text), std::move(entities)};
}

td_api::object_ptr<td_api::formattedText> extract_input_caption(
    tl_object_ptr<td_api::InputMessageContent> &input_message_content) {
  switch (input_message_content->get_id()) {
    case td_api::inputMessageAnimation::ID: {
      auto input_animation = static_cast<td_api::inputMessageAnimation *>(input_message_content.get());
      return std::move(input_animation->caption_);
    }
    case td_api::inputMessageAudio::ID: {
      auto input_audio = static_cast<td_api::inputMessageAudio *>(input_message_content.get());
      return std::move(input_audio->caption_);
    }
    case td_api::inputMessageDocument::ID: {
      auto input_document = static_cast<td_api::inputMessageDocument *>(input_message_content.get());
      return std::move(input_document->caption_);
    }
    case td_api::inputMessagePhoto::ID: {
      auto input_photo = static_cast<td_api::inputMessagePhoto *>(input_message_content.get());
      return std::move(input_photo->caption_);
    }
    case td_api::inputMessageVideo::ID: {
      auto input_video = static_cast<td_api::inputMessageVideo *>(input_message_content.get());
      return std::move(input_video->caption_);
    }
    case td_api::inputMessageVoiceNote::ID: {
      auto input_voice_note = static_cast<td_api::inputMessageVoiceNote *>(input_message_content.get());
      return std::move(input_voice_note->caption_);
    }
    default:
      return nullptr;
  }
}

Result<FormattedText> process_input_caption(const ContactsManager *contacts_manager, DialogId dialog_id,
                                            tl_object_ptr<td_api::formattedText> &&caption, bool is_bot) {
  if (caption == nullptr) {
    return FormattedText();
  }
  TRY_RESULT(entities, get_message_entities(contacts_manager, std::move(caption->entities_)));
  TRY_STATUS(fix_formatted_text(caption->text_, entities, true, false,
                                need_always_skip_bot_commands(contacts_manager, dialog_id, is_bot), is_bot, false));
  return FormattedText{std::move(caption->text_), std::move(entities)};
}

void add_formatted_text_dependencies(Dependencies &dependencies, const FormattedText *text) {
  if (text == nullptr) {
    return;
  }
  for (auto &entity : text->entities) {
    if (entity.user_id.is_valid()) {
      dependencies.user_ids.insert(entity.user_id);
    }
  }
}

bool has_media_timestamps(const FormattedText *text, int32 min_media_timestamp, int32 max_media_timestamp) {
  if (text == nullptr) {
    return false;
  }
  for (auto &entity : text->entities) {
    if (entity.type == MessageEntity::Type::MediaTimestamp && min_media_timestamp <= entity.media_timestamp &&
        entity.media_timestamp <= max_media_timestamp) {
      return true;
    }
  }
  return false;
}

bool has_bot_commands(const FormattedText *text) {
  if (text == nullptr) {
    return false;
  }
  for (auto &entity : text->entities) {
    if (entity.type == MessageEntity::Type::BotCommand) {
      return true;
    }
  }
  return false;
}

bool need_always_skip_bot_commands(const ContactsManager *contacts_manager, DialogId dialog_id, bool is_bot) {
  if (!dialog_id.is_valid()) {
    return true;
  }
  if (is_bot) {
    return false;
  }

  switch (dialog_id.get_type()) {
    case DialogType::User: {
      auto user_id = dialog_id.get_user_id();
      return user_id == ContactsManager::get_replies_bot_user_id() || !contacts_manager->is_user_bot(user_id);
    }
    case DialogType::SecretChat: {
      auto user_id = contacts_manager->get_secret_chat_user_id(dialog_id.get_secret_chat_id());
      return !user_id.is_valid() || !contacts_manager->is_user_bot(user_id);
    }
    case DialogType::Chat:
    case DialogType::Channel:
    case DialogType::None:
      return false;
    default:
      UNREACHABLE();
      return false;
  }
}

vector<tl_object_ptr<telegram_api::MessageEntity>> get_input_message_entities(const ContactsManager *contacts_manager,
                                                                              const vector<MessageEntity> &entities,
                                                                              const char *source) {
  vector<tl_object_ptr<telegram_api::MessageEntity>> result;
  vector<MessageEntity> splittable_entities;
  for (auto &entity : entities) {
    if (!is_user_entity(entity.type)) {
      continue;
    }
    if (is_splittable_entity(entity.type)) {
      splittable_entities.push_back(entity);
      continue;
    }
    switch (entity.type) {
      case MessageEntity::Type::BlockQuote:
        result.push_back(make_tl_object<telegram_api::messageEntityBlockquote>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Code:
        result.push_back(make_tl_object<telegram_api::messageEntityCode>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Pre:
        result.push_back(make_tl_object<telegram_api::messageEntityPre>(entity.offset, entity.length, string()));
        break;
      case MessageEntity::Type::PreCode:
        result.push_back(make_tl_object<telegram_api::messageEntityPre>(entity.offset, entity.length, entity.argument));
        break;
      case MessageEntity::Type::TextUrl:
        result.push_back(
            make_tl_object<telegram_api::messageEntityTextUrl>(entity.offset, entity.length, entity.argument));
        break;
      case MessageEntity::Type::MentionName: {
        auto input_user = contacts_manager->get_input_user(entity.user_id);
        LOG_CHECK(input_user != nullptr) << source;
        result.push_back(make_tl_object<telegram_api::inputMessageEntityMentionName>(entity.offset, entity.length,
                                                                                     std::move(input_user)));
        break;
      }
      default:
        UNREACHABLE();
    }
  }
  split_entities(splittable_entities, vector<MessageEntity>());
  for (auto &entity : splittable_entities) {
    switch (entity.type) {
      case MessageEntity::Type::Bold:
        result.push_back(make_tl_object<telegram_api::messageEntityBold>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Italic:
        result.push_back(make_tl_object<telegram_api::messageEntityItalic>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Underline:
        result.push_back(make_tl_object<telegram_api::messageEntityUnderline>(entity.offset, entity.length));
        break;
      case MessageEntity::Type::Strikethrough:
        result.push_back(make_tl_object<telegram_api::messageEntityStrike>(entity.offset, entity.length));
        break;
      default:
        UNREACHABLE();
    }
  }

  return result;
}

vector<tl_object_ptr<telegram_api::MessageEntity>> get_input_message_entities(const ContactsManager *contacts_manager,
                                                                              const FormattedText *text,
                                                                              const char *source) {
  if (text != nullptr && !text->entities.empty()) {
    return get_input_message_entities(contacts_manager, text->entities, source);
  }
  return {};
}

}  // namespace td
",new_text
554,"#ifndef DETECTOR_H
#define DETECTOR_H

#include <cmath>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
#include ""particle.h""

// Beginning of detector class
class detector
{
private:
  std::string detector_type; // ""tr"" for tracker, ""cr"" for calorimeter, ""mc"" for muon chamber
  bool status{false};
  int detected_particles{0};

public:
  // Default constructor
  detector() = default;

  // Parameterized constructor
  detector(std::string type, bool  [MASK] )
  {
    if (type != ""tr"" && type != ""cr"" && type != ""mc"")
    {
      throw std::invalid_argument(""Invalid detector type. Must be 'tr', 'cr', or 'mc', which stand for tracker (electrons and muons), calorimeter (electrons) and muon chamber (muons) respectively."");
    }
    detector_type = type;
    status =  [MASK] ;
  }

  // Destructor
  ~detector() {}

  // Getter methods
  std::string get_detector_type() const { return detector_type; }
  bool get_status() const { return status; }
  int get_detected_particles() const { return detected_particles; }

  // Setter methods
  void set_detector_type(const std::string& type)
  {
  if (type != ""tr"" && type != ""cr"" && type != ""mc"")
  {
    throw std::invalid_argument(""Invalid detector type. Must be 'tr', 'cr', or 'mc', which stand for tracker (electrons and muons), calorimeter (electrons) and muon chamber (muons) respectively."");
  }
  detector_type = type;
  }
  void set_status(bool s) { status = s; }
  void set_detected_particles(int count) { detected_particles = count; }

  // Method to print the status of the detector
  void print_status() const;

  // Method to detect a particle
  int detect_particle(const particle& p);
};



// Functionalities needed, in addition to constructor/destructor/setters/getters (see slides on BB):
// - write a function that takes a particle
//   and returns a bool and a print-out on whether this type of detector detected the particle
//   depending on the detector/particle combination (see slides on BB)
// - have data members that keep track of how many particles were detected by this particular
// detector,
//   and of which type
// - write a function (accessor) that prints how many particles passed through this detector

// End of detector class

#endif
",detector_status
555,"#include ""CyclicPolinomialRHashStorage.h""
#include ""InputInterface.h""
#include <iostream>

void CyclicPolinomialRHashStorage::addHash(HashGeneratorInterface* h) {
    CyclicPolinomialRHash* h2 = h->cyclicPolinomialRHash();
    signatureStorage_.emplace(h2->hashValue(), signatureStorage_.size());
}

bool CyclicPolinomialRHashStorage::readHash(InputInterface* input) {
    typename CyclicPolinomialRHash::HashValueType value;
    if(!input->get(value)) return false;
    signatureStorage_.emplace(value, signatureStorage_.size());
    return true;
}

size_t CyclicPolinomialRHashStorage::findHash(HashGeneratorInterface* inf) {
    CyclicPolinomialRHash* h = inf->cyclicPolinomialRHash();

    if(auto  [MASK]  = signatureStorage_.find(h->hashValue());  [MASK]  != signatureStorage_.end()) {
        return  [MASK] ->second;
    }
    return NOT_FOUND;
}
",pos
556,"#include <iostream>
#include <fstream>
#include ""alias.h""

using namespace std;

const char *filename = ""commands.json"";

string read_file(const char *name) {
    string line;
    string  [MASK] ;
    ifstream file(name);
    if (file.is_open()) {
        while (getline(file, line)) {
             [MASK]  += line;
        }
        file.close();
    }
    return  [MASK] ;
}

vector<fill::alias> read_json(const char *name) {
    auto l = read_file(name);
    if (l.length() > 0) {
        return json::parse(l);
    }
    return {};
}

void write_json(const char *name, const vector<fill::alias> *aliases) {
    ofstream file(name);
    json j = *aliases;
    file << setw(4) << j << endl;
}

void register_cmd(const char *cmd, const char *pattern) {
    auto aliases = read_json(filename);
    auto alias = fill::alias(cmd, pattern);
    aliases.push_back(alias);
    write_json(filename, &aliases);
}

int try_call(const char *cmd, const char *query) {
    auto aliases = read_json(filename);
    json j = aliases;
    for (auto &alias : aliases) {
        if (alias.name == cmd) {
            // TODO
            return 0;
        }
    }
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc > 3) {
        char *sub = argv[1];
        if (strcmp(sub, ""register"") == 0) {
            register_cmd(argv[2], argv[3]);
            return 0;
        }
    }

    if (argc > 2) {
        return try_call(argv[1], argv[2]);
    }

    return 1;
}
",lines
557,"#include <iostream>
#include <fstream>
#include <cmath>
#include <iomanip>
#include <list>
#include ""Rider.h""
#include ""Driver.h""

//By making a function to print out every drivers for output1, it saves a lot of space
void PrintForOutput1(std::list<Driver>& drivers, std::list<Driver>::iterator itrDriver, std::ofstream& out_str){
	itrDriver = drivers.begin();
	int listSize = drivers.size();
	for (int i=0; i<listSize; i++)
	{
	out_str << *itrDriver << std::endl;
	itrDriver++;
	}
}

//Similar to the above function, this one saves a lot of space
void PrintForOutput2(std::list<Rider>& riders, std::list<Rider>::iterator itrRider, std::ofstream& out_str){
	itrRider = riders.begin();
	int listSize = riders.size();
	for (int i=0; i<listSize; i++)
	{
	out_str << *itrRider << std::endl;
	itrRider++;
	}
}

//You need two different print out functions for REQUEST, CANCEL, and NO_DRIVERS, since the text is different.
void PrintForOutput0Request(std::list<Rider>& riders, std::list<Rider>::iterator& itrRider, std::string DriverFN, double Rating, double Distance, std::ofstream& out_str){
	Distance = Distance * 10;
	Distance = floor(Distance);
	Distance = Distance / 10;

	if (itrRider->getVehicle_Pref() == ""Economy"")
	{
	out_str << ""Ride requested for user "" << itrRider->getFirstName() << "", looking for an "" << itrRider->getVehicle_Pref() << "" vehicle."" << std::endl;
	out_str << ""Pick Up Location: "" << itrRider->getPickup_Location() << "", Drop Off Location: "" << itrRider->getDropoff_Location() << ""."" << std::endl;
	out_str << ""We have found the closest driver "" << DriverFN << ""("" << Rating << "") for you."" << std::endl;
	out_str << DriverFN << "" is now "" << Distance << "" miles away from you."" << std::endl;
	}
	else
	{
	out_str << ""Ride requested for user "" << itrRider->getFirstName() << "", looking for a "" << itrRider->getVehicle_Pref() << "" vehicle."" << std::endl;
	out_str << ""Pick Up Location: "" << itrRider->getPickup_Location() << "", Drop Off Location: "" << itrRider->getDropoff_Location() << ""."" << std::endl;
	out_str << ""We have found the closest driver "" << DriverFN << ""("" << Rating << "") for you."" << std::endl;
	out_str << DriverFN << "" is now "" << Distance << "" miles away from you."" << std::endl;
	}
	
}

void PrintForOutput0Cancel(std::list<Rider>& riders, std::list<Rider>::iterator& itrRider, std::string OGDriverFN, std::string DriverFN, double Rating, double Distance, std::ofstream& out_str){
	Distance = Distance * 10;
	Distance = floor(Distance);
	Distance = Distance / 10;

	if (itrRider->getVehicle_Pref() == ""Economy"")
	{
	out_str << ""Your driver "" << OGDriverFN << "" has cancelled the ride request. We will now find a new driver for you."" << std::endl;
	out_str << ""Ride requested for user "" << itrRider->getFirstName() << "", looking for an "" << itrRider->getVehicle_Pref() << "" vehicle."" << std::endl;
	out_str << ""Pick Up Location: "" << itrRider->getPickup_Location() << "", Drop Off Location: "" << itrRider->getDropoff_Location() << ""."" << std::endl;
	out_str << ""We have found the closest driver "" << DriverFN << ""("" << Rating << "") for you."" << std::endl;
	out_str << DriverFN << "" is now "" << Distance << "" miles away from you."" << std::endl;
	}
	else
	{
	out_str << ""Your driver "" << OGDriverFN << "" has cancelled the ride request. We will now find a new driver for you."" << std::endl;
	out_str << ""Ride requested for user "" << itrRider->getFirstName() << "", looking for a "" << itrRider->getVehicle_Pref() << "" vehicle."" << std::endl;
	out_str << ""Pick Up Location: "" << itrRider->getPickup_Location() << "", Drop Off Location: "" << itrRider->getDropoff_Location() << ""."" << std::endl;
	out_str << ""We have found the closest driver "" << DriverFN << ""("" << Rating << "") for you."" << std::endl;
	out_str << DriverFN << "" is now "" << Distance << "" miles away from you."" << std::endl;
	}
}

void PrintForOutput0NoDriver(std::list<Rider>& riders, std::list<Rider>::iterator& itrRider, std::ofstream& out_str){
	if (itrRider->getVehicle_Pref() == ""Economy"")
	{
	out_str << ""Ride request for user "" << itrRider->getFirstName() << "", looking for an "" << itrRider->getVehicle_Pref() << "" vehicle."" << std::endl;
	out_str << ""Pick Up Location: "" << itrRider->getPickup_Location() << "", Drop Off Location: "" << itrRider->getDropoff_Location() << "" ."" << std::endl;
	out_str << ""Sorry we can not find a driver for you at this moment."" << std::endl;
	}
	else
	{
	out_str << ""Ride request for user "" << itrRider->getFirstName() << "", looking for a "" << itrRider->getVehicle_Pref() << "" vehicle."" << std::endl;
	out_str << ""Pick Up Location: "" << itrRider->getPickup_Location() << "", Drop Off Location: "" << itrRider->getDropoff_Location() << "" ."" << std::endl;
	out_str << ""Sorry we can not find a driver for you at this moment."" << std::endl;	
	}
}

//Two simple function that quickly checks a rider's/phone-nummber existence and outputs each scenarios text.
bool CheckForRider(std::list<Rider>& riders, std::list<Rider>::iterator itrRider, std::string PhoneNum, std::ofstream& out_str){
	itrRider = riders.begin();
	int listSize = riders.size();
	for (int i=0; i<listSize; i++)
	{
		if (PhoneNum == itrRider->getPhoneNumber())
		{
			if (itrRider->getCurrentState() == ""Driver_on_the_way"")
			{
			out_str << ""You have already requested a ride and your driver is on the way to the pickup location."" << std::endl;
			exit(1);	
			}

			if (itrRider->getCurrentState() == ""During_the_trip"")
			{
			out_str << ""You can not request a ride at this moment as you are already on a trip."" << std::endl;	
			exit(1);
			}

			if (itrRider->getCurrentState() == ""Ready_to_request"")
			{
			return true;
			}

			out_str << ""Account does not exist."" << std::endl;	
			exit(1);
		}
	itrRider++;
	}
	out_str << ""Account does not exist."" << std::endl;	
	exit(1);
}

bool CheckForPhoneNumber(std::list<Rider>& riders, std::list<Rider>::iterator itrRider, std::list<Driver>& drivers, std::list<Driver>::iterator itrDriver, std::string PhoneNum, std::ofstream& out_str){
	itrRider = riders.begin();
	itrDriver = drivers.begin();
	int listsize = riders.size();

	for (int i=0; i<listsize; i++)
	{
		if (PhoneNum == itrRider->getPhoneNumber())
		{
			return true;
		}

		if (PhoneNum == itrDriver->getPhoneNumber())
		{
			return true;
		}
	itrRider++;
	itrDriver++;
	}
	out_str << ""Account does not exist."" << std::endl;	
	exit(1);
}

//The given function by the assignment
double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
    const double radiusOfEarth = 6371.0; // Earth's radius in kilometers

    // convert latitude and longitude from degrees to radians
    lat1 *= M_PI / 180.0;
    lon1 *= M_PI / 180.0;
    lat2 *= M_PI / 180.0;
    lon2 *= M_PI / 180.0;

    // Haversine formula
    double dLat = lat2 - lat1;
    double dLon = lon2 - lon1;
    double a = sin(dLat / 2.0) * sin(dLat / 2.0) + cos(lat1) * cos(lat2) * sin(dLon / 2.0) * sin(dLon / 2.0);
    double c = 2.0 * atan2(sqrt(a), sqrt(1.0 - a));
    // distance in kilometers
    double distanceKM = radiusOfEarth * c;
    // convert it to distance in miles
    double distanceMiles = distanceKM * 0.621371;

    return distanceMiles;
}

 // // // // // // // // // // // // // // // // // // 

 // MAIN

int main(int argc, char** argv){

	//INPUT FOR DRIVERS
	std::ifstream in_str1(argv[1]);

    if (!in_str1.good()) {
    std::cerr << ""Can't open "" << argv[1] << "" to read.\n"";
    exit(1);
    }

    //INPUT FOR RIDERS
	std::ifstream in_str2(argv[2]);

    if (!in_str2.good()) {
    std::cerr << ""Can't open "" << argv[2] << "" to read.\n"";
    exit(1);
    }

    //OUTPUT-0
    std::ofstream out_str0(argv[3]);

    //OUTPUT-1
    std::ofstream out_str1(argv[4]);

    //OUTPUT-2
    std::ofstream out_str2(argv[5]);

    //COMMAND
    std::string Command = argv[7];

    //CHECKING IF PHONE NUMBERS PROVIDED IS VALID 974-349-9468

    std::string PhoneNumString = argv[6];
    if (PhoneNumString.size() != 12)
    {
    out_str0 << ""Phone number is invalid."" << std::endl;
    exit(1);
    }
    else
    {
    if (PhoneNumString[3] != '-' && PhoneNumString[7] != '-')
	    {
	    out_str0 << ""Phone number is invalid."" << std::endl;	
	    exit(1);
	    }
    }


 // // // // // // // // // // // // // // // // // // 

 // Creation of List and Their Iterators

 	std::list<Driver> drivers;
 	std::list<Driver>::iterator itrDriver = drivers.begin();

 	std::list<Rider> riders;
 	std::list<Rider>::iterator itrRider = riders.begin();

 	std::string ClassString;
 	std::list<std::string> ClassStorage;
 	std::list<std::string>::iterator itrString = ClassStorage.begin();

    //Parsing To Store DRIVERS 
    int newline = 0;
    int Age;
    double Rating;
    double LA;
    double LO;
    while (in_str1 >> ClassString) 
    {
	    ClassStorage.push_back(ClassString);
	    newline += 1;

	   //CREATING NEW OBJECTS
		if (newline == 13) 
		{
		itrString++;
		Driver a(*itrString);
		itrString++;
		//
		a.setLastName(*itrString);
		itrString++;
		//
		a.setGender(*itrString);
		itrString++;
		//
		Age = std::stoi(*itrString);
		a.setAge(Age);
		itrString++;
		//
		a.setPhoneNumber(*itrString);
		itrString++;
		//
		Rating = stod(*itrString);
		a.setRating(Rating);
		itrString++;
		//
		LA = stod(*itrString);
		a.setCurrent_Lat(LA);
		itrString++;
		//
		LO = stod(*itrString);
		a.setCurrent_Lon(LO);
		itrString++;
		//
		a.setVehicleType(*itrString);
		itrString++;
		//
		a.setCurrentState(*itrString);
		itrString++;
		//
		if (a.getCurrentState() == ""Available"")
		{
		a.setRidersFN(""null"");
		itrString++;
		a.setRidersLN(""null"");
		itrString++;
		a.setRidersPN(""null"");
		drivers.push_back(a);
		newline = 0;
		}
		else if (a.getCurrentState() != ""Available"")
		{
		a.setRidersFN(*itrString);
		itrString++;
		//
		a.setRidersLN(*itrString);
		itrString++;
		//
		a.setRidersPN(*itrString);
		drivers.push_back(a);
		newline = 0;
		}
		}
	}

	ClassStorage.clear();

	itrString = ClassStorage.begin();

	//Parsing To Store RIDERS
    double  [MASK] ;
    double Lon_Pickup;
    double Lat_Dropoff;
    double Lon_Dropoff;
    while (in_str2 >> ClassString) 
    {
	    ClassStorage.push_back(ClassString);
	    newline += 1;

	   //CREATING NEW OBJECTS
		if (newline == 17) 
		{
		itrString++;
		Rider b(*itrString);
		itrString++;
		//
		b.setLastName(*itrString);
		itrString++;
		//
		b.setGender(*itrString);
		itrString++;
		//
		Age = std::stoi(*itrString);
		b.setAge(Age);
		itrString++;
		//
		b.setPhoneNumber(*itrString);
		itrString++;
		//
		Rating = stod(*itrString);
		b.setRating(Rating);
		itrString++;
		//
		b.setPickup_Location(*itrString);
		itrString++;
		//
		 [MASK]  = stod(*itrString);
		b.setLatitude_P_L( [MASK] );
		itrString++;
		//
		Lon_Pickup = stod(*itrString);
		b.setLongitude_P_L(Lon_Pickup);
		itrString++;
		//
		b.setDropoff_Location(*itrString);
		itrString++;
		//
		Lat_Dropoff = stod(*itrString);
		b.setLatitude_D_L(Lat_Dropoff);
		itrString++;
		//
		Lon_Dropoff = stod(*itrString);
		b.setLongitude_D_L(Lon_Dropoff);
		itrString++;
		//
		b.setVehicle_Pref(*itrString);
		itrString++;
		//
		b.setCurrentState(*itrString);
		itrString++;
		//
		if (b.getCurrentState() == ""Ready_to_request"")
			{
			b.setDriversFN(""null"");
			b.setDriversLN(""null"");
			b.setDriversPN(""null"");
			riders.push_back(b);
			newline = 0;
			itrString++;
			itrString++;
			}
			else if (b.getCurrentState() != ""Ready_to_request"")
			{
			b.setDriversFN(*itrString);
			itrString++;
			//
			b.setDriversLN(*itrString);
			itrString++;
			//
			b.setDriversPN(*itrString);
			riders.push_back(b);
			newline = 0;
			}
		}
	}
	ClassStorage.clear();



// IF GIVEN A REQUEST ORDER

if (Command == ""request"") 
{

 // // // // // // // // // // // // // // // // // // 

 // Checking Rider and Finding Nearest Driver

	CheckForRider(riders, itrRider, PhoneNumString, out_str0);

	//I need the loop to go through the rider data and find the right rider 
	itrRider = riders.begin();
	while (PhoneNumString != itrRider->getPhoneNumber())
	{
	itrRider++;
	}

	//Checks for the nearest driver
	itrDriver = drivers.begin();
	int driverslistSize = drivers.size();
	std::string SelectedDriverName;
	std::string SelectedDriverNumber;
	double SelectedDriverRating;
	double SelectedDriverDistance = 999;
	double SelectedDriverComparision;
	for (int i = 0; i < driverslistSize; i++)
	{
		if (itrDriver->getCurrentState() == ""Available"" && itrRider->getVehicle_Pref() == itrDriver->getVehicleType())
		{
		
		SelectedDriverComparision = calculateDistance(itrRider->getLatitude_P_L(), itrRider->getLongitude_P_L(), itrDriver->getCurrent_Lat(), itrDriver->getCurrent_Lon());

			if (SelectedDriverDistance > SelectedDriverComparision)
			{
			//If we didn't include these 4 variables below, I will never be able to obtain the NEAREST driver
			SelectedDriverDistance = SelectedDriverComparision;
			SelectedDriverName = itrDriver->getFirstName();
			SelectedDriverRating = itrDriver->getRating();
			SelectedDriverNumber = itrDriver->getPhoneNumber();
			}

		}	
	itrDriver++;
	}
	//Because the distance will never be 999, it's a good number to use to determine if we can't find a driver
	if (SelectedDriverDistance == 999) 
	{
	PrintForOutput0NoDriver(riders, itrRider, out_str0);
	exit(1);
	}

	itrDriver = drivers.begin();
	while (SelectedDriverNumber != itrDriver->getPhoneNumber())
	{
	itrDriver++;
	}
	

 // // // // // // // // // // // // // // // // // // 

 // Changing the Driver and Rider data for printiner

	itrDriver->setCurrentState(""On_the_way_to_pickup"");
	itrDriver->setRidersFN(itrRider->getFirstName());
	itrDriver->setRidersLN(itrRider->getLastName());
	itrDriver->setRidersPN(itrRider->getPhoneNumber());
	itrRider->setCurrentState(""Driver_on_the_way"");
	itrRider->setDriversFN(itrDriver->getFirstName());
	itrRider->setDriversLN(itrDriver->getLastName());
	itrRider->setDriversPN(itrDriver->getPhoneNumber());


 // // // // // // // // // // // // // // // // // // 

 // Printing Output

	PrintForOutput0Request(riders, itrRider, SelectedDriverName, SelectedDriverRating, SelectedDriverDistance, out_str0);
	PrintForOutput1(drivers, itrDriver, out_str1);
	PrintForOutput2(riders, itrRider, out_str2);
}

// IF GIVEN A CANCEL ORDER
else if (Command == ""cancel"") 
{

	CheckForPhoneNumber(riders, itrRider, drivers, itrDriver, PhoneNumString, out_str0);

 // // // // // // // // // // // // // // // // // // 

 // Checking if command is a Rider or Driver, also other cases.

	bool RiderCanceling = false;
	bool DriverCanceling = false;
	bool Nothing = false;
	itrRider = riders.begin();
	itrDriver = drivers.begin();
	while (RiderCanceling == false && DriverCanceling == false && Nothing == false)
	{
		if (PhoneNumString == itrRider->getPhoneNumber())
		{
		RiderCanceling = true;
		std::cout << ""Rider"" << std::endl;
		} 
		else if (PhoneNumString == itrDriver->getPhoneNumber())
		{
		DriverCanceling = true;
		std::cout << ""Driver"" << std::endl;
		}
		else
		{
		if (itrRider == riders.end())
		{
		Nothing = true;
		}
		itrRider++;
		itrDriver++;
		}
	}

	if (RiderCanceling == false && DriverCanceling == false)
	{

	out_str0 << ""Account does not exist."" << std::endl;	
	exit(1);
	}


 // // // // // // // // // // // // // // // // // // 

 // If the Rider is Canceling

	if (RiderCanceling == true)
	{	
		if (itrRider->getCurrentState() == ""Driver_on_the_way"")
		{
		out_str0 << ""Ride request for user "" << itrRider->getFirstName() << "" is now canceled by the user."" << std::endl;

		itrDriver = drivers.begin();
		while (PhoneNumString != itrDriver->getRidersPN())
		{
		itrDriver++;
		}
		itrDriver->setCurrentState(""Available"");
		itrDriver->setRidersFN(""null"");
		itrDriver->setRidersLN(""null"");
		itrDriver->setRidersPN(""null"");

		riders.erase(itrRider);
		}
		else
		{
		out_str0 << ""You can only cancel a ride request if your driver is currently on the way to the pickup location."" << std::endl;	
		exit(1);
		}


 // // // // // // // // // // // // // // // // // // 

 // Printing Output

	PrintForOutput1(drivers, itrDriver, out_str1);
	PrintForOutput2(riders, itrRider, out_str2);

	}

 // // // // // // // // // // // // // // // // // // 

 // If the Driver is Canceling

	if (DriverCanceling == true)
	{
		if (itrDriver->getCurrentState() == ""On_the_way_to_pickup"")
		{

			//I need the loop to go through the rider data and find the right rider 
			itrRider = riders.begin();
			while (PhoneNumString != itrRider->getDriversPN())
			{
			itrRider++;
			}

			std::string OGDriverName = itrDriver->getFirstName();

			// Changes The Current Driver's State and Data
			itrDriver->setCurrentState(""Holder"");
			itrDriver->setRidersFN(""null"");
			itrDriver->setRidersLN(""null"");
			itrDriver->setRidersPN(""null"");
			

			// // // // // // // // // // // // // // // // // // 

 			// Finding Nearest Driver

			itrDriver = drivers.begin();
			int driverslistSize = drivers.size();
			std::string SelectedDriverName;
			std::string SelectedDriverNumber;
			double SelectedDriverRating;
			double SelectedDriverDistance = 999;
			double SelectedDriverComparision;
			for (int i = 0; i < driverslistSize; i++)
			{
				if (itrDriver->getCurrentState() == ""Available"" && itrRider->getVehicle_Pref() == itrDriver->getVehicleType())
				{
				
				SelectedDriverComparision = calculateDistance(itrRider->getLatitude_P_L(), itrRider->getLongitude_P_L(), itrDriver->getCurrent_Lat(), itrDriver->getCurrent_Lon());

					if (SelectedDriverDistance > SelectedDriverComparision)
					{
					SelectedDriverDistance = SelectedDriverComparision;
					SelectedDriverName = itrDriver->getFirstName();
					SelectedDriverRating = itrDriver->getRating();
					SelectedDriverNumber = itrDriver->getPhoneNumber();
					}

				}	
			itrDriver++;
			}
			if (SelectedDriverDistance == 999)
			{
			PrintForOutput0NoDriver(riders, itrRider, out_str0);
			exit(1);
			}

			itrDriver = drivers.begin();
			while (SelectedDriverNumber != itrDriver->getPhoneNumber())
			{
			itrDriver++;
			}


			// // // // // // // // // // // // // // // // // // 

			// Changing the Driver and Rider data for printiner

				itrDriver->setCurrentState(""On_the_way_to_pickup"");
				itrDriver->setRidersFN(itrRider->getFirstName());
				itrDriver->setRidersLN(itrRider->getLastName());
				itrDriver->setRidersPN(itrRider->getPhoneNumber());
				itrRider->setCurrentState(""Driver_on_the_way"");
				itrRider->setDriversFN(itrDriver->getFirstName());
				itrRider->setDriversLN(itrDriver->getLastName());
				itrRider->setDriversPN(itrDriver->getPhoneNumber());

				itrDriver = drivers.begin();
				while (itrDriver->getCurrentState() != ""Holder"")
				{
				itrDriver++;
				}
				itrDriver->setCurrentState(""Available"");

			// // // // // // // // // // // // // // // // // // 

			// Printing Output

				PrintForOutput0Cancel(riders, itrRider, OGDriverName, SelectedDriverName, SelectedDriverRating, SelectedDriverDistance, out_str0);
				PrintForOutput1(drivers, itrDriver, out_str1);
				PrintForOutput2(riders, itrRider, out_str2);

		}
		else
		{
		out_str0 << ""You can only cancel a ride request if you are currently on the way to the pickup location."" << std::endl;	
		exit(1);
		}
	}
}
else
{
out_str0 << ""Not a given command, must be 'request' or 'cancel'."" << std::endl;
exit(1);
}

return 0;
}

",Lat_Pickup
558,"#include ""xv3cart_firmware_mock/xv3cart_firmware_mock.hpp""


int main(int argc, char ** argv)
{
  if (argc < 2) {
    std::cerr << ""Usage: "" << argv[0] << "" <port>"" << std::endl;
    return 1;
  }
  std::string port = argv[1];
  auto  [MASK]  = std::make_shared<xv3cart_firmware_mock::Xv3CartFirmwareMock>(port, 115200);
   [MASK] ->rx_tof_packet_ = std::make_unique<xv3cart_firmware_mock::RxToFPacket>();
   [MASK] ->rx_whl_packet_ = std::make_unique<xv3cart_firmware_mock::RxWhlPacket>();
   [MASK] ->rx_info_packet_ = std::make_unique<xv3cart_firmware_mock::RxInfoPacket>();
   [MASK] ->rx_trigger1_packet_ = std::make_unique<xv3cart_firmware_mock::RxTrigger1Packet>();

   [MASK] ->configure();
   [MASK] ->activate();

  while (true) {
     [MASK] ->read();
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
  }
}
",interface
559,"#include ""AStar.h""

#include <algorithm>
#include <cmath>
#include <limits>
#include <set>

#include ""World/World.h""

#include <iomanip>
#include <iostream>

#include ""PrintUtils.h""

AStar::AStar() {}

Path AStar::find_path(
        sf::Vector2<int> start, sf::Vector2<int> end, const World& world) {
    m_parents = std::vector<sf::Vector2<int>>(world.size(), {-1, -1});
    m_scores =
            std::vector<float>(world.size(), std::numeric_limits<float>::max());
    auto width = world.width();
    m_goal = end;
    m_world = &world;

    GraphNode  [MASK] {heuristic_at(start, end), start};
    m_scores[start.x + width * start.y] = 0;
    m_open_set.insert( [MASK] );
    m_in_open_set.insert(start);

    while(!m_open_set.empty()) {
        auto node_iter = m_open_set.begin();
        auto node = *node_iter;
        if(node.position == end) {
            sf::Vector2<int> pos = end;
            std::vector<sf::Vector2<double>> path;

            while(pos != start) {
                path.push_back(sf::Vector2<double>(pos));
                pos = m_parents[index_from_point(pos)];
            }

            path.push_back(sf::Vector2<double>(start));
            std::reverse(path.begin(), path.end());

            return Path(path,
                    m_scores[index_from_point(pos)],
                    CoordinateKind::MapSpace);
        }
        m_open_set.erase(node_iter);
        m_in_open_set.erase(m_in_open_set.find(node.position));
        m_closed_set.insert(node.position);

        auto neighbors = get_neighbors(node.position);

        for(auto pt : neighbors) {
            if(pt.x < 0 || pt.x >= world.width() || pt.y < 0 ||
                    pt.y >= world.height()) {
                continue;
            }
            if(m_closed_set.find(pt) != m_closed_set.end()) {
                continue;
            }
            if(m_in_open_set.find(pt) == m_in_open_set.end()) {
                auto is_movable = world.tile(pt.x, pt.y).is_passable();
                float g_score = 0;

                if(!is_movable) {
                    g_score = std::numeric_limits<float>::max();
                } else {
                    g_score = m_scores[index_from_point(node.position)] + 1.0;
                }

                m_open_set.emplace(g_score + heuristic_at(pt, m_goal), pt);
                if(g_score >= m_scores[index_from_point(pt)]) {
                    continue;
                }

                m_parents[index_from_point(pt)] = node.position;
                m_in_open_set.insert(pt);
                m_scores[index_from_point(pt)] = g_score;
            }
        }
    }
    return Path::make_empty();
}


float AStar::distance_between(
        const sf::Vector2<int>& start, const sf::Vector2<int>& end) const {
    auto d1 = start.x - end.x;
    auto d2 = start.y - end.y;
    return std::sqrt(d1 * d1 + d2 * d2);
}

std::array<sf::Vector2<int>, 4> AStar::get_neighbors(
        const sf::Vector2<int>& pos) {
    return {{
            sf::Vector2<int>(pos.x - 1, pos.y),
            sf::Vector2<int>(pos.x, pos.y - 1),
            sf::Vector2<int>(pos.x + 1, pos.y),
            sf::Vector2<int>(pos.x, pos.y + 1),
    }};
}

void AStar::print_cost_matrix() const {
    for(int y = 0; y < m_world->height(); ++y) {
        for(int x = 0; x < m_world->width(); ++x) {
            auto score = m_scores[x + y * m_world->width()];
            if(score != std::numeric_limits<float>::max()) {
                std::cout << std::setw(3) << score << "" | "";
            } else {
                std::cout << ""MAX""
                          << "" | "";
            }
        }
        std::cout << ""\n"";
    }
}

float AStar::heuristic_at(
        const sf::Vector2<int>& start, const sf::Vector2<int>& end) const {
    return std::abs(start.x - end.x) + std::abs(start.y - end.y);
}

int AStar::index_from_point(const sf::Vector2<int>& pt) {
    return pt.x + pt.y * m_world->width();
}

",first_point
560,"// C++ Tic Tac Toe game by <NAME>
// https://github.com/salar90/Tic-Tac-Toe

#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
struct player
{
	char *name;
	int wins;
};

void disp(int a[3][3])
{
	clrscr();
	char s[7][7];
	int i,j;
	s[0][0]=201;
	s[0][1]=205;
	s[0][2]=203;
	s[0][3]=205;
	s[0][4]=203;
	s[0][5]=205;
	s[0][6]=187;
	s[1][0]=186;
	s[1][2]=186;
	s[1][4]=186;
	s[1][6]=186;
	s[2][0]=204;
	s[2][1]=205;
	s[2][2]=206;
	s[2][3]=205;
	s[2][4]=206;
	s[2][5]=205;
	s[2][6]=185;
	s[3][0]=186;
	s[3][2]=186;
	s[3][4]=186;
	s[3][6]=186;
	s[4][0]=204;
	s[4][1]=205;
	s[4][2]=206;
	s[4][3]=205;
	s[4][4]=206;
	s[4][5]=205;
	s[4][6]=185;
	s[5][0]=186;
	s[5][2]=186;
	s[5][4]=186;
	s[5][6]=186;
	s[6][0]=200;
	s[6][1]=205;
	s[6][2]=202;
	s[6][3]=205;
	s[6][4]=202;
	s[6][5]=205;
	s[6][6]=188;
	s[1][1]='1';
	s[1][3]='2';
	s[1][5]='3';
	s[3][1]='4';
	s[3][3]='5';
	s[3][5]='6';
	s[5][1]='7';
	s[5][3]='8';
	s[5][5]='9';
	for(i=0;i<=2;i++)
		for (j=0;j<=2;j++)
			if(a[i][j]==1)
				s[i*2+1][j*2+1]='X';
			else if(a[i][j]==2)
				s[i*2+1][j*2+1]='O';

	for(i=0;i<=6;i++)
		{
			for(j=0;j<=6;j++)
				cout << s[i][j];
			cout << ""\n"";
		}
}
int checkwin(int a[3][3])
{
	int i;
	for (i=0;i<=2;i++)
	{
		if (a[i][0]==a[i][1] && a[i][1]==a[i][2] && a[i][1] !=0)
			return a[i][1];
		if (a[0][i]==a[1][i] && a[1][i]==a[2][i] && a[2][i] !=0)
			return a[2][i];
	}
	if (a[0][0]==a[1][1] && a[1][1]==a[2][2] && a[0][0]!=0)
		return a[0][0];
	if (a[2][0]==a[1][1] && a[1][1]==a[0][2] && a[2][0]!=0)
		return a[2][0];
	return 0;
}
int playgame(int a[3][3],player fp,player sp)
{
	int  [MASK] =0;
	int count=0;
	while ( [MASK] ==0)
	{


		int choice;
		int chx,chy;

		disp(a);
		cout << ""\nTurn of ""<< fp.name;
		cout << ""\nEnter number of the cell for X."";
		char ch;
		do
		{
			ch=getch();
			choice=ch-49;//choice range: 0 to 8
			chy=choice/3;
			chx=choice%3;
		}while (!(ch>='0' && ch <= '9' ) || a[chy][chx]!=0);
		a[chy][chx]=1;
		count++;
		 [MASK] =checkwin(a);
		if ( [MASK] ==1) break;
		if (count==9) return 3;


		disp(a);
		cout << ""\nTurn of ""<< sp.name;
		cout << ""\nEnter number of the cell for O."";

		do
		{
			ch=getch();
			choice=ch-49;//choice range: 0 to 8
			chy=choice/3;
			chx=choice%3;
		}while (!(ch>='0' && ch <= '9' ) || a[chy][chx]!=0);
		a[chy][chx]=2;
		count++;
		 [MASK] =checkwin(a);
		if ( [MASK] ==2) break;
		if (count==9) return 3;

	}
	disp(a);
	return  [MASK] ;
}
void main()
{
	char ch;
	int i,j;
	int pvp[3][3];
	player p1;
	player p2;
	clrscr();
	cout << ""Welcome."";
	cout << ""\nEnter Player1 name:  "";
	cin >> p1.name;
	cout << ""\nEnter Player2 name:  "";
	cin >> p2.name;
	p1.wins=0;
	p2.wins=0;

	do
	{
		for (i=0 ;i<=2;i++)
			for (j=0;j<=2;j++)
				pvp[i][j]=0;
		int winner;
		winner=playgame(pvp,p1,p2);
		switch (winner)
		{
		case 1:
			cout <<""\n""<< p1.name <<"" Wins."";
			break;
		case 2:
			cout <<""\n"" << p2.name <<"" Wins."";
			break;
		case 3:
			cout <<""\nNo Winner !"";
			break;
		}


		cout << ""\nPlay again?(y/n)"";
		ch=' ';
		while(ch !='Y' && ch !='y' && ch !='N' && ch !='n')
			ch=getch();
		if (ch=='N' || ch=='n') break;

	}while(1);


}",haswon
561,"#include ""jbd_bms.h""
#include ""esphome/core/log.h""
#include ""esphome/core/helpers.h""

namespace esphome {
namespace jbd_bms {

static const char *const TAG = ""jbd_bms"";

static const uint8_t MAX_NO_RESPONSE_COUNT = 5;

static const uint8_t JBD_PKT_START = 0xDD;
static const uint8_t JBD_PKT_END = 0x77;
static const uint8_t JBD_CMD_READ = 0xA5;
static const uint8_t JBD_CMD_WRITE = 0x5A;

static const uint8_t JBD_CMD_HWINFO = 0x03;
static const uint8_t JBD_CMD_CELLINFO = 0x04;
static const uint8_t JBD_CMD_HWVER = 0x05;

static const uint8_t JBD_CMD_ENTER_FACTORY = 0x00;
static const uint8_t JBD_CMD_EXIT_FACTORY = 0x01;
static const uint8_t JBD_CMD_FORCE_SOC_RESET = 0x0A;
static const uint8_t JBD_CMD_ERROR_COUNTS = 0xAA;
static const uint8_t JBD_CMD_CAP_REM = 0xE0;   // Set remaining capacity
static const uint8_t JBD_CMD_MOS = 0xE1;       // Set charging/discharging bitmask
static const uint8_t JBD_CMD_BALANCER = 0xE2;  // Enable/disable balancer

static const uint8_t JBD_MOS_CHARGE = 0x01;
static const uint8_t JBD_MOS_DISCHARGE = 0x02;

static const uint8_t ERRORS_SIZE = 16;
static const char *const ERRORS[ERRORS_SIZE] = {
    ""Cell overvoltage"",               // 0x00
    ""Cell undervoltage"",              // 0x01
    ""Pack overvoltage"",               // 0x02
    ""Pack undervoltage"",              // 0x03
    ""Charging over temperature"",      // 0x04
    ""Charging under temperature"",     // 0x05
    ""Discharging over temperature"",   // 0x06
    ""Discharging under temperature"",  // 0x07
    ""Charging overcurrent"",           // 0x08
    ""Discharging overcurrent"",        // 0x09
    ""Short circuit"",                  // 0x0A
    ""IC front-end error"",             // 0x0B
    ""Mosfet Software Lock"",           // 0x0C (See register 0xE1 ""MOSFET control"")
    ""Charge timeout Close"",           // 0x0D
    ""Unknown (0x0E)"",                 // 0x0E
    ""Unknown (0x0F)"",                 // 0x0F
};

void JbdBms::setup() { this->send_command(JBD_CMD_READ, JBD_CMD_HWINFO); }

void JbdBms::loop() {
  const uint32_t now = millis();

  if (now - this->last_byte_ > this->rx_timeout_) {
    ESP_LOGVV(TAG, ""Buffer cleared due to timeout: %s"",
              format_hex_pretty(&this->rx_buffer_.front(), this->rx_buffer_.size()).c_str());
    this->rx_buffer_.clear();
    this->last_byte_ = now;
  }

  while (this->available()) {
    uint8_t byte;
    this->read_byte(&byte);
    if (this->parse_jbd_bms_byte_(byte)) {
      this->last_byte_ = now;
    } else {
      ESP_LOGVV(TAG, ""Buffer cleared due to reset: %s"",
                format_hex_pretty(&this->rx_buffer_.front(), this->rx_buffer_.size()).c_str());
      this->rx_buffer_.clear();
    }
  }
}

void JbdBms::update() {
  this->track_online_status_();
  this->send_command(JBD_CMD_READ, JBD_CMD_HWINFO);
}

bool JbdBms::parse_jbd_bms_byte_(uint8_t byte) {
  size_t at = this->rx_buffer_.size();
  this->rx_buffer_.push_back(byte);
  const uint8_t *raw = &this->rx_buffer_[0];

  // Example response
  // 0xDD 0x03 0x00 0x1D 0x06 0x17 0x00 0x00 0x01 0xF3 0x01 0xF4 0x00 0x00 0x2C 0x7C 0x00 0x00
  // 0x00 0x00 0x00 0x00 0x80 0x64 0x03 0x04 0x03 0x0B 0x8D 0x0B 0x8C 0x0B 0x88 0xFA 0x85 0x77
  //
  // Byte Len  Payload                Content              Coeff.      Unit        Example value
  // 0     1   0xDD                   Start of frame
  // 1     1   0x03                   Function
  // 2     1   0x00                   Status
  // 3     1   0x1D                   Data length n
  // 4     n     0x06 0x17
  //             0x00 0x00
  //             0x01 0xF3
  //             0x01 0xF4
  //             0x00 0x00
  //             0x2C 0x7C
  //             0x00 0x00
  //             0x00 0x00
  //             0x00 0x00
  //             0x80 0x64
  //             0x03 0x04
  //             0x03 0x0B
  //             0x8D 0x0B
  //             0x8C 0x0B
  //             0x88
  // 4+n    2   0xFA 0x85               Checksum
  // 4+n+2  1   0x77                    End of frame

  if (at == 0) {
    if (raw[0] != 0xDD) {
      ESP_LOGW(TAG, ""Invalid header: 0x%02X"", raw[0]);

      // return false to reset buffer
      return false;
    }

    return true;
  }

  // Byte 1 (Function)
  // Byte 2 (Status)
  // Byte 3 (Length)
  if (at < 3)
    return true;

  uint16_t data_len = raw[3];
  uint16_t frame_len = 4 + data_len + 3;

  // Byte 0...4+data_len+3
  if (at < frame_len - 1)
    return true;

  uint8_t function = raw[1];
  uint16_t  [MASK]  = chksum_(raw + 2, data_len + 2);
  uint16_t remote_crc = uint16_t(raw[frame_len - 3]) << 8 | (uint16_t(raw[frame_len - 2]) << 0);
  if ( [MASK]  != remote_crc) {
    ESP_LOGW(TAG, ""CRC check failed! 0x%04X != 0x%04X"",  [MASK] , remote_crc);
    return false;
  }

  ESP_LOGVV(TAG, ""RX <- %s"", format_hex_pretty(raw, at + 1).c_str());

  std::vector<uint8_t> data(this->rx_buffer_.begin() + 4, this->rx_buffer_.begin() + frame_len - 3);

  this->on_jbd_bms_data(function, data);

  // return false to reset buffer
  return false;
}

void JbdBms::on_jbd_bms_data(const uint8_t &function, const std::vector<uint8_t> &data) {
  this->reset_online_status_tracker_();

  switch (function) {
    case JBD_CMD_HWINFO:
      this->on_hardware_info_data_(data);
      this->send_command(JBD_CMD_READ, JBD_CMD_CELLINFO);
      break;
    case JBD_CMD_CELLINFO:
      this->on_cell_info_data_(data);
      break;
    case JBD_CMD_HWVER:
      this->on_hardware_version_data_(data);
      break;
    case JBD_CMD_ERROR_COUNTS:
      this->on_error_counts_data_(data);
      break;
    case JBD_CMD_MOS:
    case JBD_CMD_EXIT_FACTORY:
    case JBD_CMD_FORCE_SOC_RESET:
      break;
    default:
      ESP_LOGW(TAG, ""Unhandled response (function 0x%02X) received: %s"", function,
               format_hex_pretty(&data.front(), data.size()).c_str());
  }
}

void JbdBms::on_cell_info_data_(const std::vector<uint8_t> &data) {
  auto jbd_get_16bit = [&](size_t i) -> uint16_t {
    return (uint16_t(data[i + 0]) << 8) | (uint16_t(data[i + 1]) << 0);
  };

  ESP_LOGI(TAG, ""Cell info frame (%d bytes) received"", data.size());
  ESP_LOGVV(TAG, ""  %s"", format_hex_pretty(&data.front(), data.size()).c_str());

  uint8_t data_len = data.size();
  if (data_len < 2 || data_len > 64 || (data_len % 2) != 0) {
    ESP_LOGW(TAG, ""Skipping cell info frame because of invalid length: %d"", data_len);
    return;
  }

  // Byte Len  Payload                Content              Coeff.      Unit        Example value
  // 0     2   0x0F 0x3B              Cell voltage 1       0.001       V           3899 = 3.899
  // 2     2   0x0F 0x30              Cell voltage 2       0.001       V
  // 4     2   0x0F 0x2D              Cell voltage 3       0.001       V
  // 6     2   0x0F 0x31              Cell voltage 4       0.001       V
  uint8_t cells = std::min(data_len / 2, 32);
  float min_cell_voltage = 100.0f;
  float max_cell_voltage = -100.0f;
  float average_cell_voltage = 0.0f;
  uint8_t min_voltage_cell = 0;
  uint8_t max_voltage_cell = 0;
  for (uint8_t i = 0; i < cells; i++) {
    float cell_voltage = (float) jbd_get_16bit(0 + (i * 2)) * 0.001f;
    average_cell_voltage = average_cell_voltage + cell_voltage;
    if (cell_voltage < min_cell_voltage) {
      min_cell_voltage = cell_voltage;
      min_voltage_cell = i + 1;
    }
    if (cell_voltage > max_cell_voltage) {
      max_cell_voltage = cell_voltage;
      max_voltage_cell = i + 1;
    }
    this->publish_state_(this->cells_[i].cell_voltage_sensor_, cell_voltage);
  }
  average_cell_voltage = average_cell_voltage / cells;

  this->publish_state_(this->min_cell_voltage_sensor_, min_cell_voltage);
  this->publish_state_(this->max_cell_voltage_sensor_, max_cell_voltage);
  this->publish_state_(this->max_voltage_cell_sensor_, (float) max_voltage_cell);
  this->publish_state_(this->min_voltage_cell_sensor_, (float) min_voltage_cell);
  this->publish_state_(this->delta_cell_voltage_sensor_, max_cell_voltage - min_cell_voltage);
  this->publish_state_(this->average_cell_voltage_sensor_, average_cell_voltage);
}

void JbdBms::on_error_counts_data_(const std::vector<uint8_t> &data) {
  auto jbd_get_16bit = [&](size_t i) -> uint16_t {
    return (uint16_t(data[i + 0]) << 8) | (uint16_t(data[i + 1]) << 0);
  };

  ESP_LOGI(TAG, ""Error counts frame (%d bytes) received"", data.size());
  ESP_LOGVV(TAG, ""  %s"", format_hex_pretty(&data.front(), data.size()).c_str());

  uint8_t data_len = data.size();
  if (data_len != 24) {
    ESP_LOGW(TAG, ""Skipping error counts frame because of invalid length: %d"", data_len);
    return;
  }

  this->publish_state_(this->short_circuit_error_count_sensor_, jbd_get_16bit(0));
  this->publish_state_(this->charge_overcurrent_error_count_sensor_, jbd_get_16bit(2));
  this->publish_state_(this->discharge_overcurrent_error_count_sensor_, jbd_get_16bit(4));
  this->publish_state_(this->cell_overvoltage_error_count_sensor_, jbd_get_16bit(6));
  this->publish_state_(this->cell_undervoltage_error_count_sensor_, jbd_get_16bit(8));
  this->publish_state_(this->charge_overtemperature_error_count_sensor_, jbd_get_16bit(10));
  this->publish_state_(this->charge_undertemperature_error_count_sensor_, jbd_get_16bit(12));
  this->publish_state_(this->discharge_overtemperature_error_count_sensor_, jbd_get_16bit(14));
  this->publish_state_(this->discharge_undertemperature_error_count_sensor_, jbd_get_16bit(16));
  this->publish_state_(this->battery_overvoltage_error_count_sensor_, jbd_get_16bit(18));
  this->publish_state_(this->battery_undervoltage_error_count_sensor_, jbd_get_16bit(20));
}

void JbdBms::on_hardware_info_data_(const std::vector<uint8_t> &data) {
  auto jbd_get_16bit = [&](size_t i) -> uint16_t {
    return (uint16_t(data[i + 0]) << 8) | (uint16_t(data[i + 1]) << 0);
  };
  auto jbd_get_32bit = [&](size_t i) -> uint32_t {
    return (uint32_t(jbd_get_16bit(i + 0)) << 16) | (uint32_t(jbd_get_16bit(i + 2)) << 0);
  };

  ESP_LOGI(TAG, ""Hardware info frame (%d bytes) received"", data.size());
  ESP_LOGVV(TAG, ""  %s"", format_hex_pretty(&data.front(), data.size()).c_str());

  ESP_LOGD(TAG, ""  Device model: %s"", this->device_model_.c_str());

  // Byte Len  Payload                Content              Coeff.      Unit        Example value
  //  0    2   0x06 0x17              Total voltage                                1559
  float total_voltage = jbd_get_16bit(0) * 0.01f;
  this->publish_state_(this->total_voltage_sensor_, total_voltage);

  //  2    2   0x00 0x00              Current
  float current = (float) ((int16_t) jbd_get_16bit(2)) * 0.01f;
  float power = total_voltage * current;
  this->publish_state_(this->current_sensor_, current);
  this->publish_state_(this->power_sensor_, power);
  this->publish_state_(this->charging_power_sensor_, std::max(0.0f, power));               // 500W vs 0W -> 500W
  this->publish_state_(this->discharging_power_sensor_, std::abs(std::min(0.0f, power)));  // -500W vs 0W -> 500W

  //  4    2   0x01 0xF3              Residual Capacity                            499
  this->publish_state_(this->capacity_remaining_sensor_, (float) jbd_get_16bit(4) * 0.01f);

  //  6    2   0x01 0xF4              Nominal Capacity                             500
  this->publish_state_(this->nominal_capacity_sensor_, (float) jbd_get_16bit(6) * 0.01f);

  //  8    2   0x00 0x00              Cycle Life
  this->publish_state_(this->charging_cycles_sensor_, (float) jbd_get_16bit(8));

  // 10    2   0x2C 0x7C              Production date
  uint16_t production_date = jbd_get_16bit(10);
  ESP_LOGD(TAG, ""  Date of manufacture: %d.%d.%d"", 2000 + (production_date >> 9), (production_date >> 5) & 0x0f,
           production_date & 0x1f);

  // 12    4   0x00 0x00 0x00 0x00    Balancer Status
  uint32_t balance_status_bitmask = jbd_get_32bit(12);
  this->publish_state_(this->balancer_status_bitmask_sensor_, (float) balance_status_bitmask);
  this->publish_state_(this->balancing_binary_sensor_, balance_status_bitmask > 0);

  // 16    2   0x00 0x00              Protection Status
  uint16_t errors_bitmask = jbd_get_16bit(16);
  this->publish_state_(this->errors_bitmask_sensor_, (float) errors_bitmask);
  this->publish_state_(this->errors_text_sensor_, this->error_bits_to_string_(errors_bitmask));

  // 18    1   0x80                   Version                                      0x10 = 1.0, 0x80 = 8.0
  this->publish_state_(this->software_version_sensor_, (data[18] >> 4) + ((data[18] & 0x0f) * 0.1f));

  // 19    1   0x64                   State of charge
  this->publish_state_(this->state_of_charge_sensor_, data[19]);

  // 20    1   0x03                   Mosfet bitmask
  uint8_t operation_status = data[20];
  this->mosfet_status_ = operation_status;
  this->publish_state_(this->operation_status_bitmask_sensor_, operation_status);
  this->publish_state_(this->charging_binary_sensor_, operation_status & JBD_MOS_CHARGE);
  this->publish_state_(this->charging_switch_, operation_status & JBD_MOS_CHARGE);
  this->publish_state_(this->discharging_binary_sensor_, operation_status & JBD_MOS_DISCHARGE);
  this->publish_state_(this->discharging_switch_, operation_status & JBD_MOS_DISCHARGE);

  // 21    2   0x04                   Cell count
  this->publish_state_(this->battery_strings_sensor_, data[21]);

  // 22    3   0x03                   Temperature sensors
  // 23    2   0x0B 0x8D              Temperature 1
  // 25    2   0x0B 0x8C              Temperature 2
  // 27    2   0x0B 0x88              Temperature 3
  uint8_t temperature_sensors = std::min(data[22], (uint8_t) 6);
  this->publish_state_(this->temperature_sensors_sensor_, temperature_sensors);
  for (uint8_t i = 0; i < temperature_sensors; i++) {
    this->publish_state_(this->temperatures_[i].temperature_sensor_,
                         (float) (jbd_get_16bit(23 + (i * 2)) - 2731) * 0.1f);
  }
}

void JbdBms::on_hardware_version_data_(const std::vector<uint8_t> &data) {
  ESP_LOGI(TAG, ""Hardware version frame (%d bytes) received"", data.size());
  ESP_LOGVV(TAG, ""  %s"", format_hex_pretty(&data.front(), data.size()).c_str());

  // Byte Len  Payload                                              Content
  // 0    25   0x4A 0x42 0x44 0x2D 0x53 0x50 0x30 0x34 0x53 0x30
  //           0x33 0x34 0x2D 0x4C 0x34 0x53 0x2D 0x32 0x30 0x30
  //           0x41 0x2D 0x42 0x2D 0x55
  this->device_model_ = std::string(data.begin(), data.end());

  ESP_LOGI(TAG, ""  Model name: %s"", this->device_model_.c_str());
  this->publish_state_(this->device_model_text_sensor_, this->device_model_);
}

void JbdBms::track_online_status_() {
  if (this->no_response_count_ < MAX_NO_RESPONSE_COUNT) {
    this->no_response_count_++;
  }
  if (this->no_response_count_ == MAX_NO_RESPONSE_COUNT) {
    this->publish_device_unavailable_();
    this->no_response_count_++;
  }
}

void JbdBms::reset_online_status_tracker_() {
  this->no_response_count_ = 0;
  this->publish_state_(this->online_status_binary_sensor_, true);
}

void JbdBms::publish_device_unavailable_() {
  this->publish_state_(this->online_status_binary_sensor_, false);
  this->publish_state_(this->errors_text_sensor_, ""Offline"");

  this->publish_state_(state_of_charge_sensor_, NAN);
  this->publish_state_(total_voltage_sensor_, NAN);
  this->publish_state_(current_sensor_, NAN);
  this->publish_state_(power_sensor_, NAN);
  this->publish_state_(charging_power_sensor_, NAN);
  this->publish_state_(discharging_power_sensor_, NAN);
  this->publish_state_(nominal_capacity_sensor_, NAN);
  this->publish_state_(charging_cycles_sensor_, NAN);
  this->publish_state_(capacity_remaining_sensor_, NAN);
  this->publish_state_(min_cell_voltage_sensor_, NAN);
  this->publish_state_(max_cell_voltage_sensor_, NAN);
  this->publish_state_(min_voltage_cell_sensor_, NAN);
  this->publish_state_(max_voltage_cell_sensor_, NAN);
  this->publish_state_(delta_cell_voltage_sensor_, NAN);
  this->publish_state_(average_cell_voltage_sensor_, NAN);
  this->publish_state_(operation_status_bitmask_sensor_, NAN);
  this->publish_state_(errors_bitmask_sensor_, NAN);
  this->publish_state_(balancer_status_bitmask_sensor_, NAN);
  this->publish_state_(battery_strings_sensor_, NAN);
  this->publish_state_(temperature_sensors_sensor_, NAN);
  this->publish_state_(software_version_sensor_, NAN);

  for (auto &temperature : this->temperatures_) {
    this->publish_state_(temperature.temperature_sensor_, NAN);
  }

  for (auto &cell : this->cells_) {
    this->publish_state_(cell.cell_voltage_sensor_, NAN);
  }
}

void JbdBms::dump_config() {  // NOLINT(google-readability-function-size,readability-function-size)
  ESP_LOGCONFIG(TAG, ""JbdBms:"");
  ESP_LOGCONFIG(TAG, ""  RX timeout: %d ms"", this->rx_timeout_);

  LOG_BINARY_SENSOR("""", ""Balancing"", this->balancing_binary_sensor_);
  LOG_BINARY_SENSOR("""", ""Charging"", this->charging_binary_sensor_);
  LOG_BINARY_SENSOR("""", ""Discharging"", this->discharging_binary_sensor_);
  LOG_BINARY_SENSOR("""", ""Online status"", this->online_status_binary_sensor_);

  LOG_SENSOR("""", ""Total voltage"", this->total_voltage_sensor_);
  LOG_SENSOR("""", ""Battery strings"", this->battery_strings_sensor_);
  LOG_SENSOR("""", ""Software version"", this->software_version_sensor_);
  LOG_SENSOR("""", ""Current"", this->current_sensor_);
  LOG_SENSOR("""", ""Power"", this->power_sensor_);
  LOG_SENSOR("""", ""Charging Power"", this->charging_power_sensor_);
  LOG_SENSOR("""", ""Discharging Power"", this->discharging_power_sensor_);
  LOG_SENSOR("""", ""State of charge"", this->state_of_charge_sensor_);
  LOG_SENSOR("""", ""Operation status bitmask"", operation_status_bitmask_sensor_);
  LOG_SENSOR("""", ""Errors bitmask"", errors_bitmask_sensor_);
  LOG_SENSOR("""", ""Nominal capacity"", this->nominal_capacity_sensor_);
  LOG_SENSOR("""", ""Charging cycles"", this->charging_cycles_sensor_);
  LOG_SENSOR("""", ""Balancer status bitmask"", balancer_status_bitmask_sensor_);
  LOG_SENSOR("""", ""Capacity remaining"", this->capacity_remaining_sensor_);
  LOG_SENSOR("""", ""Average cell voltage sensor"", this->average_cell_voltage_sensor_);
  LOG_SENSOR("""", ""Delta cell voltage sensor"", delta_cell_voltage_sensor_);
  LOG_SENSOR("""", ""Maximum cell voltage"", this->max_cell_voltage_sensor_);
  LOG_SENSOR("""", ""Min voltage cell"", this->min_voltage_cell_sensor_);
  LOG_SENSOR("""", ""Max voltage cell"", this->max_voltage_cell_sensor_);
  LOG_SENSOR("""", ""Minimum cell voltage"", this->min_cell_voltage_sensor_);
  LOG_SENSOR("""", ""Temperature sensors"", temperature_sensors_sensor_);
  LOG_SENSOR("""", ""Short circuit error count"", this->short_circuit_error_count_sensor_);
  LOG_SENSOR("""", ""Charge overcurrent error count"", this->charge_overcurrent_error_count_sensor_);
  LOG_SENSOR("""", ""Discharge overcurrent error count"", this->discharge_overcurrent_error_count_sensor_);
  LOG_SENSOR("""", ""Cell overvoltage error count"", this->cell_overvoltage_error_count_sensor_);
  LOG_SENSOR("""", ""Cell undervoltage error count"", this->cell_undervoltage_error_count_sensor_);
  LOG_SENSOR("""", ""Charge overtemperature error count"", this->charge_overtemperature_error_count_sensor_);
  LOG_SENSOR("""", ""Charge undertemperature error count"", this->charge_undertemperature_error_count_sensor_);
  LOG_SENSOR("""", ""Discharge overtemperature error count"", this->discharge_overtemperature_error_count_sensor_);
  LOG_SENSOR("""", ""Discharge undertemperature error count"", this->discharge_undertemperature_error_count_sensor_);
  LOG_SENSOR("""", ""Battery overvoltage error count"", this->battery_overvoltage_error_count_sensor_);
  LOG_SENSOR("""", ""Battery undervoltage error count"", this->battery_undervoltage_error_count_sensor_);
  LOG_SENSOR("""", ""Temperature 1"", this->temperatures_[0].temperature_sensor_);
  LOG_SENSOR("""", ""Temperature 2"", this->temperatures_[1].temperature_sensor_);
  LOG_SENSOR("""", ""Temperature 3"", this->temperatures_[2].temperature_sensor_);
  LOG_SENSOR("""", ""Temperature 4"", this->temperatures_[3].temperature_sensor_);
  LOG_SENSOR("""", ""Temperature 5"", this->temperatures_[4].temperature_sensor_);
  LOG_SENSOR("""", ""Temperature 6"", this->temperatures_[5].temperature_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 1"", this->cells_[0].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 2"", this->cells_[1].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 3"", this->cells_[2].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 4"", this->cells_[3].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 5"", this->cells_[4].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 6"", this->cells_[5].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 7"", this->cells_[6].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 8"", this->cells_[7].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 9"", this->cells_[8].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 10"", this->cells_[9].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 11"", this->cells_[10].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 12"", this->cells_[11].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 13"", this->cells_[12].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 14"", this->cells_[13].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 15"", this->cells_[14].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 16"", this->cells_[15].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 17"", this->cells_[16].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 18"", this->cells_[17].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 19"", this->cells_[18].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 20"", this->cells_[19].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 21"", this->cells_[20].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 22"", this->cells_[21].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 23"", this->cells_[22].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 24"", this->cells_[23].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 25"", this->cells_[24].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 26"", this->cells_[25].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 27"", this->cells_[26].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 28"", this->cells_[27].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 29"", this->cells_[28].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 30"", this->cells_[29].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 31"", this->cells_[30].cell_voltage_sensor_);
  LOG_SENSOR("""", ""Cell Voltage 32"", this->cells_[31].cell_voltage_sensor_);

  LOG_TEXT_SENSOR("""", ""Operation status"", this->operation_status_text_sensor_);
  LOG_TEXT_SENSOR("""", ""Errors"", this->errors_text_sensor_);
  LOG_TEXT_SENSOR("""", ""Device model"", this->device_model_text_sensor_);

  this->check_uart_settings(9600);
}

float JbdBms::get_setup_priority() const {
  // After UART bus
  return setup_priority::BUS - 1.0f;
}

void JbdBms::publish_state_(binary_sensor::BinarySensor *binary_sensor, const bool &state) {
  if (binary_sensor == nullptr)
    return;

  binary_sensor->publish_state(state);
}

void JbdBms::publish_state_(sensor::Sensor *sensor, float value) {
  if (sensor == nullptr)
    return;

  sensor->publish_state(value);
}

void JbdBms::publish_state_(switch_::Switch *obj, const bool &state) {
  if (obj == nullptr)
    return;

  obj->publish_state(state);
}

void JbdBms::publish_state_(text_sensor::TextSensor *text_sensor, const std::string &state) {
  if (text_sensor == nullptr)
    return;

  text_sensor->publish_state(state);
}

bool JbdBms::change_mosfet_status(uint8_t address, uint8_t bitmask, bool state) {
  if (this->mosfet_status_ == 255) {
    ESP_LOGE(TAG, ""Unable to change the Mosfet status because it's unknown"");
    return false;
  }

  uint16_t value = (this->mosfet_status_ & (~(1 << bitmask))) | ((uint8_t) state << bitmask);

  this->mosfet_status_ = value;

  value ^= (1 << 0);
  value ^= (1 << 1);

  return this->write_register(address, value);
}

bool JbdBms::write_register(uint8_t address, uint16_t value) {
  uint8_t frame[9];
  uint8_t data_len = 2;

  frame[0] = JBD_PKT_START;
  frame[1] = JBD_CMD_WRITE;
  frame[2] = address;
  frame[3] = data_len;
  frame[4] = value >> 8;
  frame[5] = value >> 0;
  auto crc = chksum_(frame + 2, data_len + 2);
  frame[6] = crc >> 8;
  frame[7] = crc >> 0;
  frame[8] = JBD_PKT_END;

  ESP_LOGVV(TAG, ""Send command: %s"", format_hex_pretty(frame, sizeof(frame)).c_str());
  this->write_array(frame, 9);
  this->flush();

  return true;
}

void JbdBms::send_command(uint8_t action, uint8_t function) {
  uint8_t frame[7];
  uint8_t data_len = 0;

  frame[0] = JBD_PKT_START;
  frame[1] = action;
  frame[2] = function;
  frame[3] = data_len;
  auto crc = chksum_(frame + 2, data_len + 2);
  frame[4] = crc >> 8;
  frame[5] = crc >> 0;
  frame[6] = JBD_PKT_END;

  this->write_array(frame, 7);
  this->flush();
}

std::string JbdBms::error_bits_to_string_(const uint16_t mask) {
  std::string values = """";
  if (mask) {
    for (int i = 0; i < ERRORS_SIZE; i++) {
      if (mask & (1 << i)) {
        values.append(ERRORS[i]);
        values.append("";"");
      }
    }
    if (!values.empty()) {
      values.pop_back();
    }
  }
  return values;
}

}  // namespace jbd_bms
}  // namespace esphome
",computed_crc
562,"#include ""algo.hpp""

#include ""mgp.hpp""

Algo::PathFinder::PathFinder(const mgp::Node &start_node, const mgp::Node &end_node, int64_t max_length,
                             const mgp::List &rel_types, const mgp::RecordFactory &record_factory)
    : start_node_(start_node), end_node_id_(end_node.Id()), max_length_(max_length), record_factory_(record_factory) {
  UpdateRelationshipDirection(rel_types);
}

void Algo::PathFinder::UpdateRelationshipDirection(const mgp::List &relationship_types) {
  all_incoming_ = false;
  all_outgoing_ = false;

  if (relationship_types.Size() == 0) {  // if no relationships were passed as arguments, all relationships are allowed
    any_outgoing_ = true;
    any_incoming_ = true;
    return;
  }

  bool in_rel = false;
  bool out_rel = false;

  for (const auto &rel : relationship_types) {
    std::string rel_type{std::string(rel.ValueString())};
    bool starts_with = rel_type.starts_with('<');
    bool ends_with = rel_type.ends_with('>');

    // '<' -> all incoming relationship are accepted
    // '>' -> all outgoing relationships are good
    if (rel_type.size() == 1) {
      if (starts_with) {
        any_incoming_ = true;
        in_rel = true;
      } else if (ends_with) {
        any_outgoing_ = true;
        out_rel = true;
      } else {
        rel_direction_[rel_type] = RelDirection::kAny;
        in_rel = out_rel = true;
      }
      continue;
    }

    if (starts_with && ends_with) {  // <type>
      rel_direction_[rel_type.substr(1, rel_type.size() - 2)] = RelDirection::kBoth;
      in_rel = out_rel = true;
    } else if (starts_with) {  // <type
      rel_direction_[rel_type.substr(1)] = RelDirection::kIncoming;
      in_rel = true;
    } else if (ends_with) {  // type>
      rel_direction_[rel_type.substr(0, rel_type.size() - 1)] = RelDirection::kOutgoing;
      out_rel = true;
    } else {  // type
      rel_direction_[rel_type] = RelDirection::kAny;
      in_rel = out_rel = true;
    }
  }

  if (!in_rel) {
    all_outgoing_ = true;
  } else if (!out_rel) {
    all_incoming_ = true;
  }
}

Algo::RelDirection Algo::PathFinder::GetDirection(const std::string &rel_type) const {
  auto it = rel_direction_.find(rel_type);
  if (it == rel_direction_.end()) {
    return RelDirection::kNone;
  }
  return it->second;
}

void Algo::PathFinder::DFS(const mgp::Node &curr_node, mgp::Path &curr_path, std::unordered_set<int64_t> &visited) {
  if (curr_node.Id() == end_node_id_) {
    auto record = record_factory_.NewRecord();
    record.Insert(std::string(kResultAllSimplePaths).c_str(), curr_path);
    return;
  }

  if (static_cast<int64_t>(curr_path.Length()) == max_length_) {
    return;
  }

  visited.insert(curr_node.Id().AsInt());
  std::unordered_set<int64_t> seen;

  auto iterate = [&visited, &seen, &curr_path, this](mgp::Relationships relationships, RelDirection direction,
                                                     bool always_expand) {
    for (const auto relationship : relationships) {
      auto next_node_id =
          direction == RelDirection::kOutgoing ? relationship.To().Id().AsInt() : relationship.From().Id().AsInt();

      if (visited.contains(next_node_id)) {
        continue;
      }

      auto type = std::string(relationship.Type());
      auto wanted_direction = GetDirection(type);

      if (always_expand || wanted_direction == RelDirection::kAny || wanted_direction == direction) {
        curr_path.Expand(relationship);
        DFS(direction == RelDirection::kOutgoing ? relationship.To() : relationship.From(), curr_path, visited);
        curr_path.Pop();
      } else if (wanted_direction == RelDirection::kBoth) {
        if (direction == RelDirection::kOutgoing && seen.contains(relationship.To().Id().AsInt())) {
          curr_path.Expand(relationship);
          DFS(relationship.To(), curr_path, visited);
          curr_path.Pop();
        } else if (direction == RelDirection::kIncoming) {
          seen.insert(relationship.From().Id().AsInt());
        }
      }
    }
  };

  if (!all_outgoing_) {
    iterate(curr_node.InRelationships(), RelDirection::kIncoming, any_incoming_);
  }
  if (!all_incoming_) {
    iterate(curr_node.OutRelationships(), RelDirection::kOutgoing, any_outgoing_);
  }
  visited.erase(curr_node.Id().AsInt());
}

void Algo::PathFinder::FindAllPaths() {
  mgp::Path path{start_node_};
  std::unordered_set<int64_t> visited;
  DFS(start_node_, path, visited);
}

void Algo::AllSimplePaths(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
  mgp::MemoryDispatcherGuard guard{memory};
  const auto arguments = mgp::List(args);
  const auto record_factory = mgp::RecordFactory(result);

  try {
    const auto start_node{arguments[0].ValueNode()};
    const auto end_node{arguments[1].ValueNode()};
    const auto rel_types{arguments[2].ValueList()};
    const auto max_nodes{arguments[3].ValueInt()};

    PathFinder pathfinder{start_node, end_node, max_nodes, rel_types, record_factory};
    pathfinder.FindAllPaths();

  } catch (const std::exception &e) {
    record_factory.SetErrorMessage(e.what());
    return;
  }
}

void Algo::Cover(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
  mgp::MemoryDispatcherGuard guard{memory};
  const auto arguments = mgp::List(args);
  const auto record_factory = mgp::RecordFactory(result);
  try {
    auto list_nodes = arguments[0].ValueList();
    std::unordered_set<mgp::Node> nodes;
    for (const auto &elem : list_nodes) {
      auto node = elem.ValueNode();
      nodes.insert(node);
    }

    for (const auto &node : nodes) {
      for (const auto rel : node.OutRelationships()) {
        if (nodes.find(rel.To()) != nodes.end()) {
          auto record = record_factory.NewRecord();
          record.Insert(std::string(kCoverRet1).c_str(), rel);
        }
      }
    }

  } catch (const std::exception &e) {
    record_factory.SetErrorMessage(e.what());
    return;
  }
}

void Algo::CheckConfigTypes(const mgp::Map &map) {
  if (!map.At(""unweighted"").IsNull() && !map.At(""unweighted"").IsBool()) {
    throw mgp::ValueException(""unweighted config option should be bool!"");
  }
  if (!map.At(""epsilon"").IsNull() && !map.At(""epsilon"").IsNumeric()) {
    throw mgp::ValueException(""epsilon config option should be numeric!"");
  }
  if (!map.At(""distance_prop"").IsNull() && !map.At(""distance_prop"").IsString()) {
    throw mgp::ValueException(""distance_prop config option should be string!"");
  }
  if (!map.At(""heuristic_name"").IsNull() && !map.At(""heuristic_name"").IsString()) {
    throw mgp::ValueException(""heuristic_name config option should be string!"");
  }
  if (!map.At(""latitude_name"").IsNull() && !map.At(""latitude_name"").IsString()) {
    throw mgp::ValueException(""latitude_name config option should be string!"");
  }
  if (!map.At(""longitude_name"").IsNull() && !map.At(""longitude_name"").IsString()) {
    throw mgp::ValueException(""longitude_name config option should be string!"");
  }
  if (!map.At(""whitelisted_labels"").IsNull() && !map.At(""whitelisted_labels"").IsList()) {
    throw mgp::ValueException(""whitelisted_labels config option should be list!"");
  }
  if (!map.At(""whitelisted_labels"").IsNull()) {
    auto list = map.At(""whitelisted_labels"").ValueList();
    for (const auto value : list) {
      if (!value.IsString()) {
        throw mgp::ValueException(""Labels in the whitelisted_labels config list must be strings!"");
      }
    }
  }
  if (!map.At(""blacklisted_labels"").IsNull() && !map.At(""blacklisted_labels"").IsList()) {
    throw mgp::ValueException(""blacklisted_labels config option should be list!"");
  }
  if (!map.At(""blacklisted_labels"").IsNull()) {
    auto list = map.At(""blacklisted_labels"").ValueList();
    for (const auto value : list) {
      if (!value.IsString()) {
        throw mgp::ValueException(""Labels in the blacklisted_labels config list must be strings!"");
      }
    }
  }
  if (!map.At(""relationships_filter"").IsNull() && !map.At(""relationships_filter"").IsList()) {
    throw mgp::ValueException(""relationships_filter config option should be list!"");
  } else if (!map.At(""relationships_filter"").IsNull() && map.At(""relationships_filter"").IsList()) {
    auto list = map.At(""relationships_filter"").ValueList();
    for (const auto value : list) {
      if (!value.IsString()) {
        throw mgp::ValueException(""Elements in relationships_filter config list must be strings!"");
      }
      auto rel_type = std::string(value.ValueString());
      const size_t size = rel_type.size();
      const char first_elem = rel_type[0];
      const char last_elem = rel_type[size - 1];

      if (first_elem == '<' && last_elem == '>') {
        throw mgp::ValueException(""Wrong relationship format => <relationship> is not allowed!"");
      }
    }
  }

  if (!map.At(""duration"").IsNull() && !map.At(""duration"").IsBool()) {
    throw mgp::ValueException(""duration config option should be bool!"");
  }
}
double Algo::GetRadians(double degrees) { return degrees * M_PI / 180.0; }

double Algo::GetHaversineDistance(double lat1, double lon1, double lat2, double lon2) {
  // IN KM
  const double earthRadius = 6371.0;
  lat1 = GetRadians(lat1);
  lon1 = GetRadians(lon1);
  lat2 = GetRadians(lat2);
  lon2 = GetRadians(lon2);

  double  [MASK]  = lat2 - lat1;
  double dLon = lon2 - lon1;
  double a = sin( [MASK]  / 2) * sin( [MASK]  / 2) + cos(lat1) * cos(lat2) * sin(dLon / 2) * sin(dLon / 2);
  double c = 2 * atan2(sqrt(a), sqrt(1 - a));
  double distance = earthRadius * c;

  // returns distance in km
  return distance;
}

// calculates the heuristic based on haversine, or returns the value if the heuristic is custom
double Algo::CalculateHeuristic(const Config &config, const mgp::Node &node, const GoalNodes &nodes) {
  if (config.heuristic_name != kDefaultHeuristic) {
    auto heuristic = node.GetProperty(config.heuristic_name);
    if (heuristic.IsNumeric()) {
      return heuristic.ValueNumeric();
    }
    if (heuristic.IsDuration() && config.duration) {
      return heuristic.ValueDuration().Microseconds();
    }
    throw mgp::ValueException(""Custom heuristic property must be of a numeric, or duration data type!"");
  }
  auto coordinate_pair = GetLatLon(node, config);
  auto &latitude_source = coordinate_pair.first;
  auto &longitude_source = coordinate_pair.second;
  return GetHaversineDistance(latitude_source, longitude_source, nodes.lat_lon.first, nodes.lat_lon.second);
}

std::pair<double, double> Algo::GetLatLon(const mgp::Node &target, const Config &config) {
  auto latitude = target.GetProperty(config.latitude_name);
  auto longitude = target.GetProperty(config.latitude_name);
  if (latitude.IsNull() || longitude.IsNull()) {
    throw mgp::ValueException(
        ""Latitude and longitude properties, or a custom heuristic value, must be specified in every node!"");
  }
  if (latitude.IsNumeric() && longitude.IsNumeric()) {
    return std::make_pair<double, double>(latitude.ValueNumeric(), longitude.ValueNumeric());
  }
  throw mgp::ValueException(""Latitude and longitude must be numeric data types!"");
}

double Algo::CalculateDistance(const Config &config, const mgp::Relationship &rel) {
  if (config.unweighted) {  // return same distance if unweighted
    return 10;
  }
  auto distance = rel.GetProperty(config.distance_prop);
  if (distance.IsNull()) {
    throw mgp::ValueException(""If the graph is weighted, distance property of the relationship must be specified!"");
  }
  if (distance.IsNumeric()) {
    return distance.ValueNumeric();
  }
  if (distance.IsDuration() && config.duration) {
    return distance.ValueDuration().Microseconds();
  }
  throw mgp::ValueException(""Distance property must be a numeric or duration datatype!"");
}

bool Algo::RelOk(const mgp::Relationship &rel, const Config &config,
                 const RelationshipType rel_type) {  // in true incoming, in false outgoing
  if (config.in_rels.size() == 0 && config.out_rels.size() == 0) {
    return true;
  }

  if (rel_type == RelationshipType::IN && config.in_rels.find(std::string(rel.Type())) != config.in_rels.end()) {
    return true;
  }

  if (rel_type == RelationshipType::OUT && config.out_rels.find(std::string(rel.Type())) != config.out_rels.end()) {
    return true;
  }

  return false;
}

bool Algo::IsLabelOk(const mgp::Node &node, const Config &config) {
  bool whitelist_empty = config.whitelist.empty();

  for (auto label : node.Labels()) {
    if (config.blacklist.find(std::string(label)) != config.blacklist.end()) {
      return false;
    }
    if (!whitelist_empty && config.whitelist.find(std::string(label)) == config.whitelist.end()) {
      return false;
    }
  }
  return true;
}
void Algo::ExpandRelationships(const std::shared_ptr<NodeObject> &prev, const RelationshipType rel_type,
                               const GoalNodes &nodes, TrackingLists &lists, const Config &config) {
  auto rels = rel_type == RelationshipType::IN ? prev->node.InRelationships() : prev->node.OutRelationships();
  for (const auto rel : rels) {
    if (!RelOk(rel, config, rel_type)) {
      continue;
    }
    const auto node = rel_type == RelationshipType::IN ? rel.From() : rel.To();
    if (!IsLabelOk(node, config)) {
      continue;
    }
    auto heuristic = CalculateHeuristic(config, node, nodes) * config.epsilon;  // epsilon 0 == UCS
    auto distance = CalculateDistance(config, rel);
    auto nb = std::make_shared<NodeObject>(heuristic, distance + prev->total_distance, node, rel, prev);
    if (!lists.closed.FindAndCompare(nb)) {
      continue;
    }
    lists.open.InsertOrUpdate(nb);
  }
}

std::shared_ptr<Algo::NodeObject> Algo::InitializeStart(const mgp::Node &start) {
  if (start.InDegree() == 0 && start.OutDegree() == 0) {
    throw mgp::ValueException(""Start node must have in or out relationships!"");
  }

  if (start.InDegree() != 0) {
    return std::make_shared<NodeObject>(0, 0, start, *start.InRelationships().begin(), nullptr);
  }

  return std::make_shared<NodeObject>(0, 0, start, *start.OutRelationships().begin(), nullptr);
}

std::pair<mgp::Path, double> Algo::HelperAstar(const GoalNodes &nodes, const Config &config) {
  TrackingLists lists = TrackingLists();

  auto start_nb = InitializeStart(nodes.start);
  lists.open.InsertOrUpdate(start_nb);

  while (!lists.open.Empty()) {
    auto nb = lists.open.Top();
    lists.open.Pop();
    if (nb->node == nodes.target) {
      return BuildResult(nb, nodes.start);
    }
    lists.closed.Insert(nb);
    ExpandRelationships(nb, RelationshipType::OUT, nodes, lists, config);
    ExpandRelationships(nb, RelationshipType::IN, nodes, lists, config);
  }
  return std::pair<mgp::Path, double>(mgp::Path(nodes.start), 0);
}

std::pair<mgp::Path, double> Algo::BuildResult(std::shared_ptr<NodeObject> final_node, const mgp::Node &start) {
  mgp::Path path = mgp::Path(start);
  std::vector<mgp::Relationship> rels;

  double weight = final_node->total_distance;
  while (final_node->prev) {
    rels.push_back(final_node->rel);
    final_node = final_node->prev;
  }

  for (auto it = rels.rbegin(); it != rels.rend(); ++it) {
    path.Expand(std::move(*it));
  }

  return std::pair<mgp::Path, double>(std::move(path), weight);
}

void Algo::AStar(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
  mgp::MemoryDispatcherGuard guard{memory};
  const auto arguments = mgp::List(args);
  const auto record_factory = mgp::RecordFactory(result);

  try {
    auto start = arguments[0].ValueNode();
    auto target = arguments[1].ValueNode();
    auto config_map = arguments[2].ValueMap();
    CheckConfigTypes(config_map);
    auto config = Config(config_map);
    // if there is a custom heuristic, there is no need for target latitude and lognitude
    auto nodes = config.heuristic_name == kDefaultHeuristic ? GoalNodes(start, target, GetLatLon(target, config))
                                                            : GoalNodes(start, target);
    std::pair<mgp::Path, double> pair = HelperAstar(nodes, config);
    mgp::Path &path = pair.first;
    const double weight = pair.second;

    auto record = record_factory.NewRecord();
    record.Insert(std::string(kAStarPath).c_str(), std::move(path));
    record.Insert(std::string(kAStarWeight).c_str(), weight);

  } catch (const std::exception &e) {
    record_factory.SetErrorMessage(e.what());
    return;
  }
}
",dLat
563,"/*******************************************************************************
 * Copyright 2025 ROBOTIS CO., LTD.
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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.
 *******************************************************************************/

/* Authors: <NAME>, <NAME>, <NAME> */

#include <moveit/move_group_interface/move_group_interface.h>

#include <chrono>
#include <memory>
#include <string>
#include <thread>

#include <rclcpp/rclcpp.hpp>
#include <std_msgs/msg/bool.hpp>
#include <std_msgs/msg/string.hpp>

using namespace std::chrono_literals;

class ManipulatorController : public rclcpp::Node
{
public:
  ManipulatorController()
  : Node(""manipulator_controller"")
  {
    subscription_ = this->create_subscription<std_msgs::msg::String>(
      ""/manipulator_control"",
      10,
      std::bind(&ManipulatorController::controlCallback, this, std::placeholders::_1)
    );

    manipulator_completed_pub_ = this->create_publisher<std_msgs::msg::Bool>(
      ""/is_manipulator_completed"", 10);
  }

  void initializeMoveGroups(const std::shared_ptr<rclcpp::Node> & node_ptr)
  {
    arm_move_group_ = std::make_shared<moveit::planning_interface::MoveGroupInterface>(
      node_ptr,
      ""arm"");
    gripper_move_group_ = std::make_shared<moveit::planning_interface::MoveGroupInterface>(
      node_ptr,
      ""gripper"");
  }

private:
  void controlCallback(const std_msgs::msg::String::SharedPtr msg)
  {
    std::string command = msg->data;
    RCLCPP_INFO(this->get_logger(), ""Received command: %s"", command.c_str());

    if (command == ""pick_target"") {
      pickTarget();
    } else if (command == ""place_target"") {
      placeTarget();
    } else {
      RCLCPP_WARN(this->get_logger(), ""Unknown command received: %s"", command.c_str());
    }
  }

  void pickTarget()
  {
    gripper_move_group_->setNamedTarget(""open"");
    if (gripper_move_group_->move()) {
      RCLCPP_INFO(this->get_logger(), ""Gripper opened successfully"");
    } else {
      RCLCPP_ERROR(this->get_logger(), ""Failed to open gripper"");
    }

    arm_move_group_->setNamedTarget(""target"");
    if (arm_move_group_->move()) {
      RCLCPP_INFO(this->get_logger(), ""Arm moved to target (pick_target) successfully"");
    } else {
      RCLCPP_ERROR(this->get_logger(), ""Failed to move arm to target (pick_target)"");
    }

    gripper_move_group_->setNamedTarget(""close"");
    if (gripper_move_group_->move()) {
      RCLCPP_INFO(this->get_logger(), ""Gripper closed successfully"");
    } else {
      RCLCPP_ERROR(this->get_logger(), ""Failed to close gripper"");
    }

    arm_move_group_->setNamedTarget(""home"");
    if (arm_move_group_->move()) {
      RCLCPP_INFO(this->get_logger(), ""Arm moved to init_pose successfully"");
    } else {
      RCLCPP_ERROR(this->get_logger(), ""Failed to move arm to init_pose"");
    }
    std::this_thread::sleep_for(2s);

    publishManipulatorCompleted();
  }

  void placeTarget()
  {
    arm_move_group_->setNamedTarget(""target"");
    if (arm_move_group_->move()) {
      RCLCPP_INFO(this->get_logger(), ""Arm moved to place_target successfully"");
    } else {
      RCLCPP_ERROR(this->get_logger(), ""Failed to move arm to place_target"");
    }

    gripper_move_group_->setNamedTarget(""open"");
    if (gripper_move_group_->move()) {
      RCLCPP_INFO(this->get_logger(), ""Gripper opened successfully"");
    } else {
      RCLCPP_ERROR(this->get_logger(), ""Failed to open gripper"");
    }

    arm_move_group_->setNamedTarget(""home"");
    if (arm_move_group_->move()) {
      RCLCPP_INFO(this->get_logger(), ""Arm moved to init_pose successfully"");
    } else {
      RCLCPP_ERROR(this->get_logger(), ""Failed to move arm to init_pose"");
    }
    std::this_thread::sleep_for(2s);

    publishManipulatorCompleted();
  }

  void publishManipulatorCompleted()
  {
    auto  [MASK]  = std_msgs::msg::Bool();
     [MASK] .data = true;
    manipulator_completed_pub_->publish( [MASK] );
  }

  rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscription_;
  rclcpp::Publisher<std_msgs::msg::Bool>::SharedPtr manipulator_completed_pub_;
  std::shared_ptr<moveit::planning_interface::MoveGroupInterface> arm_move_group_;
  std::shared_ptr<moveit::planning_interface::MoveGroupInterface> gripper_move_group_;
};

int main(int argc, char * argv[])
{
  rclcpp::init(argc, argv);
  auto node = std::make_shared<ManipulatorController>();
  node->initializeMoveGroups(node);

  rclcpp::spin(node);
  rclcpp::shutdown();
  return 0;
}
",completed_msg
564,"#include <iostream>
using namespace std;

class BankAccount
{
public:
    BankAccount(int dollars, int cents, double rate){
        if ((dollars < 0) || (cents < 0) || (rate < 0))
        {
            cout << ""Illegal values for money or interest rate.\n"";
            exit(1);
        }
        dollarsPart = dollars;
        centsPart = cents;
        interestRate = fraction(rate);
    }
    //Initializes the account balance to $dollars.cents and
    //initializes the interest rate to rate percent.
    BankAccount(int dollars, double rate){
        if ((dollars < 0) || (rate < 0))
        {
            cout << ""Illegal values for money or interest rate.\n"";
            exit(1);
        }
        dollarsPart = dollars;
        centsPart = 0;
        interestRate = fraction(rate);
    }
    //Initializes the account balance to $dollars.00 and
    //initializes the interest rate to rate percent.
    BankAccount( ) : dollarsPart(0), centsPart(0), interestRate(0.0)
    {
        
    }
    //Initializes the account balance to $0.00 and the
    //interest rate to 0.0%.
    void set(int dollars, int cents, double rate){
        if ((dollars < 0) || (cents < 0) || (rate < 0))
        {
            cout << ""Illegal values for money or interest rate.\n"";
            return;
        }
        dollarsPart = dollars;
        centsPart = cents;
        interestRate = fraction(rate);
    }
    //Postcondition: The account balance has been set to $dollars.cents;
    //The interest rate has been set to rate percent.
    void set(int dollars, double rate){
    if ((dollars < 0) || (rate < 0))
        {
        cout << ""Illegal values for money or interest rate.\n"";
        return;
        }
    dollarsPart = dollars;
    interestRate = fraction(rate);
    }
    //Postcondition: The account balance has been set to $dollars.00.
    //The interest rate has been set to rate percent.
    double getBalance( ){
        return (dollarsPart + 0.01 * centsPart);
    }
    //Returns the current account balance.
    double getRate( ){
        return percent(interestRate);
    }
    //Returns the current account interest rate as a percentage.
    void output(ostream& outs){
        outs.setf(ios::fixed);
        outs.setf(ios::showpoint);
        outs.precision(2);
        outs << ""Account balance $"" << getBalance( ) << endl;
        outs << ""Interest rate ""<< getRate( ) << ""%"" << endl;
    }
    //Precondition: If outs is a file output stream, then
    //outs has already been connected to a file.
    //Postcondition: Account balance and interest rate
    //have been written to the stream outs.
private:
    int dollarsPart;
    int centsPart;
    double interestRate;
    //Expressed as a fraction, for example, 0.057 for 5.7%
    double fraction(double percentValue){
        return (percentValue/100.0);
    }
    //Converts a percentage to a fraction. For example, fraction(50.3)
    //returns 0.503.
    double percent(double  [MASK] ){
        return ( [MASK]  * 100);
    }
    //Converts a fraction to a percentage. For example, percent(0.503)
    //returns 50.3.
};


class SavingsAccount : public BankAccount
{
    public:
    SavingsAccount(int dollars, int cents, double rate)
    {
        BankAccount(dollars, cents, rate);
    }
    //Other constructors would go here
    void deposit(int dollars, int cents)
    {
        double balance = getBalance();
        balance += dollars;
        balance += (static_cast<double>(cents) / 100);
        int newDollars = static_cast<int>(balance);
        int newCents = static_cast<int>((balance - newDollars) * 100);
        set(newDollars, newCents, getRate());
    }
    //Adds $dollars.cents to the account balance
    void withdraw(int dollars, int cents)
    {
        double balance = getBalance();
        balance -= dollars;
        balance -= (static_cast<double>(cents) / 100);
        int newDollars = static_cast<int>(balance);
        int newCents = static_cast<int>((balance - newDollars) * 100);
        set(newDollars, newCents, getRate());
    }
    //Subtracts $dollars.cents from the account balance
private:
};

int main()
{
    SavingsAccount account(100, 50, 5.5);
    account.output(cout);
    cout << endl;
    cout << ""Depositing $10.25."" << endl;
    account.deposit(10,25);
    account.output(cout);
    cout << endl;
    cout << ""Withdrawing $11.80."" << endl;
    account.withdraw(11,80);
    account.output(cout);
    cout << endl;
}",fractionValue
565,"// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.

// A byte based ANS entropy coder
#pragma once

#include ""ans_util.hpp""
#include ""interp.hpp""

namespace constants {
const uint32_t MAX_SIGMA = 256;
const uint32_t MAX_FRAME_SIZE = 4096;
const uint32_t FRAME_FACTOR = 64;
const uint64_t RADIX_LOG2 = 32;
const uint64_t RADIX = 1ULL << RADIX_LOG2;
const uint64_t K = 16;
}

struct enc_entry {
    uint16_t freq;
    uint16_t base;
    uint64_t sym_upper_bound;
};

// Normalize the frequencies so the frame is a power of two
std::array<uint16_t, constants::MAX_SIGMA> adjust_freqs(
    const std::array<uint64_t, constants::MAX_SIGMA>& freqs)
{
    std::array<uint16_t, constants::MAX_SIGMA> adj_freqs { 0 };
    size_t uniq_syms = 0;
    size_t initial_sum = 0;
    for (size_t i = 0; i < constants::MAX_SIGMA; i++) {
        initial_sum += freqs[i];
        uniq_syms += freqs[i] != 0;
    }
    size_t target_frame_size = uniq_syms * constants::FRAME_FACTOR;
    if (target_frame_size > constants::MAX_FRAME_SIZE) {
        target_frame_size = constants::MAX_FRAME_SIZE;
    }
    if (!is_power_of_two(target_frame_size)) {
        target_frame_size = next_power_of_two(target_frame_size);
    }

    double c = double(target_frame_size) / double(initial_sum);
    size_t cur_frame_size = std::numeric_limits<uint64_t>::max();
    double fudge = 1.0;
    while (cur_frame_size > target_frame_size) {
        fudge -= 0.01;
        cur_frame_size = 0;
        for (size_t sym = 0; sym < constants::MAX_SIGMA; sym++) {
            adj_freqs[sym] = (fudge * double(freqs[sym]) * c);
            if (adj_freqs[sym] == 0 && freqs[sym] != 0)
                adj_freqs[sym] = 1;
            cur_frame_size += adj_freqs[sym];
        }
    }
    int64_t excess = target_frame_size - cur_frame_size;
    for (size_t sym = 0; sym < constants::MAX_SIGMA; sym++) {
        auto ncnt = adj_freqs[constants::MAX_SIGMA - sym - 1];
        if (ncnt == 0)
            continue;
        double ratio = double(excess) / double(cur_frame_size);
        size_t adder = size_t(ratio * double(ncnt));
        if (adder > excess) {
            adder = excess;
        }
        excess -= adder;
        cur_frame_size -= ncnt;
        adj_freqs[constants::MAX_SIGMA - sym - 1] += adder;
    }
    if (excess != 0) {
        size_t max_freq = 0;
        size_t max_sym = 0;
        for (size_t sym = 0; sym < constants::MAX_SIGMA; sym++) {
            if (adj_freqs[sym] > max_freq) {
                max_freq = adj_freqs[sym];
                max_sym = sym;
            }
        }
        adj_freqs[max_sym] += excess;
    }
    return adj_freqs;
}

struct ans_byte_encode {
    static ans_byte_encode create(const uint8_t* in_u8, size_t n)
    {
        ans_byte_encode model;
        std::array<uint64_t, constants::MAX_SIGMA> freqs { 0 };
        for (size_t i = 0; i < n; i++) {
            freqs[in_u8[i]]++;
        }
        model.nfreqs = adjust_freqs(freqs);
        model.frame_size = std::accumulate(
            std::begin(model.nfreqs), std::end(model.nfreqs), 0);
        uint64_t cur_base = 0;
        uint64_t tmp = constants::K * constants::RADIX;
        for (size_t sym = 0; sym < constants::MAX_SIGMA; sym++) {
            model.table[sym].freq = model.nfreqs[sym];
            model.table[sym].base = cur_base;
            model.table[sym].sym_upper_bound = tmp * model.nfreqs[sym];
            cur_base += model.nfreqs[sym];
        }
        model.lower_bound = constants::K * model.frame_size;
        return model;
    }

    size_t serialize(uint8_t*& out_u8)
    {
        auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);
        std::array<uint32_t, constants::MAX_SIGMA> increasing_freqs;
        increasing_freqs[0] = nfreqs[0];
        for (size_t sym = 1; sym < constants::MAX_SIGMA; sym++) {
            increasing_freqs[sym] = increasing_freqs[sym - 1] + nfreqs[sym] + 1;
        }
        auto in_buf = increasing_freqs.data();
        auto bytes_written = interpolative_internal::encode(out_ptr_u32, in_buf,
            constants::MAX_SIGMA,
            constants::MAX_FRAME_SIZE + constants::MAX_SIGMA);

        out_u8 += bytes_written;
        return bytes_written;
    }

    void encode_symbol(uint64_t& state, uint8_t sym, uint8_t*& out_u8)
    {
        const auto& e = table[sym];
        if (state >= e.sym_upper_bound) {
            auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);
            *out_ptr_u32 = state & 0xFFFFFFFF;
            out_u8 += sizeof(uint32_t);
            state = state >> constants::RADIX_LOG2;
        }
        state = ((state / e.freq) * frame_size) + (state % e.freq) + e.base;
    }
    uint64_t initial_state() const { return lower_bound; }

    void flush_state(uint64_t state, uint8_t*& out_u8)
    {
        auto out_ptr_u64 = reinterpret_cast<uint64_t*>(out_u8);
        *out_ptr_u64++ = state - lower_bound;
        out_u8 += sizeof(uint64_t);
    }

    std::array<uint16_t, constants::MAX_SIGMA> nfreqs = { 0 };
    std::array<enc_entry, constants::MAX_SIGMA> table = { 0 };
    uint64_t frame_size;
    uint64_t lower_bound;
};

struct dec_entry {
    uint16_t freq;
    uint16_t offset;
    uint8_t sym;
};

struct ans_byte_decode {

    static ans_byte_decode load(const uint8_t* in_u8)
    {
        ans_byte_decode model;
        auto in_ptr_u32 = reinterpret_cast<const uint32_t*>(in_u8);
        std::array<uint32_t, constants::MAX_SIGMA> efreqs;
        interpolative_internal::decode(in_ptr_u32, model.nfreqs.data(),
            constants::MAX_SIGMA,
            constants::MAX_FRAME_SIZE + constants::MAX_SIGMA);
        uint32_t prev = model.nfreqs[0];
        for (size_t sym = 1; sym < constants::MAX_SIGMA; sym++) {
            auto cur = model.nfreqs[sym];
            model.nfreqs[sym] = cur - prev - 1;
            prev = cur;
        }
        model.frame_size = std::accumulate(
            std::begin(model.nfreqs), std::end(model.nfreqs), 0ULL);
        model.frame_mask = model.frame_size - 1;
        model.frame_log2 = log2(model.frame_size);
        model.table.resize(model.frame_size);
        uint64_t tmp = constants::K * constants::RADIX;
        uint16_t cur_base = 0;
        for (size_t sym = 0; sym < constants::MAX_SIGMA; sym++) {
            auto cur_freq = model.nfreqs[sym];
            for (uint16_t k = 0; k < cur_freq; k++) {
                model.table[cur_base + k].freq = cur_freq;
                model.table[cur_base + k].sym = sym;
                model.table[cur_base + k].offset = k;
            }
            cur_base += model.nfreqs[sym];
        }
        model.lower_bound = constants::K * model.frame_size;
        return model;
    }

    uint64_t init_state(const uint8_t*& in_u8)
    {
        in_u8 -= sizeof(uint64_t);
        auto  [MASK]  = reinterpret_cast<const uint64_t*>(in_u8);
        return * [MASK]  + lower_bound;
    }

    uint8_t decode_sym(uint64_t& state, const uint8_t*& in_u8)
    {
        const auto& entry = table[state & frame_mask];
        state = uint64_t(entry.freq) * (state >> frame_log2)
            + uint64_t(entry.offset);
        if (state < lower_bound) {
            in_u8 -= sizeof(uint32_t);
            auto in_ptr_u32 = reinterpret_cast<const uint32_t*>(in_u8);
            state = state << constants::RADIX_LOG2 | uint64_t(*in_ptr_u32);
        }
        return entry.sym;
    }

    std::array<uint32_t, constants::MAX_SIGMA> nfreqs = { 0 };
    uint64_t frame_size;
    uint64_t frame_mask;
    uint64_t frame_log2;
    uint64_t lower_bound;
    std::vector<dec_entry> table;
};

// Compress the the input byte stream. Run 4 states in parallel
size_t ans_byte_compress(
    void* dst, size_t dstCapacity, const void* src, size_t srcSize)
{
    auto in_u8 = reinterpret_cast<const uint8_t*>(src);
    auto ans_frame = ans_byte_encode::create(in_u8, srcSize);
    uint8_t* out_u8 = reinterpret_cast<uint8_t*>(dst);

    // serialize model
    ans_frame.serialize(out_u8);

    // start encoding
    uint64_t state_a = ans_frame.initial_state();
    uint64_t state_b = ans_frame.initial_state();
    uint64_t state_c = ans_frame.initial_state();
    uint64_t state_d = ans_frame.initial_state();

    size_t cur_sym = 0;
    while ((srcSize - cur_sym) % 4 != 0) {
        ans_frame.encode_symbol(state_a, in_u8[srcSize - cur_sym - 1], out_u8);
        cur_sym += 1;
    }
    while (cur_sym != srcSize) {
        ans_frame.encode_symbol(state_a, in_u8[srcSize - cur_sym - 1], out_u8);
        ans_frame.encode_symbol(state_b, in_u8[srcSize - cur_sym - 2], out_u8);
        ans_frame.encode_symbol(state_c, in_u8[srcSize - cur_sym - 3], out_u8);
        ans_frame.encode_symbol(state_d, in_u8[srcSize - cur_sym - 4], out_u8);
        cur_sym += 4;
    }

    // flush final state
    ans_frame.flush_state(state_a, out_u8);
    ans_frame.flush_state(state_b, out_u8);
    ans_frame.flush_state(state_c, out_u8);
    ans_frame.flush_state(state_d, out_u8);

    return out_u8 - reinterpret_cast<uint8_t*>(dst);
}

// decompress the ANS stream. Run 4 states in parallel
void ans_byte_decompress(
    void* dst, size_t to_decode, const void* cSrc, size_t cSrcSize)
{
    auto in_u8 = reinterpret_cast<const uint8_t*>(cSrc);
    auto ans_frame = ans_byte_decode::load(in_u8);
    in_u8 += cSrcSize;

    auto state_d = ans_frame.init_state(in_u8);
    auto state_c = ans_frame.init_state(in_u8);
    auto state_b = ans_frame.init_state(in_u8);
    auto state_a = ans_frame.init_state(in_u8);

    size_t cur_idx = 0;
    auto out_u8 = reinterpret_cast<uint8_t*>(dst);
    size_t fast_decode = to_decode - (to_decode % 4);
    while (cur_idx != fast_decode) {
        out_u8[cur_idx] = ans_frame.decode_sym(state_d, in_u8);
        out_u8[cur_idx + 1] = ans_frame.decode_sym(state_c, in_u8);
        out_u8[cur_idx + 2] = ans_frame.decode_sym(state_b, in_u8);
        out_u8[cur_idx + 3] = ans_frame.decode_sym(state_a, in_u8);
        cur_idx += 4;
    }
    while (cur_idx != to_decode) {
        out_u8[cur_idx++] = ans_frame.decode_sym(state_a, in_u8);
    }
}",in_ptr_u64
566,"#include ""stdafx.h""
#include <iostream>
#include <cmath>
#include <cstdio>
#include <fstream>

using namespace std;

#define N 3					//粒子个数
#define DIM 2				//问题维数
#define MAX_STEP 10000000	//最大迭代步数

double* pos;				//存储位置
double*	pre_pos;			//存储上一步位置
double* velocity;			//存储速度（暂未使用）
double* force;				//存储受力
double* potential;
double* kinetic_energy;
double max_force;			//存储最大受力

void initialize(){
	//此处设置初始位置
	pos[0] = sqrt(2)/2.0;		//粒子1的x坐标
	pos[1] = sqrt(2)/2.0;		//粒子1的y坐标
	pos[2] = 0.0;				//粒子2的x坐标
	pos[3] = 1.0;				//粒子2的y坐标
	pos[4] = -1.0;				//粒子3的x坐标
	pos[5] = 0.0;				//粒子3的y坐标

	for(int i=0;i<DIM*N; i++)
		pre_pos[i] = pos[i];	

	for(int i=0;i<DIM*N; i++)
		*(velocity+i) = 0.0;
}

void compute_force(){
	/*
	  totalForce 两个粒子ij之间的相互作用力合力,吸引为负
	  dist 两个粒子之间的距离
	  */
	for(int i=0; i<N*DIM; i++){
		force[i] = 0.0;				//将每个粒子的受力清零
		max_force = 0.0;			//存储最大合力（用于变步长计算）
	}
	double  r, x, y, dist, dx, dy, totalForce;
	for(int i=0;i<N;i++){
		x = pos[i*DIM + 0];
		y = pos[i*DIM + 1];
		r = x*x + y*y;
		force[i*DIM + 0] += -x;		//外势力作用
		force[i*DIM + 1] += -y;		//外势力作用
		for(int j=i+1;j<N;j++){
			dx = pos[i*DIM + 0] - pos[j*DIM + 0];
			dy = pos[i*DIM + 1] - pos[j*DIM + 1];
			dist = sqrt(dx*dx+dy*dy);
			totalForce = (48*pow(dist,-13.0)-24*pow(dist,-7.0));			
			//printf(""i=%d,j=%d, dist ij = %f, force = %f\n"",i,j,dist, totalForce);
			force[i*DIM + 0] += totalForce*dx/dist;
			force[i*DIM + 1] += totalForce*dy/dist;
			force[j*DIM + 0] -= totalForce*dx/dist;
			force[j*DIM + 1] -= totalForce*dy/dist;
		}
		if(abs(force[i*DIM + 0]>max_force)) max_force = abs(force[i*DIM + 0]);
		if(abs(force[i*DIM + 1]>max_force)) max_force = abs(force[i*DIM + 1]);
	}
	/*
	for(int i=0; i<N; i++){
		printf(""i=%d,fx=%f,fy=%f\n"",i,force[i*DIM+0],force[i*DIM+1]);
	}*/
}

// Verlet 算法
void compute_pos(double step = 1e-5){
	for(int i=0;i<N*DIM;i++){
		pre_pos[i] = 2*pos[i]-pre_pos[i]+step*step*force[i];  // Verlet 算法
		velocity[i] = (pos[i]-pre_pos[i]) / step;
	}
	swap(pre_pos,pos);
}

void compute_energy(){
	double  dist, dx, dy;
	for(int i=0;i<N;i++){
		kinetic_energy[i] = 0.5*velocity[i*DIM+0]*velocity[i*DIM+0]
							+0.5*velocity[i*DIM+1]*velocity[i*DIM+1];
		potential[i] = 0.5*(pos[i*DIM+0]*pos[i*DIM+0]+pos[i*DIM+1]*pos[i*DIM+1]);
		for(int j=0;j<N;j++){
			if (i==j) continue;
			dx = pos[i*DIM + 0] - pos[j*DIM + 0];
			dy = pos[i*DIM + 1] - pos[j*DIM + 1];
			dist = sqrt(dx*dx+dy*dy);
			potential[i] += 4*(pow(dist,-12)-pow(dist,-6));
		}
	}
}

//打印所有粒子的位置信息
void print_pos(int step = 0){
	for(int i=0; i<N; i++){
		printf(""step:%d,i=%d,x=%f,y=%f\n"",step,i,pos[i*DIM+0],pos[i*DIM+1]);
	}
	cout << endl;
}

int main(){
	pos			= new double[N*DIM];
	pre_pos		= new double[N*DIM];
	velocity	= new double[N*DIM];
	force		= new double[N*DIM];
	potential   = new double[N];
	kinetic_energy = new double[N];
	initialize();
	double  [MASK] ;	//时间步长
	double time=0.0;	//统计当前物理时间
	//print_pos(0);
	ofstream out(""result.txt"");

	for(int i=0;i<MAX_STEP;i++){
		compute_force();					//计算所有粒子受力
		 [MASK]  = 1e-5;1.0/max_force;		//计算应该使用的时间步长（取为固定步长）
		compute_pos( [MASK] );				//向前推进一步
		compute_energy();
		time+= [MASK] ;					//计算此步物理时间
		if(i%10000 == 0)					//每隔10000步存储一次数据
		{
			out << time << "" "" ;
			for(int in=0; in<N; in++){
				out << pos[in*DIM +0] << "" "" << pos[in*DIM +1] << "" ""
					<< velocity[in*DIM +0] << "" "" << velocity[in*DIM +1] << "" ""
//					<< sqrt(0.5*velocity[in*DIM +0]*velocity[in*DIM +0]
//							+0.5*velocity[in*DIM +1]*velocity[in*DIM +1]) << "" ""
					<< kinetic_energy[in] << "" "" << potential[in] << "" "";
			}
			out << endl;
			if(i%1000000 == 0)				//每隔1000000显示一次进度
				print_pos(i);
		}
	}
	return 0;
}

",time_step
567,"#include ""MainWindow.hpp""

#include <QFileDialog>
#include <QMessageBox>

#include ""ui_MainWindow.h""
#include ""TinDataLoader.hpp""
#include ""TinDataSaver.hpp""





MainWindow::MainWindow(QWidget * aParent):
	QMainWindow(aParent),
	mUI(new Ui::MainWindow)
{
	mUI->setupUi(this);
	mUI->gvMain->setScene(&mGraphicsScene);
	mUI->gvMain->setDragMode(QGraphicsView::ScrollHandDrag);

	// Connect the signals and slots:
	connect(mUI->actFileNew,    &QAction::triggered, this, &MainWindow::newFile);
	connect(mUI->actFileOpen,   &QAction::triggered, this, &MainWindow::openFile);
	connect(mUI->actFileSave,   &QAction::triggered, this, &MainWindow::saveFile);
	connect(mUI->actFileSaveAs, &QAction::triggered, this, &MainWindow::saveFileAs);
	connect(mUI->actFileImport, &QAction::triggered, this, &MainWindow::importFile);
	connect(mUI->actExit,       &QAction::triggered, this, &MainWindow::close);
	connect(mUI->actZoomIn,     &QAction::triggered, this, &MainWindow::zoomIn);
	connect(mUI->actZoomOut,    &QAction::triggered, this, &MainWindow::zoomOut);
	connect(mUI->actZoomAll,    &QAction::triggered, this, &MainWindow::zoomAll);
}




MainWindow::~MainWindow()
{
	// Nothing explicit needed here, only the destructor needs to be defined in the cpp file due to unique_ptr
}





bool MainWindow::askSaveCurrentData()
{
	if (!mIsDataDirty)
	{
		return true;
	}
	auto resp = QMessageBox::question(
		this,
		tr(""Save the data?""),
		tr(""The data has changed, would you like to save it to a file?""),
		QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No | QMessageBox::StandardButton::Cancel
	);
	if (resp == QMessageBox::StandardButton::Cancel)
	{
		// The user doesn't want to save and doesn't want to continue:
		return false;
	}
	if (resp == QMessageBox::StandardButton::Yes)
	{
		saveFile();
		if (mIsDataDirty)
		{
			// The user cancelled saving the file, cancel the causing operation as well:
			return false;
		}
	}
	return true;
}





TinData MainWindow::loadTinDataFromFile(const QString & aFileName)
{
	// Read first 4 KiB of the file to detect the format:
	QFile f(aFileName);
	if (!f.open(QFile::ReadOnly))
	{
		QMessageBox::warning(
			this,
			tr(""Cannot load TIN data""),
			tr(""Cannot open file %1 for reading"").arg(aFileName)
		);
		return {};
	}
	auto probe = f.read(4096);
	f.seek(0);

	// Try to detect the format:
	TinData data;
	if (TinDataLoader::doesProbeMatch(probe))
	{
		data = TinDataLoader::loadFrom(f);
	}
	else
	{
		QMessageBox::warning(
			this,
			tr(""Cannot load TIN data""),
			tr(""Cannot detect data format in file %1."").arg(aFileName)
		);
		return {};
	}
	return data;
}





void MainWindow::rebuildScene()
{
	mGraphicsScene.clear();
	for (const auto & pt: mTinData.points())
	{
		mGraphicsScene.addRect(pt->mX, -pt->mY, 5, 5);
	}
	for (const auto & constraint: mTinData.constraints())
	{
		auto pt1 = constraint->point1();
		auto pt2 = constraint->point2();
		mGraphicsScene.addLine(
			pt1->mX, -pt1->mY,
			pt2->mX, -pt2->mY
		);
	}
}





void MainWindow::newFile()
{
	if (!askSaveCurrentData())
	{
		return;
	}

	mTinData.clear();
	mFileName.clear();
}





void MainWindow::openFile()
{
	auto fileName = QFileDialog::getOpenFileName(
		this,                                      // Parent widget
		tr(""Open a TIN data file""),                // Title
		QString(),                                 // Initial folder
		tr(""All supported formats (*.tin *.shp)"")  // Filter
	);
	if (fileName.isEmpty())
	{
		return;
	}
	openSpecifiedFile(fileName);
}





void MainWindow::openSpecifiedFile(const QString & aFileName)
{
	try
	{
		auto data = loadTinDataFromFile(aFileName);
		std::swap(mTinData, data);
	}
	catch (const std::exception & exc)
	{
		QMessageBox::warning(
			this,
			tr(""Cannot load TIN data""),
			tr(""Cannot load TIN data from file %1:\n%2"")
				.arg(aFileName, QString::fromUtf8(exc.what())
			)
		);
		return;
	}
	mFileName = aFileName;
	rebuildScene();
	updateTitle();
	zoomAll();
}





void MainWindow::saveFile()
{
	// If the file is already assigned, save there:
	if (!mFileName.isEmpty())
	{
		saveFileTo(mFileName);
		return;
	}

	// If no file is assigned, ask the user where to save:
	saveFileAs();
}





void MainWindow::saveFileAs()
{
	auto fileName = QFileDialog::getSaveFileName(
		this,                   // Parent widget
		tr(""Save TIN data""),    // Title
		QString(),              // Initial folder
		tr(""TIN file (*.tin)"")  // Filter
	);
	if (fileName.isEmpty())
	{
		return;
	}
	saveFileTo(fileName);
	mFileName = fileName;
	updateTitle();
}





void MainWindow::saveFileTo(const QString & aFileName)
{
	QFile f(aFileName);
	if (!f.open(QFile::WriteOnly | QFile::Truncate))
	{
		QMessageBox::warning(
			this,
			tr(""Cannot save TIN data""),
			tr(""File %1 cannot be written to."").arg(aFileName)
		);
		return;
	}

	TinDataSaver::saveTo(mTinData, f);
}





void MainWindow::importFile()
{
	auto fileName = QFileDialog::getOpenFileName(
		this,                                      // Parent widget
		tr(""Open a TIN data file""),                // Title
		QString(),                                 // Initial folder
		tr(""All supported formats (*.tin *.shp)"")  // Filter
	);
	if (fileName.isEmpty())
	{
		return;
	}
	try
	{
		auto data = loadTinDataFromFile(fileName);
		mTinData.import(std::move(data));
	}
	catch (const std::exception & exc)
	{
		QMessageBox::warning(
			this,
			tr(""Cannot import TIN data""),
			tr(""Cannot import TIN data from file %1:\n%2"")
				.arg(fileName, QString::fromUtf8(exc.what())
			)
		);
	}
	rebuildScene();
	zoomAll();
}





void MainWindow::updateTitle()
{
	if (mFileName.isEmpty())
	{
		this->setWindowTitle(tr(""TinVisualiser""));
	}
	else
	{
		this->setWindowTitle(tr(""TinVisualiser: %1"").arg(mFileName));
	}
}





void MainWindow::zoomIn()
{
	mUI->gvMain->scale(mUI->gvMain->mZoomFactor, mUI->gvMain->mZoomFactor);
}





void MainWindow::zoomOut()
{
	mUI->gvMain->scale(1 / mUI->gvMain->mZoomFactor, 1 / mUI->gvMain->mZoomFactor);
}





void MainWindow::zoomAll()
{
	// If there are no points, there's nothing to zoom to:
	if (mTinData.points().empty())
	{
		return;
	}

	// Get the data extents:
	double  [MASK]  = mTinData.points()[0]->mX, maxX =  [MASK] ;
	double minY = -mTinData.points()[0]->mY, maxY = minY;
	for (const auto & pt: mTinData.points())
	{
		auto x = pt->mX, y = -pt->mY;
		if (x <  [MASK] )
		{
			 [MASK]  = x;
		}
		if (x > maxX)
		{
			maxX = x;
		}
		if (y < minY)
		{
			minY = y;
		}
		if (y > maxY)
		{
			maxY = y;
		}
	}

	// Zoom:
	mUI->gvMain->fitInView( [MASK] , minY, maxX -  [MASK] , maxY - minY, Qt::KeepAspectRatio);
}
",minX
568,"#include ""socketcan_cpp/socketcan_cpp.h""
#include <string>
#include <iostream>

int main()
{   
    scpp::SocketCan  [MASK] ;
    if ( [MASK] .open(""can0"") == scpp::STATUS_OK)
    {
    for (int j = 0; j < 20000; ++j)
    {
        scpp::CanFrame fr;
        
        while( [MASK] .read(fr) == scpp::STATUS_OK)
        {
            printf(""len %d byte, id: %d, data: %02x %02x %02x %02x %02x %02x %02x %02x  \n"", fr.len, fr.id, 
                fr.data[0], fr.data[1], fr.data[2], fr.data[3],
                fr.data[4], fr.data[5], fr.data[6], fr.data[7]);
        }
        scpp::CanFrame cf_to_write;
        
        cf_to_write.id = 123;
        cf_to_write.len = 8;
        for (int i = 0; i < 8; ++i)
            cf_to_write.data[i] = j & (254);
        auto write_sc_status =  [MASK] .write(cf_to_write);
        if (write_sc_status != scpp::STATUS_OK)
            printf(""something went wrong on socket write, error code : %d \n"", int32_t(write_sc_status));
        else
            printf(""Message was written to the socket \n"");
    }
    }
    else
    {
        printf(""Cannot open can socket!"");
    }
    return 0;
}   
",sockat_can
569,"#include ""stdafx.hpp""

#include ""hud.hpp""

#ifdef SPT_HUD_ENABLED

#include ""..\feature.hpp""
#include ""convar.hpp""
#include ""interfaces.hpp""
#include ""playerio.hpp""
#include ""signals.hpp""
#include ""game_detection.hpp""
#include ""visualizations\imgui\imgui_interface.hpp""

ConVar y_spt_hud_edgebug(""y_spt_hud_edgebug"",
                         ""0"",
                         0,
                         ""Draws text in the middle of the screen when you get an edgeboog"");
ConVar y_spt_hud_edgebug_sec(""y_spt_hud_edgebug_sec"", ""1"", 0, ""Duration of the boog text in seconds"");

// Boog detection
class BoogFeature : public FeatureWrapper<BoogFeature>
{
public:
	void BoogTick(bool simulating);
	bool ShouldDrawBoog();
	void DrawBoog();
	int ticksLeftToDrawBoog = 0;
	bool previousTickFalling = false;
	vgui::HFont boogFont = 0;

protected:
	virtual bool ShouldLoadFeature() override;

	virtual void InitHooks() override;

	virtual void LoadFeature() override;

	virtual void UnloadFeature() override;
};

static BoogFeature spt_boog;

void BoogFeature::BoogTick(bool simulating)
{
	if (!simulating)
		return;

	if (ticksLeftToDrawBoog > 0)
	{
		ticksLeftToDrawBoog -= 1;
	}

	bool ground = spt_playerio.m_fFlags.GetValue() & FL_ONGROUND;
	Vector vel = spt_playerio.m_vecAbsVelocity.GetValue();
	const float boog_vel = -4.5f;

	if (previousTickFalling)
	{
		if (!ground && vel.z == boog_vel)
		{
			ticksLeftToDrawBoog = (y_spt_hud_edgebug_sec.GetFloat()) / 0.015f;
		}
	}

	previousTickFalling = vel.z < boog_vel && !ground;
}

bool BoogFeature::ShouldDrawBoog()
{
	bool rval =
	    ticksLeftToDrawBoog > 0 && y_spt_hud_edgebug.GetBool() && interfaces::surface && spt_hud_feat.renderView;

	if (rval)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void BoogFeature::DrawBoog()
{
	auto surface = interfaces::surface;
	auto renderView = spt_hud_feat.renderView;

	if (boogFont == 0)
	{
		if (!surface)
		{
			return;
		}

		boogFont = surface->CreateFont();

		if (boogFont == 0)
		{
			return;
		}
		if (utils::GetBuildNumber() <= 3420)
		{
			typedef bool(__thiscall * SetFontGlyphSetOld_func)(void* thisptr,
			                                                   vgui::HFont font,
			                                                   const char* windowsFontName,
			                                                   int tall,
			                                                   int weight,
			                                                   int blur,
			                                                   int scanlines,
			                                                   int flags);
			const int vtidx_SetFontGlyphSet = 65;
			((*(SetFontGlyphSetOld_func**)(surface))[vtidx_SetFontGlyphSet])(surface,
			                                                                 boogFont,
			                                                                 ""Trebuchet MS"",
			                                                                 96,
			                                                                 0,
			                                                                 0,
			                                                                 0,
			                                                                 0x010);
		}
		else
		{
			surface->SetFontGlyphSet(boogFont, ""Trebuchet MS"", 96, 0, 0, 0, 0x010);
		}
	}

	surface->DrawSetTextFont(boogFont);
	surface->DrawSetTextColor(255, 255, 255, 255);
	surface->DrawSetTexture(0);
	int tall = 0, len = 0;
	surface->GetTextSize(boogFont, L""boog"", len, tall);

	int x = renderView->width / 2 - len / 2;
	int y = renderView->height / 2 + 100;

	if (tall + y > renderView->height)
	{
		y = renderView->height - tall;
	}

	surface->DrawSetTextPos(x, y);
	surface->DrawPrintText(L""boog"", wcslen(L""boog""));
}

bool BoogFeature::ShouldLoadFeature()
{
	return spt_hud_feat.ShouldLoadFeature() && spt_playerio.ShouldLoadFeature();
}

void BoogFeature::InitHooks() {}

static void SV_FrameWrapper(bool finalTick)
{
	spt_boog.BoogTick(true);
}

void BoogFeature::LoadFeature()
{
	bool  [MASK]  = false;

	// Prefer SV_Frame, also works in demos
	if (SV_FrameSignal.Works)
	{
		 [MASK]  = true;
		SV_FrameSignal.Connect(SV_FrameWrapper);
	}
	// Fall back on Tick signal, only works outside of demos
	else if (TickSignal.Works)
	{
		 [MASK]  = true;
		TickSignal.Connect(this, &BoogFeature::BoogTick);
	}

	if ( [MASK] )
	{
		bool result = spt_hud_feat.AddHudDefaultGroup(HudCallback(std::bind(&BoogFeature::DrawBoog, this),
		                                                          std::bind(&BoogFeature::ShouldDrawBoog, this),
		                                                          false));
		if (result)
		{
			InitConcommandBase(y_spt_hud_edgebug);
			InitConcommandBase(y_spt_hud_edgebug_sec);

			SptImGui::RegisterHudCvarCallback(
			    y_spt_hud_edgebug,
			    [](ConVar& var)
			    {
				    SptImGui::CvarCheckbox(y_spt_hud_edgebug, ""##checkbox"");
				    SptImGui::CvarDouble(y_spt_hud_edgebug_sec,
				                        ""edgebug display time"",
				                        ""enter time in seconds"");
			    },
			    true);
		}
	}
}

void BoogFeature::UnloadFeature() {}

#endif
",boogHooked
570,"#include ""Generator.hpp""

void GenCFG::data_seg() {
  asm_.push_back(""# Beginning of the data section\n"");
  asm_.push_back("".data"");
  std::vector<std::string>  [MASK] ;
  std::vector<std::string> data_word;
  std::set<std::string> labels;
  for (auto& line : ir_) {
    if (line.find("":"") != std::string::npos) {
      labels.insert(line.substr(0, line.size() - 1));
    }
  }
  for (auto& line : ir_) {
    std::vector<std::string> tokens;
    tokens = cvt2tokens(line);

    if (tokens[0] == ""assign"") {
      if (data_map_.find(tokens[1]) == data_map_.end()) {
        if (tokens.size() == 4) {
           [MASK] .push_back(tokens[1] + "": \t\t.space \t"" +
                               std::to_string(4 * atoi(tokens[2].c_str())));
          data_map_[tokens[1]] = std::make_pair(
              tokens[1],
              (tokens[3].find(""."") != std::string::npos ? FLOAT : INT));
          arrays_.insert(tokens[1]);
        } else if (tokens.size() == 3) {
          if (tokens[2].find(""."") != std::string::npos) {
             [MASK] .push_back(tokens[1] + "": \t\t.float \t"" + tokens[2]);
            data_map_[tokens[1]] = std::make_pair(tokens[1], FLOAT);
          } else {
            data_word.push_back(tokens[1] + "": \t\t.word \t"" + tokens[2]);
            data_map_[tokens[1]] = std::make_pair(tokens[1], INT);
          }
        }
      }
    }
    size_t i = 0;
    for (auto& token : tokens) {
      if (i++ == 0) continue;
      if (tokens[0] == ""call"" && i == 2) continue;
      if (tokens[0] == ""callr"" && i == 3) continue;
      if (token.find("":"") != std::string::npos) continue;
      if (labels.find(token) != labels.end()) continue;
      if (data_map_.find(token) != data_map_.end()) continue;
      if (is_num(token)) {
        if (token.find(""."") != std::string::npos) {
          int pos = token.find(""."");
          std::string digit = token.substr(0, pos);
          std::string decimal = token.substr(pos + 1, token.size());
           [MASK] .push_back(""num_"" + digit + ""_"" + decimal +
                               "": \t.float \t"" + token);
          std::string asm_code = ""num_"" + digit + ""_"" + decimal;
          data_map_[token] = std::make_pair(asm_code, FLOAT);
        } else {
          data_word.push_back(""num_"" + std::to_string(atoi(token.c_str())) +
                              "": \t\t.word \t"" + token);
          std::string asm_code = ""num_"" + std::to_string(atoi(token.c_str()));
          data_map_[token] = std::make_pair(asm_code, INT);
        }
      } else {
        if (token.find(""f"") != std::string::npos) {
           [MASK] .push_back(token + "": \t\t.float \t0.0"");
          data_map_[token] = std::make_pair(token, FLOAT);
        } else {
          data_word.push_back(token + "": \t\t.word \t0"");
          data_map_[token] = std::make_pair(token, INT);
        }
      }
    }
  }
  asm_.reserve(data_word.size() +  [MASK] .size());
  for (auto& data : data_word) {
    asm_.push_back(data);
  }
  for (auto& data :  [MASK] ) {
    asm_.push_back(data);
  }
}

void GenCFG::find_blocks() {
  std::vector<size_t> line_num;
  for (size_t i = 0; i < ir_.size(); ++i) {
    std::vector<std::string> tokens;
    tokens = cvt2tokens(i);
    if (tokens[0].find(""main:"") != std::string::npos ||
        (tokens[0].find("":"") != std::string::npos &&
         tokens[0].find(""label"") != std::string::npos)) {
      line_num.push_back(i);
    }
  }
  for (size_t i = 0; i < line_num.size(); ++i) {
    size_t range_beg = line_num[i] + 1;
    size_t range_end =
        line_num.size() == (i + 1) ? ir_.size() : line_num[i + 1];
    block_t block = {range_beg, range_end};
    std::cout << ""\n# Detect block "" << i << "" IR line : "" << range_beg << "" ~ ""
              << range_end << std::endl;
    blocks_.push_back(block);
  }
}

void GenCFG::graph_coloring(size_t id, graph_ptr graph) {
  size_t int_regs[8];
  size_t float_regs[16];
  memset(int_regs, 0, sizeof(size_t) * 8);
  memset(float_regs, 0, sizeof(size_t) * 16);
  std::unordered_map<std::string, reg_t> regs;

  auto max_priority = [&]() {
    static size_t i = 0;
    std::string var_name;
    for (auto& node : *graph) {
      if (i == 0) {
        var_name = node.first;
        break;
      }
    }
    size_t size = -1;
    for (auto& node : *graph) {
      auto& var = node.first;
      auto& vec = node.second;
      if (size < vec.size()) {
        // max spill cost
        var_name = var;
        size = vec.size();
      }
    }
    return var_name;
  };

  while (!graph->empty()) {
    auto var = max_priority();
    auto table = data_map_[var].second == INT ? int_regs : float_regs;
    auto size = data_map_[var].second == INT ? 8 : 16;
    for (size_t i = 0; i < size; ++i) {
      if (table[i] == 0) {
        regs[var] = i;  // store into register
        table[i] = 1;
        break;
      }
    }
    if (regs.find(var) == regs.end()) {
      regs[var] = -1;  // store into memory
    }
    regs_[{id, var}] = regs[var];
    if (!var.empty()) {
      graph->erase(var);
    }
  }
}

graph_ptr GenCFG::build_graph(size_t id) {
  // graph data structure
  graph_ptr graph = std::make_shared<graph_t>();

  size_t size = vars_[id].size();
  for (size_t i = 0; i < size; ++i) {
    std::string var = vars_[id][i];
    size_t beg_pos = live_ranges_[{id, var}].start_pos_;
    size_t end_pos = live_ranges_[{id, var}].end_pos_;
    std::vector<std::string> temp_vec;
    for (size_t j = 0; j < size; ++j) {
      if (i == j) continue;
      std::string temp_var = vars_[id][j];
      size_t temp_beg = live_ranges_[{id, temp_var}].start_pos_;
      size_t temp_end = live_ranges_[{id, temp_var}].end_pos_;
      if (end_pos >= temp_beg && beg_pos <= temp_end) {
        temp_vec.push_back(temp_var);
      }
    }
    (*graph)[var] = temp_vec;
  }
  return graph;
}

void GenCFG::analyse_live() {
  vars_.reserve(blocks_.size());
  // store vars in each blocks into vars_
  for (size_t i = 0; i < blocks_.size(); ++i) {
    size_t beg_pos = blocks_[i].start_pos_;
    size_t end_pos = blocks_[i].end_pos_;
    std::vector<std::string> tokens;
    std::set<std::string> vars;
    for (size_t j = beg_pos; j < end_pos; ++j) {
      tokens = cvt2tokens(j);
      size_t i = 0;
      for (auto& token : tokens) {
        if (i++ == 0) continue;
        if (tokens[0] == ""call"" && i == 2) continue;
        if (tokens[0] == ""callr"" && i == 3) continue;
        if (token.find("":"") != std::string::npos) continue;
        if (token.find(""label"") != std::string::npos) continue;
        // if it's a variable
        if (!is_num(token) && arrays_.find(token) == arrays_.end()) {
          vars.insert(token);
        }
      }
    }

    std::vector<std::string> temp_vars;
    temp_vars.reserve(vars.size());
    for (auto& var : vars) {
      temp_vars.push_back(var);
    }
    vars_.push_back(std::move(temp_vars));
  }
  // lamda function: analyse live range
  size_t live_beg, live_end;
  auto detect_live_range = [&](size_t id, std::string var_name) {
    size_t beg_pos = blocks_[id].start_pos_;
    size_t end_pos = blocks_[id].end_pos_;
    size_t times = 0;
    for (size_t j = beg_pos; j < end_pos; ++j) {
      auto& line = ir_[j];
      if (line.find(var_name) != std::string::npos) {
        if (times++ == 0) {
          live_beg = j;
          live_end = j;
        } else {
          live_end = j;
        }
      }
    }
  };
  // set live range for each variable in each block
  for (size_t i = 0; i < vars_.size(); ++i) {
    for (size_t j = 0; j < vars_[i].size(); ++j) {
      detect_live_range(i, vars_[i][j]);
      live_ranges_[{i, vars_[i][j]}] = {live_beg, live_end};
    }
  }
  // build graph for each block and graph coloring
  for (size_t i = 0; i < vars_.size(); ++i) {
    graph_coloring(i, build_graph(i));
  }
}

std::string GenCFG::alloc_reg(std::string token) {
  std::string funcname;
  if (!func_stack_.empty()) {
    funcname = func_stack_.top();
    auto& params = func_map_[funcname];
    for (auto& param : params) {
      if (param.first == token) {
        if (param.second == ""int"") {
          param.second = ""$a"" + std::to_string(a_idx_);
          return ""$a"" + std::to_string(a_idx_++);
        } else if (param.second == ""float"") {
          param.second = ""$f"" + std::to_string(fp_idx_);
          return ""$f"" + std::to_string(fp_idx_++);
        } else {
          return param.second;
        }
      }
    }
  }

  if (is_inside_block_ == true) {
    if (regs_.find({block_id_, token}) != regs_.end() &&
        regs_[{block_id_, token}] != -1) {
      if (data_map_[token].second == FLOAT) {
        return ""$f"" + std::to_string(regs_[{block_id_, token}]);
      } else {
        return ""$t"" + std::to_string(regs_[{block_id_, token}]);
      }
    }
  }

  return """";
}

std::string GenCFG::load(std::string token) {
  std::string reg = alloc_reg(token);
  if (reg.empty()) {
    asm_.push_back(""    la $t9, "" + data_map_[token].first);
    if (check_type(token) == FLOAT) {
      reg = ""$f16"";
      asm_.push_back(""    lwc1 $f16, 0($t9)"");
    } else {
      reg = ""$t8"";
      asm_.push_back(""    lw $t8, 0($t9)"");
    }
  }
  return reg;
}

std::string GenCFG::load(std::string token, std::string res) {
  std::string reg = alloc_reg(token);
  if (reg.empty()) {
    asm_.push_back(""    la $t9, "" + data_map_[token].first);
    reg = res;
    if (check_type(token) == FLOAT) {
      asm_.push_back(""    lwc1 "" + reg + "", 0($t9)"");
    } else {
      asm_.push_back(""    lw "" + reg + "", 0($t9)"");
    }
  }
  return reg;
}

void GenCFG::store(std::string token, std::string reg) {
  std::string new_reg = alloc_reg(token);
  if (new_reg.empty()) {
    asm_.push_back(""    la $t9, "" + data_map_[token].first);
    if (check_type(token) == FLOAT) {
      asm_.push_back(""    swc1 "" + reg + "", 0($t9)"");
    } else {
      asm_.push_back(""    sw "" + reg + "", 0($t9)"");
    }
  } else {
    if (check_type(token) == FLOAT) {
      asm_.push_back(""    mov.s "" + new_reg + "", "" + reg);
    } else {
      asm_.push_back(""    move "" + new_reg + "", "" + reg);
    }
  }
}

void GenCFG::assign_asm(std::vector<std::string>& tokens) {
  reset_reg();
  if (tokens.size() == 4) {  // array
    size_t size = atoi(tokens[2].c_str());
    if (check_type(tokens[3]) == FLOAT) {
      asm_.push_back(""    la $t0, "" + data_map_[tokens[3]].first);
      asm_.push_back(""    lwc1 $f1, 0($t0)"");
      asm_.push_back(""    la $t0, "" + data_map_[tokens[1]].first);
      for (size_t i = 0; i < size; ++i) {
        asm_.push_back(""    swc1 $f1, "" + std::to_string(4 * (i + 1)) +
                       ""($t0)"");
      }
    } else {
      asm_.push_back(""    la $t0, "" + data_map_[tokens[3]].first);
      asm_.push_back(""    lw $t1, 0($t0)"");
      asm_.push_back(""    la $t0, "" + data_map_[tokens[1]].first);
      for (size_t i = 0; i < size; ++i) {
        asm_.push_back(""    sw $t1, "" + std::to_string(4 * (i + 1)) + ""($t0)"");
      }
    }
  } else if (tokens.size() == 3) {
    store(tokens[1], load(tokens[2]));
  }
  reset_reg();
}

void GenCFG::operator_asm(std::vector<std::string>& tokens) {
  reset_reg();
  std::string reg1, reg2;
  if (check_type(tokens[3]) == INT) {
    reg1 = load(tokens[1], ""$t8"");
    reg2 = load(tokens[2], ""$t9"");
    if (tokens[0] != ""mult"" && tokens[0] != ""div"") {
      asm_.push_back(""    "" + tokens[0] + "" $t8"" + "", "" + reg1 + "", "" + reg2);
      reg1 = ""$t8"";
    } else {
      asm_.push_back(""    "" + tokens[0] + "" "" + reg1 + "", "" + reg2);
      asm_.push_back(""    mflo "" + reg1);
    }
  } else {
    reg1 = load(tokens[1], ""$f16"");
    reg2 = load(tokens[2], ""$f17"");
    if (tokens[0] != ""mult"" && tokens[0] != ""div"") {
      asm_.push_back(""    "" + tokens[0] + "".s "" + "" $f16"" + "", "" + reg1 + "", "" +
                     reg2);
      reg1 = ""$f16"";
    } else {
      asm_.push_back(""    "" + tokens[0] + "" "" + reg1 + "", "" + reg2);
      asm_.push_back(""    mflo "" + reg1);
    }
  }
  store(tokens[3], reg1);
  reset_reg();
}

void GenCFG::return_asm(std::vector<std::string>& tokens) {
  if (tokens.size() == 2) {
    asm_.push_back(""    move $v0, "" + load(tokens[1]));
  }
  asm_.push_back(""    addi $sp, $sp, 4"");
  asm_.push_back(""    lw $ra, -4($sp)"");
  asm_.push_back(""    addi $sp, $sp, 32"");
  asm_.push_back(""    lw $s0, -4($sp)"");
  asm_.push_back(""    lw $s1, -8($sp)"");
  asm_.push_back(""    lw $s2, -12($sp)"");
  asm_.push_back(""    lw $s3, -16($sp)"");
  asm_.push_back(""    lw $s4, -20($sp)"");
  asm_.push_back(""    lw $s5, -24($sp)"");
  asm_.push_back(""    lw $s6, -28($sp)"");
  asm_.push_back(""    lw $s7, -32($sp)"");
  asm_.push_back(""    jr $ra"");
}

void GenCFG::call_asm(std::vector<std::string>& tokens) {
  asm_.push_back(""    sw $t4, -4($sp)"");
  asm_.push_back(""    sw $t5, -8($sp)"");
  asm_.push_back(""    sw $t6, -12($sp)"");
  asm_.push_back(""    sw $t7, -16($sp)"");
  asm_.push_back(""    sw $t8, -20($sp)"");
  asm_.push_back(""    sw $t9, -24($sp)"");
  asm_.push_back(""    addi $sp, $sp, -24"");
  asm_.push_back(""    swc1 $f12, -4($sp)"");
  asm_.push_back(""    swc1 $f13, -8($sp)"");
  asm_.push_back(""    swc1 $f14, -12($sp)"");
  asm_.push_back(""    addi $sp, $sp, -12"");
  asm_.push_back(""    sw $a0, -4($sp)"");
  asm_.push_back(""    sw $a1, -8($sp)"");
  asm_.push_back(""    sw $a2, -12($sp)"");
  asm_.push_back(""    sw $a3, -16($sp)"");
  asm_.push_back(""    addi $sp, $sp, -16"");
  size_t param_size = 0;
  size_t param_idx = 0;
  if (tokens[0] == ""callr"") {
    param_size = tokens.size() - 3;
    param_idx = 3;
  } else {
    param_size = tokens.size() - 2;
    param_idx = 2;
  }
  for (size_t i = 0; i < param_size; ++i) {
    if (check_type(tokens[param_idx]) == INT) {
      asm_.push_back(""    move $a"" + std::to_string(i) + "", "" +
                     load(tokens[param_idx + i]));
    } else {
      asm_.push_back(""    mov.s $f"" + std::to_string(i + 12) + "", "" +
                     load(tokens[param_idx + i]));
    }
  }

  std::string funcname =
      ret_func_name(tokens[0] == ""callr"" ? tokens[2] : tokens[1]);

  asm_.push_back(""    jal "" + funcname);
  asm_.push_back(""    addi $sp, $sp, 16"");
  asm_.push_back(""    lw $a0, -4($sp)"");
  asm_.push_back(""    lw $a1, -8($sp)"");
  asm_.push_back(""    lw $a2, -12($sp)"");
  asm_.push_back(""    lw $a3, -16($sp)"");
  asm_.push_back(""    addi $sp, $sp, 12"");
  asm_.push_back(""    lwc1 $f12, -4($sp)"");
  asm_.push_back(""    lwc1 $f13, -8($sp)"");
  asm_.push_back(""    lwc1 $f14, -12($sp)"");
  asm_.push_back(""    addi $sp, $sp, 24"");
  asm_.push_back(""    lw $t4, -4($sp)"");
  asm_.push_back(""    lw $t5, -8($sp)"");
  asm_.push_back(""    lw $t6, -12($sp)"");
  asm_.push_back(""    lw $t7, -16($sp)"");
  asm_.push_back(""    lw $t8, -20($sp)"");
  asm_.push_back(""    lw $t9, -24($sp)"");
  if (tokens[0] == ""callr"") {
    if (check_type(tokens[1]) == INT) {
      asm_.push_back(""    move "" + load(tokens[1]) + "", $v0"");
    } else {
      asm_.push_back(""    mov.s "" + load(tokens[1]) + "", $v0"");
    }
  }
}

void GenCFG::array_load_asm(std::vector<std::string>& tokens) {
  std::string reg = load(tokens[3], ""$t9"");
  asm_.push_back(""    sll "" + reg + "", "" + reg + "", 2"");
  asm_.push_back(""    la $t8, "" + data_map_[tokens[2]].first);
  asm_.push_back(""    add $t8, $t8, "" + reg);
  asm_.push_back(""    srl "" + reg + "", "" + reg + "", 2"");
  if (check_type(tokens[2]) == FLOAT) {
    asm_.push_back(""    lwc1 $f16, 0($t8)"");
    store(tokens[1], ""$f16"");
  } else {
    asm_.push_back(""    lw  $t8, 0($t8)"");
    store(tokens[1], ""$t8"");
  }
}

void GenCFG::array_store_asm(std::vector<std::string>& tokens) {
  std::string reg = load(tokens[2], ""$t9"");
  asm_.push_back(""    sll "" + reg + "", "" + reg + "", 2"");
  asm_.push_back(""    la $t8, "" + data_map_[tokens[1]].first);
  asm_.push_back(""    add $t8, $t8, "" + reg);
  asm_.push_back(""    srl "" + reg + "", "" + reg + "", 2"");
  if (check_type(tokens[1]) == FLOAT) {
    asm_.push_back(""    swc1 "" + load(tokens[3], ""$f16"") + "", 0($t8)"");
  } else {
    asm_.push_back(""    sw "" + load(tokens[3], ""$t9"") + "", 0($t8)"");
  }
}

void GenCFG::condition_asm(std::vector<std::string>& tokens) {
  std::string cond_asm;
  if (tokens[0] == ""brgt"") {
    cond_asm = ""bgt"";
  } else if (tokens[0] == ""breq"") {
    cond_asm = ""beq"";
  } else if (tokens[0] == ""brlt"") {
    cond_asm = ""blt"";
  } else if (tokens[0] == ""brgeq"") {
    cond_asm = ""bge"";
  } else if (tokens[0] == ""brleq"") {
    cond_asm = ""ble"";
  } else if (tokens[0] == ""brneq"") {
    cond_asm = ""bne"";
  }

  std::string reg1 = load(tokens[1], ""$t8"");
  std::string reg2 = load(tokens[2], ""$t9"");

  asm_.push_back(""    "" + cond_asm + "", "" + reg1 + "", "" + reg2 + "", "" +
                 tokens[3]);
}

void GenCFG::func_asm(std::vector<std::string>& code) {
  func_stack_.push(code[0].substr(0, code[0].size() - 1));
  reset_reg();
  asm_.push_back(""\n"" + code[0] + ""\n"");
  asm_.push_back(""    sw $s0, -4($sp)"");
  asm_.push_back(""    sw $s1, -8($sp)"");
  asm_.push_back(""    sw $s2, -12($sp)"");
  asm_.push_back(""    sw $s3, -16($sp)"");
  asm_.push_back(""    sw $s4, -20($sp)"");
  asm_.push_back(""    sw $s5, -24($sp)"");
  asm_.push_back(""    sw $s6, -28($sp)"");
  asm_.push_back(""    sw $s7, -32($sp)"");
  asm_.push_back(""    addi $sp, $sp, -32"");
  asm_.push_back(""    sw $ra, -4($sp)"");
  asm_.push_back(""    addi $sp, $sp, -4"");

  for (size_t i = 1; i < code.size(); ++i) {
    auto& line = code[i];
    std::vector<std::string> tokens;
    tokens = cvt2tokens(line);
    asm_.push_back(""\n    # IR:"" + line);
    if (tokens[0] == ""assign"") {
      assign_asm(tokens);
    } else if (tokens[0] == ""add"" || tokens[0] == ""sub"" || tokens[0] == ""and"" ||
               tokens[0] == ""or"" || tokens[0] == ""mult"" || tokens[0] == ""div"") {
      operator_asm(tokens);
    } else if (tokens[0] == ""goto"") {
      asm_.push_back(""    j "" + tokens[1]);
    } else if (tokens[0] == ""breq"" || tokens[0] == ""brneq"" ||
               tokens[0] == ""brlt"" || tokens[0] == ""brgt"" ||
               tokens[0] == ""brgeq"" || tokens[0] == ""brleq"") {
      condition_asm(tokens);
    } else if (tokens[0] == ""return"") {
      return_asm(tokens);
    } else if (tokens[0] == ""call"" || tokens[0] == ""callr"") {
      call_asm(tokens);
    } else if (tokens[0] == ""array_store"") {
      array_store_asm(tokens);
    } else if (tokens[0] == ""array_load"") {
      array_load_asm(tokens);
    } else if (tokens[0] != ""main:"") {
      // function procedure
      asm_.push_back(tokens[0]);
    }
  }

  reset_reg();
  func_stack_.pop();
}

void GenCFG::text_seg() {
  asm_.push_back(""\n# Beginning of the code section\n"");
  asm_.push_back("".text"");

  built_in_printi();
  built_in_exit();
  built_in_not();

  // main entrance
  asm_.push_back(""main:"");

  size_t times = 0;
  for (size_t i = 0; i < ir_.size(); ++i) {
    auto& line = ir_[i];
    std::vector<std::string> tokens;
    tokens = cvt2tokens(line);
    // init block variables or release block registers
    block_init(i);
    if (tokens[0] == ""assign"") {
      asm_.push_back(""\n    # IR:"" + line);
      assign_asm(tokens);
    } else if (tokens[0] == ""add"" || tokens[0] == ""sub"" || tokens[0] == ""and"" ||
               tokens[0] == ""or"" || tokens[0] == ""mult"" || tokens[0] == ""div"") {
      asm_.push_back(""\n    # IR:"" + line);
      operator_asm(tokens);
    } else if (tokens[0] == ""goto"") {
      block_release(i);
      asm_.push_back(""    j "" + tokens[1]);
      continue;
    } else if (tokens[0] == ""breq"" || tokens[0] == ""brneq"" ||
               tokens[0] == ""brlt"" || tokens[0] == ""brgt"" ||
               tokens[0] == ""brgeq"" || tokens[0] == ""brleq"") {
      asm_.push_back(""\n    # IR:"" + line);
      condition_asm(tokens);
    } else if (tokens[0] == ""return"") {
      block_release(i);
      asm_.push_back(""\n    # IR:"" + line);
      return_asm(tokens);
      continue;
    } else if (tokens[0] == ""call"" || tokens[0] == ""callr"") {
      asm_.push_back(""\n    # IR:"" + line);
      call_asm(tokens);
    } else if (tokens[0] == ""array_store"") {
      asm_.push_back(""\n    # IR:"" + line);
      array_store_asm(tokens);
    } else if (tokens[0] == ""array_load"") {
      asm_.push_back(""\n    # IR:"" + line);
      array_load_asm(tokens);
    } else if (tokens[0] == ""main:"") {
      asm_.push_back(""\nmain0:\n"");
      asm_.push_back(""    sw $s0, -4($sp)"");
      asm_.push_back(""    sw $s1, -8($sp)"");
      asm_.push_back(""    sw $s2, -12($sp)"");
      asm_.push_back(""    sw $s3, -16($sp)"");
      asm_.push_back(""    sw $s4, -20($sp)"");
      asm_.push_back(""    sw $s5, -24($sp)"");
      asm_.push_back(""    sw $s6, -28($sp)"");
      asm_.push_back(""    sw $s7, -32($sp)"");
      asm_.push_back(""    addi $sp, $sp, -32"");
      asm_.push_back(""    sw $ra, -4($sp)"");
      asm_.push_back(""    addi $sp, $sp, -4"");
    } else {
      if (tokens[0].find(""label"") == std::string::npos) {
        if (times == 0) {
          asm_.push_back(""\n    # IR: goto, main0"");
          asm_.push_back(""    j main0"");
          times++;
        }
        // function procedure
        std::vector<std::string> func_ir;
        while (line.find(""return"") == std::string::npos) {
          func_ir.push_back(line);
          ++i;
          line = ir_[i];
        }
        func_ir.push_back(line);
        func_asm(func_ir);
      } else {
        asm_.push_back(tokens[0]);
      }
    }
    block_release(i);
  }
}

void GenCFG::block_init(size_t line_id) {
  if (blocks_[block_id_].start_pos_ == line_id) {
    asm_.push_back(""\n    # Enter block and load vars into registers ... \n"");
    // load a set of variable you expected to use
    auto& vars = vars_[block_id_];
    for (size_t i = 0; i < vars.size(); ++i) {
      if (regs_[{block_id_, vars[i]}] != -1) {
        if (data_map_[vars[i]].second == INT) {
          load(vars[i], ""$t"" + std::to_string(regs_[{block_id_, vars[i]}]));
        } else {
          load(vars[i], ""$f"" + std::to_string(regs_[{block_id_, vars[i]}]));
        }
      }
    }
    // enter into block
    is_inside_block_ = true;
  }
}

void GenCFG::block_release(size_t line_id) {
  if (blocks_[block_id_].end_pos_ - 1 == line_id) {
    // leave this block
    is_inside_block_ = false;
    asm_.push_back(""\n    # Leave block and save registers into vars ... \n"");
    // save a set of variable in registers
    auto& vars = vars_[block_id_];
    for (size_t i = 0; i < vars.size(); ++i) {
      if (regs_[{block_id_, vars[i]}] != -1) {
        if (data_map_[vars[i]].second == INT) {
          store(vars[i], ""$t"" + std::to_string(regs_[{block_id_, vars[i]}]));
        } else {
          store(vars[i], ""$f"" + std::to_string(regs_[{block_id_, vars[i]}]));
        }
      }
    }

    // detect the next block
    block_id_++;
  }
}

void GenCFG::generate() {
  data_seg();
  find_blocks();   // detect blocks
  analyse_live();  // live range analysis
  text_seg();
}
",data_float
571,"#include ""choose_file_controller.h""

#include ""application.h""
#include ""io_task.h""
#include ""path.h""
#include ""text_list_model.h""
#include ""view_system.h""

#define LOG() qDebug() << ""[ChooseFileController]""

ChooseFileController::ChooseFileController(QObject* parent)
    : QObject(parent), suggestions(new FileSuggestionListModel(this)) {
  suggestions->min_filter_sub_match_length = 1;
}

QString ChooseFileController::GetPath() const { return folder + file; }

bool ChooseFileController::CanOpen() const {
  if (choose_folder) {
    return allow_creating || (file.isEmpty() && !folder.isEmpty());
  } else {
    int i = suggestions->IndexOfSuggestionWithName(file);
    if (i < 0) {
      return allow_creating && !file.isEmpty();
    } else {
      return !suggestions->list[i].is_dir;
    }
  }
}

QString ChooseFileController::GetDefaultFolder() const {
  return QStandardPaths::writableLocation(QStandardPaths::HomeLocation) + '/';
}

static bool Compare(const FileSuggestion& a, const FileSuggestion& b) {
  if (a.is_dir != b.is_dir) {
    return a.is_dir > b.is_dir;
  } else {
    return a.name < b.name;
  }
}

void ChooseFileController::SetPath(const QString& path) {
  if (path == GetPath()) {
    return;
  }
  QString  [MASK]  = folder;
  folder = Path::GetFolderPath(path);
  file = Path::GetFileName(path);
  LOG() << ""Chaning path to"" << path << ""folder:"" << folder << ""file:"" << file;
  if ( [MASK]  != folder) {
    LOG() << ""Will refresh list of file suggestions"";
    QString path = folder;
    bool choose_folder = this->choose_folder;
    IoTask::Run<QList<FileSuggestion>>(
        this,
        [path, choose_folder]() {
          QList<FileSuggestion> results;
          QDir::Filters filters =
              QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden;
          if (!choose_folder) {
            filters |= QDir::Files;
          }
          QDirIterator it(path, filters);
          while (it.hasNext()) {
            FileSuggestion suggestion;
            suggestion.name = it.next();
            suggestion.name.remove(path);
            suggestion.is_dir = it.fileInfo().isDir();
            results.append(suggestion);
          }
          std::sort(results.begin(), results.end(), Compare);
          return results;
        },
        [this](QList<FileSuggestion> results) {
          suggestions->list = results;
          if (!suggestions->SetFilter(file)) {
            suggestions->Load();
          }
        });
  } else {
    suggestions->SetFilter(file);
  }
  emit pathChanged();
}

void ChooseFileController::pickSelectedSuggestion() {
  int i = suggestions->GetSelectedItemIndex();
  if (i < 0) {
    return;
  }
  const FileSuggestion& suggestion = suggestions->list[i];
  QString path = folder + suggestion.name;
  if (suggestion.is_dir) {
    path += '/';
  }
  SetPath(path);
}

void ChooseFileController::openOrCreateFile() {
  if (!CanOpen()) {
    return;
  }
  QString path = GetResultPath();
  IoTask::Run<bool>(
      this,
      [path]() {
        LOG() << ""Checking if"" << path << ""exists"";
        return QFile::exists(path);
      },
      [this, path](bool exists) {
        Application& app = Application::Get();
        if (exists) {
          emit fileChosen(path);
        } else {
          QString type = choose_folder ? ""folder"" : ""file"";
          AlertDialog dialog(
              ""Create new "" + type + '?',
              ""Do you want to create a new "" + type + "": "" + path + '?');
          app.view.DisplayAlertDialog(dialog);
          QObject::connect(&app.view, &ViewSystem::alertDialogAccepted, this,
                           &ChooseFileController::CreateFile);
        }
      });
}

void ChooseFileController::CreateFile() {
  QString path = GetResultPath();
  LOG() << ""Creating"" << path;
  bool choose_folder = this->choose_folder;
  QString folder = this->folder;
  IoTask::Run(
      this,
      [path, choose_folder, folder] {
        if (choose_folder) {
          QDir().mkpath(path);
        } else {
          QDir().mkpath(folder.sliced(0, folder.size() - 1));
          QFile(path).open(QFile::WriteOnly);
        }
      },
      [this, path] { emit fileChosen(path); });
}

QString ChooseFileController::GetResultPath() const {
  QString path = GetPath();
  if (path.endsWith('/')) {
    path = path.sliced(0, path.length() - 1);
  }
  return path;
}

FileSuggestionListModel::FileSuggestionListModel(QObject* parent)
    : TextListModel(parent) {
  SetRoleNames({{0, ""title""}, {1, ""icon""}});
  searchable_roles = {0};
}

int FileSuggestionListModel::IndexOfSuggestionWithName(
    const QString& name) const {
  for (int i = 0; i < list.size(); i++) {
    if (list[i].name == name) {
      return i;
    }
  }
  return -1;
}

QVariantList FileSuggestionListModel::GetRow(int i) const {
  const FileSuggestion& suggestion = list[i];
  QString icon;
  if (suggestion.is_dir) {
    icon = ""folder_open"";
  } else {
    icon = ""insert_drive_file"";
  }
  return {suggestion.name, icon};
}

int FileSuggestionListModel::GetRowCount() const { return list.size(); }
",old_folder
572,"/*
 * main.cpp
 */

#include ""libpfc/include/libpfc.h""

#include <string>
#include <chrono>
#include <x86intrin.h>
#include <stdio.h>
#include <stdexcept>


#define CALIBRATION_LOOPS (300 * 1000 * 1000)
#define CPU_W ""%4""
#define REF_W ""%8""
#define TSC_W ""%8""
#define MHZ_W ""%8""


int64_t nanos() {
    auto t = std::chrono::high_resolution_clock::now();
    return std::chrono::time_point_cast<std::chrono::nanoseconds>(t).time_since_epoch().count();
}

void busy_loop(uint64_t iters) {
    volatile int  [MASK] ;
    do {
         [MASK]  = 0;
    } while (--iters > 0);
    (void) [MASK] ;
}


static void run_test() {
    auto err = pfcInit();
    if (err) {
        const char* msg = pfcErrorString(err);
        throw std::runtime_error(std::string(""pfcInit() failed (error "") + std::to_string(err) + "": "" + msg + "")"");
    }

    err = pfcPinThread(0);
    if (err) {
        // let's treat this as non-fatal, it could occur if, for example
        printf(""WARNING: Pinning to CPU 0 failed, continuing without pinning\n"");
    } else {
        printf(""Pinned to CPU 0\n"");
    }

    // just use the fixed counters for now
    PFC_CFG  cfg[7] = {2,2,2};

    err = pfcWrCfgs(0, sizeof(cfg)/sizeof(cfg[0]), cfg);
    if (err) {
        const char* msg = pfcErrorString(err);
        throw std::runtime_error(std::string(""pfcWrCfgs() failed (error "") + std::to_string(err) + "": "" + msg + "")"");
    }

    printf(CPU_W ""s"" REF_W ""s"" TSC_W ""s"" MHZ_W ""s\n"", ""CPU#"", ""REF_TSC"", ""rdtsc"", ""Eff Mhz"");

    /* calculate CPU frequency using reference cycles */
    for (int i = 0; i < 100; i++) {
        PFC_CNT cnt[7] = {};

        int64_t start = nanos();
        PFCSTART(cnt);
        int64_t tsc =__rdtsc();
        busy_loop(CALIBRATION_LOOPS);
        PFCEND(cnt);
        int64_t tsc_delta   = __rdtsc() - tsc;
        int64_t nanos_delta = nanos() - start;

        printf(CPU_W ""d"" REF_W "".2f"" TSC_W "".2f"" MHZ_W "".2f\n"",
                sched_getcpu(),
                1000.0 * cnt[PFC_FIXEDCNT_CPU_CLK_REF_TSC] / nanos_delta,
                1000.0 * tsc_delta / nanos_delta,
                1000.0 * CALIBRATION_LOOPS / nanos_delta);
    }
}

int main(int argc, char **argv) {
	run_test();
	return 0;
}


",sink
573,"#include ""LevelsetOpenCL.h""

#include <agtkIO.h>

#include ""itkImage.h""

#include <chrono>
#include <functional>

int main(int argc, char *argv[])
{
  LevelSetOpenCL::staticConstructor();

  //sizes
  agtk::Image3DSize m_Size9x, m_Size3x, m_Size1x;
  m_Size9x.Fill(10);

  m_Size3x[0] = m_Size3x[1] = m_Size9x[0] * 3;
  m_Size3x[2] = m_Size9x[0];

  m_Size1x[0] = m_Size1x[1] = m_Size3x[0] * 3;
  m_Size1x[2] = m_Size9x[0];

   //spacings
  agtk::Image3DSpacing spacing9x, spacing3x, spacing1x;
  spacing9x.Fill(1);

  spacing3x[0] = spacing3x[1] = spacing9x[0] / 3;
  spacing3x[2] = 1;

  spacing1x[0] = spacing1x[1] = spacing3x[0] / 3;
  spacing1x[2] = 1;

  agtk::FloatImage3D::Pointer input9x = agtk::FloatImage3D::New();
  input9x->SetSpacing(spacing9x);
  input9x->SetRegions(agtk::Image3DRegion(m_Size9x));
  input9x->Allocate();
  input9x->FillBuffer(0);
  agtk::Image3DIndex index;
  index.Fill(1);
  input9x->SetPixel(index, 1);
  //save
  agtk::writeImage(input9x, std::string(""B:/input9x.nrrd""));
 
  auto m_QueueExec = cl::CommandQueue(LevelSetOpenCL::s_OpenCL->context, LevelSetOpenCL::s_OpenCL->device);

  const int Dim = 3;
  cl::size_t<Dim> m_OriginZero; //todo const
  for (int i = 0; i < Dim; ++i) {
    m_OriginZero[i] = 0;
  }

  auto copyToItk = [&](cl::Image3D from, ImageType* to, const cl::size_t<Dim>& size)
  {
    m_QueueExec.enqueueReadImage(
      from,
      CL_TRUE,
      m_OriginZero,
      size,
      0, 0,
      to->GetBufferPointer()
      );
    m_QueueExec.finish();
  };

  auto downsample = [&](cl::Image3D from, cl::Image3D to, agtk::Image3DSize size) {
    cl::Kernel downsample3Kernel(LevelSetOpenCL::s_OpenCL->program, ""downsample3x3"");
    downsample3Kernel.setArg(0, from);
    downsample3Kernel.setArg(1, to);
    m_QueueExec.enqueueNDRangeKernel(
      downsample3Kernel,
      cl::NullRange,
      cl::NDRange(size[0], size[1], size[2]),
      cl::NullRange
      );

    m_QueueExec.finish();
  };

  auto upsample = [&](cl::Image3D from, cl::Image3D to, agtk::Image3DSize size) {
    cl::Kernel downsample3Kernel(LevelSetOpenCL::s_OpenCL->program, ""upsample3_1"");
    downsample3Kernel.setArg(0, from);
    downsample3Kernel.setArg(1, to);
    m_QueueExec.enqueueNDRangeKernel(
      downsample3Kernel,
      cl::NullRange,
      cl::NDRange(size[0], size[1], size[2]),
      cl::NullRange
      );

    m_QueueExec.finish();
  };

  auto save = [&](cl::Image3D image, agtk::Image3DSize size, agtk::Image3DSpacing spacing, std::string filename) {
    auto  [MASK]  = agtk::FloatImage3D::New();
     [MASK] ->SetRegions(agtk::Image3DRegion(size));
     [MASK] ->SetSpacing(spacing);
     [MASK] ->Allocate();
     [MASK] ->FillBuffer(0);

    cl::size_t<3> sizeCl;
    sizeCl[0] = size[0];
    sizeCl[1] = size[1];
    sizeCl[2] = size[2];
    copyToItk(image,  [MASK] , sizeCl);
    agtk::writeImage( [MASK] , filename);
  };

  auto m_InputData9x = cl::Image3D(
    LevelSetOpenCL::s_OpenCL->context,
    CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
    cl::ImageFormat(CL_R, CL_FLOAT),
    m_Size9x[0], // Width(),
    m_Size9x[1], // Height(),
    m_Size9x[2], // Depth(),
    0, 0,
    const_cast<float*>(input9x->GetBufferPointer())
    );
  auto m_InputData9x_ = cl::Image3D(
    LevelSetOpenCL::s_OpenCL->context,
    CL_MEM_READ_WRITE,
    cl::ImageFormat(CL_R, CL_FLOAT),
    m_Size9x[0], // Width(),
    m_Size9x[1], // Height(),
    m_Size9x[2] // Depth(),
    );

  auto m_InputData3x_ = cl::Image3D(
    LevelSetOpenCL::s_OpenCL->context,
    CL_MEM_READ_WRITE,
    cl::ImageFormat(CL_R, CL_FLOAT),
    m_Size3x[0], // Width(),
    m_Size3x[1], // Height(),
    m_Size3x[2] // Depth(),
    );

  auto m_InputData3x = cl::Image3D(
    LevelSetOpenCL::s_OpenCL->context,
    CL_MEM_READ_WRITE,
    cl::ImageFormat(CL_R, CL_FLOAT),
    m_Size3x[0], // Width(),
    m_Size3x[1], // Height(),
    m_Size3x[2] // Depth(),
    );

  auto m_InputData1x = cl::Image3D(
    LevelSetOpenCL::s_OpenCL->context,
    CL_MEM_READ_WRITE,
    cl::ImageFormat(CL_R, CL_FLOAT),
    m_Size1x[0], // Width(),
    m_Size1x[1], // Height(),
    m_Size1x[2] // Depth(),
    );

  //proc
  upsample(m_InputData9x, m_InputData3x, m_Size3x);
  save(m_InputData3x, m_Size3x, spacing3x, std::string(""B:/input3x.nrrd""));

  upsample(m_InputData3x, m_InputData1x, m_Size1x);
  save(m_InputData1x, m_Size1x, spacing1x, std::string(""B:/input1x.nrrd""));

  downsample(m_InputData1x, m_InputData3x_, m_Size3x);
  save(m_InputData3x_, m_Size3x, spacing3x, std::string(""B:/input3x_.nrrd""));
 
  downsample(m_InputData3x, m_InputData9x_, m_Size9x);
  save(m_InputData9x_, m_Size9x, spacing9x, std::string(""B:/input9x_.nrrd""));
 
  system(""pause"");

  return EXIT_SUCCESS;
}

",imageItk
574,"//
//    rfnoc-hls-neuralnet: Vivado HLS code for neural-net building blocks
//
//    Copyright (C) 2017 <NAME>
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program 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 General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
#include <fstream>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include ""firmware/parameters.h""
#include ""firmware/myproject.h""
#include ""nnet_helpers.h""


int main(int argc, char **argv)
{
    
    //hls-fpga-machine-learning insert data
    //input_t  data_str[Y_INPUTS][N_CHAN];
    //for(int i=0; i<Y_INPUTS; i++){
    //    for(int j=0; j<N_CHAN; j++){
    //	    data_str[i][j]=1;
    //	}
    //}
  input_t  data_str[Y_INPUTS][N_CHAN] = {0.2794435, 0.04060272, -0.05572316, -0.1889425, 0.2780532, -0.1243143, -0.05448467, 0.1114198, -0.07794067, -0.09206132, -0.1932618, 0.1010775, 0.009639716, -0.06205285, 0.01033651, 0.2041055, 0.200241, -0.07361811, 0.3155678, 0.1373228, 0.3606532, -0.3027224, -0.07007817, 0.2620515};

    result_t res_str[N_OUTPUTS];
    for(int i=0; i<N_OUTPUTS; i++){
	    res_str[i]=0;
    }

    unsigned short size_in,  [MASK] ;
    myproject(data_str, res_str, size_in,  [MASK] );

    result_t res_expected[N_OUTPUTS] = {0.528625502721, 0.352447456382, 0.11757160967, 0.000254924257721, 8.45225898784e-05, 0.00101598437936};
    
    for(int i=0; i<N_OUTPUTS; i++){
	std::cout << res_str[i] << "" (expected "" << res_expected[i] << "", "" << 100.0*((float)res_str[i]-(float)res_expected[i])/(float)res_expected[i] << "" percent difference)"" << std::endl;
    }
    //std::cout << std::endl;
    
    return 0;
}
",size_out
575,"#pragma once
#define VOCLIB_IMPLEMENTATION
#include <voclib.h>
#include <exception>
#include <vector>

class Vocoder {
public:
Vocoder(unsigned char bands, unsigned char filters_per_band, unsigned int  [MASK] ) {
if (!voclib_initialize(this->voc_instance, bands, filters_per_band,  [MASK] )) {
throw std::runtime_error(""A parameter (bands, filters per band, or sample rate) was outside of its range."");
}
}

std::vector<float> Process(const float* carrier_buffer, const float* modulator_buffer, unsigned int frames) {
// We allocate a larger size than we most probably need to ensure that we have enough space since this could verry easily go out of bounds.
// TODO: determine if this allocates too much memory.
std::vector<float> buf(sizeof(carrier_buffer)*sizeof(modulator_buffer));
if (!voclib_process(this->voc_instance, carrier_buffer, modulator_buffer, buf.data(), frames)) {
throw std::runtime_error(""Process: one or more parameters are not valid."");
} else {
return buf;
}
}

// Nice little compatibility version, if you so choose to use it.
std::vector<float> Process(const std::vector<float> carrier_buffer, const std::vector<float> modulator_buffer, unsigned int frames) {
std::vector<float> buf(sizeof(carrier_buffer)+sizeof(modulator_buffer));
if (!voclib_process(this->voc_instance, carrier_buffer.data(), modulator_buffer.data(), buf.data(), frames)) {
throw std::runtime_error(""Process: one or more parameters are not valid."");
} else {
return buf;
}
}

void Reset() {
voclib_reset_history(this->voc_instance);
}

void SetReactionTime(float reaction_time) {
if (!voclib_set_reaction_time(this->voc_instance, reaction_time)) {
throw std::runtime_error(""Invalid reaction time! Range: 0.002-2.0"");
}
}

float GetReactionTime() {
return voclib_get_reaction_time(this->voc_instance);
}

void SetFormantShift(float formant_shift) {
if (!voclib_set_formant_shift(this->voc_instance, formant_shift)) {
throw std::runtime_error(""Formant shift is not valid. Range: 0.25-4.0"");
}
}

float GetFormantShift() {
return voclib_get_formant_shift(this->voc_instance);
}
private:
voclib_instance* voc_instance;
};
",sample_rate
576,"#include ""custom_tree_widget.h""

#include <QByteArray>
#include <QDebug>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QImage>
#include <QLabel>
#include <QMimeData>
#include <QMouseEvent>
#include <QPainter>
#include <QPixmap>
#include ""glog/logging.h""
CustomTreeWidget::CustomTreeWidget(QWidget* parent) : QTreeWidget(parent) {
  this->installEventFilter(this);
  this->setMouseTracking(true);
  this->setAcceptDrops(true);
  m_bNewTreeState = false;
}

void CustomTreeWidget::setNewTreeState(bool state) {
  m_bNewTreeState = state;
}

void CustomTreeWidget::dragEnterEvent(QDragEnterEvent* event) {
  if (event->mimeData()->hasText()) {
    if (event->source() == this) {
      event->setDropAction(Qt::MoveAction);
      event->accept();
    } else {
      event->acceptProposedAction();
    }
  } else {
    event->ignore();
  }
}

void CustomTreeWidget::dragMoveEvent(QDragMoveEvent* event) {
  if (event->mimeData()->hasText()) {
    if (event->source() == this) {
      event->setDropAction(Qt::MoveAction);
      event->accept();
    } else {
      event->acceptProposedAction();
    }
  } else {
    event->ignore();
  }
}

void CustomTreeWidget::dropEvent(QDropEvent* event) {
  //    if (event->mimeData()->hasFormat(""application/x-dnditemdata"")) {
  //        QByteArray itemData =
  //        event->mimeData()->data(""application/x-dnditemdata""); QDataStream
  //        dataStream(&itemData, QIODevice::ReadOnly);

  //        QPixmap pixmap;
  //        QPoint offset;
  //        dataStream >> pixmap >> offset;

  //        QLabel *newIcon = new QLabel(this);
  //        newIcon->setPixmap(pixmap);
  //        newIcon->move(event->pos() /*- offset*/);
  //        newIcon->show();
  //        newIcon->setAttribute(Qt::WA_DeleteOnClose);

  //        if (event->source() == this) {
  //            event->setDropAction(Qt::MoveAction);
  //            event->accept();
  //        } else {
  //            event->acceptProposedAction();
  //        }
  //    } else {
  //        event->ignore();
  //    }

  //    qDebug() << ""-------dropEvent"";
  //    if(m_pNewTreeWidget == nullptr) {
  //        qDebug() << ""-------2"";
  //        m_pNewTreeWidget = new NewTreeWidget;
  //        m_pNewTreeWidget->resize(200, 300);
  //        m_pNewTreeWidget->move(mapToGlobal(event->pos()));
  //        m_pNewTreeWidget->show();
  //    }
}

void CustomTreeWidget::dragLeaveEvent(QDragLeaveEvent* event) {
  qDebug() << ""-------dragLeaveEvent"";

  Q_UNUSED(event);

  QList<QString> listItemText = getSelectedItemsText();
  if (!m_bNewTreeState) {
    if (listItemText.count()) {
      emit signalCreateNewTree(listItemText);
    }
  } else {
    if (listItemText.count()) {
      emit signalNewItemText(listItemText);
    }
  }
}

void CustomTreeWidget::mouseReleaseEvent(QMouseEvent* event) {
  is_pressed = false;
  QTreeWidget::mouseReleaseEvent(event);
  qDebug() << ""-------mouseReleaseEvent---------------"";
}

// void DragTreeWidget::mouseMoveEvent(QMouseEvent *event)
//{
//    static int i = 0;
//    qDebug() << ""-------mouseMoveEvent"" << i++;
//}

bool CustomTreeWidget::eventFilter(QObject* target, QEvent* event) {
  //    if(event->type() == QEvent::MouseMove)
  //    {
  //       // This piece of code is never called
  //        qDebug() << ""-------mouseMoveEvent"";
  //    }
  return QTreeWidget::eventFilter(target, event);
}

QList<QString> CustomTreeWidget::getSelectedItemsText() {
  QList<QString> listItemText;
  QList<QTreeWidgetItem*> listItem = this->selectedItems();
  if (listItem.count()) {
    foreach (QTreeWidgetItem* item, listItem) {
      QString text = item->text(0);
      if (item->childCount() == 0)
        listItemText.append(text);
    }
  }
  return listItemText;
}

void CustomTreeWidget::mousePressEvent(QMouseEvent* event) {
  is_pressed = true;
  index_list_ = this->selectedIndexes();
  QTreeWidget::mousePressEvent(event);
  QList<QString>  [MASK]  = getSelectedItemsText();
  if ( [MASK] .count() == 0) {
    return;
  }

  QImage image(30, 10, QImage::Format_ARGB32);
  image.fill(QColor(47, 168, 236, 150));
  QPixmap pixmap = QPixmap::fromImage(image);
  // pixmap.load(Global::GetImagePath() + ""hover.png"");

  //  dataStream << pixmap
  //             << QPoint(event->pos() /*- child->pos()*/ +
  //                       QPoint(pixmap.width() / 2, pixmap.height() / 2));
  std::string res;
  for (auto model_index : this->selectedIndexes()) {
    LOG(INFO) << model_index.row();
    res.append(std::to_string(model_index.row()) + ""-"");
  }
  QMimeData* mimeData = new QMimeData;
  QString q_str = QString::fromStdString(res);
  mimeData->setText(q_str);

  QPixmap tempPixmap = pixmap;
  QPainter painter;
  painter.begin(&tempPixmap);
  // painter.fillRect(pixmap.rect(), QColor(47, 168, 236, 150));
  if (m_bNewTreeState) {
    QFont font = painter.font();
    font.setPixelSize(16);
    painter.setFont(font);
    QPen pen = painter.pen();
    pen.setStyle(Qt::DotLine);
    pen.setColor(QColor(""#2FEC2F""));
    painter.setPen(pen);

    for (int i = 0; i <  [MASK] .size(); i++) {
      const QRect rectangle = QRect(10, 10 + 40 * i, pixmap.width() - 10, 50);
      QRect boundingRect;
      painter.drawText(rectangle, 0,  [MASK] .at(i), &boundingRect);
    }
    auto index_list = this->selectedIndexes();
    for (auto& index : index_list) {
    }
  }
  painter.end();

  QDrag* drag = new QDrag(this);
  drag->setMimeData(mimeData);
  drag->setPixmap(tempPixmap);
  drag->setHotSpot(/*mapToGlobal(event->pos())*/ QPoint(pixmap.width() / 2,
                                                        pixmap.height() / 2));

  if (drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction) ==
      Qt::MoveAction) {
    //        child->close();
  } else {
    //        child->show();
    //        child->setPixmap(pixmap);
  }
}
bool CustomTreeWidget::IsMousePressedFromDataTree() {
  return is_pressed;
}
",listText
577,"#include ""../common/platform.h""
#include ""theater.h""

#include ""../common/file_system.h""
#include ""../common/xml.h""
#include ""../display/text_edit.h""
#include ""bitmap.h""
#include ""engine.h""
#include ""global.h""

namespace engine {

static BadgeRole stringToRole(const xml::saxString& role);

class UnitsFile : public xml::Parser {
	static const int ROOT = 1;

		bool has_images_;
		xml::saxString images_;

	static const int BADGE = 2;

		bool has_id_;
		xml::saxString id_;
		bool has_label_;
		xml::saxString label_;
		bool has_index_;
		int index_;
		bool has_role_;
		xml::saxString role_;

public:
	UnitsFile(display::TextBufferSource* source, BadgeFile* badgeFile, BadgeData* badgeData) : xml::Parser(null) {
		_source = source;
		_badgeFile = badgeFile;
		_badgeData = badgeData;
	}

	bool load() {
		const display::TextBufferSource::Value* v = _source->pin();
		open((*v)->image);
		v->release();
		return parse();
	}

	virtual int matchTag(const xml::saxString& tag) {
		if (tag.equals(""root"")) {
			return ROOT;
		} else if (tag.equals(""badge"")) {
			has_id_ = false;
			has_label_ = false;
			has_index_ = false;
			has_role_ = false;
			return BADGE;
		} else
			return -1;
	}

	virtual bool matchedTag(int index) {
		switch (index) {
		case ROOT:
			if (!has_images_)
				return false;
			root(images_);
			return true;
		case BADGE:
			if (!has_id_ || !has_label_ || !has_index_ || !has_role_)
				return false;
			badge(id_, label_, index_, role_);
			return true;
		default:
			return false;
		}
	}

	virtual bool matchAttribute(int index, 
								xml::XMLParserAttributeList* attribute) {
		switch (index) {
		case BADGE:
			if (attribute->name.equals(""id"")) {
				has_id_ = true;
				id_ = attribute->value;
			} else if (attribute->name.equals(""label"")) {
				has_label_ = true;
				label_ = attribute->value;
			} else if (attribute->name.equals(""index"")) {
				has_index_ = true;
				index_ = attribute->value.toInt();
			} else if (attribute->name.equals(""role"")) {
				has_role_ = true;
				role_ = attribute->value;
			} else
				return false;
			return true;
		case ROOT:
			if (attribute->name.equals(""images"")) {
				has_images_ = true;
				images_ = attribute->value;
			} else
				return false;
			return true;
		default:
			return false;
		}
	}

	virtual void errorText(xml::ErrorCodes code, 
						   const xml::saxString& text,
						   script::fileOffset_t  [MASK] ) {
		global::reportError(_source->filename(), ""'"" + text.toString() + ""' "" + xml::errorCodeString(code),  [MASK] );
	}

	void root(const xml::saxString& images) {
		_badgeData->unitMap = loadBitMap(fileSystem::pathRelativeTo(images.toString(), _source->filename()));
		_badgeData->emptyUnitMap = _badgeData->unitMap->dupHeader();
		_badgeData->emptyUnitMap->setColorPalette(0, 0xff0000);
		_badgeData->toeUnitMap = _badgeData->unitMap->dupHeader();
		_badgeData->toeUnitMap->setColorPalette(0, 0xc0c0c0);
	}

	void badge(const xml::saxString& id, const xml::saxString& label, int index, const xml::saxString& role) {
		BadgeInfo* b = _badgeData->getBadge(id.text, id.length);
		if (b != null)
			global::reportError(_source->filename(), ""Duplicate badge id"", textLocation(id));
		else {
			BadgeInfo* b = new BadgeInfo(id.toString(), label.toString(), stringToRole(role), index);
			_badgeData->defineBadge(b->id, b);
		}
	}

private:
	display::TextBufferSource*	_source;
	BadgeFile*					_badgeFile;
	BadgeData*					_badgeData;
};

BadgeInfo* BadgeData::getBadge(const char* text, int length) const {
	return *_badges.get(string(text, length));
}

bool BadgeData::defineBadge(const string& name, BadgeInfo* badge) {
	return _badges.put(name, badge);
}

BadgeFile* BadgeFile::factory(const string& filename) {
	static dictionary<BadgeFile*> badgeFiles;

	display::TextBufferManager* tbm = manageTextFile(filename);
	return global::fileWeb.manageFile(tbm->filename(), tbm->source(&global::fileWeb), &badgeFiles);
}

BadgeFile::BadgeFile(display::TextBufferSource* source) : derivative::Object<BadgeData>(source->web()) {
	_source = source;
	_age = 0;
}

bool BadgeFile::build() {
	bool result = true;
	if (_age != _source->age()) {
		_age = _source->age();

		BadgeData* mutableV;
		const derivative::Value<BadgeData>* v = derivative::Value<BadgeData>::factory(&mutableV);

		UnitsFile u(_source, this, mutableV);

		result = u.load();
		if (result)
			set(v);
	}
	return result;
}

fileSystem::TimeStamp BadgeFile::age() {
	return _age;
}

string BadgeFile::toString() {
	return ""BadgeFile "" + _source->filename();
}

void BadgeFile::setSource(display::TextBufferSource* source) {
	if (_source != source) {
		removeDependency(_source);
		dependsOn(source);
		global::fileWeb.addToBuild(source);
		_source = source;
	}
}

BadgeInfo::BadgeInfo() {
}

BadgeInfo* BadgeInfo::factory(fileSystem::Storage::Reader* r) {
	BadgeInfo* b = new BadgeInfo();
	int role;
	if (r->read(&role) &&
		r->read(&b->label) &&
		r->read(&b->index)) {
		b->role = (BadgeRole)role;
		return b;
	} else {
		delete b;
		return null;
	}
}

void BadgeInfo::store(fileSystem::Storage::Writer* o) const {
	o->write((int)role);
	o->write(label);
	o->write(index);
}

bool BadgeInfo::equals(const BadgeInfo* b) const {
	if (role == b->role &&
		label == b->label &&
		index == b->index)
		return true;
	else
		return false;
}


bool isNoncombat(BadgeRole r) {
	return r == BR_PASSIVE || r == BR_SUPPLY || r == BR_HQ;
}

static BadgeRole stringToRole(const xml::saxString& role) {
	if (role.length == 0)
		return BR_NONE;
	else if (role.equals(""attdef""))
		return BR_ATTDEF;
	else if (role.equals(""hq""))
		return BR_HQ;
	else if (role.equals(""tac""))
		return BR_TAC;
	else if (role.equals(""def""))
		return BR_DEF;
	else if (role.equals(""art""))
		return BR_ART;
	else if (role.equals(""passive""))
		return BR_PASSIVE;
	else if (role.equals(""supply""))
		return BR_SUPPLY;
	else if (role.equals(""supplyDepot""))
		return BR_SUPPLY_DEPOT;
	else if (role.equals(""fighter""))
		return BR_FIGHTER;
	else if (role.equals(""lowbomb""))
		return BR_LOWBOMB;
	else if (role.equals(""hibomb""))
		return BR_HIBOMB;
	else
		fatalMessage(""Incorrect role "" + role.toString());
	return BR_NONE;
}

}  // namespac engine
",location
578,"//
// Copyright 2017 The Android Open Source Project
//
// 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.
//

#pragma once

#include <hidl/HidlSupport.h>

#include ""async_fd_watcher.h""
#include ""hci_internals.h""
#include ""hci_protocol.h""

namespace android {
namespace hardware {
namespace bluetooth {
namespace hci {

class H4Protocol : public HciProtocol {
private:
    int                 mSocketFd;
    uint8_t             mTxBuf[2048];

    PacketReadCallback  mEventCb;
    PacketReadCallback  mAclCb;
    PacketReadCallback  mScoCb;

    HciPacketType       mHciPacketType;
    hci::HciPacketizer  mHciPacketizer;

public:
    H4Protocol(int fd, PacketReadCallback  [MASK] , PacketReadCallback acl_cb, PacketReadCallback sco_cb) :
        mSocketFd(fd),
        mEventCb( [MASK] ),
        mAclCb(acl_cb),
        mScoCb(sco_cb),
        mHciPacketType(HCI_PACKET_TYPE_UNKNOWN),
        mHciPacketizer([this]() { OnPacketReady(); }) {}

    size_t Send(uint8_t type, const uint8_t* data, size_t length);

    void OnPacketReady(void);
    void OnDataReady(int fd);
};

}  // namespace hci
}  // namespace bluetooth
}  // namespace hardware
}  // namespace android
",event_cb
579,"//
// Created by foxfire on 1/20/18.
//

#include ""gfx_opengl.hpp""

#include <cstdio>
#include <string>

#ifdef __APPLE__
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#endif

#include ""fox/counter.hpp""
#include ""fox/gfx/eigen_opengl.hpp""
#include ""fox/obj_model_loader.h""

#ifdef __ANDROID__
std::string data_root = ""/sdcard/opengl_testing1"";
#elif __APPLE__
std::string data_root = ""/Users/foxfire/dev/opengl_testing1"";
#elif _WIN32
std::string data_root = ""C:/dev/opengl_testing1"";
#else // Linux
std::string data_root = ""/home/foxfire/dev/opengl_testing1"";
#endif

#define print_opengl_error() print_opengl_error2((char *)__FILE__, __LINE__)
int print_opengl_error2(char *file, int line);

gfx_opengl::gfx_opengl() : gfx()
{

}

gfx_opengl::~gfx_opengl()
{

}

void gfx_opengl::init(int w, int h)
{
	win_w = w;
	win_h = h;
	
	// init glew first
	glewExperimental = GL_TRUE; // Needed in core profile
	if(glewInit() != GLEW_OK)
	{
		printf(""Failed to initialize GLEW\n"");
		exit(-1);
	}
	
	// HACK: to get around initial glew error with core profiles
	GLenum gl_err = glGetError();
	while(gl_err != GL_NO_ERROR)
	{
		//printf(""glError in file %s @ line %d: %s (after glew init)\n"",
		//	(char *)__FILE__, __LINE__, gluErrorString(gl_err));
		gl_err = glGetError();
	}
	
	print_opengl_error();
	
	print_info();
	
	// init basic OpenGL stuff
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	
	glEnable(GL_DEPTH_TEST);
	glDisable(GL_BLEND); // alpha channel
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	
	glEnable(GL_POLYGON_SMOOTH);
	glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
	
	// OpenGL 3.2 core requires a VAO to be bound to use a VBO
	// WARNING: GLES 2.0 does not support VAOs
	glGenVertexArrays(1, &default_vao);
	glBindVertexArray(default_vao);
	
	// initialize some defaults
	trans = {0.0f, 0.0f, 0.0f};
	rot = {0.0f, 0.0f, 0.0f};
	
	eye = Eigen::Vector3f(0.0f, 0.0f, 3.0f);
	target = Eigen::Vector3f(0.0f, 0.0f, 0.0f);
	up = Eigen::Vector3f(0.0f, 1.0f, 0.0f);
	
	fox::gfx::look_at(eye, target, up, V);
	
	color = Eigen::Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
	La = Eigen::Vector3f(1.0f,1.0f, 1.0f);
	Ls = Eigen::Vector3f(1.0f,1.0f, 1.0f);
	Ld = Eigen::Vector3f(1.0f,1.0f, 1.0f);
	rot = Eigen::Vector3f(0.0f, 0.0f, 0.0f);
	trans = Eigen::Vector3f(0.0f, 0.0f, 0.0f);
	scale = 1.0f;
	light_pos = Eigen::Vector4f(eye[0], eye[1], eye[2], 1.0f);
	M = Eigen::Matrix4f::Identity();
	fox::gfx::perspective(65.0f, (float)w / (float)h, 0.01f, 40.0f, P);
	
	MV = V * M;
	
	normal_matrix(0, 0) = MV(0, 0);
	normal_matrix(0, 1) = MV(0, 1);
	normal_matrix(0, 2) = MV(0, 2);
	
	normal_matrix(1, 0) = MV(1, 0);
	normal_matrix(1, 1) = MV(1, 1);
	normal_matrix(1, 2) = MV(1, 2);
	
	normal_matrix(2, 0) = MV(2, 0);
	normal_matrix(2, 1) = MV(2, 1);
	normal_matrix(2, 2) = MV(2, 2);
	
	MVP = P * MV;
	
	load_shaders();
	
	// load a mesh
	mesh = (OBJ_MODEL *)malloc(sizeof(OBJ_MODEL));
	if(mesh == nullptr)
	{
		printf(""Failed to allocate memory for obj model\n"");
		exit(-1);
	}
	std::string mesh_file = data_root + ""/meshes/icosphere.obj"";
	obj_model_load(mesh_file.c_str(), mesh);
	if(obj_model_check_arrays(mesh))
		obj_model_gl_arrays(mesh);
	obj_model_print_info(mesh);
	printf(""Model has %d verticies\n"", mesh->vert_count);
	printf(""Vertex data takes up %.3f MB\n"", (float)mesh->vert_count * 12 /
											 (1024 * 1024));
	printf(""Normal data takes up %.3f MB\n"", (float)mesh->vert_count * 12 /
											 (1024 * 1024));
	
	// see if we have a material file to load uniforms from
	if(mesh->mtl)
	{
		Ka = Eigen::Vector3f(mesh->mtl->Ka[0], mesh->mtl->Ka[1], mesh->mtl->Ka[2]);
		Ks = Eigen::Vector3f(mesh->mtl->Ks[0], mesh->mtl->Ks[1], mesh->mtl->Ks[2]);
		Kd = Eigen::Vector3f(mesh->mtl->Kd[0], mesh->mtl->Kd[1], mesh->mtl->Kd[2]);
		// TODO: make sure Ns is what we want for shininess
		shininess = mesh->mtl->Ns;
		
		//this->texture_filename = m->mtl->texture_filename;
	}
		// otherwise create some defaults at least
	else
	{
		Ka = Eigen::Vector3f(0.3f, 0.3f, 0.3f);
		Ks = Eigen::Vector3f(0.1f, 0.1f, 0.1f);
		Kd = Eigen::Vector3f(0.6f, 0.6f, 0.6f);
		shininess = 5.0f;
	}
	
	// create VBOs
	glGenBuffers(1, &vertex_vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * mesh->vert_count * 3,
				 mesh->v, GL_STATIC_DRAW);
	print_opengl_error();
	glGenBuffers(1, &normal_vbo);
	glBindBuffer(GL_ARRAY_BUFFER, normal_vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * mesh->vert_count * 3,
				 mesh->vn, GL_STATIC_DRAW);
	print_opengl_error();
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	
	// set shader uniforms and arrays
	int u;
	glUseProgram(shader_id);
	u = glGetUniformLocation(shader_id, ""light_pos"");
	glUniform4fv(u, 1, light_pos.data());
	u = glGetUniformLocation(shader_id, ""La"");
	glUniform3fv(u, 1, La.data());
	u = glGetUniformLocation(shader_id, ""Ls"");
	glUniform3fv(u, 1, Ls.data());
	u = glGetUniformLocation(shader_id, ""Ld"");
	glUniform3fv(u, 1, Ld.data());
	u = glGetUniformLocation(shader_id, ""color"");
	glUniform4fv(u, 1, color.data());
	u = glGetUniformLocation(shader_id, ""MVP"");
	glUniformMatrix4fv(u, 1, GL_FALSE, MVP.data());
	u = glGetUniformLocation(shader_id, ""MV"");
	glUniformMatrix4fv(u, 1, GL_FALSE, MV.data());
	u = glGetUniformLocation(shader_id, ""normal_matrix"");
	glUniformMatrix3fv(u, 1, GL_FALSE, normal_matrix.data());
	u = glGetUniformLocation(shader_id, ""shininess"");
	glUniform1f(u, shininess);
	u = glGetUniformLocation(shader_id, ""Ka"");
	glUniform3fv(u, 1, Ka.data());
	u = glGetUniformLocation(shader_id, ""Ks"");
	glUniform3fv(u, 1, Ks.data());
	u = glGetUniformLocation(shader_id, ""Kd"");
	glUniform3fv(u, 1, Kd.data());
	print_opengl_error();
	
	// start counters
	update_counter = new fox::counter();
	fps_counter = new fox::counter();
	
	rot_vel = 16.0f;
}

void gfx_opengl::render()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	float dt = update_counter->update();
	rot[1] = rot_vel * dt;
	M = M * Eigen::AngleAxisf(rot[0] / 180.0f * (float)M_PI,
							  Eigen::Vector3f::UnitX());
	M = M * Eigen::AngleAxisf(rot[1] / 180.0f * (float)M_PI,
							  Eigen::Vector3f::UnitY());
	M = M * Eigen::AngleAxisf(rot[2] / 180.0f * (float)M_PI,
							  Eigen::Vector3f::UnitZ());
	
	MV = V * M;
	
	normal_matrix(0, 0) = MV(0, 0);
	normal_matrix(0, 1) = MV(0, 1);
	normal_matrix(0, 2) = MV(0, 2);
	
	normal_matrix(1, 0) = MV(1, 0);
	normal_matrix(1, 1) = MV(1, 1);
	normal_matrix(1, 2) = MV(1, 2);
	
	normal_matrix(2, 0) = MV(2, 0);
	normal_matrix(2, 1) = MV(2, 1);
	normal_matrix(2, 2) = MV(2, 2);
	
	MVP = P * MV;
	
	glUseProgram(shader_id);
	int u;
	u = glGetUniformLocation(shader_id, ""MVP"");
	glUniformMatrix4fv(u, 1, GL_FALSE, MVP.data());
	u = glGetUniformLocation(shader_id, ""MV"");
	glUniformMatrix4fv(u, 1, GL_FALSE, MV.data());
	u = glGetUniformLocation(shader_id, ""normal_matrix"");
	glUniformMatrix3fv(u, 1, GL_FALSE, normal_matrix.data());
	GLint vertex_loc, normal_loc;
	vertex_loc = glGetAttribLocation(shader_id, ""vertex"");
	normal_loc = glGetAttribLocation(shader_id, ""normal"");
	
	glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
	glEnableVertexAttribArray(vertex_loc);
	glVertexAttribPointer(vertex_loc, 3, GL_FLOAT, GL_FALSE, 0, 0);
	
	glBindBuffer(GL_ARRAY_BUFFER, normal_vbo);
	glEnableVertexAttribArray(normal_loc);
	glVertexAttribPointer(normal_loc, 3, GL_FLOAT, GL_FALSE, 0, 0);
	
	glDrawArrays(GL_TRIANGLES, 0, mesh->vert_count);
	
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void gfx_opengl::resize(int w, int h)
{
	win_w = w;
	win_h = h;
	
	glViewport(0, 0, win_w, win_h);
	fox::gfx::perspective(65.0f, (float)win_w / (float)win_h, 0.01f, 40.0f, P);
	//fox::gfx::ortho(0.0f, (float)win_w, 0.0f, (float)win_h, -10.0f, 10.0f, P);
	
	MVP = P * MV;
	
	glUseProgram(shader_id);
	int u;
	u = glGetUniformLocation(shader_id, ""MVP"");
	glUniformMatrix4fv(u, 1, GL_FALSE, MVP.data());
}

void gfx_opengl::deinit()
{
	// TODO: can this be freed earlier?
	if(shader_vert_id != 0)
		glDeleteShader(shader_vert_id);
	// TODO: can this be freed earlier?
	if(shader_frag_id != 0)
		glDeleteShader(shader_frag_id);
	if(shader_id != 0)
		glDeleteProgram(shader_id);
	
	glDeleteBuffers(1, &vertex_vbo);
	glDeleteBuffers(1, &normal_vbo);
	
	// TODO: this probably can be done after the VBOs are created
	obj_model_free(mesh);
	
	delete update_counter;
	delete fps_counter;
}

void gfx_opengl::load_shaders()
{
	print_opengl_error();
	
	// load shaders
	std::string fname = data_root + ""/shaders/smooth_ads_v150.vert"";
	FILE *f;
	uint8_t *vert_data, *frag_data;
	long  [MASK] , vsize;
	long ret, result;
	f = fopen(fname.c_str(), ""rt"");
	if(f == NULL)
	{
		printf(""ERROR couldn't open shader file %s\n"", fname.c_str());
		exit(-1);
	}
	// find the file size
	fseek(f, 0, SEEK_END);
	vsize = ftell(f);
	rewind(f);
	
	vert_data = (uint8_t *)malloc(sizeof(uint8_t) * vsize);
	if(vert_data == nullptr)
	{
		printf(""Failed to allocate vertex shader memory\n"");
		exit(-1);
	}
	result = fread(vert_data, sizeof(uint8_t), vsize, f);
	if(result != vsize)
	{
		printf(""ERROR: loading shader: %s\n"", fname.c_str());
		printf(""Expected %d bytes but only read %d\n"", vsize, result);
		
		fclose(f);
		free(vert_data);
		exit(-1);
	}
	// TODO: is this really a good idea?
	vert_data[vsize - 1] = '\0';
	fclose(f);
	
	fname = data_root + ""/shaders/smooth_ads_v150.frag"";
	f = fopen(fname.c_str(), ""rt"");
	if(f == NULL)
	{
		printf(""ERROR couldn't open shader file %s\n"", fname.c_str());
		exit(-1);
	}
	// find the file size
	fseek(f, 0, SEEK_END);
	 [MASK]  = ftell(f);
	rewind(f);
	
	frag_data = (uint8_t *)malloc(sizeof(uint8_t) *  [MASK] );
	if(frag_data == nullptr)
	{
		printf(""Failed to allocate vertex shader memory\n"");
		exit(-1);
	}
	result = fread(frag_data, sizeof(uint8_t),  [MASK] , f);
	if(result !=  [MASK] )
	{
		printf(""ERROR: loading shader: %s\n"", fname.c_str());
		printf(""Expected %d bytes but only read %d\n"",  [MASK] , result);
		
		fclose(f);
		free(frag_data);
		exit(-1);
	}
	// TODO: is this really a good idea?
	frag_data[ [MASK]  - 1] = '\0';
	fclose(f);
	
	// actually create the shader
	shader_vert_id = glCreateShader(GL_VERTEX_SHADER);
	if(shader_vert_id == 0)
	{
		printf(""Failed to create GL_VERTEX_SHADER!\n"");
		exit(-1);
	}
	glShaderSource(shader_vert_id, 1, (GLchar **)&vert_data, NULL);
	glCompileShader(shader_vert_id);
	free(vert_data);
	
	// print shader info log
	int length = 0, chars_written = 0;
	char *info_log;
	glGetShaderiv(shader_vert_id, GL_INFO_LOG_LENGTH, &length);
	// WTF? so why was 4 used?
	// use 2 for the length because NVidia cards return a line feed always
	if(length > 4)
	{
		info_log = (char *)malloc(sizeof(char) * length);
		if(info_log == NULL)
		{
			printf(""ERROR couldn't allocate %d bytes for shader info log!\n"",
				   length);
			exit(-1);
		}
		
		glGetShaderInfoLog(shader_vert_id, length, &chars_written, info_log);
		
		printf(""Shader info log: %s\n"", info_log);
		
		free(info_log);
	}
	
	// actually create the shader
	shader_frag_id = glCreateShader(GL_FRAGMENT_SHADER);
	if(shader_frag_id == 0)
	{
		printf(""Failed to create GL_VERTEX_SHADER!\n"");
		exit(-1);
	}
	glShaderSource(shader_frag_id, 1, (GLchar **)&frag_data, NULL);
	glCompileShader(shader_frag_id);
	free(frag_data);
	
	// print shader info log
	length = 0;
	chars_written = 0;
	glGetShaderiv(shader_frag_id, GL_INFO_LOG_LENGTH, &length);
	// WTF? so why was 4 used?
	// use 2 for the length because NVidia cards return a line feed always
	if(length > 4)
	{
		info_log = (char *)malloc(sizeof(char) * length);
		if(info_log == NULL)
		{
			printf(""ERROR couldn't allocate %d bytes for shader info log!\n"",
				   length);
			exit(-1);
		}
		
		glGetShaderInfoLog(shader_frag_id, length, &chars_written, info_log);
		
		printf(""Shader info log: %s\n"", info_log);
		
		free(info_log);
	}
	
	// create the shader program
	shader_id = glCreateProgram();
	if(shader_id == 0)
	{
		printf(""Failed at glCreateProgram()!\n"");
		exit(-1);
	}
	
	glAttachShader(shader_id, shader_vert_id);
	glAttachShader(shader_id, shader_frag_id);
	
	glLinkProgram(shader_id);
	
	glGetProgramiv(shader_id, GL_INFO_LOG_LENGTH, &length);
	
	// use 2 for the length because NVidia cards return a line feed always
	if(length > 4)
	{
		info_log = (char *)malloc(sizeof(char) * length);
		if(info_log == NULL)
		{
			printf(""ERROR couldn't allocate %d bytes for shader program info log!\n"",
				   length);
			exit(-1);
		}
		else
		{
			printf(""Shader program info log:\n"");
		}
		
		glGetProgramInfoLog(shader_id, length, &chars_written, info_log);
		
		printf(""%s\n"", info_log);
		
		free(info_log);
	}
	
	print_opengl_error();
}

void gfx_opengl::print_info()
{
	printf(""GLEW library version %s\n"", glewGetString(GLEW_VERSION));
	
	if(glewIsSupported(""GL_VERSION_5_1""))
	{
		printf(""GLEW supported GL_VERSION_5_1\n"");
	}
	else if(glewIsSupported(""GL_VERSION_5_0""))
	{
		printf(""GLEW supported GL_VERSION_5_0\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_8""))
	{
		printf(""GLEW supported GL_VERSION_4_8\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_7""))
	{
		printf(""GLEW supported GL_VERSION_4_7\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_6""))
	{
		printf(""GLEW supported GL_VERSION_4_6\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_5""))
	{
		printf(""GLEW supported GL_VERSION_4_5\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_4""))
	{
		printf(""GLEW supported GL_VERSION_4_4\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_3""))
	{
		printf(""GLEW supported GL_VERSION_4_3\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_2""))
	{
		printf(""GLEW supported GL_VERSION_4_2\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_1""))
	{
		printf(""GLEW supported GL_VERSION_4_1\n"");
	}
	else if(glewIsSupported(""GL_VERSION_4_0""))
	{
		printf(""GLEW supported GL_VERSION_4_0\n"");
	}
	else if(glewIsSupported(""GL_VERSION_3_2""))
	{
		printf(""GLEW supported GL_VERSION_3_2\n"");
	}
	else if(glewIsSupported(""GL_VERSION_3_1""))
	{
		printf(""GLEW supported GL_VERSION_3_1\n"");
	}
	else if(glewIsSupported(""GL_VERSION_3_0""))
	{
		printf(""GLEW supported GL_VERSION_3_0\n"");
	}
	else if(glewIsSupported(""GL_VERSION_2_1""))
	{
		printf(""GLEW supported GL_VERSION_2_1\n"");
	}
	else if(glewIsSupported(""GL_VERSION_2_0""))
	{
		printf(""GLEW supported GL_VERSION_2_0\n"");
	}
	else
	{
		printf(""NO GLEW GL_VERSION seems to be supported!\n"");
	}
	
	printf(""GL_VENDOR: %s\n"", glGetString(GL_VENDOR));
	printf(""GL_RENDERER: %s\n"", glGetString(GL_RENDERER));
	printf(""GL_VERSION: %s\n"", glGetString(GL_VERSION));
	printf(""GL_SHADING_LANGUAGE_VERSION: %s\n"",
		   glGetString(GL_SHADING_LANGUAGE_VERSION));
	
	printf(""Eigen version: %d.%d.%d\n"", EIGEN_WORLD_VERSION,
		   EIGEN_MAJOR_VERSION,  EIGEN_MINOR_VERSION);
	
	
}

//------------------------------------------------------------------------------
// Returns 1 if an OpenGL error occurred, 0 otherwise.
int print_opengl_error2(char *file, int line)
{
	GLenum gl_err;
	int	ret_code = 0;
	
	gl_err = glGetError();
	while(gl_err != GL_NO_ERROR)
	{
		printf(""glError in file %s @ line %d: %s\n"", file, line,
			gluErrorString(gl_err));
		
		ret_code = 1;
		gl_err = glGetError();
	}
	return ret_code;
}
",fsize
580,"#include <iostream>
#include <vector>
#include <stdint.h>
#include <stdio.h>
#include <cstring>
#include <cstdlib>
#include <algorithm>

#define MEMSIZE 1024
inline bool matches(const char* program, std::vector<int8_t> seq) {
    if(seq.size()==0) {
        return true;
    }
    std::vector<int8_t>::iterator seqhead=seq.begin();

    const char* instruction_counter=program;
    std::vector<const char*> stack;

    int8_t memory[MEMSIZE];
    memset(memory,0,sizeof(memory));
    int8_t* memptr=memory;

    unsigned int steps_since_output=0;
    while(*instruction_counter && steps_since_output<50) {
        switch(*instruction_counter) {
        case 'a':
            steps_since_output=0;
            //printf(""%d "",*memptr);
            if(*seqhead == *memptr) {
                seqhead++;
                if(seqhead==seq.end()){
                    return true;
                }
            } else {
                return false;
            }
            break;
        case 'b':
            (*memptr)++;
            break;
        case 'c':
            (*memptr)--;
            break;
        case 'd':
            memptr--;
            if(memptr<memory) {
                memptr+=MEMSIZE;
            }
            break;
        case 'e':
            memptr++;
            if(memptr>=memory+MEMSIZE) {
                memptr-=MEMSIZE;
            }
            break;
        case 'f':
            if(*memptr) {
                stack.push_back(instruction_counter);
            } else {
                int bracecount=1;
                while(bracecount && *instruction_counter) {
                    instruction_counter++;
                    if(*instruction_counter=='[') bracecount++;
                    if(*instruction_counter==']') bracecount--;
                }
                if(!*instruction_counter) {
                    return false;
                }
            }
            break;
        case 'g':
            if(stack.empty()) {
                return false;
            }
            if(*memptr) {
                instruction_counter=stack.back();
            } else {
                stack.pop_back();
            }
            break;
        default:
            std::cerr <<""Error! Unidentified instruction ""<< (*instruction_counter) << std::endl;
        }
        instruction_counter++;
        steps_since_output++;
    }
    return false;
}
inline void increment_program(char* &program) {
    char* ind=program;
    while(*ind=='g') {
        *(ind++)='a';
    }
    if(*ind=='\0') {
        *(--program)='a';
    } else {
        (*ind)++;
    }
}

//Ordering is   .=a
//              +=b
//              -=c
//              <=d
//              >=e
//              [=f
//              ]=g

int main(int argc, char** argv)
{
    std::vector<int8_t>  [MASK] ;
    for(int i=1; i<argc; i++) {
         [MASK] .push_back(atoi(argv[i]));
    }
    char programbuff[100];
    programbuff[99]='\0';
    char* program=&programbuff[99];
    while(true) {
        increment_program(program);
        if(matches(program, [MASK] )){
            std::cout << ""Found match!"" <<std::endl;
            std::string programstr(program);
            std::replace( programstr.begin(), programstr.end(), 'a', '.');
            std::replace( programstr.begin(), programstr.end(), 'b', '+');
            std::replace( programstr.begin(), programstr.end(), 'c', '-');
            std::replace( programstr.begin(), programstr.end(), 'd', '<');
            std::replace( programstr.begin(), programstr.end(), 'e', '>');
            std::replace( programstr.begin(), programstr.end(), 'f', '[');
            std::replace( programstr.begin(), programstr.end(), 'g', ']');
            std::cout << ""New program ""<< programstr << std::endl;
            return 0;
        }
    }
    return 0;
}

",sequence
581,"#include <SimpleDHT.h>

const int pinInside = 3;
const int pinOutside = 5;
const int pinRelais = 10;
const int pinLED = 12;
float absHum[] = {0,0};
SimpleDHT11 sensor;

SimpleDHT11 sensorInside(pinInside); // Model: DHT11
SimpleDHT11 sensorOutside(pinOutside); // Modell: DHT11

SimpleDHT11 sensors[] = {sensorInside, sensorOutside};

float getAbsHum(float relHum, float temp){
  // calculate absolute humidity following https://carnotcycle.wordpress.com/2012/08/04/how-to-convert-relative-humidity-to-absolute-humidity/
  const float e = 2.7182;
  float  [MASK]  = 17.67*temp /(temp+243.5);
  float absHum = 13.247 * relHum *pow(e,  [MASK] )/(temp+273.15);
  return absHum;
}

void setup() {
  pinMode(pinInside, INPUT);
  pinMode(pinOutside, INPUT);
  pinMode(pinRelais, OUTPUT);
  pinMode(pinLED, OUTPUT);

}

void loop() {
  for (int i = 0; i < 2; i++){ // loop over both sensors
    sensor = sensors[i];
    // copied from SimpleDHT11 example
    byte temp = 0;
    byte relHum = 0;
    int err = SimpleDHTErrSuccess;
    if ((err = sensor.read(&temp, &relHum, NULL)) != SimpleDHTErrSuccess) {
      return;
    }
    absHum[i]= getAbsHum(relHum, temp);
  }
  if (absHum[0] > absHum[1]){
    digitalWrite(pinRelais, HIGH);
  }
  else{
    digitalWrite(pinRelais, LOW); 
  }
  // LED flashing to indicate that the process is still running
  delay(1000);
  digitalWrite(pinLED, HIGH);
  delay(1000);
  digitalWrite(pinLED, LOW); 
}
",expo
582,"#include ""Sandbox2D.h""
#include ""backends/imgui_impl_opengl3.h""
#include ""imgui_internal.h""

Sandbox2D::Sandbox2D() : m_CameraController(Zero::OrthographicCameraController(16.0f/9.0f,false,-1000.0f,1000.0f))
{
	Zero::Renderer::Init();
	Zero::Renderer2D::Init();

	m_MainWindowClearColor.r = 1.0f;
	m_MainWindowClearColor.g = 1.0f;
	m_MainWindowClearColor.b = 1.0f;
	m_MainWindowClearColor.a = 1.0f;

	m_FramebufferClearColor.r = 0.5f;
	m_FramebufferClearColor.g = 0.5f;
	m_FramebufferClearColor.b = 0.5f;
	m_FramebufferClearColor.a = 1.0f;


	Zero::Ref<BrushData> whiteBrushData;
	whiteBrushData.reset(new BrushData(
							""White Brush"",
							""F://Projects_and_program_files/ZeroEngine/Sandbox/textures/white_texture.png"",
							0.0f,
							new float[4] {0.0f, 0.0f, 0.0f, 1.0f},
							0.5f)
						);

	m_Brushes.push_back(whiteBrushData);


	Zero::Ref<BrushData> smileyBrushData;
	
	smileyBrushData.reset(new BrushData(""smiley brush"",
						 ""F://Projects_and_program_files/ZeroEngine/Sandbox/textures/smily.png"",
						  1.0f,
						  new float[4]{1.0f, 1.0f, 1.0f, 1.0f},
						  0.5f)
						  );


	m_Brushes.push_back(smileyBrushData);

	Zero::Ref<BrushData> sandwichBrushData;

	sandwichBrushData.reset(new BrushData(""sandwich brush"",
								   ""F://Projects_and_program_files/ZeroEngine/Sandbox/textures/sandwich.png"",
								   2.0f,
								   new float[4] { 1.0f, 1.0f, 1.0f, 1.0f },
							       0.5f)
								   );

	m_Brushes.push_back(sandwichBrushData);
	m_CurrentBrush = m_Brushes[0];

	ImGuiIO& io = ImGui::GetIO();

	io.WantSaveIniSettings = true;
	io.LogFilename = ""ImGui Log.log"";
	io.IniFilename = ""ImGui Config.ini"";
	io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
	io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
	io.WantCaptureMouse = true;

	//ZERO_CLIENT_INFO(Zero::Renderer2D::GetFramebuffer()->GetFramebufferDetails());
}


glm::vec3 Sandbox2D::ScreenToWorldPoint(glm::vec3 position)
{
	glm::mat4 viewProjectionMatrix = m_CameraController.GetCamera().GetProjectionMatrix();
	glm::mat4 invertedMatrix = glm::inverse(viewProjectionMatrix);

	//float w = 1.0f;
	glm::vec4 temp;
	temp.x = position.x;
	temp.y = position.y;
	temp.z = position.z;
	temp.w = 1.0f;

	glm::vec4 result = invertedMatrix * temp;
	result.x /= temp.w;
	result.y /= temp.w;
	result.z /= temp.w;

	return glm::vec3(result.x, result.y, result.z);

}

bool Sandbox2D::CreateQuad()
{
	if (m_Points.size() == 2)
	{
		//Calculate points in clockwise order.

		float height = m_CurrentBrush->BrushThickness;

		glm::vec3 direction1 = glm::normalize(m_Points[1] - m_Points[0]);
		glm::vec3 forward = glm::vec3(0.0f, 0.0f, 1.0f);
		glm::vec3 crossVector1 = glm::cross(direction1, forward);

		glm::vec3 backward = glm::vec3(0.0f, 0.0f, -1.0f);
		glm::vec3 crossVector2 = glm::cross(direction1, backward);

		glm::vec3 point1 = m_Points[0] + crossVector1 * height / 2.0f;
		glm::vec3 point2 = m_Points[0] + crossVector2 * height / 2.0f;

		glm::vec3 direction2 = glm::normalize(m_Points[0] - m_Points[1]);
		glm::vec3 crossVector3 = glm::cross(direction2, forward);

		glm::vec3 crossVector4 = glm::cross(direction2, backward);


		glm::vec3 point3 = m_Points[1] + crossVector3 * height / 2.0f;
		glm::vec3 point4 = m_Points[1] + crossVector4 * height / 2.0f;

		glm::vec4 vertexColor = glm::vec4(m_CurrentBrush->BrushColor[0],
										  m_CurrentBrush->BrushColor[1],
										  m_CurrentBrush->BrushColor[2],
										  m_CurrentBrush->BrushColor[3]);
		Zero::MeshVertex v1;
		v1.Position = point1;
		v1.Color = vertexColor;
		v1.Uv = glm::vec2(0.0f, 0.0f);
		v1.TexIndex = m_CurrentBrush->BrushTexSlot;

		Zero::MeshVertex v2;
		v2.Position = point2;
		v2.Color = vertexColor;
		v2.Uv = glm::vec2(0.0f, 1.0f);
		v2.TexIndex = m_CurrentBrush->BrushTexSlot;

		Zero::MeshVertex v3;
		v3.Position = point3;
		v3.Color = vertexColor;
		v3.Uv = glm::vec2(1.0f, 1.0f);
		v3.TexIndex = m_CurrentBrush->BrushTexSlot;

		Zero::MeshVertex v4;
		v4.Position = point4;
		v4.Color = vertexColor;
		v4.Uv = glm::vec2(1.0f, 0.0f);
		v4.TexIndex = m_CurrentBrush->BrushTexSlot;

		Zero::Ref<Zero::Quad> quad;
		auto vertices = std::vector<Zero::MeshVertex>{ v1,v2,v3,v4 };
		quad.reset(new Zero::Quad(vertices));

		Zero::Renderer2D::AddQuadToBuffer(quad.get(), m_CurrentBrush->BrushTex);
		m_Points.clear();

		return true;
	}

	return false;
}

void Sandbox2D::SceneSection(bool* show)
{
	//int currentId = 0;

	//Scene Section window configuration.


	ImGuiWindowFlags sceneSectionWindowFlags = 0;
	//sceneSectionWindowFlags |= ImGuiWindowFlags_AlwaysAutoResize;
	sceneSectionWindowFlags |= ImGuiWindowFlags_NoCollapse;
	sceneSectionWindowFlags |= ImGuiWindowFlags_NoBackground;
	sceneSectionWindowFlags |= ImGuiWindowFlags_NoDocking;
	sceneSectionWindowFlags |= ImGuiWindowFlags_NoSavedSettings;

	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
	ImGui::Begin(""Scene Section"");
	//ZERO_CLIENT_INFO(""Scene Section \\/"");

	ImVec2 availSize =  ImGui::GetContentRegionAvail();
	
	if (m_SceneWindowSize != (*(glm::vec2*)&availSize))
	{
		Zero::FramebufferSpecification framebufferSpec = Zero::Renderer2D::GetFramebuffer()->GetFramebufferSpecification();
		framebufferSpec.Width = (uint32_t)availSize.x;
		framebufferSpec.Height = (uint32_t)availSize.y;

		Zero::Renderer2D::GetFramebuffer()->SetFramebufferSpecification(framebufferSpec);


		float aspectRatio = availSize.x / availSize.y;
		m_CameraController.SetAspectRatio(aspectRatio);

		m_SceneWindowSize.x = availSize.x;
		m_SceneWindowSize.y = availSize.y;

	}
	auto viewportMinRegion = ImGui::GetWindowContentRegionMin();
	auto viewportMaxRegion = ImGui::GetWindowContentRegionMax();
	auto viewportOffset = ImGui::GetWindowPos();

	m_ViewportBounds[0] = {viewportMinRegion.x + viewportOffset.x, viewportMinRegion.y + viewportOffset.y };
	m_ViewportBounds[1] = { viewportMaxRegion.x + viewportOffset.x, viewportMaxRegion.y + viewportOffset.y };

	

	ImVec2 uv0 = ImVec2(-1.0f, 1.0f); //Bottom-Left
	ImVec2 uv1 = ImVec2(0.0f, 0.0f);

	ImVec4 border_col = ImVec4(0.5f, 0.5f, 0.5f, 1.0f);
	ImVec4 tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);

	ImGui::Image((void*)(Zero::Renderer2D::GetFramebuffer()->GetFramebufferTexID()), availSize, uv0, uv1, tint_col, border_col);
	ImGui::PopStyleVar();
	//ImGui::PopID();
	ImGui::End();
}

void Sandbox2D::OptionsSection(bool* show)
{
	//int currentId = 0;
	//Option section configuration.

	ImGuiWindowFlags optionSectionWindowFlags = 0;
	//optionSectionWindowFlags |= ImGuiWindowFlags_AlwaysAutoResize;
	optionSectionWindowFlags |= ImGuiWindowFlags_NoCollapse;
	optionSectionWindowFlags |= ImGuiWindowFlags_NoBackground;
	optionSectionWindowFlags |= ImGuiWindowFlags_NoDocking;
	optionSectionWindowFlags |= ImGuiWindowFlags_NoSavedSettings;


	ImGui::Begin(""Option Section"");	


	ImGui::ColorPicker4(""Brush Color"", m_CurrentBrush->BrushColor);
	ImGui::Text(""Clear the shapes:"");
	if (ImGui::Button(""Clear""))
	{
		Zero::Renderer2D::ClearBuffer();
	}
	ImGui::SliderFloat(""Brush Width"", &m_CurrentBrush->BrushThickness, 0.2f, 1.0f, ""%.3f"", ImGuiSliderFlags_AlwaysClamp);

	uint32_t brushesInRow = 0;
	ImGui::Text(""Brushes"");
	for (int i = 0; i < m_Brushes.size(); i++)
	{
		if (brushesInRow == BrushesPerLine)
		{
			ImGui::NewLine();
			brushesInRow = 0;
		}
		Zero::Ref<BrushData> brushData = m_Brushes[i];
		float my_tex_w = (float)brushData->BrushTex->GetWidth();
		float my_tex_h = (float)brushData->BrushTex->GetHeight();

		//ImGui::PushID(currentId);
		int frame_padding = -1 + i;
		ImVec2 size = ImVec2(32.0f, 32.0f);
		ImVec2 uv0 = ImVec2(-1.0f, 1.0f); //Bottom-Left
		ImVec2 uv1 = ImVec2(0.0f, 0.0f);

		ImVec4 bg_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
		ImVec4 tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
		if (ImGui::ImageButton((void*)(intptr_t)(brushData->BrushTex->GetTextureID()), size, uv0, uv1, frame_padding, bg_col, tint_col))
		{
			m_CurrentBrush = brushData;
		}
		//currentId++;
		ImGui::SameLine();
		//ImGui::PopID();
		brushesInRow++;
	}
	ImGui::End();
}



void Sandbox2D::OnAttach()
{
}

void Sandbox2D::OnDetach()
{
	Zero::Renderer2D::ClearBuffer();
}

void Sandbox2D::OnUpdate(Zero::Timestep timestep)
{
	Zero::RenderCommand::SetClearColor(m_FramebufferClearColor);
	Zero::RenderCommand::Clear();

	Zero::Renderer::BeginScene(m_CameraController.GetCamera());
	Zero::Renderer2D::BeginScene(m_CameraController.GetCamera());

	
	Zero::FramebufferSpecification framebufferSpec = Zero::Renderer2D::GetFramebuffer()->GetFramebufferSpecification();

	/*
	float aspectRatio = (float)framebufferSpec.Width / (float)framebufferSpec.Height;
	m_CameraController.SetAspectRatio(aspectRatio);
	*/

	m_CameraController.OnUpdate(timestep);

	/*
	if (Zero::Input::IsKeyPressed(ZERO_MOUSE_BUTTON_1))
	{
		m_MouseHold = true;
	}
	else if (Zero::Input::IsKeyReleased(ZERO_MOUSE_BUTTON_1))
	{
		m_MouseHold = false;
	}
	*/
	
	m_MouseHold = ImGui::IsMouseDown(ImGuiMouseButton_Left);
	/*
	if (m_MouseHold)
	{
		ZERO_CLIENT_INFO(""Left Mouse Button is Holded."");
	}
	*/
	
	
	/*
	auto mousePosPair = Zero::Input::GetMousePosNormalized(m_SceneWindowSize.x,
														   m_SceneWindowSize.y);
	m_MousePos = glm::vec3(mousePosPair.first, mousePosPair.second, 0);
	*/
	
	;

	auto temp = ImGui::GetMousePos();
	m_MousePos.x = temp.x;
	m_MousePos.y = temp.y;
	m_MousePos.z = 0.0f;

	m_MousePos.x -= m_ViewportBounds[0].x;
	m_MousePos.y -= m_ViewportBounds[0].y;

	
	glm::vec2 viewPortSize = m_ViewportBounds[1] - m_ViewportBounds[0];
	//m_MousePos.y = viewPortSize.y - m_MousePos.y;

	uint32_t mouseX = (uint32_t)m_MousePos.x;
	uint32_t mouseY = (uint32_t)m_MousePos.y;
	//ZERO_CLIENT_INFO(""Mouse X: "" + std::to_string(mouseX) + "", Mouse Y: "" + std::to_string(mouseY));

	bool isMousePosInBounds = mouseX >= 0 && mouseY >= 0 && mouseX < viewPortSize.x && mouseY < viewPortSize.y;
	
	if (m_MouseHold && isMousePosInBounds)
	{
		
		//ZERO_CLIENT_INFO(Zero::Renderer2D::GetFramebuffer()->GetFramebufferDetails());
		
		glm::vec3 normalizedMousePos;
		normalizedMousePos.x = -1.0f + 2.0f * (m_MousePos.x/ framebufferSpec.Width);
		normalizedMousePos.y = 1.0f - 2.0f * (m_MousePos.y / (float)framebufferSpec.Height);
		normalizedMousePos.z = m_MousePos.z;
		glm::vec3 worldPos = ScreenToWorldPoint(normalizedMousePos);
		
		ZERO_CLIENT_INFO(""World Position: "" 
						  + std::to_string(worldPos.x) + "", "" 
						  + std::to_string(worldPos.y) + "", "" 
						  + std::to_string(worldPos.z));
		
		

		float distance = glm::distance(m_PreviousPoint, worldPos);
		float clearQuadVecDistance = 2 * m_QuadDrawMinDistance;

		
		if (distance >= clearQuadVecDistance && m_Points.size() == 1)
		{
			ZERO_CLIENT_INFO(""Clearing points array"");
			m_Points.clear();
		}
		else if (distance >= m_QuadDrawMinDistance)
		{
			m_Points.push_back(worldPos);
			glm::vec3 direction = glm::normalize(worldPos - m_PreviousPoint);
			m_PreviousPoint = worldPos;
			if (CreateQuad())
			{
				ZERO_CLIENT_INFO(""Drawing Quad"");
				//We are doing this to avoid showing vacant spaces between lines.
				m_Points.push_back(worldPos - direction * 0.1f);
			}

		}
		
		
	}	
	
	Zero::Renderer2D::UpdateFramebuffer();
	//std::string pixelInfo = ""Pixel Color: "" + Zero::RenderCommand::ReadPixel(mousePos.x, mousePos.y, framebufferSpec.Width, framebufferSpec.Height);
	//ZERO_CLIENT_INFO(pixelInfo);
	//Zero::RenderCommand::SetViewport(0, 0, framebufferSpec.Width, framebufferSpec.Height);


	Zero::RenderCommand::SetClearColor(m_MainWindowClearColor);
	Zero::RenderCommand::Clear();

	Zero::Renderer2D::EndScene();
	Zero::Renderer::EndScene();
	
}

void Sandbox2D::OnEvent(Zero::Event& event)
{
	Zero::EventDispatcher eventDispatcher(event);
	eventDispatcher.Dispatch<Zero::WindowResizedEvent>(ZERO_BIND_EVENT_FN(Sandbox2D::OnWindowResized));
	eventDispatcher.Dispatch<Zero::KeyPressedEvent>(ZERO_BIND_EVENT_FN(Sandbox2D::OnKeyPressed));
	eventDispatcher.Dispatch<Zero::KeyTypedEvent>(ZERO_BIND_EVENT_FN(Sandbox2D::OnKeyTyped));
	eventDispatcher.Dispatch<Zero::MouseScrolledEvent>(ZERO_BIND_EVENT_FN(Sandbox2D::OnMouseScrolled));
	eventDispatcher.Dispatch<Zero::MouseButtonClickedEvent>(ZERO_BIND_EVENT_FN(Sandbox2D::OnMouseClicked));

	m_CameraController.OnEvent(event);
}


void Sandbox2D::OnImGuiRender()
{
	ImGuiWindowFlags windowFlags = ImGuiWindowFlags_NoDocking;
	windowFlags |= ImGuiWindowFlags_NoTitleBar;
	windowFlags |= ImGuiWindowFlags_NoCollapse;
	windowFlags |= ImGuiWindowFlags_NoResize;
	windowFlags |= ImGuiWindowFlags_NoMove;
	windowFlags |= ImGuiWindowFlags_NoBringToFrontOnFocus;
	windowFlags |= ImGuiWindowFlags_NoNavFocus;
	windowFlags |= ImGuiWindowFlags_NoBackground;
	
	ImGuiViewport* viewport = ImGui::GetMainViewport();
	ImGui::SetNextWindowPos(viewport->Pos);
	ImGui::SetNextWindowSize(viewport->Size);
	ImGui::SetNextWindowViewport(viewport->ID);

	ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
	ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
	ImGui::Begin(""MainWindow"", nullptr, windowFlags);
	ImGui::PopStyleVar(3);

	ImGuiID  [MASK]  =  ImGui::GetID(""MainWindowDockSpace"");
	
	ImGui::DockSpace( [MASK] , ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_PassthruCentralNode);
	
	ImGui::End();

	SceneSection(nullptr);
	OptionsSection(nullptr);
	
}
bool Sandbox2D::OnWindowResized(Zero::WindowResizedEvent& event)
{
	//float aspectRatio = (float)event.GetWidth() / (float)event.GetHeight();
	//m_CameraController.SetAspectRatio(aspectRatio);
	return true;
}

bool Sandbox2D::OnKeyPressed(Zero::KeyPressedEvent& event)
{
	return false;
}

bool Sandbox2D::OnKeyTyped(Zero::KeyTypedEvent& event)
{
	return false;
}

bool Sandbox2D::OnMouseScrolled(Zero::MouseScrolledEvent& event)
{
	return false;
}

bool Sandbox2D::OnMouseClicked(Zero::MouseButtonClickedEvent& event)
{
	return false;
}
",dockspaceID
583,"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _CRT_SECURE_NO_WARNINGS
#include <fstream>
#include <iostream>

using namespace std;

typedef unsigned char  	BYTE;
typedef unsigned short  WORD;
typedef unsigned int  	DWORD;
typedef int  		LONG;


#define BITS_PER_PIXCEL 24
#define FORMAT_RGBA 4
#define FORMAT_RGB  3

#pragma pack(1)

typedef struct
{
    WORD    bfType;
    DWORD   bfSize;
    WORD    bfReserved1;
    WORD    bfReserved2;
    DWORD   bfOffBits;
} BMP_FILE_HEADER;

typedef struct {
    DWORD      biSize;
    LONG       biWidth;
    LONG       biHeight;
    WORD       biPlanes;
    WORD       biBitCount;
    DWORD      biCompression;
    DWORD      biSizeImage;
    LONG       biXPelsPerMeter;
    LONG       biYPelsPerMeter;
    DWORD      biClrUsed;
    DWORD      biClrImportant;
} BMP_INFO_HEADER;

#pragma pack()


int rgbaToBmpFile(const char* pFileName, const char* pRgbaData, const int nWidth, const int nHeight, const int format)
{
    BMP_FILE_HEADER bmpHeader;
    BMP_INFO_HEADER bmpInfo;

    FILE* fp = NULL;
    char* pBmpSource = NULL;
    char* pBmpData = NULL;

    int i = 0, j = 0;

    
    int  [MASK]  = (nWidth * BITS_PER_PIXCEL + 31) / 32 * 4;
    int pixcelBytes =  [MASK]  * nHeight;

    bmpHeader.bfType = 0x4D42;
    bmpHeader.bfReserved1 = 0;
    bmpHeader.bfReserved2 = 0;
    bmpHeader.bfOffBits = sizeof(BMP_FILE_HEADER) + sizeof(BMP_INFO_HEADER);
    bmpHeader.bfSize = bmpHeader.bfOffBits + pixcelBytes;

    bmpInfo.biSize = sizeof(BMP_INFO_HEADER);
    bmpInfo.biWidth = nWidth;
   
    bmpInfo.biHeight = -nHeight;
    bmpInfo.biPlanes = 1;
    bmpInfo.biBitCount = BITS_PER_PIXCEL;
    bmpInfo.biCompression = 0;
    bmpInfo.biSizeImage = pixcelBytes;
    bmpInfo.biXPelsPerMeter = 100;
    bmpInfo.biYPelsPerMeter = 100;
    bmpInfo.biClrUsed = 0;
    bmpInfo.biClrImportant = 0;


    /** convert in memort, then write to file. */
    pBmpSource = (char*)malloc(pixcelBytes);
    if (!pBmpSource)
    {
        return -1;
    }

    /** open file */
    fp = fopen(pFileName, ""wb+"");
    if (!fp)
    {
        return -1;
    }

    fwrite(&bmpHeader, sizeof(BMP_FILE_HEADER), 1, fp);
    fwrite(&bmpInfo, sizeof(BMP_INFO_HEADER), 1, fp);
    /** Here you should consider color format. RGBA ? RGB? BGR?
        Param format is RGBA, format for file is BGR */
    pBmpData = pBmpSource;
    for (i = 0; i < nHeight; i++)
    {
        for (j = 0; j < nWidth; j++)
        {
            pBmpData[0] = pRgbaData[2];
            pBmpData[1] = pRgbaData[1];
            pBmpData[2] = pRgbaData[0];
            pRgbaData += format;
            pBmpData += FORMAT_RGB;
        }
        //pack for 4 bytes
        pBmpData += ( [MASK]  - nWidth * FORMAT_RGB);
    }
    fwrite(pBmpSource, pixcelBytes, 1, fp);

    fclose(fp);
    free(pBmpSource);

    return 0;
}

int clipRgbaToBmpFile(const char* pFileName, const char* pRgbaData,
    const int nWidth, const int nHeight, const int format,
    const int nClipLeft, const int nClipTop, const int nClipWidth, const int nClipHeight)
{
    char* pClipSource = NULL;
    char* pClipData = NULL;
    int pixcelBytes = nClipWidth * nClipHeight * format;
    int i = 0;

    pClipSource = (char*)malloc(pixcelBytes);
    if (!pClipSource)
    {
        return -1;
    }

    //move to right position
    pRgbaData += nClipTop * nWidth * format;
    pRgbaData += nClipLeft * format;

    pClipData = pClipSource;
    for (i = 0; i < nClipHeight; i++)
    {
        memcpy(pClipData, pRgbaData, nClipWidth * format);
        pRgbaData += nWidth * format;
        pClipData += nClipWidth * format;
    }

    rgbaToBmpFile(pFileName, pClipSource, nClipWidth, nClipHeight, format);

    //release
    free(pClipSource);

    return 0;
}

int main(const int argc, const char** argv)
{
    int  width = 640;
    int  height = 360;
    int  format = FORMAT_RGB;
    
	char colorR = 0xff;
    char colorG = 0xff;
	char colorB = 0x00;
    

    int size = width * height * format;
    char* pRgb = (char*)malloc(size);

    for (int i = 0; i < width * height; i++)
    {
        pRgb[i * format] = colorR[1024];
        pRgb[i * format + 1] = colorG;
        pRgb[i * format + 2] = colorB;
    }

    rgbaToBmpFile((char*)""test.bmp"", pRgb, width, height, format);

    free(pRgb);
}",bytesPerLine
584,"#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cctype>
#include <locale>

#ifndef STRING_UTILS_H
#define STRING_UTILS_H


static inline std::vector<std::string> Compact(const std::vector<std::string> &tokens){
  std::vector<std::string> compacted;

  for(size_t i=0; i<tokens.size(); ++i) {
    if (!tokens[i].empty()) {
      compacted.push_back(tokens[i]);
    }
  }

  return compacted;
}

static inline std::vector<std::string> Split(const std::string &str, const std::string &delim, const bool trim_empty = false){
  size_t pos, last_pos = 0, len;
  std::vector<std::string> tokens;

  while(true) {
    pos = str.find(delim, last_pos);
    if (pos == std::string::npos) {
      pos = str.size();
    }

    len = pos-last_pos;
    if ( !trim_empty || len != 0) {
      tokens.push_back(str.substr(last_pos, len));
    }

    if (pos == str.size()) {
      break; 
    } else {
      last_pos = pos + delim.size();
    }
  }

  return tokens;
}

static inline std::string Join(const std::vector<std::string> &tokens, const std::string &delim, const bool trim_empty = false){
  if(trim_empty) {
    return Join(Compact(tokens), delim, false);
  } else {
    std::stringstream ss;
    for(size_t i=0; i<tokens.size()-1; ++i) {
      ss << tokens[i] << delim;
    }
    ss << tokens[tokens.size()-1];

    return ss.str();
  }
}

static inline std::string Trim(const std::string &str){
  
  std::string blank = ""\r\n\t "";
  size_t begin = str.size(), end = 0;
  for (size_t i=0; i<str.size(); ++i) {
    if ( blank.find(str[i]) == std::string::npos) {
      begin = i;
      break;
    }
  }

  for (size_t i=str.size(); i>0; --i) {
    if ( blank.find(str[i-1]) == std::string::npos) {
      end = i-1;
      break;
    }
  }
  
  if (begin >= end) {
    return """";
  } else {
    return str.substr(begin, end-begin+1);
  }
}

static inline std::string Repeat(const std::string &str, unsigned int  [MASK] ){
  std::stringstream ss;
  for(unsigned int i=0; i< [MASK] ; ++i) {
    ss << str;
  }
  return ss.str();
}

static inline std::string ReplaceAll(const std::string &source, const std::string &target, const std::string &replacement){
  return Join(Split(source, target, false), replacement, false);
}

static inline std::string ToUpper(const std::string &str){
  std::string s(str);
  std::transform(s.begin(), s.end(), s.begin(), toupper);
  return s;
}

static inline std::string ToLower(const std::string &str){
  std::string s(str);
  std::transform(s.begin(), s.end(), s.begin(), tolower);
  return s;
}


static inline std::string ReadFile(const std::string &filepath) {
  std::ifstream ifs(filepath.c_str());
  std::string content( (std::istreambuf_iterator<char>(ifs) ),
                       (std::istreambuf_iterator<char>()    ) );
  ifs.close();
  return content;
}

static inline void WriteFile(const std::string &filepath, const std::string &content) {
  std::ofstream ofs(filepath.c_str());
  ofs << content;
  ofs.close();
  return;
}

//https://stackoverflow.com/questions/216823/how-to-trim-a-stdstring
// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

#endif",times
585,"#include <iostream>
#include <string>
#include <regex>
// #include <cmath>
#include <complex>
#include ""ThreeVector.hpp""
#include ""FourVector.hpp""
#include ""pp6day1.hpp""
#include ""pp6day2.hpp""


// std::ostream& operator<<(std::ostream& s, const ThreeVector& c)
// {
//   ///
//   /// Print a ThreeVector in the form (x, y, z)
//   /// 
//   s << ""("" << c.getx() << "", "" << c.gety() << "", "" << c.getz() << "")"";
//   return s;
// }


int main()
// int main(int argc, char *argv[])
{
  // string to decide what to do
  // TODO make it 'human' so that the user could type (e.g.)
  // > Please can I find out the intercept of a straight line on the x-axis
  // and the program knows what to do (by matching 'intercept' and 'x-axis')
  std::string  [MASK] ;
  
  std::cout << ""Hello World"" << std::endl;

  std::cout << ""Welcome to PP6Calculator (reborn). ""
	    << ""Please specify which function you would like to perform: ""
	    << std::endl
	    << ""> "";
  
  std::getline(std::cin, [MASK] );
  
  if(std::regex_match( [MASK] , std::regex(""(^i$)|(.*intercept.*)"")))
    askinterceptXAxis();
  else if(std::regex_match( [MASK] , std::regex(""(^q$)|(.*quadratic.*)"")))
    askquadraticSolver();
  else if(std::regex_match( [MASK] ,std::regex(""(^im$)"")))
    askFourVectorDot();
  else if(std::regex_match( [MASK] ,std::regex(""([34]m$)|(.*modulus.*)"")))
    {
      if(std::regex_match( [MASK] ,std::regex(""(^3m$)|(.*\b3.vector.*modulus.*)"")))
	askThreeVectormodulus();
      else if(std::regex_match( [MASK] ,std::regex(""(^4m$)|(.*\b4.vector.*modulus.*)"")))
	{
	  // Initialise variables for the FourVector
	  double t,x,y,z;
	  coutChosen(""4-vector modulus squared"");
	  std::cout << ""Choose the t term: "" << std::endl;
	  promptForValue(&t);
	  std::cout << ""Choose the x term: "" << std::endl;
	  promptForValue(&x);
	  std::cout << ""Choose the y term: "" << std::endl;
	  promptForValue(&y);
	  std::cout << ""Choose the z term: "" << std::endl;
	  promptForValue(&z);
	    
	    
	  std::cout << ""The modulus squared of the 4-vector "" <<  FourVector(t,x,y,z)
		    << "" is "" << FourVector(t,x,y,z).modulusSquared() << std::endl;
	}
      else
	{
	  std::cout << ""You want to do a modulus, but I'm not sure which one"" << std::endl;
	}
    }
  else
    {
      std::cout << ""You chose "" <<  [MASK]  << std::endl;
      std::cout << ""Sorry, I'm not yet complete enough to give you what you want.""
		<< std::endl;
    }
  return 0;
}
",decision
586,"#pragma once
#include <array>

constexpr const std::array<short, 26> _make_letter_points() {
    std::array<short, 26> _letter_points{};
    _letter_points[ 0] = 1;  // A
    _letter_points[ 1] = 3;  // B
    _letter_points[ 2] = 3;  // C
    _letter_points[ 3] = 2;  // D
    _letter_points[ 4] = 1;  // E
    _letter_points[ 5] = 4;  // F
    _letter_points[ 6] = 2;  // G
    _letter_points[ 7] = 4;  // H
    _letter_points[ 8] = 1;  // I
    _letter_points[ 9] = 8;  // J
    _letter_points[10] = 10; // K
    _letter_points[11] = 1;  // L
    _letter_points[12] = 2;  // M
    _letter_points[13] = 1;  // N
    _letter_points[14] = 1;  // O
    _letter_points[15] = 3;  // P
    _letter_points[16] = 8;  // Q
    _letter_points[17] = 1;  // R
    _letter_points[18] = 1;  // S
    _letter_points[19] = 1;  // T
    _letter_points[20] = 1;  // U
    _letter_points[21] = 4;  // V
    _letter_points[22] = 10; // W
    _letter_points[23] = 10; // X
    _letter_points[24] = 10; // Y
    _letter_points[25] = 10; // Z
    return _letter_points;
}

constexpr static const std::array<short, 26> letter_points = _make_letter_points();

/**
 * @brief Returns the amount of points a given letter is worth.
 * @param letter A letter (from A-Z).
 * @return The amount of points the letter is worth, or -1 if the letter is invalid.
 */
constexpr short get_points_from_letter(char letter) {
    char  [MASK]  = 0;
    if (letter >= 'a' && letter <= 'z')
         [MASK]  = letter - 'a';
    else if (letter >= 'A' && letter <= 'Z')
         [MASK]  = letter - 'A';
    else
        return -1;
    
    return letter_points[ [MASK] ];
}
",index
587,"#ifndef VIEWPORT_PANEL_H
#define VIEWPORT_PANEL_H

#include ""Theme/EditorResources.h""

#include <Engine.h>
#include <imgui/imgui.h>

namespace Cober {

	class ViewportPanel 
	{
	public:
		ViewportPanel();
		~ViewportPanel();

		static ViewportPanel& Get() { return *m_Instance; }
		
		// void RenderSkybox();
		void CreateFramebuffer(uint32_t width = 1280, uint32_t height = 720);
		Ref<Framebuffer>& GetFramebuffer() { return m_Fbo; };

		void BindFramebuffer();
		void UnbindFramebuffer();
		void FBOClearAttachments(uint32_t  [MASK] , int value) { m_Fbo->ClearAttachment( [MASK] , value); }

		void OnEvent(Event& event);	// Abstract to EVENT API
		void ResizeViewport(Ref<Camera> editorCamera);
		void ResizeFramebufferSpecification(Ref<Camera> editorCamera, uint32_t width, uint32_t height);

		void OnGuiRender(Ref<EditorCamera>& editorCamera, Ref<Camera>& camera);

		void SetCursorEntity();
		void MustResize(bool resize = true) { m_MustResize = resize; }; 
		void PlayButtonBar(EngineApp::GameState gameState);
		inline bool AllowViewportCameraEvents() { return m_AllowViewportCameraEvents; }

	private:
		Ref<Framebuffer> m_Fbo;
		std::map<std::string, Ref<Texture>> m_AssetIconMap;
		static ViewportPanel* m_Instance;

		glm::vec2 m_ViewportMargin = { 0.0f, 0.0f };
		glm::vec2 m_ViewportSize = { 0.0f, 0.0f };
		ImVec2 m_MinViewportBound, m_MaxViewportBound;
		bool m_ViewportFocused = false, m_ViewportHovered = false;
		bool m_StartedCameraClickInViewport = false, m_AllowViewportCameraEvents = false;
		bool m_MustResize = false;

		bool m_MouseButtonHeld = false;
		glm::vec2 m_Mouse{0.0f, 0.0f}, m_LastMousePos{ 0.0f, 0.0f };

		std::filesystem::path m_FilePath;
		int m_GizmoType = -1;
	};
}

#endif",attachmentIndex
588,"#ifdef GRAPHQL_JSON_HPP__

#include <json/json.h>
#include <json/writer.h>
#include <memory>
#include <sstream>
#include <iostream>

namespace GraphQL::Json
{

    bool CJsonSerializer::Serialize(IJsonSerializable* pObj, std::string& output )
    {
        if (pObj == NULL)
            return false;
        
        // cast object to ::Json::value
        ::Json::Value serializeRoot;
        pObj->Serialize(serializeRoot);
        
        // read ::Json::value to std::string
        ::Json::StreamWriterBuilder builder;
        // builder[""commentStyle""] = ""None"";
        // builder[""indentation""] = ""   "";  // or whatever you like
        output = ::Json::writeString(builder, serializeRoot);

        return true;
    }
    
    bool CJsonSerializer::Deserialize(IJsonSerializable* pObj, std::string& input )
    {
        if (pObj == NULL)
            return false;
        
        ::Json::Value  [MASK] ;
        std::string errs;
        
        ::Json::CharReaderBuilder builder;
        // builder[""collectComments""] = false;

        std::istringstream sin(input);

        // read std::string to ::Json::value
        bool ok = ::Json::parseFromStream(builder, sin, & [MASK] , &errs);
        if(!ok) {
            std::cerr << ""error : "" << errs << std::endl;
        }
        
        // cast ::Json::value to object
        pObj->Deserialize( [MASK] );
        
        return true;
    }
}

#endif  // GRAPHQL_JSON_HPP__
",deserializeRoot
589,"#include <unistd.h>
#include <sys/wait.h>
#ifdef __linux__
#include <sys/prctl.h>
#endif
#include <fcntl.h>
#include <execinfo.h>
#include <chrono>
#include <thread>
#include <algorithm>
#include <regex>

#include ""app.h""
#include ""utils.h""

namespace leaf
{

void SignalManager::installHandler() {
    struct sigaction act;

    act.sa_sigaction = SignalManager::catchSignal;
    sigemptyset (&act.sa_mask);
    act.sa_flags = SA_RESTART | SA_SIGINFO;
    sigaction(SIGBUS, &act, NULL);
    sigaction(SIGFPE, &act, NULL);
    sigaction(SIGILL, &act, NULL);
    sigaction(SIGSEGV, &act, NULL);
    sigaction(SIGABRT, &act, NULL);

    // To avoid zombie process
    act.sa_handler = SIG_IGN;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD, &act, NULL);
}

void SignalManager::catchSignal(int sig, siginfo_t *info, void *ctxt) {
    auto& tty = Tty::getInstance();
    tty.enableAutoWrap_s();
    tty.disableMouse_s();
    tty.showCursor_s();
    if ( ConfigManager::getInstance().getConfigValue<ConfigType::Height>() == 0 ) {
        tty.disableAlternativeBuffer_s();
    }
    tty.restoreOrigTerminal_s();

    const char* msg = """";
    switch ( sig ) {
    case SIGBUS:
        msg = ""catch signal SIGBUS...\n"";
        break;
    case SIGFPE:
        msg = ""catch signal SIGFPE...\n"";
        break;
    case SIGILL:
        msg = ""catch signal SIGILL...\n"";
        break;
    case SIGSEGV:
        msg = ""catch signal SIGSEGV...\n"";
        break;
    case SIGABRT:
        msg = ""catch signal SIGABRT...\n"";
        break;
    default:
        break;
    }

    write(STDERR_FILENO, msg, strlen(msg));

    int mapfd = open(""/proc/self/maps"", O_RDONLY);
    if ( mapfd != -1 ) {
        const char* header = ""\n******************** Memory map ********************\n\n"";
        write(STDERR_FILENO, header, strlen(header));

        char buf[256];
        ssize_t n;

        while ( (n = read(mapfd, buf, sizeof(buf))) > 0 ) {
            write(STDERR_FILENO, buf, n);
        }

        close (mapfd);
    }

    void* arr[100];
    size_t size = backtrace(arr, 100);
    const char* header = ""\n******************** Backtrace ********************\n\n"";
    write(STDERR_FILENO, header, strlen(header));
    backtrace_symbols_fd(arr, size, STDERR_FILENO);

    auto pid = fork();
    if ( pid < 0 ) {
        msg = ""fork error\n"";
        write(STDERR_FILENO, msg, strlen(msg));
        std::_Exit(EXIT_FAILURE);
    }
    else if ( pid == 0 ) {
        header = ""\n******************** addr2line Backtrace ********************\n\n"";
        write(STDERR_FILENO, header, strlen(header));

        if ( dup2(STDERR_FILENO, STDOUT_FILENO) < 0 ) {
            perror(""dup2()"");
            std::_Exit(EXIT_FAILURE);
        }

        char** stacktrace = backtrace_symbols(arr, size);
        if ( stacktrace == nullptr ) {
            perror(""backtrace_symbols()"");
            std::_Exit(EXIT_FAILURE);
        }

        for ( size_t i = 0; i < size; ++i ) {
            std::string str(stacktrace[i]);
            std::smatch sm;
            std::regex_match(str, sm, std::regex(""(.*)\\((.*)\\)\\s*\\[(.*)\\]""));
            auto exe = sm.str(1);
            auto addr1 = sm.str(2);
            auto addr2 = sm.str(3);
            if ( !addr1.empty() && addr1[0] == '+' ) {
                addr2 = addr1;
            }

            if ( system((""addr2line -apfCi -e "" + exe + "" "" + addr2).c_str()) < 0 ) {
                perror(""system()"");
                std::_Exit(EXIT_FAILURE);
            }
        }

        free(stacktrace);

        header = ""\n******************** gdb Backtrace ********************\n\n"";
        write(STDERR_FILENO, header, strlen(header));

        char pid_buf[24];
        sprintf(pid_buf, ""%d"", getppid());
        execlp(""gdb"", ""gdb"", ""--batch"", ""-n"", ""-iex"",
               ""set auto-load safe-path /"", ""-ex"", ""bt"", ""-p"", pid_buf, nullptr);
    } else {
        if ( waitpid(pid, nullptr, 0) < 0 ) {
            msg = ""waitpid error\n"";
            write(STDERR_FILENO, msg, strlen(msg));
            std::_Exit(EXIT_FAILURE);
        }
    }

    // default behavior, so that a core file can be produced
    struct sigaction act;
    act.sa_handler = SIG_DFL;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(sig, &act, NULL);
    raise(sig);
}

Application::Application(int argc, char* argv[])
    : Configuration(argc, argv),
    result_content_(std::get<1>(previous_result_)),
    cpu_count_{ std::max(std::thread::hardware_concurrency(), 1u) },
    step_{ 100000 * cpu_count_ },
    fuzzy_engine_(cpu_count_),
    key_map_{
        { ""Ctrl_@"", Key::Ctrl_At },
        { ""Ctrl_A"", Key::Ctrl_A },
        { ""Ctrl_B"", Key::Ctrl_B },
        { ""Ctrl_C"", Key::Ctrl_C },
        { ""Ctrl_D"", Key::Ctrl_D },
        { ""Ctrl_E"", Key::Ctrl_E },
        { ""Ctrl_F"", Key::Ctrl_F },
        { ""Ctrl_G"", Key::Ctrl_G },
        { ""Ctrl_H"", Key::Ctrl_H },
        { ""Ctrl_I"", Key::Ctrl_I },
        { ""Ctrl_J"", Key::Ctrl_J },
        { ""Ctrl_K"", Key::Ctrl_K },
        { ""Ctrl_L"", Key::Ctrl_L },
        { ""Ctrl_M"", Key::Ctrl_M },
        { ""Enter"",  Key::Ctrl_M },
        { ""Ctrl_N"", Key::Ctrl_N },
        { ""Ctrl_O"", Key::Ctrl_O },
        { ""Ctrl_P"", Key::Ctrl_P },
        { ""Ctrl_Q"", Key::Ctrl_Q },
        { ""Ctrl_R"", Key::Ctrl_R },
        { ""Ctrl_S"", Key::Ctrl_S },
        { ""Ctrl_T"", Key::Ctrl_T },
        { ""Ctrl_U"", Key::Ctrl_U },
        { ""Ctrl_V"", Key::Ctrl_V },
        { ""Ctrl_W"", Key::Ctrl_W },
        { ""Ctrl_X"", Key::Ctrl_X },
        { ""Ctrl_Y"", Key::Ctrl_Y },
        { ""Ctrl_Z"", Key::Ctrl_Z },
        { ""ESC"",    Key::ESC },
        { ""Ctrl_\\"", Key::FS },
        { ""Ctrl_]"", Key::GS },
        { ""Ctrl_^"", Key::RS },
        { ""Ctrl_/"", Key::US },
        { ""Backspace"", Key::Backspace },

        { ""Up"", Key::Up },
        { ""Down"", Key::Down },
        { ""Right"", Key::Right },
        { ""Left"", Key::Left },
        { ""Ctrl_Up"", Key::Ctrl_Up },
        { ""Ctrl_Down"", Key::Ctrl_Down },
        { ""Ctrl_Right"", Key::Ctrl_Right },
        { ""Ctrl_Left"", Key::Ctrl_Left },
        { ""Shift_Up"", Key::Shift_Up },
        { ""Shift_Down"", Key::Shift_Down },
        { ""Shift_Right"", Key::Shift_Right },
        { ""Shift_Left"", Key::Shift_Left },
        { ""Home"", Key::Home },
        { ""End"", Key::End },
        { ""Insert"", Key::Insert },
        { ""Delete"", Key::Delete },
        { ""Page_Up"", Key::Page_Up },
        { ""Page_Down"", Key::Page_Down },
        { ""F1"", Key::F1 },
        { ""F2"", Key::F2 },
        { ""F3"", Key::F3 },
        { ""F4"", Key::F4 },
        { ""F5"", Key::F5 },
        { ""F6"", Key::F6 },
        { ""F7"", Key::F7 },
        { ""F8"", Key::F8 },
        { ""F9"", Key::F9 },
        { ""F10"", Key::F10 },
        { ""F11"", Key::F11 },
        { ""F12"", Key::F12 },
        { ""Shift_F1"", Key::Shift_F1 },
        { ""Shift_F2"", Key::Shift_F2 },
        { ""Shift_F3"", Key::Shift_F3 },
        { ""Shift_F4"", Key::Shift_F4 },
        { ""Shift_F5"", Key::Shift_F5 },
        { ""Shift_F6"", Key::Shift_F6 },
        { ""Shift_F7"", Key::Shift_F7 },
        { ""Shift_F8"", Key::Shift_F8 },
        { ""Shift_F9"", Key::Shift_F9 },
        { ""Shift_F10"", Key::Shift_F10 },
        { ""Shift_F11"", Key::Shift_F11 },
        { ""Shift_F12"", Key::Shift_F12 },
        { ""Ctrl_F1"", Key::Ctrl_F1 },
        { ""Ctrl_F2"", Key::Ctrl_F2 },
        { ""Ctrl_F3"", Key::Ctrl_F3 },
        { ""Ctrl_F4"", Key::Ctrl_F4 },
        { ""Ctrl_F5"", Key::Ctrl_F5 },
        { ""Ctrl_F6"", Key::Ctrl_F6 },
        { ""Ctrl_F7"", Key::Ctrl_F7 },
        { ""Ctrl_F8"", Key::Ctrl_F8 },
        { ""Ctrl_F9"", Key::Ctrl_F9 },
        { ""Ctrl_F10"", Key::Ctrl_F10 },
        { ""Ctrl_F11"", Key::Ctrl_F11 },
        { ""Ctrl_F12"", Key::Ctrl_F12 },
        { ""Shift_Tab"", Key::Shift_Tab },
        { ""Single_Click"", Key::Single_Click },
        { ""Double_Click"", Key::Double_Click },
        { ""Right_Click"", Key::Right_Click },
        { ""Wheel_Down"", Key::Wheel_Down },
        { ""Wheel_Up"", Key::Wheel_Up },
        { ""Ctrl_LeftMouse"", Key::Ctrl_LeftMouse },
        { ""Shift_LeftMouse"", Key::Shift_LeftMouse },

        { ""Alt_a"", Key::Alt_a }, { ""Alt_A"", Key::Alt_A },
        { ""Alt_b"", Key::Alt_b }, { ""Alt_B"", Key::Alt_B },
        { ""Alt_c"", Key::Alt_c }, { ""Alt_C"", Key::Alt_C },
        { ""Alt_d"", Key::Alt_d }, { ""Alt_D"", Key::Alt_D },
        { ""Alt_e"", Key::Alt_e }, { ""Alt_E"", Key::Alt_E },
        { ""Alt_f"", Key::Alt_f }, { ""Alt_F"", Key::Alt_F },
        { ""Alt_g"", Key::Alt_g }, { ""Alt_G"", Key::Alt_G },
        { ""Alt_h"", Key::Alt_h }, { ""Alt_H"", Key::Alt_H },
        { ""Alt_i"", Key::Alt_i }, { ""Alt_I"", Key::Alt_I },
        { ""Alt_j"", Key::Alt_j }, { ""Alt_J"", Key::Alt_J },
        { ""Alt_k"", Key::Alt_k }, { ""Alt_K"", Key::Alt_K },
        { ""Alt_l"", Key::Alt_l }, { ""Alt_L"", Key::Alt_L },
        { ""Alt_m"", Key::Alt_m }, { ""Alt_M"", Key::Alt_M },
        { ""Alt_n"", Key::Alt_n }, { ""Alt_N"", Key::Alt_N },
        { ""Alt_o"", Key::Alt_o }, { ""Alt_O"", Key::Alt_O },
        { ""Alt_p"", Key::Alt_p }, { ""Alt_P"", Key::Alt_P },
        { ""Alt_q"", Key::Alt_q }, { ""Alt_Q"", Key::Alt_Q },
        { ""Alt_r"", Key::Alt_r }, { ""Alt_R"", Key::Alt_R },
        { ""Alt_s"", Key::Alt_s }, { ""Alt_S"", Key::Alt_S },
        { ""Alt_t"", Key::Alt_t }, { ""Alt_T"", Key::Alt_T },
        { ""Alt_u"", Key::Alt_u }, { ""Alt_U"", Key::Alt_U },
        { ""Alt_v"", Key::Alt_v }, { ""Alt_V"", Key::Alt_V },
        { ""Alt_w"", Key::Alt_w }, { ""Alt_W"", Key::Alt_W },
        { ""Alt_x"", Key::Alt_x }, { ""Alt_X"", Key::Alt_X },
        { ""Alt_y"", Key::Alt_y }, { ""Alt_Y"", Key::Alt_Y },
        { ""Alt_z"", Key::Alt_z }, { ""Alt_Z"", Key::Alt_Z }
    }, op_map_{
        { ""Exit"",                   Operation::Exit },
        { ""Accept"",                 Operation::Accept },
        { ""Backspace"",              Operation::Backspace },
        { ""Delete"",                 Operation::Delete },
        { ""ClearLeftCharacters"",    Operation::ClearLeft },
        { ""DeleteLeftWord"",         Operation::DeleteLeftWord },
        { ""Page_Up"",                Operation::PageUp },
        { ""Page_Down"",              Operation::PageDown },
        { ""CursorMoveLeft"",         Operation::CursorMoveLeft },
        { ""CursorMoveRight"",        Operation::CursorMoveRight },
        { ""CursorMoveToBegin"",      Operation::CursorMoveToBegin },
        { ""CursorMoveToEnd"",        Operation::CursorMoveToEnd },
    }, key_op_map_{
        { Key::ESC,             Operation::Exit },
        { Key::Ctrl_M,          Operation::Accept },
        { Key::Double_Click,    Operation::Accept },
        { Key::Backspace,       Operation::Backspace },
        { Key::Delete,          Operation::Delete },
        { Key::Ctrl_U,          Operation::ClearLeft },
        { Key::Ctrl_W,          Operation::DeleteLeftWord },
        { Key::Page_Up,         Operation::PageUp },
        { Key::Page_Down,       Operation::PageDown },
        { Key::Left,            Operation::CursorMoveLeft },
        { Key::Right,           Operation::CursorMoveRight },
        { Key::Home,            Operation::CursorMoveToBegin },
        { Key::End,             Operation::CursorMoveToEnd },
        { Key::Ctrl_J,          Operation::CursorLineMoveDown },
        { Key::Ctrl_K,          Operation::CursorLineMoveUp },
        { Key::Single_Click,    Operation::Single_Click },
        { Key::Double_Click,    Operation::Double_Click },
        //{ Key::Right_Click,     Operation::Right_Click },
        //{ Key::Middle_Click,    Operation::Middle_Click },
        { Key::Wheel_Down,      Operation::Wheel_Down },
        { Key::Wheel_Up,        Operation::Wheel_Up },
        //{ Key::Ctrl_LeftMouse,  Operation::Ctrl_LeftMouse },
        //{ Key::Shift_LeftMouse, Operation::Shift_LeftMouse },
    }, task_map_{
        { Operation::CursorLineMoveUp,
            [this] { ui_queue_.put([this] { tui_.scrollUp<MainWindow>(); }); }
        },
        { Operation::CursorLineMoveDown,
            [this] { ui_queue_.put([this] { tui_.scrollDown<MainWindow>(); }); }
        },
        { Operation::PageUp,
            [this] { ui_queue_.put([this] { tui_.pageUp<MainWindow>(); }); }
        },
        { Operation::PageDown,
            [this] { ui_queue_.put([this] { tui_.pageDown<MainWindow>(); }); }
        },
        { Operation::Single_Click,
            [this] { ui_queue_.put([this, yx=current_yx_] { tui_.singleClick(yx); }); }
        },
        { Operation::Wheel_Down,
            [this] { ui_queue_.put([this, yx=current_yx_] { tui_.wheelDown(yx); }); }
        },
        { Operation::Wheel_Up,
            [this] { ui_queue_.put([this, yx=current_yx_] { tui_.wheelUp(yx); }); }
        },
    }, cmdline_task_map_{
        { Operation::Backspace,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                if ( cursor_pos > 0 ) {
                    already_zero_ = false;
                    auto orig_cursor_pos = cursor_pos;
                    do {
                        --cursor_pos;
                    } while ( cursor_pos > 0 && !utils::is_utf8_boundary(pattern[cursor_pos]) );
                    pattern.erase(cursor_pos, orig_cursor_pos - cursor_pos);

                    cmdline_queue_.put([this, pattern, cursor_pos] {
                        tui_.updateCmdline(pattern, cursor_pos);
                    });
                }
            }
        },
        { Operation::Delete,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                if ( pattern.length() ) {
                    already_zero_ = false;
                    if ( cursor_pos < pattern.length() ) {
                        auto orig_cursor_pos = cursor_pos;
                        do {
                            ++cursor_pos;
                        } while ( cursor_pos < pattern.length()
                                  && !utils::is_utf8_boundary(pattern[cursor_pos]) );
                        pattern.erase(orig_cursor_pos, cursor_pos - orig_cursor_pos);
                        cursor_pos = orig_cursor_pos;
                    }
                    else {
                        auto orig_cursor_pos = cursor_pos;
                        do {
                            --cursor_pos;
                        } while ( cursor_pos > 0 && !utils::is_utf8_boundary(pattern[cursor_pos]) );
                        pattern.erase(cursor_pos, orig_cursor_pos - cursor_pos);
                    }
                    cmdline_queue_.put([this, pattern, cursor_pos] {
                        tui_.updateCmdline(pattern, cursor_pos);
                    });
                }
            }
        },
        { Operation::ClearLeft,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                if ( cursor_pos > 0 ) {
                    already_zero_ = false;
                    pattern.erase(0, cursor_pos);
                    cursor_pos = 0;
                    cmdline_queue_.put([this, pattern, cursor_pos] {
                        tui_.updateCmdline(pattern, cursor_pos);
                    });
                    _shorten(pattern, cursor_pos);
                }
                else {
                    already_zero_ = true;
                }
            }
        },
        { Operation::DeleteLeftWord,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                auto orig_cursor_pos = cursor_pos;
                while ( cursor_pos > 0 && pattern[cursor_pos-1] == ' ' ) {
                    --cursor_pos;
                }
                while ( cursor_pos > 0 && pattern[cursor_pos-1] != ' ' ) {
                    --cursor_pos;
                }
                pattern.erase(cursor_pos, orig_cursor_pos - cursor_pos);
                cmdline_queue_.put([this, pattern, cursor_pos] {
                    tui_.updateCmdline(pattern, cursor_pos);
                });

                if ( cursor_pos > 0 ) {
                    already_zero_ = false;
                }
            }
        },
        { Operation::CursorMoveLeft,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                if ( cursor_pos > 0 ) {
                    already_zero_ = false;
                    do {
                        --cursor_pos;
                    } while ( cursor_pos > 0 && !utils::is_utf8_boundary(pattern[cursor_pos]) );

                    cmdline_queue_.put([this, pattern, cursor_pos] {
                        tui_.updateCmdline(pattern, cursor_pos);
                    });
                }
                else {
                    already_zero_ = true;
                }
            }
        },
        { Operation::CursorMoveRight,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                if ( cursor_pos < pattern.length() ) {
                    do {
                        ++cursor_pos;
                    } while ( cursor_pos < pattern.length()
                              && !utils::is_utf8_boundary(pattern[cursor_pos]) );

                    cmdline_queue_.put([this, pattern, cursor_pos] {
                        tui_.updateCmdline(pattern, cursor_pos);
                    });
                }
            }
        },
        { Operation::CursorMoveToBegin,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                if ( cursor_pos > 0 ) {
                    cursor_pos = 0;
                    already_zero_ = true;
                    cmdline_queue_.put([this, pattern, cursor_pos] {
                        tui_.updateCmdline(pattern, cursor_pos);
                    });
                }
            }
        },
        { Operation::CursorMoveToEnd,
            [this](std::string& pattern, uint32_t& cursor_pos) {
                cursor_pos = pattern.length();
                cmdline_queue_.put([this, pattern, cursor_pos] {
                    tui_.updateCmdline(pattern, cursor_pos);
                });
            }
        },
    }
{
    content_.reserve(255);
}

#ifdef __APPLE__
constexpr int SIG_UserDefined = SIGUSR1;
#else
const int SIG_UserDefined = SIGRTMIN+8;
#endif

void Application::_handleSignal() {
    sigset_t waitset;
    sigemptyset(&waitset);

    sigaddset(&waitset, SIGINT);    // ctrl-c
    sigaddset(&waitset, SIGQUIT);
    sigaddset(&waitset, SIGTERM);
    sigaddset(&waitset, SIGTSTP);
    sigaddset(&waitset, SIGCONT);
    sigaddset(&waitset, SIGWINCH);
    sigaddset(&waitset, SIG_UserDefined);

    while ( running_.load(std::memory_order_relaxed) )  {
        int sig;
        int ret = sigwait(&waitset, &sig);
        if ( ret != -1 ) {
            switch ( sig )
            {
            case SIGINT:
            case SIGQUIT:
            case SIGTERM:
                Tty::getInstance().exit();
                return;
            case SIGTSTP:
                Cleanup::getInstance().doWork(false);
                kill(getpid(), SIGSTOP);
                sigstop_ = true;
                break;
            case SIGCONT:
                if ( sigstop_ ) {
                    sigstop_ = false;
                    Tty::getInstance().setNewTerminal();
                    _resume();
                }
                break;
            case SIGWINCH:
                break;
            default:
                if ( sig == SIG_UserDefined ) {
                    return;
                }
                break;
            }
        }
        //// for sigwaitinfo
        //else if ( errno == EINTR ) {
        //    continue;
        //}
        else {
            Error::getInstance().appendError(ErrorMessage);
            std::exit(EXIT_FAILURE);
        }
    }
}

void Application::_readConfig() {

}

void Application::start() {
    std::thread  [MASK] (&Application::_handleSignal, this);
    std::thread reader(&Application::_readData, this);
    std::thread input(&Application::_input, this);
    std::thread ui(&Application::_doWork, this, std::ref(ui_queue_));
    std::thread cmdline(&Application::_doWork, this, std::ref(cmdline_queue_));
    std::thread show_flag(&Application::_showFlag, this);

    _doWork(task_queue_);

    show_flag.join();
     [MASK] .join();
    reader.join();
    input.join();
    ui.join();
    cmdline.join();
}

int Application::_exec(const char* cmd) {
    int fd[2];

    if ( pipe(fd) < 0 ) {
        Error::getInstance().appendError(ErrorMessage);
        std::exit(EXIT_FAILURE);
        return -1;
    }

    auto pid = fork();
    if ( pid < 0 ) {
        close(fd[0]);
        close(fd[1]);
        Error::getInstance().appendError(ErrorMessage);
        std::exit(EXIT_FAILURE);
        return -1;
    }
    else if ( pid == 0 ) {
#ifdef __linux__
        prctl(PR_SET_PDEATHSIG, SIGKILL);
#endif
        close(fd[0]);
        if ( fd[1] != STDOUT_FILENO ) {
            dup2(fd[1], STDOUT_FILENO);
            close(fd[1]);
        }
        execl(""/bin/sh"", ""sh"", ""-c"", cmd, nullptr);
        std::exit(127);
    }

    close(fd[1]);

    return fd[0];
}

void Application::_readData() {
    using namespace std::chrono;

    struct FdRAII
    {
        explicit FdRAII(int fd) : fd(fd) {}
        ~FdRAII() {
            if ( fd != STDIN_FILENO ) {
                close(fd);
            }
        }
        int fd;
    };

    FdRAII read_fd = FdRAII(STDIN_FILENO);
    if ( isatty(STDIN_FILENO) ) {
#ifdef __APPLE__
        auto cmd = ""find . -name \"".\"" -o -name \"".*\"" -prune -o -type f -print 2>/dev/null | cut -b3-"";
#else
        auto cmd = ""find . -name \"".\"" -o -name \"".*\"" -prune -o -type f -printf \""%P\n\"" 2>/dev/null"";
#endif
        read_fd.fd = _exec(cmd);
    }

    BufferStorage storage;
    auto start_time = steady_clock::now();
    char buffer[BufferLen];
    while ( running_ ) {
        auto len = read(read_fd.fd, buffer, sizeof(buffer));
        if ( len < 0 ) {
            if ( errno == EINTR ) {
                continue;
            }
            else {
                Error::getInstance().appendError(ErrorMessage);
                std::exit(EXIT_FAILURE);
            }
        }
        else if ( len == 0 ) {
            // indicate the end
            storage.put(std::make_shared<DataBuffer>());
            task_queue_.put([this, s=std::move(storage)]() mutable {
                _processData(std::move(s));
            });

            break;
        }
        storage.put(std::make_shared<DataBuffer>(buffer, len));
        auto end_time = steady_clock::now();
        if ( duration_cast<milliseconds>(end_time - start_time).count() > 50 ) {
            start_time = end_time;
            task_queue_.put([this, s=std::move(storage)]() mutable {
                _processData(std::move(s));
            });
        }
    }
}

void Application::_processData(BufferStorage&& storage) {
    static char eol = '\0';
    for ( auto& sp_buffer : storage.getBuffers() ) {
        // end
        if ( sp_buffer->len == 0 ) {
            if ( !incomplete_str_.empty() ) {
                DataBufferPtr data = std::make_shared<DataBuffer>(incomplete_str_.c_str(),
                                                                  incomplete_str_.length());
                buffer_storage_.put(data);
                incomplete_str_.clear();
                content_.push_back(makeConstString(data->buffer, data->len));
            }

            flag_running_ = false;
            break;
        }
        uint32_t i = 0;
        if ( !incomplete_str_.empty() ) {
            for ( ; i < sp_buffer->len; ++i ) {
                if ( sp_buffer->buffer[i] == '\r' || sp_buffer->buffer[i] == '\n' ) {
                    auto incomplete_len = incomplete_str_.length();
                    uint32_t str_len = incomplete_len + i;
                    DataBufferPtr data = std::make_shared<DataBuffer>(str_len);
                    memcpy(data->buffer, incomplete_str_.c_str(), incomplete_len);
                    if ( i > 0 ) {
                        memcpy(data->buffer + incomplete_len, sp_buffer->buffer, i);
                    }
                    buffer_storage_.put(data);
                    incomplete_str_.clear();
                    content_.push_back(makeConstString(data->buffer, str_len));
                    eol = sp_buffer->buffer[i];
                    ++i;    // point to next character
                    break;
                }
            }

            if ( i == sp_buffer->len ) {
                // no '\r' or '\n' found
                if ( eol == '\0' ) {
                    incomplete_str_.append(sp_buffer->buffer, sp_buffer->len);
                }
                continue;
            }
        }

        if ( eol == '\r' && i < sp_buffer->len && sp_buffer->buffer[i] == '\n' ) {
            ++i;
        }

        eol = '\0';

        auto start = sp_buffer->buffer + i;
        for ( ; i < sp_buffer->len; ++i ) {
            if ( sp_buffer->buffer[i] == '\r' || sp_buffer->buffer[i] == '\n' ) {
                content_.push_back(makeConstString(start, sp_buffer->buffer + i - start));
                if ( sp_buffer->buffer[i] == '\r' ) {
                    if ( i + 1 == sp_buffer->len ) {
                        eol = '\r';
                    }
                    else if ( sp_buffer->buffer[i + 1] == '\n' ) {
                        ++i;
                    }
                }
                start = sp_buffer->buffer + i + 1;
            }
        }

        if ( start < sp_buffer->buffer + sp_buffer->len ) {
            incomplete_str_ = std::string(start, sp_buffer->buffer + sp_buffer->len - start);
        }
    }

    buffer_storage_.extend(std::move(storage));

    if ( !pattern_.empty() ) {
        _search(true);
    }
    else {
        result_content_size_.store(content_.size(), std::memory_order_relaxed);
        cmdline_queue_.put([this, result_size=content_.size(), total_size=content_.size()] {
            tui_.updateLineInfo(result_size, total_size);
        });
        static bool enough_size = false;
        if ( enough_size == false ) {
            if ( content_.size() >= tui_.getCoreHeight<MainWindow>() ) {
                enough_size = true;
            }
            ui_queue_.put([this]{ _initBuffer(); });
        }
    }
}

void Application::_input() {
    using namespace std::chrono;
    using Ms = std::chrono::milliseconds;
    using TimePoint = decltype(steady_clock::now());

    TimePoint cur_time;
    TimePoint start_time;
    bool timeout = true;
    std::string pattern;
    uint32_t cursor_pos = 0;
    Operation last_op = Operation::Invalid;
    while ( true ) {
        auto tup = Tty::getInstance().getchar();
        if ( timeout == true ) {
            timeout = false;
            start_time = steady_clock::now();
        }
        auto key = std::get<0>(tup);
        if ( key == Key::Ctrl_I ) { // tab
            normal_mode_ = !normal_mode_;
            cmdline_queue_.put([this] {
                tui_.redrawPrompt(normal_mode_);
            });
        }

        if ( normal_mode_ ) {
            if ( std::get<1>(tup) == ""j"" ) {
                key = Key::Ctrl_J;
            }
            else if ( std::get<1>(tup) == ""k"" ) {
                key = Key::Ctrl_K;
            }
            else if ( key == Key::Char ) {
                key = Key::Unknown;
            }
        }

        if ( key == Key::Char ) {
            last_op = Operation::Input;
            pattern.insert(cursor_pos, std::get<1>(tup));
            ++cursor_pos;
            cmdline_queue_.put([this, pattern, cursor_pos] {
                tui_.updateCmdline(pattern, cursor_pos);
            });

            cur_time = steady_clock::now();
            if ( result_content_size_.load(std::memory_order_relaxed) < 20000
                 || duration_cast<Ms>(cur_time - start_time).count() > 500 ) {
                start_time = cur_time;

                search_count_++;
                task_queue_.put([this, pattern] {
                    pattern_ = std::move(pattern);
                    _search(false);
                });
            }
        }
        else if ( key == Key::Timeout ) {
            timeout = true;
            switch ( last_op ) {
            case Operation::Input:
                if ( start_time != cur_time ) {
                    search_count_++;
                    task_queue_.put([this, pattern] {
                        pattern_ = std::move(pattern);
                        _search(false);
                    });
                }
                break;
            case Operation::Backspace:
            case Operation::Delete:
                if ( start_time != cur_time ) {
                    _shorten(pattern, cursor_pos);
                }
                break;
            default:
                break;
            }
        }
        else if ( key == Key::Exit ) {
            _notifyExit();
            break;
        }
        else {
            if ( key == Key::Single_Click || key == Key::Right_Click
                 || key == Key::Middle_Click || key == Key::Wheel_Down
                 || key == Key::Wheel_Up || key == Key::Ctrl_LeftMouse
                 || key == Key::Shift_LeftMouse ) {
                auto& esc_code = std::get<1>(tup);
                auto semicolon = esc_code.find(';');
                current_yx_.line = std::stol(esc_code.substr(semicolon+1));
                current_yx_.col = std::stol(esc_code.substr(0, semicolon));
            }

            auto iter = key_op_map_.find(key);
            if ( iter != key_op_map_.end() ) {
                auto op = iter->second;
                last_op = op;
                if ( op == Operation::Exit ) {
                    _notifyExit();
                    break;
                }
                else if ( op == Operation::Accept ) {
                    _notifyExit();
                    tui_.setAccept();
                    break;
                }

                auto it = cmdline_task_map_.find(op);
                if ( it != cmdline_task_map_.end() ) {
                    it->second(pattern, cursor_pos); // e.g. ctrl-u, backspace, left, right
                }

                if ( op == Operation::Backspace || op == Operation::Delete ) {
                    cur_time = steady_clock::now();
                    if ( duration_cast<Ms>(cur_time - start_time).count() > 200 ) {
                        start_time = cur_time;
                        _shorten(pattern, cursor_pos);
                    }
                }

                auto task_iter = task_map_.find(op);
                if ( task_iter != task_map_.end() ) {
                    task_queue_.put(task_iter->second);
                }
            }
            else {
                last_op = Operation::Invalid;
            }
        }
    }
}

void Application::_notifyExit() {
#ifdef __APPLE__
    kill(getpid(), SIG_UserDefined);
#else
    union sigval sigv;
    sigqueue(getpid(), SIG_UserDefined, sigv);
#endif

    running_ = false;

    ui_queue_.put(Task());
    task_queue_.put(Task());
    cmdline_queue_.put(Task());
}

void Application::_shorten(const std::string& pattern, uint32_t cursor_pos) {
    if ( already_zero_ ) {
        return;
    }

    if ( cursor_pos == 0 ) {
        already_zero_ = true;
    }
    else {
        already_zero_ = false;
    }

    if ( pattern.empty() ) {
        task_queue_.put([this] {
            result_content_size_.store(content_.size(), std::memory_order_relaxed);
            cmdline_queue_.put([this, content_size=content_.size()] {
                tui_.updateLineInfo(content_size, content_size);
            });
        });
        task_queue_.put([this] {
            index_ = 0;
            pattern_.clear();
            ui_queue_.put([this]{ _initBuffer(); });
        });
    }
    else {
        search_count_++;
        task_queue_.put([this, pattern] {
            pattern_ = std::move(pattern);
            index_ = 0;
            _search(false);
        });
    }

}

void Application::_search(bool is_continue) {
    if ( running_ == false ) { // stop continue
        return;
    }

    if ( !is_continue ) {
        search_count_--;
    }

    using namespace std::chrono;
    StrContainer::const_iterator source_begin;
    uint32_t content_size{ 0 };
    auto total_size{ content_.size() };
    StrContainer cur_content;
    std::function<void()> guard;

    if ( index_ == 0 ) {
        cb_content_.clear();
        result_content_.clear();
        index_ = std::min(step_, static_cast<decltype(step_)>(total_size));
        source_begin = content_.cbegin();
        content_size = index_;
    }
    else {
        uint32_t result_size = is_continue ? 0 : result_content_.size();
        if ( result_size >= step_ ) {
            source_begin = result_content_.cbegin();
            content_size = step_;
            if ( result_size > step_ ) {
                cb_content_.push_front(result_content_.cbegin() + step_, result_content_.cend());
            }
        }
        else {
            if ( result_size > 0 ) {
                cur_content.reserve(step_);
                cur_content.push_back(result_content_.cbegin(), result_content_.cend());
            }
            uint32_t cb_size = cb_content_.size();
            if ( cb_size >= step_ - result_size ) {
                if ( result_size == 0 ) {
                    source_begin = cb_content_.cbegin();
                    content_size = step_;
                    guard = [this, content_size] {
                        cb_content_.pop_front(content_size);
                    };
                }
                else {
                    auto last = cb_content_.cbegin() + (step_ - result_size);
                    cur_content.push_back(cb_content_.cbegin(), last);
                    cb_content_.pop_front(step_ - result_size);
                }
            }
            else {
                if ( cb_size > 0 ) {
                    cur_content.push_back(cb_content_.cbegin(), cb_content_.cend());
                    cb_content_.clear();
                }
                if ( index_ < total_size ) {
                    uint32_t offset = step_ - result_size - cb_size;
                    auto size = std::min(offset, static_cast<decltype(step_)>(total_size - index_));
                    if ( offset == step_ ) {
                        source_begin = content_.cbegin() + index_;
                        content_size = size;
                    }
                    else {
                        cur_content.push_back(content_.cbegin() + index_, content_.cbegin() + (index_ + size));
                    }
                    index_ += size;
                }
            }
        }

        if ( source_begin == nullptr ) {
            source_begin = cur_content.cbegin();
            content_size = cur_content.size();
        }
    }

    auto result = fuzzy_engine_.fuzzyMatch(source_begin, content_size, pattern_, preference_);
    if ( is_continue && result_content_.size() > 0 ) {
        result = fuzzy_engine_.merge(previous_result_, result);
    }

    {
        std::unique_lock<std::mutex> lock(result_mutex_);
        while ( access_count_ > 0 ) {
            result_cond_.wait(lock);
        }

        // sync with _updateResult()
        if ( !is_continue || (index_ >= total_size && cb_content_.size() == 0) ) {
            access_count_++;
        }
    }

    previous_result_ = std::move(result);
    result_content_size_.store(result_content_.size(), std::memory_order_relaxed);
    cmdline_queue_.put([this, result_size=result_content_.size(), total_size] {
        tui_.updateLineInfo(result_size, total_size);
    });

    // update result only when not continue or last continue
    if ( !is_continue || (index_ >= total_size && cb_content_.size() == 0) ) {
        ui_queue_.put([this, pattern=pattern_, result_size=result_content_.size()]{
            _updateResult(result_size, pattern);
        });
    }

    if ( guard ) {
        guard();
    }

    if ( (index_ < total_size || cb_content_.size() > 0) && search_count_ == 0 ) {
        _search(true);
    }

}

void Application::_doWork(BlockingQueue<Task>& q) {
    while ( running_ ) {
        auto task = q.take();
        if ( task ) {
            task();
        }
        else {
            break;
        }
    }
}

std::vector<HighlightString> Application::_generateHighlightStr(uint32_t first, uint32_t last,
                                                                const std::string& pattern) {
    std::vector<HighlightString> res;

    if ( first == last ) {
        return res;
    }
    res.reserve(last - first);

    auto highlights = fuzzy_engine_.getHighlights(result_content_.cbegin() + first,
                                                  last - first, pattern);
    const char* reset_color = ""\033[0m"";
    auto& match_color = tui_.getColor(HighlightGroup::Match0);
    auto& normal_color = tui_.getColor(HighlightGroup::Normal);

    auto max_width = tui_.getCoreWidth<MainWindow>() - indent_;
    if ( static_cast<int32_t>(max_width) <= 0 ) {
        return res;
    }
    auto iter = result_content_.cbegin() + first;
    auto end = result_content_.cbegin() + last;
    for (uint32_t i = 0; iter != end; ++iter, ++i ) {
        std::string s;
        s.reserve(iter->len << 1);
        auto& p_context = highlights[i];

        if ( iter->len <= max_width  ) {
            auto p = iter->str;
            for ( uint32_t j = 0; j < p_context->end_index; ++j ) {
                s.append(normal_color);
                s.append(p, iter->str + p_context->positions[j].col - p);
                p = iter->str + p_context->positions[j].col;
                s.append(match_color);
                s.append(p, p_context->positions[j].len);
                p += p_context->positions[j].len;
            }

            if ( auto len = iter->str + iter->len - p ) {
                s.append(normal_color);
                s.append(p, len);
            }
        }
        else {
            uint32_t right = p_context->end + std::min(iter->len - p_context->end, 10u);
            uint32_t left = 0;
            if ( right > max_width ) {
                left = right - max_width;
            }
            else {
                right = max_width;
            }

            auto p = iter->str + left;
            bool is_beginning = true;
            for ( uint32_t j = 0; j < p_context->end_index; ++j ) {
                auto col = p_context->positions[j].col;
                if ( col < left ) {
                    continue;
                }
                else if ( left == 0 || is_beginning == false ) {
                    is_beginning = false;
                    s.append(normal_color);
                    s.append(p, iter->str + p_context->positions[j].col - p);
                }
                else {
                    if ( col >= left + 2 ) {
                        is_beginning = false;

                        s.append(normal_color);
                        s.append("".."");
                        s.append(p + 2, iter->str + p_context->positions[j].col - p - 2);
                    }
                    else {
                        continue;
                    }
                }

                p = iter->str + p_context->positions[j].col;
                s.append(match_color);
                s.append(p, p_context->positions[j].len);
                p += p_context->positions[j].len;
            }

            if ( auto len = right - p_context->end ) {
                s.append(normal_color);
                if ( right < iter->len ) {
                    s.append(p, len - 2);
                    s.append("".."");
                }
                else {
                    s.append(p, len);
                }
            }
        }

        s.append(reset_color);

        res.emplace_back(std::move(s), *iter);
    }

    return res;
}

void Application::_initBuffer() {
    tui_.setBuffer<MainWindow>([this, indicator=0u]() mutable {
        auto height = tui_.getCoreHeight<MainWindow>();

        auto first = indicator;
        auto last = std::min(indicator + height,
                             static_cast<decltype(indicator)>(content_.size()));
        indicator = last;

        std::vector<HighlightString> res;
        res.reserve(last - first);

        const char* reset_color = ""\033[0m"";
        auto& normal_color = tui_.getColor(HighlightGroup::Normal);

        auto max_width = tui_.getCoreWidth<MainWindow>() - indent_;
        auto iter = content_.cbegin() + first;
        auto end = content_.cbegin() + last;
        if ( normal_color == reset_color ) {
            for ( ; iter != end; ++iter ) {
                if ( iter->len <= max_width  ) {
                    res.emplace_back(std::string(iter->str, iter->len), *iter);
                }
                else {
                    res.emplace_back(std::string(iter->str, max_width - 2) + "".."", *iter);
                }
            }
        }
        else {
            for ( ; iter != end; ++iter ) {
                if ( iter->len <= max_width  ) {
                    res.emplace_back(normal_color + std::string(iter->str, iter->len) + reset_color,
                                     *iter);
                }
                else {
                    res.emplace_back(normal_color + std::string(iter->str, max_width - 2) + ""..""
                                     + reset_color, *iter);
                }
            }
        }

        return res;
    });
}

void Application::_showFlag() {
    while ( flag_running_ && running_ ) {
        tui_.showFlag(true);
        std::this_thread::sleep_for(std::chrono::milliseconds(150));
    }
    tui_.showFlag(false);
}

// in ui_queue_ thread
void Application::_updateResult(uint32_t result_size, const std::string& pattern) {
    // [0, indicator) has been translated into highlight string
    tui_.setBuffer<MainWindow>([this, result_size, pattern, indicator=0u]() mutable {
        auto height = tui_.getCoreHeight<MainWindow>();

        auto first = indicator;
        auto last = std::min(indicator + height, result_size);
        indicator = last;

        return _generateHighlightStr(first, last, pattern);
    });

    {
        std::lock_guard<std::mutex> lock(result_mutex_);
        if ( access_count_ > 0 ) {
            access_count_--;
        }
        result_cond_.notify_one();
    }
}

void Application::_resume() {
    tui_.init(true);
    cmdline_queue_.put([this] {
        tui_.drawBorder();
        tui_.redrawPrompt(normal_mode_);
        tui_.updateCmdline(pattern_);
        tui_.updateLineInfo();
        tui_.setBuffer<MainWindow>();
    });
}

} // end namespace leaf
",sig_handler
590,"#include <SDL.h>
#include <Windows.h>
#include <gl/GL.h>
#include <gl/GLU.h>
#include <cmath>
#include <iostream>
#include <fstream>

void loadPerspective(float fov, float aspect, float znear, float zfar)
{

	float ymax = znear * (float)tan(fov * (M_PI / 360));
	float ymin = -ymax;
	float xmax = ymax * aspect;
	float xmin = ymin * aspect;

	float width = xmax - xmin;
	float height = ymax - ymin;

	float depth = zfar - znear;
	float q = -(zfar + znear) / depth;
	float qn = -2 * (zfar * znear) / depth;

	float w = 2 * znear / width;
	w = w / aspect;
	float h = 2 * znear / height;

	GLfloat m [16] =
	{
		w, 0, 0, 0,

		0, h, 0, 0,

		0, 0, q, -1,

		0, 0, qn, 0
	};

	glLoadMatrixf(m);
}

float Map(const float value, const float fromLow, const float fromHigh, const float toLow, const float toHigh)
{
	return ((value - fromLow) / (fromHigh - fromLow) * (toHigh - toLow)) + toLow;
}

void DrawRectangle(const float width, const float height)
{
	GLfloat halfWidth = (width * 0.5f);
	GLfloat halfHeight = (width * 0.5f);
	glBegin(GL_LINE_LOOP);
	{
		glVertex2f(-halfWidth, halfHeight);
		glVertex2f(halfWidth, halfHeight);
		glVertex2f(halfWidth, -halfHeight);
		glVertex2f(-halfWidth, -halfHeight);
	}
	glEnd();
}

void FillRectangle(const float width, const float height)
{
	GLfloat halfWidth = (width * 0.5f);
	GLfloat halfHeight = (height * 0.5f);
	glBegin(GL_TRIANGLE_FAN);
	{
		glVertex2f(-halfWidth, halfHeight);
		glVertex2f(halfWidth, halfHeight);
		glVertex2f(halfWidth, -halfHeight);
		glVertex2f(-halfWidth, -halfHeight);
	}
	glEnd();
}

void DrawRectangle(const float x, const float y, const float width, const float height)
{
	glBegin(GL_LINE_LOOP);
	{
		glVertex2f(x, y);
		glVertex2f(x + width, y);
		glVertex2f(x + width, y + height);
		glVertex2f(x , y + height);
	}
	glEnd();
}

void FillRectangle(const float x, const float y, const float width, const float height)
{
	glBegin(GL_TRIANGLE_FAN);
	{
		glVertex2f(x, y);
		glVertex2f(x + width, y);
		glVertex2f(x + width, y + height);
		glVertex2f(x, y + height);
	}
	glEnd();
}

void FillCircle(const float radius, const int resolution = 16)
{
	float step = (2 * M_PI) / resolution;
	glBegin(GL_TRIANGLE_FAN);
	{
		float angle = 0;
		for (int i = 0; i <= resolution; ++i)
		{
			glVertex2f(cos(angle) * radius, sin(angle) * radius);
			angle += step;
		}
	}
	glEnd();
}

void DrawCircle(const float radius, const int resolution = 16)
{
	glBegin(GL_LINE_LOOP);
	{
		const float step = (2 * M_PI) / resolution;
		float angle = 0;
		for (int i = 0; i <= resolution; ++i)
		{
			glVertex2f(cos(angle) * radius, sin(angle) * radius);
			angle += step;
		}
	}
	glEnd();
}

void DrawBatteryIndicator(const int percent)
{
	float scale = Map(percent, 0, 100, -0.75, 0.75);
	float shadeR = Map(percent, 0, 100, 1, 0);
	float shadeG = Map(percent, 0, 100, 0, 1);

	float height = 0.75 * 2;
	float  [MASK]  = height * scale;
	float scaledDifference = height * (1.0-scale);

	glColor3f(1.0f, 1.0f, 1.0f);
	FillRectangle(1.0f, height);

	glColor3f(0.5f, 0.5f, 0.5f);
	FillRectangle(-0.5f, -0.75f, 1.0f, scaledDifference);

	glColor3f(shadeR, shadeG, 0.0f);
	FillRectangle(-0.5f, -0.75f + scaledDifference, 1.0f,  [MASK] );
}

void DrawPowerIndicator()
{
	int seconds = 0;
	int percent = 0;

	auto state = SDL_GetPowerInfo(&seconds, &percent);

	switch (state)
	{
	case SDL_PowerState::SDL_POWERSTATE_CHARGED:
		{

		}
		break;
	case SDL_PowerState::SDL_POWERSTATE_CHARGING:
		{

		}
		break;
	case SDL_PowerState::SDL_POWERSTATE_ON_BATTERY:
		{
			//if (percent != -1)
			//{
				//DrawBatteryIndicator(percent);
			//}			
		}
		break;
	case SDL_PowerState::SDL_POWERSTATE_NO_BATTERY:
		{
			//glColor3f(0.75f, 0.75f, 0.75f);
			//FillCircle(1, 32);
		}
		break;
	}
}

int main(int argn, char* args[])
{
	int s = sizeof(GLbitfield);

	SDL_Init(SDL_INIT_EVERYTHING);

	SDL_Window * window = nullptr;
	
	window = SDL_CreateWindow("""", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
	
	SDL_GLContext context = SDL_GL_CreateContext(window);

	int numJoysticks = SDL_NumJoysticks();

	SDL_Joystick * joystick = SDL_JoystickOpen(0);
	int axes = SDL_JoystickNumAxes(joystick);
	int hats = SDL_JoystickNumHats(joystick);
	int buttons = SDL_JoystickNumButtons(joystick);

	bool joystickMode = (numJoysticks > 0);
	
	float x = 0, y = 0;
	float angle = 0;
	Uint32 last = 0;

	float xOffset = 0, yOffset = 0;
	float pAngle = 0, mAngle = 0;

	bool running = true;
	SDL_Event e;
	while (running)
	{
		int now = SDL_GetTicks();
		int diff = now - last;
		last = now;

		float delta = diff / 1000.0f;

		while (SDL_PollEvent(&e))
		{
			if (e.type == SDL_QUIT)
			{
				running = false;
			}
			else if (e.type == SDL_KEYDOWN)
			{
				if (!joystickMode)
				{
					switch (e.key.keysym.sym)
					{
					case SDLK_w: yOffset = 1; break;
					case SDLK_a: xOffset = -1; break;
					case SDLK_x: yOffset = -1; break;
					case SDLK_d: xOffset = 1; break;
					case SDLK_q: pAngle = -1; break;
					case SDLK_e: mAngle = 1; break;
					}
				}
			}
			else if (e.type == SDL_KEYUP)
			{
				if (!joystickMode)
				{
					switch (e.key.keysym.sym)
					{
					case SDLK_w: yOffset = 0; break;
					case SDLK_a: xOffset = 0; break;
					case SDLK_x: yOffset = 0; break;
					case SDLK_d: xOffset = 0; break;
					case SDLK_q: pAngle = 0; break;
					case SDLK_e: mAngle = 0; break;
					}
				}
			}
			else if (e.type == SDL_JOYAXISMOTION)
			{
				if (joystickMode)
				{
					xOffset = Map(SDL_JoystickGetAxis(joystick, 0), -32768, 32767, -1, 1);
					yOffset = Map(SDL_JoystickGetAxis(joystick, 1), -32768, 32767, 1, -1);
					pAngle = Map(SDL_JoystickGetAxis(joystick, 2), -32768, 32767, 0, -1);
					mAngle = Map(SDL_JoystickGetAxis(joystick, 5), -32768, 32767, 0, 1);
				}
			}
		}

		const float dead = 0.2f;

		x += (xOffset < dead && xOffset > -dead) ? 0 : xOffset * delta;
		y += (yOffset < dead && yOffset > -dead) ? 0 : yOffset * delta;

		float pAngleOffset = (pAngle < dead && pAngle > -dead) ? 0 : pAngle * (M_PI * 2) * delta;
		float mAngleOffset = (mAngle < dead && mAngle > -dead) ? 0 : mAngle * (M_PI * 2) * delta;

		pAngleOffset *= 10;
		mAngleOffset *= 10;

		angle += pAngleOffset;
		angle += mAngleOffset;

		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		{
			glViewport(0, 0, 800, 600);

			glMatrixMode(GL_PROJECTION);
			glLoadIdentity();

			glMatrixMode(GL_MODELVIEW);
			glLoadIdentity();

			glPushMatrix();
			glTranslatef(0.75f,-0.75f,0.0f);
			glScalef(0.25f, 0.25f, 1.0f);
			DrawPowerIndicator();
			glPopMatrix();

			glMatrixMode(GL_PROJECTION);
			loadPerspective(60.0, 800.0f / 600.0f, 0.1f, 100.0f);

			glMatrixMode(GL_MODELVIEW);
			glLoadIdentity();

			glPushMatrix();
			
				glTranslatef(x, y, -5.0);
				glRotatef(angle, 0, 1, 0);

				/*glColor3f(1.0f, 1.0f, 1.0f);
				glBegin(GL_TRIANGLE_FAN);
				glVertex3d(0, 1, 0);
				glVertex3d(0.5, 0, 0.5);
				glVertex3d(-0.5, 0, 0.5);
				glVertex3d(-0.5, 0, -0.5);
				glVertex3d(0.5, 0, -0.5);
				glEnd();*/

				glColor3f(0.0f, 0.0f, 1.0f);

				glBegin(GL_LINE_LOOP);
					glVertex3f(0.6, 0.75, 0.6);
					glVertex3f(0.6, 0.75, -0.6);
					glVertex3f(-0.6, 0.75, -0.6);
					glVertex3f(-0.6, 0.75, 0.6);
				glEnd();

				glBegin(GL_LINE_LOOP);
					glVertex3f(0.8, 0.75, 0.8);
					glVertex3f(0.8, 0.75, -0.8);
					glVertex3f(-0.8, 0.75, -0.8);
					glVertex3f(-0.8, 0.75, 0.8);
				glEnd();

				glBegin(GL_LINE_LOOP);
					glVertex3f(0.8, 0.8, 0.8);
					glVertex3f(0.8, 0.8, -0.8);
					glVertex3f(-0.8, 0.8, -0.8);
					glVertex3f(-0.8, 0.8, 0.8);
				glEnd();
				
				glBegin(GL_LINE_LOOP);
					glVertex3f(0.6, -0.75, 0.6);
					glVertex3f(0.6, -0.75, -0.6);
					glVertex3f(-0.6, -0.75, -0.6);
					glVertex3f(-0.6, -0.75, 0.6);
				glEnd();
				
				glBegin(GL_LINE_LOOP);
					glVertex3f(0.8, -0.75, 0.8);
					glVertex3f(0.8, -0.75, -0.8);
					glVertex3f(-0.8, -0.75, -0.8);
					glVertex3f(-0.8, -0.75, 0.8);
				glEnd();
				
				
				glBegin(GL_LINE_LOOP);
					glVertex3f(0.8, -0.85, 0.8);
					glVertex3f(0.8, -0.85, -0.8);
					glVertex3f(-0.8, -0.85, -0.8);
					glVertex3f(-0.8, -0.85, 0.8);
				glEnd();

				glBegin(GL_LINES);

					glVertex3f(0.6, 0.75, 0.6);
					glVertex3f(0.6, -0.75, 0.6);

					glVertex3f(0.6, 0.75, -0.6);
					glVertex3f(0.6, -0.75, -0.6);

					glVertex3f(-0.6, 0.75, 0.6);
					glVertex3f(-0.6, -0.75, 0.6);

					glVertex3f(-0.6, 0.75, -0.6);
					glVertex3f(-0.6, -0.75, -0.6);
				
				glEnd();

				/*glVertex3d(0, 1, 0);
				glVertex3d(0.5, 0, 0.5);

				glVertex3d(0, 1, 0);
				glVertex3d(-0.5, 0, 0.5);

				glVertex3d(0, 1, 0);
				glVertex3d(-0.5, 0, -0.5);

				glVertex3d(0, 1, 0);
				glVertex3d(0.5, 0, -0.5);

				glVertex3d(0.5, 0, 0.5);
				glVertex3d(-0.5, 0, 0.5);

				glVertex3d(-0.5, 0, 0.5);
				glVertex3d(-0.5, 0, -0.5);

				glVertex3d(-0.5, 0, -0.5);
				glVertex3d(0.5, 0, -0.5);

				glVertex3d(0.5, 0, -0.5);
				glVertex3d(0.5, 0, 0.5);*/

				/*glColor3f(1.0f, 0.0f, 1.0f);
				glBegin(GL_POLYGON);
					glVertex3d(1.5, 1, -3);
					glVertex3d(0.5, 0, -3);
					glVertex3d(2.5, 0, -3);
				glEnd();*/

			glPopMatrix();

			/*glBegin(GL_QUADS);
			glVertex2f(-0.25f, -0.25f);
			glVertex2f(0.25f, -0.25f);
			glVertex2f(0.25f, 0.25f);
			glVertex2f(-0.25f, 0.25f);
			glEnd();*/
		}

		SDL_GL_SwapWindow(window);
	}

	SDL_JoystickClose(joystick);

	SDL_GL_DeleteContext(context);
	SDL_DestroyWindow(window);
	SDL_Quit();
	return 0;
}",scaledHeight
591,"#include ""Worker.h""

void Worker::ReadFile()
{
    // snprintf(fileName,sizeof(fileName),""%s"",a);
    // strcat(fileName,Name);
    if ((fd=fopen(fileName, ""rb"")) == NULL)
    {
      printf(""Achtung: Open file error or file not found!\n"");
      FileIsSet = 0;
      sSizeOfFile = 0;
    }
    else
    {
      FileIsSet = 1;
      fseek(fd,0,SEEK_END);
      sSizeOfFile = ftell(fd);

    }
    FileIsIndexed = FileIndexation();  
}


bool Worker::FileIndexation() {
  bool iFileIsIndexed = 0;
  FileIsIndexed = 0;

  TotalHeader.clear();
  uint32_t uiBuffer[3] = {0,0,0};
  uiEventWithMaxSize = 0;
  uiTotalEvents=0;
  uint32_t uiMaxSize = 0;
  fseek(fd,0,SEEK_SET);
  if (sSizeOfFile!=0)
  {
    while (!feof(fd))
    {
      fread(&(TotalHeader.syncword),WORD_SIZE,1,fd);
      if ((TotalHeader.syncword) == SYNC_WORD || (TotalHeader.syncword) == SYNC_WORD_ADC64)
      {
          currPos = ftell(fd);

        // if (FileIsSet==0) FileIsSet = 1;
        uiTotalEvents++;
        eventPositions.push_back(ftell(fd));
        fread(&TotalHeader.EvHeader,sizeof(TotalHeader.EvHeader),1,fd);
        if (uiMaxSize < TotalHeader.EvHeader.length)
        {
          uiMaxSize = TotalHeader.EvHeader.length;
          uiEventWithMaxSize = uiTotalEvents;
        }
      }
      iFileIsIndexed = 1;
    }
  }
  return iFileIsIndexed;
}

void Worker::ReadEvent(int64_t i, int16_t  [MASK] )
{
  event_waveform.Initialize();
  fseek(fd,eventPositions[i],SEEK_SET);
  fread(&TotalHeader.EvHeader,sizeof(TotalHeader.EvHeader),1,fd);
  const uint32_t BS = (TotalHeader.EvHeader.length/4); // size of event block excluding event header

  uint32_t uiBuffer[BS];
  for (int p=0; p<BS; p++) uiBuffer[p] = 0;
  fread(&uiBuffer, sizeof(uiBuffer),1,fd);
  uint32_t offset = 0;   // in elements of event buffer
  int32_t  end    = BS;  // remain number of elements (32-bit words)
  // if (uiTotalEvents%10000==0) DisplayTimeToCalculate(ftell(fd)/1024,sSizeOfFile/1024,start_time);
  while (end > 0)
  {
    TotalHeader.DeviceHeader.sn     = uiBuffer[offset];
    offset++;
    TotalHeader.DeviceHeader.id     = (uiBuffer[offset] & 0xFF000000)>>24;
    TotalHeader.DeviceHeader.length = (uiBuffer[offset] & 0x00FFFFFF);
    offset++;
    while (end > 0)
    {
      TotalHeader.ChHeader.ch     = (uiBuffer[offset] & 0xFF000000) >> 24;
      TotalHeader.ChHeader.length = (uiBuffer[offset] & 0x00FFFFFC)  >> 2;
      TotalHeader.ChHeader.type   = (uiBuffer[offset] & 0x3);

      if(TotalHeader.ChHeader.length > 2048 && end > 3) break;

      offset++; // skip mstream header

      switch (TotalHeader.ChHeader.type)  
      {
        case 0:
          TotalHeader.TimeHeader.taisec   = uiBuffer[offset];
          offset++;
          TotalHeader.TimeHeader.tainsec  = (uiBuffer[offset] & 0xFFFFFFFC) >> 2;
          TotalHeader.TimeHeader.taiflags = (uiBuffer[offset] & 0x3);
          offset++;
          TotalHeader.TimeHeader.chlo     = uiBuffer[offset];
          offset++;
          TotalHeader.TimeHeader.chup     = uiBuffer[offset];
          offset++;

          break;
        case 1:
          uint16_t ch = TotalHeader.ChHeader.ch;
          // event_waveform.wf.clear();           
          if (TotalHeader.DeviceHeader.sn == 101830393) ch+=64;//If many ADCs IDs should be added +n*64
          
 
          if (ch== [MASK] ) event_waveform.ADCID = TotalHeader.DeviceHeader.sn;
          const uint16_t SN = (TotalHeader.ChHeader.length-2)*2;  // Number of samples
          TotalHeader.SubHeader.wf_tslo = uiBuffer[offset];
          offset++;

          TotalHeader.SubHeader.wf_tsup = (uiBuffer[offset] & 0xFFFFFFFC) >> 2;
          offset++;
          int16_t wave = 0;
          int32_t polarity = 1;
          int32_t iSignalOffset = 0;
          if (ch== [MASK] ) 
          {
            event_waveform.channel=ch;
            for (int s=0; s<(SN/2); s++)
            {
              auto ind = offset+s;     // dirrect cycle
              wave = (((uiBuffer[ind] & 0xFFFF0000) >> 16) * polarity + iSignalOffset);
              event_waveform.wf.push_back(wave);
              wave = ((uiBuffer[ind] & 0xFFFF) * polarity + iSignalOffset);
              event_waveform.wf.push_back(wave);
            }
            // event_waveform.wf_size = event_waveform.wf.size();
            // if (event_waveform.wf.size() > 0) break;
          }

          offset += (SN/2);
          break;
      }
      end = BS - offset;
      if (end <= 1) break;
    }
    if (end <= 1) break;
  }
}

double Worker::getIndexationProgress()
{
  double progress = 0;
  if (currPos >=0 && currPos <= sSizeOfFile) progress = (double)currPos/(double)sSizeOfFile;
  else progress = 1.;
  return progress;
}

void Worker::doWork(ProgressDialog *dialog, const char * a) 
{
    ReadFile();
    dialog->accept();
}",extChannel
592,"#include <cpu.hpp>
#include <emulator.hpp>

#define CPU_DEBUG 0

register_type rt_lookup[] = {RT_B, RT_C, RT_D, RT_E, RT_H, RT_L, RT_HL, RT_A};

void CPU::cpu_init()
{
  cpu_context.registers.pc = 0x100;
  cpu_context.registers.sp = 0xFFFE;
  cpu_context.registers.a = 0x01;
  cpu_context.registers.f = 0xB0;
  cpu_context.registers.b = 0x00;
  cpu_context.registers.c = 0x13;
  cpu_context.registers.d = 0x00;
  cpu_context.registers.e = 0xD8;
  cpu_context.registers.h = 0x01;
  cpu_context.registers.l = 0x4D;
  cpu_context.ie_register = 0;
  cpu_context.int_flags = 0;
  cpu_context.int_master_enabled = false;
  cpu_context.enabling_ime = false;

  emulator.timer.timer_get_context()->div = 0xABCC;

  ppu.ppu_init();
}

CPUContext* CPU::cpu_get_context()
{
  return &cpu_context;
}

void CPU::fetch_instruction()
{
  cpu_context.cur_opcode = bus.bus_read(cpu_context.registers.pc++);
  cpu_context.cur_instruction = instruction_by_opcode(cpu_context.cur_opcode);
}

void CPU::fetch_data()
{
  cpu_context.mem_destination = 0;
  cpu_context.dest_is_mem = false;

  if (cpu_context.cur_instruction == NULL) {
    return;
  }

  switch (cpu_context.cur_instruction->mode) {
    case AM_IMP:
      return;

    case AM_R:
      cpu_context.fetched_data =
          cpu_read_reg(cpu_context.cur_instruction->reg_1);
      return;

    case AM_R_R:
      cpu_context.fetched_data =
          cpu_read_reg(cpu_context.cur_instruction->reg_2);
      return;

    case AM_R_D8:
      cpu_context.fetched_data = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);
      cpu_context.registers.pc++;
      return;

    case AM_R_D16:
    case AM_D16: {
      u16 lo = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);

      u16 hi = bus.bus_read(cpu_context.registers.pc + 1);
      emulator.emulator_cycles(1);

      cpu_context.fetched_data = lo | (hi << 8);

      cpu_context.registers.pc += 2;

      return;
    }

    case AM_MR_R:
      cpu_context.fetched_data =
          cpu_read_reg(cpu_context.cur_instruction->reg_2);
      cpu_context.mem_destination =
          cpu_read_reg(cpu_context.cur_instruction->reg_1);
      cpu_context.dest_is_mem = true;

      if (cpu_context.cur_instruction->reg_1 == RT_C) {
        cpu_context.mem_destination |= 0xFF00;
      }

      return;

    case AM_R_MR: {
      u16 addr = cpu_read_reg(cpu_context.cur_instruction->reg_2);

      if (cpu_context.cur_instruction->reg_2 == RT_C) {
        addr |= 0xFF00;
      }

      cpu_context.fetched_data = bus.bus_read(addr);
      emulator.emulator_cycles(1);
    }
      return;

    case AM_R_HLI:
      cpu_context.fetched_data =
          bus.bus_read(cpu_read_reg(cpu_context.cur_instruction->reg_2));
      emulator.emulator_cycles(1);
      cpu_set_reg(RT_HL, cpu_read_reg(RT_HL) + 1);
      return;

    case AM_R_HLD:
      cpu_context.fetched_data =
          bus.bus_read(cpu_read_reg(cpu_context.cur_instruction->reg_2));
      emulator.emulator_cycles(1);
      cpu_set_reg(RT_HL, cpu_read_reg(RT_HL) - 1);
      return;

    case AM_HLI_R:
      cpu_context.fetched_data =
          cpu_read_reg(cpu_context.cur_instruction->reg_2);
      cpu_context.mem_destination =
          cpu_read_reg(cpu_context.cur_instruction->reg_1);
      cpu_context.dest_is_mem = true;
      cpu_set_reg(RT_HL, cpu_read_reg(RT_HL) + 1);
      return;

    case AM_HLD_R:
      cpu_context.fetched_data =
          cpu_read_reg(cpu_context.cur_instruction->reg_2);
      cpu_context.mem_destination =
          cpu_read_reg(cpu_context.cur_instruction->reg_1);
      cpu_context.dest_is_mem = true;
      cpu_set_reg(RT_HL, cpu_read_reg(RT_HL) - 1);
      return;

    case AM_R_A8:
      cpu_context.fetched_data = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);
      cpu_context.registers.pc++;
      return;

    case AM_A8_R:
      cpu_context.mem_destination =
          bus.bus_read(cpu_context.registers.pc) | 0xFF00;
      cpu_context.dest_is_mem = true;
      emulator.emulator_cycles(1);
      cpu_context.registers.pc++;
      return;

    case AM_HL_SPR:
      cpu_context.fetched_data = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);
      cpu_context.registers.pc++;
      return;

    case AM_D8:
      cpu_context.fetched_data = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);
      cpu_context.registers.pc++;
      return;

    case AM_A16_R:
    case AM_D16_R: {
      u16 lo = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);

      u16 hi = bus.bus_read(cpu_context.registers.pc + 1);
      emulator.emulator_cycles(1);

      cpu_context.mem_destination = lo | (hi << 8);
      cpu_context.dest_is_mem = true;

      cpu_context.registers.pc += 2;
      cpu_context.fetched_data =
          cpu_read_reg(cpu_context.cur_instruction->reg_2);
    }
      return;

    case AM_MR_D8:
      cpu_context.fetched_data = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);
      cpu_context.registers.pc++;
      cpu_context.mem_destination =
          cpu_read_reg(cpu_context.cur_instruction->reg_1);
      cpu_context.dest_is_mem = true;
      return;

    case AM_MR:
      cpu_context.mem_destination =
          cpu_read_reg(cpu_context.cur_instruction->reg_1);
      cpu_context.dest_is_mem = true;
      cpu_context.fetched_data =
          bus.bus_read(cpu_read_reg(cpu_context.cur_instruction->reg_1));
      emulator.emulator_cycles(1);
      return;

    case AM_R_A16: {
      u16 lo = bus.bus_read(cpu_context.registers.pc);
      emulator.emulator_cycles(1);

      u16 hi = bus.bus_read(cpu_context.registers.pc + 1);
      emulator.emulator_cycles(1);

      u16 addr = lo | (hi << 8);

      cpu_context.registers.pc += 2;
      cpu_context.fetched_data = bus.bus_read(addr);
      emulator.emulator_cycles(1);

      return;
    }

    default:
      printf(""Unknown Addressing Mode! %d (%02X)\n"",
             cpu_context.cur_instruction->mode,
             cpu_context.cur_opcode);
      exit(-7);
      return;
  }
}

bool CPU::cpu_step()
{
  if (!cpu_context.halted) {
    u16 pc = cpu_context.registers.pc;

    fetch_instruction();
    emulator.emulator_cycles(1);
    fetch_data();

#if CPU_DEBUG == 1
    std::string flags;
    flags += (cpu_context.registers.f & (1 << 7) ? 'Z' : '-');
    flags += (cpu_context.registers.f & (1 << 6) ? 'N' : '-');
    flags += (cpu_context.registers.f & (1 << 5) ? 'H' : '-');
    flags += (cpu_context.registers.f & (1 << 4) ? 'C' : '-');

    std::string inst = """";
    inst = instruction_to_str(&cpu_context);
    printf(
        ""%08lX - %04X: %-12s (%02X %02X %02X) A: %02X F:%s BC: %02X%02X DE: ""
        ""%02X%02X HL: %02X%02X\n"",
        emulator.get_context()->ticks,
        pc,
        inst.c_str(),
        cpu_context.cur_opcode,
        bus.bus_read(pc + 1),
        bus.bus_read(pc + 2),
        cpu_context.registers.a,
        flags.c_str(),
        cpu_context.registers.b,
        cpu_context.registers.c,
        cpu_context.registers.d,
        cpu_context.registers.e,
        cpu_context.registers.h,
        cpu_context.registers.l);

    if (cpu_context.cur_instruction == NULL) {
      printf(""Unknown Instruction! %02X\n"", cpu_context.cur_opcode);
      return false;
    }

    debug_update();
    debug_print();

#endif

    execute();
  } else {
    emulator.emulator_cycles(1);

    if (cpu_context.int_flags) {
      cpu_context.halted = false;
    }
  }

  if (cpu_context.int_master_enabled) {
    cpu_handle_interrupts();
    cpu_context.enabling_ime = false;
  }

  if (cpu_context.enabling_ime) {
    cpu_context.int_master_enabled = true;
  }

  return true;
}

void CPU::execute()
{
  // execute the correct instruction function
  switch (cpu_context.cur_instruction->type) {
    case IN_NOP:
      proc_nop();
      break;
    case IN_LD:
      proc_ld();
      break;
    case IN_INC:
      proc_inc();
      break;
    case IN_DEC:
      proc_dec();
      break;
    case IN_RLCA:
      proc_rlca();
      break;
    case IN_ADD:
      proc_add();
      break;
    case IN_RRCA:
      proc_rrca();
      break;
    case IN_STOP:
      proc_stop();
      break;
    case IN_RLA:
      proc_rla();
      break;
    case IN_JR:
      proc_jr();
      break;
    case IN_RRA:
      proc_rra();
      break;
    case IN_DAA:
      proc_daa();
      break;
    case IN_CPL:
      proc_cpl();
      break;
    case IN_SCF:
      proc_scf();
      break;
    case IN_CCF:
      proc_ccf();
      break;
    case IN_HALT:
      proc_halt();
      break;
    case IN_ADC:
      proc_adc();
      break;
    case IN_SUB:
      proc_sub();
      break;
    case IN_SBC:
      proc_sbc();
      break;
    case IN_AND:
      proc_and();
      break;
    case IN_XOR:
      proc_xor();
      break;
    case IN_OR:
      proc_or();
      break;
    case IN_CP:
      proc_cp();
      break;
    case IN_POP:
      proc_pop();
      break;
    case IN_JP:
      proc_jp();
      break;
    case IN_PUSH:
      proc_push();
      break;
    case IN_RET:
      proc_ret();
      break;
    case IN_CB:
      proc_cb();
      break;
    case IN_CALL:
      proc_call();
      break;
    case IN_RETI:
      proc_reti();
      break;
    case IN_LDH:
      proc_ldh();
      break;
    case IN_DI:
      proc_di();
      break;
    case IN_EI:
      proc_ei();
      break;
    case IN_RST:
      proc_rst();
      break;
    case IN_NONE:
      proc_none();
      break;
  }
}

u16 CPU::reverse(u16 n)
{
  return ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
}

u16 CPU::cpu_read_reg(register_type rt)
{
  switch (rt) {
    case RT_A:
      return cpu_context.registers.a;
    case RT_F:
      return cpu_context.registers.f;
    case RT_B:
      return cpu_context.registers.b;
    case RT_C:
      return cpu_context.registers.c;
    case RT_D:
      return cpu_context.registers.d;
    case RT_E:
      return cpu_context.registers.e;
    case RT_H:
      return cpu_context.registers.h;
    case RT_L:
      return cpu_context.registers.l;

    case RT_AF:
      return reverse(*((u16*)&cpu_context.registers.a));
    case RT_BC:
      return reverse(*((u16*)&cpu_context.registers.b));
    case RT_DE:
      return reverse(*((u16*)&cpu_context.registers.d));
    case RT_HL:
      return reverse(*((u16*)&cpu_context.registers.h));

    case RT_PC:
      return cpu_context.registers.pc;
    case RT_SP:
      return cpu_context.registers.sp;
    default:
      return 0;
  }
}

void CPU::cpu_set_reg(register_type rt, u16 val)
{
  switch (rt) {
    case RT_A:
      cpu_context.registers.a = val & 0xFF;
      break;
    case RT_F:
      cpu_context.registers.f = val & 0xFF;
      break;
    case RT_B:
      cpu_context.registers.b = val & 0xFF;
      break;
    case RT_C: {
      cpu_context.registers.c = val & 0xFF;
    } break;
    case RT_D:
      cpu_context.registers.d = val & 0xFF;
      break;
    case RT_E:
      cpu_context.registers.e = val & 0xFF;
      break;
    case RT_H:
      cpu_context.registers.h = val & 0xFF;
      break;
    case RT_L:
      cpu_context.registers.l = val & 0xFF;
      break;

    case RT_AF:
      *((u16*)&cpu_context.registers.a) = reverse(val);
      break;
    case RT_BC:
      *((u16*)&cpu_context.registers.b) = reverse(val);
      break;
    case RT_DE:
      *((u16*)&cpu_context.registers.d) = reverse(val);
      break;
    case RT_HL: {
      *((u16*)&cpu_context.registers.h) = reverse(val);
      break;
    }

    case RT_PC:
      cpu_context.registers.pc = val;
      break;
    case RT_SP:
      cpu_context.registers.sp = val;
      break;
    case RT_NONE:
      break;
  }
}

u8 CPU::cpu_read_reg8(register_type rt)
{
  switch (rt) {
    case RT_A:
      return cpu_context.registers.a;
    case RT_F:
      return cpu_context.registers.f;
    case RT_B:
      return cpu_context.registers.b;
    case RT_C:
      return cpu_context.registers.c;
    case RT_D:
      return cpu_context.registers.d;
    case RT_E:
      return cpu_context.registers.e;
    case RT_H:
      return cpu_context.registers.h;
    case RT_L:
      return cpu_context.registers.l;
    case RT_HL: {
      return bus.bus_read(cpu_read_reg(RT_HL));
    }
    default:
      printf(""**ERR INVALID REG8: %d\n"", rt);
      exit(-5);
  }
}

void CPU::cpu_set_reg8(register_type rt, u8 val)
{
  switch (rt) {
    case RT_A:
      cpu_context.registers.a = val & 0xFF;
      break;
    case RT_F:
      cpu_context.registers.f = val & 0xFF;
      break;
    case RT_B:
      cpu_context.registers.b = val & 0xFF;
      break;
    case RT_C:
      cpu_context.registers.c = val & 0xFF;
      break;
    case RT_D:
      cpu_context.registers.d = val & 0xFF;
      break;
    case RT_E:
      cpu_context.registers.e = val & 0xFF;
      break;
    case RT_H:
      cpu_context.registers.h = val & 0xFF;
      break;
    case RT_L:
      cpu_context.registers.l = val & 0xFF;
      break;
    case RT_HL:
      bus.bus_write(cpu_read_reg(RT_HL), val);
      break;
    default:
      printf(""**ERR INVALID REG8: %d\n"", rt);
      exit(-5);
  }
}

CPURegisters* CPU::cpu_get_registers()
{
  return &cpu_context.registers;
}

u8 CPU::cpu_get_int_flags()
{
  return cpu_context.int_flags;
}

void CPU::cpu_set_int_flags(u8 value)
{
  cpu_context.int_flags = value;
}

void CPU::cpu_set_flags(char z, char n, char h, char c)
{
  if (z != -1) {
    BIT_SET(cpu_context.registers.f, 7, z);
  }

  if (n != -1) {
    BIT_SET(cpu_context.registers.f, 6, n);
  }

  if (h != -1) {
    BIT_SET(cpu_context.registers.f, 5, h);
  }

  if (c != -1) {
    BIT_SET(cpu_context.registers.f, 4, c);
  }
}

void CPU::cpu_handle_interrupts()
{
  if (interrupt_check(0x40, IT_VBLANK)) {
  } else if (interrupt_check(0x48, IT_LCD_STAT)) {
  } else if (interrupt_check(0x50, IT_TIMER)) {
  } else if (interrupt_check(0x58, IT_SERIAL)) {
  } else if (interrupt_check(0x60, IT_JOYPAD)) {
  }
}

void CPU::cpu_request_interrupts(interrupt_type t)
{
  cpu_context.int_flags |= t;
}

void CPU::interrupt_handle(u16 address)
{
  stack_push16(cpu_context.registers.pc);
  cpu_context.registers.pc = address;
}

bool CPU::interrupt_check(u16 address, interrupt_type it)
{
  if (cpu_context.int_flags & it && cpu_context.ie_register & it) {
    interrupt_handle(address);
    cpu_context.int_flags &= ~it;
    cpu_context.halted = false;
    cpu_context.int_master_enabled = false;

    return true;
  }

  return false;
}

bool CPU::is_16_bit(register_type rt)
{
  return rt >= RT_AF;
}

register_type CPU::decode_reg(u8 reg)
{
  if (reg > 0b111) {
    return RT_NONE;
  }
  return rt_lookup[reg];
}

u8 CPU::cpu_get_ie_register()
{
  return cpu_context.ie_register;
}

void CPU::cpu_set_ie_register(u8 n)
{
  cpu_context.ie_register = n;
}

void CPU::stack_push(u8 data)
{
  cpu_context.registers.sp--;
  bus.bus_write(cpu_context.registers.sp, data);
}

u8 CPU::stack_pop()
{
  return bus.bus_read(cpu_context.registers.sp++);
}

void CPU::stack_push16(u16 data)
{
  stack_push((data >> 8) & 0xFF);
  stack_push(data & 0xFF);
}

u16 CPU::stack_pop16()
{
  u16 lo = stack_pop();
  u16 hi = stack_pop();

  return (hi << 8) | lo;
}

void CPU::proc_none()
{
  printf(""INVALID INSTRUCTION!\n"");
  exit(-7);
}

void CPU::proc_cb()
{
  u8 op = cpu_context.fetched_data;
  register_type reg = decode_reg(op & 0b111);
  u8 bit = (op >> 3) & 0b111;
  u8 bit_op = (op >> 6) & 0b11;
  u8  [MASK]  = cpu_read_reg8(reg);

  emulator.emulator_cycles(1);

  if (reg == RT_HL) {
    emulator.emulator_cycles(2);
  }

  switch (bit_op) {
    case 1:
      // BIT
      cpu_set_flags(!( [MASK]  & (1 << bit)), 0, 1, -1);
      return;

    case 2:
      // RST
       [MASK]  &= ~(1 << bit);
      cpu_set_reg8(reg,  [MASK] );
      return;

    case 3:
      // SET
       [MASK]  |= (1 << bit);
      cpu_set_reg8(reg,  [MASK] );
      return;
  }

  bool flagC = CPU_FLAG_C(cpu_context);

  switch (bit) {
    case 0: {
      // RLC
      bool setC = false;
      u8 result = ( [MASK]  << 1) & 0xFF;

      if (( [MASK]  & (1 << 7)) != 0) {
        result |= 1;
        setC = true;
      }

      cpu_set_reg8(reg, result);
      cpu_set_flags(result == 0, false, false, setC);
    }
      return;

    case 1: {
      // RRC
      u8 old =  [MASK] ;
       [MASK]  >>= 1;
       [MASK]  |= (old << 7);

      cpu_set_reg8(reg,  [MASK] );
      cpu_set_flags(! [MASK] , false, false, old & 1);
    }
      return;

    case 2: {
      // RL
      u8 old =  [MASK] ;
       [MASK]  <<= 1;
       [MASK]  |= flagC;

      cpu_set_reg8(reg,  [MASK] );
      cpu_set_flags(! [MASK] , false, false, !!(old & 0x80));
    }
      return;

    case 3: {
      // RR
      u8 old =  [MASK] ;
       [MASK]  >>= 1;

       [MASK]  |= (flagC << 7);

      cpu_set_reg8(reg,  [MASK] );
      cpu_set_flags(! [MASK] , false, false, old & 1);
    }
      return;

    case 4: {
      // SLA
      u8 old =  [MASK] ;
       [MASK]  <<= 1;

      cpu_set_reg8(reg,  [MASK] );
      cpu_set_flags(! [MASK] , false, false, !!(old & 0x80));
    }
      return;

    case 5: {
      // SRA
      u8 u = (int8_t) [MASK]  >> 1;
      cpu_set_reg8(reg, u);
      cpu_set_flags(!u, 0, 0,  [MASK]  & 1);
    }
      return;

    case 6: {
      // SWAP
       [MASK]  = (( [MASK]  & 0xF0) >> 4) | (( [MASK]  & 0xF) << 4);
      cpu_set_reg8(reg,  [MASK] );
      cpu_set_flags( [MASK]  == 0, false, false, false);
    }
      return;

    case 7: {
      // SRL
      u8 u =  [MASK]  >> 1;
      cpu_set_reg8(reg, u);
      cpu_set_flags(!u, 0, 0,  [MASK]  & 1);
    }
      return;
  }

  fprintf(stderr, ""ERROR: INVALID CB: %02X"", op);
  exit(-5);
}

void CPU::proc_rlca()
{
  u8 u = cpu_context.registers.a;
  bool c = (u >> 7) & 1;
  u = (u << 1) | c;
  cpu_context.registers.a = u;

  cpu_set_flags(0, 0, 0, c);
}

void CPU::proc_rrca()
{
  u8 b = cpu_context.registers.a & 1;
  cpu_context.registers.a >>= 1;
  cpu_context.registers.a |= (b << 7);

  cpu_set_flags(0, 0, 0, b);
}

void CPU::proc_rla()
{
  u8 u = cpu_context.registers.a;
  u8 cf = CPU_FLAG_C(cpu_context);
  u8 c = (u >> 7) & 1;

  cpu_context.registers.a = (u << 1) | cf;
  cpu_set_flags(0, 0, 0, c);
}

void CPU::proc_stop()
{
  fprintf(stderr, ""STOPPING!\n"");
  exit(-5);
}

void CPU::proc_daa()
{
  u8 u = 0;
  int fc = 0;

  if (CPU_FLAG_H(cpu_context)
      || (!CPU_FLAG_N(cpu_context) && (cpu_context.registers.a & 0xF) > 9))
  {
    u = 6;
  }

  if (CPU_FLAG_C(cpu_context)
      || (!CPU_FLAG_N(cpu_context) && cpu_context.registers.a > 0x99))
  {
    u |= 0x60;
    fc = 1;
  }

  cpu_context.registers.a += CPU_FLAG_N(cpu_context) ? -u : u;

  cpu_set_flags(cpu_context.registers.a == 0, -1, 0, fc);
}

void CPU::proc_cpl()
{
  cpu_context.registers.a = ~cpu_context.registers.a;
  cpu_set_flags(-1, 1, 1, -1);
}

void CPU::proc_scf()
{
  cpu_set_flags(-1, 0, 0, 1);
}

void CPU::proc_ccf()
{
  cpu_set_flags(-1, 0, 0, CPU_FLAG_C(cpu_context) ^ 1);
}

void CPU::proc_halt()
{
  cpu_context.halted = true;
}

void CPU::proc_rra()
{
  u8 carry = CPU_FLAG_C(cpu_context);
  u8 new_c = cpu_context.registers.a & 1;

  cpu_context.registers.a >>= 1;
  cpu_context.registers.a |= (carry << 7);

  cpu_set_flags(0, 0, 0, new_c);
}

void CPU::proc_and()
{
  cpu_context.registers.a &= cpu_context.fetched_data;
  cpu_set_flags(cpu_context.registers.a == 0, 0, 1, 0);
}

void CPU::proc_xor()
{
  cpu_context.registers.a ^= cpu_context.fetched_data & 0xFF;
  cpu_set_flags(cpu_context.registers.a == 0, 0, 0, 0);
}

void CPU::proc_or()
{
  cpu_context.registers.a |= cpu_context.fetched_data & 0xFF;
  cpu_set_flags(cpu_context.registers.a == 0, 0, 0, 0);
}

void CPU::proc_cp()
{
  int n = (int)cpu_context.registers.a - (int)cpu_context.fetched_data;

  cpu_set_flags(n == 0,
                1,
                ((int)cpu_context.registers.a & 0x0F)
                        - ((int)cpu_context.fetched_data & 0x0F)
                    < 0,
                n < 0);
}

void CPU::proc_di()
{
  cpu_context.int_master_enabled = false;
}

void CPU::proc_ei()
{
  cpu_context.enabling_ime = true;
}

static bool is_16_bit(register_type rt)
{
  return rt >= RT_AF;
}

void CPU::proc_ld()
{
  if (cpu_context.dest_is_mem) {
    // LD (BC), A for instance...

    if (is_16_bit(cpu_context.cur_instruction->reg_2)) {
      // if 16 bit register...
      emulator.emulator_cycles(1);
      bus.bus_write16(cpu_context.mem_destination, cpu_context.fetched_data);
    } else {
      bus.bus_write(cpu_context.mem_destination, (u8)cpu_context.fetched_data);
    }

    emulator.emulator_cycles(1);

    return;
  }

  if (cpu_context.cur_instruction->mode == AM_HL_SPR) {
    u8 hflag = (cpu_read_reg(cpu_context.cur_instruction->reg_2) & 0xF)
            + (cpu_context.fetched_data & 0xF)
        >= 0x10;

    u8 cflag = (cpu_read_reg(cpu_context.cur_instruction->reg_2) & 0xFF)
            + (cpu_context.fetched_data & 0xFF)
        >= 0x100;

    cpu_set_flags(0, 0, hflag, cflag);
    cpu_set_reg(cpu_context.cur_instruction->reg_1,
                cpu_read_reg(cpu_context.cur_instruction->reg_2)
                    + (int8_t)cpu_context.fetched_data);

    return;
  }

  cpu_set_reg(cpu_context.cur_instruction->reg_1, cpu_context.fetched_data);
}

void CPU::proc_ldh()
{
  if (cpu_context.cur_instruction->reg_1 == RT_A) {
    cpu_set_reg(cpu_context.cur_instruction->reg_1,
                (u16)bus.bus_read(0xFF00 | cpu_context.fetched_data));
  } else {
    bus.bus_write(cpu_context.mem_destination, cpu_context.registers.a);
  }

  emulator.emulator_cycles(1);
}

bool CPU::check_cond()
{
  bool z = CPU_FLAG_Z(cpu_context);
  bool c = CPU_FLAG_C(cpu_context);

  switch (cpu_context.cur_instruction->cond) {
    case CT_NONE:
      return true;
    case CT_C:
      return c;
    case CT_NC:
      return !c;
    case CT_Z:
      return z;
    case CT_NZ:
      return !z;
  }

  return false;
}

void CPU::proc_nop() {}

void CPU::goto_addr(u16 addr, bool pushpc)
{
  if (check_cond()) {
    if (pushpc) {
      emulator.emulator_cycles(2);
      stack_push16(cpu_context.registers.pc);
    }

    cpu_context.registers.pc = addr;
    emulator.emulator_cycles(1);
  }
}

void CPU::proc_jp()
{
  goto_addr(cpu_context.fetched_data, false);
}

void CPU::proc_jr()
{
  int8_t rel = (int8_t)(cpu_context.fetched_data & 0xFF);
  u16 addr = cpu_context.registers.pc + (u16)rel;

  goto_addr(addr, false);
}

void CPU::proc_call()
{
  goto_addr(cpu_context.fetched_data, true);
}

void CPU::proc_rst()
{
  goto_addr((u16)cpu_context.cur_instruction->param, true);
}

void CPU::proc_ret()
{
  if (cpu_context.cur_instruction->cond != CT_NONE) {
    emulator.emulator_cycles(1);
  }

  if (check_cond()) {
    u16 lo = (u16)stack_pop();
    emulator.emulator_cycles(1);
    u16 hi = stack_pop();
    emulator.emulator_cycles(1);

    u16 n = (hi << 8) | lo;
    cpu_context.registers.pc = n;

    emulator.emulator_cycles(1);
  }
}

void CPU::proc_reti()
{
  cpu_context.int_master_enabled = true;
  proc_ret();
}

void CPU::proc_pop()
{
  u16 lo = stack_pop();
  emulator.emulator_cycles(1);
  u16 hi = stack_pop();
  emulator.emulator_cycles(1);

  u16 n = (hi << 8) | lo;

  cpu_set_reg(cpu_context.cur_instruction->reg_1, n);

  if (cpu_context.cur_instruction->reg_1 == RT_AF) {
    cpu_set_reg(cpu_context.cur_instruction->reg_1, n & 0xFFF0);
  }
}

void CPU::proc_push()
{
  u16 hi = (cpu_read_reg(cpu_context.cur_instruction->reg_1) >> 8) & 0xFF;
  emulator.emulator_cycles(1);
  stack_push(hi);

  u16 lo = cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xFF;
  emulator.emulator_cycles(1);
  stack_push(lo);

  emulator.emulator_cycles(1);
}

void CPU::proc_inc()
{
  u16 val = cpu_read_reg(cpu_context.cur_instruction->reg_1) + 1;

  if (is_16_bit(cpu_context.cur_instruction->reg_1)) {
    emulator.emulator_cycles(1);
  }

  if (cpu_context.cur_instruction->reg_1 == RT_HL
      && cpu_context.cur_instruction->mode == AM_MR)
  {
    val = bus.bus_read(cpu_read_reg(RT_HL)) + 1;
    val &= 0xFF;
    bus.bus_write(cpu_read_reg(RT_HL), val);
  } else {
    cpu_set_reg(cpu_context.cur_instruction->reg_1, val);
    val = cpu_read_reg(cpu_context.cur_instruction->reg_1);
  }

  if ((cpu_context.cur_opcode & 0x03) == 0x03) {
    return;
  }

  cpu_set_flags(val == 0, 0, (val & 0x0F) == 0, -1);
}

void CPU::proc_dec()
{
  u16 val = cpu_read_reg(cpu_context.cur_instruction->reg_1) - 1;

  if (is_16_bit(cpu_context.cur_instruction->reg_1)) {
    emulator.emulator_cycles(1);
  }

  if (cpu_context.cur_instruction->reg_1 == RT_HL
      && cpu_context.cur_instruction->mode == AM_MR)
  {
    val = bus.bus_read(cpu_read_reg(RT_HL)) - 1;
    bus.bus_write(cpu_read_reg(RT_HL), val);
  } else {
    cpu_set_reg(cpu_context.cur_instruction->reg_1, val);
    val = cpu_read_reg(cpu_context.cur_instruction->reg_1);
  }

  if ((cpu_context.cur_opcode & 0x0B) == 0x0B) {
    return;
  }

  cpu_set_flags(val == 0, 1, (val & 0x0F) == 0x0F, -1);
}

void CPU::proc_sub()
{
  u16 val = cpu_read_reg(cpu_context.cur_instruction->reg_1)
      - cpu_context.fetched_data;

  int z = val == 0;
  int h = ((int)cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xF)
          - ((int)cpu_context.fetched_data & 0xF)
      < 0;
  int c = ((int)cpu_read_reg(cpu_context.cur_instruction->reg_1))
          - ((int)cpu_context.fetched_data)
      < 0;

  cpu_set_reg(cpu_context.cur_instruction->reg_1, val);
  cpu_set_flags(z, 1, h, c);
}

void CPU::proc_sbc()
{
  u8 val = cpu_context.fetched_data + CPU_FLAG_C(cpu_context);

  int z = cpu_read_reg(cpu_context.cur_instruction->reg_1) - val == 0;

  int h = ((int)cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xF)
          - ((int)cpu_context.fetched_data & 0xF)
          - ((int)CPU_FLAG_C(cpu_context))
      < 0;
  int c = ((int)cpu_read_reg(cpu_context.cur_instruction->reg_1))
          - ((int)cpu_context.fetched_data) - ((int)CPU_FLAG_C(cpu_context))
      < 0;

  cpu_set_reg(cpu_context.cur_instruction->reg_1,
              cpu_read_reg(cpu_context.cur_instruction->reg_1) - val);
  cpu_set_flags(z, 1, h, c);
}

void CPU::proc_adc()
{
  u16 u = cpu_context.fetched_data;
  u16 a = cpu_context.registers.a;
  u16 c = CPU_FLAG_C(cpu_context);

  cpu_context.registers.a = (a + u + c) & 0xFF;

  cpu_set_flags(cpu_context.registers.a == 0,
                0,
                ((a & 0xF) + (u & 0xF) + c) > 0xF,
                (a + u + c) > 0xFF);
}

void CPU::proc_add()
{
  u32 val = cpu_read_reg(cpu_context.cur_instruction->reg_1)
      + cpu_context.fetched_data;

  bool is_16bit = is_16_bit(cpu_context.cur_instruction->reg_1);

  if (is_16bit) {
    emulator.emulator_cycles(1);
  }

  if (cpu_context.cur_instruction->reg_1 == RT_SP) {
    val = cpu_read_reg(cpu_context.cur_instruction->reg_1)
        + (int8_t)cpu_context.fetched_data;
  }

  int z = (val & 0xFF) == 0;
  int h = (cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xF)
          + (cpu_context.fetched_data & 0xF)
      >= 0x10;
  int c = (int)(cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xFF)
          + (int)(cpu_context.fetched_data & 0xFF)
      >= 0x100;

  if (is_16bit) {
    z = -1;
    h = (cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xFFF)
            + (cpu_context.fetched_data & 0xFFF)
        >= 0x1000;
    u32 n = ((u32)cpu_read_reg(cpu_context.cur_instruction->reg_1))
        + ((u32)cpu_context.fetched_data);
    c = n >= 0x10000;
  }

  if (cpu_context.cur_instruction->reg_1 == RT_SP) {
    z = 0;
    h = (cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xF)
            + (cpu_context.fetched_data & 0xF)
        >= 0x10;
    c = (int)(cpu_read_reg(cpu_context.cur_instruction->reg_1) & 0xFF)
            + (int)(cpu_context.fetched_data & 0xFF)
        >= 0x100;
  }

  cpu_set_reg(cpu_context.cur_instruction->reg_1, val & 0xFFFF);
  cpu_set_flags(z, 0, h, c);
}

void CPU::debug_update()
{
  if (bus.bus_read(0xFF02) == 0x81) {
    char c = bus.bus_read(0xFF01);

    dbg_msg += c;

    bus.bus_write(0xFF02, 0);
  }
}

void CPU::debug_print()
{
  if (!dbg_msg.empty()) {
    printf(""DBG: %s\n"", dbg_msg.c_str());
  }
}
",reg_val
593,"// Copyright 2021 University of Nottingham Ningbo China
// Author: <NAME> <<EMAIL>>
//
// 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 FCORE_TOOLCHAIN_VARIABLE_HPP
#define FCORE_TOOLCHAIN_VARIABLE_HPP

#include <cstdint>
#include <string>
#include <utility>

#include <nlohmann/json.hpp>
#include ""tools/array_linearizer.hpp""


namespace fcore{
    typedef enum {
        c_type_void = 1,
        c_type_char = 2,
        c_type_short = 3,
        c_type_int = 4,
        c_type_long = 5,
        c_type_float = 6,
        c_type_struct = 7
    } c_types_t;

    typedef enum {
        variable_input_type = 0,
        variable_output_type = 1,
        variable_memory_type = 2,
        variable_regular_type = 3
    } iom_spec_t;

    struct variable_class_t{
        iom_spec_t iom_spec;
        bool common_io;
    };


    typedef enum {
        var_type_float_const = 0,
        var_type_int_const = 1,
        var_type_scalar = 2,
        var_type_array = 3,
        var_type_struct = 4
    } variable_type_t;


    class variable {
    public:
        variable();
        explicit variable(std::string n);
        variable(const std::string &n, float value);
        variable(const std::string &n, int value);

        std::string get_identifier();
        std::string get_identifier(const std::vector<int>& idx);
        std::string get_linear_identifier();
        std::string get_linear_identifier(const int& idx);
        std::string get_linear_identifier(const std::vector<int>& idx);

        int get_linear_index();
        int get_linear_index(const std::vector<int>& idx);
        float get_float_val() const;
        int get_int_value() const;

        static std::string  type_to_string(const c_types_t &t);

        void set_immediate(const float f) {
            if(variable_type == var_type_float_const){
                const_f = f;
            } else {
                throw std::runtime_error(""Setting the floating point value of a non floating point variable is not allowed"");
            }
        }
        void set_immediate(const int i){
            if(variable_type == var_type_int_const){
                const_i = i;
            } else {
                throw std::runtime_error(""Setting the integer  value of a non integer point variable is not allowed"");
            }
        }

        void set_const_f(float f);
        void set_const_i(int i);

        variable_type_t get_type() {return variable_type;};
        void set_type(variable_type_t t) {variable_type = t;};

        void set_name(std::string n){name = std::move(n);};
        std::string get_name() {return name;};

        [[nodiscard]] std::string to_str();

        static bool is_explicit_register(std::string s);
        static bool is_terminal() { return true;};

        void set_used(bool status);
        [[nodiscard]] bool is_used() const;

        [[nodiscard]] bool is_constant() const { return (variable_type ==var_type_float_const || variable_type == var_type_int_const);};
        [[nodiscard]] bool is_float() const {return variable_type == var_type_float_const;};

        [[nodiscard]]  int get_bound_reg();
        void set_bound_reg(int reg) { bound_register[0] = reg;};

        [[nodiscard]]  std::vector<int> get_bound_reg_array() const { return bound_register;};
        void set_bound_reg_array(std::vector<int> reg) { bound_register = std::move(reg);};

        [[nodiscard]] std::pair<uint32_t, bool> get_value() const;

        friend bool operator==(const variable& lhs, const variable& rhs){
            bool  [MASK]  = lhs.variable_class.common_io == rhs.variable_class.common_io;
             [MASK]  &= lhs.variable_class.iom_spec == rhs.variable_class.iom_spec;
             [MASK]  &= lhs.first_occurrence == rhs.first_occurrence;
             [MASK]  &= lhs.last_occurrence == rhs.last_occurrence;
             [MASK]  &= lhs.name == rhs.name;
             [MASK]  &= lhs.bound_register == rhs.bound_register;
             [MASK]  &= lhs.used == rhs.used;
             [MASK]  &= lhs.variable_type == rhs.variable_type;
             [MASK]  &= lhs.const_i == rhs.const_i;
             [MASK]  &= lhs.const_f == rhs.const_f;
             [MASK]  &= lhs.contiguity == rhs.contiguity;
             [MASK]  &= lhs.array_index == rhs.array_index;
             [MASK]  &= lhs.array_shape == rhs.array_shape;
             [MASK]  &= lhs.struct_accessors == rhs.struct_accessors;
             [MASK]  &= lhs.c_type == rhs.c_type;
            return  [MASK] ;
        };

        variable_class_t get_variable_class() {return variable_class;};
        void set_variable_class(variable_class_t vc) {
            variable_class = vc;
        };

        unsigned  int get_size();

        unsigned int get_last_occurrence() const {return last_occurrence;};
        void set_last_occurrence(unsigned int lo) {last_occurrence = lo;};

        unsigned int get_first_occurrence() const {return first_occurrence;};
        void set_first_occurrence(unsigned int fo) {first_occurrence = fo;};

        void set_contiguity(bool ac) { contiguity = ac;};
        bool is_contiguous() {return contiguity;};

        std::vector<int> get_array_shape() const {return array_shape;};
        void set_array_shape(std::vector<int> as) {array_shape = std::move(as);};

        std::vector<int> get_array_index() const {return array_index;};
        void set_array_index(std::vector<int> ai) {array_index = std::move(ai);};

        void add_struct_accessors(const std::vector<std::string> &a){struct_accessors = a;};
        std::vector<std::string> get_struct_accessors() const {return struct_accessors;};

        static std::shared_ptr<variable> deep_copy(const std::shared_ptr<variable>& original);

        void set_c_type(c_types_t type){c_type = type;};
        c_types_t get_c_type(){ return c_type;};

    private:
        std::vector<std::string> struct_accessors;
        variable_class_t variable_class;
        variable_type_t variable_type;

        unsigned int first_occurrence;
        unsigned int last_occurrence;

        bool contiguity;

        std::vector<int> bound_register;

        std::string name;
        std::vector<bool> used;

        int const_i;
        float const_f;

        std::vector<int> array_shape;
        std::vector<int> array_index;

        c_types_t c_type;
    };
}



#endif //FCORE_TOOLCHAIN_VARIABLE_HPP
",cond
594,"#pragma hdrstop

//
//  Licensed to the Apache Software Foundation (ASF) under one
//  or more contributor license agreements.  See the NOTICE file
//  distributed with this work for additional information
//  regarding copyright ownership.  The ASF licenses this file
//  to you 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 ""Portalizacion.h""

//---------------------------------------------------------------------------
Portalizacion::Portalizacion(unsigned int ancho,unsigned int  [MASK] ){

        portales = new Matriz<Punto>(ancho ,  [MASK] );

}
//---------------------------------------------------------------------------
Portalizacion::~Portalizacion(){

        delete(portales);
}
//---------------------------------------------------------------------------
Lista2<Punto> * Portalizacion::getPortales(unsigned int x,unsigned int y,unsigned int dim){

        Lista2<Punto> *aux = new Lista2<Punto>();

        for ( int x2 = x + dim  ; x2 >= (int)x ; x2--){
                Punto *p = portales->get(x2,y);
                if ( p != NULL)
                        aux->agregarFinal(p);
        }
        for ( int y2 = y ; y2 < y + dim ; y2++){
                Punto *p = portales->get(x,y2);
                if ( p != NULL)
                        aux->agregarFinal(p);
        }
        for ( int x2 = x ; x2 < x + dim ; x2++){
                Punto *p = portales->get(x2,y+dim);
                if ( p != NULL)
                        aux->agregarFinal(p);
        }
        for ( int y2 = y + dim  ; y2 > (int)y ; y2--){
                Punto *p = portales->get(x+dim,y2);
                if ( p != NULL)
                        aux->agregarFinal(p);
        }
        return aux;

};
//---------------------------------------------------------------------------
void Portalizacion::portalizar(Lista<Cuadrante> *c,Lista<Cuadrante> *h){
    unsigned int x,y,dim;
    Lista2<Punto> *portales;

    for (Cuadrante *auxH = h->primero(); auxH; auxH = h->siguiente()){

           x    = auxH->getX();
           y    = auxH->getY();
           dim  = auxH->getLargo();

         //agrego los portales
          if (!this->hayPortales(x,y,dim,ARRIBA))
            this->set( x + ( dim / 2) , y );
          if (!this->hayPortales(x,y,dim,IZQUIERDA))
            this->set( x , y + (dim / 2 ) );
          if (!this->hayPortales(x,y,dim,ABAJO))
            this->set( x + ( dim / 2 ), y + dim  );
          if (!this->hayPortales(x,y,dim,DERECHA))
            this->set( x +  dim , y + (dim / 2) );


           portales = this->getPortales(x,y,dim);

           auxH->setPortales(portales);
    }

    for (Cuadrante *auxC = c->primero(); auxC; auxC = c->siguiente()){


           x    = auxC->getX();
           y    = auxC->getY();
           dim  = auxC->getLargo();
                 
           portales = this->getPortales(x,y,dim);

           auxC->setPortales(portales);
    }
}
//---------------------------------------------------------------------------
void  Portalizacion::set(unsigned int x,unsigned int y){
        Punto *p = portales->get(x,y);
        if (p == NULL){
                p = new Punto(x,y);
                portales->set(p,x,y);
        };

}
//---------------------------------------------------------------------------
bool Portalizacion::hayPortales(int x,int y,int dim,int dir){
        bool hay = false;

  switch (dir)
        {
        case ARRIBA:
        for ( int x2 = x + dim  ; x2 >= (int)x ; x2--){
                Punto *p = portales->get(x2,y);
                if ( p != NULL)
                        hay = true;
        }
        break;
        case IZQUIERDA:
        for ( int y2 = y ; y2 < y + dim ; y2++){
                Punto *p = portales->get(x,y2);
                if ( p != NULL)
                        hay = true;
        }
        break;
        case ABAJO:
        for ( int x2 = x ; x2 < x + dim ; x2++){
                Punto *p = portales->get(x2,y+dim);
                if ( p != NULL)
                        hay = true;
        }
        break;
        case DERECHA:
        for ( int y2 = y + dim  ; y2 >= (int)y ; y2--){
                Punto *p = portales->get(x+dim,y2);
                if ( p != NULL)
                        hay = true;
        }
        break;
        }

        return hay;
}
//---------------------------------------------------------------------------


#pragma package(smart_init)
",alto
595,"#include ""MacLeaderboardManager.h""

namespace linguine::alfredo {

void MacLeaderboardManager::getHighScores(std::function<void(std::vector<Record> results)> onSuccess,
                                          std::function<void(std::string reason)> onError) {
  auto highScore = 1'000'000;
  auto  [MASK]  = std::string(""abcdefghijklmnopqrstuvwxyz"");
  auto randomLength = std::uniform_int_distribution(3, 15);

  auto results = std::vector<Record>();

  for (auto i = 0; i < 10; ++i) {
    auto name =  [MASK] .substr(0, randomLength(_random));

    auto randomScore = std::uniform_int_distribution(4, highScore - 1);
    highScore = randomScore(_random);

    results.push_back({ name, highScore });
  }

  results[4].isPlayer = true;

  onSuccess(results);
}

void MacLeaderboardManager::submitScore(int32_t score,
                                        std::function<void()> onSuccess,
                                        std::function<void(std::string)> onError) {
  onSuccess();
}

}  // namespace linguine::alfredo
",alphabet
596,"
/*
 * Copyright (c) 2012 <NAME>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the ""Software""),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

/** \file Channel.cc
 * \brief 
 *
 * The problem with SYSV message queues for bidirectional messages, is that
 * if the message is read it is deleted.  If the process reading the message
 * fails in some manner, then the message is not processed and the sender
 * does not get a response and requires mitigation.
 *
 * Consider new method where the message is read and consumed as separate
 * steps.  Perhaps a message can be peeked with SYS MQ.
 */

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <syslog.h>
#include <glob.h>

#include ""string_util.h""
#include ""Channel.h""
#include ""Service.h""

namespace { int debug = 0; }

/**
 * dst is the destination service id
 * src is the source service id
 */
struct channel_message {
    long dst;
    long src;
    long error;
    char body[1012];
};
#define MESSAGE_OK        0
#define MESSAGE_ERROR     1
#define MESSAGE_EXCEPTION 2

/** 
 * Look through list of processes to see if the named service is
 * alive.  We check by looking a process that has its executable
 * as /usr/sbin/[service_name].
 *
 * Note: readlink does not NULL terminate the strings it reads, so
 *   we must do it explicitly.
 */
static int
is_alive( char *service_name ) {
    int result = 0;
    glob_t processes;
    size_t i;
    char exe[256], path[80];

    sprintf( path, ""/usr/sbin/%s"", service_name );

    memset( &processes, 0, sizeof(processes) );
    glob( ""/proc/*/exe"", GLOB_NOSORT, NULL, &processes );

    for ( i = 0 ; i < processes.gl_pathc ; i++ ) {
        int count = readlink( processes.gl_pathv[i], exe, sizeof(exe) );
        if ( count == -1 ) continue;
        exe[count] = '\0';
        if ( strcmp(exe, path) == 0 ) {
            result = 1;
            break;
        }
    }

    globfree( &processes );
    return result;
}

/**
 */
key_t service_key( const char *service_name ) {
    key_t key = *( (key_t*)service_name );
    if ( key == -1 ) {
        syslog( LOG_ERR, ""could not generate a key for '%s'"", service_name );
        exit( 1 );
    }
    // send this to stdout if the tcl interpreter is interactive
    // syslog( LOG_NOTICE, ""channel key for '%s' is 0x%08x"", service_name, key );
    return key;
}

/**
 * will need a path name to point the mq at
 *
 * Channel needs to be a thread that reads the Q and
 * calls the interpreter when it gets the message
 *
 * The channel cannot accept messages until the interpreter is
 * fully initialized.  Also, the channel should be the primary
 * (only?) evaluator in the interpreter.
 *
 * Should make the Interpreter be a base class and have a 
 * TclInterpreter and a RubyInterpreter?  The Interpreter
 * should provide an evalute method ...
 *
 *
 * There will be a race here ... where the client of a service
 * will not be able to start until the server.  However, if they
 * talk to each other then they are both clients and servers
 * so neither could start.  So, the client needs to be able to
 * create the server's directory also.
 */
Channel::Channel( Service *service )
: service(service) {
    key_t key = service_key( service->name() );
    syslog( LOG_NOTICE, ""msgQ id = 0x%08x"", key );

    // Eventually change this so only root can send...
    q = msgget( key, IPC_CREAT | 0777 );
    if ( q < 0 ) {
        syslog( LOG_ERR, ""could not create a msgQ for '%s'"", service->name() );
        exit( 1 );
    }
}

/**
 * \todo should use IPC_NOWAIT -- and try again if EAGAIN
 * \todo fix message length calculation
 */
void
Channel::send( long dst, int result, char *message ) {
    int flags = 0; // IPC_NOWAIT | MSG_NOERROR
    struct channel_message m;
    m.dst = dst;
    m.src = 1;
    m.error = result;
    int bytes = strlcpy( m.body, message, sizeof(m.body) );
    if ( bytes > sizeof(m.body) ) {
        syslog( LOG_WARNING, ""message body truncated"" );
        bytes = sizeof(m.body) - 1;
    }
    if ( msgsnd(q, &m, bytes + sizeof(char) + sizeof(long) + sizeof(long), flags) < 0 ) {
        syslog( LOG_ERR, ""failed to msgsnd"" );
    }
}

/**
 * block ... read from Q and process msg
 * \todo add retry logic when we get a msgrcv err on Channel
 */
long
Channel::receive( char *buffer, int length ) {
    int flags = 0; // IPC_NOWAIT | MSG_NOERROR
    struct channel_message request;
    int bytes = msgrcv( q, &request, sizeof(request), 1, flags );
    if ( bytes < 0 ) {
        // how to handle error
        syslog( LOG_ERR, ""Error receiving Channel request"" );
    }
    if ( debug > 0 ) syslog( LOG_NOTICE, ""request '%s'"", request.body );
    strlcpy( buffer, request.body, length );
    return request.src;
}

/**
 */
ChannelClient::ChannelClient( char *service_name ) {
    strlcpy( service, service_name, sizeof(service) );
    key_t key = service_key( service_name );
    // Eventually change this so only root can send...
    q = msgget( key, IPC_CREAT | 0777 );
    if ( q < 0 ) {
        syslog( LOG_ERR, ""could not create a msgQ for '%s'"", service_name );
        exit( 1 );
    }
}

/**
 * \todo should use IPC_NOWAIT -- and try again if EAGAIN
 * \todo fix message length calculation
 */
void
ChannelClient::send( char *message ) {
    int flags = 0; // IPC_NOWAIT | MSG_NOERROR
    struct channel_message m;
    m.dst = 1;
    m.src = getpid();
    m.error = 0;
    int bytes = strlcpy( m.body, message, sizeof(m.body) );
    if ( bytes > sizeof(m.body) ) {
        syslog( LOG_WARNING, ""message body truncated"" );
        bytes = sizeof(m.body) - 1;
    }
    if ( msgsnd(q, &m, bytes + sizeof(char) + sizeof(long) + sizeof(long), flags) < 0 ) {
        syslog( LOG_ERR, ""failed to msgsnd"" );
    }
}

/**
 * block ... read from Q and process msg
 */
int
ChannelClient::receive( char *buffer, int length ) {
    int flags = 0; // IPC_NOWAIT | MSG_NOERROR
    struct channel_message request;

    int bytes = msgrcv( q, &request, sizeof(request), getpid(), flags );
    if ( bytes < 0 ) {
        // how to handle error -- try again
    }
    strlcpy( buffer, request.body, length );
    return request.error;
}

/**
 */
int
ChannelClient::receive( char *buffer, int length, time_t  [MASK]  ) {
    struct channel_message request;
    time_t elapsed = 0;
    struct timespec delay = { 1, 0 };
    pid_t pid = getpid();

    do {
        int bytes = msgrcv( q, &request, sizeof(request), pid, IPC_NOWAIT );

        if ( bytes > 0 ) {
            strlcpy( buffer, request.body, length );
            return request.error;
        }

#if 0 // where is valgrind on OSX
        /**
         * We only want this error correction when we are not running under
         * valgrind, since valgrind changes the name of the program that is
         * running and all messaging would fail since we can not detect process
         * liveness after the program name change.
         */
        if ( RUNNING_ON_VALGRIND == 0 ) {
            if ( is_alive(service) == false ) return MESSAGE_EXCEPTION;
        }
#endif
        nanosleep( &delay, NULL );
    } while ( ++elapsed <  [MASK]  );

    syslog( LOG_ERR, ""ERROR channel recv timed out"" );
    return MESSAGE_EXCEPTION;
}

/* vim: set autoindent expandtab sw=4 : */
",time_limit
597,"#include <mutex>
#include <memory>
#include <rclcpp/rclcpp.hpp>
#include <yaml-cpp/yaml.h>
#include <cv_bridge/cv_bridge.h>
#include <sensor_msgs/msg/image.hpp>
#include <sensor_msgs/msg/point_cloud.hpp>
#include <geometry_msgs/msg/point32.hpp>
#include <builtin_interfaces/msg/time.hpp>

#include <filesystem>

#include ""kl_tracker/feature_tracker.h""

double stamp2double(builtin_interfaces::msg::Time stamp)
{
    return static_cast<double>(stamp.sec) + static_cast<double>(stamp.nanosec) * 1e-9;
}
builtin_interfaces::msg::Time double2stamp(double sec)
{
    builtin_interfaces::msg::Time stamp;
    stamp.sec = static_cast<int32_t>(sec);
    stamp.nanosec = static_cast<uint32_t>((sec - stamp.sec) * 1e9);
    return stamp;
}

struct NodeConfig
{
    std::string img_topic = ""/cam0/image_raw"";
    std::string feature_points_topic = ""feature"";
    std::string feature_image_topic = ""tracked_img"";
    std::string config_file = ""nothing.yaml"";
    double freq;
};
struct NodeState
{
    bool first_image_flag = true;
    bool publish_frame = false;
    bool first_pub_flag = true;
    int pub_count = 1;
    double first_image_time = 0.0;
    double last_image_time = 0.0;
};

class FeatureTrackerNode : public rclcpp::Node
{
public:
    FeatureTrackerNode() : Node(""feature_tracker_node"")
    {
        loadParams();
        initSubscribers();
        initPublishers();
        m_feature_tracker = std::make_shared<FeatureTracker>(m_tracker_config, std::make_shared<PinholeCamera>(m_camera_params));
    }
    void loadParams()
    {
        this->declare_parameter(""img_topic"", ""/camera/image_raw"");
        this->declare_parameter(""config_file"", ""nothing.yaml"");
        this->declare_parameter(""freq"", 10.0);
        this->get_parameter(""img_topic"", m_config.img_topic);
        this->get_parameter(""config_file"", m_config.config_file);
        this->get_parameter(""freq"", m_config.freq);
        if (std::filesystem::exists(m_config.config_file))
        {
            YAML::Node config = YAML::LoadFile(m_config.config_file);
            RCLCPP_INFO(this->get_logger(), ""[FeatureTracker] Load From File: %s"", m_config.config_file.c_str());
            const YAML::Node &camera_node = config[""camera""];
            m_camera_params.width = camera_node[""width""].as<int>();
            m_camera_params.height = camera_node[""height""].as<int>();
            m_camera_params.fx = camera_node[""fx""].as<double>();
            m_camera_params.fy = camera_node[""fy""].as<double>();
            m_camera_params.cx = camera_node[""cx""].as<double>();
            m_camera_params.cy = camera_node[""cy""].as<double>();
            m_camera_params.k1 = camera_node[""k1""].as<double>();
            m_camera_params.k2 = camera_node[""k2""].as<double>();
            m_camera_params.p1 = camera_node[""p1""].as<double>();
            m_camera_params.p2 = camera_node[""p2""].as<double>();
            const YAML::Node &tracker_node = config[""tracker""];
            m_tracker_config.equalize = tracker_node[""equalize""].as<bool>();
            m_tracker_config.f_threshold = tracker_node[""f_threshold""].as<double>();
            m_tracker_config.focal_length = tracker_node[""focal_length""].as<double>();
            m_tracker_config.min_dist = tracker_node[""min_dist""].as<int>();
            m_tracker_config.max_count = tracker_node[""max_count""].as<int>();
            m_tracker_config.window_size = tracker_node[""window_size""].as<int>();
        }
        else
        {
            RCLCPP_WARN(this->get_logger(), ""[FeatureTracker] File: %s Not Exits, Load From Default"", m_config.config_file.c_str());
        }
    }

    void imageCallback(const sensor_msgs::msg::Image::SharedPtr msg)
    {
        if (m_state.first_image_flag)
        {
            m_state.first_image_flag = false;
            m_state.first_image_time = stamp2double(msg->header.stamp);
            m_state.last_image_time = m_state.first_image_time;
            return;
        }
        double cur_image_time = stamp2double(msg->header.stamp);
        if (cur_image_time - m_state.last_image_time > 1.0 || cur_image_time < m_state.last_image_time)
        {
            RCLCPP_WARN(this->get_logger(), ""[FeatureTracker] Image Time Error"");
            m_state.first_image_flag = true;
            m_state.first_image_time = 0.0;
            m_state.last_image_time = 0.0;
            m_state.pub_count = 1;
            return;
        }

        m_state.last_image_time = cur_image_time;

        if (round(1.0 * m_state.pub_count / (cur_image_time - m_state.first_image_time)) <= m_config.freq)
        {
            m_state.publish_frame = true;
            if (abs(1.0 * m_state.pub_count / (cur_image_time - m_state.first_image_time) - m_config.freq) < 0.01 * m_config.freq)
            {
                m_state.first_image_time = cur_image_time;
                m_state.pub_count = 0;
            }
        }
        else
        {
            m_state.publish_frame = false;
        }
        cv::Mat img = cv_bridge::toCvCopy(msg, ""mono8"")->image;
        m_feature_tracker->track(img, cur_image_time, m_state.publish_frame);

        if (m_state.publish_frame)
        {

            m_state.pub_count++;
            publishFeaturePoints(msg->header);
            publishFeatureImage(msg->header, img);
        }
    }

    void publishFeaturePoints(std_msgs::msg::Header &header)
    {
        if (m_state.first_pub_flag)
            m_state.first_pub_flag = false;
        else
        {
            if (m_feature_pts_pub->get_subscription_count() < 1)
                return;
            sensor_msgs::msg::PointCloud feature_pts_msg;
            sensor_msgs::msg::ChannelFloat32 id_of_point;
            sensor_msgs::msg::ChannelFloat32 u_of_point;
            sensor_msgs::msg::ChannelFloat32 v_of_point;
            sensor_msgs::msg::ChannelFloat32 velocity_x_of_point;
            sensor_msgs::msg::ChannelFloat32 velocity_y_of_point;
            feature_pts_msg.header = header;
            for (size_t j = 0; j < m_feature_tracker->ids().size(); j++)
            {
                if (m_feature_tracker->trackCnt()[j] <= 1)
                    continue;
                const int &id = m_feature_tracker->ids()[j];

                const cv::Point2f &xy = m_feature_tracker->curPtsXY()[j];
                const cv::Point2f &uv = m_feature_tracker->curPtsUV()[j];
                const cv::Point2f &velocity = m_feature_tracker->ptsVelocity()[j];
                geometry_msgs::msg::Point32 p;
                p.x = xy.x;
                p.y = xy.y;
                p.z = 1.0;
                feature_pts_msg.points.push_back(p);
                id_of_point.values.push_back(id);
                u_of_point.values.push_back(uv.x);
                v_of_point.values.push_back(uv.y);
                velocity_x_of_point.values.push_back(velocity.x);
                velocity_y_of_point.values.push_back(velocity.y);
            }
            feature_pts_msg.channels.push_back(id_of_point);
            feature_pts_msg.channels.push_back(u_of_point);
            feature_pts_msg.channels.push_back(v_of_point);
            feature_pts_msg.channels.push_back(velocity_x_of_point);
            feature_pts_msg.channels.push_back(velocity_y_of_point);
            m_feature_pts_pub->publish(feature_pts_msg);
        }
    }

    void publishFeatureImage(std_msgs::msg::Header &header, const cv::Mat &img)
    {
        if (m_feature_img_pub->get_subscription_count() < 1)
        {
            return;
        }
        cv::Mat show_img;
        cv::cvtColor(img, show_img, CV_GRAY2RGB);
        for (size_t j = 0; j < m_feature_tracker->curPtsUV().size(); j++)
        {
            double len = std::min(1.0, 1.0 * m_feature_tracker->trackCnt()[j] / m_feature_tracker->config().window_size);
            cv::circle(show_img, m_feature_tracker->curPtsUV()[j], 2, cv::Scalar(255 * (1 - len), 0, 255 * len), 2);
        }
        cv_bridge::CvImage  [MASK] ;
         [MASK] .header = header;
         [MASK] .encoding = sensor_msgs::image_encodings::BGR8;
         [MASK] .image = show_img;
        sensor_msgs::msg::Image::SharedPtr msg =  [MASK] .toImageMsg();
        m_feature_img_pub->publish(*msg);
    }

    void initSubscribers()
    {
        m_img_sub = this->create_subscription<sensor_msgs::msg::Image>(m_config.img_topic, 100, std::bind(&FeatureTrackerNode::imageCallback, this, std::placeholders::_1));
    }

    void initPublishers()
    {
        m_feature_pts_pub = this->create_publisher<sensor_msgs::msg::PointCloud>(m_config.feature_points_topic, 100);
        m_feature_img_pub = this->create_publisher<sensor_msgs::msg::Image>(m_config.feature_image_topic, 100);
    }

private:
    NodeConfig m_config;
    PinholeParams m_camera_params;
    NodeState m_state;
    TrackerConfig m_tracker_config;
    std::shared_ptr<FeatureTracker> m_feature_tracker;
    rclcpp::Subscription<sensor_msgs::msg::Image>::SharedPtr m_img_sub;
    rclcpp::Publisher<sensor_msgs::msg::PointCloud>::SharedPtr m_feature_pts_pub;
    rclcpp::Publisher<sensor_msgs::msg::Image>::SharedPtr m_feature_img_pub;
};

int main(int argc, char **argv)
{
    rclcpp::init(argc, argv);
    rclcpp::spin(std::make_shared<FeatureTrackerNode>());
    rclcpp::shutdown();
    return 0;
}
",cv_image
598,"/*
 * ----------------------------------------------------------------------------
 * Copyright 2018 ARM Ltd.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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 ""mbed.h""
#include <stdio.h>
#include ""BlockDevice.h""
#include ""intelhex.h""

int block_dump(BlockDevice &bd, size_t early_stop)
{
    uint8_t buf[1024]; /* 65536 needs to be dividable by this number */
    size_t  [MASK]  = bd.size();
    intelhex_header();
    for (size_t offset = 0; offset <  [MASK] ;) {
        size_t read_size =  [MASK]  - offset;
        if (read_size > sizeof(buf)) {
            read_size = sizeof(buf);
        }

        int retval = bd.read(buf, offset, sizeof(buf));
        if (retval != 0) {
            return retval;
        }

        intelhex_data(buf, offset, read_size);
        offset += read_size;

        if (early_stop) {
            if (offset > early_stop) {
                printf(""early stop\n"");
                break;
            }
        }
    }
    intelhex_footer();
    return 0;
}

int main() {
    int retval;
    BlockDevice *bd = BlockDevice::get_default_instance();
    printf(""Dump start\n"");

    retval = bd->init();
    printf(""init() = %d\n"", retval);

    retval = block_dump(*bd, 0);
    printf(""block_dump() = %d\n"", retval);

    retval = bd->deinit();
    printf(""deinit() = %d\n"", retval);

    printf(""Dump done\n"");
    while(1);
}

",bd_size
599,"#include ""LevelSystem.h""
#include <fstream>
#include <iostream>

using namespace std;
using namespace sf;

std::unique_ptr<LevelSystem::TILE[]> LevelSystem::_tiles;
size_t LevelSystem::_width;
size_t LevelSystem::_height;
Vector2f LevelSystem::_offset(0.0f, 0.0f);

float LevelSystem::_tileSize(100.f);
vector<std::unique_ptr<sf::RectangleShape>> LevelSystem::_sprites;

std::map<LevelSystem::TILE, sf::Color> LevelSystem::_colours{ {WALL, Color::Green}, {END, Color::Red} };

sf::Color LevelSystem::getColor(LevelSystem::TILE t) {
    auto it = _colours.find(t);
    if (it == _colours.end()) {
        _colours[t] = Color::Transparent;
    }
    return _colours[t];
}

void LevelSystem::setColor(LevelSystem::TILE t, sf::Color c) {
    auto it = _colours.find(t);
    if (it != _colours.end())
    {
        _colours[t] = c;
    }
}

void LevelSystem::loadLevelFile(const std::string& path, float tileSize) {
    _tileSize = tileSize;
    size_t w = 0, h = 0;
    string buffer;

    // Load in file to buffer
    ifstream f(path);
    if (f.good()) {
        f.seekg(0, std::ios::end);
        buffer.resize(f.tellg());
        f.seekg(0);
        f.read(&buffer[0], buffer.size());
        f.close();
    }
    else {
        throw string(""Couldn't open level file: "") + path;
    }

    std::vector<TILE>  [MASK] ;
    for (int i = 0; i < buffer.size(); ++i) {
        const char c = buffer[i];
        switch (c) {
        case 'w':
             [MASK] .push_back(WALL);
            break;
        case 's':
             [MASK] .push_back(START);
            break;
        case 'e':
             [MASK] .push_back(END);
            break;
        case ' ':
             [MASK] .push_back(EMPTY);
            break;
        case '+':
             [MASK] .push_back(WAYPOINT);
            break;
        case 'n':
             [MASK] .push_back(ENEMY);
            break;
        case '\n':      // end of line
            if (w == 0) { // if we haven't written width yet
                w = i;      // set width
            }
            h++; // increment height
            break;
        default:
            cout << c << endl; // Don't know what this tile type is
        }
    }
    if ( [MASK] .size() != (w * h)) {
        throw string(""Can't parse level file"") + path;
    }
    _tiles = std::make_unique<TILE[]>(w * h);
    _width = w; //set static class vars
    _height = h;
    std::copy( [MASK] .begin(),  [MASK] .end(), &_tiles[0]);
    cout << ""Level "" << path << "" Loaded. "" << w << ""x"" << h << std::endl;
    buildSprites();
}

int LevelSystem::getHeight()
{
    return _height;
}

int LevelSystem::getWidth()
{
    return _width;
}

void LevelSystem::buildSprites() {
    _sprites.clear();
    for (size_t y = 0; y < LevelSystem::getHeight(); ++y) {
        for (size_t x = 0; x < LevelSystem::getWidth(); ++x) {
            auto s = make_unique<RectangleShape>();
            s->setPosition(getTilePosition({ x, y }));
            s->setSize(Vector2f(_tileSize, _tileSize));
            s->setFillColor(getColor(getTile({ x, y })));
            _sprites.push_back(move(s));
        }
    }
}

Vector2f LevelSystem::getTilePosition(Vector2ul p) {
    return (Vector2f(p.x, p.y) * _tileSize);
}

LevelSystem::TILE LevelSystem::getTile(Vector2ul p) {
    if (p.x > _width || p.y > _height) {
        throw string(""Tile out of range: "") + to_string(p.x) + "","" + to_string(p.y) + "")"";
    }
    return _tiles[(p.y * _width) + p.x];
}

LevelSystem::TILE LevelSystem::getTileAt(Vector2f v) {
    auto a = v - _offset;
    if (a.x < 0 || a.y < 0) {
        throw string(""Tile out of range "");
    }
    return getTile(Vector2ul((v - _offset) / (_tileSize)));
}

void LevelSystem::Render(RenderWindow& window) {
    for (size_t i = 0; i < _width * _height; ++i) {
        window.draw(*_sprites[i]);
    }
}
",temp_tiles
600,"#ifndef AUTONOMOUS_BICYCLE_PID_H
#define AUTONOMOUS_BICYCLE_PID_H

#include <time.h>

class PID {
public:
    double kp, ki, kd, windupGuard;
    double setPoint, output, error;
    double sampleTime;

    PID() {}
    PID(double kp, double kd, double ki, double windupGuard) {
        this->kp = kp;
        this->ki = ki;
        this->kd = kd;
        this->windupGuard = windupGuard;
        this->current_time = time(NULL);
        this->last_time = time(NULL);
    }

    void clear() {
        this->PTerm = 0;
        this->ITerm = 0;
        this->DTerm = 0;
        this->last_error = 0;
        this->output = 0;
    }

    void update(double feedback) {
        this->error = this->setPoint - feedback;
        this->current_time = time(NULL);

        double  [MASK]  = this->current_time - this->last_time;
        double deltaError = this->error - this->last_error;

        if ( [MASK]  >= this->sampleTime) {
            this->PTerm = this->kp * this->error;
            this->ITerm += this->error *  [MASK] ;

            if (this->ITerm < -this->windupGuard)
                this->ITerm = -this->windupGuard;

            if (this->ITerm > this->windupGuard)
                this->ITerm = this->windupGuard;

            this->DTerm = 0;
            if ( [MASK]  > 0) {
                this->DTerm = deltaError /  [MASK] ;
            }

            this->last_time = this->current_time;
            this->last_error = this->error;

            this->output = this->PTerm + (this->ki * this->ITerm) + (this->kd * this->DTerm);
        }
    }

    void setKp(double kp) {
        this->kp = kp;
    }

    void setKd(double kd) {
        this->kd = kd;
    }

    void setKi(double ki) {
        this->ki = ki;
    }

    void setWindUp(double WindUp) {
        this->windupGuard = WindUp;
    }

    void setSampleTime(double sampleTime) {
        this->sampleTime = sampleTime;
    }

private:
    float PTerm, ITerm, DTerm, last_error;
    time_t current_time, last_time;
};

#endif //AUTONOMOUS_BICYCLE_PID_H
",deltaTime
601,"#include ""Perro.h""
#include <iostream>


// Ejemplo de constructor por defecto con lista inicializadora
// Perro::Perro() : edad(0), raza(""""), tamanio(""""), color("""") {}

// Ejemplo de constructor por defecto iniciando los atributos en el cuerpo del constructor
Perro::Perro() {
    this->edad = 0;
    this->raza = """";
    this->tamanio = """";
    this->color = """";
}

void Perro::ladrar() {
    std::cout << ""Guau Guau"" << std::endl;
}

void Perro::agregarPropietario(std::string nombre, std::string docIdentidad) {
    // Asocia a la variable de instancia pPropietario un nuevo pPropietario
    // Es memoria dinámica, en el destructor se debe liberar
    this->pPropietario = new Propietario(nombre, docIdentidad);
}

void Perro::agregarVeterinario(std::string nombre, int  [MASK] ) {
    this->pVeterinario = new Veterinario(nombre,  [MASK] );
}

Veterinario *Perro::getVeterinario() {
    return this->pVeterinario;
}

void Perro::agregarRaza(std::string nombre, std::string paisOrigen) {
    this->pRaza = new Raza(nombre, paisOrigen);
}

Raza *Perro::getRaza() {
    return this->pRaza;
}

void Perro::setRaza(Raza *pRaza) {
    this->pRaza = pRaza;
}

Perro::Perro(std::string nombre, int edad, std::string raza, std::string tamanio, std::string color ):
    nombre(nombre), edad(edad), raza(raza), tamanio(tamanio), color(color) {}


void Perro::setPropietario(Propietario *pPropietario) {
    this->pPropietario = pPropietario;
}

Propietario *Perro::getPropietario() {
    return this->pPropietario;
}

int Perro::getEdad() {
    return edad;
}

void Perro::setEdad(int edad) {
    this->edad = edad;
}

std::string Perro::getRaza() {
    return raza;
}

void Perro::setRaza(std::string raza) {
    this->raza = raza;
}

std::string Perro::getTamanio() {
    return tamanio;
}

void Perro::setTamanio(std::string tamanio) {
    this->tamanio = tamanio;
}

std::string Perro::getNombre() {
    return nombre;
}

void Perro::setNombre(std::string nombre) {
    this->nombre = nombre;
}

std::string Perro::getColor() {
    return color;
}

void Perro::setColor(std::string color) {
    this->color = color;
}

Perro::~Perro() {
    delete pPropietario;
}




",aniosExperiencia
602,"#include <iostream>
#include <string>

std::string to_three(int a) {
	int c = a;
	std::string res = """";
	while (c > 0) {
		std::string str = std::to_string(c % 3);
		res += str;
		c /= 3;
	}
	std::string result = """";
	for (int i = res.size() - 1; i >= 0; i -= 1) {
		result += res[i];
	}
	return result;
}
int main() {
	std::string a = """";
	std::string c = """";
	std::cin >> a >> c;
	a = to_three(std::stoi(a));
	c = to_three(std::stoi(c));
	if (a.size() < c.size()) {
		while (a.size() < c.size()) {
			a = ""0"" + a;
		}
	}
	else {
		while (c.size() < a.size()) {
			c = ""0"" + c;
		}
	}
	std::string result = """";
	for (int j = 0; j < a.size(); j += 1) {
		std::string res = std::to_string(((a[j] - '0') + (c[j] - '0')) % 3);
		result += res;
	}
	std::string  [MASK]  = """";
	for (int j = 0; j < result.size(); j += 1) {
		std::string res = std::to_string(((result[j] - '0') + (a[j] - '0')) % 3);
		 [MASK]  += res;
	}
	int ch = 0;
	for (int i = 0; i <  [MASK] .size(); i += 1) {
		ch += ( [MASK] [i] - '0') * std::pow(3,  [MASK] .size() - i - 1);
	}
	std::cout << ch;
}
",final_result
603,"#include <algorithm>
#include <array>
#include <cstdint>
#include <cstdlib>
#include <exception>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <map>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <variant>
#include <vector>
#include ""vle.hpp""
#include ""vle/GbSequence.hpp""
#include ""vle/Unicode.hpp""
#include ""vle/unicode/Utf16Sequence.hpp""
#include ""vle/unicode/Utf8Sequence.hpp""

static_assert(File::Vle<File::GbSequence, std::uint8_t>);
static_assert(File::Vle<File::Unicode::Utf8Sequence, std::uint8_t>);
static_assert(File::Vle<File::Unicode::Utf16Sequence, std::uint16_t>);

template<typename Point, File::Vle<Point> T>
void validateVle(bool& isValid, std::optional<T>& vleSequence, typename T::Point point) {
    if (vleSequence.has_value()) {
        T& sequence{vleSequence.value()};
        if (!sequence.isComplete() && !sequence.addPoint(point)) {
            isValid = false;
            return;
        }
        if (sequence.isComplete()) {
            if (!sequence.isValid()) {
                isValid = false;
            }
            vleSequence.reset();
            return;
        }
        return;
    }
    std::optional<T> possibleSequence{T::build(point)};
    if (possibleSequence.has_value()) {
        T sequence{possibleSequence.value()};
        if (!sequence.isComplete()) {
            vleSequence.emplace(sequence);
            return;
        }
        if (!sequence.isValid()) {
            isValid = false;
            return;
        }
        return;
    }
    isValid = false;
}

enum class FileType {
    empty,
    ascii,
    latin1,
    utf8,
    utf16,
    gb,
    data
};

enum class FileError {
    metadataError,
    doesNotExist,
    invalidPerms,
    notRegularFile,
    unreadable,
};

using FileState = std::variant<FileType, FileError>;

void file(std::vector<char*>&& args);

std::optional<FileError> findMetadata(const std::filesystem::path& path) noexcept;


FileState classifyFile(std::ifstream&& fileReader);

int main(const int argc, char* argv[]) {
    try {
        if (argc <= 1) {
            throw std::invalid_argument(""Invalid number of arguments."");
        }
        std::vector<char*> arguments{};
        arguments.assign(argv + 1, argv + argc);
        file(std::move(arguments));
    } catch (std::exception& e) {
        std::cerr << e.what() << ""Usage: file [files]"" << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

void file(std::vector<char*>&& args) {
    std::ranges::sort(args);
    auto last = std::ranges::unique(args, [](const char* a, const char* b) {
        return std::filesystem::weakly_canonical(a) == std::filesystem::weakly_canonical(b);
    });
    args.erase(last.begin(), args.end());
    std::map<std::filesystem::path, FileState> fileStates{};
    std::mutex fileStateMutex{};
    std::vector<std::thread> threads{};
    threads.reserve(args.size());
    for (char*& arg: args) {
        threads.emplace_back([&arg, &fileStateMutex, &fileStates] {
            const std::filesystem::path path{arg, std::filesystem::path::generic_format};
            std::optional possibleError{findMetadata(path)};
            if (possibleError.has_value()) {
                std::lock_guard guard{fileStateMutex};
                fileStates.emplace(path, *possibleError);
                return;
            }
            const std::uintmax_t fileSize{file_size(path)};
            if (fileSize == 0) {
                std::lock_guard guard{fileStateMutex};
                fileStates.emplace(path, FileType::empty);
                return;
            }
            std::ifstream fileBuffer{path, std::ios::binary};
            if (!fileBuffer.is_open()) {
                std::lock_guard guard{fileStateMutex};
                fileStates.emplace(path, FileError::unreadable);
                return;
            }
            FileState fileState{classifyFile(std::move(fileBuffer))};
            std::lock_guard guard{fileStateMutex};
            fileStates.emplace(path, fileState);
        });
    }
    for (std::thread& thread: threads) {
        thread.join();
    }
    for (auto [path, result]: fileStates) {
        std::string message;
        if (std::holds_alternative<FileType>(result)) {
            switch (std::get<FileType>(result)) {
                case FileType::empty:
                    message = ""empty"";
                    break;
                case FileType::ascii:
                    message = ""ASCII text"";
                    break;
                case FileType::latin1:
                    message = ""ISO-8859-1 text"";
                    break;
                case FileType::utf8:
                    message = ""UTF-8 text"";
                    break;
                case FileType::utf16:
                    message = ""UTF-16 text"";
                    break;
                case FileType::gb:
                    message = ""GB 18030 text"";
                    break;
                case FileType::data:
                    message = ""data"";
                    break;
            }
        } else {
            switch (std::get<FileError>(result)) {
                case FileError::metadataError:
                    message = ""Was unable to check status of file"";
                    break;
                case FileError::doesNotExist:
                    message = ""File does not exist"";
                    break;
                case FileError::invalidPerms:
                    message = ""Invalid permissions"";
                    break;
                case FileError::notRegularFile:
                    message = ""File is not a regular file"";
                    break;
                case FileError::unreadable:
                    message = ""Lacked read permissions"";
            }
        }
        std::cout << path.generic_string() << "": "" << message << ""\n"";
    }
    std::flush(std::cout);
}

constexpr bool isByteAscii(const std::uint8_t byte) {
    return (0x08 <= byte && byte <= 0x0D) || (byte == 0x1B) | (0x20 <= byte && byte <= 0x7E);
}

constexpr bool isByteLatin1(const std::uint8_t byte) {
    return isByteAscii(byte) || byte >= 0xA0;
}

FileState classifyFile(std::ifstream&& fileReader) {
    using namespace File;
    bool isAscii{true}, isLatin1{true}, isUtf8{true}, isUtf16{true},  [MASK] {true};
    std::optional<Unicode::Utf8Sequence> utf8Sequence{std::nullopt};
    std::optional<Unicode::Utf16Sequence> utf16Sequence{std::nullopt};
    std::optional<GbSequence> gbSequence{std::nullopt};
    std::optional<Unicode::Endianness> endianness{std::nullopt};
    std::array<std::uint8_t, 2> byteBuffer{0, 0};
    std::uintmax_t bytesRead{0};
    std::uint8_t byte;
    fileReader.get(reinterpret_cast<char&>(byte));
    while (fileReader.good()) {
        bytesRead++;
        if (isAscii && !isByteAscii(byte)) {
            isAscii = false;
        }
        if (!isAscii && isUtf16) {
            byteBuffer[(bytesRead - 1) % 2] = byte;
            if (bytesRead % 2 == 0) {
                if (endianness.has_value()) {
                    const std::uint16_t point = [&] {
                        switch (endianness.value()) {
                            case Unicode::Endianness::bigEndian:
                                return byteBuffer[0] << 8 | byteBuffer[1];
                            case Unicode::Endianness::littleEndian:
                                return byteBuffer[1] << 8 | byteBuffer[0];
                        }
                        return 0;
                    }();
                    validateVle<std::uint16_t, Unicode::Utf16Sequence>(
                        isUtf16, utf16Sequence, point);
                } else {
                    const std::uint16_t bigEndian{
                        static_cast<std::uint16_t>(byteBuffer[0] << 8 | byteBuffer[1])
                    };
                    const std::uint16_t littleEndian{
                        static_cast<std::uint16_t>(byteBuffer[1] << 8 | byteBuffer[0])
                    };
                    if (bigEndian == 0xFEFF) {
                        endianness = Unicode::Endianness::bigEndian;
                    } else if (littleEndian == 0xFEFF) {
                        endianness = Unicode::Endianness::littleEndian;
                    } else {
                        isUtf16 = false;;
                    }
                }
            }
        }
        if (!isAscii && isUtf8) {
            validateVle<std::uint8_t, Unicode::Utf8Sequence>(isUtf8, utf8Sequence, byte);
        }
        if (!isAscii &&  [MASK] ) {
            validateVle<std::uint8_t, GbSequence>( [MASK] , gbSequence, byte);
        }
        if (!isAscii && isLatin1 && !isByteLatin1(byte)) {
            isLatin1 = false;
        }
        if (!isAscii && !isUtf16 && !isUtf8 && ! [MASK]  && !isLatin1) {
            return FileType::data;
        }
        fileReader.get(reinterpret_cast<char&>(byte));
    }
    if (utf16Sequence.has_value()) {
        isUtf16 = false;
    }
    if (utf8Sequence.has_value()) {
        isUtf8 = false;
    }
    if (gbSequence.has_value()) {
         [MASK]  = false;
    }
    if (isAscii) {
        return FileType::ascii;
    }
    if (isUtf16) {
        return FileType::utf16;
    }
    if (isUtf8) {
        return FileType::utf8;
    }
    if (isLatin1) {
        return FileType::latin1;
    }
    if ( [MASK] ) {
        return FileType::gb;
    }
    return FileType::data;
}


std::optional<FileError> findMetadata(const std::filesystem::path& path) noexcept {
    namespace fs = std::filesystem;
    std::error_code ec{};
    const fs::file_status metadata{status(path, ec)};
    if (!status_known(metadata)) {
        return std::make_optional(FileError::metadataError);
    }
    if (!exists(metadata)) {
        return std::make_optional(FileError::doesNotExist);
    }
    if (metadata.type() == fs::file_type::unknown) {
        return std::make_optional(FileError::invalidPerms);
    }
    if (!is_regular_file(metadata)) {
        return std::make_optional(FileError::notRegularFile);
    }
    if ((metadata.permissions() & (fs::perms::owner_read | fs::perms::group_read |
                                   fs::perms::others_read)) ==
        fs::perms::none) {
        return std::make_optional(FileError::unreadable);
    }
    return std::nullopt;
}

",isGb
604,"#pragma once

#include <coin/IpJournalist.hpp>
#include <Python.h>


class PythonJournal : public Ipopt::Journal {
public:
  PythonJournal(Ipopt::EJournalLevel default_level, PyObject *stream)
    : Journal(""PythonJournal"", default_level)
    , stream_(stream) {
    Py_XINCREF(stream_);
  }

  virtual ~PythonJournal() {
    Py_XDECREF(stream_);
  }

protected:
  virtual void PrintImpl(Ipopt::EJournalCategory category,
			 Ipopt::EJournalLevel level,
			 const char* str) override {
    PyObject_CallMethod(stream_, ""write"", ""s"", str);
  }

  virtual void PrintfImpl(Ipopt::EJournalCategory category,
			  Ipopt::EJournalLevel level,
			  const char* pformat,
			  va_list ap) override {
    // Define string
    static const int  [MASK]  = 8192;
    char s[ [MASK] ];

    if (vsnprintf(s,  [MASK] , pformat, ap) >  [MASK] ) {
      PrintImpl(category, level, ""Warning: not all characters of next line are printed to the file.\n"");
    }
    PrintImpl(category, level, s);
  }

  virtual void FlushBufferImpl() override {
    PyObject_CallMethod(stream_, ""flush"", """");
  }

private:
  PyObject *stream_;
};
",max_len
605,"//  MyWeatherClock.ino
//  dt 01DEC2024.. fancy up my CYD clock!!
//  add barosensor lib from Freetronics
//  try sparkfun MS5637 lib - barosensor doesn't work with ESP32!! dt 03DEC2024
//
//  add humidity detector?? dt 06DEC2024
//  DHT22???

#include ""DHT.h""
#include <WiFi.h>
#include ""time.h""
#include ""esp_sntp.h""
#include <TFT_eSPI.h>
#include <Wire.h>
#include ""SparkFun_MS5637_Arduino_Library.h""

// custom I2C ports for ESP32 on CN1?..
#define I2C_SDA 27
#define I2C_SCL 22
// IO for DHT11
#define DHTPIN 17 // on a spare connector for CYD.. used for blue rgb led.. 
//
//#define DHTTYPE DHT11   // DHT 11
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// instantiate baro sensor..
MS5637 BaroSensor;
    float pressure;
    float temperature;
// instantiate humidity sensor..
DHT HumSensor(DHTPIN, DHTTYPE);    


// A library for interfacing with LCD displays
//
// Can be installed from the library manager (Search for ""TFT_eSPI"")
//https://github.com/Bodmer/TFT_eSPI

TFT_eSPI tft = TFT_eSPI();
  int x = 5;
  int y = 10;
  //int fontNum = 2;
  int fontNum = 3;

const char *ssid = ""xxxx"";
const char *password = ""<PASSWORD>"";
// won't connect to hidden SSIDs... from arduino.cc reference pages.

const char *ntpServer1 = ""10.28.174.11"";  // when cottage is back on line..
const char *ntpServer2 = ""au.pool.ntp.org"";
//
const char *ntpServer3 = ""time.nist.gov"";
const long gmtOffset_sec = 3600;
const int daylightOffset_sec = 3600;

const char *time_zone = ""AEST-10AEDT,M10.1.0,M4.1.0/3"";  // TimeZone rule for Melbourne, AU including daylight adjustment rules (optional)
IPAddress ip;                    // the IP address of your device...
void printLocalTime() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    Serial.println(""No time available (yet)"");
    return;
  }
  Serial.println(&timeinfo, ""%A, %B %d %Y %H:%M:%S"");
}
void printHMS() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    Serial.println(""No time available (yet)"");
    return;
  }
  Serial.println(&timeinfo, ""%H:%M:%S"");
}
// Callback function (gets called when time adjusts via NTP)
void timeavailable(struct timeval *t) {
  Serial.println(""Got time adjustment from NTP!"");
  printLocalTime();
}
void ShowHMS() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    tft.println(""pls wait...)"");
    return;
  }
   tft.println(&timeinfo, ""%H:%M:%S"");
}
void ShowDMY() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    tft.println(""pls wait...)"");
    return;
  }
   tft.setTextSize(3);
   tft.println(&timeinfo, ""%A,   ""); // extra spaces to flush longer day names! dt 01NOV2024
   tft.println(&timeinfo, "" %d %B %Y"" );
}

// SETUP starts here!!!!

void setup() {
  Serial.begin(9600);
  HumSensor.begin();
  Wire.begin(I2C_SDA, I2C_SCL); // it really helps to tell wire.begin if you change from the default i2c pins!! dt 03DEC2024
  if (BaroSensor.begin() == false)
  {
    Serial.println(""MS5637 sensor did not respond. Please check wiring."");
  }
  // Start the tft display and set it to black
  tft.init();
  tft.setRotation(1); //This is the display in landscape

  // Clear the screen before writing to it
  tft.fillScreen(TFT_BLACK);

  tft.setTextColor(TFT_CYAN, TFT_BLACK);
  tft.setCursor(5, 5);
  tft.setTextSize(2);
  tft.println(""My Weather Clock!!""); // Left Aligned
//
  tft.setTextColor(TFT_BLUE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10,35);
  tft.println(""The Temp is: "");
//
  tft.setTextColor(TFT_RED, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10,55);
  tft.println(""Barometer is: "");
//  
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10,75);
  tft.println(""Humidity is: "");
 

  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.drawCentreString(""The Time is:"", x, y, fontNum);
  // now for the time connect..
  Serial.begin(115200);
  // First step is to configure WiFi STA and connect in order to get the current time and date.
  Serial.printf(""Connecting to %s "", ssid);
  WiFi.begin(ssid, password);

  /**
   * NTP server address could be acquired via DHCP,
   *
   * NOTE: This call should be made BEFORE esp32 acquires IP address via DHCP,
   * otherwise SNTP option 42 would be rejected by default.
   * NOTE: configTime() function call if made AFTER DHCP-client run
   * will OVERRIDE acquired NTP server address
   */
  esp_sntp_servermode_dhcp(1);  // (optional)

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(""."");
    }
  Serial.println("" CONNECTED"");
  //print the local IP address
  ip = WiFi.localIP();
  Serial.println(ip);

  // set notification call-back function
  sntp_set_time_sync_notification_cb(timeavailable);

  /**
   * This will set configured ntp servers and constant TimeZone/daylightOffset
   * should be OK if your time zone does not need to adjust daylightOffset twice a year,
   * in such a case time adjustment won't be handled automagically.
   */
  //configTime(gmtOffset_sec, daylightOffset_sec, ntpServer1, ntpServer2);

  /**
   * A more convenient approach to handle TimeZones with daylightOffset
   * would be to specify a environment variable with TimeZone definition including daylight adjustmnet rules.
   * A list of rules for your zone could be obtained from https://github.com/esp8266/Arduino/blob/master/cores/esp8266/TZ.h
   */
  configTzTime(time_zone, ntpServer1, ntpServer2, ntpServer3);
}

void loop() {

  float temperature = BaroSensor.getTemperature();
  float pressure = BaroSensor.getPressure();
  float  [MASK]  = HumSensor.readHumidity(); 
    Serial.println();
    Serial.print(""Temperature: "");
    Serial.print(temperature, 1);
    Serial.print("" Pressure:    "");
    Serial.print(pressure, 3);
    Serial.println();
    Serial.print("" Humidity:    "");
    Serial.print( [MASK] , 3);
    Serial.println();
    //
  tft.setTextSize(2);  
  tft.setTextColor(TFT_YELLOW, TFT_BLACK);
  tft.setCursor(170,35);  
  tft.print(temperature, 1);
  tft.println("" deg.C"");
  //
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setCursor(170,55);
  tft.print(pressure, 2);
  tft.println("" mBar"");
  //
  tft.setTextColor(TFT_GREENYELLOW, TFT_BLACK);
  tft.setCursor(170,75);
  tft.print( [MASK] );
  tft.println("" %"");
  // 
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.setTextSize(6);
  delay(1000);
  //
  // position clock in middle of screen..
  tft.setCursor(15,125);
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  // draw text??
  ShowHMS();  // show time on screen
  tft.setCursor(15,185);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  ShowDMY();  // show day, date..
  // serial check of time..
  printHMS();  // it will take some time to sync time :)
}
",humidval
606,"// Created on Fri Nov 08 2024
// © 2024 BLACKHAND Studio. 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.

#pragma once

#include <cstdint>
#include <memory>
#include <stack>
#include <functional>
#include <stdexcept>

/// @file
/// @brief 풀(Pool) 기반 메모리 관리 인터페이스 및 컴포넌트 전용 풀 구현
///
/// 풀을 통해 객체를 재활용함으로써 캐시 친화성과 메모리 할당/해제에 따르는 오버헤드 감소 기대.
/// PoolBase는 풀의 기본 인터페이스를 제공하며, ComponentPool은 특정 컴포넌트 타입 T에 특화된 풀 구현.
/// Acquire 메서드를 통해 객체를 대여받고, 스마트 포인터와 커스텀 해제자를 이용해 객체 생명주기 관리.

namespace MIR
{
    /**
     * @brief 풀(Pool) 인터페이스를 위한 기본 클래스
     * 
     * 모든 풀 클래스는 이 클래스를 상속받아야 함.
     * 다양한 타입의 컴포넌트 풀을 일관성 있게 관리하기 위한 공통 타입 기준 역할 수행.
     */
    class PoolBase
    {
    public:
        /**
         * @brief 가상 소멸자
         * 
         * 상속받은 풀 클래스에서 안전한 소멸을 보장하기 위해 가상 소멸자 구현.
         */
        virtual ~PoolBase() = default;
    };

    /**
     * @brief 특정 타입 T에 대한 컴포넌트 풀 구현
     * 
     * ComponentPool은 T 타입의 컴포넌트를 재사용하기 위한 풀.
     * 최대 MAX_SIZE개의 컴포넌트를 스택(pool)에 보관할 수 있으며, 
     * Acquire 메서드를 통해 필요 시 새 컴포넌트를 생성하거나, 
     * 풀에서 재사용 가능한 컴포넌트를 팝.
     * 사용이 끝난 컴포넌트는 커스텀 해제자(Deleter)를 통해 다시 풀에 반환.
     * 
     * @tparam T 풀에서 관리할 컴포넌트 타입
     */
    template <typename T>
    class ComponentPool : public PoolBase
    {
    public:
        /**
         * @brief 풀에서 보관할 수 있는 최대 컴포넌트 수
         * 
         * 이 값은 풀에 재사용 가능한 컴포넌트를 얼마나 많이 쌓아둘 수 있는지 결정.
         * 여기서는 0xFF(255)로 설정.
         */
        static constexpr std::size_t MAX_SIZE = 0xFF;

        /**
         * @brief ComponentPool 기본 생성자
         * 
         * 초기 상태에서는 풀(stack)이 비어있음.
         */
        ComponentPool() = default;

        /**
         * @brief 풀로부터 컴포넌트를 대여(Acquire)하는 메서드
         * 
         * 템플릿 파라미터 T 타입의 컴포넌트를 반환합니다.
         * 내부적으로 풀(stack)이 비어있으면 새로 할당하고, 
         * 비어있지 않으면 스택 최상단의 재사용 가능한 컴포넌트를 가져와 
         * 새로 전달받은 인자(Args...)로 재초기화.
         * 반환 타입은 스마트 포인터(uniqe_ptr)를 이용하며, 
         * 해제 시 커스텀 해제자를 통해 컴포넌트가 다시 풀로 반환되거나 
         * 풀에 여유공간이 없으면 delete.
         * 
         * @tparam Args 컴포넌트 생성자에 전달할 파라미터 타입
         * @param args 컴포넌트 생성자에 전달할 실제 인자
         * @return 커스텀 해제자가 설정된 unique_ptr을 반환, 
         * 해제 시 풀로 반환(또는 삭제).
         */
        template <typename... Args>
        inline std::unique_ptr<Component,
            std::function<void(Component*)>> Acquire(Args&&... args)
        {
            T* component;

            if (pool.empty())
            {
                // 풀에 여유 컴포넌트가 없으므로 새로운 컴포넌트 할당
                component = new T(std::forward<Args>(args)...);
            }
            else
            {
                // 기존 컴포넌트를 재사용
                component = pool.top();
                pool.pop();

                // 새 인자로 재초기화
                *component = T(std::forward<Args>(args)...);
            }

            // 커스텀 해제자 정의: unique_ptr이 해제될 때 호출됨
            auto  [MASK]  = [this](Component* ptr)
            {
                this->Release(static_cast<T*>(ptr));
            };

            return std::unique_ptr<Component,
                std::function<void(Component*)>>(component,  [MASK] );
        }

    private:
        /**
         * @brief 풀로 재사용할 컴포넌트를 저장하는 스택
         * 
         * 재사용 가능한 컴포넌트는 여기서 관리되며, 
         * Acquire 시 스택에서 꺼내 사용하거나,
         * 커스텀 해제자를 통해 다시 스택으로 반환.
         */
        std::stack<T*> pool;

        /**
         * @brief 커스텀 해제자 로직
         * 
         * 컴포넌트 사용이 끝나면 이 함수가 호출되어 컴포넌트를 다시 풀에 반환하거나,
         * 풀이 가득 차 있을 경우 delete.
         * 
         * @param component 반환할 컴포넌트 포인터
         */
        inline void Release(T* component)
        {
            if (component)
            {
                if (pool.size() < MAX_SIZE)
                    pool.push(component);
                else
                    delete component;
            }
        }
    };
}
",deleter
607,"#include <Time.h>
#include <Wire.h>
#include <DS1307RTC.h>
#include <dht.h>

// Pin Definitions
#define DHT22_PIN1 2
#define DHT22_PIN2 3
#define readmoistd1 37
#define readmoistd2 36
#define VALVE 44
#define L1 42
#define L2 43
#define L3 45
#define stepm 4
#define dirm 35

const int FAN_PINS[] = {41, 40, 39, 38};
const int MOISTURE_PINS[] = {readmoistd1, readmoistd2};
const int LDR_PINS[] = {A0, A1};
const int MOISTURE_ANALOG_PINS[] = {A2, A3};

// Variables
float hum[2];
float temp[2];
int delay_1 = 10;
int delay_2 = 1000;
int margin_3 = 100;
int margin_4 = 10;

void setup() {
  Serial.begin(9600);
  pinMode(stepm, OUTPUT);
  pinMode(dirm, OUTPUT);

  for (int i = 0; i < sizeof(FAN_PINS) / sizeof(FAN_PINS[0]); i++) {
    pinMode(FAN_PINS[i], OUTPUT);
  }

  pinMode(VALVE, OUTPUT);
  pinMode(L1, OUTPUT);
  pinMode(L2, OUTPUT);
  pinMode(L3, OUTPUT);
}

void loop() {
  int h = hour();
  int chk1 = DHT.read22(DHT22_PIN1);
  hum[0] = DHT.humidity;
  temp[0] = DHT.temperature;

  int chk2 = DHT.read22(DHT22_PIN2);
  hum[1] = DHT.humidity;
  temp[1] = DHT.temperature;

  for (int i = 0; i < sizeof(LDR_PINS) / sizeof(LDR_PINS[0]); i++) {
    int sensorValue = analogRead(LDR_PINS[i]);
    float sensorVoltage = sensorValue * (5.0 / 1024.0);
    float resistance = (sensorVoltage * 5000.0) / (5.0 - sensorVoltage);

    if ((h >= 6 && h < 11) || (h >= 17 && h < 22)) {
      controlLights(h, resistance, resistance, L1 + i);
    }

    if (h >= 6 && h < 11) {
      ValveOn(h, MOISTURE_ANALOG_PINS[i]);
    }

    if (h >= 11 && h < 16 && (temp[0] >= 30 || temp[1] >= 30)) {
      OnFanLines();
      MoveStepper1();
      OffFanLines();
    } else {
      OnFanLines();
      MoveStepper2();
      OffFanLines();
    }
  }

  printValues();
  delay(5000);
}

void controlLights(int hour, float resistance1, float  [MASK] , int pin) {
  if ((hour >= 17 && hour < 19) || (hour < 17 && (resistance1 > 400 ||  [MASK]  > 400))) {
    digitalWrite(pin, HIGH);
  } else {
    digitalWrite(pin, LOW);
  }
}

void ValveOn(int hour, int analogPin) {
  if ((hour == 6 || hour == 17) && analogRead(analogPin) >= 570) {
    digitalWrite(VALVE, HIGH);
  } else {
    digitalWrite(VALVE, LOW);
  }
}

void MoveStepper1() {
  digitalWrite(dirm, HIGH);
  for (int x = 0; x < margin_4; x++) {
    for (int x = 0; x < margin_3; x++) {
      digitalWrite(stepm, HIGH);
      delayMicroseconds(delay_1);
      digitalWrite(stepm, LOW);
      delayMicroseconds(delay_1);
    }
  }
}

void MoveStepper2() {
  digitalWrite(dirm, LOW);
  for (int x = 0; x < margin_4; x++) {
    for (int x = 0; x < margin_3; x++) {
      digitalWrite(stepm, HIGH);
      delayMicroseconds(delay_1);
      digitalWrite(stepm, LOW);
      delayMicroseconds(delay_1);
    }
  }
}

void OnFanLines() {
  for (int i = 0; i < sizeof(FAN_PINS) / sizeof(FAN_PINS[0]); i++) {
    digitalWrite(FAN_PINS[i], HIGH);
  }
}

void OffFanLines() {
  for (int i = 0; i < sizeof(FAN_PINS) / sizeof(FAN_PINS[0]); i++) {
    digitalWrite(FAN_PINS[i], LOW);
  }
}

void printValues() {
  Serial.print(hum[0]);
  Serial.print(""\t"");
  Serial.print(temp[0]);
  Serial.print(""\t"");
  Serial.print(hum[1]);
  Serial.print(""\t"");
  Serial.print(temp[1]);
  Serial.print(""\t"");

  for (int i = 0; i < sizeof(LDR_PINS) / sizeof(LDR_PINS[0]); i++) {
    int sensorValue = analogRead(LDR_PINS[i]);
    float sensorVoltage = sensorValue * (5.0 / 1024.0);
    float resistance = (sensorVoltage * 5000.0) / (5.0 - sensorVoltage);
    Serial.print(sensorVoltage);
    Serial.print(""\t"");
    Serial.print(resistance);
    Serial.print(""\t"");
  }

  for (int i = 0; i < sizeof(MOISTURE_ANALOG_PINS) / sizeof(MOISTURE_ANALOG_PINS[0]); i++) {
    Serial.print(analogRead(MOISTURE_ANALOG_PINS[i]));
    Serial.print(""\t"");
    Serial.print(digitalRead(MOISTURE_PINS[i]));
    Serial.print(""\t"");
  }
  
  Serial.println();
}
",resistance2
608,"#include ""arc_hybrid_planner/hybrid_planning_interface.hpp""

HybridPlanningInterface::HybridPlanningInterface(const rclcpp::Node::SharedPtr& node)
: m_node(node), m_planning_group(""ur_manipulator"")
{	
	std::string hybrid_planning_action_name = """";
	if (m_node->has_parameter(""hybrid_planning_action_name""))
	{
		m_node->get_parameter<std::string>(""hybrid_planning_action_name"", hybrid_planning_action_name);
	}
	else
	{
		RCLCPP_ERROR(LOGGER, ""hybrid_planning_action_name parameter was not defined"");
		std::exit(EXIT_FAILURE);
	}
	m_hp_action_client = rclcpp_action::create_client<moveit_msgs::action::HybridPlanner>(m_node, hybrid_planning_action_name);

	m_target_pose_service = m_node->create_service<arc_interfaces::srv::ArcTargetPose>(""/arc_planning_interface/move_to_target_pose"", 
        std::bind(&HybridPlanningInterface::target_pose_service_callback, this, std::placeholders::_1, std::placeholders::_2));

    m_cancel_all_goal_service = m_node->create_service<std_srvs::srv::Trigger>(""/arc_planning_interface/cancel_all_goals"", 
        std::bind(&HybridPlanningInterface::cancel_all_goal_service_callback, this, std::placeholders::_1, std::placeholders::_2));

    m_hp_comm_publisher = m_node->create_publisher<arc_interfaces::msg::ArcHPComm>(""/arc_planning_interface/hp_comm"", 1);
}

void HybridPlanningInterface::init()
{
    if (!m_hp_action_client->wait_for_action_server(20s))
    {
        RCLCPP_ERROR(LOGGER, ""Hybrid planning action server not available after waiting"");
        return;
    }

    robot_model_loader::RobotModelLoader robot_model_loader(m_node, ""robot_description"");
    const moveit::core::RobotModelPtr& robot_model = robot_model_loader.getModel();

    // Create a RobotState and JointModelGroup
    m_robot_state = std::make_shared<moveit::core::RobotState>(robot_model);
    const moveit::core::JointModelGroup* joint_model_group = m_robot_state->getJointModelGroup(m_planning_group);

    // Configure a valid robot state
    m_robot_state->setToDefaultValues(joint_model_group, ""ready"");
    m_robot_state->update();
}


bool HybridPlanningInterface::move(const geometry_msgs::msg::PoseStamped& target_pose)
{
	moveit_msgs::msg::MotionPlanRequest goal_motion_request = createMotionPlanRequest();
    goal_motion_request.goal_constraints.push_back(createPoseGoal(target_pose));
    
    moveit_msgs::msg::MotionSequenceRequest sequence_request = createSequenceRequest(goal_motion_request);
    auto goal_action_request = moveit_msgs::action::HybridPlanner::Goal();
    goal_action_request.planning_group = m_planning_group;
    goal_action_request.motion_sequence = sequence_request;

    goal_motion_request.max_acceleration_scaling_factor = 0.01;
    goal_motion_request.max_velocity_scaling_factor = 0.01;

    goal_motion_request.max_cartesian_speed = 0.1;
    
    auto send_goal_options = createGoalOptions();
    RCLCPP_INFO(LOGGER, ""Sending hybrid planning goal"");
    auto goal_handle_future = m_hp_action_client->async_send_goal(goal_action_request, send_goal_options);
    return true;
}

bool HybridPlanningInterface::move_blocking(const geometry_msgs::msg::PoseStamped& target_pose)
{
	moveit_msgs::msg::MotionPlanRequest goal_motion_request = createMotionPlanRequest();
    goal_motion_request.goal_constraints.push_back(createPoseGoal(target_pose));
    
    moveit_msgs::msg::MotionSequenceRequest sequence_request = createSequenceRequest(goal_motion_request);
    auto goal_action_request = moveit_msgs::action::HybridPlanner::Goal();
    goal_action_request.planning_group = m_planning_group;
    goal_action_request.motion_sequence = sequence_request;

    goal_motion_request.max_acceleration_scaling_factor = 0.01;
    goal_motion_request.max_velocity_scaling_factor = 0.01;

    // reduce speed
    goal_motion_request.max_cartesian_speed = 0.1;
    
    auto send_goal_options = createGoalOptions();
    RCLCPP_INFO(LOGGER, ""Sending hybrid planning goal"");
    auto goal_handle_future = m_hp_action_client->async_send_goal(goal_action_request, send_goal_options);

    return true;
}


moveit_msgs::msg::MotionPlanRequest HybridPlanningInterface::createMotionPlanRequest() 
{
    moveit_msgs::msg::MotionPlanRequest request;
    moveit::core::robotStateToRobotStateMsg(*m_robot_state, request.start_state);
    request.group_name = m_planning_group;
    request.num_planning_attempts = 100;
    request.max_velocity_scaling_factor = 0.1;
    request.max_acceleration_scaling_factor = 0.1;
    request.allowed_planning_time = 2.0;
    request.planner_id = ""ompl"";
    request.pipeline_id = ""ompl"";
    return request;
}

moveit_msgs::msg::Constraints HybridPlanningInterface::createPoseGoal(const geometry_msgs::msg::PoseStamped& target_pose) 
{
    std::vector<double> tolerance_pose(3, 0.01);
    std::vector<double>  [MASK] (3, 0.01);
    return kinematic_constraints::constructGoalConstraints(""tool0"", target_pose, tolerance_pose,  [MASK] );
}

moveit_msgs::msg::MotionSequenceRequest HybridPlanningInterface::createSequenceRequest(const moveit_msgs::msg::MotionPlanRequest& goal_motion_request) {
    moveit_msgs::msg::MotionSequenceItem sequence_item;
    sequence_item.req = goal_motion_request;
    sequence_item.blend_radius = 0.0;
    moveit_msgs::msg::MotionSequenceRequest sequence_request;
    sequence_request.items.push_back(sequence_item);
    return sequence_request;
}

void HybridPlanningInterface::hp_action_result_callback(const rclcpp_action::ClientGoalHandle<moveit_msgs::action::HybridPlanner>::WrappedResult& result) {
    arc_interfaces::msg::ArcHPComm hp_comm_msg;
    switch (result.code)
    {
        case rclcpp_action::ResultCode::SUCCEEDED:
            RCLCPP_INFO(LOGGER, ""Hybrid planning goal succeeded"");
            is_planning_success = 1;
            hp_comm_msg.status = 1; // 1 for success, 0 for failure
            hp_comm_msg.message = ""Hybrid planning goal succeeded"";
            hp_comm_msg.time_stamp = m_node->now();
            m_hp_comm_publisher->publish(hp_comm_msg);
            break;
        case rclcpp_action::ResultCode::ABORTED:
            RCLCPP_ERROR(LOGGER, ""Hybrid planning goal was aborted"");
            is_planning_success = -1; // -1 for failure 1 for success 0 for not started
            hp_comm_msg.status = 0; // 1 for success, 0 for failure
            hp_comm_msg.message = ""Hybrid planning goal aborted"";
            hp_comm_msg.time_stamp = m_node->now();
            m_hp_comm_publisher->publish(hp_comm_msg);
            return;
        case rclcpp_action::ResultCode::CANCELED:
            RCLCPP_ERROR(LOGGER, ""Hybrid planning goal was canceled"");
            return;
        case rclcpp_action::ResultCode::UNKNOWN:
            RCLCPP_ERROR(LOGGER, ""Hybrid planning goal failed"");
            return;
        default:
            RCLCPP_ERROR(LOGGER, ""Unknown hybrid planning result code"");
            return;
    }
    RCLCPP_INFO(LOGGER, ""Hybrid planning result received"");
}

rclcpp_action::Client<moveit_msgs::action::HybridPlanner>::SendGoalOptions HybridPlanningInterface::createGoalOptions() {
    auto options = rclcpp_action::Client<moveit_msgs::action::HybridPlanner>::SendGoalOptions();
    options.result_callback = std::bind(&HybridPlanningInterface::hp_action_result_callback, this, std::placeholders::_1);
    options.feedback_callback =
				[](rclcpp_action::ClientGoalHandle<moveit_msgs::action::HybridPlanner>::SharedPtr /*unused*/,
					const std::shared_ptr<const moveit_msgs::action::HybridPlanner::Feedback> feedback) {
					//RCLCPP_INFO(LOGGER, ""Hybrid planning feedback received"");
					//RCLCPP_INFO(LOGGER, feedback->feedback.c_str());
				};

    return options;
}

geometry_msgs::msg::PoseStamped HybridPlanningInterface::get_pose(float x, float y, float z)
{
	geometry_msgs::msg::PoseStamped target_pose;
	target_pose.header.frame_id = ""world"";
	target_pose.pose.position.x = x;
	target_pose.pose.position.y = y;
	target_pose.pose.position.z = z;
	target_pose.pose.orientation.x = 1.0;
	target_pose.pose.orientation.y = 0.0;
	target_pose.pose.orientation.z = 0.0;
	target_pose.pose.orientation.w = 0.0;

	return target_pose;
}

void HybridPlanningInterface::target_pose_service_callback(
    const std::shared_ptr<arc_interfaces::srv::ArcTargetPose::Request> request,
    std::shared_ptr<arc_interfaces::srv::ArcTargetPose::Response> response)
{   
    RCLCPP_INFO(LOGGER, ""Received target pose request"");
    geometry_msgs::msg::PoseStamped target_pose;
    target_pose.pose = request->pose;
    // Assuming ""world"" as the frame of reference. Modify if needed.
    target_pose.header.frame_id = ""world"";

    response->success = move(target_pose);
}

void HybridPlanningInterface::cancel_all_goal_service_callback(
    const std::shared_ptr<std_srvs::srv::Trigger::Request> request,
    std::shared_ptr<std_srvs::srv::Trigger::Response> response)
{
    RCLCPP_INFO(LOGGER, ""Received cancel all goal request"");
    m_hp_action_client->async_cancel_all_goals();
    response->success = true;
}

void HybridPlanningInterface::run()
{
	try {
		while (true) {
			auto target_pose = get_pose(0.17, 0.5, 0.3);
			move(target_pose);
			rclcpp::sleep_for(2s);
			target_pose = get_pose(-0.4, 0.5, 0.3);
			move(target_pose);
            rclcpp::sleep_for(2s);
		}
	} catch (const std::exception& e) {
		RCLCPP_ERROR(LOGGER, ""Exception thrown: %s"", e.what());
	}
}
",tolerance_angle
609,"#include ""AimbotMelee.h""

#include ""../Aimbot.h""
#include ""../../Simulation/MovementSimulation/MovementSimulation.h""
#include ""../../Ticks/Ticks.h""
#include ""../../Visuals/Visuals.h""
#include <unordered_set>
#include <algorithm>

std::vector<Target_t> CAimbotMelee::GetTargets(CTFPlayer* pLocal, CTFWeaponBase* pWeapon)
{
	std::vector<Target_t> vTargets;

	const Vec3 vLocalPos = F::Ticks.GetShootPos();
	const Vec3 vLocalAngles = I::EngineClient->GetViewAngles();

	if (Vars::Aimbot::General::Target.Value & Vars::Aimbot::General::TargetEnum::Players)
	{
		bool bDisciplinary = Vars::Aimbot::Melee::WhipTeam.Value && SDK::AttribHookValue(0, ""speed_buff_ally"", pWeapon) > 0;
		for (auto pEntity : H::Entities.GetGroup(bDisciplinary ? EGroupType::PLAYERS_ALL : EGroupType::PLAYERS_ENEMIES))
		{
			bool bTeammate = pEntity->m_iTeamNum() == pLocal->m_iTeamNum();
			if (F::AimbotGlobal.ShouldIgnore(pEntity, pLocal, pWeapon))
				continue;

			float flFOVTo; Vec3 vPos, vAngleTo;
			if (!F::AimbotGlobal.PlayerBoneInFOV(pEntity->As<CTFPlayer>(), vLocalPos, vLocalAngles, flFOVTo, vPos, vAngleTo))
				continue;

			float flDistTo = vLocalPos.DistTo(vPos);
			vTargets.emplace_back(pEntity, TargetEnum::Player, vPos, vAngleTo, flFOVTo, flDistTo, bTeammate ? 0 : F::AimbotGlobal.GetPriority(pEntity->entindex()));
		}
	}

	if (Vars::Aimbot::General::Target.Value)
	{
		bool bWrench = pWeapon->GetWeaponID() == TF_WEAPON_WRENCH;
		bool bDestroySapper = pWeapon->GetWeaponID() == TF_WEAPON_FIREAXE && SDK::AttribHookValue(0, ""set_dmg_apply_to_sapper"", pWeapon);

		for (auto pEntity : H::Entities.GetGroup(bWrench || bDestroySapper ? EGroupType::BUILDINGS_ALL : EGroupType::BUILDINGS_ENEMIES))
		{
			if (F::AimbotGlobal.ShouldIgnore(pEntity, pLocal, pWeapon))
				continue;

			if (pEntity->m_iTeamNum() == pLocal->m_iTeamNum() && (bWrench && !AimFriendlyBuilding(pEntity->As<CBaseObject>()) || bDestroySapper && !pEntity->As<CBaseObject>()->m_bHasSapper()))
				continue;

			Vec3 vPos = pEntity->GetCenter();
			Vec3 vAngleTo = Math::CalcAngle(vLocalPos, vPos);
			float flFOVTo = Math::CalcFov(vLocalAngles, vAngleTo);
			if (flFOVTo > Vars::Aimbot::General::AimFOV.Value)
				continue;

			float flDistTo = vLocalPos.DistTo(vPos);
			vTargets.emplace_back(pEntity, pEntity->IsSentrygun() ? TargetEnum::Sentry : pEntity->IsDispenser() ? TargetEnum::Dispenser : TargetEnum::Teleporter, vPos, vAngleTo, flFOVTo, flDistTo);
		}
	}

	if (Vars::Aimbot::General::Target.Value & Vars::Aimbot::General::TargetEnum::NPCs)
	{
		for (auto pEntity : H::Entities.GetGroup(EGroupType::WORLD_NPC))
		{
			if (F::AimbotGlobal.ShouldIgnore(pEntity, pLocal, pWeapon))
				continue;

			Vec3 vPos = pEntity->GetCenter();
			Vec3 vAngleTo = Math::CalcAngle(vLocalPos, vPos);
			float flFOVTo = Math::CalcFov(vLocalAngles, vAngleTo);
			if (flFOVTo > Vars::Aimbot::General::AimFOV.Value)
				continue;

			float flDistTo = vLocalPos.DistTo(vPos);
			vTargets.emplace_back(pEntity, TargetEnum::NPC, vPos, vAngleTo, flFOVTo, flDistTo);
		}
	}

	return vTargets;
}

bool CAimbotMelee::AimFriendlyBuilding(CBaseObject* pBuilding)
{
	if (!pBuilding->m_bMiniBuilding() && pBuilding->m_iUpgradeLevel() != 3 || pBuilding->m_iHealth() < pBuilding->m_iMaxHealth() || pBuilding->m_bHasSapper())
		return true;

	if (pBuilding->IsSentrygun())
	{
		int iShells, iMaxShells, iRockets, iMaxRockets; pBuilding->As<CObjectSentrygun>()->GetAmmoCount(iShells, iMaxShells, iRockets, iMaxRockets);
		if (iShells < iMaxShells || iRockets < iMaxRockets)
			return true;
	}

	return false;
}

std::vector<Target_t> CAimbotMelee::SortTargets(CTFPlayer* pLocal, CTFWeaponBase* pWeapon)
{
	auto vTargets = GetTargets(pLocal, pWeapon);

	F::AimbotGlobal.SortTargets(vTargets, Vars::Aimbot::General::TargetSelectionEnum::Distance);
	vTargets.resize(std::min(size_t(Vars::Aimbot::General::MaxTargets.Value), vTargets.size()));
	F::AimbotGlobal.SortPriority(vTargets);
	return vTargets;
}



int CAimbotMelee::GetSwingTime(CTFWeaponBase* pWeapon)
{
	if (pWeapon->GetWeaponID() == TF_WEAPON_KNIFE)
		return 0;
	return Vars::Aimbot::Melee::SwingTicks.Value;
}

void CAimbotMelee::SimulatePlayers(CTFPlayer* pLocal, CTFWeaponBase* pWeapon, std::vector<Target_t> vTargets, Vec3& vEyePos)
{
	// swing prediction / auto warp
	const int iSwingTicks = GetSwingTime(pWeapon);
	int iMax = (m_iDoubletapTicks && Vars::Doubletap::AntiWarp.Value && pLocal->m_hGroundEntity())
		? std::max(iSwingTicks - Vars::Doubletap::TickLimit.Value - 1, 0)
		: std::max(iSwingTicks, m_iDoubletapTicks);

	if ((Vars::Aimbot::Melee::SwingPrediction.Value || m_iDoubletapTicks) && pWeapon->m_flSmackTime() < 0.f && iMax)
	{
		PlayerStorage tStorage;
		std::unordered_map<int, PlayerStorage> mStorage;

		F::MoveSim.Initialize(pLocal, tStorage, false, !m_iDoubletapTicks);
		for (auto& tTarget : vTargets)
			F::MoveSim.Initialize(tTarget.m_pEntity, mStorage[tTarget.m_pEntity->entindex()], false);

		for (int i = 0; i < iMax; i++) // intended for plocal to collide with targets
		{
			if (i < iMax)
			{
				if (pLocal->InCond(TF_COND_SHIELD_CHARGE) && iMax - i <= GetSwingTime(pWeapon)) // demo charge fix for swing pred
					tStorage.m_MoveData.m_flMaxSpeed = tStorage.m_MoveData.m_flClientMaxSpeed = SDK::MaxSpeed(pLocal, false, true);
				F::MoveSim.RunTick(tStorage);
			}
			if (i < iSwingTicks - m_iDoubletapTicks)
			{
				for (auto& tTarget : vTargets)
				{
					auto& tStorage = mStorage[tTarget.m_pEntity->entindex()];

					F::MoveSim.RunTick(tStorage);
					if (!tStorage.m_bFailed)
						m_mRecordMap[tTarget.m_pEntity->entindex()].emplace_front(
							!Vars::Aimbot::Melee::SwingPredictLag.Value || tStorage.m_bPredictNetworked ? tTarget.m_pEntity->m_flSimulationTime() + TICKS_TO_TIME(i + 1) : 0.f,
							Vars::Aimbot::Melee::SwingPredictLag.Value ? tStorage.m_vPredictedOrigin : tStorage.m_MoveData.m_vecAbsOrigin,
							tTarget.m_pEntity->m_vecMins(), tTarget.m_pEntity->m_vecMaxs()
						);
				}
			}
		}
		vEyePos = tStorage.m_MoveData.m_vecAbsOrigin + pLocal->m_vecViewOffset();

		if (Vars::Visuals::Simulation::SwingLines.Value && Vars::Visuals::Simulation::PlayerPath.Value)
		{
			const bool bAlwaysDraw = !Vars::Aimbot::General::AutoShoot.Value || Vars::Debug::Info.Value;
			if (!bAlwaysDraw)
			{
				m_mPaths[pLocal->entindex()] = tStorage.m_vPath;
				for (auto& tTarget : vTargets)
					m_mPaths[tTarget.m_pEntity->entindex()] = mStorage[tTarget.m_pEntity->entindex()].m_vPath;
			}
			else
			{
				G::LineStorage.clear();
				G::BoxStorage.clear();
				G::PathStorage.clear();

				if (Vars::Colors::PlayerPathIgnoreZ.Value.a)
				{
					G::PathStorage.emplace_back(tStorage.m_vPath, I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPathIgnoreZ.Value, Vars::Visuals::Simulation::PlayerPath.Value);
					for (auto& tTarget : vTargets)
						G::PathStorage.emplace_back(mStorage[tTarget.m_pEntity->entindex()].m_vPath, I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPathIgnoreZ.Value, Vars::Visuals::Simulation::PlayerPath.Value);
				}
				if (Vars::Colors::PlayerPath.Value.a)
				{
					G::PathStorage.emplace_back(tStorage.m_vPath, I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPath.Value, Vars::Visuals::Simulation::PlayerPath.Value, true);
					for (auto& tTarget : vTargets)
						G::PathStorage.emplace_back(mStorage[tTarget.m_pEntity->entindex()].m_vPath, I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPath.Value, Vars::Visuals::Simulation::PlayerPath.Value, true);
				}
			}
		}

		F::MoveSim.Restore(tStorage);
		for (auto& tTarget : vTargets)
			F::MoveSim.Restore(mStorage[tTarget.m_pEntity->entindex()]);
	}
}

bool CAimbotMelee::CanBackstab(CBaseEntity* pTarget, CTFPlayer* pLocal, Vec3 vEyeAngles)
{
	if (!pLocal || !pTarget)
		return false;

	if (Vars::Aimbot::Melee::IgnoreRazorback.Value)
	{
		CUtlVector<CBaseEntity*> itemList;
		int iBackstabShield = SDK::AttribHookValue(0, ""set_blockbackstab_once"", pTarget, &itemList);
		if (iBackstabShield && itemList.Count())
		{
			CBaseEntity* pEntity = itemList.Element(0);
			if (pEntity && pEntity->ShouldDraw())
				return false;
		}
	}

	Vec3 vToTarget = (pTarget->GetAbsOrigin() - pLocal->m_vecOrigin()).To2D();
	const float flDist = vToTarget.Normalize();
	if (!flDist)
		return false;

	float flTolerance = 0.0625f;
	float flExtra = 2.f * flTolerance / flDist; // account for origin compression

	float flPosVsTargetViewMinDot = 0.f + 0.0031f + flExtra;
	float flPosVsOwnerViewMinDot = 0.5f + flExtra;
	float flViewAnglesMinDot = -0.3f + 0.0031f; // 0.00306795676297 ?

	auto TestDots = [&](Vec3 vTargetAngles)
		{
			Vec3 vOwnerForward; Math::AngleVectors(vEyeAngles, &vOwnerForward);
			vOwnerForward.Normalize2D();

			Vec3 vTargetForward; Math::AngleVectors(vTargetAngles, &vTargetForward);
			vTargetForward.Normalize2D();

			const float flPosVsTargetViewDot = vToTarget.Dot(vTargetForward); // Behind?
			const float flPosVsOwnerViewDot = vToTarget.Dot(vOwnerForward); // Facing?
			const float flViewAnglesDot = vTargetForward.Dot(vOwnerForward); // Facestab?

			return flPosVsTargetViewDot > flPosVsTargetViewMinDot && flPosVsOwnerViewDot > flPosVsOwnerViewMinDot && flViewAnglesDot > flViewAnglesMinDot;
		};

	Vec3 vTargetAngles = { 0.f, H::Entities.GetEyeAngles(pTarget->entindex()).y, 0.f };
	if (!Vars::Aimbot::Melee::BackstabAccountPing.Value)
	{
		if (!TestDots(vTargetAngles))
			return false;
	}
	else
	{
		if (Vars::Aimbot::Melee::BackstabDoubleTest.Value && !TestDots(vTargetAngles))
			return false;

		vTargetAngles.y += H::Entities.GetPingAngles(pTarget->entindex()).y;
		if (!TestDots(vTargetAngles))
			return false;
	}

	return true;
}

int CAimbotMelee::CanHit(Target_t& tTarget, CTFPlayer* pLocal, CTFWeaponBase* pWeapon, Vec3 vEyePos)
{
	if (Vars::Aimbot::General::Ignore.Value & Vars::Aimbot::General::IgnoreEnum::Unsimulated && H::Entities.GetChoke(tTarget.m_pEntity->entindex()) > Vars::Aimbot::General::TickTolerance.Value)
		return false;

	float flRange = SDK::AttribHookValue(pWeapon->GetSwingRange(), ""melee_range_multiplier"", pWeapon);
	float flHull = SDK::AttribHookValue(18, ""melee_bounds_multiplier"", pWeapon);
	if (pLocal->m_flModelScale() > 1.0f)
	{
		flRange *= pLocal->m_flModelScale();
		flHull *= pLocal->m_flModelScale();
	}
	Vec3 vSwingMins = { -flHull, -flHull, -flHull };
	Vec3 vSwingMaxs = { flHull, flHull, flHull };
	auto& vSimRecords = m_mRecordMap[tTarget.m_pEntity->entindex()];

	std::vector<TickRecord*> vRecords = {};
	if (F::Backtrack.GetRecords(tTarget.m_pEntity, vRecords))
	{
		if (!vRecords.empty())
		{
			for (auto& tRecord : vSimRecords)
				vRecords.push_back(&tRecord);
			vRecords = F::Backtrack.GetValidRecords(vRecords, pLocal, true, -TICKS_TO_TIME(vSimRecords.size()));
		}
		if (vRecords.empty())
			return false;
	}
	else
	{
		matrix3x4 aBones[MAXSTUDIOBONES];
		if (!tTarget.m_pEntity->SetupBones(aBones, MAXSTUDIOBONES, BONE_USED_BY_ANYTHING, tTarget.m_pEntity->m_flSimulationTime()))
			return false;

		F::Backtrack.m_tRecord = { tTarget.m_pEntity->m_flSimulationTime(), tTarget.m_pEntity->m_vecOrigin(), tTarget.m_pEntity->m_vecMins(), tTarget.m_pEntity->m_vecMaxs(), *reinterpret_cast<BoneMatrix*>(&aBones) };
		vRecords = { &F::Backtrack.m_tRecord };
	}

	CGameTrace trace = {};
	CTraceFilterHitscan filter = {}; filter.pSkip = pLocal;
	for (auto pRecord : vRecords)
	{
		Vec3 vRestoreOrigin = tTarget.m_pEntity->GetAbsOrigin();
		Vec3 vRestoreMins = tTarget.m_pEntity->m_vecMins();
		Vec3 vRestoreMaxs = tTarget.m_pEntity->m_vecMaxs();

		tTarget.m_pEntity->SetAbsOrigin(pRecord->m_vOrigin);
		tTarget.m_pEntity->m_vecMins() = pRecord->m_vMins + 0.125f; // account for origin compression
		tTarget.m_pEntity->m_vecMaxs() = pRecord->m_vMaxs - 0.125f;

		Vec3 vDiff = { 0, 0, std::clamp(vEyePos.z - pRecord->m_vOrigin.z, tTarget.m_pEntity->m_vecMins().z, tTarget.m_pEntity->m_vecMaxs().z) };
		tTarget.m_vPos = pRecord->m_vOrigin + vDiff;
		Aim(G::CurrentUserCmd->viewangles, Math::CalcAngle(vEyePos, tTarget.m_vPos), tTarget.m_vAngleTo);

		Vec3 vForward; Math::AngleVectors(tTarget.m_vAngleTo, &vForward);
		Vec3 vTraceEnd = vEyePos + (vForward * flRange);

		SDK::TraceHull(vEyePos, vTraceEnd, {}, {}, MASK_SOLID, &filter, &trace);
		bool bReturn = trace.m_pEnt && trace.m_pEnt == tTarget.m_pEntity;
		if (!bReturn)
		{
			SDK::TraceHull(vEyePos, vTraceEnd, vSwingMins, vSwingMaxs, MASK_SOLID, &filter, &trace);
			bReturn = trace.m_pEnt && trace.m_pEnt == tTarget.m_pEntity;
		}

		if (bReturn && Vars::Aimbot::Melee::AutoBackstab.Value && pWeapon->GetWeaponID() == TF_WEAPON_KNIFE)
		{
			if (tTarget.m_iTargetType == TargetEnum::Player)
				bReturn = CanBackstab(tTarget.m_pEntity, pLocal, tTarget.m_vAngleTo);
			else
				bReturn = false;
		}

		tTarget.m_pEntity->SetAbsOrigin(vRestoreOrigin);
		tTarget.m_pEntity->m_vecMins() = vRestoreMins;
		tTarget.m_pEntity->m_vecMaxs() = vRestoreMaxs;

		if (bReturn)
		{
			tTarget.m_pRecord = pRecord;
			tTarget.m_bBacktrack = tTarget.m_iTargetType == TargetEnum::Player;

			return true;
		}
		else switch (Vars::Aimbot::General::AimType.Value)
		{
		case Vars::Aimbot::General::AimTypeEnum::Smooth:
		case Vars::Aimbot::General::AimTypeEnum::Assistive:
		{
			auto vAngle = Math::CalcAngle(vEyePos, tTarget.m_vPos);

			Vec3 vForward = Vec3(); Math::AngleVectors(vAngle, &vForward);
			Vec3 vTraceEnd = vEyePos + (vForward * flRange);

			SDK::Trace(vEyePos, vTraceEnd, MASK_SHOT | CONTENTS_GRATE, &filter, &trace);
			if (trace.m_pEnt && trace.m_pEnt == tTarget.m_pEntity)
				return 2;
		}
		}
	}

	return false;
}



bool CAimbotMelee::Aim(Vec3  [MASK] , Vec3 vToAngle, Vec3& vOut, int iMethod)
{
	if (Vec3* pDoubletapAngle = F::Ticks.GetShootAngle())
	{
		vOut = *pDoubletapAngle;
		return true;
	}

	bool bReturn = false;
	switch (iMethod)
	{
	case Vars::Aimbot::General::AimTypeEnum::Plain:
	case Vars::Aimbot::General::AimTypeEnum::Silent:
	case Vars::Aimbot::General::AimTypeEnum::Locking:
		vOut = vToAngle;
		break;
	case Vars::Aimbot::General::AimTypeEnum::Smooth:
	{
		const float flSmoothFactor = std::clamp<float>(Vars::Aimbot::General::AssistStrength.Value, 0.f, 100.f);
		if (flSmoothFactor >= 100.f)
		{
			vOut = vToAngle;
			return true;
		}

		Vec3 vDelta = vToAngle -  [MASK] ;
		Math::ClampAngles(vDelta);

		const float flSmoothDiv = Math::RemapVal(flSmoothFactor, 1.f, 100.f, 1.5f, 30.f);
		vOut =  [MASK]  + vDelta / flSmoothDiv;
		Math::ClampAngles(vOut);
		return true;
	}
	case Vars::Aimbot::General::AimTypeEnum::Assistive: 
	{
		Vec3 vMouseDelta = G::CurrentUserCmd->viewangles.DeltaAngle(G::LastUserCmd->viewangles);
		Vec3 vTargetDelta = vToAngle.DeltaAngle(G::LastUserCmd->viewangles);
		float flMouseDelta = vMouseDelta.Length2D(), flTargetDelta = vTargetDelta.Length2D();
		vTargetDelta = vTargetDelta.Normalized() * std::min(flMouseDelta, flTargetDelta);
		vOut =  [MASK]  - vMouseDelta + vMouseDelta.LerpAngle(vTargetDelta, Vars::Aimbot::General::AssistStrength.Value / 100.f);
		bReturn = true;
		break;
	}
	case Vars::Aimbot::General::AimTypeEnum::Legit: 
	{
		Vec3 vDelta = vToAngle -  [MASK] ;
		Math::ClampAngles(vDelta);
		float flDiv = 4.f;
		vOut =  [MASK]  + vDelta / flDiv;
		Math::ClampAngles(vOut);
		return true;
	}
}

	Math::ClampAngles(vOut);
	return bReturn;
}

// assume angle calculated outside with other overload
void CAimbotMelee::Aim(CUserCmd* pCmd, Vec3& vAngle, int iMethod)
{
	bool bDoubleTap = F::Ticks.m_bDoubletap || F::Ticks.GetTicks(H::Entities.GetWeapon()) || F::Ticks.m_bSpeedhack;
	switch (iMethod)
	{
	case Vars::Aimbot::General::AimTypeEnum::Plain:
		if (G::Attacking != 1 && !bDoubleTap)
			break;
		[[fallthrough]];
	case Vars::Aimbot::General::AimTypeEnum::Smooth:
	case Vars::Aimbot::General::AimTypeEnum::Assistive:
		pCmd->viewangles = vAngle;
		I::EngineClient->SetViewAngles(vAngle);
		break;
	case Vars::Aimbot::General::AimTypeEnum::Silent:
		if (G::Attacking == 1 || bDoubleTap)
		{
			SDK::FixMovement(pCmd, vAngle);
			pCmd->viewangles = vAngle;
			G::PSilentAngles = true;
		}
		break;
	case Vars::Aimbot::General::AimTypeEnum::Locking:
		SDK::FixMovement(pCmd, vAngle);
		pCmd->viewangles = vAngle;
	case Vars::Aimbot::General::AimTypeEnum::Legit:
		pCmd->viewangles = vAngle;
		I::EngineClient->SetViewAngles(vAngle);
	}
}

static inline void DrawVisuals(CTFPlayer* pLocal, CTFWeaponBase* pWeapon, CUserCmd* pCmd, Target_t& tTarget, std::unordered_map<int, std::vector<Vec3>>& mPaths)
{
	bool bPath = Vars::Visuals::Simulation::SwingLines.Value && Vars::Visuals::Simulation::PlayerPath.Value && Vars::Aimbot::General::AutoShoot.Value && !Vars::Debug::Info.Value;
	bool bLine = Vars::Visuals::Line::Enabled.Value;
	bool bBoxes = Vars::Visuals::Hitbox::BonesEnabled.Value & Vars::Visuals::Hitbox::BonesEnabledEnum::OnShot;
	if (pCmd->buttons & IN_ATTACK && G::CanPrimaryAttack && pWeapon->m_flSmackTime() < 0.f)
	{
		G::LineStorage.clear();
		G::BoxStorage.clear();
		G::PathStorage.clear();

		if (bPath)
		{
			if (Vars::Colors::PlayerPathIgnoreZ.Value.a)
			{
				G::PathStorage.emplace_back(mPaths[pLocal->entindex()], I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPathIgnoreZ.Value, Vars::Visuals::Simulation::PlayerPath.Value);
				G::PathStorage.emplace_back(mPaths[tTarget.m_pEntity->entindex()], I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPathIgnoreZ.Value, Vars::Visuals::Simulation::PlayerPath.Value);
			}
			if (Vars::Colors::PlayerPath.Value.a)
			{
				G::PathStorage.emplace_back(mPaths[pLocal->entindex()], I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPath.Value, Vars::Visuals::Simulation::PlayerPath.Value, true);
				G::PathStorage.emplace_back(mPaths[tTarget.m_pEntity->entindex()], I::GlobalVars->curtime + Vars::Visuals::Simulation::DrawDuration.Value, Vars::Colors::PlayerPath.Value, Vars::Visuals::Simulation::PlayerPath.Value, true);
			}
		}
	}
	if (G::Attacking == 1)
	{
		if (bLine)
		{
			Vec3 vEyePos = pLocal->GetShootPos();
			float flDist = vEyePos.DistTo(tTarget.m_vPos);
			Vec3 vForward; Math::AngleVectors(tTarget.m_vAngleTo, &vForward);

			if (Vars::Colors::LineIgnoreZ.Value.a)
				G::LineStorage.emplace_back(std::pair<Vec3, Vec3>(vEyePos, vEyePos + vForward * flDist), I::GlobalVars->curtime + Vars::Visuals::Line::DrawDuration.Value, Vars::Colors::LineIgnoreZ.Value);
			if (Vars::Colors::Line.Value.a)
				G::LineStorage.emplace_back(std::pair<Vec3, Vec3>(vEyePos, vEyePos + vForward * flDist), I::GlobalVars->curtime + Vars::Visuals::Line::DrawDuration.Value, Vars::Colors::Line.Value, true);
		}
		if (bBoxes)
		{
			auto vBoxes = F::Visuals.GetHitboxes(tTarget.m_pRecord->m_BoneMatrix.m_aBones, tTarget.m_pEntity->As<CBaseAnimating>());
			G::BoxStorage.insert(G::BoxStorage.end(), vBoxes.begin(), vBoxes.end());

			//if (Vars::Colors::BoneHitboxEdgeIgnoreZ.Value.a || Vars::Colors::BoneHitboxFaceIgnoreZ.Value.a)
			//	G::BoxStorage.emplace_back(tTarget.m_pRecord->m_vOrigin, tTarget.m_pRecord->m_vMins, tTarget.m_pRecord->m_vMaxs, Vec3(), I::GlobalVars->curtime + Vars::Visuals::Hitbox::DrawDuration.Value, Vars::Colors::BoneHitboxEdgeIgnoreZ.Value, Vars::Colors::BoneHitboxFaceIgnoreZ.Value);
			//if (Vars::Colors::BoneHitboxEdge.Value.a || Vars::Colors::BoneHitboxFace.Value.a)
			//	G::BoxStorage.emplace_back(tTarget.m_pRecord->m_vOrigin, tTarget.m_pRecord->m_vMins, tTarget.m_pRecord->m_vMaxs, Vec3(), I::GlobalVars->curtime + Vars::Visuals::Hitbox::DrawDuration.Value, Vars::Colors::BoneHitboxEdge.Value, Vars::Colors::BoneHitboxFace.Value, true);
		}
	}
}

void CAimbotMelee::Run(CTFPlayer* pLocal, CTFWeaponBase* pWeapon, CUserCmd* pCmd)
{
	static int iStaticAimType = Vars::Aimbot::General::AimType.Value;
	const int iLastAimType = iStaticAimType;
	const int iRealAimType = Vars::Aimbot::General::AimType.Value;

	if (pWeapon->m_flSmackTime() > 0.f && !iRealAimType && iLastAimType)
		Vars::Aimbot::General::AimType.Value = iLastAimType;
	iStaticAimType = Vars::Aimbot::General::AimType.Value;

	if (F::AimbotGlobal.ShouldHoldAttack(pWeapon))
		pCmd->buttons |= IN_ATTACK;
	if (!Vars::Aimbot::General::AimType.Value
		|| !F::AimbotGlobal.ShouldAim() && pWeapon->m_flSmackTime() < 0.f)
		return;

	m_mRecordMap.clear(); m_mPaths.clear();
	m_iDoubletapTicks = F::Ticks.GetTicks(pWeapon);
	if (AutoEngie(pLocal, pWeapon, pCmd))
		return;

	if (RunSapper(pLocal, pWeapon, pCmd))
		return;

	auto vTargets = SortTargets(pLocal, pWeapon);
	if (vTargets.empty())
		return;

	const bool bShouldSwing = m_iDoubletapTicks <= (GetSwingTime(pWeapon) ? 14 : 0) || Vars::Doubletap::AntiWarp.Value && pLocal->m_hGroundEntity();
	Vec3 vEyePos = pLocal->GetShootPos();

	SimulatePlayers(pLocal, pWeapon, vTargets, vEyePos);

	//if (!G::AimTarget.m_iEntIndex)
	//	G::AimTarget = { vTargets.front().m_pEntity->entindex(), I::GlobalVars->tickcount, 0 };

	for (auto& tTarget : vTargets)
	{
		const auto iResult = CanHit(tTarget, pLocal, pWeapon, vEyePos);
		if (!iResult) continue;
		if (iResult == 2)
		{
			G::AimTarget = { tTarget.m_pEntity->entindex(), I::GlobalVars->tickcount, 0 };
			Aim(pCmd, tTarget.m_vAngleTo);
			break;
		}

		G::AimTarget = { tTarget.m_pEntity->entindex(), I::GlobalVars->tickcount };
		G::AimPoint = { tTarget.m_vPos, I::GlobalVars->tickcount };

		if (Vars::Aimbot::General::AutoShoot.Value && pWeapon->m_flSmackTime() < 0.f)
		{
			if (bShouldSwing)
				pCmd->buttons |= IN_ATTACK;
			if (m_iDoubletapTicks)
				F::Ticks.m_bDoubletap = true;
		}

		G::Attacking = SDK::IsAttacking(pLocal, pWeapon, pCmd, true);
		if (G::Attacking == 1)
		{
			if (tTarget.m_bBacktrack)
				pCmd->tick_count = TIME_TO_TICKS(tTarget.m_pRecord->m_flSimTime + F::Backtrack.GetFakeInterp());
			// bug: fast old records seem to be progressively more unreliable ?
		}
		else
		{
			vEyePos = pLocal->GetShootPos();
			Aim(G::CurrentUserCmd->viewangles, Math::CalcAngle(vEyePos, tTarget.m_vPos), tTarget.m_vAngleTo);
		}
		DrawVisuals(pLocal, pWeapon, pCmd, tTarget, m_mPaths);

		Aim(pCmd, tTarget.m_vAngleTo);
		break;
	}
}

static inline int GetAttachment(CBaseObject* pBuilding, int i)
{
	int iAttachment = pBuilding->GetBuildPointAttachmentIndex(i);
	if (pBuilding->IsSentrygun() && pBuilding->m_iUpgradeLevel() > 1) // idk why i need this
		iAttachment = 3;
	return iAttachment;
}

bool CAimbotMelee::FindNearestBuildPoint(CBaseObject* pBuilding, CTFPlayer* pLocal, Vec3& vPoint)
{
	bool bFoundPoint = false;

	Vec3 vEyePos = pLocal->GetShootPos();
	static auto tf_obj_max_attach_dist = U::ConVars.FindVar(""tf_obj_max_attach_dist"");
	float flNearestPoint = tf_obj_max_attach_dist->GetFloat();

	for (int i = 0; i < pBuilding->GetNumBuildPoints(); i++)
	{
		int v = GetAttachment(pBuilding, i);

		Vec3 vOrigin;
		if (pBuilding->GetAttachment(v, vOrigin)) // issues using pBuilding->GetBuildPoint i on sentries above level 1 for some reason
		{
			if (!SDK::VisPos(pLocal, pBuilding, vEyePos, vOrigin))
				continue;

			float flDist = (vOrigin - pLocal->m_vecOrigin()).Length();
			if (flDist < flNearestPoint)
			{
				flNearestPoint = flDist;
				vPoint = vOrigin;
				bFoundPoint = true;
			}
		}
	}

	return bFoundPoint;
}

bool CAimbotMelee::RunSapper(CTFPlayer* pLocal, CTFWeaponBase* pWeapon, CUserCmd* pCmd)
{
	if (pWeapon->GetWeaponID() != TF_WEAPON_BUILDER)
		return false;

	const Vec3 vLocalPos = pLocal->GetShootPos();
	const Vec3 vLocalAngles = I::EngineClient->GetViewAngles();

	std::vector<Target_t> vTargets;
	for (auto pEntity : H::Entities.GetGroup(EGroupType::BUILDINGS_ENEMIES))
	{
		auto pBuilding = pEntity->As<CBaseObject>();
		if (pBuilding->m_bHasSapper() || !pBuilding->IsInValidTeam())
			continue;

		Vec3 vPoint;
		if (!FindNearestBuildPoint(pBuilding, pLocal, vPoint))
			continue;

		Vec3 vAngleTo = Math::CalcAngle(vLocalPos, vPoint);
		const float flFOVTo = Math::CalcFov(vLocalAngles, vAngleTo);
		const float flDistTo = vLocalPos.DistTo(vPoint);

		if (flFOVTo > Vars::Aimbot::General::AimFOV.Value)
			continue;

		vTargets.emplace_back(pBuilding, TargetEnum::Unknown, vPoint, vAngleTo, flFOVTo, flDistTo);
	}
	F::AimbotGlobal.SortTargets(vTargets, Vars::Aimbot::General::TargetSelectionEnum::Distance);
	if (vTargets.empty())
		return true;

	//if (!G::AimTarget.m_iEntIndex)
	//	G::AimTarget = { vTargets.front().m_pEntity->entindex(), I::GlobalVars->tickcount, 0 };

	for (auto& tTarget : vTargets)
	{
		static int iLastRun = 0;

		bool bShouldAim = true;
		if (Vars::Aimbot::General::AutoShoot.Value)
			pCmd->buttons |= IN_ATTACK;
		else
			bShouldAim = pCmd->buttons & IN_ATTACK;
		if (Vars::Aimbot::General::AimType.Value == Vars::Aimbot::General::AimTypeEnum::Silent)
			bShouldAim = bShouldAim && (iLastRun != I::GlobalVars->tickcount - 1 || G::PSilentAngles && !F::Ticks.CanChoke());
		
		if (bShouldAim)
		{
			G::AimTarget = { tTarget.m_pEntity->entindex(), I::GlobalVars->tickcount };
			G::AimPoint = { tTarget.m_vPos, I::GlobalVars->tickcount };

			G::Attacking = true;

			Aim(pCmd->viewangles, Math::CalcAngle(vLocalPos, tTarget.m_vPos), tTarget.m_vAngleTo);
			tTarget.m_vAngleTo.x = pCmd->viewangles.x; // we don't need to care about pitch
			Aim(pCmd, tTarget.m_vAngleTo);

			iLastRun = I::GlobalVars->tickcount;
		}

		break;
	}

	return true;
}

bool CAimbotMelee::AimFriendlyBuilding(CTFPlayer* pLocal, CBaseObject* pBuilding)
{
	// Current Metal
	int iCurrMetal = pLocal->m_iMetalCount();

	// Autorepair is on
	bool bShouldRepair = false;
	switch (pBuilding->GetClassID())
	{
	case ETFClassID::CObjectSentrygun:
	{
		if (Vars::Aimbot::Melee::AutoEngie::AutoRepair.Value & Vars::Aimbot::Melee::AutoEngie::AutoRepairEnum::Sentry)
		{
			// Current sentry ammo
			int iSentryAmmo = pBuilding->As<CObjectSentrygun>()->m_iAmmoShells();
			// Max Sentry ammo
			int iMaxAmmo = 0;

			// Set Ammo depending on level
			switch (pBuilding->m_iUpgradeLevel())
			{
			case 1:
				iMaxAmmo = 150;
				break;
			case 2:
			case 3:
				iMaxAmmo = 200;
			}

			// Sentry needs ammo
			if (iSentryAmmo < iMaxAmmo)
				return true;

			bShouldRepair = true;
			break;
		}
	}
	case ETFClassID::CObjectDispenser:
	{
		if (Vars::Aimbot::Melee::AutoEngie::AutoRepair.Value & Vars::Aimbot::Melee::AutoEngie::AutoRepairEnum::Dispenser)
			bShouldRepair = true;
		break;
	}
	case ETFClassID::CObjectTeleporter:
	{
		if (Vars::Aimbot::Melee::AutoEngie::AutoRepair.Value & Vars::Aimbot::Melee::AutoEngie::AutoRepairEnum::Teleporter)
			bShouldRepair = true;
		break;
	}
	default:
		break;
	}

	// Buildings needs to be repaired
	if (iCurrMetal && bShouldRepair && pBuilding->m_iHealth() != pBuilding->m_iMaxHealth())
		return true;

	// Autoupgrade is on
	if (Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value)
	{
		// Upgrade lvel
		int iUpgradeLevel = pBuilding->m_iUpgradeLevel();

		// Don't upgrade mini sentries
		if (pBuilding->m_bMiniBuilding())
			return false;

		int iLevel = 0;
		// Pick The right rvar to check depending on building type
		switch (pBuilding->GetClassID())
		{

		case ETFClassID::CObjectSentrygun:
			// Enabled check
			if (!(Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value & Vars::Aimbot::Melee::AutoEngie::AutoUpgradeEnum::Sentry))
				return false;
			iLevel = Vars::Aimbot::Melee::AutoEngie::AutoUpgradeSentryLVL.Value;
			break;

		case ETFClassID::CObjectDispenser:
			// Enabled check
			if (!(Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value & Vars::Aimbot::Melee::AutoEngie::AutoUpgradeEnum::Dispenser))
				return false;
			iLevel = Vars::Aimbot::Melee::AutoEngie::AutoUpgradeDispenserLVL.Value;
			break;

		case ETFClassID::CObjectTeleporter:
			// Enabled check
			if (!(Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value & Vars::Aimbot::Melee::AutoEngie::AutoUpgradeEnum::Teleporter))
				return false;
			iLevel = Vars::Aimbot::Melee::AutoEngie::AutoUpgradeTeleporterLVL.Value;
			break;
		}

		// Can be upgraded
		if (iUpgradeLevel < iLevel && iCurrMetal)
			return true;
	}
	return false;
}

bool ShouldWrenchBuilding(ETFClassID id)
{
	switch (id)
	{
	case ETFClassID::CObjectSentrygun:
		// Repair sentries check
		if (!(Vars::Aimbot::Melee::AutoEngie::AutoRepair.Value & Vars::Aimbot::Melee::AutoEngie::AutoRepairEnum::Sentry) && !(Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value & Vars::Aimbot::Melee::AutoEngie::AutoUpgradeEnum::Sentry))
			return false;
		break;
	case ETFClassID::CObjectDispenser:
		// Repair Dispensers check
		if (!(Vars::Aimbot::Melee::AutoEngie::AutoRepair.Value & Vars::Aimbot::Melee::AutoEngie::AutoRepairEnum::Dispenser) && !(Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value & Vars::Aimbot::Melee::AutoEngie::AutoUpgradeEnum::Dispenser))
			return false;
		break;
	case ETFClassID::CObjectTeleporter:
		// Repair Teleporters check
		if (!(Vars::Aimbot::Melee::AutoEngie::AutoRepair.Value & Vars::Aimbot::Melee::AutoEngie::AutoRepairEnum::Teleporter) && !(Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value & Vars::Aimbot::Melee::AutoEngie::AutoUpgradeEnum::Teleporter))
			return false;
		break;
	default:
		return false;
	}
	return true;
}

std::vector<Target_t> CAimbotMelee::GetTargetBuilding(CTFPlayer* pLocal, CTFWeaponBase* pWeapon)
{
	std::vector<Target_t> vValidTargets;

	const Vec3 vLocalPos = pLocal->GetShootPos();
	const Vec3 vLocalAngles = I::EngineClient->GetViewAngles();

	for (auto pEntity : H::Entities.GetGroup(EGroupType::BUILDINGS_TEAMMATES))
	{
		if (!pEntity->IsBuilding())
			continue;

		if (!ShouldWrenchBuilding(pEntity->GetClassID()))
			continue;

		Vec3 vPos = pEntity->GetCenter();
		Vec3 vAngleTo = Math::CalcAngle(vLocalPos, vPos);
		const float flFOVTo = Math::CalcFov(vLocalAngles, vAngleTo);
		const float flDistTo = vLocalPos.DistTo(vPos);

		if (flFOVTo > Vars::Aimbot::General::AimFOV.Value)
			continue;

		vValidTargets.push_back({ pEntity, TargetEnum::Dispenser, vPos, vAngleTo, flFOVTo, flDistTo });
	}

	std::sort(vValidTargets.begin(), vValidTargets.end(), [&](const Target_t& a, const Target_t& b) -> bool
			  {
				  const auto a_iClassID = a.m_pEntity->GetClassID();
				  const auto b_iClassID = b.m_pEntity->GetClassID();
				  switch (a_iClassID)
				  {
				  case ETFClassID::CObjectSentrygun:
				  {
					  if (Vars::Aimbot::Melee::AutoEngie::AutoRepairPrio.Value == Vars::Aimbot::Melee::AutoEngie::AutoRepairPrioEnum::Sentry)
						  return a_iClassID != b_iClassID;
					  break;
				  }
				  case ETFClassID::CObjectDispenser:
				  {
					  if (Vars::Aimbot::Melee::AutoEngie::AutoRepairPrio.Value == Vars::Aimbot::Melee::AutoEngie::AutoRepairPrioEnum::Dispenser)
						  return a_iClassID != b_iClassID;
					  break;
				  }
				  case ETFClassID::CObjectTeleporter:
				  {
					  if (Vars::Aimbot::Melee::AutoEngie::AutoRepairPrio.Value == Vars::Aimbot::Melee::AutoEngie::AutoRepairPrioEnum::Teleporter)
						  return a_iClassID != b_iClassID;
					  break;
				  }
				  default: break;
				  }
				  return false;
			  });

	return vValidTargets;
}

bool CAimbotMelee::AutoEngie(CTFPlayer* pLocal, CTFWeaponBase* pWeapon, CUserCmd* pCmd)
{
	if (pLocal->m_iClass() != TF_CLASS_ENGINEER || !Vars::Aimbot::Melee::AutoEngie::AutoUpgrade.Value && !Vars::Aimbot::Melee::AutoEngie::AutoRepair.Value)
		return false;

	auto vTargets = GetTargetBuilding(pLocal, pWeapon);
	if (vTargets.empty())
		return false;

	const bool bShouldSwing = m_iDoubletapTicks <= (GetSwingTime(pWeapon) ? 14 : 0) || Vars::Doubletap::AntiWarp.Value && pLocal->m_hGroundEntity();

	Vec3 vEyePos = pLocal->GetShootPos();
	SimulatePlayers(pLocal, pWeapon, vTargets, vEyePos);
	
	for (auto& tTarget : vTargets)
	{
		if (!AimFriendlyBuilding(pLocal, tTarget.m_pEntity->As<CBaseObject>()))
			continue;

		const auto iResult = CanHit(tTarget, pLocal, pWeapon, vEyePos);
		if (!iResult) continue;
		if (iResult == 2)
		{
			G::AimTarget = { tTarget.m_pEntity->entindex(), I::GlobalVars->tickcount, 0 };
			Aim(pCmd, tTarget.m_vAngleTo);
			return true;
		}

		G::AimTarget = { tTarget.m_pEntity->entindex(), I::GlobalVars->tickcount };
		G::AimPoint = { tTarget.m_vPos, I::GlobalVars->tickcount };

		if (Vars::Aimbot::General::AutoShoot.Value && pWeapon->m_flSmackTime() < 0.f)
		{
			if (bShouldSwing)
				pCmd->buttons |= IN_ATTACK;
			if (m_iDoubletapTicks)
				F::Ticks.m_bDoubletap = true;
		}

		G::Attacking = SDK::IsAttacking(pLocal, pWeapon, pCmd, true);
		if (G::Attacking != 1)
		{
			vEyePos = pLocal->GetShootPos();
			Aim(G::CurrentUserCmd->viewangles, Math::CalcAngle(vEyePos, tTarget.m_vPos), tTarget.m_vAngleTo);
		}
		DrawVisuals(pLocal, pWeapon, pCmd, tTarget, m_mPaths);

		Aim(pCmd, tTarget.m_vAngleTo);
		return true;
	}
	return false;
}
",vCurAngle
610,"#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <limits>
#include <algorithm>

using namespace std;

class Server {
private:
    string serverType; // 服务器型号
    int core;          // CPU核数
    int memory;        // 内存大小
    int price;         // 硬件成本
    int cost;          // 每日能耗成本

    int aAvailableCore;   // A节点可用CPU核数
    int aAvailableMemory; // A节点可用内存
    int bAvailableCore;   // B节点可用CPU核数
    int bAvailableMemory; // B节点可用内存
public:
    Server(const string &serverType, int core, int memory, int price, int cost) {
        try {
            if (core % 2 != 0 || memory % 2 != 0) {
                throw ""Server requires even core and memory requirements."";
            }
        }
        catch (const char *msg) {
            cerr << msg << endl;
        }
        this->serverType = serverType;
        this->core = core;
        this->memory = memory;
        this->price = price;
        this->cost = cost;

        aAvailableCore = core / 2;
        aAvailableMemory = memory / 2;
        bAvailableCore = core / 2;
        bAvailableMemory = memory / 2;
    }

    ~Server() {}

    string getServerType() { return serverType; }

    int getCore() const { return core; }

    int getMemory() const { return memory; }

    int getPrice() const { return price; }

    int getCost() const { return cost; }

    int getAAvailableCore() const { return aAvailableCore; }

    int getAAvailableMemory() const { return aAvailableMemory; }

    int getBAvailableCore() const { return bAvailableCore; }

    int getBAvailableMemory() const { return bAvailableMemory; }

    void addAvailableCore(int num, const string &node) {
        try {
            if (node == ""A"")
                aAvailableCore += num;
            else if (node == ""B"")
                bAvailableCore += num;
            else if (node == ""AB"") {
                aAvailableCore += num;
                bAvailableCore += num;
            } else
                throw ""Specify the correct node."";
        }
        catch (const char *msg) {
            cerr << msg << endl;
        }
    }

    void addAvailableMemory(int num, const string &node) {
        try {
            if (node == ""A"")
                aAvailableMemory += num;
            else if (node == ""B"")
                bAvailableMemory += num;
            else if (node == ""AB"") {
                aAvailableMemory += num;
                bAvailableMemory += num;
            } else
                throw ""Specify the correct node."";
        }
        catch (const char *msg) {
            cerr << msg << endl;
        }
    }

    bool allocate(int core_num, int memory_num, const string &node) {
        if (node == ""A"") { // 在A节点上分配
            int remainCore = aAvailableCore - core_num;
            int remainMemory = aAvailableMemory - memory_num;
            if (remainCore >= 0 && remainMemory >= 0) {
                aAvailableCore = remainCore;
                aAvailableMemory = remainMemory;
                return true;
            }
        } else if (node == ""B"") { // 在B节点上分配
            int remainCore = bAvailableCore - core_num;
            int remainMemory = bAvailableMemory - memory_num;
            if (remainCore >= 0 && remainMemory >= 0) {
                bAvailableCore = remainCore;
                bAvailableMemory = remainMemory;
                return true;
            }
        } else if (node == ""AB"") { // 在AB两个节点上分配
            int coreOnEachNode = core_num / 2;
            int memoryOnEachNode = memory_num / 2;
            int aRemainCore = aAvailableCore - coreOnEachNode;
            int aRemainMemory = aAvailableMemory - memoryOnEachNode;
            int bRemainCore = bAvailableCore - coreOnEachNode;
            int bRemainMemory = bAvailableMemory - memoryOnEachNode;
            if (aRemainCore >= 0 && aRemainMemory >= 0 && bRemainCore >= 0 && bRemainMemory >= 0) {
                aAvailableCore = aRemainCore;
                aAvailableMemory = aRemainMemory;
                bAvailableCore = bRemainCore;
                bAvailableMemory = bRemainMemory;
                return true;
            }
        }
        return false;
    }
}; // end class Server

struct VM {
    /* data */
    string vmType; // 虚拟机类型
    int core;      // CPU核数
    int memory;    // 内存大小
    bool is_dual;  // 是否为双节点部署

    /* init */
    VM() : core(0), memory(0), is_dual(false) {}

    VM(string vt, int c, int m, bool is_d) : vmType(vt), core(c), memory(m), is_dual(is_d) {}
};

struct VMDeployInfo {  // 部署用
    /* data */
    int serverId; // 部署的服务器id
    string node;  // 部署的节点
    VM vm;        // 虚拟机的信息

    /* init */
    VMDeployInfo(int sid, string n, const VM &v) : serverId(sid), node(n), vm(v.vmType, v.core, v.memory, v.is_dual) {}
};

struct VMInfoInServer {  // 迁移用
    /* data */
    int vmId;     // 部署的虚拟机id
    string node;  // 部署的节点
    VM vm;        // 虚拟机的信息

    /* init */
    VMInfoInServer(int vid, string n, const VM &v) : vmId(vid), node(n), vm(v.vmType, v.core, v.memory, v.is_dual) {}
};

struct MigrateInfo {
    /* data */
    int vmId;           // 虚拟机id
    int serverId;       // 目的服务器id
    string targetNode;  // 目的服务器节点

    /* init */
    MigrateInfo(int vid, int sid, string tn) : vmId(vid), serverId(sid), targetNode(tn) {}
};

class Schedule {
private:
    int totalCost = 0;                               // 最后的总成本
    int nextId = 0;                                  // 服务器ID，都为非负数，每次加一
    int nextTempId = -1;                             // 服务器临时ID，都用负数表示，每次减一
    vector<Server> coreLgMemoryServerVec;            // CPU核数大于内存的类型的服务器向量
    vector<Server> memoryLgCoreServerVec;            // 内存大于CPU核数的类型的服务器向量
    vector<VM> vmTypeVec;                            // 所有类型的虚拟机向量
    unordered_map<int, Server> ownedServerMap;       // 拥有的服务器向量  <服务器id，服务器>
    map<string, int> purchaseServerOneDay;           // 一天中购买的服务器 <类型, 数量>
    unordered_map<int, VMDeployInfo> deployedVM;     // 所有的部署的虚拟机 <虚拟机id, 部署信息>
    vector<pair<int, VMDeployInfo>> deployVMOneDay;  // 一天中部署的虚拟机 <虚拟机id, 部署信息>
    vector<MigrateInfo> migrateInfoOneDay;           // 一天中的迁移信息
    unordered_map<int, vector<VMInfoInServer>> serverOwnedVM;// 服务器上部署的虚拟机信息 <服务器id，<虚拟机信息>>
public:
    VM getVMByType(const string &vmType) {  // 根据虚拟机类型查找虚拟机
        for (const auto &it : vmTypeVec) {
            if (it.vmType == vmType)
                return it;
        }
    }

    Server getServerByType(const string &sType, bool coreLgMemory) {  // 在服务器类型向量中根据服务器type查找服务器
        if (coreLgMemory) {
            for (auto &it: coreLgMemoryServerVec) {
                if (it.getServerType() == sType) {
                    return it;
                }
            }
        } else {
            for (auto &it: memoryLgCoreServerVec) {
                if (it.getServerType() == sType) {
                    return it;
                }
            }
        }
    }

    void purchaseServer(const VM &vm, const int days) {
        bool coreLgMemory;
        string purchaseServerType;  // 要购买的服务器类型名称
        double minCost = numeric_limits<double>::max();  // 定义部署的最小支出

        if (vm.core > vm.memory) {
            coreLgMemory = true;
            for (auto &it: coreLgMemoryServerVec) {
                if (!vm.is_dual && it.getCore() / 2 >= vm.core && it.getMemory() / 2 >= vm.memory) {  // 单节点部署的虚拟机
                    // double cost = addVMCost(it, vm, days);
                    double cost = it.getPrice();   // 选择最便宜的服务器
                    if (cost < minCost) {
                        purchaseServerType = it.getServerType();
                        minCost = cost;
                    }
                }
                if (vm.is_dual && it.getCore() >= vm.core && it.getMemory() >= vm.memory) {  // 双节点部署的虚拟机
                    // double cost = addVMCost(it, vm, days);
                    double cost = it.getPrice();   // 选择最便宜的服务器
                    if (cost < minCost) {
                        purchaseServerType = it.getServerType();
                        minCost = cost;
                    }
                }
            }  // end for
        }  // end if(vm.core > vm.memory)

        if (vm.core <= vm.memory) {
            coreLgMemory = false;
            for (auto &it: memoryLgCoreServerVec) {
                if (!vm.is_dual && it.getCore() / 2 >= vm.core && it.getMemory() / 2 >= vm.memory) {  // 单节点部署的虚拟机
                    // double cost = addVMCost(it, vm, days);
                    double cost = it.getPrice();   // 选择最便宜的服务器
                    if (cost < minCost) {
                        purchaseServerType = it.getServerType();
                        minCost = cost;
                    }
                }
                if (vm.is_dual && it.getCore() >= vm.core && it.getMemory() >= vm.memory) {  // 双节点部署的虚拟机
                    // double cost = addVMCost(it, vm, days);
                    double cost = it.getPrice();   // 选择最便宜的服务器
                    if (cost < minCost) {
                        purchaseServerType = it.getServerType();
                        minCost = cost;
                    }
                }
            }  // end for
        }  // end if(vm.core <= vm.memory)

        Server pServer = getServerByType(purchaseServerType, coreLgMemory);
        ownedServerMap.emplace(nextTempId, pServer);
        nextTempId--;  // 每次id减一
        if (purchaseServerOneDay.find(purchaseServerType) != purchaseServerOneDay.end()) {  // 存在该类型的服务器
            purchaseServerOneDay[purchaseServerType] += 1;
        } else {
            purchaseServerOneDay[purchaseServerType] = 1;
        }
    }

    static double addVMCost(const Server &s, const VM &v, const int days) {
        int sc = s.getCore();      // 服务器CPU核数
        int sm = s.getMemory();    // 服务器内存数
        int sp = s.getPrice();     // 服务器价格
        int se = s.getCost();      // 服务器每日能耗
        int vc = v.core;           // 虚拟机CPU核数
        int vm = v.memory;         // 虚拟机内存数

        return double(sp + se * days) * (double(vc) / double(sc) + double(vm) / double(sm));
    }

    static double addVMLossFunction(const int remainSource, const double deployCost) {
        return 1.0 * remainSource + 0.0 * deployCost;
    }

    void addVM(const string &vmType, const int vmId, const int currDay, const int totalDay) {
        int sid;        // 部署在的服务器id
        string node;    // 部署的节点
        VM vm = getVMByType(vmType);
        bool is_dual = vm.is_dual;
        bool isNeedPurchase = true;  // 是否需要新购买服务器
        double minLoss = numeric_limits<double>::max();  // 定义部署的最小代价

        if (!is_dual) {  // 单节点部署
            if (vm.core > vm.memory) {  // 虚拟机CPU核数大于内存数
                for (auto &it: ownedServerMap) {  // 遍历服务器
                    int serverId = it.first;
                    Server server = it.second;
                    // 在CPU核数大于内存数的服务器节点中找
                    if (server.getBAvailableCore() > server.getBAvailableMemory() &&
                        server.getBAvailableCore() >= vm.core && server.getBAvailableMemory() >= vm.memory) { // B节点
                        int bRemainSource =
                                server.getBAvailableCore() - vm.core + server.getBAvailableMemory() - vm.memory;
                        // 所以如果只考虑成本的话，部署在A节点还是B节点无法判断，二者的成本相同
                        double deployCost = addVMCost(server, vm, totalDay - currDay);
                        double loss = addVMLossFunction(bRemainSource, deployCost);
                        if (loss < minLoss) {
                            isNeedPurchase = false;
                            node = ""B"";
                            sid = serverId;
                            minLoss = loss;
                        }
                    }
                    if (server.getAAvailableCore() > server.getAAvailableMemory() &&
                        server.getAAvailableCore() >= vm.core && server.getAAvailableMemory() >= vm.memory) {  // A节点
                        int aRemainSource =
                                server.getAAvailableCore() - vm.core + server.getAAvailableMemory() - vm.memory;
                        double deployCost = addVMCost(server, vm, totalDay - currDay);
                        double loss = addVMLossFunction(aRemainSource, deployCost);
                        if (loss < minLoss) {  // 目的是寻找最小代价的部署方案
                            isNeedPurchase = false;
                            node = ""A"";
                            sid = serverId;
                            minLoss = loss;  // 更新最小代价
                        }
                    }
                }
            } else {  // vm.core <= vm.memory  vm.core==vm.memory的情况要不要单独拿出来？
                for (auto &it: ownedServerMap) {  // 遍历服务器
                    int serverId = it.first;
                    Server server = it.second;
                    // 在CPU核数小于等于内存数的服务器节点中找
                    if (server.getBAvailableCore() <= server.getBAvailableMemory() &&
                        server.getBAvailableCore() >= vm.core && server.getBAvailableMemory() >= vm.memory) { // B节点
                        int bRemainSource =
                                server.getBAvailableCore() - vm.core + server.getBAvailableMemory() - vm.memory;
                        // 所以如果只考虑成本的话，部署在A节点还是B节点无法判断，二者的成本相同
                        double deployCost = addVMCost(server, vm, totalDay - currDay);
                        double loss = addVMLossFunction(bRemainSource, deployCost);
                        if (loss < minLoss) {
                            isNeedPurchase = false;
                            node = ""B"";
                            sid = serverId;
                            minLoss = loss;
                        }
                    }
                    if (server.getAAvailableCore() <= server.getAAvailableMemory() &&
                        server.getAAvailableCore() >= vm.core && server.getAAvailableMemory() >= vm.memory) {  // A节点
                        int aRemainSource =
                                server.getAAvailableCore() - vm.core + server.getAAvailableMemory() - vm.memory;
                        double deployCost = addVMCost(server, vm, totalDay - currDay);
                        double loss = addVMLossFunction(aRemainSource, deployCost);
                        if (loss < minLoss) {  // 目的是寻找最小代价的部署方案
                            isNeedPurchase = false;
                            node = ""A"";
                            sid = serverId;
                            minLoss = loss;  // 更新最小代价
                        }
                    }
                }
            }
        }  // end if(!is_dual)

        if (is_dual) {  // 双节点部署
            if (vm.core > vm.memory) {
                for (const auto &it: ownedServerMap) {
                    int serverId = it.first;
                    Server server = it.second;
                    int sACore = server.getAAvailableCore();
                    int sBCore = server.getBAvailableCore();
                    int sAMem = server.getAAvailableMemory();
                    int sBMem = server.getBAvailableMemory();
                    int vmHalfCore = vm.core / 2;
                    int vmHalfMem = vm.memory / 2;
                    if ((sACore > sAMem || sBCore > sBMem) && sACore >= vmHalfCore && sAMem >= vmHalfMem &&
                        sBCore >= vmHalfCore && sBMem >= vmHalfMem) {
                        int aRemainSource = sACore - vmHalfCore + sAMem - vmHalfMem;
                        int bRemainSource = sBCore - vmHalfCore + sBMem - vmHalfMem;
                        int remainSource = aRemainSource > bRemainSource ? bRemainSource : aRemainSource;
                        double deployCost = addVMCost(server, vm, totalDay - currDay);
                        double loss = addVMLossFunction(remainSource, deployCost);
                        if (loss < minLoss) {
                            isNeedPurchase = false;
                            node = ""AB"";
                            sid = serverId;
                            minLoss = loss;
                        }
                    }
                }
            }  // end if(vm.core > vm.memory)

            if (vm.core <= vm.memory) {
                for (const auto &it: ownedServerMap) {
                    int serverId = it.first;
                    Server server = it.second;
                    int sACore = server.getAAvailableCore();
                    int sBCore = server.getBAvailableCore();
                    int sAMem = server.getAAvailableMemory();
                    int sBMem = server.getBAvailableMemory();
                    int vmHalfCore = vm.core / 2;
                    int vmHalfMem = vm.memory / 2;
                    if ((sACore <= sAMem || sBCore <= sBMem) && sACore >= vmHalfCore && sAMem >= vmHalfMem &&
                        sBCore >= vmHalfCore && sBMem >= vmHalfMem) {
                        int aRemainSource = sACore - vmHalfCore + sAMem - vmHalfMem;
                        int bRemainSource = sBCore - vmHalfCore + sBMem - vmHalfMem;
                        int remainSource = aRemainSource > bRemainSource ? bRemainSource : aRemainSource;
                        double deployCost = addVMCost(server, vm, totalDay - currDay);
                        double loss = addVMLossFunction(remainSource, deployCost);
                        if (loss < minLoss) {
                            isNeedPurchase = false;
                            node = ""AB"";
                            sid = serverId;
                            minLoss = loss;
                        }
                    }
                }
            }  // end if(vm.core <= vm.memory)
        }  // end if(is_dual)

        /* 即使没有以上条件的服务器，是否再遍历一遍，能部署就部署? */
        if (!isNeedPurchase) {  // 不需要购买新的服务器
            auto it = ownedServerMap.find(sid);
            if (it->second.allocate(vm.core, vm.memory, node)) {  // 返回引用问题
                VMDeployInfo info = VMDeployInfo(sid, node, vm);
                pair<int, VMDeployInfo> deployedVMInfo(vmId, info);
                deployVMOneDay.push_back(deployedVMInfo);
            }
        } else {  // 需要购买服务器
            purchaseServer(vm, totalDay - currDay);
            auto it = ownedServerMap.find(nextTempId + 1);  // 购买服务器後，nextTempId減一，所以買的服務器id爲加一後的值
            int pServerId = it->first;
            if (!is_dual) {  // 单节点直接部署到A节点上
                if (it->second.allocate(vm.core, vm.memory, ""A"")) {
                    VMDeployInfo info = VMDeployInfo(pServerId, ""A"", vm);
                    pair<int, VMDeployInfo> deployedVMInfo(vmId, info);
                    deployVMOneDay.push_back(deployedVMInfo);
                }
            }
            if (is_dual) {  // 双节点部署
                if (it->second.allocate(vm.core, vm.memory, ""AB"")) {
                    VMDeployInfo info = VMDeployInfo(pServerId, ""AB"", vm);
                    pair<int, VMDeployInfo> deployedVMInfo(vmId, info);
                    deployVMOneDay.push_back(deployedVMInfo);
                }
            }
        }  // end if(isNeedPurchase)
    }


    bool deleteVM(const int vmId) {
        // 首先在当天的部署记录中寻找，当天的部署信息在最后一天转换id之后才并入总的部署信息中
        for (auto itOneDay = deployVMOneDay.begin(); itOneDay != deployVMOneDay.end(); itOneDay++) {
            if (itOneDay->first == vmId) {
                VMDeployInfo info = itOneDay->second;
                VM vm = info.vm;
                string node = info.node;
                int serverId = info.serverId;
                // 释放服务器资源
                auto its = ownedServerMap.find(serverId);
                if (vm.is_dual) {
                    its->second.addAvailableCore(vm.core / 2, node);
                    its->second.addAvailableMemory(vm.memory / 2, node);
                } else {
                    its->second.addAvailableCore(vm.core, node);
                    its->second.addAvailableMemory(vm.memory, node);
                }
                // 删除部署信息
                deployVMOneDay.erase(itOneDay);
                return true;
            }
        }

        // 如果没找到，然后在以前的部署记录中寻找
        auto it = deployedVM.find(vmId);
        if (it == deployedVM.end()) {
            return false;
        } else {
            VMDeployInfo info = it->second;
            VM vm = info.vm;
            string node = info.node;
            int serverId = info.serverId;
            // 释放服务器资源
            auto its = ownedServerMap.find(serverId);
            if (vm.is_dual) {  // node == ""AB""
                its->second.addAvailableCore(vm.core / 2, node);
                its->second.addAvailableMemory(vm.memory / 2, node);
            } else {
                its->second.addAvailableCore(vm.core, node);
                its->second.addAvailableMemory(vm.memory, node);
            }
            // 删除部署信息
            deployedVM.erase(vmId);
            for (auto vmInfo = serverOwnedVM.find(serverId)->second.begin();
                 vmInfo != serverOwnedVM.find(serverId)->second.end(); vmInfo++) {
                if (vmInfo->vmId == vmId) {
                    serverOwnedVM.find(serverId)->second.erase(vmInfo);
                    return true;
                }
            }
            return false;
        }
    }

    static double
    calcUtilizationRate(Server &server, const string &node, const int allocateCoreNum, const int allocateMemoryNum) {
        // 分配一定资源后的资源利用率。后两个参数为0表示原服务器的利用率。
        if (node == ""A"") {
            double ACore = double(server.getCore()) / 2;
            double AMemory = double(server.getMemory()) / 2;
            double coreUtilization = (ACore - server.getAAvailableCore() + allocateCoreNum) / ACore;
            double memoryUtilization = (AMemory - server.getAAvailableMemory() + allocateMemoryNum) / AMemory;
            return coreUtilization + memoryUtilization;
        }
        if (node == ""B"") {
            double BCore = double(server.getCore()) / 2;
            double BMemory = double(server.getMemory()) / 2;
            double coreUtilization = (BCore - server.getBAvailableCore() + allocateCoreNum) / BCore;
            double memoryUtilization = (BMemory - server.getBAvailableMemory() + allocateMemoryNum) / BMemory;
            return coreUtilization + memoryUtilization;
        }
        if (node == ""AB"") {
            double ACore, AMemory, BCore, BMemory;
            ACore = BCore = double(server.getCore()) / 2;
            AMemory = BMemory = double(server.getMemory()) / 2;
            double coreUtilization = min((ACore - server.getAAvailableCore() + double(allocateCoreNum) / 2) / ACore,
                                         (BCore - server.getBAvailableCore() + double(allocateCoreNum) / 2) / BCore);
            double memoryUtilization = min(
                    (AMemory - server.getAAvailableMemory() + double(allocateMemoryNum) / 2) / AMemory,
                    (BMemory - server.getBAvailableMemory() + double(allocateMemoryNum) / 2) / BMemory);
            return coreUtilization + memoryUtilization;
        }
        return 0;
    }

    void migrateVM() {
        int migrateLimit = int(deployedVM.size() * 0.005) - 1;
        auto vmit = deployedVM.begin();
        int migrateNum = 0;
        for (; vmit != deployedVM.end() && migrateNum < migrateLimit; vmit++) {
            int serverId = vmit->second.serverId;
            auto originalServer = ownedServerMap.find(serverId);
            VM vm = vmit->second.vm;  // 要迁移的虚拟机
            int vmId = vmit->first;  // 要迁移的虚拟机id
            string node = vmit->second.node;  // 要迁移的虚拟机原来所在的节点
            bool canMigrate = false;  // 是否可以进行迁移
            int targetServerId;  // 目标服务器id
            string targetNode;  // 目标服务器节点
            double currUtilizationRate = calcUtilizationRate(originalServer->second, node, 0, 0);
            for (auto &ito: ownedServerMap) {  // 遍历查找可以放置的服务器
                if (ito.first != serverId) {  // 目的服务器与原服务器不同
                    if (vm.is_dual) {  // 双节点部署
                        if (ito.second.getAAvailableCore() >= vm.core / 2 &&
                            ito.second.getAAvailableMemory() >= vm.memory / 2 &&
                            ito.second.getBAvailableCore() >= vm.core / 2 &&
                            ito.second.getBAvailableMemory() >= vm.memory / 2) {
                            double utilizationRate = calcUtilizationRate(ito.second, ""AB"", vm.core, vm.memory);
                            if (utilizationRate > currUtilizationRate) {
                                currUtilizationRate = utilizationRate;
                                targetServerId = ito.first;
                                targetNode = ""AB"";
                                canMigrate = true;
                            }
                        }
                    } else {  // if(!is_dual)
                        if (ito.second.getAAvailableCore() >= vm.core &&
                            ito.second.getAAvailableMemory() >= vm.memory) {
                            double utilizationRate = calcUtilizationRate(ito.second, ""A"", vm.core, vm.memory);
                            if (utilizationRate > currUtilizationRate) {
                                currUtilizationRate = utilizationRate;
                                targetServerId = ito.first;
                                targetNode = ""A"";
                                canMigrate = true;
                            }
                        }
                        if (ito.second.getBAvailableCore() >= vm.core &&
                            ito.second.getBAvailableMemory() >= vm.memory) {
                            double utilizationRate = calcUtilizationRate(ito.second, ""B"", vm.core, vm.memory);
                            if (utilizationRate > currUtilizationRate) {
                                currUtilizationRate = utilizationRate;
                                targetServerId = ito.first;
                                targetNode = ""B"";
                                canMigrate = true;
                            }
                        }
                    }
                }
            }

            if (canMigrate) {
                // 在目标服务器上分配资源
                auto targetServer = ownedServerMap.find(targetServerId);
                targetServer->second.allocate(vm.core, vm.memory, targetNode);

                // 原服務器加上釋放的資源
                if (vm.is_dual) {
                    originalServer->second.addAvailableCore(vm.core / 2, node);
                    originalServer->second.addAvailableMemory(vm.memory / 2, node);
                } else {  // !vm.is_dual
                    originalServer->second.addAvailableCore(vm.core, node);
                    originalServer->second.addAvailableMemory(vm.memory, node);
                }

                // 在serverOwnedVM中将该id服务器上的虚拟机信息清空
                auto vmInfo = serverOwnedVM.find(serverId)->second;
                auto vmi = vmInfo.begin();
                for (;vmi!=vmInfo.end();vmi++){
                    if (vmi->vmId == vmId)
                        break;
                }
                vmInfo.erase(vmi);

                // serverOwnedVM中在目标服务器上添加该虚拟机的信息
                serverOwnedVM.find(targetServerId)->second.emplace_back(vmId, targetNode, vm);

                // 修改部署信息
                auto deployInfo = deployedVM.find(vmId);
                deployInfo->second.serverId = targetServerId;
                deployInfo->second.node = targetNode;

                // 记录迁移信息
                migrateInfoOneDay.emplace_back(vmId, targetServerId, targetNode);

                migrateNum++;
            }
        }
    }


    void convertID() {
        int purchaseNumberOneDay = 0;  // 一天中購買的服務器臺數
        for (auto &ps: purchaseServerOneDay)
            purchaseNumberOneDay += ps.second;

        map<int, int> convertMap;
        for (auto &pServerOneDay: purchaseServerOneDay) {
            string sType = pServerOneDay.first;
            int number = pServerOneDay.second;
            int counter = 0;  // 已经修改counter个sType的服务器id，sType的服务器在一天中有number台
            for (int i = 1; i <= purchaseNumberOneDay && counter < number; i++) {
                auto serverInfo = ownedServerMap.find(nextTempId + i);
                if (serverInfo != ownedServerMap.end() && serverInfo->second.getServerType() == sType) {
                    int newID = nextId;
                    nextId++;
                    int oldID = serverInfo->first;
                    Server s = serverInfo->second;
                    ownedServerMap.emplace(newID, s);
                    ownedServerMap.erase(oldID);
                    convertMap.emplace(oldID, newID);
                    counter++;
                }
            }
        }
        // 将获得的转换字典用于修改当天的部署信息
        auto it = deployVMOneDay.begin();
        for (; it != deployVMOneDay.end(); it++) {
            int oldID = it->second.serverId;
            if (oldID > -1)  // 部署在以前的服务器上不用更改id
                continue;
            else
                it->second.serverId = convertMap[oldID];
        }
    }

    void main() {

        int  [MASK] ;
        cin >>  [MASK] ;
        for (int i = 0; i <  [MASK] ; i++) {
            string delimiter;  // 把int后的逗号或括号读出来

            string serverType;
            cin >> serverType;
            serverType.erase(0, 1); // 去除左括号
            serverType.pop_back();  // 去除逗号

            int core;
            cin >> core;
            cin >> delimiter;

            int memory;
            cin >> memory;
            cin >> delimiter;

            int price;
            cin >> price;
            cin >> delimiter;

            int cost;
            cin >> cost;
            cin >> delimiter;

            Server server = Server(serverType, core, memory, price, cost);

            if (core > memory && core - memory >= 60 && core - memory <= 120) { // CPU核数大于内存数的服务器类型
                coreLgMemoryServerVec.push_back(server);
            }
            if (memory >= core && memory - core >= 120 && memory - core <= 180) { // 内存数大于等于CPU核数的服务器类型
                memoryLgCoreServerVec.push_back(server);
            }
        }

        int vmNumber;
        cin >> vmNumber;
        for (int i = 0; i < vmNumber; i++) {
            string delimiter;  // 把int后的逗号或括号读出来

            string vmType;
            cin >> vmType;
            vmType.erase(0, 1);  // 去除左括号
            vmType.pop_back();   // 去除逗号

            int core;
            cin >> core;
            cin >> delimiter;

            int memory;
            cin >> memory;
            cin >> delimiter;

            int is_dual;
            cin >> is_dual;
            cin >> delimiter;

            VM vm = VM(vmType, core, memory, is_dual);

            vmTypeVec.push_back(vm);
        }

        int days;
        cin >> days;
        for (int day = 0; day < days; day++) {
            // 在一天的请求开始前进行迁移

            migrateVM();


            int questNumber;
            cin >> questNumber;
            for (int j = 0; j < questNumber; j++) {
                string delimiter;  // 把int后的逗号或括号读出来

                string questType;
                cin >> questType;
                questType.erase(0, 1);  // 去除左括号
                questType.pop_back();           // 去除逗号

                if (questType == ""add"") {
                    string vmType;
                    cin >> vmType;
                    vmType.pop_back();         // 去除逗号

                    int vmId;
                    cin >> vmId;
                    cin >> delimiter;

                    addVM(vmType, vmId, day, days);
                }  // end add quest

                if (questType == ""del"") {
                    int vmId;
                    cin >> vmId;
                    cin >> delimiter;

                    deleteVM(vmId);
                }  // end del quest
            }  // end for (int j = 0; j < questNumber; j++)

            // 为当天的服务器转换id
            convertID();

            // 将当天的部署信息合并到总的部署信息中
            for (auto &vmOneDay: deployVMOneDay) {
                int vmId = vmOneDay.first;
                VMDeployInfo info = vmOneDay.second;
                deployedVM.emplace(vmId, info);
            }

            // 将该天的部署信息加入到服务器拥有的虚拟机信息
            for (auto &it: deployVMOneDay) {
                int vmId = it.first;
                int serverId = it.second.serverId;
                VMInfoInServer vmInfoInServer = VMInfoInServer(vmId, it.second.node, it.second.vm);
                auto server = serverOwnedVM.find(serverId);
                if (server == serverOwnedVM.end()) {  // 如果没有该服务器
                    vector<VMInfoInServer> vmInfoInServerVec;
                    vmInfoInServerVec.push_back(vmInfoInServer);
                    serverOwnedVM.emplace(serverId, vmInfoInServerVec);
                } else {  // 存在该服务器
                    vector<VMInfoInServer> vmInfoInServerVec = server->second;
                    vmInfoInServerVec.push_back(vmInfoInServer);
                    serverOwnedVM[serverId] = vmInfoInServerVec;
                }
            }

            // 输出信息
            cout << ""(purchase, "" << purchaseServerOneDay.size() << "")\n"";
            for (const auto &it : purchaseServerOneDay) {
                cout << ""("" << it.first << "", "" << it.second << "")\n"";
            }
            cout << ""(migration, "" << migrateInfoOneDay.size() << "")\n"";
            for (const auto &it : migrateInfoOneDay) {
                string node = it.targetNode;
                if (node == ""AB"")
                    cout << ""("" << it.vmId << "", "" << it.serverId << "")\n"";
                else
                    cout << ""("" << it.vmId << "", "" << it.serverId << "", "" << node << "")\n"";
            }
            for (const auto &it : deployVMOneDay) {
                VMDeployInfo info = it.second;
                if (info.node == ""AB"") {
                    cout << ""("" << info.serverId << "")\n"";
                } else {
                    cout << ""("" << info.serverId << "", "" << info.node << "")\n"";
                }
            }

            // 清空当天变量
            purchaseServerOneDay.clear();
            deployVMOneDay.clear();
            migrateInfoOneDay.clear();
        }
    }

}; //end class Schedule

int main() {
    Schedule schedule = Schedule();
    schedule.main();
    return 0;
}
",serverNumber
611,"// Application.cpp is the file
// that holds the class to setup
// and initialise the application.

// Include headers
#include ""Application.h""

namespace applicationFramework
{
	// Set constants
	const double Application::FRAME_TIME = 1.0 /
		Application::FPS * 1000.0; // Milliseconds

	Application *Application::instance = NULL;

	// Class constructor
	Application::Application() 
	{
		elapsedTimeInSeconds = 0;
		frameTimeElapsed = 0;
		title = ""OpenGL Demo"";
		eyeVector = Vector<float>(0.0, 0.0, -10.0); // move the eye position back
		position = 0.0f;
		direction = 1.0 / FRAME_TIME;
	}

	// Class Destructor
	Application::~Application() 
	{
	}

	void Application::startApplication(int argc, char *argv[])
	{
		setInstance();	// Sets the instance to self, used in the callback wrapper functions

		// Initialize GLUT
		glutInit(&argc, argv);
		glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
		glutInitWindowPosition(WINDOW_X_POSITION, WINDOW_Y_POSITION);
		glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
		glutCreateWindow(title.c_str());

		// Function callbacks with wrapper functions
		glutReshapeFunc(reshapeWrapper);
		glutMouseFunc(mouseButtonPressWrapper);
		glutMotionFunc(mouseMoveWrapper);
		glutDisplayFunc(displayWrapper);
		glutKeyboardFunc(keyboardDownWrapper);
		glutKeyboardUpFunc(keyboardUpWrapper);
		glutSpecialFunc(specialKeyboardDownWrapper);
		glutSpecialUpFunc(specialKeyboardUpWrapper);

		init();						// Initialize
		glutIdleFunc(runWrapper); 	// The program run loop
		glutMainLoop();				// Start the main GLUT thread
	}

	void Application::load() 
	{
		// Subclass and override this method
	}

	void Application::render(float dTime) 
	{
		// Subclass and override this method
		static int frame = 0;
		std::cout << ""GlutFramework Display: Frame: "" << frame << "", dt(sec): "" << dTime << "", Position: "" << position << std::endl;
		++frame;

		// DEMO: Create a teapot and move it back and forth on the x-axis
		glTranslatef(position, 0.0f, 0.0f);
		glutSolidTeapot(2.5);
		if (position > 4 && direction > 0) {
			direction = -1.0 / FRAME_TIME;
		}
		else if (position < -4 && direction < 0) {
			direction = 1.0 / FRAME_TIME;
		}
		position += direction;
	}

	void Application::reshape(int width, int height) 
	{
		glViewport(0, 0, (GLsizei)width, (GLsizei)height);
	}

	void Application::mouseButtonPress(int button, int state, int x, int y) 
	{
		printf(""MouseButtonPress: x: %d y: %d\n"", x, y);
	}

	void Application::mouseMove(int x, int y) 
	{
		printf(""MouseMove: x: %d y: %d\n"", x, y);
	}

	void Application::keyboardDown(unsigned char key, int x, int y)
	{
		// Subclass and override this method
		printf(""KeyboardDown: %c = %d\n"", key, (int)key);
		if (key == 27) { //27 =- ESC key
			exit(0);
		}

		keyStates.keyDown((int)key);
	}

	void Application::keyboardUp(unsigned char key, int x, int y)
	{
		// Subclass and override this method
		printf(""KeyboardUp: %c \n"", key);
		keyStates.keyUp((int)key);
	}

	void Application::specialKeyboardDown(int key, int x, int y)
	{
		// Subclass and override this method
		printf(""SpecialKeyboardDown: %d\n"", key);
	}

	void Application::specialKeyboardUp(int key, int x, int y)
	{
		// Subclass and override this method	
		printf(""SpecialKeyboardUp: %d \n"", key);
	}

	// ******************************
	// ** Graphics helper routines **
	// ******************************

	// Initialize the projection/view matricies.
	void Application::setDisplayMatricies() 
	{
		/* Setup the projection and model view matricies */
		int width = glutGet(GLUT_WINDOW_WIDTH);
		int height = glutGet(GLUT_WINDOW_HEIGHT);
		float aspectRatio = width / height;
		glViewport(0, 0, width, height);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(60, aspectRatio, 1, 500.0);

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		gluLookAt(eyeVector.x, eyeVector.y, eyeVector.z,
			centerVector.x, centerVector.y, centerVector.z,
			upVector.x, upVector.y, upVector.z);
	}

	void Application::setupLights() 
	{
		GLfloat light1_position[] = { 0.0, 1.0, 1.0, 0.0 };
		GLfloat white_light[] = { 1.0, 1.0, 1.0, 1.0 };
		GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 };
		GLfloat ambient_light[] = { 0.8, 0.8, 0.8, 1.0 };

		glLightfv(GL_LIGHT0, GL_POSITION, light1_position);
		glLightfv(GL_LIGHT0, GL_AMBIENT, ambient_light);
		glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);
		glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);

		glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
	}

	void Application::setLookAt(float eyeX, float eyeY, float eyeZ,
		float centerX, float centerY, float centerZ, float upX, float upY, float upZ) 
	{
		eyeVector = Vector<float>(eyeX, eyeY, eyeZ);
		centerVector = Vector<float>(centerX, centerY, centerZ);
		upVector = Vector<float>(upX, upY, upZ);
	}

	Vector<float> Application::getEyeVector() const 
	{
		return eyeVector;
	}

	Vector<float> Application::getCenterVector() const 
	{
		return centerVector;
	}

	Vector<float> Application::getUpVector() const 
	{
		return upVector;
	}

	void Application::setTitle(std::string  [MASK] ) 
	{
		title =  [MASK] ;
	}

	// **************************
	// ** GLUT Setup functions **
	// **************************
	void Application::init() 
	{
		glClearColor(0.0, 0.0, 0.0, 1.0);

		glEnable(GL_LIGHTING);
		glEnable(GL_LIGHT0);
		glShadeModel(GL_SMOOTH);
		glEnable(GL_DEPTH_TEST);

		load();
	}

	void Application::setInstance() 
	{
		std::cout << ""GlutFramework::setInstance()"" << std::endl;
		instance = this;
	}

	void Application::run() 
	{
		if (frameRateTimer.isStopped()) {	// The initial frame has the timer stopped, start it once
			frameRateTimer.start();
		}

		frameRateTimer.stop();			// stop the timer and calculate time since last frame
		double milliseconds = frameRateTimer.getElapsedMilliseconds();
		frameTimeElapsed += milliseconds;

		if (frameTimeElapsed >= FRAME_TIME) {	// If the time exceeds a certain ""frame rate"" then show the next frame
			glutPostRedisplay();
			frameTimeElapsed -= FRAME_TIME;		// remove a ""frame"" and start counting up again
		}
		frameRateTimer.start();			// start the timer
	}

	void Application::renderApplication() 
	{
		if (displayTimer.isStopped()) {			// Start the timer on the initial frame
			displayTimer.start();
		}

		glClearColor(0.0, 0.0, 0.0, 1.0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear once

		displayTimer.stop();		// Stop the timer and get the elapsed time in seconds
		elapsedTimeInSeconds = displayTimer.getElapsedSeconds(); // seconds

		setupLights();
		setDisplayMatricies();

		render(elapsedTimeInSeconds);

		glutSwapBuffers();
		displayTimer.start();		// reset the timer to calculate the time for the next frame
	}

	// ******************************************************************
	// ** Static functions which are passed to Glut function callbacks **
	// ******************************************************************

	void Application::displayWrapper() 
	{
		instance->renderApplication();
	}

	void Application::reshapeWrapper(int width, int height) 
	{
		instance->reshape(width, height);
	}

	void Application::runWrapper() 
	{
		instance->run();
	}

	void Application::mouseButtonPressWrapper(int button, int state, int x, int y) 
	{
		instance->mouseButtonPress(button, state, x, y);
	}

	void Application::mouseMoveWrapper(int x, int y) 
	{
		instance->mouseMove(x, y);
	}

	void Application::keyboardDownWrapper(unsigned char key, int x, int y) 
	{
		instance->keyboardDown(key, x, y);
	}

	void Application::keyboardUpWrapper(unsigned char key, int x, int y) 
	{
		instance->keyboardUp(key, x, y);
	}

	void Application::specialKeyboardDownWrapper(int key, int x, int y) 
	{
		instance->specialKeyboardDown(key, x, y);
	}

	void Application::specialKeyboardUpWrapper(int key, int x, int y) 
	{
		instance->specialKeyboardUp(key, x, y);
	}
}
",theTitle
612,"#pragma once

#include ""Runtime/Core/Math/Vector2.h""
#include ""Runtime/Function/Render/RenderCamera.h""

#include <vector>

namespace MarsEngine
{
    class MarsEditor;

    enum class EditorCommand : unsigned int
    {
        camera_left      = 1 << 0,  // A
        camera_back      = 1 << 1,  // S
        camera_foward    = 1 << 2,  // W
        camera_right     = 1 << 3,  // D
        camera_up        = 1 << 4,  // Q
        camera_down      = 1 << 5,  // E
        translation_mode = 1 << 6,  // T
        rotation_mode    = 1 << 7,  // R
        scale_mode       = 1 << 8,  // C
        exit             = 1 << 9,  // Esc
        delete_object    = 1 << 10, // Delete
    };

    class EditorInputManager
    {
    public:
        void initialize();
        void tick(float delta_time);

    public:
        void registerInput();
        void updateCursorOnAxis(Vec2 cursor_uv);
        void processEditorCommand();
        void onKeyInEditorMode(int key, int scancode, int action, int mods);

        void onKey(int key, int scancode, int action, int mods);
        void onReset();
        void onCursorPos(double xpos, double ypos);
        void onCursorEnter(int entered);
        void onScroll(double xoffset, double yoffset);
        void onMouseButtonClicked(int key, int action);
        void onWindowClosed();

        bool isCursorInRect(Vec2 pos, Vec2 size) const;

    public:
        Vec2 getEngineWindowPos() const { return m_engine_window_pos; };
        Vec2 getEngineWindowSize() const { return m_engine_window_size; };
        float      getCameraSpeed() const { return m_camera_speed; };

        void setEngineWindowPos (Vec2  [MASK] ) { m_engine_window_pos =  [MASK] ; };
        void setEngineWindowSize(Vec2 new_window_size) { m_engine_window_size = new_window_size; };
        void resetEditorCommand () { m_editor_command = 0; }

    private:
        Vec2 m_engine_window_pos {0.0f, 0.0f};
        Vec2 m_engine_window_size {1280.0f, 768.0f};
        float      m_mouse_x {0.0f};
        float      m_mouse_y {0.0f};
        float      m_camera_speed {0.05f};

        size_t       m_cursor_on_axis {3};
        unsigned int m_editor_command {0};
    };
} // namespace MarsEngine
",new_window_pos
613,"/*
 * pop_model1.cpp -- numerically solve analytic population models with
 * 	two components, models used in the paper (in all cases, both 
 * 	logistic and linear resource regrowth variants)
 * 
 * 1. Volterra: VOLTERRA_LIN, VOLTERRA_LOG
 * 2. Volterra, logistic consumers (farmer-soil model): SOIL_LIN, SOIL_LOG
 * 3. Rosenzweig-MacArthur: RMA_LIN, RMA_LOG
 * 4. Ratio-dependent: RATIO_LIN, RATIO_LOG
 * 5. Warfare model (Turchin-Korotayev): TURCHIN
 * 
 * Copyright 2023 <NAME> <<EMAIL>>
 * 
 * This is free and unencumbered software released into the public domain.
 * 
 * Anyone is free to copy, modify, publish, use, compile, sell, or
 * distribute this software, either in source code form or as a compiled
 * binary, for any purpose, commercial or non-commercial, and by any
 * means.
 * 
 * In jurisdictions that recognize copyright laws, the author or authors
 * of this software dedicate any and all copyright interest in the
 * software to the public domain. We make this dedication for the benefit
 * of the public at large and to the detriment of our heirs and
 * successors. We intend this dedication to be an overt act of
 * relinquishment in perpetuity of all present and future rights to this
 * software under copyright law.
 * 
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 * For more information, please refer to <https://unlicense.org>
 * 
 */

#ifndef HAVE_INLINE
#define HAVE_INLINE
#endif

#include <stdio.h>
#include <stdlib.h>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_odeiv2.h>
#include <random>
#include <time.h>
#include <stdexcept>

struct params {
	enum class type {
		NO_TYPE,
		TURCHIN,
		VOLTERRA_LOG,
		VOLTERRA_LIN,
		SOIL_LOG,
		SOIL_LIN,
		RMA_LOG, /* Rosenzweig-MacArthur */
		RMA_LIN, /* same with linear resource regrowth */
		RMA_LOG_LOG, /* Rosenzweig-MacArthur-like model with logistic consumers */
		RMA_LOG_LIN, /* same with linear resource regrowth */
		RATIO_LIN, /* ratio dependent functional response, symmetric */
		RATIO_LOG, /* ratio dependent functional response, logistic resources, symmetric */
		LRATIO_LIN, /* ratio dependent functional response, logistic consumers */
		LRATIO_LOG /* ratio dependent functional response, logistic consumers + resources */
	};
	type t = type::NO_TYPE;
	double r = 0.01;
	double K = 1000.0;
	double a = 0.1;
	double b = 0.01;
	double c = 0.01;
	double d = 0.01;
	double g = 0.5;
	double E = 0.0; // constant influx of resources (logistic ratio-dep. model)
	double xmin = 0.0; // do not let x or y fall below this value (if > 0.0)
	double ymin = 0.0;
	
	static bool try_parse_type(const char* x, type& t) {
		if(!x) return false;
		
		switch(x[0]) {
			case 't':
			case 'T':
				t = type::TURCHIN;
				return true;
			case 's':
			case 'S':
				if(x[1] == 'l' || x[1] == 'L') t = type::SOIL_LOG;
				else t = type::SOIL_LIN;
				return true;
			case 'v':
			case 'V':
				if(x[1] == 'l' || x[1] == 'L') t = type::VOLTERRA_LOG;
				else t = type::VOLTERRA_LIN;
				return true;
			case 'r':
			case 'R':
				switch(x[1]) {
					case 'm':
					case 'M':
						if(x[2] == 'l' || x[2] == 'L') t = type::RMA_LOG;
						else if (x[2] == 0) t = type::RMA_LIN;
						else return false;
						return true;
					case 'l':
					case 'L':
						t = type::RATIO_LOG;
						return true;
					case 0:
						t = type::RATIO_LIN;
						return true;
					default:
						return false;
				}
			case 'l':
			case 'L':
				switch(x[1]) {
					case 'l':
					case 'L':
						t = type::LRATIO_LOG;
						return true;
					case 'r':
					case 'R':
						if(x[2] == 'l' || x[2] == 'L') t = type::RMA_LOG_LOG;
						else if (x[2] == 0) t = type::RMA_LOG_LIN;
						else return false;
						return true;
					case 0:
						t = type::LRATIO_LIN;
						return true;
					default:
						return false;
				}
			default:
				return false;
		}
	}
	
	// return if x should be limited to strictly below K
	static bool limit_x(type t) {
		switch(t) {
			case type::TURCHIN:
			case type::SOIL_LOG:
			case type::SOIL_LIN:
			case type::LRATIO_LIN:
			case type::LRATIO_LOG:
				return true;
			default:
				return false;
		}
	}
	bool limit_x() const { return limit_x(t); }
	
	// return if y should be limited to strictly below K
	static bool limit_y(type t) {
		switch(t) {
			case type::VOLTERRA_LOG:
			case type::VOLTERRA_LIN:
			case type::SOIL_LOG:
			case type::SOIL_LIN:
			case type::RMA_LOG:
			case type::RMA_LIN:
			case type::RATIO_LIN:
			case type::RATIO_LOG:
			case type::LRATIO_LIN:
			case type::LRATIO_LOG:
				return true;
			default:
				return false;
		}
	}
	bool limit_y() const { return limit_y(t); }
	
	// get the value of the stationary solution
	void get_sol(double x[2]) const {
		switch(t) {
			case type::VOLTERRA_LOG:
				x[0] = c * K * ( 1.0 - d / b) / a;
				x[1] = d * K / b;
				break;
			case type::VOLTERRA_LIN:
				x[0] = c * K * ( b / d - 1.0) / a;
				x[1] = d * K / b;
				break;
			case type::SOIL_LOG:
				x[0] = c * K / (a + c);
				x[1] = x[0];
				break;
			case type::SOIL_LIN:
				x[0] = K * c * (sqrt(1.0 + 4.0*a/c) - 1.0) / (2.0 * a);
				x[1] = x[0];
				break;
			case type::TURCHIN:
				x[0] = 0.5 * b * r * (sqrt(1.0 + 4.0*a / (b*r)) - 1) / a;
				x[1] = r * (1.0 - x[0]);
				x[0] *= K;
				break;
			case type::RMA_LOG:
			case type::RMA_LIN:
				x[1] = K * d / (b - d * g);
				x[0] = K * (c * b / a) * (b - (1.0 + g) * d) / (b - g * d);
				if(t == type::RMA_LOG) x[0] /= (b - g * d);
				else x[0] /= d;
				break;
			case type::RATIO_LIN:
				x[1] = c * K / (c + a - a * g * d / b);
				x[0] = x[1] * (b / d - g);
				break;
			case type::RATIO_LOG:
				//!! TODO: E term is not taken into account here!
				x[1] = K * (1.0 - (a / c) * (1 - d * g / b));
				x[0] = x[1] * (b / d - g);
				break;
			case type::LRATIO_LIN:
				x[1] = K * c * (1.0 + g) / (a + c * (1.0 + g));
				x[0] = x[1];
				break;
			case type::LRATIO_LOG:
				x[1] = K * (1.0 - (a / c) * 1.0 / (1.0 + g));
				x[0] = x[1];
				break;
			default:
				throw std::runtime_error(""Stationary solution not implemented for the requested model type!\n"");
		}
	}
	
	/*
	 * Calculate the eigenvalues of the Jacobian at the stationary solution,
	 * return the two parts of the expression and true / false based on
	 * whether there is an imaginary part.
	 * I.e. if the return value is true, than the eigenvalues are
	 * x[0] +/- i x[1]
	 * otherwise
	 * x[0] +/- x[1]
	 */
	bool get_jac_comp(double x[2]) const {
		double tmp1;
		double scale;
		switch(t) {
			case type::VOLTERRA_LOG:
				tmp1 = c * d / b;
				x[0] = -0.5 * tmp1;
				tmp1 = tmp1 * tmp1 - 4 * tmp1 * (b - d);
				scale = 0.5;
				break;
			case type::SOIL_LOG:
				tmp1 = r + c*c / (a + c);
				x[0] = -1.0 * tmp1 / 2.0;
				tmp1 = tmp1 * tmp1 - 4 * r * c;
				scale = 0.5;
				break;
			case type::SOIL_LIN:
				{
					double xs = c * (sqrt(1.0 + 4.0*a/c) - 1.0) / (2.0 * a);
					tmp1 = -r - c - a * xs;
					x[0] = tmp1 / 2.0;
					tmp1 = tmp1 * tmp1 - 4.0 * c * r - 8.0 * a * r * xs;
					scale = 0.5;
				}
				break;
			case type::VOLTERRA_LIN:
				tmp1 = b * c / d;
				x[0] = -1.0 * tmp1 / 2.0;
				tmp1 = tmp1 * tmp1 - 4.0 * c * (b - d);
				scale = 0.5;
				break;
			case type::TURCHIN:
				{
					double xs = 0.5 * b * r * (sqrt(1.0 + 4.0*a / (b*r)) - 1) / a;
					tmp1 = -b - r * xs;
					x[0] = 0.5 * tmp1;
					tmp1 = tmp1 * tmp1 - 8.0 * b * r + 4.0 * b * r * xs;
					scale = 0.5;
					break;
				}
			case type::RATIO_LIN:
				{
					double tmp2 = (b - g * d) / (b * d);
					double aa = a * tmp2;
					// double bb = b * tmp2;
					double cc = c * tmp2;
					double dd = d * tmp2;
					double B1 = (aa + 1) * dd * dd + cc;
					double C1 = cc * dd * dd + aa * dd * dd * dd;
					x[0] = -0.5 * B1;
					tmp1 = B1 * B1 - 4.0 * C1;
					scale = 0.5;
					break;
				}
			case type::RATIO_LOG:
				{
					//!! TODO: E term is not taken into account here!
					double tmp2 = (b - g * d) / (b * d);
					double aa = a * tmp2;
					// double bb = b * tmp2;
					double cc = c * tmp2;
					double dd = d * tmp2;
					// double gg = d * e / (b - d * e);
					double B1 = (aa + 1) * dd * dd + cc - 2 * aa * dd;
					double C1 = cc * dd * dd - aa * dd * dd * dd;
					x[0] = -0.5 * B1;
					tmp1 = B1 * B1 - 4.0 * C1;
					scale = 0.5;
					break;
				}
			case type::RMA_LIN:
				{
					double x1 = d / (b - d * g);
					double B = c * (1.0 + (1.0 - x1) / (x1 * (1.0 + g * x1)) );
					double C = c * d * (1.0 - x1) / (x1 * (1.0 + g * x1));
					x[0] = -0.5 * B;
					tmp1 = B * B - 4.0 * C;
					scale = 0.5;
				}
				break;
			case type::RMA_LOG:
				{
					double x1 = d / (b - d * g);
					double B = c * ((1.0 - x1) / (1.0 + g * x1) + 2.0 * x1 - 1.0);
					double C = c * d * (1.0 - x1) / (1.0 + g * x1);
					x[0] = -0.5 * B;
					tmp1 = B * B - 4.0 * C;
					scale = 0.5;
				}
				break;
			case type::LRATIO_LIN:
				{
					double TrJ = -1.0 * r - c - a / ((1.0 + g)*(1.0 + g));
					double DetJ = r * (c + a / (1.0 + g));
					x[0] = 0.5 * TrJ;
					tmp1 = TrJ * TrJ - 4.0 * DetJ;
					scale = 0.5;
				}
				break;
			case type::LRATIO_LOG:
				{
					double TrJ = -1.0 * r - c - a / ((1.0 + g)*(1.0 + g)) + 2.0 * a / (1.0 + g);
					double DetJ = r * (c - a / (1.0 + g));
					x[0] = 0.5 * TrJ;
					tmp1 = TrJ * TrJ - 4.0 * DetJ;
					scale = 0.5;
				}
				break;
			default:
				throw std::runtime_error(""Jacobian eigenvalues not implemented for the requested model type!\n"");
		}
		
		if(tmp1 >= 0.0) {
			x[1] = sqrt(tmp1) * scale;
			return false;
		}
		x[1] = sqrt(-1.0 * tmp1) * scale;
		return true;
	}
	
	/* print (the beginning) of a file header with the names of important parameters */
	void print_header(FILE* f, char sep, bool newline = false) const {
		switch(t) {
			case type::VOLTERRA_LOG:
			case type::VOLTERRA_LIN:
				fprintf(f, ""a%1$cb%1$cc%1$cd%1$cr%1$cK"", sep);
				break;
			case type::SOIL_LOG:
			case type::SOIL_LIN:
				fprintf(f, ""a%1$cc%1$cr%1$cK"", sep);
				break;
			default:
				throw std::runtime_error(""Parameter output not implemented for the requested model type!\n"");
		}
		if(newline) putc('\n', f);
		else putc(sep, f);
	}
	
	/* print the current value of parameters that are used by the current model */
	void print_pars(FILE* f, char sep, bool newline = false) const {
		switch(t) {
			case type::VOLTERRA_LOG:
			case type::VOLTERRA_LIN:
				fprintf(f,""%2$f%1$c%3$f%1$c%4$f%1$c%5$f%1$c%6$f%1$c%7$f"", sep, a, b, c, d, r, K);
				break;
			case type::SOIL_LOG:
			case type::SOIL_LIN:
				fprintf(f,""%2$f%1$c%3$f%1$c%4$f%1$c%5$f"", sep, a, c, r, K);
				break;
			default:
				throw std::runtime_error(""Parameter output not implemented for the requested model type!\n"");
		}
		if(newline) putc('\n', f);
		else putc(sep, f);
	}
	
	
	/* set the a parameter automatically based on the values of b, c, d
	 * in the case of the Volterra and RMA model variants */
	void set_auto_a() {
		switch(t) {
			case type::VOLTERRA_LOG:
				a = (1.0 - d / b) * c * b / d;
				r = b - d;
				break;
			case type::VOLTERRA_LIN:
				a = (1.0 - d / b) * c * b * b / d / d;
				r = b - d;
				break;
			case type::RMA_LOG:
				r = (b / (g + 1.0) - d);
				if(r < 0.0) throw std::runtime_error(""set_auto_a(): parameters are out of range!\n"");
				a = c * ( (g + 1.0) * (g + 1.0) * (r + d) * r ) / (d * d + d * (g + 1.0) * r);
				break;
			case type::RMA_LIN:
				r = (b / (g + 1.0) - d);
				if(r < 0.0) throw std::runtime_error(""set_auto_a(): parameters are out of range!\n"");
				a = c * r * (r + d) * (1.0 + g) * (1.0 + g) / d / d;
				break;
			default:
				throw std::runtime_error(""Auto-adjustment of the a parameter is not supported for this model variant!\n"");
		}
	}
	
	/* set the b and d parameters automatically based on the values of a, c, r
	 * in the case of the Volterra model, the RMA model and their linear variants */
	void set_auto_bd() {
		switch(t) {
			case type::VOLTERRA_LOG:
				d = r * c / a;
				b = d + r;
				break;
			case type::VOLTERRA_LIN:
				d = 0.5 * c * r * (1.0 + sqrt(1 + 4.0*a/c)) / a;
				b = a*d*d/c/r;
				break;
			case type::RMA_LOG:
				{
					double tmp1 = (g + 1.0)*(g + 1.0) * c / a;
					double tmp2 = tmp1 - (g + 1.0);
					double tmp3 = tmp2*tmp2 + 4.0*tmp1;
					double tmp4 = 0.5 * (tmp2 + sqrt(tmp3));
					d = tmp4 * r;
					b = (r + d) * (g + 1.0);
				}
				break;
			case type::RMA_LIN:
				{
					double tmp1 = (g + 1.0)*(g + 1.0) * c / a;
					double tmp2 = 0.5 * (tmp1 + sqrt(tmp1*tmp1 + 4.0*tmp1));
					d = tmp2 * r;
					b = (r + d) * (g + 1.0);
				}
				break;
			default:
				throw std::runtime_error(""Auto-adjustment of the b and d parameters is not supported for this model variant!\n"");
		}
	}

	int dfunc(double t, const double y1[], double dydt[]) const {
		double x = y1[0];
		double y = y1[1];
		
		switch(this->t) {
			case params::type::TURCHIN:
				dydt[0] = r * x * (1 - x / K) - c * x * y; // x: population
				dydt[1] = a * x * x / (K * K) - b * y; // y: warfare level
				break;
			case params::type::VOLTERRA_LIN:
				dydt[0] = -1.0 * d * x + b * x * y / K; // x: population
				dydt[1] = c * (K - y) - a * x * y / K; // y: resource level
				break;
			case params::type::VOLTERRA_LOG:
				dydt[0] = -1.0 * d * x + b * x * y / K; // x: population
				dydt[1] = c * y * (1 - y / K) - a * x * y / K; // y: resource level
				break;
			case params::type::SOIL_LIN:
				dydt[0] = r * x * (1 - x / y); // x: population
				dydt[1] = c * (K - y) - a * x * y / K; // y: resource level
				break;
			case params::type::SOIL_LOG:
				dydt[0] = r * x * (1 - x / y); // x: population
				dydt[1] = c * y * (1 - y / K) - a * x * y / K; // y: resource level
				break;
			case params::type::RMA_LIN:
				dydt[0] = -1.0 * d * x + b * x * y / (K + g * y); // x: population
				dydt[1] = c * (K - y) - a * x * y / (K + g * y); // y: resource level
				break;
			case params::type::RMA_LOG:
				dydt[0] = -1.0 * d * x + b * x * y / (K + g * y); // x: population
				dydt[1] = c * y * (1 - y / K) - a * x * y / (K + g * y); // y: resource level
				break;
			case params::type::RMA_LOG_LIN:
				dydt[0] = r * x * (1 - x / y); // x: population
				dydt[1] = c * (K - y) - a * x * y / (K + g * y); // y: resource level
				break;
			case params::type::RMA_LOG_LOG:
				dydt[0] = r * x * (1 - x / y); // x: population
				dydt[1] = c * y * (1 - y / K) - a * x * y / (K + g * y); // y: resource level
				break;
			case params::type::RATIO_LIN:
				dydt[0] = b * x * y / (x + g * y) - d * x; // x: population
				dydt[1] = c * (K - y) - a * x * y / (x + g * y); // y: resource level
				break;
			case params::type::RATIO_LOG:
				dydt[0] = b * x * y / (x + g * y) - d * x; // x: population
				dydt[1] = c * y * (1.0 - y / K) - a * x * y / (x + g * y) + E; // y: resource level
				break;
			case params::type::LRATIO_LIN:
				dydt[0] = r * x * (1 - x / y); // x: population
				dydt[1] = c * (K - y) - a * x * y / (x + g * y); // y: resource level
				break;
			case params::type::LRATIO_LOG:
				dydt[0] = r * x * (1 - x / y); // x: population
				dydt[1] = c * y * (1.0 - y / K) - a * x * y / (x + g * y) + E; // y: resource level
				break;
			default:
				return GSL_EBADFUNC;
		}
		
		return GSL_SUCCESS;
	}
};

int dfunc(double t, const double y1[], double dydt[], void* params1) {
	const params& pars = *(const params*)params1;
	return pars.dfunc(t, y1, dydt);
}


int get_segment(double dydt[2]) {
	const double eps = 1e-15;
	if(fabs(dydt[0]) < eps || fabs(dydt[1]) < eps) return 0;
	if(dydt[0] > 0.0) {
		if(dydt[1] > 0.0) return 1;
		else return 2;
	}
	else if(dydt[1] > 0.0) return 4;
	return 3;
}


/* run one instance of the simulation from the given initial conditions using the given parameters */
int do_one_run(const params& pars, const double y0[2], double tmax, double dt, bool fixed_step, double noise_x,
		double noise_y, bool discrete_noise, FILE* fout, FILE* cout, bool cycles_summary, int target_segment,
		std::mt19937_64& rng, char sep, bool output_params) {
	
	std::normal_distribution<double> nx(0.0, noise_x > 0.0 ? noise_x : 1.0);
	std::normal_distribution<double> ny(0.0, noise_y > 0.0 ? noise_y : 1.0);
	
	gsl_odeiv2_system sys = {dfunc, nullptr, 2, const_cast<params*>(&pars)};
	gsl_odeiv2_driver* d = nullptr;
	if(fixed_step <= 0.0) d = gsl_odeiv2_driver_alloc_y_new(&sys, gsl_odeiv2_step_rkf45, 1e-6, 1e-6, 0.0);
	
	double t = 0.0;
	double y1[] = {y0[0], y0[1]};
	double dydt[] = {0.0, 0.0};
	int segment = 0; // which segment of the phase space we are in
	double last_t = -1.0; // last time when segment == target_segment
	double ys[] = {0.0, 0.0}; // stationary solution
	double dst[] = {0.0, 0.0}; // distance from the stationary solution
	double step1 = -1.0; // decrease in distance in the first cycle
	double overshoot = -1.0; // maximum overshoot (only calculated if cycles_summary == true)
	const double dist_eps = 1e-6; // stop running in cycles_summary mode if we are this close to the stationary solution
	
	
	if(fout) fprintf(fout, ""%f\t%f\t%f\n"", t, y1[0], y1[1]);
	
	// keep track of the derivatives in dydt
	pars.dfunc(t, y1, dydt);
	
	// calculate the eigenvalues of the Jacobian at the stationary solution if needed
	double j1[2];
	bool ji = false;
	if(cout || cycles_summary) {
		pars.get_sol(ys);
		segment = get_segment(dydt);
		if(segment == target_segment) last_t = t; // note: this is expected
		dst[0] = y1[0] - ys[0];
		dst[1] = y1[1] - ys[1];
		
		ji = pars.get_jac_comp(j1);
		if(!ji) {
			// real eigenvalues, we only care about the larger one
			// (which should still be negative)
			j1[0] += j1[1];
			j1[1] = 0.0;
		}
		if(!cycles_summary)
			fprintf(stderr, ""%f\t%f\t%f\t%f\n"", j1[0], j1[1], ys[0], ys[1]);
	}
	
	bool need_reset = false;
	
	while(tmax > 0.0 && t < tmax) {
		// add noise sampled from a Gaussian to either or both variables
		if(noise_x > 0.0) y1[0] = std::max(0.0, y1[0] + nx(rng) * y1[0]);
		if(noise_y > 0.0) y1[1] = std::max(0.0, y1[1] + ny(rng) * y1[1]);
		
		if(fixed_step) {
			for(int i = 0; i < 2; i++) if(discrete_noise && dydt[i] != 0.0) {
				bool xn = false;
				if(dydt[i] < 0.0) {
					xn = true;
					dydt[i] *= -1.0;
				}
				std::exponential_distribution<double> ed1(1.0 / dydt[i]);
				dydt[i] = ed1(rng);
				if(xn) dydt[i] *= -1.0;
			}
			y1[0] += dydt[0];
			y1[1] += dydt[1];
			if(y1[0] < 0.0) y1[0] = 0.0; // all variables are constrained to >= 0
			if(y1[1] < 0.0) y1[1] = 0.0;
			if(pars.limit_x() && y1[0] > pars.K) y1[0] = pars.K;
			if(pars.limit_y() && y1[1] > pars.K) y1[1] = pars.K;
			t += dt;
		}
		else {
			if(noise_x > 0.0 || noise_y > 0.0) need_reset = true;
			if(need_reset) { gsl_odeiv2_driver_reset(d); need_reset = false; }
			double t1 = t + dt;
			int r = gsl_odeiv2_driver_apply(d, &t, t1, y1);
			if(r != GSL_SUCCESS) {
				fprintf(stderr, ""Error advancing the solution (%d)!\n"", r);
				gsl_odeiv2_driver_free(d);
				return r;
			}
			if(pars.xmin > 0.0) if(y1[0] < pars.xmin) {
				y1[0] = pars.xmin;
				need_reset = true;
			}
			if(pars.ymin > 0.0) if(y1[1] < pars.ymin) {
				y1[1] = pars.ymin;
				need_reset = true;
			}
		}
		
		if(cycles_summary && y1[0] > ys[0] && y1[0] > overshoot) overshoot = y1[0];
		
		if(fout) fprintf(fout, ""%f\t%f\t%f\n"", t, y1[0], y1[1]);
		
		// calculate the new derivatives, test if they are in the same segment if needed
		if(cout || cycles_summary || fixed_step) pars.dfunc(t, y1, dydt);
		if(cout || cycles_summary) {
			int seg2 = get_segment(dydt);
			
			double d2;
			double dst2[] = {0.0, 0.0};
			
			if(seg2 == target_segment || cycles_summary) {
				dst2[0] = y1[0] - ys[0];
				dst2[1] = y1[1] - ys[1];
				d2 = sqrt(dst2[0]*dst2[0] + dst2[1]*dst2[1]);
				if(cycles_summary && d2 < dist_eps) break;
			}
			
			if(seg2 != 0 && seg2 != segment) { // only process derivatives if they are not close to zero
				// check if the progression is ""valid"", i.e. we didn't skip a segment
				if(seg2 == segment + 1 || (seg2 == 1 && segment == 4)) {
					// valid progression, update segment
					segment = seg2;
				}
				else {
					// invalid progression (probably we are too close to the stationary solution),
					// stop evaluating this
					cout = nullptr;
					if(cycles_summary) break;
				}
				
				if((segment == target_segment) && cout) {
					if(last_t >= 0.0) {
						double tmp1 = dst2[0] / dst[0];
						double tmp2 = dst2[1] / dst[1];
						double d1 = sqrt(dst[0]*dst[0] + dst[1]*dst[1]);
						
						double tmp3 = d2 / d1;
						if(cycles_summary) {
							step1 = tmp3;
							break;
						}
						fprintf(cout, ""%f\t%f\t%f\t%f\n"", t - last_t, tmp1, tmp2, tmp3);
					}
					last_t = t;
					dst[0] = dst2[0];
					dst[1] = dst2[1];
				}
			}
		}
	}
	
	if(d) gsl_odeiv2_driver_free(d);
	
	if(cycles_summary) {
		if(overshoot > 0.0) overshoot = (overshoot - ys[0]) / ys[0];
		FILE* f1 = stdout;
		if(output_params) pars.print_pars(f1, sep, false);
		fprintf(f1, ""%2$f%1$c%3$f%1$c%4$f%1$c%5$f\n"", sep, j1[0], j1[1], step1 > 0.0 ? step1 : NAN, std::max(overshoot, 0.0));
	}
	
	return 0;
}


int main(int argc, char **argv) {
	params pars;
	double x = 100.0;
	double y = 10.0;
	double tmax = 500.0; // maximum time
	bool tmax_par = false; // whether the above was read as a command line parameter
	double dt = 1.0; // time step for output
	bool fixed_step = false; // if true, instead of running a solver,
	// use discrete-time steps (of e.g. 1 year), essentially evolving
	// the system as a difference equation
	double noise_x = 0.0; // add noise from a Gaussian with this relative scale
	double noise_y = 0.0; // to the x or y variables in each year
	bool discrete_noise = false; // add noise in the discrete model
	// directly to the yearly differences
	uint64_t seed = time(0);
	char* cycles_out = nullptr; // output info about convergence per cycles
	bool cycles_summary = false; // only output some summary info:
	// decrease of distance after the first cycle, eigenvalues and maximum overshoot
	int target_segment = 1; // which segment to consider as the target for convergence analysis
	
	bool auto_a = false; // adjust the a parameter automatically (only works for the VOLTERRA_LOG and VOLTERRA_LIN model versions)
	bool auto_bd = false; // adjust the b and d parameters automatically (only works for the VOLTERRA_LOG and VOLTERRA_LIN model versions)
	
	bool multi_run = false; // repeated runs with cycles_summary == true
	double amin, amax, astep = -1.0;
	double bmin, bmax, bstep = -1.0;
	double  [MASK] , cmax, cstep = -1.0;
	
	bool flush = false;
	
	for(int i = 1; i < argc; i++) if(argv[i][0] == '-') switch(argv[i][1]) {
		case 'M':
			{
				multi_run = true;
				double min1 = atof(argv[i+1]);
				double step1 = atof(argv[i+2]);
				double max1 = atof(argv[i+3]);
				switch(argv[i][2]) {
					case 'a':
						amin = min1; amax = max1; astep = step1;
						break;
					case 'b':
						bmin = min1; bmax = max1; bstep = step1;
						break;
					case 'c':
						 [MASK]  = min1; cmax = max1; cstep = step1;
						break;
					default:
						fprintf(stderr, ""Unknown parameter: %s!\n"", argv[i]);
						return 1;
				}
				i += 3;
				break;
			}
		case 'a':
			if(argv[i+1][0] == '-' && argv[i+1][1] == 0) auto_a = true;
			else pars.a = atof(argv[i+1]);
			i++;
			break;
		case 'b':
			if(argv[i+1][0] == '-' && argv[i+1][1] == 0) auto_bd = true;
			pars.b = atof(argv[i+1]);
			i++;
			break;
		case 'c':
			pars.c = atof(argv[i+1]);
			i++;
			break;
		case 'd':
			if(argv[i+1][0] == '-' && argv[i+1][1] == 0) auto_bd = true;
			pars.d = atof(argv[i+1]);
			i++;
			break;
		case 'g':
			pars.g = atof(argv[i+1]);
			i++;
			break;
		case 'r':
			pars.r = atof(argv[i+1]);
			i++;
			break;
		case 'K':
			pars.K = atof(argv[i+1]);
			i++;
			break;
		case 't':
			if(!params::try_parse_type(argv[i+1], pars.t)) {
				fprintf(stderr, ""Unknown model type: %s!\n"", argv[i+1]);
				return 1;
			}
			i++;
			break;
		case 'x':
			x = atof(argv[i+1]);
			i++;
			break;
		case 'y':
			y = atof(argv[i+1]);
			i++;
			break;
		case 'm':
			switch(argv[i][2]) {
				case 'x':
					pars.xmin = atof(argv[i+1]);
					i++;
					break;
				case 'y':
					pars.ymin = atof(argv[i+1]);
					i++;
					break;
				default:
					fprintf(stderr, ""Unknown parameter: %s!\n"", argv[i]);
					return 1;
			}
			break;
		case 'T':
			tmax = atof(argv[i+1]);
			tmax_par = true;
			i++;
			break;
		case 'D':
			dt = atof(argv[i+1]);
			i++;
			break;
		case 'E':
			pars.E = atof(argv[i+1]);
			i++;
			break;
		case 'F':
			fixed_step = true;
			break;
		case 'N':
			switch(argv[i][2]) {
				case 'x':
					noise_x = atof(argv[i+1]);
					i++;
					break;
				case 'y':
					noise_y = atof(argv[i+1]);
					i++;
					break;
				case 0:
					noise_x = atof(argv[i+1]);
					noise_y = noise_y;
					i++;
					break;
				case 'd':
					discrete_noise = true;
					break;
				default:
					fprintf(stderr, ""Unknown parameter: %s!\n"", argv[i]);
					return 1;
			}
			break;
		case 's':
			seed = strtoul(argv[i+1], nullptr, 10);
			i++;
			break;
		case 'C':
			switch(argv[i][2]) {
				case 0:
					cycles_out = argv[i+1];
					i++;
					break;
				case 's':
					target_segment = atoi(argv[i+1]);
					i++;
					if(target_segment < 1 || target_segment > 4) {
						fprintf(stderr, ""Invalid value for target segment: %s %s!\n"", argv[i], argv[i+1]);
						return 1;
					}
					break;
				case 'S':
					cycles_summary = true;
					if(!tmax_par) tmax = -1.0;
					break;
				default:
					fprintf(stderr, ""Unknown parameter: %s!\n"", argv[i]);
					return 1;
			}
			break;
		case 'f':
			flush = true;
			break;
		default:
			fprintf(stderr, ""Unknown parameter: %s!\n"", argv[i]);
			return 1;
	}
	else {
		fprintf(stderr, ""Unknown parameter: %s!\n"", argv[i]);
		return 1;
	}
	
	if(pars.t == params::type::NO_TYPE) {
		fprintf(stderr, ""Type of system not given!\n"");
		return 1;
	}
	
	if(multi_run) {
		cycles_summary = true;
		switch(pars.t) {
			case params::type::VOLTERRA_LOG:
			case params::type::VOLTERRA_LIN:
				if((bstep <= 0.0 && astep <= 0.0) || cstep <= 0.0) throw std::runtime_error(""Missing parameters!\n"");
				if(bstep > 0.0 && astep > 0.0) throw std::runtime_error(""Invalid parameter combination!\n"");
				break;
			case params::type::SOIL_LIN:
			case params::type::SOIL_LOG:
				if(astep <= 0.0 || cstep <= 0.0) throw std::runtime_error(""Missing parameters!\n"");
				break;
			default:
				throw std::runtime_error(""Repeated runs not supported for the given model variant!\n"");
		}
	}
	else {
		if(auto_a && auto_bd) throw std::runtime_error(""Unsupported parameter combination (either a or b and d must be specified)!\n"");
		if(auto_a) { pars.set_auto_a(); fprintf(stderr, ""%f\n"", pars.a); }
		if(auto_bd) { pars.set_auto_bd(); fprintf(stderr, ""%f\t%f\n"", pars.b, pars.d); }
	}
	
	std::mt19937_64 rng(seed);
	
	FILE* fout = stdout;
	FILE* cout = nullptr;
	if(cycles_summary) fout = nullptr;
	else if(cycles_out) {
		if(cycles_out[0] == '-' && cycles_out[1] == 0) {
			cout = stdout;
			fout = nullptr;
		}
		else {
			cout = fopen(cycles_out, ""w"");
			if(!cout) {
				fprintf(stderr, ""Error opening output file %s!\n"", cycles_out);
				return 1;
			}
		}
	}
	
	double y0[] = {x, y};
	
	if(multi_run) {
		pars.print_header(stdout, ',', false);
		fprintf(stdout, ""lambda_re,lambda_im,step1,overshoot\n"");
		switch(pars.t) {
			case params::type::VOLTERRA_LOG:
			case params::type::VOLTERRA_LIN:
				if(bstep > 0.0) {
					for(pars.b = bmin; pars.b <= bmax; pars.b += bstep)
					for(pars.c =  [MASK] ; pars.c <= cmax; pars.c += cstep) {
						if(auto_a) pars.set_auto_a();
						do_one_run(pars, y0, tmax, dt, fixed_step, noise_x, noise_y, discrete_noise,
							fout, cout, cycles_summary, target_segment, rng, ',', true);
						if(flush) fflush(stdout);
					}
					break;
				}
				else auto_bd = true; // fallthrough in this case
			case params::type::SOIL_LIN:
			case params::type::SOIL_LOG:
				{
					for(pars.a = amin; pars.a <= amax; pars.a += astep)
					for(pars.c =  [MASK] ; pars.c <= cmax; pars.c += cstep) {
						if(auto_bd) pars.set_auto_bd();
						do_one_run(pars, y0, tmax, dt, fixed_step, noise_x, noise_y, discrete_noise,
							fout, cout, cycles_summary, target_segment, rng, ',', true);
						if(flush) fflush(stdout);
					}
				}
				break;
			default:
				// note: this is already handled in line 802
				throw std::runtime_error(""Repeated runs not supported for the given model variant!\n"");
		}
	}
	else do_one_run(pars, y0, tmax, dt, fixed_step, noise_x, noise_y, discrete_noise, fout, cout,
		cycles_summary, target_segment, rng, '\t', false);
	
	if(cout && cout != stdout) fclose(cout);
	
	return 0;
}

",cmin
614,"#include ""entity.hpp""

Entity::Entity() : entitySprite(entityTexture){
  initEntity();
}

void Entity::initEntity() {
  tex.size = 16;
  tex.XIndex = 1;
  tex.YIndex = 0;

  sf::Texture* loadedTex = &tm.loadTexture(""../assets/tileset.png"", false, tex.size, tex.XIndex, tex.YIndex);
  entityTexture = *loadedTex;
  entitySprite.setTexture(entityTexture);
  entitySprite.setTextureRect(sf::IntRect(
    {static_cast<int>(tex.size) * static_cast<int>(tex.XIndex),
     static_cast<int>(tex.size) * static_cast<int>(tex.YIndex)},
    {static_cast<int>(tex.size), static_cast<int>(tex.size)}
  ));
  entitySprite.setPosition(d.position);
}

sf::FloatRect Entity::getEntityBounds() {
  return entitySprite.getGlobalBounds();
}


void Entity::resloveCollision(bool collided){
  if(collided){
  if (d.velocity.y > 0) {
      d.velocity.y = 0;
      d.position.y = std::floor(d.position.y / tex.size) * tex.size;
    }
    d.onGround = true;
  } else {
    d.onGround = false;
  }
}

void Entity::updateEntity(float dt, bool collided) {
  resloveCollision(collided);
  gravity(dt);
  move();
  jump(dt);
  d.position += d.velocity * dt;
  entitySprite.setPosition(d.position);
}

void Entity::setEntityCollisionLayer(collisionLayer entitycl){
  cl = entitycl; 
}

void Entity::setEntityCollisionMask(std::vector<collisionLayer> entityMask){
  entityCollisionMask = entityMask;
}

collisionLayer Entity::getEntityCollisionLayer(){
  return cl;
}

std::vector<collisionLayer> Entity::getEntityCollisionMask(){
  return entityCollisionMask;
}

sf::Vector2f Entity::getPosition(){
  return d.position;
}

void Entity::gravity(float dt) {
  if (!d.onGround) {
    d.velocity.y += d.g * dt;
    if (d.velocity.y > d.max_g) {
      d.velocity.y = d.max_g;
    }
  }
}

void Entity::jump(float dt){
  if(d.onGround &&sf::Keyboard::isKeyPressed(sf::Keyboard::Key::W)){
    d.velocity.y -= d.jumpHeight;
    d.canJump = false;
  }else{
    d.canJump = true;
  }
}

void Entity::move() {
  if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::A)) {
    d.velocity.x = -d.speed;
  } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::D)) {
    d.velocity.x = d.speed;
  } else {
    d.velocity.x = 0;
  }
}

void Entity::draw(sf::RenderTarget& target, sf::RenderStates  [MASK] ) const {
  target.draw(entitySprite,  [MASK] );
}
",states
615,"/*

Copyright (C) 2015-2020 <NAME>

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 ""boost/property_tree/ptree.hpp""
#include ""boost/property_tree/ini_parser.hpp""
#include ""boost/algorithm/string.hpp""

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>

#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>

#ifdef __linux__
#include <linux/sockios.h>
#endif

char version[] = ""NXCORE Manager, Kenwood, version 1.4.6"";
char copyright[] = ""Copyright (C) <NAME>, 2015-2020"";

struct rpt {
	struct sockaddr_in rpt_addr_00; // socket address for 64000
	struct sockaddr_in rpt_addr_01; //socket address for 64001
	char *hostname;
	int time_since_rx;  // in seconds
	int time_since_tx;  // in seconds
	int hold_time;  // how long to hold talkgroup
	int tx_hold_time;  // how long to hold talkgroup after tx
	int rx_activity;     // flag to show receive activity
	int tx_busy;     // flag to show transmit activity
	int busy_tg;     // talkgroup being transmitted
	int stealth; // send heartbeat or not
	unsigned char tx_ran;	
	unsigned char rx_ran;	
	int active_tg; // talkgroup currently active
	int last_tg;  // used for talk group hold time
	int *tg_list;   // if a talkgroup isn't in this list, it isn't repeated
	int *tac_list;   // Tactical talkgroups (only comes through if received) 
	int uid; // need this for Kenwood udp 64001 data
	int tx_uid; // UID on repeater transmitting
	int tx_otaa;
	int keydown;
	int snd_queue;
	int disable;
        int tg_network_on;
        int tg_network_off;
	int msg_flag;

} *repeater;


// RAN is at up_packet[24]

unsigned char up_packet[28] = { 0x8a, 0xcc, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, \
			0x4b, 0x57, 0x4e, 0x45, 0x00, 0x00, 0x00, 0x00, \
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, \
			0x00, 0x01, 0x00, 0x00 };

unsigned char down_packet[20] = { 0x8b, 0xcc, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, \
			0x4b, 0x57, 0x4e, 0x45, 0x00, 0x00, 0x00, 0x00, \
			0x01, 0x00, 0x00, 0x00 };


void rpton_64001(int);
void shutdown_64001(int);
void snd_packet(unsigned char [], int, int,int, int);
int tg_lookup(int, int);
int tac_lookup(int, int);

int repeater_count;

int debug = 0;

std::vector<std::string> r_list;

unsigned int tempaddr;

int socket_00, socket_01;   // Sockets we use

int tx_sem;  // Semaphore for doing UDP send operations 
int tx_busy_sem;  // Semaphore for keeping transmit busy from a race condition 


void ptime(void)
{
	auto t = std::time(nullptr);
	auto tm = *std::localtime(&t);
	std::cout << std::put_time(&tm, ""%m-%d-%Y %H:%M:%S "") << "":  "";
}



// See if incoming packet address matches a repeater.  If it does,
// return the index to it.  Otherwise return -1 for no match

int get_repeater_id(struct sockaddr_in *addr)
{
	int i;

	for(i = 0; i < repeater_count; i++)
	{	
		if((in_addr_t)addr->sin_addr.s_addr == (in_addr_t)repeater[i].rpt_addr_00.sin_addr.s_addr)
		{
			return i;
		}
	}

	return(-1);
}

struct sockaddr_in myaddr_00;

void *listen_thread(void *thread_id)
{
        struct sockaddr_in remaddr;     /* remote address */
        socklen_t addrlen = sizeof(remaddr);            /* length of addresses */
        int recvlen;                    /* # bytes received */
        unsigned char buf[80];     /* receive buffer */
	int rpt_id;
	int strt_packet;

	struct sockaddr_in tport; // This is a test port to reflect what is received
	int GID, UID, RAN;

        /* create UDP socket for repeaters */

        if ((socket_00 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
                perror(""cannot create socket\n"");
                return 0;
        }

        if ((socket_01 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
                perror(""cannot create socket\n"");
                return 0;
        }

        /* bind the socket to any valid IP address and a specific port */

        memset((char *)&myaddr_00, 0, sizeof(myaddr_00));
        myaddr_00.sin_family = AF_INET;
        myaddr_00.sin_addr.s_addr = htonl(INADDR_ANY);
        myaddr_00.sin_port = htons(64000);

        if (bind(socket_00, (struct sockaddr *)&myaddr_00, sizeof(myaddr_00)) < 0) {
                perror(""bind failed"");
                return 0;
        }

        memset((char *)&myaddr_00, 0, sizeof(myaddr_00));
        myaddr_00.sin_family = AF_INET;
        myaddr_00.sin_addr.s_addr = htonl(INADDR_ANY);
        myaddr_00.sin_port = htons(64001);

        if (bind(socket_01, (struct sockaddr *)&myaddr_00, sizeof(myaddr_00)) < 0) {
                perror(""bind failed"");
                return 0;
        }


	// Set up the test port
	memset((char *)&tport, 0, sizeof(tport));
	tport.sin_family = AF_INET;
	tport.sin_addr.s_addr = inet_addr(""127.0.0.1"");
	tport.sin_port = htons(50000);

        /* now loop, receiving data and printing what we received */
        for (;;) {
                recvlen = recvfrom(socket_00, buf, 80, 0, (struct sockaddr *)&remaddr, &addrlen);

		if (recvlen == -1)
		{
			ptime();
			std::cout << ""Receive socket returned error"" << std::endl;
			continue;
		}

		strt_packet = 0;

		rpt_id = get_repeater_id(&remaddr);
		if ( rpt_id != -1)
		{
			buf[8] = (repeater[rpt_id].rpt_addr_00.sin_addr.s_addr) >> 24;
			buf[9] = ((repeater[rpt_id].rpt_addr_00.sin_addr.s_addr) >> 16) & 0xff;
			buf[10] = ((repeater[rpt_id].rpt_addr_00.sin_addr.s_addr) >> 8) & 0xff;
			buf[11] = (repeater[rpt_id].rpt_addr_00.sin_addr.s_addr) & 0xff;

		}

		// Detect start/stop for voice 

                if (recvlen == 47) {



			if (rpt_id == -1)
			{
				ptime();
				std::cout << "" Unauthorized repeater, ""
					<< inet_ntoa(remaddr.sin_addr)
					<< "", dropping packet"" << std::endl;

				continue;  // Throw out packet, not in our list
			}


			// This would be a start packet
			if((buf[20] == 0x0a) && (buf[21] == 0x05) &&
				(buf[22] == 0x0a) && (buf[23] == 0x10) &&
					(buf[28] == 0x01))
			{
				GID = (buf[31] << 8) + buf[34];
				UID = (buf[29] << 8) + buf[32];
				RAN = buf[24];
				repeater[rpt_id].keydown = 0; // need to stop a shutdown transmission if receiving

				if ((UID==0) && (GID==0))
					continue;

                                if ((repeater[rpt_id].tg_network_off == GID) && (repeater[rpt_id].tg_network_off != 0))
                                {
                                        repeater[rpt_id].disable = 1;
					ptime();
                                        std::cout << ""Repeater  -> "" << r_list[rpt_id]
                                                << "" <- disabled due to TG: "" << GID << std::endl;
					continue;
                                }

                                if ((repeater[rpt_id].tg_network_on == GID) && (repeater[rpt_id].tg_network_on != 0))
                                {
                                        repeater[rpt_id].disable = 0;
					ptime();
                                        std::cout << ""Repeater  ->  "" << r_list[rpt_id]
                                                << "" <- enabled due to TG: "" << GID << std::endl;
					continue;
                                }


				if (RAN != repeater[rpt_id].rx_ran)
				{
					ptime();
					std::cout << ""Repeater  ->"" << r_list[rpt_id]
						<< ""<-  not passing start from UID: "" << UID
						<< "" from TG: "" << GID
						<< "" because RAN: "" << RAN
						<< "" isn't the correct receive RAN"" << std::endl;
					while(tx_sem == 1)
						usleep(1);
				
						tx_sem = 1;
						sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&tport,
		 					sizeof(tport));
						tx_sem = 0;



					repeater[rpt_id].rx_activity = 1;
					repeater[rpt_id].time_since_rx = 0;
					repeater[rpt_id].active_tg = GID;
					repeater[rpt_id].last_tg = GID;
						
					continue;
				}

				repeater[rpt_id].rx_activity = 1;
				repeater[rpt_id].active_tg = GID;
				repeater[rpt_id].busy_tg = GID;
				repeater[rpt_id].uid = UID;
				strt_packet = 1;

				ptime();
				std::cout << ""Repeater  ->"" << r_list[rpt_id]
					<< ""<-  receiving start from UID: "" << UID
					<< "" from TG: "" << GID
					<< "" on RAN: "" << RAN << std::endl;

				repeater[rpt_id].time_since_rx = 0;
			}
		
			// End, send shutdown on 64001	
			if((buf[20] == 0x0a) && (buf[21] == 0x05) &&
				(buf[22] == 0x0a) && (buf[23] == 0x10) &&
					(buf[28] == 0x08))
			{
				GID = (buf[31] << 8) + buf[34];
				UID = (buf[29] << 8) + buf[32];
				RAN = buf[24];
				if ((UID==0) && (GID==0))
					continue;

				if (repeater[rpt_id].rx_activity == 0)
					continue;

				if (RAN != repeater[rpt_id].rx_ran)
				{
					ptime();
					std::cout << ""Repeater  ->"" << r_list[rpt_id]
						<< ""<-  not passing stop from UID: "" << UID
						<< "" from TG: "" << GID
						<< "" because RAN: "" << RAN
						<< "" isn't the correct receive RAN"" << std::endl;

					while(tx_sem == 1)
						usleep(1);	

						tx_sem = 1;
						sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&tport,
		 					sizeof(tport));
						tx_sem = 0;

					// Special case: if no talkgroup and different RAN, assume local
					// and block network activity

					if (GID == 0)
					{
						repeater[rpt_id].rx_activity = 0;
						repeater[rpt_id].time_since_rx = 0;
						repeater[rpt_id].active_tg = GID;
						repeater[rpt_id].last_tg = repeater[rpt_id].active_tg;
					}
					continue;
				}

				repeater[rpt_id].rx_activity = 0;    // Activity on channel is over
				repeater[rpt_id].last_tg = repeater[rpt_id].active_tg;
	
				repeater[rpt_id].time_since_rx = 0;
				ptime();
				std::cout << ""Repeater  ->"" << r_list[rpt_id]
					<< ""<-  receiving stop from UID: "" << UID
					<< "" from TG: "" << GID << std::endl;
			}	


                        if(repeater[rpt_id].disable)
                                continue;
				
			// Need to put GID back if not a start packet

			GID = repeater[rpt_id].active_tg;

			while(tx_sem == 1)
				usleep(1);
			
				tx_sem = 1;
				sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&tport,
		 			sizeof(tport));
				tx_sem = 0;

			snd_packet(buf, recvlen, GID, rpt_id, strt_packet);

				
		}
                
		if ((recvlen == 59) || (recvlen == 53)) {

                        if(repeater[rpt_id].disable)
                                continue;

			if (rpt_id == -1)
			{
				if(debug)
				{
					ptime();
					std::cout << ""Unauthorized repeater, "" 
						<< inet_ntoa(remaddr.sin_addr) 
						<< "", dropping packet"" << std::endl;
				}	

				continue;  // Throw out packet, not in our list
			}	

			// Heartbeat packet from another repeater, bounce back
			// but then continue 
			if ((buf[0] == 0x00) && (buf[1] == 0x00) && (buf[21] == 0x99))
			{
				
				while(tx_sem==1)
					usleep(1);
				tx_sem=1;

				buf[21] = 0x98; // return code so we don't loop

				sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&repeater[rpt_id].rpt_addr_00,
		 			sizeof(repeater[rpt_id].rpt_addr_00));
				tx_sem=0;
				continue; 
			}

			// If we receive a reply, ignore it

			if ((buf[0] == 0x00) && (buf[1] == 0x00) && (buf[21] == 0x98))
				continue;
		

			// Special case where we don't get start packet, if there is activity in 2 seconds
			// and talkgroup matches, just start letting packets through

			// Commenting all this out, causing problems
			//

			//if((repeater[rpt_id].time_since_rx < 2)&&(repeater[rpt_id].time_since_rx > 1)&&(repeater[rpt_id].rx_activity == 0))
			//{
			//		std::cout << ""Repeater ->"" << r_list[rpt_id] << ""<-  Sending non-IDed data through since rx was close enough, TG: ""
			//			<< repeater[rpt_id].active_tg << std::endl;
			//	repeater[rpt_id].rx_activity = 1;
			//	strt_packet=1;
			//}

			repeater[rpt_id].keydown = 0; // need to prevent transmitting shutdown if receive activity

			if (repeater[rpt_id].rx_activity == 0)
			{
				if(debug)
				{
					ptime();
					std::cout << ""Not sending vocoder packet from Repeater "" 
						<< rpt_id << "" due to rx_flag not set"" << std::endl;
				}

				continue;
			}


			repeater[rpt_id].time_since_rx = 0;	
			GID = repeater[rpt_id].active_tg;

			// send packet to repeaters that can receive it


			while(tx_sem==1)
				usleep(1);
			tx_sem=1;
			sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&tport,
		 		sizeof(tport));
			tx_sem=0;

			snd_packet(buf, recvlen, GID, rpt_id, strt_packet);
		}

		if ((recvlen == 43) && (repeater[rpt_id].disable != 1)&&(repeater[rpt_id].msg_flag ==1))
		{

			GID = (buf[26] << 8) + buf[25];
			UID = (buf[24] << 8) + buf[23];
			RAN = buf[20];

			if (RAN != repeater[rpt_id].rx_ran)
			{
				ptime();
				std::cout << ""Repeater  ->"" << r_list[rpt_id]
					<< ""<-  not passing messaging datagram from UID: "" << UID
					<< "" from TG: "" << GID
					<< "" because RAN: "" << RAN
					<< "" isn't the correct receive RAN"" << std::endl;
				while(tx_sem == 1)
					usleep(1);
				
					tx_sem = 1;
					sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&tport,
		 				sizeof(tport));
					tx_sem = 0;

				repeater[rpt_id].rx_activity=0;
				continue;
			}
			// handle start of message

			if((buf[17]==0x06)&&(buf[18]==0x18)&&(buf[21]==0x20))
			{

				repeater[rpt_id].rx_activity = 1;
				repeater[rpt_id].active_tg = GID;
				repeater[rpt_id].busy_tg = GID;
				repeater[rpt_id].uid = UID;
				strt_packet = 1;

				ptime();
				std::cout << ""Repeater  ->"" << r_list[rpt_id]
					<< ""<-  receiving message start from UID: "" << UID
					<< "" from TG: "" << GID
					<< "" on RAN: "" << RAN << std::endl;

				repeater[rpt_id].time_since_rx = 0;
			}
	
			if((buf[17]==0x01)&&(buf[18]==0x18))
			{

				repeater[rpt_id].rx_activity = 1;
				GID = repeater[rpt_id].active_tg;
				UID = repeater[rpt_id].uid;

				ptime();
				std::cout << ""Repeater  ->"" << r_list[rpt_id]
					<< ""<-  receiving message data from UID: "" << UID
					<< "" from TG: "" << GID
					<< "" on RAN: "" << RAN << std::endl;

				repeater[rpt_id].time_since_rx = 0;
			}
	

			if((buf[17]==0x06)&&(buf[18]==0x18)&&((buf[21]==0x10)||buf[19]==0x08))
			{
				repeater[rpt_id].rx_activity = 0;    // Activity on channel is over
				repeater[rpt_id].last_tg = repeater[rpt_id].active_tg;
	
				repeater[rpt_id].time_since_rx = 0;
				ptime();
				std::cout << ""Repeater  ->"" << r_list[rpt_id]
					<< ""<-  receiving message stop from UID: "" << UID
					<< "" from TG: "" << GID << std::endl;

				repeater[rpt_id].time_since_rx = 0;	
				GID = repeater[rpt_id].active_tg;
			}

			// send packet to repeaters that can receive it


			while(tx_sem==1)
				usleep(1);
			tx_sem=1;
			sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&tport,
		 		sizeof(tport));
			tx_sem=0;

			snd_packet(buf, recvlen, GID, rpt_id, strt_packet);

		}
		
        }	
}


void snd_packet(unsigned char buf[], int recvlen, int GID, int rpt_id, int strt_packet)
{
	int i;
	int tg;
	int tac_flag;
	int o_bufsize;


	// This blocks talkgroups received on a repeater that don't match
	// the talkgroup list

	if (tg_lookup(GID, rpt_id) == -1)
	{
		if(debug)
		{
			ptime();
			std::cout << ""Repeater  ->"" << r_list[rpt_id] 
			<< ""<-  blocked, unauthorized talkgroup: "" 
			<< GID << std::endl;
		}

		return;
	}


	// Sending selection logic

	for(i = 0; i < repeater_count; i++)
	{
	
		repeater[i].snd_queue = 0;

		// Don't reflect our own packets back

		if (rpt_id == i)
			continue;

		if (repeater[i].disable)
			continue;

		// Block OTAA if needed

		if((buf[20] == 0x0a) && (buf[21] == 0x05) && (buf[22] == 0x0a) &&
			 ((buf[23] == 0x01) || (buf[23] == 0x80)) &&
				(repeater[i].tx_otaa == 0))
		{
			continue;
		}

		// Get the flag from the Tactical group list
		tac_flag = tac_lookup(GID, i);

		// Is the talkgroup being sent in this repeater's list? If not, stop here

		tg = tg_lookup(GID, i);
		if (tg != -1)

		{		
		

			// Process TAC groups first
			// The only way to let the TAC group(s) through is if the RX active group matches
	

			if(tac_flag != -1)
			{
				if((repeater[i].time_since_rx == repeater[i].hold_time) || (repeater[i].active_tg != GID))
					continue;
			}


			// First, if this particular repeater just had RX activity, if the packet 
			// doesn't match the last talkgroup, drop it.  This should solve most contention
			// issues

			if((repeater[i].last_tg != GID) && (tac_flag == -1))
			{
				if(repeater[i].time_since_rx < repeater[i].hold_time)
				{
					if(debug)
					{
						ptime();
						std::cout << ""Blocking TG: "" << GID 
							<< "" sent on Repeater  ->"" << r_list[i]
							<< ""<-  due to recent RX on TG: "" 
							<< repeater[i].last_tg << std::endl;
					}

					continue;
				}
			}


			// Next, we need to determine if we need to preempt a talkgroup
			// Talkgroups that are on the left in the NXCore.ini list get higher priority

			if((tg_lookup(GID, i) < tg_lookup(repeater[i].busy_tg, i)) && (strt_packet==1)&&(repeater[i].tx_busy==1) &&
				(tac_flag == -1))
			{
				repeater[i].busy_tg = GID;

				if(debug)
				{
					ptime();
					std::cout << ""Overriding TG: "" << repeater[i].busy_tg 
						<< "" with  TG: "" << GID 
						<< "" on Repeater  ->"" << r_list[i] << std::endl;
				}
			}

			// Next, if repeater is considered busy, only send the talkgroup it has been assigned

			if((repeater[i].tx_busy == 1) && (repeater[i].busy_tg!=GID) && (tac_flag == -1))
			{
				if(debug)
				{
					ptime();
					std::cout << "" Repeater  ->"" << r_list[i] << ""<-  not geting "" 
						<< GID << ""due to active TX on "" 
						<< repeater[i].busy_tg << std::endl;
				}

				continue;	
			}


			if(strt_packet == 1)
			{
				repeater[i].keydown = 0;
				rpton_64001(i);
				tx_busy_sem=1;
				repeater[i].time_since_tx = 0;
				repeater[i].tx_busy = 1;
				tx_busy_sem=0;
				repeater[i].busy_tg = GID;
			}
			else
			{
				if((buf[3] % 3))
					rpton_64001(i);
				repeater[i].keydown = 0;
			}	

			// Need to rewrite IP address for len 47 and 59 packets it is 8,9,10,11
			buf[8] = (char)(tempaddr >> 24) & 0xff;
			buf[9] = (char)(tempaddr >> 16) & 0xff;
			buf[10] = (char)(tempaddr >> 8) & 0xff;
			buf[11] = (char)tempaddr & 0xff;

			if((recvlen == 47)&&(strt_packet == 1))
			{
				buf[24] = repeater[i].tx_ran;
			}

			repeater[i].tx_uid = repeater[rpt_id].uid;

			if(debug)
			{
				ptime();
				std::cout << ""Sending datagram to repeater  ->"" << r_list[i] << std::endl;
			}


			repeater[i].snd_queue = 1;

			repeater[i].time_since_tx = 0;

		}
				
	}

	for(i = 0; i < repeater_count; i++)
	{
		if(repeater[i].snd_queue==1)
		{

			if(strt_packet == 1)
				rpton_64001(i);
			while(tx_sem==1)
				usleep(1);
			tx_sem=1;

			if(sendto(socket_00, buf, recvlen, 0, (struct sockaddr *)&repeater[i].rpt_addr_00,
		 		sizeof(repeater[i].rpt_addr_00)) < 0)
			{
				ptime();
				std::cout << ""sendto error..."" << std::endl;
			}
			tx_sem=0;
			
			while(1)
			{

				#ifdef __FreeBSD__
				ioctl(socket_00,FIONWRITE,&o_bufsize);
				#else
				ioctl(socket_00,SIOCOUTQ,&o_bufsize);
				#endif
				if(o_bufsize == 0)
					break;
				usleep(500);
			}
	
			repeater[i].snd_queue = 0;

			if(repeater[rpt_id].rx_activity == 0)
			{		
				repeater[i].keydown=3;
			}
		}
	}
}

int tg_lookup(int GID, int i)
{
	int j;

	j = 0;

	while (repeater[i].tg_list[j] != 0)
	{
		if (repeater[i].tg_list[j++] == GID)
			return(j-1);
	}
	return(-1);
}

int tac_lookup(int GID, int i)
{
	int j;

	j = 0;

	while (repeater[i].tac_list[j] != 0)
	{
		if (repeater[i].tac_list[j++] == GID)
			return(j-1);
	}
	return(-1);
}


void *timing_thread(void *t_id)
{
	int i;
	int minor_cycle=0;
	unsigned int seconds = 0;
	char h_buf[59];
	unsigned char nx_packet[28] = { 0x00, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x4e, 0x58, 0x44, 0x4e, 0x4e, 0x31, 0x58, 0x44,
				 0x4e, 0x43, 0x54, 0x00, 0x00, 0x00, 0x00, 0x01,
				0x00, 0x00, 0x00, 0x00 };
	char buf_64[80];

	
	
        memset((char *)&h_buf[0], 0, sizeof(h_buf));
	h_buf[21] = 0x99;
	for(;;)
	{

		// minor cycle ~ 80ms


		// send shutdown packets if needed

		for ( i = 0; i < repeater_count; i++)
		{
			if((repeater[i].keydown > 0)&&((minor_cycle % 2) == 1))
				shutdown_64001(i);
		}	

		// clear out 64001 packets

		recv(socket_01,buf_64, 80, MSG_DONTWAIT);

		// major loop ~ 1 second

		if(minor_cycle == 0)
		{

			for( i = 0; i < repeater_count; i++)
			{
				repeater[i].time_since_rx++;
				if(repeater[i].time_since_rx > repeater[i].hold_time)
				{
					repeater[i].time_since_rx = repeater[i].hold_time;
					repeater[i].rx_activity = 0;
				}

				repeater[i].time_since_tx++;
		
				while(tx_busy_sem == 1)
					usleep(1);
				if(repeater[i].time_since_tx > repeater[i].tx_hold_time)
				{
					repeater[i].time_since_tx = repeater[i].tx_hold_time;
					repeater[i].tx_busy = 0;
				}
			}	
	
			if((++seconds % 20) == 0 )
			{
				for( i = 0; i < repeater_count; i++)
				{
					if ( repeater[i].stealth && repeater[i].tx_busy == 0)
					{
						while(tx_sem==1)
							usleep(1);
						tx_sem=1;
						sendto(socket_00, h_buf, sizeof(h_buf), 0, (struct sockaddr *)&repeater[i].rpt_addr_00,
							sizeof(repeater[i].rpt_addr_00));

						sendto(socket_01, nx_packet, sizeof(nx_packet), 0, (struct sockaddr *)&repeater[i].rpt_addr_01,
							sizeof(repeater[i].rpt_addr_01));
						tx_sem=0;

					}	
				}

			}	

		}

		usleep(80000);
		if(++minor_cycle > 11)
			minor_cycle = 0;
	}
	return (void *)0;
}


// 64001 sequence, must send every 0.2seconds

void rpton_64001(int rpt_no)
{
		int o_bufsize;

		up_packet[24] = (char)repeater[rpt_no].tx_ran;
		while(tx_sem==1)
			usleep(1);
		tx_sem=1;
		sendto(socket_01, up_packet, sizeof(up_packet), 0, (struct sockaddr *)&repeater[rpt_no].rpt_addr_01,
		 	sizeof(repeater[rpt_no].rpt_addr_01));
		tx_sem=0;
		while(1)
		{
			#ifdef __FreeBSD__
			ioctl(socket_01,FIONWRITE,&o_bufsize);
			#else
			ioctl(socket_01,SIOCOUTQ,&o_bufsize);
			#endif
			if(o_bufsize == 0)
				break;
			usleep(500);
		}
	
}

// Shutdown sequence to key down repeater

void shutdown_64001(int rpt_no)
{

	down_packet[12] = (char)(repeater[rpt_no].tx_uid >> 8);
	down_packet[13] = (char)repeater[rpt_no].tx_uid & 0xff;

	while(tx_sem==1)
		usleep(1);

	tx_sem=1;
	sendto(socket_01, down_packet, sizeof(down_packet), 0, (struct sockaddr *)&repeater[rpt_no].rpt_addr_01,
		sizeof(repeater[rpt_no].rpt_addr_01));
	tx_sem=0;

	if(--repeater[rpt_no].keydown < 0)
		repeater[rpt_no].keydown = 0;

}


int main(int argc, char *argv[])
{
	unsigned int i, j;
	int len;
	struct addrinfo hints, *result;

	boost::property_tree::ptree pt;

	try {

	boost::property_tree::ini_parser::read_ini(""NXCore.ini"", pt);

	}
	catch(const boost::property_tree::ptree_error  &e)
	{
		std::cout << ""Config file not found!"" << std::endl << std::endl;
		exit(1);
	}


	if(argc > 1)
		if (strcmp(argv[1], ""-d"") == 0)
			debug = 1;

	// Print out version and copyright info
	std::cout << version << std::endl;
	std::cout << copyright << std::endl << std::endl;

	// Get list of repeaters

	std::string s = pt.get<std::string>(""repeaters"");
	std::string tg;

	std::vector<std::string> elems;
	std::vector<std::string> tg_elems;

	// Split by space or tab
	boost::split(elems, s, boost::is_any_of(""\t ,""), boost::token_compress_on);

	repeater_count = elems.size();
	std::cout << ""Repeater Count:  "" << repeater_count << std::endl << std::endl;

	r_list = elems;

	repeater = (struct rpt *)calloc(repeater_count, sizeof(struct rpt));


	tempaddr = inet_addr(pt.get<std::string>(""nodeip"").c_str());

	up_packet[4] = (tempaddr >> 24);
	up_packet[5] = (tempaddr >> 16) & 0xff;
	up_packet[6] = (tempaddr >> 8) & 0xff;
	up_packet[7] = (tempaddr & 0xff);

	down_packet[4] = (tempaddr >> 24);
	down_packet[5] = (tempaddr >> 16) & 0xff;
	down_packet[6] = (tempaddr >> 8) & 0xff;
	down_packet[7] = (tempaddr & 0xff);


	// Start populating structure
	std::string key;

	for(i = 0; i < elems.size(); i++)
	{

		key.assign(elems[i]);
		key.append("".address"");

		memset(&hints,0, sizeof(hints));
		hints.ai_family = AF_INET;

		
		len = pt.get<std::string>(key).size();
		repeater[i].hostname = (char *)calloc(1, len+1);
		memcpy(repeater[i].hostname, (char *)pt.get<std::string>(key).c_str(),len+1);

		if(getaddrinfo(repeater[i].hostname, NULL, &hints, &result) == -1)
		{
			std::cout << ""Error resolving "" << pt.get<std::string>(key) << "", exiting"" << std::endl;
			exit(1);
		}	
	
		repeater[i].rpt_addr_00.sin_addr.s_addr = ((struct sockaddr_in *)(result->ai_addr))->sin_addr.s_addr;
		repeater[i].rpt_addr_01.sin_addr.s_addr = ((struct sockaddr_in *)(result->ai_addr))->sin_addr.s_addr;
		repeater[i].rpt_addr_00.sin_family = AF_INET;
		repeater[i].rpt_addr_01.sin_family = AF_INET;
		repeater[i].rpt_addr_00.sin_port = htons(64000);
		repeater[i].rpt_addr_01.sin_port = htons(64001);
		
		freeaddrinfo(result);
		std::cout << std::endl << std::endl;
		std::cout << ""Repeater "" << r_list[i] << "" address: "" 
			<< inet_ntoa(repeater[i].rpt_addr_00.sin_addr) << std::endl << std::endl;

		// Parse out the talkgroups

		key.assign(elems[i]);
		key.append("".tg_list"");
		tg = pt.get<std::string>(key).c_str();

		boost::split(tg_elems, tg, boost::is_any_of(""\t ,""), boost::token_compress_on);
	
		repeater[i].tg_list = (int *)calloc(tg_elems.size()+1,sizeof(int));
		std::cout << ""Talkgroups "" << tg_elems.size() << std::endl; 
		std::cout << ""Repeater "" << r_list[i] << ""  Talkgroups: "";

		for(j = 0; j < tg_elems.size(); j++)
		{
			repeater[i].tg_list[j] = atoi(tg_elems[j].c_str());
			std::cout << "" "" << repeater[i].tg_list[j];

		}
		std::cout << std::endl;

		// Do the same for the tactical list

		key.assign(elems[i]);
		key.append("".tac_list"");
		tg = pt.get<std::string>(key).c_str();

		boost::split(tg_elems, tg, boost::is_any_of(""\t ,""), boost::token_compress_on);
	
		repeater[i].tac_list = (int *)calloc(tg_elems.size()+1,sizeof(int));
		std::cout << ""Tactical Talkgroups "" << tg_elems.size() << std::endl; 
		std::cout << ""Repeater "" << i << ""  Tactical Talkgroup List: "";

		for(j = 0; j < tg_elems.size(); j++)
		{
			repeater[i].tac_list[j] = atoi(tg_elems[j].c_str());
			std::cout << "" "" << repeater[i].tac_list[j];

		}


		std::cout << std::endl << std::endl;
		repeater[i].tx_ran = pt.get<int>(elems[i] + "".tx_ran"");
		repeater[i].rx_ran = pt.get<int>(elems[i] + "".rx_ran"");
		repeater[i].hold_time = pt.get<int>(elems[i] + "".rx_hold_time"");
		repeater[i].time_since_rx = repeater[i].hold_time;
		repeater[i].stealth = pt.get<int>(elems[i] + "".stealth"");
		repeater[i].tx_hold_time = pt.get<int>(elems[i] + "".tx_hold_time"");
		repeater[i].time_since_tx = repeater[i].tx_hold_time;
		repeater[i].tx_otaa = pt.get<int>(elems[i] + "".tx_otaa"");

                try {
                        repeater[i].tg_network_off = pt.get<int>(elems[i] + "".tg_network_off"");
                        repeater[i].tg_network_on = pt.get<int>(elems[i] + "".tg_network_on"");
                }
                catch(const boost::property_tree::ptree_error &e)
                {
                        repeater[i].tg_network_off = 0;
                        repeater[i].tg_network_on = 0;
                }
		
		try {
			repeater[i].msg_flag = pt.get<int>(elems[i] + "".msg_flag"");
		}
		catch(const boost::property_tree::ptree_error &e)
		{
			repeater[i].msg_flag = 0;
		}

	}

	//

	tx_sem = 0;
	tx_busy_sem = 0;

	// start the threads


	pthread_t l_thread;
	pthread_t t_thread;

	if(pthread_create(&l_thread, NULL, listen_thread, (void *)0))  {
		fprintf(stderr, ""Problem creating thread.  Exiting\n"");
		return 1; 
	}
	
	if(pthread_create(&t_thread, NULL, timing_thread, (void *)0))  {
		fprintf(stderr, ""Problem creating thread.  Exiting\n"");
		return 1; 
	}

	int  [MASK]  = 0;


	while(1==1)
	{
	
		sleep(10);
		 [MASK] ++;

		if ( [MASK]  > 90)
		{
			while(tx_sem==1)
				usleep(1);
			tx_sem = 1;
		
			for (i = 0; i < (unsigned int)repeater_count; i++)
			{
                       		if(getaddrinfo(repeater[i].hostname, NULL, &hints, &result) == 0)
                        	{
                                	repeater[i].rpt_addr_00.sin_addr.s_addr = ((struct sockaddr_in *)(result->ai_addr))->sin_addr.s_addr;
                                	repeater[i].rpt_addr_01.sin_addr.s_addr = ((struct sockaddr_in *)(result->ai_addr))->sin_addr.s_addr;
				freeaddrinfo(result);
                        	}
			}
			tx_sem = 0;
		 [MASK]  = 0;
		}

	}
	pthread_exit(NULL);
}
",counter
616,"#pragma once

#include <functional>
#include <limits>
#include <queue>
#include <utility>
#include <vector>

#include ""../graph_traits/graph_traits.hpp""

namespace graph {
    template <typename Cost, typename Graph>
    std::vector<Cost> dijkstra(const Graph& g, int s) {
        using state = std::pair<Cost, int>;

        const int n = traits::get_size(g);

        std::vector<Cost>  [MASK] (n, std::numeric_limits<Cost>::max());

        std::priority_queue<state, std::vector<state>, std::greater<state>> pq{};
        pq.emplace( [MASK] [s] = 0, s);

        while (pq.size()) {
            auto [du, u] = pq.top();
            pq.pop();
            if (du !=  [MASK] [u]) {
                continue;
            }
            for (const auto& edge : traits::get_edges(g, u)) {
                int v = traits::get_dest(edge);
                Cost cost = traits::get_cost(edge);
                if (du + cost <  [MASK] [v]) {
                    pq.emplace( [MASK] [v] = du + cost, v);
                }
            }
        }

        return  [MASK] ;
    }
}",dist
617,"/*
# Copyright 2024 MangDang (www.mangdang.net) 
#
# 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.
#
# Description: This Turtle Arduino project is based on MD Robot Starter Kit(ESP32S3 chipset), including 
#      Test single servo to move
#      Test all servoes to move
#      Two move forward functions
#
#
*/
#include <action.h>
#include <Arduino.h>
#include <ESP32Servo.h>
#include <Preferences.h>

#define TIMES_WALK 1
#define SERVO_LOOP_DELAY 1
#define STEP_DELAY 10
#define INTERPOLATION_NUM1 (2*15+1)
#define INTERPOLATION_NUM2 66

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;

Preferences preferences;

int minUs = 500;
int maxUs = 2500;
int servo1Pin = 38;  // leftfront
int servo2Pin = 39;  // leftback
int servo3Pin = 40;  // rightfront
int servo4Pin = 41;  // rightback
int servo5Pin = 42;  // head
int ang[]   = { 0, 0, 0, 0, 0 };
int osang[] = { 0, -3, -3, 2, 0 };  //offset angle
int AngS[]  = { 0, 0, 0, 0, 0 };  // the current angle pos
int timewalk1 = 100;
int timewalk2 = 50;
int timeLT = 300;  // time for left turn
int timeST = 100;  // time for right turn

// set servo#x to move to y position
int input_ang(int x, int y) {
  switch (x) {
    case 0:
      return 90 - y -osang[0];
    case 1:
      return 90 - y - osang[1];
    case 2:
      return 90 + y + osang[2];
    case 3:
      return 90 + y + osang[3];
    case 4:
      return 180 - y;
  }
}

// void Servo_Offset();
void MoveInit() {
  Serial.println(""MoveInit start"");
  preferences.begin(""memory"", false);

  servo1.attach(servo1Pin, minUs, maxUs);
  servo2.attach(servo2Pin, minUs, maxUs);
  servo3.attach(servo3Pin, minUs, maxUs);
  servo4.attach(servo4Pin, minUs, maxUs);
  servo5.attach(servo5Pin, minUs, maxUs);

  // get osang value from preferences
  // osang[0] = preferences.getInt(""LFAngle"", osang[0]);
  // osang[1] = preferences.getInt(""LBAngle"", osang[1]);
  // osang[2] = preferences.getInt(""RFAngle"", osang[2]);
  // osang[3] = preferences.getInt(""RBAngle"", osang[3]);
  // osang[4] = preferences.getInt(""HDAngle"", osang[4]);
  for (int i = 0; i < 5; i++) {
    AngS[i] = osang[i];
  }

  Serial.println(""MoveInit end"");
}

void MoveReset() {
  Serial.println(""MoveReset start"");

  servoLeftFront(0, TIMES_WALK, SERVO_LOOP_DELAY);
  servoRightBack(0, TIMES_WALK, SERVO_LOOP_DELAY);
  servoRightFront(0, TIMES_WALK, SERVO_LOOP_DELAY);
  servoLeftBack(0, TIMES_WALK, SERVO_LOOP_DELAY);
  servoHead(0, TIMES_WALK, SERVO_LOOP_DELAY);

  Serial.println(""MoveReset end"");
}

void servoLeftFront(int ange, int timewalk, int servo_delay) {
  if (timewalk < 1) {
    Serial.println(""servo timewalk error!"");
    return;
  }
  Serial.print(""servoLeftFront start: ang = "");
  Serial.println(ange);
  int angtmp = ange - AngS[0];
  for (int i = 1; i <= timewalk; i++) {
    servo1.write(input_ang(0, AngS[0] + angtmp * i / timewalk));
    delay(servo_delay);
  }
  AngS[0] = ange;
  Serial.println(""servoLeftFront end!"");
}

void servoLeftBack(int ange, int timewalk, int servo_delay) {
  if (timewalk < 1) {
    Serial.println(""servo timewalk error!"");
    return;
  }
  Serial.print(""servoLeftBack start: ang = "");
  Serial.println(ange);
  int angtmp = ange - AngS[1];
  for (int i = 1; i <= timewalk; i++) {
    servo2.write(input_ang(1, AngS[1] + angtmp * i / timewalk));
    delay(servo_delay);
  }
  AngS[1] = ange;
  Serial.println(""servoLeftBack end!"");
}

void servoRightFront(int ange, int timewalk, int servo_delay) {
  if (timewalk < 1) {
    Serial.println(""servo timewalk error!"");
    return;
  }
  Serial.print(""servoRightFront start: ang = "");
  Serial.println(ange);
  int angtmp = ange - AngS[2];
  for (int i = 1; i <= timewalk; i++) {
    servo3.write(input_ang(2, AngS[2] + angtmp * i / timewalk));
    delay(servo_delay);
  }
  AngS[2] = ange;
  Serial.println(""servoRightFront end!"");
}

void servoRightBack(int ange, int timewalk, int servo_delay) {
  if (timewalk < 1) {
    Serial.println(""servo timewalk error!"");
    return;
  }
  Serial.print(""servoRightBack start: ang = "");
  Serial.println(ange);
  int angtmp = ange - AngS[3];
  for (int i = 1; i <= timewalk; i++) {
    servo4.write(input_ang(3, AngS[3] + angtmp * i / timewalk));
    delay(servo_delay);
  }
  AngS[3] = ange;
  Serial.println(""servoRightBack end!"");
}

void servoHead(int ange, int timewalk, int servo_delay) {
  if (timewalk < 1) {
    Serial.println(""servo timewalk error!"");
    return;
  }
  Serial.print(""servoHead start: ang = "");
  Serial.println(ange);
  int angtmp = ange - AngS[4];
  for (int i = 1; i <= timewalk; i++) {
    servo5.write(input_ang(4, AngS[4] + angtmp * i / timewalk));
    delay(servo_delay);
  }
  AngS[4] = ange;
  Serial.println(""servoHead end!"");
}

// simple forward movement
void MoveForward(int step_delay, int loop_num) {
  for (int i = 0; i < loop_num; i++) {
    Serial.print(""MoveForward loop count:"");
    Serial.println(i);
    servoLeftFront(15, TIMES_WALK, SERVO_LOOP_DELAY);
    servoRightBack(15, TIMES_WALK, SERVO_LOOP_DELAY);
    servoRightFront(-15, TIMES_WALK, SERVO_LOOP_DELAY);
    servoLeftBack(-15, TIMES_WALK, SERVO_LOOP_DELAY);
    servoHead(15, TIMES_WALK, SERVO_LOOP_DELAY);
    
    delay(step_delay);
    
    servoLeftFront(0, TIMES_WALK, SERVO_LOOP_DELAY);
    servoRightBack(0, TIMES_WALK, SERVO_LOOP_DELAY);
    servoRightFront(0, TIMES_WALK, SERVO_LOOP_DELAY);
    servoLeftBack(0, TIMES_WALK, SERVO_LOOP_DELAY);
    servoHead(0, TIMES_WALK, SERVO_LOOP_DELAY);
    
    delay(step_delay);
  }
}

// forward movement smoothly
void smoothMoveForward(int loopNum) { 
  unsigned char angle1_position_init[INTERPOLATION_NUM1] = {90, 90, 90, 90, 90, 90, 90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90,  90};
  unsigned char angle2_position_init[INTERPOLATION_NUM1] = {90, 90, 91, 92, 93, 94, 94,  95,  96,  97,  98,  98,  99,  100, 101, 102, 102, 103, 104, 105, 106, 106, 107, 108, 109, 110, 111, 111, 112, 113, 114};
  unsigned char angle3_position_init[INTERPOLATION_NUM1] = {90, 91, 93, 95, 96, 98, 100, 102, 103, 105, 107, 109, 110, 112, 114, 115, 117, 119, 121, 122, 124, 126, 128, 129, 131, 133, 135, 136, 138, 140, 141};
  unsigned char angle4_position_init[INTERPOLATION_NUM1] = {90, 87, 85, 83, 81, 79, 77,  75,  73,  71,  69,  67,  65,  63,  60,  58,  56,  54,  52,  50,  48,  46,  44,  42,  40,  38,  36,  33,  31,  29,  27};
  
  unsigned char angles1_tem[INTERPOLATION_NUM2] = {90, 88, 86, 84, 82, 80, 78, 76, 74, 72, 70, 68, 66, 64, 62, 62, 62, 62, 62, 62, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 48, 49, 51, 52, 54, 55, 56, 58, 59, 60, 62, 63, 65, 66, 67, 69, 70, 72, 73, 74, 76, 77, 78, 80, 81, 83, 84, 85, 87, 88, 90};
  unsigned char angles2_tem[INTERPOLATION_NUM2] = {114, 115, 115, 116, 117, 118, 119, 119, 120, 121, 122, 123, 123, 124, 125, 126, 127, 127, 128, 129, 130, 131, 132, 132, 133, 134, 135, 136, 136, 137, 138, 138, 137, 137, 136, 136, 135, 135, 135, 134, 134, 133, 133, 132, 132, 131, 131, 131, 131, 131, 131, 131, 130, 129, 127, 126, 125, 124, 122, 121, 120, 119, 117, 116, 115, 114};
  unsigned char angles3_tem[INTERPOLATION_NUM2] = {141, 140, 138, 136, 135, 133, 131, 129, 128, 126, 124, 122, 121, 119, 117, 115, 114, 112, 110, 109, 107, 105, 103, 102, 100, 98, 96, 95, 93, 91, 90, 90, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 117, 117, 117, 117, 117, 117, 119, 121, 122, 124, 126, 128, 129, 131, 133, 135, 136, 138, 140, 141};
  unsigned char angles4_tem[INTERPOLATION_NUM2] = {27, 29, 30, 32, 33, 35, 36, 38, 39, 41, 42, 44, 45, 46, 48, 48, 48, 48, 48, 48, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 62, 61, 60, 58, 57, 56, 55, 54, 53, 51, 50, 49, 48, 47, 46, 45, 43, 42, 41, 40, 39, 38, 36, 35, 34, 33, 32, 31, 30, 28, 27};
  
  //from calibration position to walk position
  for (int j = 0; j < INTERPOLATION_NUM1; j++){
    servo1.write( int(angle1_position_init[j]) - osang[0]);
    servo2.write( int(angle2_position_init[j]) - osang[1]);
    servo3.write( int(angle3_position_init[j]) + osang[2]);
    servo4.write( int(angle4_position_init[j]) + osang[3]);
    delay(STEP_DELAY);
  }
  
  //forward walk loop
  for (int i = 0; i <= loopNum; i++){
    for (int j = 0; j < INTERPOLATION_NUM2 ; j++){
      servo1.write( int(angles1_tem[j]) - osang[0]);
      servo2.write( int(angles2_tem[j]) - osang[1]);
      servo3.write( int(angles3_tem[j]) + osang[2]);
      servo4.write( int(angles4_tem[j]) + osang[3]);
      delay(STEP_DELAY);
    }
  }
  
  //from walk position to calibration position
  for (int j = 0; j < INTERPOLATION_NUM1; j++){
    servo1.write(int(angle1_position_init[INTERPOLATION_NUM1 - 1 - j]) - osang[0]);
    servo2.write(int(angle2_position_init[INTERPOLATION_NUM1 - 1 - j]) - osang[1]);
    servo3.write(int(angle3_position_init[INTERPOLATION_NUM1 - 1 - j]) + osang[2]);
    servo4.write(int(angle4_position_init[INTERPOLATION_NUM1 - 1 - j]) + osang[3]);
    delay(STEP_DELAY);
  }
}

void MovementDance() {

  int timewalk1 = 8;
  int timewalk2 = 16;
  int  [MASK]  = 6;
  int stepDelay = 30;

  unsigned char LF_angle_slow[] = {110, 109, 108, 107, 105, 104, 102, 100,  98,  95,  92,  89,  85,  81,76,  70,  63,  57,  51,  47,  43,  39,  37,  34,  32,  31,  29,  28,27,  27,  26,  26,  25};
  unsigned char LB_angle_slow[] = {160, 159, 157, 155, 153, 150, 148, 145, 142, 138, 134, 130, 126, 120,115, 109, 102,  96,  91,  87,  83,  81,  78,  77,  75,  74,  73,  72,71,  71,  70,  70,  70};
  unsigned char RF_angle_slow[] = {69,  70,  71,  72,  74,  75,  77,  79,  81,  84,  87,  90,  94,  98, 103, 109, 116, 122, 128, 132, 136, 140, 142, 145, 147, 148, 150, 151,152, 152, 153, 153, 154};
  unsigned char RB_angle_slow[] = {19,  20,  22,  24,  26,  29,  31,  34,  37,  41,  45,  49,  53,  59, 64,  70,  77,  83,  88,  92,  96,  98, 101, 102, 104, 105, 106, 107,108, 108, 109, 109, 109};

  unsigned char LF_angle_fast[] = {110, 109, 108, 105, 100,  93,  81,  61,  25};
  unsigned char LB_angle_fast[] = {160, 159, 157, 152, 145, 135, 121, 100,  70};
  unsigned char RF_angle_fast[] = {69,  70,  71,  74,  79,  86,  98,  118, 154};
  unsigned char RB_angle_fast[] = {19,  20,  22,  27,  34,  44,  58,  79,  109,};

  for (int i = 0; i <  [MASK] ; i++) {
    for (int j = 0; j <= timewalk1; j++){
      servo1.write(int(LF_angle_fast[j]) - osang[0]);
      servo2.write(int(LB_angle_fast[j]) - osang[1]);
      servo3.write(int(RF_angle_fast[j]) + osang[2]);
      servo4.write(int(RB_angle_fast[j]) + osang[3]);
      delay(stepDelay);
    }

    for (int j = 0; j <= 2 * timewalk2; j++){
      servo1.write(int(LF_angle_slow[2 * timewalk2 - j]) - osang[0]);
      servo2.write(int(LB_angle_slow[2 * timewalk2 - j]) - osang[1]);
      servo3.write(int(RF_angle_slow[2 * timewalk2 - j]) + osang[2]);
      servo4.write(int(RB_angle_slow[2 * timewalk2 - j]) + osang[3]);
      delay(stepDelay);
    }
  }
}
",loop_times
618,"/*
 * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
 * SPDX-License-Identifier: BSD-3-Clause-Clear
 */

#include <glib-unix.h>
#include <gst/gst.h>
#include <glib.h>

#define DEFAULT_FILE1 ""/opt/video.mp4""
#define DEFAULT_FILE2 ""/opt/video.mp4""

 /**
  * GstAppContext:
  * @pipeline: Pipeline connecting all the elements for Use Case.
  * @plugins : List of all the plugins used in Pipeline.
  * @mloop   : Main Loop for the Application.
  *
  * Application context to pass information between the functions.
  */
typedef struct
{
  // Pointer to the pipeline
  GstElement *pipeline;
  // Pointer to the mainloop
  GMainLoop  *loop;
  //Input sources
  gchar *file1;
  gchar *file2;
} GstAppContext;

/**
  * Create and initialize application context:
  *
  * @param NULL
  */
static GstAppContext *
gst_app_context_new ()
{
    // Allocate memory for the new context
    GstAppContext *ctx = (GstAppContext *) g_new0 (GstAppContext, 1);

    if (NULL == ctx) {
      g_printerr (""\n Unable to create App Context\n"");
      return NULL;
    }

    // Initialize the context fields
    ctx->pipeline = NULL;
    ctx->loop = NULL;
    ctx->file1 = g_strdup (DEFAULT_FILE1);
    ctx->file2 = g_strdup (DEFAULT_FILE2);

    return ctx;
}

 /**
  * Free Application context:
  *
  * @param appctx application context object
  */
static void
gst_app_context_free (GstAppContext * appctx)
{
    // If specific pointer is not NULL, unref it
    if (appctx->loop != NULL) {
      g_main_loop_unref (appctx->loop);
      appctx->loop = NULL;
    }

    if (appctx->pipeline != NULL) {
      gst_object_unref (appctx->pipeline);
      appctx->pipeline = NULL;
    }

    if (appctx->file1 != NULL)
      g_free (appctx->file1);

    if (appctx->file2 != NULL)
      g_free (appctx->file2);

    if (appctx != NULL)
      g_free ((gpointer)appctx);
}

 /**
  * Function to link the dynamic video pad of demux to queue:
  *
  * @param element GStreamer source element
  * @param pad GStreamer source element pad
  * @param data sink element object
  */
static void
on_pad_added (GstElement *src, GstPad *new_pad, gpointer data) {
    GstElement *parser = (GstElement *) data;
    GstPad *sink_pad = gst_element_get_static_pad (parser, ""sink"");

    if (gst_pad_is_linked (sink_pad)) {
        g_object_unref (sink_pad);
        return;
    }

    if (gst_pad_link (new_pad, sink_pad) != GST_PAD_LINK_OK) {
        g_printerr (""Failed to link dynamic pad.\n"");
    } else {
        g_print (""Dynamic pad linked.\n"");
    }

    g_object_unref (sink_pad);
}

 /**
  * Handles interrupt by CTRL+C.
  *
  * @param userdata pointer to AppContext.
  * @return FALSE if the source should be removed, else TRUE.
  */
gboolean
handle_interrupt_signal (gpointer userdata)
{
    GstAppContext *appctx = (GstAppContext *) userdata;
    GstState state,  [MASK] ;

    g_print (""\n\nReceived an interrupt signal, send EOS ...\n"");

    if (!gst_element_get_state (
        appctx->pipeline, &state, & [MASK] , GST_CLOCK_TIME_NONE)) {
      gst_printerr (""ERROR: get current state!\n"");
      gst_element_send_event (appctx->pipeline, gst_event_new_eos ());
      return TRUE;
    }

    if (state == GST_STATE_PLAYING) {
      gst_element_send_event (appctx->pipeline, gst_event_new_eos ());
    } else {
      g_main_loop_quit (appctx->loop);
    }
    return TRUE;
}

/**
  * Handles End-Of-Stream(eos) Event.
  *
  * @param bus Gstreamer bus for Mesaage passing in Pipeline.
  * @param message Gstreamer eos Event Message.
  * @param userdata Pointer to Main Loop for Handling eos.
  */
static
gboolean eos_cb (GstBus *bus, GstMessage *msg, gpointer user_data) {
    g_print (""End of stream reached.\n"");
    g_main_loop_quit ((GMainLoop *) user_data);
    return FALSE;
}

/**
  * Handles error events.
  *
  * @param bus Gstreamer bus for Mesaage passing in Pipeline.
  * @param message Gstreamer Error Event Message.
  * @param userdata Pointer to Main Loop for Handling Error.
  */
static
gboolean error_cb (GstBus *bus, GstMessage *msg, gpointer user_data) {
    GError *err;
    gchar *debug_info;

    gst_message_parse_error (msg, &err, &debug_info);
    g_printerr (""Error from %s: %s\n"", GST_OBJECT_NAME (msg->src), err->message);
    g_printerr (""Debug info: %s\n"", debug_info ? debug_info : ""none"");

    g_clear_error (&err);
    g_free (debug_info);

    g_main_loop_quit ((GMainLoop *) user_data);
    return FALSE;
}

/**
  * Handles warning events.
  *
  * @param bus Gstreamer bus for Mesaage passing in Pipeline.
  * @param message Gstreamer Error Event Message.
  * @param userdata Pointer to Main Loop for Handling Error.
  */
static
gboolean warning_cb (GstBus *bus, GstMessage *msg, gpointer user_data) {
    GError *err;
    gchar *debug_info;

    gst_message_parse_warning (msg, &err, &debug_info);
    g_printerr (""Warning from %s: %s\n"", GST_OBJECT_NAME (msg->src), err->message);
    g_printerr (""Debug info: %s\n"", debug_info ? debug_info : ""none"");

    g_clear_error (&err);
    g_free (debug_info);
    return TRUE;
}

int
main (int argc, char *argv[]) {
    GstAppContext *appctx = NULL;
    GstElement *src1, *demux1, *parse1, *dec1, *conv1;
    GstElement *src2, *demux2, *parse2, *dec2, *conv2, *compositor, *sink;
    GstBus *bus;
    guint intrpt_watch_id = 0;

    // create the app context
    appctx = gst_app_context_new ();
    if (NULL == appctx) {
      g_printerr (""\n Failed app context Initializing: Unknown error!\n"");
      return -1;
    }

    // Setting Display environment variables
    setenv (""XDG_RUNTIME_DIR"", ""/dev/socket/weston"", 0);
    setenv (""WAYLAND_DISPLAY"", ""wayland-1"", 0);

    GOptionEntry entries[] = {
        { ""file1"", 0, 0, G_OPTION_ARG_FILENAME, (gpointer) &appctx->file1,
          ""First video file"", ""FILE"" },
        { ""file2"", 0, 0, G_OPTION_ARG_FILENAME, (gpointer) &appctx->file2, 
          ""Second video file"", ""FILE"" },
        { NULL }
    };

    GOptionContext *context = g_option_context_new (""- video compositor"");
    g_option_context_add_main_entries (context, entries, NULL);
    g_option_context_add_group (context, gst_init_get_option_group());

    if (!g_option_context_parse (context, &argc, &argv, NULL)) {
        g_printerr (""Failed to parse options.\n"");
        return -1;
    }
    g_option_context_free (context);

    //Initialize GST library.
    gst_init (&argc, &argv);

    appctx->pipeline = gst_pipeline_new (""composite-pipeline"");

    src1 = gst_element_factory_make (""filesrc"", ""src1"");
    demux1 = gst_element_factory_make (""qtdemux"", ""demux1"");
    parse1 = gst_element_factory_make (""h264parse"", ""parse1"");
    dec1 = gst_element_factory_make (""v4l2h264dec"", ""dec1"");
    conv1 = gst_element_factory_make(""videoconvert"", ""conv1"");

    src2 = gst_element_factory_make (""filesrc"", ""src2"");
    demux2 = gst_element_factory_make (""qtdemux"", ""demux2"");
    parse2 = gst_element_factory_make (""h264parse"", ""parse2"");
    dec2 = gst_element_factory_make (""v4l2h264dec"", ""dec2"");
    conv2 = gst_element_factory_make (""videoconvert"", ""conv2"");

    compositor = gst_element_factory_make (""compositor"", ""compositor"");
    sink = gst_element_factory_make (""waylandsink"", ""sink"");

    if (!appctx->pipeline || !src1 || !demux1 || !parse1 || !dec1 || !conv1 ||
        !src2 || !demux2 || !parse2 || !dec2 || !conv2 ||
        !compositor || !sink) {
        g_printerr (""Failed to create elements.\n"");
        return -1;
    }

    // Set display properties
    g_object_set (G_OBJECT (sink), ""fullscreen"", true, NULL);

    // Set filesrc properties
    g_object_set (src1, ""location"", appctx->file1, NULL);
    g_object_set (src2, ""location"", appctx->file2, NULL);

    gst_bin_add_many (GST_BIN(appctx->pipeline),
        src1, demux1, parse1, dec1, conv1,
        src2, demux2, parse2, dec2, conv2,
        compositor, sink, NULL);

    gst_element_link (src1, demux1);
    gst_element_link (src2, demux2);

    gst_element_link_many (parse1, dec1, conv1, NULL);
    gst_element_link_many (parse2, dec2, conv2, NULL);
    gst_element_link (compositor, sink);

    g_signal_connect (demux1, ""pad-added"", G_CALLBACK (on_pad_added), parse1);
    g_signal_connect (demux2, ""pad-added"", G_CALLBACK (on_pad_added), parse2);

    GstPad *sinkpad1 = gst_element_request_pad_simple (compositor, ""sink_%u"");
    GstPad *srcpad1 = gst_element_get_static_pad (conv1, ""src"");
    gst_pad_link (srcpad1, sinkpad1);
    g_object_set (sinkpad1, ""xpos"", 0, ""ypos"", 0, NULL);

    GstPad *sinkpad2 = gst_element_request_pad_simple (compositor, ""sink_%u"");
    GstPad *srcpad2 = gst_element_get_static_pad (conv2, ""src"");
    gst_pad_link (srcpad2, sinkpad2);
    g_object_set (sinkpad2, ""xpos"", 640, ""ypos"", 0, NULL);

    gst_object_unref (sinkpad1);
    gst_object_unref (sinkpad2);
    gst_object_unref (srcpad1);
    gst_object_unref (srcpad2);

    appctx->loop = g_main_loop_new (NULL, FALSE);

    // Watch for messages on the pipeline's bus.
    bus = gst_element_get_bus (appctx->pipeline);
    gst_bus_add_signal_watch (bus);
    g_signal_connect (bus, ""message::error"", G_CALLBACK(error_cb), appctx->loop);
    g_signal_connect (bus, ""message::warning"", G_CALLBACK(warning_cb), NULL);
    g_signal_connect (bus, ""message::eos"", G_CALLBACK(eos_cb), appctx->loop);
    gst_object_unref (bus);

    // Register function for handling interrupt signals with the main loop.
    intrpt_watch_id = g_unix_signal_add (SIGINT, handle_interrupt_signal, appctx);

    // Set the pipeline to the PAUSED state, On successful transition
    // move application state to PLAYING state in state_changed_cb function
    g_print (""Setting pipeline to PLAYING state ...\n"");
    switch (gst_element_set_state (appctx->pipeline, GST_STATE_PLAYING)) {
      case GST_STATE_CHANGE_FAILURE:
        g_printerr (""\n Failed to transition to PLAYING state!\n"");
        if(intrpt_watch_id)
          g_source_remove (intrpt_watch_id);
        gst_app_context_free (appctx);
        return -1;
      case GST_STATE_CHANGE_NO_PREROLL:
        g_print (""\n Pipeline is live and does not need PREROLL.\n"");
        break;
      case GST_STATE_CHANGE_ASYNC:
        g_print (""\n Pipeline is PREROLLING ...\n"");
        break;
      case GST_STATE_CHANGE_SUCCESS:
        g_print (""\n Pipeline state change was successful\n"");
        break;
    }

    g_print (""\n Application is running... \n"");
    g_main_loop_run (appctx->loop);

    if(intrpt_watch_id)
      g_source_remove (intrpt_watch_id);

    g_print (""\n Setting pipeline to NULL state ...\n"");
    gst_element_set_state (appctx->pipeline, GST_STATE_NULL);

    gst_app_context_free (appctx);

    gst_deinit ();

    g_print (""Application End Successfully\n"");

    return 0;
}
",pending
619,"// Fill out your copyright notice in the Description page of Project Settings.


#include ""InventoryBagMock.h""
#include ""BattleRoyale/core/Utils/Inventory/InventoryArrayItem.h""

TScriptInterface<IIInventoryItemInstance> UInventoryBagMock::AddItem(TSubclassOf<UInventoryItemStaticData> itemClass, int value1, int value2)
{
	return nullptr;
}

void UInventoryBagMock::RemoveFirstItem(TSubclassOf<UInventoryItemStaticData> itemClass)
{
}

void UInventoryBagMock::RemoveItem(TScriptInterface<IIInventoryItemInstance> item)
{
}

void UInventoryBagMock::RemoveItemByID(int ID)
{
}

bool UInventoryBagMock::ExistItemWithID(int ID) const
{
	for(auto&& item : mItems)
	{
		if(item.mId == ID)
		{
			return true;
		}
	}
	return false;
}

void UInventoryBagMock::SetMaxItems(int  [MASK] )
{
	mMaxItems =  [MASK] ;
}

TScriptInterface<IIInventoryItemInstance> UInventoryBagMock::FindFirstItem(TSubclassOf<UInventoryItemStaticData> itemClass)
{
	return nullptr;
}

TScriptInterface<IIInventoryItemInstance> UInventoryBagMock::FindItemWithID(int ID)
{
	return nullptr;
}

void UInventoryBagMock::PerformActionForEachItem(const std::function<bool(UInventoryArrayItem* inventoryItem)>& action) const
{
	for(auto&& item : mItems)
	{
		const auto inventoryItem = NewObject<UInventoryArrayItem>();
		inventoryItem->SetID(item.mId);
		inventoryItem->mInventoryItem = nullptr;
		if(action(inventoryItem))
		{
			break;
		}
	}
}

int UInventoryBagMock::Num() const
{
	return mItems.Num();
}

bool UInventoryBagMock::IsFull() const
{
	return mItems.Num() == mMaxItems;
}

bool UInventoryBagMock::IsEmpty() const
{
	return mItems.Num() <= 0;
}
",max
620,"// * * * SPROCKET_HAL_Test * * *
//
// This software allows testing the SPROCKET1 test pixel,
// including performing the role of the SAR logic.

String DOCSTRING = ""This Arduino is running SPROCKET_HAL_Test v0.11TEST, updated 6/5/2023. Macros: "";

//makeinclude GPIO_user.cpp DO NOT MODIFY THIS LINE
#include ""GPIO_user.h""
#include ""generic_hal.h""

#define GPIO_NUMBER (16U)

//Variables for CDAC emulator.
float CL;
float CR;
float CompInp;
char data_array[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
long numConversions;

uint16_t data_buffer[100];
bool user_echo = 1;

//User input
String u;


//#define EMULATOR 1
//#define UNO 1
#define PORTENTA 1


// *** CDAC CONTROL MACROS ***
//Note that EMULATOR takes precedence over ARDUINO/PORTENTA if asserted.
#if defined(EMULATOR)
#define assert_qequal() \
  CL = (CL + CR) / 2; \
  CR = CL;
#define deassert_qequal() ;
#define assert_dacclr() CL = 0;
#define deassert_dacclr() ;
#define assert_caphi() CR = 1;
#define deassert_caphi() ;
#define assert_caplo() CR = 0;
#define deassert_caplo() ;
#define get_comp() CompInp > CL ? 1 : 0

#elif defined(PORTENTA)
//** Note: Portenta GPIO interface methods are adapted from the Portenta GPIO HAL:
//https://github.com/arduino/portentax8-stm32h7-fw/blob/b2d8715d5a4619f4dc6ab258e1f1017789342ce4/libraries/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c
/* OLD Pinout before we got the new breakout board!
#define assert_qequal() GPIOC->BSRR = GPIO_PIN_7
#define deassert_qequal() GPIOC->BSRR = (uint32_t)GPIO_PIN_7 << GPIO_NUMBER
#define assert_dacclr() GPIOC->BSRR = GPIO_PIN_6;
#define deassert_dacclr() GPIOC->BSRR = (uint32_t)GPIO_PIN_6 << GPIO_NUMBER
//Recall that capHi is actually capHib, an active LOW signal.
#define assert_caphi() GPIOJ->BSRR = (uint32_t)GPIO_PIN_11 << GPIO_NUMBER
#define deassert_caphi() GPIOJ->BSRR = GPIO_PIN_11
#define assert_caplo() GPIOG->BSRR = GPIO_PIN_7
#define deassert_caplo() GPIOG->BSRR = (uint32_t)GPIO_PIN_7 << GPIO_NUMBER
#define get_comp() ((GPIOK->IDR & GPIO_PIN_1) != 0x00U)
*/

#define assert_qequal() GPIOH->BSRR = GPIO_PIN_15
#define deassert_qequal() GPIOH->BSRR = (uint32_t)GPIO_PIN_15 << GPIO_NUMBER
#define assert_dacclr() GPIOJ->BSRR = GPIO_PIN_11;
#define deassert_dacclr() GPIOJ->BSRR = (uint32_t)GPIO_PIN_11 << GPIO_NUMBER
//Recall that capHi is actually capHib, an active LOW signal.
#define assert_caphi() GPIOH->BSRR = (uint32_t)GPIO_PIN_12 << GPIO_NUMBER
#define deassert_caphi() GPIOH->BSRR = GPIO_PIN_12
#define assert_caplo() GPIOI->BSRR = GPIO_PIN_6
#define deassert_caplo() GPIOI->BSRR = (uint32_t)GPIO_PIN_6 << GPIO_NUMBER
#define get_comp() ((GPIOI->IDR & GPIO_PIN_2) != 0x00U)

#elif defined(UNO)



#endif

// *** FE CONTROL MACROS ***

#if defined(PORTENTA)
/* OLD Pinout before we got the new Portenta Breakout
#define assert_presamp() GPIOC->BSRR = GPIO_PIN_2
#define deassert_presamp() GPIOC->BSRR = (uint32_t)GPIO_PIN_2 << GPIO_NUMBER
#define assert_postsamp() GPIOH->BSRR = GPIO_PIN_15
#define deassert_postsamp() GPIOH->BSRR = (uint32_t)GPIO_PIN_15 << GPIO_NUMBER //Changed from C3
#define assert_rst() GPIOA->BSRR = GPIO_PIN_4
#define deassert_rst() GPIOA->BSRR = (uint32_t)GPIO_PIN_4 << GPIO_NUMBER

//PH15 should not be connected to anything.
#define NOP GPIOG->BSRR = GPIO_PIN_10;
*/

#define assert_pulsetrig() GPIOI->BSRR = GPIO_PIN_3
#define deassert_pulsetrig() GPIOI->BSRR = (uint32_t)GPIO_PIN_3 << GPIO_NUMBER
#define assert_presamp() GPIOK->BSRR = GPIO_PIN_1
#define deassert_presamp() GPIOK->BSRR = (uint32_t)GPIO_PIN_1 << GPIO_NUMBER
#define assert_postsamp() GPIOC->BSRR = GPIO_PIN_6
#define deassert_postsamp() GPIOC->BSRR = (uint32_t)GPIO_PIN_6 << GPIO_NUMBER 
//Remember that rst is ACTIVE LOW so, we assert it by pulling it low.
#define assert_rst() GPIOJ->BSRR = (uint32_t)GPIO_PIN_7 << GPIO_NUMBER
#define deassert_rst() GPIOJ->BSRR = GPIO_PIN_7

//PH15 should not be connected to anything.
#define NOP GPIOH->BSRR = GPIO_PIN_6;

#elif defined(UNO)
//The corresponding pins do not exist on the UNO
#define assert_presamp() ;
#define deassert_presamp() ;
#define assert_postsamp() ;
#define deassert_postsamp() ;
#define assert_rst() ;
#define deassert_rst() ;

#endif


// *** Unconditional macros ***


/* OLD Pinout before new Portenta Breakout
#define write_captrim_0(val) digitalWrite(D6, val); 
#define write_captrim_1(val) digitalWrite(D7, val); 
#define write_captrim_2(val) digitalWrite(D8, val);
#define write_captrim_3(val) digitalWrite(D9, val);
#define write_captrim_4(val) digitalWrite(D11, val);//Skip D10 which overlaps w/ D19.
#define write_captrim_5(val) digitalWrite(D12, val);
#define write_range2(val) digitalWrite(D13, val);
#define write_testen(val) digitalWrite(D14, val);
*/
#define write_captrim_0(val)  (val) ? GPIOH->BSRR = GPIO_PIN_11 : GPIOH->BSRR = (uint32_t)GPIO_PIN_11 << GPIO_NUMBER;
#define write_captrim_1(val) (val) ? GPIOC->BSRR = GPIO_PIN_7 : GPIOC->BSRR = (uint32_t)GPIO_PIN_7 << GPIO_NUMBER;
#define write_captrim_2(val) (val) ? GPIOI->BSRR = GPIO_PIN_4 : GPIOI->BSRR = (uint32_t)GPIO_PIN_4 << GPIO_NUMBER;
#define write_captrim_3(val) (val) ? GPIOA->BSRR = GPIO_PIN_8 : GPIOA->BSRR = (uint32_t)GPIO_PIN_8 << GPIO_NUMBER;
#define write_captrim_4(val) (val) ? GPIOH->BSRR = GPIO_PIN_10 : GPIOH->BSRR = (uint32_t)GPIO_PIN_10 << GPIO_NUMBER;
#define write_captrim_5(val) (val) ? GPIOH->BSRR = GPIO_PIN_14 : GPIOH->BSRR = (uint32_t)GPIO_PIN_14 << GPIO_NUMBER;
#define write_range2(val) (val) ? GPIOI->BSRR = GPIO_PIN_7 : GPIOI->BSRR = (uint32_t)GPIO_PIN_7 << GPIO_NUMBER;
#define write_testen(val) (val) ? GPIOH->BSRR = GPIO_PIN_9 : GPIOH->BSRR = (uint32_t)GPIO_PIN_9 << GPIO_NUMBER;
#define write_rangelock(val) (val) ? GPIOG->BSRR = GPIO_PIN_7 : GPIOG->BSRR = (uint32_t)GPIO_PIN_7 << GPIO_NUMBER;
//All CDAC pulses should have a width of 90ns.
#define pulse_dacclr() \
  assert_dacclr(); NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP; \
  deassert_dacclr();

#define pulse_caphi() \
  assert_caphi(); NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;\
  deassert_caphi();

#define pulse_caplo() \
  assert_caplo(); NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP; \
  deassert_caplo();

#define pulse_qequal() \
  assert_qequal(); NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP; \
  deassert_qequal();

//Config register bits
char config[8] = { 0, 0, 0, 0, 0, 0,  //CapTrim<0:5>
                   0,                 //Range2
                   0
                 };               //TestEn


void setup() {
  // put your setup code here, to run once:
  Serial.begin(230400);
  set_config("""");

#if defined(PORTENTA)
  //CompOut
  pinMode(PI_2,INPUT);

  //Pulse Trig
  pinMode(PI_3,OUTPUT);

  //ADC Control Signals
  pinMode(PH_15,OUTPUT);
  pinMode(PJ_11,OUTPUT);
  pinMode(PH_12,OUTPUT);
  pinMode(PI_6,OUTPUT);

  //Phase control signals
  pinMode(PK_1,OUTPUT);
  pinMode(PC_6,OUTPUT);
  pinMode(PJ_7,OUTPUT);

  //CapTrim, range2, testen
  pinMode(PH_11,OUTPUT);
  pinMode(PC_7,OUTPUT);
  pinMode(PI_4,OUTPUT);
  pinMode(PA_8,OUTPUT);
  pinMode(PH_10,OUTPUT);
  pinMode(PH_14,OUTPUT);
  pinMode(PI_7,OUTPUT);
  pinMode(PH_9,OUTPUT);

  //RangeLock
  pinMode(PG_7, OUTPUT);
#endif

  CompInp = 0.5;

  //Always write Rangelock=0
  write_rangelock(0);
}

void loop() {

  //Always write Rangelock=0
  write_rangelock(0);

  //Accept and handle user input
  get_user_string(u);
  
  if (user_echo) {
    Serial.println(u);
  }

  //rc = REPORT CONFIG
if (u.substring(0, 6) == ""echo:o"") {
  user_echo = (u.substring(6, 1) == ""n"");

} else if (u == ""rc"") {
    report_config();
  //sc = SET CONFIG
 } else if (u.substring(0, 2) == ""sc"") {
    Serial.println(""Setting new config..."");
    set_config(u.substring(u.indexOf(':') + 1));
    report_config();
  }
  //emu = EMULATE CDAC OPERATION
  else if (u == ""emu"") {
    CompInp = 0;

    while (CompInp < 1) {
      do_conversion(data_array);


      print_data_big_endian(data_array, 10);
      Serial.println();

      CompInp = CompInp + 0.05;
    }
  }
  //stop = STOP; AWAIT RESET
  else if (u == ""stop"") {
    await_reset();
  } else if (u == ""adcsmoke"") {
    adc_smoke_test();
  } 
  else if (u == ""getcomp"") {
      if (get_comp()) {
        Serial.println(""1"");
      }
      else {
        Serial.println(""0"");
      }
    }
  else if (u == ""deassert"") {
      deassert_cdac_fe_signals();
    }
  else if (u == ""presamp"") {
      assert_presamp();
    }
  else if (u == ""~presamp"") {
      deassert_presamp();
    }
  else if (u == ""sample"") {
      assert_postsamp();
    }
  else if (u == ""~sample"") {
      deassert_postsamp();
    }
  else if (u == ""rst"") {
      assert_rst();
    }
  else if (u == ""~rst"") {
      deassert_rst();
    }
  else if (u == ""cap"") {
    serial_print_cap_values();
  } else if (u == ""runfe*"") {
    run_front_end();
  } else if (u == ""IDN?"") {
    Serial.print(DOCSTRING);
#ifdef PORTENTA
    Serial.print(""PORTENTA "");
#endif
#ifdef UNO
    Serial.print(""UNO "");
#endif
#ifdef EMULATOR
    Serial.print(""EMU "");
#endif
    Serial.println();
  } else if (u == ""PING"") {
    Serial.println(""PONG"");
  } else if (u.substring(0, 5) == ""cdac:"") {
    Serial.println(""Setting CDAC"");
    cdac_cmd_str(u.substring(u.indexOf(':') + 1));
  } else if (u.substring(0, 9) == ""cdac100x:"") {
    cdac_100x(u.substring(u.indexOf(':') + 1));
  } else if (u.substring(0, 8) == ""compinp:"") {
    CompInp = atof(u.substring(u.indexOf(':') + 1).c_str());
  } else if (u == ""conv100x"") {
    do_conversion_100x();
  } else if (u == ""conv"") {
    do_conversion(data_array);
    print_data_big_endian(data_array, 10);
    Serial.println();
  } else if (u.substring(0, 7) == ""convNx:"") {
    //Serial.println(""#hello world!"")
    numConversions = atol(u.substring(u.indexOf(':') + 1).c_str());
    for (int i = 0; i < (1 + numConversions / 100); i++) {
      do_conversion_100x();
    }
  } else if (u == ""samp100x"") {
    do_sample_100x();
  } else if (u == ""samp"") {
    do_sample(data_array);
    print_data_big_endian(data_array, 10);
    Serial.println();
  } else if (u.substring(0, 7) == ""sampNx:"") {
    numConversions = atol(u.substring(u.indexOf(':') + 1).c_str());
    for (int i = 0; i < (1 + numConversions / 100); i++) {
      do_sample_100x();
    }
  } else if (u == ""delay_demo"") {
    delay_demo();
  }
}

//Pass a null string to initialize to whatever is already stored in memory.
void set_config(String config_str) {
  for (int i = 0; i < config_str.length(); i++) {
    if (config_str[i] == '0') config[i] = 0;
    else config[i] = 1;
  }

  write_captrim_0(config[0]);
  write_captrim_1(config[1]);
  write_captrim_2(config[2]);
  write_captrim_3(config[3]);
  write_captrim_4(config[4]);
  write_captrim_5(config[5]);
  write_range2(config[6]);
  write_testen(config[7]);
}

void report_config() {
  Serial.print(""Config is: "");
  print_data(config, 8);
  Serial.println("""");
}


void serial_print_cap_values() {
  Serial.print(""CompInp: "");
  Serial.print(CompInp);
  Serial.print("" CL: "");
  Serial.print(CL);
  Serial.print("" CR: "");
  Serial.println(CR);
}

/**
   do_conversion - performs a single SAR ADC conversion and returns the data as a binary array.

*/
void do_conversion(char* data) {

  int capseq = 10;
  int current_precision = 9;

  noInterrupts();
  //For all 9 bits of data to collect.
  for (int i = 9; i >= 0; i--) {

    //Go through all previous data, using the value to
    //assert caphi or caplo.
    for (int k = i; k <= 9; k++) {
      //At the beginning of the calculation only, assert dacclr.
      if (k == i) {
        //Serial.println(""DACclr!"");
        assert_dacclr();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;  //0ns
        assert_caphi(); NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;  //30ns
        NOP;              //60ns
        deassert_dacclr();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;//90ns  --> DACclr PW = 90ns
        deassert_caphi(); NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;//120ns --> caphib PW = 90ns
      } else if (data[k] == 1) {
        assert_caphi();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
        NOP;
        NOP;
        deassert_caphi();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP; // --> caphib PW = 90ns
      } else {
        assert_caplo();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
        NOP;
        NOP;
        deassert_caplo();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP; // --> caphib PW = 90ns
      }

      //Serial.print(""Capclk ~ "");
      //serial_print_cap_values();
      assert_qequal();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
      NOP;
      NOP;
      deassert_qequal();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP; // --> Qequal PW = 90ns
      //Serial.print(""Qequal ~ "");
      //serial_print_cap_values();
    }

    NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
    data[i] = get_comp();
    NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
    //Serial.print(""Recorded "");
    //Serial.println(int(data[i]));
  }
  interrupts();
}
/** do_conversion_100x - runs do_conversion() 100 times and saves the data in a
    100-entry buffer.
*/
void  do_conversion_100x() {
  for (int i = 0; i < 100; i++) {
    do_conversion(data_array);
    delayMicroseconds(5); 
    data_buffer[i] = bin_array_to_dec_big_endian(data_array, 10);
  }

  //Serial.println(""did convs!"");
  String  [MASK]  = String();
  for (int i = 0; i < 100; i++) {
     [MASK]  += String(data_buffer[i], DEC) + String(""\n"");
    //Serial.println(data_buffer[i]);
  }
//  Serial.println(""-------------------------"");
  Serial.print( [MASK] ); //println has hardcoded \r\n (sic!)
  //Serial.print(""\n"");
}

void deassert_cdac_fe_signals() {
  //Zero out PreSamp, PostSamp, Rst.
  deassert_presamp();
  deassert_postsamp();
  deassert_rst();

  //Deassert all CDAC signals.
  deassert_caphi();
  deassert_caplo();
  deassert_qequal();
  deassert_dacclr();
}

void adc_smoke_test() {
  //Set up config (CapTrim=Nominal, TestEn=1)
  set_config(""00000101"");
  report_config();

  deassert_cdac_fe_signals();

  Serial.println(""CapTrim=Nom; Ready to begin!"");
  get_user_string(u);

  for (int k = 0; k < 2; k++) {
    for (int i = 1; i < 4; i++) {
      pulse_dacclr();

      pulse_caphi();
      pulse_qequal();

      if (i == 1) Serial.println(""Expected voltage: 0.5 Vref"");

      if (i == 2) {
        pulse_caphi();
        pulse_qequal();
        Serial.println(""Expected voltage: 0.75 Vref"");
      }
      if (i == 3) {
        pulse_caplo();
        pulse_qequal();
        Serial.println(""Expected voltage: 0.25 Vref"");
      }
      get_user_string(u);
    }
    set_config(""11111101"");
    report_config();
    Serial.println(""CapTrim=Hi; Ready to begin!"");
    get_user_string(u);
  }
}

void cdac_cmd_str(String cmd_str) {

  for (int i = 0; i < cmd_str.length(); i++) {
    if (cmd_str[i] == '0') data_array[i] = 0;
    else data_array[i] = 1;
  }

  cdac_cmd(data_array);
}

//Run a CDAC 100 times and print the output from Comp to Serial.
void cdac_100x(String cmd_str) {
  for (int i = 0; i < cmd_str.length(); i++) {
    if (cmd_str[i] == '0') data_array[i] = 0;
    else data_array[i] = 1;
  }

  for (int i = 0; i < 100; i++) {
    cdac_cmd(data_array);
    NOP;NOP;NOP; NOP;NOP;NOP;NOP;NOP;NOP;NOP;
    Serial.print(get_comp());NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
  }
  Serial.println();
}


void cdac_cmd(char* data_array) {
  deassert_cdac_fe_signals();

  pulse_dacclr();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;

  //Start from the lowest bit.
  //Do 10->1 instead of 9->0 to avoid having to deal with
  //overflow comparisons.
  for (int i = 10; i > 0; i--) {
    if (data_array[i - 1] > 0) {
      pulse_caphi();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
    } else {
      pulse_caplo();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
    }
    pulse_qequal();NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
  }
}

/** Executes one sample, including reset, sampling, and conversion phases.
 *  Stores the result in the provided char*.
 */
void do_sample(char* data) {
  noInterrupts();
  assert_rst();       //0ns
  assert_pulsetrig();
  for(uint8_t i = 0; i < 29; i++) NOP; //870ns
  deassert_rst();     //900ns --> Reset PW = 900 ns
  assert_presamp();   //930ns
  assert_postsamp();  //960ns
  NOP;NOP;NOP;NOP;NOP;NOP;NOP;//1200 ns
  deassert_presamp(); //1200 ns --> PW(Postsamp^ --> Presampv) = 240ns
  NOP;NOP;NOP; NOP;NOP;NOP; NOP;NOP;NOP; //1470ns
  deassert_postsamp();//1500 ns --> PW(Presampv --> Postsampv) = 300ns

  deassert_pulsetrig();
  assert_rst(); //AQ added 6/20/2023 to see if it would make FE sweeps work. 
  //This should already have interrupts disabled but just in case...
  do_conversion(data);
  interrupts();
  
}

void do_sample_100x() {
  for (int i = 0; i < 100; i++) {
    do_sample(data_array);
    data_buffer[i] = bin_array_to_dec_big_endian(data_array, 10);
  }

  for (int i = 0; i < 100; i++) {
    Serial.println(data_buffer[i]);
  }
}

void run_front_end() {
  long sample_ct;

  deassert_cdac_fe_signals();

  while (!Serial.available()) {

    for (long i = 0; i < 10000; i++) {

      //TBD: Check the Portenta timing on this!!!
      //assert_postsamp();
      //assert_presamp();
      //deassert_presamp();
      //deassert_postsamp();
      noInterrupts();
      assert_rst();       //0ns
      assert_pulsetrig();
      for(uint8_t i = 0; i < 29; i++) NOP; //870ns
      deassert_rst();     //900ns --> Reset PW = 900 ns
      assert_postsamp();   //930ns
      assert_presamp();  //960ns
      NOP;NOP;NOP;NOP;NOP;NOP;NOP;//1200 ns
      deassert_presamp(); //1200 ns --> PW(Postsamp^ --> Presampv) = 240ns
      NOP;NOP;NOP; NOP;NOP;NOP; NOP;NOP;NOP; //1470ns
      deassert_postsamp();//1500 ns --> PW(Presampv --> Postsampv) = 300ns
      interrupts();
      
      deassert_pulsetrig();

      delayMicroseconds(5);
      assert_rst();
      delayMicroseconds(5);
      //assert_rst();
      //deassert_rst();
    }

    sample_ct++;
    Serial.print(sample_ct * 10);
    Serial.println("" k samples taken..."");
  }
}

void delay_demo() {
  volatile int i;

  while (1) {

    deassert_dacclr();
    delay(1);
    if (Serial.available()) break;

    noInterrupts();
    assert_dacclr();
    deassert_dacclr();
    NOP;
    assert_dacclr();
    NOP;
    deassert_dacclr();
    NOP;
    assert_dacclr();
    NOP;
    NOP;
    deassert_dacclr();
    NOP;
    assert_dacclr();
    NOP; NOP; NOP;
    deassert_dacclr();
    NOP; NOP;
    interrupts();
  }

}
",measurements
621,"
#include ""nbody_plugin.h""

#include <common/utils.h>

#include <map>
#include <string>
#include <stdexcept>

static auto& PluginsMap() {
  static std::map<std::string, NBodyPlugin*> plugins;
  return plugins;
}

NBodyPlugin::NBodyPlugin(const std::string& name) {
  RegisterPlugin(this, name);
}

void RegisterPlugin(NBodyPlugin* plugin, const std::string& name) {
  CHECK(PluginsMap().insert({ name, plugin }).second);
}

NBodyPlugin* SelectPlugin(const std::string& name) {
  auto it = PluginsMap().find(name);
  if (it == PluginsMap().end()) {
    throw std::runtime_error(""Plugin not found: "" + name);
  }
  printf(""Implementation plugin: %s\n"", name.c_str());
  return it->second;
}

std::vector<std::string> AvailablePlugins() {
  std::vector<std::string>  [MASK] ;
  for (const auto& kv : PluginsMap()) {
     [MASK] .push_back(kv.first);
  }
  return  [MASK] ;
}
",plugin_names
622,"//          Copyright <NAME> 2019.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#include ""vgm.h""
#include ""mapped_file.h""
extern ""C"" {
#include <comment.h>
#include <xmalloc.h>
#include <debug.h>
}
#include <player/vgmplayer.hpp>
#include <player/s98player.hpp>
#include <player/droplayer.hpp>
#include <utils/MemoryLoader.h>
#include <zlib.h>
#include <memory>
#include <cmath>
#include <cstdio>
#include <cstring>

//------------------------------------------------------------------------------
struct DATA_LOADER_delete { void operator()(DATA_LOADER *x) const noexcept { DataLoader_Deinit(x); } };
typedef std::unique_ptr<DATA_LOADER, DATA_LOADER_delete> DATA_LOADER_u;

//------------------------------------------------------------------------------
static_assert(sizeof(WAVE_32BS) == 2 * sizeof(INT32) &&
              alignof(WAVE_32BS) == alignof(INT32),
              ""The type WAVE_32BS is not structured as expected."");

static constexpr int samplerate = 44100;
static constexpr UINT32 maxrender = 4096;
static const double fadefactor = std::exp(-1.0 / samplerate);
static UINT32 maxloops = 1;

struct vgm_private {
    enum class State { stopped, started, atend };
    State state = State::stopped;
    double volume = 1;
    mapped_file map;
    DATA_LOADER_u loader;
    std::unique_ptr<PlayerBase> player;
};

//------------------------------------------------------------------------------
static int vgz_open(input_plugin_data *ip_data, const UINT8 *data, size_t size);
static int vgm_open_after_map(input_plugin_data *ip_data);
static UINT8 vgm_play_callback(PlayerBase *player, void *user_param, UINT8 evt_type, void *evt_param);

//------------------------------------------------------------------------------
static int vgm_open(input_plugin_data *ip_data)
{
    d_print(""vgm_open(%p): %s\n"", ip_data, ip_data->filename);

    int ret = 0;
    std::unique_ptr<vgm_private> priv(new vgm_private);

    ip_data->priv = priv.get();

    mapped_file &map = priv->map;
    if (!map.open(ip_data->fd))
        ret = -IP_ERROR_ERRNO;
    else {
        const UINT8 *data = (const UINT8 *)map.data();
        size_t size = map.size();

        if (size >= 2 && data[0] == 0x1f && data[1] == 0x8b)
            ret = vgz_open(ip_data, data, size);
        else
            ret = vgm_open_after_map(ip_data);
    }

    if (ret == 0)
        priv.release();
    else
        ip_data->priv = nullptr;

    return ret;
}

static int vgz_open(input_plugin_data *ip_data, const UINT8 *data, size_t size)
{
    vgm_private *priv = (vgm_private *)ip_data->priv;

    struct File_Deleter { void operator()(FILE *x) { fclose(x); } };
    std::unique_ptr<FILE, File_Deleter> fh(tmpfile());
    if (!fh)
        return -IP_ERROR_ERRNO;

    int fd = dup(ip_data->fd);
    if (fd == -1)
        return -IP_ERROR_ERRNO;

    struct Gz_Deleter { void operator()(gzFile x) { gzclose(x); } };
    std::unique_ptr<gzFile_s, Gz_Deleter> gz(gzdopen(fd, ""r""));
    if (!gz) {
        close(fd);
        return -IP_ERROR_FILE_FORMAT;
    }

    int gzcount;
    UINT8 buffer[8192];
    while ((gzcount = gzread(gz.get(), buffer, sizeof(buffer))) > 0) {
        if (fwrite(buffer, 1, gzcount, fh.get()) != gzcount)
            return -IP_ERROR_ERRNO;
    }
    if (gzcount == -1)
        return -IP_ERROR_FILE_FORMAT;

    if (fflush(fh.get()) != 0)
        return -IP_ERROR_ERRNO;
    rewind(fh.get());

    mapped_file &map = priv->map;
    if (!map.open(fileno(fh.get())))
        return -IP_ERROR_ERRNO;

    return vgm_open_after_map(ip_data);
}

static int vgm_open_after_map(input_plugin_data *ip_data)
{
    vgm_private *priv = (vgm_private *)ip_data->priv;

    mapped_file &map = priv->map;
    const UINT8 *data = (const UINT8 *)map.data();
    size_t size = map.size();

    DATA_LOADER *loader = MemoryLoader_Init(data, size);
    if (!loader)
        throw std::bad_alloc();
    priv->loader.reset(loader);

    DataLoader_SetPreloadBytes(loader, 0x100);
    if (DataLoader_Load(loader) != 0)
        return -IP_ERROR_FILE_FORMAT;

    if (VGMPlayer::IsMyFile(loader) == 0)
        priv->player.reset(new VGMPlayer);
    else if (S98Player::IsMyFile(loader) == 0)
        priv->player.reset(new S98Player);
    else if (DROPlayer::IsMyFile(loader) == 0)
        priv->player.reset(new DROPlayer);
    else
        return -IP_ERROR_FILE_FORMAT;

    PlayerBase &player = *priv->player;
    if (player.LoadFile(loader) != 0)
        return -IP_ERROR_FILE_FORMAT;
    player.SetCallback(&vgm_play_callback, priv);
    player.SetSampleRate(samplerate);
    player.Start();
    priv->state = vgm_private::State::started;
    priv->volume = 1;

    ip_data->sf = sf_bits(32) | sf_rate(samplerate) | sf_channels(2) | sf_signed(1);
    ip_data->sf |= sf_host_endian();
    channel_map_init_stereo(ip_data->channel_map);
    return 0;
}

static UINT8 vgm_play_callback(PlayerBase *player, void *user_param, UINT8 evt_type, void *evt_param)
{
    vgm_private *priv = (vgm_private *)user_param;

    switch (evt_type) {
    case PLREVT_LOOP: {
        UINT32 curloop = *(UINT32 *)evt_param;
        if (curloop >= maxloops)
            priv->state = vgm_private::State::atend;
        break;
    }
    case PLREVT_END:
        priv->state = vgm_private::State::atend;
        break;
    }
    return 0;
}

static int vgm_close(input_plugin_data *ip_data)
{
    d_print(""vgm_close(%p)\n"", ip_data);

    vgm_private *priv = (vgm_private *)ip_data->priv;
    PlayerBase *player = priv->player.get();

    if (player) {
        player->Stop();
        player->UnloadFile();
    }

    delete priv;
    ip_data->priv = nullptr;
    return 0;
}

static int vgm_read(input_plugin_data *ip_data, char *buffer, int count)
{
    d_print(""vgm_read(%p, %d)\n"", ip_data, count);

    vgm_private *priv = (vgm_private *)ip_data->priv;
    PlayerBase &player = *priv->player;

    bool atend = priv->state == vgm_private::State::atend;
    if (atend && player.GetLoopTicks() == 0)
        return 0; // if not a looped song, just stop right here

    int  [MASK]  = count / sizeof(WAVE_32BS);
    if ( [MASK]  > maxrender)  [MASK]  = maxrender;  // workaround for libvgm internal limit

    std::fill(buffer, buffer +  [MASK]  * sizeof(WAVE_32BS), 0);
    int got = player.Render( [MASK] , (WAVE_32BS *)buffer);

    for (int i = 0; i < 2 * got; ++i) {
        INT32 *dst = (INT32 *)(buffer + i * sizeof(int32_t));

        INT32 smpl = *dst;

        constexpr unsigned smplbits = 24;
        constexpr INT32 smplmax = (1 << (smplbits - 1)) - 1;
        constexpr INT32 smplmin = -smplmax;

        // clipping
        if (smpl > smplmax)
            smpl = smplmax;
        else if (smpl < smplmin)
            smpl = smplmin;
        // 32 bit conversion
        smpl *= 1 << (32 - smplbits);

        *dst = smpl;
    }

    if (atend) { // if a looped song, smoothly turn down the volume
        double vol = priv->volume;
        for (int i = 0; i < got; ++i) {
            WAVE_32BS *dst = &((WAVE_32BS *)buffer)[i];
            vol *= fadefactor;
            dst->L = (INT32)std::lround(vol * dst->L);
            dst->R = (INT32)std::lround(vol * dst->R);
            if (vol < 1e-4) { got = i; break; }
        }
        priv->volume = vol;
    }

    return got * sizeof(WAVE_32BS);
}

static int vgm_seek(input_plugin_data *ip_data, double offset)
{
    d_print(""vgm_seek(%p)\n"", ip_data);

    vgm_private *priv = (vgm_private *)ip_data->priv;
    PlayerBase &player = *priv->player;

    priv->state = vgm_private::State::started;
    priv->volume = 1;
    player.Reset();
    player.Seek(PLAYPOS_SAMPLE, std::lround(offset * samplerate));

    return 0;
}

static int vgm_read_comments(input_plugin_data *ip_data, struct keyval **comments)
{
    d_print(""vgm_read_comments(%p)\n"", ip_data);

    vgm_private *priv = (vgm_private *)ip_data->priv;
    PlayerBase &player = *priv->player;
    GROWING_KEYVALS(c);

    const char *title = NULL;
    const char *author = NULL;
    const char *game = NULL;
    const char *date = NULL;
    const char *comment = NULL;
    const char *system = NULL;

    const char *const *tags = player.GetTags();
    for (const char *const *t = tags; *t; t += 2) {
        if (!strcmp(t[0], ""TITLE""))
            title = t[1];
        else if (!strcmp(t[0], ""ARTIST""))
            author = t[1];
        else if (!strcmp(t[0], ""GAME""))
            game = t[1];
        else if (!strcmp(t[0], ""DATE""))
            date = t[1];
        else if (!strcmp(t[0], ""COMMENT""))
            comment = t[1];
        else if (!strcmp(t[0], ""SYSTEM""))
            system = t[1];
    }

    if (title && title[0])
        comments_add_const(&c, ""title"", title);
    if (author && author[0])
        comments_add_const(&c, ""artist"", author);
    if (game && game[0])
        comments_add_const(&c, ""album"", game);
    if (date && date[0])
        comments_add_const(&c, ""date"", date);
    if (comment && comment[0])
        comments_add_const(&c, ""comment"", comment);
    if (system && system[0])
        comments_add_const(&c, ""genre"", system);

    keyvals_terminate(&c);
    *comments = c.keyvals;

    return 0;
}

static int vgm_duration(input_plugin_data *ip_data)
{
    d_print(""vgm_duration(%p)\n"", ip_data);

    vgm_private *priv = (vgm_private *)ip_data->priv;
    PlayerBase &player = *priv->player;

    return player.Tick2Second(player.GetTotalPlayTicks(maxloops));
}

static long vgm_bitrate(input_plugin_data *ip_data)
{
    d_print(""vgm_bitrate(%p)\n"", ip_data);

    return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
}

static char *vgm_codec(input_plugin_data *ip_data)
{
    d_print(""vgm_codec(%p)\n"", ip_data);

    return nullptr;
}

static char *vgm_codec_profile(input_plugin_data *ip_data)
{
    d_print(""vgm_codec_profile(%p)\n"", ip_data);

    return nullptr;
}

//------------------------------------------------------------------------------
static int vgm_set_maxloops(const char *val)
{
    unsigned num;
    unsigned size;
    if (sscanf(val, ""%u%n"", &num, &size) != 1 || strlen(val) != size) {
        errno = EINVAL;
        return -IP_ERROR_ERRNO;
    }
    maxloops = num;
    return 0;
}

static int vgm_get_maxloops(char **val)
{
    char str[32];
    sprintf(str, ""%u"", maxloops);
    *val = xstrdup(str);
    return 0;
}

//------------------------------------------------------------------------------
const struct input_plugin_ops ip_ops = {
    .open = &vgm_open,
    .close = &vgm_close,
    .read = &vgm_read,
    .seek = &vgm_seek,
    .read_comments = &vgm_read_comments,
    .duration = &vgm_duration,
    .bitrate = &vgm_bitrate,
    .bitrate_current = &vgm_bitrate,
    .codec = &vgm_codec,
    .codec_profile = &vgm_codec_profile
};

const int ip_priority = 50;
const char * const ip_extensions[] = { ""vgm"", ""vgz"", ""s98"", ""dro"", nullptr };
const char * const ip_mime_types[] = { nullptr };
const struct input_plugin_opt ip_options[] = { {""max_loops"", &vgm_set_maxloops, &vgm_get_maxloops}, { nullptr } };
const unsigned ip_abi_version = IP_ABI_VERSION;
",want
623,"/**
 * Loads csvs with no frills or other bullshit.
 */

#pragma once

#include <cassert>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

namespace tb {
template <typename T = std::string>
class TableRow {
 public:
  int ncols = row.size();
  std::map<std::string, T> row;

  explicit TableRow(std::map<std::string, T> _row) { row = _row; }

  std::string ToString() {
    std::ostringstream os;
    for (const auto &r : row) {
      os << row.second << "", "";
    }

    return os.str();
  }
};  // namespace tb

template <typename T = std::string, typename I = unsigned int>
struct Table {
  static std::vector<I> dummy_index;

  std::vector<I> index;
  std::vector<std::string> headings;
  std::vector<TableRow<T>> rows;

  Table(std::vector<std::string> _headings,
        std::vector<I> _index = dummy_index) {
    headings = _headings;

    if (_index == dummy_index) {
      index = std::vector<I>{};
    } else {
      index = _index;
    }
  };

  Table(std::vector<TableRow<T>>  [MASK] , std::vector<std::string> _headings,
        std::vector<T> _index) {
    rows =  [MASK] ;
    headings = _headings;
    index = _index;
  }

  void MergeFront(const Table &t) {
    assert(t.headings == headings);
    rows.insert(rows.start(), t.rows);
  }

  void MergeBack(const Table &t) {
    assert(t.headings == headings);
    rows.insert(rows.end(), t.rows);
  }

  void MergeAt(const Table &t, int index) {
    assert(t.headings == headings);
    assert(index + 1 < rows.size());
    rows.insert(rows.start() + index, t.rows);
  }

  // Assumes l -> r preserved on create
  void AddRow(const std::vector<T> &values) {
    assert(values.size() == headings.size());

    std::map<std::string, T> row;

    for (size_t i = 0; i < values.size(); ++i) {
      row[headings[i]] = values[i];
    }

    rows.push_back(TableRow<T>(row));
  }

  int size() { return rows.size(); }
  std::pair<int, int> shape() {
    return std::make_pair(rows.size(), headings.size());
  }

  std::string ToString() {
    std::ostringstream os;

    for (const auto heading : headings) {
      os << heading << "", "";
    }
    os << ""\n"";

    for (const auto row : rows) {
      os << row << ""\n "";
    }

    return os.str();
  }

  TableRow<T> ILoc(int index) { return rows[index]; }
  TableRow<T> Loc(int index, const std::string &col) {
    return rows[index].at(col);
  }
};

class Tb {
 public:
  Tb() = default;
  Tb(const std::string &csvfile, const char delim = ',')
      : csvfile(csvfile), delim(delim) {
    _ReadCsv(csvfile);
  };

  static Tb ReadCsv(const std::string &csvfile) { return _ReadCsv(csvfile); }

 private:
  Table table;

  Tb _ReadCsv(const std::string &csvfile) {}
};
}  // namespace tb
",_rows
624,"#include <iostream>
#include <functional>
#include <vector>

//***************************

class Pose3D {
    // TODO
};
class Direction3D {
    // TODO
};
class Duration {
    // TODO
};
class TimePoint {
    // TODO
public:
    TimePoint operator+=(Duration const&)
    {
        // TODO
        return {};
    }

    friend bool operator == (TimePoint const&, TimePoint const&) {
        // TODO
        return true;
    }
};


class Transformation {
    // TODO
public:
    Pose3D operator()(Pose3D) {
        return {
            // TODO
        };
    }
};

class AngleVelocity {
    // TODO
};
class Acceleration {
    // TODO
};



//***************************
class KinematicState {
    // TODO
    TimePoint m_time;
public:
    KinematicState(TimePoint time)
        : m_time{std::move(time)}
    {}

    TimePoint getTime() const { return m_time; }

    KinematicState transformed(Transformation) const {
        // TODO
        return *this;
    }
};

class TrajectoryIterator;
class Trajectory;

class TrajectoryRange {
    friend class TrajectoryIterator;
    TimePoint m_startTime;
    TimePoint m_endTime;
    Duration m_step;
    Trajectory const& m_trajectory;

public:
    TrajectoryRange(TimePoint start, TimePoint stop, Duration step, Trajectory const& trajectory);

    TrajectoryIterator begin() const;

    TrajectoryIterator end() const;

    Duration getStep() const;
};

class Trajectory {
public:
    KinematicState evaluateAtTime(TimePoint) const;

    TrajectoryRange getRange(Duration) const;

    Trajectory transformed(Transformation const&) const;
};

class TrajectoryIterator : public std::iterator<
                        std::input_iterator_tag,       // iterator_category
                        KinematicState,                // value_type
                        Duration,                      // difference_type
                        KinematicState*,               // pointer
                        KinematicState&                // reference
                                      >
{
    TimePoint m_time;
    TrajectoryRange const& m_range;

public:
    TrajectoryIterator(TimePoint time, TrajectoryRange const& range)
        : m_time{std::move(time)}
        , m_range{range}
    {}

    TrajectoryIterator& operator++() {
        m_time += m_range.getStep();
        return *this;
    }

    TrajectoryIterator operator++(int) {
        auto  [MASK] (*this);
        ++(*this);
        return  [MASK] ;
    }

    bool operator==(TrajectoryIterator const& other) const {
        return m_time == other.m_time;
    }

    bool operator!=(TrajectoryIterator const& other) const {
        return !(*this == other);
    }

    KinematicState operator*() const {
        return m_range.m_trajectory.evaluateAtTime(m_time);
    }
};

TrajectoryRange::TrajectoryRange(TimePoint start, TimePoint stop, Duration step, Trajectory const& trajectory)
    : m_startTime{std::move(start)}
    , m_endTime{std::move(stop)}
    , m_step{std::move(step)}
    , m_trajectory{trajectory}
{}

TrajectoryIterator TrajectoryRange::begin() const {
    return { m_startTime, *this };
}

TrajectoryIterator TrajectoryRange::end() const {
    return { m_endTime, *this };
}

Duration TrajectoryRange::getStep() const { return m_step; }

KinematicState Trajectory::evaluateAtTime(TimePoint time) const {
    return {time};
}

TrajectoryRange Trajectory::getRange(Duration step) const {
    return {TimePoint{}, TimePoint{}, step, *this};
}

Trajectory Trajectory::transformed(Transformation const&) const {
    return {};
}

class TrajectoryBuilder {
    // TODO
public:
    Trajectory build() const {
        // TODO
        return {};
    }
    TrajectoryBuilder& initialPose(Pose3D) { return *this; }
    TrajectoryBuilder& atTime(TimePoint) { return *this; }
    TrajectoryBuilder& accelerate(Duration, Acceleration) { return *this; }
    TrajectoryBuilder& rotateSystem(Direction3D, AngleVelocity) { return *this; }
};

//***************************

class SimulatorConfig {
    // TODO
    Duration m_timeStep;
public:
    SimulatorConfig(Duration timeStep)
        : m_timeStep{std::move(timeStep)}
    {}

    Duration getTimeStep() const { return m_timeStep; }
};

class SimulatorConfigBuilder {
    // TODO
    Duration m_timeStep;

public:
    SimulatorConfig build() const {
        return { m_timeStep };
    }

    SimulatorConfigBuilder& setTimeStep(Duration step) {
        m_timeStep = step;
        return *this;
    }

};


//***************************
class EnvironmentConfig {
    // TODO
};

class EnvironmentConfigBuilder {
    // TODO
public:
    EnvironmentConfig build() const {
        // TODO
        return {};
    }

    EnvironmentConfigBuilder& addSphere() {
        // TODO
        return *this;
    }

    EnvironmentConfigBuilder& addBox() {
        // TODO
        return *this;
    }
};
//***************************

class ImuSensorConfig {
    // TODO
public:
    ImuSensorConfig(std::string){}
};
class Laser2dSensorConfig {
    // TODO
public:
    Laser2dSensorConfig(std::string) {}
};

//***************************
class SystemConfig {
    // TODO
};

class SystemConfigBuilder {
    // TODO
public:
    SystemConfig build() const {
        // TODO
        return {};
    }
    SystemConfigBuilder& addImu(ImuSensorConfig) {
        // TODO
        return *this;
    }
    SystemConfigBuilder& add2dLaser(Laser2dSensorConfig) {
        // TODO
        return *this;
    }
};

//***************************
class Environment {
    // TODO
};

class EnvironmentFactory {
public:
    Environment create(EnvironmentConfig) const {
        return {};
    }
};

class RawSensorDataCollector {
    // TODO
public:
    void addImuSample(TimePoint) {
        // TODO
    }
    void add2dLaserSamples(TimePoint) {
        // TODO
    }
};


//***************************

class SimulationSetup {};
class Simulation {
    std::function<void(RawSensorDataCollector&)> m_behavior;

public:
    Simulation(std::function<void(RawSensorDataCollector&)> behavior)
        : m_behavior{ std::move(behavior) }
    {}

    void run(RawSensorDataCollector& dataCollector) {
        m_behavior(dataCollector);
    }
};

class SimulationBuilder {
    std::function<void(RawSensorDataCollector&)> m_behavior;

public:
    SimulationBuilder& setBehavior(std::function<void(RawSensorDataCollector&)> behavior) {
        m_behavior = std::move(behavior);
        return *this;
    }
    Simulation build() const {
        return { m_behavior };
    }
};


//***************************
class AbstractSensorImpl {
public:
    virtual Simulation
    sample(Environment& env, KinematicState const& state) const = 0;

    virtual Simulation
    sampleAt(Environment& env, Trajectory const& trajectory, Duration const& period) const {
        const auto behavior = [&env,&trajectory,&period, this](RawSensorDataCollector& collector) {
            for(auto const& state : trajectory.getRange(period)) {
                sample(env, state).run(collector);
            }
        };
        return SimulationBuilder()
            .setBehavior(behavior)
            .build();

    }
};

class AbstractSensor {
    std::unique_ptr<AbstractSensorImpl> m_impl;

public:
    AbstractSensor(std::unique_ptr<AbstractSensorImpl> impl)
        : m_impl{std::move(impl)}
    {}

    Simulation
    sample(Environment& env, KinematicState const& state) const {
        return m_impl->sample(env, state);
    };

    Simulation
    sampleAt(Environment& env, Trajectory const& trajectory, Duration const& period) const {
        return m_impl->sampleAt(env, trajectory, period);
    }
};


//***************************
class ImuSensorImpl : public AbstractSensorImpl {
public:
    virtual Simulation
    sample(Environment& env, KinematicState const& state) const {
        auto const behavior = [&state](RawSensorDataCollector& collector) {
            /* auto sample =
                { Acceleration{ state.getAcceleration() + gravity }
                , AngleVelocity{ state.getAngularVelocityFrom() }
                }; */
            collector.addImuSample(state.getTime()/*sample*/);
        };
        return SimulationBuilder()
            .setBehavior(behavior)
            .build();
    }

};


class SystemSensorImpl : public AbstractSensorImpl {
    struct SensorConfig {
        AbstractSensor sensor;
        Transformation trafo;
        Duration period;
    };
    std::vector<SensorConfig> m_sensors;

public:
    virtual Simulation
    sample(Environment& env, KinematicState const& state) const override {
        auto const behavior = [&state,&env,this](RawSensorDataCollector& collector) {
            for(auto const& sensorConfig : m_sensors) {
                auto simulation = sensorConfig.sensor.sample(
                    env,
                    state.transformed(sensorConfig.trafo));
                simulation.run(collector);
            }
        };
        return SimulationBuilder()
            .setBehavior(behavior)
            .build();
    }

    virtual Simulation
    sampleAt(Environment& env, Trajectory const& trajectory, Duration const& period) const override {
        auto const behavior = [&env,&trajectory,&period, this](RawSensorDataCollector& collector) {
            for(auto const& config : m_sensors) {
                auto simulation = config.sensor.sampleAt(
                    env,
                    trajectory.transformed(config.trafo),
                    config.period);
                simulation.run(collector);
            }
        };
        return SimulationBuilder()
            .setBehavior(behavior)
            .build();
    }
};

class SystemFactory {
public:
    AbstractSensor create(SystemConfig) {
        return AbstractSensor{std::make_unique<SystemSensorImpl>()};
    }
};


class Simulator {
    SimulatorConfig m_simConfig;
    Environment m_env;

public:
    Simulator(SimulatorConfig simConfig, Environment env)
        : m_simConfig{std::move(simConfig)}
        , m_env{std::move(env)}
    {}

    std::function<void(RawSensorDataCollector&)>
    simulate(AbstractSensor const& sensor, Trajectory const& trajectory) {
        return [&sensor,&trajectory,this](RawSensorDataCollector& collector) {
            for(auto const& state : trajectory.getRange(m_simConfig.getTimeStep())) {
                auto simulation = sensor.sample(m_env, state);
                simulation.run(collector);
            }
        };
    }
};
//***************************

class SimulatorFactory {
public:
    Simulator create(
        SimulatorConfig simConfig,
        Environment env)
    {
        return {simConfig, env};
    }
};


//***************************
int main()
{


    auto simulatorConfig =
        SimulatorConfigBuilder()
            /* ... */
            .build();

    auto environmentConfig =
        EnvironmentConfigBuilder()
            .addSphere(/*...*/)
            .addBox(/*...*/)
            .build();

    auto systemConfig =
        SystemConfigBuilder()
            .addImu(ImuSensorConfig{""imu1"" /*...*/})
            .add2dLaser(Laser2dSensorConfig{""laser2d_1"" /*...*/})
            .build();

    auto environment = EnvironmentFactory().create(environmentConfig);
    auto simulator = SimulatorFactory().create(
        simulatorConfig,
        environment);

    auto trajectory =
        TrajectoryBuilder()
            .initialPose(Pose3D{})
            .atTime(TimePoint{})
            .accelerate(Duration{}, Acceleration{})
            .atTime(TimePoint{})
            .rotateSystem(Direction3D{}, AngleVelocity{})
            .build();

    auto system = SystemFactory().create(systemConfig);
    auto simulation = simulator.simulate(system, trajectory);

    std::cout << ""hello world from simulator"" << std::endl;
}


/*
void test() {
    System system;
    Trajectory trajectory;
    Environment environment;

    ScanFileWriter scanFileWriter;
    SimulatorConfig simConfig;

    auto simulator = Simulator{simConfig,environment};
    simulator.simulationOf(system, trajectory).runWith(scanFileWriter);
}*/
",copy
625,"// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#include ""AuthRegistry.h""

#include ""cephx/CephxAuthorizeHandler.h""
#ifdef HAVE_GSSAPI
#include ""krb/KrbAuthorizeHandler.hpp""
#endif
#include ""none/AuthNoneAuthorizeHandler.h""
#include ""common/ceph_context.h""
#include ""common/debug.h""
#include ""auth/KeyRing.h""

#define dout_subsys ceph_subsys_auth
#undef dout_prefix
#define dout_prefix *_dout << ""AuthRegistry("" << this << "") ""

AuthRegistry::AuthRegistry(CephContext *cct)
  : cct(cct)
{
  cct->_conf.add_observer(this);
}

AuthRegistry::~AuthRegistry()
{
  cct->_conf.remove_observer(this);
  for (auto i : authorize_handlers) {
    delete i.second;
  }
}

const char** AuthRegistry::get_tracked_conf_keys() const
{
  static const char *keys[] = {
    ""auth_supported"",
    ""auth_client_required"",
    ""auth_cluster_required"",
    ""auth_service_required"",
    ""ms_mon_cluster_mode"",
    ""ms_mon_service_mode"",
    ""ms_mon_client_mode"",
    ""ms_cluster_mode"",
    ""ms_service_mode"",
    ""ms_client_mode"",
    ""keyring"",
    NULL
  };
  return keys;
}

void AuthRegistry::handle_conf_change(
  const ConfigProxy& conf,
  const std::set<std::string>& changed)
{
  std::scoped_lock l(lock);
  _refresh_config();
}


void AuthRegistry::_parse_method_list(const string& s,
				      std::vector<uint32_t> *v)
{
  std::list<std::string> sup_list;
  get_str_list(s, sup_list);
  if (sup_list.empty()) {
    lderr(cct) << ""WARNING: empty auth protocol list"" << dendl;
  }
  v->clear();
  for (auto& i : sup_list) {
    ldout(cct, 5) << ""adding auth protocol: "" << i << dendl;
    if (i == ""cephx"") {
      v->push_back(CEPH_AUTH_CEPHX);
    } else if (i == ""none"") {
      v->push_back(CEPH_AUTH_NONE);
    } else if (i == ""gss"") {
      v->push_back(CEPH_AUTH_GSS);
    } else {
      lderr(cct) << ""WARNING: unknown auth protocol defined: "" << i << dendl;
    }
  }
  if (v->empty()) {
    lderr(cct) << ""WARNING: no auth protocol defined"" << dendl;
  }
  ldout(cct,20) << __func__ << "" "" << s << "" -> "" << *v << dendl;
}

void AuthRegistry::_parse_mode_list(const string& s,
				    std::vector<uint32_t> *v)
{
  std::list<std::string> sup_list;
  get_str_list(s, sup_list);
  if (sup_list.empty()) {
    lderr(cct) << ""WARNING: empty auth protocol list"" << dendl;
  }
  v->clear();
  for (auto& i : sup_list) {
    ldout(cct, 5) << ""adding con mode: "" << i << dendl;
    if (i == ""crc"") {
      v->push_back(CEPH_CON_MODE_CRC);
    } else if (i == ""secure"") {
      v->push_back(CEPH_CON_MODE_SECURE);
    } else {
      lderr(cct) << ""WARNING: unknown connection mode "" << i << dendl;
    }
  }
  if (v->empty()) {
    lderr(cct) << ""WARNING: no connection modes defined"" << dendl;
  }
  ldout(cct,20) << __func__ << "" "" << s << "" -> "" << *v << dendl;
}

void AuthRegistry::_refresh_config()
{
  if (cct->_conf->auth_supported.size()) {
    _parse_method_list(cct->_conf->auth_supported, &cluster_methods);
    _parse_method_list(cct->_conf->auth_supported, &service_methods);
    _parse_method_list(cct->_conf->auth_supported, &client_methods);
  } else {
    _parse_method_list(cct->_conf->auth_cluster_required, &cluster_methods);
    _parse_method_list(cct->_conf->auth_service_required, &service_methods);
    _parse_method_list(cct->_conf->auth_client_required, &client_methods);
  }
  _parse_mode_list(cct->_conf.get_val<string>(""ms_mon_cluster_mode""),
		   &mon_cluster_modes);
  _parse_mode_list(cct->_conf.get_val<string>(""ms_mon_service_mode""),
		   &mon_service_modes);
  _parse_mode_list(cct->_conf.get_val<string>(""ms_mon_client_mode""),
		   &mon_client_modes);
  _parse_mode_list(cct->_conf.get_val<string>(""ms_cluster_mode""),
		   &cluster_modes);
  _parse_mode_list(cct->_conf.get_val<string>(""ms_service_mode""),
		   &service_modes);
  _parse_mode_list(cct->_conf.get_val<string>(""ms_client_mode""),
		   &client_modes);

  ldout(cct,10) << __func__ << "" cluster_methods "" << cluster_methods
		<< "" service_methods "" << service_methods
		<< "" client_methods "" << client_methods
		<< dendl;
  ldout(cct,10) << __func__ << "" mon_cluster_modes "" << mon_cluster_modes
		<< "" mon_service_modes "" << mon_service_modes
		<< "" mon_client_modes "" << mon_client_modes
		<< ""; cluster_modes "" << cluster_modes
		<< "" service_modes "" << service_modes
		<< "" client_modes "" << client_modes
		<< dendl;

  // if we have no keyring, filter out cephx
  _no_keyring_disabled_cephx = false;
  bool any_cephx = false;
  for (auto *p : {&cluster_methods, &service_methods, &client_methods}) {
    auto q = std::find(p->begin(), p->end(), CEPH_AUTH_CEPHX);
    if (q != p->end()) {
      any_cephx = true;
      break;
    }
  }
  if (any_cephx) {
    KeyRing k;
    int r = k.from_ceph_context(cct);
    if (r == -ENOENT) {
      for (auto *p : {&cluster_methods, &service_methods, &client_methods}) {
	auto q = std::find(p->begin(), p->end(), CEPH_AUTH_CEPHX);
	if (q != p->end()) {
	  p->erase(q);
	  _no_keyring_disabled_cephx = true;
	}
      }
    }
    if (_no_keyring_disabled_cephx) {
      lderr(cct) << ""no keyring found at "" << cct->_conf->keyring
	       << "", disabling cephx"" << dendl;
    }
  }
}

void AuthRegistry::get_supported_methods(
  int peer_type,
  std::vector<uint32_t> *methods,
  std::vector<uint32_t> *modes)
{
  if (methods) {
    methods->clear();
  }
  if (modes) {
    modes->clear();
  }
  std::scoped_lock l(lock);
  switch (cct->get_module_type()) {
  case CEPH_ENTITY_TYPE_CLIENT:
    // i am client
    if (methods) {
      *methods = client_methods;
    }
    if (modes) {
      switch (peer_type) {
      case CEPH_ENTITY_TYPE_MON:
	*modes = mon_client_modes;
	break;
      default:
	*modes = client_modes;
      }
    }
    return;
  case CEPH_ENTITY_TYPE_MON:
    // i am mon
    switch (peer_type) {
    case CEPH_ENTITY_TYPE_MON:
      // they are mon
      if (methods) {
	*methods = cluster_methods;
      }
      if (modes) {
	*modes = mon_cluster_modes;
      }
      break;
    default:
      // they are anything but mons
      if (methods) {
	*methods = service_methods;
      }
      if (modes) {
	*modes = mon_service_modes;
      }
    }
    return;
  default:
    // i am a non-mon daemon
    switch (peer_type) {
    case CEPH_ENTITY_TYPE_MON:
    case CEPH_ENTITY_TYPE_MGR:
    case CEPH_ENTITY_TYPE_MDS:
    case CEPH_ENTITY_TYPE_OSD:
      // they are another daemon
      if (methods) {
	*methods = cluster_methods;
      }
      if (modes) {
	*modes = cluster_modes;
      }
      break;
    default:
      // they are a client
      if (methods) {
	*methods = service_methods;
      }
      if (modes) {
	*modes = service_modes;
      }
      break;
    }
  }
}

bool AuthRegistry::is_supported_method(int peer_type, int method)
{
  std::vector<uint32_t> s;
  get_supported_methods(peer_type, &s);
  return std::find(s.begin(), s.end(), method) != s.end();
}

bool AuthRegistry::any_supported_methods(int peer_type)
{
  std::vector<uint32_t> s;
  get_supported_methods(peer_type, &s);
  return !s.empty();
}

void AuthRegistry::get_supported_modes(
  int peer_type,
  uint32_t auth_method,
  std::vector<uint32_t> *modes)
{
  std::vector<uint32_t> s;
  get_supported_methods(peer_type, nullptr, &s);
  if (auth_method == CEPH_AUTH_NONE) {
    // filter out all but crc for AUTH_NONE
    modes->clear();
    for (auto mode : s) {
      if (mode == CEPH_CON_MODE_CRC) {
	modes->push_back(mode);
      }
    }
  } else {
    *modes = s;
  }
}

uint32_t AuthRegistry::pick_mode(
  int peer_type,
  uint32_t auth_method,
  const std::vector<uint32_t>& preferred_modes)
{
  std::vector<uint32_t>  [MASK] ;
  get_supported_modes(peer_type, auth_method, & [MASK] );
  for (auto mode : preferred_modes) {
    if (std::find( [MASK] .begin(),  [MASK] .end(), mode)
	!=  [MASK] .end()) {
      return mode;
    }
  }
  ldout(cct,1) << ""failed to pick con mode from client's "" << preferred_modes
	       << "" and our "" <<  [MASK]  << dendl;
  return CEPH_CON_MODE_UNKNOWN;
}

AuthAuthorizeHandler *AuthRegistry::get_handler(int peer_type, int method)
{
  std::scoped_lock l{lock};
  ldout(cct,20) << __func__ << "" peer_type "" << peer_type << "" method "" << method
		<< "" cluster_methods "" << cluster_methods
		<< "" service_methods "" << service_methods
		<< "" client_methods "" << client_methods
		<< dendl;
  if (cct->get_module_type() == CEPH_ENTITY_TYPE_CLIENT) {
    return nullptr;
  }
  switch (peer_type) {
  case CEPH_ENTITY_TYPE_MON:
  case CEPH_ENTITY_TYPE_MGR:
  case CEPH_ENTITY_TYPE_MDS:
  case CEPH_ENTITY_TYPE_OSD:
    if (std::find(cluster_methods.begin(), cluster_methods.end(), method) ==
	cluster_methods.end()) {
      return nullptr;
    }
    break;
  default:
    if (std::find(service_methods.begin(), service_methods.end(), method) ==
	service_methods.end()) {
      return nullptr;
    }
    break;
  }

  auto iter = authorize_handlers.find(method);
  if (iter != authorize_handlers.end()) {
    return iter->second;
  }
  AuthAuthorizeHandler *ah = nullptr;
  switch (method) {
  case CEPH_AUTH_NONE:
    ah = new AuthNoneAuthorizeHandler();
    break;
  case CEPH_AUTH_CEPHX:
    ah = new CephxAuthorizeHandler();
    break;
#ifdef HAVE_GSSAPI
  case CEPH_AUTH_GSS:
    ah = new KrbAuthorizeHandler();
    break;
#endif
  }
  if (ah) {
    authorize_handlers[method] = ah;
  }
  return ah;
}

",allowed_modes
626,"#include <iostream>
#include ""stdlib.h""
#include ""SplStack.h""

using namespace std;

int main()
{
    SplStack<int> *p =  new SplStack<int>(4);  // int 类型的栈
    
    // 测试空栈
    p->traverse();

    // 测试入栈
    for (int i = 0; i < 10; i++)
    {
        cout << ""push: "" << i << endl;
        p->push(i);
    }
    p->traverse();

    cout << ""is full: "" << p->isFull() << endl;
    cout << ""stack length: "" << p->length() << endl;

    // 测试出栈
    int  [MASK]  = -1;
    for (int i = 0; i < 11; i++)
    {
        p->pop( [MASK] );
        cout << ""pop: "" <<  [MASK]  << endl;
    }
    p->traverse();


    // 测试清空栈
    for (int i = 0; i < 10; i++)
    {
        p->push(i);
    }
    p->clear();
    p->traverse();
    
    cout << ""is empty: "" << p->isEmpty() << endl;

    delete p;
    p = nullptr;
    cout << ""success"" << endl;
    return 0;

}

",elm
627,"#pragma once
//#include ""zrpc.h""
#include <string>
#include <msgpack.hpp>
#include <iostream>

namespace zrpc
{
    namespace detail
    {
        template<typename T>
        inline void pack(const T& value, std::string& buffer)
        {
            std::stringstream  [MASK] ;
            msgpack::pack( [MASK] , value);
             [MASK] .seekg(0);
             [MASK] .str().swap(buffer);
        }

        template<typename T>
        inline bool tryPack(const T& value, std::string& buffer)
        {
            try
            {
                pack(value, buffer);
                return true;
            }
            catch (const std::exception& e)
            {
                std::cout << e.what() << std::endl;
                return false;
            }
            return false;
        }

        template<typename T>
        inline std::string pack(const T& value)
        {
            std::string buffer;
            pack(value, buffer);
            return buffer;
        }

        //template<typename T>
        //inline void unpack(const std::string& buffer, T& value)
        //{
        //    msgpack::object_handle oh = msgpack::unpack(buffer.c_str(), buffer.size());
        //    msgpack::object obj = oh.get();
        //    obj.convert(value);
        //}

        //template<typename T>
        //inline bool tryUnpack(const std::string& buffer, T& value)
        //{
        //    try
        //    {
        //        unpack(buffer, value);
        //        return true;
        //    }
        //    catch (const std::exception& e)
        //    {
        //        std::cout << e.what() << std::endl;
        //        return false;
        //    }
        //}

        template<typename T>
        inline void unpack(const char* data, std::size_t len, T& value)
        {
            msgpack::object_handle oh = msgpack::unpack(data, len);
            msgpack::object obj = oh.get();
            obj.convert(value);
        }

        template<typename T>
        inline bool tryUnpack(const char* data, std::size_t len, T& value)
        {
            try
            {
                unpack(data, len, value);
                return true;
            }
            catch (const std::exception& e)
            {
                std::cout << e.what() << std::endl;
                return false;
            }
            return false;
        }

        template<typename T>
        inline T unpack(const char* data, std::size_t len)
        {
            T value;
            unpack(data, len, value);
            return value;
        }

        //template<typename T>
        //inline T unpack(const std::string& buffer)
        //{
        //    T value;
        //    unpack(buffer, value);
        //    return value;
        //}
    }
}
",sbuffer
628,"// TODO: Part 1b
#include ""Models/FSLogo.h""
#include ""shaderc/shaderc.h"" // needed for compiling shaders at runtime
#ifdef _WIN32 // must use MT platform DLL libraries on windows
	#pragma comment(lib, ""shaderc_combined.lib"") 
#endif

void PrintLabeledDebugString(const char* label, const char* toPrint)
{
	std::cout << label << toPrint << std::endl;
#if defined WIN32 //OutputDebugStringA is a windows-only function 
	OutputDebugStringA(label);
	OutputDebugStringA(toPrint);
#endif
}

class Renderer
{
	// TODO: Part 2b
	struct shaderVars
	{
		GW::MATH::GMATRIXF viewMatrix, perspectiveMatrix;
		GW::MATH::GVECTORF lightColour, lightDir;
		GW::MATH::GVECTORF ambientLight, camPos;
	};
	// TODO: Part 3a
	struct instanceData
	{
		GW::MATH::GMATRIXF worldMatrix;
		OBJ_ATTRIBUTES material;
	};

	// proxy handles
	GW::SYSTEM::GWindow win;
	GW::GRAPHICS::GVulkanSurface vlk;
	GW::CORE::GEventReceiver shutdown;
	
	// what we need at a minimum to draw a triangle
	VkDevice device = nullptr;
	VkPhysicalDevice physicalDevice = nullptr;
	VkRenderPass renderPass;
	VkBuffer vertexHandle = nullptr;
	VkDeviceMemory vertexData = nullptr;
	// TODO: Part 1g
	VkBuffer indexHandle = nullptr;
	VkDeviceMemory indexData = nullptr;
	// TODO: Part 2c
	VkShaderModule vertexShader = nullptr;
	VkShaderModule fragmentShader = nullptr;
	// pipeline settings for drawing (also required)
	VkPipeline pipeline = nullptr;
	VkPipelineLayout pipelineLayout = nullptr;
	// TODO: Part 2d
	std::vector<VkBuffer> uniformBufferHandle;
	std::vector<VkDeviceMemory> uniformBufferData;
	VkDescriptorSetLayout descriptorSetLayout = nullptr;
	VkDescriptorPool descriptorPool = nullptr;
	std::vector<VkDescriptorSet> descriptorSets = {};

	// TODO: Part 3d
	std::vector<VkBuffer> storageBufferHandle;
	std::vector<VkDeviceMemory> storageBufferData;

	unsigned int windowWidth, windowHeight;

	// TODO: Part 2a
	GW::MATH::GMatrix interfaceProxy;
	GW::MATH::GMATRIXF viewMatrix = GW::MATH::GIdentityMatrixF;
	GW::MATH::GMATRIXF leftHandedPerspectiveMatrix = GW::MATH::GIdentityMatrixF;
	GW::MATH::GVECTORF lightColour = { 0.9f, 0.9f, 1.0f, 1.0f };
	GW::MATH::GVECTORF lightDir = { -1.0f, -1.0f, 2.0f };
	GW::MATH::GVECTORF ambientLight = { 0.25f, 0.25f, 0.35f };

	// TODO: Part 2b // TODO: Part 4d
	shaderVars shader = {};
	
	// TODO: Part 3a
	std::vector<instanceData> instances;

	GW::MATH::GMATRIXF identityMatrix = GW::MATH::GIdentityMatrixF;
	GW::MATH::GMATRIXF yRotationMatrix;

	// TODO: Part 2b
	std::chrono::high_resolution_clock::time_point startTime;

public:

	Renderer(GW::SYSTEM::GWindow _win, GW::GRAPHICS::GVulkanSurface _vlk)
	{
		win = _win;
		vlk = _vlk;
		UpdateWindowDimensions();
		GetHandlesFromSurface();

		// TODO: Part 2a
		interfaceProxy.Create();
		startTime = std::chrono::high_resolution_clock::now();
		// TODO: Part 2b // TODO: Part 4d
		shader.lightColour = lightColour;
		shader.lightDir = lightDir;
		shader.ambientLight = ambientLight;

		// TODO: Part 2a
		initializeViewMatrix();
		initializePerspectiveMatrix();

		// TODO: part 3a

		for (int i = 0; i < FSLogo_meshcount; i++)
		{
			instanceData temp{};
			temp.worldMatrix = GW::MATH::GIdentityMatrixF;
			temp.material = FSLogo_materials[i].attrib;
			instances.push_back(temp);
		}

		createDescriptorLayout();
		InitializeGraphics();
		BindShutdownCallback();
	}

	void initializeViewMatrix()
	{
		GW::MATH::GVECTORF cameraPosition = { 0.75f, 0.25f, -1.5f };
		GW::MATH::GVECTORF targetPosition = { 0.15f, 0.75f, 0.0f };
		GW::MATH::GVECTORF upVector = { 0.0f, 1.0f, 0.0f };
		interfaceProxy.LookAtLHF(cameraPosition, targetPosition, upVector, viewMatrix);
		shader.viewMatrix = viewMatrix;
		shader.camPos = cameraPosition;
	}

	void initializePerspectiveMatrix()
	{
		float aspectRatio = 0.0f;
		vlk.GetAspectRatio(aspectRatio);
		interfaceProxy.ProjectionDirectXLHF(G_DEGREE_TO_RADIAN_F(65.0f), aspectRatio, 0.1, 100, leftHandedPerspectiveMatrix);
		shader.perspectiveMatrix = leftHandedPerspectiveMatrix;
	}

	void createDescriptorLayout()
	{
		VkDescriptorSetLayoutBinding uniformBinding = {};
		uniformBinding.binding = 0;
		uniformBinding.descriptorCount = 1;
		uniformBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
		uniformBinding.pImmutableSamplers = nullptr;
		uniformBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;

		VkDescriptorSetLayoutBinding storageBinding = {};
		storageBinding.binding = 1;
		storageBinding.descriptorCount = 1;
		storageBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
		storageBinding.pImmutableSamplers = nullptr;
		storageBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;

		std::array<VkDescriptorSetLayoutBinding, 2> bindings = { uniformBinding, storageBinding };

		VkDescriptorSetLayoutCreateInfo layoutInfo = {};
		layoutInfo.bindingCount = 2;
		layoutInfo.flags = 0;
		layoutInfo.pBindings = bindings.data();
		layoutInfo.pNext = nullptr;
		layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;

		vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout);
	}

private:
	void UpdateWindowDimensions()
	{
		win.GetClientWidth(windowWidth);
		win.GetClientHeight(windowHeight);
	}

	void InitializeGraphics()
	{
		InitializeVertexBuffer();
		// TODO: Part 1g
		InitializeIndexBuffer();
		// TODO: Part 2d // TODO: Part 3d
		initializeUniformBuffer();
		initializeStorageBuffer();
		initializeDescriptorPool();
		initializeDescriptorSets();
		linkDescriptorSetUniformBuffer();
		CompileShaders();
		InitializeGraphicsPipeline();
	}

	void GetHandlesFromSurface()
	{
		vlk.GetDevice((void**)&device);
		vlk.GetPhysicalDevice((void**)&physicalDevice);
		vlk.GetRenderPass((void**)&renderPass);
	}

	void InitializeVertexBuffer()
	{
		// TODO: Part 1c
		float verts[] = 
		{
			0,   0.5f,
			0.5f, -0.5f,
			-0.5f, -0.5f
		};

		CreateVertexBuffer(&FSLogo_vertices[0], sizeof(FSLogo_vertices));
	}

	void CreateVertexBuffer(const void* data, unsigned int sizeInBytes)
	{
		GvkHelper::create_buffer(physicalDevice, device, sizeInBytes,
			VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
			VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &vertexHandle, &vertexData);
		// Transfer triangle data to the vertex buffer. (staging would be prefered here)
		GvkHelper::write_to_buffer(device, vertexData, data, sizeInBytes);
	}

	void InitializeIndexBuffer() //part of 1g
	{
		GvkHelper::create_buffer(physicalDevice, device, sizeof(FSLogo_indices),
			VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
			VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &indexHandle, &indexData);
		GvkHelper::write_to_buffer(device, indexData, &FSLogo_indices[0], sizeof(FSLogo_indices));
	}

	//part 2d
	void initializeUniformBuffer()
	{
		unsigned int bufferSize = sizeof(shaderVars);  //size of the uniform data

		//gets the number of active frames
		uint32_t imageCount;
		vlk.GetSwapchainImageCount(imageCount);

		//resizes the vectors for the uniform buffers for each frame
		uniformBufferHandle.resize(imageCount);
		uniformBufferData.resize(imageCount);

		for (size_t i = 0; i < imageCount; i++) //loops through each active frame and creates a buffer for each
		{
			GvkHelper::create_buffer(physicalDevice, device, bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &uniformBufferHandle[i], &uniformBufferData[i]);
			GvkHelper::write_to_buffer(device, uniformBufferData[i], &shader, bufferSize);
		}
	}

	//part 3d
	void initializeStorageBuffer()
	{
		unsigned int bufferSize = sizeof(instanceData) * instances.size();  //size of the storage data

		//gets the number of active frames
		uint32_t imageCount;
		vlk.GetSwapchainImageCount(imageCount);

		//resizes the vectors for the uniform buffers for each frame
		storageBufferHandle.resize(imageCount);
		storageBufferData.resize(imageCount);

		for (size_t i = 0; i < imageCount; i++) //loops through each active frame and creates a buffer for each
		{
			GvkHelper::create_buffer(physicalDevice, device, bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &storageBufferHandle[i], &storageBufferData[i]);
			GvkHelper::write_to_buffer(device, storageBufferData[i], instances.data(), bufferSize);
		}
	}

	void initializeDescriptorPool()
	{
		VkDescriptorPoolSize  [MASK]  = {};
		 [MASK] .descriptorCount = uniformBufferHandle.size();
		 [MASK] .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;

		VkDescriptorPoolSize storagePoolSize = {};
		storagePoolSize.descriptorCount = storageBufferHandle.size();
		storagePoolSize.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;

		std::array<VkDescriptorPoolSize, 2> poolSizes = {  [MASK] , storagePoolSize };

		VkDescriptorPoolCreateInfo descriptorPoolInfo = {};
		descriptorPoolInfo.flags = 0;
		descriptorPoolInfo.maxSets = uniformBufferHandle.size();
		descriptorPoolInfo.pNext = nullptr;
		descriptorPoolInfo.poolSizeCount = 2;
		descriptorPoolInfo.pPoolSizes = poolSizes.data();
		descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;

		vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);
	}

	void initializeDescriptorSets()
	{
		VkDescriptorSetAllocateInfo descriptorAllocateInfo = {};
		descriptorAllocateInfo.descriptorPool = descriptorPool;
		descriptorAllocateInfo.descriptorSetCount = 1;
		descriptorAllocateInfo.pNext = nullptr;
		descriptorAllocateInfo.pSetLayouts = &descriptorSetLayout;
		descriptorAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;

		descriptorSets.resize(uniformBufferHandle.size());

		for (int i = 0; i < uniformBufferData.size(); i++)
		{
			vkAllocateDescriptorSets(device, &descriptorAllocateInfo, &descriptorSets[i]);
		}
	}

	void linkDescriptorSetUniformBuffer()
	{
		for (int i = 0; i < uniformBufferData.size(); i++)
		{
			VkDescriptorBufferInfo uniformDescriptorBuffer = {};
			uniformDescriptorBuffer.buffer = uniformBufferHandle[i];
			uniformDescriptorBuffer.offset = 0;
			uniformDescriptorBuffer.range = sizeof(shaderVars);

			VkDescriptorBufferInfo storageDescriptorBuffer = {};
			storageDescriptorBuffer.buffer = storageBufferHandle[i];
			storageDescriptorBuffer.offset = 0;
			storageDescriptorBuffer.range = sizeof(instanceData) * instances.size();

			VkWriteDescriptorSet writeUniformDescriptor = {};
			writeUniformDescriptor.descriptorCount = 1;
			writeUniformDescriptor.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
			writeUniformDescriptor.dstArrayElement = 0;
			writeUniformDescriptor.dstBinding = 0;
			writeUniformDescriptor.dstSet = descriptorSets[i];
			writeUniformDescriptor.pBufferInfo = &uniformDescriptorBuffer;
			writeUniformDescriptor.pImageInfo = nullptr;
			writeUniformDescriptor.pNext = nullptr;
			writeUniformDescriptor.pTexelBufferView = nullptr;
			writeUniformDescriptor.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;


			VkWriteDescriptorSet writeStorageDescriptor = {};
			writeStorageDescriptor.descriptorCount = 1;
			writeStorageDescriptor.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
			writeStorageDescriptor.dstArrayElement = 0;
			writeStorageDescriptor.dstBinding = 1;
			writeStorageDescriptor.dstSet = descriptorSets[i];
			writeStorageDescriptor.pBufferInfo = &storageDescriptorBuffer;
			writeStorageDescriptor.pImageInfo = nullptr;
			writeStorageDescriptor.pNext = nullptr;
			writeStorageDescriptor.pTexelBufferView = nullptr;
			writeStorageDescriptor.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;

			std::array<VkWriteDescriptorSet, 2> writeDescriptors = { writeUniformDescriptor, writeStorageDescriptor };

			vkUpdateDescriptorSets(device, 2, writeDescriptors.data(), 0, nullptr);
		}
	}

	void CompileShaders()
	{
		// Intialize runtime shader compiler HLSL -> SPIRV
		shaderc_compiler_t compiler = shaderc_compiler_initialize();
		shaderc_compile_options_t options = CreateCompileOptions();

		CompileVertexShader(compiler, options);
		CompilePixelShader(compiler, options);

		// Free runtime shader compiler resources
		shaderc_compile_options_release(options);
		shaderc_compiler_release(compiler);
	}

	shaderc_compile_options_t CreateCompileOptions()
	{
		shaderc_compile_options_t retval = shaderc_compile_options_initialize();
		shaderc_compile_options_set_source_language(retval, shaderc_source_language_hlsl);
		shaderc_compile_options_set_invert_y(retval, true); // TODO: Part 2g
#ifndef NDEBUG
		shaderc_compile_options_set_generate_debug_info(retval);
#endif
		return retval;	
	}

	void CompileVertexShader(const shaderc_compiler_t& compiler, const shaderc_compile_options_t& options)
	{
		std::string vertexShaderSource = ReadFileIntoString(""../VertexShader.hlsl"");

		shaderc_compilation_result_t result = shaderc_compile_into_spv( // compile
			compiler, vertexShaderSource.c_str(), vertexShaderSource.length(),
			shaderc_vertex_shader, ""main.vert"", ""main"", options);
		
		if (shaderc_result_get_compilation_status(result) != shaderc_compilation_status_success) // errors?
		{
			PrintLabeledDebugString(""Vertex Shader Errors:\n"", shaderc_result_get_error_message(result));
			abort();
			return;
		}
		
		GvkHelper::create_shader_module(device, shaderc_result_get_length(result), // load into Vulkan
			(char*)shaderc_result_get_bytes(result), &vertexShader);
		
		shaderc_result_release(result); // done
	}
	
	void CompilePixelShader(const shaderc_compiler_t& compiler, const shaderc_compile_options_t& options)
	{
		std::string fragmentShaderSource = ReadFileIntoString(""../FragmentShader.hlsl"");
		
		shaderc_compilation_result_t result;
		
		result = shaderc_compile_into_spv( // compile
			compiler, fragmentShaderSource.c_str(), fragmentShaderSource.length(),
			shaderc_fragment_shader, ""main.frag"", ""main"", options);

		if (shaderc_result_get_compilation_status(result) != shaderc_compilation_status_success) // errors?
		{
			PrintLabeledDebugString(""Fragment Shader Errors:\n"", shaderc_result_get_error_message(result));
			abort();
			return;
		}
		
		GvkHelper::create_shader_module(device, shaderc_result_get_length(result), // load into Vulkan
			(char*)shaderc_result_get_bytes(result), &fragmentShader);
		
		shaderc_result_release(result); // done
	}

	void InitializeGraphicsPipeline()
	{
		// Create Pipeline & Layout (Thanks Tiny!)
		VkPipelineShaderStageCreateInfo stage_create_info[2] = {};
		// Create Stage Info for Vertex Shader
		stage_create_info[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
		stage_create_info[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
		stage_create_info[0].module = vertexShader;
		stage_create_info[0].pName = ""main"";

		// Create Stage Info for Fragment Shader
		stage_create_info[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
		stage_create_info[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
		stage_create_info[1].module = fragmentShader;
		stage_create_info[1].pName = ""main"";

		VkPipelineInputAssemblyStateCreateInfo assembly_create_info = CreateVkPipelineInputAssemblyStateCreateInfo();
		VkVertexInputBindingDescription vertex_binding_description = CreateVkVertexInputBindingDescription();

		std::array<VkVertexInputAttributeDescription, 3> vertex_attribute_description;
		vertex_attribute_description[0].binding = 0;
		vertex_attribute_description[0].location = 0;
		vertex_attribute_description[0].format = VK_FORMAT_R32G32B32_SFLOAT;
		vertex_attribute_description[0].offset = 0;

		vertex_attribute_description[1].binding = 0;
		vertex_attribute_description[1].location = 1;
		vertex_attribute_description[1].format = VK_FORMAT_R32G32B32_SFLOAT;
		vertex_attribute_description[1].offset = sizeof(OBJ_VEC3);

		vertex_attribute_description[2].binding = 0;
		vertex_attribute_description[2].location = 2;
		vertex_attribute_description[2].format = VK_FORMAT_R32G32B32_SFLOAT;
		vertex_attribute_description[2].offset = sizeof(OBJ_VEC3) * 2;

		VkPipelineVertexInputStateCreateInfo input_vertex_info = CreateVkPipelineVertexInputStateCreateInfo(&vertex_binding_description, 1, vertex_attribute_description.data(), 3);
		VkViewport viewport = CreateViewportFromWindowDimensions();
		VkRect2D scissor = CreateScissorFromWindowDimensions(); 
		VkPipelineViewportStateCreateInfo viewport_create_info = CreateVkPipelineViewportStateCreateInfo(&viewport, 1, &scissor, 1);
		VkPipelineRasterizationStateCreateInfo rasterization_create_info = CreateVkPipelineRasterizationStateCreateInfo();
		VkPipelineMultisampleStateCreateInfo multisample_create_info = CreateVkPipelineMultisampleStateCreateInfo();
		VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info = CreateVkPipelineDepthStencilStateCreateInfo();
		VkPipelineColorBlendAttachmentState color_blend_attachment_state = CreateVkPipelineColorBlendAttachmentState();
		VkPipelineColorBlendStateCreateInfo color_blend_create_info = CreateVkPipelineColorBlendStateCreateInfo(&color_blend_attachment_state, 1);

		// Dynamic State 
		VkDynamicState dynamic_states[2] = 
		{
			// By setting these we do not need to re-create the pipeline on Resize
			VK_DYNAMIC_STATE_VIEWPORT, 
			VK_DYNAMIC_STATE_SCISSOR
		};
		VkPipelineDynamicStateCreateInfo dynamic_create_info = CreateVkPipelineDynamicStateCreateInfo(dynamic_states, 2);

		CreatePipelineLayout();

		// Pipeline State... (FINALLY) 
		VkGraphicsPipelineCreateInfo pipeline_create_info = {};
		pipeline_create_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
		pipeline_create_info.stageCount = 2;
		pipeline_create_info.pStages = stage_create_info;
		pipeline_create_info.pInputAssemblyState = &assembly_create_info;
		pipeline_create_info.pVertexInputState = &input_vertex_info;
		pipeline_create_info.pViewportState = &viewport_create_info;
		pipeline_create_info.pRasterizationState = &rasterization_create_info;
		pipeline_create_info.pMultisampleState = &multisample_create_info;
		pipeline_create_info.pDepthStencilState = &depth_stencil_create_info;
		pipeline_create_info.pColorBlendState = &color_blend_create_info;
		pipeline_create_info.pDynamicState = &dynamic_create_info;
		pipeline_create_info.layout = pipelineLayout;
		pipeline_create_info.renderPass = renderPass;
		pipeline_create_info.subpass = 0;
		pipeline_create_info.basePipelineHandle = VK_NULL_HANDLE;

		vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipeline_create_info, nullptr, &pipeline);
	}

	VkPipelineInputAssemblyStateCreateInfo CreateVkPipelineInputAssemblyStateCreateInfo()
	{
		VkPipelineInputAssemblyStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
		retval.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
		retval.primitiveRestartEnable = false;
		return retval;
	}

	VkVertexInputBindingDescription CreateVkVertexInputBindingDescription()
	{
		// TODO: Part 1e
		VkVertexInputBindingDescription retval = {};
		retval.binding = 0;
		retval.stride = sizeof(OBJ_VERT);
		retval.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
		return retval;
	}

	VkPipelineVertexInputStateCreateInfo CreateVkPipelineVertexInputStateCreateInfo(
		VkVertexInputBindingDescription* bindingDescriptions, uint32_t bindingCount,
		VkVertexInputAttributeDescription* attributeDescriptions, uint32_t attributeCount)
	{
		VkPipelineVertexInputStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
		retval.vertexBindingDescriptionCount = bindingCount;
		retval.pVertexBindingDescriptions = bindingDescriptions;
		retval.vertexAttributeDescriptionCount = attributeCount;
		retval.pVertexAttributeDescriptions = attributeDescriptions;
		return retval;
	}

	VkViewport CreateViewportFromWindowDimensions()
	{
		VkViewport retval = {};
		retval.x = 0;
		retval.y = 0;
		retval.width = static_cast<float>(windowWidth);
		retval.height = static_cast<float>(windowHeight);
		retval.minDepth = 0;
		retval.maxDepth = 1;
		return retval;
	}

	VkRect2D CreateScissorFromWindowDimensions()
	{
		VkRect2D retval = {};
		retval.offset.x = 0;
		retval.offset.y = 0;
		retval.extent.width = windowWidth;
		retval.extent.height = windowHeight;
		return retval;
	}

	VkPipelineViewportStateCreateInfo CreateVkPipelineViewportStateCreateInfo(VkViewport* viewports, uint32_t viewportCount, VkRect2D* scissors, uint32_t scissorCount)
	{
		VkPipelineViewportStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
		retval.viewportCount = viewportCount;
		retval.pViewports = viewports;
		retval.scissorCount = scissorCount;
		retval.pScissors = scissors;
		return retval;
	}

	VkPipelineRasterizationStateCreateInfo CreateVkPipelineRasterizationStateCreateInfo()
	{
		VkPipelineRasterizationStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
		retval.rasterizerDiscardEnable = VK_FALSE;
		retval.polygonMode = VK_POLYGON_MODE_FILL;
		retval.lineWidth = 1.0f;
		retval.cullMode = VK_CULL_MODE_BACK_BIT;
		retval.frontFace = VK_FRONT_FACE_CLOCKWISE;
		retval.depthClampEnable = VK_FALSE;
		retval.depthBiasEnable = VK_FALSE;
		retval.depthBiasClamp = 0.0f;
		retval.depthBiasConstantFactor = 0.0f;
		retval.depthBiasSlopeFactor = 0.0f;
		return retval;
	}

	VkPipelineMultisampleStateCreateInfo CreateVkPipelineMultisampleStateCreateInfo()
	{
		VkPipelineMultisampleStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
		retval.sampleShadingEnable = VK_FALSE;
		retval.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
		retval.minSampleShading = 1.0f;
		retval.pSampleMask = VK_NULL_HANDLE;
		retval.alphaToCoverageEnable = VK_FALSE;
		retval.alphaToOneEnable = VK_FALSE;
		return retval;
	}

	VkPipelineDepthStencilStateCreateInfo CreateVkPipelineDepthStencilStateCreateInfo()
	{
		VkPipelineDepthStencilStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
		retval.depthTestEnable = VK_TRUE;
		retval.depthWriteEnable = VK_TRUE;
		retval.depthCompareOp = VK_COMPARE_OP_LESS;
		retval.depthBoundsTestEnable = VK_FALSE;
		retval.minDepthBounds = 0.0f;
		retval.maxDepthBounds = 1.0f;
		retval.stencilTestEnable = VK_FALSE;
		return retval;
	}

	VkPipelineColorBlendAttachmentState CreateVkPipelineColorBlendAttachmentState()
	{
		VkPipelineColorBlendAttachmentState retval = {};
		retval.colorWriteMask = 0xF;
		retval.blendEnable = VK_FALSE;
		retval.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_COLOR;
		retval.dstColorBlendFactor = VK_BLEND_FACTOR_DST_COLOR;
		retval.colorBlendOp = VK_BLEND_OP_ADD;
		retval.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
		retval.dstAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;
		retval.alphaBlendOp = VK_BLEND_OP_ADD;
		return retval;
	}

	VkPipelineColorBlendStateCreateInfo CreateVkPipelineColorBlendStateCreateInfo(VkPipelineColorBlendAttachmentState* attachmentStates, uint32_t attachmentCount)
	{
		VkPipelineColorBlendStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
		retval.logicOpEnable = VK_FALSE;
		retval.logicOp = VK_LOGIC_OP_COPY;
		retval.attachmentCount = attachmentCount;
		retval.pAttachments = attachmentStates;
		retval.blendConstants[0] = 0.0f;
		retval.blendConstants[1] = 0.0f;
		retval.blendConstants[2] = 0.0f;
		retval.blendConstants[3] = 0.0f;
		return retval;
	}

	VkPipelineDynamicStateCreateInfo CreateVkPipelineDynamicStateCreateInfo(VkDynamicState* dynamicStates, uint32_t dynamicStateCount)
	{
		VkPipelineDynamicStateCreateInfo retval = {};
		retval.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
		retval.dynamicStateCount = dynamicStateCount;
		retval.pDynamicStates = dynamicStates;
		return retval;
	}

	void CreatePipelineLayout()
	{
		// Descriptor pipeline layout
		// TODO: Part 2d // TODO: Part 3d
		VkPipelineLayoutCreateInfo pipeline_layout_create_info = {};
		pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
		pipeline_layout_create_info.setLayoutCount = 1;
		pipeline_layout_create_info.pSetLayouts = &descriptorSetLayout;
		pipeline_layout_create_info.pushConstantRangeCount = 0;
		pipeline_layout_create_info.pPushConstantRanges = nullptr;

		vkCreatePipelineLayout(device, &pipeline_layout_create_info,nullptr, &pipelineLayout);
	}

	void BindShutdownCallback()
	{
		// GVulkanSurface will inform us when to release any allocated resources
		shutdown.Create(vlk, [&]() {
			if (+shutdown.Find(GW::GRAPHICS::GVulkanSurface::Events::RELEASE_RESOURCES, true)) {
				CleanUp(); // unlike D3D we must be careful about destroy timing
			}
			});
	}


public:
	void Render()
	{
		uint32_t activeImage;
		vlk.GetSwapchainCurrentImage(activeImage);

		// TODO: Part 3i
		std::chrono::high_resolution_clock::time_point currentTime = std::chrono::high_resolution_clock::now();
		float elapsedTime = std::chrono::duration<float>(currentTime - startTime).count();
		float rotationSpeed = -1.0f; // Rotation speed in radians per second
		float radians = elapsedTime * rotationSpeed;
		interfaceProxy.RotateYLocalF(identityMatrix, radians, yRotationMatrix);
		instances[1].worldMatrix = yRotationMatrix;

		VkCommandBuffer commandBuffer = GetCurrentCommandBuffer();
		SetUpPipeline(commandBuffer);
		// TODO: Part 3i
		GvkHelper::write_to_buffer(device, storageBufferData[activeImage], instances.data(), sizeof(instanceData) * instances.size());

		vkCmdBindIndexBuffer(commandBuffer, indexHandle, 0, VK_INDEX_TYPE_UINT32);

		// TODO: Part 2e
		vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[activeImage], 0, 0);

		// TODO: Part 1h
		//vkCmdDrawIndexed(commandBuffer, FSLogo_indexcount, 1, 0, 0, 0);
		// TODO: Part 3f
		for (int i = 0; i < FSLogo_meshcount; i++)
		{
			vkCmdDrawIndexed(commandBuffer, FSLogo_meshes[i].indexCount, 1, FSLogo_meshes[i].indexOffset, 0, FSLogo_meshes[i].materialIndex);
		}
		//vkCmdDraw(commandBuffer, FSLogo_vertexcount, 1, 0, 0); // TODO: Part 1d
	}

private:

	VkCommandBuffer GetCurrentCommandBuffer()
	{
		VkCommandBuffer retval;
		unsigned int currentBuffer;
		vlk.GetSwapchainCurrentImage(currentBuffer);
		vlk.GetCommandBuffer(currentBuffer, (void**)&retval);
		return retval;
	}

	void SetUpPipeline(VkCommandBuffer& commandBuffer)
	{
		UpdateWindowDimensions(); // what is the current client area dimensions?
		SetViewport(commandBuffer);
		SetScissor(commandBuffer);
		vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
		BindVertexBuffers(commandBuffer);
	}

	void SetViewport(const VkCommandBuffer& commandBuffer)
	{
		VkViewport viewport = CreateViewportFromWindowDimensions();
		vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
	}

	void SetScissor(const VkCommandBuffer& commandBuffer)
	{
		VkRect2D scissor = CreateScissorFromWindowDimensions();
		vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
	}

	void BindVertexBuffers(VkCommandBuffer& commandBuffer)
	{
		VkDeviceSize offsets[] = { 0 };
		vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vertexHandle, offsets);
	}


	void CleanUp()
	{
		// wait till everything has completed
		vkDeviceWaitIdle(device);
		// Release allocated buffers, shaders & pipeline
		// TODO: Part 1g
		vkDestroyBuffer(device, indexHandle, nullptr);
		vkFreeMemory(device, indexData, nullptr);

		// TODO: Part 2d
		for (int i = 0; i < uniformBufferHandle.size(); i++)
		{
			vkDestroyBuffer(device, uniformBufferHandle[i], nullptr);

			vkFreeMemory(device, uniformBufferData[i], nullptr);
		}
		uniformBufferHandle.clear();
		uniformBufferData.clear();

		vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
		vkDestroyDescriptorPool(device, descriptorPool, nullptr);

		// TODO: Part 3d
		for (int i = 0; i < storageBufferHandle.size(); i++) 
		{
			vkDestroyBuffer(device, storageBufferHandle[i], nullptr);
			vkFreeMemory(device, storageBufferData[i], nullptr);
		}
		storageBufferHandle.clear();
		storageBufferData.clear();

		vkDestroyBuffer(device, vertexHandle, nullptr);
		vkFreeMemory(device, vertexData, nullptr);
		vkDestroyShaderModule(device, vertexShader, nullptr);
		vkDestroyShaderModule(device, fragmentShader, nullptr);
		vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
		vkDestroyPipeline(device, pipeline, nullptr);
	}
};
",uniformPoolSize
629,"// /*************************************************************
//  * ДЗ-2 Примитивная рекурсия (Вариант 2.10)
//  * Студент: <NAME>, КТбо1-7
//  * Программа: Реализует вычисление функции f(x1, x2),
//  * полученной из базовых функций:
//  *   g(x) = x
//  *   h(x, y, z) = x + y
//  * по схеме примитивной рекурсии:
//  *   1) f(0, x2) = x2
//  *   2) f(x1 + 1, x2) = x1 + f(x1, x2)
//  * Аналитическая формула (для x1 ≥ 0):
//  *   f(x1, x2) = x2 + (x1 * (x1 - 1)) / 2
//  *************************************************************/

#include <iostream>
#include <clocale>
#include <windows.h>
#include <string>
#include <limits>

using namespace std;

// Структура для хранения результата рекурсивной функции
struct RecurResult {
    int value;       // Вычисленное значение функции
    wstring trace;   // Пошаговое описание вычислений
};

// Примитивно-рекурсивная реализация функции F(n, x)
// Ввод: шаг рекурсии и параметр
// Вывод: занчение примитивно-рекурсивной функции
RecurResult recurFunc(int x1, int x2);

int main() {
    SetConsoleOutputCP(1251);
    SetConsoleCP(1251);
    setlocale(LC_ALL, ""Russian"");
    wcout << L""Схема рекурсии:\n1) f(0, x2) = x2\n2) f(x1 + 1, x2) = x1 + f(x1, x2)\n""
          << L""Аналитическая формула: f(x1, x2) = x2 + (x1 * (x1 - 1)) / 2\n\n"";

    bool programRunning = true;
    while (programRunning) {
        int x1, x2;
        bool inputValid = true;
        wcout << L""Введите x1: "";
        if (!(cin >> x1)) {
            wcout << L""Ошибка: введите целое число."" << endl;
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
            inputValid = false;
        }
        if (inputValid) {
            wcout << L""Введите x2: "";
            if (!(cin >> x2)) {
                wcout << L""Ошибка: введите целое число."" << endl;
                cin.clear();
                cin.ignore(numeric_limits<streamsize>::max(), '\n');
                inputValid = false;
            }
        }
        bool flag = inputValid;
        if (inputValid && x1 < 0) {
            wcout << L""Ошибка: x1 должен быть неотрицательным."" << endl;
            flag = false;
        }
        if (!flag) {
            bool validChoice = false;
            int choice = 0;
            while (!validChoice) {
                wcout << L""Повторить ввод? (1 - да, 2 - нет): "";
                if (cin >> choice && (choice == 1 || choice == 2))
                    validChoice = true;
                else {
                    wcout << L""Ошибка: введите 1 или 2."" << endl;
                    cin.clear();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                }
            }
            programRunning = (choice == 1);
        }
        if (flag) {
            RecurResult recursionResult = recurFunc(x1, x2);
            wcout << L""--- Пошаговое вычисление ---\n"" << recursionResult.trace << endl;
            int analiticResult = x2 + (x1 * (x1 - 1)) / 2;
            wcout << L""--- Сравнение с аналитической формулой ---\n""
                  << L""f("" << x1 << L"","" << x2 << L"") по рекурсии = "" << recursionResult.value << endl
                  << L""f("" << x1 << L"","" << x2 << L"") по аналитической формуле = "" << analiticResult << endl
                  << (recursionResult.value == analiticResult ? L""Результаты совпадают!\n"" : L""Результаты НЕ совпадают!\n"");
            bool validChoice = false;
            int choice = 0;
            while (!validChoice) {
                wcout << L""Повторить ввод? (1 - да, 2 - нет): "";
                if (cin >> choice && (choice == 1 || choice == 2))
                    validChoice = true;
                else {
                    wcout << L""Ошибка: введите 1 или 2."" << endl;
                    cin.clear();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                }
            }
            programRunning = (choice == 1);
        }
    }
    wcout << L""Программа завершена."" << endl;
    return 0;
}

RecurResult recurFunc(int x1, int x2) {
    if (x1 == 0) {
        RecurResult result;
        result.value = x2;
        result.trace = L""f(0,"" + to_wstring(x2) + L"") = "" + to_wstring(x2) + L""\n"";
        return result;
    }
    RecurResult  [MASK]  = recurFunc(x1 - 1, x2);
    RecurResult current;
    current.value = x1 - 1 +  [MASK] .value;
    current.trace =  [MASK] .trace + L""f("" + to_wstring(x1) + L"","" + to_wstring(x2) 
        + L"") = h("" + to_wstring(x1 - 1) + L"", f("" + to_wstring(x1 - 1) + L"","" 
        + to_wstring(x2) + L""), "" + to_wstring(x2) + L"") = h("" + to_wstring(x1 - 1) 
        + L"","" + to_wstring( [MASK] .value) + L"","" + to_wstring(x2) + L"") = "" 
        + to_wstring(current.value) + L""\n"";

    return current;
}",prev
630,"/*
 * Copyright © 2023 Sietium Semiconductor.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the ""Software""),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include ""common/configs.h""
#include ""common/debug.hpp""

#include ""vram/vram.hpp""
#include ""mmu/mmu.hpp""
#include ""noc/network_on_chip.hpp""
#include ""command_processor.hpp""

command_processor::command_processor(vram *rvgpu_vram, mmu *rvgpu_mmu, noc* connector) {
    m_vram = rvgpu_vram;
    m_mmu = rvgpu_mmu;
    m_noc = connector;
}

command_processor::~command_processor() {
}

void command_processor::run(uint64_t cmds) {
    rvgpu_command cmd;
    cmd.dim.x = m_vram->read<uint32_t>(m_mmu->find_pa(cmds + 0));
    cmd.dim.y = m_vram->read<uint32_t>(m_mmu->find_pa(cmds + 4));
    cmd.dim.z = m_vram->read<uint32_t>(m_mmu->find_pa(cmds + 8));
    cmd.program.pointer         = m_vram->read<uint32_t>(m_mmu->find_pa(cmds + 16));
    cmd.program.stack_pointer   = m_vram->read<uint32_t>(m_mmu->find_pa(cmds + 24));
    cmd.program.argsize         = m_vram->read<uint32_t>(m_mmu->find_pa(cmds + 32));    
    for (uint32_t i=0; i<cmd.program.argsize; i++) {
        cmd.program.args[i]     = m_vram->read<uint32_t>(m_mmu->find_pa(cmds + 40 + i*8));
    }

    for (uint32_t sz=0; sz<cmd.dim.z; sz+=1) {
        // Split Z
        for (uint32_t sy=0; sy<cmd.dim.y; sy+=1) {
            // Split Y
            command_split_1d(cmd.dim.x, cmd.program);
        }
    }
}

void command_processor::command_split_1d(uint32_t splitx, program_t prog) {
    m_noc->write_message_size((splitx - 1) / 16 + 1);

    uint32_t tcount = splitx;
    uint32_t start = 0;
    uint32_t  [MASK]  = 0;

    while (tcount > 0) {
        message msg = {};

        msg.target =  [MASK] ;
        msg.shader = prog;
        msg.shader.stack_pointer +=  [MASK]  * SM_STACK_SIZE;
        msg.start = start;
        if (tcount > 16) {
            msg.count = 16;
        } else {
            msg.count = tcount;
        }

        m_noc->write_message( [MASK] , msg);

        start += 16;
        tcount = tcount - msg.count;
         [MASK]  = ( [MASK]  + 1) % SM_NUM;
    }
}

bool command_processor::finished() {
    return m_noc->message_size_is_zero();
}
",sm_id
631,"#include ""model/Bishop.h""
#include ""model/Square.h""
#include ""model/Board.h""
Bishop::Bishop(Piece::figure type, bool color) : Piece(type, color) {}

Bishop::~Bishop() {

}

bool Bishop::canMoveTo(SquarePtr startSquare, SquarePtr endSquare, Board &gameboard) {
    int startRow=(startSquare->getNr()/8+1);
    int startColumn=startSquare->getNr()-(startRow-1)*8+1;
    int endRow=endSquare->getNr()/8+1;
    int  [MASK] =endSquare->getNr()-(endRow-1)*8+1;
    if ((endRow >= 5) && (startRow < 4))return false;
    if ((endRow > 5) && (startRow == 4))return false;
    if ((endRow > 6) && (startRow == 5))return false;
    if ((endRow < 4) && (startRow == 5))return false;
    if ((endRow < 3) && (startRow == 4))return false;
    if ((endRow < 3) && (startRow > 3))return false;
    if (( [MASK]  - startColumn == endRow - startRow) || ( [MASK]  - startColumn == startRow - endRow)) {
        int rowOffset = (endRow - startRow > 0) ? 1 : -1;
        int colOffset = ( [MASK]  - startColumn > 0) ? 1 : -1;
        int checkRow;
        int checkColumn;
        for (checkRow = startRow + rowOffset, checkColumn = startColumn + colOffset;
             checkRow !=  endRow;
             checkRow = checkRow + rowOffset, checkColumn = checkColumn + colOffset)
        {
            if (gameboard.getSquare((checkRow-1)*8+checkColumn-1)->getPiece()!= nullptr) {
                return false;
            }
        }
        return true;
    }
    return false;
}


",endColumn
632,"#include ""gamescreen.h""

#include <QGuiApplication>
#include <QScreen>

extern byte* screen;

GameScreen::GameScreen() {
}

void GameScreen::draw(QPainter* painter) {
	for (int i = 0; i < pixel_width; ++i) {
		for (int j = 0; j < pixel_height; ++j) {
			auto color = colors[screen[i * pixel_height + j]];
			// NOTE: user bit offset 2 for brightness
			buffer[i][j] = 0xFF000000 | (color.r << 18) | (color.g << 10) | (color.b << 2);
		}
	}
	QByteArray data = QByteArray::fromRawData(reinterpret_cast<const char*>(buffer), pixel_width * pixel_height);
	QImage image(reinterpret_cast<const uchar*>(data.constData()), pixel_width, pixel_height, QImage::Format_RGB32);
	QBrush brush(QColor(0, 0, 0));

	auto screen = screenRect();

	QRectF imageRect = QRectF(screen.x(), screen.y(), image_width, image_height);
	QRectF backgroundRect = QRectF(0, 0, screen.width(), screen.height());

	painter->fillRect(backgroundRect, brush);
	painter->drawImage(imageRect, image);
	painter->save();
	painter->restore();
}

QSize GameScreen::resize(int orientation) {
	QSize screenSize;

	if (orientation == 1) {
		image_width = QGuiApplication::primaryScreen()->size().width();
		image_height = image_width / screen_ratio;
		screenSize = {
			QGuiApplication::primaryScreen()->size().width(), QGuiApplication::primaryScreen()->size().height()};
	} else {
		image_height = QGuiApplication::primaryScreen()->size().width();
		image_width = image_height * screen_ratio;
		screenSize = {
			QGuiApplication::primaryScreen()->size().height(), QGuiApplication::primaryScreen()->size().width()};
	}

	return screenSize;
}

QRect GameScreen::activeScreen() const {
	auto screen = screenRect();
	return QRect(screen.x(), screen.y(), image_width, image_height);
}

QRect GameScreen::screenRect() const {
	auto  [MASK] {0};
	auto screenHeight{0};
	auto heightOffset{0};
	auto widthOffset{0};

	if (image_width == QGuiApplication::primaryScreen()->size().width()) {
		 [MASK]  = QGuiApplication::primaryScreen()->size().width();
		screenHeight = QGuiApplication::primaryScreen()->size().height();
		heightOffset = (screenHeight - image_height) / 2;
	} else {
		 [MASK]  = QGuiApplication::primaryScreen()->size().height();
		screenHeight = QGuiApplication::primaryScreen()->size().width();
		widthOffset = ( [MASK]  - image_width) / 2;
	}

	return QRect(widthOffset, heightOffset,  [MASK] , screenHeight);
}
",screenWidth
633,"
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2024, Advanced Micro Devices, Inc. All rights reserved.

#include <ck_tile/core.hpp>
#include ""layernorm2d_fwd.hpp""
#include <iostream>

#pragma once

using S = ck_tile::stream_config;
using A = layernorm2d_fwd_args;

template <typename DataType_,
          ck_tile::index_t Repeat_M_,         // each thread repeat along M
          ck_tile::index_t Repeat_N_,         // each thread repeat along N
          ck_tile::index_t ThreadPerBlock_M_, // num threads along M
          ck_tile::index_t ThreadPerBlock_N_, // num threads along N
          ck_tile::index_t Vector_N_,         // vector size along N
          bool kPadN_,
          bool kSaveMeanInvStd_,
          bool kTwoPass_>
using trait_ = layernorm2d_fwd_traits_<DataType_,
                                       Repeat_M_,
                                       Repeat_N_,
                                       ThreadPerBlock_M_,
                                       ThreadPerBlock_N_,
                                       Vector_N_,
                                       kPadN_,
                                       kSaveMeanInvStd_,
                                       kTwoPass_>;

template <typename Traits_>
float layernorm2d_fwd_(const S& s, A a)
{
    using DataType = typename Traits_::DataType;

    using PipelineProblem = ck_tile::Layernorm2dFwdPipelineProblem<
        typename LayerNormTypeConfig<DataType>::XDataType,
        typename LayerNormTypeConfig<DataType>::GammaDataType,
        typename LayerNormTypeConfig<DataType>::BetaDataType,
        typename LayerNormTypeConfig<DataType>::ComputeDataType,
        typename LayerNormTypeConfig<DataType>::YDataType,
        typename LayerNormTypeConfig<DataType>::MeanDataType,
        typename LayerNormTypeConfig<DataType>::InvStdDataType,
        typename Traits_::Shape,
        Traits_::kPadN,
        Traits_::kSaveMeanInvStd,
        Traits_::kTwoPass>;

    using OnePassPipeline = ck_tile::Layernorm2dFwdPipelineOnePass<PipelineProblem>;
    using TwoPassPipeline = ck_tile::Layernorm2dFwdPipelineTwoPass<PipelineProblem>;
    using Pipeline        = std::conditional_t<Traits_::kTwoPass, TwoPassPipeline, OnePassPipeline>;

    using Kernel = ck_tile::Layernorm2dFwd<Pipeline>;

    const dim3  [MASK]                        = Kernel::GridSize(a);
    constexpr dim3 blocks                  = Kernel::BlockSize();
    constexpr ck_tile::index_t kBlockPerCu = 1;

    auto kargs = Kernel::MakeKargs(a);
    if(s.log_level_ > 0)
        std::cout << "", "" << Kernel::GetName() << std::flush;

    return ck_tile::launch_kernel(
        s, ck_tile::make_kernel<blocks.x, kBlockPerCu>(Kernel{},  [MASK] , blocks, 0, kargs));
}
",grids
634,"/* Copyright (c) 2018 vesoft inc. All rights reserved.
 *
 * This source code is licensed under Apache 2.0 License,
 * attached with Common Clause Condition 1.0, found in the LICENSES directory.
 */

#pragma once

#include <s2/s2loop.h>
#include <s2/s2polygon.h>

#include ""common/base/StatusOr.h""
#include ""common/datatypes/Geography.h""

namespace nebula {
namespace geo {

class GeoUtils final {
 public:
  static std::unique_ptr<S2Region> s2RegionFromGeography(Geography geog) {
    switch (geog.shape()) {
      case GeoShape::POINT: {
        const auto& point = geog.point();
        auto s2Point = s2PointFromCoordinate(point.coord);
        return std::make_unique<S2PointRegion>(s2Point);
      }
      case GeoShape::LINESTRING: {
        const auto& lineString = geog.lineString();
        auto coordList = lineString.coordList;
        auto s2Points = s2PointsFromCoordinateList(coordList);
        auto s2Polyline = std::make_unique<S2Polyline>(s2Points, S2Debug::DISABLE);
        return s2Polyline;
      }
      case GeoShape::POLYGON: {
        const auto& polygon = geog.polygon();
        uint32_t numCoordList = polygon.numCoordList();
        std::vector<std::unique_ptr<S2Loop>> s2Loops;
        s2Loops.reserve(numCoordList);
        for (size_t i = 0; i < numCoordList; ++i) {
          auto coordList = polygon.coordListList[i];
          if (!coordList.empty()) {
            coordList.pop_back();  // Remove redundant last coordinate
          }
          auto s2Points = s2PointsFromCoordinateList(coordList);
          auto s2Loop = std::make_unique<S2Loop>(std::move(s2Points), S2Debug::DISABLE);
          s2Loop->Normalize();  // All loops must be oriented CCW(counterclockwise) for S2
          s2Loops.emplace_back(std::move(s2Loop));
        }
        auto s2Polygon = std::make_unique<S2Polygon>(std::move(s2Loops), S2Debug::DISABLE);
        return s2Polygon;
      }
      default:
        LOG(FATAL)
            << ""Geography shapes other than Point/LineString/Polygon are not currently supported"";
        return nullptr;
    }
  }

  static S2Point s2PointFromCoordinate(const Coordinate& coord) {
    auto  [MASK]  = S2LatLng::FromDegrees(
        coord.y, coord.x);  // Note: S2Point requires latitude to be first, and longitude to be last
    return  [MASK] .ToPoint();
  }

  static std::vector<S2Point> s2PointsFromCoordinateList(const std::vector<Coordinate>& coordList) {
    std::vector<S2Point> s2Points;
    uint32_t numCoords = coordList.size();
    s2Points.reserve(numCoords);
    for (size_t i = 0; i < numCoords; ++i) {
      auto coord = coordList[i];
      auto s2Point = s2PointFromCoordinate(coord);
      s2Points.emplace_back(s2Point);
    }

    return s2Points;
  }

  static void removeAdjacentDuplicateCoordinates(std::vector<Coordinate>& coordList) {
    if (coordList.size() < 2) {
      return;
    }

    auto last = std::unique(coordList.begin(), coordList.end());
    coordList.erase(last, coordList.end());
  }
};

}  // namespace geo
}  // namespace nebula
",latlng
635,"#include ""StartStopTimer.hpp""

void StartStopTimer::init(Callback cb, uint32_t stackDepth, UBaseType_t tskPriority)
{
    TaskParams *p = &_tskParams;
    _tskPriority = tskPriority;
    _stackDepth = stackDepth;
    _tskParams.callback = cb;

    BaseType_t res = xTaskCreate
    (
        _taskFunction,          // Function to be called by the task
        ""Task"",                 // Name of the task (for debugging)
        stackDepth,             // Stack size (bytes)
        static_cast<void *>(&_tskParams),  // Parameter to be passed to the taskFunction
        tskPriority,            // Task priority
        &_tskParams.tskHandle   // Task handle (used to delete/suspend/resume task)
    );
    if (res != pdPASS)
    {
        log_e(""!!! task not created, initialization stopped !!!"");
        while (true) { delay(10); }
    }

    //log_i(""task creation result = %d stack: %d, priority: %d\n"", res, _stackDepth, _tskPriority);
    
    vTaskSuspend(_tskParams.tskHandle);

    //log_i(""start: %ld, stop: %ld, interval: %ld\n"", p->tStart, p->tStop, p->tInterval);
    log_i(""==> done %p"", _tskParams.tskHandle);
}

/**
 * Convenience function to convert the date time strings
 * into the needed timestamps and the task interval into
 * seconds. The cycle period ist set to one day (86400 sec)
 * and the number of cycles (days) to be performed is computed.
 * Example:
 *      startDateTime  (CEST): ""2023-06-13 22:40"" --> 1686688800
 *      stopDateTime   (CEST): ""2023-06-14 06:15"" --> 1686716100
 *      taskInterval:          ""00:05""            --> 300
*/
void StartStopTimer::setCycleStartStop(const char startDateTime[], const char stopDateTime[], const char taskInterval[]) 
{
    char buf[20];
    tm td = {0};
    int tskHH;
    int tskMM;
    
    sscanf(taskInterval, ""%d:%d"", &tskHH, &tskMM);
    _tskParams.tInterval = 60 * (60 * tskHH + tskMM);
    
    sscanf(startDateTime, ""%d-%d-%d %d:%d"", &td.tm_year, &td.tm_mon, &td.tm_mday, &td.tm_hour, &td.tm_min);
    td.tm_year -= 1900;
    td.tm_mon -= 1;
    td.tm_isdst = -1;
    _tskParams.tStart = mktime(&td);
    strftime(buf, sizeof(buf), ""%F %H:%M"", &td);
    log_i(""%s"", buf);

    sscanf(stopDateTime, ""%d-%d-%d %d:%d"", &td.tm_year, &td.tm_mon, &td.tm_mday, &td.tm_hour, &td.tm_min);
    td.tm_year -= 1900;
    td.tm_mon -= 1;
    td.tm_isdst = -1;
    _tskParams.tStop = mktime(&td);
    strftime(buf, sizeof(buf), ""%F %H:%M"", &td);
    log_i(""%s"", buf);

    _tskParams.tCyclePeriod = 86400;
    _tskParams.nbrOfCycles = 1 + (_tskParams.tStop - _tskParams.tStart) / _tskParams.tCyclePeriod;
    log_i(""start: %d, stop: %d, diff: %d"", _tskParams.tStart, _tskParams.tStop, _tskParams.tStop - _tskParams.tStart);
    log_i(""taskInterval: %d"", _tskParams.tInterval);
    log_i(""nbrOfCycles: %d"", _tskParams.nbrOfCycles); 
};

void StartStopTimer::setCycleStart(time_t tsecStart)  { _tskParams.tStart = tsecStart; }

void StartStopTimer::setCycleStop(time_t  [MASK] )    { _tskParams.tStop =  [MASK] ; }

void StartStopTimer::setTaskInterval(time_t tsecInterval)  { _tskParams.tInterval = tsecInterval; }

void StartStopTimer::setCyclePeriod(time_t tsecPeriod)      { _tskParams.tCyclePeriod = tsecPeriod; }

void StartStopTimer::setNbrOfCycles(uint32_t nbrOfCycles)   { _tskParams.nbrOfCycles = nbrOfCycles; }

void StartStopTimer::setIntervalMultiplier(uint32_t factor) { _tskParams.intervalMultiplier = factor; }

void StartStopTimer::resume()  { vTaskResume(_tskParams.tskHandle); }

void StartStopTimer::suspend() { vTaskSuspend(_tskParams.tskHandle); }

void StartStopTimer::deleteTask() { vTaskDelete(_tskParams.tskHandle); _tskParams.tskHandle = nullptr; }

TaskHandle_t StartStopTimer::getTaskHandle() { return _tskParams.tskHandle; }

void StartStopTimer::_taskFunction(void *params)
{
    TaskParams *p = static_cast<TaskParams *>(params);
    
    //log_i(""nbrOfCycles=%d"", p->nbrOfCycles);

    for (uint32_t n = 0; n < p->nbrOfCycles; n++)
    {
        //log_i(""cycle: %d"", n);
        // Wait until start time of 1st cycle is reached
        while (p->tStart > time(nullptr)) { vTaskDelay(pdMS_TO_TICKS(10)); } 
        p->tStart = time(nullptr);  // remember start time of cycle

        // Do task until stop time is reached
        while (time(nullptr) < p->tStop)
        {
            p->callback(); // call the function supplied by the user
            //log_i(""wait interval: %d * %d"", p->intervalMultiplier, p->tInterval);
            vTaskDelay(pdMS_TO_TICKS(p->intervalMultiplier * p->tInterval));
        }
        p->tStart += p->tCyclePeriod;
        p->tStop  += p->tCyclePeriod;        
    }

    vTaskDelete(p->tskHandle); p->tskHandle = nullptr; // delete task
    //vTaskSuspend(p->tskHandle); // suspend the task until resume is called by the user
};


",tsecStop
636,"// Fill out your copyright notice in the Description page of Project Settings.


#include ""VoxelActor.h""

const int32 bTriangles[] = { 2, 1, 0, 0, 3, 2 };
const FVector2D bUVs[] = {FVector2D(0.0, 0.0), FVector2D(0.0, 1.0), FVector2D(1.0, 1.0), FVector2D(1.0, 0.0)};
const FVector bNormals0[] = {FVector(0, 0, 1), FVector(0, 0, 1), FVector(0, 0, 1), FVector(0, 0, 1)};
const FVector bNormals1[] = { FVector(0, 0, -1), FVector(0, 0, -1), FVector(0, 0, -1), FVector(0, 0, -1) };
const FVector bNormals2[] = { FVector(0, 1, 0), FVector(0, 1, 0), FVector(0, 1, 0), FVector(0, 1, 0) };
const FVector bNormals3[] = { FVector(0, -1, 0), FVector(0, -1, 0), FVector(0, -1, 0), FVector(0, -1, 0) };	
const FVector bNormals4[] = { FVector(1, 0, 0), FVector(1, 0, 0), FVector(1, 0, 0), FVector(1, 0, 0) };
const FVector bNormals5[] = { FVector(-1, 0, 0), FVector(-1, 0, 0), FVector(-1, 0, 0), FVector(-1, 0, 0) };
const FVector bMask[] = { FVector(0, 0, 1), FVector(0, 0, -1), FVector(0, 1, 0), FVector(0, -1, 0), FVector(1, 0, 0), FVector(-1, 0, 0) };



// Sets default values
AVoxelActor::AVoxelActor()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = false;

}

// Called when the game starts or when spawned
void AVoxelActor::BeginPlay()
{
	Super::BeginPlay();
	
}

// Called every frame
void AVoxelActor::Tick(float  [MASK] )
{
	Super::Tick( [MASK] );

}

void AVoxelActor::OnConstruction(const FTransform & Transform)
{
	FName YourObjectName(""Test"");
	chunkZElements = 80;
	chunkTotalElements = chunkLineElements * chunkLineElements	* chunkZElements;
	chunkLineElementsP2 = chunkLineElements * chunkLineElements;
	VoxelSizeHalf = voxelSize / 2;

	FString string = ""voxel_"" + FString::FromInt(chunkXindex) + ""+"" + FString::FromInt(chunkYindex);
	FName name = FName(*string);
	proceduralComponent = NewObject<UProceduralMeshComponent>(this, name);
	proceduralComponent->RegisterComponent();

	RootComponent = proceduralComponent;
	RootComponent->SetWorldTransform(Transform);

	RootComponent->SetMobility(EComponentMobility::Static);


	Super::OnConstruction(Transform);

	GenerateChunk();
	UpdateMesh();
}


void AVoxelActor::GenerateChunk()
{
	FRandomStream RandomStream = FRandomStream(randomSeed);
	TArray<FIntVector> TreeCenters;

	chunkFields.SetNumUninitialized(chunkTotalElements);

	TArray <int32> noise = calculateNoise();


	for (int32 x = 0; x < chunkLineElements; x++)
	{
		for (int32 y = 0; y < chunkLineElements; y++)
		{
			for (int32 z = 0; z < chunkZElements; z++)
			{
				int32 index = x + (y * chunkLineElements) + (z * chunkLineElementsP2);

				//chunkFields[index] = (z < 30) ? 1 : 0; // Generate no noise

				if (z == 31 + noise[x + y * chunkLineElements] && RandomStream.FRand() < 0.02)
					TreeCenters.Add(FIntVector(x, y, z)); // WOOD
				else if (z == 30 + noise[x + y * chunkLineElements])
					chunkFields[index] = 1; // GRASS
				else if (z >= 30 - 3 + noise[x + y * chunkLineElements] && z < 30 + noise[x + y * chunkLineElements])
					chunkFields[index] = 2; // DIRT

				else if (z < 30 - 3 + noise[x + y * chunkLineElements])
					chunkFields[index] = 3; // STONE
				else chunkFields[index] = 0; // AIR




				/*if (z == 30 + noise[x + y * chunkLineElements])
				chunkFields[index] = 1;
				else if (z >= 27 + noise[x + y * chunkLineElements] && z < 30 + noise[x + y * chunkLineElements])
					chunkFields[index] = 2;

				else if (z < 27 + noise[x + y * chunkLineElements])
					chunkFields[index] = 3;
				else chunkFields[index] = 0;*/

				//chunkFields[index] = (z == 29 + noise[x + y * chunkLineElements]) ? 2 : 0;
				//chunkFields[index] = (z < 29 + noise[x + y * chunkLineElements]) ? 3 : 0;
			}
		}
	}

	for (FIntVector TreeCenter : TreeCenters)
	{
		int32 TreeHeight = RandomStream.RandRange(3, 6);
		int32 randomX = RandomStream.RandRange(0, 2);
		int32 randomY = RandomStream.RandRange(0, 2);
		int32 randomZ = RandomStream.RandRange(0, 2);

		for (int32 TreeX = -2; TreeX < 3; TreeX++)
		{
			for (int32 TreeY = -2; TreeY < 3; TreeY++)
			{
				for (int32 TreeZ = -2; TreeZ < 3; TreeZ++)
				{
					if (inRange(TreeX + TreeCenter.X, chunkLineElements) && inRange(TreeY + TreeCenter.Y, chunkLineElements) && inRange(TreeZ + TreeCenter.Z, chunkZElements))
					{
						float radius = FVector(TreeX * randomX, TreeY * randomY, TreeZ * randomZ).Size();

						if (radius <= 2.8)
						{
							if (RandomStream.FRand() < 0.5 || radius <= 1.2)
							{
								chunkFields[TreeCenter.X + TreeX + (chunkLineElements * (TreeCenter.Y + TreeY)) + (chunkLineElementsP2 * (TreeCenter.Z + TreeZ + TreeHeight))] = 21;// LEAF
							}
						}
					}
				}
			}
		}

	}
}

void AVoxelActor::UpdateMesh()
{
	TArray<FMeshSection> meshSections;
	meshSections.SetNum(Materials.Num());
	int32 el_num = 0;

	for (int32 x = 0; x < chunkLineElements; x++)
	{
		for (int32 y = 0; y < chunkLineElements; y++)
		{
			for (int32 z = 0; z < chunkZElements; z++)
			{
				int32 index = x + (chunkLineElements * y) + (chunkLineElementsP2 * z);
				int32 meshIndex = chunkFields[index];

				if (meshIndex > 0)
				{
					meshIndex--;

					TArray<FVector> &Vertices = meshSections[meshIndex].Vertices;
					TArray<int32> &Triangles = meshSections[meshIndex].Triangles;
					TArray<FVector> &Normals = meshSections[meshIndex].Normals;
					TArray<FVector2D> &UVs = meshSections[meshIndex].UVs;
					TArray<FProcMeshTangent> &Tangents = meshSections[meshIndex].Tangents;
					TArray<FColor> &VertexColors = meshSections[meshIndex].VertexColors;
					int32 ElementID = meshSections[meshIndex].ElementID;

					int triangle_num = 0;
					for (int i = 0; i < 6; i++)
					{
						int NewIndex = index + bMask[i].X + (bMask[i].Y * chunkLineElements) + (bMask[i].Z * chunkLineElementsP2);

						bool flag = false;
						if (meshIndex >= 20) flag = true;
						else if ((x + bMask[i].X < chunkLineElements) && (x + bMask[i].X >= 0) && (y + bMask[i].Y < chunkLineElements) && (y + bMask[i].Y >= 0))
						{
							if (NewIndex < chunkFields.Num() && NewIndex >= 0)
								if (chunkFields[NewIndex] < 1) flag = true;
						}
						else flag = true;
						if (flag)
						{
							Triangles.Add(bTriangles[0] + triangle_num + ElementID);
							Triangles.Add(bTriangles[1] + triangle_num + ElementID);
							Triangles.Add(bTriangles[2] + triangle_num + ElementID);
							Triangles.Add(bTriangles[3] + triangle_num + ElementID);
							Triangles.Add(bTriangles[4] + triangle_num + ElementID);
							Triangles.Add(bTriangles[5] + triangle_num + ElementID);
							triangle_num += 4;

							switch (i)
							{
							case 0: {
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));

								Normals.Append(bNormals0, ARRAY_COUNT(bNormals0));
								break;
							}

							case 1: {
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));

								Normals.Append(bNormals1, ARRAY_COUNT(bNormals1));
								break;
							}

							case 2: {
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));

								Normals.Append(bNormals2, ARRAY_COUNT(bNormals2));
								break;
							}

							case 3: {
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));

								Normals.Append(bNormals3, ARRAY_COUNT(bNormals3));
								break;
							}

							case 4: {
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));

								Normals.Append(bNormals4, ARRAY_COUNT(bNormals4));
								break;
							}

							case 5: {
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));

								Normals.Append(bNormals5, ARRAY_COUNT(bNormals5));
								break;
							}
							}
							UVs.Append(bUVs, ARRAY_COUNT(bUVs));

							FColor color = FColor(255, 255, 255, i);
							VertexColors.Add(color); VertexColors.Add(color); VertexColors.Add(color); VertexColors.Add(color);
						}
					}
					el_num += triangle_num;
					meshSections[meshIndex].ElementID += triangle_num;
				}
			}
		}
	}

	proceduralComponent->ClearAllMeshSections();

	for (int i = 0; i < meshSections.Num(); i++)
	{
		if (meshSections[i].Vertices.Num() > 0)
			proceduralComponent->CreateMeshSection(i, meshSections[i].Vertices, meshSections[i].Triangles, meshSections[i].Normals, meshSections[i].UVs, meshSections[i].VertexColors, meshSections[i].Tangents, collision);
	}


	int s = 0;
	while (s < Materials.Num())
	{
		proceduralComponent->SetMaterial(s, Materials[s]);
		s++;
	}

}

TArray<int32> AVoxelActor::calculateNoise_Implementation()
{
	TArray <int32> aa;
	aa.SetNum(chunkLineElementsP2);
	return aa;
}

bool AVoxelActor::inRange(int32 value, int32 range)
{
	return (value >= 0 && value < range);
}








//void AVoxelActor::UpdateMesh() // NO NOISE WORKING
//{
//	TArray<FVector> Vertices;
//	TArray<int32> Triangles;
//	TArray<FVector> Normals;
//	TArray<FVector2D> UVs;
//	TArray<FProcMeshTangent> Tangents;
//	TArray<FColor> VertexColors;
//
//	int32 ElementID = 0;
//
//	for (int32 x = 0; x < chunkLineElements; x++)
//	{
//		for (int32 y = 0; y < chunkLineElements; y++)
//		{
//			for (int32 z = 0; z < chunkZElements; z++)
//			{
//				int32 index = x + (chunkLineElements * y) + (chunkLineElementsP2 * z);
//				int32 meshIndex = chunkFields[index];
//
//				if (meshIndex > 0)
//				{
//
//					meshIndex--;
//
//					int triangle_num = 0;
//					for (int i = 0; i < 6; i++)
//					{
//						int NewIndex = index + bMask[i].X + (bMask[i].Y * chunkLineElements) + (bMask[i].Z * chunkLineElementsP2);
//
//						bool flag = false;
//						if (meshIndex >= 20) flag = true;
//						else if ((x + bMask[i].X < chunkLineElements) && (x + bMask[i].X >= 0) && (y + bMask[i].Y < chunkLineElements) && (y + bMask[i].Y >= 0))
//						{
//							if (NewIndex < chunkFields.Num() && NewIndex >= 0)
//								if (chunkFields[NewIndex] < 1) flag = true;
//						}
//						else flag = true;
//						if (flag)
//						{
//							Triangles.Add(bTriangles[0] + triangle_num + ElementID);
//							Triangles.Add(bTriangles[1] + triangle_num + ElementID);
//							Triangles.Add(bTriangles[2] + triangle_num + ElementID);
//							Triangles.Add(bTriangles[3] + triangle_num + ElementID);
//							Triangles.Add(bTriangles[4] + triangle_num + ElementID);
//							Triangles.Add(bTriangles[5] + triangle_num + ElementID);
//							triangle_num += 4;
//
//							switch (i)
//							{
//							case 0: {
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//
//								Normals.Append(bNormals0, ARRAY_COUNT(bNormals0));
//								break;
//							}
//
//							case 1: {
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//
//								Normals.Append(bNormals1, ARRAY_COUNT(bNormals1));
//								break;
//							}
//
//							case 2: {
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//
//								Normals.Append(bNormals2, ARRAY_COUNT(bNormals2));
//								break;
//							}
//
//							case 3: {
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//
//								Normals.Append(bNormals3, ARRAY_COUNT(bNormals3));
//								break;
//							}
//
//							case 4: {
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//
//								Normals.Append(bNormals4, ARRAY_COUNT(bNormals4));
//								break;
//							}
//
//							case 5: {
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), -VoxelSizeHalf + (z * voxelSize)));
//								Vertices.Add(FVector(-VoxelSizeHalf + (x * voxelSize), -VoxelSizeHalf + (y * voxelSize), VoxelSizeHalf + (z * voxelSize)));
//
//								Normals.Append(bNormals5, ARRAY_COUNT(bNormals5));
//								break;
//							}
//							}
//							UVs.Append(bUVs, ARRAY_COUNT(bUVs));
//
//							FColor color = FColor(255, 255, 255, i);
//							VertexColors.Add(color); VertexColors.Add(color); VertexColors.Add(color); VertexColors.Add(color);
//						}
//					}
//					ElementID += triangle_num;
//				}
//			}
//		}
//	}
//
//
//	proceduralComponent->ClearAllMeshSections();
//	proceduralComponent->CreateMeshSection(0, Vertices, Triangles, Normals, UVs, VertexColors, Tangents, true);
//
//}
",DeltaTime
637,"// Homework 2
// Fortune teller program
// It will receive some inputs from the user and will tell them which type of
// C++ programmer they are.

#include <array>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>

using std::array;
using std::cin;
using std::cout;
using std::endl;
using std::map;
using std::pair;
using std::string;
using std::vector;

int main() {

  cout << ""Welcome to the fortune teller program!"" << endl;
  cout << ""Please enter your name:"" << endl;

  string name{};
  cin >> name;

  cout << ""Please enter the time of year when you were born:\n(pick from ""
          ""'spring', 'summer', 'autumn', 'winter')""
       << endl;

  string season{};
  cin >> season;

  cout << ""Please enter an adjective:"" << endl;
  string  [MASK] {};
  cin >>  [MASK] ;

  cout << ""Please enter another adjective:"" << endl;
  string adjective2{};
  cin >> adjective2;

  // Fortune teller program
  vector<string> adjectives{ [MASK] , adjective2};

  unsigned adj_idx = name.size() % adjectives.size();

  map<string, string> noun = {{""spring"", ""STL guru""},
                              {""summer"", ""C++ expert""},
                              {""autumn"", ""coding beast""},
                              {""winter"", ""software design hero""}};

  array<string, 3UL> ending = {""eats UB for breakfast"",
                               ""finds errors quicker than the compiler"",
                               ""is not afraid of C++ error messages""};

  unsigned end_idx = name.size() % ending.size();

  // Resulting message
  cout << ""\nHere is your description:"" << endl;
  cout << name << "",""
       << "" the "" << adjectives.at(adj_idx) << "" "" << noun.at(season) << "" that ""
       << ending.at(end_idx) << endl;
}
",adjective1
638,"#include <iostream>
#include <chrono>
#include <vector>
#include <algorithm>
using namespace std;

#include <Windows.h>

int nScreenWidth = 120;
int nScreenHeight = 40;

float fPlayerX = 8.0f;
float fPlayerY = 8.0f;
float fPlayerA = 0.0f;

int nMapHeight = 16;
int nMapWidth = 16;

float fFOV = 3.14159f / 4.0f;

float fDepth = 16.0f;

int main()
{



	wchar_t* screen = new  wchar_t[nScreenWidth * nScreenHeight];
	HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
	SetConsoleActiveScreenBuffer(hConsole);
	DWORD dwBytesWritten = 0;

	wstring map;

	map += L""################"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""#..........#...#"";
	map += L""#..........#...#"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""#.......########"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""#..............#"";
	map += L""################"";

	auto  [MASK]  = chrono::system_clock::now();
	auto tp2 = chrono::system_clock::now();


	while (true)
	{

		tp2 = chrono::system_clock::now();
		chrono::duration<float> elapsedTime = tp2 -  [MASK] ;
		 [MASK]  = tp2;
		float fElapsedTime = elapsedTime.count();

		if (GetAsyncKeyState((unsigned short)'A') & 0x8000)
		{
			fPlayerA -= (1.6f) * fElapsedTime;
		}
		if (GetAsyncKeyState((unsigned short)'D') & 0x8000)
		{
			fPlayerA += (1.6f) * fElapsedTime;
		}
		if (GetAsyncKeyState((unsigned short)'W') & 0x8000)
		{
			fPlayerX += sinf(fPlayerA) * 5.0f * fElapsedTime;
			fPlayerY += cosf(fPlayerA) * 5.0f * fElapsedTime;

			if (map[(int)fPlayerY * nMapWidth + (int)fPlayerX] == '#')
			{
				fPlayerX -= sinf(fPlayerA) * 5.0f * fElapsedTime;
				fPlayerY -= cosf(fPlayerA) * 5.0f * fElapsedTime;
			}

		}
		if (GetAsyncKeyState((unsigned short)'S') & 0x8000)
		{
			fPlayerX -= sinf(fPlayerA) * 5.0f * fElapsedTime;
			fPlayerY -= cosf(fPlayerA) * 5.0f * fElapsedTime;

			if (map[(int)fPlayerY * nMapWidth + (int)fPlayerX] == '#')
			{
				fPlayerX += sinf(fPlayerA) * 5.0f * fElapsedTime;
				fPlayerY += cosf(fPlayerA) * 5.0f * fElapsedTime;
			}
		}

		for (int x = 0; x < nScreenWidth; x++)
		{

			// for each column, calculate the projected ray angle into world space
			float fRayAngle = (fPlayerA - fFOV / 2.0f) + ((float)x / (float)nScreenWidth) * fFOV;

			float fDistanceToWall = 0;
			bool bHitWall = false;
			bool  bBoundary = false;

			float fEyeX = sinf(fRayAngle);
			float fEyeY = cosf(fRayAngle);


			while (!bHitWall && fDistanceToWall < fDepth)
			{
				fDistanceToWall += 0.1f;
				
				int nTestX = (int)(fPlayerX + fEyeX * fDistanceToWall);
				int nTestY = (int)(fPlayerY + fEyeY * fDistanceToWall);

				if (nTestX < 0 || nTestX >= nMapWidth || nTestY < 0 || nTestY >= nMapHeight)
				{
					bHitWall = true;
					fDistanceToWall = fDepth;

				}
				else
				{
					if (map[nTestY * nMapWidth + nTestX] == '#')
					{
						bHitWall = true;

						vector<pair<float, float>> p; // distance, dot product 

						for (int tx = 0; tx < 2; tx++)
						{
							for (int ty = 0; ty < 2; ty++)
							{
								float vy = (float)nTestY + ty - fPlayerY;
								float vx = (float)nTestX + tx - fPlayerX;
								float d = sqrt(vx * vx + vy * vy);
								float dot = (fEyeX * vx / d) + (fEyeY * vy / d);
								p.push_back(make_pair(d, dot));

							}
						}

						// Sort pairs from closest to furthest
						sort(p.begin(), p.end(), [](const pair<float, float>& left, const pair<float, float>& right) {return left.first < right.first;  });

						float fBound = 0.01f;
						if (acos(p.at(0).second) < fBound) bBoundary = true;
						if (acos(p.at(1).second) < fBound) bBoundary = true;
						//if (acos(p.at(2).second) < fBound) bBoundary = true;
					}
				}

			}

			// Calculate distance to ceiling and floor
			int nCeiling = (float)(nScreenHeight / 2.0f) - nScreenHeight / ((float)fDistanceToWall);
			int nFloor = nScreenHeight - nCeiling;

			short nShade = ' '; 

			if (fDistanceToWall <= fDepth / 4.0f)           nShade = 0x2588;
			else if (fDistanceToWall < fDepth / 3.0f)      nShade = 0x2593;
			else if (fDistanceToWall < fDepth / 2.0f)      nShade = 0x2592;
			else if (fDistanceToWall < fDepth)      nShade = 0x2591;
			else                                            nShade = ' ';
				
			if (bBoundary)  nShade = ' ';

			for (int y = 0; y < nScreenHeight; y++)
			{
				if (y < nCeiling)
				{
					screen[y * nScreenWidth + x] = ' ';
				}
				else if (y > nCeiling && y <= nFloor)
				{
					if (fDistanceToWall <= fDepth / 4.0f)           nShade = 0x2588;
					else if (fDistanceToWall < fDepth / 3.0f)      nShade = 0x2593;
					else if (fDistanceToWall < fDepth / 2.0f)      nShade = 0x2592;
					else if (fDistanceToWall < fDepth)      nShade = 0x2591;
					else                                            nShade = ' ';

					if (bBoundary)  nShade = ' ';

					screen[y * nScreenWidth + x] = nShade;
				}
				else
				{
					//shade floor based on distance
					float b = 1.0f - (((float)y - nScreenHeight / 2.0f) / ((float)nScreenHeight / 2.0f));

					if (b < 0.25)	
						nShade = '#';
					else if (b < 0.5)	
						nShade = 'x';
					else if (b < 0.75)	
						nShade = '.';
					else  if (b < 0.9)	
						nShade = '-';
					else 	
						nShade = ' ';

					screen[y * nScreenWidth + x] = nShade;
				}
			}
		}

		swprintf_s(screen, 40, L""X=%3.2f, Y=%3.2f, A=%3.2f FPS=%3.2f "", fPlayerX, fPlayerY, fPlayerA, 1.0f / fElapsedTime);

		// display map
		for (int nx = 0; nx < nMapWidth; nx++)
		{
			for (int ny = 0; ny < nMapHeight; ny++)
			{
				screen[(ny + 1) * nScreenWidth + nx] = map[ny * nMapWidth + nx];
			}
		}

		screen[((int)fPlayerY + 1)* nScreenWidth + (int)fPlayerX] = 'P';
		screen[nScreenWidth * nScreenHeight - 1] = '\0';
		WriteConsoleOutputCharacter(hConsole, screen, nScreenWidth * nScreenHeight, { 0, 0 }, &dwBytesWritten);

	}

	return 0;
}",tp1
639,"#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main() {
    // Seed the random number generator with the current time
    srand(time(nullptr));

    // Generate a random number between 1 and 100
    int  [MASK]  = rand() % 100 + 1;

    // Initialize the user's guess to be outside the valid range
    int guess = 0;

    // Loop until the user guesses the correct number
    while (guess !=  [MASK] ) {
        // Ask the user for their guess
        cout << ""Guess a number between 1 and 100: "";
        cin >> guess;

        // Check if the user's guess is too low, too high, or correct
        if (guess <  [MASK] ) {
            cout << ""Too low. Try again."" << endl;
        } else if (guess >  [MASK] ) {
            cout << ""Too high. Try again."" << endl;
        } else {
            cout << ""You guessed it! The number was "" <<  [MASK]  << ""."" << endl;
        }
    }

    // Exit the program
    return 0;
}",randomNumber
640,"/* Fill-in information from Blynk Device Info here */
#define BLYNK_TEMPLATE_ID """"     // The template ID from Blynk IoT platform
#define BLYNK_TEMPLATE_NAME """"   // The template name from Blynk IoT platform
#define BLYNK_AUTH_TOKEN """"      // The authentication token for Blynk platform

#include <WiFi.h>                // Includes the Wi-Fi library for the ESP32
#include <WiFiClient.h>          // Includes the Wi-Fi client library for network connections
#include <BlynkSimpleEsp32.h>    // Includes the Blynk library specific to ESP32
#include <string.h>              // Includes the library for using string functions
#include <DHT.h>                 // Includes the DHT sensor library

/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial       // Enable debug printing to serial monitor

// DHT sensor configuration
#define DHTPIN 17                 // Pin where the DHT sensor is connected
#define DHTTYPE DHT11            // Type of DHT sensor
DHT dht(DHTPIN, DHTTYPE);        // Create a DHT sensor object

#define RELAY_PIN 16             // GPIO pin connected to the relay
#define SOIL_PIN 34              // Analog pin connected to the soil moisture sensor

#define INTERVAL 3000            // Interval at which to send sensor data (milliseconds)
unsigned long previousMillis = 0; // Stores last time sensor data was sent

char auth[] = BLYNK_AUTH_TOKEN;  // Blynk authorization token

/* Fill-in the WiFi SSID and password */
char ssid[] = """";                // WiFi SSID
char pass[] = """";                // WiFi password

void setup()
{
  Serial.begin(115200);          // Initialize serial communication at 115200bps
  dht.begin();                   // Initialize the DHT sensor
  pinMode(RELAY_PIN, OUTPUT);    // Set the relay pin as an output
  digitalWrite(RELAY_PIN, HIGH); // Initialize the relay to be OFF
  Blynk.begin(auth, ssid, pass); // Connect to Blynk
}

void loop()
{
  Blynk.run();                   // Run Blynk process
  unsigned long  [MASK]  = millis(); // Get the current time
  // Check if it is time to read and send sensor data
  if ( [MASK]  - previousMillis >= INTERVAL) {
    previousMillis =  [MASK] ;       // Update the last sent time
    float t = dht.readTemperature();      // Read temperature from DHT sensor
    float h = dht.readHumidity();         // Read humidity from DHT sensor

    // Check if DHT readings were successful
    if (isnan(h) || isnan(t)) {
      Serial.println(""Failed to read from DHT sensor!\n"");
    } else {
      Blynk.virtualWrite(V0, t);          // Send temperature to Blynk
      Blynk.virtualWrite(V1, h);          // Send humidity to Blynk
      BLYNK_PRINT.printf(""Humidity: %.2f, Temperature: %.2f, "", h, t);
    }

    int moisture = analogRead(SOIL_PIN);  // Read soil moisture level
    Blynk.virtualWrite(V2, moisture);     // Send soil moisture to Blynk
    BLYNK_PRINT.printf(""Soil moisture level: %d\n"", moisture); 
  }
}

// Function to control the relay from the Blynk app
BLYNK_WRITE(V3)
{
  if (param.asInt() == HIGH)  // Check if button in app is pressed
  {
    digitalWrite(RELAY_PIN, LOW); // Turn on relay (activate water pump)
  }
  else
  {
    digitalWrite(RELAY_PIN, HIGH); // Turn off relay (deactivate water pump)
  }
}
",currentMillis
641,"#include ""llvm/IR/PassManager.h""
#include ""llvm/IR/Module.h""
#include ""llvm/IR/Function.h""
#include ""llvm/IR/BasicBlock.h""
#include ""llvm/IR/IRBuilder.h""
#include ""llvm/IR/Instructions.h""
#include ""llvm/IR/Constants.h""
#include ""llvm/IR/LLVMContext.h""
#include ""llvm/Passes/PassPlugin.h""
#include ""llvm/Support/raw_ostream.h""
#include ""llvm/Support/FileSystem.h""
#include ""llvm/Passes/PassBuilder.h""
#include <map>
#include <vector>
#include <string>
#include <fstream>
#include <cstdlib>
#include <fcntl.h>
#include <unistd.h>
#include <system_error>

using namespace llvm;

struct CodeCoveragePass : public PassInfoMixin<CodeCoveragePass> {
  // Map to hold unique IDs for each basic block.
  std::map<const BasicBlock*, unsigned> BlockIDMap;

  // Structure to hold CFG information per function.
  struct CFGInfo {
    unsigned EntryID;
    std::vector<unsigned> ExitIDs;
  };
  std::map<std::string, CFGInfo> FunctionCFG;

  // Get environment variable value with error checking
  std::string getEnvVar(const char* name) {
    const char* value = std::getenv(name);
    if (!value) {
      errs() << ""Error: Environment variable "" << name << "" is not set\n"";
      return """";
    }
    return std::string(value);
  }

  // Get next block ID with file locking
  unsigned getNextBlockID() {
    std::string counterFile = getEnvVar(""BLOCK_COUNTER_FILE"");
    if (counterFile.empty()) return 0;

    // Open the file for reading and writing
    int fd = open(counterFile.c_str(), O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
      errs() << ""Error: Cannot open counter file: "" << counterFile << ""\n"";
      return 0;
    }

    // Create file lock structure
    struct flock fl;
    fl.l_type = F_WRLCK;    // Write lock
    fl.l_whence = SEEK_SET;  // From beginning of file
    fl.l_start = 0;          // Offset from l_whence
    fl.l_len = 0;           // Lock whole file
    fl.l_pid = getpid();    // Process ID

    // Acquire exclusive lock
    if (fcntl(fd, F_SETLKW, &fl) == -1) {
      errs() << ""Error: Cannot lock counter file\n"";
      close(fd);
      return 0;
    }

    // Read current value
    char buf[32];
    unsigned currentID = 0;
    ssize_t bytes_read = read(fd, buf, sizeof(buf) - 1);
    if (bytes_read > 0) {
      buf[bytes_read] = '\0';
      currentID = std::stoul(buf);
    }

    // Increment the counter
    currentID++;

    // Write back the incremented value
    std::string newVal = std::to_string(currentID);
    lseek(fd, 0, SEEK_SET);
    write(fd, newVal.c_str(), newVal.length());
    ftruncate(fd, newVal.length());  // Truncate file to new length

    // Release the lock
    fl.l_type = F_UNLCK;
    fcntl(fd, F_SETLK, &fl);

    // Close file
    close(fd);

    return currentID - 1;  // Return the ID we're using (not the next one)
  }

  // Append CFG information to the CFG file
  void appendCFGInfo(const Module &M) {
    std::string  [MASK]  = getEnvVar(""CFG_FILE"");
    if ( [MASK] .empty()) return;

    std::error_code EC;
    
    // Open file in append mode
    raw_fd_ostream Out( [MASK] , EC, sys::fs::OF_Append | sys::fs::OF_Text);
    if (EC) {
      errs() << ""Error opening CFG file for writing: "" << EC.message() << ""\n"";
      return;
    }

    // Write module information
    Out << ""    {\n"";
    Out << ""      \""module_name\"": \"""" << M.getName().str() << ""\"",\n"";
    Out << ""      \""functions\"": [\n"";
    
    bool firstFunc = true;
    for (auto &entry : FunctionCFG) {
      if (!firstFunc)
        Out << "",\n"";
      firstFunc = false;
      Out << ""        {\n"";
      Out << ""          \""name\"": \"""" << entry.first << ""\"",\n"";
      Out << ""          \""entry_block\"": "" << entry.second.EntryID << "",\n"";
      Out << ""          \""exit_blocks\"": ["";
      for (size_t i = 0; i < entry.second.ExitIDs.size(); ++i) {
        Out << entry.second.ExitIDs[i];
        if (i + 1 < entry.second.ExitIDs.size())
          Out << "", "";
      }
      Out << ""]\n        }"";
    }
    Out << ""\n      ]\n    }\n"";
    
    Out.close();
  }

  PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
    // 1. Traverse the module to assign unique IDs and collect CFG data.
    for (Function &F : M) {
      if (F.isDeclaration())
        continue;
      bool firstBlock = true;
      CFGInfo cfg;
      for (BasicBlock &BB : F) {
        // Get a new unique block ID with locking
        unsigned blockID = getNextBlockID();
        BlockIDMap[&BB] = blockID;
        
        if (firstBlock) {
          cfg.EntryID = blockID;
          firstBlock = false;
        }
        // A block is considered an exit if its terminator is a return, resume, or unreachable.
        Instruction *TI = BB.getTerminator();
        if (isa<ReturnInst>(TI) || isa<ResumeInst>(TI) || isa<UnreachableInst>(TI))
          cfg.ExitIDs.push_back(blockID);
      }
      FunctionCFG[F.getName().str()] = cfg;
    }

    // 2. Declare the external helper function __coverage_push.
    LLVMContext &Ctx = M.getContext();
    Type *VoidTy = Type::getVoidTy(Ctx);
    Type *Int32Ty = Type::getInt32Ty(Ctx);
    FunctionType *PushFuncTy = FunctionType::get(VoidTy, {Int32Ty}, false);
    Function *PushFunc = cast<Function>(
      M.getOrInsertFunction(""__coverage_push"", PushFuncTy).getCallee());
    PushFunc->setCallingConv(CallingConv::C);

    // 3. Insert a call to __coverage_push at the beginning of every basic block.
    for (Function &F : M) {
      if (F.isDeclaration())
        continue;
      for (BasicBlock &BB : F) {
        IRBuilder<> Builder(&*BB.getFirstInsertionPt());
        unsigned bbID = BlockIDMap[&BB];
        Value *IDVal = ConstantInt::get(Int32Ty, bbID);
        Builder.CreateCall(PushFunc, {IDVal});
      }
    }

    // 4. Append the CFG information to the specified file
    appendCFGInfo(M);

    return PreservedAnalyses::none();
  }
};

// Registration for the new pass manager
llvm::PassPluginLibraryInfo getCodeCoveragePassPluginInfo() {
    return {
        LLVM_PLUGIN_API_VERSION, ""CodeCoveragePass"", LLVM_VERSION_STRING,
        [](PassBuilder &PB) {
            // Register for explicit pass pipeline use
            PB.registerPipelineParsingCallback(
                [](StringRef Name, ModulePassManager &MPM,
                   ArrayRef<PassBuilder::PipelineElement>) {
                    if (Name == ""code-coverage-pass"") {
                        MPM.addPass(CodeCoveragePass());
                        return true;
                    }
                    return false;
                });

            // Register to run before any optimizations
            PB.registerOptimizerEarlyEPCallback(
                [](ModulePassManager &MPM, OptimizationLevel Level) {
                    MPM.addPass(CodeCoveragePass());
                });
        }};
}

extern ""C"" LLVM_ATTRIBUTE_WEAK ::llvm::PassPluginLibraryInfo llvmGetPassPluginInfo() {
    return getCodeCoveragePassPluginInfo();
}
",cfgFile
642,"#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>
#include ""Game.hpp""
#include ""SimpleMenu.hpp""

int main() {
    if (SDL_Init(SDL_INIT_VIDEO) != 0 || TTF_Init() != 0) {
        SDL_Log(""SDL/TTF Init Error: %s"", SDL_GetError());
        return -1;
    }

    SDL_Window* window = SDL_CreateWindow(""Digger Menu"",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, 0);
    if (!window) {
        SDL_Log(""Window creation failed: %s"", SDL_GetError());
        TTF_Quit();
        SDL_Quit();
        return -1;
    }

    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (!renderer) {
        SDL_Log(""Renderer creation failed: %s"", SDL_GetError());
        SDL_DestroyWindow(window);
        TTF_Quit();
        SDL_Quit();
        return -1;
    }

    TTF_Font* font = TTF_OpenFont(""/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"", 24);
    if (!font) {
        SDL_Log(""Font load failed: %s"", TTF_GetError());
        SDL_DestroyRenderer(renderer);
        SDL_DestroyWindow(window);
        TTF_Quit();
        SDL_Quit();
        return -1;
    }

    enum class AppState { Menu, Game, Exit };
    AppState  [MASK]  = AppState::Menu;

    while ( [MASK]  != AppState::Exit) {
        if ( [MASK]  == AppState::Menu) {
            SimpleMenu menu(renderer, font);
            MenuAction action = menu.run();
            if (action == MenuAction::StartGame) {
                 [MASK]  = AppState::Game;
            } else if (action == MenuAction::Exit) {
                 [MASK]  = AppState::Exit;
            }
        }

        if ( [MASK]  == AppState::Game) {
            Game game;
            if (game.init(renderer)) {
                GameResult result = game.run();
                if (result == GameResult::BackToMenu)
                     [MASK]  = AppState::Menu;
                else if (result == GameResult::Quit)
                     [MASK]  = AppState::Exit;
            } else {
                SDL_Log(""Failed to initialize game"");
                 [MASK]  = AppState::Menu;
            }
        }
    }

    TTF_CloseFont(font);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    TTF_Quit();
    SDL_Quit();

    return 0;
}
",state
643,"#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <stdio.h>
#include <Adafruit_NeoPixel.h>

// Update these with values suitable for your network.

const char* ssid = ""YOUR_WIFI_SSID"";
const char* password = ""<PASSWORD>"";
const char* mqtt_server = ""io.adafruit.com"";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

#define PIN 12

Adafruit_NeoPixel strip = Adafruit_NeoPixel(50, PIN, NEO_RGB + NEO_KHZ800);

void setup() {
  pinMode(BUILTIN_LED, OUTPUT);     // Initialize the BUILTIN_LED pin as an output
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  strip.begin();
  rainbowCycle(50);
}

void setup_wifi() {

  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print(""Connecting to "");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(""."");
  }

  Serial.println("""");
  Serial.println(""WiFi connected"");
  Serial.println(""IP address: "");
  Serial.println(WiFi.localIP());
}

String red = ""Red: "";
String green = ""Green: "";
String blue = ""Blue: "";

int redColor, greenColor, blueColor;

void array_to_string(byte array[], unsigned int len, char buffer[])
{
    for (unsigned int i = 0; i < len; i++)
    {
        byte nib1 = (array[i] >> 4) & 0x0F;
        byte nib2 = (array[i] >> 0) & 0x0F;
        buffer[i*2+0] = nib1  < 0xA ? '0' + nib1  : 'A' + nib1  - 0xA;
        buffer[i*2+1] = nib2  < 0xA ? '0' + nib2  : 'A' + nib2  - 0xA;
    }
    buffer[len*2] = '\0';
}

#define MAX_WORD_COUNT 3
#define MIN_WORD_COUNT 3
char *Words[MAX_WORD_COUNT];

byte split_message(char* str) {
  byte  [MASK]  = 0; //number of words
  char * item = strtok (str, "",""); //getting first word (uses space & comma as delimeter)

  while (item != NULL) {
    if ( [MASK]  >= MAX_WORD_COUNT) {
      break;
    }
    Words[ [MASK] ] = item;
    item = strtok (NULL, "",""); //getting subsequence word
     [MASK] ++;
  }
  return   [MASK] ;
}

char payloadString[30];

void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}
void rainbowCycle(uint8_t wait) {
  uint16_t i;

  for(i=0; i< strip.numPixels(); i++) {
    strip.setPixelColor(i, Wheel((i * 256 / strip.numPixels()) & 255));
    strip.show();
    delay(wait);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
int messageLength, payloadlength;
void callback(char* topic, byte* payload, unsigned int length) {
  sprintf(payloadString, ""%s"", payload);
  messageLength = sizeof(payloadString);
  payloadString[messageLength] = '\0';
  Serial.print(""Message arrived ["");
  Serial.print(topic);
  Serial.print(""] "");
  Serial.println(payloadString);

  if(strstr(payloadString, ""rainbow"")){
    Serial.println(""Rainbow!!!"");
    rainbowCycle(50);
  } else {
    split_message(payloadString);

    redColor = atoi(Words[0]);
    greenColor = atoi(Words[1]);
    blueColor = atoi(Words[2]);

    Serial.println(red + redColor);
    Serial.println(green + greenColor);
    Serial.println(blue + blueColor);
    colorWipe(strip.Color(redColor, greenColor, blueColor), 50);
  }
  for(uint8_t i = 0; i < length; i++) {
    payload[i] = 0x00;
  }
}



void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print(""Attempting MQTT connection..."");
    // Attempt to connect
    if (client.connect(""ESP8266Client"", ""YOUR_AIO_USERNAME"", ""YOUR_AIO_KEY"")) {
      Serial.println(""connected"");
      client.subscribe(""YOUR_AIO_FEED"");
    } else {
      Serial.print(""failed, rc="");
      Serial.print(client.state());
      Serial.println("" try again in 5 seconds"");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}
void loop() {

  if (!client.connected()) {
    reconnect();
  }
  client.loop();

}
",word_count
644,"/*******************************************************************************
 *  Copyright (C) 2024 Intel Corporation
 *
 *  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.
 *
 *
 *  SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

// Standard includes
#include <iostream>
#include <unordered_map>
#include <memory>
#include <utility>
#include <mutex>
#include <vector>
#include <algorithm>

#include <string.h>

// Local includes
#include ""diag_common.h""
#include ""diag_pd.h""
#include ""diag_create_pkt.h""
#include ""diag_pkt_database.h""

// namespace diag {
#define MIN_REPEAT_THRESH_FOR_STRONG_SUSPECT_FOR_HOLD 3
#define HOLD_BYTE_INTERVAL 80

// Wrapper helper struct to store the pkt size and data. This ensures proper
// cleanup of the data
struct PktWrapper {
 public:
  PktWrapper(const int &size,
             const bf_diag_sess_hdl_t &hdl,
             const bf_dev_port_t &port)
      : pkt_size(size), sess_hdl(hdl), dev_port(port) {
    pkt = new uint8_t[size];
    if (pkt == nullptr) {
      DIAG_PRINT(""Malloc failed\n"");
      DIAG_ASSERT(0);
    }
  }
  ~PktWrapper() { delete[] pkt; }
  uint32_t pkt_size;
  uint8_t *pkt;
  bf_diag_sess_hdl_t sess_hdl;
  bf_dev_port_t dev_port;

  // Vectors to store all the bit locations that experience flips
  std::vector<uint32_t> flips_1_to_0_vec;
  std::vector<uint32_t> flips_0_to_1_vec;
};

// should this be static, how about using anonymous namespace?
static std::unordered_map<pkt_id_type, std::unique_ptr<PktWrapper>>
    g_pkt_database;
static std::mutex mtx;
static pkt_id_type g_pkt_id = 0;

namespace {
void diag_encode_sess_port_in_pkt_id(const bf_diag_sess_hdl_t sess_hdl,
                                     const bf_dev_port_t dev_port,
                                     pkt_id_type *pkt_id) {
  // pkt_id is a 64 bit u_int. Use the most significant 4 bytes to encode
  // the sess_hdl and the port with 2 bytes for each in that order
  if (DIAG_MIN_PKT_SIZE_ENABLED) {
    // for min size pkt, make pkt_id 2 bytes and save bytes
    *pkt_id = *pkt_id & 0xffffff;
    *pkt_id |= ((static_cast<pkt_id_type>(sess_hdl) & 0xffff) << 32);
    *pkt_id |= ((static_cast<pkt_id_type>(dev_port) & 0xffff) << 16);
  } else {
    *pkt_id = *pkt_id & 0xffffffff;
    *pkt_id |= ((static_cast<pkt_id_type>(sess_hdl) & 0xffff) << 48);
    *pkt_id |= ((static_cast<pkt_id_type>(dev_port) & 0xffff) << 32);
  }
}

void diag_decode_sess_port_from_pkt_id(const pkt_id_type pkt_id,
                                       bf_diag_sess_hdl_t *sess_hdl,
                                       bf_dev_port_t *dev_port) {
  if (DIAG_MIN_PKT_SIZE_ENABLED) {
    *sess_hdl = (pkt_id >> 32) & 0xffff;
    *dev_port = (pkt_id >> 16) & 0xffff;
  } else {
    *sess_hdl = (pkt_id >> 48) & 0xffff;
    *dev_port = (pkt_id >> 32) & 0xffff;
  }
}

inline uint32_t diag_get_header_size() {
// The header size of the packet is determined by the mode in which the
// SLT has been compiled.
#if defined(DIAG_PHV_STRESS_ENABLE)
  return 378;
#elif defined(DIAG_PHV_FLOP_CONFIG_1)
  // 14 (Eth) + 2 (Override) + 48W + 64H +64B (PHVs)
  return 400;
#elif defined(DIAG_PHV_FLOP_CONFIG_2)
  // 14 (Eth) + 2 (Override) + 16W + 32H + 16B (PHVs)
  return 160;
#elif defined(DIAG_PHV_FLOP_CONFIG_3)
  return DIAG_PKT_HEADER_SIZE;
#elif defined(DIAG_PATTERN_SHIFT_ENABLE)
  return 240;
#else
  return DIAG_PKT_HEADER_SIZE;
#endif
}

void diag_log_bit_flip_in_pkt(const pkt_id_type &pkt_id,
                              const uint32_t &byte_offset,
                              const bool &is_1_to_0_flip) {
  // Get the pkt data for the pkt_id
  auto &pkt_wrapper = g_pkt_database.at(pkt_id);

  // If the flip is from 1->0 and if it is not in the header, we don't
  // log it because it's not the regular setup issue
  if (is_1_to_0_flip && (byte_offset >= diag_get_header_size())) {
    return;
  }

  // Get the vectors for logging bit flips
  auto &vec_1_to_0 = pkt_wrapper.get()->flips_1_to_0_vec;
  auto &vec_0_to_1 = pkt_wrapper.get()->flips_0_to_1_vec;

  // Sanity check. The absolute bit offset should not already be present in
  // either of the maps. That would mean that we are adding the same bit
  // twice, which would indicate an error in our compare logic. Assert in
  // that case
  if (is_1_to_0_flip) {
    if (std::find(vec_1_to_0.begin(), vec_1_to_0.end(), byte_offset) !=
        vec_1_to_0.end()) {
      DIAG_PRINT(
          ""Trying to add the same byte offset (%d) twice for pkt_id (%lu) for ""
          ""a 1 to 0 flip. Something is wrong in the pkt compare logic. ""
          ""Asserting\n"",
          byte_offset,
          pkt_id);
      DIAG_ASSERT(0);
    }
  } else {
    if (std::find(vec_0_to_1.begin(), vec_0_to_1.end(), byte_offset) !=
        vec_0_to_1.end()) {
      DIAG_PRINT(
          ""Trying to add the same byte offset (%d) twice for pkt_id (%lu) for ""
          ""a 0 to 1 flip. Something is wrong in the pkt compare logic. ""
          ""Asserting\n"",
          byte_offset,
          pkt_id);
      DIAG_ASSERT(0);
    }
  }

  if (is_1_to_0_flip) {
    vec_1_to_0.push_back(byte_offset);
  } else {
    vec_0_to_1.push_back(byte_offset);
  }
}

void diag_classify_suspicion_for_setup(const pkt_id_type &pkt_id,
                                       bool *is_weak_suspect) {
  // Get the pkt data for the pkt_id
  auto &pkt_wrapper = g_pkt_database.at(pkt_id);

  // If there is even a single 1->0 flip, it is a weak suspect for setup
  if (pkt_wrapper.get()->flips_1_to_0_vec.size()) {
    *is_weak_suspect = true;
  } else {
    *is_weak_suspect = false;
  }
}

void diag_classify_suspicion_for_hold(
    const pkt_id_type &pkt_id,
    bool *is_weak_suspect,
    bool *is_strong_suspect,
    std::vector<std::vector<uint32_t>> *ss_hold_bit_flips_index_vec) {
  std::vector<uint32_t> bit_index;

  *is_strong_suspect = false;
  *is_weak_suspect = false;

  // Get the pkt data for the pkt_id
  auto &pkt_wrapper = g_pkt_database.at(pkt_id);

  auto &vec_0_to_1 = pkt_wrapper.get()->flips_0_to_1_vec;

  while (vec_0_to_1.size()) {
    std::vector<uint32_t> temp;
    int counter = 0;
    auto first = vec_0_to_1.front();
    for (auto iter = vec_0_to_1.begin(); iter != vec_0_to_1.end();) {
      // If the bit flips are on the required (80 byte) boundary, add the
      // bit index to a temp vector
      if ((((*iter) - first) % (HOLD_BYTE_INTERVAL)) == 0) {
        counter++;
        temp.push_back(*iter);
      }
      if ((*iter) == first) {
        iter = vec_0_to_1.erase(iter);
      } else {
        iter++;
      }
    }
    if (counter >= MIN_REPEAT_THRESH_FOR_STRONG_SUSPECT_FOR_HOLD) {
      *is_strong_suspect = true;
      ss_hold_bit_flips_index_vec->push_back(temp);
      // Remove the bit flips that have been accounted for in here
      // from the main vector so we don't go over them again.
      std::for_each(temp.begin(), temp.end(), [&](const int ele) {
        for (auto iter = vec_0_to_1.begin(); iter != vec_0_to_1.end();) {
          if ((*iter) == ele) {
            iter = vec_0_to_1.erase(iter);
          } else {
            iter++;
          }
        }
      });
    } else {
      *is_weak_suspect = true;
    }
  }
}

void diag_classify_suspicion(
    const pkt_id_type &pkt_id,
    bool *is_weak_suspect_for_setup,
    bool *is_weak_suspect_for_hold,
    bool *is_strong_suspect_for_hold,
    std::vector<std::vector<uint32_t>> *ss_hold_bit_flips_index_vec) {
  // Get the pkt data for the pkt_id
  auto &pkt_wrapper = g_pkt_database.at(pkt_id);

  // Classify suspicion level for setup
  diag_classify_suspicion_for_setup(pkt_id, is_weak_suspect_for_setup);

  // Clasify suspicion level for hold
  diag_classify_suspicion_for_hold(pkt_id,
                                   is_weak_suspect_for_hold,
                                   is_strong_suspect_for_hold,
                                   ss_hold_bit_flips_index_vec);

  // SS_Hold takes precedence over S_Hold
  if (*is_strong_suspect_for_hold) {
    *is_weak_suspect_for_hold = false;
  }
}

void diag_get_overall_pkt_failure_type(const pkt_id_type &pkt_id,
                                       const bool &is_weak_suspect_for_setup,
                                       const bool &is_strong_suspect_for_setup,
                                       const bool &is_weak_suspect_for_hold,
                                       const bool &is_strong_suspect_for_hold,
                                       const bool &is_payload_setup,
                                       diag_slt_failure_type_e *failure_type,
                                       std::string *failure_name) {
  if (/* Condition that needs to be true */ is_weak_suspect_for_setup &&
      !(/* Conditions that need to be false */ is_strong_suspect_for_setup ||
        is_weak_suspect_for_hold || is_strong_suspect_for_hold ||
        is_payload_setup)) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_S_SETUP;
    *failure_name = ""S_Setup"";
  } else if (is_strong_suspect_for_setup &&
             !(is_weak_suspect_for_hold || is_strong_suspect_for_hold ||
               is_payload_setup)) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_SS_SETUP;
    *failure_name = ""SS_Setup"";
  } else if (is_weak_suspect_for_hold &&
             !(is_weak_suspect_for_setup || is_strong_suspect_for_setup ||
               is_strong_suspect_for_hold || is_payload_setup)) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_S_HOLD;
    *failure_name = ""S_Hold"";
  } else if (is_strong_suspect_for_hold &&
             !(is_weak_suspect_for_setup || is_strong_suspect_for_setup ||
               is_payload_setup)) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_SS_HOLD;
    *failure_name = ""SS_Hold"";
  } else if (is_payload_setup &&
             !(is_weak_suspect_for_setup || is_strong_suspect_for_setup ||
               is_weak_suspect_for_hold || is_strong_suspect_for_hold)) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_PAYLOAD_SETUP;
    *failure_name = ""Payload_Setup"";
  } else if ((is_weak_suspect_for_setup || is_strong_suspect_for_setup) &&
             (is_weak_suspect_for_hold || is_strong_suspect_for_hold) &&
             is_payload_setup) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_MIXED;
    *failure_name = ""Mixed ("";
    *failure_name += is_weak_suspect_for_setup ? ""S_Setup + "" : ""SS_Setup + "";
    *failure_name += is_weak_suspect_for_hold ? ""S_Hold + "" : ""SS_Hold + "";
    *failure_name += ""Payload_Setup)"";
  } else if ((is_weak_suspect_for_setup || is_strong_suspect_for_setup) &&
             is_payload_setup) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_MIXED;
    *failure_name = ""Mixed ("";
    *failure_name += is_weak_suspect_for_setup ? ""S_Setup + "" : ""SS_Setup + "";
    *failure_name += ""Payload_Setup)"";
  } else if ((is_weak_suspect_for_hold || is_strong_suspect_for_hold) &&
             is_payload_setup) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_MIXED;
    *failure_name = ""Mixed ("";
    *failure_name += is_weak_suspect_for_hold ? ""S_Hold + "" : ""SS_Hold + "";
    *failure_name += ""Payload_Setup)"";
  } else if ((is_weak_suspect_for_setup || is_strong_suspect_for_setup) &&
             (is_weak_suspect_for_hold || is_strong_suspect_for_hold)) {
    *failure_type = DIAG_SLT_FAILURE_TYPE_MIXED;
    *failure_name = ""Mixed ("";
    *failure_name += is_weak_suspect_for_setup ? ""S_Setup + "" : ""SS_Setup + "";
    *failure_name += is_weak_suspect_for_hold ? ""S_Hold"" : ""SS_Hold"";
    *failure_name += "")"";
  } else {
    *failure_type = DIAG_SLT_FAILURE_TYPE_NO_FAILURE;
    *failure_name += ""No Corruptions"";
  }
}

void diag_print_pkt_classification_summary(const pkt_id_type &pkt_id,
                                           const bf_diag_sess_hdl_t &sess_hdl,
                                           const bf_dev_port_t &dev_port,
                                           const uint32_t &size,
                                           const std::string &failure_name,
                                           const uint64_t &num_bytes_mismatch,
                                           const uint64_t &num_bits_mismatch) {
  DIAG_PRINT(
      ""pkt_id %8lx : Summary : Session : %d : Port : %-3d : Pkt ""
      ""size : %d\n"",
      pkt_id,
      sess_hdl,
      dev_port,
      size);
  DIAG_PRINT(""pkt_id %8lx : Suspected for               : %s\n"",
             pkt_id,
             failure_name.c_str());
  DIAG_PRINT(""pkt_id %8lx : Total bytes that mismatched : %-4lu\n"",
             pkt_id,
             num_bytes_mismatch);
  DIAG_PRINT(""pkt_id %8lx : Total bits that mismatched  : %-5lu\n"",
             pkt_id,
             num_bits_mismatch);
}

}  // anonymous namespace

// Add a pkt to the central database
int diag_add_pkt_to_db(const pkt_id_type pkt_id,
                       const uint32_t pkt_size,
                       const uint8_t *pkt_buf) {
  std::lock_guard<std::mutex> lock(mtx);

  // pkt_id should not be present in the map. Assert otherwise
  if (g_pkt_database.find(pkt_id) != g_pkt_database.end()) {
    DIAG_PRINT(""Pkt id %lx already present in the map\n"", pkt_id);
    DIAG_ASSERT(0);
  }

  bf_diag_sess_hdl_t hdl;
  bf_dev_port_t port;
  diag_decode_sess_port_from_pkt_id(pkt_id, &hdl, &port);
  PktWrapper *pkt_wrapper = new PktWrapper(pkt_size, hdl, port);
  if (pkt_wrapper == nullptr) {
    DIAG_PRINT(
        ""Malloc failed for pkt_id %lx sess %x port %d \n"", pkt_id, hdl, port);
    return -1;
  }
  memcpy(pkt_wrapper->pkt, pkt_buf, pkt_size);
  std::unique_ptr<PktWrapper> ptr(pkt_wrapper);
  g_pkt_database[pkt_id] = std::move(ptr);

  return 0;
}

// Retrieve pkt from the central database
int diag_get_pkt_from_db(const pkt_id_type pkt_id,
                         const uint32_t pkt_size,
                         uint32_t *cached_pkt_size,
                         uint8_t *pkt_buf) {
  std::lock_guard<std::mutex> lock(mtx);

  // Get the pkt data corresponding to the pkt_id
  if (g_pkt_database.find(pkt_id) == g_pkt_database.end()) {
    DIAG_PRINT(""Pkt id %lx not present in the map\n"", pkt_id);
    return -1;
  }

  const auto &pkt_wrapper = g_pkt_database.at(pkt_id);
  *cached_pkt_size = pkt_wrapper.get()->pkt_size;
#if !defined(DIAG_PATTERN_SHIFT_ENABLE) && !defined(DIAG_PHV_FLOP_CONFIG_3)
  // Have the below check only in cases when DIAG_PATTERN_SHIFT_ENABLE is
  // turned off as in this mode, the dataplane adds upto 31 bytes to
  // to the packet after the payload of 240 bytes.
  if (*cached_pkt_size != pkt_size) {
    DIAG_PRINT(
        ""Pkt size (%d) decoded for pkt_id %lx not matching up with the pkt ""
        ""size (%d) passed in the params\n"",
        *cached_pkt_size,
        pkt_id,
        pkt_size);
    return -1;
  }
#endif  // DIAG_PATTERN_SHIFT_ENABLE
  const auto decoded_pkt_raw_data = pkt_wrapper.get()->pkt;
  memcpy(pkt_buf, decoded_pkt_raw_data, pkt_size);

  return 0;
}

// Encode pkt_id at the tail of the packet
pkt_id_type diag_encode_pkt_id(const bf_diag_sess_hdl_t sess_hdl,
                               const bf_dev_port_t dev_port,
                               const uint32_t pkt_size,
                               uint8_t *pkt_buf) {
  std::lock_guard<std::mutex> lock(mtx);

  // We are going to encode the same pkt_id consecutive locations in the
  // payload
  uint8_t total_bytes_req = DIAG_PKT_ID_ENCODE_SIZE;
  if ((pkt_size - DIAG_PKT_HEADER_SIZE) < total_bytes_req) {
    DIAG_PRINT(""Pkt size (%d) not sufficient to encode pkt_id \n"", pkt_size);
    return PKT_DATABASE_ERR;
  }

  auto encoded_pkt_id = g_pkt_id;

  // Encode the sess hdl and port in the pkt_id
  diag_encode_sess_port_in_pkt_id(sess_hdl, dev_port, &encoded_pkt_id);

  // We start from the tail of the packet and encode consecutive copies of the
  // pkt_id
  int diag_min_size_off = DIAG_MIN_PKT_SIZE_ENABLED ? 2 : 0;
  for (int i = 0; i < DIAG_PKT_ID_REPLICATION_FACTOR; i++) {
    uint8_t *ptr_1 =
        &pkt_buf[pkt_size -
                 ((i + 1) * (sizeof(pkt_id_type) - diag_min_size_off))];
    uint8_t *ptr_2 = (uint8_t *)&encoded_pkt_id;
    // FIXME need to handle endianness properly
    for (int j = 0; j < (sizeof(pkt_id_type) - diag_min_size_off); j++) {
      ptr_1[j] = ptr_2[j];
    }
  }

  // Increment the pkt_id before exiting
  g_pkt_id++;

  return encoded_pkt_id;
}

// Decode pkt_id, sess_hdl, and dev_port from the tail of the packet
pkt_id_type diag_decode_pkt_id(const uint32_t pkt_size,
                               const uint8_t *pkt_buf,
                               pkt_id_type *pkt_id,
                               bf_diag_sess_hdl_t *sess_hdl,
                               bf_dev_port_t *dev_port) {
  std::lock_guard<std::mutex> lock(mtx);

  uint8_t total_bytes_req = DIAG_PKT_ID_ENCODE_SIZE;
  if ((pkt_size - DIAG_PKT_HEADER_SIZE) < total_bytes_req) {
    // DIAG_PRINT(""Pkt size (%d) not sufficient to decode pkt_id\n"", pkt_size);
    *pkt_id = PKT_DATABASE_ERR;
    return PKT_DATABASE_ERR;
  }

  // We start from the tail of the packet and decode consecutive copies of the
  // pkt_id
  pkt_id_type pkt_id_arr[PKT_ID_REPLICATION_FACTOR_DEF] = {0};
  int diag_min_size_off = DIAG_MIN_PKT_SIZE_ENABLED ? 2 : 0;
  for (int i = 0; i < DIAG_PKT_ID_REPLICATION_FACTOR; i++) {
    const uint8_t *ptr_1 =
        &pkt_buf[pkt_size -
                 ((i + 1) * (sizeof(pkt_id_type) - diag_min_size_off))];
    uint8_t *ptr_2 = (uint8_t *)&pkt_id_arr[i];
    // FIXME need to handle endianness properly
    for (int j = 0; j < (sizeof(pkt_id_type) - diag_min_size_off); j++) {
      ptr_2[j] = ptr_1[j];
    }
  }

  for (int i = 0; i < (DIAG_PKT_ID_REPLICATION_FACTOR - 1); i++) {
    if (pkt_id_arr[i] != pkt_id_arr[i + 1]) {
#if 0
      DIAG_PRINT(
          ""Mismatch in decoded pkt_ids (%d:%lx %d:%lx) from the payload\n"",
          i,
          pkt_id_arr[i],
          i + 1,
          pkt_id_arr[i + 1]);
#endif
      *pkt_id = PKT_DATABASE_ERR;
      return PKT_DATABASE_ERR;
    }
  }

  *pkt_id = pkt_id_arr[0];
  diag_decode_sess_port_from_pkt_id(*pkt_id, sess_hdl, dev_port);

  return 0;
}

// Cleanup the pkt database
void diag_cleanup_pkt_database(const bf_diag_sess_hdl_t sess_hdl) {
  std::lock_guard<std::mutex> lock(mtx);

  DIAG_PRINT(""Cleaning up pkt database for session %d\n"", sess_hdl);

  // Go through the entire map and remove all packets which belong to this
  // particular session
  for (auto item = g_pkt_database.begin(); item != g_pkt_database.end();) {
    pkt_id_type pkt_id = item->first;
    bf_diag_sess_hdl_t decoded_sess_hdl;
    bf_dev_port_t dev_port;
    diag_decode_sess_port_from_pkt_id(pkt_id, &decoded_sess_hdl, &dev_port);
    if (sess_hdl == decoded_sess_hdl) {
      item = g_pkt_database.erase(item);
    } else {
      item++;
    }
  }
}

/* Compare received pkt with the replica in the database */
bf_status_t diag_compare_pkt_with_database(
    const uint32_t size,
    const uint8_t *received_pkt,
    const pkt_id_type pkt_id,
    const bf_diag_sess_hdl_t sess_hdl,
    const bf_dev_port_t  [MASK] ,
    uint8_t *exp_bytes,
    uint32_t *cached_pkt_size,
    uint64_t *num_bytes_mismatch,
    uint64_t *num_bits_mismatch,
    uint64_t *num_1_to_0_flips,
    uint64_t *num_0_to_1_flips,
    diag_slt_failure_type_e *failure_type) {
  uint32_t i = 0, j = 0;
  *num_bytes_mismatch = 0;
  *num_bits_mismatch = 0;
  *num_1_to_0_flips = 0;
  *num_0_to_1_flips = 0;
  *cached_pkt_size = 0;
  uint8_t bits_mismatch = 0;
  uint32_t num_bytes_added_by_dataplane = 0;
  uint8_t flips_1_to_0 = 0;
  uint8_t flips_0_to_1 = 0;
  bool is_1_to_0_flip = false;
  int max_print_per_packet = 0;
  bool is_suspect_for_setup = false;
  bool is_strong_suspect_for_setup = false;
  bool is_suspect_for_hold = false;
  bool is_suspect_for_unknown = false;
  bool is_suspect_for_setup_payload = false;

  bool pkt_is_payload_setup = false;
  bool pkt_is_strong_suspect_for_setup = false;

  // Lets be optimistic and set the failure_type to none
  *failure_type = DIAG_SLT_FAILURE_TYPE_NO_FAILURE;

  // Create a copy of the received packet
  uint8_t buf[DIAG_MAX_PKT_SIZE];
  memset(buf, 0, sizeof(buf));
  memcpy(buf, received_pkt, size);

  /* Retrieve the cached pkt from the pkt_id */
  if (diag_get_pkt_from_db(pkt_id, size, cached_pkt_size, exp_bytes) != 0) {
    DIAG_PRINT(
        "">>>>>>>>> Unable to retrieve pkt for pkt_id %lx from the ""
        ""database ""
        ""<<<<<<<<<\n"",
        pkt_id);
    return BF_UNEXPECTED;
  }

  // Safety check
  // Recieved pkt size can be larger than cached pkt size if we are in
  // DIAG_PATTERN_SHIFT_ENABLE  mode. For all other cases, it will be
  // equal.
  if (size < *cached_pkt_size) {
    DIAG_PRINT(
        "">>>>>>>>> Received pkt size (%d) is smaller than the sent ""
        ""one (%d) ""
        ""<<<<<<<<<\n"",
        size,
        *cached_pkt_size);
    return BF_UNEXPECTED;
  }

#if defined(DIAG_PATTERN_SHIFT_ENABLE) || defined(DIAG_PHV_FLOP_CONFIG_3)
  // In this mode, the dataplane would have added (size-cached_pkt_size)
  // number of bytes in the packet after the header of 240 Bytes. To keep
  // rest of the comparison algo the same, lets overwrite the bytes added
  // by the dataplane with the bytes which were there in the packet from
  // from the beginning.
  int start_of_payload = 0;
#if defined(DIAG_PATTERN_SHIFT_ENABLE)
  start_of_payload = 240;
#elif defined(DIAG_PHV_FLOP_CONFIG_3)
  start_of_payload = 125;
#endif
  if (size > *cached_pkt_size) {
    num_bytes_added_by_dataplane = size - *cached_pkt_size;
    for (i = start_of_payload; i < *cached_pkt_size; i++) {
      buf[i] = buf[i + num_bytes_added_by_dataplane];
    }
  }
#endif  // DIAG_PATTERN_SHIFT_ENABLE

  max_print_per_packet = 0;
  /* Compare the cached packet with the received packet */
  for (i = 0; i < *cached_pkt_size; i++) {
#if !defined(DIAG_PHV_STRESS_ENABLE) && !defined(DIAG_PHV_FLOP_TEST)
    if ((i == DIAG_TCP_SRC_PORT_BYTE) || (i == DIAG_TCP_SRC_PORT_BYTE + 1)) {
      /* Don't compare these bytes because the dataplane would have filled
         in these values */
      continue;
    } else {
      break;
    }
#endif
    if (exp_bytes[i] != buf[i]) {
      (*num_bytes_mismatch)++;

      bits_mismatch = 0;
      flips_1_to_0 = 0;
      flips_0_to_1 = 0;
      // Now there can be multiple flips in a byte
      for (j = 0; j < 8; j++) {
        is_1_to_0_flip = false;
        is_suspect_for_setup = false;
        is_strong_suspect_for_setup = false;
        is_suspect_for_hold = false;
        is_suspect_for_setup_payload = false;
        if (((buf[i] >> j) & 0x01) != ((exp_bytes[i] >> j) & 0x01)) {
          bits_mismatch++;
          if (((buf[i] >> j) & 0x01) == 0) {
            flips_1_to_0++;
            is_1_to_0_flip = true;
            // For this to be a suspect for setup issue, this byte needs to be
            // within the header
            if (i < diag_get_header_size()) {
              // if the bit that flipped is bit 1, then this is a strong suspect
              // for setup
              if (j == 1) {
                is_strong_suspect_for_setup = true;
                is_suspect_for_setup = false;
                pkt_is_strong_suspect_for_setup = true;
              } else {
                is_suspect_for_setup = true;
                is_strong_suspect_for_setup = false;
              }
            } else {
              is_suspect_for_setup_payload = true;
              pkt_is_payload_setup = true;
            }
          } else {
            is_1_to_0_flip = false;
            flips_0_to_1++;
            // Hold issue can occur in the header as well as the payload. So
            // mark it as a suspect for hold always
            is_suspect_for_hold = true;
          }
          DIAG_PRINT(
              ""BIT_FLIP pkt_id %8lx : Exp Byte: 0x%-2x : Rcv Byte: 0x%-2x : ""
              ""Byte Offset: %-4d : Bit Offset: %-1d : %-4s : %-9s\n"",
              pkt_id,
              exp_bytes[i],
              buf[i],
              i,
              j,
              is_1_to_0_flip ? ""1->0"" : ""0->1"",
              is_suspect_for_setup
                  ? ""S_Setup""
                  : is_strong_suspect_for_setup
                        ? ""SS_Setup""
                        : is_suspect_for_hold
                              ? ""S_Hold""
                              : is_suspect_for_setup_payload ? ""Payload_Setup""
                                                             : ""Unknown"");
        }
      }
      (*num_bits_mismatch) = (*num_bits_mismatch) + bits_mismatch;
      (*num_1_to_0_flips) = (*num_1_to_0_flips) + (flips_1_to_0);
      (*num_0_to_1_flips) = (*num_0_to_1_flips) + (flips_0_to_1);
      // If (1->0 flips + 0->1 flips) is greater than 1, that that indicaes
      // that the byte suffered from multibit corruption.
      if ((flips_1_to_0 + flips_0_to_1) > 1) {
        // Before we proceed with doing any analytics on this byte/packet
        // make sure that the byte does not have any multibit corruptions
        // If there are multiple bit corruptions within a byte, then the
        // overall failure type of the packet is unknown
        *failure_type = DIAG_SLT_FAILURE_TYPE_UNKNOWN;
      } else {
        // We try to classify the packets only if the failure mode is known
        // Log the bit flips details so that we can categorize this pkt later
        diag_log_bit_flip_in_pkt(pkt_id, i, flips_1_to_0 == 1);
      }
    }
  }

  if (*failure_type == DIAG_SLT_FAILURE_TYPE_UNKNOWN) {
    diag_print_pkt_classification_summary(pkt_id,
                                          sess_hdl,
                                           [MASK] ,
                                          size + DIAG_PKT_CRC_HEADER_SIZE,
                                          ""Unknown"",
                                          *num_bytes_mismatch,
                                          *num_bits_mismatch);
    return BF_UNEXPECTED;
  }

  if (*num_bytes_mismatch) {
    // Finally see if the packet can be categorized as a strong suspect for
    // setup
    // or hold issue
    bool is_weak_suspect_for_setup = false;
    bool is_strong_suspect_for_setup = false;
    bool is_weak_suspect_for_hold = false;
    bool is_strong_suspect_for_hold = false;
    std::vector<std::vector<uint32_t>> hold_bit_flips_vec;
    diag_classify_suspicion(pkt_id,
                            &is_weak_suspect_for_setup,
                            &is_weak_suspect_for_hold,
                            &is_strong_suspect_for_hold,
                            &hold_bit_flips_vec);

    // Check if any byte in the packet was classified as a strong suspect for
    // for setup. If yes, then is_weak_suspect_for_setup needs to be false
    if (pkt_is_strong_suspect_for_setup) {
      is_strong_suspect_for_setup = true;
      is_weak_suspect_for_setup = false;
    }

    // Sanity check. hold_bit_flips_vec should be non-empty only if the packet
    // is a strong suspect for hold. Else we have messed up the classification
    // logic
    if ((!is_strong_suspect_for_hold && hold_bit_flips_vec.size()) ||
        (is_strong_suspect_for_hold && (!hold_bit_flips_vec.size()))) {
      DIAG_PRINT(
          ""BIT_FLIP pkt_id %8lx : Strong hold suspicion logic messed up : ""
          ""strong_suspect (%d) bit_flip_vec size (%lu). Asserting\n"",
          pkt_id,
          is_strong_suspect_for_hold,
          hold_bit_flips_vec.size());
      DIAG_ASSERT(0);
    }

    // Determine the final failure type for the packet
    std::string failure_name;
    diag_get_overall_pkt_failure_type(pkt_id,
                                      is_weak_suspect_for_setup,
                                      is_strong_suspect_for_setup,
                                      is_weak_suspect_for_hold,
                                      is_strong_suspect_for_hold,
                                      pkt_is_payload_setup,
                                      failure_type,
                                      &failure_name);

    diag_print_pkt_classification_summary(pkt_id,
                                          sess_hdl,
                                           [MASK] ,
                                          size + DIAG_PKT_CRC_HEADER_SIZE,
                                          failure_name,
                                          *num_bytes_mismatch,
                                          *num_bits_mismatch);

    if (is_strong_suspect_for_hold) {
      DIAG_PRINT(
          ""BIT_FLIP pkt_id %8lx : 80 byte boundary failures found in the ""
          ""following bytes (<byte_offset:exp_byte:recv_byte>):\n"",
          pkt_id);
      std::for_each(
          hold_bit_flips_vec.begin(),
          hold_bit_flips_vec.end(),
          [&](const std::vector<uint32_t> vec) {
            DIAG_PRINT(""BIT_FLIP pkt_id %8lx : "", pkt_id);
            for (auto iter = vec.begin(); iter != vec.end(); iter++) {
              DIAG_PRINT(
                  ""<%-4d:%-2x:%-2x> "", *iter, exp_bytes[*iter], buf[*iter]);
            }
            DIAG_PRINT(""\n"");
          });
    }
    return BF_UNEXPECTED;
  } else {
    // No bit flips in the packet
    *failure_type = DIAG_SLT_FAILURE_TYPE_NO_FAILURE;
  }

  // Keep the compiler happy
  (void)num_bytes_added_by_dataplane;
  return BF_SUCCESS;
}

//} // namespace diag
",ingress_port
645,"// Chromosome.cpp.haplotyped markers for a chromosome

#include ""Chromosome.h""
#include <iostream>
using namespace std;


// Chromosome(): default constructor
Chromosome::Chromosome()
{}

MarkerSet * Chromosome::getMarkerSet()
{
	return chromosome[position_ms];
}

MarkerSet * Chromosome::getMarkerSet(unsigned int pos)
{
	return chromosome[pos];
}

void Chromosome::clear()
{
	for ( size_t i = 0 ; i < chromosome.size() ; i++ ) { delete chromosome[i]; }
	chromosome.clear();
}

// addMarkerSet(): adds a MarkerSet
void Chromosome::addMarkerSet(MarkerSet * ms)
{
	chromosome.push_back(ms);
}

void Chromosome::print_snps(ostream& out, unsigned int start, unsigned int end)
{
	unsigned int p_ms = position_ms;

	unsigned int ms_start = start / MARKER_SET_SIZE;
	unsigned int  [MASK]  = end / MARKER_SET_SIZE;
	if( start % MARKER_SET_SIZE != 0 ) { position_ms = ms_start; chromosome[ms_start++]->print(out,start % MARKER_SET_SIZE,MARKER_SET_SIZE); out << ' '; }
	print(out,ms_start, [MASK] );
	if( end % MARKER_SET_SIZE != 0 ) { out << ' '; chromosome[ [MASK] ]->print(out,0,end % MARKER_SET_SIZE); }

	position_ms = p_ms;
}

void Chromosome::print(ostream& out,unsigned int start,unsigned int end)
{
	for(position_ms=start;position_ms<end;position_ms++) 
	{
		if( position_ms > start ) out << ' ';
		chromosome[position_ms]->print(out);
	}
}

ostream& operator<<(ostream &fout, Chromosome& c)
{
	fout << c.getMarkerSet();
	return fout;
}

// end Chromosome.cpp
",ms_end
646,"#include <unistd.h>
#include ""UserThread.h""
//#include <stdio.h>

void userThread_Resume(ThreadScheduler &schedule , int id)
{
    if(id < 0 || id >= schedule.max_index){
        return;
    }//judge max_index

    UserThread *t = &(schedule.threads[id]);

    if (t->state == READY ) {
        t->state = RUNNING ;//set running
        schedule.running_thread  = id ;

        swapcontext(&(schedule.main),&(t->ctx));
    }//run the thread
}

void userThread_Yield(ThreadScheduler &schedule,ThreadState state )
{
    //schedule.showThreadInfo();
    if(schedule.running_thread != -1 ){
        UserThread *t = &(schedule.threads[schedule.running_thread]);
        t->state = state;
        schedule.running_thread = -1;
        swapcontext(&(t->ctx),&(schedule.main));
        puts(""main"");
    }
}

void userThread_Body(ThreadScheduler *ps)
{
    int id = ps->running_thread;

    if(id != -1){
        UserThread *t = &(ps->threads[id]);

        t->func(t->arg);

        t->state = FREE;

        ps->running_thread = -1;
    }
}

int userThread_Create(ThreadScheduler &schedule,Function func,void *arg,int priority )
{

    int id = 0;

    for(id = 0; id < schedule.max_index; ++id ){
        if(schedule.threads[id].state == FREE){
            break;
        }
    }
    if (id == schedule.max_index) schedule.max_index++;
    UserThread *t = &(schedule.threads[id]);
    t->ID = id ;//1.thread id
    t->priority = priority ; //2.priority
    t->PID = getpid() ;//3.PID
    std::time_t now = std::time(nullptr);
    std::tm* local_time = std::localtime(&now);//4.get time
    t->create_second = now;
    t->create_time = local_time ;
    t->func = func;
    t->arg = arg;
    t->state = READY;
    getcontext(&(t->ctx));
    t->ctx.uc_stack.ss_sp = t->stack;
    t->ctx.uc_stack.ss_size = DEFAULT_STACK_SZIE;
    t->ctx.uc_stack.ss_flags = 0;
    t->ctx.uc_link = &(schedule.main);
    //schedule.running_thread = id;
    makecontext(&(t->ctx),(void (*)(void))(userThread_Body),1,&schedule);
    //std::cout<<""thread create finished the info is as follows:""<<std::endl;
    //t->helpShowThreadInfo();
    //swapcontext(&(schedule.main), &(t->ctx));
    return id;
}

int schedule_Finished(const ThreadScheduler &schedule)
{
    if (schedule.running_thread != -1){
        return 0;
    }else{
        for(int i = 0; i < schedule.max_index; ++i){
            if(schedule.threads[i].state != FREE){
                return 0;
            }
        }
    }

    return 1;
}
void RR(ThreadScheduler &schedule,int  [MASK]  ){

    while(!schedule_Finished(schedule)){
        for (int j = 0; j < schedule.max_index; j++) {
            std::clock_t clock_start = std::clock();
            while (schedule.threads[j].state == READY) {
                userThread_Resume(schedule, j);
                //schedule.showThreadInfo();
                std::clock_t clock_end = std::clock();
                std::cout<<""gap""<<(clock_end - clock_start)<< std::endl;
                if (clock_end - clock_start >  [MASK] ) {puts(""break"");break;}
            }
        }
    }
}
void PriorityS(ThreadScheduler &schedule){
    std::priority_queue<UserThread,std::vector<UserThread>,uthreadCMPPS> pq;//1.put data into priorityqueue
    for (int j = 0; j < schedule.max_index; j++) {

        if (schedule.threads[j].state == READY) {
            pq.push(schedule.threads[j]);

        }
    }
    while(!pq.empty())
    {
        UserThread  tmp= pq.top();
        int id = tmp.ID ;
        pq.pop();
        while(schedule.threads[id].state!=FREE) {
            userThread_Resume(schedule, id);
        }
    }
}
void FIFO(ThreadScheduler &schedule) {
    std::priority_queue<UserThread, std::vector<UserThread>, uthreadCMPPS2> pq;//1.put data into priorityqueue//1.put data into priorityqueue


    for (int j = 0; j < schedule.max_index; j++) {

        if (schedule.threads[j].state == READY) {
            pq.push(schedule.threads[j]);

        }
    }
    while (!pq.empty()) {
        UserThread tmp = pq.top();
        int id = tmp.ID;
        pq.pop();
        while (schedule.threads[id].state != FREE) {
            userThread_Resume(schedule, id);
        }
    }
}
",gaptime
647,"#include ""ConsoleView.h""

ConsoleView::ConsoleView(Model *model) : View(model)
{
    _chipsMap[NONE] = ""."";
    _chipsMap[BLACK] = ""x"";
    _chipsMap[RED] = ""o"";
}

void ConsoleView::update(GameState state)
{
    paintField();

    if (state == CONTINUES)
    {
        std::cout << ""next turn"" << std::endl;
    }
    else if (state == WIN)
    {
        std::cout << ""first player win"" << std::endl;
    }
    else if (state == LOSE)
    {
        std::cout << ""second player win"" << std::endl;
    }
    else if (state == DRAW)
    {
        std::cout << ""draw"" << std::endl;
    }
    else
    {
        throw std::runtime_error(""incorrect game state"");
    }
}

void ConsoleView::paintField()
{
    std::vector<std::vector<Chip>>  [MASK]  = _model->getGameField();

    for (int i = _model->getHeight() - 1; i >= 0; --i)
    {
        for (int j = 0; j < _model->getWidth(); ++j)
        {
            std::cout << _chipsMap.at( [MASK] .at(i).at(j)) << "" "";
        }
        std::cout << std::endl;
    }

    for (int i = 0; i < 7; ++i)
        std::cout << i << "" "";
    std::cout << std::endl << std::endl;
}
",field
648,"#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>

static void error_callback(int error, const char* description)
{
    fputs(description, stderr);
}

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
    {
        glfwSetWindowShouldClose(window, GL_TRUE);
    }
}




static unsigned int compileShader(unsigned int type, const std::string& source)
{
  unsigned int id = glCreateShader(type);
  const char* src = source.c_str();
  glShaderSource(id, 1, &src, nullptr);
  glCompileShader(id);

  // TODO: Error Handling
  int result = 0;
  glGetShaderiv(id, GL_COMPILE_STATUS, &result);
  if (result == GL_FALSE)
  {
    int length = 0;
    glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
    char* message = (char*)alloca(length * sizeof(char));
    glGetShaderInfoLog(id, length, &length, message);
    std::cout << ""Failed to compile shader!"" << (type == GL_VERTEX_SHADER ? ""vertex"" : ""fragment"") << std::endl;
    std::cout << message << std::endl;
    glDeleteShader(id);
    return 0;

  }

  return id;
}


static int CreateShader(const std::string& vertexShader, const std::string& fragmentShader)
{
  unsigned int program = glCreateProgram();
  unsigned int vs = compileShader ( GL_VERTEX_SHADER, vertexShader );
  unsigned int fs = compileShader ( GL_FRAGMENT_SHADER, fragmentShader );

  glAttachShader ( program, vs );
  glAttachShader ( program, fs );
  glLinkProgram ( program );
  glValidateProgram ( program );

  glDeleteShader ( vs );
  glDeleteShader ( fs );

  return program;
}

int main(void) {
    GLFWwindow* window;
    glfwSetErrorCallback(error_callback);

    if (!glfwInit()) {
        exit(EXIT_FAILURE);
    }

    window = glfwCreateWindow(640, 480, ""Simple example"", NULL, NULL);

    if (!window) {
        glfwTerminate();
        exit(EXIT_FAILURE);
    }

    glfwMakeContextCurrent(window);

    // in documentation it is stated that glewInit must come after glfwMakeContextCurrent in order for GLEW to work
    if (glewInit() != GLEW_OK) {
      std::cout << ""Error, glewInit is being weird"" << std::endl;
    }

    std::cout << glGetString(GL_VERSION) << std::endl;

    glfwSetKeyCallback(window, key_callback);



    //
    unsigned int  [MASK] ;
    glGenBuffers(1, & [MASK] );
    glBindBuffer(GL_ARRAY_BUFFER,  [MASK] );

    float positions[6] = {
      -0.5f, -0.5f,
       0.0f,  0.5f,
       0.5f, -0.5f
    };

    glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), positions, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
    glEnableVertexAttribArray(0);


    std::string vertexShader =
      ""#version 330 core\n""
      ""\n""
      ""layout(location = 0) in vec4 position;""
      ""\n""
      ""void main()""
      ""{\n""
      ""   gl_Position = position;\n""
      ""}\n"";

    std::string fragmentShader =
      ""#version 330 core\n""
      ""\n""
      ""layout(location = 0) out vec4 color;""
      ""\n""
      ""void main()""
      ""{\n""
      ""   color = vec4(1.0, 0.0, 0.0, 1.0);\n""
      ""}\n"";

    unsigned int shader = CreateShader(vertexShader, fragmentShader);
    glUseProgram(shader);




    while (!glfwWindowShouldClose(window)) {
      /*
        float ratio;
        int width, height;
        glfwGetFramebufferSize(window, &width, &height);
        ratio = width / (float) height;
        glViewport(0, 0, width, height);
        glClear(GL_COLOR_BUFFER_BIT);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(-ratio, ratio, -1.f, 1.f, 1.f, -1.f);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glRotatef((float) glfwGetTime() * 50.f, 0.f, 0.f, 1.f);
        glBegin(GL_TRIANGLES);
        glColor3f(1.f, 0.f, 0.f);
        glVertex3f(-0.6f, -0.4f, 0.f);
        glColor3f(0.f, 1.f, 0.f);
        glVertex3f(0.6f, -0.4f, 0.f);
        glColor3f(0.f, 0.f, 1.f);
        glVertex3f(0.f, 0.6f, 0.f);
        glEnd();
        glfwSwapBuffers(window);
        glfwPollEvents();
        */


        glClear(GL_COLOR_BUFFER_BIT);
        glDrawArrays( GL_TRIANGLES, 0, 3);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glDeleteShader(shader);
    glfwDestroyWindow(window);
    glfwTerminate();
    exit(EXIT_SUCCESS);
}
",buff1
649,"module;

#include <filesystem>
#include <format>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <string>
#include <string_view>
#include <thirdparty/libgit2/include/git2.h>
#include <unordered_map>

export module gitkf:git_repository;
import :client_exception;
import :git_smart_pointer;
import :ring_buffer;
import :string_utils;

export struct GitRef {
    std::string name {};
    std::string id {};
    bool isTag {};
    bool isBranch {};
    bool isRemote {};
};

export template <size_t N>
std::string GitHashToString(const unsigned char (&hash)[N])
{
    static const char kHex[] = ""0123456789abcdef"";
    std::string res(40, '\0');
    auto* pData = res.data();
    for (auto ch : hash) {
        *pData++ = kHex[ch >> 4];
        *pData++ = kHex[ch & 0xf];
    }
    return res;
}

export class GitRepository {
public:
    explicit GitRepository(const std::string& repoPath)
    {
        git_buf buf {};
        std::unique_ptr<git_buf>  [MASK]  { &buf };
        if (git_repository_discover( [MASK] .get(), repoPath.c_str(), /*across_fs=*/false, /*ceiling_dirs=*/nullptr)) {
            throw ClientException(404, std::format(""Git repo is not found under '{}'."", repoPath));
        }

        m_repoPath =  [MASK] ->ptr;
        if (git_repository_open(std::out_ptr(m_pRepo),  [MASK] ->ptr)) {
            throw std::runtime_error { std::format(""Open git repo '{}' failed."", m_repoPath) };
        }
        while (m_repoPath.ends_with('/')) {
            m_repoPath.pop_back();
        }

        // Remove "".git"" part.
        m_workDir = std::filesystem::path { m_repoPath }.parent_path().string();
    }

    git_repository* Get() const { return m_pRepo.get(); }
    git_repository* GetRepo() const { return m_pRepo.get(); }
    const std::string& GetRepoRoot() const { return m_repoPath; }
    const std::string& GetRepoWorkDir() const { return m_workDir; }

    std::unordered_multimap<std::string, GitRef> GetRefs()
    {
        std::unordered_multimap<std::string, GitRef> refs {};
        auto payload = std::make_pair(&refs, m_pRepo.get());
        git_reference_foreach(
            m_pRepo.get(),
            [](git_reference* pReference, void* payload) {
                auto pPair = (std::pair<std::unordered_multimap<std::string, GitRef>*, git_repository*>*)payload;
                auto* pRefs = pPair->first;
                auto* pRepo = pPair->second;
                auto name = git_reference_name(pReference);
                git_oid oid {};
                git_reference_name_to_id(&oid, pRepo, name);
                auto id = GitHashToString(oid.id);
                GitRef ref {};
                ref.name = TrimLeft(name, { ""refs/heads/"", ""refs/remotes/"", ""refs/tags/"" });
                ref.id = id;
                ref.isTag = git_reference_is_tag(pReference);
                ref.isBranch = git_reference_is_branch(pReference);
                ref.isRemote = git_reference_is_remote(pReference);
                pRefs->emplace(std::move(id), std::move(ref));
                git_reference_free(pReference);
                return 0;
            },
            &payload);
        return refs;
    }

private:
    std::string m_repoPath {};
    std::string m_workDir {};
    std::unique_ptr<git_repository> m_pRepo {};
};

export std::shared_ptr<GitRepository> GetSharedGitRepository(const std::string& repoPath)
{
    static std::shared_mutex s_repository_cache_mutex {};
    static ring_buffer<std::pair<std::string, std::shared_ptr<GitRepository>>, 50> s_repo_cache;

    // If the repository existed in the cache, return it.
    {
        std::shared_lock read_lock { s_repository_cache_mutex };
        auto it = std::find_if(
            s_repo_cache.begin(), s_repo_cache.end(), [&repoPath](const auto& pair) { return pair.first == repoPath; });
        if (it != s_repo_cache.end()) {
            return it->second;
        }
    }

    // Create a new one add to the cache.
    std::unique_lock write_lock { s_repository_cache_mutex };

    // Maybe added by other thread already, let's double check.
    auto it = std::find_if(
        s_repo_cache.begin(), s_repo_cache.end(), [&repoPath](const auto& pair) { return pair.first == repoPath; });
    if (it != s_repo_cache.end()) {
        return it->second;
    }

    // Really create a new one.
    auto pRepo = std::make_shared<GitRepository>(repoPath);
    s_repo_cache.push_front(std::make_pair(repoPath, pRepo));
    return pRepo;
}",pBuf
650,"#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
#include ""SoftwareSerial.h""
#include <Keypad.h>     // Bibliothek für das Keypad
#include <Keypad_I2C.h> // Bibliothek für das Keypad über I2C

#define PIN_TX 51
#define PIN_RX 53
// ######### INIT SIM / SMS #########
// Cell phone number incl. country code ""+49"" for Germany and xxxxxxxxxxx = phone number
//   don't forget to change your phone number: !!!!!!!!!!!!!!
const char TELEFONE_NUMBER[] = ""+xxxxxxxxxxxx""  ;
// 
bool sim = false;
bool refill_ongoing = false;

SoftwareSerial mySerial(PIN_TX, PIN_RX);

// ########## INIT DISPLAY ##########

// LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address UNO
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address MEGA2560 ; PIN 20 SDA, PIN 21SCL 
//                 or 0x3F correct? see https://www.youtube.com/watch?v=B8DNokj9LnY


// ############ specific configurations ####################

// max = number of buttons (default: 5; even with 1,2 or 3 rows of 5 compartments); if you want to have a button for each compartment increase up to 15 or more
// don't forget to look at EEPROM structure when changing value of max
const int max = 10; 
// number of rows (1 = 5 compartments, 2 = 10 compartments, 3 = 15 compartments)
// if maxrow <=2 the button #5 is used to start refill programm otherwise for open 3rd row during programming
const int maxrow = 1;

unsigned long idlePeriod = 120000; // time in ms between idle messages or shutdown e.g. 180000  
// powersave = 0 show text when Idle; powersave = 1 shutdown when IdlePeriod reached

// debug modus: if you need 10 vendors and one additonal PIN (TX0 / Digital PIN 1 which should normally not be used) on UNO turn debug mode to 0 which disables serial 
// I use this pin to send a message to my smarthome system for any purchased product
bool debug = true;
 //          if (!debug) {
          const int homematic_pin = 6;   
          const int homematic_pin_empty = 7;
 //          }
unsigned long idleTimerMillis = 0;
int randomNumber = 0;

// ### sms_available_products = 0 to send SMS only when sold out, otherwise 99
// sms_change_thresholds :   ""threshold=0"", ""threshold=3"", ""threshold=99"" (send this via sms, works until restart)
 
int sms_available_products = 3;
int last_available_products = 99;

const int buzzer_pin = 49;


// #### parameter for Paypal or sumup payment (QR-code incl. value to be generated via Paypal mobile app or sumup webpage)
// email forward to sms including following string: 
//const char smsPayPal7       = ""Sie haben 7,00 EUR erhalten"";
const int  smsPayPal7value  = 700;

// ox cashless payment
bool ox = false;
int ox_credit_per_pulse = 100;
// volatile int ox_coinsCurrentValue = 0;
volatile int ox_difference = 0; 
int ox_Change = 0; // a coin has been inserted flag
unsigned long ox_currentMillis = 0;
unsigned long ox_oldMillis = 0;
volatile int ox_pulsecount = 0;
int ox_inhibit_relais_pin = 11;
int ox_act = 12;


// nv10 cashless payment
// NV10 - payment with bill now available for Mega 2560

// DIPs on NV10:
// 1 LOW
// 2 HIGH (this has been changed recently!)
// 3 LOW
// 4 HIGH
// DIP2 on HIGH to get 4 pulses instead of 1 because in some installations compartment opening impacted the pulse interrupt. Now all pulses less 4 are ignored.
// credit per pulse is now 125 instead of 500

bool nv10 = false;
int nv10_credit_per_pulse = 125;
// volatile int nv10_coinsCurrentValue = 0;
volatile int nv10_difference = 0; 
int nv10_Change = 0; // a coin has been inserted flag
unsigned long nv10_currentMillis = 0;
unsigned long nv10_oldMillis = 0;
volatile int nv10_pulsecount = 0;
int nv10_act = 13;
int nv10_ch1 = 9;
int nv10_ch2 = 10;

char last_paytype = '?';

// ########## keypad usage ##########
// in case of keypad usage: set maxrow = 1 and max to number of vending units!
// it is not possible to use select buttons and keypad in parallel.
// each vending unit can have a specific price
bool keypad = false;
const byte ROWS = 4;  
const byte COLS = 3;   
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};

byte rowPins[ROWS] = {0, 1, 2, 3}; // connection to rows of keypads (PCF8574 P0-P3)
byte colPins[COLS] = {4, 5, 6};    // columns (PCF8574 P4-P6)

Keypad_I2C customKeypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS, 0x20); // 0x20 is the I2C Address des PCF8574 (changeable, you find it with help of sketch ""i2c_scanner"")

unsigned long lastKeyPressTime = 0;
int knumber = 0;
int select = 999;
bool singleDigitEntered = false;
bool doubleDigitEntered = false;
bool tripleDigitEntered = false;

// ########## INIT BUTTONS ##########

//const int selector[5] = {17, 16, 15, 14, 0 }; // input pins for selector buttons (A0=14, A1=15, A2=16, A3=17, Dig0=0) UNO
//const int selector[15] = {A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15}; // input pins for selector buttons MEGA
const int selector[15] = {A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15}; // input pins for selector buttons MEGA
//const int selector[5] = {A1, A2, A3, A4, A5}; // input pins for selector buttons MEGA 5 buttons and 5/10 or 15 boxes

// ### don't uses dig1 PIN because it is related to the serial monitor and will causes issues with external periphery (UNO)
// PINS
const int configbutton = 5;   // 5 for Mega; 13 for Uno
const int refillbutton = 3;  // 3 for Mega; for Uno 12 (if only one row of compartments exists: maxrow = 1)
const int powersave_relais_pin = 4;  // 4 for Mega; for Uno 11
const int powersave = 0;  // powersave = 1 -> turnoff power after idle threshold; run at least onetime with 0 to ensure correct data on eeprom

// #### EEPROM structure
//  0          -> 1           : version of this structure : 1 
//  2          -> 3           : max = number of buttons
//  4          ->            
//  index * 2 + 4             : conveyorItems []
//  index * 2 + max * 2 + 4   : conveyorPrice []

const int EEPROM_version = 1;
 

// ########## INIT VALUES ##########
// #max
// #PREIS
int conveyorPrice[15] = {700, 700, 700, 700, 700, 700, 700, 700, 700, 700, 700, 700, 700, 700, 700}; // default price  
//int conveyorPrice[5] = {700, 700, 700, 700, 700}; // default price  
int conveyorItems[15] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
//int conveyorItems[5] = {2, 2, 2, 2, 2};

// ########## INIT COIN ACCEPTOR ##########

const int coinInt = 0; // attach coinInt to interrupt pin 0 = digital pin 2 = digitalPinToInterrupt(2) . (interrupt pin 1 = digital pin 3 = digitalPinToInterrupt(3))
const int coin_relais_pin = 17;
// ########## INIT Cashless payment ox interrupt ##############
const int ox_Int = 18; // attach coinInt to interrupt pin 
// ########## INIT bill payment nv10 interrupt ##############
const int nv10_Int = 19; // attach nv10 to interrupt pin 

// set the coinsCurrentValue to a volatile float
// volatile as this variable changes any time the Interrupt is triggered
volatile int coinsCurrentValue = 0;
int coinsChange = 0; // a coin has been inserted flag

unsigned long currentMillis = 0;
unsigned long oldMillis = 0;

int pulsecount;

const unsigned int wt_ms = 100; // wait ms

// const int relaisPin = xx; //
//const int relays[10] = {3, 4, 5, 6, 7, 8, 9, 10 , 11, 12}; //uno: 10 boxes
const int relays[15] = {22,24,26,28,30,32,34,36,38,40,42,44,46,48,50}; // mega: 15 boxes
 

//const int poweroffrelais = 4;  // mega: 4; uno: only possible if less 10 compartments; in this case pin 12 recommended; remove this pin from relais list
// poweroffrelais replaced by powersave_relais_pin
// ########## END OF INIT ##########

// ########## SETUP ###################################################################################

void setup() {



if (debug) {
  Serial.begin(9600); // start serial communication
  Serial.println(""Setup gestartet"");
  }
 for (int index = 0; index < max; index++) {
   pinMode(selector[index], INPUT_PULLUP);
 }
 
  pinMode(configbutton, INPUT_PULLUP);
  pinMode(refillbutton, INPUT_PULLUP);  
  pulsecount = 0;
  digitalWrite(powersave_relais_pin, HIGH);
  pinMode (powersave_relais_pin, OUTPUT);

  digitalWrite(homematic_pin, HIGH);
  pinMode (homematic_pin, OUTPUT);

  digitalWrite(homematic_pin_empty, HIGH);
  pinMode (homematic_pin_empty, OUTPUT);

  digitalWrite(buzzer_pin, LOW);
  pinMode (buzzer_pin, OUTPUT);

 
   /// #### start coin acceptor & deactivate ox_inhibit
  // payment_on_off ();
      
 // lcd.begin(20, 4); // set up the LCD's number of columns and rows
  lcd.begin(16, 2); // set up the LCD's number of columns and rows
  lcd.print(""Bitte warten...""); // Print wait message to the LCD
   if (debug) {
  Serial.println(""Warten auf Muenzpruefer"");
  }
  delay(500); // don't start main loop until we're sure that the coin selector has started

  lcd.clear();
  lcd.setCursor(0, 0); 

  // if coinInt goes HIGH (a Pulse), call the coinInserted function
  // an attachInterrupt will always trigger, even if your using delays
  //  attachInterrupt(digitalPinToInterrupt(2), coinInserted, RISING);
  attachInterrupt(coinInt, coinInserted, RISING);
   
  pinMode(ox_act, INPUT_PULLUP);
  if (digitalRead(ox_act) == LOW) {ox = true;} else {ox = false;}

if (debug) {
 if (ox) {
    Serial.print("" ox true "");
    }
    else
    {
    Serial.print("" ox false "");
    }
}     

if (ox) {
 ox_oldMillis = millis();
 if (debug) {
      Serial.print("" ox_oldMillis "");
      Serial.print(ox_oldMillis);
 }
 
}

  pinMode(nv10_act, INPUT_PULLUP);
  if (digitalRead(nv10_act) == LOW) {nv10 = true;} else {nv10 = false;}

if (debug) {
 if (nv10) {
    Serial.print("" nv10 true "");
    }
    else
    {
    Serial.print("" nv10 false "");
    }
}   
 
if (nv10) {
 nv10_oldMillis = millis();
 if (debug) {
      Serial.print("" nv10_oldMillis "");
      Serial.print(nv10_oldMillis);
 }
 
}
if (sim)
   {
    lcd.setCursor(0, 1);
  lcd.print(""SIM init..10sek ""); 
     delay(10000);
   // Serial.begin(9600);
	digitalWrite(buzzer_pin, HIGH); 
  delay(250);
  digitalWrite(buzzer_pin, LOW); 
  
  mySerial.begin(9600);


	Serial.println(""Initializing sim.."");
  mySerial.println(""AT"");
  updateSerial(wt_ms);
  Serial.println(""AT+CMGF=1"");
  mySerial.println(""AT+CMGF=1""); // SMS text mode
  updateSerial(wt_ms);  

//## how to handle incoming SMS:
//### display sms
mySerial.println(""AT+CNMI=1,2,0,0,0""); // Decides how newly arrived SMS messages should be handled
// save sms
//  mySerial.println(""AT+CNMI=2,1,0,0,0""); // Decides how newly arrived SMS messages should be handled
  updateSerial(wt_ms);
  delay(1000);
  

  Serial.println("" AT+CMGL:"");
 // mySerial.println(""AT+CMGL=\""ALL\""\r""); // show all sms stored in SIM-card
 // updateSerial(wt_ms);
 //Serial.println("" del all sms:"");
 //mySerial.println(""AT+CMGL=\""DEL ALL\""\r""); // delete all sms from sim-card
 // updateSerial(wt_ms);
 Serial.println("" weiter.."");
  updateSerial(wt_ms);
  delay(1000);

  last_available_products = sms_available_products;

   }

  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print(""ox ""); 
  lcd.print(ox);  
  lcd.print("" nv10 ""); 
  lcd.print(nv10);  
  lcd.print("" sim ""); 
  lcd.print(sim);  
  lcd.setCursor(0, 0);
//  lcd.print("" av ""); 
 // lcd.print(available_products);  
  lcd.print("" mx ""); 
  lcd.print(max);  
  lcd.print("" mxr ""); 
  lcd.print(maxrow);  
  delay(3000); 

if (keypad) {
lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print(""key ""); 
  lcd.print(keypad);  
 if (debug) {
      Serial.print("" keypad active! "");
       }
  customKeypad.begin();
  Wire.begin();
delay(200);
}


// Relais initialisieren

 for (int index = 0; index < (max * maxrow); index++) {
  digitalWrite(relays[index], HIGH); // Turn OFF
  pinMode(relays[index], OUTPUT);
 }

digitalWrite(powersave_relais_pin,HIGH);
 pinMode(powersave_relais_pin, OUTPUT);

 if ((readEEPROM (0) != EEPROM_version) or (readEEPROM (2) != max))
 {
   if (debug) {
    Serial.print(""EEPROM_vers "");

    Serial.print (readEEPROM (0)); 
    Serial.print(""Emax "");
    Serial.print (readEEPROM (2)); 
    Serial.print(""PVer: "");
    Serial.print(EEPROM_version);  
    Serial.print(""PrMax: ""); 
    Serial.println(max);   
   }    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""INIT EEPROM "");
    lcd.setCursor(0, 1);    
    lcd.print("" v "");
    lcd.print( EEPROM_version);
  //  lcd.print("" max "");    
  //  lcd.print( max );   
  if (debug) {
      Serial.print(""writeEEprom.. "");     
  }      
   writeEEPROMcomplete();
   if (debug) {
    Serial.print(""ende IF "");
   }    
 } 
 else
 {
// read EEPROM and update values
if (debug) {
  Serial.println("" else:read EEPROM and upd "");
}  
 readEEPROMcomplete();
   
 }
   
 //delay(200);
coinsCurrentValue = 0;
lcd.print(""Guthaben reset"");
delay(200);
if (debug) {
  Serial.println(""Bereit"");
}  
  lcd.clear();
  lcd.print(""Bereit."");
 // if coinInt goes HIGH (a Pulse), call the coinInserted function
  // an attachInterrupt will always trigger, even if your using delays
  //  attachInterrupt(digitalPinToInterrupt(2), coinInserted, RISING);
  attachInterrupt(coinInt, coinInserted, RISING);

  payment_on_off ();
}

// ########## COIN INSERT ##########

// This function is called by interrupt every time we receives a pulse from the coin acceptor
void coinInserted() {
coinsChange = 1; // flag that there has been a coin inserted
last_paytype = 'C';


  currentMillis = millis();
  int difference = currentMillis - oldMillis;

//  Serial.print(""difference: "");
if (debug) {
  Serial.println(difference); 
}
  oldMillis = currentMillis;
  pulsecount++;

// new coin? start to count from beginning....   
if (difference > 140 or difference < 50 ) {
    if (pulsecount > 1) {
       pulsecount = 1;
     }
   }

if (difference < 141) {
switch (pulsecount) {
case 2: coinsCurrentValue = coinsCurrentValue + 10;  
        break; 
case 3: coinsCurrentValue = coinsCurrentValue + 10;  
        break; 
case 4: coinsCurrentValue = coinsCurrentValue + 30;  
        break; 
case 5: coinsCurrentValue = coinsCurrentValue + 50;  
        break; 
case 6: coinsCurrentValue = coinsCurrentValue + 100;  
        break;         
   } // switch
  } // if
    idleTimerMillis = millis();
if (debug) {    
  Serial.print (""(/coinsInserted)neuer Wert: "");
  Serial.println (  coinsCurrentValue);
  Serial.print(""last Paytype: "");
  Serial.println (last_paytype);
}
}


// ########## OX PULSE - cashless payment ##########

// This function is called by interrupt every time we receives a pulse from the coin acceptor
void ox_pulse() {
ox_Change = 1; // flag that there has been cashless payment done
last_paytype = 'O';

ox_pulsecount++;
ox_currentMillis = millis();
 int ox_difference = ox_currentMillis - ox_oldMillis;
     
  ox_oldMillis  = ox_currentMillis; 

if (debug) {    
  Serial.print (""(/ox_pulse) neuer Wert: "");
  Serial.println (  ox_pulsecount);
}

// new ox payment? start to count from beginning
 if (ox_difference > 310)
 {
   if (ox_pulsecount > 1)
   {
     ox_pulsecount = 1;
   }
 } // diff > xxx

 if ((ox_difference < 309) and (ox_difference > 0))
 {


  // {
     coinsCurrentValue = coinsCurrentValue + ox_pulsecount * ox_credit_per_pulse;
     ox_pulsecount = 0;
   }
 //}
if (debug) {    
  Serial.print (""(/ox_pulse) coinsCurrentValue "");
  Serial.println (  coinsCurrentValue);
  Serial.print (""(/ox_pulse) ox_difference: "");
  Serial.println (  ox_difference);
  Serial.print(""last Paytype: "");
  Serial.println (last_paytype);
}

}
// ################ ox back - inform Naxay about cash payments #############################
void ox_pulse_back(int oxCurrentValue ) {
 
if (debug) {    
  Serial.print (""(oxCurrentValue: "");
  Serial.println (  oxCurrentValue );
  Serial.print (""ox_credit_per_pulse: "");
  Serial.print (ox_credit_per_pulse );
}
// now we want to use the ox pin for output for a moment...
   detachInterrupt(digitalPinToInterrupt(ox_Int));   
   delay(200);
   pinMode (ox_Int, OUTPUT);
   digitalWrite(ox_Int, HIGH);
   delay(100);
   digitalWrite(ox_Int, LOW);
   delay(500);
 
// ### back to normal usage of ox-pin
   delay (200);
   pinMode(ox_Int, INPUT_PULLUP);
   delay (1000);
   attachInterrupt(digitalPinToInterrupt(ox_Int), ox_pulse, RISING);

 if (debug) {    
  Serial.print (""(/ox_pulse_back end)"");  
  }

}


// ########## nv10 PULSE - bill payment ##########

// This function is called by interrupt every time we receives a pulse from the bill acceptor
void nv10_pulse() {
nv10_Change = 1; // flag that there has been cashless payment done
last_paytype = 'N';

nv10_pulsecount++;
nv10_currentMillis = millis();
 int nv10_difference = nv10_currentMillis - nv10_oldMillis;
     
nv10_oldMillis  = nv10_currentMillis; 

if (debug) {    
  Serial.print (""(/nv10_pulse) neuer Wert: "");
  Serial.println (  nv10_pulsecount);
  Serial.print (""(/nv10_pulse) nv10_difference: "");
  Serial.println (  nv10_difference);
  Serial.print(""last Paytype: "");
  Serial.println (last_paytype);
}

// new bill? start to count from beginning
 if (nv10_difference > 310)
 {
   if (nv10_pulsecount > 1)
   {
     nv10_pulsecount = 1;
   }
 } // diff > 140

 if (nv10_difference < 309)
 {

switch (nv10_pulsecount) {
case 4: coinsCurrentValue  = coinsCurrentValue + nv10_pulsecount * nv10_credit_per_pulse;  
        nv10_pulsecount    = 0;
        break; 
case 8: coinsCurrentValue  = coinsCurrentValue + nv10_pulsecount * nv10_credit_per_pulse;  
        nv10_pulsecount    = 0;
        break; 
case 12: coinsCurrentValue = coinsCurrentValue + nv10_pulsecount * nv10_credit_per_pulse;
        nv10_pulsecount    = 0;
        break; 
   } // switch

 }
if (debug) {    
  Serial.print (""(/nv10_pulse) coinsCurrentValue "");
  Serial.println (  coinsCurrentValue);
  Serial.print (""(/nv10_pulse) nv10_difference: "");
  Serial.println (  nv10_difference);
}
}
 
// ########## Open Compartement ##########

// Fach Öffnen
void CompartementOpen(int j) {

// detach interrupts to avoid impact (false ccountings)

if (ox)   
 {
   detachInterrupt(digitalPinToInterrupt(ox_Int));   
    } // ox
if (nv10) 
    {
    detachInterrupt(digitalPinToInterrupt(nv10_Int));
    digitalWrite(nv10_ch1, HIGH);
    pinMode (nv10_ch1, OUTPUT);
    digitalWrite(nv10_ch2, HIGH);
    pinMode (nv10_ch2, OUTPUT);
    }

  detachInterrupt(coinInt);
 if (debug) {
  Serial.print(""Fachnummer "");
  Serial.print(j+1);
  Serial.println("" oeffnen:"");
 }
 
 // lcd.clear();
 // lcd.setCursor(0, 0);  
 // lcd.print(""Bitte warten."");
  delay(100);
 
  digitalWrite(relays[j], LOW); // Fach öffnen
  delay(500);
  digitalWrite(relays[j], HIGH); // Relais wieder aus
 delay(1000);
  attachInterrupt(coinInt, coinInserted, RISING);  
// attach interrupts again if products are still available 
//if (!refill_ongoing)
{
 payment_on_off();
}
}


// ############## payment system on or off depending on if products still available
 
 void payment_on_off () {
   if (debug) {
    Serial.print(""payment_on_off "");
   }    
  
 int available_products = 0;
for (int avail_index = 0; avail_index < max; avail_index++) {
 available_products = available_products + conveyorItems[avail_index];
  
  }   
 if (debug)  
   {
    Serial.print(""anz avail "");
    Serial.print(available_products);
   }  
 
  //lcd.clear();
  lcd.setCursor(14, 0);
  lcd.print("" av ""); 
  lcd.print(available_products);  
  //delay (2000);
 
 if (available_products > 0)
  {
   lcd.clear();
   lcd.setCursor(0, 0);  
   lcd.print(""Bitte warten."");
 //  delay(100);

   digitalWrite(coin_relais_pin,HIGH);
   pinMode(coin_relais_pin, OUTPUT);
   
 //  delay (500);
if (ox)    {
    if (debug) {
      Serial.print(""attachOX "");
      }    
   digitalWrite(ox_inhibit_relais_pin,HIGH);
   pinMode(ox_inhibit_relais_pin, OUTPUT);
   attachInterrupt(digitalPinToInterrupt(ox_Int), ox_pulse, RISING);
      } // ox
if (nv10) {
   if (debug) {
      Serial.print(""attachNV10 "");
      }    
    
   digitalWrite(nv10_ch1, LOW);
   pinMode (nv10_ch1, OUTPUT);
   digitalWrite(nv10_ch2, LOW);
   pinMode (nv10_ch2, OUTPUT);
   delay(300);
   attachInterrupt(digitalPinToInterrupt(nv10_Int), nv10_pulse, RISING);
   if (debug) {
      Serial.print(""attachNV10 done"");
      }    
   
   }

  displayBalance(); // display current balance      

          if (sim)
          {

           if ((last_available_products == available_products) && ( (available_products == 3) || (available_products == 0) )
            || ((sms_available_products == 99) && (available_products > 3)))
           {
          updateSerial(wt_ms);
          mySerial.println(""AT+CMGF=1"");
          updateSerial(wt_ms);
          if (debug) {    
           Serial.print(""AT+CMGF=1 "");    
          }
          if (debug) {    
           Serial.println(""AT+CMGS=\""""+String(TELEFONE_NUMBER)+""\"""");    
           }
	         mySerial.println(""AT+CMGS=\""""+String(TELEFONE_NUMBER)+""\"""");
	         updateSerial(wt_ms);
          if (debug) {    
          Serial.print(""sms prep sold item "");  
          Serial.print(available_products);
      }
        mySerial.print(""noch verfuegbar: "" + String(available_products));
        updateSerial(wt_ms);
	      mySerial.write(26);
        mySerial.println("""");
        updateSerial(wt_ms);
        last_available_products = available_products;
        }
          }



   } //if available_products > 0
 else  //available_product == 0
 {   
   if (ox)   
   {
   detachInterrupt(digitalPinToInterrupt(ox_Int));   
   digitalWrite(ox_inhibit_relais_pin,LOW);
   pinMode(ox_inhibit_relais_pin, OUTPUT);
   
 //  delay (1000);   
    } // ox
    if (nv10) {
    detachInterrupt(digitalPinToInterrupt(nv10_Int));
    digitalWrite(nv10_ch1, HIGH);
    pinMode (nv10_ch1, OUTPUT);
    digitalWrite(nv10_ch2, HIGH);
    pinMode (nv10_ch2, OUTPUT);
    
    }


// ##### inform smart home that no further product available
          digitalWrite(homematic_pin_empty, LOW); 
          delay(1500);
          digitalWrite(homematic_pin_empty, HIGH); 
          delay(200);

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""Ware leer! "");
    delay (5000);
   digitalWrite(coin_relais_pin,LOW);
   pinMode(coin_relais_pin, OUTPUT);       

 if (sim)
  {
// Configuring TEXT mode
	 updateSerial(wt_ms);
   mySerial.println(""AT+CMGF=1"");
   updateSerial(wt_ms);
  if (debug) {    
     Serial.print(""AT+CMGF=1 "");    
     }
  if (debug) {    
     Serial.println(""AT+CMGS=\""""+String(TELEFONE_NUMBER)+""\"""");    
     }
	mySerial.println(""AT+CMGS=\""""+String(TELEFONE_NUMBER)+""\"""");
	updateSerial(wt_ms);
    if (debug) {    
     Serial.print(""sms prep "");  
     Serial.print(available_products);
     }
   mySerial.print(""ausverkauft!"");
	 updateSerial(wt_ms);
	 // following is not length of string, it writes ""STR-Z"" which is needed to send sms:
   mySerial.write(26);
   mySerial.println("""");
   updateSerial(wt_ms);
  }

 }  // else
  
 }

// ########## LCD IDLE ##########

// messages on LCD while idle
void idle() {
  // only run when idlePeriod has been reached since last run and no coins have been thrown
  
  if ((millis() > idleTimerMillis + idlePeriod) && (coinsCurrentValue > 1) ) {
   
     idleTimerMillis = millis();     
     coinsCurrentValue = 0;
     lcd.print(""Guthaben reset..."");
     delay(200);
     lcd.clear();
     lcd.print(""Bereit.."");
     payment_on_off ();    
//     displayBalance(); // display current balance      
     
  }
    
  if ((millis() > idleTimerMillis + idlePeriod) && (coinsCurrentValue < 1) ) {
  // idle display text messages only if not in powersave mode
   if (powersave == 0)
 {   

    idleTimerMillis = millis();
    randomNumber = random(0, 5); // random number from 0 to 4
    lcd.clear();
    if (randomNumber == 0) {
      lcd.setCursor(0, 0);
 // #PREIS
      lcd.print(""Preis"");
      lcd.setCursor(0, 1);
      lcd.print("""");
    } else if (randomNumber == 1) {
      lcd.setCursor(0, 0);
      lcd.print(""Bitte passend "");
      lcd.setCursor(0, 1);
      lcd.print(""zahlen. "");
    } else if (randomNumber == 2) {
      lcd.setCursor(0, 0);
      lcd.print(""Geld einwerfen, dann"");
      lcd.setCursor(0, 1);
      lcd.print(""Fach waehlen"");
    } else if (randomNumber == 3) {
      lcd.setCursor(0, 0);
  // #PREIS
      lcd.print(""Willkommen!"");
      lcd.setCursor(0, 1);
      lcd.print(""   "");
    } else if (randomNumber == 4) {
      lcd.setCursor(0, 0);
      lcd.print(""Leergut bitte"");
      lcd.setCursor(0, 1);
      lcd.print(""zurueck. Danke."");
    }
 
   // clear lcd 1000 msec before idle periode expires and no coins have been thrown
  if ((millis() > idleTimerMillis + idlePeriod - 1000) && (coinsCurrentValue < 1)) {
    lcd.clear();
  }
 
 }
else
 {
// shutdown when powersave == 1
  if (debug) {
  Serial.print(""power off.."");
  }  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(""power off..."");
  delay(2000);
   digitalWrite(powersave_relais_pin, LOW);
  delay(5000);  
  // power relais not available?... continue..
  idleTimerMillis = millis();
  lcd.clear();
  digitalWrite(powersave_relais_pin, HIGH);
  lcd.print(""Bereit.."");
  delay(2000);
 }
  }

}


// ########## SET VALUES ##########

void set_values() {
  if (debug) {
  Serial.println(""Gerätekonfiguration gestartet"");
  }
  

  
if (sim) {
    digitalWrite(buzzer_pin, HIGH); 
    delay(250);
    digitalWrite(buzzer_pin, LOW); 
      last_available_products = sms_available_products;
      lcd.clear();
      lcd.setCursor(0, 0);
      if (debug) {
       Serial.println("" set sms_available_products: "");
       Serial.println(sms_available_products);
               }
       lcd.print(""sms ab Anzahl: "");
       lcd.print(sms_available_products);
       delay(500);
        if (keypad)
           lcd.clear();
           lcd.setCursor(0, 0);
           lcd.setCursor(0, 1);
          {lcd.print(""*=open #=weiter"");
          }
       delay(1000);
    }


    int scope = 0;
for (int index = 0; index < max; index++) {
     idleTimerMillis = millis();
      // set conveyor items
    scope = 0;      
    int pass = index + 1;
   if (debug) {
    Serial.print(""Anz"");
    Serial.println(pass);
   }    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""Fachnr. "");
    lcd.print(pass);
    lcd.print("" Anzahl "");
    lcd.setCursor(0, 1);
    lcd.print(conveyorItems[index]);
    lcd.print(""  "");


    // Setup Warenmenge Button 1 = runterzählen, Button 2 = raufzählen, Button 3 = weiter, Button 4 = alle öffnen, Button 5 = refill (öffne alle leeren & setzte Werte)
if (debug) {
    Serial.print(""scope "");
    Serial.println(scope);
   
 }    
   // set of product counter only without keypad (with keypad maxrow is always one)
while ((scope == 0) && (keypad == false)) { 
//while (scope == 0) {
      if (digitalRead(selector[0]) == LOW && conveyorItems[index] > 0) {
        conveyorItems[index] = conveyorItems[index] - 1;
 //       lcd.clear();        
        lcd.setCursor(0, 1);
        lcd.print(conveyorItems[index]);
        lcd.print(""   "");
        delay(200);
      } //selector [0]
      if (digitalRead(selector[1]) == LOW && conveyorItems[index] < 10) {
        conveyorItems[index] = conveyorItems[index] + 1;
 //       lcd.clear();        
        lcd.setCursor(0, 1);
        lcd.print(conveyorItems[index]);
        lcd.print(""   "");
        delay(200);
      } //selector [1]
      
      if (digitalRead(selector[3]) == LOW) {
if (debug) {
        Serial.print(""alle oeffnen "");
}
        //if (maxrow == 1) {
           CompartementOpen(index);          
           delay(500);           
        //   } //maxrow == 1
        if (maxrow > 1) {
           CompartementOpen(index+max);          
           delay(500);
           } //maxrow ==2
        if (maxrow > 2) {
           CompartementOpen(index+max+max);          
           delay(500);           
           } // maxrow ==3

           lcd.clear();
           lcd.setCursor(0, 0);
           lcd.print(""Fach geoeffnet."");
           lcd.setCursor(0, 1);
           lcd.print(""(3) druecken!"");
           delay(200);

      } //selector [3]
       
      if (digitalRead(selector[4]) == LOW) {
 if (debug) {
        Serial.print(""refill.. "");
 }        
           refill();  
           writeEEPROMcomplete();           
           scope = max + 1;           
           delay(200);
      } //selector [4]


      if (digitalRead(selector[2]) == LOW) {
if (debug) {        
        Serial.print(""Neue Anz: "");
        Serial.println(conveyorItems[index]);
}
        scope++;
        delay(400);
      } //selector [2]
    } // while (scope == 0) and keypad not used

  } //for (int index = 0;

  // Setup Preise Button 1 = runterzählen, Button 2 = raufzählen in 10er Schritten, Button 3 = Ende und Anzeige
if (debug) {
  Serial.print(""while Prs "");
}  
if (scope <= max)
 {
  for (int index = 0; index < max; index++) {
    // set conveyor prices with buttons
    scope = 0;
    int pass = index + 1;
 if (debug) {
    Serial.print(""Preis Fach "");
    Serial.println(pass);
 }    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""Fach "");
    lcd.print(pass);
    lcd.print("" Preis"");
    lcd.setCursor(0, 1);
    
    lcd.print("" "");
    lcd.print(conveyorPrice[index] / 100.00);
    lcd.print(""     "");
    while ((scope == 0) and (!keypad)) {
      if (digitalRead(selector[0]) == LOW && conveyorPrice[index] >= 10) {
// enter value up/down via button 1 or 2
        conveyorPrice[index] = conveyorPrice[index] - 10;
        displayConfPrice(index);
        delay(300);
      }
      if (digitalRead(selector[0]) == LOW && conveyorPrice[index] > 0 && conveyorPrice[index] < 10) {
        conveyorPrice[index] = 0;
        displayConfPrice(index);
        delay(300);
      }
      if (digitalRead(selector[1]) == LOW && conveyorPrice[index] < 2000) {
        conveyorPrice[index] = conveyorPrice[index] + 10;
        displayConfPrice(index);
        delay(300);
      }
      if (digitalRead(selector[2]) == LOW) {
// -- next entry via button 3 
  if (debug) {
        Serial.print(""Neuer Preis:  "");
        Serial.println(conveyorPrice[index] / 100.00);
  }        
        scope++;
        delay(400);
   }
      } // while scope and not keypad

// ########   enter price with help of keypad
  while ((scope == 0) and (keypad))

  {

   if (keypad) {
      char key = customKeypad.getKey();
 
      if (key) {
      if (debug) {
      Serial.print(""pr_keypad_2 "");
      }    
    unsigned long currentTime = millis();
    digitalWrite(buzzer_pin, HIGH); 
    delay(150);
    digitalWrite(buzzer_pin, LOW); 

if (tripleDigitEntered && (currentTime - lastKeyPressTime <= 1000)) {
      if (debug) {
    Serial.print(""pr_four digits entered! "");
   }    
      // 4th press within short time
       knumber = knumber * 10 + (key - '0');
      singleDigitEntered = false;
      doubleDigitEntered = false;
      tripleDigitEntered = false;
      Serial.println(knumber);
    }
 else {

if (doubleDigitEntered && (currentTime - lastKeyPressTime <= 1000)) {
      if (debug) {
    Serial.print(""pr_three digits entered! "");
   }    
      // third press within short time
       knumber = knumber * 10 + (key - '0');
      singleDigitEntered = false;
      doubleDigitEntered = false;
      tripleDigitEntered = true;
      Serial.println(knumber);
    }
 else {
 
 
    if (singleDigitEntered && (currentTime - lastKeyPressTime <= 1000)) {
      if (debug) {
    Serial.print(""pr_keypad_3 "");
   }    
      // second press within short time
       knumber = knumber * 10 + (key - '0');
      singleDigitEntered = false;
      doubleDigitEntered = true;
      tripleDigitEntered = false;
      lastKeyPressTime = currentTime;
      Serial.println(knumber);
    } else {
 
      // first key pressed
      knumber = key - '0';
      singleDigitEntered = true;
      doubleDigitEntered = false;
      tripleDigitEntered = false;
      lastKeyPressTime = currentTime;
  if (debug) {
         Serial.print(""pr_keypad_4 "");
         Serial.println(knumber);
        } // debug
    } // else single
   } // else double
  } // else triple

  } // keypad
  

  // last press long time ago...
  if ((singleDigitEntered && (millis() - lastKeyPressTime > 1000))) {
    if (debug) {
    Serial.print(""pr_keypad_5 "");
   }    
    singleDigitEntered = false;
    doubleDigitEntered = false;
    tripleDigitEntered = false;
    Serial.println(knumber);
    digitalWrite(buzzer_pin, HIGH); 
    delay(100);
    digitalWrite(buzzer_pin, LOW); 
  }
}
// valid keys selected 
 // select = 999;
if ((knumber > 0) && (millis() - lastKeyPressTime > 1000))
{
 if (debug)
  {
  Serial.println(""valid keypad price entry! "");
  Serial.println(""knumber: "");
  Serial.println(knumber);
  Serial.println(""lastKeyPressTime: "");
  Serial.println(lastKeyPressTime);
  Serial.println(""singleDigitEntered: "");
  Serial.println(singleDigitEntered);
  Serial.println(""select b: "");
  Serial.println(select);
  }
//       lcd.clear();
//       lcd.setCursor(0, 0);
//       if (select != 999){
//       lcd.print(knumber);
//       lcd.setCursor(0, 1);
//       lcd.print(""* save # weiter"");
//       }
//       else 
//        {
//       lcd.print(conveyorPrice[index] / 100.00);
       //lcd.print (""*"");
//       }
       delay(500);
       select = knumber;
       knumber = 0;

       if (debug)
  {
  if (select != 999){
   Serial.println(""LCD: *"");  
  
  Serial.println(""upd: "");
  Serial.println("" knumber: "");
  Serial.println(knumber);
  Serial.println("" select c: "");
  Serial.println(select);
   lcd.clear();
  lcd.setCursor(0, 0);
  //lcd.print(knumber);
  lcd.print(select);
}
  }

}

 if (knumber == -13 )
  {
if (debug)
  {
  Serial.println(""save pressed: "");
  Serial.println(""knumber: "");
  Serial.println(knumber);
  Serial.println(""select b: "");
  Serial.println(select);
  Serial.println(""conveyorPrice OLD: "");
  Serial.println(conveyorPrice[index]);
  }


  scope ++;
    if (select != 999){
    conveyorPrice[index] = select;
    select = 999;
    // or knumber? no it is -13 at this point.
   // }
    //else {
    if (debug) {
        Serial.print(""conveyorPrice new (formatted):  "");
        Serial.println(conveyorPrice[index] / 100.00);
    } 
    }
       
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""Fach "");
    lcd.print(pass);
    lcd.print("" Preis"");
    lcd.setCursor(0, 1);
    lcd.print("" "");
    lcd.print(conveyorPrice[index] / 100.00);
    delay (800);
    knumber = 0;
  } // * entered, next value with

  if (knumber == -6 )
  {
  scope ++;
    if (debug) {
        Serial.print(""Fach oeffnen:  "");
        Serial.println(""knumber: "");
        Serial.println(knumber);
        Serial.println(""select b: "");
        Serial.println(select);
        Serial.println(""conveyorPrice OLD: "");
        Serial.println(conveyorPrice[index]);        
  }        
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""Fach "");
    lcd.print(pass);
    lcd.print("" oeffnen"");
    lcd.setCursor(0, 1);
    lcd.print("" "");

    CompartementOpen(index);          
    delay(500);      
    knumber = 0;     

  } // # compartment open via keypad *

  } // while scope and keypad

    }
  }

 coinsCurrentValue = 0;
 //displayBalance();
if (debug) {  
  Serial.println(""Neu Eeprom."");
}  
  writeEEPROMcomplete();
if (debug) {
  Serial.println(""Konfig beendet"");
}  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(""Gespeichert"");
  delay(200);

   // check if products available and activate/deactivate payments systems
  payment_on_off ();
  coinsCurrentValue = 0;
  lcd.print(""Guthaben reset...."");
  delay(200);
  lcd.clear();
  displayBalance();
  }

// ########## Refill ##########
// open all empty boxes and set their value to maxrow

void refill() {
 refill_ongoing = true;
 if (debug) {
  Serial.print("" Refill "");
 }  
  lcd.clear();
if (debug) {
      Serial.print(""maxrow "");
      Serial.print(maxrow);
}
   
 for (int rindex = 0; rindex < max; rindex++) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(""Refill# "");
     if (debug) {
      Serial.print(""Refill Col "");
      Serial.print(rindex+1);
      Serial.print(""conyeyorItems[rindex]: "");
      Serial.print(conveyorItems[rindex]);
     } 

      
      lcd.print(rindex+1);

    if ( conveyorItems[rindex] == 0) {
      if (debug) {
          Serial.print(""Öffnen "");
      }          
          lcd.setCursor(0, 1);
          lcd.print (rindex+1); 
          CompartementOpen(rindex); 
          conveyorItems[rindex] ++;
          delay(200);
                 }
          
    if (( conveyorItems[rindex] == 1) and (maxrow > 1)) {
       if (debug) {
          Serial.print(""rindex + max "");
       }          
          lcd.setCursor(0, 1);
          CompartementOpen(rindex + max); 
          lcd.print (rindex+max +1); 
          conveyorItems[rindex] ++;          
          delay(200);
          }

    if (( conveyorItems[rindex] == 2) and (maxrow > 2)) {
        if (debug) {
          Serial.print(""rindex + 10 "");
        }
          lcd.setCursor(0, 1);
          lcd.print (rindex+max + max +1);
          CompartementOpen(rindex + max + max); 
          delay(200);
          conveyorItems[rindex] ++;
          }
         
    delay(100);
    } 
    
    if (sim) {
      last_available_products = sms_available_products; 
      lcd.clear();
      lcd.setCursor(0, 0);
      if (debug) {
       Serial.println("" set sms_available_products: "");
       Serial.println(sms_available_products);
               }
       lcd.print(""sms_available_products: "");
       lcd.print(sms_available_products);
       delay(2000);
    }

    lcd.clear();
    lcd.setCursor(0, 0);
    if (debug) {
    Serial.println("" Refill ende. "");
    lcd.print(""Refill beendet."");
    }    
    delay(2000);
    refill_ongoing = false;
    payment_on_off ();
    coinsCurrentValue = 0;
    lcd.print(""Guthaben reset"");
    delay(200);

    lcd.clear();
    displayBalance();
    }


// ########## LCD MESSAGES ##########

void displayBalance() {
  if (debug) {
  Serial.print(""Value:  "");
  Serial.println(coinsCurrentValue / 100.00);
  }  
  lcd.clear(); // reset LCD
  lcd.setCursor(0, 0);
  lcd.print("" Guthaben"");
  lcd.setCursor(0, 1); // set cursor to LCD row 2 column 1 (starting with 0)

  lcd.print("" "");
  lcd.print(coinsCurrentValue / 100.00); // display current balance

//  if you have a display with more than two lines:
//  lcd.setCursor(0, 2);  
//  lcd.print(""Fragen? Tel:"");
//  lcd.setCursor(0, 3);  
//  lcd.print(String(TELEFONE_NUMBER));
}

void displayPrice(int  [MASK] ) {
  if (debug) {
  Serial.print(""Warenpreis:  "");
  Serial.println( [MASK]  / 100.00);
  }  
  lcd.clear(); // reset LCD
  lcd.setCursor(0, 0);
  lcd.print(""Preis"");
  lcd.setCursor(0, 1); // set cursor to LCD row 2 column 1 (starting with 0)

  lcd.print("" "");
  lcd.print( [MASK]  / 100.00);
  if (coinsCurrentValue > 0) {
    delay(500);
    displayBalance();
  }
}

void displayEmpty() {
  if (debug) {
  Serial.println(""Fach leer"");
  }  
  lcd.clear(); // reset LCD
  lcd.setCursor(0, 0);
  lcd.print(""Leider leer :("");
  lcd.setCursor(0, 1); // set cursor to LCD row 2 column 1 (starting with 0)
  lcd.print(""Bitte neu waehlen"");
  if (coinsCurrentValue > 0) {
    delay(1000);
    displayBalance();
  }
}

void displayConfPrice(int con) {
  lcd.setCursor(0, 1);
  lcd.print("" "");
  lcd.print(conveyorPrice[con] / 100.00);
  lcd.print(""     "");
}

// ########## write eeprom ########## see https://www.youtube.com/watch?v=5x0nUy36Trs
void writeEPROM (int address, int number)
{
     
   EEPROM.write(address, (number >> 8) & 0xFF);
   EEPROM.write(address + 1, number & 0xFF);
}

// ########## read eeprom ##########
int readEEPROM (int address)
 {  
   return (EEPROM.read(address) << 8) + EEPROM.read(address + 1);
  } 

// #########  write eeprom complete #########
void writeEEPROMcomplete ()
 { 
   if (debug) {
    Serial.print(""writeEEPcomp.."");
    Serial.print(""vers "");
    Serial.print(EEPROM_version);  
    Serial.print(""max ""); 
    Serial.print(max);   
   }
   writeEPROM (0, EEPROM_version);
   writeEPROM (2, max);
   if (debug) {
   Serial.print(""write und max done."");
   }
    for (int index = 0; index < max; index++) {
//    3          -> 4 + 2 * index : conveyorItems []
//    4          -> index * 2 + max * 2 + 4 : conveyorPrice []
   
   if (debug) {
     Serial.print(""index * 2 + 4  = "");
     Serial.print(index * 2 + 4);     
     Serial.print(""Items [index]: ""); 
     Serial.print(conveyorItems[index]);
   }
     writeEPROM (index * 2 + 4, conveyorItems[index]);

if (debug) {
     Serial.print(""index * 2 + 2 * max + 4 = "");
     Serial.print(index * 2 + 2 * max + 4);     
     Serial.print(""Price [index]: ""); 
     Serial.print(conveyorPrice[index]);
}
     writeEPROM (index * 2 + max * 2 + 4, conveyorPrice[index]);
   
    }  

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""saved. "");
    delay (200);
 displayBalance();
   

  }

// #########  read eeprom complete #########
void readEEPROMcomplete ()
 { 
 if (debug) {
    Serial.print(""readEEPcompl.."");
 }    

 //   EEPROM_version = readEEPROM (0);
 //   max            = readEEPROM (2);

if (debug) {    
    Serial.print(""vers "");
    Serial.print(EEPROM_version);  
    Serial.print(""max ""); 
    Serial.print(max);   
}

    for (int index = 0; index < max; index++) {
//    3          -> 4 + 2 * index : conveyorItems []
//    4          -> index * 2 + max * 2 + 4 : conveyorPrice []
//        delay (500);
 if (debug) {
     Serial.print(""index = "");
     Serial.println(index);     
 
     Serial.print("" index * 2 + 4  = "");
     Serial.print(index * 2 + 4);     
     Serial.print("" Items [index]: ""); 
     Serial.print(conveyorItems[index]);
 }     
     conveyorItems[index] = readEEPROM(index * 2 + 4);
  if (debug) {
     Serial.print("" Items new [index]: ""); 
     Serial.print(conveyorItems[index]);

     Serial.print("" index * 2 + 2 * max + 4 = "");
     Serial.print(index * 2 + 2 * max + 4);     
     Serial.print("" Price old [index]: ""); 
     Serial.print(conveyorPrice[index]);
  }
     conveyorPrice[index] = readEEPROM(index * 2 + max * 2 + 4);
     if (debug) {
     Serial.print("" Price new [index]: ""); 
     Serial.print(conveyorPrice[index]);
     Serial.println("" ----- ""); 
     }
    }  

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(""loaded. "");
    if (debug) {
    Serial.print("" loaded EEPR. ""); 
    }    
    delay (200);
   

  }

// ######################## update serial / sms ######################
void updateSerial(unsigned int wait_ms)
{

  String dataString = """";
  String part1 = """";
  String part2 = """";
  
  int numval = 0;
   int position = 0;
  delay(wait_ms);
  if(mySerial.available()) {
    dataString = mySerial.readString();
    Serial.println(dataString);
  }

  if(dataString != """"){
    if (debug) {
 //   Serial.print("" datastring != ** ""); 
 //   Serial.println(dataString);
    Serial.println(""lenght: "");
    Serial.println(dataString.length());
    Serial.println(""indexOf Paypal_payed7: "");
  //  Serial.println(dataString.indexOf(""Sie haben 7,00 EUR erhalten""));
    Serial.println(dataString.indexOf(""*EUR erhalten* detected.""));
 }    
  
  //#### SMS received about Paypal paymend (forwarded email):
  //  if (dataString.indexOf ("" EUR erhalten"") >0) or (dataString.indexOf ("" EUR mit PayPal gesendet."") >0) {
    if (dataString.indexOf ("" EUR erhalten"") >0)  {
  //  currentMillis = millis();
      idleTimerMillis = millis();
      digitalWrite(buzzer_pin, HIGH); 
      delay(500);
      digitalWrite(buzzer_pin, LOW); 


  // clarify the position within sms string how much money to consider  
   if (debug) {    
   Serial.print(""dataString *_EUR erhalten* / length: "");  
   Serial.println(dataString); 
   Serial.println(dataString.length());
   position = dataString.indexOf(""EUR""); 
   Serial.print(""Position EUR: ""); 
   Serial.println(position); 
   } // debug
   part2 = dataString.substring( (position - 6), (position - 4)); 
   part1 = dataString.substring ( (position - 3 ), (position - 1)  );  
   numval = ( (part2.toInt() * 100) + part1.toInt() );
  
  if (debug) {    
   Serial.print(""part1: "");  
   Serial.println(part1);     
   Serial.print(""part2: "");  
   Serial.println(part2);   
   Serial.print(""numval: "");  
   Serial.print(numval);  
  } // debug

// paypal changed sms message in 9/24 - sometimes separator . instead of comma; one digit after separator
  if ((part2.substring (0,1) == ""n"") && (part1.substring (0,1) == "".""))
   {
    if (debug) {    
     Serial.print(""separator point instea of comma!"");  
      } //debug
     part2 = dataString.substring( (position - 5), (position - 3)); 
     part1 = dataString.substring ( (position - 2 ), (position - 1)  );  
   //  numval = ( (part2.toInt() * 100) + part1.toInt() );
 // upd 12/24: payment 2.5 was considered as 2.05 - corrected:
     numval = ( (part2.toInt() * 100) + (part1.toInt() * 10) );
     if (debug) {    
        Serial.println(""part1 a: "");  
        Serial.println(part1);     
        Serial.print(""part2 a: "");  
        Serial.println(part2);   
        Serial.print(""numval: "");  
        Serial.print(numval);  
       } // debug
   }  // point as separator / on digit after separator
 //     coinsCurrentValue = coinsCurrentValue + smsPayPal7value;
      coinsCurrentValue = coinsCurrentValue + numval;
       displayBalance();
  //   if (debug) {
    Serial.print("" sms Zahlung erfolgt. "" ); 
  //  } 
    } // forwarded email for paypal business accounts

 //#### SMS received about Paypal payment (direct sms from Paypal - for privat (non business) paypal accounts):
  // sometimes two spaces on front of text ""EUR"", sometimes one space!!!
        if ((dataString.indexOf (""  EUR mit PayPal gesendet."") >0)  or
        (dataString.indexOf ("" EUR mit PayPal gesendet."") >0))  {
  //  currentMillis = millis();
      idleTimerMillis = millis();
      digitalWrite(buzzer_pin, HIGH); 
      delay(500);
      digitalWrite(buzzer_pin, LOW); 


  // clarify the position within sms string how much money to consider  
   if (debug) {    
   Serial.print(""dataString *..EUR mit PayPal gesendet.*/ length: "");  
   Serial.println(dataString); 
   Serial.println(dataString.length());
   position = dataString.indexOf(""EUR""); 
   Serial.print(""Position EUR: ""); 
   Serial.println(position); 
   } // debug
   part2 = dataString.substring( (position - 6), (position - 4)); 
   part1 = dataString.substring ( (position - 3 ), (position - 1)  );  
   numval = ( (part2.toInt() * 100) + part1.toInt() );
  
  if (debug) {    
   Serial.print(""part1 b: "");  
   Serial.println(part1);     
   Serial.print(""part2 b: "");  
   Serial.println(part2);   
   Serial.print(""numval: "");  
   Serial.print(numval);  
  } // debug
// paypal changed sms message in 9/24 - sometimes separator . instead of comma; one digit after separator
  if ((part2.substring (0,1) == ""n"") && (part1.substring (0,1) == "".""))
   {
    if (debug) {    
     Serial.print(""separator point instead of comma!"");  
      } //debug
     part2 = dataString.substring( (position - 5), (position - 3)); 
     part1 = dataString.substring ( (position - 2 ), (position - 1)  );  
  //   numval = ( (part2.toInt() * 100) + part1.toInt() );
 // upd 12/24: payment 2.5 was considered as 2.05 - corrected:
     numval = ( (part2.toInt() * 100) + (part1.toInt() * 10) );
     if (debug) {    
        Serial.println(""part1 c: "");  
        Serial.println(part1);     
        Serial.print(""part2 c: "");  
        Serial.println(part2);   
        Serial.print(""numval: "");  
        Serial.print(numval);  
       } // debug
   }  // point as separator / on digit after separator

 //     coinsCurrentValue = coinsCurrentValue + smsPayPal7value;
      coinsCurrentValue = coinsCurrentValue + numval;
       displayBalance();
  //   if (debug) {
    Serial.print("" sms Zahlung erfolgt. "" ); 
  //  } 
    } // direct SMS for privat paypal account
//###########################################
//#### SMS received about sumup:
  // 
        if ((dataString.indexOf (""SumUp - Sie wurden bezahlt - Sie wurden soeben bezahlt!"") >0)  or
        (dataString.indexOf (""Sie haben eine Zahlung für den folgenden Zahlungslink erhalten: Betrag"") >0))  {
  //  currentMillis = millis();
      idleTimerMillis = millis();
      digitalWrite(buzzer_pin, HIGH); 
      delay(500);
      digitalWrite(buzzer_pin, LOW); 


  // clarify the position within sms string how much money to consider  
   if (debug) {    
   Serial.print(""dataString *sumup - Sie wurden bezahlt ...*/ length: "");  
   Serial.println(dataString); 
   Serial.println(dataString.length());
   position = dataString.indexOf(""EUR""); 
   Serial.print(""Position EUR: ""); 
   Serial.println(position); 
   } // debug
   part2 = dataString.substring( (position - 6), (position - 4)); 
   part1 = dataString.substring ( (position - 3 ), (position - 1)  );  
   numval = ( (part2.toInt() * 100) + part1.toInt() );
  
  if (debug) {    
   Serial.print(""part1 b: "");  
   Serial.println(part1);     
   Serial.print(""part2 b: "");  
   Serial.println(part2);   
   Serial.print(""numval: "");  
   Serial.print(numval);  
  } // debug
// paypal changed sms message in 9/24 - sometimes separator . instead of comma; one digit after separator

 //     coinsCurrentValue = coinsCurrentValue + smsPayPal7value;
      coinsCurrentValue = coinsCurrentValue + numval;
       displayBalance();
  //   if (debug) {
    Serial.print("" sms Zahlung erfolgt. "" ); 
  //  } 
    } // sms about sumup payment
//###########################################


//#### SMS received to change sms threshold (inform with smsm about sold/remaining items):


    if (dataString.indexOf (""threshold=0"") >0) { 
      sms_available_products = 0;
      digitalWrite(buzzer_pin, HIGH); 
      delay(500);
      digitalWrite(buzzer_pin, LOW); 
      if (debug) {
       Serial.println("" sms threshold changed to 0 ""); 
       }
       lcd.clear();
       lcd.setCursor(0, 0);
       lcd.print(""sms = 0"");
       sms_available_products = 0;
       delay(1000);
       displayBalance();
    }

if (dataString.indexOf (""threshold=3"") >0) { 
      sms_available_products = 3;
      digitalWrite(buzzer_pin, HIGH); 
      delay(500);
      digitalWrite(buzzer_pin, LOW); 
      if (debug) {
       Serial.println("" sms threshold changed to 3 ""); 
       }
       lcd.clear();
       lcd.setCursor(0, 0);
       lcd.print(""sms = 3"");
       sms_available_products = 3;
       delay(1000);
       displayBalance();
    }

if (dataString.indexOf (""threshold=99"") >0) { 
      digitalWrite(buzzer_pin, HIGH); 
      delay(500);
      digitalWrite(buzzer_pin, LOW); 
      if (debug) {
       Serial.println("" sms threshold changed to 99 ""); 
       }
       lcd.clear();
       lcd.setCursor(0, 0);
       lcd.print(""sms = 99"");
       sms_available_products = 99;
       delay(1000);
       displayBalance();
    }

if (dataString.indexOf (""refill"") >0) { 
      digitalWrite(buzzer_pin, HIGH); 
      delay(500);
      digitalWrite(buzzer_pin, LOW); 
      if (debug) {
       Serial.println("" sms refill ""); 
       }
       lcd.clear();
       lcd.setCursor(0, 0);
       lcd.print(""refill"");
         refill();
         writeEEPROMcomplete(); 
       delay(1000);
       displayBalance();
    }


  } //## datastring ...

  while(Serial.available()) {
    mySerial.write(Serial.read());
  }
} //# updateSerial



// ########## MAIN LOOP ##########

void loop() {
  if (digitalRead(configbutton) == LOW) {
if (debug) {
   Serial.print(""DigitalRead(configb): LOW"");
}
   set_values();
   delay(1000);
  }

 if (digitalRead(refillbutton) == LOW) {
if (debug) {   
   Serial.print(""DigitalRead(refillbutton): LOW"");
}   
   refill();
 writeEEPROMcomplete(); 
   delay(1000);
  }  
//if (debug) {
//    Serial.print(""idle "");
// }    
  idle();

  // check if a coin has been inserted
 if (coinsChange == 1) {
  if (debug) {
    Serial.print(""CoinsChange "");
   }    
   coinsChange = 0; // unflag that a coin has been inserted
   idleTimerMillis = millis();
   displayBalance(); // display current balance
  
  }



// check if a bill has been inserted
 if (nv10_Change == 1) {
  if (debug) {
    Serial.print(""NV10_Change "");
   }    
   nv10_Change = 0; // unflag that a coin has been inserted
   idleTimerMillis = millis();
   displayBalance(); // display current balance
  
  }

// check if a card or mobile payment has been done
 if (ox_Change == 1) {
  if (debug) {
    Serial.print(""ox_Change "");
   }    
   ox_Change = 0; // unflag that a card or mobile payment has been done
   idleTimerMillis = millis();
   displayBalance(); // display current balance
  
  }
 // *********** keypad pressed **********

 if (keypad) {
char key = customKeypad.getKey();
 
  if (key) {
    if (debug) {
    Serial.print(""keypad_2 "");
   }    
    unsigned long currentTime = millis();
    digitalWrite(buzzer_pin, HIGH); 
    delay(150);
    digitalWrite(buzzer_pin, LOW); 

    if (singleDigitEntered && (currentTime - lastKeyPressTime <= 1000)) {
      if (debug) {
    Serial.print(""keypad_3 "");
   }    
      // second press within short time
       knumber = knumber * 10 + (key - '0');
      singleDigitEntered = false;
      Serial.println(knumber);
    } else {
 
      // first key pressed
      knumber = key - '0';
      singleDigitEntered = true;
      lastKeyPressTime = currentTime;
  if (debug) {
         Serial.print(""keypad_4 "");
         Serial.println(knumber);
        } // debug
  } // else
  } // keypad
  

  // last press long time ago...
  if ((singleDigitEntered && (millis() - lastKeyPressTime > 1000))) {
    if (debug) {
    Serial.print(""keypad_5 "");
   }    
    singleDigitEntered = false;
    Serial.println(knumber);
    digitalWrite(buzzer_pin, HIGH); 
    delay(100);
    digitalWrite(buzzer_pin, LOW); 
  }
}
// valid keys selected 
  select = 999;
if ((knumber > 0) && (millis() - lastKeyPressTime > 1000) and (knumber <= (max * maxrow)))
{
 if (debug)
  {
  Serial.println(""valid keypad entry! "");
  Serial.println(""knumber: "");
  Serial.println(knumber);
  Serial.println(""lastKeyPressTime: "");
  Serial.println(lastKeyPressTime);
  Serial.println(""singleDigitEntered: "");
  Serial.println(singleDigitEntered);
  Serial.println(""select a: "");
  Serial.println(select);
  }
       lcd.clear();
       lcd.setCursor(0, 0);
       lcd.print(knumber);
       delay(500);
       select = knumber -1;
       knumber = 0;

}
else {
  if (knumber > (max * maxrow))
  {
if (debug) {
    Serial.println(""keypad entry invalid "");
    }
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(knumber);
    lcd.setCursor(0, 1);
    lcd.print(""ungueltig!"");
    digitalWrite(buzzer_pin, HIGH); 
    delay(500);
    digitalWrite(buzzer_pin, LOW); 
    knumber = 0;
 }
}
 
  // ********** BUTTON PRESSED **********

   
   for (int index = 0; index < max; index++) {    
    if 
     (((digitalRead(selector[index]) == LOW) and (!keypad)) or ((select == index) and (keypad)))
  
          { // button pressed
if (debug) {
      Serial.print(""Spalte "");
      Serial.print(index + 1);
      Serial.println("" gedrueckt "");
      Serial.println("" items: "");
      Serial.print(conveyorItems[index]);
      Serial.println(""  "");
      Serial.println("" INDEX selected:"");
      Serial.println(select);
}      
      if (conveyorItems[index] > 0) {
        if (coinsCurrentValue < conveyorPrice[index]) { // insufficient balance - display price
          displayPrice(conveyorPrice[index]);
          idleTimerMillis = millis();
          delay(2000);
        }
       // #### SELL ITEM ##### 
        if ((coinsCurrentValue > conveyorPrice[index] - 1) ) { // sufficient balance
          coinsCurrentValue = coinsCurrentValue - conveyorPrice[index]; // reduce balance
          conveyorItems[index]--; // reduce items
    if (debug) {
    Serial.print(""update EEPROM conveyorItem "");
    Serial.print(index * 2 + 4, conveyorItems[index]);          
    }
          writeEPROM (index * 2 + 4, conveyorItems[index]);
          if (coinsCurrentValue < 0) {
            coinsCurrentValue = 0;  // correct float rounding error
          }
          delay(200);
      
//          which compartment to open?
if (debug) {
    Serial.print(""conveyorItems[index] "");
    Serial.print(conveyorItems[index]);
    Serial.print(""index "");
    Serial.print(index);
    }
          if ( conveyorItems[index] == 0) {
           if (debug) {
          Serial.print(""index open "");
           }
           CompartementOpen(index); }   
          if ( conveyorItems[index] == 1) {
          if (debug) {
          Serial.print(""index plus max öffnen "");
          }          
          CompartementOpen(index + max); }
          if ( conveyorItems[index] == 2) {
           if (debug) {
          Serial.print(""index + 2 * max "");
           }
          CompartementOpen(index + max + max); }
          displayBalance(); // display current balance
          idleTimerMillis = millis(); // reset idle timer

// turn off payment (coin acceptor or cashless system - ox ) if no further product available
// 

//          inform homematic about sold item only if serial.print not used (using digital pin1 which is dedicaded to serial) (issue with uno only)
          delay(100);
          digitalWrite(homematic_pin, LOW); 
          delay(1500);
          digitalWrite(homematic_pin, HIGH); 
          delay(200);
// inform Nayax Onyx about sold items but only if it was paid cash (possible last_paytype = O (onyx), N (nv10) or C (cash) )
  if (debug) {
    Serial.println(""lastPaytype - C=Coin, N=NV10, O=Onyx, ?=not set: "");
    Serial.print(last_paytype);
    Serial.println(""<-lastPaytype"");
   }    


         if(ox) {
          if  (last_paytype != 'O') {
          ox_pulse_back (conveyorPrice[index]);
          } // not for ox payments
          } 


        }
        // ##### END SELL ITEM ##########
      } else {
        displayEmpty();
        idleTimerMillis = millis(); // reset idle timer
        delay(200);
      }
       //reset key 
       select = 999;
       knumber = 0;
    }
    
  }

//##### check if SMS incoming....
if (sim)
{

updateSerial(0);
}


}
",currentPrice
651,"// =============================================================================
// Project: qcomm - Quantum Communication Simulator
// File: architecture.cpp
// Description: Implementation of architecture and related functions
// Author: <NAME> <<EMAIL>>
// License: Apache-2.0 license (see LICENSE file for details)
// =============================================================================

#include <iostream>
#include <fstream>
#include <sstream>
#include <yaml-cpp/yaml.h>
#include ""utils.h""
#include ""architecture.h""
#include ""mapping.h""

void Architecture::display() const
{
  cout << endl
       << ""Architecture:"" << endl
       << IND << ""number_of_cores: "" << number_of_cores << endl
       << IND << ""mesh_size: '"" << mesh_x << ""x"" << mesh_y << ""'"" << endl
       << IND << ""qubits_per_core: "" << qubits_per_core << endl
       << IND << ""total_physical_qubits: "" << mesh_x * mesh_y * qubits_per_core << endl
       << IND << ""ltm_ports: "" << ltm_ports << endl;

  cout << IND << ""teleportation_type: "" << teleportation_type;
  if (teleportation_type == TP_TYPE_A2A)
    cout << "" # all to all"" << endl;
  else if (teleportation_type == TP_TYPE_MESH)
    cout << "" # mesh"" << endl;
  else 
    cout << "" # ??\?"" << endl;

  cout << IND << ""dst_selection_mode: "" << dst_selection_mode;
  if (dst_selection_mode == DST_SEL_LOAD_INDEPENDENT)
    cout << "" # load independent"" << endl;
  else if (dst_selection_mode == DST_SEL_LOAD_AWARE)
    cout << "" # load aware"" << endl;
  else
    cout << "" # ??\?"" << endl;
  

  cout << IND << ""wireless_enabled: "" << boolalpha << wireless_enabled << endl;
  if (wireless_enabled)
    cout << IND << ""radio_channels: "" << radio_channels << endl;

  cout << IND << ""mapping_type: "" << mapping_type;
  if (mapping_type == MAP_RANDOM)
    cout << "" # random"" << endl;
  else if (mapping_type == MAP_SEQUENTIAL)
    cout << "" # sequential"" << endl;
  else
    cout << "" # ??\?"" << endl;
}

bool Architecture::readFromFile(const string& file_name)
{
  YAML::Node  [MASK] ;
  bool result = loadYAMLFile(file_name,  [MASK] );
  
  result &= getOrFail<int>( [MASK] , ""mesh_x"", file_name, mesh_x);
  result &= getOrFail<int>( [MASK] , ""mesh_y"", file_name, mesh_y);
  result &= getOrFail<int>( [MASK] , ""link_width"", file_name, link_width);
  result &= getOrFail<int>( [MASK] , ""qubits_per_core"", file_name, qubits_per_core);
  result &= getOrFail<int>( [MASK] , ""ltm_ports"", file_name, ltm_ports);
  result &= getOrFail<int>( [MASK] , ""radio_channels"", file_name, radio_channels);
  result &= getOrFail<bool>( [MASK] , ""wireless_enabled"", file_name, wireless_enabled);
  result &= getOrFail<int>( [MASK] , ""teleportation_type"", file_name, teleportation_type);
  result &= getOrFail<int>( [MASK] , ""dst_selection_mode"", file_name, dst_selection_mode);
  result &= getOrFail<int>( [MASK] , ""mapping_type"", file_name, mapping_type);
  
  updateDerivedVariables();
  
  return result;
}

void Architecture::updateMeshX(const int nv)
{
  mesh_x = nv;
  updateDerivedVariables();
}

void Architecture::updateMeshY(const int nv)
{
  mesh_y = nv;
  updateDerivedVariables();
}

void Architecture::updateLinkWidth(const int nv)
{
  link_width = nv;
}

void Architecture::updateQubitsPerCore(const int nv)
{
  qubits_per_core = nv;
}

void Architecture::updateLTMPorts(const int nv)
{
  ltm_ports = nv;
}

void Architecture::updateRadioChannels(const int nv)
{
  radio_channels = nv;
}

void Architecture::updateWirelessEnabled(const int nv)
{
  wireless_enabled = nv;
}

void Architecture::updateTeleportationType(const int nv)
{
  teleportation_type = nv;
}

void Architecture::updateDstSelectionMode(const int nv)
{
  dst_selection_mode = nv;
}

void Architecture::updateMappingType(const int nv)
{
  mapping_type = nv;
}

void Architecture::updateDerivedVariables()
{
  number_of_cores = mesh_x * mesh_y;
}

",config
652,"
#include ""Hexagon1.h""

//make the six points in the hexagon
Point Hexagon::center(point_of_Hexagon l)
{
	return Point(l.first, l.second);
}
Point Hexagon::p1(point_of_Hexagon l)
{
	return Point(l.first, l.second-distance);
}
Point Hexagon::p2(point_of_Hexagon l)
{
	return Point(l.first+sqrt(3.0) * distance/2,l.second-distance/2);
}
Point Hexagon::p3(point_of_Hexagon l)
{
	return Point(l.first+sqrt(3.0)*distance/2,l.second+distance/2);
}
Point Hexagon::p4(point_of_Hexagon l)
{
	return Point(l.first, l.second+distance);
}
Point Hexagon::p5(point_of_Hexagon l)
{
	return Point(l.first-sqrt(3.0)*distance/2,l.second+distance/2);
}
Point Hexagon::p6(point_of_Hexagon l)
{
	return Point(l.first-sqrt(3.0)*distance/2,l.second-distance/2);
}

//to judge if the hexagon can be created
Hexagon::Hexagon(point_of_Hexagon l,double dis)
	:location(l), distance(dis)
	{
		if (dis<=0) throw error2();
		center(l);
		hexagon.add (p1(l));
		hexagon.add (p2(l));
		hexagon.add (p3(l));
		hexagon.add (p4(l));
		hexagon.add (p5(l));
		hexagon.add (p6(l));
	}

//default constructor
Hexagon::Hexagon()
	:location(make_pair(0,0)),distance(0){}

//to fullfill the color of the hexagon
void Hexagon::set_full_color(Color x)
{
	hexagon.set_fill_color(x);
}
//add the hexagon to the window
void Hexagon::add_to_swin(Simple_window& win)
{
	win.attach(hexagon);
}
//to add the hexagon in the same row
void Hexagon::muti_add_to_swin(Simple_window& win,int x,Color y)
{
	double interval=sqrt(3.0)* distance;
	for(int i=0;i<x;i++)
	{
		Hexagon *h1=new Hexagon (make_pair(location.first+i*interval,location.second),distance);
		h1->set_full_color(y);
		h1->add_to_swin(win);
		Hexagon *h2=new Hexagon (make_pair(location.first-i*interval,location.second),distance);
		h2->set_full_color(y);
		h2->add_to_swin(win);
			
	}
}
//to add the hexagon in the neighborthood but not in the same row,'cause teh muti_add_to_swin has implenment this
void Hexagon::make_vicinity__hexagon(Simple_window& win,int x,Color col_down,Color col_up)
{
	double interval1=sqrt(3.0)*distance;
	double interval2=sqrt(3.0)*distance/2;
	double  [MASK] =distance*3/2;
		 
	for (int i=1;i<x;i++)
	{
	double New_first_1=location.first+i*interval2;
	double New_second_1=location.second+i* [MASK] ;
	Hexagon *h1=new Hexagon (make_pair(New_first_1,New_second_1),distance);
	h1->add_to_swin(win);
	h1->muti_add_to_swin(win,x,col_down);
	}

	for (int i=1;i<x;i++)
	{
	double New_first_1=location.first-+i*interval2;
	double New_second_1=location.second-i* [MASK] ;
	Hexagon *h1=new Hexagon (make_pair(New_first_1,New_second_1),distance);
	h1->add_to_swin(win);
	h1->muti_add_to_swin(win,x,col_up);
	}
}
",interval3
653,"//
//  EulerProblems.cpp
//  testC
//
//  Created by <NAME> on 16/08/12.
//  Copyright (c) 2012 <NAME>. All rights reserved.
//

#include ""EulerProblems.h""
//
//  Problems.cpp
//  testC
//
//  Created by <NAME> on 16/08/12.
//  Copyright (c) 2012 <NAME>. All rights reserved.
//

//#include ""Problems.h""
#if 0
#include <stdio.h>


#define LENGTHARR  1000000
bool arr[LENGTHARR];

void initializeArr()
{
    for(int i = 0 ; i < LENGTHARR ; i++)
    {
        arr[i] = false;
    }
}
int hashfunc( long j)
{
    long p;
    p = j % 1000003; // took a prime just greater than 1000000
    if(arr[p] == true)
    {
        return 0;
    }
    else
    {
        
        arr[p] = true;
        
    }
    return 1;
    
    
}

int Problem44()
{
    long t = 1, u = 1;
    long p = 1, h = 1;
    
    
    for(int i = 1; i< 10000; i++)
    {
        initializeArr();
        
        while( p < 1000000 )
        {
            p = p + 3*t + 1;
            
            if( hashfunc(p) == 0)
                printf(""clash at p-tagon P%ld  %ld\n"", t+1, p); // this will never be encountered
            t++;
        }
        
        while( h < 1000000   )
        {
            h = h + 4*u + 1;
            
            if( hashfunc(h) == 0)
                printf(""clash at hexagon H%ld  %ld\n"", u+1, h);
            u++;
        }
        p = p - 1000000;
        h = h - 1000000;
    }
    return 1;
    
    
}
/*
struct bignum
{
    int digits[1000];
    int sig;
    bignum()
    {
        memset(digits, 0, 1000 );
        sig = 0;
    }
    
};

void AddBigNum(bignum a, bignum b, bignum &c)
{
    int carry = 0;
    int max;
    int i;
    max = (a.sig > b.sig)? a.sig: b.sig;
    for( i = 0 ; i< max ; i++)
    {
        c.digits[i] = a.digits[i] + b.digits[i] + carry;
        if ((c.digits[i] - 10) >= 0)
        {
            carry = 1 ;
            c.digits[i] = c.digits[i] % 10 ;
        }
        else
        {
            carry = 0 ;
        }
    }
    if(carry == 1)
    {
        c.digits[i] = 1;
        c.sig = max+1;
        
    }
    else
    {
        c.sig = max;
        
    }
    
    
}

void PRINTBIG(bignum a)
{
    for( int i = a.sig ; i > 0 ; i--)
    {
        printf (""%d"", a.digits[i-1]);
        
    }
    
}
*/

/*
 
 int i;
 int c = 0;
 bignum  numr, denom, numr1, denom2;
 numr.digits[0] = 3;
 numr.sig = 1 ;
 denom.digits[0] = 2;
 denom.sig = 1 ;
 
 for(i = 2; i<=1000 ; i++)
 {
 
 //numr1  = numr + 2*denom;
 AddBigNum(denom, denom, numr1);
 AddBigNum(numr, numr1, numr1);
 
 //denom2 = numr + denom ;
 AddBigNum(numr, denom, denom2);
 numr   = numr1 ;
 denom  = denom2 ;
 
 
 printf (""Num = "");
 PRINTBIG(numr);
 printf(""/"");
 PRINTBIG(denom);
 printf(""\n"");
 if(numr.sig > denom.sig)
 {
 c++;
 }
 
 }
 printf(""%d\n"", c);
 
 */

int checkpandigital(unsigned long i)
{
    int digits[] ={0, 0, 0, 0, 0, 0, 0, 0, 0};
    
    int rem = 0;
    int num = 0;
    while(i > 0)
    {
        rem = i %10 ;
        if(rem == 0) return 0;
        if(digits[rem - 1] == 1)
        {
            // digit is repeated
            return 0;
        }
        else
        {
            digits[rem - 1] = 1;
        }
        i = i /10 ;
        num++;
    }
    for( int j = 0 ; j < num ; j++)
    {
        if(digits[j] == 0) return 0;
    }
    
    return 1;
}

/*
 unsigned long i;
 for( i = 3 ; i < 10000001; i = i + 2)
 {
 int flag = 1;
 for(unsigned long j = 2; j <= sqrt(i); j++)
 {
 if( i % j == 0)
 {
 flag = 0;
 break;
 }
 
 }
 if(flag == 1)
 {
 if(checkpandigital(i) == 1)
 {
 printf(""Pandigital = %ld\n"", i);
 }
 }
 }
*/
int checkpandigitalwith0(unsigned long i)
{
    int digits[] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    
    int rem = 0;
    int num = 0;
    while(i > 0)
    {
        rem = i %10 ;
        if(digits[rem] == 1)
        {
            // digit is repeated
            return 0;
        }
        else
        {
            digits[rem] = 1;
        }
        i = i /10 ;
        num++;
    }
    for( int j = 0 ; j < num ; j++)
    {
        if(digits[j] == 0) return 0;
    }
    
    return 1;
}


unsigned long long reverse(unsigned long long n)
{
    unsigned long long k = 0;
    while(n > 0)
    {
        k = k*10 + n%10;
        n /= 10;
    }
    
    return k;
}

bool checkPallindrome(unsigned long long  n)
{
    
    if (reverse(n) == n) return true;
    
    return false;
}

struct bignum
{
    int digits[1000];
    int sig;
    bignum()
    {
        memset(digits, 0, 1000 );
        sig = 0;
    }
    void setnum(long long i)
    {
        int j = 0;
        while(i > 0)
        {
            digits[j] = i%10;
            i/= 10;
            j++;
        }
        sig = j;
        
    }
    
};
bool checkBigNumPallindrome(bignum n)
{
    for( int i = 0 ; i< (n.sig/2) ; i++)
    {
        if (n.digits[n.sig- i- 1]!= n.digits[i])
            return false;
    }
    return true;
    
}

void ReverseBigNum(bignum a, bignum &c)
{
    for( int i = 0 ; i< a.sig ; i++)
    {
        c.digits[a.sig- i - 1]= a.digits[i];
    }
    c.sig = a.sig;
    
}

void AddBigNum(bignum a, bignum b, bignum &c)
{
    int carry = 0;
    int max;
    int i;
    max = (a.sig > b.sig)? a.sig: b.sig;
    for( i = 0 ; i< max ; i++)
    {
        c.digits[i] = a.digits[i] + b.digits[i] + carry;
        if ((c.digits[i] - 10) >= 0)
        {
            carry = 1 ;
            c.digits[i] = c.digits[i] % 10 ;
        }
        else
        {
            carry = 0 ;
        }
    }
    if(carry == 1)
    {
        c.digits[i] = 1;
        c.sig = max+1;
        
    }
    else
    {
        c.sig = max;
        
    }
    
    
}

void PRINTBIG(bignum a)
{
    for( int i = a.sig ; i > 0 ; i--)
    {
        printf (""%d"", a.digits[i-1]);
        
    }
    
}

/*
 unsigned long long i;
 bignum num, b, c;
 int count;
 int ans = 0;
 for(i = 1; i < 10000 ; i++)
 {
 count = 1;
 num.setnum(i);
 ReverseBigNum(num, c);
 AddBigNum(num, c , num);
 while(count <= 50)
 {
 if(checkBigNumPallindrome(num) == true)
 {
 
 
 break;
 }
 count++;
 ReverseBigNum(num, c);
 AddBigNum(num, c, num);
 
 }
 if(count > 50)
 {
 printf(""Not Num= %lld  iter= %d Stopat= "", i , count);
 PRINTBIG(num);
 printf(""\n"");
 ans+= 1;
 }
 
 
 
 }
 
 printf(""Total Lyc numbers =  %d\n"", ans);
*/



#define NUM73 12000


unsigned long long HCF(unsigned long long num1, unsigned long long num2)
{
    unsigned long long  [MASK] ;
    if(num1 > num2)
    {
         [MASK]  = num1;
        num1 = num2;
        num2 =  [MASK] ;
    }
    while(num1 > 1)
    {
         [MASK]  = num2 % num1;
        if( [MASK]  == 0) break;
        num2 = num1;
        num1 =  [MASK] ;
    }
    return num1;
    
}

void SolveProblem73()
{
    unsigned int iN, jD;
    int count = 0;
    
    
    for(iN = 1; iN <= NUM73; iN++)
    {
        unsigned int left, right;
        left  = 2*iN + 1;  // 1/2 > iN/left
        right = 3*iN - 1;  // 1/3 < iN/right
        
        if(left <= NUM73) // this is to ensure that the denominator is less than the NUM or else dont run the loop
        {
            if(right > NUM73) right = NUM73; // this is to ensure the same as above but for right bound
            
            for(jD = left; jD <= right; jD++)
            {
                //printf(""%d/%d, "", iN, jD);
                if(HCF(iN, jD) == 1)
                {
                    count++;
                }
            }
            //printf(""\n"");
        }
        
    }
    printf(""Count = %d\n"", count);
    
}

#define NUM72 1000000

void SolveProblem72()
{
    unsigned long long iN, jD;
    unsigned long long count = 0;
    
    
    for(iN = 1; iN <= NUM72; iN++)
    {
        int k = 1;
        if(iN%2 == 0) k = 2;
        for(jD = iN+1; jD <= NUM72; jD = jD + k)
        {
            //printf(""%d/%d, "", iN, jD);
            if(HCF(iN, jD) == 1)
            {
                count++;
            }
        }
        
        
    }
    printf(""Count = %lld\n"", count);
    
}

#define SIEVE_LENGTH  100000002

static bool PrimeSieve[SIEVE_LENGTH];


static int Problem373()
{
    

    long long num = 0;
    long long sum =0;
    memset(PrimeSieve, 0, SIEVE_LENGTH);
    
    PrimeSieve[1] = true;
    for (long long i = 2 ; i <= SIEVE_LENGTH ; i++)
    {
        if(PrimeSieve[i] == true)
        {
            continue;
        }
        else
        {
            for(long long j = i*(i-1); j < SIEVE_LENGTH ; j+= i)
            {
                PrimeSieve[j] = true;
                
            }
            bool isAllPrime = true ;
            for(long long j = 1; j*j <= (i-1) ; j++)
            {
                if((i-1)%j == 0)
                {
                    num = j + ((i-1)/j);
                    if(PrimeSieve[num] == true)
                    {
                        isAllPrime = false ;
                        break;
                    }
                }
            }
            if(isAllPrime == true)
            {
                sum+= i-1 ;
            }
            
            
        }
    }
    //
    //    for (long long i = 2 ; i < SIEVE_LENGTH ; i = i + 2)
    //    {
    //        if(PrimeSieve[i+1] == false)
    //        {
    //                    }
    //
    //
    //    }
    
    printf(""sum = %lld \n"", sum);
    return 1;
}

/*
 
 //Problem 203
 int main()
 {
 unsigned long long arr6[37], arr4[37];
 
 for(int c = 0; c < 37; c++)
 {
 arr6[c] = 0;
 arr4[c] = 0;
 }
 
 for(int i = 1 ; i<=6 ; i++)
 {
 for(int j = 1 ; j<=6 ; j++)
 {
 for(int k = 1 ; k<=6 ; k++)
 {
 for(int l = 1 ; l<=6 ; l++)
 {
 for(int m = 1 ; m<=6 ; m++)
 {
 for(int n = 1 ; n<=6 ; n++)
 {
 int sum;
 sum = i+j+k+l+m+n;
 arr6[sum]++;
 
 }
 
 }
 
 }
 
 }
 
 }
 
 }
 for(int i = 1 ; i<=4 ; i++)
 {
 for(int j = 1 ; j<=4 ; j++)
 {
 for(int k = 1 ; k<=4 ; k++)
 {
 for(int l = 1 ; l<=4 ; l++)
 {
 for(int m = 1 ; m<=4 ; m++)
 {
 for(int n = 1 ; n<=4 ; n++)
 {
 for(int o = 1 ; o<=4 ; o++)
 {
 for(int p = 1 ; p<=4 ; p++)
 {
 for(int q = 1 ; q<=4 ; q++)
 {
 int sum;
 
 sum = i+j+k+l+m+n+o+p+q;
 arr4[sum]++;
 }
 }
 }
 }
 
 }
 
 }
 
 }
 
 }
 
 }
 unsigned long long totalcases = 0;
 for(int i = 9 ; i <37 ; i++)
 {
 for( int j = 6 ; j<i ; j++)
 {
 totalcases += arr4[i] * arr6[j] ;
 }
 }
 
 printf(""Prob = %0.7f"", (double)totalcases /(4*4*4*4*4*4*4*4*4*6*6*6*6*6*6LL));
 
 
 return 1;
 }
*/

#define T_DICE 4
#define C_DICE 6
#define O_DICE 8
#define D_DICE 12
#define I_DICE 20
long long T[T_DICE+1];
long long C[T_DICE+1][T_DICE*C_DICE+1];
long long O[T_DICE*C_DICE+1][T_DICE*C_DICE*O_DICE +1];
double D[T_DICE*C_DICE*O_DICE+1][T_DICE*C_DICE*O_DICE*D_DICE +1];
long long I[T_DICE*C_DICE*O_DICE*D_DICE +1][T_DICE*C_DICE*O_DICE*D_DICE*I_DICE +1];
int main1()
{
    
    //SolveProblem54();
    
    
    int i ;
    
    T[0] = 0 ;
    T[1] = T[2] = T[3] = T[4] = 1;
    
    
    for(i = 0 ; i< (T_DICE+1); i++)
    {
        for( int j = 0 ; j < T_DICE*C_DICE+1 ; j++)
        {
            C[i][j] = 0 ;
        }
    }
    
    for(i = 0 ; i< (T_DICE*C_DICE+1); i++)
    {
        for( int j = 0 ; j < (T_DICE*C_DICE*O_DICE +1) ; j++)
        {
            O[i][j] = 0 ;
        }
    }
    
    for(i = 0 ; i< (T_DICE*C_DICE*O_DICE +1); i++)
    {
        for( int j = 0 ; j < (T_DICE*C_DICE*O_DICE*D_DICE +1) ; j++)
        {
            D[i][j] = 0.0 ;
        }
    }
    
    for(i = 0 ; i< (T_DICE*C_DICE*O_DICE*D_DICE +1 ); i++)
    {
        for( int j = 0 ; j < (T_DICE*C_DICE*O_DICE*D_DICE*I_DICE +1) ; j++)
        {
            I[i][j] = 0 ;
        }
    }
    
    
    
    C[1][1] = C[1][2] = C[1][3] = C[1][4]= C[1][5] = C[1][6]  = 1 ;
    for(int j = 2 ; j < T_DICE+1 ; j++)
    {
        for( int i  = 1 ; i <= 6 ; i++)
        {
            for( int l = 0 ; l < (T_DICE*C_DICE+1 -i) ; l++)
            {
                
                C[j][l+i] += C[j-1][l];
            }
            
        }
    }
    
    O[1][1] = O[1][2] = O[1][3] = O[1][4]= O[1][5] = O[1][6] = O[1][7]= O[1][8] = 1 ;
    for(int j = 2 ; j < T_DICE*C_DICE+1 ; j++)
    {
        for( int i  = 1 ; i <= O_DICE ; i++)
        {
            for( int l = 0 ; l < (T_DICE*C_DICE*O_DICE +1 -i) ; l++)
            {
                
                O[j][l+i] += O[j-1][l];
            }
            
        }
    }
    
    D[1][1] = D[1][2] = D[1][3] = D[1][4]= D[1][5] = D[1][6] = D[1][7]=
    D[1][8] = D[1][9] = D[1][10] = D[1][11]= D[1][12] = 1.0/1000.0 ;
    
    for(int j = 2 ; j < T_DICE*C_DICE*O_DICE +1 ; j++)
    {
        for( int i  = 1 ; i <= D_DICE ; i++)
        {
            for( int l = 0 ; l < (T_DICE*C_DICE*O_DICE*D_DICE +1 -i) ; l++)
            {
                
                D[j][l+i] += D[j-1][l];
            }
            
        }
    }
    
    I[1][1] = I[1][2] = I[1][3] = I[1][4]= I[1][5] = I[1][6] = I[1][7]=
    I[1][8] = I[1][9] = I[1][10] = I[1][11]= I[1][12] = I[1][13] = I[1][14]= I[1][15] =
    I[1][16] = I[1][17] = I[1][18]= I[1][19] = I[1][20]= 1 ;
    
    for(int j = 2 ; j < T_DICE*C_DICE*O_DICE*D_DICE +1 ; j++)
    {
        for( int i  = 1 ; i <= I_DICE ; i++)
        {
            for( int l = 0 ; l < (T_DICE*C_DICE*O_DICE*D_DICE*I_DICE +1 -i) ; l++)
            {
                
                I[j][l+i] += I[j-1][l];
            }
            
        }
    }
    
    
    return 1;
}

#endif
",temp
654,"#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
#include <stdlib.h>


using namespace std;

void check_arguments(int argc, char* argv[]) {
  string  [MASK]  = ""Usage instructions: "";
   [MASK]  += argv[0];
   [MASK]  += "" path/to/input.txt output.txt"";

  bool has_valid_args = false;

  // make sure the user has provided input and output files
  if (argc == 1) {
    cerr <<  [MASK]  << endl;
  } else if (argc == 2) {
    cerr << ""Please include an output file.\n"" <<  [MASK]  << endl;
  } else if (argc == 3) {
    has_valid_args = true;
  } else if (argc > 3) {
    cerr << ""Too many arguments.\n"" <<  [MASK]  << endl;
  }

  if (!has_valid_args) {
    exit(EXIT_FAILURE);
  }
}

void check_files(ifstream& in_file, string& in_name,
                 ofstream& out_file, string& out_name) {
  if (!in_file.is_open()) {
    cerr << ""Cannot open input file: "" << in_name << endl;
    exit(EXIT_FAILURE);
  }

  if (!out_file.is_open()) {
    cerr << ""Cannot open output file: "" << out_name << endl;
    exit(EXIT_FAILURE);
  }
}


void search(vector<int> init, vector<int> exit, vector<vector<char>> grid){
  //go up, go left, go down, go right
  vector<vector<int>> move = {{-1,0},{0,-1},{1,0},{0,1}}; 

  //create closed list of available cells
  //0 still open, 1 be closed
  vector<vector<int>> closed;
  closed.resize(7);
  for (int m=0; m<7; m++){
    closed[m].resize(7);
  }
  closed[init[0]][init[1]] = 1;

  int x = init[0];
  int y = init[1];
  int g = 0;
  
  vector<int> temp;
  vector<int> t2;
  temp.push_back(g);
  temp.push_back(x);
  temp.push_back(y);
  
  vector<vector<int>> open;  // create open expained cell list
  
  open.push_back(temp);
  //cout<<open.size()<<endl;
  //cout<<""start at: ""<<open[0][0]<<"",(""<<open[0][1]<<"",""<<open[0][2]<<"")""<<endl;
  
  bool found = false; //change it when search completed.
  bool resign = false; // flag it when exit is not exist.
  vector<int> next;

  while (found==false && resign ==false){
    if (open.size()==0){
      resign = true;
      cout << ""fail""<<endl;
    }else{
      next = open[0];
      g = next[0];
      x = next[1];
      y = next[2];
      
      open.erase(open.begin());
      cout<<""open cell:(""<<g<<"",""<<x<<"",""<<y<<"")""<<endl;

      if(x==exit[0] && y==exit[1]){
        found = true;
        cout<<""search success""<<endl;
      }else{
        //expain the open list by trying 4 direction moves. 
        for(int n=0; n<move.size(); n++){
	  int x2 = x + move[n][0];
	  int y2 = y + move[n][1];
          //cout<<""x2, ""<<x2<< "", y2, ""<<y2<<endl;
	    if(0<= x2< 7 && 0<= y2<7){
	      //cout<<""x2, ""<<x2<< "", y2, ""<<y2<<"", "";
	      //cout<<closed[x2][y2]<<"", "";
	      //cout<<grid[x2][y2]<<endl;
	      if((closed[x2][y2]==0) && (grid[x2][y2]=='-')){
		  int g2 = g+1;
		  //cout <<""g2 ""<< g2<<endl;
		  t2.clear();
		  t2.push_back(g2);
		  t2.push_back(x2);
		  t2.push_back(y2);
 		  open.push_back(t2);
                  //cout<<""open cell:(""<<g2<<"",""<<x2<<"",""<<y2<<"")""<<endl;
		  closed[x2][y2]= 1; //don't touch this cell again
		  grid[x2][y2]= 'x'; //mark the path
	       }
	    }
         }
      }
    } 
  }
  
}


int main(int argc, char* argv[]){

  check_arguments(argc, argv);

  string in_file_name_ = argv[1];
  ifstream in_file_(in_file_name_.c_str(), ifstream::in);

  string out_file_name_ = argv[2];
  ofstream out_file_(out_file_name_.c_str(), ofstream::out);

  check_files(in_file_, in_file_name_, out_file_, out_file_name_);
  
  string line;
  string file_contents;
  int player;
    
  vector<string> size;
  size.resize(2);

  vector<string> cell(7);

  vector<int> exit;  //Exit position, goal position
  exit.resize(2);

  vector<vector<char>> maze;

  vector<int> init;  //Start position
  init.resize(2);

  //int g;  // g-value 
  int count = 0;
  int i;
  // read in the file
  while(getline(in_file_, line)){
  
    istringstream iss(line);
    if (count==0){
      iss >> player;
      //cout <<player<<endl;
    }else if (count==1){
      iss >>size[0]>>size[1];
      //cout<<size[0]<<"",""<<size[1];
    }else if(1<count && count<9){
      i=count-2;
      iss >>cell[i][0]>>cell[i][1]>>cell[i][2]>>cell[i][3]>>cell[i][4]>>cell[i][5]>>cell[i][6];
    }else if(count ==9){
      iss >>exit[0]>>exit[1];
    }else if(count ==10){
      iss >>init[0]>>init[1];
    }
    count +=1;

  }
  
  cout<<""player id:""<<player<<endl;
  cout<<""maze size:""<<size[0]<<"",""<<size[1]<<endl;
  cout<<""start position:""<<init[0]<<"",""<<init[1]<<endl;
  cout<<""exit  position:""<<exit[0]<<"",""<<exit[1]<<endl;
  vector<char> t3;
  for(int j=0;j<7;j++){
    cout<<cell[j][0]<<cell[j][1]<<cell[j][2]<<cell[j][3]<<cell[j][4]<<cell[j][5]<<cell[j][6]<<endl;
    t3.clear();
    t3.push_back(cell[j][0]);
    t3.push_back(cell[j][1]);
    t3.push_back(cell[j][2]);
    t3.push_back(cell[j][3]);
    t3.push_back(cell[j][4]);
    t3.push_back(cell[j][5]);
    t3.push_back(cell[j][6]);
    maze.push_back(t3);
  }



  search(init, exit, maze);

  return 0;
}
",usage_instructions
655,"#include <stdio.h>
#include <string.h>

// C Implementation
#define MAX_NODES 5

struct adjacentListTable {
    int adjacent_list[MAX_NODES];
};

struct graph {
    int num_nodes;
    struct adjacentListTable adjacent_list_table[MAX_NODES];
};

void graphInit(struct graph *graph) {
    graph->num_nodes = 0;
    for(int i = 0; i < MAX_NODES; i++) {
        graph->adjacent_list_table[i].adjacent_list[0] = -1;
    }
}

void graphAddVertex(struct graph *graph, int value) {
    memset(graph->adjacent_list_table[value].adjacent_list, 0, MAX_NODES);
    graph->num_nodes++;
}

void graphAddEdge(struct graph *graph, int  [MASK] , int to) {
    graph->adjacent_list_table[ [MASK] ].adjacent_list[to] = 1;
    graph->adjacent_list_table[to].adjacent_list[ [MASK] ] = 1;
}

void graphPrint(struct graph *graph) {
    int i;
    for (i = 0; i < MAX_NODES; i++) {
        if(graph->adjacent_list_table[i].adjacent_list[0] != -1) {
            printf(""%d: "", i);
            for (int j = 0; j < MAX_NODES; j++) {
                printf(""%d "", graph->adjacent_list_table[i].adjacent_list[j]);
            }
            printf(""\n"");
        }
    }
}

void main() {
    static struct graph graph;
    graphInit(&graph);

    graphAddVertex(&graph, 0);
    graphAddVertex(&graph, 1);
    graphAddVertex(&graph, 2);
    graphAddVertex(&graph, 3);
    graphAddVertex(&graph, 4);

    graphAddEdge(&graph, 0, 1);
    graphAddEdge(&graph, 1, 2);
    graphAddEdge(&graph, 1, 3);
    graphAddEdge(&graph, 4, 3);

    graphPrint(&graph);
}",from
656,"#include <stdlib.h>    // malloc, free, exit
#include <stdio.h>     // fprintf, perror, fopen, etc.
#include <string.h>    // strlen, strcat, memset, strerror
#include <errno.h>     // errno
#include <sys/stat.h>  // stat
#include <brotli/encode.h>

#include <emscripten.h>
#include <emscripten/bind.h>

using namespace emscripten;

typedef struct BrotliEncoderBuffer_s {
  void*  ptr;         /**< start of buffer */
  size_t size;        /**< size of buffer */
} BrotliEncoderBuffer;

uint32_t _BrotliEncoderVersion(void) {
  return BrotliEncoderVersion();
}

bool _BrotliEncoderSetParameter(unsigned int state, BrotliEncoderParameter param, uint32_t value) {
  return BrotliEncoderSetParameter((BrotliEncoderState*) state, param, value);
}

unsigned int _BrotliEncoderCreateInstance() {
  return (unsigned int)BrotliEncoderCreateInstance(0, 0, NULL);
}

void _BrotliEncoderDestroyInstance(unsigned int state) {
  BrotliEncoderDestroyInstance((BrotliEncoderState*) state);
}

unsigned int _BrotliEncoderPrepareDictionary(BrotliSharedDictionaryType type, size_t data_size, unsigned int  [MASK] , int quality) {
  return (unsigned int)BrotliEncoderPrepareDictionary(type, data_size, (const uint8_t *) [MASK] , quality, 0, 0, NULL);
}

void _BrotliEncoderDestroyPreparedDictionary(unsigned int dictionary) {
  BrotliEncoderDestroyPreparedDictionary((BrotliEncoderPreparedDictionary*) dictionary);
}

size_t _BrotliEncoderGetPreparedDictionarySize(unsigned int dictionary) {
  return BrotliEncoderGetPreparedDictionarySize((const BrotliEncoderPreparedDictionary*) dictionary);
}

bool _BrotliEncoderAttachPreparedDictionary(unsigned int state, unsigned int dictionary) {
  return BrotliEncoderAttachPreparedDictionary((BrotliEncoderState*) state, (const BrotliEncoderPreparedDictionary*) dictionary);
}

size_t _BrotliEncoderMaxCompressedSize(size_t input_size) {
  return BrotliEncoderMaxCompressedSize(input_size);
}

bool _BrotliEncoderCompress(int quality, int lgwin, BrotliEncoderMode mode, BrotliEncoderBuffer& input_buffer, BrotliEncoderBuffer& encoded_buffer) {
  return BrotliEncoderCompress(quality, lgwin, mode, input_buffer.size, (const uint8_t *)input_buffer.ptr, &encoded_buffer.size, (uint8_t *)encoded_buffer.ptr);
}

bool _BrotliEncoderCompressStream(unsigned int state, BrotliEncoderOperation op, BrotliEncoderBuffer& input_buffer, BrotliEncoderBuffer& output_buffer) {
  return BrotliEncoderCompressStream((BrotliEncoderState*) state, op, &input_buffer.size, (const uint8_t **)&input_buffer.ptr, &output_buffer.size, (uint8_t **)&output_buffer.ptr, NULL);
}

bool _BrotliEncoderIsFinished(unsigned int state) {
  return BrotliEncoderIsFinished((BrotliEncoderState*) state);
}

bool _BrotliEncoderHasMoreOutput(unsigned int state) {
  return BrotliEncoderHasMoreOutput((BrotliEncoderState*) state);
}

// Structure setters/getters
static unsigned int BrotliEncoderBuffer_ptr_getter(const BrotliEncoderBuffer &buffer) {
  return (unsigned int)buffer.ptr;
}

static void BrotliEncoderBuffer_ptr_setter(BrotliEncoderBuffer &buffer, unsigned int ptr) {
  buffer.ptr = (void *)ptr;
}

EMSCRIPTEN_BINDINGS(BrotliEncoder) {
  // Wrapped functions
  function(""Version"", &_BrotliEncoderVersion);
  function(""SetParameter"", &_BrotliEncoderSetParameter);
  function(""CreateInstance"", &_BrotliEncoderCreateInstance);
  function(""DestroyInstance"", &_BrotliEncoderDestroyInstance);
  function(""PrepareDictionary"", &_BrotliEncoderPrepareDictionary);
  function(""DestroyPreparedDictionary"", &_BrotliEncoderDestroyPreparedDictionary);
  function(""GetPreparedDictionarySize"", &_BrotliEncoderGetPreparedDictionarySize);
  function(""AttachPreparedDictionary"", &_BrotliEncoderAttachPreparedDictionary);
  function(""MaxCompressedSize"", &_BrotliEncoderMaxCompressedSize);
  function(""Compress"", &_BrotliEncoderCompress);
  function(""CompressStream"", &_BrotliEncoderCompressStream);
  function(""HasMoreOutput"", &_BrotliEncoderHasMoreOutput);

  // Enums
  enum_<BrotliEncoderParameter>(""Parameter"")
    .value(""MODE"", BrotliEncoderParameter::BROTLI_PARAM_MODE)
    .value(""QUALITY"", BrotliEncoderParameter::BROTLI_PARAM_QUALITY)
    .value(""LGWIN"", BrotliEncoderParameter::BROTLI_PARAM_LGWIN)
    .value(""LGBLOCK"", BrotliEncoderParameter::BROTLI_PARAM_LGBLOCK)
    .value(""DISABLE_LITERAL_CONTEXT_MODELING"", BrotliEncoderParameter::BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING)
    .value(""SIZE_HINT"", BrotliEncoderParameter::BROTLI_PARAM_SIZE_HINT)
    .value(""LARGE_WINDOW"", BrotliEncoderParameter::BROTLI_PARAM_LARGE_WINDOW)
    .value(""NPOSTFIX"", BrotliEncoderParameter::BROTLI_PARAM_NPOSTFIX)
    .value(""NDIRECT"", BrotliEncoderParameter::BROTLI_PARAM_NDIRECT)
    .value(""STREAM_OFFSET"", BrotliEncoderParameter::BROTLI_PARAM_STREAM_OFFSET);

  enum_<BrotliSharedDictionaryType>(""SharedDictionaryType"")
    .value(""Raw"", BrotliSharedDictionaryType::BROTLI_SHARED_DICTIONARY_RAW)
    .value(""Serialized"", BrotliSharedDictionaryType::BROTLI_SHARED_DICTIONARY_SERIALIZED);

  enum_<BrotliEncoderMode>(""Mode"")
    .value(""GENERIC"", BrotliEncoderMode::BROTLI_MODE_GENERIC)
    .value(""TEXT"", BrotliEncoderMode::BROTLI_MODE_TEXT)
    .value(""FONT"", BrotliEncoderMode::BROTLI_MODE_FONT);

  enum_<BrotliEncoderOperation>(""Operation"")
    .value(""PROCESS"", BrotliEncoderOperation::BROTLI_OPERATION_PROCESS)
    .value(""FLUSH"", BrotliEncoderOperation::BROTLI_OPERATION_FLUSH)
    .value(""FINISH"", BrotliEncoderOperation::BROTLI_OPERATION_FINISH)
    .value(""EMIT_METADATA"", BrotliEncoderOperation::BROTLI_OPERATION_EMIT_METADATA);

  // Structures
  class_<BrotliEncoderBuffer>(""Buffer"")
    .constructor<>()
    .property(""ptr"", &BrotliEncoderBuffer_ptr_getter, &BrotliEncoderBuffer_ptr_setter)
    .property(""size"", &BrotliEncoderBuffer::size);
}
",data_ptr
657,"/*
  JOAAT.h - Implementation of the Jenkin's HASH for Arduino.
  Created by alessandromrc, 27 September 2022.
*/


#ifndef JOAAT_H_
#define JOAAT_H_

typedef const unsigned char* JOAAT_STR;


class JOAAT {
private:
  uint32_t encode(const uint8_t* key, size_t length) {
    size_t i = 0;
    uint32_t hash = 0;
    while (i != length) {
      hash += key[i++];
      hash += hash << 10;
      hash ^= hash >> 6;
    }
    hash += hash << 3;
    hash ^= hash >> 11;
    hash += hash << 15;
    return hash;
  }
public:

  uint32_t encode_str(JOAAT_STR str) {
    return encode(str, strlen((char*)str));
  }

  bool validate_string_checksum(JOAAT_STR str, uint32_t checksum) {
    if (encode_str(str) == checksum)
      return true;

    return false;
  }

  bool validate_checksum(uint32_t  [MASK] , uint32_t checksum2) {
    return ( [MASK]  == checksum2);
  }
};

#endif
",checksum1
658,"#include ""hzpch.h""
#include ""ImGuiLayer.h""

#include ""imgui.h""
#include ""OpenGL/ImGuiOpenGLRenderer.h""
#include ""GLFW/glfw3.h""
#include ""Hazel/Application.h""


namespace Hazel {

	ImGuiLayer::ImGuiLayer():Layer(""ImguiLayer"") 
	{

	}
	ImGuiLayer::~ImGuiLayer() {

	}


	void ImGuiLayer::OnAttach()
	{
		ImGui::CreateContext();
		ImGui::StyleColorsDark();

		ImGuiIO& io = ImGui::GetIO();
		io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;
		io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;

		//TEMPORARY:should eventually use Hazel key codes
		io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;
		io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT;
		io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
		io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
		io.KeyMap[ImGuiKey_PageUp] = GLFW_KEY_PAGE_UP;
		io.KeyMap[ImGuiKey_PageDown] = GLFW_KEY_PAGE_DOWN;
		io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME;
		io.KeyMap[ImGuiKey_End] = GLFW_KEY_END;
		io.KeyMap[ImGuiKey_Insert] = GLFW_KEY_INSERT;
		io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE;
		io.KeyMap[ImGuiKey_Backspace] = GLFW_KEY_BACKSPACE;
		io.KeyMap[ImGuiKey_Space] = GLFW_KEY_SPACE;
		io.KeyMap[ImGuiKey_Enter] = GLFW_KEY_ENTER;
		io.KeyMap[ImGuiKey_A] = GLFW_KEY_A;
		io.KeyMap[ImGuiKey_C] = GLFW_KEY_C;
		io.KeyMap[ImGuiKey_V] = GLFW_KEY_V;
		io.KeyMap[ImGuiKey_X] = GLFW_KEY_X;
		io.KeyMap[ImGuiKey_Y] = GLFW_KEY_Y;
		io.KeyMap[ImGuiKey_Z] = GLFW_KEY_Z;

		const char* glsl_version = ""#version 130"";
		ImGui_ImplOpenGL3_Init(glsl_version);
			
	}
	void ImGuiLayer::OnDetach()
	{

	}
	void ImGuiLayer::OnUpdate() 
	{
		
		ImGuiIO& io = ImGui::GetIO();
		Application& app = Application::Get();
		io.DisplaySize = ImVec2(app.GetWindow().GetWidth(), app.GetWindow().GetHeight());
		
		float time = (float)glfwGetTime();
		io.DeltaTime = m_Time > 0.0f ? (time - m_Time) : (1 / 60.0f);
		m_Time = time;
		
		ImGui_ImplOpenGL3_NewFrame();
		ImGui::NewFrame();


		static bool show = true;
		ImGui::ShowDemoWindow(&show);

		ImGui::Render();
		ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

	}
	void ImGuiLayer::OnEvent(Event& event) 
	{
		EventDispatcher dispatcher(event);
		dispatcher.Dispatch<MouseButtonPressedEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnMouseButtonPressedEvent));
		dispatcher.Dispatch<MouseButtonReleasedEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnMouseButtonReleasedEvent));
		dispatcher.Dispatch<MouseMovedEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnMouseMoveEvent));
		dispatcher.Dispatch<MouseScrolledEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnMouseScrolledEvent));
		dispatcher.Dispatch<KeyPressedEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnKeyPressedEvent));
		dispatcher.Dispatch<KeyTypedEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnKeTypedEvent));
		dispatcher.Dispatch<KeyReleasedEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnKeyReleasedEvent));
		dispatcher.Dispatch<WindowResizeEvent>(HZ_BIND_EVENT_FN(ImGuiLayer::OnWindowResizeEvent));
	}

	

	bool ImGuiLayer::OnMouseButtonPressedEvent(MouseButtonPressedEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		io.MouseDown[e.GetMouseButton()] = true;
		return false;
	}
	
	bool ImGuiLayer::OnMouseButtonReleasedEvent(MouseButtonReleasedEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		io.MouseDown[e.GetMouseButton()] = false;

		return false;
	}
	
	bool ImGuiLayer::OnMouseMoveEvent(MouseMovedEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		io.MousePos = ImVec2(e.GetX(), e.GetY());

		return false;
	}
	
	bool ImGuiLayer::OnMouseScrolledEvent(MouseScrolledEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		io.MouseWheel += e.GetYOffset();
		io.MouseWheelH += e.GetXOffset();

		return false;

	}
	
	bool ImGuiLayer::OnKeyPressedEvent(KeyPressedEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		io.KeysDown[e.GetKeyCode()] = true;

		io.KeyCtrl = io.KeysDown[GLFW_KEY_LEFT_CONTROL] || io.KeysDown[GLFW_KEY_RIGHT_CONTROL];
		io.KeyShift = io.KeysDown[GLFW_KEY_LEFT_SHIFT] || io.KeysDown[GLFW_KEY_RIGHT_SHIFT];
		io.KeyAlt = io.KeysDown[GLFW_KEY_LEFT_ALT] || io.KeysDown[GLFW_KEY_RIGHT_ALT];
		io.KeySuper = io.KeysDown[GLFW_KEY_LEFT_SUPER] || io.KeysDown[GLFW_KEY_RIGHT_SUPER];
		return false;
	}
	
	bool ImGuiLayer::OnKeyReleasedEvent(KeyReleasedEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		io.KeysDown[e.GetKeyCode()] = false;

		return false;
	}
	
	bool ImGuiLayer::OnKeTypedEvent(KeyTypedEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		int  [MASK]  = e.GetKeyCode();
		if ( [MASK]  > 0 &&  [MASK]  < 0x10000) {
			io.AddInputCharacter((unsigned short) [MASK] );
		}

		return false;
	}
	
	bool ImGuiLayer::OnWindowResizeEvent(WindowResizeEvent& e)
	{
		ImGuiIO& io = ImGui::GetIO();
		io.DisplaySize = ImVec2(e.GetWidth(), e.GetHeight());
		io.DisplayFramebufferScale = ImVec2(1.0f, 1.0f);

		return false;
	}

}",keycode
659,"#include <cstring>
#include <fstream>
#include <iostream>

#include <cartridge.h>
#include <tools.h>
#include <iomanip>
#include <cpu.h>
#include <sstream>
#include <vector>
#include <mbc.h>
Cartridge::Cartridge() {

}
const char* ROM_TYPES[0x100] = {
   nullptr
};



bool Cartridge::LoadROM(std::string  [MASK] ) {
	ROM_TYPES[0x00] = ""ROM ONLY"";
	ROM_TYPES[0x01] = ""MBC1"";
	ROM_TYPES[0x02] = ""MBC1+RAM"";
	ROM_TYPES[0x03] = ""MBC1+RAM+BATTERY"";
	ROM_TYPES[0x04] = ""0x04 ???"";
	ROM_TYPES[0x05] = ""MBC2"";
	ROM_TYPES[0x06] = ""MBC2+BATTERY"";
	ROM_TYPES[0x07] = ""0x07 ???"";
	ROM_TYPES[0x08] = ""ROM+RAM 1"";
	ROM_TYPES[0x09] = ""ROM+RAM+BATTERY 1"";
	ROM_TYPES[0x0A] = ""0x0A ???"";
	ROM_TYPES[0x0B] = ""MMM01"";
	ROM_TYPES[0x0C] = ""MMM01+RAM"";
	ROM_TYPES[0x0D] = ""MMM01+RAM+BATTERY"";
	ROM_TYPES[0x0E] = ""0x0E ???"";
	ROM_TYPES[0x0F] = ""MBC3+TIMER+BATTERY"";
	ROM_TYPES[0x10] = ""MBC3+TIMER+RAM+BATTERY 2"";
	ROM_TYPES[0x11] = ""MBC3"";
	ROM_TYPES[0x12] = ""MBC3+RAM 2"";
	ROM_TYPES[0x13] = ""MBC3+RAM+BATTERY 2"";
	ROM_TYPES[0x14] = ""0x14 ???"";
	ROM_TYPES[0x15] = ""0x15 ???"";
	ROM_TYPES[0x16] = ""0x16 ???"";
	ROM_TYPES[0x17] = ""0x17 ???"";
	ROM_TYPES[0x18] = ""0x18 ???"";
	ROM_TYPES[0x19] = ""MBC5"";
	ROM_TYPES[0x1A] = ""MBC5+RAM"";
	ROM_TYPES[0x1B] = ""MBC5+RAM+BATTERY"";
	ROM_TYPES[0x1C] = ""MBC5+RUMBLE"";
	ROM_TYPES[0x1D] = ""MBC5+RUMBLE+RAM"";
	ROM_TYPES[0x1E] = ""MBC5+RUMBLE+RAM+BATTERY"";
	ROM_TYPES[0x1F] = ""0x1F ???"";
	ROM_TYPES[0x20] = ""MBC6"";
	ROM_TYPES[0x21] = ""0x21 ???"";
	ROM_TYPES[0x22] = ""MBC7+SENSOR+RUMBLE+RAM+BATTERY"";
	ROM_TYPES[0xFC] = ""POCKET CAMERA"";
	ROM_TYPES[0xFD] = ""BANDAI TAMA5"";
	ROM_TYPES[0xFE] = ""HuC3"";
	ROM_TYPES[0xFF] = ""HuC1 + RAM + BATTERY"";

	tools.RenderToDisplay(""assets/loading"");
	std::ifstream file( [MASK] , std::ios::binary | std::ios::ate);

	if (file.is_open())
	{

		std::cout << ""[INFO] Loading ROM..\n"";
		// get size of file and allocate a buffer to hold the contents
		std::streampos size = file.tellg();
		char* buffer = new char[size];




		// go back to the beginning of the file and fill the buffer
		file.seekg(0, std::ios::beg);
		file.read(buffer, size);
		file.close();
		if (size > 32768) {
			std::cout << ""[INFO] ROM size is higher than 32768 bytes (32KB)! ROM will continue executing if it has MBC.\n"";
			//size = 0x8000;
		}
		if (size == 256) {
			std::cout << ""INFO: GameBoy Bootroom loaded.\n\n"";
			cpu.runningBootrom = true;
		}

		if (!cpu.runningBootrom) {
			cart.type = buffer[0x147];
			cart.rom_size = buffer[0x148];
			detect_mbc_type(cart.type);
			cart.rom_banks_count = size / 0x4000;
			cart.ram_banks_count = get_ram_banks_count(buffer[0x149]);
			std::cout << ""[INFO] ROM Type: "" << ROM_TYPES[cart.type] << "" | ROM Banks: "" << rom_banks_count << ""\n"";
		}



		// load the rom into the gb's memory, since its going to rom_data and not main memory, it wont start at 0x0100 (256 bytes)
		int logocount = 0;
		int titlecount = 0;
		std::string titleting = """";
		bool logomatches = true;
		int size_filter = size;
		if (size_filter > 32768)
			size_filter = 0x8000;

		
		for (int i = 0; i < size; ++i)
		{
			if (!cpu.runningBootrom) {
				if (i > 0x0103 && i < 0x0134) {
					logo[logocount] = buffer[i];
					if (logo[logocount] == cpu.nintendoLogo[logocount]) {

					}
					else {
						logomatches = false;
					}
					logocount++;


				}
				else if (i > 0x0133 && i < 0x0144) {
					title[titlecount] = buffer[i];
					titleting += title[titlecount];
					titlecount++;



				}
			}
			if(i >= 0x0100)
			rom_data[i] = buffer[i];
			else {
				rom_data[i] = cpu.dmg_bootrom[i];
			}

		}

		if (!cpu.runningBootrom) {
			uint16_t x = 0;
			for (uint16_t i = 0x0134; i <= 0x014C; i++) {
				x = x - rom_data[i] - 1;
			}
			cart.checksum = rom_data[0x014D];
			printf(""[INFO] Checksum : %2.2X (%s)\n"", cart.checksum, (x & 0xFF) ? ""PASSED"" : ""FAILED"");
		}
		
		if (logomatches) {
			printf(""[INFO] Nintendo logo matches!\n\n"");
		}
		else {
			printf(""[INFO] Nintendo logo doesn't match! This means this rom is not official, or its corrupted.\n\n"");

		}
		std::cout << ""[INFO] ROM '"" << titleting << ""' Loaded!\n\n"";



		// clean the buffer
		delete[] buffer;
		return true;
	}
	return false;

}
void Cartridge::detect_mbc_type(uint8_t type) {
	/*switch (type) {
	case 0x00:
	case 0x08:
	case 0x09:
		mbc = new MBC0(memory);
		break;
	case 0x01:
	case 0x02:
	case 0x03:
		mbc = new MBC1(memory, ram, rom_banks_count, ram_banks_count);
		break;
	case 0x05:
	case 0x06:
		mbc = new MBC2(memory, ram, rom_banks_count, ram_banks_count);
		break;
	case 0x0F:
	case 0x10:
	case 0x11:
	case 0x12:
	case 0x13:
		mbc = new MBC3(memory, ram, rom_banks_count, ram_banks_count);
		break;
	case 0x19:
	case 0x1A:
	case 0x1B:
	case 0x1C:
	case 0x1D:
	case 0x1E:
		mbc = new MBC5(memory, ram, rom_banks_count, ram_banks_count);
		break;
	default:
		std::cout << ""Unsupported MBC type: "" << type << std::endl;
		exit(1);
	}*/
}

int Cartridge::get_ram_banks_count(uint8_t type) {
	switch (type) {
	case 0x00:
		return 0;
		break;
	case 0x01:
		return 0;
		break;
	case 0x02:
		return 1;
		break;
	case 0x03:
		return 4;
		break;
	case 0x04:
		return 16;
		break;
	case 0x05:
		return 8;
		break;
	default:
		std::cout << ""Incorrect RAM type: "" << type << std::endl;
		exit(1);
	}
}
",filename
660,"#include <iostream>
#include <string>
#include <stdio.h>   // _fileno
#include <io.h>      // _get_osfhandle, _setmode
#include <fcntl.h>   // _O_U16TEXT, _O_U8TEXT
#include <windows.h>

using namespace std;

void utf16()
{
    /**
     * Using UTF-16 IO, the sink and source are UTF-16 encoded.
     *   - File I/O: ReadFile/WriteFile
     *   - Console Input: ReadConsoleW
     *   - Console Output: WriteConsoleW for each wchar, so only supports UCS-2
     */
    _setmode(_fileno(stdin), _O_U16TEXT);
    _setmode(_fileno(stdout), _O_U16TEXT);
    _setmode(_fileno(stderr), _O_U16TEXT);

    // write BOM (useful if output is redirected to file)
    wchar_t bom = '\xFF\xFE';
    wcout.write(&bom, 1);
    wcerr.write(&bom, 1);

    wstring s = L""UTF-16 [鑫][靐][龘][䲜][䨻][𠔻][𪚥]"";
    do {
       wcout << s << endl;
       wcerr << s << endl;
    } while (getline(wcin, s));
}

void utf8()
{
    /**
     * Using UTF-8 IO, the sink and source are UTF-8 encoded.
     *   - Input: ReadFile -> UTF-8 -> UTF-16
     *   - File Output: UTF-16 -> UTF-8 -> WriteFile
     *   - Console Output: same as UTF-16. WriteConsoleW for each wchar, so only supports UCS-2
     * 
     * Note: ReadFile/ReadConsoleA get ANSI characters from ConsoleInputCP, but SetConsoleCP(CP_UTF8) 
     * doesn't work since it only supports DBCS. See also
     * https://github.com/microsoft/terminal/blob/master/src/host/dbcs.cpp#TranslateUnicodeToOem.
     * The perfect solution is that using UTF-8 mode if stdin is redirected, or UTF-16 for console.
     * It should be fixed in UCRT to use ReadConsoleW as same as UTF-16 mode rather than ReadFile.
     */
    int  [MASK]  = _fileno(stdin);
    HANDLE hInput = reinterpret_cast<HANDLE>(_get_osfhandle( [MASK] ));
    DWORD mode;
    mode = GetConsoleMode(hInput, &mode) ? _O_U16TEXT : _O_U8TEXT;
    _setmode( [MASK] , mode);
    _setmode(_fileno(stdout), _O_U8TEXT);
    _setmode(_fileno(stderr), _O_U8TEXT);

    wstring s = L""UTF-8 [鑫][靐][龘][䲜][䨻][𠔻][𪚥]"";
    do {
        wcout << s << endl;
        wcerr << s << endl;
    } while (getline(wcin, s));
}

int wmain(int argc, wchar_t* argv[])
{
    // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/setmode#remarks
    // https://stackoverflow.com/questions/8947949/mixing-cout-and-wcout-in-same-program
    // Unicode translation mode of file is for wide IO functions and narrow is not supported.
    // Wide IO functions use direct I/O and have nothing to do with ACP and OEMCP.

    switch (argv[1] ? argv[1][0] : L'0')
    {
        case L'1': utf16(); break;
        case L'2': utf8(); break;
        default: wcout << L""1: UTF-16\n2: UTF-8\n"";
    }
}
",fdInput
661,"/*
 * SPDX-License-Identifier: Apache-2.0
 */


#include <algorithm>
#include <cmath>
#include <numeric>
#include ""onnx/defs/tensor/utils.h""

namespace ONNX_NAMESPACE {

static const char* Cast_ver9_doc = R""DOC(
The operator casts the elements of a given input tensor to a data type
specified by the 'to' argument and returns an output tensor of the same size in
the converted type. The 'to' argument must be one of the data types specified
in the 'DataType' enum field in the TensorProto message.

Casting from string tensor in plain (e.g., ""3.14"" and ""1000"") and scientific numeric representations
(e.g., ""1e-5"" and ""1E8"") to float types is supported. For example, converting string ""100.5"" to an integer may
result 100. There are some string literals reserved for special floating-point values;
""+INF"" (and ""INF""), ""-INF"", and ""NaN"" are positive infinity, negative infinity, and not-a-number, respectively.
Any string which can exactly match ""+INF"" in a case-insensitive way would be mapped to positive infinite. Similarly,
this case-insensitive rule is applied to ""INF"" and ""NaN"". When casting from numeric tensors
to string tensors, plain floating-point representation (such as ""314.15926"") would be used.
Converting non-numerical-literal string such as ""Hello World!"" is an undefined behavior. Cases
of converting string representing floating-point arithmetic value, such as ""2.718"", to INT is an undefined behavior.

Conversion from a numerical type to any numerical type is always allowed.
User must be aware of precision loss and value change caused by range difference between two types.
For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Cast,
    9,
    OpSchema()
        .SetDoc(Cast_ver9_doc)
        .Attr(
            ""to"",
            ""The data type to which the elements of the input tensor are cast. ""
            ""Strictly must be one of the types from DataType enum in TensorProto"",
            AttributeProto::INT)
        .Input(0, ""input"", ""Input tensor to be cast."", ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor with the same shape as input with type ""
            ""specified by the 'to' argument"",
            ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)"",
             ""tensor(string)""},
            ""Constrain input types. Casting from complex is not supported."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)"",
             ""tensor(string)""},
            ""Constrain output types. Casting to complex is not supported."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromAttributeToOutput(ctx, ""to"", 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* Reshape_ver13_doc = R""DOC(
Reshape the input tensor similar to numpy.reshape.
First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
At most one dimension of the new shape can be -1. In this case, the value is
inferred from the size of the tensor and the remaining dimensions. A dimension
could also be 0, in which case the actual dimension value is unchanged (i.e. taken
from the input tensor).)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Reshape,
    13,
    OpSchema()
        .SetDoc(Reshape_ver13_doc)
        .Input(0,
            ""data"",
            ""An input tensor."",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .Input(1,
            ""shape"",
            ""Specified shape for output."",
            ""tensor(int64)"",
            OpSchema::Single,
            true,
            1,
            OpSchema::NonDifferentiable)
        .Output(0,
            ""reshaped"",
            ""Reshaped data."",
            ""T"",
            OpSchema::Single,
            true,
            1,
            OpSchema::Differentiable)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types_with_bfloat(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape Inference if 2nd input data (the target shape) is available
          const TensorProto* targetShapeInitializer = ctx.getInputData(1);
          if (!targetShapeInitializer) {
            return;
          }
          // Make targetShape (0 -> same as originalShape, -1 -> inferred).
          // The targetShape vector represents the specified shape for output.
          std::vector<int64_t> targetShape;
          if (targetShapeInitializer->has_raw_data()) {
            const std::string& bytes = targetShapeInitializer->raw_data();
            targetShape.insert(
                targetShape.end(),
                reinterpret_cast<const int64_t*>(bytes.c_str()),
                reinterpret_cast<const int64_t*>(bytes.c_str() + bytes.size()));
          } else {
            const auto& data = targetShapeInitializer->int64_data();
            targetShape.insert(targetShape.end(), data.begin(), data.end());
          }

          // Iterate through targetShape, adding dimensions in the outputShape
          // TensorProto. If the targertShape dimension is -1, we do not set the
          // dimension value in this iteration, but we record the Dimension. If
          // targertShape dimension is 0, we attempt to propagate the dimension
          // value/param. If the value cannot be inferred, we set the flag in
          // the unresolveZeros vector. If targetShape dimension is positive, we
          // set the dimension value in the outputShape. We track the product of
          // the dimensions we are setting outputShape in the outputProduct
          // variable. The outputProduct will potentially be used for inferring
          // a dimension marked -1.
          auto* outputShape =
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          TensorShapeProto::Dimension* negativeOneDim = nullptr;
          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
          std::vector<bool> unresolvedZeros(targetShape.size(), false);
          int64_t outputProduct = 1;
          for (int i = 0; i < static_cast<int>(targetShape.size()); ++i) {
            // Add a new dimension to outputShape
            auto* new_dim = outputShape->add_dim();
            if (targetShape[i] == -1) {
              // Check if multiple -1's. If not, set negativeOneDim, marking
              // this dimension to potentially be filled in later.
              if (negativeOneDim) {
                fail_shape_inference(
                    ""Target shape may not have multiple -1 dimensions"");
              }
              negativeOneDim = new_dim;
            } else if (targetShape[i] == 0) {
              // Check if data input has a shape and if the index i is within
              // its bounds. If these conditions are satisfied, any dimension
              // value/param should be propogated. If dimension value cannot be
              // inferred, set the corresponding  unresolvedZeros flag to true.
              unresolvedZeros[i] = true;
              if (dataInputTensorType.has_shape()) {
                if (i >= dataInputTensorType.shape().dim_size()) {
                  fail_shape_inference(""Invalid position of 0"");
                }
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  const auto& dim_value =
                      dataInputTensorType.shape().dim(i).dim_value();
                  new_dim->set_dim_value(dim_value);
                  outputProduct *= dim_value;
                  unresolvedZeros[i] = false;
                } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
                  const auto& dim_param =
                      dataInputTensorType.shape().dim(i).dim_param();
                  new_dim->set_dim_param(dim_param);
                }
              }
            } else if (targetShape[i] > 0) {
              // Set the dimension value to targetShape[i]
              new_dim->set_dim_value(targetShape[i]);
              outputProduct *= targetShape[i];
            } else {
              // Check if value is less than -1; fail if so
              fail_shape_inference(""Invalid dimension value: "", targetShape[i]);
            }
          }

          // If negativeOneDim has been set, we attempt to infer its value. This
          // can be done if all dimension values for the data input tensor shape
          // are known other than the ones corresponding to unresolvedZeros
          // flags.
          if (negativeOneDim) {
            // First, attempt to compute product of data input shape dimensions
            // that are not marked by unresolvedZeros. If not possible, set the
            // inputProductValid flag to false.
            if (!outputProduct) {
              fail_shape_inference(""Invalid Target shape product of 0"");
            }
            int64_t inputProduct = 1;
            bool inputProductValid = true;
            if (!dataInputTensorType.has_shape()) {
              inputProductValid = false;
            } else {
              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  inputProduct *=
                      dataInputTensorType.shape().dim(i).dim_value();
                } else if (
                    i >= static_cast<int>(unresolvedZeros.size()) ||
                    !unresolvedZeros[i]) {
                  inputProductValid = false;
                  break;
                }
              }
            }
            if (inputProductValid) {
              if (inputProduct % outputProduct != 0) {
                fail_shape_inference(
                    ""Dimension could not be inferred: incompatible shapes"");
              }
              negativeOneDim->set_dim_value(inputProduct / outputProduct);
            }
          }
        }));

static const char* Reshape_ver5_doc = R""DOC(
Reshape the input tensor similar to numpy.reshape.
First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
At most one dimension of the new shape can be -1. In this case, the value is
inferred from the size of the tensor and the remaining dimensions. A dimension
could also be 0, in which case the actual dimension value is unchanged (i.e. taken
from the input tensor).)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Reshape,
    5,
    OpSchema()
        .SetDoc(Reshape_ver5_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Input(1, ""shape"", ""Specified shape for output."", ""tensor(int64)"")
        .Output(0, ""reshaped"", ""Reshaped data."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape Inference if 2nd input data (the target shape) is available
          const TensorProto* targetShapeInitializer = ctx.getInputData(1);
          if (!targetShapeInitializer) {
            return;
          }
          // Make targetShape (0 -> same as originalShape, -1 -> inferred).
          // The targetShape vector represents the specified shape for output.
          std::vector<int64_t> targetShape;
          if (targetShapeInitializer->has_raw_data()) {
            const std::string& bytes = targetShapeInitializer->raw_data();
            targetShape.insert(
                targetShape.end(),
                reinterpret_cast<const int64_t*>(bytes.c_str()),
                reinterpret_cast<const int64_t*>(bytes.c_str() + bytes.size()));
          } else {
            const auto& data = targetShapeInitializer->int64_data();
            targetShape.insert(targetShape.end(), data.begin(), data.end());
          }

          // Iterate through targetShape, adding dimensions in the outputShape
          // TensorProto. If the targertShape dimension is -1, we do not set the
          // dimension value in this iteration, but we record the Dimension. If
          // targertShape dimension is 0, we attempt to propagate the dimension
          // value/param. If the value cannot be inferred, we set the flag in
          // the unresolveZeros vector. If targetShape dimension is positive, we
          // set the dimension value in the outputShape. We track the product of
          // the dimensions we are setting outputShape in the outputProduct
          // variable. The outputProduct will potentially be used for inferring
          // a dimension marked -1.
          auto* outputShape =
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          TensorShapeProto::Dimension* negativeOneDim = nullptr;
          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
          std::vector<bool> unresolvedZeros(targetShape.size(), false);
          int64_t outputProduct = 1;
          for (int i = 0; i < static_cast<int>(targetShape.size()); ++i) {
            // Add a new dimension to outputShape
            auto* new_dim = outputShape->add_dim();
            if (targetShape[i] == -1) {
              // Check if multiple -1's. If not, set negativeOneDim, marking
              // this dimension to potentially be filled in later.
              if (negativeOneDim) {
                fail_shape_inference(
                    ""Target shape may not have multiple -1 dimensions"");
              }
              negativeOneDim = new_dim;
            } else if (targetShape[i] == 0) {
              // Check if data input has a shape and if the index i is within
              // its bounds. If these conditions are satisfied, any dimension
              // value/param should be propogated. If dimension value cannot be
              // inferred, set the corresponding  unresolvedZeros flag to true.
              unresolvedZeros[i] = true;
              if (dataInputTensorType.has_shape()) {
                if (i >= dataInputTensorType.shape().dim_size()) {
                  fail_shape_inference(""Invalid position of 0"");
                }
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  const auto& dim_value =
                      dataInputTensorType.shape().dim(i).dim_value();
                  new_dim->set_dim_value(dim_value);
                  outputProduct *= dim_value;
                  unresolvedZeros[i] = false;
                } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
                  const auto& dim_param =
                      dataInputTensorType.shape().dim(i).dim_param();
                  new_dim->set_dim_param(dim_param);
                }
              }
            } else if (targetShape[i] > 0) {
              // Set the dimension value to targetShape[i]
              new_dim->set_dim_value(targetShape[i]);
              outputProduct *= targetShape[i];
            } else {
              // Check if value is less than -1; fail if so
              fail_shape_inference(""Invalid dimension value: "", targetShape[i]);
            }
          }

          // If negativeOneDim has been set, we attempt to infer its value. This
          // can be done if all dimension values for the data input tensor shape
          // are known other than the ones corresponding to unresolvedZeros
          // flags.
          if (negativeOneDim) {
            // First, attempt to compute product of data input shape dimensions
            // that are not marked by unresolvedZeros. If not possible, set the
            // inputProductValid flag to false.
            if (!outputProduct) {
              fail_shape_inference(""Invalid Target shape product of 0"");
            }
            int64_t inputProduct = 1;
            bool inputProductValid = true;
            if (!dataInputTensorType.has_shape()) {
              inputProductValid = false;
            } else {
              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
                  inputProduct *=
                      dataInputTensorType.shape().dim(i).dim_value();
                } else if (
                    i >= static_cast<int>(unresolvedZeros.size()) ||
                    !unresolvedZeros[i]) {
                  inputProductValid = false;
                  break;
                }
              }
            }
            if (inputProductValid) {
              if (inputProduct % outputProduct != 0) {
                fail_shape_inference(
                    ""Dimension could not be inferred: incompatible shapes"");
              }
              negativeOneDim->set_dim_value(inputProduct / outputProduct);
            }
          }
        }));

static const char* Shape_ver1_doc = R""DOC(
Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Shape,
    1,
    OpSchema()
        .SetDoc(Shape_ver1_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""shape"", ""Shape of the input tensor"", ""T1"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Input tensor can be of arbitrary type."")
        .TypeConstraint(
            ""T1"",
            {""tensor(int64)""},
            ""Constrain output to int64 tensor."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(
              TensorProto::INT64);

          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          if (ctx.getInputType(0)->tensor_type().has_shape()) {
            ctx.getOutputType(0)
                ->mutable_tensor_type()
                ->mutable_shape()
                ->add_dim()
                ->set_dim_value(
                    ctx.getInputType(0)->tensor_type().shape().dim_size());
          }
        }));

static const char* Size_ver1_doc = R""DOC(
Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Size,
    1,
    OpSchema()
        .SetDoc(Size_ver1_doc)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""size"", ""Total number of elements of the input tensor"", ""T1"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Input tensor can be of arbitrary type."")
        .TypeConstraint(
            ""T1"",
            {""tensor(int64)""},
            ""Constrain output to int64 tensor, which should be a scalar though."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(
              TensorProto::INT64);
          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
        }));

ONNX_OPERATOR_SET_SCHEMA(
    Concat,
    11,
    OpSchema()
        .Attr(
            ""axis"",
            ""Which axis to concat on. A negative value means counting dimensions from the back. ""
            ""Accepted range is [-r, r-1] where r = rank(inputs).."",
            AttributeProto::INT)
        .SetDoc(
            ""Concatenate a list of tensors into a single tensor. ""
            ""All input tensors must have the same shape, except for the dimension size of the axis to concatenate on."")
        .Input(
            0,
            ""inputs"",
            ""List of tensors for concatenation"",
            ""T"",
            OpSchema::Variadic)
        .Output(0, ""concat_result"", ""Concatenated tensor"", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto numInputs = ctx.getNumInputs();
          if (numInputs < 1 ||
              !hasNInputShapes(ctx, static_cast<int>(numInputs))) {
            return;
          }

          auto rank = ctx.getInputType(0)->tensor_type().shape().dim_size();

          auto axisAttr = ctx.getAttribute(""axis"");
          if (!axisAttr) {
            fail_shape_inference(""Required attribute axis is missing"");
          }
          int axis = static_cast<int>(axisAttr->i());
          if (axis < -rank || axis >= rank) {
            fail_shape_inference(""axis must be in [-rank, rank-1]."");
          }
          if (axis < 0) {
            axis += rank;
          }

          if (numInputs == 1) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
            return;
          }

          bool all_lengths_known = true;
          int total_length = 0;

          auto* output_shape =
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (int64_t i = 0; i < rank; ++i) {
            output_shape->add_dim();
          }

          for (size_t i = 0; i < numInputs; i++) {
            const auto& shape = ctx.getInputType(i)->tensor_type().shape();
            if (shape.dim_size() != rank) {
              fail_shape_inference(""All inputs to Concat must have same rank"");
            }
            for (int j = 0; j < rank; j++) {
              if (j == axis) {
                if (shape.dim(j).has_dim_value()) {
                  total_length += static_cast<int>(shape.dim(j).dim_value());
                } else {
                  all_lengths_known = false;
                }
              } else {
                auto& output_dim = *output_shape->mutable_dim(j);
                const auto& input_dim = shape.dim(j);
                mergeInDimensionInfo(input_dim, output_dim, j);
              }
            }
          }

          if (all_lengths_known) {
            output_shape->mutable_dim(axis)->set_dim_value(total_length);
          }
        }));

static const char* Split_ver11_doc =
    R""DOC(Split a tensor into a list of tensors, along the specified
'axis'. Lengths of the parts can be specified using argument 'split'.
Otherwise, the tensor is split to equal sized parts.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Split,
    11,
    OpSchema()
        .Input(0, ""input"", ""The tensor to split"", ""T"")
        .Output(
            0,
            ""outputs"",
            ""One or more outputs forming list of tensors after splitting"",
            ""T"",
            OpSchema::Variadic)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .Attr(
            ""axis"",
            ""Which axis to split on. ""
            ""A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] ""
            ""where r = rank(input)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Attr(
            ""split"",
            ""length of each output. Values should be >= 0."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .SetDoc(Split_ver11_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
            propagateElemTypeFromInputToOutput(ctx, 0, i);
          }
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
          int rank = shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -rank || axis >= rank) {
            fail_type_inference(
                ""Invalid value of attribute 'axis'. Rank="",
                rank,
                "" Value="",
                axis);
          }
          if (axis < 0) {
            axis += rank;
          }
          const auto& split_dim = shape.dim(axis);
          if (!split_dim.has_dim_value()) {
            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() =
                  shape;
              ctx.getOutputType(i)
                  ->mutable_tensor_type()
                  ->mutable_shape()
                  ->mutable_dim(axis)
                  ->Clear();
            }
            return;
          }
          int split_dim_value = static_cast<int>(split_dim.dim_value());

          std::vector<int64_t> split;
          if (getRepeatedAttribute(ctx, ""split"", split)) {
            if (split.size() != ctx.getNumOutputs()) {
              fail_shape_inference(
                  ""Mismatch between number of splits ("",
                  split.size(),
                  "") and outputs ("",
                  ctx.getNumOutputs(),
                  "")"");
            }
            int64_t total_dim = 0;
            for (int64_t d : split) {
              total_dim += d;
            }
            if (total_dim != split_dim_value) {
              fail_shape_inference(
                  ""Mismatch between the sum of 'split' ("",
                  total_dim,
                  "") and the split dimension of the input ("",
                  split_dim_value,
                  "")"");
            }
          } else {
            int num_outputs = static_cast<int>(ctx.getNumOutputs());
            if (split_dim_value % num_outputs != 0) {
              fail_shape_inference(""The input is not evenly splittable"");
            }
            int chunk_size = split_dim_value / num_outputs;
            for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); i++) {
              split.push_back(chunk_size);
            }
          }
          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() =
                shape;
            ctx.getOutputType(i)
                ->mutable_tensor_type()
                ->mutable_shape()
                ->mutable_dim(axis)
                ->set_dim_value(split[i]);
          }
        }));

static const char* Slice_ver11_doc = R""DOC(
Produces a slice of the input tensor along multiple axes. Similar to numpy:
https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
dimension and step for each axis in the list of axes, it uses this information to
slice the input `data` tensor. If a negative value is passed for any of the
start or end indices, it represents number of elements before the end of that
dimension. If the value passed to start or end is larger than the `n` (the
number of elements in this dimension), it represents `n`. For slicing to the
end of a dimension with unknown size, it is recommended to pass in `INT_MAX`
when sclicing forward and 'INT_MIN' when slicing backward.
If a negative value is passed for step, it represents slicing backward.
However step value cannot be 0.
If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
Example 1:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  axes = [0, 1]
  starts = [1, 0]
  ends = [2, 3]
  steps = [1, 2]
  result = [
      [5, 7],
  ]
Example 2:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  starts = [0, 1]
  ends = [-1, 1000]
  result = [
      [2, 3, 4],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Slice,
    11,
    OpSchema()
        .SetDoc(Slice_ver11_doc)
        .Input(0, ""data"", ""Tensor of data to extract slices from."", ""T"")
        .Input(
            1,
            ""starts"",
            ""1-D tensor of starting indices of corresponding axis in `axes`"",
            ""Tind"")
        .Input(
            2,
            ""ends"",
            ""1-D tensor of ending indices (exclusive) of corresponding axis in `axes`"",
            ""Tind"")
        .Input(
            3,
            ""axes"",
            ""1-D tensor of axes that `starts` and `ends` apply to. Negative value means counting dimensions ""
            ""from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            ""Tind"",
            OpSchema::Optional)
        .Input(
            4,
            ""steps"",
            ""1-D tensor of slice step of corresponding axis in `axes`. ""
            ""Negative value means slicing backward. 'steps' cannot be 0. ""
            ""Defaults to 1."",
            ""Tind"",
            OpSchema::Optional)
        .Output(0, ""output"", ""Sliced data tensor."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeConstraint(
            ""Tind"",
            {""tensor(int32)"", ""tensor(int64)""},
            ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          size_t num_inputs = ctx.getNumInputs();
          if (num_inputs != 3 && num_inputs != 4 && num_inputs != 5) {
            fail_type_inference(
                ""Slice op must have either three, four or five inputs."");
          }
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          // Shape Inference if
          //     1. 2nd and 3rd input data (starts, ends) are available.
          // and 2. 4th and 5th optional input (axes, steps) are either not set,
          // or set and is initializer.
          const TensorProto* startsInitializer = ctx.getInputData(1);
          const TensorProto* endsInitializer = ctx.getInputData(2);
          const TensorProto* axesInitializer =
              hasInputShape(ctx, 3) ? ctx.getInputData(3) : nullptr;
          const TensorProto* stepsInitializer =
              hasInputShape(ctx, 4) ? ctx.getInputData(4) : nullptr;

          if (!startsInitializer || !endsInitializer ||
              (hasInputShape(ctx, 3) && !ctx.getInputData(3)) ||
              (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
            return;
          }

          // don't know data_type- can't proceed
          if (!startsInitializer->has_data_type())
            return;

          auto get_initializer_data =
              [](const TensorProto* initializer) -> std::vector<int64_t> {
            std::vector<int64_t> vec;
            if (initializer->data_type() == TensorProto::INT64) {
              const auto& data = ParseData<int64_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else if (initializer->data_type() == TensorProto::INT32) {
              const auto& data = ParseData<int32_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else {
              // unaccepted data type
              fail_shape_inference(
                  ""Only supports `int32_t` or `int64_t` inputs for starts/ends/axes/steps"");
            }
            return vec;
          };

          auto clamp = [](int64_t val, int64_t low, int64_t high) -> int64_t {
            if (val < low)
              return low;
            if (val > high)
              return high;
            return val;
          };

          std::vector<int64_t> starts = get_initializer_data(startsInitializer);
          std::vector<int64_t> ends = get_initializer_data(endsInitializer);

          if (starts.size() != ends.size()) {
            fail_shape_inference(
                ""Incorrect or missing input value for starts and ends"");
          }

          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();
          std::vector<int64_t> axes(starts.size());
          if (!axesInitializer) {
            std::iota(axes.begin(), axes.end(), 0);
          } else {
            axes = get_initializer_data(axesInitializer);
            if (axes.size() != starts.size()) {
              fail_shape_inference(""Input axes has incorrect length"");
            }
          }

          std::vector<int64_t> steps;
          if (!stepsInitializer) {
            steps = std::vector<int64_t>(starts.size(), 1);
          } else {
            steps = get_initializer_data(stepsInitializer);
            if (steps.size() != axes.size()) {
              fail_shape_inference(""Input steps has incorrect length"");
            }
          }

          for (size_t i = 0; (int64_t)i < input_rank; ++i) {
            // first update rank of output dim
            auto* output_dim = ctx.getOutputType(0)
                                   ->mutable_tensor_type()
                                   ->mutable_shape()
                                   ->add_dim();
            const auto& input_dim = input_shape.dim((int)i);
            if (input_dim.has_dim_value()) {
              output_dim->set_dim_value(input_dim.dim_value());
            } else if (input_dim.has_dim_param()) {
              output_dim->set_dim_param(input_dim.dim_param());
            }
          }

          std::unordered_set<int64_t> unique_axes;
          size_t axes_size = axes.size();
          for (size_t axis_index = 0; axis_index < axes_size; ++axis_index) {
            auto axis = axes[axis_index] < 0
                ? axes[axis_index] + static_cast<int64_t>(input_rank)
                : axes[axis_index];

            if (axis >= static_cast<int64_t>(input_rank) || axis < 0) {
              fail_shape_inference(""Input axes has invalid data"");
            }

            if (unique_axes.find(axis) != unique_axes.end()) {
              fail_shape_inference(""'axes' has duplicates"");
            }

            unique_axes.insert(axis);

            auto input_dim =
                ctx.getInputType(0)->tensor_type().shape().dim((int)axis);

            // input dim value is missing - cannot perform shape inference for
            // this axis
            if (!input_dim.has_dim_value()) {
              // Clear any previously propagated dim_param and leave this
              // dimension ""empty"", before moving on to the next dimension
              ctx.getOutputType(0)
                  ->mutable_tensor_type()
                  ->mutable_shape()
                  ->mutable_dim(static_cast<int>(axis))
                  ->clear_dim_param();
              continue;
            }

            const auto input_dim_value = input_dim.dim_value();

            // process step
            auto step = steps[axis_index];
            if (step == 0) {
              fail_shape_inference(""'step' cannot be 0"");
            }

            // process start
            auto start = starts[axis_index];
            if (start < 0)
              start += input_dim_value;
            if (step < 0)
              start = clamp(start, 0, input_dim_value - 1);
            else
              start = clamp(start, 0, input_dim_value);

            // process end
            auto end = ends[axis_index];
            if (end < 0)
              end += input_dim_value;
            if (step < 0)
              end = clamp(end, -1, input_dim_value);
            else
              end = clamp(end, 0, input_dim_value);

            // find output dim value for this axis
            auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / step));
            if (temp < 0)
              temp = 0;

            // assign output value
            ctx.getOutputType(0)
                ->mutable_tensor_type()
                ->mutable_shape()
                ->mutable_dim((int)axis)
                ->set_dim_value(temp);
          }
        }));

static const char* Transpose_ver1_doc = R""DOC(
Transpose the input tensor similar to numpy.transpose. For example, when
perm=(1, 0, 2), given an input tensor of shape (1, 2, 3), the output shape
will be (2, 1, 3).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Transpose,
    1,
    OpSchema()
        .SetDoc(Transpose_ver1_doc)
        .Attr(
            ""perm"",
            ""A list of integers. By default, reverse the dimensions, ""
            ""otherwise permute the axes according to the values given."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""transposed"", ""Transposed output."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          auto input_type = ctx.getInputType(0);
          const TensorShapeProto& shape = input_type->tensor_type().shape();
          std::vector<int64_t> perm;
          bool  [MASK]  = getRepeatedAttribute(ctx, ""perm"", perm);
          if (! [MASK] ) {
            for (int i = shape.dim_size() - 1; i >= 0; --i)
              perm.push_back(i);
          } else if (!perm.empty()) {
            // check if every index is valid
            for (int64_t fromDimIndex : perm)
              if (!(0 <= fromDimIndex && fromDimIndex < shape.dim_size())) {
                std::ostringstream oss;
                oss << ""Invalid attribute perm {"" << perm[0];
                for (size_t i = 1; i != perm.size(); ++i) {
                  oss << "", "" << perm[i];
                }
                oss << ""}, input shape = {"";
                if (shape.dim_size() > 0) {
                  oss << shape.dim(0).dim_value();
                  for (int i = 1; i != shape.dim_size(); ++i) {
                    oss << "", "" << shape.dim(i).dim_value();
                  }
                  oss << ""}"";
                }
                fail_type_inference(oss.str());
              }
          }

          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          for (size_t i = 0; i < perm.size(); ++i) {
            appendSingleDimCopiedFromInputTypeToOutputType(
                ctx, 0, 0, static_cast<size_t>(perm[i]));
          }
        }));

static const char* ScatterND_ver11_doc = R""DOC(
ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
is produced by creating a copy of the input `data`, and then updating its value to values
specified by `updates` at specific index positions specified by `indices`. Its output shape
is the same as the shape of `data`. Note that `indices` should not have duplicate entries.
That is, two or more `updates` for the same index-location is not supported.

`indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
 `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
update to a slice of the tensor.

`updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
The remaining dimensions of `updates` correspond to the dimensions of the
replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
of shapes.

The `output` is calculated via the following equation:

    output = np.copy(data)
    update_indices = indices.shape[:-1]
    for idx in np.ndindex(update_indices):
        output[indices[idx]] = updates[idx]

The order of iteration in the above loop is not specified.
In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
This ensures that the output value does not depend on the iteration order.

This operator is the inverse of GatherND.

Example 1:
```
  data    = [1, 2, 3, 4, 5, 6, 7, 8]
  indices = [[4], [3], [1], [7]]
  updates = [9, 10, 11, 12]
  output  = [1, 11, 3, 10, 9, 6, 7, 12]
```

Example 2:
```
  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
  indices = [[0], [2]]
  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterND,
    11,
    OpSchema()
        .SetDoc(ScatterND_ver11_doc)
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(1, ""indices"", ""Tensor of rank q >= 1."", ""tensor(int64)"")
        .Input(
            2,
            ""updates"",
            ""Tensor of rank q + r - indices_shape[-1] - 1."",
            ""T"")
        .Output(0, ""output"", ""Tensor of rank r >= 1."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* ScatterElements_ver11_doc = R""DOC(
ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
rank r >= 1 and an optional attribute axis that identifies an axis of `data`
(by default, the outer-most axis, that is axis 0). The output of the operation
is produced by creating a copy of the input `data`, and then updating its value
to values specified by `updates` at specific index positions specified by
`indices`. Its output shape is the same as the shape of `data`.

For each entry in `updates`, the target index in `data` is obtained by combining
the corresponding entry in `indices` with the index of the entry itself: the
index-value for dimension = axis is obtained from the value of the corresponding
entry in `indices` and the index-value for dimension != axis is obtained from the
index of the entry itself.

For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
is performed as below:
```
  output[indices[i][j]][j] = updates[i][j] if axis = 0,
  output[i][indices[i][j]] = updates[i][j] if axis = 1,
```

This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.

Example 1:
```
  data = [
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
  ]
  indices = [
      [1, 0, 2],
      [0, 2, 1],
  ]
  updates = [
      [1.0, 1.1, 1.2],
      [2.0, 2.1, 2.2],
  ]
  output = [
      [2.0, 1.1, 0.0]
      [1.0, 0.0, 2.2]
      [0.0, 2.1, 1.2]
  ]
```
Example 2:
```
  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
  indices = [[1, 3]]
  updates = [[1.1, 2.1]]
  axis = 1
  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    ScatterElements,
    11,
    OpSchema()
        .SetDoc(ScatterElements_ver11_doc)
        .Attr(
            ""axis"",
            ""Which axis to scatter on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be ""
            ""within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Input(
            2,
            ""updates"",
            ""Tensor of rank r >=1 (same rank and shape as indices)"",
            ""T"")
        .Output(0, ""output"", ""Tensor of rank r >= 1 (same rank as input)."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Input and output types can be of any tensor type."")
        .TypeConstraint(
            ""Tind"",
            {""tensor(int32)"", ""tensor(int64)""},
            ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* Gather_ver11_doc = R""DOC(
Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
them in an output tensor of rank q + (r - 1).

axis = 0 :

Let
k = indices[i_{0}, ..., i_{q-1}]
Then
output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]

```
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  indices = [
      [0, 1],
      [1, 2],
  ]
  output = [
      [
          [1.0, 1.2],
          [2.3, 3.4],
      ],
      [
          [2.3, 3.4],
          [4.5, 5.7],
      ],
  ]
```
axis = 1 :

Let
k = indices[i_{0}, ..., i_{q-1}]
Then
output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]

```
  data = [
      [1.0, 1.2, 1.9],
      [2.3, 3.4, 3.9],
      [4.5, 5.7, 5.9],
  ]
  indices = [
      [0, 2],
  ]
  axis = 1,
  output = [
      [
          [1.0, 1.9],
          [2.3, 3.9],
          [4.5, 5.9],
      ],
  ]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Gather,
    11,
    OpSchema()
        .SetDoc(Gather_ver11_doc)
        .Attr(
            ""axis"",
            ""Which axis to gather on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] ""
            ""along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Output(0, ""output"", ""Tensor of rank q + (r - 1)."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to any tensor type."")
        .TypeConstraint(
            ""Tind"",
            {""tensor(int32)"", ""tensor(int64)""},
            ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 2)) {
            return;
          }
          const TensorShapeProto& data_shape =
              ctx.getInputType(0)->tensor_type().shape();
          const TensorShapeProto& indices_shape =
              ctx.getInputType(1)->tensor_type().shape();
          int r = data_shape.dim_size();
          if (r < 1) {
            fail_shape_inference(""data tensor must have rank >= 1"");
          }
          int q = indices_shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -r || axis >= r) {
            fail_shape_inference(""axis must be in [-r, r-1]"");
          }
          if (axis < 0) {
            axis += r;
          }
          int out_rank = q + r - 1;
          if (out_rank == 0) {
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          }
          for (int i = 0; i < out_rank; ++i) {
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() = (i < axis) ? data_shape.dim(i) : // i < axis < r
                (i >= axis && i < axis + q) ? indices_shape.dim(i - axis)
                                            : // i - axis < q
                    data_shape.dim(i - q + 1); // i < out_rank < q + r - 1
          }
        }));

static const char* GatherElements_ver11_doc = R""DOC(

GatherElements takes two inputs `data` and `indices` of the same rank r >= 1
and an optional attribute `axis` that identifies an axis of `data`
(by default, the outer-most axis, that is axis 0). It is an indexing operation
that produces its output by indexing into the input data tensor at index
positions determined by elements of the `indices` tensor.
Its output shape is the same as the shape of `indices` and consists of one value
(gathered from the `data`) for each element in `indices`.

For instance, in the 3-D case (r = 3), the output produced is determined
by the following equations:
```
  out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
  out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
  out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,
```

This operator is also the inverse of ScatterElements. It is similar to Torch's gather operation.

Example 1:
```
  data = [
      [1, 2],
      [3, 4],
  ]
  indices = [
      [0, 0],
      [1, 0],
  ]
  axis = 1
  output = [
      [
        [1, 1],
        [4, 3],
      ],
  ]
```
Example 2:
```
  data = [
      [1, 2, 3],
      [4, 5, 6],
      [7, 8, 9],
  ]
  indices = [
      [1, 2, 0],
      [2, 0, 0],
  ]
  axis = 0
  output = [
      [
        [4, 8, 3],
        [7, 2, 3],
      ],
  ]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    GatherElements,
    11,
    OpSchema()
        .SetDoc(GatherElements_ver11_doc)
        .Attr(
            ""axis"",
            ""Which axis to gather on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, with the same rank r as the input. All index values are expected to be ""
            ""within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Output(0, ""output"", ""Tensor of the same shape as indices."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to any tensor type."")
        .TypeConstraint(
            ""Tind"",
            {""tensor(int32)"", ""tensor(int64)""},
            ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // propagate indices' shape to output if it exists
          if (hasInputShape(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 1, 0);
          }
        }));

static const char* Squeeze_ver11_doc = R""DOC(
Remove single-dimensional entries from the shape of a tensor.
Takes a  parameter `axes` with a list of axes to squeeze.
If `axes` is not provided, all the single dimensions will be removed from
the shape. If an axis is selected with shape entry not equal to one, an error is raised.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Squeeze,
    11,
    OpSchema()
        .Attr(
            ""axes"",
            ""List of integers indicating the dimensions to squeeze. Negative value means counting dimensions ""
            ""from the back. Accepted range is [-r, r-1] where r = rank(data)."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .SetDoc(Squeeze_ver11_doc)
        .Input(0, ""data"", ""Tensors with at least max(dims) dimensions."", ""T"")
        .Output(0, ""squeezed"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_ndim = input_shape.dim_size();
          std::transform(
              axes.begin(),
              axes.end(),
              axes.begin(),
              [&](int64_t axis) -> int64_t {
                return axis < 0 ? axis + input_ndim : axis;
              });

          for (int i = 0, j = 0; i < input_ndim; ++i) {
            if (std::find(axes.begin(), axes.end(), i) != axes.end()) {
              if (input_shape.dim(i).has_dim_value() &&
                  input_shape.dim(i).dim_value() != 1) {
                fail_shape_inference(
                    ""Dimension of input "",
                    i,
                    "" must be 1 instead of "",
                    input_shape.dim(i).dim_value());
              }
              ++j;
            } else {
              *ctx.getOutputType(0)
                   ->mutable_tensor_type()
                   ->mutable_shape()
                   ->add_dim() = input_shape.dim(i);
            }
          }
        }));

static const char* Unsqueeze_ver11_doc = R""DOC(
Insert single-dimensional entries to the shape of an input tensor (`data`).
Takes one required argument `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).

For example:
  Given an input tensor (`data`) of shape [3, 4, 5], then
  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].

The attribute `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
The order of values in `axes` does not matter and can come in any order.

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Unsqueeze,
    11,
    OpSchema()
        .Attr(
            ""axes"",
            ""List of integers indicating the dimensions to be inserted. Negative value means counting dimensions ""
            ""from the back. Accepted range is [-r, r-1] where r = rank(expanded)."",
            AttributeProto::INTS)
        .SetDoc(Unsqueeze_ver11_doc)
        .Input(0, ""data"", ""Original tensor"", ""T"")
        .Output(0, ""expanded"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }

          // validate 'axes' for duplicate entries
          std::unordered_set<int64_t> unique_values;
          for (const auto val : axes) {
            if (unique_values.find(val) != unique_values.end()) {
              fail_shape_inference(
                  ""'axes' attribute must not contain any duplicates"");
            }
            unique_values.insert(val);
          }

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_ndim = input_shape.dim_size();
          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
          for (auto& axe : axes) {
            if (axe < -output_ndim || axe >= output_ndim) {
              fail_shape_inference(
                  ""values in 'axes' are beyond the bounds of the computed output shape"");
            }
            if (axe < 0) {
              axe += output_ndim;
            }
          }

          // sort after correcting negative axes values (if any) in the previous
          // step
          std::sort(axes.begin(), axes.end());

          int j = 0;
          for (int i = 0; i < input_ndim; ++i) {
            while (static_cast<size_t>(j) < axes.size() &&
                   axes[j] ==
                       ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
              ctx.getOutputType(0)
                  ->mutable_tensor_type()
                  ->mutable_shape()
                  ->add_dim()
                  ->set_dim_value(1);
              ++j;
            }
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() =
                ctx.getInputType(0)->tensor_type().shape().dim(i);
          }
          while (static_cast<size_t>(j) < axes.size() &&
                 axes[j] ==
                     ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
            ctx.getOutputType(0)
                ->mutable_tensor_type()
                ->mutable_shape()
                ->add_dim()
                ->set_dim_value(1);
            ++j;
          }
        }));

static const char* SpaceToDepth_ver1_doc =
    R""DOC(SpaceToDepth rearranges blocks of spatial data into depth. More specifically,
this op outputs a copy of the input tensor where values from the height and width dimensions
are moved to the depth dimension.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    SpaceToDepth,
    1,
    OpSchema()
        .Attr(
            ""blocksize"",
            ""Blocks of [blocksize, blocksize] are moved."",
            AttributeProto::INT)
        .SetDoc(SpaceToDepth_ver1_doc)
        .Input(
            0,
            ""input"",
            ""Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth""
            "", H is the height and W is the width."",
            ""T"")
        .Output(
            0,
            ""output"",
            ""Output tensor of [N, C * blocksize * blocksize, H/blocksize, W/blocksize]."",
            ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto blocksize = getAttribute(ctx, ""blocksize"", 0);
          if (blocksize <= 0) {
            fail_shape_inference(""Blocksize must be positive"");
          }
          if (hasInputShape(ctx, 0)) {
            auto& input_shape = getInputShape(ctx, 0);
            if (input_shape.dim_size() == 4) {
              // TODO: Clarify what behavior should be if H or W is not a
              // multiple of blocksize.
              updateOutputShape(
                  ctx,
                  0,
                  {input_shape.dim(0),
                   input_shape.dim(1) * (blocksize * blocksize),
                   input_shape.dim(2) / blocksize,
                   input_shape.dim(3) / blocksize});
            } else {
              fail_shape_inference(""Input tensor must be 4-dimensional"");
            }
          }
        }));

static const char* DepthToSpace_ver11_doc =
    R""DOC(DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
the input tensor where values from the depth dimension are moved in spatial blocks to the height
and width dimensions. By default, `mode` = `DCR`.
In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
following order: depth, column, and then row. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])

tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])

y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])


In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
following order: column, row, and the depth. The output y is computed from the input x as below:

b, c, h, w = x.shape

tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])

tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])

y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    DepthToSpace,
    11,
    OpSchema()
        .Attr(
            ""blocksize"",
            ""Blocks of [blocksize, blocksize] are moved."",
            AttributeProto::INT)
        .Attr(
            ""mode"",
            ""DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order."",
            AttributeProto::STRING,
            std::string(""DCR""))
        .SetDoc(DepthToSpace_ver11_doc)
        .Input(
            0,
            ""input"",
            ""Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth""
            "", H is the height and W is the width."",
            ""T"")
        .Output(
            0,
            ""output"",
            ""Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]."",
            ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto blocksize = getAttribute(ctx, ""blocksize"", 0);
          if (blocksize <= 0) {
            fail_shape_inference(""Blocksize must be positive"");
          }
          if (hasInputShape(ctx, 0)) {
            auto& input_shape = getInputShape(ctx, 0);
            if (input_shape.dim_size() == 4) {
              // TODO: Clarify what behavior should be if C is not a multiple of
              // blocksize*blocksize.
              updateOutputShape(
                  ctx,
                  0,
                  {input_shape.dim(0),
                   input_shape.dim(1) / (blocksize * blocksize),
                   input_shape.dim(2) * blocksize,
                   input_shape.dim(3) * blocksize});
            } else {
              fail_shape_inference(""Input tensor must be 4-dimensional"");
            }
          }
        }));

static const char* Tile_ver6_doc =
    R""DOC(Constructs a tensor by tiling a given tensor.
This is the same as function `tile` in Numpy, but no broadcast.
For example A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Tile,
    6,
    OpSchema()
        .SetDoc(Tile_ver6_doc)
        .Input(0, ""input"", ""Input tensor of any shape."", ""T"")
        .Input(
            1,
            ""repeats"",
            ""1D int64 tensor of the same length as input's dimension number, ""
            ""includes numbers of repeated copies along input's dimensions."",
            ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor of the same dimension and type as tensor input. ""
            ""output_dim[i] = input_dim[i] * repeats[i]"",
            ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeConstraint(
            ""T1"",
            {""tensor(int64)""},
            ""Constrain repeat's type to int64 tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape inference

          // Needs atleast the first input to proceed
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();

          const auto* repeats_inputs = ctx.getInputData(1);

          auto* output_shape =
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          if (nullptr != repeats_inputs && hasNInputShapes(ctx, 2)) {
            // shape inference is possible only when 'repeats' is an initializer
            const auto& repeats_shape =
                ctx.getInputType(1)->tensor_type().shape();
            if (repeats_shape.dim_size() != 1 ||
                repeats_inputs->data_type() != TensorProto::INT64) {
                  fail_shape_inference(""'Repeats' input must be 1D tensor of type int64"");
            }

            const auto& repeats_data = ParseData<int64_t>(repeats_inputs);

            if (repeats_data.size() != static_cast<size_t>(input_rank)) {
              fail_shape_inference(
                  ""'Repeats' input has incorrect number of values. ""
                  ""The number of values in 'repeats' must be equal ""
                  ""to the number of input dimensions."");
            }

            for (size_t i = 0; (int64_t)i < input_rank; ++i) {
              const auto& input_dim = input_shape.dim((int)i);
              auto* output_dim = output_shape->add_dim();
              if (input_dim.has_dim_value()) {
                output_dim->set_dim_value(
                    input_dim.dim_value() * repeats_data[i]);
              }
            }
          } else {
            // Infer output shape's rank in any case (if repeats data is not
            // available)
            auto* output_shape_0 = getOutputShape(ctx, 0);
            for (size_t i = 0; (int64_t)i < input_rank; ++i) {
              output_shape_0->add_dim();
            }
          }
          return;
        }));

static const char* Resize_ver11_doc = R""DOC(
Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * (roi_end - roi_start) * scale) if input \""sizes\"" is not specified.
)DOC"";

static const char* Resize_attr_coordinate_transformation_mode_doc = R""DOC(
This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>

The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, length_original as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input ""roi"", scale = length_resized / length_original, <br/>

if coordinate_transformation_mode is ""half_pixel"", <br/>
x_original = (x_resized + 0.5) / scale - 0.5, <br/>

if coordinate_transformation_mode is ""pytorch_half_pixel"", <br/>
x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0, <br/>

if coordinate_transformation_mode is ""align_corners"", <br/>
x_original = x_resized * (length_original - 1) / (length_resized - 1), <br/>

if coordinate_transformation_mode is ""asymmetric"", <br/>
x_original = x_resized / scale, <br/>

if coordinate_transformation_mode is ""tf_half_pixel_for_nn"", <br/>
x_original = (x_resized + 0.5) / scale, <br/>

if coordinate_transformation_mode is ""tf_crop_and_resize"", <br/>
x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1).)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Resize,
    11,
    OpSchema()
        .Attr(
            ""mode"",
            ""Three interpolation modes: nearest (default), linear and cubic. ""
            ""The \""linear\"" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). ""
            ""The \""cubic\"" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor)."",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Attr(
            ""cubic_coeff_a"",
            ""The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75""
            "" (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. ""
            ""This attribute is valid only if \""mode\"" is \""cubic\""."",
            AttributeProto::FLOAT,
            static_cast<float>(-0.75))
        .Attr(
            ""exclude_outside"",
            ""If set to 1, the weight of sampling locations outside the tensor will be set to 0""
            "" and the weight will be renormalized so that their sum is 1.0. The default value is 0."",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Attr(
            ""coordinate_transformation_mode"",
            Resize_attr_coordinate_transformation_mode_doc,
            AttributeProto::STRING,
            std::string(""half_pixel""))
        .Attr(
            ""nearest_mode"",
            ""Four modes: round_prefer_floor (default, as known as round half down), round_prefer_ceil (as known as round half up), floor, ceil. Only used by nearest interpolation. It indicates how to get \""nearest\"" pixel in input tensor from x_original, so this attribute is valid only if \""mode\"" is \""nearest\""."",
            AttributeProto::STRING,
            std::string(""round_prefer_floor""))
        .Attr(
            ""extrapolation_value"",
            ""When coordinate_transformation_mode is \""tf_crop_and_resize\"" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f."",
            AttributeProto::FLOAT,
            static_cast<float>(0))
        .Input(0, ""X"", ""N-D tensor"", ""T1"")
        .Input(
            1,
            ""roi"",
            ""1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is \""tf_crop_and_resize\"""",
            ""T2"")
        .Input(
            2,
            ""scales"",
            ""The scale array along each dimension. It takes value greater than 0. If it's less than 1,""
            "" it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should""
            "" be the same as the rank of input 'X'. Only one of 'scales' and 'sizes' can be specified. If 'size' is needed, the user can use an empty string as the name of 'scales' in this operator's input list."",
            ""tensor(float)"")
        .Input(
            3,
            ""sizes"",
            ""The size of the output tensor. The number of elements of 'sizes' should be the same as the""
            "" rank of input 'X'. Only one of 'scales' and 'sizes' can be specified."",
            ""tensor(int64)"",
            OpSchema::Optional)
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T1"")
        .TypeConstraint(
            ""T1"",
            OpSchema::all_tensor_types(),
            ""Constrain input 'X' and output 'Y' to all tensor types."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain roi type to float or double."")
        .SetDoc(Resize_ver11_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          resizeShapeInference(ctx, true);
        }));

ONNX_OPERATOR_SET_SCHEMA(
    Identity,
    1,
    OpSchema()
        .SetDoc(""Identity operator"")
        .Input(0, ""input"", ""Input tensor"", ""T"")
        .Output(0, ""output"", ""Tensor to copy input into."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));

ONNX_OPERATOR_SET_SCHEMA(
    IsNaN,
    9,
    OpSchema()
        .SetDoc(R""DOC(Returns which elements of the input are NaN.)DOC"")
        .Input(0, ""X"", ""input"", ""T1"")
        .Output(0, ""Y"", ""output"", ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input types to float tensors."")
        .TypeConstraint(
            ""T2"",
            {""tensor(bool)""},
            ""Constrain output types to boolean tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          updateOutputElemType(ctx, 0, TensorProto::BOOL);
          if (hasInputShape(ctx, 0)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* NonZero_ver9_doc = R""DOC(
    Returns the indices of the elements that are non-zero
    (in row-major order - by dimension).
    NonZero behaves similar to numpy.nonzero:
    https://docs.scipy.org/doc/numpy/reference/generated/numpy.nonzero.html
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    NonZero,
    9,
    OpSchema()
        .SetDoc(NonZero_ver9_doc)
        .Input(0, ""X"", ""input"", ""T"")
        .Output(0, ""Y"", ""output"", ""tensor(int64)"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          updateOutputElemType(ctx, 0, TensorProto::INT64);
        }));

static const char* GatherND_ver12_doc = R""DOC(
Given `data` tensor of rank `r` >= 1, `indices` tensor of rank `q` >= 1, and `batch_dims` integer `b`, this operator gathers
slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1 - b`.

`indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
where each element defines a slice of `data`

`batch_dims` (denoted as `b`) is an integer indicating the number of batch dimensions, i.e the leading `b` number of dimensions of
`data` tensor and `indices` are representing the batches, and the gather starts from the `b+1` dimension.

Some salient points about the inputs' rank and shape:

1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`

2) The first `b` dimensions of the shape of `indices` tensor and `data` tensor must be equal.

3) b < min(q, r) is to be honored.

4) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r-b` (inclusive)

5) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
   It is an error if any of the index values are out of bounds.

The output is computed as follows:

The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.

1) If `indices_shape[-1] > r-b` => error condition

2) If `indices_shape[-1] == r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensors
   containing 1-D tensors of dimension `r-b`, where `N` is an integer equals to the product of 1 and all the elements in the batch dimensions
   of the indices_shape. Let us think of each such `r-b` ranked tensor as `indices_slice`. Each *scalar value* corresponding to `data[0:b-1,indices_slice]`
   is filled into the corresponding location of the `(q-b-1)`-dimensional tensor to form the `output` tensor (Example 1 below)

3) If `indices_shape[-1] < r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensor
   containing 1-D tensors of dimension `< r-b`. Let us think of each such tensors as `indices_slice`. Each *tensor slice* corresponding
   to `data[0:b-1, indices_slice , :]` is filled into the corresponding location of the `(q-b-1)`-dimensional tensor
   to form the `output` tensor (Examples 2, 3, 4 and 5 below)

This operator is the inverse of `ScatterND`.

`Example 1`

  batch_dims = 0

  data    = [[0,1],[2,3]]   # data_shape = [2, 2]

  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]

  output  = [0,3]           # output_shape = [2]

`Example 2`

  batch_dims = 0

  data    = [[0,1],[2,3]]  # data_shape = [2, 2]

  indices = [[1],[0]]      # indices_shape = [2, 1]

  output  = [[2,3],[0,1]]  # output_shape = [2, 2]

`Example 3`

  batch_dims = 0

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]

  output  = [[2,3],[4,5]]                 # output_shape = [2, 2]

`Example 4`

  batch_dims = 0

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]

  output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]

`Example 5`

  batch_dims = 1

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[1],[0]]             # indices_shape = [2, 1]

  output  = [[2,3],[4,5]]             # output_shape = [2, 2]


)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    GatherND,
    12,
    OpSchema()
        .SetDoc(GatherND_ver12_doc)
        .Attr(
            ""batch_dims"",
            ""The number of batch dimensions. The gather of indexing starts from dimension of data[batch_dims:]"",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] ""
            ""along axis of size s. It is an error if any of the index values are out of bounds."",
            ""tensor(int64)"")
        .Output(
            0,
            ""output"",
            ""Tensor of rank q + r - indices_shape[-1] - 1."",
            ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);

          // Shape inference
          if (!hasNInputShapes(ctx, 2)) {
            // cannot proceed with shape or rank inference
            return;
          }

          const auto& data_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto data_rank = data_shape.dim_size();

          const auto& indices_shape =
              ctx.getInputType(1)->tensor_type().shape();
          const auto indices_rank = indices_shape.dim_size();

          int64_t batch_dims_data = getAttribute(ctx, ""batch_dims"", 0);
          if (data_rank < 1 || indices_rank < 1) {
            fail_shape_inference(
                ""Both `data` and `indices` input tensors in GatherND op ""
                ""need to have rank larger than 0."");
          }

          // cannot ascertain if the input shapes are valid if shape of
          // `indices` is missing last dimension value so return at this point
          if (!indices_shape.dim(indices_rank - 1).has_dim_value()) {
            return;
          }

          const auto last_index_dimension =
              indices_shape.dim(indices_rank - 1).dim_value() + batch_dims_data;

          if (last_index_dimension > data_rank) {
            fail_shape_inference(
                ""Last dimension of `indices` input tensor in GatherND op ""
                ""must not be larger than the rank of `data` tensor"");
          }

          for (int i = 0; i < indices_rank - 1; ++i) {
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() = indices_shape.dim(i);
          }

          for (int i = static_cast<int>(last_index_dimension); i < data_rank;
               ++i) {
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() = data_shape.dim(i);
          }
        }));

static const char* Pad_ver11_doc = R""DOC(
Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
a padded tensor (`output`) is generated.

The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):

1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0)

2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis

3) `edge` - pads with the edge values of array


Example 1 (`constant` mode):
  Insert 0 pads to the beginning of the second dimension.

  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'constant'

  constant_value = 0.0

  output =
  [
      [0.0, 0.0, 1.0, 1.2],
      [0.0, 0.0, 2.3, 3.4],
      [0.0, 0.0, 4.5, 5.7],
  ]


Example 2 (`reflect` mode):
  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'reflect'

  output =
  [
      [1.0, 1.2, 1.0, 1.2],
      [2.3, 3.4, 2.3, 3.4],
      [4.5, 5.7, 4.5, 5.7],
  ]


Example 3 (`edge` mode):
  data =
  [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]

  pads = [0, 2, 0, 0]

  mode = 'edge'

  output =
  [
      [1.0, 1.0, 1.0, 1.2],
      [2.3, 2.3, 2.3, 3.4],
      [4.5, 4.5, 4.5, 5.7],
  ]

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Pad,
    11,
    OpSchema()
        .Attr(
            ""mode"",
            ""Supported modes: `constant`(default), `reflect`, `edge`"",
            AttributeProto::STRING,
            std::string(""constant""))
        .SetDoc(Pad_ver11_doc)
        .Input(0, ""data"", ""Input tensor."", ""T"")
        .Input(
            1,
            ""pads"",
            ""Tensor of integers indicating the number of padding elements to add or remove (if negative) ""
            ""at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. ""
            ""`pads` should be a 1D tensor of shape [2 * input_rank]. ""
            ""`pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...], ""
            ""where xi_begin is the number of pad values added at the beginning of axis `i` and ""
            ""xi_end, the number of pad values added at the end of axis `i`."",
            ""tensor(int64)"")
        .Input(
            2,
            ""constant_value"",
            ""(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0)."",
            ""T"",
            OpSchema::Optional)
        .Output(0, ""output"", ""Tensor after padding."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_numeric_types(),
            ""Constrains input and output to only numeric types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Shape inference needs the input data shape
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();

          // Infer output shape if 'pads' tensor is available
          const auto* pads_initializer = ctx.getInputData(1);
          if (nullptr != pads_initializer) {
            if (pads_initializer->dims_size() != 1 ||
                pads_initializer->data_type() != TensorProto::INT64) {
                  fail_shape_inference(""'pads' input must be a 1D (shape: [2 * input_rank]) tensor of type int64"");
            }

            const auto& pads_data = ParseData<int64_t>(pads_initializer);
            if (pads_data.size() != static_cast<size_t>(2 * input_rank)) {
              fail_shape_inference(""Pads has incorrect number of values"");
            }

            auto* output_shape =
                ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
            for (size_t i = 0; static_cast<int64_t>(i) < input_rank; ++i) {
              const auto& input_dim = input_shape.dim((int)i);
              auto* output_dim = output_shape->add_dim();
              if (input_dim.has_dim_value()) {
                output_dim->set_dim_value(
                    input_dim.dim_value() + pads_data[i] +
                    pads_data[i + input_rank]);
              } else if (pads_data[i] + pads_data[i + input_rank] == 0) {
                *output_dim = input_dim;
              }
            }
          } else {
            // Infer output shapes' rank in any case
            auto* output_shape_0 = getOutputShape(ctx, 0);
            for (size_t i = 0; static_cast<int64_t>(i) < input_rank; ++i) {
              output_shape_0->add_dim();
            }
          }
          return;
        }));

static const char* Cast_ver1_doc = R""DOC(
The operator casts the elements of a given input tensor to a data type
specified by the 'to' argument and returns an output tensor of the same size in
the converted type. The 'to' argument must be one of the data types specified
in the 'DataType' enum field in the TensorProto message.
NOTE: Casting to and from strings is not supported yet.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Cast,
    1,
    OpSchema()
        .SetDoc(Cast_ver1_doc)
        .Attr(
            ""to"",
            ""The data type to which the elements of the input tensor are cast. ""
            ""Strictly must be one of the types from DataType enum in TensorProto"",
            AttributeProto::STRING)
        .Input(0, ""input"", ""Input tensor to be cast."", ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor with the same shape as input with type ""
            ""specified by the 'to' argument"",
            ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain input types. Casting from strings and complex are not supported."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain output types. Casting to strings and complex are not supported.""));

static const char* Cast_ver6_doc = R""DOC(
The operator casts the elements of a given input tensor to a data type
specified by the 'to' argument and returns an output tensor of the same size in
the converted type. The 'to' argument must be one of the data types specified
in the 'DataType' enum field in the TensorProto message.
NOTE: Casting to and from strings is not supported yet.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Cast,
    6,
    OpSchema()
        .SetDoc(Cast_ver6_doc)
        .Attr(
            ""to"",
            ""The data type to which the elements of the input tensor are cast. ""
            ""Strictly must be one of the types from DataType enum in TensorProto"",
            AttributeProto::INT)
        .Input(0, ""input"", ""Input tensor to be cast."", ""T1"")
        .Output(
            0,
            ""output"",
            ""Output tensor with the same shape as input with type ""
            ""specified by the 'to' argument"",
            ""T2"")
        .TypeConstraint(
            ""T1"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain input types. Casting from strings and complex are not supported."")
        .TypeConstraint(
            ""T2"",
            {""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)"",
             ""tensor(int8)"",
             ""tensor(int16)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(uint8)"",
             ""tensor(uint16)"",
             ""tensor(uint32)"",
             ""tensor(uint64)"",
             ""tensor(bool)""},
            ""Constrain output types. Casting to strings and complex are not supported."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromAttributeToOutput(ctx, ""to"", 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* Concat_ver1_doc =
    R""DOC(Concatenate a list of tensors into a single tensor)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Concat,
    1,
    OpSchema()
        .Attr(
            ""axis"",
            ""Which axis to concat on.  Default value is 1."",
            AttributeProto::INT,
            OPTIONAL_VALUE)
        .SetDoc(Concat_ver1_doc)
        .Input(
            0,
            ""inputs"",
            ""List of tensors for concatenation"",
            ""T"",
            OpSchema::Variadic)
        .Output(0, ""concat_result"", ""Concatenated tensor"", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain output types to float tensors.""));

ONNX_OPERATOR_SET_SCHEMA(
    Concat,
    4,
    OpSchema()
        .Attr(""axis"", ""Which axis to concat on"", AttributeProto::INT)
        .SetDoc(""Concatenate a list of tensors into a single tensor"")
        .Input(
            0,
            ""inputs"",
            ""List of tensors for concatenation"",
            ""T"",
            OpSchema::Variadic)
        .Output(0, ""concat_result"", ""Concatenated tensor"", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto numInputs = ctx.getNumInputs();
          if (numInputs < 1 ||
              !hasNInputShapes(ctx, static_cast<int>(numInputs))) {
            return;
          }

          auto rank = ctx.getInputType(0)->tensor_type().shape().dim_size();

          auto axisAttr = ctx.getAttribute(""axis"");
          if (!axisAttr) {
            fail_shape_inference(""Required attribute axis is missing"");
          }
          int axis = static_cast<int>(axisAttr->i());
          if (rank <= axis) {
            fail_shape_inference(""rank must be greater than axis"");
          }
          if (axis < 0) {
            return; // TODO: check if negative axis must be supported
          }

          bool all_lengths_known = true;
          int total_length = 0;

          auto* output_shape =
              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (int64_t i = 0; i < rank; ++i) {
            output_shape->add_dim();
          }

          for (size_t i = 0; i < numInputs; i++) {
            const auto& shape = ctx.getInputType(i)->tensor_type().shape();
            if (shape.dim_size() != rank) {
              fail_shape_inference(""All inputs to Concat must have same rank"");
            }
            for (int j = 0; j < rank; j++) {
              if (j == axis) {
                if (shape.dim(j).has_dim_value()) {
                  total_length += static_cast<int>(shape.dim(j).dim_value());
                } else {
                  all_lengths_known = false;
                }
              } else {
                auto& output_dim = *output_shape->mutable_dim(j);
                const auto& input_dim = shape.dim(j);
                mergeInDimensionInfo(input_dim, output_dim, j);
              }
            }
          }

          if (all_lengths_known) {
            output_shape->mutable_dim(axis)->set_dim_value(total_length);
          }
        }));

static const char* Split_ver1_doc =
    R""DOC(Split a tensor into a list of tensors, along the specified
'axis'. The lengths of the split can be specified using argument 'axis' or
optional second input blob to the operator. Otherwise, the tensor is split
to equal sized parts.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Split,
    1,
    OpSchema()
        .Input(0, ""input"", ""The tensor to split"", ""T"")
        .Input(
            1,
            ""split"",
            ""Optional list of output lengths (see also arg 'split')"",
            ""T"",
            OpSchema::Optional)
        .Output(
            0,
            ""outputs..."",
            ""One or more outputs forming list of tensors after splitting"",
            ""T"",
            OpSchema::Variadic)
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input types to float tensors."")
        .Attr(
            ""axis"",
            ""Which axis to split on"",
            AttributeProto::INT,
            OPTIONAL_VALUE)
        .Attr(
            ""split"",
            ""length of each output"",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .SetDoc(Split_ver1_doc));

static const char* Pad_ver1_doc = R""DOC(
Given `data` tensor, paddings, mode, and value.
Example:
  Insert 0 paddings to the beginning of the second dimension.
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  paddings = [0, 0, 2, 0]
  output = [
      [
          [0.0, 0.0, 1.0, 1.2],
          [0.0, 0.0, 2.3, 3.4],
          [0.0, 0.0, 4.5, 5.7],
      ],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Pad,
    1,
    OpSchema()
        .Attr(
            ""paddings"",
            ""List of integers indicate the padding element count at the ""
            ""beginning and end of each axis, for 2D it is the number of pixel. ""
            ""`paddings` rank should be double of the input's rank. `paddings` format should be as follow ""
            ""[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels ""
            ""added at the beginning of axis `i` and xi_end, the number of pixels added at ""
            ""the end of axis `i`."",
            AttributeProto::INTS)
        .Attr(
            ""mode"",
            ""Three modes: constant(default), reflect, edge"",
            AttributeProto::STRING,
            std::string(""constant""))
        .Attr(
            ""value"",
            ""One float, indicates the value to be filled, default is 0"",
            AttributeProto::FLOAT,
            0.0f)
        .SetDoc(Pad_ver1_doc)
        .Input(0, ""data"", ""Input tensor."", ""T"")
        .Output(0, ""output"", ""Tensor after padding."", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input and output types to float tensors.""));

static const char* Reshape_ver1_doc = R""DOC(
Reshape the input tensor similar to numpy.reshape.
It takes a tensor as input and an argument `shape`. It outputs the reshaped tensor.
At most one dimension of the new shape can be -1. In this case, the value is
inferred from the size of the tensor and the remaining dimensions. A dimension
could also be 0, in which case the actual dimension value is unchanged (i.e. taken
from the input tensor).)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Reshape,
    1,
    OpSchema()
        .SetDoc(Reshape_ver1_doc)
        .Attr(""shape"", ""New shape"", AttributeProto::INTS, OPTIONAL_VALUE)
        // This attribute was added via AllowConsumed API in OpSchema.
        // After removing the API, we're now using the Attr API to simulate the
        // old definition.
        .Attr(
            ""consumed_inputs"",
            ""legacy optimization attribute."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .Input(0, ""data"", ""An input tensor."", ""T"")
        .Output(0, ""reshaped"", ""Reshaped data."", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input and output types to float tensors.""));

static const char* Upsample_ver1_doc = R""DOC(
Upsample the input tensor.
The width and height of the output tensor are:
  output_width = floor(input_width * width_scale),
  output_height = floor(input_height * height_scale).
Example:
  Given `data` tensor, width_scale, height_scale, mode,
  Upsample the input 4-D tensor in nearest mode:
  data = [[[
      [1, 2],
      [3, 4]
  ]]]
  width_scale = 2
  height_scale = 2
  mode = ""nearest""
  output = [[[
      [1, 1, 2, 2],
      [1, 1, 2, 2],
      [3, 3, 4, 4],
      [3, 3, 4, 4]
  ]]]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Tile,
    1,
    OpSchema()
        .SetDoc(""Repeat the elements of a tensor along an axis."")
        .Input(0, ""input"", ""Input tensor of any shape."", ""T"")
        .Input(
            1,
            ""tiles"",
            ""Number of repeated copies to make of the input tensor."",
            ""T"")
        .Input(2, ""axis"", ""Axis along which to repeat."", ""T"")
        .Output(
            0,
            ""output"",
            ""Output tensor of same shape and type as input."",
            ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input types to float tensors."")
        .TypeConstraint(
            ""T1"",
            {""tensor(int64)""},
            ""Constrain tiles and axis's type to int64 tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          // Only rank of output can be inferred. We can do better if second
          // input is a constant, but this requires extending InferenceContext
          // interface to get values of constant inputs.
        }));

ONNX_OPERATOR_SET_SCHEMA(
    Upsample,
    1,
    OpSchema()
        .SetSupportLevel(OpSchema::SupportType::EXPERIMENTAL)
        .Attr(
            ""width_scale"",
            ""The scale along width dimension. It takes value greater than or equal to 1."",
            AttributeProto::FLOAT)
        .Attr(
            ""height_scale"",
            ""The scale along height dimension. It takes value greater than or equal to 1."",
            AttributeProto::FLOAT)
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest(default), bilinear"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""4-D tensor, [N,C,H,W]"", ""T"")
        .Output(0, ""Y"", ""4-D tensor after resizing, [N,C,H,W]"", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(bool)"",
             ""tensor(int32)"",
             ""tensor(int64)"",
             ""tensor(float16)"",
             ""tensor(float)"",
             ""tensor(double)""},
            ""Constrain output types to bool, int32, int64, float16, float, double tensors."")
        .SetDoc(Upsample_ver1_doc));

static const char* Upsample_ver7_doc = R""DOC(
Upsample the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * scale).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Upsample,
    7,
    OpSchema()
        .Attr(
            ""scales"",
            ""The scale array along each dimension. It takes value greater than or equal to 1.""
            "" The number of elements of 'scales' should be the same as the rank of input 'X'."",
            AttributeProto::FLOATS)
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""N-D tensor"", ""T"")
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .SetDoc(Upsample_ver7_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          const auto& input_shape = getInputShape(ctx, 0);
          auto* output_shape = getOutputShape(ctx, 0);
          const auto* scales = ctx.getAttribute(""scales"");

          if (output_shape->dim_size() > 0) {
            if (output_shape->dim_size() != input_shape.dim_size()) {
              fail_shape_inference(
                  ""Ranks inferred ("",
                  input_shape.dim_size(),
                  "") is not equal to the existing rank value ("",
                  output_shape->dim_size(),
                  "")."");
            }
          } else { // Infer the rank of output anyway
            for (int i = 0; i < input_shape.dim_size(); ++i) {
              output_shape->add_dim();
            }
          }

          if (nullptr != scales) {
            // Infer output shape's dimension value if 'scales' is known.
            if (scales->type() == AttributeProto_AttributeType_FLOATS) {
              const std::vector<float> scales_data(
                  scales->floats().begin(), scales->floats().end());
              if (scales_data.size() !=
                  static_cast<size_t>(input_shape.dim_size())) {
                fail_shape_inference(
                    ""Number of elements of attribute 'scales' must be same as rank of input 'X'"");
              }
              resizeShapeInferenceHelper_opset7_to_10(
                  input_shape, scales_data, output_shape);
            } else {
              fail_shape_inference(""Attribute 'scales' must have floats type."");
            } // scales->type() == float
          } else {
            fail_shape_inference(""Attribute 'scales' is required."");
          } // nullptr != scales
        }));

static const char* Upsample_ver9_doc = R""DOC(
Upsample the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * scale).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Upsample,
    9,
    OpSchema()
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""N-D tensor"", ""T"")
        .Input(
            1,
            ""scales"",
            ""The scale array along each dimension. It takes value greater than or equal to 1.""
            "" The number of elements of 'scales' should be the same as the rank of input 'X'."",
            ""tensor(float)"")
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input 'X' and output 'Y' to all tensor types."")
        .SetDoc(Upsample_ver9_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          resizeShapeInference_opset7_to_10(ctx);
        }));

static const char* Resize_ver10_doc = R""DOC(
Resize the input tensor.
Each dimension value of the output tensor is:
  output_dimension = floor(input_dimension * scale).
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Resize,
    10,
    OpSchema()
        .Attr(
            ""mode"",
            ""Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)"",
            AttributeProto::STRING,
            std::string(""nearest""))
        .Input(0, ""X"", ""N-D tensor"", ""T"")
        .Input(
            1,
            ""scales"",
            ""The scale array along each dimension. It takes value greater than 0. If it's less than 1,""
            "" it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should""
            "" be the same as the rank of input 'X'."",
            ""tensor(float)"")
        .Output(0, ""Y"", ""N-D tensor after resizing"", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input 'X' and output 'Y' to all tensor types."")
        .SetDoc(Resize_ver10_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          resizeShapeInference_opset7_to_10(ctx);
        }));

static const char* Slice_ver1_doc = R""DOC(
Produces a slice of the input tensor along multiple axes. Similar to numpy:
https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
Slices uses `axes`, `starts` and `ends` attributes to specify the start and end
dimension for each axis in the list of axes, it uses this information to
slice the input `data` tensor. If a negative value is passed for any of the
start or end indices, it represent number of elements before the end of that
dimension. If the value passed to start or end is larger than the `n` (the
number of elements in this dimension), it represents `n`. For slicing to the
end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
Example 1:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  axes = [0, 1]
  starts = [1, 0]
  ends = [2, 3]
  result = [
      [5, 6, 7],
  ]
Example 2:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  starts = [0, 1]
  ends = [-1, 1000]
  result = [
      [2, 3, 4],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Slice,
    1,
    OpSchema()
        .SetDoc(Slice_ver1_doc)
        .Input(0, ""data"", ""Tensor of data to extract slices from."", ""T"")
        .Attr(
            ""axes"",
            ""Axes that `starts` and `ends` apply to. ""
            ""It's optional. If not present, will be treated as ""
            ""[0, 1, ..., len(`starts`) - 1]."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .Attr(
            ""starts"",
            ""Starting indices of corresponding axis in `axes`"",
            AttributeProto::INTS)
        .Attr(
            ""ends"",
            ""Ending indices (exclusive) of corresponding axis in axes`"",
            AttributeProto::INTS)
        .Output(0, ""output"", ""Sliced data tensor."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          std::vector<int64_t> starts;
          std::vector<int64_t> ends;
          if (!getRepeatedAttribute(ctx, ""starts"", starts) ||
              !getRepeatedAttribute(ctx, ""ends"", ends) ||
              starts.size() != ends.size()) {
            fail_shape_inference(
                ""Incorrect or missing attribute value for starts and ends"");
            ;
          }
          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            for (int i = 0; (size_t)i < starts.size(); ++i) {
              axes.push_back(i);
            }
          } else if (axes.size() != starts.size()) {
            fail_shape_inference(""Attribute axes has incorrect length"");
            ;
          } else if (!std::is_sorted(axes.begin(), axes.end())) {
            // TODO support shape inference for unsorted axes
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (size_t i = 0, j = 0; (int64_t)i <
               ctx.getInputType(0)->tensor_type().shape().dim_size();
               ++i) {
            auto* newdim = ctx.getOutputType(0)
                               ->mutable_tensor_type()
                               ->mutable_shape()
                               ->add_dim();
            if (j < axes.size() && static_cast<size_t>(axes[j]) == i) {
              // There's a lot of potential behaviors. For now just
              // handle some simple cases.
              if (ctx.getInputType(0)
                      ->tensor_type()
                      .shape()
                      .dim((int)i)
                      .has_dim_value() &&
                  starts[j] >= 0 && ends[j] >= 0) {
                auto newval = std::min(
                                  (int64_t)ctx.getInputType(0)
                                      ->tensor_type()
                                      .shape()
                                      .dim((int)i)
                                      .dim_value(),
                                  ends[j]) -
                    starts[j];
                if (newval >= 0) {
                  newdim->set_dim_value(newval);
                }
              }
              ++j;
            } else {
              *newdim = ctx.getInputType(0)->tensor_type().shape().dim((int)i);
            }
          }
        }));

static const char* Slice_ver10_doc = R""DOC(
Produces a slice of the input tensor along multiple axes. Similar to numpy:
https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
dimension and step for each axis in the list of axes, it uses this information to
slice the input `data` tensor. If a negative value is passed for any of the
start or end indices, it represent number of elements before the end of that
dimension. If the value passed to start or end is larger than the `n` (the
number of elements in this dimension), it represents `n`. For slicing to the
end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
If a negative value is passed for step, it represents slicing backward.
If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
Example 1:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  axes = [0, 1]
  starts = [1, 0]
  ends = [2, 3]
  steps = [1, 2]
  result = [
      [5, 7],
  ]
Example 2:
  data = [
      [1, 2, 3, 4],
      [5, 6, 7, 8],
  ]
  starts = [0, 1]
  ends = [-1, 1000]
  result = [
      [2, 3, 4],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Slice,
    10,
    OpSchema()
        .SetDoc(Slice_ver10_doc)
        .Input(0, ""data"", ""Tensor of data to extract slices from."", ""T"")
        .Input(
            1,
            ""starts"",
            ""1-D tensor of starting indices of corresponding axis in `axes`"",
            ""Tind"")
        .Input(
            2,
            ""ends"",
            ""1-D tensor of ending indices (exclusive) of corresponding axis in `axes`"",
            ""Tind"")
        .Input(
            3,
            ""axes"",
            ""1-D tensor of axes that `starts` and `ends` apply to."",
            ""Tind"",
            OpSchema::Optional)
        .Input(
            4,
            ""steps"",
            ""1-D tensor of slice step of corresponding axis in `axes`. Default to 1. "",
            ""Tind"",
            OpSchema::Optional)
        .Output(0, ""output"", ""Sliced data tensor."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeConstraint(
            ""Tind"",
            {""tensor(int32)"", ""tensor(int64)""},
            ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          size_t num_inputs = ctx.getNumInputs();
          if (num_inputs != 3 && num_inputs != 4 && num_inputs != 5) {
            fail_type_inference(
                ""Slice op must have either three, four or five inputs."");
          }
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }
          // Shape Inference if
          //     1. 2nd and 3rd input data (starts, ends) are available.
          // and 2. 4th and 5th optional input (axes, steps) are either not set,
          // or set and is initializer.
          const TensorProto* startsInitializer = ctx.getInputData(1);
          const TensorProto* endsInitializer = ctx.getInputData(2);
          const TensorProto* axesInitializer =
              hasInputShape(ctx, 3) ? ctx.getInputData(3) : nullptr;
          const TensorProto* stepsInitializer =
              hasInputShape(ctx, 4) ? ctx.getInputData(4) : nullptr;

          if (!startsInitializer || !endsInitializer ||
              (hasInputShape(ctx, 3) && !ctx.getInputData(3)) ||
              (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
            return;
          }

          // don't know data_type- can't proceed
          if (!startsInitializer->has_data_type())
            return;

          auto get_initializer_data =
              [](const TensorProto* initializer) -> std::vector<int64_t> {
            std::vector<int64_t> vec;
            if (initializer->data_type() == TensorProto::INT64) {
              const auto& data = ParseData<int64_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else if (initializer->data_type() == TensorProto::INT32) {
              const auto& data = ParseData<int32_t>(initializer);
              vec.insert(vec.end(), data.begin(), data.end());
            } else {
              // unaccepted data type
              fail_shape_inference(
                  ""Only supports `int32_t` or `int64_t` inputs for starts/ends/axes/steps"");
            }
            return vec;
          };

          auto clamp = [](int64_t val, int64_t low, int64_t high) -> int64_t {
            if (val < low)
              return low;
            if (val > high)
              return high;
            return val;
          };

          std::vector<int64_t> starts = get_initializer_data(startsInitializer);
          std::vector<int64_t> ends = get_initializer_data(endsInitializer);

          if (starts.size() != ends.size()) {
            fail_shape_inference(
                ""Incorrect or missing input value for starts and ends"");
          }

          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto input_rank = input_shape.dim_size();
          std::vector<int64_t> axes(starts.size());
          if (!axesInitializer) {
            std::iota(axes.begin(), axes.end(), 0);
          } else {
            axes = get_initializer_data(axesInitializer);
            if (axes.size() != starts.size()) {
              fail_shape_inference(""Input axes has incorrect length"");
            }
          }

          std::vector<int64_t> steps;
          if (!stepsInitializer) {
            steps = std::vector<int64_t>(starts.size(), 1);
          } else {
            steps = get_initializer_data(stepsInitializer);
            if (steps.size() != axes.size()) {
              fail_shape_inference(""Input steps has incorrect length"");
            }
          }

          for (size_t i = 0; (int64_t)i < input_rank; ++i) {
            // first update rank of output dim
            auto* output_dim = ctx.getOutputType(0)
                                   ->mutable_tensor_type()
                                   ->mutable_shape()
                                   ->add_dim();
            const auto& input_dim = input_shape.dim((int)i);
            if (input_dim.has_dim_value()) {
              output_dim->set_dim_value(input_dim.dim_value());
            } else if (input_dim.has_dim_param()) {
              output_dim->set_dim_param(input_dim.dim_param());
            }
          }

          std::unordered_set<int64_t> unique_axes;
          size_t axes_size = axes.size();
          for (size_t axis_index = 0; axis_index < axes_size; ++axis_index) {
            auto axis = axes[axis_index] < 0
                ? axes[axis_index] + static_cast<int64_t>(input_rank)
                : axes[axis_index];

            if (axis >= static_cast<int64_t>(input_rank) || axis < 0) {
              fail_shape_inference(""Input axes has invalid data"");
            }

            if (unique_axes.find(axis) != unique_axes.end()) {
              fail_shape_inference(""'axes' has duplicates"");
            }

            unique_axes.insert(axis);
            auto input_dim =
                ctx.getInputType(0)->tensor_type().shape().dim((int)axis);

            // input dim value is missing - cannot perform shape inference for
            // this axis
            if (!input_dim.has_dim_value())
              continue;

            const auto input_dim_value = input_dim.dim_value();

            // process step
            auto step = steps[axis_index];
            if (step == 0) {
              fail_shape_inference(""'step' cannot be 0"");
            }

            // process start
            auto start = starts[axis_index];
            if (start < 0)
              start += input_dim_value;
            if (step < 0)
              start = clamp(start, 0, input_dim_value - 1);
            else
              start = clamp(start, 0, input_dim_value);

            // process end
            auto end = ends[axis_index];
            if (end < 0)
              end += input_dim_value;
            if (step < 0)
              end = clamp(end, -1, input_dim_value);
            else
              end = clamp(end, 0, input_dim_value);

            // find output dim value for this axis
            auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / step));
            if (temp < 0)
              temp = 0;

            // assign output value
            ctx.getOutputType(0)
                ->mutable_tensor_type()
                ->mutable_shape()
                ->mutable_dim((int)axis)
                ->set_dim_value(temp);
          }
        }));

static const char* Scatter_ver9_doc = R""DOC(
Given `data`, `updates` and `indices` input tensors of rank r >= 1, write the values provided by `updates`
into the first input, `data`, along `axis` dimension of `data` (by default outer-most one as axis=0) at corresponding `indices`.
For each entry in `updates`, the target index in `data` is specified by corresponding entry in `indices`
for dimension = axis, and index in source for dimension != axis. For instance, in a 2-D tensor case,
data[indices[i][j]][j] = updates[i][j] if axis = 0, or data[i][indices[i][j]] = updates[i][j] if axis = 1,
where i and j are loop counters from 0 up to the respective size in `updates` - 1.
Example 1:
  data = [
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
      [0.0, 0.0, 0.0],
  ]
  indices = [
      [1, 0, 2],
      [0, 2, 1],
  ]
  updates = [
      [1.0, 1.1, 1.2],
      [2.0, 2.1, 2.2],
  ]
  output = [
      [2.0, 1.1, 0.0]
      [1.0, 0.0, 2.2]
      [0.0, 2.1, 1.2]
  ]
Example 2:
  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
  indices = [[1, 3]]
  updates = [[1.1, 2.1]]
  axis = 1
  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Scatter,
    9,
    OpSchema()
        .SetDoc(Scatter_ver9_doc)
        .Attr(
            ""axis"",
            ""Which axis to scatter on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1]"",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of r >= 1 (same rank as input)."",
            ""Tind"")
        .Input(
            2,
            ""updates"",
            ""Tensor of rank r >=1 (same rank and shape as indices)"",
            ""T"")
        .Output(0, ""output"", ""Tensor of rank r >= 1 (same rank as input)."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Input and output types can be of any tensor type."")
        .TypeConstraint(
            ""Tind"",
            {""tensor(int32)"", ""tensor(int64)""},
            ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (hasNInputShapes(ctx, 1)) {
            propagateShapeFromInputToOutput(ctx, 0, 0);
          }
        }));

static const char* DepthToSpace_ver1_doc =
    R""DOC(DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
the input tensor where values from the depth dimension are moved in spatial blocks to the height
and width dimensions.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    DepthToSpace,
    1,
    OpSchema()
        .Attr(
            ""blocksize"",
            ""Blocks of [blocksize, blocksize] are moved."",
            AttributeProto::INT)
        .SetDoc(DepthToSpace_ver1_doc)
        .Input(
            0,
            ""input"",
            ""Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth""
            "", H is the height and W is the width."",
            ""T"")
        .Output(
            0,
            ""output"",
            ""Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]."",
            ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          auto blocksize = getAttribute(ctx, ""blocksize"", 0);
          if (blocksize <= 0) {
            fail_shape_inference(""Blocksize must be positive"");
          }
          if (hasInputShape(ctx, 0)) {
            auto& input_shape = getInputShape(ctx, 0);
            if (input_shape.dim_size() == 4) {
              // TODO: Clarify what behavior should be if C is not a multiple of
              // blocksize*blocksize.
              updateOutputShape(
                  ctx,
                  0,
                  {input_shape.dim(0),
                   input_shape.dim(1) / (blocksize * blocksize),
                   input_shape.dim(2) * blocksize,
                   input_shape.dim(3) * blocksize});
            } else {
              fail_shape_inference(""Input tensor must be 4-dimensional"");
            }
          }
        }));

static const char* Gather_ver1_doc = R""DOC(
Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
them in an output tensor of rank q + (r - 1).
Example 1:
```
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  indices = [
      [0, 1],
      [1, 2],
  ]
  output = [
      [
          [1.0, 1.2],
          [2.3, 3.4],
      ],
      [
          [2.3, 3.4],
          [4.5, 5.7],
      ],
  ]
```
Example 2:
```
  data = [
      [1.0, 1.2, 1.9],
      [2.3, 3.4, 3.9],
      [4.5, 5.7, 5.9],
  ]
  indices = [
      [0, 2],
  ]
  axis = 1,
  output = [
      [
          [1.0, 1.9],
          [2.3, 3.9],
          [4.5, 5.9],
      ],
  ]
```
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Gather,
    1,
    OpSchema()
        .SetDoc(Gather_ver1_doc)
        .Attr(
            ""axis"",
            ""Which axis to gather on. Negative value means ""
            ""counting dimensions from the back. Accepted range is [-r, r-1]"",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds. ""
            ""It is an error if any of the index values are out of bounds."",
            ""Tind"")
        .Output(0, ""output"", ""Tensor of rank q + (r - 1)."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to any tensor type."")
        .TypeConstraint(
            ""Tind"",
            {""tensor(int32)"", ""tensor(int64)""},
            ""Constrain indices to integer types"")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 2)) {
            return;
          }
          const TensorShapeProto& data_shape =
              ctx.getInputType(0)->tensor_type().shape();
          const TensorShapeProto& indices_shape =
              ctx.getInputType(1)->tensor_type().shape();
          int r = data_shape.dim_size();
          if (r < 1) {
            fail_shape_inference(""data tensor must have rank >= 1"");
          }
          int q = indices_shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -r || axis >= r) {
            fail_shape_inference(""axis must be in [-r, r-1]"");
          }
          if (axis < 0) {
            axis += r;
          }
          int out_rank = q + r - 1;

          if (out_rank == 0) {
            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          }
          for (int i = 0; i < out_rank; ++i) {
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() = (i < axis) ? data_shape.dim(i) : // i < axis < r
                (i >= axis && i < axis + q) ? indices_shape.dim(i - axis)
                                            : // i - axis < q
                    data_shape.dim(i - q + 1); // i < out_rank < q + r - 1
          }
        }));

static const char* Squeeze_ver1_doc = R""DOC(
Remove single-dimensional entries from the shape of a tensor.
Takes a  parameter `axes` with a list of axes to squeeze.
If `axes` is not provided, all the single dimensions will be removed from
the shape. If an axis is selected with shape entry not equal to one, an error is raised.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Squeeze,
    1,
    OpSchema()
        .Attr(
            ""axes"",
            ""List of non-negative integers, indicate the dimensions to squeeze."",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .SetDoc(Squeeze_ver1_doc)
        .Input(0, ""data"", ""Tensors with at least max(dims) dimensions."", ""T"")
        .Output(0, ""squeezed"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();

          for (int i = 0, j = 0; i < input_shape.dim_size(); ++i) {
            if (static_cast<size_t>(j) < axes.size() && axes[j] == i) {
              if (input_shape.dim(i).has_dim_value() &&
                  input_shape.dim(i).dim_value() != 1) {
                fail_shape_inference(
                    ""Dimension of input "",
                    i,
                    "" must be 1 instead of "",
                    input_shape.dim(i).dim_value());
              }
              ++j;
            } else {
              *ctx.getOutputType(0)
                   ->mutable_tensor_type()
                   ->mutable_shape()
                   ->add_dim() = input_shape.dim(i);
            }
          }
        }));

static const char* Unsqueeze_ver1_doc = R""DOC(
Insert single-dimensional entries to the shape of a tensor.
Takes one required argument `axes`, a list of dimensions that will be inserted.
Dimension indices in `axes` are as seen in the output tensor. For example:
  Given a tensor such that tensor with shape [3, 4, 5], then
  Unsqueeze(tensor, axes=[0, 4]) has shape [1, 3, 4, 5, 1]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Unsqueeze,
    1,
    OpSchema()
        .Attr(
            ""axes"",
            ""List of non-negative integers, indicate the dimensions to be inserted"",
            AttributeProto::INTS)
        .SetDoc(Unsqueeze_ver1_doc)
        .Input(0, ""data"", ""Original tensor"", ""T"")
        .Output(0, ""expanded"", ""Reshaped tensor with same data as input."", ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          std::vector<int64_t> axes;
          if (!getRepeatedAttribute(ctx, ""axes"", axes)) {
            return;
          }
          std::sort(axes.begin(), axes.end());

          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
            return;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          int j = 0;
          for (int i = 0;
               i < ctx.getInputType(0)->tensor_type().shape().dim_size();
               ++i) {
            while (static_cast<size_t>(j) < axes.size() &&
                   axes[j] ==
                       ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
              ctx.getOutputType(0)
                  ->mutable_tensor_type()
                  ->mutable_shape()
                  ->add_dim()
                  ->set_dim_value(1);
              ++j;
            }
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() =
                ctx.getInputType(0)->tensor_type().shape().dim(i);
          }
          while (static_cast<size_t>(j) < axes.size() &&
                 axes[j] ==
                     ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
            ctx.getOutputType(0)
                ->mutable_tensor_type()
                ->mutable_shape()
                ->add_dim()
                ->set_dim_value(1);
            ++j;
          }
        }));

static const char* OneHot_ver9_doc = R""DOC(
    Produces a one-hot tensor based on inputs.
    The locations represented by the index values in the 'indices' input tensor will have 'on_value'
    and the other locations will have 'off_value' in the output tensor, where 'on_value' and 'off_value'
    are specified as part of required input argument 'values', which is a two-element tensor of format
    [off_value, on_value]. The rank of the output tensor will be one greater than the rank of the
    input tensor. The additional dimension is for one-hot representation. The additional dimension will
    be inserted at the position specified by 'axis'. If 'axis' is not specified then then additional
    dimension will be inserted as the innermost dimension, i.e. axis=-1. The size of the additional
    dimension is specified by required scalar input 'depth'. The type of the output tensor is the same
    as the type of the 'values' input. Any entries in the 'indices' input tensor with values outside
    the range [0, depth) will result in one-hot representation with all 'off_value' values in the
    output tensor.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    OneHot,
    9,
    OpSchema()
        .SetDoc(OneHot_ver9_doc)
        .Attr(
            ""axis"",
            ""(Optional) Axis along which one-hot representation in added. Default: axis=-1. ""
            ""axis=-1 means that the additional dimension will be inserted as the ""
            ""innermost/last dimension in the output tensor."",
            AttributeProto::INT,
            static_cast<int64_t>(-1))
        .Input(
            0,
            ""indices"",
            ""Input tensor containing indices. The values must be non-negative integers. ""
            ""Any entries in the 'indices' input tensor with values outside the range [0, depth) ""
            ""will result in one-hot representation with all 'off_value' values in the output tensor.""
            ""In case 'indices' is of non-integer type, the values will be casted to int64 before use."",
            ""T1"")
        .Input(
            1,
            ""depth"",
            ""Scalar specifying the number of classes in one-hot tensor. This is also the size ""
            ""of the one-hot dimension (specified by 'axis' attribute) added on in the output ""
            ""tensor. The values in the 'indices' input tensor are expected to be ""
            ""in the range [0, depth). ""
            ""In case 'depth' is of non-integer type, it will be casted to int64 before use."",
            ""T2"")
        .Input(
            2,
            ""values"",
            ""Rank 1 tensor containing exactly two elements, in the format [off_value, on_value], ""
            ""where 'on_value' is the value used for filling locations specified in 'indices' input ""
            ""tensor, and 'off_value' is the value used for filling locations other than those specified ""
            ""in 'indices' input tensor. "",
            ""T3"")
        .Output(
            0,
            ""output"",
            ""Tensor of rank one greater than input tensor 'indices', i.e. rank(output) = rank(indices) + 1. ""
            ""The data type for the elements of the output tensor is the same as the type of input 'values' ""
            ""is used."",
            ""T3"")
        .TypeConstraint(
            ""T1"",
            OpSchema::all_numeric_types(),
            ""Constrains input to only numeric types."")
        .TypeConstraint(
            ""T2"",
            OpSchema::all_numeric_types(),
            ""Constrains input to only numeric types."")
        .TypeConstraint(
            ""T3"",
            OpSchema::all_tensor_types(),
            ""Constrain to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Check that the node has three inputs.
          if (ctx.getNumInputs() != 3) {
            fail_type_inference(""OneHot node must have three inputs."");
          }
          // Input 'depth' must be a scalar or a single-element vector.
          // TODO: Ideally to match spec for this input only allow Scalar should
          // be allowed. Making this change now can affect backward
          // compatibility for this op. Since this does not seem like a good
          // justification to update version for this op, allowing both scalar
          // and 1 element vector for now. In future when version update for
          // this op is done we should only allow scalar or chage the spec to
          // allow both.
          if (hasInputShape(ctx, 1)) {
            auto& depth_shape = getInputShape(ctx, 1);
            if (depth_shape.dim_size() != 0 && depth_shape.dim_size() != 1) {
              fail_type_inference(
                  ""Input 'depth' must be a scalar or rank 1 tensor."");
            }
            if (depth_shape.dim_size() == 1 &&
                depth_shape.dim((int)0).has_dim_value() &&
                depth_shape.dim((int)0).dim_value() != 1) {
              fail_type_inference(
                  ""Input 'depth' must have exactly one element."");
            }
          }
          // Input 'values' must be a two-element vector.
          if (hasInputShape(ctx, 2)) {
            auto& values_shape = getInputShape(ctx, 2);
            if (values_shape.dim_size() != 1) {
              fail_type_inference(""Input 'values' must be rank 1 tensor."");
            }
            if (values_shape.dim((int)0).has_dim_value() &&
                values_shape.dim((int)0).dim_value() != 2) {
              fail_type_inference(
                  ""Input 'values' must have exactly two elements."");
            }
          }
          // Set output type to be the same as the third input, 'values'.
          propagateElemTypeFromInputToOutput(ctx, 2, 0);
          // Set the output shape, if input 0 (indices) shape is available.
          if (hasInputShape(ctx, 0)) {
            const TensorShapeProto& indices_shape =
                ctx.getInputType(0)->tensor_type().shape();
            int r = indices_shape.dim_size();
            if (r < 1) {
              fail_shape_inference(""Indices tensor must have rank >= 1"");
            }
            int out_rank = r + 1;
            int axis = static_cast<int>(getAttribute(ctx, ""axis"", -1));
            if (axis < -out_rank || axis >= out_rank) {
              fail_shape_inference(
                  ""'axis' must be in [-rank(indices)-1, rank(indices)]"");
            }
            if (axis < 0) {
              axis += out_rank;
            }
            auto* output_shape = getOutputShape(ctx, 0);
            for (int i = 0; i < out_rank; ++i) {
              auto* dim = output_shape->add_dim();
              if (i < axis) {
                if (indices_shape.dim(i).has_dim_value()) {
                  dim->set_dim_value(indices_shape.dim(i).dim_value());
                } else if (indices_shape.dim(i).has_dim_param()) {
                  dim->set_dim_param(indices_shape.dim(i).dim_param());
                }
              } else if (i > axis) {
                if (indices_shape.dim(i - 1).has_dim_value()) {
                  dim->set_dim_value(indices_shape.dim(i - 1).dim_value());
                } else if (indices_shape.dim(i - 1).has_dim_param()) {
                  dim->set_dim_param(indices_shape.dim(i - 1).dim_param());
                }
              }
            }
          }
        }));

static const char* Compress_ver9_doc = R""DOC(
    Selects slices from an input tensor along a given axis where condition evaluates to True for each axis index.
    In case axis is not provided, input is flattened before elements are selected.
    Compress behaves like numpy.compress: https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html
    )DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Compress,
    9,
    OpSchema()
        .SetDoc(Compress_ver9_doc)
        .Attr(
            ""axis"",
            ""(Optional) Axis along which to take slices. If not specified, ""
            ""input is flattened before elements being selected."",
            AttributeProto::INT,
            OPTIONAL_VALUE)
        .Input(0, ""input"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""condition"",
            ""Rank 1 tensor of booleans to indicate which slices or data elements to be selected. ""
            ""Its length can be less than the input length alone the axis ""
            ""or the flattened input size if axis is not specified. ""
            ""In such cases data slices or elements exceeding the condition length are discarded."",
            ""T1"")
        .Output(
            0,
            ""output"",
            ""Tensor of rank r if axis is specified. Otherwise output is a Tensor of rank 1."",
            ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .TypeConstraint(
            ""T1"",
            {""tensor(bool)""},
            ""Constrains to boolean tensors.""));

static const char* Split_ver2_doc =
    R""DOC(Split a tensor into a list of tensors, along the specified
'axis'. Lengths of the parts can be specified using argument 'split'.
Otherwise, the tensor is split to equal sized parts.
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Split,
    2,
    OpSchema()
        .Input(0, ""input"", ""The tensor to split"", ""T"")
        .Output(
            0,
            ""outputs"",
            ""One or more outputs forming list of tensors after splitting"",
            ""T"",
            OpSchema::Variadic)
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to all tensor types."")
        .Attr(
            ""axis"",
            ""Which axis to split on. "",
            AttributeProto::INT,
            static_cast<int64_t>(0))
        .Attr(
            ""split"",
            ""length of each output"",
            AttributeProto::INTS,
            OPTIONAL_VALUE)
        .SetDoc(Split_ver2_doc)
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
            propagateElemTypeFromInputToOutput(ctx, 0, i);
          }
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
          int rank = shape.dim_size();
          int axis = static_cast<int>(getAttribute(ctx, ""axis"", 0));
          if (axis < -rank || axis >= rank) {
            fail_type_inference(
                ""Invalid value of attribute 'axis'. Rank="",
                rank,
                "" Value="",
                axis);
          }
          // Previously Split-2 does not mention how to deal with negative axis
          // However, there is an existing test onnx/backend/test/data/pytorch-converted/test_GLU
          // using Split-2 with negative axis and it is hard to be regenerated.
          // To compromise, handle negative axis for Split-2 here.
          if (axis < 0) {
            axis += rank;
          }
          const auto& split_dim = shape.dim(axis);
          if (!split_dim.has_dim_value()) {
            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() =
                  shape;
              ctx.getOutputType(i)
                  ->mutable_tensor_type()
                  ->mutable_shape()
                  ->mutable_dim(axis)
                  ->Clear();
            }
            return;
          }
          int split_dim_value = static_cast<int>(split_dim.dim_value());

          std::vector<int64_t> split;
          if (getRepeatedAttribute(ctx, ""split"", split)) {
            if (split.size() != ctx.getNumOutputs()) {
              fail_shape_inference(
                  ""Mismatch between number of splits ("",
                  split.size(),
                  "") and outputs ("",
                  ctx.getNumOutputs(),
                  "")"");
            }
            int64_t total_dim = 0;
            for (int64_t d : split) {
              total_dim += d;
            }
            if (total_dim != split_dim_value) {
              fail_shape_inference(
                  ""Mismatch between the sum of 'split' ("",
                  total_dim,
                  "") and the split dimension of the input ("",
                  split_dim_value,
                  "")"");
            }
          } else {
            int num_outputs = static_cast<int>(ctx.getNumOutputs());
            if (split_dim_value % num_outputs != 0) {
              fail_shape_inference(""The input is not evenly splittable"");
            }
            int chunk_size = split_dim_value / num_outputs;
            for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); i++) {
              split.push_back(chunk_size);
            }
          }
          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() =
                shape;
            ctx.getOutputType(i)
                ->mutable_tensor_type()
                ->mutable_shape()
                ->mutable_dim(axis)
                ->set_dim_value(split[i]);
          }
        }));

static const char* Pad_ver2_doc = R""DOC(
Given `data` tensor, pads, mode, and value.
Example:
  Insert 0 pads to the beginning of the second dimension.
  data = [
      [1.0, 1.2],
      [2.3, 3.4],
      [4.5, 5.7],
  ]
  pads = [0, 2, 0, 0]
  output = [
      [
          [0.0, 0.0, 1.0, 1.2],
          [0.0, 0.0, 2.3, 3.4],
          [0.0, 0.0, 4.5, 5.7],
      ],
  ]
)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    Pad,
    2,
    OpSchema()
        .Attr(
            ""pads"",
            ""List of integers indicating the number of padding elements to add or remove (if negative) ""
            ""at the beginning and end of each axis. For 2D it is the number of pixels. ""
            ""`pads` rank should be double of the input's rank. `pads` format should be as follow ""
            ""[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels ""
            ""added at the beginning of axis `i` and xi_end, the number of pixels added at ""
            ""the end of axis `i`."",
            AttributeProto::INTS)
        .Attr(
            ""mode"",
            ""Three modes: constant(default), reflect, edge"",
            AttributeProto::STRING,
            std::string(""constant""))
        .Attr(
            ""value"",
            ""One float, indicates the value to be filled."",
            AttributeProto::FLOAT,
            0.0f)
        .SetDoc(Pad_ver2_doc)
        .Input(0, ""data"", ""Input tensor."", ""T"")
        .Output(0, ""output"", ""Tensor after padding."", ""T"")
        .TypeConstraint(
            ""T"",
            {""tensor(float16)"", ""tensor(float)"", ""tensor(double)""},
            ""Constrain input and output types to float tensors."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          propagateElemTypeFromInputToOutput(ctx, 0, 0);
          if (!hasNInputShapes(ctx, 1)) {
            return;
          }

          auto& input_shape = ctx.getInputType(0)->tensor_type().shape();

          std::vector<int64_t> pads;
          if (!getRepeatedAttribute(ctx, ""pads"", pads)) {
            fail_shape_inference(""Attribute value for pads is required"");
          }
          if (pads.size() != static_cast<size_t>(input_shape.dim_size() * 2)) {
            fail_shape_inference(""Attribute pads has incorrect length"");
            ;
          }

          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();

          for (size_t i = 0; (int64_t)i < input_shape.dim_size(); ++i) {
            auto* newdim = ctx.getOutputType(0)
                               ->mutable_tensor_type()
                               ->mutable_shape()
                               ->add_dim();
            if (ctx.getInputType(0)
                    ->tensor_type()
                    .shape()
                    .dim((int)i)
                    .has_dim_value()) {
              newdim->set_dim_value(
                  ctx.getInputType(0)
                      ->tensor_type()
                      .shape()
                      .dim((int)i)
                      .dim_value() +
                  pads[i] + pads[input_shape.dim_size() + i]);
            } else if (pads[i] + pads[input_shape.dim_size() + i] == 0) {
              *newdim = input_shape.dim((int)i);
            }
          }
        }));

static const char* GatherND_ver11_doc = R""DOC(
Given `data` tensor of rank `r` >= 1, and `indices` tensor of rank `q` >= 1, this operator gathers
slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1`.

`indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
where each element defines a slice of `data`

Some salient points about the inputs' rank and shape:

1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`

2) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r` (inclusive)

3) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
   It is an error if any of the index values are out of bounds.

The output is computed as follows:

The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.

1) If `indices_shape[-1] > r` => error condition

2) If `indices_shape[-1] == r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
   containing 1-D tensors of dimension `r`. Let us think of each such `r` ranked tensor as `indices_slice`.
   Each *scalar value* corresponding to `data[indices_slice]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
   to form the `output` tensor (Example 1 below)

3) If `indices_shape[-1] < r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
   containing 1-D tensors of dimension `< r`. Let us think of each such tensors as `indices_slice`.
   Each *tensor slice* corresponding to `data[indices_slice , :]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
   to form the `output` tensor (Examples 2, 3, and 4 below)

This operator is the inverse of `ScatterND`.

`Example 1`

  data    = [[0,1],[2,3]]   # data_shape = [2, 2]

  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]

  output  = [0,3]           # output_shape = [2]

`Example 2`

  data    = [[0,1],[2,3]]  # data_shape = [2, 2]

  indices = [[1],[0]]      # indices_shape = [2, 1]

  output  = [[2,3],[0,1]]  # output_shape = [2, 2]

`Example 3`

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]

  output  = [[2,3],[4,5]]                 # output_shape = [2, 2]

`Example 4`

  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]

  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]

  output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]

)DOC"";

ONNX_OPERATOR_SET_SCHEMA(
    GatherND,
    11,
    OpSchema()
        .SetDoc(GatherND_ver11_doc)
        .Input(0, ""data"", ""Tensor of rank r >= 1."", ""T"")
        .Input(
            1,
            ""indices"",
            ""Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] ""
            ""along axis of size s. It is an error if any of the index values are out of bounds."",
            ""tensor(int64)"")
        .Output(
            0,
            ""output"",
            ""Tensor of rank q + r - indices_shape[-1] - 1."",
            ""T"")
        .TypeConstraint(
            ""T"",
            OpSchema::all_tensor_types(),
            ""Constrain input and output types to any tensor type."")
        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
          // Type inference
          propagateElemTypeFromInputToOutput(ctx, 0, 0);

          // Shape inference
          if (!hasNInputShapes(ctx, 2)) {
            // cannot proceed with shape or rank inference
            return;
          }

          const auto& data_shape = ctx.getInputType(0)->tensor_type().shape();
          const auto data_rank = data_shape.dim_size();

          const auto& indices_shape =
              ctx.getInputType(1)->tensor_type().shape();
          const auto indices_rank = indices_shape.dim_size();

          if (data_rank < 1 || indices_rank < 1) {
            fail_shape_inference(
                ""Both `data` and `indices` input tensors in GatherND op ""
                ""need to have rank larger than 0."");
          }

          // cannot ascertain if the input shapes are valid if shape of
          // `indices` is missing last dimension value so return at this point
          if (!indices_shape.dim(indices_rank - 1).has_dim_value()) {
            return;
          }

          const auto last_index_dimension =
              indices_shape.dim(indices_rank - 1).dim_value();

          if (last_index_dimension > data_rank) {
            fail_shape_inference(
                ""Last dimension of `indices` input tensor in GatherND op ""
                ""must not be larger than the rank of `data` tensor"");
          }

          for (int i = 0; i < indices_rank - 1; ++i) {
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() = indices_shape.dim(i);
          }

          for (int i = static_cast<int>(last_index_dimension); i < data_rank;
               ++i) {
            *ctx.getOutputType(0)
                 ->mutable_tensor_type()
                 ->mutable_shape()
                 ->add_dim() = data_shape.dim(i);
          }
        }));
} // namespace ONNX_NAMESPACE
",has_perm_attr
662,"#include <stdint.h>
#include <iostream>
#include <cstring>
#include <fstream>
#include <chrono>
#include <thread>
#include ""headers/MLX90640_API.h""

#define MLX_I2C_ADDR 0x33

int main(){
    int  [MASK]  = 0;
    static uint16_t eeMLX90640[832];
    float emissivity = 1;
    uint16_t frame[834];
    static float image[768];
    float eTa;
    static uint16_t data[768*sizeof(float)];

    std::fstream fs;

    MLX90640_SetDeviceMode(MLX_I2C_ADDR, 0);
    MLX90640_SetSubPageRepeat(MLX_I2C_ADDR, 0);
    MLX90640_SetRefreshRate(MLX_I2C_ADDR, 0b010);
    MLX90640_SetChessMode(MLX_I2C_ADDR);

    paramsMLX90640 mlx90640;
    MLX90640_DumpEE(MLX_I2C_ADDR, eeMLX90640);
    MLX90640_ExtractParameters(eeMLX90640, &mlx90640);

    int refresh = MLX90640_GetRefreshRate(MLX_I2C_ADDR);

    int frames = 30;
    int subpage;
    static float mlx90640To[768];
         [MASK]  = ! [MASK] ;
        MLX90640_GetFrameData(MLX_I2C_ADDR, frame);
        eTa = MLX90640_GetTa(frame, &mlx90640);
        subpage = MLX90640_GetSubPageNumber(frame);
        MLX90640_CalculateTo(frame, &mlx90640, emissivity, eTa, mlx90640To);

        MLX90640_BadPixelsCorrection((&mlx90640)->brokenPixels, mlx90640To, 1, &mlx90640);
        MLX90640_BadPixelsCorrection((&mlx90640)->outlierPixels, mlx90640To, 1, &mlx90640);

        for(int x = 0; x < 32; x++){
            for(int y = 0; y < 24; y++){
                //std::cout << image[32 * y + x] << "","";
                float val = mlx90640To[32 * (23-y) + x];
                std::cout << val << "","";
            }
            std::cout << std::endl;
        }
    return 0;
}
",state
663,"#include ""Arduino.h""
#include ""LRL_Key.h""

static int DEFAULT_KEY_PIN = A0;

LRL_Key::LRL_Key()
{
  _refreshRate = 10;
  _keyPin = DEFAULT_KEY_PIN;
  _prevKey = KEY_NONE;
  _oldTime = 0;
}

// Used to categorize button presses based on analog read of input pin
static int bmap[6]= {60,200,400,600,800,1024};

int LRL_Key::getKey()
{
  int key = SAMPLE_WAIT;

  if (millis() > _oldTime + _refreshRate) {
     int _analog = analogRead(_keyPin);

     for (int a=0;a<6;a++) {
       if(_analog<bmap[a]) {
         key=a;
         break;
       }
     } // for

     if (_prevKey != key) {
       _prevKey = key;
     } else {
       key = SAMPLE_WAIT; // Indicative of NO CHANGE
     }

     _oldTime = millis();
   } 

   return key;
}

void LRL_Key::setRate(int  [MASK] )
{
  _refreshRate =  [MASK] ;
}

",rate
664,"// Fill out your copyright notice in the Description page of Project Settings.

#include ""PlayerBase.h""

#include ""PaperFlipbookComponent.h""
#include ""Camera/CameraComponent.h""
#include ""GameFramework/SpringArmComponent.h""

APlayerBase::APlayerBase() : Health(0)
{
    // only allow yaw rotation
    bUseControllerRotationPitch = false;
    bUseControllerRotationYaw = true;
    bUseControllerRotationRoll = false;

    // TODO: remove this when the real character exists
    CreateTemporaryMesh();

    // setup the camera
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT(""CameraBoom""));
    CameraBoom->SetupAttachment(RootComponent);
    CameraBoom->TargetArmLength = 600.0f;
    CameraBoom->bDoCollisionTest = false;
    CameraBoom->SetRelativeRotation(FRotator(0.0f, -90.0f, 0.0f));

    SideViewCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT(""SideViewCamera""));
    //SideViewCameraComponent->ProjectionMode = ECameraProjectionMode::Orthographic;
    SideViewCameraComponent->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
    SideViewCameraComponent->bUsePawnControlRotation = false;
    SideViewCameraComponent->bAutoActivate = true;

    // replicate animations over the network
    GetSprite()->SetIsReplicated(true);
    bReplicates = true;
}

void APlayerBase::CreateTemporaryMesh()
{
    // create a temporary capsule mesh for the player
    UStaticMeshComponent *TemporaryMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT(""Temporary Mesh""));
    UStaticMesh *TemporaryMesh = ConstructorHelpers::FObjectFinder<UStaticMesh>(TEXT(""StaticMesh'/Engine/BasicShapes/Cylinder.Cylinder'"")).Object;
    TemporaryMeshComponent->SetStaticMesh(TemporaryMesh);
    TemporaryMeshComponent->SetupAttachment(GetSprite());
}

void APlayerBase::Damage(int  [MASK] )
{
    Health -=  [MASK] ;

    if (Health <= 0)
    {
        Health = 0;
        UE_LOG(LogTemp, Warning, TEXT(""Dead""));
    }
}
",amount
665,"//
// Created by 朱宇 on 18/08/2017.
//


char r[] = {
        0x43, 0xe3, 0xaf, 0x2a, 0x0d, 0xb9, 0x08, 0x67,
        0x50, 0x97, 0x68, 0x77, 0x65, 0x0f, 0x42, 0x6d,
        0x21, 0x57, 0xa4, 0x5e, 0x10, 0xde, 0x64, 0x6f,
        0xf8, 0x57, 0x19, 0x8b, 0x22, 0x6d, 0xf0, 0xd4,
        0xb2, 0x24, 0x34, 0x08, 0xe0, 0x3b, 0xa7, 0x11,
        0xd9, 0xc3, 0x4c, 0x51, 0xcb, 0x34, 0x44, 0x13,
};


int sign_test(char* file) {
    EVP_PKEY *privkey;
    FILE *fp;
    EC_KEY *eckey;
    const EC_GROUP *group = NULL;
    const EC_POINT *pub_key = NULL;
    const EC_POINT *ec_point = NULL;

    BIGNUM *p = BN_new();
    BIGNUM *a = BN_new();
    BIGNUM *b = BN_new();


    BIGNUM *x = BN_new();
    BIGNUM *y = BN_new();

    BIGNUM *xg = BN_new();
    BIGNUM *yg = BN_new();
    BIGNUM *order = BN_new();

    BIGNUM *kinv;
    BIGNUM *rp;
    BIGNUM *sp;
    int  [MASK]  = 0;

    const BIGNUM *priv_key;
    ECDSA_SIG* result;
    ECDSA_SIG* result2;
    kinv = BN_bin2bn((const unsigned char*)k, sizeof(k), NULL);
    rp = BN_bin2bn((const unsigned char*)r1, sizeof(r1), NULL);
    sp = BN_bin2bn((const unsigned char*)s1, sizeof(s1), NULL);
    result2 = ECDSA_SIG_new();
    privkey = EVP_PKEY_new();

    fp = fopen (file, ""r"");
    PEM_read_PrivateKey( fp, &privkey, NULL, NULL);
    fclose(fp);

    eckey = EVP_PKEY_get1_EC_KEY(privkey);
    group = EC_KEY_get0_group(eckey);
    pub_key = EC_KEY_get0_public_key(eckey);
    ec_point = EC_GROUP_get0_generator(group);

    printf (""p, a, b: \n"");
    if (EC_GROUP_get_curve_GFp(group, p, a, b, NULL)) {
        BN_print_fp(stdout, p);
        putc('\n', stdout);
        BN_print_fp(stdout, a);
        putc('\n', stdout);
        BN_print_fp(stdout, b);
        putc('\n', stdout);
    }
    printf(""xp, yp: \n"");
    if (EC_POINT_get_affine_coordinates_GFp(group, pub_key, x, y, NULL)) {
        BN_print_fp(stdout, x);
        putc('\n', stdout);
        BN_print_fp(stdout, y);
        putc('\n', stdout);
    }

    printf(""xg, yg: \n"");
    if (EC_POINT_get_affine_coordinates_GFp(group, ec_point, xg, yg, NULL)) {
        BN_print_fp(stdout, xg);
        putc('\n', stdout);
        BN_print_fp(stdout, yg);
        putc('\n', stdout);
    }

    printf(""order: \n"");
    if (EC_GROUP_get_order(group, order, NULL)) {
        BN_print_fp(stdout, order);
        putc('\n', stdout);
    }

    printf(""private: \n"");
    priv_key = EC_KEY_get0_private_key(eckey);
    if (priv_key) {
        BN_print_fp(stdout, priv_key);
        putc('\n', stdout);
    }

    char digist[] = {};

    //<KEY>
    //EDED<KEY>

    //E<KEY>9D2FDA9134A6A927C176E6BFFC899165D4FB8AF94E92D2CB275B605E614C078DAF0E93312CF5D5EB4FB7
    //21B2C18EA1D99E282F167858C1D6ACC619CF8FC9C31CD53F121E3CE79F05D81E671BF4F575774032CDC1DA604B21E29C
    result = ECDSA_do_sign_ex((const unsigned char*)digist, sizeof(digist), kinv, rp, eckey);

    BN_print_fp(stdout, result->r);
    putc('\n', stdout);
    BN_print_fp(stdout, result->s);
    putc('\n', stdout);

    result2->r = rp;
    result2->s = sp;
    printf(""new sult:\n"");
    BN_print_fp(stdout, result2->r);
    putc('\n', stdout);
    BN_print_fp(stdout, result2->s);
    putc('\n', stdout);
     [MASK]  = ECDSA_do_verify((const unsigned char*)digist, sizeof(digist),
                             result2, eckey);
    printf(""verify: %d\n"",  [MASK] );

    return 0;
}",verity
666,"/*
Copyright 2022 The Photon Authors

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 ""estring.h""
#include <algorithm>

size_t estring_view::find_first_of(const charset& set) const
{
    auto it = begin();
    for (;it != end(); ++it)
        if (set.test(*it))
            return it - begin();
    return npos;
}

size_t estring_view::find_first_not_of(const charset& set) const
{
    auto it = begin();
    for (;it != end(); ++it)
        if (!set.test(*it))
            return it - begin();
    return npos;
}

size_t estring_view::find_last_of(const charset& set) const
{
    auto it = rbegin();
    for (;it != rend(); ++it)
        if (set.test(*it))
            return &*it - &*begin();
    return npos;
}

size_t estring_view::find_last_not_of(const charset& set) const
{
    auto it = rbegin();
    for (;it != rend(); ++it)
        if (!set.test(*it))
            return &*it - &*begin();
    return npos;
}

bool estring_view::to_uint64_check(uint64_t* v) const
{
    v ? (*v = 0) : 0;
    for (unsigned char c : *this) {
        if (c > '9' || c < '0')
            return false;
        v ? (*v = *v * 10 + (c - '0')) : 0;
    }
    return true;
}

uint64_t estring_view::hex_to_uint64() const
{
    uint64_t ret = 0;
    for (unsigned char c : *this) {
        if (c >= '0' && c <= '9') {
            ret = ret * 16 + (c - '0');
        } else if (c >= 'A' && c <= 'F') {
            ret = ret * 16 + (c - 'A' + 10);
        } else if (c >= 'a' && c <= 'f') {
            ret = ret * 16 + (c - 'a' + 10);
        } else {
            return ret;
        }
    }
    return ret;
}

std::string& estring::append(uint64_t x)
{
    auto begin = size();
    do
    {
        *this += '0' + x % 10;
        x /= 10;
    } while(x);
    auto end = size();
    auto  [MASK]  = &(*this)[0];
    std::reverse( [MASK]  + begin,  [MASK]  + end);
    return *this;
}
",ptr
667,"/*MOTORS FUNCTIONS---------------------------------------------------------------------------------------------------------*/
void speed_right_motor(int right){
  /*
  * Right motor output speed configuration
  */                         
  if(right >= 0)                                    
  {
    digitalWrite(motor_right_BIN1,LOW);                  
    digitalWrite(motor_right_BIN2,HIGH);
    ledcWrite(pwm_right_channel, right);
  }
  
  if(right < 0)                                     
  {                            
    digitalWrite(motor_right_BIN1,HIGH);                  
    digitalWrite(motor_right_BIN2,LOW);
    ledcWrite(pwm_right_channel, abs(right));
  }
}


void speed_left_motor(int left){
  /*
  * Left motor output speed configuration
  */ 
  if(left >= 0)                                    
  {
    digitalWrite(motor_left_AIN1,LOW);                  
    digitalWrite(motor_left_AIN2,HIGH);
    ledcWrite(pwm_left_channel, left);
  }
  
  if(left < 0)                                     
  {                            
    digitalWrite(motor_left_AIN1,HIGH);                  
    digitalWrite(motor_left_AIN2,LOW);
    ledcWrite(pwm_left_channel, abs(left));
  }
}


void speed_motors(int  [MASK] ){
  /*
  * Right and Left motor output speed configuration.
  * One output speed on both motors
  */                      

  if( [MASK]  >= 0)                                    
  {
    digitalWrite(motor_left_AIN1,LOW);                  
    digitalWrite(motor_left_AIN2,HIGH);
    digitalWrite(motor_right_BIN1,LOW);                  
    digitalWrite(motor_right_BIN2,HIGH);
    ledcWrite(pwm_right_channel,  [MASK] );
    ledcWrite(pwm_left_channel,  [MASK] );
  }
  
  if( [MASK]  < 0)                                     
  {                            
    digitalWrite(motor_left_AIN1,HIGH);                  
    digitalWrite(motor_left_AIN2,LOW);
    digitalWrite(motor_right_BIN1,HIGH);                  
    digitalWrite(motor_right_BIN2,LOW);
    ledcWrite(pwm_right_channel, abs( [MASK] ));
    ledcWrite(pwm_left_channel, abs( [MASK] ));
  }
}
/*---------------------------------------------------------------------------------------------------------------------------*/

/*BLUETOOTH FUNCTIONS--------------------------------------------------------------------------------------------------------*/
void bluetooth_app(){
  /*
  * Received one string from the bluettoth app and splited into
  * usefull values 
  */
  if (SerialBT.available()>0) {
    value = SerialBT.readStringUntil('#');
    if (value.length()==7){
      angle = value.substring(0,3);
      strength = value.substring(3,6);
      button = value.substring(6,8);
      SerialBT.flush();
      value = """";
    }
      
  }
}
/*---------------------------------------------------------------------------------------------------------------------------*/
",robot_speed
668,"#include ""PixelStats.h""

#define LOG_TAG ""pixelstats-system""
#include <log/log.h>
#include <metricslogger/metrics_logger.h>

namespace hardware {
namespace google {
namespace pixelstats {
namespace V1_0 {
namespace implementation {

using namespace android::metricslogger;

PixelStats::PixelStats()
    :limiter_(kDailyRatelimit) {}

void loggerAddFields(ComplexEventLogger* logger) {
    logger->Record();
}

template<typename... Args>
void loggerAddFields(ComplexEventLogger* logger, int32_t field, int32_t value, Args... args) {
    logger->AddTaggedData(LOGBUILDER_TYPE, TYPE_ACTION);
    logger->AddTaggedData(field, value);
    loggerAddFields(logger, args...);
}

template<typename... Args>
void logIntAction(int32_t category, Args... args) {
    ComplexEventLogger logger(category);
    logger.AddTaggedData(LOGBUILDER_TYPE, TYPE_ACTION);
    loggerAddFields(&logger, args...);
}

// Methods from ::hardware::google::pixelstats::V1_0::IPixelStats follow.
Return<void> PixelStats::reportUsbConnectorConnected() {
    // Ratelimit to max 20 / 24hrs (expected 0/24hrs)
    if (rateLimit(android::metricslogger::ACTION_USB_CONNECTOR_CONNECTED, 20))
        return Void();
    logIntAction(android::metricslogger::ACTION_USB_CONNECTOR_CONNECTED);
    return Void();
}

Return<void> PixelStats::reportUsbConnectorDisconnected(int32_t durationMillis) {
    // Ratelimit to max 20 / 24hrs (expected 0/24hrs)
    if (rateLimit(android::metricslogger::ACTION_USB_CONNECTOR_DISCONNECTED, 20))
        return Void();
    logIntAction(android::metricslogger::ACTION_USB_CONNECTOR_DISCONNECTED,
                 android::metricslogger::FIELD_DURATION_MILLIS, durationMillis);
    return Void();
}

Return<void> PixelStats::reportUsbAudioConnected(int32_t vid, int32_t pid) {
    // Ratelimit to max 20 / 24hrs (expected 0/24hrs)
    if (rateLimit(android::metricslogger::ACTION_USB_AUDIO_CONNECTED, 20))
        return Void();
    logIntAction(android::metricslogger::ACTION_USB_AUDIO_CONNECTED,
                 android::metricslogger::FIELD_USB_AUDIO_VIDPID, (vid << 16) | pid);
    return Void();
}

Return<void> PixelStats::reportUsbAudioDisconnected(int32_t vid, int32_t pid,
                                                    int32_t durationMillis) {
    // Ratelimit to max 20 / 24hrs (expected 0/24hrs)
    if (rateLimit(android::metricslogger::ACTION_USB_AUDIO_DISCONNECTED, 20))
        return Void();
    logIntAction(android::metricslogger::ACTION_USB_AUDIO_DISCONNECTED, FIELD_USB_AUDIO_VIDPID,
                    (vid << 16) | pid, android::metricslogger::FIELD_DURATION_MILLIS,
                    durationMillis);
    return Void();
}

Return<void> PixelStats::reportSpeakerImpedance(int32_t speakerLocation, int32_t milliOhms) {
    // Ratelimit to max 2 / 24hrs (expected 1/24hrs)
    if (rateLimit(android::metricslogger::ACTION_SPEAKER_IMPEDANCE, 2))
        return Void();

    logIntAction(android::metricslogger::ACTION_SPEAKER_IMPEDANCE, FIELD_SPEAKER_LOCATION,
                    speakerLocation, FIELD_SPEAKER_IMPEDANCE_MILLIOHMS, milliOhms);
    return Void();
}

static android::metricslogger::HardwareType toMetricsLoggerHardwareType(
    IPixelStats::HardwareType pixelstatsType) {
    switch (pixelstatsType) {
        case IPixelStats::HardwareType::MICROPHONE:
            return android::metricslogger::HardwareType::HARDWARE_MICROPHONE;
        case IPixelStats::HardwareType::CODEC:
            return android::metricslogger::HardwareType::HARDWARE_CODEC;
        case IPixelStats::HardwareType::SPEAKER:
            return android::metricslogger::HardwareType::HARDWARE_SPEAKER;
        case IPixelStats::HardwareType::FINGERPRINT:
            return android::metricslogger::HardwareType::HARDWARE_FINGERPRINT;
        case IPixelStats::HardwareType::UNKNOWN:
        default:
            return android::metricslogger::HardwareType::HARDWARE_UNKNOWN;

    }
}

static android::metricslogger::HardwareFailureCode toMetricsLoggerHardwareFailure(
    IPixelStats::HardwareErrorCode pixelstatsError) {
    switch (pixelstatsError) {
        case IPixelStats::HardwareErrorCode::COMPLETE:
            return HARDWARE_FAILURE_COMPLETE;
        case IPixelStats::HardwareErrorCode::SPEAKER_HIGH_Z:
            return HARDWARE_FAILURE_SPEAKER_HIGH_Z;
        case IPixelStats::HardwareErrorCode::SPEAKER_SHORT:
            return HARDWARE_FAILURE_SPEAKER_SHORT;
        case IPixelStats::HardwareErrorCode::FINGERPRINT_SENSOR_BROKEN:
            return HARDWARE_FAILURE_FINGERPRINT_SENSOR_BROKEN;
        case IPixelStats::HardwareErrorCode::FINGERPRINT_TOO_MANY_DEAD_PIXELS:
            return HARDWARE_FAILURE_FINGERPRINT_TOO_MANY_DEAD_PIXELS;
        case IPixelStats::HardwareErrorCode::UNKNOWN:
        default:
            return HARDWARE_FAILURE_UNKNOWN;
    }
}

Return<void> PixelStats::reportHardwareFailed(HardwareType hardwareType, int32_t hardwareLocation,
                                              HardwareErrorCode errorCode) {
    // Ratelimit to max 15 / 24hrs (expected 0/24hrs)
    if (rateLimit(android::metricslogger::ACTION_HARDWARE_FAILED, 15))
        return Void();

    logIntAction(ACTION_HARDWARE_FAILED,
                 FIELD_HARDWARE_TYPE, toMetricsLoggerHardwareType(hardwareType),
                 FIELD_HARDWARE_LOCATION, hardwareLocation,
                 FIELD_HARDWARE_FAILURE_CODE, toMetricsLoggerHardwareFailure(errorCode));
    return Void();
}

Return<void> PixelStats::reportPhysicalDropDetected(int32_t confidencePctg, int32_t  [MASK] ,
                                                    int32_t freefallDurationMs) {
    // Ratelimit to max 10 / 24hrs (expected 0/24hrs)
    if (rateLimit(android::metricslogger::ACTION_PHYSICAL_DROP, 10))
        return Void();

    logIntAction(ACTION_PHYSICAL_DROP, FIELD_CONFIDENCE_PERCENT, confidencePctg,
                 FIELD_ACCEL_MILLI_G,  [MASK] ,
                 FIELD_DURATION_MILLIS, freefallDurationMs);
    return Void();
}

Return<void> PixelStats::reportChargeCycles(const hidl_string& buckets) {
    // Ratelimit to max 2 / 24hrs (expected 1/24hrs)
    if (rateLimit(android::metricslogger::ACTION_BATTERY_CHARGE_CYCLES, 2))
        return Void();
    LogMultiAction(ACTION_BATTERY_CHARGE_CYCLES, FIELD_BATTERY_CHARGE_CYCLES, buckets);
    return Void();
}

static android::metricslogger::IoOperation toMetricsLoggerIoOperation(IPixelStats::IoOperation op) {
    switch (op) {
        default:
        case IPixelStats::IoOperation::UNKNOWN:
            return android::metricslogger::IoOperation::IOOP_UNKNOWN;
        case IPixelStats::IoOperation::READ:
            return android::metricslogger::IoOperation::IOOP_READ;
        case IPixelStats::IoOperation::WRITE:
            return android::metricslogger::IoOperation::IOOP_WRITE;
        case IPixelStats::IoOperation::UNMAP:
            return android::metricslogger::IoOperation::IOOP_UNMAP;
        case IPixelStats::IoOperation::SYNC:
            return android::metricslogger::IoOperation::IOOP_SYNC;
    }
}

Return<void> PixelStats::reportSlowIo(IoOperation operation, int32_t count) {
    // Ratelimit to max 2 per 24hrs
    if (rateLimit(android::metricslogger::ACTION_SLOW_IO, 2))
        return Void();
    logIntAction(ACTION_SLOW_IO, FIELD_IO_OPERATION_TYPE, toMetricsLoggerIoOperation(operation),
                    FIELD_IO_OPERATION_COUNT, count);
    return Void();
}

Return<void> PixelStats::reportBatteryHealthSnapshot(const BatteryHealthSnapshotArgs& args) {
    // Ratelimit to max 2 per 24hrs
    if (rateLimit(android::metricslogger::ACTION_BATTERY_HEALTH, 2))
        return Void();
    logIntAction(ACTION_BATTERY_HEALTH,
                 FIELD_BATTERY_HEALTH_SNAPSHOT_TYPE, (int32_t)args.type,
                 FIELD_BATTERY_TEMPERATURE_DECI_C, args.temperatureDeciC,
                 FIELD_BATTERY_VOLTAGE_UV, args.voltageMicroV,
                 FIELD_BATTERY_CURRENT_UA, args.currentMicroA,
                 FIELD_BATTERY_OPEN_CIRCUIT_VOLTAGE_UV, args.openCircuitVoltageMicroV,
                 FIELD_BATTERY_RESISTANCE_UOHMS, args.resistanceMicroOhm,
                 FIELD_END_BATTERY_PERCENT, args.levelPercent);
    return Void();
}

Return<void> PixelStats::reportBatteryCausedShutdown(int32_t voltageMicroV) {
    // Ratelimit to max 5 per 24hrs
    if (rateLimit(android::metricslogger::ACTION_BATTERY_CAUSED_SHUTDOWN, 5))
        return Void();
    logIntAction(ACTION_BATTERY_CAUSED_SHUTDOWN, FIELD_BATTERY_VOLTAGE_UV, voltageMicroV);
    return Void();
}

bool PixelStats::rateLimit(int action, int limit) {
    if (limiter_.RateLimit(action, limit)) {
        ALOGE(""Rate limited action %d\n"", action);
        return true;
    }
    return false;
}

}  // namespace implementation
}  // namespace V1_0
}  // namespace pixelstats
}  // namespace google
}  // namespace hardware
",accelPeak
669,"#include ""Application.h""

namespace SandBox
{
    ExampleLayer::ExampleLayer(const char* name /* = ""ExampleLayer"" */)
        : Layer(name), m_Camera(-1.6f, 1.6f, -0.9f, 0.9f)
    {
        m_CameraPosition = m_Camera.GetPosition();
        m_CameraRotation = m_Camera.GetRotation();

        // clang-format off

        float vertices[28] = {
            -0.5f, -0.5f, 0.0f,  0.0f, 0.0f,
             0.5f, -0.5f, 0.0f,  1.0f, 0.0f,
             0.5f,  0.5f, 0.0f,  1.0f, 1.0f,
            -0.5f,  0.5f, 0.0f,  0.0f, 1.0f,
        };

        uint32_t indices[6] = {
            0, 1, 2,
            2, 3, 0,
        };

        // clang-format on

        Vertex::BufferLayout layout = { Vertex::ShaderDataType::Float3, Vertex::ShaderDataType::Float2 };

        m_VertexArray.reset(Vertex::VertexArray::Create());
        m_VertexBuffer.reset(Vertex::VertexBuffer::Create(vertices, sizeof(vertices), layout));

        m_VertexArray->AddVertexBuffer(m_VertexBuffer);

        m_IndexBuffer.reset(Vertex::IndexBuffer::Create(indices, sizeof(indices)));

        m_VertexArray->SetIndexBuffer(m_IndexBuffer);

        // --------------------------------------

        Vertex::BufferLayout  [MASK]  = { Vertex::ShaderDataType::Mat4, Vertex::ShaderDataType::Mat4 };

        auto vertex_source   = Vertex::Shader::ReadSPIRVFromFile(""./res/shaders/vertex.spv"");
        auto fragment_source = Vertex::Shader::ReadSPIRVFromFile(""./res/shaders/fragment.spv"");

        m_Shader.reset(Vertex::Shader::Create(vertex_source, fragment_source, layout));

#ifndef VX_RENDER_API_VULKAN
        m_ArchTexture.reset(Vertex::Texture2D::Create(""res/arch.png""));
        m_VETexture.reset(Vertex::Texture2D::Create(""res/VertexEngine.png""));

        m_Shader->Bind();

        m_UniformBuffer.reset(Vertex::UniformBuffer::Create( [MASK] , 0));
#endif

        Vertex::Logger::Info(""Initialized test layer"");
    }

    void ExampleLayer::OnUpdate(const Vertex::TimeDelta delta_time)
    {
        if (Vertex::Input::IsKeyPressed(VX_KEY_W))
            m_CameraPosition.y -= m_CameraSpeed * delta_time.TotalSeconds();
        if (Vertex::Input::IsKeyPressed(VX_KEY_S))
            m_CameraPosition.y += m_CameraSpeed * delta_time.TotalSeconds();
        if (Vertex::Input::IsKeyPressed(VX_KEY_A))
            m_CameraPosition.x -= m_CameraSpeed * delta_time.TotalSeconds();
        if (Vertex::Input::IsKeyPressed(VX_KEY_D))
            m_CameraPosition.x += m_CameraSpeed * delta_time.TotalSeconds();

        if (Vertex::Input::IsKeyPressed(VX_KEY_Q))
            m_CameraRotation += m_CameraRotationSpeed * delta_time.TotalSeconds();
        if (Vertex::Input::IsKeyPressed(VX_KEY_E))
            m_CameraRotation -= m_CameraRotationSpeed * delta_time.TotalSeconds();

        m_Camera.SetPosition(m_CameraPosition);
        m_Camera.SetRotation(m_CameraRotation);

        Vertex::Renderer::Clear({ 0.1f, 0.1f, 0.1f, 1.0f });

        Vertex::Renderer::BeginScene(m_Camera);

        glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f));

#ifndef VX_RENDER_API_VULKAN
        m_UniformBuffer->Bind();

        m_VETexture->Bind();

        m_UniformBuffer->SetValue((glm::mat4)m_Camera.GetProjectionViewMatrix(), 0);

        for (float x = 0.0f; x < 20.0f; x++)
        {
            for (float y = 0.0f; y < 20.0f; y++)
            {
                // clang-format off

                m_UniformBuffer->SetValue(glm::translate(
                    glm::mat4(1.0f), glm::vec3(x * 0.11f, y * 0.11f, 0.0f)
                ) * scale, Vertex::GetSizeOfShaderDataType(Vertex::ShaderDataType::Mat4));

                Vertex::Renderer::Submit(m_VertexArray, m_UniformBuffer, m_Shader);

                // clang-format on
            }
        }

        m_ArchTexture->Bind();

        m_UniformBuffer->SetValue(glm::translate(glm::mat4(1.0f), glm::vec3(1.0f, 1.0f, 0.0f)),
                                  Vertex::GetSizeOfShaderDataType(Vertex::ShaderDataType::Mat4));

        Vertex::Renderer::Submit(m_VertexArray, m_UniformBuffer, m_Shader);
#else

        Vertex::Renderer::Submit(m_VertexArray, m_Shader);

#endif

        Vertex::Renderer::EndScene();

        m_AvgFrameRate = (m_AvgFrameRate == 0) ? (1.0f / delta_time.TotalSeconds())
                                               : (m_AvgFrameRate + (1.0f / delta_time.TotalSeconds())) / 2;
    }

    void ExampleLayer::OnGUIUpdate(const Vertex::TimeDelta delta_time)
    {
#ifndef VX_RENDER_API_VULKAN
        ImGui::Begin(""Renderer"");
        ImGui::Text(""%s"", Vertex::Renderer::GetRendererInfo().c_str());
        ImGui::Text(""\n %.2f"", m_AvgFrameRate);
        ImGui::End();
#endif
    }
}

Vertex::Application* Vertex::CreateApplication()
{
    return new SandBox::SandBoxApp(""SandBoxApp"");
}",uniform_block_layout
670,"/*
 * common.cpp
 *
 *  Created on: Sep 13, 2019
 *      Author: siwei
 */

#include ""common.h""

#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <string>
#include <sys/stat.h>

extern int level;

int getfile(const std::string& path, std::string& result)
{
    char buffer[256];
    std::ifstream in(path);
    if (!in.is_open())
    {
        ERROR(""Error opening file"");
        return -1;
    }
    while (!in.eof())
    {
        in.getline(buffer, 10000);
        result = result + buffer;
    }
    DEBUG(""result is %s"", result.c_str());
    return 0;
}

namespace U
{
pipe::pipe(std::string  [MASK] )
{
    fifo =  [MASK] ;
    fd = open( [MASK] .c_str(), O_RDWR);
    if (fd < 0)
    {
        ERROR(""open fd error,errno is %s,errno is %d"", strerror(errno), errno);
        if (errno == 2)
        {
            ERROR(""%s is not existed,created it"",  [MASK] .c_str());
            int ret = mkfifo( [MASK] .c_str(), S_IFIFO | 0666);
            if (ret == -1)
            {
                ERROR(""mkfifo return -1,%s created failed"",  [MASK] .c_str());
            } else
            {
                DEBUG(""mkfifo %s successed"",  [MASK] .c_str());
                fd = open( [MASK] .c_str(), O_RDWR);
                owner = 1;
            }
        }
    }
}

pipe::~pipe()
{
    close(fd);
    if (owner == 1)
    {
        DEBUG(""%s created by this,unlink it"", fifo.c_str());
        unlink(fifo.c_str());
    }
    DEBUG(""%s pipe end success"", fifo.c_str());
}

int pipe::senMsg(char* buf,int length)
{
    int len = write(fd, buf, length);
    if (len < 0)
    {
        ERROR(""write error,errno is %s"", strerror(errno));
        return -1;
    }
    return 0;
}

int pipe::recvMsg(char* buff,int len)
{
    return read(fd, buff, len);
}

int pipe::getFd()
{
    return fd;
}
}

",fifoName
671,"/*
 *  Copyright 2008-2009 NVIDIA Corporation
 *
 *  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 <cmath>
#include <algorithm>
#include <list>
#include <vector>

#include ""ocuequation/eqn_incompressns3d.h""
#include ""ocustorage/grid3d.h""
#include ""ocuutil/imagefile.h""
#include ""ocuutil/color.h""
#include ""ocuutil/timing_pool.h""

#ifdef OCU_DOUBLESUPPORT

#include ""eqn_cubicrayleigh3d.h""

using namespace ocu;

double rand_val(double min_val, double max_val) {
  return min_val + 2 * max_val * ((double)rand())/RAND_MAX;
}

void write_slice(const char *filename, const Grid3DDevice<double> &grid)
{
  Grid3DHost<double> h_grid;
  h_grid.init_congruent(grid);
  h_grid.copy_all_data(grid);


  int nx = grid.nx();
  int ny = grid.ny();
  int nz = grid.nz();

  ImageFile img;
  img.allocate(nx, ny);

  for (int i=0; i < nx; i++)
    for (int j=0; j < ny; j++) {
      double temperature = h_grid.at(i,j,nz/2);
      if (temperature < -2) temperature = -2;
      if (temperature > 2)  temperature = 2;
      //float3 color = make_float3(temperature, temperature, temperature);
      float3 color = hsv_to_rgb(make_float3((temperature + 2)*90, 1, 1));
      //float3 color = pseudo_temperature((temperature+1)*.5);
      img.set_rgb(i,j,(unsigned char)(255*color.x),(unsigned char)(255*color.y),(unsigned char)(255*color.z));
    }

  img.write_ppm(filename);
}

double linear_regression(const std::vector<double> &err_mult, const std::vector<double> &err_val) {

  // apply linear regression to estimate what value will be when error_mult is 0
  // aka y-intercept

  double x_m=0;
  double y_m=0;
  double num = 0;
  double denom = 0;

  int n = err_mult.size();
  int i;
  for (i=0; i < n; i++) {
    x_m += err_mult[i];
    y_m += err_val[i];
  }
  x_m /= n;
  y_m /= n;

  for (i=0; i < n; i++) {
    num += ((err_mult[i] - x_m) * (err_val[i] - y_m));
    denom += ((err_mult[i] - x_m) * (err_mult[i] - x_m));
  }
  
  double slope = num / denom;
  return y_m - (slope * x_m);
}



double stddev(const std::list<double> &data) {
  double  [MASK]  = 0;
  int n = data.size();
  std::list<double>::const_iterator i;
  for(i= data.begin(); i != data.end(); i++) {
     [MASK]  += *i;
  }
   [MASK]  /= n;

  double var = 0;
  for(i= data.begin(); i != data.end(); i++) {
    var += (*i -  [MASK] ) * (*i -  [MASK] );
  }
  var /= n;

  return sqrt(var);
}

void Rayleigh_init_params(Eqn_CubicRayleigh3DParamsD &params, int res, double Ra, DirectionType vertical) {

  int nx = res;
  int ny = res;
  int nz = res;
  float domain_x = 1.0;
  float domain_y = 1.0;
  float domain_z = 1.0;

  float hx = domain_x/nx;
  float hy = domain_y/ny;
  float hz = domain_z/nz;

  params.init_grids(nx, ny, nz);
  params.hx = hx;
  params.hy = hy;
  params.hz = hz;
  params.max_divergence = 1e-12;
  
  // if everything is set to one, Ra = deltaT
  params.viscosity = 1;
  params.thermal_diffusion = 1;
  params.gravity = -1;
  params.bouyancy = Ra;
  params.vertical_direction = vertical;

  //params.advection_scheme = IT_SECOND_ORDER_CENTERED;
  //params.time_step = TS_ADAMS_BASHFORD2;
  //params.cfl_factor = .7;
  params.advection_scheme = IT_FIRST_ORDER_UPWIND;
  params.time_step = TS_FORWARD_EULER;
  params.cfl_factor = .99;

  BoundaryCondition dirichelet;
  dirichelet.type = BC_DIRICHELET;
  BoundaryCondition closed;

  closed.aux_value = 1; // no slip on all sides
  closed.type = BC_FORCED_INFLOW_VARIABLE_SLIP; // closed & no slip on all sides
  
  params.flow_bc = BoundaryConditionSet(closed);
  params.temp_bc = BoundaryConditionSet(dirichelet);

  if (vertical & DIR_XAXIS_FLAG) {
    params.temp_bc.xpos = dirichelet;
    params.temp_bc.xneg = dirichelet;

    if (vertical == DIR_XNEG)
      params.temp_bc.xpos.value = 1;
    else
      params.temp_bc.xneg.value = 1;
  }
  else if (vertical & DIR_YAXIS_FLAG) {
    params.temp_bc.ypos = dirichelet;
    params.temp_bc.yneg = dirichelet;

    if (vertical == DIR_YNEG)
      params.temp_bc.ypos.value = 1;
    else
      params.temp_bc.yneg.value = 1;
  }
  else {
    params.temp_bc.zpos = dirichelet;
    params.temp_bc.zneg = dirichelet;

    if (vertical == DIR_ZNEG)
      params.temp_bc.zpos.value = 1;
    else
      params.temp_bc.zneg.value = 1;
  }

  double mint = 10000;
  double maxt = -10000;
  int i,j,k;
  for (int i=0; i < nx; i++) {
    for (int j=0; j < ny; j++) {
      for (int k=0; k < nz; k++) {
        float y;
        switch(vertical) {
          case DIR_XPOS: y = 1 - (((i+.5) * hx) / domain_x); break;
          case DIR_XNEG: y = (((i+.5) * hx) / domain_x); break;
          case DIR_YPOS: y = 1 - (((j+.5) * hy) / domain_y); break;
          case DIR_YNEG: y = (((j+.5) * hy) / domain_y); break;
          case DIR_ZPOS: y = 1 - (((k+.5) * hz) / domain_z); break;
          case DIR_ZNEG: y = (((k+.5) * hz) / domain_z); break;
        }

        double newtemp = y; // from 0 to 1
        mint = std::min(mint, newtemp);
        maxt = std::max(maxt, newtemp);
        params.init_temp.at(i,j,k) = newtemp;
        params.init_u.at(i,j,k) = rand_val(-1e-4, 1e-4);
        params.init_v.at(i,j,k) = rand_val(-1e-4, 1e-4);
        params.init_w.at(i,j,k) = rand_val(-1e-4, 1e-4);
      }
    }
  }

  printf(""init min/max t = %f %f\n"", mint, maxt);
}

bool Rayleigh_run_resolution_ra(int res, double deltaT, double &ratio) {
  printf(""deltaT = %f\n"", deltaT);

  DirectionType vertical = DIR_YPOS;
  Eqn_CubicRayleigh3DParamsD params;
  Eqn_CubicRayleigh3DD  eqn;

  Rayleigh_init_params(params, res, deltaT, vertical);
  eqn.set_parameters(params);

  std::list<double> data;

  int count = 1;
  int under_count = 0;
  bool done = false;
  double last_maxu=0, last_maxv = 0, last_maxw=0;
  bool ok = false;
  std::list<double> u_data, v_data;

  while (!done) {
    count++;        

    eqn.advance(.01);
    double max_u, max_v, max_w;
    eqn.get_u().reduce_maxabs(max_u);
    eqn.get_v().reduce_maxabs(max_v);
    eqn.get_w().reduce_maxabs(max_w); // not used in any calculations, but useful for troubleshooting

    double mag_lateral;
    double u_ratio, v_ratio;

    if (vertical & DIR_XAXIS_FLAG) {
      u_ratio = log(max_v / last_maxv);
      v_ratio = log(max_u / last_maxu);
      mag_lateral = max_v;
    }
    else if (vertical & DIR_YAXIS_FLAG) {
      u_ratio = log(max_u / last_maxu);
      v_ratio = log(max_v / last_maxv);
      mag_lateral = max_u;
    }
    else {
      u_ratio = log(max_u / last_maxu);
      v_ratio = log(max_w / last_maxw);
      mag_lateral = max_u;
    }

    u_data.push_back(u_ratio);
    v_data.push_back(v_ratio);

    if (count > 40) {
      u_data.pop_front();
      v_data.pop_front();

      double max_mag = fabs(u_ratio) > fabs(v_ratio) ? u_ratio : v_ratio;
      double max_stddev = fabs(u_ratio) > fabs(v_ratio) ? stddev(u_data) : stddev(v_data);
      // if both have stabilized, take the avg (?)
      if (max_stddev < .01 * fabs(max_mag)) {
        done = true;
        ok = true;
        ratio = std::max(u_ratio, v_ratio); // take max so if one is positive, we get a positive number
      }
    }

    if (fabs((u_ratio - v_ratio)/u_ratio) < .01) {
      under_count++;
      printf(""under_count = %d\n"", under_count);
      if (count > 100 && under_count > 10) {
        done = true;
        ratio = .5 * (u_ratio + v_ratio);
        ok = true;
      }
    }

    
    printf(""> Log ratio: %.10f, %.10f, Max u = %.12f, Max v = %.12f, Max w = %.12f\n"", u_ratio, v_ratio, max_u, max_v, max_w);
    fflush(stdout);

    last_maxu = max_u;
    last_maxv = max_v;
    last_maxw = max_w;

    if (mag_lateral < 1e-12) {
      printf(""[Shrunk to zero]\n"");
      done = true;
    }
    if (mag_lateral > .1) {
      printf(""[Blew up]\n"");
      done = true;
    }

    if (count > 5000) {
      printf(""[Not converging]\n"");
      done = true;
    }
  }

  printf(""\n............ DONE ...............\n\n"");

  return ok;
}

double Rayleigh_run_resolution(int res, double start, double end, double step=1.0) {
  // estimate the Ra_cr value
  printf(""run resolution %d\n"", res);

  double lb_ra=0, lb_decay;
  double ub_ra=0, ub_decay;

  for (double rayleigh_number = start; rayleigh_number <= end; rayleigh_number += step) {

    double decay_rate;

    Rayleigh_run_resolution_ra(res, rayleigh_number, decay_rate);
    if (decay_rate < 0) {
      lb_ra = rayleigh_number;
      lb_decay = decay_rate;
    }
    else {
      ub_ra = rayleigh_number;
      ub_decay = decay_rate;
      break;
    }
  }

  // interpolate to find zero-crossing.  We know that lb < 0 & ub > 0, hence the signs
  return lb_ra - lb_decay / (ub_decay - lb_decay);
}


void Rayleigh_run() {
  double ra_16 = 6642.534538;
//  ra_16 = Rayleigh_run_resolution(16, 6641, 6644,1);
  ra_16 = Rayleigh_run_resolution(16, 6641, 6643,.1);
  double ra_32 = 6756.473870; 
//  ra_32 = Rayleigh_run_resolution(32, 6756, 6760,1);
  ra_32 = Rayleigh_run_resolution(32, 6756, 6757,.1);
  double ra_64 = 6787.156363;
  //ra_64 = Rayleigh_run_resolution(64, 6787, 6800,1);
  double ra_128 = 6787.156363;
  //ra_128 = Rayleigh_run_resolution(128, 6790, 6800,1);
  
  double ra_exact = 6799.0; 

  double er_16 = ra_16 - ra_exact;
  double er_32 = ra_32 - ra_exact;
  double er_64 = ra_64 - ra_exact;
  double er_128 = ra_128 - ra_exact;

  double order_32 = log(er_16/er_32) / log(2.0);
  double order_64 = log(er_32/er_64) / log(2.0);
  double order_128 = log(er_64/er_32) / log(2.0);


  printf(""16  - %f (error %f)\n"", ra_16, er_16);
  printf(""32  - %f (error %f) - order(%f)\n"", ra_32, er_32, order_32);
  //printf(""64  - %f (error %f) - order(%f)\n"", ra_64, er_64, order_64);
  //printf(""128  - %f (error %f) - order(%f)\n"", ra_128, er_128, order_128);


  // the extrapolated value for Ra_cr based on our calculations are determined by the system of equations:
  // Ra_cr + 1 e = ra_32
  // Ra_cr + 4 e = ra_16
  // easiest way to solve this equation for t Ra_cr is by linear regression.  Ra_cr is simply
  // the y-intercept of the least-squares fit line.

  std::vector<double> err_mult, err_val;
  err_mult.push_back(4);
  err_val.push_back(ra_16);
  err_mult.push_back(1);
  err_val.push_back(ra_32);
  //err_mult.push_back(.25);
  //err_val.push_back(ra_64);
  //err_mult.push_back(1.0/16.0);
  //err_val.push_back(ra_128);

  double estimated_ra_exact = linear_regression(err_mult, err_val);

  // ideally error here will be very very small
  printf(""\nestimated_ra_exact = %f, error = %.10f\n"", estimated_ra_exact, fabs(estimated_ra_exact - ra_exact));
  
  fflush(stdout);
}






void Nusselt_init_params(Eqn_CubicRayleigh3DParamsD &params, int res, double Ra, double Pr, DirectionType vertical) {

  int nx = res;
  int ny = res;
  int nz = res;
  float domain_x = 1.0;
  float domain_y = 1.0;
  float domain_z = 1.0;

  float hx = domain_x/nx;
  float hy = domain_y/ny;
  float hz = domain_z/nz;

  params.init_grids(nx, ny, nz);
  params.hx = hx;
  params.hy = hy;
  params.hz = hz;
  params.max_divergence = 1e-8;
  
  // if everything is set to one, Ra = deltaT
  params.viscosity = Pr;
  params.thermal_diffusion = 1;
  params.gravity = -1;
  params.bouyancy = Ra * Pr;
  params.vertical_direction = vertical;

  params.advection_scheme = IT_SECOND_ORDER_CENTERED;
  params.time_step = TS_ADAMS_BASHFORD2;

  BoundaryCondition dirichelet;
  dirichelet.type = BC_DIRICHELET;
  BoundaryCondition closed;

  closed.aux_value = 1; // no slip on all sides
  closed.type = BC_FORCED_INFLOW_VARIABLE_SLIP; // closed & no slip on all sides
  
  params.flow_bc = BoundaryConditionSet(closed);
  params.temp_bc = BoundaryConditionSet(dirichelet);

  if (vertical & DIR_XAXIS_FLAG) {
    params.temp_bc.xpos = dirichelet;
    params.temp_bc.xneg = dirichelet;

    if (vertical == DIR_XNEG)
      params.temp_bc.xpos.value = 1;
    else
      params.temp_bc.xneg.value = 1;
  }
  else if (vertical & DIR_YAXIS_FLAG) {
    params.temp_bc.ypos = dirichelet;
    params.temp_bc.yneg = dirichelet;

    if (vertical == DIR_YNEG)
      params.temp_bc.ypos.value = 1;
    else
      params.temp_bc.yneg.value = 1;
  }
  else {
    params.temp_bc.zpos = dirichelet;
    params.temp_bc.zneg = dirichelet;

    if (vertical == DIR_ZNEG)
      params.temp_bc.zpos.value = 1;
    else
      params.temp_bc.zneg.value = 1;
  }

  int i,j,k;
  for (int i=0; i < nx; i++) {
    for (int j=0; j < ny; j++) {
      for (int k=0; k < nz; k++) {
        float y;
        switch(vertical) {
          case DIR_XPOS: y = 1 - (((i+.5) * hx) / domain_x); break;
          case DIR_XNEG: y = (((i+.5) * hx) / domain_x); break;
          case DIR_YPOS: y = 1 - (((j+.5) * hy) / domain_y); break;
          case DIR_YNEG: y = (((j+.5) * hy) / domain_y); break;
          case DIR_ZPOS: y = 1 - (((k+.5) * hz) / domain_z); break;
          case DIR_ZNEG: y = (((k+.5) * hz) / domain_z); break;
        }

        params.init_temp.at(i,j,k) = y + rand_val(-1e-4, 1e-4);
        params.init_u.at(i,j,k) = 0;
        params.init_v.at(i,j,k) = 0;
        params.init_w.at(i,j,k) = 0;
      }
    }
  }
}

double print_nusselt(const Grid3DDevice<double> &grid, const Grid3DDevice<double> &v, float hx, float hy, float hz)
{
  Grid3DHost<double> h_grid;
  h_grid.init_congruent(grid);
  h_grid.copy_all_data(grid);

  Grid3DHost<double> h_v;
  h_v.init_congruent(v);
  h_v.copy_all_data(v);


  int nx = grid.nx();
  int ny = grid.ny();
  int nz = grid.nz();
  double nu_b = 0;

  for (int j=0; j <= ny; j+=ny) {
    double sum = 0;

    for (int i=0; i < nx; i++) {
      for (int k=0; k < nz; k++) {
        double T_z = (h_grid.at(i,j,k) - h_grid.at(i,j-1,k)) / hy;
        double wT = h_v.at(i,j,k) * .5 * (h_grid.at(i,j,k) + h_grid.at(i,j-1,k));
        sum += wT - T_z;
      }
    }
    if (j==0) nu_b = sum / (nx * nz);
    printf(""Nusselt[%d]: %f\n"", j, sum / (nx * nz));
  }

  return nu_b;
}

double Nusselt_run_resolution(int res, double dt, double Ra, double Pr, double t1=1, bool do_diagnostic=true) {
  printf(""\nRa =%f\n\n"", Ra);
  DirectionType vertical = DIR_YPOS;
  Eqn_CubicRayleigh3DParamsD params;
  Eqn_CubicRayleigh3DD  eqn;

  Nusselt_init_params(params, res, Ra, Pr, vertical);
  eqn.set_parameters(params);

  double last_maxu=0, last_maxv = 0, last_maxw=0;
  int next_frame = 1;
  
  CPUTimer clock;
  clock.start();

  for (double t = 0; t <= t1; t += dt) {
    eqn.advance_one_step(dt);

    if (do_diagnostic) {
      double max_u, max_v, max_w;
      eqn.get_u().reduce_maxabs(max_u);
      eqn.get_v().reduce_maxabs(max_v);
      eqn.get_w().reduce_maxabs(max_w); // not used in any calculations, but useful for troubleshooting

      double mag_lateral;
      double u_ratio, v_ratio;

      if (vertical & DIR_XAXIS_FLAG) {
        u_ratio = log(max_v / last_maxv);
        v_ratio = log(max_u / last_maxu);
        mag_lateral = max_v;
      }
      else if (vertical & DIR_YAXIS_FLAG) {
        u_ratio = log(max_u / last_maxu);
        v_ratio = log(max_v / last_maxv);
        mag_lateral = max_u;
      }
      else {
        u_ratio = log(max_u / last_maxu);
        v_ratio = log(max_w / last_maxw);
        mag_lateral = max_u;
      }
      
      printf(""> Log ratio: %.10f, %.10f, Max u = %.12f, Max v = %.12f, Max w = %.12f\n"", u_ratio, v_ratio, max_u, max_v, max_w);
      fflush(stdout);

      last_maxu = max_u;
      last_maxv = max_v;
      last_maxw = max_w;

      if (t > next_frame * t1/100) {
        char buff[1024];
        sprintf(buff, ""output.%04d.ppm"", next_frame);
        printf(""%s\n"", buff);
        write_slice(buff, eqn.get_temperature());
        next_frame++;
      }
    }
    else {

      if (t > next_frame * t1/200) {
        next_frame++;
        print_nusselt(eqn.get_temperature(), eqn.get_v(), eqn.hx(), eqn.hy(), eqn.hz());
      }
      printf(""%.4f%% done\r"", t/t1 * 100);
    }
  }
  clock.stop();
  printf(""Elapsed sec: %.8f\n"", clock.elapsed_sec());

  printf(""\n............ DONE ...............\n\n"");

  // calculate Nusselt #
  double nu_b = print_nusselt(eqn.get_temperature(), eqn.get_v(), eqn.hx(), eqn.hy(), eqn.hz());

  return nu_b;
}


void Nusselt_run() {
  //UNITTEST_ASSERT_EQUAL_DOUBLE(run_resolution(32, 8e-5, 44e3, 0.71, 1, false), 2.055, .003);
//  Nusselt_run_resolution(32, 8e-5, 87e3, 0.71, 1, false);
//  Nusselt_run_resolution(32, 8e-5, 25e3, 0.71, 2, false);
//  Nusselt_run_resolution(32, 8e-5, 91e3, 0.71, 2, false);
  //Nusselt_run_resolution(32, 8e-5, 25e3, 0.71, 4, false);
  Nusselt_run_resolution(32, 2e-5, 44e3, 0.71, 4, false);
  //Nusselt_run_resolution(32, 8e-5, 45e3, 0.71, 4, false);
  //Nusselt_run_resolution(32, 8e-5, 87e3, 0.71, 4, false);
  //Nusselt_run_resolution(32, 8e-5, 91e3, 0.71, 8, false);

/*
  std::vector<double> err_mult, err_val;
  err_mult.push_back(4);
  err_val.push_back(run_resolution(16, 32e-5, 44e3, 0.71, 3, false));
  err_mult.push_back(1);
  err_val.push_back(run_resolution(32, 8e-5, 44e3, 0.71, 3, false));
//  err_mult.push_back(.25);
//  err_val.push_back(run_resolution(64, 2e-5, 44e3, 0.71, 1, false));

  double estimated_nu_exact = linear_regression(err_mult, err_val);
  printf(""Extrapolated: %f\n"", estimated_nu_exact);
*/
}



int main(int argc, const char **argv)
{
  Nusselt_run();
  return 0;
}

#else // ! OCU_DOUBLESUPPORT


int main(int argc, const char **argv)
{
  printf(""[ERROR] cubicrayleigh only runs when compiled with double precision support\n"");
  exit(-1);

  return 0;
}

#endif // OCU_DOUBLESUPPORT",mean
672,"#pragma once

#include ""spdlog/spdlog.h""
#include ""Core/CoreMacros.h""

namespace KEngine
{
	enum class LogVerbosity
	{
		Trace,
		Info,
		Warning,
		Error,
		Critical
	};


	class KENGINE_API Log
	{
	public:
		static void Init();

		inline static std::shared_ptr<spdlog::logger>& GetEngineLogger() { return KEngineLogger; }
		inline static std::shared_ptr<spdlog::logger>& GetApplicationLogger() { return ApplicationLogger; }

		template<typename... Args>
		static void LogMessage(std::shared_ptr<spdlog::logger> Logger, LogVerbosity  [MASK] , fmt::format_string<Args...> fmt, Args&&... args)
		{
			if (!Logger) return;

			switch ( [MASK] )
			{
			case LogVerbosity::Trace:
				Logger->trace(fmt, std::forward<Args>(args)...);
				break;
			case LogVerbosity::Info:
				Logger->info(fmt, std::forward<Args>(args)...);
				break;
			case LogVerbosity::Warning:
				Logger->warn(fmt, std::forward<Args>(args)...);
				break;
			case LogVerbosity::Error:
				Logger->error(fmt, std::forward<Args>(args)...);
				break;
			case LogVerbosity::Critical:
				Logger->critical(fmt, std::forward<Args>(args)...);
				break;
			}
		}

	private:
		static std::shared_ptr<spdlog::logger> KEngineLogger;
		static std::shared_ptr<spdlog::logger> ApplicationLogger;
	};
}

",level
673,"/******************************************************************
eventQueue class for event notification between threads

Features:
- command pattern
- event queue to notify the comsumer
- can be used as blocking or non-blocking mode
- client can produce and consume specified event with name
- xxx

Written by <NAME>, <EMAIL>

Apache License Version 2.0, check LICENSE for more information.
All text above must be included in any redistribution.

Changelog:
2021-07-06: Initial version
2021-08-29: Updated declaration and cleanup redundancy
2021-xx-xx: xxx
******************************************************************/
#pragma once
#include <string>
#include <algorithm>
#include <list>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <assert.h>

template<typename T>
class EventQueue
{
public:
    static const std::string& VERSION()
    {
        return ""00.08"";
    }

public:
    using SharedPtr = std::shared_ptr<EventQueue>;
    using UniquePtr = std::unique_ptr<EventQueue>;
    using EventFunc = std::function<std::shared_ptr<T>()>; // nullary functor

public:
    struct stopped {};

    class EventPack
    {
    public:
        EventPack(EventFunc Func, const std::string Name = std::string("""")) : name_(Name), func_(Func) {};
        ~EventPack() {};

    public:
        std::string name_;
        EventFunc func_;
    };

public:
    EventQueue(int MaxSize = 50, bool Blocking = false)
        : max_size_(MaxSize), blocking_(Blocking), state_(STATE_READY), ref_count_(0) {};
    ~EventQueue() { this->stop(false); };

    void produce(EventFunc Event, const std::string Name = std::string(""""))
    {
        std::unique_lock<std::mutex> lock(mtx_);
        assert(STATE_READY == state_);
        queue_.emplace_back(Event, Name);
        while (queue_.size() > max_size_)
        {
            queue_.pop_front();
        }
        cv_.notify_one();
    };

    EventFunc consume()
    {
        std::unique_lock<std::mutex> lock(mtx_);
        if (blocking_)
        {
            cv_.wait(lock, [=]() { return STATE_READY != state_ || !queue_.empty(); });
            if (!queue_.empty())
            {
                EventFunc event(queue_.front().func_);
                queue_.pop_front();
                return event;
            }
            // The queue has been stopped. Notify the waiting thread blocked in
            // eventQueue::stop(true) (if any) that the queue is empty now
            cv_.notify_all();
            throw stopped();
        }
        else
        {
            if (!queue_.empty())
            {
                EventFunc event(queue_.front().func_);
                queue_.pop_front();
                return event;
            }
            else
            {
                return nullptr;
            }
        }
    };

    EventFunc consume(const std::string& Name)
    {
        std::unique_lock<std::mutex> lock(mtx_);
        if (blocking_)
        {
            cv_.wait(lock, [=]() { return STATE_READY != state_ || !queue_.empty(); });
            if (!queue_.empty())
            {
                typename std::list<EventPack>::const_iterator found = std::find_if(queue_.begin(), queue_.end(), [=](const auto& Obj)
                {
                    return Obj.name_ == Name;
                });
                if (found != queue_.end())
                {
                    EventFunc event(found->func_);
                    queue_.erase(found);
                    return event;
                }
            }
            // The queue has been stopped. Notify the waiting thread blocked in
            // eventQueue::stop(true) (if any) that the queue is empty now
            cv_.notify_all();
            throw stopped();
        }
        else
        {
            if (!queue_.empty())
            {
                typename std::list<EventPack>::const_iterator found = std::find_if(queue_.begin(), queue_.end(), [=](const auto& Obj)
                {
                    return Obj.name_ == Name;
                });
                if (found != queue_.end())
                {
                    EventFunc event(found->func_);
                    queue_.erase(found);
                    return event;
                }
                else
                {
                    return nullptr;
                }
            }
            else
            {
                return nullptr;
            }
        }
    };

    void stop(bool  [MASK] )
    {
        std::unique_lock<std::mutex> lock(mtx_);
        state_ = STATE_STOPPED;
        cv_.notify_all();
        if ( [MASK] )
        {
            // Wait till all events have been consumed
            cv_.wait(lock, [=]() { return queue_.empty(); });
        }
        else
        {
            // Cancel all pending events
            queue_.clear();
        }
    };

protected:
    friend void intrusive_ptr_add_ref(EventQueue* Ptr)
    {
        ++Ptr->ref_count_;
    };

    friend void intrusive_ptr_release(EventQueue* Ptr)
    {
        if (!--Ptr->ref_count_)
        {
            delete Ptr;
        }
    };

public:
    enum State { STATE_READY, STATE_STOPPED };

protected:
    int max_size_{ -1 };
    bool blocking_{ false };
    std::mutex mtx_;
    std::condition_variable cv_;
    std::list<EventPack> queue_;
    State state_;
    std::atomic_int ref_count_;
};
",WaitCompletion
674,"#include <gl/glut.h>
#include <cg/cg.h>
#include <Cg/cgGL.h>
#include <stdio.h>

int ww = 640, hh = 480;

void render();
void reshape(int w, int h);

static CGcontext   myCgContext;
static CGprofile   myCgVertexProfile;
static CGprofile   myCgFragmentProfile;
static CGprogram   myCgVertexProgram;
static CGprogram   myCgFragmentProgram;
static const char *myProgramName = ""Hello CG"";
static const char *myVertexProgramFileName = ""01vs.cg"";
static const char *myVertexProgramName = ""vs_main"";
static const char *myFragmentProgramFileName = ""01fs.cg"";
static const char *myFragmentProgramName = ""fs_main"";

int main(int argc, char** argv) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
	glutInitWindowSize(ww, hh);
	glutCreateWindow(myProgramName);
	glutDisplayFunc(render);
	glutReshapeFunc(reshape);
	glEnable(GL_DEPTH_TEST);
	myCgContext = cgCreateContext();
	cgGLSetDebugMode(CG_FALSE);
	cgSetParameterSettingMode(myCgContext, CG_DEFERRED_PARAMETER_SETTING);
	myCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
	cgGLSetOptimalOptions(myCgVertexProfile);
	myCgVertexProgram =
		cgCreateProgramFromFile(
			myCgContext,
			/* Cg runtime context */
			CG_SOURCE,
			/* Program in human-readable form */
			myVertexProgramFileName,
			/* Name of file containing program */
			myCgVertexProfile,
			/* Profile: OpenGL ARB vertex program */
			myVertexProgramName,
			/* Entry function name */
			NULL);
	/* No extra compiler options */
	cgGLLoadProgram(myCgVertexProgram);
	myCgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
	cgGLSetOptimalOptions(myCgFragmentProfile);
	myCgFragmentProgram =
		cgCreateProgramFromFile(
			myCgContext,
			/* Cg runtime context */
			CG_SOURCE,
			/* Program in human-readable form */
			myFragmentProgramFileName,
			/* Name of file containing program */
			myCgFragmentProfile,
			/* Profile: OpenGL ARB vertex program */
			myFragmentProgramName,
			/* Entry function name */
			NULL);
	/* No extra compiler options */
	cgGLLoadProgram(myCgFragmentProgram);
	glutMainLoop();
	return 0;
}
void reshape(int w, int h) {
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45, (float)w / (float)h, 0.1, 100);
	glViewport(0, 0, w, h);
	ww = w;
	hh = h;
}
void render() {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor(.0f, .0f, .2f, 1.0f);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(.0, .0, 5.0, .0, .0, .0, .0, 1.0, .0);
	static float angle;
	glRotatef(angle, 0.0, 1.0, 0.0);
	cgGLBindProgram(myCgVertexProgram);
	cgGLEnableProfile(myCgVertexProfile);
	cgGLBindProgram(myCgFragmentProgram);
	cgGLEnableProfile(myCgFragmentProfile);
	//将ModelViewProjection矩阵传入shader
	CGparameter  [MASK]  = cgGetNamedParameter(myCgVertexProgram, ""MVP"");
	cgGLSetStateMatrixParameter( [MASK] , CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
	glutSolidTorus(0.3, 1.0, 30, 30);
	cgGLDisableProfile(myCgVertexProfile);
	cgGLDisableProfile(myCgFragmentProfile);
	angle += 0.5;
	if (angle >= 360) angle = 0.0f;
	glutSwapBuffers();
	glutPostRedisplay();
}",mvp
675,"/*
 * (C) Copyright 2019-2020 UCAR
 *
 * This software is licensed under the terms of the Apache Licence Version 2.0
 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
 */

#include ""atlas/field.h""
#include ""atlas/functionspace.h""
#include ""atlas/grid.h""
#include ""atlas/util/Config.h""

#include ""eckit/config/YAMLConfiguration.h""

#include ""ucldasv2/Geometry/Geometry.h""

namespace ucldasv2 {

// ----------------------------------------------------------------------------

  Geometry::Geometry(const eckit::Configuration & conf,
                     const eckit::mpi::Comm & comm)
    : comm_(comm),
      fmsinput_(comm, conf) {

    fmsinput_.updateNameList();

    ucldasv2_geo_setup_f90(keyGeom_, &conf, &comm);

    // Set ATLAS lon/lat field
    atlasFieldSet_.reset(new atlas::FieldSet());
    ucldasv2_geo_set_atlas_lonlat_f90(keyGeom_, atlasFieldSet_->get());
    atlas::Field atlasField = atlasFieldSet_->field(""lonlat"");

    // Create ATLAS function space
    atlasFunctionSpace_.reset(new atlas::functionspace::PointCloud(atlasField));

    // Set ATLAS function space pointer in Fortran
    ucldasv2_geo_set_atlas_functionspace_pointer_f90(keyGeom_,
      atlasFunctionSpace_->get());

    // Fill ATLAS fieldset
    atlasFieldSet_.reset(new atlas::FieldSet());
    ucldasv2_geo_fill_atlas_fieldset_f90(keyGeom_, atlasFieldSet_->get());
  }
  // ----------------------------------------------------------------------------
  Geometry::Geometry(const Geometry & other)
    : comm_(other.comm_),
      fmsinput_(other.fmsinput_) {
    const int  [MASK]  = other.keyGeom_;
    ucldasv2_geo_clone_f90(keyGeom_,  [MASK] );
    atlasFunctionSpace_.reset(new atlas::functionspace::PointCloud(
                              other.atlasFunctionSpace_->lonlat()));
    ucldasv2_geo_set_atlas_functionspace_pointer_f90(keyGeom_,
      atlasFunctionSpace_->get());
    atlasFieldSet_.reset(new atlas::FieldSet());
    for (int jfield = 0; jfield < other.atlasFieldSet_->size(); ++jfield) {
      atlas::Field atlasField = other.atlasFieldSet_->field(jfield);
      atlasFieldSet_->add(atlasField);
    }
  }
  // ----------------------------------------------------------------------------
  Geometry::~Geometry() {
    ucldasv2_geo_delete_f90(keyGeom_);
  }
  // ----------------------------------------------------------------------------
  GeometryIterator Geometry::begin() const {
    // return start of the geometry on this mpi tile
    int ist, iend, jst, jend;
    ucldasv2_geo_start_end_f90(keyGeom_, ist, iend, jst, jend);
    return GeometryIterator(*this, ist, jst);
  }
  // ----------------------------------------------------------------------------
  GeometryIterator Geometry::end() const {
    // return end of the geometry on this mpi tile
    // decided to return index out of bounds for the iterator loops to work
    return GeometryIterator(*this, -1, -1);
  }
  // -----------------------------------------------------------------------------
  std::vector<size_t> Geometry::variableSizes(
      const oops::Variables & vars) const {
    std::vector<size_t> lvls(vars.size());
    ucldasv2_geo_get_num_levels_f90(toFortran(), vars, lvls.size(),
                                                      lvls.data());
    return lvls;
  }
  // ----------------------------------------------------------------------------
  void Geometry::print(std::ostream & os) const {
    // TODO(Travis): Implement this correctly.
  }
  // -----------------------------------------------------------------------------
  atlas::FunctionSpace * Geometry::atlasFunctionSpace() const {
    return atlasFunctionSpace_.get();
  }
  // -----------------------------------------------------------------------------
  atlas::FieldSet * Geometry::atlasFieldSet() const {
    return atlasFieldSet_.get();
  }
  // ----------------------------------------------------------------------------
}  // namespace ucldasv2
",key_geo
676,"/*
 * StderrLogger.cpp
 *
 *  Created on: May 7, 2016
 *      Author: samuele
 */

#include ""StderrLogger.h""
#include <iostream>                                     // for printing on the stderr
#include <cstdarg>                                      // for va_list definition
#include <cstdio>                                       // for vsprintf definition
#include <boost/date_time/posix_time/posix_time.hpp>    // for posix_time definition

#define BUFFER_SIZE 4096

namespace macisamuele {
namespace Logger {

std::map<int, std::string> initLogStringMap() {
    std::map<int, std::string>  [MASK] ;
     [MASK] [LOG_EMERG] = ""EMERG"";
     [MASK] [LOG_ALERT] = ""ALERT"";
     [MASK] [LOG_CRIT] = ""CRIT"";
     [MASK] [LOG_ERR] = ""ERR"";
     [MASK] [LOG_WARNING] = ""WARNING"";
     [MASK] [LOG_NOTICE] = ""NOTICE"";
     [MASK] [LOG_INFO] = ""INFO"";
     [MASK] [LOG_DEBUG] = ""DEBUG"";
     [MASK] [LOG_TRACE] = ""TRACE"";
    return  [MASK] ;
}

StderrLogger::StderrLogger() :
        logStringMap(initLogStringMap()) {
    CONSTRUCTOR(this);
}

StderrLogger::~StderrLogger() {
    DESTRUCTOR(this);
}

void StderrLogger::log(int iLevel, const std::string& iLocation, const char * iMessage, ...) {
    char aBuffer[BUFFER_SIZE + 1] = { 0 };
    va_list argptr;
    va_start(argptr, iMessage);
    vsprintf(aBuffer, iMessage, argptr);
    std::cerr << boost::posix_time::microsec_clock::local_time() << "" | "" << logStringMap[iLevel] << "" | "" << iLocation << "" | "" << aBuffer << std::endl;
}

} /* namespace Logger */
} /* namespace macisamuele */
",aMap
677,"#pragma once

#include <cmath>
#include <vector>
#include <SDL.h>

#define SCREEN_WIDTH 600
#define SCREEN_HEIGHT 600

#define SCREEN_X 400
#define SCREEN_Y 300

float cameraDistance = 20;
float scale = 2;
float cameraAngle = 0;

using namespace std;

class Block {
private:
    vector<vector<float>> cubeVertices = {
        {1.0f, 1.0f, 1.0f},     // TR F
        {1.0f, -1.0f, 1.0f},    // BR F
        {-1.0f, -1.0f, 1.0f},   // BL F
        {-1.0f, 1.0f, 1.0f},    // TL F
        {1.0f, 1.0f, -1.0f},    // TR B
        {1.0f, -1.0f, -1.0f},   // BR B
        {-1.0f, -1.0f, -1.0f},  // BL B
        {-1.0f, 1.0f, -1.0f}    // TL B
    };

    vector<int> CURXYPOS = {0, 0};

public:
    bool renderPointsToCamera(SDL_Renderer* renderer);
    bool renderPointsAboveFacingCameraPoints(SDL_Renderer* renderer);
    bool rotateY(SDL_Renderer * renderer, float angle);
};


bool Block::renderPointsToCamera(SDL_Renderer* renderer) {
    // Project and draw the rotated and scaled cube
    for (const auto& vertex : cubeVertices) {
        float x = vertex[0] * scale;
        float y = vertex[1] * scale;
        float z = vertex[2] * scale;

        int screenX = SCREEN_X + static_cast<int>(cameraDistance * x);
        int screenY = SCREEN_Y + static_cast<int>(cameraDistance * y);

        SDL_RenderDrawPoint(renderer, static_cast<int>(screenX), static_cast<int>(screenY));
    }

    return true;
}

bool Block::rotateY(SDL_Renderer* renderer, float angle) {
    vector<vector<float>>  [MASK]  = {};
    for (const auto& vertex : cubeVertices) {
        float newX = vertex[0] * cos(angle) - vertex[2] * sin(angle);
        float newZ = vertex[0] * sin(angle) + vertex[2] * cos(angle);

         [MASK] .push_back({newX, vertex[1], newZ});
    }
    cubeVertices =  [MASK] ;
    return true;
}
",rotatedVerticies
678,"#include ""RFT_IF_PACKET_Rev1.2.h""

#include <string.h>

CRT_RFT_IF_PACKET::CRT_RFT_IF_PACKET()
{
	memset(m_rcvd_product_name,     0x00, sizeof(m_rcvd_product_name));
	memset(m_rcvd_serial_number,    0x00, sizeof(m_rcvd_serial_number));
	memset(m_rcvd_firmware_version, 0x00, sizeof(m_rcvd_firmware_version));

	m_rcvd_curr_RX_ID = 0;	// current sensor's RX ID, Only CAN version
	m_rcvd_curr_TX_ID_1 = 0;  // current sensor's TX ID #1, Only CAN version
	m_rcvd_curr_TX_ID_2 = 0;  // current sensor's TX ID #2, Only CAN version
	m_rcvd_set_RX_ID = 0;		// setting value of sensor's RX ID, Only CAN version
	m_rcvd_set_TX_ID_1 = 0;   // setting value of sensor's TX ID #1, Only CAN version
	m_rcvd_set_TX_ID_2 = 0;	// setting value of sensor's TX ID #2, Only CAN version

	m_rcvd_curr_comm_baudrate = 0; // current baudrate
	m_rcvd_set_comm_baudrate = 0;  // setting value of baudrate

	m_rcvd_filter_type = 0;
	m_rcvd_filter_setting_value = 0;

	m_rcvd_tx_frq = 0;

	m_response_cmd = 0;
	m_response_result = 0;
	m_response_errcode = 0;

	memset(m_rcvdForce, 0x00, sizeof(m_rcvdForce));

	m_rcvdForceStatus = 0;

	memset(m_rcvdOverloadCnt, 0x00, sizeof(m_rcvdOverloadCnt));

	m_fDividerForce = FORCE_DIVIDER;
	m_fDividerTorque = TORQUE_DIVIDER;
}

CRT_RFT_IF_PACKET::~CRT_RFT_IF_PACKET()
{

}

void CRT_RFT_IF_PACKET::setDivider(float force, float torque)
{
	m_fDividerForce = force;
	m_fDividerTorque = torque;
}

bool CRT_RFT_IF_PACKET::DFG_read_product_name(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_PRODUCT_NAME;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_serial_number(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_SERIAL_NUMBER;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_firmware_version(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_FIRMWARE_VER;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_message_ID(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_ID;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_comm_baudrate(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_COMM_BAUDRATE;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_filter_type(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_FT_FILTER;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_force_once(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_FT_ONCE;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_force(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_FT_CONT;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_read_output_frq(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_CONT_OUT_FRQ;

	return true;
}



bool CRT_RFT_IF_PACKET::DFG_read_overload_count(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_GET_OVERLOAD_COUNT;

	return true;
}












bool CRT_RFT_IF_PACKET::DFG_set_message_ID(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE], unsigned char rxID, unsigned char txID_1, unsigned char txID_2)
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_SET_ID;
	data_field[1] = rxID;
	data_field[2] = txID_1;
	data_field[3] = txID_2;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_set_comm_baudrate(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE], unsigned char baud_type)
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_SET_COMM_BAUDRATE;
	data_field[1] = baud_type;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_set_filter_type(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE], unsigned char filter_type, unsigned char set_value)
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_SET_FT_FILTER;
	data_field[1] = filter_type;
	data_field[2] = set_value;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_set_stop_force_out(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE])
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_FT_CONT_STOP;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_set_output_frq(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE], unsigned char frq_type)
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_SET_CONT_OUT_FRQ;
	data_field[1] = frq_type;

	return true;
}

bool CRT_RFT_IF_PACKET::DFG_set_bias(unsigned char data_field[COMMAND_PACKET_DATA_FIELD_SIZE], unsigned char is_on)
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	data_field[0] = CMD_SET_BIAS;
	data_field[1] = is_on;

	return true;
}


void CRT_RFT_IF_PACKET::convertPacket_To_Force(unsigned char *rcvdPacket, float *force, float forceDivider, float torqueDivider)
{
	short raw;
	unsigned short temp;

	for (int idx = 0; idx < RFT_NUM_OF_FORCE; idx++)
	{
		temp = rcvdPacket[2 * idx] * 256 + rcvdPacket[2 * idx + 1];
		raw = (signed short)temp;

		if (idx < 3) // force
		{
			force[idx] = ((float)raw) / forceDivider;
		}
		else // torque
		{
			force[idx] = ((float)raw) / torqueDivider;
		}
	}

	// force status - overload.....
	m_rcvdForceStatus = rcvdPacket[12];
}


bool CRT_RFT_IF_PACKET::rcvd_data_field_processing(unsigned char data_field[RESPONSE_PACKET_DATA_FIELD_SIZE], unsigned char check_command_type)
{
	if (data_field == 0) // pointer validataion checking.
		return false;

	unsigned char rcvd_cmd_type = data_field[0]; // command type

	if (check_command_type != 0)
	{
		if (rcvd_cmd_type != check_command_type)
			return false;
	}

	bool  [MASK]  = true;

	switch (rcvd_cmd_type)
	{
	case CMD_GET_PRODUCT_NAME:
		for (int idx = 0; idx < RFT_PRODUCT_NAME_LENGTH; idx++)
			m_rcvd_product_name[idx] = data_field[idx + 1];
		break;
	case CMD_GET_SERIAL_NUMBER:
		for (int idx = 0; idx < RFT_SERIAL_NUMBER_LENGTH; idx++)
			m_rcvd_serial_number[idx] = data_field[idx + 1];
		break;
	case CMD_GET_FIRMWARE_VER:
		for (int idx = 0; idx < RFT_FIRMWARE_VER_LENGTH; idx++)
			m_rcvd_firmware_version[idx] = data_field[idx + 1];
		break;
	case CMD_SET_ID:
		m_response_cmd = rcvd_cmd_type;
		m_response_result = data_field[1];
		m_response_errcode = data_field[2];
		break;
	case CMD_GET_ID:
		m_rcvd_curr_RX_ID	= data_field[1];	// current sensor's RX ID, Only CAN version
		m_rcvd_curr_TX_ID_1 = data_field[2];	// current sensor's TX ID #1, Only CAN version
		m_rcvd_curr_TX_ID_2 = data_field[3];	// current sensor's TX ID #2, Only CAN version
		m_rcvd_set_RX_ID	= data_field[4];	// setting value of sensor's RX ID, Only CAN version
		m_rcvd_set_TX_ID_1	= data_field[5];	// setting value of sensor's TX ID #1, Only CAN version
		m_rcvd_set_TX_ID_2	= data_field[6];	// setting value of sensor's TX ID #2, Only CAN version
		break;
	case CMD_SET_COMM_BAUDRATE:
		m_response_cmd = rcvd_cmd_type;
		m_response_result = data_field[1];
		m_response_errcode = data_field[2];
		break;
	case CMD_GET_COMM_BAUDRATE:
		m_rcvd_curr_comm_baudrate = data_field[1]; // current baudrate
		m_rcvd_set_comm_baudrate  = data_field[2]; // setting value of baudrate
		break;
	case CMD_SET_FT_FILTER:
		m_response_cmd = rcvd_cmd_type;
		m_response_result = data_field[1];
		m_response_errcode = data_field[2];
		break;
	case CMD_GET_FT_FILTER:
		m_rcvd_filter_type			= data_field[1];
		m_rcvd_filter_setting_value = data_field[2];
		break;
	case CMD_FT_ONCE:
		m_response_cmd = rcvd_cmd_type;
		//convertPacket_To_Force((&data_field[1]), m_rcvdForce, FORCE_DIVIDER, TORQUE_DIVIDER);
		convertPacket_To_Force((&data_field[1]), m_rcvdForce, m_fDividerForce, m_fDividerTorque);
		break;
	case CMD_FT_CONT:
		m_response_cmd = rcvd_cmd_type;
		//convertPacket_To_Force((&data_field[1]), m_rcvdForce, FORCE_DIVIDER, TORQUE_DIVIDER);
		convertPacket_To_Force((&data_field[1]), m_rcvdForce, m_fDividerForce, m_fDividerTorque);
		break;
	case CMD_FT_CONT_STOP:
		// NO - RESPONSE PACKET
		break;
	case CMD_RESERVED_1:
		break;
	case CMD_RESERVED_2:
		break;
	case CMD_SET_CONT_OUT_FRQ:
		m_response_cmd = rcvd_cmd_type;
		m_response_result = data_field[1];
		m_response_errcode = data_field[2];
		break;
	case CMD_GET_CONT_OUT_FRQ:
		m_rcvd_tx_frq = data_field[1];
		break;
	case CMD_SET_BIAS:
		break;
	case CMD_GET_OVERLOAD_COUNT:
		m_response_cmd = rcvd_cmd_type;
		for (int i = 0; i < RFT_NUM_OF_FORCE; i++)
		{
			m_rcvdOverloadCnt[i] = data_field[i + 1];
		}
		break;
	default:
		 [MASK]  = false;
		break;
	}

	return  [MASK] ;
}


///////////////////////////////////////////////////////////////////////////////////////////
// functions for UART communication, checksum calculation, UART Packet generation
unsigned char CRT_RFT_IF_PACKET::calcChecksum(unsigned char *pkt_buff, int pkt_size)
{
	unsigned char checksum = 0;

	for (int idx = 1; idx < (pkt_size - 2); idx++) // except SOP, CHECKSUM and EOP
		checksum += pkt_buff[idx];

	return checksum;
}

// UPG(Uart Packet Generation) functions

bool CRT_RFT_IF_PACKET::UPG_read_product_name(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_product_name(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_serial_name(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_serial_number(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_firmware_version(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_firmware_version(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_comm_baudrate(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_comm_baudrate(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_filter_type(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_filter_type(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_force_once(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_force_once(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_force(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_force(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_output_frq(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_output_frq(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_read_overload_count(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_read_overload_count(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}


bool CRT_RFT_IF_PACKET::UPG_set_comm_baudrate(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE], unsigned char buad_type)
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_set_comm_baudrate(packet_buff + 1, buad_type);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_set_filter_type(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE], unsigned char filter_type, unsigned char set_value)
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_set_filter_type(packet_buff + 1, filter_type, set_value);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_set_stop_force_out(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE])
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_set_stop_force_out(packet_buff + 1);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_set_output_frq(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE], unsigned char frq_type)
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_set_output_frq(packet_buff + 1, frq_type);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UPG_set_bias(unsigned char packet_buff[UART_COMMAND_PACKET_SIZE], unsigned char is_on)
{
	if (packet_buff == 0)
		return false;

	// buffer clear
	for (int idx = 0; idx < UART_COMMAND_PACKET_SIZE; idx++)
		packet_buff[idx] = 0x00;

	packet_buff[0] = SOP;
	DFG_set_bias(packet_buff + 1, is_on);
	packet_buff[UART_COMMAND_PACKET_SIZE - 2] = calcChecksum(packet_buff, UART_COMMAND_PACKET_SIZE);
	packet_buff[UART_COMMAND_PACKET_SIZE - 1] = EOP;

	return true;
}

bool CRT_RFT_IF_PACKET::UART_packet_processing(unsigned char packet_buff[UART_RESPONSE_PACKET_SIZE], unsigned char check_command_type)
{
	if (packet_buff == 0)
		return false;

	unsigned char checksum = calcChecksum(packet_buff, UART_RESPONSE_PACKET_SIZE);
	if ((packet_buff[0] == SOP)
		&& (packet_buff[UART_RESPONSE_PACKET_SIZE - 2] == checksum)
		&& (packet_buff[UART_RESPONSE_PACKET_SIZE - 1] == EOP))
	{
		if (rcvd_data_field_processing(packet_buff + 1, check_command_type))
			return true;
		else
			return false;
	}
	else
	{
		return false;
	}

	return true;
}

// END OF FILE
",prcs_result
679,"#include <Adafruit_NeoPixel.h>

#define NEOPIXEL_PIN 6

# define REQUEST_BOARD_STATUS '1'
# define REQUEST_CLEAR_BOARD '2'

int WHITE_MARGIN = 650;
int BLACK_MARGIN = 450; 

char boardStatus[64];

Adafruit_NeoPixel strip = Adafruit_NeoPixel(64, NEOPIXEL_PIN);

int multiplexerPinsValues[16][4] = { 
                                    {0, 0, 0, 0},
                                    {0, 0, 0, 1},
                                    {0, 0, 1, 0},
                                    {0, 0, 1, 1},
                                    {0, 1, 0, 0},
                                    {0, 1, 0, 1},
                                    {0, 1, 1, 0},
                                    {0, 1, 1, 1},
                                    {1, 0, 0, 0},
                                    {1, 0, 0, 1},
                                    {1, 0, 1, 0},
                                    {1, 0, 1, 1},
                                    {1, 1, 0, 0},
                                    {1, 1, 0, 1},
                                    {1, 1, 1, 0},
                                    {1, 1, 1, 1}
                                 };


void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);

  strip.begin();
  strip.show();
  
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
}

void loop() {
  if (Serial.available()){
    char request = Serial.read();
    switch(request){
      case REQUEST_BOARD_STATUS:
        readBoard();
        break;
      case REQUEST_CLEAR_BOARD:
        clearBoard();
        break;
    }
  }
}

void readBoard(){
  for (int multiplexerPin=0; multiplexerPin<16; multiplexerPin++){
    // Set multiplexer pin
    for (int i=0; i<4; i++){
      digitalWrite(9+i, multiplexerPinsValues[multiplexerPin][i]);
    }
    readValues(multiplexerPin);
  }

  for (int i=0; i<64; i++){
    Serial.write(boardStatus[i]);
  }
  Serial.println();
}

void clearBoard(){
  for (int i=0; i<64; i++){
    strip.setPixelColor(i, 0, 0, 0);
  }
}

void readValues(int multiplexerPin){
  int z = multiplexerPin*4;
  boardStatus[z] = checkVal(analogRead(A0));
  z++;
  boardStatus[z] = checkVal(analogRead(A1));
  z++;
  boardStatus[z] = checkVal(analogRead(A2));
  z++;
  boardStatus[z] = checkVal(analogRead(A3));
}


char checkVal(int  [MASK] ){
  if ( [MASK]  < WHITE_MARGIN){
    return 'w';
  }else{
    if ( [MASK]  > BLACK_MARGIN){
      return 'b';
    }else{
      return '-';
    }
  }
}

",val
680,"#include <string>

#include ""GarrysMod/Lua/Interface.h""
#include ""util/SigScan.h""

using namespace GarrysMod;

typedef void *(__cdecl *HandleChange_LuaFn)(std::string &dir, std::string &filename, std::string &ext);

HandleChange_LuaFn HandleChange_Lua;
const char *HandleChange_Lua_Signature = ""\x55\x8B\xEC\x81\xEC????\x53\x56\x57\x8B\x7D\x10"";


int Refresh(lua_State *state) {
	std::string  [MASK]  = ""lua/"";
	 [MASK] .append(LUA->CheckString(1));

	// FIX SLASHES
	size_t pos = 0;

	while ((pos =  [MASK] .find(""\\"", pos)) != std::string::npos) {
		 [MASK] .replace(pos, 1, ""/"");

		pos++;
	}

	pos = 0;

	while ((pos =  [MASK] .find(""//"", pos)) != std::string::npos) {
		 [MASK] .replace(pos, 2, ""/"");

		pos++;
	}

	std::string dir =  [MASK] .substr(0,  [MASK] .find_last_of(""/"") + 1);
	std::string ext =  [MASK] .substr( [MASK] .find_last_of(""."") + 1);

	std::string filename =  [MASK] .substr( [MASK] .find_last_of(""/"") + 1,  [MASK] .length() - ext.length() - dir.length() - 1);

	HandleChange_Lua(dir, filename, ext);

	return 0;
}

GMOD_MODULE_OPEN() {
	SigScan server = SigScan(""server"");

	HandleChange_Lua = (HandleChange_LuaFn)server.Scan(HandleChange_Lua_Signature);

	if (!HandleChange_Lua) {
		LUA->ThrowError(""HandleChange_Lua not found."");
		return 0;
	}

	LUA->PushSpecial(Lua::SPECIAL_GLOB);
		LUA->PushCFunction(Refresh);
		LUA->SetField(-2, ""refresh"");
	LUA->Pop();

	return 0;
}

GMOD_MODULE_CLOSE() {
	return 0;
}",filepath
681,"#include ""Auxiliary_Methods.h""

string Auxiliary_Methods:: int_to_string_convert (int number)
{
    ostringstream ss;
    ss << number;
    string str = ss.str();
    return str;
}

int Auxiliary_Methods::string_to_int_convert (string text)
{
    std::string str = text;
    int k;
    std::istringstream iss(str);
    iss >> k;
    return k;
}

int Auxiliary_Methods:: check_how_many_days_has_this_month(int year, int month)
{
    switch (month)
    {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        return 31;
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        return 30;
        break;
    case 2:
    {
        if (((year%4 == 0) && (year%100 !=0)) || (year%400 == 0)) return 29;
        else return 28;
    }
    break;
    }
}

bool Auxiliary_Methods:: user_specified_date_format_check (string date)
{
    if ((date[4] != '-')||(date[7] != '-')||(date.size()!=10))
    {
        cout << ""Date entered in incorrect format..."";
        Sleep (2000);
        return false;
    }

    for (int i=0; i<10; i++)
    {
        if ((i == 4) || (i == 7)) i++;
        if ((date[i] == '0')||(date[i] == '1')||(date[i] == '2')||(date[i] == '3')||(date[i] == '4')||(date[i] == '5')||(date[i] == '6')||(date[i] == '7')||(date[i] == '8')||(date[i] == '9'))
        {
            continue;
        }
        else
        {
            cout << ""Date entered in incorrect format..."";
            Sleep (2000);
            return false;
        }
    }
    return true;
}

bool Auxiliary_Methods:: user_specified_date_check (string date)
{
   SYSTEMTIME st;
   GetSystemTime(&st);
   string year_data = """", month_data = """", day_data = """";
   int year = 0, month = 0, day = 0;

   for (int i=0; i<4; i++) { year_data += date[i];}
   for (int i=0; i<2; i++) { month_data += date[i+5]; day_data += date[i+8];}

   year = string_to_int_convert(year_data);
   month = string_to_int_convert(month_data);
   day = string_to_int_convert(day_data);

   if ((year < 2000) || (year > st.wYear)) {cout << ""Year must be between 2000 and now... ""; Sleep (2000); return false;}
   if ((month < 1) || (month > 12)) {cout << ""Month must be between 1 and 12... ""; Sleep (2000); return false;}
   if ((day < 1) || (day > check_how_many_days_has_this_month(year, month)))
   {
       cout << ""Day must be between 1 and "" << check_how_many_days_has_this_month(year, month) << "".."";
       Sleep (2000);
       return false;
   }
   if ( date > get_todays_date())
   {
       cout << ""Date cannot be greater than today's date.."";
       Sleep (2000);
       return false;
   }

   return true;
}

string Auxiliary_Methods::get_todays_date()
{
    SYSTEMTIME st;
    GetSystemTime(&st);
    string month = int_to_string_convert(st.wMonth);
    string day = int_to_string_convert(st.wDay);
    if (st.wMonth < 10) month = ""0"" + int_to_string_convert (st.wMonth);
    if (st.wDay <10) day = ""0"" + int_to_string_convert (st.wDay);
    string todays_date = """";
    todays_date = int_to_string_convert(st.wYear) +""-""+ month +""-""+ day;
    return todays_date;
}
string Auxiliary_Methods::get_first_day_of_current_month ()
{
    string first_day_of_this_month = get_todays_date();
    first_day_of_this_month[8] = '0' ; first_day_of_this_month[9] = '1';
    return first_day_of_this_month;
}

string Auxiliary_Methods:: get_first_day_of_last_month()
{
    SYSTEMTIME st;
    GetSystemTime(&st);
    string last_month = int_to_string_convert(st.wMonth-1);
    string day = ""01"";
    if ((st.wMonth -1 < 10) && (st.wMonth -1 !=0)) last_month = ""0"" + int_to_string_convert(st.wMonth-1);
    if (st.wMonth -1 == 0) last_month = ""12"";
    string first_day_of_last_month = int_to_string_convert(st.wYear) +""-""+ last_month +""-""+ day;
    return first_day_of_last_month;
}

bool Auxiliary_Methods:: amount_entered_by_user_validation (string & text)
{
    int number_of_commas = 0;
    int  [MASK]  = 0;

    for (int i=0; i<text.size(); i++)
    {
        if (text[i] == ',')
        {
            text[i] = '.';
            number_of_commas++;
        }
        if (text[i] == '.')  [MASK] ++;

        if ((text[i] != '.') && ((text[i] != '0')&&(text[i] != '1')&&(text[i] != '2')&&(text[i] != '3')&&(text[i] != '4')&&(text[i] != '5')&&(text[i] != '6')&&(text[i] != '7')&&(text[i] != '8')&&(text[i] != '9')))
        {
            cout << ""Data entered in incorrect format.. ""; Sleep (2000);
            return false;
        }
        if ((text[i] == '.') || (text[i] == '0')||(text[i] == '1')||(text[i] == '2')||(text[i] == '3')||(text[i] == '4')||(text[i] == '5')||(text[i] == '6')||(text[i] == '7')||(text[i] == '8')||(text[i] == '9'))
        {
            continue;
        }
    }

    if ((number_of_commas > 1)||( [MASK]  > 1)) {cout << ""Data entered in incorrect format.. ""; Sleep (2000); return false;}
    if ((text[0] == ',') || (text[0] == '.')) {cout << ""Data entered in incorrect format.. ""; Sleep (2000); return false;}

    return true;
}
bool Auxiliary_Methods:: user_specified_date_validation (string date)
{
    if ((user_specified_date_format_check(date))&&(user_specified_date_check(date))) return true;
    else return false;
}


string Auxiliary_Methods::set_gap_size (string amount)
{
    string gap_size = ""               "";
    gap_size.erase (1,amount.size());
    return gap_size;
}

string Auxiliary_Methods::make_first_letter_capital(string text)
{
    if (!text.empty())
    {
        transform(text.begin(), text.end(), text.begin(), ::tolower);
        text[0] = toupper(text[0]);
    }
    return text;
}
",number_of_dots
682,"/*!
 * @file
 * @brief TODO
 */

 #include <egg/core/eggArchive.hpp>
 #include <rvl/arc/binary_format.h>
 #include <rvl/dvd/dvd.h>
 #include <rvl/dvd/dvdFs.h>

namespace EGG {

bool Archive::sIsArchiveListInitialized;
nw4r::ut::List Archive::sArchiveList;

Archive::~Archive() { removeList(this); }

void Archive::removeList(Archive* pArchive) {
  nw4r::ut::List_Remove(&sArchiveList, pArchive);
}

Archive* Archive::mount(void* arcStart, Heap* pHeap, int align) {
  Archive* archive = findArchive(arcStart); // r30, INLINE archive wrapper

  if (archive == nullptr) {
    archive = new (pHeap, align) Archive(); // INLINE
    EGG_ASSERT(archive, ""eggArchive.cpp"", 159, ""archive != NULL"");

    bool could_create = archive->initHandle(arcStart);
    if (could_create) {
      archive->mStatus = LOADED_AND_CAN_FAST_READ;
    } else {
      archive->mStatus = NOT_LOADED;
      EGG_ASSERT(false, ""eggArchive.cpp"", 166, ""false"");
    }

    // If we failed, clean up
    if (!could_create) // INLINE
    {
      delete archive;
      archive = nullptr;
    }
  } else {
    ++archive->mRefCount;
  }

  return archive;
}

// exact same as above but _10 set to 2 not 1
Archive* Archive::mountNoFastGet(void* arcStart, Heap* pHeap, int align) {
  Archive* archive = findArchive(arcStart); // r30, INLINE archive wrapper
  if (archive == nullptr) {
    archive = new (pHeap, align) Archive(); // INLINE
    EGG_ASSERT(archive, ""eggArchive.cpp"", 159, ""archive != NULL"");

    bool could_create = archive->initHandle(arcStart);
    if (could_create) {
      archive->mStatus = LOADED;
    } else {
      archive->mStatus = NOT_LOADED;
      EGG_ASSERT(false, ""eggArchive.cpp"", 166, ""false"");
    }

    // If we failed, clean up
    if (!could_create) // INLINE
    {
      delete archive;
      archive = nullptr;
    }
  } else {
    ++archive->mRefCount;
  }

  return archive;
}
void Archive::unmount() {
  if (mRefCount != 0 && --mRefCount == 0) {
    mStatus = NOT_LOADED;
    delete this;
  }
}
int Archive::convertPathToEntryID(const char* path) {
  return ARCConvertPathToEntrynum(&this->mArcHandle, path);
}
void* Archive::getFileFast(int entryNum, FileInfo* pInfo) {
  rvlArchiveFile fileInfo; // col
  void* result = nullptr;
  if (mStatus == LOADED_AND_CAN_FAST_READ) {
    if (mArcHandle.open(entryNum, fileInfo)) {
      result = ARCGetStartAddrInMem(&fileInfo);
      if (pInfo) {
        pInfo->startOffset = ARCGetStartOffset(&fileInfo);
        pInfo->length = ARCGetLength(&fileInfo);
      }
    }
    ARCClose(&fileInfo);
  }
  return result;
}
void Archive::getFile(const char* path, FileInfo* pInfo) {
  rvlArchiveFile fileInfo; // col
  if (mArcHandle.open(path, fileInfo)) {
    pInfo->startOffset = ARCGetStartOffset(&fileInfo);
    pInfo->length = ARCGetLength(&fileInfo);
  }
  ARCClose(&fileInfo);
}

// Reads header from u8 file on disc. Then reads header and allocates file based
// on that filesize.
void* Archive::loadFromDisc(const char* path, Heap* pHeap, int align) {
  DVDFileInfo  [MASK] ;
  int alignRounded = align > 0 ? -32 : 32; // r31
  if (!DVDOpen(path, & [MASK] ))
    return nullptr;

  void* ARC = nullptr;
  rvlArchiveHeader* readHeader = (rvlArchiveHeader*)pHeap->alloc(
      sizeof(rvlArchiveHeader), alignRounded); // r30

  if (readHeader != nullptr) {
    if ((u32)DVDReadPrio(& [MASK] , readHeader, 32, 0, 2) >= 32) {
      u32 arcSize =
          ROUND_UP(readHeader->nodes.size + sizeof(rvlArchiveHeader), 32);
      ARC = pHeap->alloc(arcSize, align); // r31

      if (ARC) {
        // needed for match
        u32 res = DVDReadPrio(& [MASK] , ARC, arcSize, 0, 2);
        if (res != arcSize) {
          pHeap->free(ARC); // If we failed to read fst
          ARC = nullptr;
        }
      }
    }
    pHeap->free(readHeader);
  }

  DVDClose(& [MASK] );
  return ARC;
}

} // namespace EGG
",dvdFileInfo
683,"#include ""hamming74_top.cc""
#include <fmt/format.h>
#include <vector>
unsigned int encode(unsigned int word) {
  return (((word & 1) ^ (word & 2) >> 1 ^ (word & 8) >> 3) << 0) |
         (((word & 1) ^ (word & 4) >> 2 ^ (word & 8) >> 3) << 1) |
         (((word & 1)) << 2) |
         (((word & 2) >> 1 ^ (word & 4) >> 2 ^ (word & 8) >> 3) << 3) |
         (((word & 2) >> 1) << 4) | (((word & 4) >> 2) << 5) |
         (((word & 8) >> 3) << 6);
}
int main() {
  using module = cxxrtl_design::p_user__module__hamming74;
  module mod;
  mod.step();
  auto &io_in = mod.p_io__in;
  auto &io_out = mod.p_io__out;
  bool  [MASK]  = true;
  // Test encoding first
  fmt::print(""Testing encoder…\n"");
  for (unsigned int inp = 0; inp < 16; ++inp) {
    io_in.set<unsigned int>(1 << 7 | inp);
    mod.step();
    auto output = io_out.get<unsigned int>();
    auto encoded = encode(inp);
    bool equal = (encoded == output);
     [MASK]  =  [MASK]  && equal;
    fmt::print(""input: {:04b}  output: {:08b} encoded: {:08b} same: {}\n"", inp,
               output, encoded, equal ? ""Y"" : ""N"");
    mod.step();
  }
  // Test decoding: encode word, modify word, decode word
  fmt::print(""Testing decoder…\n"");
  fmt::print(""Testing unaltered codewords…\n"");
  bool dec_success = true;
  for (unsigned int inp = 0; inp < 16; ++inp) {
    auto encoded = encode(inp);
    io_in.set<unsigned int>(encoded);
    mod.step();
    auto hw_out = io_out.get<unsigned int>();
    auto hw_decoded = hw_out & ((1 << 4) - 1);
    auto hw_syndrome = (hw_out & (((1 << 3) - 1) << 4)) >> 4;
    bool equal = (inp == hw_decoded);
    dec_success = dec_success && equal;
    fmt::print(""input: {:04b} encoded: {:08b} decoded: {:04b} syndrome: {:03b} ""
               ""same: {}\n"",
               inp, encoded, hw_decoded, hw_syndrome, equal ? ""Y"" : ""N"");
    mod.step();
  }
  fmt::print(""Testing single bit-flip codewords…\n"");
  std::vector<unsigned int> flips(7, 0);
  for (unsigned int inp = 0; inp < 16; ++inp) {
    auto encoded = encode(inp);
    for (unsigned int flippos = 0; flippos < 7; ++flippos) {
      auto encoded_flipped = encoded ^ (1 << flippos);
      io_in.set<unsigned int>(encoded_flipped);
      mod.step();
      auto hw_out = io_out.get<unsigned int>();
      auto hw_decoded = hw_out & ((1 << 4) - 1);
      auto hw_syndrome = (hw_out & (((1 << 3) - 1) << 4)) >> 4;
      bool equal = (inp == hw_decoded);
      if (not equal)
        flips[flippos]++;
      dec_success = dec_success && equal;
      if (not equal) {
        fmt::print(""syn: {:03b} cw: {:07b} infow: {:04b}\n""
                   ""    damaged: {:07b} decod: {:04b}\n""
                   "" error patt: {:07b} error: {:04b}\n\n"",
                   hw_syndrome, encoded, inp, encoded_flipped, hw_decoded,
                   encoded_flipped ^ encoded, hw_decoded ^ inp);
      }
      mod.step();
    }
  }
  for (unsigned int i = 0; i < 7; ++i) {
    fmt::print(""errors after flip at pos {:d}: {:d}\n"", i, flips[i]);
  }
  if ( [MASK]  && dec_success)
    return 0;
  return (not  [MASK] ) << 3 | (not  [MASK] ) << 4;
}
",enc_success
684,"//  Copyright 2013 Google Inc. 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <pthread.h>
#include <gsl/gsl_rng.h>
#include ""linelib.h""
#include ""ransampl.h""

#define MAX_PATH_LENGTH 300

char node_file[MAX_STRING], label_file[MAX_STRING], link_file[MAX_STRING], output_file[MAX_STRING];
char data[MAX_STRING];
char file_path[MAX_STRING];
int binary = 0, num_threads = 1, vector_size = 100, negative = 5;
long long samples = 1, edge_count_actual;
real alpha = 0.025, starting_alpha;

const gsl_rng_type * gsl_T;
gsl_rng * gsl_r;

line_node node_w, node_c, node_e;//, node_t;
line_hin hin_ec, hin_ew;//, hin_et;
//line_adjacency adj;
line_trainer_line trainer_ec, trainer_ew;
//line_trainer_l1 trainer_et;

double func_rand_num()
{
    return gsl_rng_uniform(gsl_r);
}

void *training_thread(void *id)
{
    long long edge_count = 0, last_edge_count = 0;
    unsigned long long  [MASK]  = (long long)id;
    real *error_vec = (real *)calloc(vector_size, sizeof(real));
    
    while (1)
    {
        //judge for exit
        if (edge_count > samples / num_threads + 2) break;
        
        if (edge_count - last_edge_count > 1000)
        {
            edge_count_actual += edge_count - last_edge_count;
            last_edge_count = edge_count;
            printf(""%cAlpha: %f Progress: %.3lf%%"", 13, alpha, (real)edge_count_actual / (real)(samples + 1) * 100);
            fflush(stdout);
            alpha = starting_alpha * (1 - edge_count_actual / (real)(samples + 1));
            if (alpha < starting_alpha * 0.0001) alpha = starting_alpha * 0.0001;
        }
        
        trainer_ec.train_sample(alpha, negative, error_vec, func_rand_num,  [MASK] );
        trainer_ew.train_sample(alpha, negative, error_vec, func_rand_num,  [MASK] );
        trainer_ew.train_sample(alpha, negative, error_vec, func_rand_num,  [MASK] );
        trainer_ew.train_sample(alpha, negative, error_vec, func_rand_num,  [MASK] );
        trainer_ew.train_sample(alpha, negative, error_vec, func_rand_num,  [MASK] );
        trainer_ew.train_sample(alpha, negative, error_vec, func_rand_num,  [MASK] );

        edge_count += 6;
    }
    free(error_vec);
    pthread_exit(NULL);
}

void TrainModel() {
    long a;
    pthread_t *pt = (pthread_t *)malloc(num_threads * sizeof(pthread_t));
    starting_alpha = alpha;
    char file_name[MAX_STRING];
    
    gsl_rng_env_setup();
    gsl_T = gsl_rng_rand48;
    gsl_r = gsl_rng_alloc(gsl_T);
    gsl_rng_set(gsl_r, 314159265);
    sprintf(file_name, ""%sw.txt"", file_path);
    printf(""start reading file: %s\n"", file_name);
    node_w.init(file_name, vector_size);
    sprintf(file_name, ""%se.txt"", file_path);
    printf(""start reading file: %s\n"", file_name);
    node_c.init(file_name, vector_size);
    node_e.init(file_name, vector_size);

    
    sprintf(file_name, ""%see.txt"", file_path);
    hin_ec.init(file_name, &node_e, &node_c, 0);
    sprintf(file_name, ""%sew.txt"", file_path);
    hin_ew.init(file_name, &node_e, &node_w, 0);

    trainer_ew.init(&hin_ew, 0);
    trainer_ec.init(&hin_ec, 0);

    clock_t start = clock();
    printf(""Training:"");
    for (a = 0; a < num_threads; a++) pthread_create(&pt[a], NULL, training_thread, (void *)a);
    for (a = 0; a < num_threads; a++) pthread_join(pt[a], NULL);
    printf(""\n"");
    clock_t finish = clock();
    printf(""Total time: %lf\n"", (double)(finish - start) / CLOCKS_PER_SEC);
    
    sprintf(file_name, ""%sfeature_name.emb"", file_path);
    node_w.output(file_name, binary);
    sprintf(file_name, ""%sentity_name.emb"", file_path);
    node_e.output(file_name, binary);
}

int ArgPos(char *str, int argc, char **argv) {
    int a;
    for (a = 1; a < argc; a++) if (!strcmp(str, argv[a])) {
        if (a == argc - 1) {
            printf(""Argument missing for %s\n"", str);
            exit(1);
        }
        return a;
    }
    return -1;
}

int main(int argc, char **argv) {
    int i;
    if (argc == 1) {
        printf(""HIN2VEC\n\n"");
        printf(""Options:\n"");
        printf(""Parameters for training:\n"");
        printf(""\t-node <file>\n"");
        printf(""\t\tA dictionary of all nodes\n"");
        printf(""\t-link <file>\n"");
        printf(""\t\tAll links between nodes. Links are directed.\n"");
        printf(""\t-path <int>\n"");
        printf(""\t\tAll meta-paths. One path per line.\n"");
        printf(""\t-output <int>\n"");
        printf(""\t\tThe output file.\n"");
        printf(""\t-binary <int>\n"");
        printf(""\t\tSave the resulting vectors in binary moded; default is 0 (off)\n"");
        printf(""\t-size <int>\n"");
        printf(""\t\tSet size of word vectors; default is 100\n"");
        printf(""\t-negative <int>\n"");
        printf(""\t\tNumber of negative examples; default is 5, common values are 5 - 10 (0 = not used)\n"");
        printf(""\t-samples <int>\n"");
        printf(""\t\tSet the number of training samples as <int>Million\n"");
        printf(""\t-iters <int>\n"");
        printf(""\t\tSet the number of interations.\n"");
        printf(""\t-threads <int>\n"");
        printf(""\t\tUse <int> threads (default 1)\n"");
        printf(""\t-alpha <float>\n"");
        printf(""\t\tSet the starting learning rate; default is 0.025\n"");
        printf(""\nExamples:\n"");
        printf(""./hin2vec -node node.txt -link link.txt -path path.txt -output vec.emb -binary 1 -size 100 -negative 5 -samples 5 -iters 20 -threads 12\n\n"");
        return 0;
    }
    output_file[0] = 0;
    if ((i = ArgPos((char *)""-output"", argc, argv)) > 0) strcpy(output_file, argv[i + 1]);
    if ((i = ArgPos((char *)""-binary"", argc, argv)) > 0) binary = atoi(argv[i + 1]);
    if ((i = ArgPos((char *)""-size"", argc, argv)) > 0) vector_size = atoi(argv[i + 1]);
    if ((i = ArgPos((char *)""-negative"", argc, argv)) > 0) negative = atoi(argv[i + 1]);
    if ((i = ArgPos((char *)""-samples"", argc, argv)) > 0) samples = (long long)(atof(argv[i + 1])*1000000);
    if ((i = ArgPos((char *)""-alpha"", argc, argv)) > 0) alpha = atof(argv[i + 1]);
    if ((i = ArgPos((char *)""-threads"", argc, argv)) > 0) num_threads = atoi(argv[i + 1]);
    if ((i = ArgPos((char *)""-data"", argc, argv)) > 0) strcpy(data, argv[i + 1]);
    sprintf(file_path, ""../../../data/%s/intermediate/"", data);
    printf(file_path);
    TrainModel();
    return 0;
}
",next_random
685,"#include<bits/stdc++.h>

using namespace std;

 void Swap(int *x,int *y){
        
                  int temp = *y;
                  *y=*x;
                  *x=temp;
             
             
        
    }
  vector<int> sortedSquares(vector<int>& nums) {
        vector<int>  [MASK] ;
         int smallest;
      for(int i=0;i<nums.size()-1;++i){
          smallest=i;
          for(int j=i+1;j<nums.size();++j)
          { if(nums[j]<nums[i]){
              smallest=j;
             Swap(&nums[i],&nums[j]);
              
          }
              }}


          
   for(int i=0;i<nums.size();i++){
        [MASK] .push_back(nums[i]*nums[i]);
   }
   return  [MASK] ;
    }
 

int main() {
    // Write C++ code here
   int n;
   cin>>n;
   int x;
   vector <int> v,kV;
   for(int i=0;i<n;i++){
       cin>>x;
       v.push_back(x);
   }
kV=sortedSquares(v); // function call 
for(int i=0;i<kV.size();i++) 
cout<<kV[i]<<"" ""; 

    return 0;
}
",sqr
686,"/*
 * Copyright (C) 2018 Open Source Robotics Foundation
 *
 * 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 <gflags/gflags.h>

#include <iostream>

#include <gz/fuel_tools.hh>

DEFINE_bool(h, false, ""Show help"");

DEFINE_string(c, """", ""Config file"");
DEFINE_string(n, """", ""Resource name"");
DEFINE_string(o, """", ""Owner name"");
DEFINE_string(s, """", ""Server name"");
DEFINE_string(t, """", ""Resource type (model / world)"");

//////////////////////////////////////////////////
int main(int argc, char **argv)
{
  // Simple usage.
  std::string usage(""Show details of a resource."");
  usage += "" Usage:\n  ./details <options>\n\n"";
  usage += ""  Example:\n""
    ""\t ./details -t model -o OpenRobotics -n Beer""
    ""\t ./details -t world -s https://localhost:4430 -o OpenRobotics -n Empty""
    ""\t ./details -c /tmp/my_config.yaml -o OpenRobotics -n Beer -t model"";

  gflags::SetUsageMessage(usage);

  // Parse command line arguments.
  gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true);

  // Show help, if specified.
  if (FLAGS_h || FLAGS_n == """" || (FLAGS_t != ""model"" && FLAGS_t != ""world""))
  {
    gflags::SetCommandLineOptionWithMode(""help"", ""false"",
        gflags::SET_FLAGS_DEFAULT);
    gflags::SetCommandLineOptionWithMode(""helpshort"", ""true"",
        gflags::SET_FLAGS_DEFAULT);
  }
  gflags::HandleCommandLineHelpFlags();

  // Setup ClientConfig.
  gz::fuel_tools::ClientConfig conf;
  conf.SetUserAgent(""ExampleDetails"");

  if (FLAGS_s != """")
  {
    // The user specified a Fuel server via command line.
    gz::fuel_tools::ServerConfig srv;
    srv.SetUrl(gz::common::URI(FLAGS_s));

    // Add the extra Fuel server.
    conf.AddServer(srv);
  }

  if (FLAGS_c != """")
  {
    if (!conf.LoadConfig(FLAGS_c))
    {
      std::cerr << ""Error loading configuration file ["" << FLAGS_c << ""]""
                << std::endl;
      return -1;
    }
  }

  // Instantiate the FuelClient object with the configuration.
  gz::fuel_tools::FuelClient client(conf);

  // Set the properties of the resource that we want to search.
  gz::fuel_tools::ModelIdentifier  [MASK] ;
  gz::fuel_tools::WorldIdentifier worldIdentifier;

  if (FLAGS_t == ""model"")
  {
     [MASK] .SetOwner(FLAGS_o);
     [MASK] .SetName(FLAGS_n);
  }
  else if (FLAGS_t == ""world"")
  {
    worldIdentifier.SetOwner(FLAGS_o);
    worldIdentifier.SetName(FLAGS_n);
  }

  // Fetch the details.
  for (const auto &server : client.Config().Servers())
  {
    if (FLAGS_t == ""model"")
    {
      // Set server
      auto id =  [MASK] ;
      id.SetServer(server);

      gz::fuel_tools::ModelIdentifier model;
      if (!client.ModelDetails(id, model))
        continue;

      std::cout << model.AsPrettyString() << std::endl;
    }
    else if (FLAGS_t == ""world"")
    {
      // Set server
      auto id = worldIdentifier;
      id.SetServer(server);

      gz::fuel_tools::WorldIdentifier world;
      if (!client.WorldDetails(id, world))
        continue;

      std::cout << world.AsPrettyString() << std::endl;
    }
  }

  return 0;
}
",modelIdentifier
687,"#ifndef T_GRAPH_HPP
#define T_GRAPH_HPP

#include <algorithm> // std::unique,sort,reverse
#include ""Edge.hpp""

namespace TemplateGraph
{
 	template <class T> class Edge; // Forward declare Edge
	template <class T> class Node;
	template <class T>
	class Graph
	{
	public:
		//////////////////////////////////////////////////////////
		//                       CONSTRUCTOR                    //
		//////////////////////////////////////////////////////////
		Graph() {};
        Graph(Node<T>* rootNode) : root_ (rootNode) {};
		//////////////////////////////////////////////////////////
		//                       ACCESSOR                       //
		//////////////////////////////////////////////////////////
        std::vector<Node<T>*> GetNodes();
        unsigned int GetSize();
        std::string Print();
		//////////////////////////////////////////////////////////
        //                       MUTATOR                        //
        //////////////////////////////////////////////////////////
        inline void SetRoot(Node<T>* node) {root_ = node;}
        void ResetAllEdgesAndNodesToUnvisited(std::string visitorName = """");
        //////////////////////////////////////////////////////////
        //                       FUNCTIONS                      //
        //////////////////////////////////////////////////////////
        // Go look in selection.cc in gmml for the types of functionality you need.
        // class DeadEndSeeker
        // {
        // public:
        //     DeadEndSeeker(AtomNode startNode, int startDepth, AtomNodeVector avoidList) : current_depth_ (startDepth), max_depth_ (startDepth), {path_.push_back(startNode); SetAvoidList(avoidList);} 
        //     inline AtomNodeVector Seek() {;}
        //     // inline void RemoveBond(Atom *otherAtom) {atomNodePtr_->RemoveEdge(otherAtom->GetNode());}
        // private:
        //     inline void SetAvoidList(AtomNodeVector avoidList) {for (auto &node : avoidList) node->SetIsVisited(true);} 
        //     int max_depth_;
        //     int current_depth_;
        //     AtomNodeVector path_;
        // };
	private:
        //////////////////////////////////////////////////////////
        //                       ACCESSOR                       //
        //////////////////////////////////////////////////////////
        void RecurveFindNodes(std::vector<Node<T>*> &foundNodes, Node<T>* currentNode);
        std::vector<Edge<T>*> GetEdges();
        inline Node<T>* GetRoot() {return root_;} 
		//////////////////////////////////////////////////////////
        //                       ATTRIBUTES                     //
        //////////////////////////////////////////////////////////
        Node<T>* root_;
	};
		//////////////////////////////////////////////////////////
        //                       DEFINITIONS                    //
        //////////////////////////////////////////////////////////

template <typename T> 
    std::string Graph<T>::Print()
    {
        std::string  [MASK] ;
        for (auto &edge : this->GetEdges())
        {
             [MASK]  += edge->Print();
             [MASK]  += ""\n"";
        }
        return  [MASK] ;
    }

template <typename T>
    std::vector<Edge<T>*> Graph<T>::GetEdges() 
    { 
        std::vector<Edge<T>*> edgesInGraph;
        for (auto &node : this->GetNodes())
        {
            //std::cout << ""Outedges of "" << node->GetLabel() << "":\n"";
            for (auto &outEdge : node->GetOutEdges())
            {
                //outEdge->SetIsVisited(false);
                edgesInGraph.push_back(outEdge);
                //std::cout << "" "" << outEdge->GetLabel() << "" set to unvisited.\n"";
            }
        }
        return edgesInGraph;
    } 

template <typename T>
    std::vector<Node<T>*> Graph<T>::GetNodes() 
    { 
        std::vector<Node<T>*> nodesInGraph;
        this->RecurveFindNodes(nodesInGraph, this->GetRoot());
        for(auto &node : nodesInGraph)
        {
            node->RemoveVisitor(""GraphRecurveFindNodes"");
        }
        return nodesInGraph;
    }

template <typename T>
    void Graph<T>::RecurveFindNodes(std::vector<Node<T>*> &foundNodes, Node<T>* currentNode)
    {
        currentNode->AddVisitor(""GraphRecurveFindNodes"");
        foundNodes.push_back(currentNode);
        for (auto &neighbor : currentNode->GetNeighbors())
        {
            if (!neighbor->GetIsVisitedBy(""GraphRecurveFindNodes""))
            {
                this->RecurveFindNodes(foundNodes, neighbor);
            }
        }
    }

template <typename T> 
    void Graph<T>::ResetAllEdgesAndNodesToUnvisited(std::string visitorName)
    {
        for(auto &edge : this->GetEdges())
        {
           edge->RemoveVisitor(visitorName);
        }
    }

template <typename T> 
    unsigned int Graph<T>::GetSize()
    {
        return this->GetNodes().size() + this->GetEdges().size();
    }

}
#endif // T_GRAPH_HPP",output
688,"#include <cxxopts.hpp>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <shaderc/shaderc.hpp>

using namespace shaderc;
namespace fs = std::filesystem;

class shader_includer : public CompileOptions::IncluderInterface
{
public:
	shader_includer(fs::path _base_path)
		: base_path_(_base_path)
	{}

	virtual shaderc_include_result* GetInclude(
		const char* _requested_source,
		shaderc_include_type _type,
		const char* _requesting_source,
		size_t _include_depth) override
	{
		shaderc_include_result* include = new shaderc_include_result;

		auto include_file = base_path_ / fs::path{ _requested_source };

		{
			const std::string* source_name =
				scoped_strings_.emplace_back(new std::string(""toto.vs""));

			include->source_name = source_name->data();
			include->source_name_length = source_name->size();
		}

		if(!fs::exists(include_file))
		{
			std::cout << ""can't find "" << include_file << std::endl;
			return include;
		}

		std::ifstream stream(include_file.c_str());
		if(!stream.is_open())
		{
			std::cout << ""failed to open "" << include_file << std::endl;
			return include;
		}
		else
		{
			const std::string* code = scoped_strings_.emplace_back(new std::string(
				std::istreambuf_iterator<char>(stream),
				std::istreambuf_iterator<char>{}));
			include->content = code->data();
			include->content_length = code->size();
		}

		return include;
	}

	virtual void ReleaseInclude(shaderc_include_result* include_result) override
	{
		delete include_result;
		for(auto str : scoped_strings_)
			delete str;
	}

private:
	fs::path base_path_;
	std::vector<std::string*> scoped_strings_;
};

int run_preprocessor(fs::path _input_path, fs::path _output_path)
{
	CompileOptions options;
	Compiler compiler;

	options.SetIncluder(std::make_unique<shader_includer>(_input_path.parent_path()));

	std::ifstream stream(_input_path.c_str());
	if(!stream.is_open())
	{
		std::cout << ""failed to open input file "" << _input_path << std::endl;
		return 1;
	}
	const std::string shader_code(std::istreambuf_iterator<char>(stream), {});

	const auto filepath = _input_path.string();
	PreprocessedSourceCompilationResult result = compiler.PreprocessGlsl(
		shader_code,
		shaderc_glsl_default_vertex_shader,
		filepath.c_str(),
		options);

	if(result.GetCompilationStatus() == shaderc_compilation_status_success)
	{
		std::ofstream stream(_output_path);
		if(!stream.is_open())
		{
			std::cout << ""failed to open output file "" << _output_path << std::endl;
			return 1;
		}

		std::copy(result.begin(), result.end(), std::ostream_iterator<char>(stream));

		std::string output(result.begin(), result.end());

		std::cout << output << std::endl;
		return 0;
	}
	else
	{
		std::cout << result.GetErrorMessage() << std::endl;
		return 1;
	}
}

int main(int argc, char** argv)
{
	std::string input_file;

	cxxopts::ParseResult  [MASK] ;

	try
	{
		cxxopts::Options options_parser(
			""glsl-preprocessor-validator"",
			""Tool to preprocess and validate OpenGL shader files"");

		// clang-format off

		options_parser      
			.positional_help(""input shader file"")
			.show_positional_help()
			.add_options()
			(""help"", ""Print help"")
			(""p"", ""Preprocess the shaders and output a file to the [output] path"")
			(""o,output"", ""Output file, only for preprocessor"", cxxopts::value<std::string>()->default_value(""""))
			(""i,input"", ""Input file"", cxxopts::value<std::string>(input_file))
			;

		// clang-format on

		options_parser.parse_positional({ ""input"" });

		 [MASK]  = options_parser.parse(argc, argv);

		if( [MASK] .count(""help""))
		{
			std::cout << options_parser.help({ """" }) << std::endl;
			return 0;
		}
	}
	catch(const std::exception& e)
	{
		std::cout << ""error parsing options: "" << e.what() << std::endl;
		return 1;
	}

	if(input_file.empty())
	{
		std::cout << ""no input file"" << std::endl;
		return 1;
	}

	fs::path filepath(input_file);

	if(!fs::exists(filepath))
	{
		std::cout << ""can't find "" << filepath << std::endl;
		return 1;
	}
	else if(!fs::is_regular_file(filepath))
	{
		std::cout << ""not a file "" << filepath << std::endl;
		return 1;
	}

	if( [MASK] .count(""p""))
	{
		fs::path output =  [MASK] [""output""].as<std::string>();
		if(fs::is_directory(output) || output.empty())
		{
			auto output_file_name = filepath.stem().string() + ""_preprocess"";
			if(filepath.has_extension())
				output_file_name += filepath.extension().string();

			output /= output_file_name;
		}

		return run_preprocessor(filepath, output);
	}

	return 0;
}",parse_result
689,"#include ""ExampleLayer.h""
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <imgui/imgui.h>

ExampleLayer::ExampleLayer()
	:Layer(""Example""), m_CameraController(1280.0f / 720.f)
{
	m_VertexArray = Shaddock::VertexArray::Create();

	float vertices[3 * 7] = {
		-0.5f, -0.5f, 0.0f, 0.8f, 0.2f, 0.8f, 1.0f,
		 0.5f, -0.5f, 0.0f, 0.2f, 0.3f, 0.8f, 1.0f,
		 0.0f,  0.5f, 0.0f, 0.8f, 0.8f, 0.2f, 1.0f
	};

	Shaddock::Ref<Shaddock::VertexBuffer> vertexBuffer = Shaddock::VertexBuffer::Create(vertices, sizeof(vertices));
	Shaddock::BufferLayout layout = {
		{Shaddock::ShaderDataType::Float3, ""a_Position""},
		{Shaddock::ShaderDataType::Float4, ""a_Color""}
	};
	vertexBuffer->SetLayout(layout);

	m_VertexArray->AddVertexBuffer(vertexBuffer);

	unsigned int indices[3] = { 0, 1, 2 };

	Shaddock::Ref<Shaddock::IndexBuffer> indexBuffer = Shaddock::IndexBuffer::Create(indices, sizeof(indices) / sizeof(uint32_t));

	m_VertexArray->SetIndexBuffer(indexBuffer);

	std::string vertexSrc = R""(
			#version 330 core
			
			layout(location = 0) in vec3 a_Position;
			layout(location = 1) in vec4 a_Color;

			uniform mat4 u_ViewProjectionMatrix;
			uniform mat4 u_Transform;

			out vec3 v_Position;
			out vec4 v_Color;

			void main()
			{
				v_Position = a_Position;
				v_Color = a_Color;
				gl_Position = u_ViewProjectionMatrix * u_Transform * vec4(a_Position, 1.0);	
			}
		)"";

	std::string fragmentSrc = R""(
			#version 330 core
			
			layout(location = 0) out vec4 color;
			in vec3 v_Position;
			in vec4 v_Color;

			void main()
			{
				color = vec4(v_Position * 0.5 + 0.5, 1.0);
				color = v_Color;
			}
		)"";

	m_Shader = Shaddock::Shader::Create(""VertexColorShader"", vertexSrc, fragmentSrc);

	// flat color shader
	m_SquareVA = Shaddock::VertexArray::Create();

	float square_vertices[5 * 4] = {
		-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
		 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
		 -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
		 0.5f,  0.5f, 0.0f, 1.0f, 1.0f
	};

	Shaddock::Ref<Shaddock::VertexBuffer> squareVertexBuffer = Shaddock::VertexBuffer::Create(square_vertices, sizeof(square_vertices));
	Shaddock::BufferLayout  [MASK]  = {
		{Shaddock::ShaderDataType::Float3, ""a_Position""},
		{Shaddock::ShaderDataType::Float2, ""a_TexCoord""},
	};
	squareVertexBuffer->SetLayout( [MASK] );

	m_SquareVA->AddVertexBuffer(squareVertexBuffer);

	unsigned int square_indices[6] = { 0, 1, 2 , 3, 2, 1 };

	Shaddock::Ref<Shaddock::IndexBuffer> squareIndexBuffer = Shaddock::IndexBuffer::Create(square_indices, sizeof(square_indices) / sizeof(uint32_t));

	m_SquareVA->SetIndexBuffer(squareIndexBuffer);

	std::string flatColorVertexSrc = R""(
			#version 330 core
			
			layout(location = 0) in vec3 a_Position;

			uniform mat4 u_ViewProjectionMatrix;
			uniform mat4 u_Transform;

			void main()
			{
				gl_Position = u_ViewProjectionMatrix * u_Transform * vec4(a_Position, 1.0);	
			}
		)"";

	std::string flatColorFragmentSrc = R""(
			#version 330 core
			
			layout(location = 0) out vec4 color;

			uniform vec3 u_Color;

			void main()
			{
				color = vec4(u_Color, 1.0);
			}
		)"";

	m_FlatColorShader = Shaddock::Shader::Create(""FlatColorShader"", flatColorVertexSrc, flatColorFragmentSrc);


	m_Texture = Shaddock::Texture2D::Create(""assets/textures/letter_p.png"");
	m_Texture->Bind();
	auto textureShader = m_ShaderLibrary.Load(""assets/shaders/Texture.glsl"");
	textureShader->SetInt(""u_Texture"", 0);
}

void ExampleLayer::OnUpdate(Shaddock::Timestep ts)
{
	m_CameraController.OnUpdate(ts);

	Shaddock::RenderCommand::SetClearColor({ 0.1f, 0.1f, 0.1f, 1.0f });
	Shaddock::RenderCommand::Clear();

	Shaddock::Renderer::BeginScene(m_CameraController.GetCamera());

	glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f));

	m_FlatColorShader->Bind();
	m_FlatColorShader->SetFloat3(""u_Color"", m_SquareColor);


	for (int y = 0; y < 20; y++)
	{
		for (int x = 0; x < 20; x++)
		{
			glm::vec3 position(x * 0.11f, y * 0.11f, 0.0f);
			glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) * scale;
			Shaddock::Renderer::Submit(m_FlatColorShader, m_SquareVA, transform);
		}
	}
	m_Texture->Bind();
	auto textureShader = m_ShaderLibrary.Get(""Texture"");
	Shaddock::Renderer::Submit(textureShader, m_SquareVA);
	//Shaddock::Renderer::Submit(m_Shader, m_VertexArray);

	Shaddock::Renderer::EndScene();
}

void ExampleLayer::OnEvent(Shaddock::Event& event)
{
	m_CameraController.OnEvent(event);
}

void ExampleLayer::OnImGuiRender()
{
	ImGui::Begin(""Setting"");
	ImGui::ColorEdit3(""Color"", glm::value_ptr(m_SquareColor));
	ImGui::End();
}
",square_layout
690,"
/** ****************************************************************************************
* \mainpage areaTrapezio
*
* @brief  Scrivi un programma che calcola l’area e il perimetro di un trapezio dopo aver letto i dati necessari
* Il progetto accetta solo numeri positivi e interi
* 
* @author <NAME> Matias
* @date 07/10/2022
*/

#include <stdio.h>
#include <math.h>

int main() {
  int baseM, basem, altezza, lato1,  [MASK] ;  //input

  float area, perimetro;  //output
  
  //lettura variabili
  printf(""Inserisci il valore della base maggiore: ""); 
  scanf(""%d"", &baseM);
  
  printf(""Inserisci il valore della base minore: "");
  scanf(""%d"", &basem);


  printf(""Inserisci il valore dell'altezza: "");
  scanf(""%d"", &altezza);

  printf(""Inserisci il valore del primo lato: "");
  scanf(""%d"", &lato1);
  
  printf(""Inserisci il valore del secondo lato: "");
  scanf(""%d"", & [MASK] );
  
  
  area=(baseM+basem)*altezza/2.0; //calcolo area
  
  perimetro=baseM+basem+lato1+ [MASK] ; //calcolo perimetro
  
   //scrittura risultato
  printf(""Area = %.2f"", area);  
  printf(""\nPerimetro = %.2f"", perimetro);
 }

",lato2
691,"// Author  :  <NAME> (siddhesh1770)
// Problem Name  :  7. Reverse Integer (Leetcode)
// Email  :  <EMAIL>
// Websit  :  https://www.siddheshpatil.in
// GitHub  :  https://www.github.com/siddhesh1770
// LinkedIn  :  https://www.linkedin.com/in/siddhesh1770

class Solution
{
public:
    int reverse(int x)
    {
        long int  [MASK]  = 0;
        //2147483647
        if (x >= 2147483647 || x <= -2147483648)
            return 0;
        if (x > 0)
        {
            while (x > 0)
            {
                 [MASK]  =  [MASK]  * 10;
                if ( [MASK]  >= 2147483647 ||  [MASK]  <= -2147483648)
                    return 0;
                 [MASK]  =  [MASK]  + (x % 10);
                x = x / 10;
            }
        }
        else
        {
            x = -1 * x;
            while (x > 0)
            {
                 [MASK]  =  [MASK]  * 10;
                if ( [MASK]  >= 2147483647 ||  [MASK]  <= -2147483648)
                    return 0;
                 [MASK]  =  [MASK]  + (x % 10);
                x = x / 10;
            }
             [MASK]  = -1 *  [MASK] ;
        }
        return int( [MASK] );
    }
};",num
692,"#include <functional>

#include <gtest/gtest.h>

#include <dma/base/initializable/CBaseSynchronousInitializable.hpp>

static const int INIT_RETURN_CODE = 1;
static const int SHUTDOWN_RETURN_CODE = 2;

class CClassUnderTest : public DMA::CBaseSynchronousInitializable
{
protected:
    virtual DMA::tSyncInitOperationResult init() override
    {
        DMA::tSyncInitOperationResult result;
        result.returnCode = INIT_RETURN_CODE;
        result.bIsOperationSuccessful = true;
        return result;
    }

    virtual DMA::tSyncInitOperationResult shutdown() override
    {
        DMA::tSyncInitOperationResult result;
        result.returnCode = SHUTDOWN_RETURN_CODE;
        result.bIsOperationSuccessful = true;
        return result;
    }
};

class Test_CClassUnderTest : public ::testing::Test
{
protected:
    void SetUp()
    {}
    void TearDown()
    {}
};

TEST_F(Test_CClassUnderTest, test_init)
{
    CClassUnderTest classUnderTest;

    auto initResult = classUnderTest.startInit();

    ASSERT_EQ(initResult.bIsOperationSuccessful, true);
    ASSERT_EQ(initResult.returnCode, INIT_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), true);
}

TEST_F(Test_CClassUnderTest, test_repetitive_init)
{
    CClassUnderTest classUnderTest;

    auto initResult = classUnderTest.startInit();

    ASSERT_EQ(initResult.bIsOperationSuccessful, true);
    ASSERT_EQ(initResult.returnCode, INIT_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), true);

    auto  [MASK]  = classUnderTest.startInit();

    ASSERT_EQ( [MASK] .bIsOperationSuccessful, true);
    ASSERT_EQ( [MASK] .returnCode, INIT_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), true);
}

TEST_F(Test_CClassUnderTest, test_shutdown)
{
    CClassUnderTest classUnderTest;

    auto initResult = classUnderTest.startInit();

    ASSERT_EQ(initResult.bIsOperationSuccessful, true);
    ASSERT_EQ(initResult.returnCode, INIT_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), true);

    auto shutdownResult = classUnderTest.startShutdown();

    ASSERT_EQ(shutdownResult.bIsOperationSuccessful, true);
    ASSERT_EQ(shutdownResult.returnCode, SHUTDOWN_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), false);
}

TEST_F(Test_CClassUnderTest, test_repetitive_shutdown)
{
    CClassUnderTest classUnderTest;

    auto initResult = classUnderTest.startInit();

    ASSERT_EQ(initResult.bIsOperationSuccessful, true);
    ASSERT_EQ(initResult.returnCode, INIT_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), true);

    auto shutdownResult = classUnderTest.startShutdown();

    ASSERT_EQ(shutdownResult.bIsOperationSuccessful, true);
    ASSERT_EQ(shutdownResult.returnCode, SHUTDOWN_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), false);

    auto repetitiveShutdownResult = classUnderTest.startShutdown();

    ASSERT_EQ(repetitiveShutdownResult.bIsOperationSuccessful, true);
    ASSERT_EQ(repetitiveShutdownResult.returnCode, SHUTDOWN_RETURN_CODE);

    ASSERT_EQ(classUnderTest.isInitialized(), false);
}

int main(int argc, char *argv[])
{
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}
",repetitiveInitResult
693,"#include <fmt/format.h>

#include <memory_resource>
#include <vector>

template <typename ItrBegin, typename ItrEnd>
void print_line(int offset, ItrBegin begin, const ItrEnd  [MASK] ) {
  fmt::print(""(dec) {:02x}:  {:3}\n"", offset, fmt::join(begin,  [MASK] , ""  ""));
  fmt::print(""(hex) {:02x}:   {:02x}\n"", offset, fmt::join(begin,  [MASK] , ""   ""));

  fmt::print(""(asc) {:02x}:"", offset);
  std::for_each(begin,  [MASK] , [](const auto c) {
    if (std::isgraph(c)) {
      fmt::print(""   {} "", static_cast<char>(c));
    } else {
      fmt::print("" \\{:03o}"", c);
    }
  });

  fmt::print(""\n"");
}

template <typename Buffer, typename Container>
void print_buffer(const std::string_view title, const Buffer &buffer,
                  const Container &container) {
  fmt::print(""==============={:^10}==============\n"", title);

  auto begin = buffer.begin();
  fmt::print(""Buffer Address Start: {}\n"",
             static_cast<const void *>(buffer.data()));
  for (const auto &elem : container) {
    fmt::print("" Item Address: {}\n"", static_cast<const void *>(&elem));
  }
  for (std::size_t offset = 0; offset < buffer.size(); offset += 16) {
    print_line(offset, std::next(begin, offset), std::next(begin, offset + 16));
  }

  fmt::print(""\n"");
}


void freed_resources() {
  std::array<std::uint8_t, 16> buffer{};
  std::pmr::monotonic_buffer_resource mem_resource(buffer.data(),
                                                   buffer.size());
  print_buffer(""initial"", buffer, """");
  std::pmr::vector<std::uint8_t> vec1({1, 2, 3, 4}, &mem_resource);
  print_buffer(""vec1"", buffer, vec1);

  {
    std::pmr::vector<std::uint8_t> vec2({6, 7, 8}, &mem_resource);
    print_buffer(""vec1 + vec2"", buffer, vec2);
  }  // memory not reclaimed from the buffer

  std::pmr::vector<std::uint8_t> vec3({14, 15, 16}, &mem_resource);
  print_buffer(""vec1 + vec3"", buffer, vec3);
}

// What happens if the vector data in the monotonic_buffer_resource
// grows and reallocats?
void growing_resources() {
  std::array<std::uint8_t, 16> buffer{};
  std::pmr::monotonic_buffer_resource mem_resource(buffer.data(),
                                                   buffer.size());
  std::pmr::vector<std::uint8_t> vec1(&mem_resource);
  vec1.push_back(1);
  print_buffer(""1"", buffer, vec1);
  vec1.push_back(2);
  print_buffer(""2"", buffer, vec1);
  vec1.push_back(3);
  print_buffer(""3"", buffer, vec1);
  vec1.push_back(4);
  print_buffer(""4"", buffer, vec1);
  vec1.push_back(5);
  print_buffer(""5"", buffer, vec1);
}

// short strings, non PMR
void nested_string() {
  fmt::print(""Size of `std::pmr::string`: {}\n"", sizeof(std::pmr::string));

  std::array<std::uint8_t, 256> buffer{};
  std::pmr::monotonic_buffer_resource mem_resource(buffer.data(),
                                                   buffer.size());
  print_buffer(""initial"", buffer, """");
  std::pmr::vector<std::pmr::string> vec1(
      {""Hello World"", ""Hello World 2"", ""Hello world long string""},
      &mem_resource);
  print_buffer(""2 short strings + 1 long string"", buffer, vec1);
}

// does not use PMR string
void nested_long_string() {
  std::array<std::uint8_t, 148> buffer{};
  std::pmr::monotonic_buffer_resource mem_resource(buffer.data(),
                                                   buffer.size());
  print_buffer(""initial"", buffer, """");
  std::pmr::vector<std::string> vec1(&mem_resource);
  vec1.emplace_back(""Hello World"");
  print_buffer(""short string"", buffer, vec1);
  vec1.emplace_back(""Hello long string here"");
  print_buffer(""long string"", buffer, vec1);
  fmt::print(""Notice the moved string\n"");
  fmt::print(""      vector address: {}\n"", static_cast<const void *>(&vec1));
  fmt::print(""short string address: {}\n"",
             static_cast<const void *>(vec1[0].c_str()));
  fmt::print("" long string address: {}\n"",
             static_cast<const void *>(vec1[1].c_str()));
}

// does use PMR string
void nested_long_pmr_string() {
  std::array<std::uint8_t, 160> buffer{};
  std::pmr::monotonic_buffer_resource mem_resource(buffer.data(),
                                                   buffer.size());
  print_buffer(""initial"", buffer, """");
  std::pmr::vector<std::pmr::string> vec1(&mem_resource);
  vec1.emplace_back(""Hello World"");
  print_buffer(""short string"", buffer, vec1);
  vec1.emplace_back(""Hello long string here"");
  print_buffer(""long string"", buffer, vec1);
  fmt::print(""Notice the moved string\n"");
  fmt::print(""      vector address: {}\n"", static_cast<const void *>(&vec1));
  fmt::print(""short string address: {}\n"",
             static_cast<const void *>(vec1[0].c_str()));
  fmt::print("" long string address: {}\n"",
             static_cast<const void *>(vec1[1].c_str()));
}

int main() {
  nested_string();

  // * know how and if your memory is growing
  // * choose the correct allocator for your use case
  // * make sure you properly nest your allocator aware types
  // * Understand which std types are allocator aware
}
",end
694,"#ifndef AZUIK_CONTAINER_HEAP_HPP
#define AZUIK_CONTAINER_HEAP_HPP
#include <cstddef>
namespace azuik
{
    namespace core
    {
        template <class T>
        class leftist_heap {
        public:
            using self_type = leftist_heap;
            using value_type = T;
            using reference = T&;

        public:
            leftist_heap()
                : m_root{nullptr}
            {}
            leftist_heap(self_type const& that);
            leftist_heap(self_type&& that) noexcept;
            ~leftist_heap();
            leftist_heap& operator=(self_type const& that);
            leftist_heap& operator=(self_type&& that) noexcept;
            auto constexpr empty() const noexcept
            {
                return m_root == nullptr;
            }
            auto constexpr top() const noexcept;
            template <class... Args>
            auto constexpr push(Args&&... args)
            {
                m_root = merge(new node{static_cast<Args&&>(args)..., nullptr, nullptr}, m_root);
            }
            auto constexpr pop()
            {
                assert(!empty() && ""empty heap"");
                node_ptr  [MASK]  = m_root;
                m_root = merge(m_root->left, m_root->right);
                delete  [MASK] ;
            }
            auto constexpr clear();
            void merge(self_type& that)
            {
                if (this == &that)
                {
                    return;
                }
                m_root = merge(m_root, that.m_root);
                that.m_root = nullptr;
            }

        private:
            struct node;
            using node_ptr = node*;
            struct node {
                value_type value;
                node_ptr* left;
                node_ptr* right;
                int npl;
                template <class... Args>
                node(Args&&... args, node_ptr left, node_ptr right, int npl = 0)
                    : value{static_cast<Args&&>(args)...}
                    , left{left}
                    , right{right}
                    , npl{npl}
                {}
            };
            node_ptr m_root;
        };
        template <class T>
        class binomial_heap {
        public:
            using value_type = T;
            using size_type = std::size_t;
            using differene_type = std::ptrdiff_t;

        private:
            struct node;
            using node_ptr = node*;
            struct node {
                value_type value;
                node_ptr next;
                node_ptr child;
            };

        public:
            auto constexpr empty() const noexcept;

            template <class... Args>
            void push(Args&&... args);
            void pop();
            void clear();
        };

    } // namespace core
} // namespace azuik
#endif
",oldRoot
695,"#include ""Audio.h""
#include ""Log.h""

#include ""SDL2/SDL.h""
#include ""SDL2/SDL_mixer.h""

Audio::Audio() : Module()
{
	music = NULL;
	name = ""audio"";
	globalMusicVolume = 20;
	globalFxVolume = 20;
}

// Destructor
Audio::~Audio()
{}

// Called before render is available
bool Audio::Awake()
{
	LOG(""Loading Audio Mixer"");
	bool ret = true;
	SDL_Init(0);

	if(SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
	{
		LOG(""SDL_INIT_AUDIO could not initialize! SDL_Error: %s\n"", SDL_GetError());
		active = false;
		ret = true;
	}

	// Load support for the JPG and PNG image formats
	int flags = MIX_INIT_OGG;
	int init = Mix_Init(flags);

	if((init & flags) != flags)
	{
		LOG(""Could not initialize Mixer lib. Mix_Init: %s"", Mix_GetError());
		active = false;
		ret = true;
	}

	// Initialize SDL_mixer
	if(Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
	{
		LOG(""SDL_mixer could not initialize! SDL_mixer Error: %s\n"", Mix_GetError());
		active = false;
		ret = true;
	}

	return ret;
}

// Called before quitting
bool Audio::CleanUp()
{
	if(!active)
		return true;

	LOG(""Freeing sound FX, closing Mixer and Audio subsystem"");

	if(music != NULL)
	{
		Mix_FreeMusic(music);
	}

	for (const auto& fxItem : fx) {
		Mix_FreeChunk(fxItem);
	}
	fx.clear();

	Mix_CloseAudio();
	Mix_Quit();
	SDL_QuitSubSystem(SDL_INIT_AUDIO);

	return true;
}

// Play a music file
bool Audio::PlayMusic(const char* path, float fadeTime)
{
	bool ret = true;

	if(!active)
		return false;

	if(music != NULL)
	{
		if(fadeTime > 0.0f)
		{
			Mix_FadeOutMusic(int(fadeTime * 1000.0f));
		}
		else
		{
			Mix_HaltMusic();
		}

		// this call blocks until fade out is done
		Mix_FreeMusic(music);
	}

	music = Mix_LoadMUS(path);

	if(music == NULL)
	{
		LOG(""Cannot load music %s. Mix_GetError(): %s\n"", path, Mix_GetError());
		ret = false;
	}
	else
	{
		if(fadeTime > 0.0f)
		{
			if(Mix_FadeInMusic(music, -1, (int) (fadeTime * 1000.0f)) < 0)
			{
				LOG(""Cannot fade in music %s. Mix_GetError(): %s"", path, Mix_GetError());
				ret = false;
			}
		}
		else
		{
			Mix_VolumeMusic(globalMusicVolume);

			if(Mix_PlayMusic(music, -1) < 0)
			{
				LOG(""Cannot play in music %s. Mix_GetError(): %s"", path, Mix_GetError());
				ret = false;
			}
		}
	}

	LOG(""Successfully playing %s"", path);
	return ret;
}

// Load WAV
int Audio::LoadFx(const char* path)
{
	int ret = 0;

	if(!active)
		return 0;

	Mix_Chunk* chunk = Mix_LoadWAV(path);

	if(chunk == NULL)
	{
		LOG(""Cannot load wav %s. Mix_GetError(): %s"", path, Mix_GetError());
	}
	else
	{
		fx.push_back(chunk);
		ret = (int)fx.size();
	}

	return ret;
}

// Play WAV
bool Audio::PlayFx(int id, int  [MASK] )
{
	bool ret = false;

	if(!active)
		return false;

	if(id > 0 && id <= fx.size())
	{
		auto fxIt = fx.begin();
		std::advance(fxIt, id-1);

		Mix_VolumeChunk(*fxIt, globalFxVolume);  // Aplicar el volumen global

		Mix_PlayChannel(-1, *fxIt,  [MASK] );

	}

	return ret;
}

void Audio::SetMusicVolume(int volume)
{
	// Asegurarte de que el volumen esté en el rango permitido (0 a 128)
	//globalMusicVolume = (volume < 0) ? 0 : (volume > MIX_MAX_VOLUME) ? MIX_MAX_VOLUME : volume;
	globalMusicVolume = volume;
	// Aplicar el volumen al canal de música actual
	Mix_VolumeMusic(globalMusicVolume);

	//LOG(""Global music volume set to: %d"", globalMusicVolume);
}

void Audio::SetFxVolume(int volume)
{
	// Asegurarte de que el volumen esté en el rango permitido (0 a 128)
	//globalFxVolume = (volume < 0) ? 0 : (volume > MIX_MAX_VOLUME) ? MIX_MAX_VOLUME : volume;
	globalFxVolume = volume;
	// Aplicar el volumen global a todos los efectos de sonido cargados
	for (auto fxChunk : fx)
	{
		Mix_VolumeChunk(fxChunk, globalFxVolume);
	}

	//LOG(""Global FX volume set to: %d"", globalFxVolume);
}",repeat
696,"#include ""call_thunk.h""

#ifdef _WIN32

#include <windows.h>

#else
#include <sys/mman.h>

#ifndef offsetof
#define offsetof(s,m) ((size_t)&reinterpret_cast<char const volatile&>((((s*)0)->m)))
#endif //offsetof

#ifndef _countof
#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#endif //_countof

#endif //_WIN32

#include <string.h>
#include <assert.h>
#include <memory>

namespace call_thunk {

#pragma pack(push, 1)

#if defined(_M_IX86) || defined(__i386__)
#include ""thunk_code_x86.cpp""
#elif defined(_M_X64) || defined(__x86_64__)
#include ""thunk_code_x64.cpp""
#endif 

void base_thunk::init_code(call_declare  [MASK] , call_declare callee, size_t argc, const argument_info* arginfos) throw(bad_call)
{
	_thunk_size = thunk_code::calc_size( [MASK] , callee, argc, arginfos);

#if defined(_WIN32)
	_code = (char*)VirtualAlloc(NULL, _thunk_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
#else
	_code = (char*)mmap(NULL, _thunk_size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
#endif //_WIN32
	_thunk = reinterpret_cast<thunk_code*>(_code);
	_code += sizeof(thunk_code);
	new(_thunk) thunk_code( [MASK] , callee, argc, arginfos);
}

void base_thunk::destroy_code()
{
	if (_thunk) 
	{
#if defined(_WIN32)
		VirtualFree(_thunk, 0, MEM_RELEASE);
#else
		munmap(_thunk, _thunk_size);
#endif //_WIN32
		_thunk = NULL;
		_code = NULL;
		_thunk_size = 0;
	}
}

void base_thunk::flush_cache()
{
#ifdef _WIN32
	FlushInstructionCache(GetCurrentProcess(), _thunk, _thunk_size);
#else
#endif //_WIN32
}

void base_thunk::bind_impl(void* object, void* proc)
{
	_thunk->bind(object, proc);
}

}
",caller
697,"/*
 * Copyright (C) 2018-2020 HERE Europe B.V.
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */

//
// Created by <NAME> on 2019-02-19.
//

#include ""movetk/metric/DistanceInterface.h""
#include ""movetk/utils/GeometryBackendTraits.h""

int main(int argc, char **argv) {
#if CGAL_BACKEND_ENABLED
	std::cerr << ""Using CGAL Backend for Geometry\n"";
#else
	std::cerr << ""Using Boost Backend for Geometry\n"";
#endif

	movetk::geom::MakePoint<GeometryKernel::MovetkGeometryKernel> make_point;
	auto  [MASK]  = make_point({3, 3});

	auto pt2 = make_point({3, 1});
	auto pt3 = make_point({5, 3});
	movetk::geom::MakeSegment<GeometryKernel::MovetkGeometryKernel> make_segment;
	auto seg = make_segment(pt2, pt3);

	movetk::metric::ComputeSquaredDistance<GeometryKernel::MovetkGeometryKernel, GeometryKernel::Norm> squared_dist;
	std::cout << ""Squared Distance from Point to Segment: "" << squared_dist( [MASK] , seg) << std::endl;
	return 0;
}
",pt1
698,"#include ""loop.hpp""

#include <godot_cpp/core/class_db.hpp>
#include <godot_cpp/variant/utility_functions.hpp>

using namespace godot;

#pragma region Registry
// Converts pipewire registry event details
// into a dictionary to be exposed in godot
static void on_registry_event(void *_data, uint32_t id,
                uint32_t permissions, const char *type, uint32_t version,
                const struct spa_dict *props) {
	PipewireLoop *lp = (PipewireLoop*)_data;

	Dictionary msg;
	msg[""$type""] = PW_REGISTRY_ADD;
	msg[""id""] = (int32_t)id;
	msg[""type""] = type;
	msg[""version""] = (int32_t)version;

	callable_mp(lp, &PipewireLoop::handle_event).call_deferred(msg);
}

static void on_registry_remove_event(void *_data, uint32_t id) {
	PipewireLoop *lp = (PipewireLoop*)_data;
	
	Dictionary msg;
	msg[""$type""] = PW_REGISTRY_REMOVE;
	msg[""id""] = (int32_t)id;

	callable_mp(lp, &PipewireLoop::handle_event).call_deferred(msg);
}

static const struct pw_registry_events registry_events = {
	PW_VERSION_REGISTRY_EVENTS,
	.global = on_registry_event,
	.global_remove = on_registry_remove_event,
};

/** Adds controls to this loop so it'll be ready to listen to events from the
 *  pipewire registry during execution.
 */
void PipewireLoop::prepare_for_registry() {
    // can not add new contexts to a loop after we've already started processing from it
    ERR_FAIL_COND(this->running == true);

    this->context = pw_context_new(this->loop,
				NULL /* properties */,
				0 /* user_data size */);

	this->core = pw_context_connect(this->context,
				NULL /* properties */,
				0 /* user_data size */);

	this->registry = pw_core_get_registry(this->core, PW_VERSION_REGISTRY,
				0 /* user_data size */);
	
	ERR_FAIL_COND(this->registry == nullptr);

	this->registry_listener = new spa_hook;
	spa_zero(*(this->registry_listener));
	
	pw_registry_add_listener(this->registry, this->registry_listener, &registry_events, this);
}
#pragma endregion Registry

#pragma region Stream
typedef struct {
    PipewireLoop *loop;
    pw_stream *stream;
    spa_video_info format;
} StreamReference;

static void on_stream_process(void *userdata)
{
        StreamReference *data = (StreamReference*)userdata;
        struct pw_buffer *b;
        struct spa_buffer *buf;
 
        if ((b = pw_stream_dequeue_buffer(data->stream)) == NULL) {
                pw_log_warn(""out of buffers: %m"");
                return;
        }
 
        buf = b->buffer;
        if (buf->datas[0].data == NULL)
                return;
 
        printf(""got a frame of size %d\n"", buf->datas[0].chunk->size);
 
        pw_stream_queue_buffer(data->stream, b);
}

static void on_param_changed(void *userdata, uint32_t id, const struct spa_pod *param)
{
        StreamReference *data = (StreamReference*)userdata;
 
        if (param == NULL || id != SPA_PARAM_Format)
                return;
 
        if (spa_format_parse(param,
                        &data->format.media_type,
                        &data->format.media_subtype) < 0)
                return;
 
        if (data->format.media_type != SPA_MEDIA_TYPE_video ||
            data->format.media_subtype != SPA_MEDIA_SUBTYPE_raw)
                return;
 
        if (spa_format_video_raw_parse(param, &data->format.info.raw) < 0)
                return;
 
        printf(""got video format:\n"");
        printf(""  format: %d (%s)\n"", data->format.info.raw.format,
                        spa_debug_type_find_name(spa_type_video_format,
                                data->format.info.raw.format));
        printf(""  size: %dx%d\n"", data->format.info.raw.size.width,
                        data->format.info.raw.size.height);
        printf(""  framerate: %d/%d\n"", data->format.info.raw.framerate.num,
                        data->format.info.raw.framerate.denom);
 
}

static const struct pw_stream_events stream_events = {
        PW_VERSION_STREAM_EVENTS,
        .param_changed = on_param_changed,
        .process = on_stream_process,
};

/** Attaches a capture stream to the loop, mainly for listening to video
 *  playback that can be fed to Godot textures
 */
void PipewireLoop::prepare_stream(char* path, pw_properties *props) {
    // can not add new contexts to a loop after we've already started processing from it
    ERR_FAIL_COND(this->running == true);

    pw_properties_set(props, PW_KEY_TARGET_OBJECT, path);

    auto data = StreamReference {
        .loop = this, 
    };
    auto stream = pw_stream_new_simple(
        loop,
        ""video-play"",
        props,
        &stream_events,
        &data
    );
    data.stream = stream;
    
    uint8_t buffer[1024];
    spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
    const spa_pod *params[1];
    auto p = spa_pod_builder_add_object(&b,
        SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
        SPA_FORMAT_mediaType,       SPA_POD_Id(SPA_MEDIA_TYPE_video),
        SPA_FORMAT_mediaSubtype,    SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
        SPA_FORMAT_VIDEO_format,    SPA_POD_CHOICE_ENUM_Id(7,
                                        SPA_VIDEO_FORMAT_RGB,
                                        SPA_VIDEO_FORMAT_RGB,
                                        SPA_VIDEO_FORMAT_RGBA,
                                        SPA_VIDEO_FORMAT_RGBx,
                                        SPA_VIDEO_FORMAT_BGRx,
                                        SPA_VIDEO_FORMAT_YUY2,
                                        SPA_VIDEO_FORMAT_I420),
        SPA_FORMAT_VIDEO_size,      SPA_POD_CHOICE_RANGE_Rectangle(
                                        &SPA_RECTANGLE(320, 240),
                                        &SPA_RECTANGLE(1, 1),
                                        &SPA_RECTANGLE(4096, 4096)),
        SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(
                                        &SPA_FRACTION(25, 1),
                                        &SPA_FRACTION(0, 1),
                                        &SPA_FRACTION(1000, 1))
    );
    params[0] = (spa_pod*)p;

    int res = pw_stream_connect(stream,
                        PW_DIRECTION_INPUT,
                        PW_ID_ANY,
                        static_cast<pw_stream_flags>(
                            PW_STREAM_FLAG_AUTOCONNECT |
                            PW_STREAM_FLAG_MAP_BUFFERS
                        ),
                        params, 1);
                        
    ERR_FAIL_COND(res < 0);

    this->stream = stream;
}
#pragma endregion Stream

// interrupts pipewire thread
static int do_stop(struct spa_loop *loop, bool async, uint32_t seq,
		const void *data, size_t size, void *_data)
{
	PipewireLoop *lp = (PipewireLoop*)_data;
	lp->_thread_stop();
	return 0;
}


pw_loop* PipewireLoop::get_loop() {
	return this->loop;
}

void PipewireLoop::poll_pw() {
	godot::UtilityFunctions::print(""[pw] entering loop"");

	this->running = true;
	
	pw_loop_enter(this->loop);
	while (this->running) {
		int res;
		if (res = pw_loop_iterate(this->loop, -1) < 0) {
			if (res != -EINTR) {
				break;
			}
		}
	}
	pw_loop_leave(this->loop);
}

void PipewireLoop::start() {
    godot::UtilityFunctions::print(""[pw] pipewire initialized"");
	this->thread_loop.instantiate();
	this->thread_loop->start(callable_mp(this, &PipewireLoop::poll_pw));
}

void PipewireLoop::stop() {
    // sends an interrupt to the 
    pw_loop_invoke(this->loop, do_stop, 1, NULL, 0, false, this);
}

void PipewireLoop::_thread_stop() {
    this->running = false;
}

void PipewireLoop::handle_event(Dictionary  [MASK] ) {
    // TODO push events to godot signals
    this->emit_signal(""pw_event"",  [MASK] );
}

PipewireLoop::PipewireLoop() {
	this->loop = pw_loop_new(NULL);
}

PipewireLoop::~PipewireLoop() {
    ERR_FAIL_COND(this->loop == nullptr);

	if (this->thread_loop->is_alive()) {
        this->stop();
		this->thread_loop->wait_to_finish();
	}
	this->thread_loop->unreference();

    /** remove registry context if prepared */
    if (this->registry != nullptr) {
        pw_proxy_destroy((struct pw_proxy*)this->registry);
        pw_core_disconnect(this->core);
        pw_context_destroy(this->context);
    }

    /** remove stream if prepared */
    if (this->stream != nullptr) {
        pw_stream_destroy(this->stream);
    }
    pw_loop_destroy(this->loop);
}",evt
699,"#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int mod = 1e9 + 7;
const int maxn = 2e5 + 5;
long long a[maxn];
int ans = 0;

#include <iostream>
using namespace std;

// 计算Cn-m的函数-动态规划O(nk)
// int C_dp(int n, int k) {
//     std::vector<std::vector<int>> dp(n + 1, std::vector<int>(k + 1, 0));

//     for (int i = 0; i <= n; i++) {
//         dp[i][0] = 1;
//     }

//     for (int i = 1; i <= n; i++) {
//         for (int j = 1; j <= std::min(i, k); j++) {
//             dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
//         }
//     }

//     return dp[n][k];
// }

// 计算Cn-m的函数-直接求解O(m)
long long C(int n, int m)
{
    // 如果m大于n或者m小于0，返回0
    if (m > n || m < 0)
    {
        return 0;
    }
    // 如果m等于n或者m等于0，返回1
    if (m == n || m == 0)
    {
        return 1;
    }
    // 初始化结果为1
    long long result = 1;
    // 边乘边除，注意先乘后除
    for (int i = 1; i <= m; i++)
    {
        result = result * (n - i + 1) / i;
    }
    // 返回结果
    return result;
}

// O(nk*k)
int calValue(int n, int k, long long *a)
{
    long long diff = 0,  [MASK]  = 0;
    long long sum = 0;
    long long C1 = 0, C2 = 0;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= k; j++)
        {
            diff = 2 * j - k - 1;
            C1 = C(i - 1, j - 1);
            C2 = C(n - i, k - j);
             [MASK]  = C1 + C2;
            sum += diff *  [MASK]  * a[i - 1];
        }
    }

    return sum;
}

int main()
{
    int n, k; // 输入的 n 和 k
    cin >> n >> k;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i]; // 输入每个数字
    }
    sort(a, a + n); // 将数字从小到大排序Sort()有O(n*log（n）)
    ans = calValue(n, k, a) % mod;
    cout << ans << endl;
    return 0;
}
",selected
700,"//-----------------
//Define Target
//-----------------
#define AOCL    1
#define CPU     2
#define GPU     3

#ifndef TARGET
  #define TARGET CPU
#endif

#define TAR_CPU_OR_GPU (TARGET==CPU) || (TARGET==GPU)
//-----------------
//Preprocessing
//-----------------

//let me use deprected commands (for clCreateCommandQueue)
#define CL_USE_DEPRECATED_OPENCL_1_2_APIS
#include ""CL/opencl.h""
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>



#define CHECK(X) assert(CL_SUCCESS == (X))

//-----------------
//Problem Size
//-----------------
//Make sure it matches size in kernels.cl

#define SIZE      10
  //size of input array
#define MAXINPUT  10
  //randomly populated elements in the input array will not exceed this value

//--------------------------------
//CHANNELS, # OF KERNELS
//--------------------------------
//#define CHANNELS

#ifdef CHANNELS
  #define NKERNELS    3
  #define K_INPUT     0
  #define K_COMPUTE   1
  #define K_OUTPUT    2
  #define NAME_K0 ""kernelInput""
  #define NAME_K1 ""kernelCompute""
  #define NAME_K2 ""kernelOutput""
  const char* kernel_names[NKERNELS] = 
     {
        NAME_K0
       ,NAME_K1
       ,NAME_K2
     };
#else
  #define NKERNELS    1
  #define K_COMPUTE   0
  #define NAME_K0     ""kernelCompute""
  const char* kernel_names[NKERNELS] = 
     {
        NAME_K0
     };
#endif




//-------------------------------------------------
//signatures 
//-------------------------------------------------
void init(int a[]);

void kernelHostVersion(  int  a_in[]
                        , int a_out[]) ;
                
int post  ( FILE *fp
          , FILE *fperor
          , int *aIn
          , int *aOutHost
          , int *aOutDev
          );

void notify_print( const char* errinfo, const void* private_info, size_t cb, void *user_data );

unsigned char *load_file(const char* filename,size_t*size_ret);

int generate_random_int()
{
    return (rand());
}
          
//-------------------------------------------------
//globals
//-------------------------------------------------
const unsigned char *binary = 0;
cl_platform_id    platform;
cl_device_id      device;
cl_context        context;
cl_program        my_program;

//multiple kernels (possibly over  multiple devices) required multiple command queues
cl_kernel         kernels[NKERNELS];
#if TAR_CPU_OR_GPU
cl_command_queue  commands[1]; 
#else
cl_command_queue  commands[NKERNELS]; 
#endif


//-------------------------------------------------
//main()
//-------------------------------------------------
int main(int argc, char**argv) 
{
  #ifdef CHANNELS
    printf(""HST::Executing **channelized** version\n"");
  #else
    printf(""HST::Executing **non-channelized** version\n"");
  #endif
//variables
  int aIn[SIZE];     
  int aOutHostRun[SIZE];  
  int aOutOclRun[SIZE]; 

  //initialize output file
  FILE *fp, *fperror;
  fp      = fopen(""out.dat"", ""w"");
  fperror = fopen(""error.log"", ""w"");

  //initialize variables
  init(aIn);

//-------------------------------------------------
//hostOnly-run
//-------------------------------------------------
  kernelHostVersion ( aIn
                    , aOutHostRun
                    );  

//-------------------------------------------------
//opencl run
//-------------------------------------------------

  //ocl device memory pointers
  //---------------------
  cl_mem aInDev  = 0;
  cl_mem aOutDev = 0;
  
  //other variables
  //---------------------
  cl_int status = 0;
  int    num_errs = 0;
  int    i;
  
  cl_uint num_platforms = 0;
  
  //platform,device, context, command queue
  //---------------------------------------
  CHECK ( clGetPlatformIDs  (1, &platform, NULL) );       
  //get platform vendor
  char cl_platform_vendor[1001];
  char cl_platform_version[51];
  CHECK (clGetPlatformInfo ( platform, CL_PLATFORM_VENDOR, 1000, (void *)cl_platform_vendor, NULL) );
  CHECK (clGetPlatformInfo ( platform, CL_PLATFORM_VERSION, 50, (void *)cl_platform_version, NULL) );
  printf(""HST::CL_PLATFORM_VENDOR:\t%s\t:: Version: %s\n"",cl_platform_vendor, cl_platform_version);   

   
#if TARGET==AOCL
  printf(""HST::Getting AOCL FPGA target device\n"");
  CHECK( clGetDeviceIDs  (platform,CL_DEVICE_TYPE_ACCELERATOR,1,&device,0) );
#elif TARGET==CPU
  printf(""HST::Getting CPU target device\n"");
  CHECK( clGetDeviceIDs  (platform,CL_DEVICE_TYPE_CPU        ,1,&device,0) );
#elif TARGET==GPU
  printf(""HST::Getting GPU target device\n"");
  CHECK( clGetDeviceIDs  (platform,CL_DEVICE_TYPE_GPU        ,1,&device,0) );
#else
  #error ""Unknown TARGET specificed.""
#endif

  context = clCreateContext( 0, 1, &device, notify_print, 0, &status );
  CHECK( status );

  //single command queue for CPU (see README for explanation)
  #if TAR_CPU_OR_GPU
      commands[0] = clCreateCommandQueue( context, device, 0, &status );
  #else      
    //Create separate queue for each kernel, even if on same device  
    for (i=0; i<NKERNELS; i++) {
        commands[i] = clCreateCommandQueue( context, device, 0, &status );
      CHECK( status );
    }
  #endif

  //pipes
  //---------------------------------------
  #if TARGET==AOCL
    //AOCL creates channels (pipes)  in the kernel file global scope
  #else
    cl_mem ch0 = 0;
    cl_mem ch1 = 0;
  
    //Create and initialize memory objects
    const int PSIZE=SIZE;
    ch0 = clCreatePipe(context,CL_MEM_READ_WRITE,sizeof(int),PSIZE,NULL,&status);
    CHECK( status );
    ch1 = clCreatePipe(context,CL_MEM_READ_WRITE,sizeof(int),PSIZE,NULL,&status);
    CHECK( status );
  
  printf(""HST::Created pipes ch0 and ch1 in host scope, to be passed to kernels\n"");
  #endif


  //load kernel
  //------------
//For FPGA target, the kernels are compiled offline (via aoc compiler), and binary is loaded   
#if TARGET==AOCL   
  cl_int               bin_status = 0;
  size_t               bin_len = 0;
  const unsigned char* my_binary;
  size_t               my_binary_len = 0;
  #ifdef CHANNELS  
    const char *         aocx_name = ""kernels_channels.aocx"";
  #else
    const char *         aocx_name = ""kernels_noChannels.aocx"";
  #endif    
  printf(""HST::Loading kernel binary %s ...\n"", aocx_name);
  
  my_binary = load_file(aocx_name, &my_binary_len); 

  if ((my_binary == 0) || (my_binary_len == 0))
  { 
    printf(""HST::Error: unable to read %s into memory or the file was not found!\n"", aocx_name);
    exit(-1);
  }

  my_program = clCreateProgramWithBinary(context,1,&device,&my_binary_len,&my_binary,&bin_status,&status);
  CHECK(status);
//For CPU/GPU targets, the kernels are compiled at runtime
#else
  #ifdef CHANNELS
    const char *clsourceFile  = ""../device/kernels_channels.cl"";
  #else
    const char *clsourceFile  = ""../device/kernels_noChannels.cl"";
  #endif


  printf(""HST::Reading kernel source file: %s\n"", clsourceFile);

  // get size of kernel source
  FILE*  kfileHandle;
  size_t kfileSize;
  kfileHandle = fopen(clsourceFile, ""r"");
  fseek(kfileHandle, 0, SEEK_END);
  kfileSize = ftell(kfileHandle);
  rewind(kfileHandle);

  // read kernel source into buffer
  char *clsource = (char*) malloc(kfileSize + 1);
  clsource[kfileSize] = '\0';
  fread(clsource, sizeof(char), kfileSize, kfileHandle);
  fclose(kfileHandle);

  my_program = clCreateProgramWithSource ( context
                                      , 1
                                      , (const char **) &clsource 
                                      , NULL
                                      , &status
                                      );
  CHECK (status);
  printf(""HST::Created program with source: %s\n"", clsourceFile);
#endif  
   
  //for CPU/GPU options, we are compiling kernel at runtime, so
  //we need to pass it pre-processor flags here
  #if TARGET==CPU
    #ifdef DEADLOCK
      const char *preProcFlags=""-DTARGET=CPU -DDEADLOCK -cl-std=CL2.0"";
    #else 
      const char *preProcFlags=""-DTARGET=CPU -cl-std=CL2.0"";
   #endif
  #elif TARGET==GPU
    #ifdef DEADLOCK
      const char *preProcFlags=""-DTARGET=GPU -DDEADLOCK -cl-std=CL2.0"";
    #else 
      const char *preProcFlags=""-DTARGET=GPU -cl-std=CL2.0"";
   #endif
  #else  
      const char *preProcFlags="""";
  #endif  


  printf(""HST::Building program\n"");
  CHECK( clBuildProgram(my_program,1,&device,preProcFlags,0,0) );
  /* 
  //If you get build error and want to see build messages, uncomment this block
  
  clBuildProgram(my_program,1,&device,preProcFlags,0,0);
  size_t len;
  clGetProgramBuildInfo(my_program, device, CL_PROGRAM_BUILD_LOG, 0, NULL, &len);
  char buffer[len];
  clGetProgramBuildInfo(my_program, device, CL_PROGRAM_BUILD_LOG, len*sizeof(char), buffer, &len);
  printf(""HST::%s\n"", buffer);
  clGetProgramBuildInfo(my_program, device, CL_PROGRAM_BUILD_STATUS, len*sizeof(char), buffer, &len);
  printf(""HST::%s\n"", buffer);
  clGetProgramBuildInfo(my_program, device, CL_PROGRAM_BUILD_OPTIONS, len*sizeof(char), buffer, &len);
  printf(""HST::%s\n"", buffer);
  */
  
  printf(""HST::Creating kernel(s)\n"");
  //create kernel(s)
  for (i=0; i<NKERNELS; i++) {  
   kernels[i] = clCreateKernel(my_program, kernel_names[i], &status);
   CHECK(status);
  }    

  //cl buffers
  //---------------------
  printf(""HST::Creating cl (device) buffers\n"");
  aInDev  = clCreateBuffer(context,CL_MEM_READ_WRITE,SIZE*sizeof(int),0,&status); CHECK(status);
  aOutDev = clCreateBuffer(context,CL_MEM_READ_WRITE,SIZE*sizeof(int),0,&status); CHECK(status);

  //Prepare Kernel, Args
  //---------------------
  printf(""HST::Preparing kernels\n"");   
  int cl_wi=0;
  
  //write initial data to buffer on device (0th command queue for 0th kernel)
  CHECK( clEnqueueWriteBuffer(commands[0],aInDev,0,0,SIZE*sizeof(int),aIn,0,0,0) );
  CHECK( clFinish(commands[0]) );
  //£
  //for (int i=0; i<NKERNELS; i++)
  //   CHECK( clFinish(commands[i]) );
  
  size_t dims[3] = {0, 0, 0};    
  //Currently I am working with Single work-instance kernels, so that
  //looping in the kernel can be explored, which is more suitable for FPGA targets
  dims[0] = 1 ;
  
  #ifdef CHANNELS
    CHECK( clSetKernelArg(kernels[K_INPUT]  ,0,sizeof(cl_mem),&aInDev)  );
    CHECK( clSetKernelArg(kernels[K_OUTPUT] ,0,sizeof(cl_mem),&aOutDev)  );
    //if cpu or gpu target (and channelized) then pipes need to passed too
    #if TAR_CPU_OR_GPU
      CHECK( clSetKernelArg(kernels[K_INPUT]  ,1,sizeof(cl_mem),(void *) &ch0 ));
      CHECK( clSetKernelArg(kernels[K_COMPUTE],0,sizeof(cl_mem),(void *) &ch0 ));
      CHECK( clSetKernelArg(kernels[K_COMPUTE],1,sizeof(cl_mem),(void *) &ch1 ));
      CHECK( clSetKernelArg(kernels[K_OUTPUT] ,1,sizeof(cl_mem),(void *) &ch1 ));
    #endif
  #else
    CHECK( clSetKernelArg(kernels[K_COMPUTE],0,sizeof(cl_mem),&aInDev)  );
    CHECK( clSetKernelArg(kernels[K_COMPUTE],1,sizeof(cl_mem),&aOutDev)  );
  #endif
 
  //Launch Kernel
  //-------------
  #ifdef DEADLOCK
    printf(""HST::Doing the **DEADLOCK** run\n"");
  #endif    
  printf(""HST::Enqueueing kernel with global size %d\n"",(int)dims[0]);  
  for (int i=0; i<NKERNELS; i++) {
    #if TAR_CPU_OR_GPU    
      CHECK( clEnqueueNDRangeKernel(commands[0],kernels[i],1,0,dims,0,0,0,0));
    #else
      CHECK( clEnqueueNDRangeKernel(commands[i],kernels[i],1,0,dims,0,0,0,0));
    #endif
  }
  
  #if TAR_CPU_OR_GPU
    CHECK( clFinish(commands[0]) );
  #else
    for (int i=0; i<NKERNELS; i++)
      CHECK( clFinish(commands[i]) );
  #endif

  //Read results
  //---------------------
  printf(""HST::Reading results to host buffers...\n"");
  #ifdef CHANNELS
    #if TAR_CPU_OR_GPU
      CHECK( clEnqueueReadBuffer(commands[0],aOutDev,1,0,SIZE*sizeof(int),aOutOclRun,0,0,0) );
    #else
      CHECK( clEnqueueReadBuffer(commands[K_OUTPUT],aOutDev,1,0,SIZE*sizeof(int),aOutOclRun,0,0,0) );
    #endif
  #else
    CHECK( clEnqueueReadBuffer(commands[K_COMPUTE],aOutDev,1,0,SIZE*sizeof(int),aOutOclRun,0,0,0) );
  #endif
   
  //Compare results
  //---------------------
  printf(""HST::Checking results...\n"");   
  post (fp, fperror, aIn, aOutHostRun, aOutOclRun);

  //Post-processing
  //---------------------
  clReleaseMemObject(aInDev);
  clReleaseMemObject(aOutDev);
  //clReleaseKernel(kernel);
  clReleaseProgram(my_program);
  clReleaseContext(context);
   
  return 0;
}

//-------------------------------------------------
//init()
//-------------------------------------------------
void init(  int a[SIZE]
         ){      
    for(int i=0; i<SIZE; i++) 
        a[i] = rand() % MAXINPUT;
        //a[i] = i+1;
}

//--------------------------------------
//- kernel_hostVersion (baseline)
//--------------------------------------
void kernelHostVersion ( int aIn[SIZE]
                       , int aOut[SIZE]) {
  printf(""HST::Running host-only application, creating golden reference\n"");
  for(int i=0; i<SIZE; i++) {
    //closed boundary
    if((i==0) || (i==SIZE-1))
      aOut[i] = aIn[i];
    //3-point averaging window
    else
      aOut[i] = (aIn[i-1] + aIn[i] + aIn[i+1]) / 3;            
  }
  printf(""HST::Host-only run complete\n\n"");
}//()


//--------------------------
//-Writing the arrays to file
//--------------------------
int post (  FILE *fp
          , FILE *fperror
          , int aIn[SIZE]
          , int aOutHost[SIZE]
          , int aOutDev[SIZE]
          ) {

    int num_errs = 0;
    int testPass = 1;
    
    //linear display with indices, and also compare results
    fprintf(fp, ""-------------------------------------------------------------\n"");
    fprintf(fp, ""       i ::  aIn,   aOutHost , aOutDev\n"");
    fprintf(fp, ""-------------------------------------------------------------\n"");

    for(int i=0; i<SIZE; i++) {
        //print to file
        fprintf (fp, ""\t%5d\t::\t%10d\t%10d\t%10d\n""
                 , i,  aIn[i],  aOutHost[i], aOutDev[i]);
        //compare hostRUn <--> OpenCLrun

        if (aOutHost[i] != aOutDev[i]) {
          num_errs++;
          fprintf (fperror, ""ERROR at i=%d, Expected = %d, Computed = %d\n"", i, aOutHost[i], aOutDev[i]);
          testPass=0;
       }
    }//for
    if (testPass==1)
     printf(""HST::$$$ Test PASSED! :) $$$\n"");
    else
     printf(""HST::XXX Test FAILED! :( XXX\n"");
  return num_errs;
}//()


//-------------------------------------------------
//notify_print
//-------------------------------------------------

void notify_print( const char* errinfo, const void* private_info, size_t cb, void *user_data )
{
   private_info = private_info;
   cb = cb;
   user_data = user_data;
   printf(""HST::Error: %s\n"", errinfo);
}


//-------------------------------------------------
//load_file
//-------------------------------------------------
unsigned char *load_file(const char* filename,size_t*size_ret)
{
   FILE* fp;
   int len;
   const size_t  [MASK]  = 1000000;
   unsigned char *result;
   size_t r = 0;
   size_t w = 0;
   fp = fopen(filename,""rb"");
   if ( !fp ) return 0;
   // Obtain file size.
   fseek(fp, 0, SEEK_END);
   len = ftell(fp);
   // Go to the beginning.
   fseek(fp, 0, SEEK_SET);
   // Allocate memory for the file data.
   result = (unsigned char*)malloc(len+ [MASK] );
   if ( !result )
   {
     fclose(fp);
     return 0;
   }
   // Read file.
   while ( 0 < (r=fread(result+w,1, [MASK] ,fp) ) )
   {
     w+=r;
   }
   fclose(fp);
   *size_ret = w;
   return result;
}
",CHUNK_SIZE
701,"/* Copyright 2014 <NAME> (https://github.com/adamgreen/)

   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.
*/

extern ""C""
{
#include <core/try_catch.h>
#include <core/mri.h>
#include <core/cmd_file.h>
#include <core/core.h>
}
#include <platformMock.h>

// Include C++ headers for test harness.
#include ""CppUTest/TestHarness.h""


TEST_GROUP(cmdFile)
{
    int  m_expectedException;

    void setup()
    {
        m_expectedException = noException;
        platformMock_Init();
        mriInit(""MRI_UART_MBED_USB"");
    }

    void teardown()
    {
        LONGS_EQUAL ( m_expectedException, getExceptionCode() );
        clearExceptionCode();
        platformMock_Uninit();
    }

    void validateExceptionCode(int  [MASK] )
    {
        m_expectedException =  [MASK] ;
        LONGS_EQUAL (  [MASK] , getExceptionCode() );
    }
};

TEST(cmdFile, IssueGdbFileOpenRequest_ReturnSuccess)
{
    OpenParameters params = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileOpenRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fopen,11111111/22222222,33333333,44444444#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileOpenRequest_ReturnError)
{
    OpenParameters params = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
    platformMock_CommInitReceiveChecksummedData(""+$F-1,12345678#"");
        IssueGdbFileOpenRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fopen,11111111/22222222,33333333,44444444#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( -1, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( -1, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0x12345678, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileOpenRequest_ReturnErrorAndControlC)
{
    OpenParameters params = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
    platformMock_CommInitReceiveChecksummedData(""+$F-1,12345678,C#"");
        IssueGdbFileOpenRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fopen,11111111/22222222,33333333,44444444#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( -1, platformMock_GetSemihostCallReturnValue() );
    CHECK_TRUE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( -1, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0x12345678, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileOpenRequest_ReturnInterruptErrorAndControlC)
{
    OpenParameters params = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
    platformMock_CommInitReceiveChecksummedData(""+$F-1,4,C#""); // 4 is EINTR
        IssueGdbFileOpenRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fopen,11111111/22222222,33333333,44444444#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_TRUE ( WasControlCFlagSentFromGdb() );
    CHECK_TRUE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( -1, GetSemihostReturnCode() );
    CHECK_EQUAL ( 4, GetSemihostErrno() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() ); // Doesn't call in this scenario.
    CHECK_EQUAL ( 0, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileWriteRequest_ReturnSuccess)
{
    TransferParameters params = { 0x11111111, 0x22222222, 0x33333333 };
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileWriteRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fwrite,11111111,22222222,33333333#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileReadRequest_ReturnSuccess)
{
    TransferParameters params = { 0x11111111, 0x22222222, 0x33333333 };
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileReadRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fread,11111111,22222222,33333333#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileCloseRequest_ReturnSuccess)
{
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileCloseRequest(0x12345678);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fclose,12345678#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileSeekRequest_ReturnSuccess)
{
    SeekParameters params = { 0x11111111, 0x22222222, 0x33333333 };
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileSeekRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Flseek,11111111,22222222,33333333#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileFStatRequest_ReturnSuccess)
{
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileFStatRequest(0x11111111, 0x22222222);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Ffstat,11111111,22222222#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileUnlinkRequest_ReturnSuccess)
{
    RemoveParameters params = { 0x11111111, 0x22222222 };
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileUnlinkRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Funlink,11111111/22222222#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileStatRequest_ReturnSuccess)
{
    StatParameters params = { 0x11111111, 0x22222222, 0x12345678 };
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileStatRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Fstat,11111111/22222222,12345678#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}

TEST(cmdFile, IssueGdbFileRenameRequest_ReturnSuccess)
{
    RenameParameters params = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
    platformMock_CommInitReceiveChecksummedData(""+$F0#"");
        IssueGdbFileRenameRequest(&params);
    STRCMP_EQUAL ( platformMock_CommChecksumData(""$Frename,11111111/22222222,33333333/44444444#+""),
                   platformMock_CommGetTransmittedData() );
    CHECK_EQUAL ( 0, platformMock_GetSemihostCallReturnValue() );
    CHECK_FALSE ( WasControlCFlagSentFromGdb() );
    CHECK_FALSE ( WasSemihostCallCancelledByGdb() );
    CHECK_EQUAL ( 0, GetSemihostReturnCode() );
    CHECK_EQUAL ( 0, GetSemihostErrno() );
    CHECK_EQUAL ( 1, platformMock_AdvanceProgramCounterToNextInstructionCalls() );
}
",expectedExceptionCode
702,"/**
 * Copyright 2022 Huawei Technologies Co., Ltd
 *
 * 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 MINDSPORE_INCLUDE_API_MODEL_GROUP_H
#define MINDSPORE_INCLUDE_API_MODEL_GROUP_H

#include <string>
#include <vector>
#include <map>
#include <memory>
#include <utility>
#include ""include/api/model.h""
#include ""include/api/status.h""
#include ""include/api/types.h""
#include ""include/api/context.h""

namespace mindspore {
class ModelGroupImpl;

/// \brief The ModelGroup class is used to define a MindSpore model group, facilitating
/// multiple models to share workspace memory.

enum class ModelGroupFlag : int {
  kUnknown = 0x0000,
  kShareWeight = 0x0001,
  kShareWorkspace = 0x0002,
  kShareWeightAndWorkspace = 0x0003,
};

class MS_API ModelGroup {
 public:
  explicit ModelGroup(ModelGroupFlag flags = ModelGroupFlag::kShareWorkspace);
  ~ModelGroup() = default;

  /// \brief Add models that require shared workspace memory.
  ///
  /// \param[in] model_path_list Define the list of model path.
  ///
  /// \return Status.
  inline Status AddModel(const std::vector<std::string> &model_path_list);

  /// \brief Add models that require shared workspace memory.
  ///
  /// \param[in] model_buff_list Define the list of model buff.
  ///
  /// \return Status.
  Status AddModel(const std::vector<std::pair<const void *, size_t>> &model_buff_list);

  /// \brief Add models that require shared weight memory.
  ///
  /// \param[in] model_list Define the list of model object.
  ///
  /// \return Status.
  Status AddModel(const std::vector<Model> &model_list);

  /// \brief Calculate the max workspace of the added models.
  ///
  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR_Lite, ModelType::kMindIR. Only
  /// ModelType::kMindIR_Lite is valid for Lite.
  /// \param[in] ms_context A context used to store options.
  ///
  /// \return Status.
  Status CalMaxSizeOfWorkspace(ModelType model_type, const std::shared_ptr<Context> &ms_context);

 private:
  std::shared_ptr<ModelGroupImpl> impl_;
  Status AddModel(const std::vector<std::vector<char>> &model_path_list);
};

Status ModelGroup::AddModel(const std::vector<std::string> &model_path_list) {
  std::vector<std::vector<char>>  [MASK] ;
  for (auto str : model_path_list) {
     [MASK] .push_back(StringToChar(str));
  }
  return AddModel( [MASK] );
}

}  // namespace mindspore
#endif  // MINDSPORE_INCLUDE_API_MODEL_GROUP_H
",model_path_list_str
703,"//
// Created by sleeplessy on 2/24/18.
//

#ifndef EMU_CS_BASIC_CAN_INTERFACE_HPP
#define EMU_CS_BASIC_CAN_INTERFACE_HPP

#include <atomic>
#include <exception>
#include <linux/can.h>
#include <net/if.h>
#include <stdexcept>
#include <string>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <unistd.h>

namespace CAN {
struct socket_interface_t {
  socket_interface_t(){};

  socket_interface_t(int socket) : holder(socket){};
  std::atomic<int> holder;
};

// EXCEPTIONS
class can_exception_t : public std::runtime_error {
public:
  can_exception_t(std::string error_info)
      : runtime_error(error_info.insert(0, ""CAN INTERFACE EXCEPTION: "")) {}

  can_exception_t() : runtime_error(""CAN INTERFACE EXCEPTION: UNKNOW""){};
};

class can_init_error : public can_exception_t {
public:
  can_init_error() : can_exception_t(""INIT FAILED."") {}

  can_init_error(std::string &error_info)
      : can_exception_t(std::string(""INIT FAILED."").append(error_info)) {}
};

class can_length_unmatch : public can_exception_t {
public:
  can_length_unmatch() : can_exception_t(""LENGTH OF DATA UNSUPPOSED."") {}
};

template <typename __CAN_FRAME_T> class basic_can_interface {
public:
  basic_can_interface(const char *interface_name)
      : _interface_name(interface_name) {
    const int protocol = CAN_RAW;
    sockaddr_can addr;
    ifreq ifr = {};
    int  [MASK]  = ::socket(PF_CAN, SOCK_RAW, protocol);
    _interface_name.copy(ifr.ifr_name, _interface_name.size());
    if (ioctl( [MASK] , SIOCGIFINDEX, &ifr) < 0) {
      throw can_init_error();
    }
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    if (bind( [MASK] , reinterpret_cast<const sockaddr *>(&addr),
             sizeof(addr)) < 0) {

      throw can_init_error();
    }
    socket_holder.holder.store( [MASK] );
  }

  virtual void close() = 0;

  virtual __CAN_FRAME_T read() = 0;

  virtual void write(const __CAN_FRAME_T &frame_to_write) = 0;

  socket_interface_t &socket() noexcept { return socket_holder; };

  const std::string &ifterface_name() { return _interface_name; };

  ~basic_can_interface() {}

private:
  std::string _interface_name;
  socket_interface_t socket_holder;
};

class can_interface : public basic_can_interface<can_frame> {
public:
  can_interface(const char *interface_name)
      : basic_can_interface<can_frame>::basic_can_interface(interface_name),
        socket_holder(socket()) {
    socket_holder.holder;
  }

  void close() override { ::close(socket_holder.holder); }

  can_frame read() override {
    can_frame rev_buffer{};
    if (::read(socket_holder.holder, &rev_buffer, sizeof(can_frame)) <
        sizeof(can_frame))
      throw can_length_unmatch();
    return rev_buffer;
  };

  void write(const can_frame &frame_to_write) override {
    if (::write(socket_holder.holder, &frame_to_write, sizeof(can_frame)) !=
        sizeof(can_frame))
      throw can_length_unmatch();
  };

private:
  socket_interface_t &socket_holder;
};

} // namespace CAN
#endif // EMU_CS_BASIC_CAN_INTERFACE_HPP
",can_sock
704,"/*
author:          <NAME>
program name:    draw_map_radiological
date:            18.05.19
version:         1.0
*/

#include <opencv2/highgui/highgui.hpp>
#include ""opencv2/imgproc/imgproc.hpp""
#include ""opencv2/xfeatures2d.hpp""
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <yaml-cpp/yaml.h>
#include <libgen.h>

#include ""gauss.h""
#include ""draw_radiological.h""
#include ""read_csv.h""
#include ""COLORS.h""
#include ""header.h""

#define DEBUG_IMAGE 0

int main( int argc, char** argv )
{
    if(argc != 6)
    {
        std::cout << FORERED << ""Not enough arguments (map, ymal, gauss_out, gauss_resulution, draw_header(0 = false,1 = true), µSv/h(0 = false,1 = true )"" << std::endl;
        return -1;
    }

    double gauss_resulution = 0.0;
    {
        std::stringstream buf;
        buf << argv[4];
        buf >> gauss_resulution;
        if(gauss_resulution == 0.0)
        {
            std::cout << FORERED << ""Gauss resulution has to be a float!!"" << std::endl;
            return -1;
        }
    }

    int draw_header = 0;
    {
        std::stringstream ss;
        ss << argv[5];
        ss >> draw_header;

        if( draw_header != 0)
        {
            if(draw_header != 1)
            {
                std::cout << FORERED << ""draw_header has to be either 0 or 1. draw_header = "" << draw_header << std::endl;
                return -1;
            }
        }
    }

    //get path of the executible
    //!!! works only for linux systems
    char result[ PATH_MAX ];
    ssize_t count = readlink(""/proc/self/exe"", result, PATH_MAX);
    const char *p;
    if (count != -1)
    {
        p = dirname(result);
    }
  
    std::string path = p;

    //read yaml map file
    YAML::Node  [MASK]  = YAML::LoadFile( argv[2] );
    std::string map_filename =  [MASK] [""image""].as<std::string>();
    //check if given map and yaml config belong to each other
    std::string given_map_path = argv[1];
    if( given_map_path.find( map_filename ) == std::string::npos )
    {
        std::cout << FORERED << given_map_path << "" does not include "" << map_filename << "" -> map and config do not belong together!!"" << std::endl;
        return -1;
    }

    //read map
    cv::Mat map;
    map = cv::imread( given_map_path, 1 );    
    if(! map.data )                              // Check for invalid input
    {
        std::cout << FORERED <<  ""Could not open or find the image1"" << std::endl ;
        return -1;
    }

    #if DEBUG_IMAGE
    cv::namedWindow(""src"", CV_WINDOW_AUTOSIZE);
    cv::imshow(""src"", map);
    #endif

    double resulution =  [MASK] [""resolution""].as<double>();
    std::vector<double> origin =  [MASK] [""origin""].as< std::vector<double> >();

    #if DEBUG_IMAGE
    {
        int origin_x = -origin[0] / resulution;
        int origin_y = map.rows + origin[1] / resulution; 

        //display origin
        std::cout << origin_x << "" "" << origin_y << std::endl;
        //paint red blob at origin
        cv::Point ori(origin_x - 2, origin_y + 2);
        cv::Point ori2(origin_x + 2, origin_y - 2);
        cv::rectangle(map, ori, ori2, cv::Scalar(0, 0, 255), CV_FILLED, 8, 0);
    }
    #endif

    //read gauss csv
    std::vector<Gauss> pos_gauss;
    read_csv_gauss(pos_gauss, argv[3], map.rows, resulution, cv::Point2f(origin[0], origin[1]) );

    //draw header
    if(draw_header == 1)
    {
        write_header( map );
    }

    //read gauss csv
    std::vector<Gauss> pos_gauss2;
    read_csv_gauss(pos_gauss2, argv[3], map.rows, resulution, cv::Point2f(origin[0], origin[1]) );

    draw_radiolocial( map, pos_gauss2, resulution, (gauss_resulution/resulution), argv[6] );

    //cv::namedWindow(""Result"", CV_WINDOW_AUTOSIZE);
    //cv::imshow(""Result"", map);

	cv::imwrite( path + ""/map_gauss.ppm"", map );

    cv::waitKey(0);
    return(0);
}
",config_map
705,"/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * 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.
 */

namespace facebook {
namespace cachelib {

/* Container Interface Implementation */
template <typename T, MMClock::Hook<T> T::*HookPtr>
MMClock::Container<T, HookPtr>::Container(serialization::MMClockObject object,
                                        PtrCompressor compressor)
    : compressor_(std::move(compressor)),
      fifo_(*object.fifo(), compressor_),
      insertionPoint_(compressor_.unCompress(
          CompressedPtr{*object.compressedInsertionPoint()})),
      tailSize_(*object.tailSize()),
      config_(*object.config()) {
  nextReconfigureTime_ = config_.mmReconfigureIntervalSecs.count() == 0
                             ? std::numeric_limits<Time>::max()
                             : static_cast<Time>(util::getCurrentTimeSec()) +
                                   config_.mmReconfigureIntervalSecs.count();
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
bool MMClock::Container<T, HookPtr>::recordAccess(T& node,
                                                AccessMode  [MASK] ) noexcept {
  if (( [MASK]  == AccessMode::kWrite && !config_.updateOnWrite) ||
      ( [MASK]  == AccessMode::kRead && !config_.updateOnRead)) {
    return false;
  }

  const auto curr = static_cast<Time>(util::getCurrentTimeSec());
  // check if the node is still being memory managed
  if (node.isInMMContainer()) {
    if (!isAccessed(node)) {
      markAccessed(node);
    }


    setUpdateTime(node, curr);


    auto func = [this, &node, curr]() {
      reconfigureLocked(curr);
      ensureNotInsertionPoint(node);
      if (node.isInMMContainer()) {
        fifo_.moveToHead(node);
        setUpdateTime(node, curr);
      }
      if (isTail(node)) {
        unmarkTail(node);
        tailSize_--;
        XDCHECK_LE(0u, tailSize_);
        updateLruInsertionPoint();
      }
    };

    // if the tryLockUpdate optimization is on, and we were able to grab the
    // lock, execute the critical section and return true, else return false
    
    // if the tryLockUpdate optimization is off, we always execute the
    // critical section and return true
    // if (config_.tryLockUpdate) {
    //   if (auto lck = LockHolder{*lruMutex_, std::try_to_lock}) {
    //     func();
    //     return true;
    //   }

    //   return false;
    // }

    // lruMutex_->lock_combine(func);
    return true;
  }
  return false;
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
cachelib::EvictionAgeStat MMClock::Container<T, HookPtr>::getEvictionAgeStat(
    uint64_t projectedLength) const noexcept {
  return lruMutex_->lock_combine([this, projectedLength]() {
    return getEvictionAgeStatLocked(projectedLength);
  });
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
cachelib::EvictionAgeStat
MMClock::Container<T, HookPtr>::getEvictionAgeStatLocked(
    uint64_t projectedLength) const noexcept {
  EvictionAgeStat stat{};
  const auto currTime = static_cast<Time>(util::getCurrentTimeSec());

  const T* node = fifo_.getTail();
  stat.warmQueueStat.oldestElementAge =
      node ? currTime - getUpdateTime(*node) : 0;
  for (size_t numSeen = 0; numSeen < projectedLength && node != nullptr;
       numSeen++, node = fifo_.getPrev(*node)) {
  }
  stat.warmQueueStat.projectedAge = node ? currTime - getUpdateTime(*node)
                                         : stat.warmQueueStat.oldestElementAge;
  return stat;
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
void MMClock::Container<T, HookPtr>::setConfig(const Config& newConfig) {
  lruMutex_->lock_combine([this, newConfig]() {
    config_ = newConfig;
    if (config_.lruInsertionPointSpec == 0 && insertionPoint_ != nullptr) {
      auto curr = insertionPoint_;
      while (tailSize_ != 0) {
        XDCHECK(curr != nullptr);
        unmarkTail(*curr);
        tailSize_--;
        curr = fifo_.getNext(*curr);
      }
      insertionPoint_ = nullptr;
    }
    nextReconfigureTime_ = config_.mmReconfigureIntervalSecs.count() == 0
                               ? std::numeric_limits<Time>::max()
                               : static_cast<Time>(util::getCurrentTimeSec()) +
                                     config_.mmReconfigureIntervalSecs.count();
  });
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
typename MMClock::Config MMClock::Container<T, HookPtr>::getConfig() const {
  return lruMutex_->lock_combine([this]() { return config_; });
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
void MMClock::Container<T, HookPtr>::updateLruInsertionPoint() noexcept {
  if (config_.lruInsertionPointSpec == 0) {
    return;
  }

  // If insertionPoint_ is nullptr initialize it to tail first
  if (insertionPoint_ == nullptr) {
    insertionPoint_ = fifo_.getTail();
    tailSize_ = 0;
    if (insertionPoint_ != nullptr) {
      markTail(*insertionPoint_);
      tailSize_++;
    }
  }

  if (fifo_.size() <= 1) {
    // we are done;
    return;
  }

  XDCHECK_NE(reinterpret_cast<uintptr_t>(nullptr),
             reinterpret_cast<uintptr_t>(insertionPoint_));

  const auto expectedSize = fifo_.size() >> config_.lruInsertionPointSpec;
  auto curr = insertionPoint_;

  while (tailSize_ < expectedSize && curr != fifo_.getHead()) {
    curr = fifo_.getPrev(*curr);
    markTail(*curr);
    tailSize_++;
  }

  while (tailSize_ > expectedSize && curr != fifo_.getTail()) {
    unmarkTail(*curr);
    tailSize_--;
    curr = fifo_.getNext(*curr);
  }

  insertionPoint_ = curr;
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
bool MMClock::Container<T, HookPtr>::add(T& node) noexcept {
  const auto currTime = static_cast<Time>(util::getCurrentTimeSec());

  return lruMutex_->lock_combine([this, &node, currTime]() {
    if (node.isInMMContainer()) {
      return false;
    }
    if (config_.lruInsertionPointSpec == 0 || insertionPoint_ == nullptr) {
      fifo_.linkAtHead(node);
    } else {
      fifo_.insertBefore(*insertionPoint_, node);
    }
    node.markInMMContainer();
    setUpdateTime(node, currTime);
    unmarkAccessed(node);
    updateLruInsertionPoint();
    return true;
  });
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
typename MMClock::Container<T, HookPtr>::LockedIterator
MMClock::Container<T, HookPtr>::getEvictionIterator() noexcept {
  LockHolder l(*lruMutex_);
  auto liter = LockedIterator{std::move(l), &fifo_};
  return liter;
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
template <typename F>
void MMClock::Container<T, HookPtr>::withEvictionIterator(F&& fun) {
  if (config_.useCombinedLockForIterators) {
    lruMutex_->lock_combine([this, &fun]() { fun(Iterator{fifo_.rbegin()}); });
  } else {
    LockHolder lck{*lruMutex_};
    fun(Iterator{fifo_.rbegin()});
  }
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
void MMClock::Container<T, HookPtr>::ensureNotInsertionPoint(T& node) noexcept {
  // If we are removing the insertion point node, grow tail before we remove
  // so that insertionPoint_ is valid (or nullptr) after removal
  if (&node == insertionPoint_) {
    insertionPoint_ = fifo_.getPrev(*insertionPoint_);
    if (insertionPoint_ != nullptr) {
      tailSize_++;
      markTail(*insertionPoint_);
    } else {
      XDCHECK_EQ(fifo_.size(), 1u);
    }
  }
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
void MMClock::Container<T, HookPtr>::removeLocked(T& node) {
  ensureNotInsertionPoint(node);
  fifo_.remove(node);
  unmarkAccessed(node);
  if (isTail(node)) {
    unmarkTail(node);
    tailSize_--;
  }
  node.unmarkInMMContainer();
  updateLruInsertionPoint();
  return;
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
bool MMClock::Container<T, HookPtr>::remove(T& node) noexcept {
  return lruMutex_->lock_combine([this, &node]() {
    if (!node.isInMMContainer()) {
      return false;
    }
    removeLocked(node);
    return true;
  });
}

// template <typename T, MMClock::Hook<T> T::*HookPtr>
// void MMClock::Container<T, HookPtr>::remove(Iterator& it) noexcept {
//   T& node = *it;
//   XDCHECK(node.isInMMContainer());
//   ++it;
//   removeLocked(node);
// }

template <typename T, MMClock::Hook<T> T::*HookPtr>
void MMClock::Container<T, HookPtr>::remove(LockedIterator& it) noexcept {
  T& node = *it;
  XDCHECK(node.isInMMContainer());
  // ++it;
  removeLocked(node);
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
bool MMClock::Container<T, HookPtr>::replace(T& oldNode, T& newNode) noexcept {
  return lruMutex_->lock_combine([this, &oldNode, &newNode]() {
    if (!oldNode.isInMMContainer() || newNode.isInMMContainer()) {
      return false;
    }
    const auto updateTime = getUpdateTime(oldNode);
    fifo_.replace(oldNode, newNode);
    oldNode.unmarkInMMContainer();
    newNode.markInMMContainer();
    setUpdateTime(newNode, updateTime);
    if (isAccessed(oldNode)) {
      markAccessed(newNode);
    } else {
      unmarkAccessed(newNode);
    }
    XDCHECK(!isTail(newNode));
    if (isTail(oldNode)) {
      markTail(newNode);
      unmarkTail(oldNode);
    } else {
      unmarkTail(newNode);
    }
    if (insertionPoint_ == &oldNode) {
      insertionPoint_ = &newNode;
    }
    return true;
  });
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
serialization::MMClockObject MMClock::Container<T, HookPtr>::saveState()
    const noexcept {
  serialization::MMClockConfig configObject;
  *configObject.updateOnWrite() = config_.updateOnWrite;
  *configObject.updateOnRead() = config_.updateOnRead;
  *configObject.tryLockUpdate() = config_.tryLockUpdate;
  *configObject.lruInsertionPointSpec() = config_.lruInsertionPointSpec;

  serialization::MMClockObject object;
  *object.config() = configObject;
  *object.compressedInsertionPoint() =
      compressor_.compress(insertionPoint_).saveState();
  *object.tailSize() = tailSize_;
  *object.fifo() = fifo_.saveState();
  return object;
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
MMContainerStat MMClock::Container<T, HookPtr>::getStats() const noexcept {
  auto stat = lruMutex_->lock_combine([this]() {
    auto* tail = fifo_.getTail();

    // we return by array here because DistributedMutex is fastest when the
    // output data fits within 48 bytes.  And the array is exactly 48 bytes, so
    // it can get optimized by the implementation.
    //
    // the rest of the parameters are 0, so we don't need the critical section
    // to return them
    return folly::make_array(fifo_.size(),
                             tail == nullptr ? 0 : getUpdateTime(*tail)
                             );
  });
  return {stat[0] /* lru size */,
          stat[1] /* tail time */,
          // 0,
          0,
          0,
          0,
          0,
          0};
}

template <typename T, MMClock::Hook<T> T::*HookPtr>
void MMClock::Container<T, HookPtr>::reconfigureLocked(const Time& currTime) {
  if (currTime < nextReconfigureTime_) {
    return;
  }
  nextReconfigureTime_ = currTime + config_.mmReconfigureIntervalSecs.count();

  // // update LRU refresh time
  // auto stat = getEvictionAgeStatLocked(0);
  // auto lruRefreshTime = std::min(
  //     std::max(config_.defaultLruRefreshTime,
  //              static_cast<uint32_t>(stat.warmQueueStat.oldestElementAge *
  //                                    config_.lruRefreshRatio)),
  //     kLruRefreshTimeCap);
  // lruRefreshTime_.store(lruRefreshTime, std::memory_order_relaxed);
}

} // namespace cachelib
} // namespace facebook
",mode
706,"/* Paging LAB RDS Encoder V1.01

 * Version List:
 * - V1 - Start version
 * - V1.01 - Fix bug with long text messages more than 24 symbols; fix bug with Tone Only Messsges *
 *
 * Protocol description: https://en.wikipedia.org/wiki/Radio_Data_System
 * Datasheet: https://web.archive.org/web/20161020015638/http://www.nrscstandards.org/SG/nrsc-4-B.pdf

 * Transmitter chip: SI4713 (f.e. Adafruit SI4713 PCB)
 * Source for chip library: https://github.com/PE5PVB/si4713 Library updated for send 1A, 4A and 7A groups
 * Datasheet for chip: https://www.skyworksinc.com/-/media/Skyworks/SL/documents/public/application-notes/AN332.pdf
 *  
 * Description: 
 * - Tone Only Messages
 * - 10 digits Numeric Messages - use "":"" for space symbol
 * - 18 digits Numeric Messages - use "":"" for space symbol
 * - Aplphanimeric - up to 80 symbols
 * - Data and Time - Fixed. You can upgrade encdoder with any RTC module if you want. F.e. https://github.com/PaulStoffregen/DS1307RTC
 * - Monitor: turn ON for monitoring RDS packet sending
 * - Test message: ON/OFF; periodicaly send Numeric 10 digits format message
 * - Warnings: there is no validation of input data values, please enter the data correctly
 * - IMPORTANT: serial port baudrate = 57600; Terminal settings: No line Ending
 * - National/International Mode: Work only in National mode, you need read Country code from EEPROM or try all countries from 1 to F
 * - Pager`s Adrress: The pager address can be found on the back cover. If it is missing, you will have to read it from EEPROM I2C 24C02.
 *
 * FaceBook group about paging: https://www.facebook.com/groups/116072934759380                    
 */

#include ""si4713.h"" //transmitter library

bool overmod;
int8_t inlevel;

//Cycle Counters 
long G_4A_Counter = millis();
long G_1A_Counter = millis();
long G_7A_Counter = millis();
long G_2A_Counter = millis();


static Config Cfg_Base; //create  default config

//RTC
SI4713 TX;

void setup() {
  Cfg_Base.cfg_Offset.All = 0x04; // default UTC offset
  Cfg_Base.cfg_pi.All = 0x6277; // default PI, 6=Ukraine 0x6277
    
  Serial.begin(57600);
  Serial.setTimeout(50); //default 1000 ms
  
  TX.Init(RESET_TX_PIN, 32768, 0x63);   // RST pin (use -1 when using external supervisor), Crystal: 32.768kHz, I2C address: 0x63
 
  uint8_t pn;
  uint8_t chiprev;
 
  TX.Rev(pn, chiprev);                         // Receive Chipversion and revision Right: Detected chip: SI4113 Revision: 65
  Serial.print(""TX CHIP: SI41"" + String(pn));
  Serial.println("" Rev: "" + String(chiprev));
  
  TX.Output(115, 4);                    // Output level: 115dBuV, antenna capacitor: 0.25pF * 4 = 1pF)
  TX.Freq(Cfg_Base.cfg_Frequency);      // Set Output frequency
  
  TX.MPX_Enable(1);                     // 1 = Enable MPX Stereocoder
  TX.MPX_Deviation(675);                // Set MPX pilot deviation to 6.75kHz
  TX.MPX_Freq(19000);                   // Set MPX pilot to 19000Hz (19kHz)

  TX.Audio_Deviation(7500);             // Set Audio deviation to 75.00kHz
  TX.Audio_Mute(0);                     // Unmute audio
  TX.Audio_PreEmphasis(50);             // Set Audio pre-emphasis to 50uS (can be switched to 75uS or 0 for no pre-emphasis)
  TX.Audio_Limiter(0);                  // Disable Audio limiter
  TX.Audio_AGC(1);                      // Enable Audio Dynamic Range Control
  TX.Audio_Comp_Threshold(-40);         // Set Audio Dynamic Range Threshold to -40dBFS (max = 0dBFS)
  TX.Audio_Comp_Attack(0);              // Set Audio Dynamic Range Attack time to 0.5mS (max value = 9 -> 5.0mS, stepsize is 0.5mS)
  TX.Audio_Comp_Release(4);             // Set Audio Dynamic Range Release time to 1S (see p43 of application notes for other values)
  TX.Audio_Comp_Gain(15);               // Set Audio Dynamic Range Gain to 15dB (max=20dB)
  TX.Audio_Limiter_Release(102);        // Set Audio Limiter Release time to 5.01mS (see p44 of application notes for other values)

  TX.RDS_PI(Cfg_Base.cfg_pi.All);       // Set RDS PI code
  TX.RDS_AF(Cfg_Base.cfg_Frequency);    // Set RDS AF to 90.8MHz (use 0 to disable AF)
  TX.RDS_PTY(10);                       // Set RDS PTY to Pop Music (see list of codes at https://www.electronics-notes.com/articles/audio-video/broadcast-audio/rds-radio-data-system-pty-codes.php)
  TX.RDS_Deviation(200);                // Set RDS deviation to 2.00kHz
  TX.RDS_COMP(0);                       // Set RDS Compressed code to not Compressed
  TX.RDS_ART(0);                        // Set RDS Artificial Head code to Not artificial head
  TX.RDS_MS(1);                         // Set RDS Mono/Stereo code to stereo
  TX.RDS_TP(1);                         // Enable RDS Traffic Program
  TX.RDS_TA(0);                         // Disable RDS Traffic Announcement
  TX.RDS_MUSP(1);                       // Set RDS Music/Speech selection to Music
  
  TX.RDS_PS_MIX(0);                     // default=3; Sets the ratio of RDS PS (group 0A) and circular buffer/FIFO groups.  
  Update_0A(); // Update radioname and parameters

  TX.RDS_Enable(1);                     // 1 = Enable RDS encoder, 0 = Disable RDS encoder
  TX.GPO(0,0,0);                        // Set GPO outputs 1,2 and 3 to low.
  
  ShowStatus();
}

// ----------------------------------------------- Loop ------------------------------------------
void loop() {

//--------------------------------------------------------------------------- TIMERS
if (((millis() - G_4A_Counter) > G_4A_PERIOD) || (G_4A_Counter ==0 )) // send 4A each minute
  {
  TX.RDS_4A_TIME (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY,
                   Cfg_Base.cfg_Year, Cfg_Base.cfg_Month, Cfg_Base.cfg_Day, Cfg_Base.cfg_Hour, Cfg_Base.cfg_Minute, 
                   Cfg_Base.cfg_Offset.refined.offset_sign, Cfg_Base.cfg_Offset.refined.offset_hour, Cfg_Base.cfg_Offset.refined.offset_minute*30, Cfg_Base.cfg_Monitor);
  G_4A_Counter = millis();
  }

if ((millis() - G_1A_Counter) > G_1A_PERIOD) // send 1A Group each second
   {
    TX.RDS_1A_PIN (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY, Cfg_Base.cfg_1A_Rpc, Cfg_Base.cfg_1A_Slc, Cfg_Base.cfg_1A_Pinc, Cfg_Base.cfg_Monitor);
    G_1A_Counter = millis();
   }

if (((millis() - G_7A_Counter) > Cfg_Base.cfg_Test_Message_Period) && (Cfg_Base.cfg_Test_Message == ON)) // Send test Message
   {
    ADflagInvert();
    Serial.println(""Debug Messade>>"" + Int2STR(G_7A_Counter, 10));
    TX.RDS_7A_PAGING (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY, Cfg_Base.cfg_7A_ADflag, DIG10, Cfg_Base.cfg_7A_Address, Int2STR(G_7A_Counter, 10), Cfg_Base.cfg_Monitor); 
    G_7A_Counter = millis();
   }
   
if (((millis() - G_2A_Counter) > Cfg_Base.cfg_2A_Period*1000)  && Cfg_Base.cfg_2A_Period !=0) // send Radiotext
   {
    TX.RDS_2A_RT (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY, Cfg_Base.cfg_2A_ADflag, Cfg_Base.cfg_2A_Text, Cfg_Base.cfg_Monitor);
    G_2A_Counter = millis();
   }

//----------------------------------------End Timers

  if (Serial.available() > 0) {
    
    String Command = """"; //copmmand from terminal or Sprut
    Command = Serial.readString(); // read command
        
    switch (Command.toInt()) { //parce command

    case SET_MONITOR: //Monitor mode ON/OFF
        SetMonitor();     
        ShowStatus ();
        break;

    case SET_TEST_MESSAGE: //Test Message Mode ON/OFF
        SetTestMessage();     
        ShowStatus ();
        break;
    
    case SEND_7A_TONE: //Send Tone Message

        ADflagInvert(); //set new message flag                
        TX.RDS_7A_PAGING (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY, Cfg_Base.cfg_7A_ADflag, TONE, Cfg_Base.cfg_7A_Address, ""AA"", Cfg_Base.cfg_Monitor);
        Serial.println(""Tone Message>> Sent"");
        break;

    case SEND_7A_NUM_10: //Send 10 Digits Numeric Message

        ADflagInvert(); //set new message flag                
        TX.RDS_7A_PAGING (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY, Cfg_Base.cfg_7A_ADflag, DIG10, Cfg_Base.cfg_7A_Address, SetMessage (""Numeric Message [max=10]>""), Cfg_Base.cfg_Monitor);
        break;

    case SEND_7A_NUM_18: //Send 10 Digits Numeric Message

        ADflagInvert(); //set new message flag                
        TX.RDS_7A_PAGING (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY, Cfg_Base.cfg_7A_ADflag, DIG18, Cfg_Base.cfg_7A_Address, SetMessage (""Numeric Message [max=18]>""), Cfg_Base.cfg_Monitor);
        break;

    case SEND_7A_ALPHA: //Send debug RDS packet
        
        ADflagInvert(); //set new message flag                
        TX.RDS_7A_PAGING (Cfg_Base.cfg_pi.All, Cfg_Base.cfg_Bo, Cfg_Base.cfg_TP, Cfg_Base.cfg_PTY, Cfg_Base.cfg_7A_ADflag, ALPHA, Cfg_Base.cfg_7A_Address, SetMessage (""Text Message [max=24]>""), Cfg_Base.cfg_Monitor); //Cfg_Base.cfg_Monitor
        break;
    
     case SHOW_STATUS: //Send debug RDS packet
        ShowStatus ();
        break;

     case SET_FRQ: //Set frequency
        SetFRQ();     
        ShowStatus ();
        break;

      case SET_COUNTRY: //Set Country Code
        SetCountry();     
        ShowStatus ();
        break;
 
      case SET_7A_ADDRESS: //Set pager address
        Set7AAddress();     
        ShowStatus ();
        break;

      default:
      Serial.println(""Command error"");
      break;
    }
    
  }

}// ================================== End Loop

// FUNCTIONS

// --------------------------------- Show Status ------------------------
void ShowStatus()
{
    
  Serial.println(""---------< Paging LAB * RDS Encoder V1 >----------"");
  Serial.println(""[xx]Radio Name: "" + Cfg_Base.cfg_Radio_Name1 + ""|"" + Cfg_Base.cfg_Radio_Name2 + ""|"" + Cfg_Base.cfg_Radio_Name3 + ""|"" + Cfg_Base.cfg_Radio_Name4);
  Serial.println(""[xx]Radio Text: "" + Cfg_Base.cfg_2A_Text );
  
  //TIME and Frequency
  String  [MASK]  = ""+""; //offset output string
  if (Cfg_Base.cfg_Offset.refined.offset_sign == 1) { [MASK]  = ""-"";} //parce offset sign
   [MASK]  =  [MASK]  + Int2STR(Cfg_Base.cfg_Offset.refined.offset_hour,2); //parce offset hour
  if (Cfg_Base.cfg_Offset.refined.offset_minute == 1) //parce offset minute
  { [MASK]  =  [MASK]  + "":30"";} 
  else
  { [MASK]  =  [MASK]  + "":00"";} 
  String tmp_FRQ = Int2STR(Cfg_Base.cfg_Frequency,5); //**** FREQUENCY *****
  Serial.println(""[xx]UTC:"" + Int2STR(Cfg_Base.cfg_Day,2) + ""-"" + Int2STR(Cfg_Base.cfg_Month,2) + ""-"" + Int2STR(Cfg_Base.cfg_Year,4) + "" "" +  Int2STR(Cfg_Base.cfg_Hour,2) + "":"" + Int2STR(Cfg_Base.cfg_Minute,2) + "" "" +  [MASK]  + "" [21]FRQ:"" + tmp_FRQ.substring(0,3) + ""."" + tmp_FRQ.substring(3,4) + ""MHz"");

  // Help and monitoring  
  String tmp_Monitor = ""OFF"";
  if (Cfg_Base.cfg_Monitor==ON) {tmp_Monitor = ""ON"";}
  String tmp_Message = ""OFF"";
  if (Cfg_Base.cfg_Test_Message==ON) {tmp_Message = ""ON"";}
  Serial.println(""[11]Help [12]Monitor:"" + tmp_Monitor + "" [13]Test Message:"" + tmp_Message);
  // Country and address  
  Serial.println(""[31]Country:""+ Int2HEX(Cfg_Base.cfg_pi.refined.pi_country,1) +"" PI:"" + Int2HEX(Cfg_Base.cfg_pi.All,4) + "" [32]Address:""+ Int2STR(Cfg_Base.cfg_7A_Address,6));
  Serial.println(""[71]Tone [72]Num_10 [73]Num_18 [74]Alphanumeric"");
  Serial.println(""--------------------------------------------------"");
  
}
// =============================================================================================

// --------- Set Frequency Menu ------------------
void SetFRQ()
{
String Date_Input = """";
byte flag = 0;

Serial.print (""Frequency [xxx.x]>"" );
while (flag == 0)
{
if (Serial.available()) // waiting input data
  {
    Date_Input = Serial.readString();
    flag = 1;

    uint16_t tmp_FRQ = Date_Input.substring(0,3).toInt() * 100 + Date_Input.substring(4,6).toInt()*10; 
    
    if (tmp_FRQ<=7600 || tmp_FRQ>=10800)
    {
      Serial.println(""FRQ: Error"");
    }
    else
    {
      Cfg_Base.cfg_Frequency = tmp_FRQ; //save config
      TX.Freq(Cfg_Base.cfg_Frequency); //set base frq
      TX.RDS_AF(Cfg_Base.cfg_Frequency);  //set RDS frq
    }
  }
}
}
//=====================================================================

//----------------------------- Set Country CODE  -----------------------
void SetCountry()
{  
String Input = """";
byte flag = 0;

Serial.print (""Country [xx]>"" );
while (flag == 0)
{
if (Serial.available()) // waiting input data
  {
    Input = Serial.readString(); 
    flag = 1;
    
    if (Input.toInt() != 0) //validate country code
    {
      Cfg_Base.cfg_pi.refined.pi_country = Input.toInt(); //save to config
      TX.RDS_PI(Cfg_Base.cfg_pi.All); //update PI      
    }
    Serial.println(Input);
  }
}
}
//=================================================================================

//------------------------------- Update radioname and parameters for 0A Group ------------------------------------------------
void Update_0A() 
{ 
  TX.RDS_PS(Cfg_Base.cfg_Radio_Name1, 0);               // Set PS Message (max 8 characters) and position number in carousel
  TX.RDS_PS(Cfg_Base.cfg_Radio_Name2, 1);               // Set PS Message (max 8 characters) and position number in carousel
  TX.RDS_PS(Cfg_Base.cfg_Radio_Name3, 2);               // Set PS Message (max 8 characters) and position number in carousel
  TX.RDS_PS(Cfg_Base.cfg_Radio_Name4, 3);               // Set PS Message (max 8 characters) and position number in carousel
  TX.RDS_PSCOUNT(Cfg_Base.cfg_0A_slots, Cfg_Base.cfg_0A_speed);                // Number of PS Messages in carousel(4), (min 1, max 12),  and carousel speed (10) (min 1, max 255);
}
//=================================================================================

// -----------------------------  Set Pager Address -------------------------------
void Set7AAddress()

{  
String Input = """";
byte flag = 0;

Serial.print (""Address [xxxxxx]>"" );
while (flag == 0)
 {
 if (Serial.available()) // waiting input data
  {
    Input = Serial.readString(); 
    flag = 1;
    
    Cfg_Base.cfg_7A_Address = Input.toInt();
    Serial.println(Int2STR(Cfg_Base.cfg_7A_Address,6));
  }
 }
}
//=================================================================================

// -------------------------- A/B Invertion for new message -----------------------
void ADflagInvert()
{
  if (Cfg_Base.cfg_7A_ADflag == 0) //Set A/B flag as new message
     {Cfg_Base.cfg_7A_ADflag = 1;}
  else
     {Cfg_Base.cfg_7A_ADflag = 0;}
}        
//=================================================================================

// -------------------------- Enter New Message -----------------------------------
String SetMessage(String Hint)
{
String Date_Input = ""Error"";
byte flag = 0;

Serial.print (Hint + ""> "" );
  while (flag == 0)
  {
    if (Serial.available()) // waiting input data
      {
        Date_Input = Serial.readString();
        flag = 1;
        Serial.println (Date_Input);
        return Date_Input;   
      } 
  }
}
//=================================================================================

//------------------------- Set Monitor Mode --------------------------------------
void SetMonitor()
{  
String Input = """";
byte flag = 0;

Serial.print (""Monitor [0/1]>"" );
while (flag == 0)
  {
    if (Serial.available()) // waiting input data
      {
        Input = Serial.readString(); 
        flag = 1;
    
        if (Input.toInt() == 0) //Turn OFF
          {
            Cfg_Base.cfg_Monitor = OFF; //save to config
          }
          else 
          {
            Cfg_Base.cfg_Monitor = ON; //save to config
          }
        Serial.println(Input);
      }
  }
}
//=================================================================================

//------------------------- Set Test Message Mode --------------------------------------
void SetTestMessage()
{  
String Input = """";
byte flag = 0;

Serial.print (""Test Message [0/1]>"" );
while (flag == 0)
 {
  if (Serial.available()) // waiting input data
   {
    Input = Serial.readString(); 
    flag = 1;
    
    if (Input.toInt() == OFF) //Turn OFF
    {
      Cfg_Base.cfg_Test_Message = OFF; //save to config
    }
    else 
    {
      Cfg_Base.cfg_Test_Message = ON; //save to config
    }
    Serial.println(Input);
   } 
 }
}
//=================================================================================
",tmp_Offset_str
707,"// ORBSLAM2_get_trajectory.cpp

// This program reads the Pose output from ORBSLAM2 (message type PoseStamped) and combines them into an array to form a nav_msgs/Path message.
	// Subscribed line: /orb_slam2_rgbd/pose
	// Published lineL /orb_slam2_rgbd/trajectory


#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <signal.h>
#include <fstream>
#include <array>
#include <cmath>

// Use Eigen3 library for vector math
#include <Eigen/Dense>
#include <Eigen/Geometry>

// Use Boost QVM library for Quaternion calculations
#include <boost/qvm/quat.hpp>
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat_access.hpp>
#include <boost/qvm/mat.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat_access.hpp>
#include <boost/qvm/vec.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec_access.hpp>

// Could use all.hpp to include all QVM headers but not recommended
// #include <boost/qvm/all.hpp>

#include <ros/ros.h>
#include <std_msgs/String.h>
#include <rosbag/bag.h>

#include <geometry_msgs/PoseStamped.h>
#include <nav_msgs/Path.h>
#include <tf2_msgs/TFMessage.h>
#include <sensor_msgs/PointCloud2.h>
#include <sensor_msgs/Image.h>

#include <message_filters/subscriber.h>
#include <message_filters/time_synchronizer.h>
#include <sensor_msgs/Image.h>
#include <visualization_msgs/Marker.h>
#include <visualization_msgs/MarkerArray.h>

// For pointcloud transformation
#include <pcl_ros/point_cloud.h>
#include <pcl_ros/transforms.h>
#include <tf/LinearMath/Transform.h>
#include <tf/LinearMath/Quaternion.h>

using namespace std;
using namespace boost::qvm;

// Rotate by this much
	// TODO Improvement: Make this a launch arg, allow rotation in other directions
double theta = -0.47; // = 26.92 deg

// vec<float,3> camOffset(0.035, 0.0003, 0.053); // x,y,z camera offset from end effector
vec<float,3> camOffset = {0, 0, 0};

// Quaternion to store the initial translation and orientation of the camera rotated by initial camera position
quat<double> armTransOffset = {0, 0, 0, 0};
quat<double> armOrientOffset = {0, 0, 0, 1};

// File to save trajectory to - is located in .ros folder
string final_save_path = ""trajectoryFinal.bag"";
string full_save_path = ""trajectoryFull.bag"";

// Signal-safe flag for whether shutdown is requested
sig_atomic_t volatile g_request_shutdown = 0;

// Define paths as global variables for simplicity
nav_msgs::Path path_ORBSLAM2; 
nav_msgs::Path path_arm;

sensor_msgs::PointCloud2 pointcloudArray[1000];
int nPC = 0;

// Have publisher as global variable
ros::Publisher ORBSLAM2_traj_pub;
ros::Publisher arm_traj_pub; 

// Marker to represent model and base of arm
visualization_msgs::MarkerArray markerArray;
visualization_msgs::Marker marker;

int firstTF = 0;

int n_ORBSLAM2_pose = 1;
int n_arm_pose = 1;
int n_debug_image = 1;

// Debug check
int n = 0;

rosbag::Bag fullBag;

// Override on exiting program
void mySigIntHandler(int sig){
	// Save the trajectory to a bag - saves to /.ros/trajectory.bag
	rosbag::Bag bag;
	bag.open(final_save_path, rosbag::bagmode::Write);

	bag.write(""/orb_slam2_rgbd/trajectory"", ros::Time::now(), path_ORBSLAM2);
	bag.write(""/tf/trajectory"", ros::Time::now(), path_arm);
	bag.write(""/visual_marker"", ros::Time::now(), markerArray);
	bag.write(""/orb_slam2_rgbd/map_points"", ros::Time::now(), pointcloudArray[nPC]);
	bag.close();
	fullBag.close();

	g_request_shutdown = 1;
}

void debug_image_Callback(const sensor_msgs::ImageConstPtr& image){
	ROS_INFO_STREAM(""Received debug image: "" << n_debug_image);
	fullBag.write(""orb_slam2_rgbd/debug_image"", ros::Time::now(), image);
	n_debug_image++;
}

void pointcloud_Callback(const sensor_msgs::PointCloud2::ConstPtr& points){
	ROS_INFO_STREAM(""Received pointcloud: "" << nPC + 1);

	if(firstTF == 0) {
	// Always store last pointcloud, if over 1000 discard any except the last one
		pointcloudArray[nPC] = *points;
		fullBag.write(""/orb_slam2_rgbd/map_points"", ros::Time::now(), points);
	}
	else { // Transform into arm frame of reference

		// Construct a pure rotation, then pure translation matrix - must be Eigen 4x4 matrix

		// Convert to Eigen quaternion (note: Initialised in wxyz, stored as xyzw)
		Eigen::Quaternionf quat(boost::qvm::S(armOrientOffset), X(armOrientOffset), Y(armOrientOffset), Z(armOrientOffset));
		Eigen::Matrix3f rotMat = quat.normalized().toRotationMatrix();
		Eigen::Matrix4f transformRotation;
		transformRotation.setIdentity(); // Set identity matrix to make bottom right a 1
		transformRotation.block<3,3>(0,0) = rotMat; // Insert rotation matrix manually

		Eigen::Vector3f transVec(boost::qvm::X(armTransOffset), Y(armTransOffset), Z(armTransOffset));
		Eigen::Matrix4f transformTranslation;
		transformTranslation.setIdentity(); // Set identity matrix to make bottom right a 1
		transformTranslation.block<3,1>(0,3) = transVec; // Insert rotation matrix manually

		// tf::Transform transformRotation;
		// tf::Quaternion quat(boost::qvm::X(armOrientOffset), Y(armOrientOffset), Z(armOrientOffset), S(armOrientOffset));
		// transformRotation.setRotation(quat);
		// transformRotation.setOrigin(tf::Vector3(0,0,0));

		// tf::Transform transformTranslation;
		// tf::Quaternion baseQuat(0,0,0,1);
		// transformTranslation.setOrigin(tf::Vector3(boost::qvm::X(armTransOffset), Y(armTransOffset), Z(armTransOffset)));
		// transformTranslation.setRotation(baseQuat);
		

//		ROS_INFO_STREAM(""armTransOffset="" << X(armTransOffset) << "","" << Y(armTransOffset) << "","" <<Z(armTransOffset));
//		ROS_INFO_STREAM(""Transform="" << transform.getOrigin().x() << "","" << transform.getOrigin().y() << "","" <<transform.getOrigin().z());

		// Apply rotation first
		sensor_msgs::PointCloud2 pointsOutTemp;
		pcl_ros::transformPointCloud(transformRotation, *points, pointsOutTemp);
		sensor_msgs::PointCloud2 pointsOut;
		pcl_ros::transformPointCloud(transformTranslation, pointsOutTemp, pointsOut);


//		ROS_INFO_STREAM(""Finished transforming pointcloud."");

		pointcloudArray[nPC] = pointsOut;
		fullBag.write(""/orb_slam2_rgbd/map_points"", ros::Time::now(), pointsOut);
	}

	// Always store last trajectory, if over 1000 discard any except the last one
	if(nPC < 999){
			nPC++;
	}
	
}

void pose_ORBSLAM2_Callback(const geometry_msgs::PoseStamped::ConstPtr& msg) {
	float xPosInit, yPosInit, zPosInit;

	geometry_msgs::PoseStamped pose;

	// Verify pose received
	ROS_INFO_STREAM(""Received ORBSLAM2 pose: "" << n_ORBSLAM2_pose);
	n_ORBSLAM2_pose++;

	// If first arm tf message never received, directly output pose instead
	if(firstTF == 0) {
		path_ORBSLAM2.header = msg->header;
		pose.header = msg->header;
		pose.pose = msg->pose;
	}
	else {
		path_ORBSLAM2.header = msg->header;
		pose.header = msg->header;

		// Use this only if the object is flat, i.e. aligned with the z-axis
		// pose.pose = msg->pose;
			
		// Extract x,y,z pose, place into quaternion
		boost::qvm::quat<double> ORBSLAM2TransQuat = {0, msg->pose.position.x, msg->pose.position.y, msg->pose.position.z};
		// Extract orientation
		quat<double> ORBSLAM2OrientQuat = {msg->pose.orientation.w, msg->pose.orientation.x, msg->pose.orientation.y, msg->pose.orientation.z};

		// Pose = Pose of arm + qv(q^-1), q = initial rotation of arm, v = ORBSLAM2 vector
		quat<double> finalTransQuat = armTransOffset + operator*(operator*(armOrientOffset, ORBSLAM2TransQuat), conjugate(armOrientOffset));

		// Rotation = q3 * q2 * q1, q3 = initial pose of arm, q2 = ORBSLAM2 pose of arm, q1 = initial pose in ORBSLAM2 (0,0,0,1) so q3 * q2
		quat<double> finalOrientQuat = operator*(armOrientOffset,ORBSLAM2OrientQuat);

		// Assign to new pose
		pose.pose.orientation.x = X(finalOrientQuat);
		pose.pose.orientation.y = Y(finalOrientQuat);
		pose.pose.orientation.z = Z(finalOrientQuat);
		pose.pose.orientation.w = S(finalOrientQuat);

		pose.pose.position.x = X(finalTransQuat);
		pose.pose.position.y = Y(finalTransQuat);
		pose.pose.position.z = Z(finalTransQuat);

	//	ROS_INFO_STREAM(""ORBSLAM2 raw position: "" << xPosInit << "" y: "" << yPosInit << "" z: "" << zPosInit);



		/*/////////////////
		Manual Rotation
		////////////////////

		// Need to rotate the trajectory so that it is flat with the z-axis
		xPosInit = msg->pose.position.x;
		yPosInit = msg->pose.position.y;
		zPosInit = msg->pose.position.z;

		double cosTheta = cos(theta);
		double sinTheta = sin(theta);

		// Rotate about y-axis and shift to position of arm
		// Flip x and z as they are upside down, and offset by starting position of tf
		pose.pose.position.x = xOffset - (xPosInit * cosTheta + zPosInit * sinTheta);
		pose.pose.position.y = yOffset + (yPosInit);
		pose.pose.position.z = zOffset - (zPosInit * cosTheta - xPosInit * sinTheta);

	//	ROS_INFO_STREAM(""ORBSLAM2 Pose.pose.position.y = "" << pose.pose.position.y);

		using namespace boost::qvm;

		// Apply 180 degree rotation about y-axis
		quat<double> ORBSLAMquat = {msg->pose.orientation.w, msg->pose.orientation.x, msg->pose.orientation.y, msg->pose.orientation.z};

		// Rotation by 180 deg in y-axis (account for skew correction)
		quat<double> rotQuat = roty_quat(3.14159f + theta);

		// Rotate ORBSLAMquat by rotQuat
		quat<double> finalOrientQuat = boost::qvm::operator*(rotQuat, ORBSLAMquat);

		pose.pose.orientation.x = boost::qvm::X(finalOrientQuat);
		pose.pose.orientation.y = boost::qvm::Y(finalOrientQuat);
		pose.pose.orientation.z = boost::qvm::Z(finalOrientQuat);
		pose.pose.orientation.w = boost::qvm::S(finalOrientQuat);

		*/

		// Caclulate transform from ORBSLAM2 frame of reference (Origin at 0,0,0, rotation 0,0,0,1) to camera frame of reference

		//	pose.pose.orientation = msg->pose.orientation;

		// Debug: Print header of msg
		// ROS_INFO_STREAM(""\nReceived pose: "" << msg->header);
	
	}

	
	// path_ORBSLAM2.header = msg->header;
	path_ORBSLAM2.poses.push_back(pose); // Add new pose to path array

	// Debug - print path - does not work
	// ROS_INFO_STREAM(""\nPath: "" << path_ORBSLAM2.poses[0].pose);
	// n = n + 1;

	// Can publish directly to view in rviz or similar
	//	traj_pub.publish(path_ORBSLAM2);
	ORBSLAM2_traj_pub.publish(path_ORBSLAM2);

	// Write to complete bag
	fullBag.write(""/orb_slam2_rgbd/trajectory"", ros::Time::now(), path_ORBSLAM2);

}

void pose_arm_Callback(/*const sensor_msgs::ImageConstPtr& image,*/ const tf2_msgs::TFMessage::ConstPtr& msg){
//	ROS_INFO_STREAM(""Got tf\n""); // Debug line

// Verify pose received
	ROS_INFO_STREAM(""Received arm pose: "" << n_arm_pose);
	n_arm_pose++;

	geometry_msgs::TransformStamped single_tf;
	geometry_msgs::PoseStamped pose;

	// Get tf from last seen value
	single_tf = msg->transforms.back();

	// z cannot be 0 (in table), so break if blank data received
	if(single_tf.transform.translation.z == 0 && firstTF == 0){
		return;
	}

	// Only grab tf frames related to child frame ""tool0_controller""
	if(single_tf.child_frame_id == ""tool0_controller""){

	//	ROS_INFO_STREAM(""Got tf for tool0_controller\n""); // Debug line
		path_arm.header = single_tf.header;
		path_arm.header.frame_id = ""map""; // To match in line with ORBSLAM2 naming conventions

		pose.header = single_tf.header;
		pose.header.frame_id = ""map"";

		// Debug test - override quaternion rotation
//		Vector3f quatXYZ(0.7071068, 0, 0);
//		float quatW = 0.7071068;

		// Place orientation into quaternion
		boost::qvm::quat<double> armQuat = {single_tf.transform.rotation.w, single_tf.transform.rotation.x, single_tf.transform.rotation.y, single_tf.transform.rotation.z};

		// Convert camera offset to quaaternion with real part 0
		quat<double> camOffsetQuat = {0, A<0>(camOffset), A<1>(camOffset), A<2>(camOffset)};

		// Rotate about z-axis 45 deg
		quat<double> rotQuat = boost::qvm::rotz_quat(0.7854f);

		// Calculate pose rotation by p' = qp(q^-1) where q = armQuat and p = camOffsetQuat;

		// Rotate into end effector frame of reference first
		quat<double> camOffsetRotated =  boost::qvm::operator*(operator*(armQuat, camOffsetQuat), conjugate(armQuat));

			// But have to remember camera is tilted by 45 deg relative to axis of end effector - possible that we need to rotate by 45 deg around z-axis of end effector
		// Rotate about z-axis 45 degrees to reach camera angle
//		quat<double> camOrientOffsetFinal = operator*(operator*(rotQuat, camOffsetRotated), conjugate(rotQuat));

		// If 45 degree rotation is already accounted for:
		quat<double> camOrientOffsetFinal = camOffsetRotated;

		// Calculating each part separately
		//quat<double> camOffsetTemp = boost::qvm::operator*(armQuat, camOffsetQuat);
		// quat<double> camOffsetConj = conjugate(camOffsetQuat);
		// quat<double> camOffsetRotated = boost::qvm::operator*(camOffsetTemp, camOffsetConj);

//		camOffsetQuat = conjugate(armQuat);

//		ROS_INFO_STREAM(""\nBoost values: s= "" << S(camOffsetRotated) << ""\nx= "" << X(camOffsetRotated) << ""\ny= ""<< Y(camOffsetRotated) << ""\nz= ""<< Z(camOffsetRotated));

		// Eigen::Vector3f quatXYZ(single_tf.transform.rotation.x, single_tf.transform.rotation.y, single_tf.transform.rotation.z);
		// float quatW = single_tf.transform.rotation.w;

		// Calculate offset of camera, rotated according to the end effector
		// Rotated vector v' = 2 * dot(u,v) * u + (s^2 - dot(u,u)) * v + 2s (u x v) - where u = [q.x,q.y,q.z]
		// Eigen::Vector3f camOffsetRotatedEigen = 2.0f * (camOffset.dot(quatXYZ)) * quatXYZ 
		// 			+ (quatW * quatW - quatXYZ.dot(quatXYZ)) * camOffset 
		// 			+ 2.0f * quatW * quatXYZ.cross(camOffset);

		// ROS_INFO_STREAM(""\ncamOffsetRotated values: "" << camOffsetRotatedEigen);

		// Have to reassign translation/position as they are different formats
		pose.pose.position.x = single_tf.transform.translation.x + boost::qvm::X(camOrientOffsetFinal);
		pose.pose.position.y = single_tf.transform.translation.y + Y(camOrientOffsetFinal);
		pose.pose.position.z = single_tf.transform.translation.z + Z(camOrientOffsetFinal);

//		ROS_INFO_STREAM(""camOffsetRotated= x:"" << X(camOffsetRotated) << "", y:"" << Y(camOffsetRotated) << "", z:"" << Z(camOffsetRotated));

		// DEBUG: Override value
//		rotQuat = rotz_quat(0.0f);

		// Rotate about 45 degrees about the z-axis
		quat<double> finalOrientQuat = boost::qvm::operator*(armQuat, rotQuat);

		// Remember qvm::quat is in form {w, x, y, z}
		pose.pose.orientation.x = boost::qvm::X(finalOrientQuat);
		pose.pose.orientation.y = Y(finalOrientQuat);
		pose.pose.orientation.z = Z(finalOrientQuat);
		pose.pose.orientation.w = S(finalOrientQuat);

		// Get offsets if it is the first TF message
		if(firstTF == 0) {
			firstTF = 1;
			armTransOffset = {0, pose.pose.position.x, pose.pose.position.y, pose.pose.position.z};
			armOrientOffset = finalOrientQuat; // Use the camera pose rather than the end effector pose

			// Print starting offsets
			ROS_INFO_STREAM(""\n Offsets are: \n x:""<< X(armTransOffset) << ""\n y:"" << Y(armTransOffset) << ""\n z:"" << Z(armTransOffset));
		}

		path_arm.poses.push_back(pose); // Add new pose to path array

		arm_traj_pub.publish(path_arm); // Publish pose

		// Write to complete bag
		fullBag.write(""/tf/trajectory"", ros::Time::now(), path_arm);
		fullBag.write(""/visual_marker"", ros::Time::now(), markerArray);

	}
}

int main(int argc, char **argv)
{

	// Initialise ROS, and override SIGINT handler (what happens with ctrl+c) with my own code
	ros::init(argc, argv, ""ORBSLAM2_get_trajectory"", ros::init_options::NoSigintHandler);
	signal(SIGINT, mySigIntHandler);

	ros::NodeHandle traj_nh;

	// Retreive camera offset values from launch file
	float camOffsetX, camOffsetY, camOffsetZ;
	traj_nh.getParam(""camOffsetX"", camOffsetX);
	traj_nh.getParam(""camOffsetY"", camOffsetY);
	traj_nh.getParam(""camOffsetZ"", camOffsetZ);

	// Define if will capture ORBSLAM2 debug image
	bool captureImageFlag;
	traj_nh.getParam(""captureImageFlag"", captureImageFlag);

	// Get camera offset from input arguments, store into vector
	boost::qvm::A<0>(camOffset) = camOffsetX;
	A<1>(camOffset) = camOffsetY;
	A<2>(camOffset) = camOffsetZ;

	ROS_INFO_STREAM(""camOffset = "" << camOffsetX << "","" << camOffsetY << "","" << camOffsetZ);

	// QUATERNION TESTING
	// boost::qvm::quat<double> q12 = {1,3,4,3};
	// boost::qvm::quat<double> q23 = {4,3.9,-1,-3};

	// boost::qvm::quat<double> q34 = boost::qvm::operator*(q12, q23);

	// // Access x,y,z, scalar components of quaternion
	// ROS_INFO_STREAM(""quat: = "" << boost::qvm::X(q34) << "","" << boost::qvm::Y(q34) << "","" << boost::qvm::Z(q34) << "","" << boost::qvm::S(q34));

	// Define subscriber line to listen to pose from ORBSLAM2
	ros::Subscriber sub_ORBSLAM2_pose = traj_nh.subscribe(""/orb_slam2_rgbd/pose"", 10, pose_ORBSLAM2_Callback);

	// Define second subscriber for obtaining the tf from the arm
	ros::Subscriber sub_arm_pose = traj_nh.subscribe(""/tf"", 1, pose_arm_Callback);

	ros::Subscriber sub_pointcloud = traj_nh.subscribe(""/orb_slam2_rgbd/map_points"", 10, pointcloud_Callback);

	// Need to define subscriber here or it is deleted when exiting 'if' block
	ros::Subscriber  [MASK] ;
	if(captureImageFlag) {
		ROS_INFO_STREAM(""Will capture debug image."");
		 [MASK]  = traj_nh.subscribe(""/orb_slam2_rgbd/debug_image"", 10, debug_image_Callback);
	}


    // message_filters::Subscriber<sensor_msgs::Image> image_sub(traj_nh, ""/camera/rgb/image_raw"", 1);
    // message_filters::Subscriber<tf2_msgs::TFMessage> tf_sub(traj_nh, ""/tf"", 1);	
    // message_filters::TimeSynchronizer<sensor_msgs::Image, tf2_msgs::TFMessage> sync(image_sub, tf_sub, 10);

    // sync.registerCallback(boost::bind(&pose_arm_Callback, _1, _2));

	// Set up publishing line for path to be sent on
	arm_traj_pub = traj_nh.advertise<nav_msgs::Path>(""/tf/trajectory"", 1000);
	ORBSLAM2_traj_pub = traj_nh.advertise<nav_msgs::Path>(""/orb_slam2_rgbd/trajectory"", 1000);

	// Set up a marker to represent the target
	ros::Publisher markerPub = traj_nh.advertise<visualization_msgs::MarkerArray>(""/visual_marker"", 0);

	// Bag to write all the trajectory and pointcloud into
	fullBag.open(full_save_path, rosbag::bagmode::Write);


	// Define marker for model stand-in - DO NOT NEED ANYMORE AS CAN TRANSFORM POINTCLOUD
	// marker.header.frame_id = ""map"";
	// marker.header.stamp = ros::Time();
	// marker.ns = ""my_namespace"";
	// marker.id = 0;
	// marker.type = visualization_msgs::Marker::CUBE;
	// marker.action = visualization_msgs::Marker::ADD;
	// marker.pose.position.x = 0.4;
	// marker.pose.position.y = 0.05;
	// marker.pose.position.z = 0.1;
	// marker.pose.orientation.x = 0.0;
	// marker.pose.orientation.y = 0.0;
	// marker.pose.orientation.z = 0.0;
	// marker.pose.orientation.w = 1.0;
	// marker.scale.x = 0.2;
	// marker.scale.y = 0.2;
	// marker.scale.z = 0.2;
	// marker.color.a = 1.0; // Don't forget to set the alpha!
	// marker.color.r = 0.0;
	// marker.color.g = 1.0;
	// marker.color.b = 0.0;

//	markerArray.markers.push_back(marker);

	// Define marker for base of arm
	marker.header.frame_id = ""map"";
	marker.header.stamp = ros::Time();
	marker.ns = ""my_namespace"";
	marker.id = 1;
	marker.type = visualization_msgs::Marker::CYLINDER;
	marker.action = visualization_msgs::Marker::ADD;
	marker.pose.position.x = 0;
	marker.pose.position.y = 0;
	marker.pose.position.z = 0.15;
	marker.pose.orientation.x = 0.0;
	marker.pose.orientation.y = 0.0;
	marker.pose.orientation.z = 0.0;
	marker.pose.orientation.w = 1.0;
	marker.scale.x = 0.1;
	marker.scale.y = 0.1;
	marker.scale.z = 0.3;
	marker.color.a = 1.0; // Don't forget to set the alpha!
	marker.color.r = 0.6; // Colour grey
	marker.color.g = 0.6;
	marker.color.b = 0.6;

	markerArray.markers.push_back(marker);

	// Set publishing to run at 60Hz
	ros::Rate loop_rate(15);

	// Run the node until terminated
	while(!g_request_shutdown)
	{
		ros::spinOnce();
		markerPub.publish(markerArray);
		// Write markers to bag
		loop_rate.sleep();
	}

	// Manual shutdown after ctrl+c
	ros::shutdown();
}",sub_debug_image
708,"/**
 * @file audio_capture_node.cpp
 * @brief Audio Capture Node for ROS 2 using SDL2
 *
 * Copyright 2025 <Hoog-V / CLFML>
 *
 * 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 ""audio_capture_node.hpp""
#include <stdio.h>

AudioCaptureNode::AudioCaptureNode()
    : Node(""audio_capture_node""), _desired_rate(-1.0) {

  // Declare and get parameters
  this->declare_parameter<std::string>(""sample_format"", ""S16LE"");
  this->get_parameter(""sample_format"", _sample_format);

  this->declare_parameter<int>(""channels"", 1);
  this->declare_parameter<int>(""sample_rate"", 16000);
  this->get_parameter(""channels"", _channels);
  this->get_parameter(""sample_rate"", _sample_rate);

  if (_channels < 1 || _channels > 8) {
    RCLCPP_ERROR_STREAM(this->get_logger(),
                        ""Invalid channel count: "" << _channels);
    throw std::runtime_error(""Unsupported media type."");
  }

  this->declare_parameter<int>(""device"", -1);
  this->get_parameter(""device"", _device);

  this->declare_parameter<int>(""chunk_size"", 1024);
  int chunk_size;
  this->get_parameter(""chunk_size"", chunk_size);

  if (chunk_size < 512 || chunk_size > 4096) {
    RCLCPP_ERROR_STREAM(this->get_logger(),
                        ""Invalid chunk size: "" << chunk_size);
    throw std::runtime_error(""Unsupported chunk size!"");
  }

  if (!ConfigureSDLStream(_device, _sample_format, chunk_size, _channels)) {
    throw std::runtime_error(""Failed to configure SDL audio capture."");
  }

  // Publishers
  _pub = this->create_publisher<audio_tools::msg::AudioData>(""audio"", 10);
  auto info_qos = rclcpp::QoS(rclcpp::KeepLast(1)).transient_local();
  _pub_info = this->create_publisher<audio_tools::msg::AudioInfo>(""audio_info"",
                                                                  info_qos);

  _pub_stamped = this->create_publisher<audio_tools::msg::AudioDataStamped>(
      ""audio_stamped"", 10);

  _timer_info = rclcpp::create_timer(this, get_clock(), std::chrono::seconds(5),
                                     [this] { publishInfo(); });
  publishInfo();
}

void AudioCaptureNode::callback(uint8_t *stream, int len) {
  audio_tools::msg::AudioData msg;
  audio_tools::msg::AudioDataStamped stamped_msg;

  // Generate frame ID
  stamped_msg.header.frame_id = std::to_string(_audio_pos++);
  // Compute timestamp based on buffer size
  size_t buffer_size_total_nsec =
      (static_cast<size_t>(len) * 1e9) / (_sample_rate * _nbytes);

  _nano_sec += buffer_size_total_nsec;
  while (_nano_sec >= RCL_S_TO_NS(1)) {
    _sec++;
    _nano_sec -= RCL_S_TO_NS(1);
  }

  stamped_msg.header.stamp.sec = _sec;
  stamped_msg.header.stamp.nanosec = _nano_sec;

  // Copy audio data
  msg.data.assign(stream, stream + len);

  stamped_msg.audio = msg;
  stamped_msg.info = _info_msg;
  // Publish messages
  _pub->publish(msg);
  _pub_stamped->publish(stamped_msg);
}

void AudioCaptureNode::publishInfo() {
  _info_msg.channels = _channels;
  _info_msg.sample_rate = _sample_rate;
  _info_msg.sample_format = _sample_format;

  _pub_info->publish(_info_msg);
}

AudioCaptureNode::~AudioCaptureNode() {
  SDL_PauseAudioDevice(_dev_id_in, 1);
  SDL_CloseAudioDevice(_dev_id_in);
}

bool AudioCaptureNode::ConfigureSDLStream(int device, const std::string &format,
                                          int chunk_size, int channels) {
  SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);

  if (SDL_Init(SDL_INIT_AUDIO) < 0) {
    RCLCPP_ERROR(this->get_logger(), ""SDL initialization failed: %s"",
                 SDL_GetError());
    return false;
  }

  SDL_SetHintWithPriority(SDL_HINT_AUDIO_RESAMPLING_MODE, ""medium"",
                          SDL_HINT_OVERRIDE);

  int  [MASK]  = SDL_GetNumAudioDevices(SDL_TRUE);
  RCLCPP_INFO(this->get_logger(), ""%s: Found %d capture devices:\n"", __func__,
               [MASK] );

  for (int i = 0; i <  [MASK] ; i++) {
    RCLCPP_INFO(this->get_logger(), ""  - Capture device #%d: '%s'\n"", i,
                SDL_GetAudioDeviceName(i, SDL_TRUE));
  }

  SDL_zero(_capture_spec_requested);
  SDL_zero(_capture_spec_obtained);

  auto format_it = _format_map.find(format);
  if (format_it == _format_map.end()) {
    RCLCPP_ERROR(this->get_logger(), ""Unknown audio format: %s"",
                 format.c_str());
    return false;
  }
  _nbytes = format_it->second.second;

  _capture_spec_requested.freq = _sample_rate;
  _capture_spec_requested.format = format_it->second.first;
  _capture_spec_requested.channels = channels;
  _capture_spec_requested.samples = chunk_size;
  _capture_spec_requested.callback = [](void *userdata, uint8_t *stream,
                                        int len) {
    static_cast<AudioCaptureNode *>(userdata)->callback(stream, len);
  };
  _capture_spec_requested.userdata = this;

  if (device >= 0 && device <  [MASK] ) {
    RCLCPP_INFO(this->get_logger(),
                ""%s: Attempting to open capture device #%d: '%s'...\n"",
                __func__, device, SDL_GetAudioDeviceName(device, SDL_TRUE));

    _dev_id_in = SDL_OpenAudioDevice(SDL_GetAudioDeviceName(device, SDL_TRUE),
                                     SDL_TRUE, &_capture_spec_requested,
                                     &_capture_spec_obtained, 0);
  } else {
    RCLCPP_INFO(this->get_logger(),
                ""%s: Attempting to open default capture device...\n"", __func__);
    _dev_id_in =
        SDL_OpenAudioDevice(nullptr, SDL_TRUE, &_capture_spec_requested,
                            &_capture_spec_obtained, 0);
  }

  if (!_dev_id_in) {
    RCLCPP_INFO(this->get_logger(), ""%s: Failed to open audio device: %s\n"",
                __func__, SDL_GetError());
    return false;
  }

  RCLCPP_INFO(this->get_logger(), ""%s: Capture device opened (SDL Id = %d):\n"",
              __func__, _dev_id_in);
  RCLCPP_INFO(this->get_logger(), ""  - Sample rate: %d\n"",
              _capture_spec_obtained.freq);
  RCLCPP_INFO(this->get_logger(), ""  - Format: %d (Requested: %d)\n"",
              _capture_spec_obtained.format, _capture_spec_requested.format);
  RCLCPP_INFO(this->get_logger(), ""  - Channels: %d (Requested: %d)\n"",
              _capture_spec_obtained.channels,
              _capture_spec_requested.channels);
  RCLCPP_INFO(this->get_logger(), ""  - Samples per frame: %d\n"",
              _capture_spec_obtained.samples);

  _sample_rate = _capture_spec_obtained.freq;
  SDL_PauseAudioDevice(_dev_id_in, 0);
  return true;
}

int main(int argc, char *argv[]) {
  rclcpp::init(argc, argv);
  rclcpp::spin(std::make_shared<AudioCaptureNode>());
  rclcpp::shutdown();
  return 0;
}",nDevices
709,"
#include <iostream>
#include <limits>
#include <queue>
#include <vector>
using namespace std;

const long long INF = numeric_limits<int>::max();

int main() {
  long long N, M, X;
  cin >> N >> M >> X;

  vector<vector<long long>> A(N), B(N);

  for (long long i = 0; i < M; ++i) {
    long long u, v;
    cin >> u >> v;
    --u;
    --v;
    A[u].push_back(v);
    B[v].push_back(u);
  }

  vector<vector<long long>> G[2] = {A, B};
  vector<vector<long long>>  [MASK] (N, vector<long long>(2, INF));
   [MASK] [0][0] = 0;

  priority_queue<tuple<long long, long long, long long>,
                 vector<tuple<long long, long long, long long>>, greater<>>
      PQ;
  PQ.emplace(0, 0, 0);

  while (!PQ.empty()) {
    auto [cos, cur, mode] = PQ.top();
    PQ.pop();

    if ( [MASK] [cur][mode] < cos)
      continue;

    if ( [MASK] [cur][mode ^ 1] > cos + X) {
       [MASK] [cur][mode ^ 1] = cos + X;
      PQ.emplace(cos + X, cur, mode ^ 1);
    }

    for (long long nxt : G[mode][cur]) {
      if ( [MASK] [nxt][mode] > cos + 1) {
         [MASK] [nxt][mode] = cos + 1;
        PQ.emplace(cos + 1, nxt, mode);
      }
    }
  }

  cout << min( [MASK] [N - 1][0],  [MASK] [N - 1][1]) << endl;

  return 0;
}
",used
710,"// Copyright (C) <2018> Intel Corporation
//
// SPDX-License-Identifier: Apache-2.0
#include ""webrtc/rtc_base/criticalsection.h""
#include ""webrtc/rtc_base/logging.h""
#include ""webrtc/rtc_base/memory/aligned_malloc.h""
#include ""webrtc/rtc_base/thread.h""
#include ""webrtc/common_video/include/video_frame_buffer.h""
#include ""webrtc/system_wrappers/include/clock.h""
#include ""talk/owt/sdk/base/customizedframescapturer.h""
#include ""talk/owt/sdk/base/customizedencoderbufferhandle.h""
#include ""talk/owt/sdk/base/nativehandlebuffer.h""
using namespace rtc;
namespace owt {
namespace base {
///////////////////////////////////////////////////////////////////////
// Definition of private class CustomizedFramesThread that periodically
// generates frames.
///////////////////////////////////////////////////////////////////////
class CustomizedFramesCapturer::CustomizedFramesThread
    : public rtc::Thread,
      public rtc::MessageHandler {
 public:
  explicit CustomizedFramesThread(CustomizedFramesCapturer* capturer, int fps)
      : capturer_(capturer), finished_(false) {
    waiting_time_ms = 1000 / fps;
  }
  virtual ~CustomizedFramesThread() { Stop(); }
  // Override virtual method of parent Thread. Context: Worker Thread.
  virtual void Run() {
    // Read the first frame and start the message pump. The pump runs until
    // Stop() is called externally or Quit() is called by OnMessage().
    if (capturer_) {
      capturer_->ReadFrame();
      rtc::Thread::Current()->Post(RTC_FROM_HERE, this);
      rtc::Thread::Current()->ProcessMessages(kForever);
    }
    rtc::CritScope cs(&crit_);
    finished_ = true;
  }
  // Override virtual method of parent MessageHandler. Context: Worker Thread.
  virtual void OnMessage(rtc::Message* /*pmsg*/) {
    if (capturer_) {
      capturer_->ReadFrame();
      rtc::Thread::Current()->PostDelayed(RTC_FROM_HERE, waiting_time_ms, this);
    } else {
      rtc::Thread::Current()->Quit();
    }
  }
  // Check if Run() is finished.
  bool Finished() const {
    rtc::CritScope cs(&crit_);
    return finished_;
  }
 private:
  CustomizedFramesCapturer* capturer_;
  mutable rtc::CriticalSection crit_;
  bool finished_;
  int waiting_time_ms;
  RTC_DISALLOW_COPY_AND_ASSIGN(CustomizedFramesThread);
};
/////////////////////////////////////////////////////////////////////
// Implementation of class CustomizedFramesCapturer.
/////////////////////////////////////////////////////////////////////
const char* CustomizedFramesCapturer::kRawFrameDeviceName =
    ""CustomizedFramesGenerator"";
CustomizedFramesCapturer::CustomizedFramesCapturer(
    std::unique_ptr<VideoFrameGeneratorInterface> raw_frameGenerator)
    : frame_generator_(std::move(raw_frameGenerator)),
      encoder_(nullptr),
      frames_generator_thread(nullptr),
      width_(frame_generator_->GetWidth()),
      height_(frame_generator_->GetHeight()),
      fps_(frame_generator_->GetFps()),
      bitrate_kbps_(0),
      frame_type_(frame_generator_->GetType()),
      frame_buffer_capacity_(0),
      frame_buffer_(nullptr),
      async_invoker_(nullptr) {}
CustomizedFramesCapturer::CustomizedFramesCapturer(
    int width, int height, int fps, int bitrate_kbps, VideoEncoderInterface* encoder)
    : frame_generator_(nullptr),
      encoder_(encoder),
      frames_generator_thread(nullptr),
      width_(width),
      height_(height),
      fps_(fps),
      bitrate_kbps_(bitrate_kbps),
      frame_buffer_capacity_(0),
      frame_buffer_(nullptr),
      async_invoker_(nullptr) {}
CustomizedFramesCapturer::~CustomizedFramesCapturer() {
  Stop();
  frame_generator_.reset(nullptr);
  // encoder is created by app. And needs to be freed by
  // application. mark it to nullptr to avoid ReadFrame
  // passing native buffer to stack.
  encoder_ = nullptr;
}
void CustomizedFramesCapturer::Init() {
  // Only I420 frame is supported. Encoded frame is not supported here.
  cricket::VideoFormat format(width_, height_, cricket::VideoFormat::kMinimumInterval,
                     cricket::FOURCC_I420);
  std::vector<cricket::VideoFormat> supported;
  supported.push_back(format);
  SetSupportedFormats(supported);
}
cricket::CaptureState CustomizedFramesCapturer::Start(
    const cricket::VideoFormat& capture_format) {
  if (IsRunning()) {
    RTC_LOG(LS_ERROR) << ""Yuv Frame Generator is already running"";
    return CS_FAILED;
  }
  SetCaptureFormat(&capture_format);
  worker_thread_ = rtc::Thread::Current();
  RTC_DCHECK(!async_invoker_);
  async_invoker_.reset(new rtc::AsyncInvoker());
  // Create a thread to generate frames.
  frames_generator_thread = new CustomizedFramesThread(this, fps_);
  bool ret = frames_generator_thread->Start();
  if (ret) {
    RTC_LOG(LS_INFO) << ""Yuv Frame Generator started"";
    return CS_RUNNING;
  } else {
    async_invoker_.reset();
    worker_thread_ = nullptr;
    RTC_LOG(LS_ERROR) << ""Yuv Frame Generator failed to start"";
    return CS_FAILED;
  }
}
bool CustomizedFramesCapturer::IsRunning() {
  return frames_generator_thread && !frames_generator_thread->Finished();
}
void CustomizedFramesCapturer::Stop() {
  if (frames_generator_thread) {
    frames_generator_thread->Quit();
    delete frames_generator_thread;
    frames_generator_thread = nullptr;
    RTC_LOG(LS_INFO) << ""Yuv Frame Generator stopped"";
  }
  SetCaptureFormat(nullptr);
  worker_thread_ = nullptr;
  async_invoker_.reset();
}
bool CustomizedFramesCapturer::GetPreferredFourccs(
    std::vector<uint32_t>* fourccs) {
  if (!fourccs) {
    return false;
  }
  fourccs->push_back(GetSupportedFormats()->at(0).fourcc);
  return true;
}
int CustomizedFramesCapturer::I420DataSize(int height,
                                           int stride_y,
                                           int stride_u,
                                           int  [MASK] ) {
  return stride_y * height + (stride_u +  [MASK] ) * ((height + 1) / 2);
}
void CustomizedFramesCapturer::AdjustFrameBuffer(uint32_t size) {
  if (size > frame_buffer_capacity_ || !frame_buffer_) {
    RTC_LOG(LS_VERBOSE) << ""Allocate new memory for frame buffer."";
    width_ = frame_generator_->GetWidth();
    height_ = frame_generator_->GetHeight();
    int stride_y = width_;
    int stride_uv = (width_ + 1) / 2;
    frame_buffer_= webrtc::I420Buffer::Create(width_, height_, stride_y, stride_uv, stride_uv);
    frame_buffer_capacity_ =
        I420DataSize(height_, stride_y, stride_uv, stride_uv);
    if (frame_buffer_capacity_ < size) {
      RTC_LOG(LS_ERROR) << ""User provides invalid data size. Expected size: ""
                    << frame_buffer_capacity_ << "", user wants: "" << size;
    }
  }
}
// Executed in the context of CustomizedFramesThread.
void CustomizedFramesCapturer::ReadFrame() {
  // Signal the previously read frame to downstream in worker_thread.
  rtc::CritScope lock(&lock_);
  if (frame_generator_ != nullptr) {
    auto frame_size = frame_generator_->GetNextFrameSize();
    AdjustFrameBuffer(frame_size);
    if (frame_generator_->GenerateNextFrame(
            frame_buffer_->MutableDataY(), frame_buffer_capacity_) != frame_size) {
      RTC_DCHECK(false);
      RTC_LOG(LS_ERROR) << ""Failed to get video frame."";
      return;
    }
    webrtc::VideoFrame capture_frame(frame_buffer_, 0, rtc::TimeMillis(),
                                  webrtc::kVideoRotation_0);
    OnFrame(capture_frame, width_, height_);
  } else if (encoder_ != nullptr) { // video encoder interface used. Pass the encoder information.
    CustomizedEncoderBufferHandle* encoder_context = new CustomizedEncoderBufferHandle;
    encoder_context->encoder = encoder_;
    encoder_context->width = width_;
    encoder_context->height = height_;
    encoder_context->fps = fps_;
    encoder_context->bitrate_kbps = bitrate_kbps_;
    rtc::scoped_refptr<owt::base::EncodedFrameBuffer> buffer =
        new rtc::RefCountedObject<owt::base::EncodedFrameBuffer>(encoder_context);
    webrtc::VideoFrame pending_frame(buffer, 0, rtc::TimeMillis(),
                                    webrtc::kVideoRotation_0);
    OnFrame(pending_frame, width_, height_);
  }
}
}  // namespace base
}  // namespace owt
",stride_v
711,"/*
 * Mission.cpp
 *
 *  Created on: Jan 8, 2014
 *      Author: <NAME>
 */

#include <iostream>
#include <cstdio>
#include <string>

#include ""Mission.h""
#include ""Array3D.h""
#include ""Agent.h""

using std::cout;
using std::endl;
using std::string;

Mission::Mission() {
	h = NULL;
}

Mission::~Mission() {
	if(h != NULL) delete h;
}

void Mission::start(string agent, int32_t *data, int x, int y, int  [MASK] , int number_of_robots) {
	cout << ""C++ called from Python"" << endl;
	Point goal(x,y);

	Agent a = RANDOM;

	if(agent == ""random"") {
		a = RANDOM;
	} else if(agent == ""heuristic"") {
		a = HEURISTIC;
	} else {
		cout << ""Invalid agent, fallback to RANDOM"" << endl;
		a = RANDOM;
	}

	Array3D<int> * arr = new Array3D<int>( [MASK] , number_of_robots, 2, data);
	h = new Harvester(arr, a, goal);
	h->load();
	h->run();
}

int Mission::traveled() {
	return h->get_traveled();
}

double Mission::collected() {
	return h->get_collected();
}

",steps
712,"// Copyright 2018 Google LLC
//
// 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.

// From https://docs.python.org/3/c-api/intro.html:
// Since Python may define some pre-processor definitions which affect the
// standard headers on some systems, you must include Python.h before any
// standard headers are included.
#define PY_SSIZE_T_CLEAN
#include <Python.h>
// clang-format: do not reorder the above include.

#include ""python/riegeli/bytes/python_reader.h""
// clang-format: do not reorder the above include.

#include <stddef.h>

#include <cstring>
#include <limits>
#include <memory>
#include <string>

#include ""absl/base/optimization.h""
#include ""absl/status/status.h""
#include ""absl/strings/str_cat.h""
#include ""absl/strings/string_view.h""
#include ""absl/types/optional.h""
#include ""absl/types/span.h""
#include ""python/riegeli/base/utils.h""
#include ""riegeli/base/base.h""
#include ""riegeli/bytes/buffered_reader.h""

namespace riegeli {
namespace python {

PythonReader::PythonReader(PyObject* src, Options options)
    : BufferedReader(options.buffer_size()), owns_src_(options.owns_src()) {
  PythonLock::AssertHeld();
  Py_INCREF(src);
  src_.reset(src);
  if (options.assumed_pos() != absl::nullopt) {
    set_limit_pos(*options.assumed_pos());
  } else {
    static constexpr Identifier id_seekable(""seekable"");
    const PythonPtr seekable_result(
        PyObject_CallMethodObjArgs(src_.get(), id_seekable.get(), nullptr));
    if (ABSL_PREDICT_FALSE(seekable_result == nullptr)) {
      FailOperation(""seekable()"");
      return;
    }
    const int seekable_is_true = PyObject_IsTrue(seekable_result.get());
    if (ABSL_PREDICT_FALSE(seekable_is_true < 0)) return;
    if (seekable_is_true == 0) {
      // Random access is not supported. Assume 0 as the initial position.
      return;
    }
    static constexpr Identifier id_tell(""tell"");
    const PythonPtr tell_result(
        PyObject_CallMethodObjArgs(src_.get(), id_tell.get(), nullptr));
    if (ABSL_PREDICT_FALSE(tell_result == nullptr)) {
      FailOperation(""tell()"");
      return;
    }
    const absl::optional<Position> file_pos =
        PositionFromPython(tell_result.get());
    if (ABSL_PREDICT_FALSE(file_pos == absl::nullopt)) {
      FailOperation(""PositionFromPython() after tell()"");
      return;
    }
    set_limit_pos(*file_pos);
    supports_random_access_ = true;
  }
}

void PythonReader::Done() {
  BufferedReader::Done();
  if (owns_src_ && src_ != nullptr) {
    PythonLock lock;
    static constexpr Identifier id_close(""close"");
    const PythonPtr close_result(
        PyObject_CallMethodObjArgs(src_.get(), id_close.get(), nullptr));
    if (ABSL_PREDICT_FALSE(close_result == nullptr)) FailOperation(""close()"");
  }
}

bool PythonReader::FailOperation(absl::string_view operation) {
  RIEGELI_ASSERT(is_open())
      << ""Failed precondition of PythonReader::FailOperation(): ""
         ""Object closed"";
  PythonLock::AssertHeld();
  if (ABSL_PREDICT_FALSE(!healthy())) {
    // Ignore this error because `PythonReader` already failed.
    PyErr_Clear();
    return false;
  }
  exception_ = Exception::Fetch();
  return Fail(absl::UnknownError(
      absl::StrCat(operation, "" failed: "", exception_.message())));
}

bool PythonReader::ReadInternal(size_t min_length, size_t max_length,
                                char* dest) {
  RIEGELI_ASSERT_GT(min_length, 0u)
      << ""Failed precondition of BufferedReader::ReadInternal(): ""
         ""nothing to read"";
  RIEGELI_ASSERT_GE(max_length, min_length)
      << ""Failed precondition of BufferedReader::ReadInternal(): ""
         ""max_length < min_length"";
  RIEGELI_ASSERT(healthy())
      << ""Failed precondition of BufferedReader::ReadInternal(): "" << status();
  if (ABSL_PREDICT_FALSE(max_length >
                         std::numeric_limits<Position>::max() - limit_pos())) {
    return FailOverflow();
  }
  PythonLock lock;
  // Find a read function to use, preferring in order: `readinto1()`,
  // `readinto()`, `read1()`, `read()`.
  if (ABSL_PREDICT_FALSE(read_function_ == nullptr)) {
    static constexpr Identifier id_readinto1(""readinto1"");
    read_function_.reset(PyObject_GetAttr(src_.get(), id_readinto1.get()));
    read_function_name_ = ""readinto1()"";
    if (read_function_ == nullptr) {
      if (ABSL_PREDICT_FALSE(!PyErr_ExceptionMatches(PyExc_AttributeError))) {
        return FailOperation(read_function_name_);
      }
      PyErr_Clear();
      static constexpr Identifier id_readinto(""readinto"");
      read_function_.reset(PyObject_GetAttr(src_.get(), id_readinto.get()));
      read_function_name_ = ""readinto()"";
      if (read_function_ == nullptr) {
        if (ABSL_PREDICT_FALSE(!PyErr_ExceptionMatches(PyExc_AttributeError))) {
          return FailOperation(read_function_name_);
        }
        PyErr_Clear();
        use_bytes_ = true;
        static constexpr Identifier id_read1(""read1"");
        read_function_.reset(PyObject_GetAttr(src_.get(), id_read1.get()));
        read_function_name_ = ""read1()"";
        if (read_function_ == nullptr) {
          if (ABSL_PREDICT_FALSE(
                  !PyErr_ExceptionMatches(PyExc_AttributeError))) {
            return FailOperation(read_function_name_);
          }
          PyErr_Clear();
          static constexpr Identifier id_read(""read"");
          read_function_.reset(PyObject_GetAttr(src_.get(), id_read.get()));
          read_function_name_ = ""read()"";
          if (ABSL_PREDICT_FALSE(read_function_ == nullptr)) {
            return FailOperation(read_function_name_);
          }
        }
      }
    }
  }
  for (;;) {
    const size_t length_to_read =
        UnsignedMin(max_length, size_t{std::numeric_limits<Py_ssize_t>::max()});
    size_t length_read;
    if (!use_bytes_) {
      PythonPtr read_result;
      {
        // Prefer using `readinto1()` or `readinto()` to avoid copying memory.
        MemoryView memory_view;
        PyObject* const memory_view_object =
            memory_view.MutableToPython(absl::MakeSpan(dest, length_to_read));
        if (ABSL_PREDICT_FALSE(memory_view_object == nullptr)) {
          return FailOperation(""MemoryView::MutableToPython()"");
        }
        read_result.reset(PyObject_CallFunctionObjArgs(
            read_function_.get(), memory_view_object, nullptr));
        if (ABSL_PREDICT_FALSE(read_result == nullptr)) {
          return FailOperation(read_function_name_);
        }
        if (ABSL_PREDICT_FALSE(!memory_view.Release())) {
          return FailOperation(""MemoryView::Release()"");
        }
      }
      const absl::optional<size_t> length_read_opt =
          SizeFromPython(read_result.get());
      if (ABSL_PREDICT_FALSE(length_read_opt == absl::nullopt)) {
        return FailOperation(
            absl::StrCat(""SizeFromPython() after "", read_function_name_));
      }
      length_read = *length_read_opt;
      if (ABSL_PREDICT_FALSE(length_read == 0)) return false;
      if (ABSL_PREDICT_FALSE(length_read > max_length)) {
        return Fail(absl::InternalError(
            absl::StrCat(read_function_name_, "" read more than requested"")));
      }
    } else {
      const PythonPtr length(SizeToPython(length_to_read));
      if (ABSL_PREDICT_FALSE(length == nullptr)) {
        return FailOperation(""SizeToPython()"");
      }
      const PythonPtr read_result(PyObject_CallFunctionObjArgs(
          read_function_.get(), length.get(), nullptr));
      if (ABSL_PREDICT_FALSE(read_result == nullptr)) {
        return FailOperation(read_function_name_);
      }
      Py_buffer buffer;
      if (ABSL_PREDICT_FALSE(PyObject_GetBuffer(read_result.get(), &buffer,
                                                PyBUF_CONTIG_RO) < 0)) {
        return FailOperation(
            absl::StrCat(""PyObject_GetBuffer() after "", read_function_name_));
      }
      if (ABSL_PREDICT_FALSE(buffer.len == 0)) {
        PyBuffer_Release(&buffer);
        return false;
      }
      if (ABSL_PREDICT_FALSE(IntCast<size_t>(buffer.len) > max_length)) {
        PyBuffer_Release(&buffer);
        return Fail(absl::InternalError(
            absl::StrCat(read_function_name_, "" read more than requested"")));
      }
      std::memcpy(dest, buffer.buf, IntCast<size_t>(buffer.len));
      length_read = IntCast<size_t>(buffer.len);
      PyBuffer_Release(&buffer);
    }
    move_limit_pos(length_read);
    if (length_read >= min_length) return true;
    dest += length_read;
    min_length -= length_read;
    max_length -= length_read;
  }
}

bool PythonReader::SeekBehindBuffer(Position new_pos) {
  RIEGELI_ASSERT(new_pos < start_pos() || new_pos > limit_pos())
      << ""Failed precondition of BufferedReader::SeekBehindBuffer(): ""
         ""position in the buffer, use Seek() instead"";
  RIEGELI_ASSERT_EQ(start_to_limit(), 0u)
      << ""Failed precondition of BufferedReader::SeekBehindBuffer(): ""
         ""buffer not empty"";
  if (ABSL_PREDICT_FALSE(!healthy())) return false;
  if (ABSL_PREDICT_FALSE(!supports_random_access_)) {
    return BufferedReader::SeekBehindBuffer(new_pos);
  }
  PythonLock lock;
  if (new_pos > limit_pos()) {
    // Seeking forwards.
    const absl::optional<Position> size = SizeInternal();
    if (ABSL_PREDICT_FALSE(size == absl::nullopt)) return false;
    if (ABSL_PREDICT_FALSE(new_pos > *size)) {
      // File ends.
      set_limit_pos(*size);
      return false;
    }
  }
  set_limit_pos(new_pos);
  const PythonPtr file_pos = PositionToPython(limit_pos());
  if (ABSL_PREDICT_FALSE(file_pos == nullptr)) {
    return FailOperation(""PositionToPython()"");
  }
  static constexpr Identifier id_seek(""seek"");
  const PythonPtr seek_result(PyObject_CallMethodObjArgs(
      src_.get(), id_seek.get(), file_pos.get(), nullptr));
  if (ABSL_PREDICT_FALSE(seek_result == nullptr)) {
    return FailOperation(""seek()"");
  }
  return true;
}

inline absl::optional<Position> PythonReader::SizeInternal() {
  RIEGELI_ASSERT(healthy())
      << ""Failed precondition of PythonReader::SizeInternal(): "" << status();
  RIEGELI_ASSERT(supports_random_access_)
      << ""Failed precondition of PythonReader::SizeInternal(): ""
         ""random access not supported"";
  PythonLock::AssertHeld();
  absl::string_view operation;
  const PythonPtr file_pos = PositionToPython(0);
  if (ABSL_PREDICT_FALSE(file_pos == nullptr)) {
    FailOperation(""PositionToPython()"");
    return absl::nullopt;
  }
  const PythonPtr  [MASK]  = IntToPython(2);  // `io.SEEK_END`
  if (ABSL_PREDICT_FALSE( [MASK]  == nullptr)) {
    FailOperation(""IntToPython()"");
    return absl::nullopt;
  }
  static constexpr Identifier id_seek(""seek"");
  PythonPtr result(PyObject_CallMethodObjArgs(
      src_.get(), id_seek.get(), file_pos.get(),  [MASK] .get(), nullptr));
  if (result.get() == Py_None) {
    // Python2 `file.seek()` returns `None`, so `tell()` is needed to get the
    // new position. Python2 is dead, but some classes still behave like that.
    static constexpr Identifier id_tell(""tell"");
    result.reset(
        PyObject_CallMethodObjArgs(src_.get(), id_tell.get(), nullptr));
    operation = ""tell()"";
  } else {
    // `io.IOBase.seek()` returns the new position.
    operation = ""seek()"";
  }
  if (ABSL_PREDICT_FALSE(result == nullptr)) {
    FailOperation(operation);
    return absl::nullopt;
  }
  const absl::optional<Position> size = PositionFromPython(result.get());
  if (ABSL_PREDICT_FALSE(size == absl::nullopt)) {
    FailOperation(absl::StrCat(""PositionFromPython() after "", operation));
    return absl::nullopt;
  }
  return *size;
}

absl::optional<Position> PythonReader::SizeImpl() {
  if (ABSL_PREDICT_FALSE(!healthy())) return absl::nullopt;
  if (ABSL_PREDICT_FALSE(!supports_random_access_)) {
    Fail(absl::UnimplementedError(""PythonReader::Size() not supported""));
    return absl::nullopt;
  }
  PythonLock lock;
  const absl::optional<Position> size = SizeInternal();
  if (ABSL_PREDICT_FALSE(size == absl::nullopt)) return absl::nullopt;
  const PythonPtr file_pos = PositionToPython(limit_pos());
  if (ABSL_PREDICT_FALSE(file_pos == nullptr)) {
    FailOperation(""PositionToPython()"");
    return absl::nullopt;
  }
  static constexpr Identifier id_seek(""seek"");
  const PythonPtr seek_result(PyObject_CallMethodObjArgs(
      src_.get(), id_seek.get(), file_pos.get(), nullptr));
  if (ABSL_PREDICT_FALSE(seek_result == nullptr)) {
    FailOperation(""seek()"");
    return absl::nullopt;
  }
  return *size;
}

}  // namespace python
}  // namespace riegeli
",whence
713,"#include ""ImageEffects.h""

PpmDocument removeRed(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		editedPixelData[i].setRed(0);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument removeBlue(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		editedPixelData[i].setBlue(0);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument removeGreen(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		editedPixelData[i].setGreen(0);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument negateRed(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		int currentRed = editedPixelData[i].getRed();
		editedPixelData[i].setRed(255 - currentRed);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument negateBlue(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		int currentBlue = editedPixelData[i].getBlue();
		editedPixelData[i].setBlue(255 - currentBlue);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument negateGreen(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		int currentGreen = editedPixelData[i].getGreen();
		editedPixelData[i].setGreen(255 - currentGreen);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument toGreyscale(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		int currentRed = editedPixelData[i].getRed();
		int currentGreen = editedPixelData[i].getGreen();
		int currentBlue = editedPixelData[i].getBlue();

		int rgbAverage = (currentRed + currentGreen + currentBlue) / 3;
		editedPixelData[i].setRGB(rgbAverage, rgbAverage, rgbAverage);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument addNoise(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();
	int noiseValue = 0;

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		noiseValue = ((rand() % 21) - 10);

		int currentRed = editedPixelData[i].getRed();
		currentRed += noiseValue;
		if (currentRed < 0) {
			currentRed = 0;
		}
		else if (currentRed > 255) {
			currentRed = 255;
		}
		editedPixelData[i].setRed(currentRed);

		int currentGreen = editedPixelData[i].getGreen();
		currentGreen += noiseValue;
		if (currentGreen < 0) {
			currentGreen = 0;
		}
		else if (currentGreen > 255) {
			currentGreen = 255;
		}
		editedPixelData[i].setGreen(currentGreen);

		int currentBlue = editedPixelData[i].getBlue();
		currentBlue += noiseValue;
		if (currentBlue < 0) {
			currentBlue = 0;
		}
		else if (currentBlue > 255) {
			currentBlue = 255;
		}
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument highContrast(PpmDocument& project)
{
	vector<Pixel> editedPixelData = project.getPixelData();

	for (int i = 0; i < project.getPixelCount(); i++)
	{
		int currentRed = editedPixelData[i].getRed();
		if (currentRed > 127) {
			currentRed = 255;
		} else {
			currentRed = 0;
		}

		int currentGreen = editedPixelData[i].getGreen();
		if (currentGreen > 127) {
			currentGreen = 255;
		} else {
			currentGreen = 0;
		}

		int currentBlue = editedPixelData[i].getBlue();
		if (currentBlue > 127) {
			currentBlue = 255;
		} else {
			currentBlue = 0;
		}

		editedPixelData[i].setRGB(currentRed, currentGreen, currentBlue);
	}

	project.setPixelData(editedPixelData);

	return project;
}

PpmDocument flipHorizontal(PpmDocument& project) {
	vector<vector<Pixel>> dataYX;
	vector<Pixel> dataRaw = project.getPixelData();
	Pixel temp;
	Pixel temp2;
	vector<Pixel> dataRawNew;
	dataRawNew.resize(dataRaw.size());
	int ticker = 0;

	dataYX.resize(project.getHeight());

	for (int i = 0; i < dataYX.size(); i++)
	{
		dataYX[i].resize(project.getWidth());
	}

	for (int j = 0; j < dataYX.size(); j++)
	{
		for (int k = 0; k < dataYX[j].size(); k++)
		{
			dataYX[j][k] = dataRaw[ticker];
			ticker++;
		}
	}

	for (int l = 0; l < dataYX.size(); l++)
	{
		for (int m = 0; m < (dataYX[l].size() / 2); m++)
		{
			int widthTemp = project.getWidth() - 1 - m;
			temp = dataYX[l][m];
			temp2 = dataYX[l][widthTemp];
			dataYX[l][m] = temp2;
			dataYX[l][widthTemp] = temp;
		}
	}

	int newTicker = 0;

	for (int n = 0; n < dataYX.size(); n++)
	{
		for (int o = 0; o < dataYX[n].size(); o++)
		{
			dataRawNew[newTicker] = dataYX[n][o];
			newTicker++;
		}
	}

	project.setPixelData(dataRawNew);
	return project;
}	

PpmDocument flipVertical(PpmDocument& project) {
	vector<vector<Pixel>> dataYX;
	vector<Pixel> dataRaw = project.getPixelData();
	Pixel temp;
	Pixel temp2;
	vector<Pixel> dataRawNew;
	dataRawNew.resize(dataRaw.size());
	int ticker = 0;

	dataYX.resize(project.getHeight());

	for (int i = 0; i < dataYX.size(); i++)
	{
		dataYX[i].resize(project.getWidth());
	}

	for (int j = 0; j < dataYX.size(); j++)
	{
		for (int k = 0; k < dataYX[j].size(); k++)
		{
			dataYX[j][k] = dataRaw[ticker];
			ticker++;
		}
	}

	for (int l = 0; l < dataYX[0].size(); l++)
	{
		for (int m = 0; m < (dataYX.size() / 2); m++)
		{
			int heightTemp = project.getHeight() - 1 - m;
			temp = dataYX[m][l];
			temp2 = dataYX[heightTemp][l];
			dataYX[m][l] = temp2;
			dataYX[heightTemp][l] = temp;
		}
	}

	int newTicker = 0;

	for (int n = 0; n < dataYX.size(); n++)
	{
		for (int o = 0; o < dataYX[n].size(); o++)
		{
			dataRawNew[newTicker] = dataYX[n][o];
			newTicker++;
		}
	}

	project.setPixelData(dataRawNew);
	return project;
}

PpmDocument rotateNinety(PpmDocument& project) {
	vector<vector<Pixel>> dataYX;
	vector<vector<Pixel>>  [MASK] ;
	vector<Pixel> dataRaw = project.getPixelData();
	vector<Pixel> dataRawNew;
	dataRawNew.resize(dataRaw.size());
	int ticker = 0;
	int newTicker = 0;
	int x = 0;

	dataYX.resize(project.getHeight());
	 [MASK] .resize(dataYX.size());

for (int i = 0; i < dataYX.size(); i++)
{
	dataYX[i].resize(project.getWidth());
	 [MASK] [i].resize(dataYX.size());
}

for (int j = 0; j < dataYX.size(); j++)
{
	for (int k = 0; k < dataYX[j].size(); k++)
	{
		dataYX[j][k] = dataRaw[ticker];
		ticker++;
	}
}

for (int m = project.getWidth() - 1; m >= 0; m--)
{
	for (int l = 0; l < project.getHeight(); l++)
	{
		 [MASK] [x][l] = dataYX[l][m];
	}
	x++;
}

for (int n = 0; n <  [MASK] .size(); n++)
{
	for (int o = 0; o <  [MASK] [n].size(); o++)
	{
		dataRawNew[newTicker] =  [MASK] [n][o];
		newTicker++;
	}
}

project.setPixelData(dataRawNew);
return project;
}

PpmDocument blurImage(PpmDocument& project) {
	vector<vector<Pixel>> dataYX;
	vector<vector<Pixel>> dataYX_blur;
	vector<Pixel> dataRaw = project.getPixelData();
	vector<Pixel> dataRawNew;
	dataRawNew.resize(dataRaw.size());
	int ticker = 0;
	int newTicker = 0;
	int tempRed = 0;
	int tempGreen = 0;
	int tempBlue = 0;
	int imgWidth = 0;
	int imgHeight = 0;

	dataYX.resize(project.getHeight());
	dataYX_blur.resize(dataYX.size());

	for (int i = 0; i < dataYX.size(); i++)
	{
		dataYX[i].resize(project.getWidth());
		dataYX_blur[i].resize(dataYX.size());
	}

	for (int j = 0; j < dataYX.size(); j++)
	{
		for (int k = 0; k < dataYX[j].size(); k++)
		{
			dataYX[j][k] = dataRaw[ticker];
			ticker++;
		}
	}

	imgHeight = dataYX.size() - 1;
	imgWidth = dataYX[0].size() - 1;

	for (int irow = 0; irow < imgHeight; irow++)
	{
		for (int icol = 0; icol < imgWidth; icol++)
		{
			if (irow == 0 && icol == 0)
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow + 1][icol].getRed()
					+ dataYX[irow][icol + 1].getRed()) / 3;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow + 1][icol].getGreen()
					+ dataYX[irow][icol + 1].getGreen()) / 3;
				tempBlue - (dataYX[irow][icol].getBlue() + dataYX[irow + 1][icol].getBlue()
					+ dataYX[irow][icol + 1].getBlue()) / 3;
			}
			else if (irow == 0 && icol != 0 && icol != imgWidth)
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow + 1][icol].getRed()
					+ dataYX[irow][icol - 1].getRed() + dataYX[irow][icol].getRed()) / 4;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow + 1][icol].getGreen()
					+ dataYX[irow][icol - 1].getGreen() + dataYX[irow][icol + 1].getGreen()) / 4;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow + 1][icol].getBlue()
					+ dataYX[irow][icol - 1].getBlue() + dataYX[irow][icol + 1].getBlue()) / 4;
			}
			else if (icol == 0 && irow != 0 && irow != imgHeight)
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow][icol + 1].getRed()
					+ dataYX[irow - 1][icol].getRed() + dataYX[irow + 1][icol].getRed()) / 4;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow][icol + 1].getGreen()
					+ dataYX[irow - 1][icol].getGreen() + dataYX[irow + 1][icol].getGreen()) / 4;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow][icol + 1].getBlue()
					+ dataYX[irow - 1][icol].getBlue() + dataYX[irow + 1][icol].getBlue()) / 4;
			}
			else if (irow == 0 && icol == imgWidth)
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow + 1][icol].getRed()
					+ dataYX[irow][icol - 1].getRed()) / 3;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow + 1][icol].getGreen()
					+ dataYX[irow][icol - 1].getGreen()) / 3;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow + 1][icol].getBlue()
					+ dataYX[irow][icol - 1].getBlue()) / 3;
			}
			else if (icol == 0 && irow == imgHeight)
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow - 1][icol].getRed()
					+ dataYX[irow][icol + 1].getRed()) / 3;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow - 1][icol].getGreen()
					+ dataYX[irow][icol + 1].getGreen()) / 3;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow - 1][icol].getBlue()
					+ dataYX[irow][icol + 1].getBlue()) / 3;
			}
			else if (icol == imgHeight && irow == imgWidth)
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow - 1][icol].getRed()
					+ dataYX[irow][icol - 1].getRed()) / 3;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow - 1][icol].getGreen()
					+ dataYX[irow][icol - 1].getGreen()) / 3;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow - 1][icol].getBlue()
					+ dataYX[irow][icol - 1].getBlue()) / 3;
			}
			else if ((irow == imgHeight) && (icol != 0) && (icol != imgWidth))
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow - 1][icol].getRed()
					+ dataYX[irow][icol + 1].getRed() + dataYX[irow][icol - 1].getRed()) / 4;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow - 1][icol].getGreen()
					+ dataYX[irow][icol + 1].getGreen() + dataYX[irow][icol - 1].getGreen()) / 4;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow - 1][icol].getBlue()
					+ dataYX[irow][icol + 1].getBlue() + dataYX[irow][icol - 1].getBlue()) / 4;
			}
			else if ((icol == imgWidth) && (irow != 0) && (irow != imgHeight))
			{
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow][icol - 1].getRed()
					+ dataYX[irow + 1][icol].getRed() + dataYX[irow - 1][icol].getRed()) / 4;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow][icol - 1].getGreen()
					+ dataYX[irow + 1][icol].getGreen() + dataYX[irow - 1][icol].getGreen()) / 4;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow][icol - 1].getBlue()
					+ dataYX[irow + 1][icol].getBlue() + dataYX[irow][icol - 1].getBlue()) / 4;
			}
			else {
				tempRed = (dataYX[irow][icol].getRed() + dataYX[irow - 1][icol].getRed()
					+ dataYX[irow][icol - 1].getRed() + dataYX[irow + 1][icol].getRed()
					+ dataYX[irow][icol + 1].getRed()) / 5;
				tempGreen = (dataYX[irow][icol].getGreen() + dataYX[irow - 1][icol].getGreen()
					+ dataYX[irow][icol - 1].getGreen() + dataYX[irow + 1][icol].getGreen()
					+ dataYX[irow][icol + 1].getGreen()) / 5;
				tempBlue = (dataYX[irow][icol].getBlue() + dataYX[irow - 1][icol].getBlue()
					+ dataYX[irow][icol - 1].getBlue() + dataYX[irow + 1][icol].getBlue()
					+ dataYX[irow][icol + 1].getBlue()) / 5;
			}
			dataYX_blur[irow][icol].setRGB(tempRed, tempGreen, tempBlue);
		}
	}

	for (int n = 0; n < dataYX_blur.size(); n++)
	{
		for (int o = 0; o < dataYX_blur[n].size(); o++)
		{
			dataRawNew[newTicker] = dataYX_blur[n][o];
			newTicker++;
		}
	}

	project.setPixelData(dataRawNew);
	return project;
}

PpmDocument pixelateImage(PpmDocument& project) {
	vector<vector<Pixel>> dataYX;
	vector<Pixel> dataRaw = project.getPixelData();
	int ticker = 0;
	int newTicker = 0;
	int x = 0;
	int pixelDiv = 3;

	dataYX.resize(project.getHeight());

	for (int i = 0; i < dataYX.size(); i++)
	{
		dataYX[i].resize(project.getWidth());
	}

	for (int j = 0; j < dataYX.size(); j++)
	{
		for (int k = 0; k < dataYX[j].size(); k++)
		{
			dataYX[j][k] = dataRaw[ticker];
			ticker++;
		}
	}

	//Find a clean divisor for pixelation

	while (dataYX.size() % pixelDiv != 0)
	{
		pixelDiv++;
	}

	//Pixelate
	
	for (int l = 0; l < dataYX.size(); l += pixelDiv)
	{
		for (int m = 0; m < dataYX[l].size(); m += pixelDiv)
		{
			for (int z = 0; z < pixelDiv; z++)
			{
				for (int x = 0; x < pixelDiv; x++)
				{
					if ((l + z) > dataYX.size() || (m + x) > dataYX[l].size())
					{
						break;
					}
					else {
						dataYX[l + z][m + x].setRGB(dataYX[l][m].getRed(), dataYX[l][m].getGreen(), dataYX[l][m].getBlue());
					}
				}
			}
		}
	}
	
	for (int n = 0; n < dataYX.size(); n++)
	{
		for (int o = 0; o < dataYX[n].size(); o++)
		{
			dataRaw[newTicker] = dataYX[n][o];
			newTicker++;
		}
	}

	project.setPixelData(dataRaw);
	return project;
}",dataYX_rotated
714,"#include <bits/stdc++.h>
using namespace std;
int n, Q, k, x, v, loc, m;
int a[8000];
int b[8000];
int c[200000];

void swap(int *x, int *y)
{
	int tmp;
	tmp = *x;
	*x = *y;
	*y = tmp;
}
void pop_sort(int start, int end)
{
	if (start >= end - 1) {
		return;
	}
	for (int i = start; i < end - 1; i++) {
		if (b[i] > b[i + 1]) {
			swap(&b[i], &b[i + 1]);
		}
	}
}

void down_sort(int start, int end)
{
	if (start >= end - 1) {
		return;
	}
	for (int i = end - 1; i > start; i--) {
		if (b[i] < b[i - 1]) {
			swap(&b[i], &b[i - 1]);
		}
	}
}

int binary_search(int l, int r, int x) {
	int R = r + 1;
	int  [MASK]  = 0;
	while (R - l >= 1) {
		 [MASK]  = (l + R) / 2;
		if (b[ [MASK] ] == x) {
			return  [MASK] ;
		}
		else if (b[ [MASK] ] < x) {
			l =  [MASK]  + 1;
		}
		else {
			R =  [MASK] ;
		}			
	}
	return -1;
}

int main()
{
	//freopen(""sort.in"", ""r"", stdin);
	//freopen(""sort.out"", ""w"", stdout);
	//fclose (stdin);
	//fclose (stdout); 
	scanf(""%d%d"", &n, &Q);
	int q = 0;
	for (int i = 0; i < n; i++) {
		scanf(""%d"", &a[i]);
		b[i] = a[i];
	}
	sort(b, b + n);

	for (int i = 0; i < Q; i++) {
		scanf(""%d"", &k);
		if (k == 1) {
			scanf(""%d%d"", &x, &v);
			a[x - 1] = v;
			for (int t = 0; t < n; t++) {
				b[t] = a[t];
			}
//			sort(b, b + n);
#if 1
			down_sort(0, x);
			if (x < n) {
				pop_sort(x - 1, n);
			}
#endif
		}
		else {
			scanf(""%d"", &x);
			int val = a[x - 1];
			loc = 0;
			for (int j = 0; j < x - 1; j++) {				
				if (a[j] == val) {
					loc++;
				}				
			}
			m = binary_search(0, n - 1, val);
			for (int t = 0; t < n; t++) {
				if (m == 0) {
					break;
				}
				if (b[m - 1] == val) {
					m--;
				}
				else {
					break;
				}
			}
			c[q] = m + loc + 1;
			q++;
		}
	}
	for (int i = 0; i < q; i++) {
		printf(""%d\n"", c[i]);
	}
	return 0;
}
",mid
715,"extern ""C"" {
#include <base/log.h>
#include <net/ip.h>
}
#undef min
#undef max

#include ""thread.h""
#include ""sync.h""
#include ""timer.h""
#include ""net.h""
#include ""fake_worker.h""

#include <iostream>
#include <iomanip>
#include <utility>
#include <memory>
#include <chrono>
#include <vector>
#include <algorithm>
#include <numeric>
#include <random>
#include <utility>

namespace {

constexpr uint64_t kNetbenchPort = 8001;

struct payload {
  uint64_t work_iterations;
  uint64_t index;
};

using namespace std::chrono;
using sec = duration<double, std::micro>;

// The maximum lateness to tolerate before dropping egress samples.
constexpr uint64_t kMaxCatchUpUS = 5;

// the number of worker threads to spawn.
int threads;
// the remote UDP address of the server.
netaddr raddr;
// the mean service time in us.
double st;
// number of iterations required for 1us on target server
int iterations_per_us = 83;

// Number of seconds to warmup at rate 0
constexpr uint64_t kWarmupUpSeconds = 5;

static std::vector<std::pair<double, uint64_t>> rates;

void ServerWorker(std::unique_ptr<rt::TcpConn> c) {
  payload p;
  std::unique_ptr<FakeWorker> w(FakeWorkerFactory(""stridedmem:3200:64""));
  if (w == nullptr) panic(""couldn't create worker"");

  while (true) {
    // Receive a network response.
    ssize_t ret = c->ReadFull(&p, sizeof(p));
    if (ret <= 0 || ret > static_cast<ssize_t>(sizeof(p))) {
      if (ret == 0 || ret == -ECONNRESET) break;
      panic(""read failed, ret = %ld"", ret);
    }

    // Perform fake work if requested.
    uint64_t workn = ntoh64(p.work_iterations);
    if (workn != 0) w->Work(workn); //82.0

    // Send a network request.
    ssize_t sret = c->WriteFull(&p, ret);
    if (sret != ret) {
      if (sret == -EPIPE || sret == -ECONNRESET) break;
      panic(""write failed, ret = %ld"", sret);
    }
  }
}

void ServerHandler(void *arg) {
  std::unique_ptr<rt::TcpQueue> q(rt::TcpQueue::Listen({0, kNetbenchPort},
				  4096));
  if (q == nullptr) panic(""couldn't listen for connections"");

  while (true) {
    rt::TcpConn *c = q->Accept();
    if (c == nullptr) panic(""couldn't accept a connection"");
    rt::Thread([=]{ServerWorker(std::unique_ptr<rt::TcpConn>(c));}).Detach();
  }
}

struct work_unit {
  double start_us, work_us, duration_us;
};

template <class Arrival, class Service>
std::vector<work_unit> GenerateWork(Arrival a, Service s, double cur_us, double last_us) {
  std::vector<work_unit> w;
  while (cur_us < last_us) {
    cur_us += a();
    w.emplace_back(work_unit{cur_us, s(), 0});
  }
  return w;
}

std::vector<work_unit>
ClientWorker(rt::TcpConn *c, rt::WaitGroup *starter,
             std::function<std::vector<work_unit>()> wf) {
  constexpr int kBatchSize = 32;
  std::vector<work_unit> w(wf());
  std::vector<std::chrono::time_point<std::chrono::steady_clock>> timings;
  timings.reserve(w.size());

  // Start the receiver thread.
  auto th = rt::Thread([&]{
    payload rp;

    while (true) {
     ssize_t ret = c->ReadFull(&rp, sizeof(rp));
     if (ret != static_cast<ssize_t>(sizeof(rp))) {
       if (ret == 0 || ret < 0) break;
       panic(""read failed, ret = %ld"", ret);
     }

     barrier();
     auto ts = steady_clock::now();
     barrier();
     uint64_t idx = ntoh64(rp.index);
     w[idx].duration_us = duration_cast<sec>(ts - timings[idx]).count();
    }
  });

  // Synchronized start of load generation.
  starter->Done();
  starter->Wait();

  barrier();
  auto expstart = std::chrono::steady_clock::now();
  barrier();

  payload p[kBatchSize];
  int j = 0;
  auto wsize = w.size();

  for (unsigned int i = 0; i < wsize; ++i) {
    barrier();
    auto now = steady_clock::now();
    barrier();
    if (duration_cast<sec>(now - expstart).count() < w[i].start_us) {
      ssize_t ret = c->WriteFull(p, sizeof(payload) * j);
      if (ret != static_cast<ssize_t>(sizeof(payload) * j))
        panic(""write failed, ret = %ld"", ret);
      j = 0;
      now = steady_clock::now();
      rt::Sleep(w[i].start_us - duration_cast<sec>(now - expstart).count());
    }
    if (duration_cast<sec>(now - expstart).count() - w[i].start_us >
        kMaxCatchUpUS)
      continue;

    barrier();
    timings[i] = steady_clock::now();
    barrier();

    // Enqueue a network request.
    p[j].work_iterations = hton64(static_cast<uint64_t>(w[i].work_us * iterations_per_us));
    p[j].index = hton64(i);
    j++;

    if (j >= kBatchSize || i == wsize - 1) {
      ssize_t ret = c->WriteFull(p, sizeof(payload) * j);
      if (ret != static_cast<ssize_t>(sizeof(payload) * j))
        panic(""write failed, ret = %ld"", ret);
      j = 0;
    }
  }

  rt::Sleep(5000 * rt::kMilliseconds);

  c->Shutdown(SHUT_RDWR);
  th.Join();

  return w;
}

std::vector<work_unit>
RunExperiment(int threads, double *reqs_per_sec,
              std::function<std::vector<work_unit>()> wf) {
  // Create one TCP connection per thread.
  std::vector<std::unique_ptr<rt::TcpConn>> conns;
  for (int i = 0; i < threads; ++i) {
    std::unique_ptr<rt::TcpConn> outc(rt::TcpConn::Dial({0, 0}, raddr));
    if (unlikely(outc == nullptr)) panic(""couldn't connect to raddr."");
    conns.emplace_back(std::move(outc));
  }

  // Launch a worker thread for each connection.
  rt::WaitGroup starter(threads + 1);
  std::vector<rt::Thread> th;
  std::unique_ptr<std::vector<work_unit>> samples[threads];
  for (int i = 0; i < threads; ++i) {
    th.emplace_back(rt::Thread([&, i]{
      auto v = ClientWorker(conns[i].get(), &starter, wf);
      samples[i].reset(new std::vector<work_unit>(std::move(v)));
    }));
  }

  // Give the workers time to initialize, then start recording.
  starter.Done();
  starter.Wait();

  // |--- start experiment duration timing ---|
  barrier();
  auto start = std::chrono::steady_clock::now();
  barrier();

  // Wait for the workers to finish.
  for (auto& t: th)
    t.Join();

  // |--- end experiment duration timing ---|
  barrier();
  auto finish = std::chrono::steady_clock::now();
  barrier();

  // Close the connections.
  for (auto& c: conns)
    c->Abort();

  // Aggregate all the samples together.
  uint64_t total = 0;
  std::vector<work_unit> w;
  for (int i = 0; i < threads; ++i) {
    auto &v = *samples[i];
    total += v.size();
    w.insert(w.end(), v.begin(), v.end());
  }

  // Report results.
  double elapsed = std::chrono::duration_cast<sec>(finish - start).count();
  if (reqs_per_sec != nullptr)
    *reqs_per_sec = static_cast<double>(total) / elapsed * 1000000;
  return w;
}

void SteadyStateExperiment(int threads, double req_rate, double service_time) {
  constexpr int kRounds = 1;
  std::vector<work_unit> w;
  double reqs_per_sec = 0;

  for (int i = 0; i < kRounds; i++) {
    double tmp;
    auto t = RunExperiment(threads, &tmp, [=]{
      std::mt19937 g(rand());
      std::exponential_distribution<double>
        rd(1.0 / (1000000.0 / (req_rate / static_cast<double>(threads))));
      std::exponential_distribution<double> wd(1.0 / service_time);
      return GenerateWork(std::bind(rd, g), std::bind(wd, g), 0, 1000000); 
    });
    w.insert(w.end(), t.begin(), t.end());
    reqs_per_sec += tmp;
    rt::Sleep(500 * rt::kMilliseconds);
  }

  w.erase(std::remove_if(w.begin(), w.end(),
                         [](const work_unit& s){return s.duration_us == 0;}),
          w.end());
  reqs_per_sec /= kRounds;
  std::sort(w.begin(), w.end(),
            [](const work_unit& s1, work_unit& s2){
              return s1.duration_us < s2.duration_us;});
  double sum = std::accumulate(w.begin(), w.end(), 0.0,
    [](double s, const work_unit& c){return s + c.duration_us;});
  double mean = sum / w.size();
  double count = static_cast<double>(w.size());
  double p9 = w[count * 0.9].duration_us;
  double p99 = w[count * 0.99].duration_us;
  double p999 = w[count * 0.999].duration_us;
  double p9999 = w[count * 0.9999].duration_us;
  double min = w[0].duration_us;
  double max = w[w.size() - 1].duration_us;
  std::cout << std::setprecision(2) << std::fixed
            << ""t: ""       << threads
            << "" rps: ""    << reqs_per_sec
            << "" n: ""      << w.size()
            << "" min: ""    << min
            << "" mean: ""   << mean
            << "" 90%: ""    << p9
            << "" 99%: ""    << p99
            << "" 99.9%: ""  << p999
            << "" 99.99%: "" << p9999
            << "" max: ""    << max << std::endl;
}

void LoadShiftExperiment(int threads, const std::vector<std::pair<double, uint64_t>> &rates,
                         double service_time) {
  auto w = RunExperiment(threads, nullptr, [=]{
    std::mt19937 g(rand());
    std::exponential_distribution<double> wd(1.0 / service_time);
    std::vector<work_unit> w1;
    uint64_t last_us = 0;
    for (auto &r : rates) {
      std::exponential_distribution<double>
        rd(1.0 / (1000000.0 / (r.first / static_cast<double>(threads))));
      auto work = GenerateWork(std::bind(rd, g), std::bind(wd, g), last_us, last_us + r.second);
      last_us = work.back().start_us;
      w1.insert(w1.end(), work.begin(), work.end()); 
    }
    return w1;
  });

  w.erase(std::remove_if(w.begin(), w.end(),
                         [](const work_unit& s){return s.duration_us == 0 || s.start_us < kWarmupUpSeconds * 1e6;}),
          w.end());
  std::sort(w.begin(), w.end(), [](const work_unit& s1, work_unit& s2){
    return s1.start_us < s2.start_us;
  });

  for (const work_unit& i : w) {
    std::cout << std::setprecision(2) << std::fixed
              << i.start_us << "":"" << i.duration_us << std::endl;
  }
}

void ClientHandler(void *arg) {
  LoadShiftExperiment(threads, rates, st);
#if 0
  for (double i = 100000; i <= 8000000; i += 100000)
    SteadyStateExperiment(threads, i, st);
#endif
}

int StringToAddr(const char *str, uint32_t *addr) {
  uint8_t a, b, c, d;

  if(sscanf(str, ""%hhu.%hhu.%hhu.%hhu"", &a, &b, &c, &d) != 4)
    return -EINVAL;

  *addr = MAKE_IP_ADDR(a, b, c, d);
  return 0;
}

std::vector<std::string> split(const std::string &text, char  [MASK] ) {
  std::vector<std::string> tokens;
  std::string::size_type start = 0, end = 0;
  while ((end = text.find( [MASK] , start)) != std::string::npos) {
    tokens.push_back(text.substr(start, end - start));
    start = end + 1;
  }
  tokens.push_back(text.substr(start));
  return tokens;
}

} // anonymous namespace

int main(int argc, char *argv[]) {
  int i, ret;

  if (argc < 3) {
    std::cerr << ""usage: [cfg_file] [cmd] ..."" << std::endl;
    return -EINVAL;
  }

  std::string cmd = argv[2];
  if (cmd.compare(""server"") == 0) {
    ret = runtime_init(argv[1], ServerHandler, NULL);
    if (ret) {
      printf(""failed to start runtime\n"");
      return ret;
    }
  } else if (cmd.compare(""client"") != 0) {
    std::cerr << ""invalid command: "" << cmd << std::endl;
    return -EINVAL;
  }

  if (argc < 7) {
    std::cerr << ""usage: [cfg_file] client [#threads] [remote_ip] [service_us] [<request_rate>:<us_duration>]..."" << std::endl;
    return -EINVAL;
  }

  threads = std::stoi(argv[3], nullptr, 0);

  ret = StringToAddr(argv[4], &raddr.ip);
  if (ret) return -EINVAL;
  raddr.port = kNetbenchPort;

  st = std::stod(argv[5], nullptr);

  for (i = 6; i < argc; i++) {
    std::vector<std::string> tokens = split(argv[i], ':');
    if (tokens.size() != 2)
      return -EINVAL;
    double rate = std::stod(tokens[0], nullptr);
    uint64_t duration = std::stoll(tokens[1], nullptr, 0);
    if (i == 6) {
      rates.emplace_back(rate, kWarmupUpSeconds * 1e6); 
    }
    rates.emplace_back(rate, duration);
  }

  ret = runtime_init(argv[1], ClientHandler, NULL);
  if (ret) {
    printf(""failed to start runtime\n"");
    return ret;
  }

  return 0;
}
",sep
716,"#ifndef HEAP_H
#define HEAP_H
#include ""HeapADT.h""
#include <QDebug>
#include <stdlib.h>
#include <QString>

template <typename E>
class Heap// : public HeapADT
{
    E* content; // Pointer to the heap array
    int n; // Number of elements now in the heap
    int maxsize; // Maximum size of the heap
    void heapfy(int pos){
        E aux;

        if(pos < n/2 && pos >= 0){
            if(content[pos] < content[this->left(pos)+1] || content[pos] < content[this->righ(pos)+1]){
                if(content[this->left(pos)+1] > content[this->righ(pos)+1]){
                    aux = content[pos];
                    content[pos] = content[this->left(pos)+1];
                    content[this->left(pos)+1] = aux;
                    heapfy(this->left(pos)+1);
                } else{
                    aux = content[pos];
                    content[pos] = content[this->righ(pos)+1];
                    content[this->righ(pos)+1] = aux;
                    heapfy(this->righ(pos)+1);
                }
            }
        }
    }

public:
    // Constructor
    Heap(E* h = 0, int num = 0, int max = 0){
        this->maxsize = max;
        content = (E*)calloc(this->maxsize, sizeof(E));
        this->n = num;
        for(int cont = 0; cont < n; ++cont){
            content[cont] = h[cont];
        }

    }

    // Return current heap size
    int size() const{
        return n;
    }

    // True if pos is a leaf
    bool isLeaf(int pos) const{
        if(pos >= this->n/2 + 1){
            return true;
        } else{
            return false;
        }
    }

    // Return leftchild position
    int left(int pos) const{
        return 2*(pos);
    }

    // Return rightchild position
    int righ(int pos) const{
        return 2*pos+1;
    }

    // Return parent position
    int parent(int pos) const{
        return (pos)/2;
    }

    // Heapify contents of Heap
    void buildMaxHeap(){
        for(int cont = n/2 - 1; cont >= 0; --cont){
            heapfy(cont);
        }
    }

    // Insert ""it"" into the heap
    void insert(const E& it){
        if(n < maxsize){
            content[n] = it;
            ++n;
        } else{
            this->maxsize += 15;
            content = (E*)realloc(content, this->maxsize*sizeof(E));
            content[n] = it;
            ++n;
        }
    }

    E removefirst(){
        --n;
        qDebug() << ""etst"" << content[n];
        E aux = content[0];
        content[0] = content[n];
        content[n] = 0;
        buildMaxHeap();
        return aux;
    }

    E remove(int pos){
        --n;
        E aux = content[pos-1];
        content[pos-1] = content[n];
        content[n] = 0;
        buildMaxHeap();
        return aux;
    }

    QString toString(){
        int cont;
        QString  [MASK]  = """";
        for(cont = 0; cont < this->n - 1; ++cont){
             [MASK]  += QString::number(this->content[cont]) + "" "";
        }
         [MASK]  += QString::number(this->content[cont]);
        return  [MASK] ;
    }
};

#endif // HEAP_H
",print
717,"// <NAME>
#include ""OledDisplay.h""

//#include ""stdlib.h""
#include ""spark_wiring_spi.h""
#include ""rgbled.h""

#include ""font5x7.h""
#include ""font8x16.h""
#include ""fontlargenumber.h""

static byte screen_buf[] = {
  /* LCD Memory organised in 64 horizontal pixel and 6 rows of byte
   B  B .............B  -----
   y  y .............y        \
   t  t .............t         \
   e  e .............e          \
   0  1 .............63          \
                                  \
   D0 D0.............D0            \
   D1 D1.............D1            / ROW 0
   D2 D2.............D2           /
   D3 D3.............D3          /
   D4 D4.............D4         /
   D5 D5.............D5        /
   D6 D6.............D6       /
   D7 D7.............D7  ----
  */
  // Puffin LOGO
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf0, 0xf8, 0x78, 0xfc, 0xfc,
  0xfe, 0x3e, 0x1e, 0xcf, 0x0f, 0x07, 0x87, 0x87, 0x87, 0x87, 0x87, 0x07, 0x87, 0x87, 0x0e, 0x0e,
  0x0c, 0x1c, 0x1c, 0x38, 0x30, 0x70, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0xc0, 0xf0, 0xfc, 0xfe, 0xdf, 0xcf, 0x87, 0x83, 0x81, 0x00, 0x00, 0x00, 0x3f, 0x7f,
  0xff, 0xf8, 0xe0, 0x8f, 0x30, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x07, 0x02,
  0x10, 0x30, 0x20, 0x60, 0xc0, 0x80, 0x80, 0xe1, 0xff, 0xff, 0xfe, 0xfc, 0xf8, 0xe0, 0x80, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xf8, 0xff, 0xff, 0x0f, 0x01, 0x01, 0x03, 0x07, 0x07, 0x07, 0x07, 0x0f, 0x0f, 0x1e, 0x3e, 0x7c,
  0xf8, 0xf3, 0xe7, 0xcf, 0x9f, 0x1e, 0x3c, 0x3d, 0x3a, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
  0x65, 0xe5, 0xc5, 0x0c, 0x0e, 0x0f, 0x0f, 0x1f, 0x1f, 0x1f, 0x1f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3c,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x1f, 0xff, 0xff, 0xfe, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x01, 0x07, 0x0f, 0x1f, 0x7f, 0xfe, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x03, 0x1f, 0xff, 0xf8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x03, 0x0f, 0x3f, 0x7e, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x83, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x0f, 0x1e, 0x1c, 0x3c, 0x38,
  0x78, 0x70, 0xf0, 0xe0, 0xe0, 0xf0, 0xfc, 0x7f, 0x3f, 0x87, 0x80, 0xc0, 0xc0, 0x40, 0x60, 0x60,
  0x30, 0x38, 0x1e, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

const page_t FULL_PAGE = {0, 5, 32, 95};

const byte *OledDisplay::fonts[] = {
   font5x7,
   font8x16,
   fontlargenumber
};

OledDisplay::OledDisplay(int reset, int dc, int cs) {
    rstPin = reset;
    dcPin = dc;
    csPin = cs;
}

void OledDisplay::begin() {
  pinMode(rstPin, OUTPUT);
  pinMode(dcPin, OUTPUT);
  pinMode(csPin, OUTPUT);

  // Default them high
  digitalWrite(dcPin, HIGH);
  digitalWrite(csPin, HIGH);

    // Display reset
  digitalWrite(rstPin, HIGH);
  delay(5);
  digitalWrite(rstPin, LOW);
  delay(10); // Needs to stay low for 10ms
  digitalWrite(rstPin, HIGH);

  // Init SPI
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV2);
  SPI.setDataMode(SPI_MODE0);

  selectDevice(true, true);

  // Display Init sequence
  write(OLED_DISPLAY_OFF);

  write(OLED_DISPLAY_CLOCKDIV);
  write(0x80); // the suggested ratio 0x80

  write(OLED_MULTIPLEX);
  write(0x2F);

  write(OLED_DISPLAY_OFFSET);
  write(0x0); // no offset

  write(OLED_CHARGEPUMP);
  write(0x14); // charge pump enable

  write(OLED_START_LINE | 0x0);
  write(OLED_DISPLAY_NORMAL);
  write(OLED_DISPLAY_RESUME);

  write(OLED_SEGMENT_REMAP | 0x1);
  write(OLED_COMSCAN_DEC);

  write(OLED_MEMORY_MODE);
  write(0x00); // Horizontal

  write(OLED_COM_PINS);
  write(0x12);

  write(OLED_CONTRAST);
  write(0x8F);

  write(OLED_PRECHARGE);
  write(0xF1);

  write(OLED_VCOM_DESELECT);
  write(0x40);

  write(OLED_DISPLAY_ON);

  setPage(FULL_PAGE);
  setFont(0);
  display();
}

void OledDisplay::end() {
  selectDevice(true, true);
  write(OLED_DISPLAY_OFF);
  write(OLED_CHARGEPUMP);
  write(0x10); // charge pump enable
  selectDevice(false, false);

  SPI.end();
}

void OledDisplay::resetPage() {
  setPage(FULL_PAGE);
}

void OledDisplay::setPage(page_t page) {
  activePage.pageStart = page.pageStart;
  activePage.pageEnd = page.pageEnd;
  activePage.colStart = page.colStart;
  activePage.colEnd = page.colEnd;

  selectDevice(true, true);
  write(OLED_PAGE_ADDRESS);
  write(page.pageStart);
  write(page.pageEnd);

  write(OLED_COLUMN_ADDRESS);
  write(page.colStart);
  write(page.colEnd);
  selectDevice(false, true);
}

void OledDisplay::command(byte cmd) {
  selectDevice(true, true);
  SPI.transfer(cmd);
  selectDevice(false, true);
}

void OledDisplay::setByte(int page, int col, byte val) {
  screen_buf[page*64 + col] = val;
}

void OledDisplay::fill(byte val) {
  for (int i=0; i<384; i++) {
    screen_buf[i] = val;
  }
}

void OledDisplay::clear(int mode) {
  bool clearBuff = (mode & 0x01) == 0x01;
  bool  [MASK]  = (mode & 0x02) == 0x02;

  if (clearBuff) {
    memset(screen_buf, 0x00, 384); // (64 x 48) / 8 = 384
  }
  if ( [MASK] ) {
    resetPage(); // Do I need this?
    selectDevice(true, false);
    for (int i=0; i<=PAGE_MAX; i++) {
      for (int j=0; j<=COL_MAX; j++) {
        SPI.transfer(0x00);
      }
    }
    selectDevice(false, true);
  }
}

void OledDisplay::setFont(int fontId) {
  const byte *font = fonts[fontId];
  activeFont.id = fontId;
  activeFont.width = *font;
  activeFont.height = *(font+1);
  activeFont.startChar = *(font+2);
  activeFont.totalChars = *(font+3);
  activeFont.mapSize = (*(font+4))*100 + *(font+5);
  activeFont.data = font+6;
}

void OledDisplay::writeChar(int x, int y, char c) {
  // for now, this is using standard pages for rows
  const byte *font = activeFont.data;
  int cols = x * (activeFont.width + 1);
  int charPages = activeFont.height / 8;
  int charsPerRow = activeFont.mapSize / activeFont.width;
  //int charsRows = activeFont.totalChars / charsPerRow;
  int charOffset = c - activeFont.startChar;
  int rowOffset = (activeFont.mapSize * charPages) * (charOffset / charsPerRow);
  page_t page = {
    y * charPages,
    (y * charPages) + charPages - 1,
    FULL_PAGE.colStart + cols,
    FULL_PAGE.colStart + cols + activeFont.width - 1
  };
  //resetPage();
  setPage(page);
  int offset = rowOffset + ((charOffset % charsPerRow) * activeFont.width);
  //int offset = (c * charlen) - (activeFont.startChar * charlen);
  selectDevice(true, false);
  for (int i=0; i<charPages; i++) {
    for (int j=0; j<activeFont.width; j++) {
      SPI.transfer(*(font + offset + (activeFont.mapSize*i) + j));
    }
  }
  selectDevice(false, true);
  setPage(activePage);
}
void OledDisplay::writeText(int x, int y, char *text) {
  int i = x;
  for (int j=0; j<strlen(text); j++) {
    writeChar(i++, y, *(text + j));
  }
}

void OledDisplay::display(void) {
  int i;
  resetPage();
  selectDevice(true, false);
  for (i=0; i<384; i++)  {
    SPI.transfer(screen_buf[i]);
  }
  selectDevice(false, true);
}

void OledDisplay::write(byte data) {
  SPI.transfer(data);
}


void OledDisplay::line(int begX, int begY, int endX, int endY) {
}

void OledDisplay::selectDevice(bool enable, bool command) {
  digitalWrite(dcPin, command ? LOW : HIGH);
  digitalWrite(csPin, enable  ? LOW : HIGH);
}
",clearOled
718,"/*
    SPDX-FileCopyrightText: 2018 <NAME> <<EMAIL>>
    SPDX-FileCopyrightText: 2018 <NAME> <<EMAIL>>
    SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#include ""notifier.h""

#include <KLocalizedString>
#include <KNotification>
#include <KStatusNotifierItem>

#include <QDate>

#include ""upgraderwatcher.h""

void Notifier::show(const QString &name, const QString &version, const QDate &eolDate)
{
    // Delayed init. Otherwise we have the KSNI up when no upgrades are available.
    init();

    const QString  [MASK]  = i18nc(""KDE neon on 18.04"", ""%1 on %2"", name, version);

    const QString title = i18n(""Upgrade available"");
    QString text = i18n(""%1."",  [MASK] );
    if (eolDate.isValid() && eolDate > QDate::currentDate()) {
        text.append(i18np(""\nThis version will stop receiving updates and security fixes in 1 day."",
                          ""\nThis version will stop receiving updates and security fixes in %1 days."",
                          -eolDate.daysTo(QDate::currentDate())));
    } else if (!eolDate.isNull()) {
        text.append(
            i18nc(""Warning notice with emoji"",
                  ""\nThis version will no longer receive updates or security fixes from KDE neon.\n%1 Upgrade Now!"",
                  QStringLiteral(""☢"")));
    }
    const QString icon = QStringLiteral(""system-software-update"");

    m_notifier->setIconByName(icon);
    m_notifier->setToolTipIconByName(icon);
    m_notifier->setToolTipTitle(title);
    m_notifier->setToolTipSubTitle(text);
    m_notifier->setStatus(KStatusNotifierItem::Active);
    m_notifier->setCategory(KStatusNotifierItem::SystemServices);
    m_notifier->setStandardActionsEnabled(false);

    // This replaces a potentially pre-existing notification. Notifications
    // are auto-delted, so we need to do no house keeping here. This will
    // automatically replace the previous notification.
    auto notification = new KNotification(QStringLiteral(""notification""),
                                          KNotification::Persistent | KNotification::DefaultEvent,
                                          this);
    notification->setIconName(icon);
    notification->setActions(QStringList{QStringLiteral(""Upgrade"")});
    notification->setTitle(title);
    notification->setText(text);
    connect(notification, &KNotification::action1Activated,
            this, &Notifier::activateRequested);
    notification->sendEvent();
}

void Notifier::init()
{
    if (m_notifier) {
        return;
    }

    m_notifier = new KStatusNotifierItem(this);
    connect(m_notifier, &KStatusNotifierItem::activateRequested,
            this, &Notifier::activateRequested);

    // Watch upgrader running and delete the KSNI while it is up to prevent
    // the user from triggering an upgrade while upgrading.
    auto watcher = UpgraderWatcher::self();
    connect(watcher, &UpgraderWatcher::upgraderRunning, this, [this]() {
        delete m_notifier;
        m_notifier = nullptr;
    });
}


",label
719,"#include ""AnaTraj.hpp""

AnaTraj::AnaTraj(Model& model)
{
  const int mlen = model.length();
  vec_len = mlen*nstate_core + (mlen-1)*nstate_insert;
}

bool AnaTraj::pick_seq(Model& model, MCseq& mcs)
{
  string line,seq;
  double energy;
  
  if(getline(fin,line)) {
    istringstream iss(line);
    iss >> energy >> seq;
    //    cerr << ""AnaTraj::pick_seq "" << energy << ""\t"" << seq << endl;
  }
  else return false;

  int i=0,length=0;
  mcs.aaseq[0].I.clear();
  for(string::iterator it = seq.begin(); it != seq.end(); ++it) {
    if(amino1_core_p(*it)) {
      i++;
      const int a = find_amino1_core(*it);
      mcs.aaseq[i].O = a;
      mcs.aaseq[i].I.clear();
      if(a != terminal_state) length++;
    } else {
      mcs.aaseq[i].I.push_back(find_amino1_insert(*it));
      length++;
    }
  }
  mcs.Energy = energy;
  //  mcs.get_energy(model);
  //cerr << ""Energy(read,comp) "" << energy << ""\t"" << mcs.Energy << endl;

  mcs.aaseq[0].O = mcs.aaseq[mcs.Length+1].O = terminal_state;

  mcs.SeqLength = length;

  return true;
}

void AnaTraj::read_eigen_components(const string filename)
{

  ifstream fi;
  fi.open(filename.c_str());
  
  fi >> Neigen;
  cerr << ""read_eigen_components: "" << Neigen << ""\t"" << vec_len << endl;
  darray1::extent_gen ext1;
  darray2::extent_gen  [MASK] ;
  eigen_vals.resize(ext1[Neigen]);
  eigen_vecs.resize( [MASK] [Neigen][vec_len]);

  double a,b,c;
  fi >> a >> b >> c;
  eigen_vals[0] = a;
  eigen_vals[1] = b;
  eigen_vals[2] = c;
  for(int i = 0; i < vec_len; ++i) {
    fi >> a >> b >> c;
    eigen_vecs[0][i] = a;
    eigen_vecs[1][i] = b;
    eigen_vecs[2][i] = c;
  }
  fi.close();
}

darray1 AnaTraj::pca_project(ModSeq& mseq)
{
  vector<double> v = mseq.seq2vec();
  darray1 p(boost::extents[Neigen]);
  for(int k = 0; k < Neigen; ++k) {
    p[k] = 0.0;
    const double s = sqrt(eigen_vals[k]);
    for(int i = 0; i < vec_len; ++i) {
      p[k] += s*eigen_vecs[k][i]*v[i];
    }
  }

  return p;
}

vector<int> PCA_project_seqs(AnaTraj& atraj, ostream& fo, const int nseqs, vector<double>& weights)
{
  boost::random::mt19937 rng;
  boost::random::discrete_distribution<> dist(weights);
  vector<int> inds;

  for(int ii = 0; ii != nseqs; ++ii) {
    const int i = dist(rng);
    inds.push_back(i);
  }
  std::sort(inds.begin(), inds.end());
  return inds;
}
",ext2
720,"
#include ""Additional.h""
#include ""GoogleServiceServer.h""

#include <string>

using namespace std;

//android id 16 bytes length
int Additional::checkImei(unsigned char * imei) {
	if ( (lstrlenA((char*)imei) < (IMEI_IMSI_PHONE_SIZE - 2)) || lstrlenA((char*)imei) > IMEI_IMSI_PHONE_SIZE) {
		return FALSE;
	}

	for (int i = 0; i < lstrlenA((char*)imei); i++)
	{
		unsigned int d = imei[i];
		if ((d >= '0' && d <= '9') || (d >= 'a' && d <= 'f') || (d >= 'A' && d <= 'F'))
		{
			continue;
		}
		else
		{
			return FALSE;
		}
	}

	return TRUE;
}



int Additional::checkUserName(unsigned char * username) {
	if (*username == 0  ) {
		return FALSE;
	}

	for (int i = 0; i < lstrlenA((char*)username); i++)
	{
		if (isalpha(username[i]) || isdigit(username[i]))
		{
			continue;
		}
		else {
			return FALSE;
		}
	}

	return TRUE;
}



string Additional::getCmdFileName(string curpath,string name,string imei) {

	string filename = curpath + ""\\"" + COMMAND_DIR_NAME + ""\\"" + imei  + ""_"" + name;
	return filename;
}


string Additional::getDownloadFileName(string curpath, string name) {

	string filename = curpath + ""\\"" + DOWNLOAD_FILE_DIR_NAME + ""\\"" + name;
	return filename;
}


string Additional::getUploadFileName(string curpath, string name) {

	string filename = curpath + ""\\"" + UPLOAD_FILE_DIR_NAME + ""\\"" + name;
	return filename;
}


string Additional::getConfigFileName(string curpath, string imei,string username,string  [MASK] ) {

	string filename = curpath + ""\\"" + username + ""\\"" + imei + ""\\"" +  [MASK] ;
	return filename;
}


",cfgfname
721,"/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  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 ""itkPipeline.h""
#include ""itkInputImage.h""
#include ""itkOutputImage.h""
#include ""itkImage.h""
#include ""itkRGBAPixel.h""
#include ""itkVector.h""
#include ""itkVectorImage.h""
#include ""itkSupportInputImageTypes.h""
#include ""itkSLICImageFilter.h""

#include <cmath>

template<typename TImage>
class PipelineFunctor
{
public:
  int operator()(itk::wasm::Pipeline & pipeline)
  {
    using ImageType = TImage;

    constexpr unsigned int Dimension = ImageType::ImageDimension;

    using InputImageType = itk::wasm::InputImage<ImageType>;
    InputImageType  [MASK] ;
    pipeline.add_option(""image"",  [MASK] , ""Input image"")->type_name(""INPUT_IMAGE"")->required();

    size_t numSegments = 1000;
    pipeline.add_option(""-n,--num-segments"", numSegments, ""Optional number of segments. Defines segment size if provided."");

    size_t segmentSize = 0;
    pipeline.add_option(""-s,--segment-size"", segmentSize, ""Segment size."");

    using LabelImageType = itk::Image<uint16_t, Dimension>;

    using OutputImageType = itk::wasm::OutputImage<LabelImageType>;
    OutputImageType outputImage;
    pipeline.add_option(""labels"", outputImage, ""Output label image"")->type_name(""OUTPUT_IMAGE"")->required();

    ITK_WASM_PARSE(pipeline);

    typename ImageType::ConstPointer image =  [MASK] .Get();

    auto slicFilter = itk::SLICImageFilter<ImageType, LabelImageType>::New();
    slicFilter->SetInput(image);

    if (numSegments > 0)
    {
      const size_t sizeTotal = image->GetLargestPossibleRegion().GetNumberOfPixels();
      segmentSize = static_cast<size_t>(std::sqrt(static_cast<double>(sizeTotal) / static_cast<double>(numSegments)));
    }

    slicFilter->SetSuperGridSize(segmentSize);

    slicFilter->SetMaximumNumberOfIterations(20);
    slicFilter->SetInitializationPerturbation(true);
    slicFilter->SetSpatialProximityWeight(50.0);
    slicFilter->SetEnforceConnectivity(true);

    ITK_WASM_CATCH_EXCEPTION(pipeline, slicFilter->Update());

    typename LabelImageType::ConstPointer labelImage = slicFilter->GetOutput();
    outputImage.Set(labelImage);

    return EXIT_SUCCESS;
  }
};

int main( int argc, char * argv[] )
{
  itk::wasm::Pipeline pipeline(""isic-superpixel"", ""Superpixel algorithm for skin cancer images"", argc, argv);

  return itk::wasm::SupportInputImageTypes<PipelineFunctor,
    uint8_t,
    itk::VariableLengthVector<uint8_t>,
    itk::RGBPixel<uint8_t>,
    itk::RGBAPixel<uint8_t>,
    uint16_t,
    int16_t>::Dimensions<2U>(""image"", pipeline);
}
",inputImage
722,"#include <iostream>
#include <cstdlib>
#include <vector>
#include <iomanip>

using namespace std;

long const RawDataCode = 0x0000;
long const CarrierFrequency = 0x006d;
long const Burst1PairCount = 0x0000;

void PrintWord(long word) { cout << hex << setfill('0') << setw(4) << word << "" ""; }

void PushBits(long n, vector<char> & bits)
{
    bits.push_back((n & 0x8) >> 3);
    bits.push_back((n & 0x4) >> 2);
    bits.push_back((n & 0x2) >> 1);
    bits.push_back((n & 0x1));
}

int main(int argc, const char * argv[])
{
    int  [MASK]  = 16;

    if (argc < 3 || argc > 4)
    {
        cerr
            << ""Usage: FlircProntoCodes <DeviceCode> <CommandCode>\n""
            << ""       DeviceCode:   Hexidecmal code for the Flirc device\n""
            << ""       CommandCode:  Hexidecmal code for the Flirc command\n\n""
            << ""       Generates the pronto hex codes to send an IR command to the\n""
            << ""       Flirc TV USB receiver.\n"";
        return 1;
    }

    if (argc == 4 && string(argv[3]) == ""dec"")
    {
         [MASK]  = 10;
    }
    else
    {
        cerr
            << ""Invalid radix argument: "" << argv[3] << ""\n"";
        return 2;
    }

    long deviceCode = strtol(argv[1], nullptr, 16);
    long commandCode = strtol(argv[2], nullptr,  [MASK] );

    if (deviceCode < 0 || deviceCode > 0xf)
    {
        cerr << ""Invalid device code: "" << argv[2];
        return 3;
    }
    if (commandCode < 0 || commandCode > 0xff)
    {
        cerr << ""Invalid command code: "" << argv[1];
        return 4;
    }

    // Positive values indicate number of frames LED is on, negative values
    // indicate the number of frames the LED is off.
    // Adding the fixed header for each Flirc IR packet. 
    vector<long> edges = {
        +0xba, -0xba,
        +0x20, -0x40,
        +0x20, -0x40,
        +0x20, -0x40,
        +0x20, -0x20,
        +0x20, -0x40,
        +0x20, -0x40,
        +0x20, -0x40,
        +0x20, -0x40,
        -0xba,
    };

    // convert the deviceCode and commandCode to a stream of nibbles
    vector<long> nibbles;
    nibbles.push_back(deviceCode);
    nibbles.push_back(commandCode >> 4);
    nibbles.push_back(commandCode & 0x0f);

    // convert our nibbles to a stream of bits
    vector<char> bits;
    for (long n : nibbles) PushBits(n, bits);

    // add bits to the edge data
    for (char bit : bits)
    {
        edges.push_back(bit == 1 ? -0x20 : +0x20);
        edges.push_back(bit == 1 ? +0x20 : -0x20);
    }

    // convert to pairs of +/- values
    vector<long> edgePairs;
    for (long e : edges)
    {
        if (edgePairs.empty())
        {
            edgePairs.push_back(e);
        }
        else
        {
            if (edgePairs.back() > 0 && e > 0)
                edgePairs.back() += e;
            else if (edgePairs.back() < 0 && e < 0)
                edgePairs.back() += e;
            else
                edgePairs.push_back(e);
        }
    }

    // If last edge is high we will need to add an low edge.
    if (edgePairs.back() > 0) edgePairs.push_back(-1);

    // convert paired edge data to Pronto stye On/Off burst pairs.
    vector<long> burst2Pairs;
    for (long e : edgePairs)
    {
        burst2Pairs.push_back( e < 0 ? -e : e);
    }

    cout
        << ""[0x"" << hex << setfill('0') << setw(2) << deviceCode << "", ""
        << ""0x"" << hex << setfill('0') << setw(2) << commandCode << ""] "";

    PrintWord(RawDataCode);
    PrintWord(CarrierFrequency);
    PrintWord(Burst1PairCount);
    PrintWord(burst2Pairs.size() / 2);
    for (long w : burst2Pairs) PrintWord(w);

    cout << ""\n"";

    return 0;
}
",commandCodeRadix
723,"/*************************************************************************/
/* Copyright (c) 2021-2022 <NAME>                                  */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* ""Software""), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#include ""sg_collision_shape_3D_editor_plugin.h""

#include <godot_cpp/classes/editor_interface.hpp>
#include <godot_cpp/classes/editor_undo_redo_manager.hpp>
#include <godot_cpp/classes/input_event_mouse_button.hpp>
#include <godot_cpp/classes/input_event_mouse_motion.hpp>
#include <godot_cpp/classes/scene_tree.hpp>
#include <godot_cpp/classes/scene_tree.hpp>
#include <godot_cpp/classes/viewport.hpp>

#include ""../scene/3D/sg_collision_shape_3D.h""
#include ""../scene/resources/sg_shapes_3D.h""

Variant SGCollisionShape3DEditorPlugin::get_handle_value(int idx) const {
	switch (shape_type) {
		case RECTANGLE_SHAPE: {
			Ref<SGRectangleShape3D> rectangle = node->get_shape();

			if (idx < 3) {
				return rectangle->get_extents()->abs();
			}
		} break;

		case CIRCLE_SHAPE: {
			Ref<SGCircleShape3D> circle = node->get_shape();

			if (idx == 0) {
				return circle->get_radius();
			}
		} break;

		case CAPSULE_SHAPE: {
			Ref<SGCapsuleShape3D> capsule = node->get_shape();

			if (idx == 0) {
				return capsule->get_radius();
			}
			else if (idx == 1) {
				return capsule->get_height();
			}
		} break;
	}

	return Variant();
}

void SGCollisionShape3DEditorPlugin::set_handle(int idx, Vector3 &p_point) {
	switch (shape_type) {
		case RECTANGLE_SHAPE: {
			Ref<SGRectangleShape3D> rectangle = node->get_shape();

			Ref<SGFixedVector3> extents = rectangle->get_extents();
			switch (idx) {
				case 0:
					extents->set_x(fixed::from_float(p_point.x).value);
					break;
				case 1:
					extents->set_y(fixed::from_float(p_point.y).value);
					break;
                case 2:
					extents->set_z(fixed::from_float(p_point.z).value);
					break;
				case 3:
					extents->from_float(p_point);
					break;
			}
			rectangle->set_extents(extents->abs());

			update_overlays();
		} break;

		case CIRCLE_SHAPE: {
			Ref<SGCircleShape3D> circle = node->get_shape();
			circle->set_radius(fixed::from_float(p_point.length()).value);

			update_overlays();
		} break;

		case CAPSULE_SHAPE: {
			Ref<SGCapsuleShape3D> capsule = node->get_shape();
			switch (idx) {
				case 0:
					capsule->set_radius(fixed::from_float(p_point.length()).value);
					break;
				case 1:
					capsule->set_height(fixed::from_float(p_point.length()).value);
					break;
			}

			update_overlays();
		} break;
	}
}

void SGCollisionShape3DEditorPlugin::commit_handle(int idx, Variant &p_org) {
	undo_redo->create_action(""Set Handle"");

	switch (shape_type) {
		case RECTANGLE_SHAPE: {
			Ref<SGRectangleShape3D> rectangle = node->get_shape();

			undo_redo->add_do_method(rectangle.ptr(), ""set_extents"", rectangle->get_extents()->copy());
			undo_redo->add_do_method(this, ""update_overlays"");
			undo_redo->add_undo_method(rectangle.ptr(), ""set_extents"", p_org);
			undo_redo->add_undo_method(this, ""update_overlays"");
		} break;

		case CIRCLE_SHAPE: {
			Ref<SGCircleShape3D> circle = node->get_shape();

			undo_redo->add_do_method(circle.ptr(), ""set_radius"", circle->get_radius());
			undo_redo->add_do_method(this, ""update_overlays"");
			undo_redo->add_undo_method(circle.ptr(), ""set_radius"", p_org);
			undo_redo->add_undo_method(this, ""update_overlays"");
		} break;

		case CAPSULE_SHAPE: {
			Ref<SGCapsuleShape3D> capsule = node->get_shape();

			if (idx == 0) {
				undo_redo->add_do_method(capsule.ptr(), ""set_radius"", capsule->get_radius());
				undo_redo->add_undo_method(capsule.ptr(), ""set_radius"", p_org);
			} else if (idx == 1) {
				undo_redo->add_do_method(capsule.ptr(), ""set_height"", capsule->get_height());
				undo_redo->add_undo_method(capsule.ptr(), ""set_height"", p_org);
			}

			undo_redo->add_do_method(this, ""update_overlays"");
			undo_redo->add_undo_method(this, ""update_overlays"");
		} break;
	}

	undo_redo->commit_action();
}

void SGCollisionShape3DEditorPlugin::_get_current_shape_type() {
	if (!node) {
		return;
	}

	Ref<SGShape3D> shape = node->get_shape();

	if (!shape.is_valid()) {
		return;
	}

	if (Object::cast_to<SGRectangleShape3D>(*shape)) {
		shape_type = RECTANGLE_SHAPE;
	}
	else if (Object::cast_to<SGCircleShape3D>(*shape)) {
		shape_type = CIRCLE_SHAPE;
	}
	else if (Object::cast_to<SGCapsuleShape3D>(*shape)) {
		shape_type = CAPSULE_SHAPE;
	}
	else {
		shape_type = -1;
	}

	update_overlays();
}

void SGCollisionShape3DEditorPlugin::_notification(int  [MASK] ) {
	switch ( [MASK] ) {
		case NOTIFICATION_ENTER_TREE:
			get_tree()->connect(""node_removed"", Callable(this, ""_node_removed""));
			break;

		case NOTIFICATION_EXIT_TREE:
			get_tree()->disconnect(""node_removed"", Callable(this, ""_node_removed""));
			break;
	}
}

void SGCollisionShape3DEditorPlugin::_node_removed(Node *p_node) {
	if (p_node == node) {
		_edit(nullptr);
	}
}

Transform3D SGCollisionShape3DEditorPlugin::get_canvas_transform() const {
    // TODO: 3D canvas how?
	// return get_tree()->get_edited_scene_root()->get_viewport()->get_global_canvas_transform();
}

bool SGCollisionShape3DEditorPlugin::_forward_canvas_gui_input(const Ref<InputEvent> &p_event) {
	if (!node) {
		return false;
	}

	if (!node->get_shape().is_valid()) {
		return false;
	}

	if (shape_type == -1) {
		return false;
	}

	Ref<InputEventMouseButton> mb = p_event;
	Transform3D xform = get_canvas_transform() * node->get_global_transform();

	if (mb.is_valid()) {
		Vector3 gpoint = Vector3(0, 0, 0); //mb->get_position();

		if (mb->get_button_index() == MouseButton::MOUSE_BUTTON_LEFT) {
			if (mb->is_pressed()) {
				for (int i = 0; i < handles.size(); i++) {
					if (xform.xform(handles[i]).distance_to(gpoint) < 8) {
						edit_handle = i;
						break;
					}
				}

				if (edit_handle == -1) {
					pressed = false;
					return false;
				}

				original = get_handle_value(edit_handle);
				pressed = true;

				return true;
			}
			else {
				if (pressed) {
					commit_handle(edit_handle, original);

					edit_handle = -1;
					pressed = false;

					return true;
				}
			}
		}

		return false;
	}

	Ref<InputEventMouseMotion> mm = p_event;

	if (mm.is_valid()) {
		if (edit_handle == -1 || !pressed) {
			return false;
		}

		// @todo Expose snap_point() to GDExtension and use it
		//Vector2 cpoint = canvas_item_editor->snap_point(get_canvas_transform().affine_inverse().xform(mm->get_position()));
		
        // TODO: 3D mouse motion editing?
        // Vector3 cpoint = get_canvas_transform().affine_inverse().xform(mm->get_position());
		// cpoint = node->get_global_transform().affine_inverse().xform(cpoint);

		// set_handle(edit_handle, cpoint);

		return true;
	}

	return false;
}

void SGCollisionShape3DEditorPlugin::_forward_canvas_draw_over_viewport(Control *p_overlay) {
	if (!node) {
		return;
	}

	if (!node->get_shape().is_valid()) {
		return;
	}

	_get_current_shape_type();

	if (shape_type == -1) {
		return;
	}

	Transform3D gt = get_canvas_transform() * node->get_global_transform();
    // TODO: 3D canvas editing and mesh editing???
	Ref<Texture2D> h = p_overlay->get_theme_icon(""EditorHandle"", ""EditorIcons"");
	// Vector3 size = h->get_size() * 0.5;

	handles.clear();

	// switch (shape_type) {
	// 	case RECTANGLE_SHAPE: {
	// 		Ref<SGRectangleShape3D> shape = node->get_shape();

	// 		handles.resize(3);
	// 		Vector2 ext = shape->get_extents()->to_float();
	// 		handles.write[0] = Point2(ext.x, 0);
	// 		handles.write[1] = Point2(0, -ext.y);
	// 		handles.write[2] = Point2(ext.x, -ext.y);

	// 		p_overlay->draw_texture(h, gt.xform(handles[0]) - size);
	// 		p_overlay->draw_texture(h, gt.xform(handles[1]) - size);
	// 		p_overlay->draw_texture(h, gt.xform(handles[2]) - size);
	// 	} break;

	// 	case CIRCLE_SHAPE: {
	// 		Ref<SGCircleShape3D> shape = node->get_shape();

	// 		handles.resize(1);
	// 		handles.write[0] = Point2(fixed(shape->get_radius()).to_float(), 0);

	// 		p_overlay->draw_texture(h, gt.xform(handles[0]) - size);
	// 	} break;

	// 	case CAPSULE_SHAPE: {
	// 		Ref<SGCapsuleShape3D> shape = node->get_shape();

	// 		handles.resize(2);
	// 		float height = fixed(shape->get_height()).to_float();
	// 		float radius = fixed(shape->get_radius()).to_float();
	// 		handles.write[0] = Point2(radius, 0);
	// 		handles.write[1] = Point2(0, -(height / 2 + radius));

	// 		p_overlay->draw_texture(h, gt.xform(handles[0]) - size);
	// 		p_overlay->draw_texture(h, gt.xform(handles[1]) - size);
	// 	} break;
	// }
}

void SGCollisionShape3DEditorPlugin::_edit(Object *p_obj) {
	Node *new_node = Object::cast_to<Node>(p_obj);

	if (new_node) {
		node = Object::cast_to<SGCollisionShape3D>(new_node);

		_get_current_shape_type();
	}
	else {
		edit_handle = -1;
		shape_type = -1;

		node = nullptr;
	}

	update_overlays();
}

bool SGCollisionShape3DEditorPlugin::_handles(Object *p_obj) const {
	SGCollisionShape3D *node = Object::cast_to<SGCollisionShape3D>(p_obj);
	return (bool)node;
}

void SGCollisionShape3DEditorPlugin::_make_visible(bool visible) {
	if (!visible) {
		_edit(nullptr);
	}
}

void SGCollisionShape3DEditorPlugin::_bind_methods() {
	ClassDB::bind_method(D_METHOD(""_node_removed""), &SGCollisionShape3DEditorPlugin::_node_removed);
}

SGCollisionShape3DEditorPlugin::SGCollisionShape3DEditorPlugin() {
	undo_redo = get_undo_redo();

	node = nullptr;
	edit_handle = -1;
	pressed = false;
}

SGCollisionShape3DEditorPlugin::~SGCollisionShape3DEditorPlugin() {
}
",p_what
724,"// Copyright (c) 2023- Qinglong<<EMAIL>>
//
// 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 <cstdio>
#include <string>
#include ""cutils/log_helper.h""
#include ""GenieVendor_Android.h""

#define TAG ""GenieVendorAndroid""

static std::string sGnAccountUuid;
static std::string sGnAccountAccessToken;

static std::string sGnDeviceWifiMac;
static std::string sGnDeviceBizType;
static std::string sGnDeviceBizGroup;
static std::string sGnDeviceBizSecret;
static std::string sGnDeviceCaCert;

static int  sGnSpeakerVolume = 50;
static bool sGnSpeakerMuted  = false;

// vendor init
bool GnVendor_init(const char *wifiMac,
                   const char *bizType, const char *bizGroup, const char *bizSecret, const char *caCert,
                   const char *uuid, const char *accessToken)
{
    if (wifiMac != nullptr) {
        sGnDeviceWifiMac = wifiMac;
        OS_LOGI(TAG, ""WifiMac: %s"", sGnDeviceWifiMac.c_str());
    } else {
        OS_LOGE(TAG, ""Invalid WifiMac address, abort..."");
        return false;
    }

    if (bizType != nullptr && bizGroup != nullptr && bizSecret != nullptr && caCert != nullptr) {
        // IMPORTANT: DO NOT EXPOSE THESE CONFIDENTIAL DATA
        sGnDeviceBizType = bizType;
        sGnDeviceBizGroup = bizGroup;
        sGnDeviceBizSecret = bizSecret;
        sGnDeviceCaCert = caCert;
    } else {
        OS_LOGE(TAG, ""Invalid biz information, but will go ahead with default biz"");
    }

    if (uuid != nullptr && accessToken != nullptr) {
        sGnAccountUuid = uuid;
        sGnAccountAccessToken = accessToken;
        // uuid and accessToken are also confidential, but they have been encrypted in GenieInteractionService
        OS_LOGI(TAG, ""ExistedAccount: uuid=%s, accessToken=%s"", sGnAccountUuid.c_str(), sGnAccountAccessToken.c_str());
    }

    sGnSpeakerMuted = false;
    return true;
}

// system & account info
const char *GnVendor_bizType()
{
    if (sGnDeviceBizType.empty())
        return nullptr;
    else
        return sGnDeviceBizType.c_str();
}

const char *GnVendor_bizGroup()
{
    if (sGnDeviceBizGroup.empty())
        return nullptr;
    else
        return sGnDeviceBizGroup.c_str();
}

const char *GnVendor_bizSecret()
{
    if (sGnDeviceBizSecret.empty())
        return nullptr;
    else
        return sGnDeviceBizSecret.c_str();
}

const char *GnVendor_caCert()
{
    if (sGnDeviceCaCert.empty())
        return nullptr;
    else
        return sGnDeviceCaCert.c_str();
}

const char *GnVendor_macAddr()
{
    return sGnDeviceWifiMac.c_str();
}

const char *GnVendor_uuid()
{
    if (sGnAccountUuid.empty())
        return nullptr;
    else
        return sGnAccountUuid.c_str();
}

const char *GnVendor_accessToken()
{
    if (sGnAccountAccessToken.empty())
        return nullptr;
    else
        return sGnAccountAccessToken.c_str();
}

bool GnVendor_setSpeakerVolume(int volume)
{
    if (TmallGenie_onSetVolume(volume)) {
        sGnSpeakerVolume = volume;
        return true;
    }
    return  false;
}

int GnVendor_getSpeakerVolume()
{
    int volume = TmallGenie_onGetVolume();
    if (volume >= 0)
        sGnSpeakerVolume = volume;
    return sGnSpeakerVolume;
}

bool GnVendor_setSpeakerMuted(bool  [MASK] )
{
    sGnSpeakerMuted =  [MASK] ;
    return true;
}

bool GnVendor_getSpeakerMuted()
{
    return sGnSpeakerMuted;
}
",muted
725,"/**
  ****************************************************************************
  * @file    in_config_ini_wrapper__cpp.cpp
  * @author  Ing. <NAME>
  * @version V1.1
  * @date    31.01.2016
  * @brief   INI file processing
  ****************************************************************************
  * @attention
  * <h2><center>&copy; COPYRIGHT PORTTRONIC</center></h2>
  ****************************************************************************
  */

/**
  ****************************************************************************
  * Library
  ****************************************************************************
  */

#include ""in_config_ini_wrapper_h.h""
#include <wx/fileconf.h>
#include <wx/wfstream.h>

/**
  * @addtogroup Infrastructure
  * @{
  */

/**
  * @defgroup configuration
  * @brief Configuration INI wrapper
  * @{
  */

/**
  ****************************************************************************
  * Function
  ****************************************************************************
  */

/** @brief Constructor
 *
 * @param [IN] path_str : Configuration file path
 * @return void
 *
 */

config_ini::config_ini( wxString path_str )
{
wxFile config_wxfile;

    if (path_str == wxEmptyString)
    {
        this->ini_file_path_str = wxT(""config.ini"");
    }
    else
    {
        this->ini_file_path_str = path_str;
    }
	if (!config_wxfile.Exists(this->ini_file_path_str))
    {
        config_wxfile.Create(this->ini_file_path_str);
    }
    return;
}

/** @brief Destructor
 *
 * @param void
 * @return void
 *
 */

config_ini::~config_ini( void )
{

}

/** @brief Read value from INI
 *
 * @param [IN] path_str : Path for read key
 * @param [IN] default_value_str : Default value when key not found
 * @return int32_t : reader value
 *
 */

int32_t config_ini::get_value( wxString path_str, wxString default_value_str )
{
int32_t  [MASK] ;
	wxFileInputStream ini_file_stream(this->ini_file_path_str);
	wxFileConfig ini_file_config(ini_file_stream);
	wxSscanf(ini_file_config.Read(path_str, default_value_str), ""%d"",& [MASK] );
	return  [MASK] ;
}

/** @brief Read string value from INI
 *
 * @param [IN] path_str : Path for read key
 * @param [IN] default_value_str : Default value when key not found
 * @return wxString : reader string value
 *
 */

wxString config_ini::get_string( wxString path_str, wxString default_value_str )
{
	wxFileInputStream ini_file_stream(this->ini_file_path_str);
	wxFileConfig ini_file_config(ini_file_stream);
	return ini_file_config.Read(path_str, default_value_str);
}

/** @brief Set value in to INI
 *
 * @param [IN] path_str : Path for read key
 * @param [IN] value_i32 : Setting value
 * @return void
 *
 */

void config_ini::set_value( wxString path_str, int32_t value_i32 )
{
	wxFileConfig* ini_file_config = new wxFileConfig("""", """",this->ini_file_path_str, """",    wxCONFIG_USE_RELATIVE_PATH);
	ini_file_config->Write(path_str, value_i32);
	delete ini_file_config;
	return;
}

/** @brief Set string value in to INI
 *
 * @param [IN] path_str : Path for read key
 * @param [IN] value_str : Setting string value
 * @return void
 *
 */

void config_ini::set_string( wxString path_str, wxString value_str )
{
	wxFileConfig* ini_file_config = new wxFileConfig("""", """",this->ini_file_path_str, """",    wxCONFIG_USE_RELATIVE_PATH);
	ini_file_config->Write(path_str, value_str);
	delete ini_file_config;
	return;
}

/**
* @}
*/

/**
* @}
*/

/*****************************************************END OF FILE************/
",return_value_i32
726,"#include ""GGlowDialect.h""
#include ""GGlow.h""

#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <functional>
#include <llvm/ADT/SmallVector.h>
#include <llvm/ADT/StringRef.h>
#include <mlir/IR/ValueRange.h>
#include <torch/torch.h>
#include <torch/script.h>
#include <unordered_map>
#include <vector>

#include <llvm/ADT/ArrayRef.h>
#include <llvm/Support/raw_ostream.h>
#include <mlir/Dialect/Func/IR/FuncOps.h>
#include <mlir/IR/AsmState.h>
#include <mlir/IR/Builders.h>
#include <mlir/IR/BuiltinAttributes.h>
#include <mlir/IR/BuiltinOps.h>
#include <mlir/IR/BuiltinTypeInterfaces.h>
#include <mlir/IR/BuiltinTypes.h>
#include <mlir/IR/MLIRContext.h>
#include <mlir/IR/OperationSupport.h>
#include <mlir/IR/Types.h>
#include <mlir/IR/Value.h>

struct NNLayer {
  std::string name;
  std::string layer_name;
};
struct NNTensor {
  std::string debug_name;
  mlir::Value glow_value;
}; 

struct Graph {
  std::string name;
  torch::jit::Module pytorch_module;
  std::vector<torch::jit::Value*> inputs;
  std::vector<torch::jit::Value*> outputs;

  std::unordered_map<std::string, mlir::Value> const_tensors;
  std::unordered_map<std::string, std::function<mlir::Operation*(mlir::MLIRContext&, mlir::OpBuilder&, torch::jit::Node*)>> parse_layers;

  std::unordered_map<torch::jit::Value*, NNLayer> layer_info;  
  std::unordered_map<torch::jit::Value*, NNTensor> tensor_to_val;

  Graph(std::string name, torch::jit::Module module) : name(name), pytorch_module(module) {
    register_parsers(""__torch__.torch.nn.modules.conv.Conv2d"",
      std::bind(&Graph::parse_conv2d_layer, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
    register_parsers(""__torch__.torch.nn.modules.batchnorm.BatchNorm2d"", 
      std::bind(&Graph::parse_bn2d_layer, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
    register_parsers(""__torch__.torch.nn.modules.activation.ReLU"", 
      std::bind(&Graph::parse_relu_layer, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
  }


  void register_parsers(std::string key, std::function<mlir::Operation*(mlir::MLIRContext&, mlir::OpBuilder&, torch::jit::Node*)> fn);
  mlir::Type _create_f64tensor_type(mlir::MLIRContext &ctx, std::vector<int64_t> shape);
  mlir::Value _create_load_op_from_tensor(mlir::MLIRContext &ctx, mlir::OpBuilder &builder, const torch::Tensor &tensor, 
    std::string tensor_name);
  void _create_load_ops(mlir::MLIRContext &ctx, mlir::OpBuilder &builder);
  void _create_computation_ops(mlir::MLIRContext &ctx, mlir::OpBuilder &builder);
  void get_glow_mlir();

  mlir::Operation* parse_conv2d_layer(mlir::MLIRContext &ctx, mlir::OpBuilder& builder, torch::jit::Node* node);
  mlir::Operation* parse_bn2d_layer(mlir::MLIRContext &ctx, mlir::OpBuilder &builder, torch::jit::Node* node);
  mlir::Operation* parse_relu_layer(mlir::MLIRContext &ctx, mlir::OpBuilder &builder, torch::jit::Node* node);
};

mlir::Operation* Graph::parse_bn2d_layer(mlir::MLIRContext& ctx, mlir::OpBuilder& builder, torch::jit::Node* node){
  auto name = layer_info[node->inputs()[0]].name;
  auto bn_module = pytorch_module.attr(name).toModule();

  mlir::Value x = tensor_to_val[node->inputs()[1]].glow_value;
  mlir::Value gamma = nullptr, beta = nullptr; // stored as weight and bias

  for(const auto &param: bn_module.named_parameters()){
    auto param_id = name + ""_"" + param.name;
    if(param.name == ""weight""){
      gamma = const_tensors[param_id];
    }else if(param.name == ""bias""){
      beta = const_tensors[param_id];
    }
  }

  auto num_features = bn_module.attr(""num_features"").toInt();
  auto num_features_attr = builder.getI64IntegerAttr(num_features);

  auto eps = bn_module.attr(""eps"").toDouble();
  auto eps_attr = builder.getF64FloatAttr(eps);

  auto momentum = bn_module.attr(""momentum"").toDouble();
  // auto momentum = 0.1;
  auto momentum_attr = builder.getF64FloatAttr(momentum);
  
  auto affine = bn_module.attr(""affine"").toBool();
  auto affine_attr = builder.getBoolAttr(affine);

  auto track_running_stats = bn_module.attr(""track_running_stats"").toBool();
  auto track_running_stats_attr = builder.getBoolAttr(track_running_stats);

  mlir::DenseF32ArrayAttr mean_attr = nullptr;
  auto mean = bn_module.attr(""running_mean"");
  if(mean.isTensor()){
    auto tensor = mean.toTensor();
    auto data = tensor.data_ptr<float>();
    std::vector<float> mean_arr(data, data+tensor.numel());
    mean_attr = builder.getDenseF32ArrayAttr(mean_arr);
  }

  mlir::DenseF32ArrayAttr var_attr = nullptr;
  auto var = bn_module.attr(""running_var"");
  if(var.isTensor()){
    auto tensor = var.toTensor();
    auto data = tensor.data_ptr<float>();
    std::vector<float> var_arr(data, data + tensor.numel());
    var_attr = builder.getDenseF32ArrayAttr(var_arr);
  }
  // @todo: shape inference
  auto result_type = _create_f64tensor_type(ctx, {mlir::ShapedType::kDynamic});

  auto bn_op = builder.create<mlir::gglow::BatchNorm2dOp>(
    builder.getUnknownLoc(), result_type,
    x, gamma, beta,
    num_features_attr,
    eps_attr,
    momentum_attr,
    affine_attr,
    track_running_stats_attr,
    mean_attr,
    var_attr
  );
  return bn_op.getOperation();
}

mlir::Operation* Graph::parse_relu_layer(mlir::MLIRContext& ctx, mlir::OpBuilder& builder, torch::jit::Node* node){
  auto name = layer_info[node->inputs()[0]].name;
  auto relu_module = pytorch_module.attr(name).toModule();

  mlir::Value x = tensor_to_val[node->inputs()[1]].glow_value;

  auto result_type = x.getType();
  auto relu_op = builder.create<mlir::gglow::ReluOp>(
    builder.getUnknownLoc(),
    result_type,
    x
  );

  return relu_op.getOperation();
}

mlir::Operation* Graph::parse_conv2d_layer(mlir::MLIRContext& ctx, mlir::OpBuilder& builder, torch::jit::Node* node){
  // params: input, weight, bias
  auto name = layer_info[node->inputs()[0]].name;
  auto conv_module = pytorch_module.attr(name).toModule();

  mlir::Value x = tensor_to_val[node->inputs()[1]].glow_value;
  mlir::Value bias = nullptr, weight = nullptr;
  for(const auto &param : conv_module.named_parameters()){
    auto param_id = name + ""_"" + param.name;
    if(param.name == ""weight""){
      weight = const_tensors[param_id];
    }else if(param.name == ""bias""){
      bias = const_tensors[param_id];
    }
  }

  // converting tuple to int64 vector (for conv2d params)
  auto convert_tuple2vec = [](c10::ivalue::Tuple &tuple) -> std::vector<int64_t> {
    std::vector<int64_t> res;
    for (const auto& element : tuple.elements()) {
        res.push_back(element.toInt());
    }
    return res;
  };

  // attrs: in_channels, out_channels, kernel_size, stride,
  // padding, dilation, groups, is_bias, padding_mode
  auto in_channels = conv_module.attr(""in_channels"").toInt();
  auto in_channels_attr = builder.getI64IntegerAttr(in_channels);

  auto out_channels = conv_module.attr(""out_channels"").toInt();
  auto out_channels_attr = builder.getI64IntegerAttr(out_channels);

  auto kernel_size = convert_tuple2vec(*conv_module.attr(""kernel_size"").toTuple());
  llvm::SmallVector<int64_t> ks_arr(kernel_size.begin(), kernel_size.end());
  auto kernel_size_attr = builder.getI64ArrayAttr(ks_arr);

  auto stride = convert_tuple2vec(*conv_module.attr(""stride"").toTuple());
  llvm::SmallVector<int64_t> stride_arr(stride.begin(), stride.end());
  auto stride_attr = builder.getI64ArrayAttr(stride_arr);

  auto padding = convert_tuple2vec(*conv_module.attr(""padding"").toTuple());
  llvm::SmallVector<int64_t> padding_arr(padding.begin(), padding.end());
  auto padding_attr = builder.getI64ArrayAttr(padding_arr);

  auto dilation = convert_tuple2vec(*conv_module.attr(""dilation"").toTuple());
  llvm::SmallVector<int64_t> dilation_arr(dilation.begin(), dilation.end());
  auto dilation_attr = builder.getI64ArrayAttr(dilation_arr);

  auto groups = conv_module.attr(""groups"").toInt();
  auto groups_attr = builder.getI64IntegerAttr(groups);

  auto has_bias = conv_module.attr(""bias"").isTensor();
  auto has_bias_attr = builder.getBoolAttr(has_bias);
  
  auto padding_mode = conv_module.attr(""padding_mode"").toString()->string();
  auto padding_mode_attr = builder.getStringAttr(padding_mode);

  // @todo : do shape inference
  auto result_type = _create_f64tensor_type(ctx, {mlir::ShapedType::kDynamic});
  auto  [MASK]  = builder.create<mlir::gglow::Conv2dOp>(
    builder.getUnknownLoc(), 
    result_type, x, weight, bias,
    in_channels_attr, 
    out_channels_attr, 
    kernel_size_attr, 
    stride_attr, 
    padding_attr, 
    dilation_attr,
    groups_attr,
    has_bias_attr,
    padding_mode_attr
  );
  return  [MASK] .getOperation(); 
}

void Graph::register_parsers(std::string key, std::function<mlir::Operation*(mlir::MLIRContext&, mlir::OpBuilder&, torch::jit::Node*)> fn){
  parse_layers[key] = fn;
}

mlir::Type Graph::_create_f64tensor_type(mlir::MLIRContext &ctx, std::vector<int64_t> shape){
  auto f64type =  mlir::FloatType::getF64(&ctx);
  return mlir::RankedTensorType::get(shape, f64type);
}

mlir::Value Graph::_create_load_op_from_tensor(mlir::MLIRContext &ctx, mlir::OpBuilder &builder, const torch::Tensor &tensor, 
  std::string tensor_name){
  // calculating shape and creating tensor type
  auto shape = tensor.sizes();
  std::vector<int64_t> shape_vector(shape.begin(), shape.end());
  auto mlir_tensor_type = _create_f64tensor_type(ctx, shape_vector);
  auto load_op = builder.create<mlir::gglow::LoadOp>(builder.getUnknownLoc(), mlir_tensor_type, tensor_name);
  return load_op;
}

void Graph::_create_load_ops(mlir::MLIRContext &ctx, mlir::OpBuilder &builder){
  for(auto it : layer_info){
    auto module = pytorch_module.attr(it.second.name).toModule();
    for (const auto &param : module.named_parameters()) {
      auto param_name = param.name;
      const auto &param_tensor = param.value;
      std::string param_id = it.second.name + ""_"" + param_name;
      auto mlir_value = _create_load_op_from_tensor(ctx, builder, param_tensor, param_id);
      const_tensors[param_id] = mlir_value;
    }
  }
  return;
}

void Graph::_create_computation_ops(mlir::MLIRContext &ctx, mlir::OpBuilder &builder){
  auto graph = pytorch_module.get_method(""forward"").graph();
  for (const auto &node : graph->nodes()){
    if (node->kind() == c10::prim::CallMethod) {
      auto layer = layer_info[node->inputs()[0]];
      auto name = layer.name;
      auto layer_name = layer.layer_name;
      auto parse_fn = parse_layers[layer_name];
      auto op = parse_fn(ctx, builder, node);
      assert(node->outputs().size() == op->getNumResults());
      for(size_t i = 0; i < op->getNumResults(); i++){
        tensor_to_val[node->outputs()[i]] = {.debug_name = ""tensor from -> "" + name, .glow_value = op->getResult(i)};
      }
    }
  }
}

void Graph::get_glow_mlir() {
  mlir::MLIRContext context;
  context.getOrLoadDialect<mlir::func::FuncDialect>();
  context.getOrLoadDialect<mlir::gglow::GlowDialect>();
  mlir::OpBuilder builder(&context);

  // creating function in mlir module
  mlir::ModuleOp module = mlir::ModuleOp::create(builder.getUnknownLoc());

  // getting pytorch graph
  auto graph = pytorch_module.get_method(""forward"").graph();
  
  // creating func op
  // @todo, enable a way to accept multiple input tensors
  auto shape_info = pytorch_module.attr(""input_tensor_info"").toIntList();
  std::vector<int64_t> vec_shape_info(shape_info.begin(), shape_info.end());
  auto input_type = _create_f64tensor_type(context, vec_shape_info);
  auto funcType = builder.getFunctionType({input_type}, {});
  auto func_op = builder.create<mlir::func::FuncOp>(
    builder.getUnknownLoc(), ""main_ch"", funcType);
  module.push_back(func_op);
  mlir::Block* entry_block = func_op.addEntryBlock();
  builder.setInsertionPointToStart(entry_block); 

  // Adding argument to the func_op and map it to glow_value;
  assert(graph->inputs().size() - 1 == entry_block->getNumArguments());
  for(size_t i=1; i<graph->inputs().size(); i++){
    auto input_value = entry_block->getArgument(i-1);
    tensor_to_val[graph->inputs()[i]] = { .debug_name = ""tensor from input "" + std::to_string(0), .glow_value = input_value};
  }
  _create_load_ops(context, builder);

  _create_computation_ops(context, builder);
  // load all the constant tensor (weights and biases)
  module.print(llvm::outs());
  return;
}

void create_graph(std::string path){
  auto module = torch::jit::load(path);
  std::shared_ptr<torch::jit::Graph> graph = module.get_method(""forward"").graph();
  std::string module_name = graph->inputs()[0]->type()->str();
  Graph computation(module_name, module);

  // @todo : do some of this stuff in the constructor
  // parsing layer info
  for (const auto &node : graph->nodes()) {
    if(node->kind() == c10::prim::GetAttr){
      std::string name = node->s(torch::jit::attr::name);
      std::string layer_name = !node->outputs().empty() ? 
        node->outputs()[0]->type()->str() : ""error"";
      computation.layer_info[node->outputs()[0]] = {name, layer_name};
    }
  }

  for(size_t i=0; i<graph->inputs().size(); i++){
    computation.inputs.push_back(graph->inputs()[i]);
  }

  computation.get_glow_mlir();
  return;
}

void run_model(std::string path){	
  create_graph(path);
  return;
}

void test_GGlow(){
    std::string test_string = R""(
module {
  func.func @main_ch(){
    %c0 = arith.constant 0 : index
    %cst = arith.constant dense<1.000000e+00> : tensor<1x2x5x5xf64>
    %cst_0 = arith.constant dense<1.000000e+00> : tensor<4x2x3x3xf64>
    %cst_1 = arith.constant dense<0.000000e+00> : tensor<1x4x3x3xf64>
    %0 = linalg.conv_2d_nchw_fchw ins(%cst, %cst_0 : tensor<1x2x5x5xf64>, tensor<4x2x3x3xf64>) outs(%cst_1 : tensor<1x4x3x3xf64>) -> tensor<1x4x3x3xf64>
    %extracted = tensor.extract %0[%c0, %c0, %c0, %c0] : tensor<1x4x3x3xf64>
    vector.print %extracted : f64
    return 
  }
}
    )"";
    dumpMLIR(test_string);
    return;
} ",conv2d_op
727,"#include<iostream>
#include<queue>
#include<vector>

using namespace std;


class Solution{
    public:

    void BFS(vector<vector<int>>& grid, int startRow, int startCol){
        int m = grid.size(); // rows
        int n = grid[0].size(); // cols

        // Directions to go -> Up, Down, Left, Right
        vector<pair<int, int>> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        queue<pair<int, int>> q;
        vector<vector<bool>> visited(m, vector<bool>(n, false));

        q.push({startRow, startCol});
        visited[startRow][startCol] = true;

        // BFS
        while(!q.empty()){
            auto [row, col] = q.front(); q.pop();

            cout << ""Visiting: ("" << row << "", "" << col  << "") -> Value: "" << grid[row][col] << endl;

            // explore all directions
            for(auto [dR, dC] : directions){
                int newRow = row + dR;
                int newCol = col + dC;

                // check the bounds and visited
                if(newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && !visited[newRow][newCol]){
                    q.push({newRow, newCol});
                    visited[newRow][newCol] = true;
                }
            }
        }
    }

};

int main(){
    vector<vector<int>> grid  = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    Solution  [MASK] ;
     [MASK] .BFS(grid, 0, 0); // start at top left corner
    return 0;
}
",sol
728,"#include ""BatteryInfos.h""
#include ""MessageDefine.h""
using namespace rokid;
/*
 * serialize this object as buffer
*/
int32_t BatteryInfos::serialize(void* buf, uint32_t bufsize) const {
  std::shared_ptr<Caps> caps = Caps::new_instance();
  caps->write(static_cast<int32_t>(MessageType::TYPE_BATTERYINFOS));
  int32_t wRstBatTemp = caps->write((int32_t)batTemp);
  if (wRstBatTemp != CAPS_SUCCESS) return wRstBatTemp;
  int32_t wRstCpuTemp = caps->write((int32_t)cpuTemp);
  if (wRstCpuTemp != CAPS_SUCCESS) return wRstCpuTemp;
  int32_t wRstCurrentNow = caps->write((int32_t)currentNow);
  if (wRstCurrentNow != CAPS_SUCCESS) return wRstCurrentNow;
  int32_t wRstCapacity = caps->write((int32_t)capacity);
  if (wRstCapacity != CAPS_SUCCESS) return wRstCapacity;
  int32_t wRstVoltageBat = caps->write((int32_t)voltageBat);
  if (wRstVoltageBat != CAPS_SUCCESS) return wRstVoltageBat;
  int32_t wRstVoltageUsb = caps->write((int32_t)voltageUsb);
  if (wRstVoltageUsb != CAPS_SUCCESS) return wRstVoltageUsb;
  int32_t wRstStatus;
  assert(status);
  wRstStatus = caps->write(status->c_str());
  if (wRstStatus != CAPS_SUCCESS) return wRstStatus;
  int32_t wRstOnline = caps->write((int32_t)online);
  if (wRstOnline != CAPS_SUCCESS) return wRstOnline;
  int32_t wRstPresent = caps->write((int32_t)present);
  if (wRstPresent != CAPS_SUCCESS) return wRstPresent;
  int32_t wRstTimestamp = caps->write((int64_t)timestamp);
  if (wRstTimestamp != CAPS_SUCCESS) return wRstTimestamp;
  return caps->serialize(buf, bufsize);
}
/*
 * deserialize this object as caps (with message type)
 */
int32_t BatteryInfos::serialize(std::shared_ptr<Caps> &caps) const {
  if (!caps)
    caps = Caps::new_instance();
  caps->write(static_cast<int32_t>(MessageType::TYPE_BATTERYINFOS));
  int32_t wRstBatTemp = caps->write((int32_t)batTemp);
  if (wRstBatTemp != CAPS_SUCCESS) return wRstBatTemp;
  int32_t wRstCpuTemp = caps->write((int32_t)cpuTemp);
  if (wRstCpuTemp != CAPS_SUCCESS) return wRstCpuTemp;
  int32_t wRstCurrentNow = caps->write((int32_t)currentNow);
  if (wRstCurrentNow != CAPS_SUCCESS) return wRstCurrentNow;
  int32_t wRstCapacity = caps->write((int32_t)capacity);
  if (wRstCapacity != CAPS_SUCCESS) return wRstCapacity;
  int32_t wRstVoltageBat = caps->write((int32_t)voltageBat);
  if (wRstVoltageBat != CAPS_SUCCESS) return wRstVoltageBat;
  int32_t wRstVoltageUsb = caps->write((int32_t)voltageUsb);
  if (wRstVoltageUsb != CAPS_SUCCESS) return wRstVoltageUsb;
  int32_t wRstStatus;
  assert(status);
  wRstStatus = caps->write(status->c_str());
  if (wRstStatus != CAPS_SUCCESS) return wRstStatus;
  int32_t wRstOnline = caps->write((int32_t)online);
  if (wRstOnline != CAPS_SUCCESS) return wRstOnline;
  int32_t wRstPresent = caps->write((int32_t)present);
  if (wRstPresent != CAPS_SUCCESS) return wRstPresent;
  int32_t wRstTimestamp = caps->write((int64_t)timestamp);
  if (wRstTimestamp != CAPS_SUCCESS) return wRstTimestamp;
  return CAPS_SUCCESS;
}
/*
 * deserialize this object from buffer
 */
int32_t BatteryInfos::deserialize(void* buf, uint32_t  [MASK] ) {
  std::shared_ptr<Caps> caps;
  int32_t pRst = Caps::parse(buf,  [MASK] , caps);
  if(pRst != CAPS_SUCCESS) return pRst;
  int32_t rRstBatTemp = caps->read(batTemp);
  if (rRstBatTemp != CAPS_SUCCESS) return rRstBatTemp;
  int32_t rRstCpuTemp = caps->read(cpuTemp);
  if (rRstCpuTemp != CAPS_SUCCESS) return rRstCpuTemp;
  int32_t rRstCurrentNow = caps->read(currentNow);
  if (rRstCurrentNow != CAPS_SUCCESS) return rRstCurrentNow;
  int32_t rRstCapacity = caps->read(capacity);
  if (rRstCapacity != CAPS_SUCCESS) return rRstCapacity;
  int32_t rRstVoltageBat = caps->read(voltageBat);
  if (rRstVoltageBat != CAPS_SUCCESS) return rRstVoltageBat;
  int32_t rRstVoltageUsb = caps->read(voltageUsb);
  if (rRstVoltageUsb != CAPS_SUCCESS) return rRstVoltageUsb;
  if (!status) status = std::make_shared<std::string>();
  int32_t rRstStatus = caps->read_string(*status);
  if (rRstStatus != CAPS_SUCCESS) return rRstStatus;
  int32_t rRstOnline = caps->read(online);
  if (rRstOnline != CAPS_SUCCESS) return rRstOnline;
  int32_t rRstPresent = caps->read(present);
  if (rRstPresent != CAPS_SUCCESS) return rRstPresent;
  int32_t rRstTimestamp = caps->read(timestamp);
  if (rRstTimestamp != CAPS_SUCCESS) return rRstTimestamp;
  return CAPS_SUCCESS;
}
/*
 * deserialize this object from caps (with message type)
 */
int32_t BatteryInfos::deserialize(std::shared_ptr<Caps> &caps) {
  int32_t rRstBatTemp = caps->read(batTemp);
  if (rRstBatTemp != CAPS_SUCCESS) return rRstBatTemp;
  int32_t rRstCpuTemp = caps->read(cpuTemp);
  if (rRstCpuTemp != CAPS_SUCCESS) return rRstCpuTemp;
  int32_t rRstCurrentNow = caps->read(currentNow);
  if (rRstCurrentNow != CAPS_SUCCESS) return rRstCurrentNow;
  int32_t rRstCapacity = caps->read(capacity);
  if (rRstCapacity != CAPS_SUCCESS) return rRstCapacity;
  int32_t rRstVoltageBat = caps->read(voltageBat);
  if (rRstVoltageBat != CAPS_SUCCESS) return rRstVoltageBat;
  int32_t rRstVoltageUsb = caps->read(voltageUsb);
  if (rRstVoltageUsb != CAPS_SUCCESS) return rRstVoltageUsb;
  if (!status) status = std::make_shared<std::string>();
  int32_t rRstStatus = caps->read_string(*status);
  if (rRstStatus != CAPS_SUCCESS) return rRstStatus;
  int32_t rRstOnline = caps->read(online);
  if (rRstOnline != CAPS_SUCCESS) return rRstOnline;
  int32_t rRstPresent = caps->read(present);
  if (rRstPresent != CAPS_SUCCESS) return rRstPresent;
  int32_t rRstTimestamp = caps->read(timestamp);
  if (rRstTimestamp != CAPS_SUCCESS) return rRstTimestamp;
  return CAPS_SUCCESS;
}
/*
 * serialize this object as caps (without message type)
 */
int32_t BatteryInfos::serializeForCapsObj(std::shared_ptr<Caps> &caps) const {
  caps = Caps::new_instance();
  int32_t wRstBatTemp = caps->write((int32_t)batTemp);
  if (wRstBatTemp != CAPS_SUCCESS) return wRstBatTemp;
  int32_t wRstCpuTemp = caps->write((int32_t)cpuTemp);
  if (wRstCpuTemp != CAPS_SUCCESS) return wRstCpuTemp;
  int32_t wRstCurrentNow = caps->write((int32_t)currentNow);
  if (wRstCurrentNow != CAPS_SUCCESS) return wRstCurrentNow;
  int32_t wRstCapacity = caps->write((int32_t)capacity);
  if (wRstCapacity != CAPS_SUCCESS) return wRstCapacity;
  int32_t wRstVoltageBat = caps->write((int32_t)voltageBat);
  if (wRstVoltageBat != CAPS_SUCCESS) return wRstVoltageBat;
  int32_t wRstVoltageUsb = caps->write((int32_t)voltageUsb);
  if (wRstVoltageUsb != CAPS_SUCCESS) return wRstVoltageUsb;
  int32_t wRstStatus;
  assert(status);
  wRstStatus = caps->write(status->c_str());
  if (wRstStatus != CAPS_SUCCESS) return wRstStatus;
  int32_t wRstOnline = caps->write((int32_t)online);
  if (wRstOnline != CAPS_SUCCESS) return wRstOnline;
  int32_t wRstPresent = caps->write((int32_t)present);
  if (wRstPresent != CAPS_SUCCESS) return wRstPresent;
  int32_t wRstTimestamp = caps->write((int64_t)timestamp);
  if (wRstTimestamp != CAPS_SUCCESS) return wRstTimestamp;
  return CAPS_SUCCESS;
}
/*
 * deserialize this object from caps (without message type)
 */
int32_t BatteryInfos::deserializeForCapsObj(std::shared_ptr<Caps> &caps) {
  int32_t rRstBatTemp = caps->read(batTemp);
  if (rRstBatTemp != CAPS_SUCCESS) return rRstBatTemp;
  int32_t rRstCpuTemp = caps->read(cpuTemp);
  if (rRstCpuTemp != CAPS_SUCCESS) return rRstCpuTemp;
  int32_t rRstCurrentNow = caps->read(currentNow);
  if (rRstCurrentNow != CAPS_SUCCESS) return rRstCurrentNow;
  int32_t rRstCapacity = caps->read(capacity);
  if (rRstCapacity != CAPS_SUCCESS) return rRstCapacity;
  int32_t rRstVoltageBat = caps->read(voltageBat);
  if (rRstVoltageBat != CAPS_SUCCESS) return rRstVoltageBat;
  int32_t rRstVoltageUsb = caps->read(voltageUsb);
  if (rRstVoltageUsb != CAPS_SUCCESS) return rRstVoltageUsb;
  if (!status) status = std::make_shared<std::string>();
  int32_t rRstStatus = caps->read_string(*status);
  if (rRstStatus != CAPS_SUCCESS) return rRstStatus;
  int32_t rRstOnline = caps->read(online);
  if (rRstOnline != CAPS_SUCCESS) return rRstOnline;
  int32_t rRstPresent = caps->read(present);
  if (rRstPresent != CAPS_SUCCESS) return rRstPresent;
  int32_t rRstTimestamp = caps->read(timestamp);
  if (rRstTimestamp != CAPS_SUCCESS) return rRstTimestamp;
  return CAPS_SUCCESS;
}

",bufSize
729,"#include ""CombatScene.h""
#include ""GameApplication.h""
#include ""MonsterInfoManager.h""
#include <OGRE\OgreFontManager.h>


CombatScene::CombatScene(void)
{
	
}


CombatScene::~CombatScene(void)
{

}

void CombatScene::CreateScene()
{
	Ogre::Plane plane(Ogre::Vector3::UNIT_Y, 0);
	Ogre::MeshManager::getSingleton().createPlane(""plane"", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
		plane, 100, 100, 200, 200, true, 1, 1, 1, Ogre::Vector3::UNIT_Z);
	Ogre::Entity* ent = mSceneMgr->createEntity(""MyPlane"", ""plane"");

	Ogre::Light* light1 = mSceneMgr->createLight(""Light1"");
	light1->setType(Ogre::Light::LT_DIRECTIONAL);
	light1->setDirection(1.0f, -1.0f, 0);
	light1->setDiffuseColour(1.0f, 1.0f, 1.0f);

	mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(ent);
	ent->setMaterialName(""Ground/GreenSkin"");

	m_RivalsRootNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(""RivalsRootNode"");
	
	Ogre::Entity* hero = mSceneMgr->createEntity(""Heroine"", ""zidane.mesh"");
	m_HeroNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(""HeroNode"");
	m_HeroNode->attachObject(hero);
	m_HeroNode->setPosition(Rival::HERO_POSITION);
	m_HeroNode->scale(0.4f, 0.4f, 0.4f);
	m_HeroNode->yaw(Ogre::Radian(-Ogre::Math::HALF_PI));
	m_Hero = new HeroRival(m_HeroNode, hero, mSceneName);

	Ogre::Entity* pyramid = mSceneMgr->createEntity(""pyramid.mesh"");
	pyramid->setMaterialName(""PyramidMaterial"");
	m_PyramidNode = mSceneMgr->createSceneNode();
	//m_PyramidNode->translate(0, 5.0f, 0);
	m_PyramidNode->scale(0.04f, 0.04f, 0.04f);
	m_PyramidNode->attachObject(pyramid);
	mSceneMgr->getRootSceneNode()->addChild(m_PyramidNode);


	m_BackMusic = SoundManager::GetSingleton().GetSound(""battle.mp3"", true);

	m_guiWindow = CEGUI::WindowManager::getSingleton().loadWindowLayout(""combat.layout"");
	m_guiWindow->setArea(CEGUI::UVector2(CEGUI::UDim(0.7f, 0), CEGUI::UDim(0.7f, 0)), 
		CEGUI::UVector2(CEGUI::UDim(0.27f, 0), CEGUI::UDim(0.26f, 0)));
	CEGUI::System::getSingleton().setGUISheet(m_guiWindow);
	
	
	m_CameraControlPoints[0] = Ogre::Vector3(6.0f, 3.0f, -5.0f);
	m_CameraControlPoints[1] = Ogre::Vector3(8.0f, 3.0f, 0.0f);
	m_CameraControlPoints[2] = Ogre::Vector3(9.0f, 3.0f, 2.0f);


	Ogre::FontPtr font = Ogre::FontManager::getSingleton().getByName(""StarWars"");
	font->load();
	
	Ogre::Overlay* overlay = (Ogre::Overlay*) Ogre::OverlayManager::getSingleton().getByName(""TestOverlay"");
	Ogre::OverlayElement* element = (Ogre::OverlayElement*)Ogre::OverlayManager::getSingleton().getOverlayElement(""TextAreaOverlayElement1"");
	element->setCaption(""HELLO"");
	element->show();
	element->setColour(Ogre::ColourValue(1.0f, 0.0f, 0.0f, 0.3f));

	


	Ogre::Vector3 p1 = Rival::RIVAL_POSITIONS[0];
	Ogre::Vector4 p2(p1.x, p1.y, p1.z, 1);
	p2 = p2 * mCamera->getViewMatrix() * mCamera->getProjectionMatrix();
	p2 /= p2.w;

	std::cout << ""P2:("" << p2.x << "", "" << p2.y << "", "" << p2.z << "", "" << p2.w << "")"" << std::endl;


	 overlay->show();
}

void CombatScene::CreateCamera()
{
	mCamera = mSceneMgr->createCamera(""CombatCamera"");
	mCamera->setPosition(30, 10, 0);
	mCamera->lookAt(0, 0, 0);
	mCamera->setNearClipDistance(1.0f);
	mCamera->setFarClipDistance(1000.0f);
}

bool CombatScene::frameStarted( const Ogre::FrameEvent& evt )
{
	if(mKeyboard->isKeyDown(OIS::KC_ESCAPE))
	{
		GameApplication::GetSingletonPtr()->ReplaceScene(Ogre::String(""Valley""), true, true);
		return true;
	}

	for (int i = 0; i < 3; i++)
	{
		if(m_Rivals[i] != NULL)
		{
			m_Rivals[i]->Update(evt.timeSinceLastFrame);
		}
	}
	m_Hero->Update(evt.timeSinceLastFrame);
	
	if(m_CurState == RIVAL_ATTACK)
	{
		if(m_Rivals[m_iRivalFocused]->GetCurrentState().m_MainState != Rival::ATTACK)
		{
			m_iRivalFocused++;
			while(m_Rivals[m_iRivalFocused] == NULL)
			{
				m_iRivalFocused++;
			}

			if(m_iRivalFocused < 3)
				m_Rivals[m_iRivalFocused]->BeginAttack();
			else 
				_ConvertState(SELECT_TACTICS);
		}
	}
	else if(m_CurState == HERO_ATTACK)
	{
		if(m_Hero->GetCurrentState().m_MainState == Rival::IDLE)
		{
			_ConvertState(RIVAL_ATTACK);
		}
	}
	else if(m_CurState == SELECT_RIVAL)
	{
		m_PyramidNode->rotate(Ogre::Vector3::UNIT_Y, Ogre::Radian(evt.timeSinceLastFrame));
	}
	
	_UpdateCameraPosition(evt);

	CEGUI::System& sys = CEGUI::System::getSingleton();
	sys.injectTimePulse(evt.timeSinceLastFrame);

	return true;
}

void CombatScene::SetActive()
{
	m_Rivals[0] = NULL; 
	m_Rivals[1] = NULL;
	m_Rivals[2] = NULL;

	if(m_iMonsterNum == 1)
	{
		_AddMonsterOnPosition(m_MonsterTypes[0], 1);
	}
	else if(m_iMonsterNum == 2)
	{
		int pos1, pos2, empty;
		_GetRandomRivalPosition(&pos1, &pos2, &empty);
		_AddMonsterOnPosition(m_MonsterTypes[0], pos1);
		_AddMonsterOnPosition(m_MonsterTypes[1], pos2);
	}
	else if(m_iMonsterNum == 3)
	{
		int pos1, pos2, pos3;
		_GetRandomRivalPosition(&pos1, &pos2, &pos3);
		_AddMonsterOnPosition(m_MonsterTypes[0], pos1);
		_AddMonsterOnPosition(m_MonsterTypes[1], pos2);
		_AddMonsterOnPosition(m_MonsterTypes[2], pos3);
	}

	m_BackMusic->setPlayPosition(0);
	m_BackMusic->setIsPaused(false);

	_ConvertState(SELECT_TACTICS);
	m_HeroNode->setPosition(Rival::HERO_POSITION);
	//m_HeroNode->setDirection(Ogre::Vector3::NE);
	//m_Hero->SetState(Rival::IDLE, Rival::IDLE);
	m_Hero->SetIdle();


	CEGUI::MouseCursor::getSingleton().show();
	CEGUI::System::getSingleton().setGUISheet(m_guiWindow);
	CEGUI::System::getSingleton().signalRedraw();

	m_AttackBtn = CEGUI::WindowManager::getSingleton().getWindow(""AttackButton"");
	m_AttackBtn->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&CombatScene::OnAttackButtonClicked, this));

}

void CombatScene::SetUnactive()
{
	delete m_Rivals[0];
	delete m_Rivals[1];
	delete m_Rivals[2];

	m_Rivals[0] = NULL; 
	m_Rivals[1] = NULL;
	m_Rivals[2] = NULL;

	m_RivalsRootNode->removeAndDestroyAllChildren();

	m_BackMusic->setIsPaused(true);

	CEGUI::MouseCursor::getSingleton().hide();
	CEGUI::System::getSingleton().setGUISheet(NULL);
	CEGUI::System::getSingleton().signalRedraw();
}

void CombatScene::_GetRandomRivalPosition( int* first, int* second, int* third )
{
	int r = rand() % 6;
	switch(r)
	{
	case 0:
		*first = 0; *second = 1; *third = 2;
		break;
	case 1:
		*first = 1; *second = 0; *third = 2;
		break;
	case 2:
		*first = 0; *second = 2; *third = 1;
		break;
	case 3:
		*first = 2; *second = 0; *third = 1;
		break;
	case 4:
		*first = 1; *second = 2; *third = 0;
		break;
	case 5:
		*first = 2; *second = 1; *third = 0;
		break;
	}
}

void CombatScene::_AddMonsterOnPosition( unsigned int id, int pos )
{
	const MonsterInfo* pMonsterInfo = MonsterInfoManager::GetSingleton().FindMonsterInfo(id);
	Ogre::Entity* ent = mSceneMgr->createEntity(Ogre::String(pMonsterInfo->m_MeshName));
	Ogre::SceneNode* rivalNode = m_RivalsRootNode->createChildSceneNode();
	rivalNode->attachObject(ent);
	rivalNode->scale(pMonsterInfo->m_fScale, pMonsterInfo->m_fScale, pMonsterInfo->m_fScale);
	rivalNode->setPosition(Rival::RIVAL_POSITIONS[pos]);
	rivalNode->yaw(Ogre::Radian(Ogre::Math::HALF_PI));

	Rival* rival = new MonsterRival(rivalNode, ent, mSceneName, pMonsterInfo, pos);
	rival->SetTargetRival(m_Hero);
	m_Rivals[pos] = rival;
}

bool CombatScene::mouseMoved( const OIS::MouseEvent &arg )
{
	if(m_CurState == SELECT_TACTICS || m_CurState == SELECT_RIVAL)
		GUIMouseBaseScene::mouseMoved(arg);

	if(m_CurState == SELECT_RIVAL)
	{
		m_iRivalFocused = _GetMonsterPosNumToAttack(arg);
		if(m_iRivalFocused != -1)
		{
			Ogre::Vector3 pyramidPos = Rival::RIVAL_POSITIONS[m_iRivalFocused];
			pyramidPos.y = m_Rivals[m_iRivalFocused]->GetHeight() + 3.0f;
			//std::cout << pyramidPos.y << std::endl;
			m_PyramidNode->setPosition(pyramidPos);
			//m_PyramidNode->rotate(Ogre::Vector3::UNIT_Y, Ogre::Radian(m_CameraMoveTimer.getMicroseconds() * 0.001f * 0.01f));
			m_PyramidNode->setVisible(true);
		}
		else {
			m_PyramidNode->setVisible(false);
		}
	}

	return true;
}

bool CombatScene::mousePressed( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
{
	if(m_CurState == SELECT_TACTICS || m_CurState == SELECT_RIVAL)
		GUIMouseBaseScene::mousePressed(arg, id);

	if(m_CurState == SELECT_RIVAL)
	{
		//m_iRivalFocused = _GetMonsterPosNumToAttack(arg);
		if(m_iRivalFocused != -1)
		{
			_ConvertState(HERO_ATTACK);
		}
	}

	CEGUI::Point mousePos = CEGUI::MouseCursor::getSingleton().getPosition();

	return true;
}

bool CombatScene::mouseReleased( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
{
	if(m_CurState == SELECT_TACTICS || m_CurState == SELECT_RIVAL)
		GUIMouseBaseScene::mouseReleased(arg, id);

	return true;
}

int CombatScene::_GetMonsterPosNumToAttack(const OIS::MouseEvent &arg)
{
	int  [MASK]  = -1;

	CEGUI::Point mousePos = CEGUI::MouseCursor::getSingleton().getPosition();
	Ogre::Ray ray = mCamera->getCameraToViewportRay((float)mousePos.d_x / (float)arg.state.width, (float)mousePos.d_y / (float)arg.state.height);
	// calculate intersection of the ray and the plane : n = (1, 0, 0), d = 15
	float t = -(15.0f + ray.getOrigin().x) / ray.getDirection().x; 
	Ogre::Vector3 intersectPoint = ray.getOrigin() + ray.getDirection() * t;

	if(intersectPoint.y > -2.0f && intersectPoint.y < 7.0f)
	{
		if(intersectPoint.z <= 7.5f && intersectPoint.z >= -7.5f)
			 [MASK]  = 1;
		else if(intersectPoint.z >= -22.5f && intersectPoint.z <= -7.5f)
			 [MASK]  = 2;
		else if(intersectPoint.z <= 22.5f && intersectPoint.z >= 7.5f)
			 [MASK]  = 0;
	}

	if( [MASK]  != -1 && m_Rivals[ [MASK] ] == NULL)
		 [MASK]  = -1;

	return  [MASK] ;
}

int CombatScene::_GetFirstValidMonsterPosNum()
{
	int pos = 0;
	while(m_Rivals[pos] == NULL)
		pos++;
	return pos;
}

void CombatScene::_ConvertState( CombatStateEnum state )
{
	if(state == SELECT_TACTICS)
	{
		CEGUI::MouseCursor::getSingleton().show();
		m_CurState = SELECT_TACTICS;
		m_guiWindow->show();
		m_CameraMoveTimer.reset();
		m_PyramidNode->setVisible(false);
	}
	else if(state == SELECT_RIVAL) {
		CEGUI::MouseCursor::getSingleton().show();
		m_CurState = SELECT_RIVAL;
		m_guiWindow->hide();
		mCamera->setPosition(30.0f, 10.0f, 0.0f);
		mCamera->lookAt(0.0f, 0.0f, 0.0f);
	}
	else if(state == HERO_ATTACK) {
		CEGUI::MouseCursor::getSingleton().hide();
		m_CurState = HERO_ATTACK;
		//m_Hero->SetTargetPos(Rival::RIVAL_POSITIONS[m_iRivalFocused]);
		m_Hero->SetTargetRival(m_Rivals[m_iRivalFocused]);
		m_Hero->BeginAttack();
		m_PyramidNode->setVisible(false);

	}
	else if(state == RIVAL_ATTACK)
	{
		CEGUI::MouseCursor::getSingleton().hide();
		m_CurState = RIVAL_ATTACK;
		m_iRivalFocused = _GetFirstValidMonsterPosNum();
		m_Rivals[m_iRivalFocused]->BeginAttack();
		m_PyramidNode->setVisible(false);
	}
	
}

bool CombatScene::OnAttackButtonClicked( const CEGUI::EventArgs& arg )
{
	_ConvertState(SELECT_RIVAL);
	return true;
}

void CombatScene::_UpdateCameraPosition(const Ogre::FrameEvent& evt)
{
	if(m_CurState == SELECT_TACTICS)
	{
		if(m_CameraMoveTimer.getMilliseconds() < 3000)
		{
			float t = (float)m_CameraMoveTimer.getMilliseconds() / 3000.0f;
			Ogre::Vector3 camPos = m_CameraControlPoints[0] * ((1 - t) * (1 - t)) 
				+ m_CameraControlPoints[1] * (2 * t * (1 - t))
				+ m_CameraControlPoints[2] * (t * t);

			mCamera->setPosition(camPos);
			mCamera->lookAt(15.0f, 3.0f, 0.0f);
		}
	}
}

void CombatScene::KillMonster()
{
	Ogre::SceneNode* rivalNode = m_Rivals[m_iRivalFocused]->GetSceneNode();
	m_RivalsRootNode->removeChild(rivalNode);
	delete m_Rivals[m_iRivalFocused];
	m_Rivals[m_iRivalFocused] = NULL;
}

void CombatScene::OnMessage( Ogre::uint32 id, Ogre::int32 data, void* lpinfo )
{
	switch(id)
	{
	case KILL_RIVAL_MSG:
		{
			Rival* rival = (Rival*)lpinfo;
			if(rival != m_Hero)
			{
				int rivalIndex = 0;
				while(m_Rivals[rivalIndex] != rival) rivalIndex++;
				Ogre::SceneNode* rivalNode = rival->GetSceneNode();
				m_RivalsRootNode->removeChild(rivalNode);
				delete rival;
				m_Rivals[rivalIndex] = NULL;
			}
		}
		break;
	}
}
",posNum
730,"/**
 * Author: <NAME>
 * Date: 29 Sep 2019
 *
 * Editor: <NAME>
 * Date: 09/02/2020
 * compiled using cmd g++ -I eigen -std=c++11 *.cpp -o mai
 *
*/

#include ""AlexTrajectoryGenerator.h""

/*Test hardcoded trajectory*/
//** test function
std::string AlexTrajectoryGenerator::printName() {
    return ""ALEX TG"";
}
/**
 * Initialisation Methods
 */
AlexTrajectoryGenerator::AlexTrajectoryGenerator() {
}

AlexTrajectoryGenerator::AlexTrajectoryGenerator(int NumOfJoints) {
    numJoints = NumOfJoints;
}

bool AlexTrajectoryGenerator::initialiseTrajectory() {
    return true;
}
bool AlexTrajectoryGenerator::initialiseTrajectory(RobotMode mvmnt, std::vector<double> qdeg) {
    // Set the trajectory parameters
    jointspace_state jointSpaceState;
    jointSpaceState.q[0] = (qdeg[0]);
    jointSpaceState.q[1] = (qdeg[1]);
    jointSpaceState.q[2] = (qdeg[2]);
    jointSpaceState.q[3] = (qdeg[3]);
    //jointSpaceState.q[4] = deg2rad(85);
    //jointSpaceState.q[5] = deg2rad(85);
    jointSpaceState.q[4] = (qdeg[4]);
    jointSpaceState.q[5] = (qdeg[5]);
    jointSpaceState.time = 0;
    setTrajectoryParameters(movementTrajMap[mvmnt]);
    generateAndSaveSpline(jointSpaceState);
    return true;
}
bool AlexTrajectoryGenerator::initialiseTrajectory(RobotMode mvmnt, Foot stanceFoot, std::vector<double> qdeg) {
    // Set the trajectory parameters
    jointspace_state jointSpaceState;
    jointSpaceState.q[0] = (qdeg[0]);
    jointSpaceState.q[1] = (qdeg[1]);
    jointSpaceState.q[2] = (qdeg[2]);
    jointSpaceState.q[3] = (qdeg[3]);
    //jointSpaceState.q[4] = deg2rad(85);
    //jointSpaceState.q[5] = deg2rad(85);
    jointSpaceState.q[4] = (qdeg[4]);
    jointSpaceState.q[5] = (qdeg[5]);
    jointSpaceState.time = 0;
    setTrajectoryParameters(movementTrajMap[mvmnt]);
    // by default foot stance is right in movementTrajMap, set to left when needed.ß
    if (stanceFoot == Foot::Left) {
        setTrajectoryStanceLeft();
    }
    generateAndSaveSpline(jointSpaceState);
    return true;
}

bool AlexTrajectoryGenerator::initialiseTrajectory(RobotMode mvmnt, double time) {
    // Set the trajectory parameters

    setTrajectoryParameters(movementTrajMap[mvmnt]);
    /*\todo: have this happen getting fed in the intialPose from the robot*/
    return true;
}
/**
 * Action Methods
 */

/*new getSetPoint: almost identical to old exo calcPosition*/
//get the position at any given time
std::vector<double> AlexTrajectoryGenerator::getSetPoint(time_tt time) {
    /*Intialize data*/
    std::vector<double> angles;
    // Discretise/Sample the spline
    time_tt startTime = trajectoryJointSpline.times.front();
    time_tt endTime = trajectoryJointSpline.times.back();
    // Every sample time, compute the value of q1 to q6 based on the time segment / set of NO_JOINTS polynomials
    int numPoints = trajectoryJointSpline.times.size();
    int numPolynomials = numPoints - 1;
    CubicPolynomial currentPolynomial[ALEX_NUM_JOINTS];

    for (int polynomial_index = 0; polynomial_index < numPolynomials; polynomial_index++) {
        //if the jointspaceState time is bounded by the section of spline

        if (time >= trajectoryJointSpline.times.at(polynomial_index) &&
            time <= trajectoryJointSpline.times.at(polynomial_index + 1)) {
            //std::cout << ""time "" << time << ""\t"" << trajectoryJointSpline.times.at(polynomial_index)  << std::endl;
            for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
                currentPolynomial[i] = trajectoryJointSpline.polynomials[i].at(polynomial_index);
                angles.push_back(evaluate_cubic_polynomial(currentPolynomial[i], time));
            }
            ////force ankles to be in the final position
            //currentPolynomial[ALEX_LEFT_ANKLE]= trajectoryJointSpline.polynomials[ALEX_LEFT_ANKLE].at(numPolynomials - 1);
            //positionArray[ALEX_LEFT_ANKLE]= evaluate_cubic_polynomial(currentPolynomial[ALEX_LEFT_ANKLE], endTime);
            //currentPolynomial[ALEX_RIGHT_ANKLE]= trajectoryJointSpline.polynomials[ALEX_RIGHT_ANKLE].at(numPolynomials - 1);
            //positionArray[ALEX_RIGHT_ANKLE]= evaluate_cubic_polynomial(currentPolynomial[ALEX_RIGHT_ANKLE], endTime);
            //make sure the angles are within boundary
            limit_position_against_angle_boundary(angles);
            return angles;
        }
    }
    //if the time point is outside range
    for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
        currentPolynomial[i] = trajectoryJointSpline.polynomials[i].at(numPolynomials - 1);
        angles.push_back(evaluate_cubic_polynomial(currentPolynomial[i], endTime));
    }
    //make sure the angles are within boundary
    limit_position_against_angle_boundary(angles);
    //else return previous poly
    return angles;
}
// handle error if reached
/***********************************************************************
Methods to Set Trajectory and Pilot Parameters
***********************************************************************/
void AlexTrajectoryGenerator::setTrajectoryParameters(TrajectoryParameters trajectoryParameter) {
    this->trajectoryParameter = trajectoryParameter;
    printTrajectoryParameters();
}

void AlexTrajectoryGenerator::setPilotParameters(PilotParameters pilotParameters) {
    this->pilotParameters = pilotParameters;
//    spdlog::debug(""Pilot Paramaters set"");
}

/**
 * Debugging Methods
 */
void AlexTrajectoryGenerator::printTrajectoryParameters() {
    //std::cout << ""Step height:"" << ((AlexTrajectoryGenerator *)trajectoryGenerator)->trajectoryParameter.step_height << std::endl;
    //std::cout << ""Slope angle: "" << ((AlexTrajectoryGenerator *)trajectoryGenerator)->trajectoryParameter.slope_angle << std::endl;

    std::cout << ""Step Type: "" << StepTypeToString[trajectoryParameter.stepType] << std::endl;
}
/*
void AlexTrajectoryGenerator::setTrajectoryParameters(time_tt step_duration, double step_height, double step_length, double hip_height_slack, double torso_forward_angle, double swing_ankle_down_angle,
                                                      Foot stance_foot, StepType movement, double seat_height, double step_end_height, double slope_angle, bool left_foot_on_tilt, bool right_foot_on_tilt) {
    trajectoryParameter.step_duration = step_duration;
    trajectoryParameter.step_height = step_height;
    trajectoryParameter.step_length = step_length;
    trajectoryParameter.hip_height_slack = hip_height_slack;
    trajectoryParameter.torso_forward_angle = torso_forward_angle;
    trajectoryParameter.swing_ankle_down_angle = swing_ankle_down_angle;
    trajectoryParameter.stance_foot = stance_foot;
    trajectoryParameter.stepType = movement;
    trajectoryParameter.seat_height = seat_height;
    trajectoryParameter.step_end_height = step_end_height;
    trajectoryParameter.slope_angle = slope_angle;
    trajectoryParameter.left_foot_on_tilt = left_foot_on_tilt;
    trajectoryParameter.right_foot_on_tilt = right_foot_on_tilt;
}

void AlexTrajectoryGenerator::setPilotParameters(double lowerleg_length, double upperleg_length, double ankle_height, double foot_length,
                                                 double hip_width, double torso_length, double buttocks_height) {
    pilotParameters.lowerleg_length = lowerleg_length;
    pilotParameters.upperleg_length = upperleg_length;
    pilotParameters.ankle_height = ankle_height;
    pilotParameters.foot_length = foot_length;
    pilotParameters.hip_width = hip_width;
    pilotParameters.torso_length = torso_length;
    pilotParameters.buttocks_height = buttocks_height;
}*/

/**********************************************************************

Functions for taskspace and joint space conversion

**********************************************************************/
std::vector<taskspace_state> AlexTrajectoryGenerator::generate_key_taskspace_states(taskspace_state initialTaskspaceState,
                                                                                    const TrajectoryParameters &trajectoryParameters, const PilotParameters &pilotParameters) {
    std::vector<taskspace_state> keyTaskspaceStates;
    double deltaFootDistance = 0.05;

    // Sit-stand
    if (trajectoryParameters.stepType == StepType::Stand) {
        double seatHeight = trajectoryParameters.seat_height;
        double buttocksHeight = pilotParameters.buttocks_height;
        {
            taskspace_state state0 = initialTaskspaceState;  // init
            state0.time = 0.4;
            state0.left_ankle_position.x = 0;
            state0.right_ankle_position.x = 0;
            state0.left_ankle_position.z = pilotParameters.ankle_height;
            state0.right_ankle_position.z = pilotParameters.ankle_height;
            state0.hip_position.x = -sin(deg2rad(85)) * (pilotParameters.upperleg_length);
            state0.hip_position.z =
                pilotParameters.lowerleg_length + pilotParameters.ankle_height + cos(deg2rad(85)) * pilotParameters.upperleg_length;
            state0.torso_forward_angle = trajectoryParameters.torso_forward_angle * 5;
            state0.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(state0);
        }
        {
            taskspace_state state1 = initialTaskspaceState;  // init
            state1.time = 0.6;
            state1.left_ankle_position.x = 0;
            state1.right_ankle_position.x = 0;
            state1.left_ankle_position.z = pilotParameters.ankle_height;
            state1.right_ankle_position.z = pilotParameters.ankle_height;
            state1.hip_position.x = -sin(deg2rad(60)) * (pilotParameters.upperleg_length);
            state1.hip_position.z =
                pilotParameters.lowerleg_length + pilotParameters.ankle_height + cos(deg2rad(60)) * pilotParameters.upperleg_length;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle * 5;
            state1.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(state1);
        }
        {
            taskspace_state state2 = initialTaskspaceState;  // init
            state2.time = 0.80;
            state2.left_ankle_position.x = 0;
            state2.right_ankle_position.x = 0;
            state2.left_ankle_position.z = pilotParameters.ankle_height;
            state2.right_ankle_position.z = pilotParameters.ankle_height;
            state2.hip_position.x = -sin(deg2rad(15)) * (pilotParameters.upperleg_length);
            state2.hip_position.z =
                pilotParameters.lowerleg_length + pilotParameters.ankle_height + cos(deg2rad(15)) * pilotParameters.upperleg_length;
            state2.torso_forward_angle = trajectoryParameters.torso_forward_angle * 3;
            state2.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(state2);
        }
        {
            taskspace_state stateEnd = initialTaskspaceState;  // init
            stateEnd.time = 1;
            stateEnd.left_ankle_position.x = 0;
            stateEnd.right_ankle_position.x = 0;
            stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
            stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
            stateEnd.hip_position.x =
                0;
            stateEnd.hip_position.z =
                pilotParameters.ankle_height + pilotParameters.upperleg_length + pilotParameters.lowerleg_length - trajectoryParameters.hip_height_slack;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle * 1;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }
    }

    // Stand-sit
    if (trajectoryParameters.stepType == StepType::Sit) {
        double seatHeight = trajectoryParameters.seat_height;
        double buttocksHeight = pilotParameters.buttocks_height;

        {
            taskspace_state state1 = initialTaskspaceState;  // init
            state1.time = 0.8;
            state1.left_ankle_position.x = 0;
            state1.right_ankle_position.x = 0;
            state1.left_ankle_position.z = pilotParameters.ankle_height;
            state1.right_ankle_position.z = pilotParameters.ankle_height;

            state1.hip_position.x =
                -0.5 * (pilotParameters.upperleg_length);
            state1.hip_position.z =
                (seatHeight + buttocksHeight) + 0.6 * (pilotParameters.ankle_height + pilotParameters.upperleg_length + pilotParameters.lowerleg_length - trajectoryParameters.hip_height_slack - (seatHeight + buttocksHeight));  // how far away from seat height
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle * 5;
            state1.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(state1);
        }

        {
            taskspace_state stateEnd = initialTaskspaceState;  // init
            stateEnd.time = 1.0;
            stateEnd.left_ankle_position.x = 0;
            stateEnd.right_ankle_position.x = 0;
            stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
            stateEnd.right_ankle_position.z = pilotParameters.ankle_height;

            stateEnd.hip_position.x =
                -1 * (pilotParameters.upperleg_length);
            stateEnd.hip_position.z =
                (seatHeight + buttocksHeight);
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle * 5;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }
    }
    // Sitting
    if (trajectoryParameters.stepType == StepType::Sitting) {
        double seatHeight = trajectoryParameters.seat_height;
        double buttocksHeight = pilotParameters.buttocks_height;

        {
            taskspace_state stateEnd = initialTaskspaceState;  // init
            stateEnd.time = 1;
            stateEnd.left_ankle_position.x = 0;
            stateEnd.right_ankle_position.x = 0;
            stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
            stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
            stateEnd.hip_position.x =
                -1 * (pilotParameters.upperleg_length);
            stateEnd.hip_position.z =
                seatHeight + buttocksHeight;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }
    }

    // Walk
    if (trajectoryParameters.stepType == StepType::Walk) {
        

        
        Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
                                       ? Foot::Left
                                       : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double stepDisplacement = ankleDistance + trajectoryParameters.step_length;
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);

        // TrajectoryGenerator forming algorithm here
        //  All key states except initial state

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance;
                state1.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height;
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
            } else {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance;
                state1.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height;
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
            }
            state1.hip_position.z = hipHeight;  // probably should deal with rounding error that makes hipheight slightly larger than leglength?
            state1.time = 0.4;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state1);
            
            std::cout << ""State1 Left.X""<< state1.left_ankle_position.x << std::endl;
            std::cout << ""State1 Left.Z""<< state1.left_ankle_position.z << std::endl;
            std::cout << ""State1 Right.X""<< state1.right_ankle_position.x << std::endl;
            std::cout << ""State1 Right.Z""<< state1.right_ankle_position.z << std::endl;
            std::cout << ""State1 Hip.X""<< state1.hip_position.x << std::endl;

        }

        {
            taskspace_state state2 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + 0.25;
                } else {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.left_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height;
                state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state2.right_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 3.0;
            } else {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + 0.25;
                } else {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.right_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height;
                state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state2.left_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 3.0;
            }
            state2.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length / 3.0, 2.0)));
            state2.time = 0.7;
            state2.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state2.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state2);
            
            std::cout << ""State2 Left.X""<< state2.left_ankle_position.x << std::endl;
            std::cout << ""State2 Left.Z""<< state2.left_ankle_position.z << std::endl;
            std::cout << ""State2 Right.X""<< state2.right_ankle_position.x << std::endl;
            std::cout << ""State2 Right.Z""<< state2.right_ankle_position.z << std::endl;
            std::cout << ""State1 Hip.X""<< state2.hip_position.x << std::endl;
   
        }

        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length * 2.999 / 3.0;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height+trajectoryParameters.step_end_height/2.0;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;


            }

            else {
                stateEnd.right_ankle_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length * 2.999/ 3.0;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height+trajectoryParameters.step_end_height/2.0;
            }
            //if stand together
            if (trajectoryParameters.step_length < 0.1) {
                stateEnd.hip_position.z = pilotParameters.ankle_height + legLengthSlacked;
            } else {
                stateEnd.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length * 2.999 / 3.0, 2.0)));
            }
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
            
            std::cout << ""StateEnd Left.X""<< stateEnd.left_ankle_position.x << std::endl;
            std::cout << ""StateEnd Left.Z""<< stateEnd.left_ankle_position.z << std::endl;
            std::cout << ""StateEnd Right.X""<< stateEnd.right_ankle_position.x << std::endl;
            std::cout << ""StateEnd Right.Z""<< stateEnd.right_ankle_position.z << std::endl;
            std::cout << ""StateEnd Hip.X""<< stateEnd.hip_position.x << std::endl;

        }
    }

    // Back
    if (trajectoryParameters.stepType == StepType::Back)

    {
        Foot backwardStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
                                       ? Foot::Right
                                       : Foot::Left);
        if (initialTaskspaceState.stance_foot != backwardStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Backward stance foot isn't at the back!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double stepDisplacement = ankleDistance + trajectoryParameters.step_length;
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;

        // TrajectoryGenerator forming algorithm here
        //  All key states except initial state

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Left)
            //||	abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x - ankleDistance;
                state1.right_ankle_position.z = initialTaskspaceState.right_ankle_position.z + trajectoryParameters.step_height;
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
            } else {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x - ankleDistance;
                state1.left_ankle_position.z = initialTaskspaceState.left_ankle_position.z + trajectoryParameters.step_height;
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
            }
            state1.hip_position.z = hipHeight;  // probably should deal with rounding error that makes hipheight slightly larger than leglength?
            state1.time = 0.5;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state1);
        }
        //Post Middle step
        {
            taskspace_state state2 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Left) {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x - ankleDistance + 0.1;
                } else {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x - ankleDistance - trajectoryParameters.step_length / 2.0;
                }
                state2.right_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height;
                state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state2.left_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.left_ankle_position.x - trajectoryParameters.step_length / 3.0;
            } else {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x - ankleDistance + 0.1;
                } else {
                    state2.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x - ankleDistance - trajectoryParameters.step_length / 2.0;
                }
                state2.left_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height;
                state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state2.right_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.right_ankle_position.x - trajectoryParameters.step_length / 3.0;
            }
            state2.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length / 3.0, 2.0)));
            state2.time = 0.7;
            state2.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state2.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state2);
        }
        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Left)
            //||	abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                stateEnd.right_ankle_position.x = initialTaskspaceState.left_ankle_position.x - trajectoryParameters.step_length;
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x - trajectoryParameters.step_length / 2.0;
            } else {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x - trajectoryParameters.step_length;
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x - trajectoryParameters.step_length / 2.0;
            }
            stateEnd.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_end_height;
            stateEnd.right_ankle_position.z = pilotParameters.ankle_height+  trajectoryParameters.step_end_height;
            stateEnd.hip_position.z = pilotParameters.ankle_height + sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length / 2.0, 2.0));
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }
    }
    //stairs
    if (trajectoryParameters.stepType == StepType::Stair) {
        taskspace_state state1 = initialTaskspaceState;
        state1.time=1.5;
        keyTaskspaceStates.push_back(state1);
        
        /*
        Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
                                       ? Foot::Left
                                       : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double heightDistance = abs(initialTaskspaceState.left_ankle_position.z - initialTaskspaceState.right_ankle_position.z);
        double stepDisplacement = ankleDistance + trajectoryParameters.step_length;
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);

        // TrajectoryGenerator forming algorithm here
        //  All key states except initial state

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance;
                state1.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height;
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
            } else {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance;
                state1.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height;
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
            }
            state1.hip_position.z = hipHeight;  // probably should deal with rounding error that makes hipheight slightly larger than leglength?
            state1.time = 0.4;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state1);
            std::cout << ""State1 Left.X""<< state1.left_ankle_position.x << std::endl;
            std::cout << ""State1 Left.Z""<< state1.left_ankle_position.z << std::endl;
            std::cout << ""State1 Right.X""<< state1.right_ankle_position.x << std::endl;
            std::cout << ""State1 Right.Z""<< state1.right_ankle_position.z << std::endl;
        }

        {
            taskspace_state state2 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                //A forward left swing
                state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + 0.7 * sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                state2.left_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height + trajectoryParameters.step_end_height;
                state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state2.right_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length * 0.0 / 3.0;
            } else {
                //if stand together
                state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + 0.35;
                state2.right_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height;
                state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state2.left_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length * 0.0 / 3.0;
            }
            state2.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length * 0.0 / 3.0, 2.0)));
            state2.time = 0.7;
            state2.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state2.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state2);
            std::cout << ""State2 Left.X""<< state2.left_ankle_position.x << std::endl;
            std::cout << ""State2 Left.Z""<< state2.left_ankle_position.z << std::endl;
            std::cout << ""State2 Right.X""<< state2.right_ankle_position.x << std::endl;
            std::cout << ""State2 Right.Z""<< state2.right_ankle_position.z << std::endl;

        }

        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_end_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.hip_position.z = pilotParameters.ankle_height + legLengthSlacked;
            }

            else {
                stateEnd.right_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.hip_position.z = pilotParameters.ankle_height + legLengthSlacked;
            }
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
            std::cout << ""StateEnd Left.X""<< stateEnd.left_ankle_position.x << std::endl;
            std::cout << ""StateEnd Left.Z""<< stateEnd.left_ankle_position.z << std::endl;
            std::cout << ""StateEnd Right.X""<< stateEnd.right_ankle_position.x << std::endl;
            std::cout << ""StateEnd Right.Z""<< stateEnd.right_ankle_position.z << std::endl;
        }*/
    }
    //down stairs
    if (trajectoryParameters.stepType == StepType::DownStair) {
        taskspace_state state1 = initialTaskspaceState;
        state1.time=1.5;
        keyTaskspaceStates.push_back(state1);

        /*Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
                                       ? Foot::Left
                                       : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double heightDistance = abs(initialTaskspaceState.left_ankle_position.z - initialTaskspaceState.right_ankle_position.z);
        double stepDisplacement = ankleDistance + trajectoryParameters.step_length;
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);

        // TrajectoryGenerator forming algorithm here
        //  All key states except initial state

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
              //A backward left swing
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x - ankleDistance;
                state1.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height * .85;
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
            } else {
              //A backward right swing
                // based on eye balling state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x - ankleDistance - 0.1; // with 0.2 seems to just clear the step, to be tested
                // state1.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height * 1.05;
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x - ankleDistance - 0.2; // with 0.2 seems to just clear the step, to be tested
                state1.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height * 0.85;
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
            }
            state1.hip_position.z = hipHeight;  // probably should deal with rounding error that makes hipheight slightly larger than leglength?
            state1.time = 0.5;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state1);
        }

        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
              //A backward left swing, ending in a left foot backward/right foot forward state
                // based on 16/10 eye balling stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x - stepDisplacement + 0.05;
                stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x - stepDisplacement;
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                stateEnd.hip_position.x = stateEnd.left_ankle_position.x;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height - trajectoryParameters.step_end_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.hip_position.z = stateEnd.left_ankle_position.z + legLengthSlacked;
            }

            else {
              //A backward right swing, ending in a step tgt
                stateEnd.right_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.hip_position.x = stateEnd.right_ankle_position.x;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.hip_position.z = stateEnd.right_ankle_position.z + legLengthSlacked;
            }
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }*/
    }

    //Ramp up
    if (trajectoryParameters.stepType == StepType::RampUp) {
        Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
            ? Foot::Left
            : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double stepDisplacement = ankleDistance + trajectoryParameters.step_length;
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);

        // TrajectoryGenerator forming algorithm here
        //  All key states except initial state

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
                //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance;
                state1.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height + trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
            }
            else {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance;
                state1.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height + trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
            }
            state1.hip_position.z = hipHeight;  // probably should deal with rounding error that makes hipheight slightly larger than leglength?
            state1.time = 0.4;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle * 0;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state1);
        }

        {
            taskspace_state state2 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
                //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + 0.3;
                }
                else {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.left_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height + trajectoryParameters.step_end_height;
                state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state2.right_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 3.0;
            }
            else {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + 0.3;
                }
                else {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.right_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height + trajectoryParameters.step_end_height;
                state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state2.left_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 3.0;
            }
            state2.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length / 3.0, 2.0)));
            state2.time = 0.70;
            state2.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state2.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state2);
        }
        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
                //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_end_height;
            }

            else {
                stateEnd.right_ankle_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_end_height;
            }

            //if stand together
            if (trajectoryParameters.step_length < 0.1) {
                stateEnd.hip_position.z = pilotParameters.ankle_height + legLengthSlacked;
            }
            else {
                stateEnd.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length /2.0, 2.0)));
            }
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }
    }

    //Ramp down

    if (trajectoryParameters.stepType == StepType::RampDown) {
        Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
            ? Foot::Left
            : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double stepDisplacement = ankleDistance + trajectoryParameters.step_length;
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);

        // TrajectoryGenerator forming algorithm here
        //  All key states except initial state

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
                //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance;
                state1.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height - trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
            }
            else {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance;
                state1.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height - trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
            }
            state1.hip_position.z = hipHeight;  // probably should deal with rounding error that makes hipheight slightly larger than leglength?
            state1.time = 0.4;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle * 0;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state1);
        }

        {
            taskspace_state state2 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
                //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + 0.3;
                }
                else {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.left_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height + trajectoryParameters.step_end_height;
                state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state2.right_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 3.0;
            }
            else {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + 0.3;
                }
                else {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.right_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height + trajectoryParameters.step_end_height;
                state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state2.left_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 3.0;
            }
            state2.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length / 3.0, 2.0)));
            state2.time = 0.70;
            state2.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state2.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state2);
        }
        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
                //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_end_height;
            }

            else {
                stateEnd.right_ankle_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_end_height;
            }

            //if stand together
            if (trajectoryParameters.step_length < 0.1) {
                stateEnd.hip_position.z = pilotParameters.ankle_height + legLengthSlacked;
            }
            else {
                stateEnd.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length / 2.0, 2.0)));
            }
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }
    }

    //Tilt up
    if (trajectoryParameters.stepType == StepType::TiltUp) {
        Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
                                       ? Foot::Left
                                       : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double heightDistance = abs(initialTaskspaceState.left_ankle_position.z - initialTaskspaceState.right_ankle_position.z);
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);
        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance;
                state1.left_ankle_position.z = initialTaskspaceState.left_ankle_position.z + trajectoryParameters.step_height + heightDistance + trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = initialTaskspaceState.right_ankle_position.z;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.hip_position.z = initialTaskspaceState.right_ankle_position.z + hipHeight - pilotParameters.ankle_height;
            } else {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance;
                state1.right_ankle_position.z = initialTaskspaceState.right_ankle_position.z + trajectoryParameters.step_height + heightDistance + trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = initialTaskspaceState.left_ankle_position.z;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.hip_position.z = initialTaskspaceState.left_ankle_position.z + hipHeight - pilotParameters.ankle_height;
            }
            state1.time = 0.5;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, but zero it out anyways
            keyTaskspaceStates.push_back(state1);
        }
        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + trajectoryParameters.step_length * cos(trajectoryParameters.slope_angle);
                stateEnd.left_ankle_position.z = initialTaskspaceState.right_ankle_position.z + heightDistance + trajectoryParameters.step_length * sin(trajectoryParameters.slope_angle);
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.hip_position.z = initialTaskspaceState.right_ankle_position.z + hipHeight - pilotParameters.ankle_height;
            }

            else {
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + trajectoryParameters.step_length * cos(trajectoryParameters.slope_angle);
                stateEnd.right_ankle_position.z = initialTaskspaceState.right_ankle_position.z + heightDistance + trajectoryParameters.step_length * sin(trajectoryParameters.slope_angle);
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.hip_position.z = initialTaskspaceState.left_ankle_position.z + hipHeight - pilotParameters.ankle_height;
            }
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }
    }

    //Tilt down
    if (trajectoryParameters.stepType == StepType::TiltDown) {
        Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
            ? Foot::Left
            : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double heightDistance = abs(initialTaskspaceState.left_ankle_position.z - initialTaskspaceState.right_ankle_position.z);
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance;
                state1.left_ankle_position.z = initialTaskspaceState.left_ankle_position.z + trajectoryParameters.step_height + heightDistance - trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = initialTaskspaceState.right_ankle_position.z;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.hip_position.z = initialTaskspaceState.right_ankle_position.x + hipHeight - pilotParameters.ankle_height;
            }
            else {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance;
                state1.right_ankle_position.z = initialTaskspaceState.right_ankle_position.z + trajectoryParameters.step_height + heightDistance - trajectoryParameters.step_length * sin(trajectoryParameters.swing_ankle_down_angle);
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = initialTaskspaceState.left_ankle_position.z;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.hip_position.z = initialTaskspaceState.left_ankle_position.z + hipHeight - pilotParameters.ankle_height;
            }

            state1.time = 0.5;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state1.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(state1);

        }

        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + trajectoryParameters.step_length * cos(trajectoryParameters.slope_angle);
                stateEnd.left_ankle_position.z = initialTaskspaceState.right_ankle_position.z + heightDistance + trajectoryParameters.step_length * sin(trajectoryParameters.slope_angle);
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.hip_position.z = initialTaskspaceState.right_ankle_position.z + hipHeight - pilotParameters.ankle_height;
            }
            else {
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + trajectoryParameters.step_length * cos(trajectoryParameters.slope_angle);
                stateEnd.left_ankle_position.z = initialTaskspaceState.right_ankle_position.z + heightDistance + trajectoryParameters.step_length * sin(trajectoryParameters.slope_angle);
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 2.0;
                stateEnd.hip_position.z = initialTaskspaceState.left_ankle_position.z + hipHeight - pilotParameters.ankle_height;
            }

            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
        }

    }


    //Uneven ground, basically a mixture of walk and stair
    if (trajectoryParameters.stepType == StepType::Uneven) {
        

        
        Foot inferredStanceFoot = ((initialTaskspaceState.left_ankle_position.x > initialTaskspaceState.right_ankle_position.x)
                                       ? Foot::Left
                                       : Foot::Right);
        if (initialTaskspaceState.stance_foot != inferredStanceFoot)
            std::cout << ""[generate_key_taskspace_states] Stance foot isn't in front of swing foot!?!!"" << std::endl;
        double ankleDistance = abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x);
        double stepDisplacement = ankleDistance + trajectoryParameters.step_length;
        double legLengthSlacked = pilotParameters.lowerleg_length + pilotParameters.upperleg_length - trajectoryParameters.hip_height_slack;
        double hipHeight = pilotParameters.ankle_height + legLengthSlacked;
        double stanceFoot_x = std::max(initialTaskspaceState.left_ankle_position.x, initialTaskspaceState.right_ankle_position.x);

        // TrajectoryGenerator forming algorithm here
        //  All key states except initial state

        // Middle state
        {
            taskspace_state state1 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance;
                state1.left_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height;
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state1.right_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.right_ankle_position.x;
            } else {
                state1.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance;
                state1.right_ankle_position.z = pilotParameters.ankle_height + trajectoryParameters.step_height;
                state1.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state1.left_ankle_position.z = pilotParameters.ankle_height;
                state1.hip_position.x = initialTaskspaceState.left_ankle_position.x;
            }
            state1.hip_position.z = hipHeight;  // probably should deal with rounding error that makes hipheight slightly larger than leglength?
            state1.time = 0.4;
            state1.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state1.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state1);
            
            std::cout << ""State1 Left.X""<< state1.left_ankle_position.x << std::endl;
            std::cout << ""State1 Left.Z""<< state1.left_ankle_position.z << std::endl;
            std::cout << ""State1 Right.X""<< state1.right_ankle_position.x << std::endl;
            std::cout << ""State1 Right.Z""<< state1.right_ankle_position.z << std::endl;
            std::cout << ""State1 Hip.X""<< state1.hip_position.x << std::endl;

        }

        {
            taskspace_state state2 = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + 0.25;
                } else {
                    state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.left_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height;
                state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                state2.right_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length / 3.0;
            } else {
                //if stand together
                if (trajectoryParameters.step_length < 0.1) {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + 0.25;
                } else {
                    state2.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x + ankleDistance + sqrt(pow(legLengthSlacked, 2.0) - pow(legLengthSlacked - trajectoryParameters.step_length * trajectoryParameters.step_height, 2.0));
                }
                state2.right_ankle_position.z = pilotParameters.ankle_height + 0.5 * trajectoryParameters.step_height;
                state2.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                state2.left_ankle_position.z = pilotParameters.ankle_height;
                state2.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length / 3.0;
            }
            state2.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length / 3.0, 2.0)));
            state2.time = 0.7;
            state2.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            state2.swing_ankle_down_angle = 0.0;  // could be non-zero due to slight issues in forward kinematics/positioning, btu zero it out anyways
            keyTaskspaceStates.push_back(state2);
            
            std::cout << ""State2 Left.X""<< state2.left_ankle_position.x << std::endl;
            std::cout << ""State2 Left.Z""<< state2.left_ankle_position.z << std::endl;
            std::cout << ""State2 Right.X""<< state2.right_ankle_position.x << std::endl;
            std::cout << ""State2 Right.Z""<< state2.right_ankle_position.z << std::endl;
            std::cout << ""State1 Hip.X""<< state2.hip_position.x << std::endl;
   
        }

        // Final state
        {
            taskspace_state stateEnd = initialTaskspaceState;
            if (initialTaskspaceState.stance_foot == Foot::Right)
            //|| abs(initialTaskspaceState.left_ankle_position.x - initialTaskspaceState.right_ankle_position.x) <= deltaFootDistance)
            {
                stateEnd.left_ankle_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.right_ankle_position.x = initialTaskspaceState.right_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.right_ankle_position.x + trajectoryParameters.step_length * 2.999 / 3.0;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height+trajectoryParameters.step_end_height/2.0;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height;


            }

            else {
                stateEnd.right_ankle_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length;
                stateEnd.left_ankle_position.x = initialTaskspaceState.left_ankle_position.x;
                stateEnd.hip_position.x = initialTaskspaceState.left_ankle_position.x + trajectoryParameters.step_length * 2.999/ 3.0;
                stateEnd.left_ankle_position.z = pilotParameters.ankle_height;
                stateEnd.right_ankle_position.z = pilotParameters.ankle_height+trajectoryParameters.step_end_height/2.0;
            }
            //if stand together
            if (trajectoryParameters.step_length < 0.1) {
                stateEnd.hip_position.z = pilotParameters.ankle_height + legLengthSlacked;
            } else {
                stateEnd.hip_position.z = pilotParameters.ankle_height + 0.999 * (sqrt(pow(legLengthSlacked, 2.0) - pow(trajectoryParameters.step_length * 2.999 / 3.0, 2.0)));
            }
            stateEnd.time = 1;
            stateEnd.torso_forward_angle = trajectoryParameters.torso_forward_angle;
            stateEnd.swing_ankle_down_angle = 0.0;
            keyTaskspaceStates.push_back(stateEnd);
            
            std::cout << ""StateEnd Left.X""<< stateEnd.left_ankle_position.x << std::endl;
            std::cout << ""StateEnd Left.Z""<< stateEnd.left_ankle_position.z << std::endl;
            std::cout << ""StateEnd Right.X""<< stateEnd.right_ankle_position.x << std::endl;
            std::cout << ""StateEnd Right.Z""<< stateEnd.right_ankle_position.z << std::endl;
            std::cout << ""StateEnd Hip.X""<< stateEnd.hip_position.x << std::endl;

        }
        
    }
    return keyTaskspaceStates;
}

// Generates discrete trajectory from parameters to use in control system
void AlexTrajectoryGenerator::compute_discrete_trajectory(
    const TrajectoryParameters &trajectoryParameters,
    const PilotParameters &pilotParameters,
    jointspace_state initialJointspaceState) {
    Foot stanceFoot = trajectoryParameters.stance_foot;
    taskspace_state initialTaskspaceState;
    std::vector<taskspace_state> taskspaceStates;
    std::vector<jointspace_state> jointspaceStates;
    jointspace_spline jointspaceSpline;

    initialTaskspaceState = jointspace_state_to_taskspace_state(initialJointspaceState, trajectoryParameters, pilotParameters);

    // Obtain key tTrajectoryParameters //  (output excludes initial state which is already known in jointspace)
    taskspaceStates = generate_key_taskspace_states(initialTaskspaceState, trajectoryParameters, pilotParameters);
    //printing the initial taskspace state
    std::cout << ""[compute_trajectory]: Keypoints (taskspace):"" << std::endl;
    std::cout << ""[compute_trajectory]:""
              << ""\t""
              << ""time | left_ankle_position | hip_position | right_ankle_position | torso_forward_angle | swing_ankle_down_angle""
              << std::endl;
    std::cout << ""[compute_trajectory]:""
              << ""\t""
              << initialTaskspaceState.time << ""\t""
              << "" | ""
              << initialTaskspaceState.left_ankle_position.x << ""\t""
              << initialTaskspaceState.left_ankle_position.y << ""\t""
              << initialTaskspaceState.left_ankle_position.z << ""\t""
              << "" | ""
              << initialTaskspaceState.hip_position.x << ""\t""
              << initialTaskspaceState.hip_position.y << ""\t""
              << initialTaskspaceState.hip_position.z << ""\t""
              << "" | ""
              << initialTaskspaceState.right_ankle_position.x << ""\t""
              << initialTaskspaceState.right_ankle_position.y << ""\t""
              << initialTaskspaceState.right_ankle_position.z << ""\t""
              << "" | ""
              << initialTaskspaceState.torso_forward_angle << ""\t""
              << "" | ""
              << initialTaskspaceState.swing_ankle_down_angle
              << std::endl;
    //printing the middle and last task space states
    for (auto currentState : taskspaceStates) {
        std::cout << ""[compute_trajectory]:""
                  << ""\t""
                  << currentState.time << ""\t""
                  << ""|""
                  << currentState.left_ankle_position.x << ""\t""
                  << currentState.left_ankle_position.y << ""\t""
                  << currentState.left_ankle_position.z << ""\t""
                  << ""|""
                  << currentState.hip_position.x << ""\t""
                  << currentState.hip_position.y << ""\t""
                  << currentState.hip_position.z << ""\t""
                  << ""|""
                  << currentState.right_ankle_position.x << ""\t""
                  << currentState.right_ankle_position.y << ""\t""
                  << currentState.right_ankle_position.z << ""\t""
                  << ""|""
                  << currentState.torso_forward_angle << ""\t""
                  << ""|""
                  << currentState.swing_ankle_down_angle
                  << std::endl;
    }

    // Convert key states to jointspace (prepend known initial jointspace state)
    jointspaceStates = taskspace_states_to_jointspace_states(initialJointspaceState, taskspaceStates, trajectoryParameters, pilotParameters);

    std::cout << ""[compute_trajectory]: Keypoints (jointspace):""
              << ""LEFT_HIP""
              << ""\t""
              << ""LEFT_KNEE""
              << ""\t""
              << ""RIGHT_HIP""
              << ""\t""
              << ""RIGHT_KNEE""
              << ""\t""
              << ""LEFT_ANKLE""
              << ""\t""
              << ""RIGHT_ANKLE"" << std::endl;
    for (auto state : jointspaceStates) {
        std::cout << ""[compute_trajectory]:\t"" << state.time << ""\t\t\t"";
        for (int i = 0; i < ALEX_NUM_JOINTS; i++)
            std::cout << rad2deg(state.q[i]) << ""\t  "";
        std::cout << std::endl;
    }
}

taskspace_state AlexTrajectoryGenerator::jointspace_state_to_taskspace_state(
    jointspace_state jointspaceState,
    TrajectoryParameters trajectoryParameters,
    PilotParameters pilotParameters) {
    taskspace_state taskspaceState{};

    // q's in a reference frame - imagine a 6link thing positioned with all angles at '0' (horizontal), then only PI is
    //  needed to be added at hip/right_leg to get exo
    double *q = jointspaceState.q;  // for readability; will be optimised out by compiler?
    //calculate the torso forward angle from left joints, which is repsect to world space vertical up
    double torso_forward_angle = M_PI_2 + q[ALEX_LEFT_ANKLE]- q[ALEX_LEFT_KNEE]- q[ALEX_LEFT_HIP];
    // Perform Forward Kinematics
    //  Put origin at base of Stance foot, vertically below the ankle
    //  Assume hip has zero width for now
    taskspaceState.left_ankle_position.x = 0.0;
    taskspaceState.left_ankle_position.y = 0.0;
    taskspaceState.left_ankle_position.z = pilotParameters.ankle_height;
    if (trajectoryParameters.left_foot_on_tilt) {
        taskspaceState.hip_position.x = taskspaceState.left_ankle_position.x - pilotParameters.lowerleg_length * (cos(q[ALEX_LEFT_ANKLE]+ deg2rad(trajectoryParameters.slope_angle))) - pilotParameters.upperleg_length * (cos(q[ALEX_LEFT_ANKLE]+ deg2rad(trajectoryParameters.slope_angle - q[ALEX_LEFT_KNEE])));
        taskspaceState.hip_position.y = 0.0;
        taskspaceState.hip_position.z = taskspaceState.left_ankle_position.z + pilotParameters.lowerleg_length * (sin(q[ALEX_LEFT_ANKLE]+ deg2rad(trajectoryParameters.slope_angle))) + pilotParameters.upperleg_length * (sin(q[ALEX_LEFT_ANKLE]+ deg2rad(trajectoryParameters.slope_angle - q[ALEX_LEFT_KNEE])));
    } else {
        taskspaceState.hip_position.x = taskspaceState.left_ankle_position.x - pilotParameters.lowerleg_length * (cos(q[ALEX_LEFT_ANKLE])) - pilotParameters.upperleg_length * (cos(q[ALEX_LEFT_ANKLE]- q[ALEX_LEFT_KNEE]));
        taskspaceState.hip_position.y = 0.0;
        taskspaceState.hip_position.z = taskspaceState.left_ankle_position.z + pilotParameters.lowerleg_length * (sin(q[ALEX_LEFT_ANKLE])) + pilotParameters.upperleg_length * (sin(q[ALEX_LEFT_ANKLE]- q[ALEX_LEFT_KNEE]));
    }
    taskspaceState.right_ankle_position.x = taskspaceState.hip_position.x + pilotParameters.upperleg_length * (sin(M_PI - q[ALEX_RIGHT_HIP]- torso_forward_angle)) - pilotParameters.lowerleg_length * (cos(M_PI_2 + M_PI - q[ALEX_RIGHT_HIP]- torso_forward_angle - q[ALEX_RIGHT_KNEE]));
    taskspaceState.right_ankle_position.y = 0.0;
    taskspaceState.right_ankle_position.z = taskspaceState.hip_position.z - pilotParameters.upperleg_length * (cos(M_PI - q[ALEX_RIGHT_HIP]- torso_forward_angle)) - pilotParameters.lowerleg_length * (sin(M_PI_2 + M_PI - q[ALEX_RIGHT_HIP]- torso_forward_angle - q[ALEX_RIGHT_KNEE]));
    taskspaceState.torso_forward_angle = torso_forward_angle;
    taskspaceState.swing_ankle_down_angle = 0;  //TODO: this is called when converting from robot to trajectory calculation. Do i need this information?
    taskspaceState.stance_foot = trajectoryParameters.stance_foot;
    taskspaceState.time = jointspaceState.time;

    return taskspaceState;
}

jointspace_state AlexTrajectoryGenerator::taskspace_state_to_jointspace_state(
    taskspace_state taskspaceState,
    TrajectoryParameters trajectoryParameters,
    PilotParameters pilotParameters) {
    jointspace_state jointspaceState{};
    // Do the bulk of the computations based on each leg
    std::vector<double> LeftTempAngles = triangle_inverse_kinematics(
        taskspaceState.left_ankle_position.x,
        taskspaceState.left_ankle_position.z,
        taskspaceState.hip_position.x,
        taskspaceState.hip_position.z,
        pilotParameters.lowerleg_length,
        pilotParameters.upperleg_length);
    std::vector<double> RightTempAngles = triangle_inverse_kinematics(
        taskspaceState.right_ankle_position.x,
        taskspaceState.right_ankle_position.z,
        taskspaceState.hip_position.x,
        taskspaceState.hip_position.z,
        pilotParameters.lowerleg_length,
        pilotParameters.upperleg_length);
    //[0] angleAtHip,  // CCW angle of upper leg from vertical down
    //[1] angleAtKnee, // CCW angle of upper leg from straight leg config
    //[2] angleAtAnkle //  CW angle of lower leg from vertical up

    jointspaceState.time = taskspaceState.time;

    
    if (trajectoryParameters.left_foot_on_tilt) {
        jointspaceState.q[ALEX_LEFT_ANKLE]= M_PI_2 + LeftTempAngles.at(2) - trajectoryParameters.slope_angle;
    } else {
        jointspaceState.q[ALEX_LEFT_ANKLE]= M_PI_2 + LeftTempAngles.at(2);
    }

    jointspaceState.q[ALEX_LEFT_ANKLE]= M_PI_2 + LeftTempAngles.at(2);
    jointspaceState.q[ALEX_LEFT_KNEE]= LeftTempAngles.at(1);
    jointspaceState.q[ALEX_LEFT_HIP]= M_PI - LeftTempAngles.at(0) - taskspaceState.torso_forward_angle;
    jointspaceState.q[ALEX_RIGHT_HIP]= M_PI - RightTempAngles.at(0) - taskspaceState.torso_forward_angle;
    jointspaceState.q[ALEX_RIGHT_KNEE]= RightTempAngles.at(1);

    if (trajectoryParameters.right_foot_on_tilt) {
        jointspaceState.q[ALEX_RIGHT_ANKLE]= M_PI_2 + RightTempAngles.at(2) - trajectoryParameters.slope_angle;
    } else {
        jointspaceState.q[ALEX_RIGHT_ANKLE]= M_PI_2 + RightTempAngles.at(2);
    }

    //Code starts here
    
    //87deg is 1.518 rad
    double anklePosStable = 1.518;
    //80deg is 1.396 rad
    //75deg is 1.31 rad
    double  [MASK]  = RAMPANKLE;
    
    if (trajectoryParameters.stepType == StepType::Uneven) {
         [MASK]  = RAMPANKLEMAX;
    }// 1.396;
    double anklePos;

     if (trajectoryParameters.left_foot_on_tilt) {
        jointspaceState.q[ALEX_LEFT_ANKLE]=  [MASK] ;
        anklePos= [MASK] ;
     }
     else{
        jointspaceState.q[ALEX_LEFT_ANKLE]= anklePosStable;
        anklePos=anklePosStable;

     }
     if (trajectoryParameters.right_foot_on_tilt) {
        jointspaceState.q[ALEX_RIGHT_ANKLE]=  [MASK] ;
        anklePos= [MASK] ;

     }
     else{
        jointspaceState.q[ALEX_RIGHT_ANKLE]= anklePosStable;
        anklePos=anklePosStable;

     }
    //std::cout << ""[taskspace_state_to_jointspace_state] set ankle pos to"" << anklePos << std::endl;


    return jointspaceState;
}

std::vector<jointspace_state> AlexTrajectoryGenerator::taskspace_states_to_jointspace_states(
    jointspace_state initialJointspaceState,
    const std::vector<taskspace_state> &taskspaceStates,
    TrajectoryParameters trajectoryParameters,
    PilotParameters pilotParameters) {
    std::vector<jointspace_state> jointspaceStates;
    jointspace_state tempJointspacestate;
    bool containNaN = false;
    jointspaceStates.push_back(initialJointspaceState);
    //First check whether any point in the trajectory contains NaN
    // convert every taskspace state to a jointspace state
    for (auto taskspaceState : taskspaceStates) {
        if(jointspace_NaN_check(taskspace_state_to_jointspace_state(taskspaceState, trajectoryParameters, pilotParameters))){
          containNaN = true;
    //      spdlog::debug(""THE TRAJECTORY CONTAINS NAN"");
        }
    }
    //construct the jointspaceStates with respect to whether it contains NaN
    for (auto taskspaceState : taskspaceStates) {
      if (containNaN == false){
        jointspaceStates.push_back(taskspace_state_to_jointspace_state(taskspaceState, trajectoryParameters, pilotParameters));
      }
      //If any part contains NaN, make all points in jointspaceStates just the initial jointstatespace points
      else{
        tempJointspacestate = taskspace_state_to_jointspace_state(taskspaceState, trajectoryParameters, pilotParameters);
        for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
            tempJointspacestate.q[i] = initialJointspaceState.q[i];
        }
        jointspaceStates.push_back(tempJointspacestate);
      }
    }
    return jointspaceStates;
}

std::vector<double> AlexTrajectoryGenerator::triangle_inverse_kinematics(
    const double xAnkle,
    const double zAnkle,
    const double xHip,
    const double zHip,
    const double Llower,
    const double Lupper) {
    // x is right, z is up; we're looking at the exo from the right side, so it walks rightwards

    const double L = sqrtf((xAnkle - xHip) * (xAnkle - xHip) + (zAnkle - zHip) * (zAnkle - zHip));
    const double angleLAcuteFromVertical = atan2f((xAnkle - xHip), (zHip - zAnkle));
    const double angleInternalHip = acos((Lupper * Lupper + L * L - Llower * Llower) / (2.0 * Lupper * L));
    if (std::isnan(angleInternalHip)) {
 //       spdlog::debug(""acos outside of domain: do not move!"");
        /*\todo throw and catch an error from this is calling function*/
    }
    //const double angleInternalAnkle = asin(sin(angleInternalHip)*Lupper/Llower);
    //const double angleInternalAnkle = acos((Llower * Llower + L * L - Lupper * Lupper) / (2.0 * Llower * L));
    const double angleInternalAnkle = asin(sin(angleInternalHip) * Lupper / Llower);
    const double angleInternalKnee = M_PI - angleInternalHip - angleInternalAnkle;

    const double angleAtHip = angleLAcuteFromVertical + angleInternalHip;
    const double angleAtKnee = M_PI - angleInternalKnee;
    const double angleAtAnkle = angleInternalAnkle - angleLAcuteFromVertical;

    return {
        angleAtHip,   // CCW angle of upper leg from vertical down
        angleAtKnee,  // CCW angle of upper leg from straight leg config
        angleAtAnkle  //  CW angle of lower leg from vertical up
    };
}

/**********************************************************************

Functions for Splines

**********************************************************************/
std::vector<CubicPolynomial> AlexTrajectoryGenerator::cubic_spline(
    double x[],
    time_tt t[],
    int numPoints) {
    std::vector<CubicPolynomial> cubicSplinePolynomials;

    // std::cout << ""[cubic_spline]: x's: "";
    // for (int i = 0; i < numPoints; i++) std::cout << x[i] << ""\t"";
    // std::cout << std::endl;

    // Cubic spline
    // Assume boundary vel and acc are zero.
    const int numPointsm1 = numPoints - 1;
    const int numPolynomials = numPointsm1;
    const int numVias = numPoints - 2;
    const int numPolynomialCoefficients = NUM_CUBIC_COEFFICIENTS;
    const int numUnknowns = numPolynomialCoefficients * numPolynomials;

    Eigen::MatrixXf A = Eigen::MatrixXf::Zero(numUnknowns, numUnknowns);
    Eigen::MatrixXf B = Eigen::MatrixXf::Zero(numUnknowns, 1);
    int offset = 0;
    A.block<2, numPolynomialCoefficients>(offset, 0)
        << 1,
        t[0], t[0] * t[0], t[0] * t[0] * t[0],
        0, 1, 2 * t[0], 3 * t[0] * t[0];
    B.block<2, 1>(offset, 0)
        << x[0],
        0;
    offset += 2;

    A.block<2, numPolynomialCoefficients>(offset, numUnknowns - numPolynomialCoefficients)
        << 1,
        t[numPointsm1], t[numPointsm1] * t[numPointsm1], t[numPointsm1] * t[numPointsm1] * t[numPointsm1],
        0, 1, 2 * t[numPointsm1], 3 * t[numPointsm1] * t[numPointsm1];
    B.block<2, 1>(offset, 0)
        << x[numPointsm1],
        0;
    offset += 2;

    for (int i = 0; i < numVias; i++) {
        int j = i + 1;
        A.block<1, numPolynomialCoefficients>(offset, i * numPolynomialCoefficients)
            << 1,
            t[j], t[j] * t[j], t[j] * t[j] * t[j];
        B.block<1, 1>(offset, 0)
            << x[j];
        offset += 1;
        A.block<1, numPolynomialCoefficients>(offset, j * numPolynomialCoefficients)
            << 1,
            t[j], t[j] * t[j], t[j] * t[j] * t[j];
        B.block<1, 1>(offset, 0)
            << x[j];
        offset += 1;
        A.block<2, 2 * numPolynomialCoefficients>(offset, i * numPolynomialCoefficients)
            << 0,
            1, 2 * t[j], 3 * t[j] * t[j], 0, -1, -2 * t[j], -3 * t[j] * t[j],
            0, 0, 2, 6 * t[j], 0, 0, -2, -6 * t[j];
        B.block<2, 1>(offset, 0)
            << 0,
            0;
        offset += 2;
    }

    Eigen::MatrixXf X = A.inverse() * B;

    for (int i = 0; i < numPolynomials; i++) {
        // cubic (t)
        cubicSplinePolynomials.push_back({.coefficients = {
                                              X(NUM_CUBIC_COEFFICIENTS * i + 0, 0),
                                              X(NUM_CUBIC_COEFFICIENTS * i + 1, 0),
                                              X(NUM_CUBIC_COEFFICIENTS * i + 2, 0),
                                              X(NUM_CUBIC_COEFFICIENTS * i + 3, 0)}});
                                              
    }

    return cubicSplinePolynomials;
}

jointspace_spline AlexTrajectoryGenerator::cubic_spline_jointspace_states(std::vector<jointspace_state> jointspaceStates) {
    jointspace_spline jointspaceSpline;
    // Get times
    for (auto &jointspaceState : jointspaceStates)
        jointspaceSpline.times.push_back(jointspaceState.time);

    // Take spline for each q
    for (int i = 0, numPoints = jointspaceStates.size(); i < ALEX_NUM_JOINTS; i++) {
        double q[numPoints];
        for (int j = 0; j < numPoints; j++) {
            q[j] = jointspaceStates.at(j).q[i];
        }
        jointspaceSpline.polynomials[i] = cubic_spline(q, jointspaceSpline.times.data(), numPoints);
    }

    return jointspaceSpline;
}

double AlexTrajectoryGenerator::evaluate_cubic_polynomial(CubicPolynomial cubicPolynomial, time_tt time) {
    return cubicPolynomial.coefficients[0] + cubicPolynomial.coefficients[1] * time + cubicPolynomial.coefficients[2] * time * time + cubicPolynomial.coefficients[3] * time * time * time;
}
double AlexTrajectoryGenerator::evaluate_cubic_polynomial_first_derivative(CubicPolynomial cubicPolynomial, time_tt time) {
    return cubicPolynomial.coefficients[1] + 2 * cubicPolynomial.coefficients[2] * time + 3 * cubicPolynomial.coefficients[3] * time * time;
}
double AlexTrajectoryGenerator::evaluate_cubic_polynomial_second_derivative(CubicPolynomial cubicPolynomial, time_tt time) {
    return 2 * cubicPolynomial.coefficients[2] + 6 * cubicPolynomial.coefficients[3] * time;
}

//Generate and store the trajectory spline into the trajectory object
void AlexTrajectoryGenerator::generateAndSaveSpline(jointspace_state initialJointspaceState) {
    this->trajectoryJointSpline = compute_trajectory_spline(trajectoryParameter, pilotParameters, initialJointspaceState);

}

/**********************************************************************

Functions for Controller

**********************************************************************/

/**
 *
 * @param initialTaskspaceState
 * @param trajectoryParameters
 * @param pilotParameters
 * @return Vector of key taskspace_states of the trajectory (excluding initial state)
 */

// Generates trajectory spline from parameters to use in control system
jointspace_spline AlexTrajectoryGenerator::compute_trajectory_spline(const TrajectoryParameters &trajectoryParameters,
                                                                     const PilotParameters &pilotParameters,
                                                                     jointspace_state initialJointspaceState) {
    Foot stanceFoot = trajectoryParameters.stance_foot;
    taskspace_state initialTaskspaceState;
    std::vector<taskspace_state> taskspaceStates;
    std::vector<jointspace_state> jointspaceStates;
    jointspace_spline jointspaceSpline;
    initialTaskspaceState = jointspace_state_to_taskspace_state(initialJointspaceState, trajectoryParameters, pilotParameters);
     // Obtain key taskspace states
    //  (output excludes initial state which is already known in jointspace)
    taskspaceStates = generate_key_taskspace_states(initialTaskspaceState, trajectoryParameters, pilotParameters);
     // Convert key states to jointspace (prepend known initial jointspace state)
    jointspaceStates = taskspace_states_to_jointspace_states(initialJointspaceState, taskspaceStates, trajectoryParameters, pilotParameters);
    //Print out all joint space states
    //  spdlog::debug(""---- Joint space via points 'states'-----"");
    //  for (auto states : jointspaceStates) {
    //      spdlog::debug(""TIME: {}"", states.time);
    //      for (auto q : states.q) {
    //         std::cout << rad2deg(q) << "", "";
    //     }
    //     std::cout << std::endl;
    // }
    // Calculate the spline for the given jointspacestates
    jointspaceSpline = cubic_spline_jointspace_states(jointspaceStates);

    return jointspaceSpline;
}

//get the velocity at any given time
/*void AlexTrajectoryGenerator::calcVelocity(time_tt time, double *velocityArray) {
    time_tt startTime = trajectoryJointSpline.times.front();
    time_tt endTime = trajectoryJointSpline.times.back();
    // Every sample time, compute the value of q1 to q6 based on the time segment / set of NUM_JOINTS polynomials
    int numPoints = trajectoryJointSpline.times.size();
    int numPolynomials = numPoints - 1;
    CubicPolynomial currentPolynomial[ALEX_NUM_JOINTS];
    jointspace_state_ex temp{};
    for (int polynomial_index = 0; polynomial_index < numPolynomials; polynomial_index++) {
        //cout << ""[discretise_spline]: pt "" << polynomial_index << "":"" << std::endl;
        //if the jointspaceState time is bounded by the section of spline
        if (time >= trajectoryJointSpline.times.at(polynomial_index) &&
            time <= trajectoryJointSpline.times.at(polynomial_index + 1)) {
            //cout << ""time "" << time << ""\t"" << trajectoryJointSpline.times.at(polynomial_index)  << std::endl;
            for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
                currentPolynomial[i] = trajectoryJointSpline.polynomials[i].at(polynomial_index);
                temp.qd[i] = evaluate_cubic_polynomial_first_derivative(currentPolynomial[i], time);
                velocityArray[i] = temp.qd[i];
            }
            return;
        }
    }
    //cout << ""[discretise_spline]:\t"" << temp.time << ""\t"";
    //if the time point is outside range
    for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
        currentPolynomial[i] = trajectoryJointSpline.polynomials[i].at(numPolynomials - 1);
        temp.qd[i] = evaluate_cubic_polynomial_first_derivative(currentPolynomial[i], endTime);
        velocityArray[i] = temp.qd[i];
    }
}
*/

jointspace_state AlexTrajectoryGenerator::compute_position_trajectory_difference(
    jointspace_spline jointspaceSpline,
    jointspace_state currentJointspaceStates) {
    jointspace_state position_diff;
    CubicPolynomial currentPolynomial[ALEX_NUM_JOINTS];
    int numPoints = jointspaceSpline.times.size();
    int numPolynomials = numPoints - 1;
    time_tt endTime = jointspaceSpline.times.back();
    jointspace_state splinePosition;

    // Get the target position based on time and spline
    // If the time is past the spline time range,
    // Calculate the diff based on last position in spline
    if (currentJointspaceStates.time >= jointspaceSpline.times.back()) {
        for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
            currentPolynomial[i] = jointspaceSpline.polynomials[i].at(numPolynomials - 1);
        }
        // calculate the position difference at each joint
        for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
            splinePosition.q[i] = evaluate_cubic_polynomial(currentPolynomial[i], endTime);
            position_diff.q[i] = currentJointspaceStates.q[i] - splinePosition.q[i];
        }
        position_diff.time = currentJointspaceStates.time;
        return position_diff;
    }
    // Else, find the relevant section in spline and calculate the position difference

    else {
        for (int polynomial_index = 0; polynomial_index < numPolynomials; polynomial_index++) {
            //cout << ""[discretise_spline]: pt "" << polynomial_index << "":"" << std::endl;
            //if the jointspaceState time is bounded by the section of spline
            if (currentJointspaceStates.time >= jointspaceSpline.times.at(polynomial_index) &&
                currentJointspaceStates.time <= jointspaceSpline.times.at(polynomial_index + 1)) {
                // capture the polynomial for the current spline
                for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
                    currentPolynomial[i] = jointspaceSpline.polynomials[i].at(polynomial_index);
                    splinePosition.q[i] = evaluate_cubic_polynomial(currentPolynomial[i], currentJointspaceStates.time);
                    position_diff.q[i] = currentJointspaceStates.q[i] - splinePosition.q[i];
                }
                //set up the position time to prevent weird behavior
                position_diff.time = currentJointspaceStates.time;
                return position_diff;
            }
        }
    }
    // return error if none of the above case return anything
    std::cout << ""[compute_position_trajectory_difference] Error: Cannot find the time region in the spline"" << std::endl;
    std::cout << ""[compute_position_trajectory_difference] Assuming no position tracking error"" << std::endl;
    for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
        position_diff.q[i] = 0;
    }
    //set up the position time to prevent weird behavior
    position_diff.time = currentJointspaceStates.time;
    return position_diff;
}

// Limiting the velocity control to not pushing against angle limit
// use AFTER the current velocity is added to the control velocity
void AlexTrajectoryGenerator::limit_velocity_against_angle_boundary(
    jointspace_state currentJointspaceStates,
    double *velocitySignal) {
    for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
        int minIndex = i * 2;
        int maxIndex = i * 2 + 1;
        //if we near the boundary and velocity is pushing towards it
        if ((currentJointspaceStates.q[i] < Q_MIN_MAX[minIndex] &&
             velocitySignal < 0) ||
            (currentJointspaceStates.q[i] > Q_MIN_MAX[maxIndex] &&
             velocitySignal > 0)) {
            velocitySignal = 0;
        }
    }
}

//limiting the position array in trajectory class
void AlexTrajectoryGenerator::limit_position_against_angle_boundary(std::vector<double> &positions) {
    for (int i = 0; i < positions.size(); i++) {
        int minIndex = i * 2;
        int maxIndex = i * 2 + 1;
        //if at the boundary
        if (positions[i] < Q_MIN_MAX[minIndex]) {
            positions[i] = Q_MIN_MAX[minIndex];
        }
        if (positions[i] > Q_MIN_MAX[maxIndex]) {
            positions[i] = Q_MIN_MAX[maxIndex];
        }
        // Got another method to properly dealt with error, so get rid of it right now
        // if (std::isnan(positions[i])) {
        //     std::cout << ""Joint "" << i << ""ISNAN now "" << std::endl;
        //     positions[i] = Q_MIN_MAX[minIndex]; /*move to smallest joint angle*/
        //     // positions[i] = Q_MIN_MAX[maxIndex] + 10000; why is this +1000 (from old code)
        // }
    }
}
bool AlexTrajectoryGenerator::jointspace_NaN_check(jointspace_state checkJointspaceState){
  bool containNaN  = false;
  //check whether the checkJointspaceState contains NaN
  for (int i = 0; i < ALEX_NUM_JOINTS; i++) {
      //Flag it if it does contains NaN
      if (std::isnan(checkJointspaceState.q[i])) {
          containNaN = true;
      }
  }
  //if any one joint returns a NaN, change the whole jointspace state to the original state
  return containNaN;
}


/*void AlexTrajectoryGenerator::getVelocityAfterPositionCorrection(
    time_tt time, double *robotPositionArray, double *velocityArray) {
    double splinePositionArray[ALEX_];
    double positionDiff[ALEX_];
    double positionFeedback[ALEX_];
    const double FEEDBACKGAIN = 1;
    calcPosition(time, splinePositionArray);
    //the spline position array is in radian, trajectory object perspective jointspace
    //so the robot position array also needs to be converted to trajectory jointspace, numbering and radian
    for (int i = 0; i < ; i++) {
        positionDiff[i] = splinePositionArray[i] - robotPositionArray[i];
    }
    //the feedback gain part
    calcVelocity(time, velocityArray);
    for (int i = 0; i < ; i++) {
        velocityArray[i] += FEEDBACKGAIN * positionDiff[i];
    }
}*/

/***********************************************************************

Getter and setter

***********************************************************************/

void AlexTrajectoryGenerator::setTrajectoryStanceRight() {
    trajectoryParameter.stance_foot = Foot::Right;
}
void AlexTrajectoryGenerator::setTrajectoryStanceLeft() {
    trajectoryParameter.stance_foot = Foot::Left;
}

double AlexTrajectoryGenerator::getStepDuration() {
    return trajectoryParameter.step_duration;
}

bool AlexTrajectoryGenerator::isTrajectoryFinished(double trajProgress) {
    double fracProgress = trajProgress / (double)trajectoryParameter.step_duration;
    if (fracProgress > 1.05) {
        return true;
    } else {
        return false;
    }
}
",anklePosLean
731,"/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   main.cpp                                           :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: adorigo <<EMAIL>>           +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2019/12/23 08:54:46 by alessandro        #+#    #+#             */
/*   Updated: 2020/04/27 17:45:29 by adorigo          ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include ""../include/ClassAnnuaire.hpp""

int
	main(void)
{
	Annuaire annuaire;
	bool  [MASK] ;
	std::string command;

	annuaire.show_startup();
	 [MASK]  = true;
	while ( [MASK] )
	{
		std::cout << "">"";
		std::getline(std::cin, command);
		if (command == ""ADD"")
			annuaire.add_contact();
		else if (command == ""SEARCH"")
			annuaire.search_contact();
		else if (command == ""EXIT"")
		{
			std::cout << ""# Bye."" << std::endl;
			 [MASK]  = false;
		}
		else
		{
			std::cout << ""wrong command sorry"" << std::endl;
		}
	}
	return (0);
}
",run
732,"

#include ""Led_matrix_8x16.h""
#include <Arduino.h>

int IIC_SCL=3;
int IIC_SDA=4;

// Character bitmaps for the LED matrix
unsigned char symbols[38][8] = {
  {0xF8, 0xFC, 0x46, 0x46, 0xFC, 0xF8}, // A
  {0xFE, 0xFE, 0x92, 0x92, 0xFE, 0x6C}, // B
  {0x7C, 0xFE, 0x82, 0x82, 0x82, 0x44}, // C
  {0xFE, 0xFE, 0x82, 0x82, 0xFE, 0x7C}, // D
  {0xFE, 0xFE, 0xD6, 0xD6, 0xC6, 0xC6}, // E
  {0xFE, 0xFE, 0x12, 0x12, 0x02, 0x02}, // F
  {0x7C, 0xFE, 0x82, 0x92, 0xF2, 0xF4}, // G
  {0xFE, 0xFE, 0x10, 0x10, 0xFE, 0xFE}, // H
  {0x82,0xFE,0xFE,0x82},               //I
  {0x40, 0x82, 0xFE, 0xFE, 0x02, 0x00}, // J
  {0xFE, 0xFE, 0x18, 0x34, 0xE2, 0xC2}, // K
  {0xFE, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0}, // L
  {0xFE, 0xFE, 0x1C, 0x70, 0x1C, 0xFE,0xFE}, // M
  {0xFE, 0xFE, 0x1C, 0x70, 0xFE, 0xFE}, // N
  {0x7C, 0xFE, 0xC6, 0xC6, 0xFE, 0x7C}, // O
  {0xFE, 0xFE, 0x12, 0x12, 0x1E, 0x0C}, // P
  {0x7C, 0xFE, 0x82, 0xC2, 0xFE, 0xBC}, // Q
  {0xFE, 0xFE, 0x12, 0x32, 0xDE, 0x8C}, // R
  {0x4C, 0x9E, 0x92, 0x92, 0xF2, 0x62}, // S
  {0x02, 0x02, 0xFE, 0xFE, 0x02, 0x02}, // T
  {0x7E, 0xFE, 0x80, 0x80, 0xFE, 0x7E}, // U
  {0x3E, 0x7E, 0xC0, 0xC0, 0x7E, 0x3E}, // V
  {0xFE, 0xFE, 0x70, 0x38, 0x70, 0xFE,0xFE}, // W
  {0xC6, 0xEE, 0x38, 0x38, 0xEE, 0xC6}, // X
  {0x0E, 0x1E, 0xF0, 0xF0, 0x1E, 0x0E}, // Y
  {0xE2, 0xF2, 0x92, 0x9A, 0x8E, 0x86}, // Z
  {0x7C, 0xFE, 0x82, 0x82, 0xFE, 0x7C}, // 0
  {0x82, 0xFE, 0xFE, 0x80}, // 1
  {0xE2, 0xF2, 0x92, 0x92, 0x9E, 0x8C}, // 2
  {0x44, 0xC6, 0x92, 0x92, 0xFE, 0x6C}, // 3
  {0x30, 0x38, 0x24, 0xFE, 0xFE, 0x20}, // 4
  {0x4E, 0xCE, 0x8A, 0x8A, 0xFA, 0x72}, // 5
  {0x7C, 0xFE, 0x92, 0x92, 0xF2, 0x60}, // 6
  {0x06, 0x06, 0xF2, 0xFA, 0x1E, 0x06}, // 7
  {0x6C, 0xFE, 0x92, 0x92, 0xFE, 0x6C}, // 8
  {0x0C, 0x9E, 0x92, 0x92, 0xFE, 0x7C}, // 9
  {0x6C},  // :
  {0x10, 0x54, 0x38, 0x7C, 0x38, 0x54} // *
};
// Function prototypes for LED matrix initialization and control
void led_matrix_init(int IIC_SCL_PIN,int IIC_SDA_PIN){
  IIC_SCL=IIC_SCL_PIN;
  IIC_SDA=IIC_SDA_PIN;
  pinMode(IIC_SCL,OUTPUT);
  pinMode(IIC_SDA,OUTPUT);
  digitalWrite(IIC_SCL,LOW);
  digitalWrite(IIC_SDA,LOW);
}




void IIC_start(){

  digitalWrite(IIC_SCL,LOW);
  delayMicroseconds(3);
  digitalWrite(IIC_SDA,HIGH);
  delayMicroseconds(3);
  digitalWrite(IIC_SCL,HIGH);
  delayMicroseconds(3);
  digitalWrite(IIC_SDA,LOW);
  delayMicroseconds(3);
}
void IIC_send(unsigned char  [MASK] ){
  for(char i = 0;i < 8;i++)
  {
      digitalWrite(IIC_SCL,LOW);
      delayMicroseconds(3); 
      if( [MASK]  & 0x01)
      {
        digitalWrite(IIC_SDA,HIGH);
      }
      else
      {
        digitalWrite(IIC_SDA,LOW);
      }
      delayMicroseconds(3);
      digitalWrite(IIC_SCL,HIGH); 
      delayMicroseconds(3);
       [MASK]  =  [MASK]  >> 1;
  }
}
void IIC_end(){
  digitalWrite(IIC_SCL,LOW);
  delayMicroseconds(3);
  digitalWrite(IIC_SDA,LOW);
  delayMicroseconds(3);
  digitalWrite(IIC_SCL,HIGH);
  delayMicroseconds(3);
  digitalWrite(IIC_SDA,HIGH);
  delayMicroseconds(3);
}


// Set the address display
void set_address(){
  IIC_start();
  IIC_send(0x40);
  IIC_end(); 
}

// Set the brightness display
void set_brightness(){
  IIC_start();
  IIC_send(0x8A);
  IIC_end(); 
}

// Retrieve the corresponding value from the array of symbols according to the corresponding character
char choose_value(char character){
  if(character>=48&&character<=58){
    character-=22;
  }
  else if(character>=97&&character<=122){
    character-=97;
  }
  else if(character>=64&&character<=90){
    character-=65;
  }
    else if(character>=97&&character<=122){
    character-=97;
  }
  else if(character==42){
    character=37;
  }
  return character;
}

// Adding values ​​to char array by matching character
void add_char(unsigned char value[],int *k,unsigned char selection){
  int i=0;
  while (symbols[selection][i]) {
    value[*k]=symbols[selection][i];
    *k+=1;
    i++;   
  }
  value[*k]=0x00;
  *k+=1;
}

// Prepare a set of symbols to be given to the anchor
void str_array(unsigned char *str,unsigned char value[],int *k){

  while (*str) {
    if (*str==' ') {
      for (int i=0; i<3; i++) {
        value[*k]=0x00;
        *k+=1;
      }
      str++;
    }
    else {
      add_char(value,k,choose_value(*str));
      str++;
    }
  }
  if (*k>16) {
    value[*k+=1]=0x00;
    *k+=2;
    for (int i=0; i<16; i++) {
      value[*k+i]=value[i];
      
    }
    *k+=16;
  }
}

// Write scrolling symbols
void write_str(unsigned char value[],int *k){
  IIC_start();
  IIC_send(0xc0);
  if (*k>16) {
    for (int m=0; *k-m-16; m++) {
      for (int i=0; i<16; i++) {
        IIC_send(value[i+m]);
      }
      delay(100);
    }

  }
  else {
    for (int i=0; i<*k; i++) {
      IIC_send(value[i]);
    }
  }
    IIC_end();
}

// Write center location
void write_location(unsigned char value[],int *k){
  IIC_start();
  IIC_send(0xc1+(((16-(*k))/2)));
  for(int i=0;i<*k;i++){
    IIC_send(value[i]);
  }
  IIC_end();
}

// Clean the led matrix
void clear8x16(){
  IIC_start();
  IIC_send(0xc0);
  for(int i=0;i<16;i++){
      IIC_send(0x00);
  }
  IIC_end();
}

// Count down from a given number or count up to a given number
void Counter(int num,unsigned char char_tuple[],int time,bool UpOrDown){
  if (num>=0&&num<=99) {
    if (UpOrDown) {
      for (int i=num; i>=0; i--) {
        int count_=0;
        String new_num=String(i);
        str_array(new_num.c_str(),char_tuple,&count_);
        write_location(char_tuple,&count_);
        delay(time);
        clear8x16();
        delay(time);
      }
    }
    else {
      for (int i=0; i<=num; i++) {
        int count_=0;
        String new_num=String(i);
        str_array(new_num.c_str(),char_tuple,&count_);
        write_location(char_tuple,&count_);
        delay(time);
        clear8x16();
        delay(time);
      }
    }
  }
  else{
        int count_=0;
        str_array(""*"",char_tuple,&count_);
        write_location(char_tuple,&count_);
        delay(time);
        clear8x16();
        delay(time);
  }

}
",send_data
733,"#ifndef BLOOM_FILTER_BLOOM_FILTER_H_
#define BLOOM_FILTER_BLOOM_FILTER_H_

#include <algorithm>
#include <assert.h>

#include ""hashutil.h""

using namespace std;
using namespace hashing;

namespace bloomfilter {
// status returned by a Bloom filter operation
enum Status {
  Ok = 0,
  NotFound = 1,
  NotEnoughSpace = 2,
  NotSupported = 3,
};

inline uint32_t reduce(uint32_t hash, uint32_t n) {
  // http://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
  return (uint32_t)(((uint64_t)hash * n) >> 32);
}

static size_t getBestK(size_t bitsPerItem) {
  return max(1, (int)round((double)bitsPerItem * log(2)));
}

inline uint64_t getBit(uint32_t index) { return 1L << (index & 63); }

template <typename ItemType, size_t bits_per_item, bool branchless,
          typename HashFamily = TwoIndependentMultiplyShift,
          int k = (int)((double)bits_per_item * 0.693147180559945 + 0.5)>
class BloomFilter {

  uint64_t *data;
  size_t size;
  size_t arrayLength;
  size_t bitCount;
  int kk;
  HashFamily hasher;

  double BitsPerItem() const { return k; }

public:
  explicit BloomFilter(const size_t n) : hasher() {
    this->size = 0;
    this->kk = getBestK(bits_per_item);
    this->bitCount = n * bits_per_item;
    this->arrayLength = (bitCount + 63) / 64;
    data = new uint64_t[arrayLength];
    std::fill_n(data, arrayLength, 0);
  }

  ~BloomFilter() { delete[] data; }

  // Add an item to the filter.
  Status Add(const ItemType &item);

  // Add multiple items to the filter.
  Status AddAll(const vector<ItemType> data, const size_t start,
                const size_t end);

  // Report if the item is inserted, with false positive rate.
  Status Contain(const ItemType &item) const;

  /* methods for providing stats  */
  // summary infomation
  std::string Info() const;

  // number of current inserted items;
  size_t Size() const { return size; }

  // size of the filter in bytes.
  size_t SizeInBytes() const { return arrayLength * 8; }
};

template <typename ItemType, size_t bits_per_item, bool branchless,
          typename HashFamily, int k>
Status BloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::Add(
    const ItemType &key) {
  uint64_t hash = hasher(key);
  uint32_t a = (uint32_t)(hash >> 32);
  uint32_t b = (uint32_t)hash;
  for (int i = 0; i < k; i++) {
    // int index = reduce(a, this->bitCount);
    // data[index >> 6] |= getBit(index);
    // reworked to avoid overflows
    // use the fact that reduce is not very sensitive to lower bits of a
    data[reduce(a, this->arrayLength)] |= getBit(a);
    a += b;
  }
  return Ok;
}

const int blockShift = 15;
const int blockLen = 1 << blockShift;

void applyBlock(uint32_t *tmp, int block, int len, uint64_t *data) {
  for (int i = 0; i < len; i++) {
    uint32_t index = tmp[(block << blockShift) + i];
    data[index >> 6] |= getBit(index);
  }
}

template <typename ItemType, size_t bits_per_item, bool branchless,
          typename HashFamily, int k>
Status BloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::AddAll(
    const vector<ItemType> keys, const size_t start, const size_t end) {
  int blocks = 1 + arrayLength / blockLen;
  uint32_t *tmp = new uint32_t[blocks * blockLen];
  int *tmpLen = new int[blocks]();
  for (size_t i = start; i < end; i++) {
    uint64_t key = keys[i];
    uint64_t hash = hasher(key);
    uint32_t a = (uint32_t)(hash >> 32);
    uint32_t b = (uint32_t)hash;
    for (int j = 0; j < k; j++) {
      int index = reduce(a, this->arrayLength);
      int block = index >> blockShift;
      int len = tmpLen[block];
      tmp[(block << blockShift) + len] = (index << 6) + (a & 63);
      tmpLen[block] = len + 1;
      if (len + 1 == blockLen) {
        applyBlock(tmp, block, len + 1, data);
        tmpLen[block] = 0;
      }
      a += b;
    }
  }
  for (int block = 0; block < blocks; block++) {
    applyBlock(tmp, block, tmpLen[block], data);
  }
  delete[] tmp;
  delete[] tmpLen;
  return Ok;
}

char bittest64(const uint64_t *t, uint64_t bit) {
  return (*t & (1L << (bit & 63))) != 0;
}
template <typename ItemType, size_t bits_per_item, bool branchless,
          typename HashFamily, int k>
Status BloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::Contain(
    const ItemType &key) const {
  uint64_t hash = hasher(key);
  uint32_t a = (uint32_t)(hash >> 32);
  uint32_t b = (uint32_t)hash;
  if (branchless && k >= 3) {
    int b0 = data[reduce(a, this->arrayLength)] >> (a & 63);
    a += b;
    int b1 = data[reduce(a, this->arrayLength)] >> (a & 63);
    a += b;
    int b2 = data[reduce(a, this->arrayLength)] >> (a & 63);
    if ((b0 & b1 & b2 & 1) == 0) {
        return NotFound;
    }
    for (int i = 3; i < k; i++) {
      a += b;
      if (((data[reduce(a, this->arrayLength)] >> (a & 63)) & 1) == 0) {
          return NotFound;
      }
    }
    return Ok;
  }
  for (int i = 0; i < k; i++) {
    if ((data[reduce(a, this->arrayLength)] & getBit(a)) == 0) {
      return NotFound;
    }
    a += b;
  }
  return Ok;
}

template <typename ItemType, size_t bits_per_item, bool branchless,
          typename HashFamily, int k>
std::string
BloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::Info() const {
  std::stringstream ss;
  ss << ""BloomFilter Status:\n""
     << ""\t\tKeys stored: "" << Size() << ""\n"";
  if (Size() > 0) {
    ss << ""\t\tk:   "" << BitsPerItem() << ""\n"";
  } else {
    ss << ""\t\tk:   N/A\n"";
  }
  return ss.str();
}

/***************
 * Simple block filter (naive implementation)
 ***************/

template <size_t blocksize, int k,
          typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
class SimpleBlockFilter {
private:
  // The filter is divided up into Buckets:
  using Bucket = uint64_t[blocksize];

  const int bucketCount;

  Bucket *directory_;

  HashFamily hasher_;

public:
  // Consumes at most (1 << log_heap_space) bytes on the heap:
  explicit SimpleBlockFilter(const int bits);
  ~SimpleBlockFilter() noexcept;
  void Add(const uint64_t key) noexcept;

  bool Find(const uint64_t key) const noexcept;
  uint64_t SizeInBytes() const { return sizeof(Bucket) * bucketCount; }
};

template <size_t blocksize, int k, typename HashFamily>
SimpleBlockFilter<blocksize, k, HashFamily>::SimpleBlockFilter(
    const int capacity)
    : bucketCount(capacity * k / (blocksize * 47)), directory_(nullptr),
      hasher_() {
  const size_t alloc_size = bucketCount * sizeof(Bucket);
  const int  [MASK]  =
      posix_memalign(reinterpret_cast<void **>(&directory_), 64, alloc_size);
  if ( [MASK] )
    throw ::std::bad_alloc();
  memset(directory_, 0, alloc_size);
}

template <size_t blocksize, int k, typename HashFamily>
SimpleBlockFilter<blocksize, k, HashFamily>::~SimpleBlockFilter() noexcept {
  free(directory_);
  directory_ = nullptr;
}

static inline uint64_t rotl64(uint64_t n, unsigned int c) {
  // assumes width is a power of 2
  const unsigned int mask = (CHAR_BIT * sizeof(n) - 1);
  // assert ( (c<=mask) &&""rotate by type width or more"");
  c &= mask;
  return (n << c) | (n >> ((-c) & mask));
}

char setbit64(uint64_t *t, uint64_t bit) { return *t |= (1L << (bit & 63)); }

template <size_t blocksize, int k, typename HashFamily>
inline void
SimpleBlockFilter<blocksize, k, HashFamily>::Add(const uint64_t key) noexcept {
  const auto hash = hasher_(key);
  const uint32_t bucket_idx = reduce(rotl64(hash, 32), bucketCount);
  Bucket *bucket = directory_ + bucket_idx;
  uint32_t a = (uint32_t)(hash >> 32);
  uint32_t b = (uint32_t)hash;
  for (int i = 0; i < k; i++) {
    setbit64((uint64_t *)bucket + (a % blocksize), a / blocksize);
    a += b;
  }
}
template <size_t blocksize, int k, typename HashFamily>
inline bool
SimpleBlockFilter<blocksize, k, HashFamily>::Find(const uint64_t key) const
    noexcept {
  const auto hash = hasher_(key);
  const uint32_t bucket_idx = reduce(rotl64(hash, 32), bucketCount);
  const Bucket *bucket = directory_ + bucket_idx;
  uint32_t a = (uint32_t)(hash >> 32);
  uint32_t b = (uint32_t)hash;
  char ok = 1;
  for (int i = 0; i < k; i++) {
    ok &= bittest64(((const uint64_t *)bucket) + (a % blocksize), a / blocksize);
    a += b;
  }
  return ok;
}

} // namespace bloomfilter
#endif // BLOOM_FILTER_BLOOM_FILTER_H_
",malloc_failed
734,"#include <FastLED.h>

/* BASIC CONFIGURATION  */
// Model of the LEDs
#define LED_TYPE NEOPIXEL
// The amount of LEDs in the setup
#define NUM_LEDS 47
// The pin that controls the LEDs
#define LED_PIN 6
// The pins that we read sensor values form
#define LEFT_CHANNEL A2
#define RIGHT_CHANNEL A4
// Arduino loop delay (for stablity, probably)
#define DELAY 1

// Confirmed volume low value, and max value
#define VOLUME_LOW 0.35
#define VOLUME_HIGH 93.85

// Minimum and maximum brightness
#define MIN_BRIGHTNESS 7
#define MAX_BRIGHTNESS 255

// Lighting modes
#define PULSE 0
#define VISUALIZATION 1

// Pulse mode configuration
#define BREATH_IN 0
#define BREATH_OUT 1
#define BREATH_LIGHT_STEP 1
#define BREATH_DIM_STEP 1
#define PULSE_MODE_DELAY 5
#define RBG_STEP 1
#define RED 0
#define GREEN 1
#define BLUE 2

// Visualization mode configuration
#define VISUALIZATION_MODE_DELAY 0

// How many previous sensor values effects the operating average?
#define AVG_LEN 30

// How many previous sensor values decides if we detect the sound
#define LONG_SECTOR 120

// How long do we keep the ""current average"" sound, before restarting the measuring
//#define MSECS 1 * 1000
//#define CYCLES MSECS / VISUALIZATION_MODE_DELAY

/**
 * Sometimes readings are wrong or strange. How much is a reading allowed
 * to deviate from the average to not be discarded?
 */
//#define DEVAITE_THRESH 0.8

// Volumes
float volume, mappedVolume, avgVolume, longerAvgVolume;

// Average sound measurement the last CYCLES
//float songAvg;

// The amount of iterations since the songAvg was reset
//int iter = 0;

// The speed the LEDs fade to black if not relit
//float fadeScale = 1.2;

// LED array
struct CRGB leds[NUM_LEDS];

/**
 * Short sound avg used to ""normalize"" the input values.
 * We use the short average instead of using the sensor input directly
 */
float volumes[AVG_LEN] = {-1};

// Longer sound avg
float longerVolumes[LONG_SECTOR] = {-1};

// Mode setting
int mode;

// handle brightness and rainbow
int breathDirection;
int decreasingColor;

// Keeping track how often, and how long times we hit a certain mode
struct timeKeeping {
  unsigned long timesStart;
  unsigned long times;
};

// How much to increment or decrement each color every cycle
struct color {
  int r;
  int g;
  int b;
};

// How much to increment or decrement brightness every cycle
struct brightness {
  int up;
  int down;
};

struct timeKeeping visualization;
struct color Color;
struct brightness Brightness;

// For testing
float lowestVolume = 99999;
float highestVolume = 0;
bool isVolumeTestingMode = 0;

void setup () {
  Serial.begin(9600);
  mode = PULSE;
  visualization.timesStart = 0;
  visualization.times= 0;
  Color.r = 1;
  Color.g = 1;
  Color.b = 1;
  Brightness.up = 1;
  Brightness.down = 1;
  // Set all lights to make sure all are working as expected
  FastLED.addLeds<LED_TYPE, LED_PIN>(leds, NUM_LEDS);
  FastLED.clear();
  FastLED.setBrightness(MAX_BRIGHTNESS);
  breathDirection = BREATH_OUT;
  fill_solid(leds, NUM_LEDS, CRGB(0, 255, 0));
  decreasingColor = GREEN;
}

void loop () {
  if (isVolumeTestingMode) {
    testVolume();
  } else {
    updateMode();
    switch (mode) {
      case PULSE:
        breath();
        delay(PULSE_MODE_DELAY);
        break;
      case VISUALIZATION:
        visualize();
        delay(VISUALIZATION_MODE_DELAY);
        break;
      default:
        break;
    }
  }
//  delay(DELAY);
}

void visualize () {
  // Color
  handleRainbow();
  // Map volume to brightness
  float volume = readVolume(160);
  int brightness = (int)fscale(VOLUME_LOW, VOLUME_HIGH, MIN_BRIGHTNESS, MAX_BRIGHTNESS, volume, 2.0);
//  Serial.println(brightness);
  FastLED.setBrightness(brightness);
  FastLED.show();
}

void breath () {
  // Color
  handleRainbow();
  // Pulse
  handlePulse();
  FastLED.show();
}

void updateMode () {
  // Actual sensor value
  volume = readVolume(20);
  
  // If 0, discard immediately. Probably not right and save CPU.
//  if (volume == 0) return;

//  mappedVolume = getMappedVolume();
//  insert(mappedVolume, volumes, AVG_LEN);
//  insert(volume, volumes, AVG_LEN);
//  avgVolume = getAvgVolume();
//  insert(avgVolume, longerVolumes, LONG_SECTOR);
  insert(volume, longerVolumes, LONG_SECTOR);
  longerAvgVolume = getLongAvgVolume();
  
  if (longerAvgVolume > VOLUME_LOW) {
    if (visualization.times != 0) {
      if (millis() - visualization.timesStart > 300) {
        changeMode(PULSE);
      } else {
        visualization.timesStart = millis();
        visualization.times++;
      }
    } else {
      visualization.timesStart = millis();
      visualization.times++;
    }
  }
//  int currentBrightness = FastLED.getBrightness();
//  Serial.print(volume);
//  Serial.print('\t');
//  Serial.print(longerAvgVolume);
//  Serial.print('\t');
//  Serial.print(visualization.times);
//  Serial.print('\t');
//  Serial.print(millis() - visualization.timesStart);
//  Serial.print('\t');
//  Serial.print(visualization.times > 15 && millis() - visualization.timesStart < 25);
//  Serial.print('\t');
//  Serial.print(millis() - visualization.timesStart > 300);
//  Serial.print('\t');
//  Serial.println(currentBrightness);
  if (visualization.times > 15 && millis() - visualization.timesStart < 25) {
    changeMode(VISUALIZATION);
  } else if (millis() - visualization.timesStart > 300) {
    changeMode(PULSE);
  }
}

/**
 * Helper functions
 */
void handleRainbow () {
  int r, g, b;
  if (decreasingColor == RED) {
    r = leds[0].r - Color.r;
    g = leds[0].g + Color.g;
    b = leds[0].b;
  } else if (decreasingColor == GREEN) {
    r = leds[0].r;
    g = leds[0].g - Color.g;
    b = leds[0].b + Color.b;
  } else if (decreasingColor == BLUE) {
    r = leds[0].r + Color.r;
    g = leds[0].g;
    b = leds[0].b - Color.b;
  }
  if (r <= 0) {
    r = 0;
    if (decreasingColor == RED) g = 255;
  }
  if (r >= 255) {
    r = 255;
    if (decreasingColor == BLUE) b = 0;
  }
  if (g <= 0) {
    g = 0;
    if (decreasingColor == GREEN) b = 255;
  }
  if (g >= 255) {
    g = 255;
    if (decreasingColor == RED) r = 0;
  }
  if (b <= 0) {
    b = 0;
    if (decreasingColor == BLUE) r = 255;
  }
  if (b >= 255) {
    b = 255;
    if (decreasingColor == GREEN) g = 0;
  }
  if (r == 255) decreasingColor = RED;
  if (g == 255) decreasingColor = GREEN;
  if (b == 255) decreasingColor = BLUE;
//  int currentBrightness = FastLED.getBrightness();
//  Serial.print(r);
//  Serial.print('\t');
//  Serial.print(g);
//  Serial.print('\t');
//  Serial.print(b);
//  Serial.print('\t');
//  Serial.println(currentBrightness);
  fill_solid(leds, NUM_LEDS, CRGB(r, g, b));
}

void handlePulse () {
  int currentBrightness = FastLED.getBrightness();
  int brightness;
  if (breathDirection == BREATH_IN) {
    brightness = currentBrightness + Brightness.up;
  }
  if (breathDirection == BREATH_OUT) {
    brightness = currentBrightness - Brightness.down;
  }
  if (brightness > MAX_BRIGHTNESS) {
    brightness = MAX_BRIGHTNESS;
    breathDirection = BREATH_OUT;
  }
  if (brightness < MIN_BRIGHTNESS) {
    brightness = MIN_BRIGHTNESS;
    breathDirection = BREATH_IN;
  }
//  Serial.println(brightness);
  FastLED.setBrightness(brightness);
}

void changeMode (int mode) {
  if (mode == PULSE) _changeToPulseMode();
  if (mode == VISUALIZATION) _changeToVisualizationMode();
}

void _changeToPulseMode () {
  Color.r = RBG_STEP;
  Color.g = RBG_STEP;
  Color.b = RBG_STEP;
  Brightness.up = BREATH_LIGHT_STEP;
  Brightness.down = BREATH_DIM_STEP;
  visualization.timesStart = 0;
  visualization.times = 0;
  mode = PULSE;
//  Serial.println(""Pulse mode"");
}

void _changeToVisualizationMode () {
//  Color.r = 5;
//  Color.g = 5;
//  Color.b = 5;
  Color.r = (int)fscale(VOLUME_LOW, VOLUME_HIGH, 5, 15, longerAvgVolume, 2.0);
  Color.g = (int)fscale(VOLUME_LOW, VOLUME_HIGH, 5, 15, longerAvgVolume, 2.0);
  Color.b = (int)fscale(VOLUME_LOW, VOLUME_HIGH, 5, 15, longerAvgVolume, 2.0);
//  Serial.print(Color.r);
//  Serial.print('\t');
//  Serial.print(Color.g);
//  Serial.print('\t');
//  Serial.println(Color.b);
//  visualization.timesStart = millis();
//  visualization.times++;
  mode = VISUALIZATION;
//  Serial.println(""Visualization mode"");
} 

float readVolume (int cycles) {
  // 1ms can run around 4 cycles
  float total = 0;
//  long before = millis();
  for (int i = 0; i < cycles; i++) {
    int left = analogRead(LEFT_CHANNEL);
    int right = analogRead(RIGHT_CHANNEL);
    float volume = (left + right) / 2;
    total += volume;
  }
//  Serial.println(millis() - before);
  return (total / cycles);
}

float getMappedVolume () {
  return fscale(VOLUME_LOW, VOLUME_HIGH, VOLUME_LOW, VOLUME_HIGH, volume, 2.0);
}

float getAvgVolume () {
  return computeAverage(volumes, AVG_LEN);
}

float getLongAvgVolume () {
  return computeAverage(longerVolumes, LONG_SECTOR);
}

void testVolume () {
  volume = readVolume(100);
  if (volume < lowestVolume) lowestVolume = volume;
  if (volume > highestVolume) highestVolume = volume;
//  mappedVolume = getMappedVolume();
//  insert(mappedVolume, volumes, AVG_LEN);
//  insert(volume, volumes, AVG_LEN);
//  avgVolume = getAvgVolume();
//  insert(avgVolume, longerVolumes, LONG_SECTOR);
  insert(volume, longerVolumes, LONG_SECTOR);
  longerAvgVolume = getLongAvgVolume();
  Serial.print(lowestVolume);
  Serial.print('\t');
  Serial.print(highestVolume);
  Serial.print('\t');
//  Serial.print(mappedVolume);
//  Serial.print('\t');
  Serial.print(volume);
  Serial.print('\t');
//  Serial.print(avgVolume);
  Serial.print('\t');
  Serial.println(longerAvgVolume);
}

/**
 * Utilities
 */
// Compute average of a int array, given the starting pointer and the length
float computeAverage (float arr[], int len) {
  float sum = 0;
  for (int i = 0; i < len; i++) {
    sum += arr[i];
  }
  return (sum / len);
}

// Insert a value into an array, and shift it down removing
// the first value if array already full 
void insert (float val, float *arr, int len) {
  for (int i = 0; i < len; i++) {
    if (arr[i] == -1) {
      arr[i] = val;
      return;
    }  
  }
  for (int i = 1; i < len; i++) {
    arr[i - 1] = arr[i];
  }
  arr[len - 1] = val;
}

//Function imported from the arduino website.
//Basically map, but with a curve on the scale (can be non-uniform).
float fscale (float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve) {
  float OriginalRange = 0;
  float NewRange = 0;
  float zeroRefCurVal = 0;
  float  [MASK]  = 0;
  float rangedValue = 0;
  boolean invFlag = 0;

  // condition curve parameter
  // limit range
  if (curve > 10) curve = 10;
  if (curve < -10) curve = -10;

  curve = (curve * -.1) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output 
  curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function

  // Check for out of range inputValues
  if (inputValue < originalMin) {
    inputValue = originalMin;
  }
  if (inputValue > originalMax) {
    inputValue = originalMax;
  }

  // Zero Refference the values
  OriginalRange = originalMax - originalMin;

  if (newEnd > newBegin){ 
    NewRange = newEnd - newBegin;
  } else {
    NewRange = newBegin - newEnd;
    invFlag = 1;
  }

  zeroRefCurVal = inputValue - originalMin;
   [MASK]  = zeroRefCurVal / OriginalRange;   // normalize to 0 - 1 float

  // Check for originalMin > originalMax  - the math for all other cases i.e. negative numbers seems to work out fine
  if (originalMin > originalMax) {
    return 0;
  }

  if (invFlag == 0) {
    rangedValue = (pow( [MASK] , curve) * NewRange) + newBegin;
  } else {
    // invert the ranges
    rangedValue = newBegin - (pow( [MASK] , curve) * NewRange);
  }

  return rangedValue;
}",normalizedCurVal
735,"#include <stdio.h>
#include <stdlib.h>

// 変数の値を入れ替える関数
void swap(int *a, int *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

// 乱数を生成する関数
int get_rand( int min_val, int  [MASK]  ) {
    return (int)(( rand() % (  [MASK] +1 - min_val ) ) + min_val );
}

//枢軸を基準に要素を並び替える関数
int partition(int data[], int begin, int end) {
	//ここを埋める
    for (int i = begin; i < end; i++) {
        if (data[i] <= data[end]) {
            swap(&data[begin], &data[i]);
            begin++;
        }
    }
    swap(&data[end], &data[begin]);
    return begin;
}

//クイックソートを行う関数
void quicksort(int data[], int begin, int end) {
    //ここを埋める
    if(begin < end){
        int p = partition(data, begin, end);
        quicksort(data, begin, p-1);
        quicksort(data, p+1, end);
    }
}


int main() {
	//データ入力
	int n;
	scanf(""%d"", &n);
	int* data = (int*)malloc(sizeof(int) * n);
	for (int i = 0; i < n; i++) {
		scanf(""%d"", &data[i]);
	}

	//ソート
	quicksort(data, 0, n - 1);

	//データ出力
	for (int i = 0; i < n; i++) {
		printf(""%d, "", data[i]);
	}

	free(data);
	return 0;
}
",max_val
736,"class Solution {
public:
 
    int solve(vector<int>temp, int k){
         unordered_map<int, int>mp;
         
        int count=0;
        int sum=0;
        mp[sum]=1;
        
        for(int i=0; i<temp.size(); i++){
            sum=sum+temp[i];
            
            if(mp.find(sum-k)!=mp.end()){
                count=count+mp[sum-k];
            }
            
            mp[sum]++;
        }
        
        return count;
    }
    
    int numSubmatrixSumTarget(vector<vector<int>>& matrix, int  [MASK] ) {
        int m=matrix.size();
        int n=matrix[0].size();
          int count=0;
        
        for(int k=0; k<m; k++){
            vector<int>arr(n,0);
             for(int i=k; i<m; i++){
                 for(int j=0; j<n; j++){
                    arr[j]=arr[j]+matrix[i][j];
                 }
                count+=solve(arr,  [MASK] ); 
             }
        }
     
        
        return count;
    }
};",target
737,"#pragma once

#include <functional>
#include <ostream>
#include <unordered_map>

#include <meojson/json.hpp>

namespace asst
{
    enum class AsstMsg
    {
        /* Global Info */
        InternalError = 0, // 内部错误
        InitFailed,        // 初始化失败
        ConnectionInfo,    // 连接相关错误
        AllTasksCompleted, // 全部任务完成
        AsyncCallInfo,     // 外部异步调用信息
        /* TaskChain Info */
        TaskChainError = 10000, // 任务链执行/识别错误
        TaskChainStart,         // 任务链开始
        TaskChainCompleted,     // 任务链完成
        TaskChainExtraInfo,     // 任务链额外信息
        TaskChainStopped,       // 任务链停止（手动停止）
        /* SubTask Info */
        SubTaskError = 20000, // 原子任务执行/识别错误
        SubTaskStart,         // 原子任务开始
        SubTaskCompleted,     // 原子任务完成
        SubTaskExtraInfo,     // 原子任务额外信息
        SubTaskStopped,       // 原子任务停止（手动停止）
    };

    inline std::ostream& operator<<(std::ostream& os, const AsstMsg& type)
    {
        static const std::unordered_map<AsstMsg, std::string>  [MASK]  = {
            /* Global Info */
            { AsstMsg::InternalError, ""InternalError"" },
            { AsstMsg::InitFailed, ""InitFailed"" },
            { AsstMsg::ConnectionInfo, ""ConnectionInfo"" },
            { AsstMsg::AllTasksCompleted, ""AllTasksCompleted"" },
            { AsstMsg::AsyncCallInfo, ""AsyncCallInfo"" },
            /* TaskChain Info */
            { AsstMsg::TaskChainError, ""TaskChainError"" },
            { AsstMsg::TaskChainStart, ""TaskChainStart"" },
            { AsstMsg::TaskChainCompleted, ""TaskChainCompleted"" },
            { AsstMsg::TaskChainExtraInfo, ""TaskChainExtraInfo"" },
            { AsstMsg::TaskChainStopped, ""TaskChainStopped"" },
            /* SubTask Info */
            { AsstMsg::SubTaskError, ""SubTaskError"" },
            { AsstMsg::SubTaskStart, ""SubTaskStart"" },
            { AsstMsg::SubTaskCompleted, ""SubTaskCompleted"" },
            { AsstMsg::SubTaskExtraInfo, ""SubTaskExtraInfo"" },
            { AsstMsg::SubTaskStopped, ""SubTaskStopped"" },
        };
        return os <<  [MASK] .at(type);
    }

    // 对外的回调接口
    using AsstMsgId = int32_t;
    using ApiCallback = void (*)(AsstMsgId msg, const char* details_json, void* custom_arg);

    // 内部使用的回调
    class Assistant;
    using AsstCallback = std::function<void(AsstMsg msg, const json::value& details, Assistant* inst)>;
}
",_type_name
738,"// Copyright (C) 2015  <NAME> (<EMAIL>)
// License: Boost Software License   See LICENSE.txt for the full license.
#ifndef DLIB_DNN_CuDNN_CPP_
#define DLIB_DNN_CuDNN_CPP_

#ifdef DLIB_USE_CUDA

#include ""cudnn_dlibapi.h""
#include ""tensor.h""
#include <cudnn.h>
#include <iostream>
#include <string>
#include ""cuda_utils.h""
#include ""cpu_dlib.h""
#include ""cuda_dlib.h""
#include ""tensor_tools.h""

static const char* cudnn_get_error_string(cudnnStatus_t s)
{
    switch(s)
    {
        case CUDNN_STATUS_NOT_INITIALIZED: 
            return ""CUDA Runtime API initialization failed."";
        case CUDNN_STATUS_ALLOC_FAILED: 
            return ""CUDA Resources could not be allocated."";
        case CUDNN_STATUS_BAD_PARAM:
            return ""CUDNN_STATUS_BAD_PARAM"";
        case CUDNN_STATUS_EXECUTION_FAILED:
            return ""CUDNN_STATUS_EXECUTION_FAILED"";
        case CUDNN_STATUS_NOT_SUPPORTED:
            return ""CUDNN_STATUS_NOT_SUPPORTED"";
        default:
            return ""A call to cuDNN failed"";
    }
}

// Check the return value of a call to the cuDNN runtime for an error condition.
#define CHECK_CUDNN(call)                                                      \
do{                                                                              \
    const cudnnStatus_t error = call;                                         \
    if (error != CUDNN_STATUS_SUCCESS)                                        \
    {                                                                          \
        std::ostringstream sout;                                               \
        sout << ""Error while calling "" << #call << "" in file "" << __FILE__ << "":"" << __LINE__ << "". "";\
        sout << ""code: "" << error << "", reason: "" << cudnn_get_error_string(error);\
        throw dlib::cudnn_error(sout.str());                            \
    }                                                                          \
}while(false)


namespace dlib
{

    namespace cuda 
    {

    // ------------------------------------------------------------------------------------

        static cudnnTensorDescriptor_t descriptor(const tensor& t) 
        {
            return (const cudnnTensorDescriptor_t)t.get_cudnn_tensor_descriptor().get_handle();
        }
        static cudnnTensorDescriptor_t descriptor(const tensor_descriptor& t) 
        {
            return (const cudnnTensorDescriptor_t)t.get_handle();
        }

    // ------------------------------------------------------------------------------------

        class cudnn_context
        {
        public:
            // not copyable 
            cudnn_context(const cudnn_context&) = delete;
            cudnn_context& operator=(const cudnn_context&) = delete;

            cudnn_context()
            {
                CHECK_CUDNN(cudnnCreate(&handle));
                CHECK_CUDA(cudaGetDevice(&device_id));
            }

            ~cudnn_context()
            {
                cudnnDestroy(handle);
            }

            cudnnHandle_t get_handle (
            ) 
            { 
                // Check if the active device for the current thread changed.  If so then
                // regenerate our cuDNN handle so it will use the currently selected
                // device.
                int new_device_id;
                CHECK_CUDA(cudaGetDevice(&new_device_id));
                if (new_device_id != device_id)
                {
                    CHECK_CUDNN(cudnnDestroy(handle));
                    CHECK_CUDNN(cudnnCreate(&handle));
                }
                return handle; 
            }

        private:
            cudnnHandle_t handle;
            int device_id;
        };

        static cudnnHandle_t context()
        {
            thread_local cudnn_context c;
            return c.get_handle();
        }

    // ------------------------------------------------------------------------------------

        class cudnn_activation_descriptor
        {
        public:
            // not copyable 
            cudnn_activation_descriptor(const cudnn_activation_descriptor&) = delete;
            cudnn_activation_descriptor& operator=(const cudnn_activation_descriptor&) = delete;

            cudnn_activation_descriptor(
                cudnnActivationMode_t mode,
                cudnnNanPropagation_t reluNanOpt,
                double reluCeiling
            )
            {
                CHECK_CUDNN(cudnnCreateActivationDescriptor(&handle));
                CHECK_CUDNN(cudnnSetActivationDescriptor(handle, mode, reluNanOpt, reluCeiling));
            }

            ~cudnn_activation_descriptor()
            {
                cudnnDestroyActivationDescriptor(handle);
            }

            cudnnActivationDescriptor_t get_handle (
            ) 
            { 
                return handle; 
            }
        private:
            cudnnActivationDescriptor_t handle;
        };

        static cudnnActivationDescriptor_t relu_activation_descriptor()
        {
            thread_local cudnn_activation_descriptor des(CUDNN_ACTIVATION_RELU, CUDNN_PROPAGATE_NAN,0);
            return des.get_handle();
        }

        static cudnnActivationDescriptor_t sigmoid_activation_descriptor()
        {
            thread_local cudnn_activation_descriptor des(CUDNN_ACTIVATION_SIGMOID, CUDNN_PROPAGATE_NAN,0);
            return des.get_handle();
        }

        static cudnnActivationDescriptor_t tanh_activation_descriptor()
        {
            thread_local cudnn_activation_descriptor des(CUDNN_ACTIVATION_TANH, CUDNN_PROPAGATE_NAN,0);
            return des.get_handle();
        }

    // ------------------------------------------------------------------------------------

        tensor_descriptor::
        tensor_descriptor(
        ) : handle(nullptr)
        {
        }

        tensor_descriptor::
        ~tensor_descriptor()
        {
            set_size(0,0,0,0);
        }

        void tensor_descriptor::
        set_size(
            int n, 
            int k,
            int nr, 
            int nc 
        )
        {
            if (n == 0 || nr == 0 || nc == 0 || k == 0)
            {
                if (handle)
                {
                    cudnnDestroyTensorDescriptor((cudnnTensorDescriptor_t)handle);
                    handle = nullptr;
                }
            }
            else
            {
                cudnnTensorDescriptor_t h;
                CHECK_CUDNN(cudnnCreateTensorDescriptor(&h));
                handle = h;

                CHECK_CUDNN(cudnnSetTensor4dDescriptor((cudnnTensorDescriptor_t)handle,
                        CUDNN_TENSOR_NCHW,
                        CUDNN_DATA_FLOAT,
                        n,
                        k,
                        nr,
                        nc));
            }
        }

        void tensor_descriptor::
        get_size (
            int& n, 
            int& k,
            int& nr,
            int& nc
        ) const
        {
            if (handle)
            {
                int nStride, cStride, hStride, wStride;
                cudnnDataType_t datatype;
                CHECK_CUDNN(cudnnGetTensor4dDescriptor((cudnnTensorDescriptor_t)handle,
                        &datatype,
                        &n,
                        &k,
                        &nr,
                        &nc,
                        &nStride,
                        &cStride,
                        &hStride,
                        &wStride));
            }
            else
            {
                n = 0;
                k = 0;
                nr = 0;
                nc = 0;
            }
        }

    // ------------------------------------------------------------------------------------

        void add(
            float beta,
            tensor& dest,
            float alpha,
            const tensor& src
        )
        {
            DLIB_CASSERT(
                  (have_same_dimensions(src, dest) ||
                  (src.num_samples()==1 && src.k()==dest.k() && src.nr()==1 && src.nc()==1) ||
                  (src.num_samples()==1 && src.k()==dest.k() && src.nr()==dest.nr() && src.nc()==dest.nc()) ||
                  (src.num_samples()==1 && src.k()==1 && src.nr()==dest.nr() && src.nc()==dest.nc())) &&
                  is_same_object(src,dest) == false , 
                    ""\n\t dest.num_samples(): "" << dest.num_samples()
                    <<""\n\t dest.k():           "" << dest.k()
                    <<""\n\t dest.nr():          "" << dest.nr()
                    <<""\n\t dest.nc():          "" << dest.nc()
                    <<""\n\t src.num_samples():  "" << src.num_samples()
                    <<""\n\t src.k():            "" << src.k()
                    <<""\n\t src.nr():           "" << src.nr()
                    <<""\n\t src.nc():           "" << src.nc()
                    );

            if (dest.size() == src.size() && beta == 1)
            {
                // Call the dlib function in this case since it's faster than the one that
                // comes with cuDNN (at least as of cuDNN v4).
                add_scaled(dest, alpha, src);
                return;
            }

            CHECK_CUDNN(cudnnAddTensor(context(),
                                    &alpha,
                                    descriptor(src),
                                    src.device(),
                                    &beta,
                                    descriptor(dest),
                                    dest.device()));
        }

        void set_tensor (
            tensor& t,
            float value
        )
        {
            if (t.size() == 0)
                return;
            CHECK_CUDNN(cudnnSetTensor(context(),
                                 descriptor(t),
                                 t.device_write_only(),
                                 &value));
        }

        void scale_tensor (
            tensor& t,
            float value
        )
        {
            if (t.size() == 0)
                return;
            CHECK_CUDNN(cudnnScaleTensor(context(),
                                   descriptor(t),
                                   t.device(),
                                   &value));
        }

        void assign_conv_bias_gradient (
            tensor& grad,
            const tensor& gradient_input
        )
        {
            DLIB_CASSERT(
                  grad.num_samples() == 1 &&
                  grad.k()  >= 1 &&
                  grad.nr() == 1 &&
                  grad.nc() == 1 &&
                  gradient_input.k() == grad.k() &&
                  gradient_input.size() > 0 &&
                  is_same_object(grad,gradient_input) == false
                  ,"""");

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnConvolutionBackwardBias(context(),
                                               &alpha,
                                               descriptor(gradient_input),
                                               gradient_input.device(),
                                               &beta,
                                               descriptor(grad),
                                               grad.device()));
        }

    // ------------------------------------------------------------------------------------

        void batch_normalize_inference (
            resizable_tensor& dest,
            const tensor& src,
            const tensor& gamma, 
            const tensor& beta,
            const tensor& running_means,
            const tensor& running_variances
        )
        {
            DLIB_CASSERT(
                gamma.num_samples() == 1 && 
                gamma.nr() == src.nr() &&
                gamma.nc() == src.nc() &&
                gamma.k()  == src.k() &&
                have_same_dimensions(gamma, beta) &&
                have_same_dimensions(gamma, running_means) &&
                have_same_dimensions(gamma, running_variances), 
                ""\ngamma.num_samples(): "" << gamma.num_samples() << 
                ""\ngamma.k():  "" << gamma.k() << 
                ""\ngamma.nr(): "" << gamma.nr() << 
                ""\ngamma.nc(): "" << gamma.nc() << 
                ""\nbeta.num_samples(): "" << beta.num_samples() << 
                ""\nbeta.k():   "" << beta.k() << 
                ""\nbeta.nr():  "" << beta.nr() << 
                ""\nbeta.nc():  "" << beta.nc() << 
                ""\nrunning_means.num_samples(): "" << running_means.num_samples() << 
                ""\nrunning_means.k():   "" << running_means.k() << 
                ""\nrunning_means.nr():  "" << running_means.nr() << 
                ""\nrunning_means.nc():  "" << running_means.nc() << 
                ""\nrunning_variances.num_samples(): "" << running_variances.num_samples() << 
                ""\nrunning_variances.k():   "" << running_variances.k() << 
                ""\nrunning_variances.nr():  "" << running_variances.nr() << 
                ""\nrunning_variances.nc():  "" << running_variances.nc() << 
                ""\nsrc.k():   "" << src.k() << 
                ""\nsrc.nr():  "" << src.nr() << 
                ""\nsrc.nc():  "" << src.nc() 
            );
            const float in_scale = 1;
            const float out_scale = 0;

            dest.copy_size(src);

            CHECK_CUDNN(cudnnBatchNormalizationForwardInference(
                                context(),
                                CUDNN_BATCHNORM_PER_ACTIVATION,
                                &in_scale,
                                &out_scale,
                                descriptor(src),
                                src.device(),
                                descriptor(dest),
                                dest.device(),
                                descriptor(gamma),
                                gamma.device(),
                                beta.device(),
                                running_means.device(),
                                running_variances.device(),
                                dlib::tt::BATCH_NORM_EPS));
        }

        void batch_normalize (
            resizable_tensor& dest,
            resizable_tensor& means,
            resizable_tensor& invstds,
            const double averaging_factor,
            resizable_tensor& running_means,
            resizable_tensor& running_variances,
            const tensor& src,
            const tensor& gamma, 
            const tensor& beta 
        )
        {
            DLIB_CASSERT(0 <= averaging_factor && averaging_factor <= 1, ""averaging_factor: "" << averaging_factor);
            DLIB_CASSERT(averaging_factor==1 || have_same_dimensions(running_means,means),"""");
            DLIB_CASSERT(averaging_factor==1 || have_same_dimensions(running_variances,invstds),"""");
            DLIB_CASSERT(
                src.num_samples() > 1 &&
                gamma.num_samples() == 1 && 
                beta.num_samples() == 1 && 
                gamma.nr() == beta.nr() && beta.nr() == src.nr() &&
                gamma.nc() == beta.nc() && beta.nc() == src.nc() &&
                gamma.k()  == beta.k()  && beta.k() == src.k(), 
                ""\ngamma.num_samples(): "" << gamma.num_samples() << 
                ""\ngamma.k():  "" << gamma.k() << 
                ""\ngamma.nr(): "" << gamma.nr() << 
                ""\ngamma.nc(): "" << gamma.nc() << 
                ""\nbeta.num_samples(): "" << beta.num_samples() << 
                ""\nbeta.k():   "" << beta.k() << 
                ""\nbeta.nr():  "" << beta.nr() << 
                ""\nbeta.nc():  "" << beta.nc() << 
                ""\nsrc.k():   "" << src.k() << 
                ""\nsrc.nr():  "" << src.nr() << 
                ""\nsrc.nc():  "" << src.nc() 
            );

            const float in_scale = 1;
            const float out_scale = 0;

            dest.copy_size(src);
            means.set_size(1, src.k(), src.nr(), src.nc());
            invstds.copy_size(means);
            running_means.copy_size(means);
            running_variances.copy_size(means);

            CHECK_CUDNN(cudnnBatchNormalizationForwardTraining(
                                context(),
                                CUDNN_BATCHNORM_PER_ACTIVATION,
                                &in_scale,
                                &out_scale,
                                descriptor(src),
                                src.device(),
                                descriptor(dest),
                                dest.device(),
                                descriptor(gamma),
                                gamma.device(),
                                beta.device(),
                                averaging_factor,
                                running_means.device(),
                                running_variances.device(),
                                dlib::tt::BATCH_NORM_EPS,
                                means.device(),
                                invstds.device()));
        }

        void batch_normalize_gradient(
            const tensor& gradient_input,
            const tensor& means,
            const tensor& invstds,
            const tensor& src,
            const tensor& gamma,
            tensor& src_grad,
            tensor& gamma_grad, 
            tensor& beta_grad 
        )
        {
            const long num = src.k()*src.nr()*src.nc();
            DLIB_CASSERT(src.num_samples() > 1, """");
            DLIB_CASSERT(num == means.size(),"""");
            DLIB_CASSERT(num == invstds.size(),"""");
            DLIB_CASSERT(num == gamma.size(),"""");
            DLIB_CASSERT(num == gamma_grad.size(),"""");
            DLIB_CASSERT(num == beta_grad.size(),"""");
            DLIB_CASSERT(have_same_dimensions(gradient_input, src),"""");
            DLIB_CASSERT(have_same_dimensions(gradient_input, src_grad),"""");

            const float in_scale = 1;
            const float out_scale = 1;
            const float in_scale_params = 1;
            const float out_scale_params = 0;

            CHECK_CUDNN(cudnnBatchNormalizationBackward(
                                context(),
                                CUDNN_BATCHNORM_PER_ACTIVATION,
                                &in_scale,
                                &out_scale,
                                &in_scale_params,
                                &out_scale_params,
                                descriptor(src),
                                src.device(),
                                descriptor(gradient_input),
                                gradient_input.device(),
                                descriptor(src_grad),
                                src_grad.device(),
                                descriptor(gamma),
                                gamma.device(),
                                gamma_grad.device(),
                                beta_grad.device(),
                                dlib::tt::BATCH_NORM_EPS,
                                means.device(),
                                invstds.device()));
        }

    // ------------------------------------------------------------------------------------

        void batch_normalize_conv_inference (
            resizable_tensor& dest,
            const tensor& src,
            const tensor& gamma, 
            const tensor& beta,
            const tensor& running_means,
            const tensor& running_variances
        )
        {
            DLIB_CASSERT(
                gamma.num_samples() == 1 && 
                gamma.nr() == 1 &&
                gamma.nc() == 1 &&
                gamma.k()  == src.k() &&
                have_same_dimensions(gamma, beta) &&
                have_same_dimensions(gamma, running_means) &&
                have_same_dimensions(gamma, running_variances), 
                ""\ngamma.num_samples(): "" << gamma.num_samples() << 
                ""\ngamma.k():  "" << gamma.k() << 
                ""\ngamma.nr(): "" << gamma.nr() << 
                ""\ngamma.nc(): "" << gamma.nc() << 
                ""\nbeta.num_samples(): "" << beta.num_samples() << 
                ""\nbeta.k():   "" << beta.k() << 
                ""\nbeta.nr():  "" << beta.nr() << 
                ""\nbeta.nc():  "" << beta.nc() << 
                ""\nrunning_means.num_samples(): "" << running_means.num_samples() << 
                ""\nrunning_means.k():   "" << running_means.k() << 
                ""\nrunning_means.nr():  "" << running_means.nr() << 
                ""\nrunning_means.nc():  "" << running_means.nc() << 
                ""\nrunning_variances.num_samples(): "" << running_variances.num_samples() << 
                ""\nrunning_variances.k():   "" << running_variances.k() << 
                ""\nrunning_variances.nr():  "" << running_variances.nr() << 
                ""\nrunning_variances.nc():  "" << running_variances.nc() << 
                ""\nsrc.k():   "" << src.k() << 
                ""\nsrc.nr():  "" << src.nr() << 
                ""\nsrc.nc():  "" << src.nc() 
            );
            const float in_scale = 1;
            const float out_scale = 0;

            dest.copy_size(src);

            CHECK_CUDNN(cudnnBatchNormalizationForwardInference(
                                context(),
                                CUDNN_BATCHNORM_SPATIAL,
                                &in_scale,
                                &out_scale,
                                descriptor(src),
                                src.device(),
                                descriptor(dest),
                                dest.device(),
                                descriptor(gamma),
                                gamma.device(),
                                beta.device(),
                                running_means.device(),
                                running_variances.device(),
                                dlib::tt::BATCH_NORM_EPS));
        }

        void batch_normalize_conv (
            resizable_tensor& dest,
            resizable_tensor& means,
            resizable_tensor& invstds,
            const double averaging_factor,
            resizable_tensor& running_means,
            resizable_tensor& running_variances,
            const tensor& src,
            const tensor& gamma, 
            const tensor& beta 
        )
        {
            DLIB_CASSERT(0 <= averaging_factor && averaging_factor <= 1, ""averaging_factor: "" << averaging_factor);
            DLIB_CASSERT(averaging_factor==1 || have_same_dimensions(running_means,means),"""");
            DLIB_CASSERT(averaging_factor==1 || have_same_dimensions(running_variances,invstds),"""");
            DLIB_CASSERT(
                src.num_samples() > 1 &&
                gamma.num_samples() == 1 && 
                beta.num_samples() == 1 && 
                gamma.nr() == 1 && 
                beta.nr() == 1 && 
                gamma.nc() == 1 && 
                beta.nc() == 1 && 
                gamma.k()  == beta.k()  && beta.k() == src.k(), 
                ""\ngamma.num_samples(): "" << gamma.num_samples() << 
                ""\ngamma.k():  "" << gamma.k() << 
                ""\ngamma.nr(): "" << gamma.nr() << 
                ""\ngamma.nc(): "" << gamma.nc() << 
                ""\nbeta.num_samples(): "" << beta.num_samples() << 
                ""\nbeta.k():   "" << beta.k() << 
                ""\nbeta.nr():  "" << beta.nr() << 
                ""\nbeta.nc():  "" << beta.nc() << 
                ""\nsrc.k():   "" << src.k() << 
                ""\nsrc.nr():  "" << src.nr() << 
                ""\nsrc.nc():  "" << src.nc() 
            );
            const float in_scale = 1;
            const float out_scale = 0;

            dest.copy_size(src);
            means.set_size(1, src.k());
            invstds.copy_size(means);
            running_means.copy_size(means);
            running_variances.copy_size(means);

            CHECK_CUDNN(cudnnBatchNormalizationForwardTraining(
                                context(),
                                CUDNN_BATCHNORM_SPATIAL,
                                &in_scale,
                                &out_scale,
                                descriptor(src),
                                src.device(),
                                descriptor(dest),
                                dest.device(),
                                descriptor(gamma),
                                gamma.device(),
                                beta.device(),
                                averaging_factor,
                                running_means.device(),
                                running_variances.device(),
                                dlib::tt::BATCH_NORM_EPS,
                                means.device(),
                                invstds.device()));
        }

        void batch_normalize_conv_gradient(
            const tensor& gradient_input,
            const tensor& means,
            const tensor& invstds,
            const tensor& src,
            const tensor& gamma,
            tensor& src_grad,
            tensor& gamma_grad, 
            tensor& beta_grad 
        )
        {
            const long num = src.nr()*src.nc();
            DLIB_CASSERT(src.k() == means.size(),"""");
            DLIB_CASSERT(src.k() == invstds.size(),"""");
            DLIB_CASSERT(src.k() == gamma.size(),"""");
            DLIB_CASSERT(src.k() == gamma_grad.size(),"""");
            DLIB_CASSERT(src.k() == beta_grad.size(),"""");
            DLIB_CASSERT(have_same_dimensions(gradient_input, src),"""");
            DLIB_CASSERT(have_same_dimensions(gradient_input, src_grad),"""");

            const float in_scale = 1;
            const float out_scale = 1;
            const float in_scale_params = 1;
            const float out_scale_params = 0;

            CHECK_CUDNN(cudnnBatchNormalizationBackward(
                                context(),
                                CUDNN_BATCHNORM_SPATIAL,
                                &in_scale,
                                &out_scale,
                                &in_scale_params,
                                &out_scale_params,
                                descriptor(src),
                                src.device(),
                                descriptor(gradient_input),
                                gradient_input.device(),
                                descriptor(src_grad),
                                src_grad.device(),
                                descriptor(gamma),
                                gamma.device(),
                                gamma_grad.device(),
                                beta_grad.device(),
                                dlib::tt::BATCH_NORM_EPS,
                                means.device(),
                                invstds.device()));
        }

    // ------------------------------------------------------------------------------------
    // ------------------------------------------------------------------------------------

        tensor_conv::
        tensor_conv(
        ) : 
            filter_handle(nullptr),
            conv_handle(nullptr),
            forward_algo(0),
            forward_workspace_size_in_bytes(0),
            forward_workspace(nullptr),
            backward_data_algo(0),
            backward_data_workspace_size_in_bytes(0),
            backward_data_workspace(nullptr),
            backward_filters_algo(0),
            backward_filters_workspace_size_in_bytes(0),
            backward_filters_workspace(nullptr)
        {
            clear();
        }

        void tensor_conv::
        clear (
        )
        {
            if (filter_handle) 
                cudnnDestroyFilterDescriptor((cudnnFilterDescriptor_t)filter_handle);
            if (conv_handle) 
                cudnnDestroyConvolutionDescriptor((cudnnConvolutionDescriptor_t)conv_handle);
            filter_handle = nullptr;
            conv_handle = nullptr;
            out_num_samples = 0;
            out_k = 0;
            out_nr = 0;
            out_nc = 0;

            if (forward_workspace)
                cudaFree(forward_workspace);
            forward_workspace = nullptr;
            forward_algo = 0;
            forward_workspace_size_in_bytes = 0;

            if (backward_data_workspace)
                cudaFree(backward_data_workspace);
            backward_data_workspace = nullptr;
            backward_data_algo = 0;
            backward_data_workspace_size_in_bytes = 0;

            if (backward_filters_workspace)
                cudaFree(backward_filters_workspace);
            backward_filters_workspace = nullptr;
            backward_filters_algo = 0;
            backward_filters_workspace_size_in_bytes = 0;

            stride_y = 0;
            stride_x = 0;
            data_num_samples = 0;
            data_k = 0;
            data_nr = 0;
            data_nc = 0;
            filters_num_samples = 0;
            filters_k = 0;
            filters_nr = 0;
            filters_nc = 0;
        }

        void tensor_conv::
        setup(
            const tensor& data,
            const tensor& filters,
            int stride_y_,
            int stride_x_
        ) 
        {
            DLIB_CASSERT(data.k() == filters.k(),"""");

            // if the last call to setup gave the same exact settings then don't do
            // anything.
            if (stride_y_ == stride_y && 
                stride_x_ == stride_x &&
                data_num_samples == data.num_samples() &&
                data_k == data.k() &&
                data_nr == data.nr() &&
                data_nc == data.nc() &&
                filters_num_samples == filters.num_samples() &&
                filters_k == filters.k() &&
                filters_nr == filters.nr() &&
                filters_nc == filters.nc())
            {
                return;
            }

            clear();
            try
            {
                stride_y = stride_y_;
                stride_x = stride_x_;
                data_num_samples = data.num_samples();
                data_k = data.k();
                data_nr = data.nr();
                data_nc = data.nc();
                filters_num_samples = filters.num_samples();
                filters_k = filters.k();
                filters_nr = filters.nr();
                filters_nc = filters.nc();

                CHECK_CUDNN(cudnnCreateFilterDescriptor((cudnnFilterDescriptor_t*)&filter_handle));
                CHECK_CUDNN(cudnnSetFilter4dDescriptor((cudnnFilterDescriptor_t)filter_handle, 
                                                 CUDNN_DATA_FLOAT, 
                                                 CUDNN_TENSOR_NCHW,
                                                 filters.num_samples(),
                                                 filters.k(),
                                                 filters.nr(),
                                                 filters.nc()));

                CHECK_CUDNN(cudnnCreateConvolutionDescriptor((cudnnConvolutionDescriptor_t*)&conv_handle));
                CHECK_CUDNN(cudnnSetConvolution2dDescriptor((cudnnConvolutionDescriptor_t)conv_handle,
                        filters.nr()/2, // vertical padding
                        filters.nc()/2, // horizontal padding
                        stride_y,
                        stride_x,
                        1, 1, // must be 1,1
                        CUDNN_CONVOLUTION)); // could also be CUDNN_CROSS_CORRELATION

                CHECK_CUDNN(cudnnGetConvolution2dForwardOutputDim(
                        (const cudnnConvolutionDescriptor_t)conv_handle,
                        descriptor(data),
                        (const cudnnFilterDescriptor_t)filter_handle,
                        &out_num_samples,
                        &out_k,
                        &out_nr,
                        &out_nc));

                tensor_descriptor dest_desc;
                dest_desc.set_size(out_num_samples,out_k,out_nr,out_nc);

                // Pick which forward algorithm we will use and allocate the necessary
                // workspace buffer.
                cudnnConvolutionFwdAlgo_t forward_best_algo;
                CHECK_CUDNN(cudnnGetConvolutionForwardAlgorithm(
                        context(), 
                        descriptor(data),
                        (const cudnnFilterDescriptor_t)filter_handle,
                        (const cudnnConvolutionDescriptor_t)conv_handle,
                        descriptor(dest_desc),
                        dnn_prefer_fastest_algorithms()?CUDNN_CONVOLUTION_FWD_PREFER_FASTEST:CUDNN_CONVOLUTION_FWD_NO_WORKSPACE,
                        std::numeric_limits<size_t>::max(),
                        &forward_best_algo));
                forward_algo = forward_best_algo;
                CHECK_CUDNN(cudnnGetConvolutionForwardWorkspaceSize( 
                        context(),
                        descriptor(data),
                        (const cudnnFilterDescriptor_t)filter_handle,
                        (const cudnnConvolutionDescriptor_t)conv_handle,
                        descriptor(dest_desc),
                        forward_best_algo,
                        &forward_workspace_size_in_bytes));
                CHECK_CUDA(cudaMalloc(&forward_workspace, forward_workspace_size_in_bytes));


                // Pick which backward data algorithm we will use and allocate the
                // necessary workspace buffer.
                cudnnConvolutionBwdDataAlgo_t backward_data_best_algo;
                CHECK_CUDNN(cudnnGetConvolutionBackwardDataAlgorithm(
                        context(),
                        (const cudnnFilterDescriptor_t)filter_handle,
                        descriptor(dest_desc),
                        (const cudnnConvolutionDescriptor_t)conv_handle,
                        descriptor(data),
                        dnn_prefer_fastest_algorithms()?CUDNN_CONVOLUTION_BWD_DATA_PREFER_FASTEST:CUDNN_CONVOLUTION_BWD_DATA_NO_WORKSPACE,
                        std::numeric_limits<size_t>::max(),
                        &backward_data_best_algo));
                backward_data_algo = backward_data_best_algo;
                CHECK_CUDNN(cudnnGetConvolutionBackwardDataWorkspaceSize( 
                        context(),
                        (const cudnnFilterDescriptor_t)filter_handle,
                        descriptor(dest_desc),
                        (const cudnnConvolutionDescriptor_t)conv_handle,
                        descriptor(data),
                        backward_data_best_algo,
                        &backward_data_workspace_size_in_bytes));
                CHECK_CUDA(cudaMalloc(&backward_data_workspace, backward_data_workspace_size_in_bytes));


                // Pick which backward filters algorithm we will use and allocate the
                // necessary workspace buffer.
                cudnnConvolutionBwdFilterAlgo_t backward_filters_best_algo;
                CHECK_CUDNN(cudnnGetConvolutionBackwardFilterAlgorithm(
                        context(),
                        descriptor(data),
                        descriptor(dest_desc),
                        (const cudnnConvolutionDescriptor_t)conv_handle,
                        (const cudnnFilterDescriptor_t)filter_handle,
                        dnn_prefer_fastest_algorithms()?CUDNN_CONVOLUTION_BWD_FILTER_PREFER_FASTEST:CUDNN_CONVOLUTION_BWD_FILTER_NO_WORKSPACE,
                        std::numeric_limits<size_t>::max(),
                        &backward_filters_best_algo));
                backward_filters_algo = backward_filters_best_algo;
                CHECK_CUDNN(cudnnGetConvolutionBackwardFilterWorkspaceSize( 
                        context(),
                        descriptor(data),
                        descriptor(dest_desc),
                        (const cudnnConvolutionDescriptor_t)conv_handle,
                        (const cudnnFilterDescriptor_t)filter_handle,
                        backward_filters_best_algo,
                        &backward_filters_workspace_size_in_bytes));
                CHECK_CUDA(cudaMalloc(&backward_filters_workspace, backward_filters_workspace_size_in_bytes));
            }
            catch(...)
            {
                clear();
                throw;
            }
        }

        tensor_conv::
        ~tensor_conv (
        )
        {
            clear();
        }

        void tensor_conv::operator() (
            resizable_tensor& output,
            const tensor& data,
            const tensor& filters,
            int stride_y,
            int stride_x
        )
        {
            DLIB_CASSERT(is_same_object(output,data) == false,"""");
            DLIB_CASSERT(is_same_object(output,filters) == false,"""");
            DLIB_CASSERT(filters.k() == data.k(),"""");
            DLIB_CASSERT(stride_y > 0 && stride_x > 0,"""");

            setup(data,filters,stride_y,stride_x);

            output.set_size(out_num_samples, out_k, out_nr, out_nc);

            DLIB_ASSERT(output.num_samples() == data.num_samples(),out_num_samples << ""  "" << data.num_samples());
            DLIB_ASSERT(output.k() == filters.num_samples(),"""");
            DLIB_ASSERT(output.nr() == 1+(data.nr()-filters.nr()%2)/stride_y,"""");
            DLIB_ASSERT(output.nc() == 1+(data.nc()-filters.nc()%2)/stride_x,output.nc() << ""  "" <<1+(data.nc()-1)/stride_x << "" : "" << data.nc() << ""  "" << stride_x);

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnConvolutionForward(
                    context(),
                    &alpha,
                    descriptor(data),
                    data.device(),
                    (const cudnnFilterDescriptor_t)filter_handle,
                    filters.device(),
                    (const cudnnConvolutionDescriptor_t)conv_handle,
                    (cudnnConvolutionFwdAlgo_t)forward_algo,
                    forward_workspace,
                    forward_workspace_size_in_bytes,
                    &beta,
                    descriptor(output),
                    output.device()));
        }

        void tensor_conv::get_gradient_for_data (
            const tensor& gradient_input, 
            const tensor& filters,
            tensor& data_gradient
        )
        {
            const float alpha = 1;
            const float beta = 1;


            CHECK_CUDNN(cudnnConvolutionBackwardData(context(),
                                                  &alpha,
                                                  (const cudnnFilterDescriptor_t)filter_handle,
                                                  filters.device(),
                                                  descriptor(gradient_input),
                                                  gradient_input.device(),
                                                  (const cudnnConvolutionDescriptor_t)conv_handle,
                                                  (cudnnConvolutionBwdDataAlgo_t)backward_data_algo,
                                                  backward_data_workspace,
                                                  backward_data_workspace_size_in_bytes,
                                                  &beta,
                                                  descriptor(data_gradient),
                                                  data_gradient.device()));
        }

        void tensor_conv::
        get_gradient_for_filters (
            const tensor& gradient_input, 
            const tensor& data,
            tensor& filters_gradient
        )
        {
            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnConvolutionBackwardFilter(context(),
                                                    &alpha,
                                                    descriptor(data),
                                                    data.device(),
                                                    descriptor(gradient_input),
                                                    gradient_input.device(),
                                                    (const cudnnConvolutionDescriptor_t)conv_handle,
                                                    (cudnnConvolutionBwdFilterAlgo_t)backward_filters_algo,
                                                    backward_filters_workspace,
                                                    backward_filters_workspace_size_in_bytes,
                                                    &beta,
                                                    (const cudnnFilterDescriptor_t)filter_handle,
                                                    filters_gradient.device()));
        }

    // ------------------------------------------------------------------------------------
    // ------------------------------------------------------------------------------------

        pooling::pooling (
        ) : handle(nullptr),window_height(0),window_width(0),stride_y(0),stride_x(0)
        {
        }

        pooling::~pooling(
        )
        {
            clear();
        }

        void pooling::
        clear(
        )
        {
            if (handle)
                cudnnDestroyPoolingDescriptor((cudnnPoolingDescriptor_t)handle);
            handle = nullptr;
            window_height = 0;
            window_width = 0;
            stride_y = 0;
            stride_x = 0;
        }

        void pooling::
        setup_max_pooling(
            int window_height_,
            int window_width_,
            int stride_y_,
            int stride_x_
        )
        {
            setup(window_height_, window_width_, stride_y_, stride_x_, CUDNN_POOLING_MAX);
            do_max_pooling = true;
        }

        void pooling::
        setup_avg_pooling(
            int window_height_,
            int window_width_,
            int stride_y_,
            int stride_x_
        )
        {
            setup(window_height_, window_width_, stride_y_, stride_x_, CUDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING);
            do_max_pooling = false;
        }

        void pooling::
        setup(
            int window_height_,
            int window_width_,
            int stride_y_,
            int stride_x_,
            int  [MASK] 
        )
        {
            if (window_height == window_height_ &&
                window_width  == window_width_ &&
                stride_y == stride_y_ &&
                stride_x == stride_x_ )
            {
                return;
            }

            clear();
            try
            {
                window_height = window_height_;
                window_width = window_width_;
                stride_x = stride_x_;
                stride_y = stride_y_;
                cudnnPoolingDescriptor_t poolingDesc;
                CHECK_CUDNN(cudnnCreatePoolingDescriptor(&poolingDesc));
                handle = poolingDesc;

                CHECK_CUDNN(cudnnSetPooling2dDescriptor(poolingDesc,
                                                (cudnnPoolingMode_t) [MASK] ,
                                                CUDNN_PROPAGATE_NAN,
                                                window_height,
                                                window_width,
                                                window_height/2,
                                                window_width/2,  
                                                stride_y,
                                                stride_x));
            }
            catch(...)
            {
                clear();
                throw;
            }
        }

        void pooling::
        operator() (
            resizable_tensor& dest,
            const tensor& src
        )
        {
            const float alpha = 1;
            const float beta = 0;
            int outN;
            int outC;
            int outH;
            int outW;
            CHECK_CUDNN(cudnnGetPooling2dForwardOutputDim((const cudnnPoolingDescriptor_t)handle,
                                                    descriptor(src),
                                                    &outN,
                                                    &outC,
                                                    &outH,
                                                    &outW));


            dest.set_size(outN,outC,outH,outW);

            DLIB_CASSERT(dest.num_samples() == src.num_samples(),"""");
            DLIB_CASSERT(dest.k() == src.k(),"""");
            DLIB_CASSERT(dest.nr() == 1+(src.nr()-window_height%2)/stride_y, 
                ""\n stride_y: "" << stride_y  <<
                ""\n window_height: "" << window_height  <<
                ""\n src.nr(): "" << src.nr()  <<
                ""\n dest.nr(): "" << dest.nr()  <<
                ""\n src.nr()/stride_y: "" <<  src.nr()/stride_y); 
            DLIB_CASSERT(dest.nc() == 1+(src.nc()-window_width%2)/stride_x, 
                ""\n stride_x: "" << stride_x  <<
                ""\n window_width: "" << window_width  <<
                ""\n src.nc(): "" << src.nc()  <<
                ""\n dest.nc(): "" << dest.nc()  <<
                ""\n src.nc()/stride_x: "" <<  src.nc()/stride_x); 

            CHECK_CUDNN(cudnnPoolingForward(context(),
                                     (const cudnnPoolingDescriptor_t)handle,
                                     &alpha,
                                     descriptor(src),
                                     src.device(),
                                     &beta,
                                     descriptor(dest),
                                     dest.device()));
        }

        void pooling::get_gradient(
            const tensor& gradient_input, 
            const tensor& dest,
            const tensor& src,
            tensor& grad 
        )
        {
            DLIB_CASSERT(have_same_dimensions(gradient_input,dest),"""");
            DLIB_CASSERT(have_same_dimensions(src,grad),"""");

            const float alpha = 1;
            const float beta = 1;
            CHECK_CUDNN(cudnnPoolingBackward(context(),
                                       (const cudnnPoolingDescriptor_t)handle,
                                       &alpha,
                                       descriptor(dest),
                                       dest.device(),
                                       descriptor(gradient_input),
                                       gradient_input.device(),
                                       descriptor(src),
                                       src.device(),
                                       &beta,
                                       descriptor(grad),
                                       grad.device()));
        }

    // ------------------------------------------------------------------------------------
    // ------------------------------------------------------------------------------------

        void softmax (
            tensor& dest,
            const tensor& src
        )
        {
            DLIB_CASSERT(have_same_dimensions(dest,src),"""");
            if (src.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;

            CHECK_CUDNN(cudnnSoftmaxForward(context(),
                                      CUDNN_SOFTMAX_ACCURATE,
                                      CUDNN_SOFTMAX_MODE_CHANNEL,
                                      &alpha,
                                      descriptor(src),
                                      src.device(),
                                      &beta,
                                      descriptor(dest),
                                      dest.device()));
        }


        void softmax_gradient (
            tensor& grad,
            const tensor& dest,
            const tensor& gradient_input
        )
        {
            DLIB_CASSERT(
                  have_same_dimensions(dest,gradient_input) == true &&
                  have_same_dimensions(dest,grad) == true , """");
            if (dest.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnSoftmaxBackward(context(),
                                      CUDNN_SOFTMAX_ACCURATE,
                                      CUDNN_SOFTMAX_MODE_CHANNEL,
                                      &alpha,
                                      descriptor(dest),
                                      dest.device(),
                                      descriptor(gradient_input),
                                      gradient_input.device(),
                                      &beta,
                                      descriptor(grad),
                                      grad.device()));
        }

    // ------------------------------------------------------------------------------------
    // ------------------------------------------------------------------------------------

        void sigmoid (
            tensor& dest,
            const tensor& src
        )
        {
            DLIB_CASSERT(have_same_dimensions(dest,src),"""");
            if (src.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnActivationForward(context(),
                                         sigmoid_activation_descriptor(),
                                         &alpha,
                                         descriptor(src),
                                         src.device(),
                                         &beta,
                                         descriptor(dest),
                                         dest.device()));
        }

        void sigmoid_gradient (
            tensor& grad,
            const tensor& dest,
            const tensor& gradient_input
        )
        {
            DLIB_CASSERT(
                  have_same_dimensions(dest,gradient_input) == true &&
                  have_same_dimensions(dest,grad) == true , """");
            if (dest.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnActivationBackward(context(),
                                          sigmoid_activation_descriptor(),
                                          &alpha,
                                          descriptor(dest),
                                          dest.device(),
                                          descriptor(gradient_input),
                                          gradient_input.device(),
                                          descriptor(dest),
                                          dest.device(),
                                          &beta,
                                          descriptor(grad),
                                          grad.device()));
        }

    // ------------------------------------------------------------------------------------

        void relu (
            tensor& dest,
            const tensor& src
        )
        {
            DLIB_CASSERT(have_same_dimensions(dest,src),"""");
            if (src.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnActivationForward(context(),
                                         relu_activation_descriptor(),
                                         &alpha,
                                         descriptor(src),
                                         src.device(),
                                         &beta,
                                         descriptor(dest),
                                         dest.device()));
        }

        void relu_gradient (
            tensor& grad,
            const tensor& dest,
            const tensor& gradient_input
        )
        {
            DLIB_CASSERT(
                  have_same_dimensions(dest,gradient_input) == true &&
                  have_same_dimensions(dest,grad) == true , """");
            if (dest.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnActivationBackward(context(),
                                          relu_activation_descriptor(),
                                          &alpha,
                                          descriptor(dest),
                                          dest.device(),
                                          descriptor(gradient_input),
                                          gradient_input.device(),
                                          descriptor(dest),
                                          dest.device(),
                                          &beta,
                                          descriptor(grad),
                                          grad.device()));
        }

    // ------------------------------------------------------------------------------------

        void tanh (
            tensor& dest,
            const tensor& src
        )
        {
            DLIB_CASSERT(have_same_dimensions(dest,src),"""");
            if (src.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnActivationForward(context(),
                                         tanh_activation_descriptor(),
                                         &alpha,
                                         descriptor(src),
                                         src.device(),
                                         &beta,
                                         descriptor(dest),
                                         dest.device()));
        }

        void tanh_gradient (
            tensor& grad,
            const tensor& dest,
            const tensor& gradient_input
        )
        {
            DLIB_CASSERT(
                  have_same_dimensions(dest,gradient_input) == true &&
                  have_same_dimensions(dest,grad) == true, """");
            if (dest.size() == 0)
                return;

            const float alpha = 1;
            const float beta = 0;
            CHECK_CUDNN(cudnnActivationBackward(context(),
                                          tanh_activation_descriptor(),
                                          &alpha,
                                          descriptor(dest),
                                          dest.device(),
                                          descriptor(gradient_input),
                                          gradient_input.device(),
                                          descriptor(dest),
                                          dest.device(),
                                          &beta,
                                          descriptor(grad),
                                          grad.device()));
        }

    // ------------------------------------------------------------------------------------

    } 
}

#endif // DLIB_USE_CUDA

#endif // DLIB_DNN_CuDNN_CPP_


",pooling_mode
739,"//!#####################################################################
//! \file Grid_Hierarchy_Backtrace.h
//!#####################################################################
// Class Grid_Hierarchy_Backtrace
//######################################################################
#ifndef __Grid_Hierarchy_Backtrace__
#define __Grid_Hierarchy_Backtrace__

#include <nova/Dynamics/Hierarchy/Grid_Hierarchy.h>
#include <nova/Dynamics/Hierarchy/Grid_Hierarchy_Lookup.h>
#include <nova/Tools/Log/Log.h>

namespace Nova{
template<class Struct_type,class T,int d>
class Grid_Hierarchy_Backtrace
{
    using TV                        = Vector<T,d>;
    using T_INDEX                   = Vector<int,d>;
    using Hierarchy                 = Grid_Hierarchy<Struct_type,T,d>;
    using Allocator_type            = SPGrid::SPGrid_Allocator<Struct_type,d>;
    using Flag_array_mask           = typename Allocator_type::template Array_mask<unsigned>;
    using Hierarchy_Lookup          = Grid_Hierarchy_Lookup<Struct_type,T,d>;

  public:
    static TV Backtrace(Hierarchy& hierarchy,int& level,const T_INDEX& cell_index,uint64_t& cell_offset,const TV& intra_cell_dX,const TV& dX)
    {
        const int original_level=level;
        const uint64_t  [MASK] =cell_offset;

        // get raw backtraced location index
        TV d_i=intra_cell_dX+dX*hierarchy.Lattice(level).one_over_dX;           // delta in cell coord = intra_cell_dX + dX/h (dX = -vel*dt)
        T_INDEX d_index;
        for(int axis=0;axis<d;++axis) d_index(axis)=std::floor(d_i(axis));
        TV weights=d_i-TV(d_index);
        T_INDEX backtraced_cell_index=cell_index+d_index;

        // clamp index, weights to grid
        const Range<int,d> cell_indices=hierarchy.Lattice(level).Cell_Indices();
        for(int axis=0;axis<d;++axis){
            if(backtraced_cell_index(axis)<cell_indices.min_corner(axis)){
                backtraced_cell_index(axis)=cell_indices.min_corner(axis);
                weights(axis)=(T)0.;}
            if(backtraced_cell_index(axis)>cell_indices.max_corner(axis)){
                backtraced_cell_index(axis)=cell_indices.max_corner(axis);
                weights(axis)=(T)1.;}}

        // look up where this is
        uint64_t backtraced_cell_offset=Flag_array_mask::Linear_Offset(backtraced_cell_index._data);
        // if found, then done
        if(Hierarchy_Lookup::Cell_Lookup(hierarchy,backtraced_cell_offset,level,weights)){
            cell_offset=backtraced_cell_offset;
            return weights;}

        Log::cout<<""Backtrace FAILED!! Originating: ""<<cell_index<<"", Backtraced: ""<<backtraced_cell_index<<std::endl;
        // giving up
        cell_offset= [MASK] ;
        level=original_level;
        return TV();
    }
};
}
#endif
",original_cell_offset
740,"#include ""mpParser.h""
#include ""Point.hpp""

#ifndef MUPARSERX_FUN_HPP_
#define MUPARSERX_FUN_HPP_

#include <string>

class MuparserXFun
{
public:
//@note initialization list does not follow the same order as the declaration
// you get warnings for this. It is better to follow the same order.
  MuparserXFun(const MuparserXFun &m)
  : m_parser(m.m_parser), m_s(m.m_s), m_k(m.m_k)
  {};

  MuparserXFun(const std::string &s, const size_t &k)
  : m_k(k), m_s(s)
  {
    try
      {}
    catch (mup::ParserError &e)
      {
        std::cerr << e.GetMsg() << std::endl;
      }
  };

  double operator()(Point &p)
  {
    mup::Value result;
    
    mup::Value m_arr(m_k,0.);
    
    for(size_t i = 0; i < m_k; ++i){
        m_arr.At(i) = p.getPoints()[i];
      }
    
    mup::Variable  [MASK] (&m_arr);


    /*This if statement is used to declarethe variables and the expression only once
      otherwise it will raise an error after the execution of the solver*/
    
    if(!this->flag){
      m_parser.DefineVar(""x"", & [MASK] );
      m_parser.SetExpr(m_s);
      this->flag = true;
    }
    
    result = m_parser.Eval();

    return result;
  };

  const std::string getM_s(){
    return m_s;
  }

private:
  const size_t      m_k;
  const std::string m_s;
  mup::ParserX      m_parser;
  bool              flag = false;
};

#endif",m_variable
741,"#include ""EXEPCH.h""

#include ""source/engine/Application.h""

#include ""source/engine/settings/ConfigFile.h""

#include ""source/engine/resources/ExeliusResourceFactory.h""

#include ""source/engine/gameobjectsystem/GameObjectSystem.h""

#include ""source/engine/gameobjectsystem/components/ExeliusComponentFactory.h""

#include ""source/messages/MessageServer.h""

#include ""source/messages/exeliusmessages/ExeliusMessageFactory.h""

#include ""source/networking/NetworkingManager.h""

#include ""source/debug/LogManager.h""

#include ""source/os/threads/JobSystem.h""

#include ""source/render/RenderManager.h""

#include ""source/resource/ResourceLoader.h""

#include ""source/os/input/InputManager.h""

#include ""source/os/events/ApplicationEvents.h"" // TODO: Remove this.

#include ""source/os/interface/graphics/Window.h"" // TODO: Remove this.

#include ""source/utility/generic/Time.h""

// ---------------------------------------------------------------------------------------------------------------
// TEST
#include ""source/os/memory/PoolAllocator.h""

class PoolTester
{
	int testInt;
public:
	PoolTester() : testInt(0) { }
	void* operator new(size_t size);
};

static auto& GetPool()
{
	static Exelius::PoolAllocator<sizeof(PoolTester), 4096> m_pool;
	return m_pool;
}

void* PoolTester::operator new(size_t size) { void* p = GetPool().Allocate(size, 0, ""PoolTester"", 0); return p; }

// END TEST
// ---------------------------------------------------------------------------------------------------------------

/// <summary>
/// Engine namespace. Everything owned by the engine will be inside this namespace.
/// </summary>
namespace Exelius
{
	/// <summary>
	/// Clients must inheret from this class in order to hook into the engine.
	/// This class contains the main loop and provides functions for the client
	/// to inject into the main loop.
	/// </summary>
	Application::Application()
		: m_pApplicationLog(nullptr)
		, m_pResourceFactory(nullptr)
		, m_pComponentFactory(nullptr)
		, m_pMessageFactory(nullptr)
		, m_lastFrameTime(0.0f)
		, m_isRunning(true)
		, m_hasLostFocus(false)
	{
		//
	}

	Application::~Application()
	{
		GameObjectSystem::DestroySingleton();

		EXELIUS_DELETE(m_pComponentFactory);
		EXELIUS_DELETE(m_pResourceFactory);
		EXELIUS_DELETE(m_pMessageFactory);

		RenderManager::GetInstance()->GetWindow()->GetEventMessenger().RemoveObserver(*InputManager::GetInstance());
		InputManager::DestroySingleton();

		RenderManager::GetInstance()->GetWindow()->GetEventMessenger().RemoveObserver(*this);
		RenderManager::DestroySingleton();

		ResourceLoader::DestroySingleton();

		EXELIUS_DELETE(m_pApplicationLog);

		NetworkingManager::DestroySingleton();

		EXELIUS_DELETE(s_pGlobalJobSystem);

		MessageServer::DestroySingleton();

		LogManager::DestroySingleton();

		StringIntern::_ClearStringInternSet();

		MemoryManager::GetInstance()->GetGlobalAllocator()->DumpMemoryData();

		MemoryManager::DestroySingleton();
	}

	bool Application::PreInitializeExelius()
	{
		// Should be the only call to ""new"" inside any Exelius code.
		MemoryManager::SetSingleton(new MemoryManager());
		EXE_ASSERT(MemoryManager::GetInstance());
		MemoryManager::GetInstance()->Initialize(true);

		LogManager::SetSingleton(EXELIUS_NEW(LogManager()));
		EXE_ASSERT(LogManager::GetInstance());
		if (!LogManager::GetInstance()->PreInitialize())
		{
			// Failed to pre-initialize LogManager
			EXE_ASSERT(false);
			return false;
		}

		return true;
	}

	bool Application::InitializeExelius()
	{
		// We instantiate this log here so that the config file warn messege will appear if needed.
		m_pApplicationLog = EXELIUS_NEW(Log(""Application""));
		EXE_ASSERT(m_pApplicationLog);

		//-----------------------------------------------
		// Config File - Open & Parse
		//-----------------------------------------------
		
		//PoolTester* pTest = new PoolTester();                                                                 <== Test code... to be removed

		// Read in the config file. This uses the logging system,
		// which is why the PreInit exists for the LoggingManager.
		ConfigFile configFile;
		if (!configFile.OpenConfigFile())
		{
			m_pApplicationLog->Warn(""Failed to open config file. Exelius will initialize with default settings."");
		}

		//-----------------------------------------------
		// Logging - Initialization
		//-----------------------------------------------

		if (!InitializeLogManager(configFile))
			return false;

		//-----------------------------------------------
		// Messaging - Initialization
		//-----------------------------------------------

		MessageServer::SetSingleton(EXELIUS_NEW(MessageServer()));
		EXE_ASSERT(MessageServer::GetInstance());

		//-----------------------------------------------
		// Job System - Initialization
		//-----------------------------------------------

		if (!s_pGlobalJobSystem)
			s_pGlobalJobSystem = EXELIUS_NEW(JobSystem());
		s_pGlobalJobSystem->Initialize();

		//-----------------------------------------------
		// Networking System - Initialization
		//-----------------------------------------------

		SetMessageFactory();
		EXE_ASSERT(m_pMessageFactory);

		NetworkingManager::SetSingleton(EXELIUS_NEW(NetworkingManager()));
		EXE_ASSERT(NetworkingManager::GetInstance());
		if (!NetworkingManager::GetInstance()->Initialize(m_pMessageFactory))
			return false;

		//-----------------------------------------------
		// Rendering - Initialization
		//-----------------------------------------------

		if (!InitializeRenderManager(configFile))
			return false;

		// TODO: This SUCKS
		RenderManager::GetInstance()->GetWindow()->GetEventMessenger().AddObserver(*this);

		//-----------------------------------------------
		// Input - Initialization
		//-----------------------------------------------

		if (!InitializeInputManager(configFile))
			return false;

		//-----------------------------------------------
		// Resource Factory - Initialization
		//-----------------------------------------------
		
		SetResourceFactory();
		EXE_ASSERT(m_pResourceFactory);

		//-----------------------------------------------
		// Resource Management - Initialization
		//-----------------------------------------------

		if (!InitializeResourceLoader(configFile))
			return false;

		//-----------------------------------------------
		// Component Factory - Initialization
		//-----------------------------------------------
		
		// This will call either the default (Exelius)
		// version, or the client's if defined.
		SetComponentFactory();
		EXE_ASSERT(m_pComponentFactory);

		//-----------------------------------------------
		// Gameobject & Component System - Initialization
		//-----------------------------------------------

		if (!InitializeGameObjectSystem(configFile))
			return false;

		//-----------------------------------------------
		// Client Application - Initialization
		//-----------------------------------------------

		return Initialize();
	}

	/// <summary>
	/// Applications main loop.
	/// Not inheretable, the client can't change this loop.
	/// </summary>
	void Application::Run()
	{
		EXE_ASSERT(m_pApplicationLog);

		constexpr int kNumFramesToAVG = 6000;
		int numFramesSinceAVG = 0;
		float accumulatedDeltaTime = 0.0f;

		//Log log;
		auto previousTime = eastl::chrono::high_resolution_clock::now();
		while (m_isRunning)
		{
			auto lastFrameTime = eastl::chrono::high_resolution_clock::now();
			eastl::chrono::duration<float> deltaTime = lastFrameTime - previousTime;
			previousTime = lastFrameTime;
			Time::DeltaTime.SetFromSeconds(deltaTime.count());

			if (numFramesSinceAVG < kNumFramesToAVG)
			{
				accumulatedDeltaTime += Time::DeltaTime.GetAsSeconds();
				++numFramesSinceAVG;
			}
			else
			{
				float avgFrameRate = accumulatedDeltaTime / (float)kNumFramesToAVG;
				m_pApplicationLog->Info(""FPS: {}"", 1.0f / avgFrameRate);
				numFramesSinceAVG = 0;
				accumulatedDeltaTime = 0.0f;
			}

			// Dispatch Messages
			MessageServer::GetInstance()->DispatchMessages();

			// Poll Window Events.
			RenderManager::GetInstance()->Update();

			// Update Components.
			GameObjectSystem::GetInstance()->Update();

			// Client Update.
			Update();

			// Refresh Input State.
			InputManager::GetInstance()->NextFrame();

			// Queue all renderable Components.
			GameObjectSystem::GetInstance()->Render();

			// Push render list to render thread.
			RenderManager::GetInstance()->EndRenderFrame();

			// Deallocate any resources necessary.
			ResourceLoader::GetInstance()->ProcessUnloadQueue();
		}
	}

	/// <summary>
	/// Sets the component factory to use when creating GameObjects
	/// and Components. 
	/// 
	/// NOTE:
	///		This will override any engine specific components unless
	///		the client's defined ComponentFactory inherets from
	///		ExeliusComponentFactory and calls it's CreateComponent()
	///		function.
	/// 
	///	Example:
	///		case default:
	///			return Exelius::ExeliusComponentFactory::CreateComponent(componentType, pOwningObject, componentData);
	/// </summary>
	void Application::SetComponentFactory()
	{
		m_pComponentFactory = EXELIUS_NEW(ExeliusComponentFactory());
	}

	/// <summary>
	/// Sets the resource factory to use when creating resources.
	/// 
	/// NOTE:
	///		This will override any engine specific resources unless
	///		the client's defined ResourceFactory inherets from
	///		ExeliusResourceFactory and calls it's CreateResource()
	///		function.
	/// 
	///	Example:
	///		case default:
	///			return Exelius::ExeliusResourceFactory::CreateResource(resourceID);
	/// </summary>
	void Application::SetResourceFactory()
	{
		m_pResourceFactory = EXELIUS_NEW(ExeliusResourceFactory());
	}

	/// <summary>
	/// Sets the message factory to use when creating Messages.
	/// 
	/// NOTE:
	///		This will override any engine specific Messages unless
	///		the client's defined MessageFactory inherets from
	///		ExeliusMessageFactory and calls it's CreateMessage()
	///		function.
	/// 
	///	Example:
	///		case default:
	///			return Exelius::ExeliusMessageFactory::CreateMessage();
	/// </summary>
	void Application::SetMessageFactory()
	{
		m_pMessageFactory = EXELIUS_NEW(ExeliusMessageFactory());
	}

	/// <summary>
	/// OS event handler. Handles the events that the platform sends.
	/// This function should not be inhereted, engine determins how OS events are handled.
	/// Example: SFML pollevent().
	/// </summary>
	/// <param name=""evnt"">The event to handle.</param>
	void Application::HandleEvent(Event& evnt)
	{
		if (evnt.GetEventType() == EventType::WindowClosed)
		{
			//WindowClosedEvent* pWinClosed = static_cast<WindowClosedEvent*>(&evnt);
			CloseApplication();
		}
	}

	/// <summary>
	/// Close the application.
	/// </summary>
	void Application::CloseApplication()
	{
		m_isRunning = false;
	}

	/// <summary>
	/// Initialize the LogManager using the config file data if necessary.
	/// </summary>
	/// <param name=""configFile"">- The pre-parsed config file.</param>
	/// <returns>True on success, false otherwise.</returns>
	bool Application::InitializeLogManager(const ConfigFile& configFile) const
	{
		EXE_ASSERT(m_pApplicationLog);

		FileLogDefinition  [MASK] ;
		ConsoleLogDefinition consoleDefinition;
		eastl::vector<LogData> logData;

		if (!configFile.PopulateLogData( [MASK] , consoleDefinition, logData))
		{
			m_pApplicationLog->Warn(""Failed to populate log data correctly. Please verify config file."");
		}

		if (!LogManager::GetInstance()->Initialize( [MASK] , consoleDefinition, logData))
		{
			m_pApplicationLog->Fatal(""Exelius::LogManager::Initialize Failed."");
			return false;
		}

		return true;
	}

	/// <summary>
	/// Initialize the RenderManager using the config file data if necessary.
	/// </summary>
	/// <param name=""configFile"">- The pre-parsed config file.</param>
	/// <returns>True on success, false otherwise.</returns>
	bool Application::InitializeRenderManager(const ConfigFile& configFile) const
	{
		EXE_ASSERT(m_pApplicationLog);

		eastl::string windowTitle(""ExeliusApplication"");
		Vector2u windowSize({ 720, 640 });
		bool isVSyncEnabled = false;

		if (!configFile.PopulateWindowData(windowTitle, windowSize, isVSyncEnabled))
		{
			m_pApplicationLog->Warn(""Failed to populate window data correctly. Please verify config file."");
		}

		RenderManager::SetSingleton(EXELIUS_NEW(RenderManager()));
		EXE_ASSERT(RenderManager::GetInstance());
		if (!RenderManager::GetInstance()->Initialize(windowTitle, windowSize, isVSyncEnabled))
		{
			m_pApplicationLog->Fatal(""Exelius::RenderManager failed to initialize."");
			return false;
		}

		return true;
	}

	/// <summary>
	/// Initialize the InputManager using the config file data if necessary.
	/// </summary>
	/// <param name=""configFile"">- The pre-parsed config file.</param>
	/// <returns>True on success, false otherwise.</returns>
	bool Application::InitializeInputManager([[maybe_unused]] const ConfigFile& configFile) const
	{
		EXE_ASSERT(m_pApplicationLog);

		InputManager::SetSingleton(EXELIUS_NEW(InputManager()));
		EXE_ASSERT(InputManager::GetInstance());
		if (!InputManager::GetInstance()->Initialize())
		{
			m_pApplicationLog->Fatal(""Exelius::InputManager failed to initialize."");
			return false;
		}

		// Attach the event observer to the window to handle window events.
		// TODO: I don't like this very much.
		RenderManager::GetInstance()->GetWindow()->GetEventMessenger().AddObserver(*InputManager::GetInstance());

		return true;
	}

	/// <summary>
	/// Initialize the ResourceLoader using the config file data if necessary.
	/// </summary>
	/// <param name=""configFile"">- The pre-parsed config file.</param>
	/// <returns>True on success, false otherwise.</returns>
	bool Application::InitializeResourceLoader([[maybe_unused]] const ConfigFile& configFile) const
	{
		EXE_ASSERT(m_pApplicationLog);

		// Create Resource Manager Singleton.
		ResourceLoader::SetSingleton(EXELIUS_NEW(ResourceLoader()));
		EXE_ASSERT(ResourceLoader::GetInstance());
		if (!ResourceLoader::GetInstance()->Initialize(m_pResourceFactory, ""EngineResources/"", true))
		{
			m_pApplicationLog->Fatal(""Exelius::ResourceLoader failed to initialize."");
			return false;
		}

		return true;
	}

	/// <summary>
	/// Initialize the GameObject System using the config file data if necessary.
	/// </summary>
	/// <param name=""configFile"">- The pre-parsed config file.</param>
	/// <returns>True on success, false otherwise.</returns>
	bool Application::InitializeGameObjectSystem([[maybe_unused]] const ConfigFile& configFile) const
	{
		EXE_ASSERT(m_pApplicationLog);

		GameObjectSystem::SetSingleton(EXELIUS_NEW(GameObjectSystem()));
		EXE_ASSERT(GameObjectSystem::GetInstance());
		if (!GameObjectSystem::GetInstance()->Initialize(m_pComponentFactory))
		{
			m_pApplicationLog->Fatal(""Exelius::GameObjectSystem failed to initialize."");
			return false;
		}

		return true;
	}
}",fileDefinition
742,"#include <vector>
#include <algorithm>
#include <set>
#include <string>
#include <map>
#include <unordered_map>
#include <iostream>
#include <climits>
#include <cmath>
#include <stack>
#include <queue>
#include <list>
#include <opencv2/objdetect.hpp>
#include ""lbplibrary.hpp""
using namespace std;
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

//class Solution {
//public:
//    vector<int> searchRange(vector<int>& nums, int target) {
//        auto low = lower_bound(nums.begin(), nums.end(), target);
//        auto up = lower_bound(nums.begin(), nums.end(),target);
//    }
//};


class Solution2 {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int> > sum(m, vector<int>(n, grid[0][0]));
        for (int i = 1; i < m; i++)
            sum[i][0] = sum[i - 1][0] + grid[i][0];
        for (int j = 1; j < n; j++)
            sum[0][j] = sum[0][j - 1] + grid[0][j];
        for (int i = 1; i < m; i++)
            for (int j = 1; j < n; j++)
                sum[i][j]  = min(sum[i - 1][j], sum[i][j - 1]) + grid[i][j];
        return sum[m - 1][n - 1];
    }
};

int BinSearch(vector<int> a, int low, int  [MASK] , int val){// 若找到则返回相应位置，没找到就是比待查元素小一点的位置
    while(low< [MASK] ){
        int mid=(low+ [MASK] )/2;
        if(a[mid] == val )  return mid;
        else if(a[mid] > val)  [MASK] =mid-1;
        else    low=mid+1;
    }
    if(low==0) return low;
    else return a[low] <= val ? low : low-1;
}

",high
743,"#include <iostream>
#include <fstream>
#include <string>
#include<vector>
#include<sstream>
#include <cctype>
#include <algorithm>
#include <map>
using namespace std;

   map<string,string> split(string s)
     {   int field_lengths[9] = {15,15,15,10,5,20,15,15,6};
        string fields[9] ={""lastn"",""firstn"",""middlen"",""aka"",""houseno"",""street"",""city"",""state"",""zip""};
        int numberof_fields = 9;
        vector<string> row_elements;
        std::map<string, string>  [MASK] ;
        int start=0;
        for(int i=0; i < numberof_fields; i++)
        {  string element = s.substr(start,field_lengths[i]);
           element.erase(std::remove_if(element.begin(), element.end(), ::isspace), element.end());
            [MASK] [fields[i]]=element;
           start+=field_lengths[i];
        }
        return  [MASK] ;
       }
    

    void envelop(vector<map<string,string>> list)
    {
      for (int i = 0; i < list.size(); i++)
      {
        cout<<list[i][""firstn""]<<"" ""<<list[i][""lastn""]<<"",""<<endl;
        cout<<list[i][""houseno""]<<"" ""<<list[i][""street""]<<"",""<<endl;
        cout<<list[i][""city""]<<"",""<<"" ""<<list[i][""state""]<<"" ""<<list[i][""zip""]<<endl;
        cout << endl;
      }
    }

     void fixed_length(vector<map<string,string>> list)
    {
      for (int i = 0; i < list.size(); i++)
      {
        int spaces = 31-(list[i][""firstn""].length()+list[i][""lastn""].length());
        cout<<list[i][""firstn""]<<"" ""<<list[i][""lastn""];
        for (int i=0;i<spaces;i++)
        {
          cout<<"" "";
        }
        spaces = 26-(list[i][""houseno""].length()+list[i][""street""].length());
        cout<<list[i][""houseno""]<<"" ""<<list[i][""street""];
         for (int i=0;i<spaces;i++)
        {
          cout<<"" "";
        }
        spaces = 38-(list[i][""city""].length()+list[i][""state""].length() + list[i][""zip""].length());
        cout<<list[i][""city""]<<"" ""<<list[i][""state""]<<"" ""<<list[i][""zip""];
         for (int i=0;i<spaces;i++)
        {
          cout<<"" "";
        }
        cout<<endl;
      }
    }

     void csv(vector<map<string,string>> list)
     {

  
       for (int i = 0; i < list.size(); i++)
      {
        cout<<list[i][""firstn""]<<"" ""<<list[i][""lastn""]<<"","";
        cout<<list[i][""houseno""]<<"" ""<<list[i][""street""]<<"","";
        cout<<list[i][""city""]<<"" ""<<list[i][""state""]<<"" ""<<list[i][""zip""]<<"","";
        cout<<endl;
      }
     }

int main(int argc, char **argv)
{
    string line;
    ifstream MyFile(argv[0]);
    vector<map<string, string> > list;
    string fields[9] ={""lastn"",""firstn"",""middlen"",""aka"",""houseno"",""street"",""city"",""state"",""zip""};

    while (getline (MyFile, line))
      {
        list.push_back(split(line));
      }
    cout<<list.size();
    cout<<endl;
  
    if (argv[1]==""envelop"")
    {
      cout<<""####################    Envelop Format       ###################""<<endl<<endl;
      envelop(list);
      cout<<endl;
    }
    if (argv[1]==""fixed_length"")
    {
    cout<<""####################    Fixed Format       ###################""<<endl<<endl;
    fixed_length(list);
    cout<<endl;
    }
    if (argv[1]==""csv"")
    {
    cout<<""####################    CSV Format       ###################""<<endl<<endl;
    csv(list);
    cout<<endl;
    }

    MyFile.close();
    return 1;
}

",my_map
744,"#include ""Draw.h""

// int frames = 0;
// double update_particles_time = 0;
// double scalar_field_draw = 0;
// double marching_cubes_draw = 0;

double sort_time = 0;
double find_time = 0;
double update_time = 0;
double field_time = 0;
double mc_time = 0;
int frame_count = 0;


void calc_mvp(Matrix& mvp)
{
    /* Define projection properties. */
    float degreesToRadiansCoefficient = atanf(1) / 45;                            /* Coefficient to recalculate degrees to radians.      */
    float  [MASK]                 = 45.0f;                                    /* 45 degrees field of view in the y direction.        */
    float frustum_aspect              = (float)window_width/(float)window_height; /* Aspect ratio.                                       */
    float frustum_z_near              = 0.01f;                                    /* How close the viewer is to the near clipping plane. */
    float frustum_z_far               = 100.0f;                                   /* How far the viewer is from the far clipping plane.  */
    float camera_distance             = 2.5f;                                     /* Distance from camera to scene center.               */

    /* Matrix that stores temporary matrix data for translation transformations. */
    Matrix mat4_translate  = Matrix::createTranslation(-0.5, -0.5, -0.5);

    /* Matrix that stores temporary matrix data for scale transformations. */
    Matrix mat4_scale      = Matrix::createScaling    ( 2.0,  2.0,  2.0);

    /* Matrix that transforms the vertices from model space to world space. */
    /* Translate and scale coordinates from [0..1] to [-1..1] range for full visibility. */
    Matrix mat4_model_view = mat4_scale * mat4_translate;

    /* Pull the camera back from the scene center. */
    mat4_model_view[14] -= float(camera_distance);

    /* Create the perspective matrix from frustum parameters. */
    Matrix mat4_perspective = Matrix::matrixPerspective(degreesToRadiansCoefficient *  [MASK] , frustum_aspect, frustum_z_near, frustum_z_far);

    /* MVP (Model View Perspective) matrix is a result of multiplication of Perspective Matrix by Model View Matrix. */
    mvp = mat4_perspective * mat4_model_view;
}


void setupGraphics(int width, int height)
{
    /* Store window width and height. */
    window_width  = width;
    window_height = height;

    /* Specify one byte alignment for pixels rows in memory for pack and unpack buffers. */
    GL_CHECK(glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    GL_CHECK(glPixelStorei(GL_PACK_ALIGNMENT,   1));

    GL_CHECK(glClearColor(1.0f, 1.0f, 1.0f, 1.0f));
    /* Initialize model view projection matrix. */
    calc_mvp(mvp);

    // SetUpSphereUpdater();
    // SetUpScalarField();

    
    SetUpParticleUpdater();
    SetUpParticleSort();
    SetUpFindStartIndex();
    SetUpParticleScalarField();

    // SetUpDrawPoints();

    SetUpMarchingCubesCells();
    SetUpMarchingCubesTriangles();
    // SetUpMarchingCubes();

    /* Enable facet culling, depth testing and specify front face for polygons. */
    GL_CHECK(glEnable   (GL_DEPTH_TEST));
    GL_CHECK(glEnable   (GL_CULL_FACE ));
    GL_CHECK(glFrontFace(GL_CW        ));

    /* Start counting time. */
    timer.reset();
    timer.getDelta();
}

void print_time(){
    LOGI(""particles : %d\ncells : %d\nsamples : %d\n"",n_particles,space_cells_per_axis,samples_per_axis);
    LOGI(""**************\n"");
    LOGI(""sort: %f\n"",sort_time/100.0);
    LOGI(""find: %f\n"",find_time/100.0);
    LOGI(""update: %f\n"",update_time/100.0);
    LOGI(""field: %f\n"",field_time/100.0);
    LOGI(""mc: %f\n"",mc_time/100.0);
    LOGI(""**************\n"");
}

/** Draws one frame. */
void renderFrame(void)
{
    // /* Update time. */
    // model_time = timer.getTime();
    // // time_delta = timer.getDelta();
    // time_delta = 0.02;

    // /* Clear the buffers that we are going to render to in a moment. */
    // GL_CHECK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));

    // // DrawSphereUpdater();
    // // DrawScalarField();

    // UpdateParticles();
    // UpdateParticleScalarField();
    // DrawScalarFieldPoints();
    
    // // DrawPoints();
    
   
    // // DrawMarchingCubes();
    
    // DrawMarchingCubesCells();
    // DrawMarchingCubesTriangles();

    /* Update time. */
    // model_time = timer.getTime();
    // time_delta = timer.getDelta();
    time_delta = 0.02;

    /* Clear the buffers that we are going to render to in a moment. */
    GL_CHECK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));

    // DrawSphereUpdater();
    // DrawScalarField();

    UpdateParticles();
    
    // timer.getDelta();
    UpdateParticleScalarField();
    // field_time += timer.getDelta();
    // // DrawScalarFieldPoints();
    
    // // DrawPoints();
    
   
    // // DrawMarchingCubes();
    
    DrawMarchingCubesCells();
    DrawMarchingCubesTriangles();

    // mc_time += timer.getDelta();

    // frame_count ++;
    // if(frame_count == 100){
    //     print_time();
    //     sort_time = 0;
    //     find_time = 0;
    //     update_time = 0;
    //     field_time = 0;
    //     mc_time = 0;
    //     frame_count = 0;
    // }
}

/** Deinitialises OpenGL ES environment. */
void cleanup()
{

    // CleanUpSphereUpdater();
    // CleanUpScalarField();
    // CleanUpMarchingCubesCells();
    // CleanUpMarchingCubesTriangles();
    // CleanUpMarchingCubes();
}



",frustum_fovy
745,"#include ""Read.h""
#include ""bithash.h""
#include <iostream>
#include <math.h>
#include <algorithm>
#include <set>
#include <queue>

#define TESTING false

int bithash::k;

////////////////////////////////////////////////////////////
// corrections_compare
//
// Simple class to compare to corrected_read's in the
// priority queue
////////////////////////////////////////////////////////////
class corrections_compare {
public:
  //  corrections_compare() {};
  bool operator() (const corrected_read* lhs, const corrected_read* rhs) const {
    //return lhs->likelihood < rhs->likelihood;
    if(lhs->likelihood < rhs->likelihood)
      return true;
    else if(lhs->likelihood > rhs->likelihood)
      return false;
    else
      return lhs->region_edits > rhs->region_edits;
  }
};

////////////////////////////////////////////////////////////
// Read (constructor)
//
// Make shallow copies of sequence and untrusted, and
// convert quality value string to array of probabilities
////////////////////////////////////////////////////////////
Read::Read(const string & h, const unsigned int* s, const string & q, vector<int> & u, const int rl)
  :untrusted(u) {

  header = h;
  read_length = rl;
  trim_length = rl;
  seq = new unsigned int[read_length];
  quals = new unsigned int[read_length];
  prob = new float[read_length];
  for(int i = 0; i < read_length; i++) {
    seq[i] = s[i];
    // quality values of 0,1 lead to p < .25
    quals[i] = q[i] - quality_scale;
    if(quals[i] >= max_qual) {
	 cerr << ""Quality value "" << quals[i] << ""larger than maximum allowed quality value "" << max_qual << "". Increase the variable 'max_qual' in Read.h."" << endl;
	 exit(EXIT_FAILURE);
    }	 
    prob[i] = max(.25, 1.0-pow(10.0,-(quals[i]/10.0)));
  }
  trusted_read = 0;
  global_like = 1.0;
}

Read::~Read() {
  delete[] seq;
  delete[] quals;
  delete[] prob;
  if(trusted_read != 0)
    delete trusted_read;
}

////////////////////////////////////////////////////////////
// trim
//
// Trim the end of the read the way BWA does it.
// Removes affected untrusted k-mers.
// Returns the trimmed read as a string.
////////////////////////////////////////////////////////////
string Read::trim(int t) {
  // find trim index
  int phredq;
  int current_trimfunc = 0;
  int max_trimfunc = 0;
  trim_length = read_length; // already set in constructor but ok
  for(int i = read_length-1; i >= 0; i--) {
    phredq = floor(.5-10*log(1.0 - prob[i])/log(10));
    current_trimfunc += (t - phredq);
    if(current_trimfunc > max_trimfunc) {
      max_trimfunc = current_trimfunc;
      trim_length = i;
    }
  }

  // update untrusted
  for(int i = untrusted.size()-1; i >= 0; i--) {
    if(untrusted[i] > trim_length - bithash::k)
      untrusted.pop_back();
  }

  vector<correction> no_cors;
  return print_corrected(no_cors);
}


////////////////////////////////////////////////////////////
// single_correct
//
// Find the set of corrections with maximum likelihood
// that result in all trusted kmers.
//
// Assumes a short read so obsolete.
////////////////////////////////////////////////////////////
/*
bool Read::single_correct(bithash *trusted, ofstream & out, double (&ntnt_prob)[4][4], bool learning) {
  if(correct_subset(untrusted, trusted, out, ntnt_prob, learning)) {
    out << header << ""\t"" << print_seq() << ""\t"" << print_corrected(trusted_read->corrections) << endl;
    return true;
  } else
    return false;
}
*/

////////////////////////////////////////////////////////////
// correct_cc
//
// Find the set of corrections with maximum likelihood that
// result in all trusted kmers in the region defined by
// the given untrusted kmer indices.
//
// Will print output if the read will not be corrected,
// but otherwise abstains.
//
// Corrections can be accessed through 'trusted_read'
//
// Return codes are:
// 0: corrected
// 1: ambiguous
// 2: full queue or quit early
// 3: empty queue or empty region
////////////////////////////////////////////////////////////
//bool Read::correct_cc(vector<short> region, vector<int> untrusted_subset, bithash *trusted, double (&ntnt_prob)[4][4], double prior_prob[4], bool learning) {  
int Read::correct_cc(vector<short> region, vector<int> untrusted_subset, bithash *trusted, double ntnt_prob[][4][4], double prior_prob[4], bool learning) {  

  unsigned int max_queue_size = 400000;

  /*
  if(header == ""@read3"") {
    cout << ""Untrusted: "" << untrusted_subset.size() << endl;
    for(int i = 0; i < untrusted_subset.size(); i++)
      cout << untrusted_subset[i] << "" "";
    cout << endl;
    cout << ""Region: "" << region.size() << endl;
    for(int i = 0; i < region.size(); i++)
      cout << region[i] << "" "";
    cout << endl << endl;
  } 
  */

  ////////////////////////////////////////
  // region
  ////////////////////////////////////////
  // sort by quality
  if(region.size() > 0)
    quality_quicksort(region, 0, region.size()-1);
  else
    // die quietly and try again with bigger region
    return 3;

  ////////////////////////////////////////
  // stats
  ////////////////////////////////////////
  unsigned int cpq_adds = 0;
  unsigned int check_count = 0;
  float exp_errors = 0;
  int nt90 = 0;
  int nt99 = 0;
  int non_acgt = 0;
  for(int i = 0; i < region.size(); i++) {
    exp_errors += (1-prob[region[i]]);
    if(prob[region[i]] < .9)
      nt90++;
    if(prob[region[i]] < .99)
      nt99++;
    if(seq[region[i]] >= 4)
      non_acgt++;
  }  

  ////////////////////////////////////////
  // filter
  ////////////////////////////////////////
  double mylike_t = correct_min_t;
  double myglobal_t = correct_min_t;
  double myspread_t = trust_spread_t;
  if(learning) {
    if(nt99 >= 8 || non_acgt > 1) {
      //out << header << ""\t"" << print_seq() << ""\t."" << endl;
      return 2;
    }
    mylike_t = learning_min_t;
    myglobal_t = learning_min_t;
    myspread_t = trust_spread_t / 2.0;
  } else if(nt99 >= 13 || non_acgt > 2) {
    // just quit
    if(TESTING)
	cerr << header << ""\t"" << print_seq() << ""\t."" << endl;
    //cerr << header << ""\t"" << region.size() << ""\t"" << untrusted_subset.size() << ""\t"" << nt90 << ""\t"" << nt99 << ""\t"" << exp_errors << ""\t0\t0\t0\t0"" << endl;
    return 2;

  } else if(nt99 >= 11) {  
    // proceed very cautiously
    if(aggressive)
      mylike_t = .05;
    else
      mylike_t = .1;

  } else if(nt99 >= 9) {
    //proceed cautiously
    if(aggressive)
      mylike_t = .001;
    else
      mylike_t = .03;
  }

  ////////////////////////////////////////
  // priority queue
  ////////////////////////////////////////
  // data structure for corrected_reads sorted by likelihood
  //priority_queue< corrected_read*, vector<corrected_read*>, corrections_compare > cpq;
  vector<corrected_read*> cpq;
  corrections_compare cpq_comp;

  ////////////////////////////////////////
  // initialize
  ////////////////////////////////////////
  corrected_read *cr, *next_cr;
  short edit_i;
  float like;
  bitset<bitsize> bituntrusted;
  for(int i = 0; i < untrusted_subset.size(); i++) {
       if(untrusted_subset[i] >= bitsize) {
	    cerr << ""These reads must be longer than assumed. Increase the variable 'bitsize' in 'Read.h' to the read length."" << endl;
	    exit(1);
       } else
	    bituntrusted.set(untrusted_subset[i]);
  }

  bool cr_added = true;  // once an iteration passes w/ no corrected reads added, we can stop
  for(short region_edit = 0; region_edit < region.size() && cr_added; region_edit++) {
    edit_i = region[region_edit];
    cr_added = false;

    for(short nt = 0; nt < 4; nt++) {
      if(seq[edit_i] != nt) {
	// P(obs=o|actual=a)*P(actual=a) for Bayes
	if(seq[edit_i] < 4)
	  like = (1.0-prob[edit_i]) * ntnt_prob[quals[edit_i]][nt][seq[edit_i]] * prior_prob[nt] / (prob[edit_i] * prior_prob[seq[edit_i]]);
	else
	  // non-ACGT
	  like = prior_prob[nt] / (1.0/3.0);

	// P(actual=a|obs=o)
	//like = (1.0-prob[edit_i]) * ntnt_prob[seq[edit_i]][nt] * / prob[edit_i];
	
	next_cr = new corrected_read(bituntrusted, like, region_edit+1);
	next_cr->corrections.push_back(correction(edit_i, nt));
      
	// add to priority queue
	//cpq.push(next_cr);
	cpq.push_back(next_cr);
	push_heap(cpq.begin(), cpq.end(), cpq_comp);
	cpq_adds++;
	cr_added = true;
      }
    }
  }

  ////////////////////////////////////////
  // process corrected reads
  ////////////////////////////////////////
  // initialize likelihood parameters
  trusted_read = 0;
  float trusted_likelihood;
  signed int untrusted_count;  // trust me
  bool ambiguous_flag = false;

  while(cpq.size() > 0) {    

    /////////////////////////
    // quit if pq is too big
    /////////////////////////
    if(cpq.size() > max_queue_size) {
      //cout << ""queue is too large for "" << header << endl;
      if(TESTING)
      	cerr << header << ""\t"" << print_seq() << ""\t."" << endl;

      if(trusted_read != 0) {
	delete trusted_read;
	trusted_read = 0;
      }
      break;
    }

    /////////////////////////
    // pop next
    /////////////////////////
    cr = cpq[0];
    pop_heap(cpq.begin(), cpq.end(), cpq_comp);
    cpq.pop_back();
    
    /////////////////////////
    // check likelihood
    /////////////////////////
    if(trusted_read != 0) {
      // if a corrected read exists, compare likelihoods and if likelihood is too low, break loop return true
      if(cr->likelihood < trusted_likelihood*myspread_t) {
	delete cr;
	break;
      }
    } else {
      // if no corrected read exists and likelihood is too low, break loop return false
      if(cr->likelihood < mylike_t || global_like*cr->likelihood < myglobal_t) {
	delete cr;
	break;
      }
    }
    
    /////////////////////////
    // check trust
    /////////////////////////
    // save for later comparison
    untrusted_count = (signed int)cr->untrusted.count();    
    if(check_trust(cr, trusted, check_count)) {
      if(trusted_read == 0) {
	// if yes, and first trusted read, save
	trusted_read = cr;
	trusted_likelihood = cr->likelihood;
      } else {
	// if yes, and if trusted read exists
	ambiguous_flag = true;

	// output ambiguous corrections for testing
	if(TESTING)
	  cerr << header << ""\t"" << print_seq() << ""\t"" << print_corrected(trusted_read->corrections) << ""\t"" << print_corrected(cr->corrections) << endl;
	
	// delete trusted_read, break loop
	delete trusted_read;
	delete cr;
	trusted_read = 0;
	break;
      }
    }

    /*
    if(header == ""@read3"") {
      cout << cr->likelihood << ""\t"";
      for(int c = 0; c < cr->corrections.size(); c++) {
	cout << "" ("" << cr->corrections[c].index << "","" << cr->corrections[c].to << "")"";
      }
      cout << ""\t"";
      for(int c = 0; c < trim_length-bithash::k+1; c++) {
	if(cr->untrusted[c])
	  cout << 1;
	else
	  cout << 0;
      }
      cout << endl;
    }
    */
    
    // if untrusted sharply increases, just bail
    if(((signed int)cr->untrusted.count() - untrusted_count)*3 < bithash::k) {

      /////////////////////////
      // add next correction
      /////////////////////////
      bool cr_added = true;  // once an iteration passes w/ no corrected reads added, we can stop
      for(short region_edit = cr->region_edits; region_edit < region.size() && cr_added; region_edit++) {
	edit_i = region[region_edit];
	cr_added = false;
	
	// add relatives
	for(short nt = 0; nt < 4; nt++) {
	  // if actual edit, 
	  if(seq[edit_i] != nt) {
	    // calculate new likelihood

	    // P(obs=o|actual=a)*P(actual=a) for Bayes
	    if(seq[edit_i] < 4)
	      like = cr->likelihood * (1.0-prob[edit_i]) * ntnt_prob[quals[edit_i]][nt][seq[edit_i]] * prior_prob[nt] / (prob[edit_i] * prior_prob[seq[edit_i]]);
	    else
	      // non-ACGT
	      like = cr->likelihood * prior_prob[nt] / (1.0/3.0);

	    // P(actual=a|obs=o)	    
	    //like = cr->likelihood * (1.0-prob[edit_i]) * ntnt_prob[seq[edit_i]][nt] / prob[edit_i];	
	    
	    // if thresholds ok, add new correction
	    if(trusted_read != 0) {
	      if(like < trusted_likelihood*myspread_t)
		continue;
	    } else {
	      // must consider spread or risk missing a case of ambiguity
	      if(like < mylike_t*myspread_t || global_like*like < myglobal_t*myspread_t)
		continue;
	    }
	    
	    next_cr = new corrected_read(cr->corrections, cr->untrusted, like, region_edit+1);
	    next_cr->corrections.push_back(correction(edit_i, nt));
	  
	    // add to priority queue
	    cpq.push_back(next_cr);
	    push_heap(cpq.begin(), cpq.end(), cpq_comp);
	    cpq_adds++;
	    cr_added = true;
	  }
	}
      }
    }

    // if not the saved max trusted, delete
    if(trusted_read != cr) {
      delete cr;
    }
  }

  // clean up priority queue
  for(int i = 0; i < cpq.size(); i++)
    delete cpq[i];
  
  if(trusted_read != 0) {
    //cerr << header << ""\t"" << region.size() << ""\t"" << untrusted_subset.size() << ""\t"" << nt90 << ""\t"" << nt99 << ""\t"" << exp_errors << ""\t"" << cpq_adds << ""\t"" << check_count << ""\t1\t"" << trusted_read->likelihood << endl;
    return 0;
  } else {
    if(TESTING && mylike_t > correct_min_t)
      cerr << header << ""\t"" << print_seq() << ""\t."" << endl;
    //cerr << header << ""\t"" << region.size() << ""\t"" << untrusted_subset.size() << ""\t"" << nt90 << ""\t"" << nt99 << ""\t"" << exp_errors << ""\t"" << cpq_adds << ""\t"" << check_count << ""\t0\t0"" << endl;

    if(ambiguous_flag)
      return 1;
    else if(cpq.size() > max_queue_size)
      return 2;
    else
      return 3;
  }
}

////////////////////////////////////////////////////////////
// print_seq
////////////////////////////////////////////////////////////
string Read::print_seq() {
  char nts[5] = {'A','C','G','T','N'};
  string sseq;
  for(int i = 0; i < read_length; i++)
    sseq.push_back(nts[seq[i]]);
  return sseq;
}

////////////////////////////////////////////////////////////
// print_corrected
//
// Print read with corrections and trimming.
////////////////////////////////////////////////////////////
string Read::print_corrected(vector<correction> & cor) {
  return print_corrected(cor, trim_length);
}
string Read::print_corrected(vector<correction> & cor, int print_nt) {
  char nts[5] = {'A','C','G','T','N'};
  string sseq;
  int correct_i;
  for(int i = 0; i < print_nt; i++) {
    correct_i = -1;
    for(int c = 0; c < cor.size(); c++) {
      if(cor[c].index == i)
	correct_i = c;
    }
    if(correct_i != -1)
      sseq.push_back(nts[cor[correct_i].to]);
    else
      sseq.push_back(nts[seq[i]]);
  }
  return sseq;
}
  

////////////////////////////////////////////////////////////
// correct
//
// Perform correction by breaking up untrusted kmers
// into connected components and correcting them
// independently.
////////////////////////////////////////////////////////////
//string Read::correct(bithash *trusted, double (&ntnt_prob)[4][4], double prior_prob[4], bool learning) {
string Read::correct(bithash *trusted, double ntnt_prob[][4][4], double prior_prob[4], bool learning) {
  ////////////////////////////////////////
  // find connected components
  ////////////////////////////////////////
  vector< vector<int> > cc_untrusted;

  // add first
  cc_untrusted.push_back(vector<int>());
  int cc = 0;
  cc_untrusted[cc].push_back(untrusted[0]);

  for(int i = 1; i < untrusted.size(); i++) {
    // if kmer from last untrusted doesn't reach next
    if(untrusted[i-1]+bithash::k-1 < untrusted[i]) {
      cc++;
      cc_untrusted.push_back(vector<int>());
    }
    cc_untrusted[cc].push_back(untrusted[i]);
  }

  ////////////////////////////////////////
  // process connected components
  ////////////////////////////////////////
  vector<correction> multi_cors;
  vector<short> chop_region;
  vector<short> big_region;
  int chop_correct_code, big_correct_code;
  for(cc = 0; cc < cc_untrusted.size(); cc++) {
    // try chopped error region
    chop_region = error_region_chop(cc_untrusted[cc]);
    chop_correct_code = correct_cc(chop_region, cc_untrusted[cc], trusted, ntnt_prob, prior_prob, learning);
    if(chop_correct_code > 0) {
      // try bigger error region
      big_region = error_region(cc_untrusted[cc]);
      if(chop_region.size() == big_region.size()) {
	// cannot correct, and nothing found so trim to untrusted
	if(chop_correct_code == 1)
	  return print_corrected(multi_cors, chop_region.front());
	else
	  return print_corrected(multi_cors, cc_untrusted[cc].front());

      } else {
	big_correct_code = correct_cc(big_region, cc_untrusted[cc], trusted, ntnt_prob, prior_prob, learning);

	if(big_correct_code == 1) {
	  // ambiguous
	  // cannot correct, but trim to region
	  if(chop_correct_code == 1)
	    return print_corrected(multi_cors, chop_region.front());
	  else
	    return print_corrected(multi_cors, big_region.front());

	} else if(big_correct_code == 2 || big_correct_code == 3) {
	  // cannot correct, and chaotic or nothing found so trim to untrusted
	  return print_corrected(multi_cors, cc_untrusted[cc].front());
	}
      }
    }
    // else, corrected!

    // corrected
    global_like *= trusted_read->likelihood;

    // store
    for(int c = 0; c < trusted_read->corrections.size(); c++)
      multi_cors.push_back(trusted_read->corrections[c]);
  }  

  // create new trusted read (mostly for learn_errors)
  corrected_read * tmp = trusted_read;
  trusted_read = new corrected_read(multi_cors, tmp->untrusted, global_like, 0);
  delete tmp;

  // print read with all corrections
  return print_corrected(multi_cors);
}


////////////////////////////////////////////////////////////
// error_region
//
// Find region of the read to consider for errors based
// on the pattern of untrusted kmers
////////////////////////////////////////////////////////////
vector<short> Read::error_region(vector<int> untrusted_subset) {
  // find intersection, or union
  vector<short> region;
  if(!untrusted_intersect(untrusted_subset, region))
    untrusted_union(untrusted_subset, region);

  // if front kmer can reach region, there may be more
  // errors in the front
  short f = region.front();
  short b = region.back();
  
  if(bithash::k-1 >= f) {
    // extend to front
    for(short i = f-1; i >= 0; i--)
      region.push_back(i);
  }
  if(trim_length-bithash::k <= b) {
    // extend to back
    for(short i = b+1; i < trim_length; i++)
      region.push_back(i);
  }

  return region;
}

////////////////////////////////////////////////////////////
// error_region_chop
//
// Find region of the read to consider for errors based
// on the pattern of untrusted kmers, using trusted kmers
// to further trim the area.
////////////////////////////////////////////////////////////
vector<short> Read::error_region_chop(vector<int> untrusted_subset) {
  // find intersection, or union
  vector<short> region;
  if(!untrusted_intersect(untrusted_subset, region))
    untrusted_union(untrusted_subset, region);

  // fix front
  int right_leftkmer = untrusted_subset.front()-1;
  if(right_leftkmer >= 0) {
    // erase all bp in rightmost left kmer
    vector<short> front_chop(region);
    region.clear();
    for(int i = 0; i < front_chop.size(); i++) {
      if(front_chop[i] > right_leftkmer+bithash::k-1)
	region.push_back(front_chop[i]);
    }

    // add back 1 base if it's low quality, or lower quality than the next base
    for(int er = 0; er < expand_region; er++) {
      int pre_region = region[0] - (er+1);
      if(pre_region >= 0 && (prob[pre_region] < .99 || prob[pre_region] <= prob[pre_region+1])) {
	vector<short>::iterator it;
	it = region.begin();
	region.insert(it, pre_region);
      }
    }
  } else {
    // extend to front
    for(int i = region[0]-1; i >= 0; i--)
      region.push_back(i);
  }

  // fix back
  int left_rightkmer = untrusted_subset.back()+1;
  if(left_rightkmer+bithash::k-1 < trim_length) {
    // erase all bp in leftmost right kmer
    vector<short> back_chop(region);
    region.clear();
    for(int i = 0; i < back_chop.size(); i++) {
      if(back_chop[i] < left_rightkmer)
	region.push_back(back_chop[i]);
    }

    // add back 1 base if it's low quality, or lower quality than the next base
    // Two issues with this:
    // 1. I think region could be empty, so there's a bug
    // 2. This won't help for errors in the middle of a read that are missing an untrusted kmer
    //    because the region will be empty, and we'll just try the intersection.
    /*
    for(int er = 0; er < expand_region; er++) {
      int post_region = region.back() + (er+1);
      if(post_region < trim_length && (prob[post_region] < .99 || prob[post_region] <= prob[post_region-1])) {
	region.push_back(post_region);
      }
    }
    */

  } else {
    // extend to back
    for(int i = region.back()+1; i < trim_length; i++)
      region.push_back(i);
  }

  return region;
}
    
////////////////////////////////////////////////////////////
// untrusted_intersect
//
// Compute the intersection of the untrusted kmers as
// start,end return true if it's non-empty or false
// otherwise
////////////////////////////////////////////////////////////
bool Read::untrusted_intersect(vector<int> untrusted_subset, vector<short> & region) {
  int start = 0;
  int end = read_length-1;

  int u;
  for(int i = 0; i < untrusted_subset.size(); i++) {
    u = untrusted_subset[i];

    // if overlap
    if(start <= u+bithash::k-1 && u <= end) {
      // take intersection
      start = max(start, u);
      end = min(end, u+bithash::k-1);
    } else {
      // intersection is empty
      return false;   
    }
  }
    
  // intersection is non-empty
  for(short i = start; i <= end; i++)
    region.push_back(i);
  return true;
}

////////////////////////////////////////////////////////////
// untrusted_union
//
// Compute the union of the untrusted kmers, though not
////////////////////////////////////////////////////////////
void Read::untrusted_union(vector<int> untrusted_subset, vector<short> & region) {
  short u;
  set<short>  [MASK] ;
  for(int i = 0; i < untrusted_subset.size(); i++) {
    u = untrusted_subset[i];

    for(short ui = u; ui < u+bithash::k; ui++)
       [MASK] .insert(ui);
  }

  set<short>::iterator it;
  for(it =  [MASK] .begin(); it !=  [MASK] .end(); it++)
    region.push_back(*it);      
}

////////////////////////////////////////////////////////////
// quality_quicksort
//
// Sort the indexes from lowest probability of an accurate
// basecall to highest
////////////////////////////////////////////////////////////
void Read::quality_quicksort(vector<short> & indexes, int left, int right) {
  int i = left, j = right;  
  short tmp;
  float pivot = prob[indexes[(left + right) / 2]];
 
  /* partition */
  while (i <= j) {
    while (prob[indexes[i]] < pivot)
      i++;    
    while (prob[indexes[j]] > pivot)      
      j--;
    if (i <= j) {
      tmp = indexes[i];
      indexes[i] = indexes[j];
      indexes[j] = tmp;
      i++;
      j--;
    }
  }

  /* recursion */
  if (left < j)
    quality_quicksort(indexes, left, j);
  if (i < right)
    quality_quicksort(indexes, i, right);  
}

////////////////////////////////////////////////////////////
// check_trust
//
// Given a corrected read and data structure holding
// trusted kmers, update the corrected_reads's vector
// of untrusted kmers and return true if it's now empty
////////////////////////////////////////////////////////////
bool Read::check_trust(corrected_read *cr, bithash *trusted, unsigned int & check_count) {
  // original read HAS errors
  if(cr->corrections.empty())
    return false;

  // make corrections to sequence, saving nt's to fix later
  vector<int> seqsave;
  int i;
  for(i = 0; i < cr->corrections.size(); i++) {
    seqsave.push_back(seq[cr->corrections[i].index]);
    seq[cr->corrections[i].index] = cr->corrections[i].to;
  }

  int edit = cr->corrections.back().index;
  int kmer_start = max(0, edit-bithash::k+1);
  //int kmer_end = min(edit, read_length-k);
  int kmer_end = min(edit, trim_length-bithash::k);

  check_count += (kmer_end - kmer_start + 1);

  bool non_acgt = false;
  for(i = kmer_start; i < kmer_end+bithash::k; i++)
    if(seq[i] >=4)
      non_acgt = true;

  //non_acgt = true;
  if(non_acgt) {
    // easier to just check kmers one by one
    for(i = kmer_start; i <= kmer_end; i++)
      // check kmer
      cr->untrusted.set(i, !trusted->check(&seq[i]));

  } else {
    // check affected kmers
    long long unsigned kmermap;
    // check first kmer and save map value  
    cr->untrusted.set(kmer_start, !trusted->check(&seq[kmer_start], kmermap));
    for(i = kmer_start+1; i <= kmer_end; i++) {
      // check kmer using map value
      cr->untrusted.set(i, !trusted->check(kmermap, seq[i-1], seq[i+bithash::k-1]));
    }
  }

  // fix sequence
  for(i = 0; i < cr->corrections.size(); i++)
    seq[cr->corrections[i].index] = seqsave[i];

  return(cr->untrusted.none());
}
",region_set
746,"#pragma once

//
//  Copyright (C) 2022 Pharap (@Pharap)
//
//  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.
//

// For uint32_t
#include <stdint.h>

namespace Hashing
{
	// https://en.wikipedia.org/wiki/Adler-32#Example_implementation
	struct Adler32
	{
		using hash_type = uint32_t;

		template<typename Type>
		hash_type operator()(const Type & object) const
		{
			return hash(object);
		}

		template<typename Type>
		static hash_type hash(const Type & object)
		{
			const auto  [MASK]  { reinterpret_cast<const unsigned char *>(&object) };

			uint32_t low { 0 };
			uint32_t high { 0 };

			for(size_t index = 0; index < sizeof(Type); ++index)
			{
				low = ((low +  [MASK] [index]) % 65521);
				high = ((low + high) % 65521);
			}
			
			return ((high << 16) | (low << 0));
		}
	};
}",pointer
747,"/***************************************************************************
 *   Copyright (C) 2023 by pilar                                           *
 *   <EMAIL>                                                        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/


#include ""pracaoc.h""


pracAOC::pracAOC(): QWidget()
{
	mainWin=new QMainForm();
	mainWin->setupUi(this);


	ctable.resize(256);
	for(int i=0; i < 256; i++)
		ctable[i] = qRgb(i,i,i);

    IMAGEW = mainWin->frameOrig->width();
    IMAGEW = (IMAGEW/4)*4;
    IMAGEH = mainWin->frameOrig->height();
    WIDTH = IMAGEW;
    HEIGHT = IMAGEH;

    qimgOrig = new QImage(IMAGEW, IMAGEH, QImage::Format_Indexed8);
	qimgOrig->setColorTable(ctable);
    qimgOrig->setColorCount(256);
    imgO = qimgOrig->bits();

    qimgDest = new QImage(IMAGEW, IMAGEH, QImage::Format_Indexed8);
	qimgDest->setColorTable(ctable);
    qimgDest->setColorCount(256);
    imgD = qimgDest->bits();

    qimgFromFile=QImage(IMAGEW, IMAGEH, QImage::Format_Indexed8);
    qimgFromFile.setColorTable(ctable);
    qimgFromFile.setColorCount(256);
    qimgFromFile.fill(0);

    for(unsigned int i=0; i<IMAGEW*IMAGEH;i++)
    {
        imgO[i]=0;
        imgD[i]=0;
    }

    gradients = (Gradient*)malloc(sizeof(Gradient) * WIDTH * HEIGHT);
    nContours = 0;

    connect ( mainWin->pushButtonCargar, SIGNAL (clicked()), this, SLOT( cargar() ) );
    connect ( mainWin->pushButtonSalir, SIGNAL (clicked()), this, SLOT( close() ) );

    connect (&timer,SIGNAL(timeout()),this,SLOT(process()));

    this->resize(this->width(), this->height());
    timer.start(33);

}


pracAOC::~pracAOC()
{
}


void pracAOC::paintEvent(QPaintEvent *)
{
	QPainter painter(this);

    QPoint  [MASK]  = mainWin->frameOrig->mapTo(this, mainWin->frameOrig->rect().topLeft());
    QPoint iniPointDest = mainWin->frameDest->mapTo(this, mainWin->frameDest->rect().topLeft());

    painter.drawImage( [MASK] , *qimgOrig);
    painter.drawImage(iniPointDest, *qimgDest);

    if(mainWin->CBShowContours->isChecked())
    {
        for(int i = 0; i<nContours; i++)
        {
            Point p = contours[i][0];
            int pIndex = 1;

            painter.setPen(QPen(Qt::green,2));
            if((mainWin->ContourType->currentIndex()==0 && !closedContour[i]) or (mainWin->ContourType->currentIndex()==1 && closedContour[i]) or mainWin->ContourType->currentIndex()==2)
            {
                while(contours[i][pIndex].x>=0)
                {
                    Point np = contours[i][pIndex];
                    painter.drawLine(QPoint(p.x, p.y)+iniPointDest, QPoint(np.x, np.y)+iniPointDest);
                    p = np;
                    pIndex++;
                }
            }

        }
    }


    if(mainWin->CBShowPolygons->isChecked())
    {
        painter.setBrush(QBrush(Qt::red));
        for(int i = 0; i<nContours; i++)
        {
            if(polygons[i][0].x>=0)
            {
                Point p = polygons[i][0];
                int pIndex = 1;

                painter.setPen(QPen(Qt::green,2));
                if((mainWin->ContourType->currentIndex()==0 && !closedContour[i]) or (mainWin->ContourType->currentIndex()==1 && closedContour[i]) or mainWin->ContourType->currentIndex()==2)
                {
                    while(polygons[i][pIndex].x>=0)
                    {
                        Point np = polygons[i][pIndex];
                        painter.setPen(QPen(Qt::green,2));
                        painter.drawLine(QPoint(p.x, p.y)+iniPointDest, QPoint(np.x, np.y)+iniPointDest);
                        painter.setPen(QPen(Qt::red,2));
                        painter.drawEllipse(QPoint(p.x,p.y)+iniPointDest, 3, 3);
                        p = np;
                        pIndex++;
                    }

                }
            }

        }
    }

	painter.end();
}

void pracAOC::resizeEvent(QResizeEvent *event)
{
    std::ignore = event;

    IMAGEW = mainWin->frameOrig->width();
    IMAGEW = (IMAGEW/4)*4;
    IMAGEH = mainWin->frameOrig->height();
    WIDTH = IMAGEW;
    HEIGHT = IMAGEH;

    *qimgOrig = qimgFromFile.scaled(WIDTH, HEIGHT);
    imgO = qimgOrig->bits();
    *qimgDest = qimgDest->scaled(WIDTH, HEIGHT);
    imgD = qimgDest->bits();

    delete gradients;
    gradients = (Gradient*)malloc(sizeof(Gradient) * WIDTH * HEIGHT);

}

void pracAOC::cargar()
{
    disconnect(&timer,SIGNAL(timeout()),this,SLOT(process()));

    unsigned alignedWidth;
    QImage qimgRead(IMAGEW,IMAGEH,QImage::Format_Indexed8);
	
    QString fn = QFileDialog::getOpenFileName(this, ""Seleccione un fichero"",""."", ""Images (*.png *.xpm *.jpg)"");
	if(qimgRead.load(fn))
	{
        qimgFromFile = qimgRead;
        qimgFromFile=qimgFromFile.convertToFormat(QImage::Format_Indexed8, ctable);

        qimgRead = qimgRead.scaled(WIDTH, HEIGHT);
		QImage qimgCRead(qimgRead.width(),qimgRead.height(),QImage::Format_Indexed8);

		qimgCRead=qimgRead.convertToFormat(QImage::Format_Indexed8, ctable);

        qimgFromFile = qimgCRead;

        alignedWidth = qimgCRead.width();

        for(unsigned y=0; y<IMAGEH && y<(unsigned) qimgCRead.height();y++)
            for(unsigned x=0; x<IMAGEW && x<(unsigned) qimgCRead.width(); x++)
            {
                imgO[y*IMAGEW+x]=(qimgCRead.bits())[(y*alignedWidth+x)];
            }

		update();
	}

    connect(&timer,SIGNAL(timeout()),this,SLOT(process()));
}



void pracAOC::process()
{
    canny_and_contours(imgO, imgD);

    update();
}


void pracAOC::closeEvent(QCloseEvent *event)
{
    std::ignore = event;

}


void pracAOC::canny_and_contours(unsigned char * input, unsigned char * output)
{
    unsigned char * output_binary = (unsigned char *) malloc(WIDTH*HEIGHT);
    unsigned char * output_blur   = (unsigned char *) malloc(WIDTH*HEIGHT);
    unsigned char * output_canny1 = (unsigned char *) malloc(WIDTH*HEIGHT);
    int           * output_gradNorm = (int *) malloc(WIDTH*HEIGHT*4);
    unsigned char * output_gradDir = (unsigned char *) malloc(WIDTH*HEIGHT);
    unsigned char * output_canny2 = (unsigned char *) malloc(WIDTH*HEIGHT);
    unsigned char * output_canny3 = (unsigned char *) malloc(WIDTH*HEIGHT);

    int N = mainWin->spinBoxBlurSize->value();

    int* kernel = (int*)Gaus1x1;
    if (N == 1) {
        kernel = (int*)Gaus3x3;
    }
    else if (N == 2) {
        kernel = (int*)Gaus5x5;
    }


    imageprocess::suavizado(input, output_blur, WIDTH, HEIGHT, kernel, N);
    memcpy(output_binary, output_blur, WIDTH*HEIGHT);
    if(mainWin->ApplyBinarization->isChecked())
        imageprocess::umbralizar(output_blur, output_binary, mainWin->BinaryThreshold->value(), WIDTH, HEIGHT);

    memset(gradients, 0, WIDTH*HEIGHT*sizeof(Gradient));
    imageprocess::calculoGradientes(output_binary, gradients, WIDTH, HEIGHT);

    for (unsigned int y = 0; y < HEIGHT; y++) {
        for (unsigned int x = 0; x < WIDTH; x++) {
            int index = y * WIDTH + x;
            float val = sqrt(pow(gradients[index].dx,2) + pow(gradients[index].dy,2)); // Initialize output with gradient magnitude
            output_gradNorm[index] = val;
            if(val > 255)
                output_canny1[index] = 255;
            else
                output_canny1[index] = val;

            float angle = atan2(gradients[index].dy, gradients[index].dx);

            float theta = angle * (360.0 / (2.0 * M_PI));

            if ((theta <= 22.5 && theta >= -22.5) || (theta <= -157.5) ||
                (theta >= 157.5))
            {
                output_gradDir[index] = 0;
            }
            else if ((theta > 22.5 && theta <= 67.5) ||
                       (theta > -157.5 && theta <= -112.5))
            {
                output_gradDir[index] = 1;
            }
            else if ((theta > 67.5 && theta <= 112.5) ||
                       (theta >= -112.5 && theta < -67.5))
            {
                output_gradDir[index] = 2;
            }
            else if ((theta >= -67.5 && theta < -22.5) ||
                       (theta > 112.5 && theta < 157.5))
            {
                output_gradDir[index] = 3;
            }
        }
    }

    memset(output_canny2, 0, WIDTH*HEIGHT);
    imageprocess::supresionNoMaximo(output_gradNorm, output_gradDir, output_canny2, WIDTH, HEIGHT);

    unsigned char lowThreshold = mainWin->minThresholdSlider->value();
    unsigned char highThreshold = mainWin->maxThresholdSlider->value();
    memset(output_canny3, 0, WIDTH*HEIGHT);
    imageprocess::dobleUmbralizacion(output_canny2, output_canny3, lowThreshold, highThreshold, WIDTH, HEIGHT);


    //output is visited now
    memset(output, 0, WIDTH*HEIGHT);
    findContours(output_canny3, output, contours, nContours);

    mainWin->detectedContours->display(nContours);

    switch(mainWin->selectOutputImage->currentIndex())
    {
        case 0:
            memset(output, 0, WIDTH*HEIGHT);
            break;
        case 1:
            memcpy(output, output_blur, WIDTH*HEIGHT);
            break;
        case 2:
            memcpy(output, output_binary, WIDTH*HEIGHT);
            break;
        case 3:
            memcpy(output, output_canny1, WIDTH*HEIGHT);
            break;
        case 4:
            memcpy(output, output_canny2, WIDTH*HEIGHT);
            break;
        case 5:
            memcpy(output, output_canny3, WIDTH*HEIGHT);
            break;

    }

    free(output_binary);
    free(output_blur);
    free(output_canny1);
    free(output_gradNorm);
    free(output_gradDir);
    free(output_canny2);
    free(output_canny3);

}

void pracAOC::findContours(unsigned char * image, unsigned char *visited, Point contours[1000][5000], int & nContours)
{
    nContours = 0;
    for(unsigned int y = 1; y<HEIGHT-1; y++)
    {
        for(unsigned int x = 1; x<WIDTH-1; x++)
        {
            int index = y*WIDTH + x;
            if(visited[index]==0 && image[index]==255)
            {
                Point ini_point = {(int) x, (int) y};
                int nPoints = followContour(image, visited, ini_point, contours[nContours], WIDTH, HEIGHT);
                if(nPoints>mainWin->spinBoxMinPoints->value())
                {
                    contours[nContours][nPoints] = {-1,-1};
                    float dist=sqrt(pow(contours[nContours][0].x-contours[nContours][nPoints-1].x, 2)+pow(contours[nContours][0].y-contours[nContours][nPoints-1].y, 2));
                    if(dist<20 && nPoints<5000)
                        closedContour[nContours] = true;
                    else
                        closedContour[nContours] = false;

                    int nPPolygon = createPolygon(contours[nContours], closedContour[nContours], nPoints, polygons[nContours], mainWin->doubleSpinBoxDistancePoly->value());
                    polygons[nContours][nPPolygon] = {-1,-1};
                    nContours++;
                }
            }
            if(nContours>=1000)
                break;
        }

        if(nContours>=1000)
            break;

    }

}

int pracAOC::followContour(unsigned char * image, unsigned char * visited, Point ini_point, Point contour[5000], int WIDTH, int HEIGHT)
{
    int nPoints= 0;

    Point directions[8];
    directions[0] = {0, -1};
    directions[4] = {1, -1};
    directions[2] = {1, 0};
    directions[5] = {1, 1};
    directions[1] = {0, 1};
    directions[6] = {-1, 1};
    directions[3] = {-1, 0};
    directions[7] = {-1, -1};

    Point cont_aux[2][5000];
    int nP_sides[2];

    nP_sides[0] = imageprocess::detectaContorno(image, visited, ini_point.x, ini_point.y, directions, cont_aux[0], WIDTH, HEIGHT);
    nP_sides[1] = imageprocess::detectaContorno(image, visited, ini_point.x, ini_point.y, directions, cont_aux[1], WIDTH, HEIGHT);

    int iC = 0;
    for(int i=nP_sides[1]-1; i>0; i--)
    {
        if(iC<5000)
        {
            contour[iC] = cont_aux[1][i];
            iC++;
        }

    }
    for(int i=0; i<nP_sides[0]; i++)
    {
        if(iC<5000)
        {
            contour[iC] = cont_aux[0][i];
            iC++;
        }
    }


    nPoints = iC;

    return nPoints;


}

int pracAOC::createPolygon(Point contour[5000], bool isClosed, int nPoints, Point polygon[5000], float distance)
{
    int nP;
    int index = 0;
    float dmax = 0;

    if(isClosed)
    {
        for(int i = 1; i<nPoints-1; i++)
        {
            float d = sqrt(pow(contour[i].x-contour[0].x,2) + pow(contour[i].y-contour[0].y,2));
            if(d > dmax)
            {
                index = i;
                dmax = d;
            }
        }

        if(dmax > distance)
        {
            int np1 = imageprocess::contornoAPoligono(contour, index+1, polygon, distance);
            int np2 = imageprocess::contornoAPoligono(&contour[index], nPoints-index, &polygon[np1-1], distance);
            nP = np1+np2-1;
            if(nP<0)
                nP = 0;
        }
        else
        {
            polygon[0] = contour[0];
            polygon[1] = contour[nPoints-1];
            nP = 2;
        }

    }
    else
        nP = imageprocess::contornoAPoligono(contour, nPoints, polygon, distance);

    return nP;
}
",iniPointOrig
748,"/*******************************************************************************
* Copyright 2019 ROBOTIS Japan CO., LTD.
*
* 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.
*******************************************************************************/

/* Author: <NAME> */

#include <ros/ros.h>
#include <ros/package.h>
#include <std_msgs/String.h>
#include <std_msgs/Bool.h>

void playSound(const std::string &path);
void thormang3CommandCallback(const std_msgs::String::ConstPtr &msg);
void manipInitCallback(const std_msgs::String::ConstPtr &msg);
void balanceCommandCallback(const std_msgs::Bool::ConstPtr &msg);

const int SPIN_RATE = 30;
ros::Publisher play_sound_pub;
std::string default_mp3_path = """";

int main(int argc, char **argv)
{
  //init ros
  ros::init(argc, argv, ""demo_node"");
  ros::NodeHandle nh(ros::this_node::getName());

  // ros::Subscriber sound_command_sub = nh.subscribe(""/robotis/mode_command"", 1, thormang3CommandCallback);
  ros::Subscriber sound_command_sub = nh.subscribe(""/robotis/base/ini_pose"", 1, thormang3CommandCallback);
  ros::Subscriber enable_ctrl_module_sub = nh.subscribe(""/robotis/enable_ctrl_module"", 1, thormang3CommandCallback);
  ros::Subscriber move_lidar_sub = nh.subscribe(""/robotis/head_control/move_lidar"", 1, thormang3CommandCallback);
  ros::Subscriber manip_init_sub = nh.subscribe(""/robotis/manipulation/ini_pose_msg"", 1, manipInitCallback);
  ros::Subscriber balance_command_sub = nh.subscribe(""/robotis/thormang3_foot_step_generator/balance_command"", 1, balanceCommandCallback);

  default_mp3_path = ros::package::getPath(""jp_thormang3_common_demo"") + ""/data/mp3/"";
  play_sound_pub = nh.advertise<std_msgs::String>(""sound/play_sound_file"", 0);
  ROS_INFO(""MP3 Path : %s"", default_mp3_path.c_str());

  // ros::start();
  ros::Rate loop_rate(SPIN_RATE);

  //node loop
  while (ros::ok())
  {
    ros::spinOnce();
    loop_rate.sleep();
  }

  return 0;
}

void playSound(const std::string &path)
{
  std_msgs::String  [MASK] ;
   [MASK] .data = path;

  play_sound_pub.publish( [MASK] );
}

void thormang3CommandCallback(const std_msgs::String::ConstPtr &msg)
{
  if (msg->data == ""ini_pose"")
    {
      playSound(default_mp3_path + ""thormang3_001_init.mp3"");
    }
  else if(msg->data == ""manipulation_module"")
    {
      playSound(default_mp3_path + ""thormang3_002_manip.mp3"");
    }
  else if(msg->data == ""walking_module"")
    {
      playSound(default_mp3_path + ""thormang3_003_walk.mp3"");
    }
  else if(msg->data == ""start"")
    {
      playSound(default_mp3_path + ""thormang3_004_scan.mp3"");
    }
}

void manipInitCallback(const std_msgs::String::ConstPtr &msg)
{
  playSound(default_mp3_path + ""thormang3_005_manip_ready.mp3"");
}

void balanceCommandCallback(const std_msgs::Bool::ConstPtr &msg)
{
  if (msg->data == true)
    {
      playSound(default_mp3_path + ""thormang3_010_auto_balancer.mp3"");
    }
}
",sound_msg
749,"#include <stdio.h>
#include <string.h>

int main(){	
	int T;
	int  [MASK]  = 0;
	int curr, next, prev, sumCurr, sumNext, sumPrev;
	char arr[101];
	
	scanf(""%d"", &T);
	getchar();
	
	for(int i = 0; i < T; i++){
		scanf(""%[^\n]"", arr);
		getchar();
		
		//Convert lower to upper
		for(int j = 0; j <strlen(arr); j++){
			if(arr[j] >= 'a' && arr[j] <= 'z'){
				arr[j] = 'A' + (arr[j] - 'a');
			}
		}
		
		//Print
		printf(""Case #%d: "", i+1);
		for(int j = 0; j < strlen(arr); j++){
			 [MASK]  = 0;
			
			if(arr[j] >= 'A' && arr[j] <= 'Z'){
				//For Alphabet
				curr = arr[j] - 'A' + 1;
				sumCurr = (curr / 10) + curr % 10;
				printf(""%02d"", curr);
				
				if(j+1 != strlen(arr) && arr[j+1] >='A' && arr[j+1] <= 'Z'){					
					next = arr[j+1] - 'A' + 1;
					sumNext = (next / 10) + next % 10;
					
					if(sumCurr != sumNext){
						 [MASK]  = 1;
					}
				} else{
					if(j+1 != strlen(arr)){
						 [MASK]  = 1;
					}
				}
				
			} else if(arr[j] >= '0' && arr[j] <= '9'){
				//For Number
				printf(""0%c"", arr[j]);
				
				if(j+1 != strlen(arr)){
					 [MASK]  = 1;
				}
			} else{
				//For non-alphabet and non-number
				printf(""%c%c%c"", arr[j], arr[j], arr[j]);
				
				if(j+1 != strlen(arr)){
					 [MASK]  = 1;
				}
			}
			
			if( [MASK]  == 1){
				printf("" "");
			}
		}
		
		printf(""\n"");
	}
	
	return 0;
}
",space
750,"/* This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://www.wtfpl.net/ for more details. */

#include ""mc7010.h""
#include <boost/program_options.hpp>
#include <rhash.h>
#include <signal.h>
#include <vector>
#include <iostream>
#include <thread>
#include <chrono>

using namespace std;
namespace bpo = boost::program_options;

int main(int argc, char *argv[])
{
    // Disable SIGPIPE
    struct sigaction act;
    act.sa_handler = SIG_IGN;
    act.sa_flags = SA_RESTART;
    sigemptyset(&act.sa_mask);
    if (sigaction(SIGPIPE, &act, NULL) < 0)
        return 1;

    std::string program_name = argv[0];
    std::string usage_examples_text = string(""Usage examples:\n\n"") + \
        ""Get single value\n"" + \
        program_name +  "" --router-ip 192.168.1.1 --router-pw password --get \""network_provider\""\n\n"" + \
        ""Get multiple values at the same time\n"" + \
        program_name +  "" --get \""network_provider,network_type\""\n\n"" + \
        ""Set LTE band mask\n"" + \
        program_name +  "" --set \""goformId=BAND_SELECT&is_gw_band=0&gw_band_mask=0&is_lte_band=1&lte_band_mask=0x02000000045\""\n\n"" + \
        ""Set antenna mode to manual\n"" + \
        program_name +  "" --set \""goformId=WAN_ANT_SWITCH_SET&ant_switch_enable=0\""\n\n"" + \
        ""Multiple get commands with 2 second wait time between requests\n"" + \
        program_name +  "" --get \""network_provider\"" --get \""network_type\"" --wait 2000"";

    string router_ip;
    string router_pw;
    int wait_ms;
    vector<string> set_command;
    vector<string> get_command;

    vector<string> unrecognized_options;
    bpo::variables_map vm;
    bpo::options_description options(""Options"");
    try
    {
        options.add_options()
            (""help,h"", ""Print help message"")
            (""version"", ""Print version string"")
            (""router-ip"", bpo::value<string>(&router_ip)->default_value(""192.168.8.1""), ""Router ip address"")
            (""router-pw"", bpo::value<string>(&router_pw)->default_value(""1234""), ""Router password"")
            (""get"", bpo::value< vector<string> >(&get_command)->composing(), ""Get command"")
            (""set"", bpo::value< vector<string> >(&set_command)->composing(), ""Set command"")
            (""wait"", bpo::value<int>(&wait_ms)->default_value(0), ""Time to wait between commands in milliseconds"")
        ;

        bpo::parsed_options parsed = bpo::parse_command_line(argc, argv, options);
        bpo::store(parsed, vm);
        unrecognized_options = bpo::collect_unrecognized(parsed.options, bpo::include_positional);
        bpo::notify(vm);

        if (vm.count(""help"") || argc < 2)
        {
            cout << VERSION_STRING << endl << endl << options << endl;
            cout << endl << usage_examples_text << endl;
            return 0;
        }

        if (vm.count(""version""))
        {
            cout << VERSION_STRING << endl;
            return 0;
        }
    }
    catch (exception& e)
    {
        cerr << ""Error: "" << e.what() << endl;
        return 1;
    }
    catch (...)
    {
        cerr << ""Exception of unknown type!"" << endl;
        return 1;
    }

    if (!unrecognized_options.empty())
    {
        cout << ""Unrecognized option"" << endl;
        for (auto option : unrecognized_options)
            cout << option << endl;
    }

    // Init curl and rhash
    curl_global_init(CURL_GLOBAL_ALL);
    rhash_library_init();

    MC7010 mc7010(router_ip, router_pw);

    if (!mc7010.login())
    {
        cerr << ""Login failed"" << endl;
        curl_global_cleanup();
        return 1;
    }

    int res = 0;
    Json::Value  [MASK] ;

    if (!get_command.empty())
    {
        for (auto cmd : get_command)
        {
            if (wait_ms > 0)
                this_thread::sleep_for(chrono::milliseconds(wait_ms));
             [MASK]  = mc7010.cmdProcess_Get(cmd);
            if ( [MASK] .empty())
            {
                res += 1;
                cerr << ""Get: "" << cmd << endl << ""Failed"" << endl;
                continue;
            }
            cout << ""Get: "" << cmd << endl <<  [MASK]  << endl;
        }
    }

    if (!set_command.empty())
    {
        for (auto cmd : set_command)
        {
            if (wait_ms > 0)
                this_thread::sleep_for(chrono::milliseconds(wait_ms));
             [MASK]  = mc7010.cmdProcess_Set(cmd);
            if ( [MASK] .empty())
            {
                res += 1;
                cerr << ""Set: "" << cmd << endl << ""Failed"" << endl;
                continue;
            }
            cout << ""Set: "" << cmd << endl <<  [MASK]  << endl;
        }
    }

    // Cleanup curl
    curl_global_cleanup();

    return res;
}
",json
751,"#include ""cblas.h""
#include ""lapacke.h""
#include ""physical_constants.hpp""
#include ""atomic_masses.hpp""
#include ""pes_interface_cppside.hpp""

template <auto NUM_COORDS>
void randPertGeom(std::array<double,NUM_COORDS>& geom_pert, std::mt19937_64& PRNG, std::uniform_real_distribution<double>& RN){
	///Given an initalized pseudorandom number generator engine, and a desired uniform distribution, randomly perturb the coordinates
	///of the given geometry.
	for(auto& coord : geom_pert) coord += RN(PRNG);
}

template <uint32_t NUM_ATOMS>
void randPertGeom(xyzfile& geom_pert, std::mt19937_64& PRNG, std::uniform_real_distribution<double>& RN){
	///Given an initalized pseudorandom number generator engine, and a desired uniform distribution, randomly perturb the coordinates
	///of the given geometry.
	for(uint32_t i=0; i<NUM_ATOMS; i++){
		geom_pert.atomvec[i].xcoord += RN(PRNG);
		geom_pert.atomvec[i].ycoord += RN(PRNG);
		geom_pert.atomvec[i].zcoord += RN(PRNG);
	}
}

template <bool geomInBohrs, auto NUM_COORDS>
double calcDisplacedE(std::array<double,NUM_COORDS> geom, const uint32_t idx, const double disp){
	///Calculate the energy at a point with one coordinate displaced.
	geom[idx] += disp;
	return EvaluateEnergy<geomInBohrs>(geom);
}

template <bool geomInBohrs, auto NUM_COORDS>
double calcDisplacedE(std::array<double,NUM_COORDS> geom, const uint32_t idx_1, const uint32_t idx_2, const double disp_1, const double disp_2){
	///Calculate the energy at a point with two coordinates displaced.
	geom[idx_1] += disp_1;
	geom[idx_2] += disp_2;
	return EvaluateEnergy<geomInBohrs>(geom);
}

template <bool extraAcc, bool geomInBohrs, auto NUM_COORDS>
void calcGrad(const std::array<double,NUM_COORDS>& geom, std::array<double,NUM_COORDS>& grad, const double disp){
	///Calculate gradient vector via two-sided numerical differentiation.
	///If requested, a more accurate six-point numerical differentiation formula will be used.
	[[maybe_unused]] const double inv_2h = static_cast<double>(1)/(2*disp);
	[[maybe_unused]] const double inv_12h = static_cast<double>(1)/(12*disp);
	[[maybe_unused]] const double inv_60h = static_cast<double>(1)/(60*disp);
	for (uint32_t i=0; i<grad.size(); i++){
		if constexpr (!extraAcc){
			grad[i] = inv_2h*( calcDisplacedE<geomInBohrs>(geom, i, disp) - calcDisplacedE<geomInBohrs>(geom, i, -disp) );
		}else{
			//grad[i] = inv_12h*( calcDisplacedE<geomInBohrs>(geom, i, -2*disp) - 8*calcDisplacedE<geomInBohrs>(geom, i, -disp) + 8*calcDisplacedE<geomInBohrs>(geom, i, disp) - calcDisplacedE<geomInBohrs>(geom, i, 2*disp));
			grad[i] = inv_60h*(
				- calcDisplacedE<geomInBohrs>(geom, i, -3*disp) + 9*calcDisplacedE<geomInBohrs>(geom, i, -2*disp)
				- 45*calcDisplacedE<geomInBohrs>(geom, i, -disp) + 45*calcDisplacedE<geomInBohrs>(geom, i, disp)
				- 9*calcDisplacedE<geomInBohrs>(geom, i, 2*disp) + calcDisplacedE<geomInBohrs>(geom, i, 3*disp)
			);
		}
	}
}
template <bool extraAcc, bool geomInBohrs, auto NUM_COORDS>
std::array<double,NUM_COORDS> calcGrad(const std::array<double,NUM_COORDS>& geom, const double disp){
	///Calculate gradient vector via two-sided numerical differentiation.
	///If requested, a more accurate six-point numerical differentiation formula will be used.
	std::array<double,NUM_COORDS> grad;
	calcGrad<extraAcc, geomInBohrs>(geom, grad, disp);
	return grad;
}

template <bool extraAcc, bool geomInBohrs, auto NUM_COORDS>
void calcHess(const std::array<double,NUM_COORDS>& geom, std::array<double,NUM_COORDS*NUM_COORDS>& hess, const double disp){
	///Calculate Hessian matrix via two-sided numerical differentiation.
	///If requested, more accurate (fourth order) formulas are used. (5 point for diagonal, 8 point for off-diagonal elements)
	///While the Hessian is exactly symmetric in infinite precision, due to finite precision and especially due to numerical differentiation
	///this would not be the case by default. Regardless, the Hessian will be populated to be exactly symmetric, by using (i,j) for (i,j) and (j,i).
	[[maybe_unused]] const double twoEcenter = 2*EvaluateEnergy_copy<geomInBohrs>(geom);
	[[maybe_unused]] const double thirtyEcenter = 30*EvaluateEnergy_copy<geomInBohrs>(geom);
	[[maybe_unused]] const double inv_4sqrh = static_cast<double>(1)/(4*disp*disp);
	[[maybe_unused]] const double inv_12sqrh = static_cast<double>(1)/(12*disp*disp);
	[[maybe_unused]] const double inv_48sqrh = static_cast<double>(1)/(48*disp*disp);
	[[maybe_unused]] const double inv_sqrh = static_cast<double>(1)/(disp*disp);
	//does not touch the diagonal
	for (uint32_t i=1; i<geom.size(); i++){
		for (uint32_t j=0; j<i; j++){
			if constexpr (!extraAcc){
				hess[i*geom.size() + j] = inv_4sqrh*(
					calcDisplacedE<geomInBohrs>(geom, i, j, disp, disp)
					- calcDisplacedE<geomInBohrs>(geom, i, j, disp, -disp)
					- calcDisplacedE<geomInBohrs>(geom, i, j, -disp, disp)
					+ calcDisplacedE<geomInBohrs>(geom, i, j, -disp, -disp) );
			}else{
				hess[i*geom.size() + j] = inv_48sqrh*(
					  - calcDisplacedE<geomInBohrs>(geom, i, j, +2*disp, +2*disp) + 16.0*calcDisplacedE<geomInBohrs>(geom, i, j, +disp, +disp)
					  + calcDisplacedE<geomInBohrs>(geom, i, j, +2*disp, -2*disp) - 16.0*calcDisplacedE<geomInBohrs>(geom, i, j, +disp, -disp)
					  + calcDisplacedE<geomInBohrs>(geom, i, j, -2*disp, +2*disp) - 16.0*calcDisplacedE<geomInBohrs>(geom, i, j, -disp, +disp)
					  - calcDisplacedE<geomInBohrs>(geom, i, j, -2*disp, -2*disp) + 16.0*calcDisplacedE<geomInBohrs>(geom, i, j, -disp, -disp)
				);
			}
			hess[j*geom.size() + i] = hess[i*geom.size() + j];
		}
	}
	//diagonal elements
	for (uint32_t i=0; i<geom.size(); i++){
		//std::cout<<""diag ""<<i<<"" value ""<<hess[i*geom.size() + i]<<std::endl;
		if constexpr (!extraAcc){
			hess[i*geom.size() + i] = inv_sqrh*( calcDisplacedE<geomInBohrs>(geom, i, disp) - twoEcenter + calcDisplacedE<geomInBohrs>(geom, i, -disp) );
		}else{
			hess[i*geom.size() + i] = inv_12sqrh*(
				- calcDisplacedE<geomInBohrs>(geom, i, 2*disp)
				+ 16.0*calcDisplacedE<geomInBohrs>(geom, i, disp)
				- thirtyEcenter
				+ 16.0*calcDisplacedE<geomInBohrs>(geom, i, -disp)
				- calcDisplacedE<geomInBohrs>(geom, i, -2*disp)
			);
		}
	}
}

template <auto NUM_COORDS>
double calcRMS(const std::array<double,NUM_COORDS>& arr){
	///Calculates the Root-Mean-Square of the elements in an array.
	double RMS = 0.0;
	for(uint32_t i=0; i<arr.size(); i++) RMS += arr[i] * arr[i];
	return std::sqrt(RMS/NUM_COORDS);
}

template <auto NUM_COORDS>
double calcMaxAbs(const std::array<double,NUM_COORDS>& arr){
	///Calculates the maximum absolute value of the elements in an array.
	double max = 0.0;
	for(uint32_t i=0; i<arr.size(); i++) if (std::abs(arr[i]) > max) max = std::abs(arr[i]);
	return max;
}

template <auto NUM_COORDS>
std::array<double,NUM_COORDS> arrayAdd(const std::array<double, NUM_COORDS>& input1, const std::array<double, NUM_COORDS>& input2){
	std::array<double, NUM_COORDS> tmp;
	for (uint32_t j=0; j<NUM_COORDS; j++) tmp[j] = input1[j]+input2[j];
	return tmp;
}

template <auto NUM_COORDS>
std::array<double,NUM_COORDS> arrayScale(const std::array<double, NUM_COORDS>& input, const double scalar){
	std::array<double, NUM_COORDS> tmp;
	for (uint32_t j=0; j<NUM_COORDS; j++) tmp[j] = input[j]*scalar;
	return tmp;
}

template <auto NUM_COORDS>
[[nodiscard]] bool diagMat(std::array<double,NUM_COORDS*NUM_COORDS>& mat, std::array<double,NUM_COORDS>& eigenvals){
	///Diagonalizes square and symmetric matrix using the DSYEV LAPACK subroutine, yielding eigenvalues and eigenvectors.
	///The input matrix is overwritten with the eigenvectors, if you need them make sure to mind the Fortran-style column-major indexing.
	///The caller must check the return value of this fn, as the diagonalizer can fail, yielding garbage results.
	const lapack_int N = eigenvals.size();
	eigenvals.fill(0.0);
	if (0 != LAPACKE_dsyev(LAPACK_COL_MAJOR,'V','U', N, mat.data(), N, eigenvals.data())){
		std::cout<<""Could not diagonalize matrix, DSYEV failed!""<<std::endl;
		return false;
	}
	return true; //eigenvals should now be filled with eigenvalues in ascending order
}

template <bool silent, auto NUM_COORDS>
[[nodiscard]] bool calcNewtonStep(std::array<double,NUM_COORDS*NUM_COORDS> hess, const std::array<double,NUM_COORDS>& grad_in, std::array<double,NUM_COORDS>& step, const double RCOND){
	///This function calculates the undamped Newton optimization step (i.e. displacement vector) from the gradient and Hessian via SVD.
	///Takes the Hessian by value as it will be overwritten with the SVD details.
	///Takes the gradient by const ref. and make a copy, the copy will be negated and then used in the SVD.
	///If the SVD succeeds, copy the resulting vector into step, otherwise step is not modified.
	///The caller must check the return value, to make sure the SVD did not fail.
	auto grad = grad_in;
	std::array<double,grad.size()> S;
	const lapack_int N = grad.size();
	lapack_int rank = 0;
	S.fill(0.0);
	for(auto& der : grad) der = -der; //turn grad into -grad
	//find a minimum norm solution to the system of linear eqs. H d = -g, where d is the optimization step
	//this uses SVD, as the Hessian should in theory be non-invertible (6 zero eigenvalues, corresponding to translations and rotations)
	//since the potential energy is invariant to those, the second derivative with respect to them is zero
	//in practice tiny eigenvalues creep in, so the matrix may have numerically fully rank
	//regardless, the SVD should be able to handle all cases
	//numerical experiments suggest RCOND should be set to around 1.0E-5 to 1.0E-3
	if (0 != LAPACKE_dgelss(LAPACK_COL_MAJOR, N, N, 1, hess.data(), N, grad.data(), N, S.data(), RCOND, &rank) ){
		std::cout<<""DGELSS failed!""<<std::endl;
		return false;
	}
	if constexpr (!silent) std::cout<<""Hessian rank: ""<<rank<<std::endl;
	step = grad;
	return true;
}

template <auto NUM_ATOMS>
void massWeightHess(const std::array<double, NUM_ATOMS>& masses, std::array<double,(NUM_ATOMS*3)*(NUM_ATOMS*3)>& hess){
	const auto NUM_COORDS = NUM_ATOMS*3;
	for (uint32_t i=0; i<NUM_COORDS; i++){
		for (uint32_t j=0; j<NUM_COORDS; j++){
			hess.at(i*NUM_COORDS + j) /= std::sqrt( emass_per_amu * masses.at(i/3) * emass_per_amu * masses.at(j/3) );
		}
	}
}

template <auto NUM_COORDS>
void calcFreq_core(const std::array<double, NUM_COORDS/3>& masses, std::array<double,NUM_COORDS*NUM_COORDS>& hessian, std::array<double, NUM_COORDS>& freqs){
	std::array<double,NUM_COORDS> eigenvals;
	massWeightHess(masses, hessian);
	assert(diagMat(hessian, eigenvals));
	for (uint32_t i=0; i<NUM_COORDS; i++){
		freqs.at(i) = std::sqrt(std::abs(eigenvals.at(i)))*invcm_per_hartree;
		if (eigenvals.at(i) < 0.0) freqs.at(i) *= -1;
	}
}

template <auto NUM_COORDS>
std::array<double,NUM_COORDS*NUM_COORDS> calcFreq(const xyzfile& geom_in, std::array<double, NUM_COORDS>& freqs, const double numderDisp){
	/// Eigenvectors are returned in Fortran-style column-major indexing!
	assert(geom_in.natoms == (NUM_COORDS/3));
	std::array<double,NUM_COORDS/3> masses;
	std::array<double,NUM_COORDS> geom;
	std::array<double,NUM_COORDS*NUM_COORDS> hessian;
	
	ExtractLinearizedCoords(geom_in, geom);
	// Convert atom coordinates to bohrs get the masses of the atoms.
	for (uint32_t j=0; j<NUM_COORDS; j++) geom.at(j) /= angs_per_bohr;
	for (uint32_t j=0; j<geom_in.natoms; j++) masses.at(j) = getAtomMass(geom_in.atomvec.at(j));
	// Calculate the Hessian, use the more accurate derivative formulas.
	calcHess<true, true>(geom, hessian, numderDisp/angs_per_bohr);
	// Calculate the frequencies and the eigenvectors of the mass-weighted Hessian.
	calcFreq_core(masses, hessian, freqs);
	return hessian;
}

template <auto NUM_COORDS>
void matmul(std::array<double,NUM_COORDS*NUM_COORDS> A, std::array<double,NUM_COORDS*NUM_COORDS> B,
  std::array<double,NUM_COORDS*NUM_COORDS>& C, const bool transposeA, const bool transposeB){
	enum CBLAS_TRANSPOSE  [MASK] ;
	enum CBLAS_TRANSPOSE TransB;
	if(transposeA){
		 [MASK]  = CblasTrans;
	}else{
		 [MASK]  = CblasNoTrans;
	}
	if(transposeB){
		TransB = CblasTrans;
	}else{
		TransB = CblasNoTrans;
	}
	const blasint N = NUM_COORDS;
	
	cblas_dgemm(CblasColMajor,  [MASK] , TransB, N, N, N, 1.0, A.data(), N, B.data(), N, 0.0, C.data(), N);
}

template <auto NUM_COORDS>
void matvecmul(std::array<double,NUM_COORDS*NUM_COORDS> A, std::array<double,NUM_COORDS> x,
  std::array<double,NUM_COORDS>& y){
	const blasint N = NUM_COORDS;
	const blasint inc = 1;
	cblas_dgemv(CblasColMajor, CblasNoTrans, N, N, 1.0, A.data(), N, x.data(), inc, 0.0, y.data(), inc);
}

template <auto NUM_ATOMS>
std::array<double,(NUM_ATOMS*3)*(NUM_ATOMS*3)> invertHessian(std::array<double,(NUM_ATOMS*3)*(NUM_ATOMS*3)> hess_in,
  const std::array<double,NUM_ATOMS>& masses, const uint32_t numImagKeep){
	/// Calculate a modified inverse of the Hessian via eigendecomposition.
	/// H^-1 = Q * L^-1 * Q^-1 , where Q is the matrix where the columns are eigenvectors and L is a digonal mtx,
	/// where the diagonal elements are the eigenvalues.
	/// Due to the near-singular nature of the Hessian in Cartesian coordinates, six of the eigenvalues should be
	/// close to zero. These are explicitly set to zero
	const auto NUM_COORDS = NUM_ATOMS*3;
	const double smallFreqThresh = 15.0; //in cm-1
	std::array<double,NUM_COORDS> eigenvals, freqs;
	std::array<double,NUM_COORDS*NUM_COORDS> diagInverse;
	// Calculate harmonic vibrational frequencies to be able to decide how many eigenvalues to null out when
	// constructing the Hessian inverse. We need a copy of the Hessian to keep the original intact.
	auto hess_mw = arrayScale(hess_in, (angs_per_bohr)*(angs_per_bohr));
	calcFreq_core(masses, hess_mw, freqs);
	uint32_t numSmallFreq = 0;
	for (uint32_t j=0; j<NUM_COORDS; j++){
		if(freqs.at(j) < smallFreqThresh) numSmallFreq++;
	}
	std::cout<<""Number of small eigenvalues: ""<<numSmallFreq<<std::endl;
	for (uint32_t j=0; j<numSmallFreq; j++) std::cout<<"" ""<<to_string_prec(freqs.at(j), 1);
	std::cout<<std::endl;
	// Diagonalize the original Hessian.
	assert(diagMat(hess_in, eigenvals));
	diagInverse.fill(0.0);
	// Construct L^-1 from the eigenvalues. Ordinarily the inverse of a diagonal mtx would be just the the reciprocal
	// of its diagonal elements. Here, with the exception of the the lowest numImagKeep eigenvaues, all small
	// eigenvalues are ""replaced by infinity"", to yield zero when inverted. This corresponds to a physical picture of
	// having infinitely strong springs restraining any pure translation and rotation, or other near-degenerate modes
	// to zero displacement in Newton steps.
	for (uint32_t j=0; j<numImagKeep; j++)	diagInverse.at(j*NUM_COORDS + j) = 1.0/eigenvals.at(j);
	for (uint32_t j=numImagKeep; j<NUM_COORDS; j++){
		if(std::abs(freqs.at(j)) > smallFreqThresh) diagInverse.at(j*NUM_COORDS + j) = 1.0/eigenvals.at(j);
	}
	std::cout<<""Inverted diagonal:"";
	for (uint32_t j=0; j<NUM_COORDS; j++) std::cout<<"" ""<<diagInverse.at(j*NUM_COORDS + j);
	std::cout<<std::endl;
	// Now that we have L^-1, do the matrix multiplications.
	matmul<NUM_COORDS>(diagInverse, hess_in, diagInverse, false, true); //L^-1 * Q^-1 = L^-1 * Q^T
	matmul<NUM_COORDS>(hess_in, diagInverse, diagInverse, false, false); //Q * (L^-1 * Q^-1) = H^-1
	return diagInverse;
}

template <auto NUM_COORDS>
void calcNewtonStep_inverse(const std::array<double,NUM_COORDS*NUM_COORDS>& hess, const std::array<double,NUM_COORDS>& grad,
  std::array<double,NUM_COORDS>& step, const std::array<double,NUM_COORDS/3>& masses, const uint32_t numImagKeep){
	// the pure undamped Newton step would be this vector: d = -(H^(-1) g)
	// (-1 times the inverse of the Hessian matrix times the gradient vector)
	auto invHess = invertHessian(hess, masses, numImagKeep);
	matvecmul(invHess, grad, step);
	for(auto& s : step) s = -s;
}

template <bool seekMinimum, auto NUM_COORDS>
double optimizeStepLen(const std::array<double,NUM_COORDS>& geom, const std::array<double,NUM_COORDS>& step, const double initStepFactor,
  const double rmsDisp_limit, const double maxDisp_limit, const double numderDisp){
	/// Optimize the length of an optimization step. The maximum step length is always enforced, and if a minimum is
	/// sought, the step length is crudely optimized to approximately minimize the energy after the step is taken.
	auto currStepFactor = initStepFactor;
	// Reduce step size until both RMS and max displacements are within limits.
	while ((calcRMS(arrayScale(step, currStepFactor)) > rmsDisp_limit) ||
	  (calcMaxAbs(arrayScale(step, currStepFactor)) > maxDisp_limit) ){
		currStepFactor *= 0.9;
	}
	if constexpr (seekMinimum){
		// If a smaller step yields a lower energy, keep reducing step length until it stops getting better.
		// If the step size becomes miniscule, return immediately.
		while (EvaluateEnergy_copy<false>(arrayAdd(geom, arrayScale(step, currStepFactor))) >
		EvaluateEnergy_copy<false>(arrayAdd(geom, arrayScale(step, 0.9*currStepFactor))) ){
			if (calcRMS(arrayScale(step, currStepFactor)) < 1E-12) return currStepFactor;
			currStepFactor *= 0.9;
		}
		// If a larger step yields a lower energy, keep increasing step length until it stops getting better, or
		// one of the step size limits would be exceeded by a larger step.
		while (EvaluateEnergy_copy<false>(arrayAdd(geom, arrayScale(step, currStepFactor))) >
		EvaluateEnergy_copy<false>(arrayAdd(geom, arrayScale(step, 1.1*currStepFactor))) ){
			if ( (calcRMS(arrayScale(step, 1.1*currStepFactor)) > rmsDisp_limit) ||
			(calcMaxAbs(arrayScale(step, 1.1*currStepFactor)) > maxDisp_limit) ){
				break;
			}else{
				currStepFactor *= 1.1;
			}
		}
	}else{
		// Trying to optimize Newton step length for minimum RMS grad when looking for a TS ruins convergence for 
		// some strange reason. Therefore it is commented out here.
		// while (calcRMS(calcGrad<true, false>((arrayAdd(geom, arrayScale(step, currStepFactor))),numderDisp)) > calcRMS(calcGrad<true, false>((arrayAdd(geom, arrayScale(step, 0.9*currStepFactor))),numderDisp))){
			// currStepFactor *= 0.9;
			// //std::cout<<""grad down!\n"";
		// }
		// while (calcRMS(calcGrad<true, false>((arrayAdd(geom, arrayScale(step, currStepFactor))),numderDisp)) > calcRMS(calcGrad<true, false>((arrayAdd(geom, arrayScale(step, 1.1*currStepFactor))),numderDisp))){
			// if ( (calcRMS(arrayScale(step, 1.1*currStepFactor)) > rmsDisp_limit) || (calcMaxAbs(arrayScale(step, 1.1*currStepFactor)) > maxDisp_limit) ) break;
			// currStepFactor *= 1.1;
			// //std::cout<<""grad up!\n"";
		// }
	}
	return currStepFactor;
}
",TransA
752,"/* Copyright 2015 CyberTech Labs Ltd.
 *
 * 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 <QtCore/QCoreApplication>
#include <QtCore/QCommandLineParser>
#include <QtCore/QFile>

#include <qrrepo/repoApi.h>
#include <qrutils/xmlUtils.h>

#include <QFileInfo>
#include <QDomElement>

const QString description = QObject::tr(""Patcher for save files, replaces world model ""
		""with contents of a given XML world model"");

int main(int argc, char *argv[])
{
	QCoreApplication app(argc, argv);
	QCoreApplication::setApplicationName(""Patcher"");
	QCoreApplication::setApplicationVersion(""2.0"");

	QCommandLineParser parser;
	parser.setApplicationDescription(description);
	parser.addHelpOption();
	parser.addVersionOption();
	parser.addPositionalArgument(""save-file"", QObject::tr(""TRIK Studio save file to be patched.""));

	QCommandLineOption patchWorld(""f"", QObject::tr(""XML file with prepared 2D model field. ""
							""Both world and robot configurations (position + ports) will be patched.""), ""field.xml"");
	parser.addOption(patchWorld);
	QCommandLineOption  [MASK] (""s"", QObject::tr(""Script file to be patched into save file.""), ""script.js"");
	parser.addOption( [MASK] );
	QCommandLineOption patchFieldWithoutRobot(""w"", QObject::tr(""XML file with prepared 2D model field. ""
										""Only world configurations will be patched.""), ""field.xml"");
	parser.addOption(patchFieldWithoutRobot);

	QCommandLineOption patchField(""wp"", QObject::tr(""XML file with prepared 2D model field. ""
										""Only world configurations and robot position will be patched.""), ""field.xml"");
	parser.addOption(patchField);

	QCommandLineOption putRobotOnStart(""rrp"", QObject::tr(""Reset robot position to start position""));
	parser.addOption(putRobotOnStart);

	parser.process(app);

	const QStringList positionalArgs = parser.positionalArguments();
	if (positionalArgs.size() != 1) {
		parser.showHelp();
	}

	const auto &saveFile = positionalArgs[0];
	qrRepo::RepoApi repo(saveFile);

	// Check that from three booleans (-f/-w/--wp options) at least two of them are not true at the same time
	if (parser.isSet(patchWorld) + parser.isSet(patchFieldWithoutRobot) + parser.isSet(patchField) > 1) {
		return 2;
	}

	if (parser.isSet(patchWorld) || parser.isSet(patchField) || parser.isSet(patchFieldWithoutRobot)) {
		bool wholeWorld = parser.isSet(patchWorld);
		bool withoutRobotPos = parser.isSet(patchFieldWithoutRobot);
		const auto &field = parser.value(wholeWorld ? patchWorld
				: withoutRobotPos ? patchFieldWithoutRobot : patchField);
		QFile fieldFile(field);
		if (!fieldFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
			return 1;
		}

		QDomDocument newWorld = utils::xmlUtils::loadDocumentWithConversion(fieldFile.fileName());

		const auto & blobs = newWorld.firstChildElement(""root"").firstChildElement(""blobs"");
		QDomDocument blobsDoc;
		QDomElement blobsRoot = blobsDoc.createElement(""root"");
		blobsRoot.appendChild(blobs);
		blobsDoc.appendChild(blobsRoot);
		repo.setMetaInformation(""blobs"", blobsDoc.toString(4));

		newWorld.firstChildElement(""root"").removeChild(blobs);
		if (!wholeWorld) {
			QDomDocument prevWorld;
			prevWorld.setContent(repo.metaInformation(""worldModel"").toString());

			newWorld.replaceChild(prevWorld.firstChildElement(""robots""),
						newWorld.firstChildElement(""robots""));

			if (withoutRobotPos) {
				newWorld.firstChildElement(""world"").replaceChild(
						prevWorld.firstChildElement(""world"").firstChildElement(""robot"")
						, newWorld.firstChildElement(""world"").firstChildElement(""robot""));
			}
		}

		repo.setMetaInformation(""worldModel"", newWorld.toString(4));
	}

	if (parser.isSet( [MASK] )) {
		const auto &script = parser.value( [MASK] );
		if (!script.isEmpty()) {
			QFile scriptFile(script);
			if (!scriptFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
				return 1;
			}

			/// Explicitly convert to QString
			const QString &scriptContent = scriptFile.readAll();
			repo.setMetaInformation(""activeCode"", scriptContent);

			repo.setMetaInformation(""activeCodeLanguageExtension"", QFileInfo(scriptFile).suffix().toLower());

			scriptFile.close();
		}
	}

	if (parser.isSet(putRobotOnStart)) {
		QDomDocument world;
		world.setContent(repo.metaInformation(""worldModel"").toString());
		auto robot = world.documentElement().firstChildElement(""robots"").firstChildElement(""robot"");
		auto start = robot.firstChildElement(""startPosition"");
		robot.setAttribute(""direction"", start.attribute(""direction""));
		auto x = start.attribute(""x"").toDouble() - 25;
		auto y = start.attribute(""y"").toDouble() - 25;
		robot.setAttribute(""position"", QString::number(x) + "":"" + QString::number(y));
		repo.setMetaInformation(""worldModel"", world.toString(4));
	}

	if (!repo.saveAll()) {
		return -1;
	}

	return 0;
}
",patchScript
753,"/**
* @file AssetManager.cpp
* @author <NAME>
* @brief Implements the AssetManager class.
* @version 1.0.0
*
* Dodoi Engine is a game engine developed by Dodoi-Lab.
* @copyright Copyright (c) 2024, Dodoi-Lab
*
* 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 ""../gfx/Gfx.h""
#include ""../sfx/Sfx.h""
#include ""AssetManager.h""
#include ""../io/FileUtils.h""

AssetManager::~AssetManager() {
    clearAssets();
}

AssetManager* AssetManager::getInstance() {
    if (instance == nullptr) {
        instance = new AssetManager();
    }

    return instance;
}

void AssetManager::addTexture(const std::string& name, const short value, const std::string& filePath) {
    SDL_Texture* texture = Gfx::getInstance()->loadTexture(filePath);

    std::pair pair = { value, texture };
    this->textures.emplace(name, pair);
}

void AssetManager::addSound(const std::string& name, const std::string& filePath) {
	Mix_Chunk* sound = Sfx::getInstance()->loadSound(filePath);
	this->sounds.emplace(name, sound);
}

SDL_Texture* AssetManager::getTexture(const std::string& name) {
    return textures[name].second;
}

Mix_Chunk* AssetManager::getSound(const std::string& name) {
	return sounds[name];
}

int AssetManager::textureCount() const {
    return (int)textures.size();
}

int AssetManager::soundCount() const {
    return (int)sounds.size();
}

void AssetManager::load() {

    auto imageFuture = std::async(std::launch::async, [&]() {
        auto  [MASK]  = FileUtils::listImageFilesInFolder();
        for (auto& file :  [MASK] ) {
            auto filePath = IMAGE_FOLDER + file;
            addTexture(FileUtils::getClearName(filePath), 0, filePath);
        }
    });
    
    auto audioFuture = std::async(std::launch::async, [&]() {
        auto sounds = FileUtils::listAudioFilesInFolder();
        for (auto& file : sounds) {
		    auto filePath = AUDIO_FOLDER + file;
	    	addSound(FileUtils::getClearName(filePath), filePath);
	    }
    });

	imageFuture.get();
	audioFuture.get();
}

void AssetManager::clearAssets() {
    for (auto& texture : textures) {
        SDL_DestroyTexture(texture.second.second);
    }
    this->textures.clear();

    for (auto& sound : sounds) {
        Mix_FreeChunk(sound.second);
    }
    this->sounds.clear();
}
",images
754,"#pragma once

#include ""frpch.h""

namespace Fresh {

	class Input {

	public:

		inline static bool IsKeyPressed(int keycode) { return s_Instance->IsKeyPressedImpl(keycode);  }
		inline static bool IsMouseButtonPressed(int  [MASK] ) { return s_Instance->IsMouseButtonPressedImpl( [MASK] ); }
		inline static float GetMouseX() { return s_Instance->GetMouseXImpl(); }
		inline static float GetMouseY() { return s_Instance->GetMouseYImpl(); }
		inline static std::pair<float, float> GetMousePos() { return s_Instance->GetMousePosImpl(); }

	protected:

		virtual bool IsKeyPressedImpl(int keycode) = 0;
		virtual bool IsMouseButtonPressedImpl(int keycode) = 0;
		virtual float GetMouseXImpl() = 0;
		virtual float GetMouseYImpl() = 0;
		virtual std::pair<float, float> GetMousePosImpl() = 0;

	private:
		static Input* s_Instance;
	};

}",button
755,"/*
 * Copyright 2019 <NAME> (<EMAIL>)
 *
 * 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 <algorithm>
#include <cstdio>
#include <cstring>
#include <errno.h>
#include <fcntl.h>
#include <linux/uinput.h>
#include <unistd.h>
#include <usbcan.h>

// A simple utility that reads CAN messages, parses them and emits uinput events
// from the steering wheel, throttle, brake and paddle shifters.
//
// This allows a car to be used as a joystick.

namespace {

// The IDs of the various inputs.
constexpr uint16_t kThrottleId = 0x01a1;
constexpr uint16_t kSteeringId = 0x01e5;
constexpr uint16_t kBrakeId = 0x00f1;
constexpr uint16_t kPaddleShifterId = 0x01f3;

// Limits for the brake, throttle and steering axes.
constexpr uint8_t kBrakeLimit = 0x4b;
constexpr uint8_t kThrottleLimit = 0xfe;
constexpr int16_t kSteeringLimit = 0x1d00;

/*
 * Handle a CAN message containing the throttle position.
 */
void HandleThrottlePos(const struct usbcan_msg* msg, int uinput_fd) {
  if (msg->frame.can_dlc == 7) {
    uint8_t value = msg->frame.data[6];

    struct input_event throttle_event = {};
    throttle_event.type = EV_ABS;
    throttle_event.code = ABS_GAS;
    throttle_event.value = value;

    if (write(uinput_fd, &throttle_event, sizeof(throttle_event)) < 0) {
      fprintf(stderr, ""Failed to write throttle event: %d (%s)\n"",
          errno, strerror(errno));
      exit(-1);
    }
  } else {
    fprintf(stderr, ""Malformed accelerator position\n"");
  }
}

/*
 * Handle a CAN message containing the brake position.
 */
void HandleBrakePos(const struct usbcan_msg* msg, int uinput_fd) {
  if (msg->frame.can_dlc == 6) {
    uint8_t value = msg->frame.data[1];

    struct input_event brake_event = {};
    brake_event.type = EV_ABS;
    brake_event.code = ABS_BRAKE;
    brake_event.value = value;

    if (write(uinput_fd, &brake_event, sizeof(brake_event)) < 0) {
      fprintf(stderr, ""Failed to write brake event: %d (%s)\n"",
          errno, strerror(errno));
      exit(-1);
    }
  } else {
    fprintf(stderr, ""Malformed brake position\n"");
  }
}

/*
 * Handle a CAN message containing the steering position.
 */
void HandleSteeringPos(const struct usbcan_msg* msg, int uinput_fd) {
  if (msg->frame.can_dlc == 8) {
    int16_t value = (static_cast<uint16_t>(msg->frame.data[1]) << 8)
        | msg->frame.data[2];
    struct input_event wheel_event = {};
    wheel_event.type = EV_ABS;
    wheel_event.code = ABS_WHEEL;
    wheel_event.value = -value;

    if (write(uinput_fd, &wheel_event, sizeof(wheel_event)) < 0) {
      fprintf(stderr, ""Failed to write wheel event: %d (%s)\n"",
          errno, strerror(errno));
      exit(-1);
    }
  } else {
    fprintf(stderr, ""Malformed steering position\n"");
  }
}

/*
 * Handle a CAN message containing the paddle shifter state.
 */
void HandlePaddleShifter(const struct usbcan_msg* msg, int uinput_fd) {
  if (msg->frame.can_dlc == 3) {
    bool up_pressed = msg->frame.data[1] & 0x01;
    bool down_pressed = msg->frame.data[1] & 0x02;

    struct input_event gear_event = {};
    gear_event.type = EV_KEY;
    gear_event.code = BTN_GEAR_UP;
    gear_event.value = up_pressed;

    if (write(uinput_fd, &gear_event, sizeof(gear_event)) < 0) {
      fprintf(stderr, ""Failed to write gear up event: %d (%s)\n"",
          errno, strerror(errno));
      exit(-1);
    }

    gear_event.code = BTN_GEAR_DOWN;
    gear_event.value = down_pressed;

    if (write(uinput_fd, &gear_event, sizeof(gear_event)) < 0) {
      fprintf(stderr, ""Failed to write gear down event: %d (%s)\n"",
          errno, strerror(errno));
      exit(-1);
    }
  } else {
    fprintf(stderr, ""Malformed steering position\n"");
  }

}

/*
 * Handle a CAN message and emit a uinput event if a match was found.
 *
 * Returns true if the message was handled.
 */
bool HandleCanMessage(const struct usbcan_msg *msg, int uinput_fd) {
  bool handled = true;
  switch (msg->frame.can_id) {
    case kThrottleId:
      HandleThrottlePos(msg, uinput_fd);
      break;
    case kBrakeId:
      HandleBrakePos(msg, uinput_fd);
      break;
    case kSteeringId:
      HandleSteeringPos(msg, uinput_fd);
      break;
    case kPaddleShifterId:
      HandlePaddleShifter(msg, uinput_fd);
      break;
    default:
      handled = false;
      break;
  }

  return handled;
}

/*
 * Invoked by libcanusb when a group of CAN packets are ready.
 */
void CanPacketCallback(uint32_t device_id, uint32_t bus_id,
                       struct usbcan_msg *msgs, uint32_t num_msgs,
                       void *arg) {
  int uinput_fd = *reinterpret_cast<int*>(arg);

  bool handled = false;
  for (uint32_t i = 0; i < num_msgs; i++) {
    handled |= HandleCanMessage(&msgs[i], uinput_fd);
  }

  if (handled) {
    // If the message was handled, emit a SYN event to uinput.
    struct input_event sync_event = {};
    sync_event.type = EV_SYN;
    sync_event.code = SYN_REPORT;
    sync_event.value = 0;

    if (write(uinput_fd, &sync_event, sizeof(sync_event)) < 0) {
      fprintf(stderr, ""Failed to write sync event: %d (%s)\n"",
          errno, strerror(errno));
    }
  }
}

// Initialize the uinput device for the joystick.
bool InitUinputDevice(int uinput_fd) {
  if (ioctl(uinput_fd, UI_SET_EVBIT, EV_ABS) < 0) {
    fprintf(stderr, ""Failed to set abs attribute: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  if (ioctl(uinput_fd, UI_SET_ABSBIT, ABS_WHEEL) < 0) {
    fprintf(stderr, ""Failed to set wheel attribute: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  if (ioctl(uinput_fd, UI_SET_ABSBIT, ABS_GAS) < 0) {
    fprintf(stderr, ""Failed to set gas attribute: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  if (ioctl(uinput_fd, UI_SET_ABSBIT, ABS_BRAKE) < 0) {
    fprintf(stderr, ""Failed to set brake attribute: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  if (ioctl(uinput_fd, UI_SET_EVBIT, EV_KEY) < 0) {
    fprintf(stderr, ""Failed to set key attribute: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  if (ioctl(uinput_fd, UI_SET_KEYBIT, BTN_GEAR_UP) < 0) {
    fprintf(stderr, ""Failed to set gear up attribute: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  if (ioctl(uinput_fd, UI_SET_KEYBIT, BTN_GEAR_DOWN) < 0) {
    fprintf(stderr, ""Failed to set gear down attribute: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  struct uinput_user_dev uidev = {};
  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, ""Cadillac ELR"");

  uidev.id.bustype = BUS_VIRTUAL;
  uidev.id.vendor = 1;
  uidev.id.product = 1;
  uidev.id.version = 1;

  uidev.absmax[ABS_WHEEL] = kSteeringLimit;
  uidev.absmin[ABS_WHEEL] = -kSteeringLimit;
  uidev.absfuzz[ABS_WHEEL] = 0;
  uidev.absflat[ABS_WHEEL] = 0;

  uidev.absmax[ABS_GAS] = kThrottleLimit;
  uidev.absmin[ABS_GAS] = 0;
  uidev.absfuzz[ABS_GAS] = 0;
  uidev.absflat[ABS_GAS] = 0;

  uidev.absmax[ABS_BRAKE] = kBrakeLimit;
  uidev.absmin[ABS_BRAKE] = 0;
  uidev.absfuzz[ABS_BRAKE] = 0;
  uidev.absflat[ABS_BRAKE] = 0;

  if (write(uinput_fd, &uidev, sizeof(uidev)) < 0) {
    fprintf(stderr, ""Failed to write uinput descriptor: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  if (ioctl(uinput_fd, UI_DEV_CREATE) < 0) {
    fprintf(stderr, ""Failed to create uinput device: %d (%s)\n"",
        errno, strerror(errno));
    return false;
  }

  return true;
}

}  // namespace

int main(int argc, char** argv) {
  fprintf(stderr, ""can-joystick\n"");

  int uinput_fd = open(""/dev/uinput"", O_WRONLY | O_NONBLOCK);
  if (uinput_fd < 0) {
    fprintf(stderr, ""Failed to open uinput: %d (%s)\n"", errno, strerror(errno));
    return -1;
  }

  if (!InitUinputDevice(uinput_fd)) {
    return -1;
  }

  bool  [MASK]  = usbcan_library_init();
  if (! [MASK] ) {
    fprintf(stderr, ""Failed to init usbcan\n"");
    return -1;
  }

  struct usbcan_bus_config config = {
    .speed = CAN_SPEED_500KBPS,
    .filters = nullptr,
    .num_filters = 0,
    .cb = CanPacketCallback,
    .arg = &uinput_fd,
  };

   [MASK]  = usbcan_init(/*device_id=*/ 0, /*bus_id=*/ 0, &config);
  if (! [MASK] ) {
    fprintf(stderr, ""Failed to init listener on bus 0\n"");
    return -1;
  }

   [MASK]  = usbcan_start(/*device_id=*/ 0, /*bus_id=*/ 0);
  if (! [MASK] ) {
    fprintf(stderr, ""Failed to start listening on bus 0\n"");
    return -1;
  }

  pause();
  usbcan_library_close();
  return 0;
}
",success
756,"#include ""Array.h""

void Array::expand(int count)
{
	int* newdata = new int[count + this->capacity];
	for (int i = 0; i < this->capacity; ++i)
	{
		newdata[i] = this->data[i];
	}
	delete[] this->data;
	this->data = newdata;
	this->capacity += count;
}
Array::Array(int capacity)
{
	this->capacity = capacity;
	this->count = 0;
	this->data = new int[capacity];
}
Array::Array(const Array& arr)
{
	this->capacity = arr.capacity;
	this->count = arr.count;
	this->data = new int[arr.count];
	for (int i = 0; i < arr.count; ++i)
	{
		this->data[i] = arr.data[i];
	}
}
Array::~Array()
{
	this->count = 0;
	this->capacity = 0;
	delete[] this->data;
}

int Array::get(int position)
{
	if (position >= count)
	{
		return this->data[count-1];
	}
	else
	{
		return this->data[position];
	}
}
void Array::set(int position, int  [MASK] )
{
	if (position > (count-1))
	{
		expand();
		this->data[count] =  [MASK] ;
		++this->count;
	}
	else
	{
		this->data[position] =  [MASK] ;
		++this->count;
	}
}



Array Array::operator=(const Array& arr)
{
	this->count = arr.count;
	this->capacity = arr.capacity;
	delete[] data;
	data = new int[capacity];
		for (int i = 0; i < this->count; ++i)
		{
			data[i] = arr.data[i];
		}
	return *this;
}",element
757,"//
// Created by saber on 2022/5/5.
//

#ifndef HZUTILS_STRINGUTIL_HPP
#define HZUTILS_STRINGUTIL_HPP

#include <objbase.h>
#include ""iostream""
#include <codecvt>
#include <string>
#include <regex>

using namespace std;

namespace hzStringUtil {
    static std::wstring To_Wide_String(const std::string& input)
    {
        std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
        return converter.from_bytes(input);
    }

    static std::string To_Byte_String(const std::wstring& input)
    {
        std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
        return converter.to_bytes(input);
    }

    static std::vector<std::wstring> WSplit(const std::wstring& in, const std::wstring& delim)
    {
         wregex re{ delim };
            return vector<wstring>{
                    wsregex_token_iterator(in.begin(), in.end(), re, -1),
                    wsregex_token_iterator()
            };
    }

    static std::vector<std::string> Split(const std::string& in, const std::string& delim)
    {
        regex re{ delim };
            return vector<string>{
                    sregex_token_iterator(in.begin(), in.end(), re, -1),
                    sregex_token_iterator()
            };
    }

    static std::string GuidToString(const GUID& guid)
    {
        char buf[64] = { 0 };
        sprintf_s(buf, sizeof(buf),
                  ""%08lX%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X"",
                  guid.Data1, guid.Data2, guid.Data3,
                  guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
                  guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
        return buf;
    }

    static bool endWith(const string& s, const string& endStr){
        size_t sLen = s.size();
        size_t endStrLen = endStr.size();
        if (sLen < endStrLen || sLen == 0 || endStrLen == 0)
        {
            return false;
        }

        return s.compare(s.size() - endStr.size(), endStr.size(), endStr) == 0;
    }

    static bool startWith(const string& s, const string& startStr){
        size_t sLen = s.size();
        size_t  [MASK]  = startStr.size();
        if (sLen <  [MASK]  || sLen == 0 ||  [MASK]  == 0)
        {
            return false;
        }

        return s.compare(0, startStr.size(), startStr) == 0;
    }

    static std::string replace(const std::string& str, const std::string& from, const std::string& to) {
        std::string result = str;
        size_t start_pos = 0;
        while((start_pos = result.find(from, start_pos)) != std::string::npos) {
            result.replace(start_pos, from.length(), to);
            start_pos += to.length();
        }
        return result;
    }

    template<typename T>
    static string join(vector<T> src, char c){
        string res;
        if(src.empty()) return res;

        auto it = src.begin();
        T v = *it;
        res += to_string(v);

        for(it++;it!=src.end();it++){
            res += c;
            v = *it;
            res += to_string(v);
        }
        return res;
    }

    static string join(vector<string> src, char c){
        string res;
        if(src.empty()) return res;

        auto it = src.begin();
        res += *it;

        for(it++;it!=src.end();it++){
            res += c;
            res += *it;
        }
        return res;
    }

    template<typename T>
    static string join(set<T> src, char c){
        string res;
        if(src.empty()) return res;

        auto it = src.begin();
        T v = *it;
        res += to_string(v);

        for(it++;it!=src.end();it++){
            res += c;
            v = *it;
            res += to_string(v);
        }
        return res;
    }

    static string join(set<string> src, char c){
        string res;
        if(src.empty()) return res;

        auto it = src.begin();
        res += *it;

        for(it++;it!=src.end();it++){
            res += c;
            res += *it;
        }
        return res;
    }

} // hz

#endif //HZUTILS_STRINGUTIL_HPP
",startStrLen
758,"/*
 EW202 Lab 5.3
 Proportional control of EW202 elevator
 <NAME>, 2019
 */

#include ""mbed.h""
#include ""rtos.h""
#include ""Motor.h""

// some defines
#define DT 20         // loop timing in ms
#define CAL_A 49.2    // inches = Ax^2+Bx+C
#define CAL_B -6.001  // calibration for instructor station
#define CAL_C 0.218
#define PROP_KP 0.1   // proportional control gain K_P

// hardware objects
Serial pc(USBTX,USBRX);
AnalogIn sensor(p20);
Motor motor(p26,p30,p29); 
DigitalOut heartbeat(LED1);

// function prototypes
float calibration(float);
float prop_control(float);





int main(void){
  int n_samples, i;
  float ref,  [MASK] , e, u;
  
  while(1){
    pc.scanf(""%d,%f"",&n_samples,&ref);

    for (i=0; i<n_samples; i++){
       [MASK]  = calibration(sensor.read());
      e = ref- [MASK] ;
      u = prop_control(e);
      motor.speed(u);

      heartbeat = !heartbeat;
      pc.printf(""%d,%f,%f\n"",i, [MASK] ,u);
      ThisThread::sleep_for(DT); 
    } // for n_samples
  } // while(1)
} // main()





/** @brief Applies calibration for GPD212 sensor
    The calibration is inches = Ay^2+By+C
    
    @param y is a float AnalogIn 0.0-1.0 
    @return height in inches as a float
*/
float calibration(float y){
  return CAL_A*y*y+CAL_B*y+CAL_C; 
}





/** @brief Implements proportional control

    @param e is the error, ref-meas in inches, float
    @return motor pwm value, a float from 0.0-1.0
*/
float prop_control(float e){
  return PROP_KP*e; 
}
",ymeas
759,"/*
 * Copyright 2018 <NAME>
 *
 * 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 <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <vector>

#include <rafi/trace.h>

#include ""CommandLineOption.h""
#include ""CycleFilter.h""

namespace rafi { namespace dump {

XLEN GetXLEN(const std::string& path)
{
    if (path.find(""rv32"") != path.npos)
    {
        return XLEN::XLEN32;
    }
    else if (path.find(""rv64"") != path.npos)
    {
        return XLEN::XLEN64;
    }
    else
    {
        std::cout << ""Failed to determine XLEN from path."" << std::endl;
        std::exit(1);
    }
}

void PrintTrace(const CommandLineOption& option, IFilter* filter)
{
    auto reader = rafi::trace::MakeTraceReader(option.GetPath());
    auto printer = rafi::trace::MakeTracePrinter(option.GetPrinterType(), GetXLEN(option.GetPath()));

    const int  [MASK]  = option.GetCycleBegin();
    const int end = std::min(option.GetCycleBegin() + option.GetCycleCount(), option.GetCycleEnd());

    if ( [MASK]  > 0)
    {
        reader->Next(static_cast<uint32_t>( [MASK] ));
    }

    for (int i =  [MASK] ; i < end; i++)
    {
        if (reader->IsEnd())
        {
            return;
        }

        if (i >=  [MASK]  && filter->Apply(reader->GetCycle()))
        {
            printer->Print(reader->GetCycle());
        }

        reader->Next();
    }
}

}}

int main(int argc, char** argv)
{
    rafi::dump::CommandLineOption option(argc, argv);

    try
    {
        auto filter = rafi::dump::MakeFilter(option.GetFilterDescription());

        PrintTrace(option, filter.get());
    }
    catch (rafi::trace::TraceException e)
    {
        e.PrintMessage();
        std::exit(1);
    }
    catch (rafi::FileOpenFailureException e)
    {
        e.PrintMessage();
        std::exit(1);
    }

    return 0;
}
",begin
760,"//=================================================
// Insert An Element At Starting Of The Linked List
//=================================================
void insert(Node* &head,int value){
    Node* newnode= new Node();
    newnode->prev=nullptr;
    newnode->data=value;
    newnode->next=head;
    head=newnode;
}

//===============================================
// Insert An Element At Middle Of The Linked List
//===============================================
void insert(Node* &head,int value,int  [MASK] ){
    Node* newnode= new Node();
    if ( [MASK] ==1){
        newnode->prev=nullptr;
        newnode->data=value;
        newnode->next=head;
        head=newnode;
        return;
    }
    Node* temp=head;
    for(int i=0;i< [MASK] -2;i++){
        temp=temp->next;
    }
    newnode->next=temp->next;
    temp->next=newnode;
    newnode->prev=temp;
    newnode->data=value;
}


//==============================================
// Insert An Element At end Of The Linked List
//==============================================
void insert(Node* &head,int value){
    Node* newnode= new Node();
    Node* temp=head;
    while(temp->next!=nullptr){
        temp=temp->next;
    }
    temp->next=newnode;
    newnode->prev=temp;
    newnode->data=value;
    newnode->next=nullptr;
}",loc
761,"#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/time.h>

#define RED ""\033[31m""
#define GREEN ""\033[32m""
#define YELLOW ""\033[33m""
#define BLUE ""\033[34m""
#define MAGENTA ""\033[35m""
#define CYAN ""\033[36m""
#define DEFAULT_COLOR ""\033[00m""

#define ERROR ""\n[Error]: ""
#define WARNING ""\n[Warning]: ""
#define SUCCESS ""\n[Successfully]: ""

#define PING_DATA_SIZE 64
#define TIMESTAMP_MODE CLOCK_REALTIME_COARSE
//#define MAX_WAIT_TIME 5
//#define MAX_NO_PACKETS 3

struct package {
    struct icmp header;
    char data[PING_DATA_SIZE];   
};

struct package_ip {
    struct ip ip_header;
    package ping_pkg;
};

long timestamp() {
    struct timespec time;
    clock_gettime(TIMESTAMP_MODE, &time);
    long time_ms = time.tv_sec * 1000 + (time.tv_nsec / 1.0e6);
    return time_ms;
}

unsigned short calculate_checksum(unsigned short *buf, int len) {
    unsigned int sum = 0;
    unsigned short answer;

    while (len > 1) {
        sum += *buf++;
        len -= 2;
    }

    if (len == 1) {
        sum += static_cast<unsigned char>(*buf);
    }

    sum = (sum >> 16) + (sum & 0xFFFF);
    sum += (sum >> 16);
    answer = ~sum;

    return answer;
}

static void prepare_icmp_pkg(package *ping_pkg) {
    unsigned int  [MASK]  = sizeof(package);
    memset(ping_pkg, 0,  [MASK] );
    srand(time(NULL));
    const short random_id = rand();
    ping_pkg -> header.icmp_hun.ih_idseq.icd_id = random_id; 
    ping_pkg -> header.icmp_type = ICMP_ECHO;                
    ping_pkg -> header.icmp_hun.ih_idseq.icd_seq = 0;        
    ping_pkg -> header.icmp_cksum = calculate_checksum(reinterpret_cast<unsigned short*>(ping_pkg),  [MASK] );
}

int ping(const char* ip, const unsigned long timeout, unsigned long* time) {
    if (ip == NULL || timeout == 0) {
        std::cout << RED << ERROR << DEFAULT_COLOR 
            << ""Uncorrect IP: "" << ip << "" or null timeout!"" << std::endl;
        return -1;
    }

    package ping_pkg;
    prepare_icmp_pkg(&ping_pkg);
    const short reply_id = ping_pkg.header.icmp_hun.ih_idseq.icd_id;

    struct sockaddr_in to_addr;
    to_addr.sin_family = AF_INET;
    if (!inet_aton(ip, (struct in_addr*)&to_addr.sin_addr.s_addr)) {
        std::cout << RED << ERROR << DEFAULT_COLOR 
            << ""Inet_Aton error!"" << std::endl;
        return -1;
    }

    if (!strcmp(ip, ""255.255.255.255"") || to_addr.sin_addr.s_addr == 0xFFFFFFFF) {
        std::cout << RED << ERROR << DEFAULT_COLOR 
            << ""The IP address is broadcast!"" << std::endl;        
        return -1;
    }

    const int sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    if (sock < 0) {
        std::cout << RED << ERROR << DEFAULT_COLOR
            << ""Establishing socket error!"" << std::endl;
        return -1;
    }

    const unsigned long start_time = timestamp();
    const socklen_t socklen = sizeof(struct sockaddr_in);
    if (sendto(sock, &ping_pkg, sizeof(ping_pkg), 0, (struct sockaddr*)&to_addr, socklen) <= 0) {
        close(sock);
        std::cout << RED << ERROR << DEFAULT_COLOR
            << ""Error sending packet!"" << std::endl;
        return -1;
    }

    int result = -1;
    struct timeval tv;
    tv.tv_sec = timeout / 1000;
    tv.tv_usec = (timeout % 1000) * 1000;

    while(true) {
        fd_set rfd;
        FD_ZERO(&rfd);
        FD_SET(sock, &rfd);

        int n = select(sock + 1, &rfd, 0, 0, &tv);
        if (n == 0) {
            result = 1;
            break;
        }
        if (n < 0) {
            break;
        }
        const unsigned long elapsed_time = (timestamp() - start_time);
        if (elapsed_time > timeout) {
            result = 1;
            break;
        } else {
            const int new_timeout = timeout - elapsed_time;
            tv.tv_sec = new_timeout / 1000;
            tv.tv_usec = (new_timeout % 1000) * 1000;
        }

        if (FD_ISSET(sock, &rfd)) {
            package_ip ip_pkg;
            struct sockaddr_in from_addr;
            socklen_t socklen = sizeof(struct sockaddr_in);
            if (recvfrom(sock, &ip_pkg, sizeof(package), 0, (struct sockaddr*)&from_addr, &socklen) <= 0) {
                break;
            }
            if (to_addr.sin_addr.s_addr == from_addr.sin_addr.s_addr
                    && reply_id == ip_pkg.ping_pkg.header.icmp_hun.ih_idseq.icd_id) {
                if (time != NULL) {
                    *time = elapsed_time;
                }
                result = 0;
                break;
            }
        }
    }
    close(sock);
    return result;
}

int main(int argc, char** argv) {
	if(argc < 3) {
	    std::cout << RED << ERROR << DEFAULT_COLOR
            << ""Please use the following syntax: "" << BLUE << ""./ping "" << GREEN 
            << ""<host> "" << MAGENTA << ""<timeout>"" << std::endl;
		return -1;
	}

	const unsigned long timeout = atoi(argv[2]);
	const char* const host = argv[1];
	unsigned long time = 0;

    while(true) {
        const int result = ping(host, timeout, &time);

        if (result == -1) {
            std::cout << RED << ERROR << DEFAULT_COLOR
                << ""Host is not available!"" << std::endl;
            return -1;
        } else if (result == 1) {
            std::cout << YELLOW << WARNING << DEFAULT_COLOR
                << ""Timeout!"" << std::endl;
        } else {
            std::cout << GREEN << SUCCESS << DEFAULT_COLOR
                << ""Ping host = "" << host << "", Timeout = "" << timeout << ""."" << std::endl
                << ""Time = "" << time << ""."" << std::endl;
        }
        sleep(1);
    }
    return 0;
}
",packet_size
762,"//==============================================================================
//
//  @@-COPYRIGHT-START-@@
//
//  Copyright (c) 2016-2017, Qualcomm Innovation Center, Inc. All rights reserved.
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//  1. Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//  2. Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//  3. Neither the name of the copyright holder nor the names of its contributors
//     may be used to endorse or promote products derived from this software
//     without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
//  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//  POSSIBILITY OF SUCH DAMAGE.
//
//  SPDX-License-Identifier: BSD-3-Clause
//
//  @@-COPYRIGHT-END-@@
//
//==============================================================================

#include <cmath>
#include <iomanip>
#include <memory>
#include <vector>

#ifdef USE_OPENCV

#include <opencv2/core/core.hpp>

#endif   // USE_OPENCV

#include ""DlCompression/ISVD.hpp""
#include ""gtest/gtest.h""

using namespace DlCompression;

enum INIT_METHOD
{
    INIT_RANDOM,     // randomly initialize data
    INIT_IDENTITY,   // initialize to an identity matrix
    INIT_FIXED       // initialize with fixed content
};

template <typename TypeParam>
class DlCompressionSVDTest : public ::testing::Test
{
protected:
    void CreateLayer(COMPRESS_LAYER_TYPE layerType, SVD_COMPRESS_TYPE mode, INIT_METHOD init_method,
                     std::vector<int>& shape, bool use_bias)
    {
        m_layerAttrib.layerType = layerType;
        m_layerAttrib.mode      = mode;
        m_layerAttrib.shape     = shape;
        std::vector<TypeParam> weights;
        std::vector<TypeParam> bias;
        std::vector<TypeParam> average_input;
        int M = 0, N = 0, k_h = 1, k_w = 1;
        N                                   = m_layerAttrib.shape[0];
        M                                   = m_layerAttrib.shape[1];
        m_layerAttrib.activation_dims.first = m_layerAttrib.activation_dims.second = 1;

        if (LAYER_TYPE_CONV == layerType)
        {
            ASSERT_EQ(m_layerAttrib.shape.size(), 4);
            k_h                                  = m_layerAttrib.shape[2];
            k_w                                  = m_layerAttrib.shape[3];
            m_layerAttrib.activation_dims.first  = m_layerAttrib.shape[2];   // top height
            m_layerAttrib.activation_dims.second = m_layerAttrib.shape[3];   // top width
        }

#ifdef USE_OPENCV
        int sz = N * M * k_h * k_w;   // Layer size
        cv::Mat A;
        // Fill layer weights
        switch (init_method)
        {
        case INIT_IDENTITY:
            ASSERT_EQ(M, N);
            A = cv::Mat::eye(M, M, CV_32F);
            break;
        case INIT_FIXED:
            A = cv::Mat::ones(1, sz, CV_32F) * 0.64;
            break;
        case INIT_RANDOM:
        default:
            A = cv::Mat(1, sz, CV_32F);
            cv::randu(A, cv::Scalar(-1), cv::Scalar(1));
            break;
        }
        weights.assign((TypeParam*) A.datastart, (TypeParam*) A.dataend);

        if (use_bias)
        {
            // Fill layer bias.
            // Always use random bias.
            cv::Mat B(N, 1, CV_32F);
            cv::randu(B, cv::Scalar(-1), cv::Scalar(1));
            bias.assign((TypeParam*) B.datastart, (TypeParam*) B.dataend);

            // Fill average inputs.
            cv::Mat C(M, 1, CV_32F);
            cv::randu(C, cv::Scalar(-1), cv::Scalar(1));
            average_input.assign((TypeParam*) C.datastart, (TypeParam*) C.dataend);
        }
#else
        // Silence compiler warnings
        (void) init_method;
#endif
        m_layerAttrib.blobs.push_back(weights);
        if (use_bias)
        {
            m_layerAttrib.blobs.push_back(bias);
            m_layerAttrib.inputChannelMean = average_input;
        }
    }

#ifdef USE_OPENCV

    // Check whether a matrix is identity matrix [I]
    bool IsIdentityMatrix(cv::Mat& Mat, int rows, int cols)
    {
        EXPECT_EQ(rows, cols);
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                if ((i == j) && Mat.at<TypeParam>(i, j) != 1.0)
                {
                    return false;
                }

                else if ((i != j) && Mat.at<TypeParam>(i, j) != 0)
                {
                    return false;
                }
            }
        }
        return true;
    }

#endif

    // Container for layer attributes
    LayerAttributes<TypeParam> m_layerAttrib;
};

TYPED_TEST_CASE(DlCompressionSVDTest, ::testing::Types<float>);

/* Sanity Test: Test SVD compression with invalid rank
 *  The rank r of a matrix M (m,n) is bound by
 *  r <= min (m, n).
 *  The compression library should not allow compression
 *  when a rank outside this range is supplied.
 */
TYPED_TEST(DlCompressionSVDTest, SANITY_TestInvalidRankInput)
{
#ifdef USE_OPENCV
    std::string layerName = ""ip1"";
    std::vector<int> shape;
    int M = 20;   // rows of FC layer
    int N = 40;   // cols of FC layer
    shape.push_back(M);
    shape.push_back(N);

    // Create rank vector
    std::vector<unsigned int> ranks;
    unsigned int r = 60;
    ranks.push_back(r);
    // Create weights vector
    std::vector<float*> splitWeights;
    std::vector<unsigned int> weightSizes;

    this->CreateLayer(LAYER_TYPE_FC, TYPE_SINGLE, INIT_RANDOM, shape, false);
    // Create an instance of the SVD object
    ISVD<float>* svdObj = GetSVDInstance<float>();
    svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);

    unsigned int weight1_size = M * r;
    std::unique_ptr<float> weights1(new float[weight1_size]);
    splitWeights.push_back(weights1.get());
    weightSizes.push_back(weight1_size);

    unsigned int weight2_size = r * N;
    std::unique_ptr<float> weights2(new float[weight2_size]);
    splitWeights.push_back(weights2.get());
    weightSizes.push_back(weight2_size);

    // Compress layer matrix with invalid rank
    EXPECT_THROW({ svdObj->SplitLayerWeights(layerName, splitWeights, weightSizes, ranks); }, std::runtime_error);
#endif
}

/* Sanity Test: Test Identity Matrix SVD
 *  Test if SVD compression of an identity matrix [I]
 *  results in sub-matrices with of the form [I|0]
 *  where the non-zero portions of the matrices is
 *  also an identity matrix.
 */
TYPED_TEST(DlCompressionSVDTest, SANITY_TestIdentityMatrixSVD)
{
#ifdef USE_OPENCV
    std::string layerName = ""ip1"";
    std::vector<int> shape;
    int M = 40;   // rows of FC layer
    int N = 40;   // cols of FC layer
    shape.push_back(M);
    shape.push_back(N);

    // Create rank vector
    std::vector<unsigned int> ranks;
    unsigned int r = 30;
    ranks.push_back(r);
    // Create weights vector
    std::vector<float*> splitWeights;
    std::vector<unsigned int> weightSizes;

    this->CreateLayer(LAYER_TYPE_FC, TYPE_SINGLE, INIT_IDENTITY, shape, false);
    // Create an instance of the SVD object
    ISVD<float>* svdObj = GetSVDInstance<float>();
    svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);

    unsigned int weight1_size = M * r;
    std::unique_ptr<float> weights1(new float[weight1_size]);
    splitWeights.push_back(weights1.get());
    weightSizes.push_back(weight1_size);

    unsigned int weight2_size = r * N;
    std::unique_ptr<float> weights2(new float[weight2_size]);
    splitWeights.push_back(weights2.get());
    weightSizes.push_back(weight2_size);

    // Compress layer matrix
    svdObj->SplitLayerWeights(layerName, splitWeights, weightSizes, ranks);
    // Split weights are in transposed form.
    // Store them in proper form in intermediate matrices.
    cv::Mat WeightMat_0(r, M, CV_32F, (float*) (splitWeights[0]));
    cv::Mat WeightMat_1(N, r, CV_32F, (float*) (splitWeights[1]));
    // Expect that these matrices are of the form
    // [I|0] with rank 'r'.
    WeightMat_0 = WeightMat_0(cv::Range(0, r), cv::Range(0, r));
    WeightMat_1 = WeightMat_1(cv::Range(0, r), cv::Range(0, r));
    ASSERT_TRUE(this->IsIdentityMatrix(WeightMat_0, r, r));
    ASSERT_TRUE(this->IsIdentityMatrix(WeightMat_1, r, r));
#endif
}

/* Sanity Tests: Test Matrix reconstruction
 *  Test if a matrix reconstructed from its components obtained
 *  from an SVD operation with low-rank compression is ""close""
 *  to the original in the Frobenius norm sense.
 *  The proximity of the reconstructed matrix to the original depends
 *  on the relation between the rank of the original matrix and that used
 *  to compress it. A rank value that is closer to the original rank leads
 *  to less aggressive compression and remains closer to the original,
 *  whereas an arbitrarily chosen compression rank that is much lower
 *  than the original rank leads to large divergence in the resulting matrix.
 */

/* Sanity Test: Test Exact reconstruction
 *  Create a very-low rank matrix (such as a uniform matrix
 *  with a repeated entries that is rank-1) and compress
 *  using an arbitrarily low rank (can be as low as the rank
 *  of the original matrix).
 *  The test expects the matrix resulting from reconstruction
 *  of the SVD components is an almost exact match to the
 *  original.
 */
TYPED_TEST(DlCompressionSVDTest, SANITY_TestExactReconstruction)
{
#ifdef USE_OPENCV
    float errorThreshold  = 1e-4;
    std::string layerName = ""ip1"";
    std::vector<int> shape;
    int M = 40;   // rows of FC layer
    int N = 30;   // cols of FC layer
    // Store dims in 'Caffe' style
    shape.push_back(N);
    shape.push_back(M);

    // Create rank vector
    std::vector<unsigned int> ranks;
    // selected rank can match the true rank of the
    // original matrix to achieve loss-less compression.
    unsigned int r = 10;
    ranks.push_back(r);
    // Create weights vector
    std::vector<float*> splitWeights;
    std::vector<unsigned int> weightSizes;

    this->CreateLayer(LAYER_TYPE_FC, TYPE_SINGLE, INIT_FIXED, shape, false);
    cv::Mat original_Matrix(N, M, CV_32F, this->m_layerAttrib.blobs[0].data());
    // Create an instance of the SVD object
    ISVD<float>* svdObj = GetSVDInstance<float>();
    svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);

    unsigned int weight1_size = M * r;
    std::unique_ptr<float> weights1(new float[weight1_size]);
    splitWeights.push_back(weights1.get());
    weightSizes.push_back(weight1_size);

    unsigned int weight2_size = r * N;
    std::unique_ptr<float> weights2(new float[weight2_size]);
    splitWeights.push_back(weights2.get());
    weightSizes.push_back(weight2_size);

    // Compress layer matrix
    svdObj->SplitLayerWeights(layerName, splitWeights, weightSizes, ranks);
    // Split weights are in transposed form.
    // Store them in proper form in intermediate matrices.
    cv::Mat WeightMat_0(r, M, CV_32F, (float*) (splitWeights[0]));
    cv::Mat WeightMat_1(N, r, CV_32F, (float*) (splitWeights[1]));

    // Reconstruct the original matrix by representing matrices
    // in their true mathematical form by nullifying the transpose
    // applied by the SVD algorithm.
    cv::Mat Reconstructed_Matrix = WeightMat_0.t() * WeightMat_1.t();
    // Estimate the tensor approximation residual (TAR)
    float recon_error = cv::norm(Reconstructed_Matrix.t(), original_Matrix, (cv::NORM_RELATIVE | cv::NORM_L2));
    ASSERT_LE(recon_error, errorThreshold);
#endif
}

/* Sanity Test: Test Lossy reconstruction
 *  Create a high-rank matrix by initializing with random values
 *  and compress using a low rank value to result in lossy
 *  compression.
 *  The test expects that compression with
 *  higher rank values results in lower reconstruction errors.
 */
TYPED_TEST(DlCompressionSVDTest, SANITY_TestLossyReconstruction)
{
#ifdef USE_OPENCV
    float errorThreshold  = 5e-1;
    std::string layerName = ""ip1"";
    std::vector<int> shape;
    int M = 160;   // rows of FC layer
    int N = 120;   // cols of FC layer
    // Store dims in 'Caffe' style
    shape.push_back(N);
    shape.push_back(M);

    // Create rank vector
    std::vector<unsigned int> ranks;
    // selected a fairly small rank to perform compression
    unsigned int r = 60;
    ranks.push_back(r);
    // Create weights vector
    std::vector<float*> splitWeights;
    std::vector<unsigned int> weightSizes;

    this->CreateLayer(LAYER_TYPE_FC, TYPE_SINGLE, INIT_RANDOM, shape, false);
    cv::Mat original_Matrix(N, M, CV_32F, this->m_layerAttrib.blobs[0].data());
    // Create an instance of the SVD object
    ISVD<float>* svdObj = GetSVDInstance<float>();
    svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);

    unsigned int weight1_size = M * r;
    std::unique_ptr<float> weights1(new float[weight1_size]);
    splitWeights.push_back(weights1.get());
    weightSizes.push_back(weight1_size);

    unsigned int weight2_size = r * N;
    std::unique_ptr<float> weights2(new float[weight2_size]);
    splitWeights.push_back(weights2.get());
    weightSizes.push_back(weight2_size);

    // Compress layer matrix
    svdObj->SplitLayerWeights(layerName, splitWeights, weightSizes, ranks);
    // Split weights are in transposed form.
    // Store them in proper form in intermediate matrices.
    cv::Mat WeightMat_0(r, M, CV_32F, (float*) (splitWeights[0]));
    cv::Mat WeightMat_1(N, r, CV_32F, (float*) (splitWeights[1]));

    // Reconstruct the original matrix by representing matrices
    // in their true mathematical form by nullifying the transpose
    // applied by the SVD algorithm.
    cv::Mat Reconstructed_Matrix = WeightMat_0.t() * WeightMat_1.t();
    // Estimate the tensor approximation residual (TAR)
    float recon_error = cv::norm(Reconstructed_Matrix.t(), original_Matrix, (cv::NORM_RELATIVE | cv::NORM_L2));
    ASSERT_LE(recon_error, errorThreshold);
#endif
}

/* Sanity Test: Test single pass SVD with FC layer
 *  Create an FC layer with standard layer parameters
 *  and examine rank selection with different criteria.
 *  The test expects that the compression scores produced
 *  by the library for a given rank value match the theoretical
 *  expected amount of compression.
 */
TYPED_TEST(DlCompressionSVDTest, PERFORMANCE_TestRankSelectionFCSingle)
{
#ifdef USE_OPENCV
    std::string layerName = ""ip1"";
    std::vector<int> shape;
    int M                = 1024;   // rows of FC layer
    int N                = 10;     // cols of FC layer
    float errorThreshold = 5e-1;
    // Store dims in 'Caffe' style
    shape.push_back(N);
    shape.push_back(M);
    this->CreateLayer(LAYER_TYPE_FC, TYPE_SINGLE, INIT_RANDOM, shape, false);

    // Perform SVD rank analysis with different metrics.
    std::vector<NETWORK_COST_METRIC> metric_types = {COST_TYPE_MEMORY, COST_TYPE_MAC};

    for (auto metric: metric_types)
    {
        std::shared_ptr<ISVD<float> > svdObj = std::shared_ptr<ISVD<float> >(GetSVDInstance<float>());
        svdObj->SetCostMetric(metric);
        svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);
        // Compute network cost
        svdObj->ComputeNetworkCost();

        size_t layerSize              = M * N;
        int optimalRankIndex          = 12;   // Pick a rank index as optimal
        float optimalCompressionScore = 0.0;

        // Set a pre-determined number of candidate ranks
        int numCandidateRanks = svdObj->SetCandidateRanks(20);
        for (int rankIndex = 0; rankIndex < numCandidateRanks; ++rankIndex)
        {
            //  svdObj->PrintCandidateRanks (rankIndex, false);
            std::vector<unsigned int> rank = svdObj->GetCandidateRanks(layerName, rankIndex);
            // Get relative compression score at each rank.
            float compressionScore = svdObj->GetCompressionScore(rankIndex, false, 0, 0);
            // Store the 'optimal' compression score
            if (rankIndex == optimalRankIndex)
                optimalCompressionScore = compressionScore;

            // Compare theoretical compression score.
            unsigned int r                 = rank.at(0);
            size_t reducedLayerSize        = (M + N) * r;
            float expectedCompressionScore = float(layerSize - reducedLayerSize) / float(layerSize);
            ASSERT_LE(fabs(compressionScore - expectedCompressionScore), errorThreshold);
        }
        // Now store optimal ranks for the network
        svdObj->StoreBestRanks(optimalRankIndex);
        // Get compression score with bestRanks
        float bestCompressionScore = svdObj->GetCompressionScore(0, true, 0, 0);
        // Compare with optimal compression score
        ASSERT_LE(fabs(bestCompressionScore - optimalCompressionScore), errorThreshold);
    }
#endif
}

/* Sanity Test: Test single pass SVD with CONV layer
 *  Create a CONV layer with standard layer parameters
 *  and examine rank selection with different criteria with
 *  single pass SVD.
 *  CONV layers, unlike FC layers are 4D tensors and require
 *  careful handling and transposition methods to achieve
 *  proper SVD compression.
 *  The test expects that the compression scores produced
 *  by the library for a given rank value match the theoretical
 *  expected amount of compression.
 */
TYPED_TEST(DlCompressionSVDTest, PERFORMANCE_TestRankSelectionConvSingle)
{
#ifdef USE_OPENCV
    std::string layerName = ""conv1"";
    std::vector<int> shape;
    float errorThreshold = 5e-1;
    int M                = 32;   // rows of Conv layer
    int N                = 64;   // cols of Conv layer
    int k_h              = 5;    // kernel height
    int k_w              = 5;    // kernel width
    int Nkk              = N * k_h * k_w;
    // Store dims in 'Caffe' style
    shape.push_back(N);
    shape.push_back(M);
    shape.push_back(k_h);
    shape.push_back(k_w);
    this->CreateLayer(LAYER_TYPE_CONV, TYPE_SINGLE, INIT_RANDOM, shape, false);

    // Perform SVD rank analysis with different metrics.
    std::vector<NETWORK_COST_METRIC> metric_types = {COST_TYPE_MEMORY, COST_TYPE_MAC};

    for (auto metric: metric_types)
    {
        std::shared_ptr<ISVD<float> > svdObj = std::shared_ptr<ISVD<float> >(GetSVDInstance<float>());
        svdObj->SetCostMetric(metric);
        svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);
        // Compute network cost
        svdObj->ComputeNetworkCost();

        size_t layerSize              = M * Nkk;
        int optimalRankIndex          = 12;   // Pick a rank index as optimal
        float optimalCompressionScore = 0.0;

        int numCandidateRanks = svdObj->SetCandidateRanks(20);
        for (int rankIndex = 0; rankIndex < numCandidateRanks; ++rankIndex)
        {
            //  svdObj->PrintCandidateRanks (rankIndex, false);
            std::vector<unsigned int> ranks = svdObj->GetCandidateRanks(layerName, rankIndex);
            // Get relative compression score at each rank.
            float compressionScore = svdObj->GetCompressionScore(rankIndex, false, 0, 0);
            // Store the 'optimal' compression score
            if (rankIndex == optimalRankIndex)
                optimalCompressionScore = compressionScore;

            // Compare theoretical compression score.
            unsigned int r                 = ranks.at(0);
            size_t reducedLayerSize        = (M + Nkk) * r;
            float expectedCompressionScore = float(layerSize - reducedLayerSize) / float(layerSize);
            ASSERT_LE(fabs(compressionScore - expectedCompressionScore), errorThreshold);
        }
        // Now store optimal ranks for the network
        svdObj->StoreBestRanks(optimalRankIndex);
        // Get compression score with bestRanks
        float bestCompressionScore = svdObj->GetCompressionScore(0, true, 0, 0);
        // Compare with optimal compression score
        ASSERT_LE(fabs(bestCompressionScore - optimalCompressionScore), errorThreshold);
    }
#endif
}

/* Sanity Test: Test successive pass SVD with CONV layer
 *  Create a CONV layer with standard layer parameters
 *  and examine rank selection with different criteria with
 *  successive pass SVD.
 *  CONV layers, unlike FC layers are 4D tensors and require
 *  careful handling and transposition methods to achieve
 *  proper SSVD compression.
 *  The test expects that the compression scores produced
 *  by the library for a given pair of SSVD ranks match the
 *  theoretical expected amount of compression.
 */
TYPED_TEST(DlCompressionSVDTest, PERFORMANCE_TestRankSelectionConvSuccessive)
{
#ifdef USE_OPENCV
    std::string layerName = ""conv2"";
    std::vector<int> shape;
    float errorThreshold = 5e-1;
    int M                = 32;   // rows of Conv layer
    int N                = 64;   // cols of Conv layer
    int k_h              = 5;    // kernel height
    int k_w              = 5;    // kernel width
    int Nkk              = N * k_h * k_w;

    // Store dims in 'Caffe' style
    shape.push_back(N);
    shape.push_back(M);
    shape.push_back(k_h);
    shape.push_back(k_w);
    this->CreateLayer(LAYER_TYPE_CONV, TYPE_SUCCESSIVE, INIT_RANDOM, shape, false);

    size_t layerSize              = M * Nkk;
    int optimalRankIndex          = 8;   // Pick a rank index as optimal
    float optimalCompressionScore = 0.0;

    // Perform SSVD rank analysis with different metrics.
    std::vector<NETWORK_COST_METRIC> metric_types = {COST_TYPE_MEMORY, COST_TYPE_MAC};

    for (auto metric: metric_types)
    {
        std::shared_ptr<ISVD<float> > svdObj = std::shared_ptr<ISVD<float> >(GetSVDInstance<float>());
        svdObj->SetCostMetric(metric);
        svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);
        // Compute network cost
        svdObj->ComputeNetworkCost();

        int numCandidateRanks = svdObj->SetCandidateRanks(20);
        for (int rankIndex = 0; rankIndex < numCandidateRanks; ++rankIndex)
        {
            //  svdObj->PrintCandidateRanks (rankIndex, false);
            std::vector<unsigned int> ranks = svdObj->GetCandidateRanks(layerName, rankIndex);
            // Get relative compression score at each rank.
            float compressionScore = svdObj->GetCompressionScore(rankIndex, false, 0, 0);
            // Store the 'optimal' compression score
            if (rankIndex == optimalRankIndex)
                optimalCompressionScore = compressionScore;

            // Compare theoretical compression score.
            ASSERT_EQ(ranks.size(), 2);
            unsigned int r                 = ranks.at(0);
            unsigned int s                 = ranks.at(1);
            size_t reducedLayerSize        = M * r + r * s * k_h * k_w + s * N;
            float expectedCompressionScore = float(layerSize - reducedLayerSize) / float(layerSize);
            ASSERT_LE(fabs(compressionScore - expectedCompressionScore), errorThreshold);
        }
        // Now store optimal ranks for the network
        svdObj->StoreBestRanks(optimalRankIndex);
        // Get compression score with bestRanks
        float bestCompressionScore = svdObj->GetCompressionScore(0, true, 0, 0);
        // Compare with optimal compression score
        ASSERT_LE(fabs(bestCompressionScore - optimalCompressionScore), errorThreshold);
    }
#endif
}

/* Sanity Test: Test the mean shift correction (MSC) for an FC layer with bias.
 *  We split both the weights and the bias of this layer. The weights will
 *  incur some error. The library will try to make up for this by adapting the
 *  bias.
 */
TYPED_TEST(DlCompressionSVDTest, SANITY_TestMscFCSingle)
{
#ifdef USE_OPENCV
    float errorThreshold  = 1e-4;
    std::string layerName = ""ip1"";
    std::vector<int> shape;
    int M = 40;   // rows of FC layer
    int N = 30;   // cols of FC layer
    // Store dims in 'Caffe' style
    shape.push_back(N);
    shape.push_back(M);

    // Create rank vector
    std::vector<unsigned int> ranks;
    // selected a fairly small rank to perform compression
    unsigned int r = 20;
    ranks.push_back(r);
    // Create weights vector
    std::vector<float*> splitWeights;
    std::vector<unsigned int> weightSizes;
    // Create bias vector
    std::vector<float*> splitBiases;
    std::vector<unsigned int> biasSizes;

    this->CreateLayer(LAYER_TYPE_FC, TYPE_SINGLE, INIT_RANDOM, shape, true);
    cv::Mat original_Matrix(N, M, CV_32F, this->m_layerAttrib.blobs[0].data());
    cv::Mat original_Bias(N, 1, CV_32F, this->m_layerAttrib.blobs[1].data());
    cv::Mat average_Inputs(M, 1, CV_32F, this->m_layerAttrib.inputChannelMean.data());
    // Create an instance of the SVD object
    ISVD<float>* svdObj = GetSVDInstance<float>();
    svdObj->StoreLayerAttributes(layerName, this->m_layerAttrib);

    // Create the data structure for the split weights.
    unsigned int weight1_size = M * r;
    std::unique_ptr<float> weights1(new float[weight1_size]);
    splitWeights.push_back(weights1.get());
    weightSizes.push_back(weight1_size);

    unsigned int weight2_size = r * N;
    std::unique_ptr<float> weights2(new float[weight2_size]);
    splitWeights.push_back(weights2.get());
    weightSizes.push_back(weight2_size);

    // Split the weights.
    svdObj->SplitLayerWeights(layerName, splitWeights, weightSizes, ranks);

    // Split weights are in transposed form.
    // Store them in proper form in intermediate matrices.
    cv::Mat WeightMat_0(r, M, CV_32F, (float*) (splitWeights[0]));
    cv::Mat WeightMat_1(N, r, CV_32F, (float*) (splitWeights[1]));

    // Reconstruct the original matrix by representing matrices
    // in their true mathematical form by nullifying the transpose
    // applied by the SVD algorithm.
    cv::Mat Reconstructed_Matrix = WeightMat_0.t() * WeightMat_1.t();

    // Create the data structure for the split biases.
    unsigned int bias1_size = r;
    std::vector<float> bias1(bias1_size);
    splitBiases.push_back(bias1.data());
    biasSizes.push_back(bias1_size);

    unsigned int bias2_size = N;
    std::vector<float> bias2(bias2_size);
    splitBiases.push_back(bias2.data());
    biasSizes.push_back(bias2_size);

    // Split layer bias.
    svdObj->SplitLayerBiases(layerName, splitBiases, biasSizes, ranks);

    // Copy the result into cv matrices.
    cv::Mat BiasMat_0(r, 1, CV_32F, (float*) (splitBiases[0]));
    cv::Mat BiasMat_1(N, 1, CV_32F, (float*) (splitBiases[1]));

    // Compute the expected bias, including the MSC correction.
    cv::Mat Bias0_Expected = cv::Mat::zeros(r, 1, CV_32F);
    // The second's layer bias gets computed using the MSC method. A correction
    // term is added to the original bias, to make up for the reconstrution
    // error. We know the reconstruction error as well as the average of this
    // layer's input channels. Using these two matrices, we can compute the bias
    // correction.
    cv::Mat Bias1_Expected = (original_Matrix.t() - Reconstructed_Matrix).t() * average_Inputs + original_Bias;
    // Check that the split biases have low L2 error.
    float bias0_error = cv::norm(Bias0_Expected, BiasMat_0, (cv::NORM_RELATIVE | cv::NORM_L2));
    float bias1_error = cv::norm(Bias1_Expected, BiasMat_1, (cv::NORM_RELATIVE | cv::NORM_L2));
    EXPECT_EQ(bias0_error, 0);
    EXPECT_LE(bias1_error, errorThreshold);

    // Run some actual data through this layer, and check if our bias correction
    // improves the accuracy.
    // As layer input, we use some data which looks similar, but not identical,
    // to the average layer input.
    cv::Mat Delta(M, 1, CV_32F);
    cv::randu(Delta, cv::Scalar(-0.1), cv::Scalar(0.1));
    cv::Mat Layer_Input = average_Inputs + Delta;
    // First we compute the reference output of this layer.
    cv::Mat Output_Reference = Layer_Input.t() * original_Matrix.t() + original_Bias.t();
    // Now compute the output of the compressed layer, without mean shift
    // correction.
    cv::Mat Output_No_Msc = Layer_Input.t() * WeightMat_0.t() * WeightMat_1.t() + original_Bias.t();
    // Now compute the output of the compressed layer, with mean shift
    // correction.
    cv::Mat Output_With_Msc = Layer_Input.t() * WeightMat_0.t() * WeightMat_1.t() + BiasMat_1.t();
    // Compute the error with and without MSC, using L2 norm.
    float  [MASK]    = cv::norm(Output_Reference, Output_No_Msc, (cv::NORM_RELATIVE | cv::NORM_L2));
    float error_with_msc = cv::norm(Output_Reference, Output_With_Msc, (cv::NORM_RELATIVE | cv::NORM_L2));
    // Verify that MSC improves the accuracy.
    float expected_improvement_factor = 5;
    EXPECT_LE(error_with_msc,  [MASK]  / expected_improvement_factor);
#endif
}
",error_no_msc
763,"#ifndef BST_H
#define BST_H

#include ""Node.h""
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <random>

using std::vector;
using std::string;
using std::cout;

template <typename T>
class BST {

private:
    Node<T> *root;

protected:

    // Methods
    int numOfElements;
    Node<T> *Insert       (Node<T> *node, T key);
    Node<T> *Remove       (Node<T> *node, T key);
    Node<T> *Search       (Node<T> *node, T key);
    void PrintTreeInOrder (Node<T> *node);
    T FindMin             (Node<T> *node);
    T FindMax             (Node<T> *node);
    T Successor           (Node<T> *node);
    T Predecessor         (Node<T> *node);

public:

    // Constructor
    BST();
    
    // Destructor
    ~BST();

    // Getters
    int getNumOfElements() {return numOfElements;}
    Node<T> *getRoot()     {return root;}

    // Methods
    T* ConvertToArray();
    void PrintTreeInOrder();
    void Insert      (T key);
    void Remove      (T v);
    bool Search      (T key);
    T  Successor     (T key);
    T  Predecessor   (T key);
    T  FindMin();
    T  FindMax();
    
    // Extra Methods (Not mine)
    int get_max_depth() const { return root ? root->max_depth() : 0; }
    void clear() { delete root; root = nullptr; }
    struct cell_display {
        string   valstr;
        bool     present;
        cell_display() : present(false) {}
        cell_display(std::string valstr) : valstr(valstr), present(true) {}
    };
    
    using display_rows = vector<vector<cell_display>>;

    // The text tree generation code below is all iterative, to avoid stack faults.

    // get_row_display builds a vector of vectors of cell_display structs
    // each vector of cell_display structs represents one row, starting at the root
    display_rows get_row_display() const {
        // start off by traversing the tree to
        // build a vector of vectors of Node pointers
        vector<Node<T>*>  [MASK] ;
        vector< std::vector<Node<T>*> > rows;
        if(!root) return display_rows();
    
        Node<T> *p = root;
        const int max_depth = root->max_depth();
        rows.resize(max_depth);
        int depth = 0;
        for(;;) {
            // Max-depth Nodes are always a leaf or null
            // This special case blocks deeper traversal
            if(depth == max_depth-1) {
                rows[depth].push_back(p);
                if(depth == 0) break;
                --depth;
                continue;
            }

            // First visit to node?  Go to left child.
            if( [MASK] .size() == depth) {
                rows[depth].push_back(p);
                 [MASK] .push_back(p);
                if(p) p = p->Left;
                ++depth;
                continue;
            }
        
            // Odd child count? Go to right child.
            if(rows[depth+1].size() % 2) {
                p =  [MASK] .back();
                if(p) p = p->Right;
                ++depth;
                continue;
            }

            // Time to leave if we get here

            // Exit loop if this is the root
            if(depth == 0) break;

             [MASK] .pop_back();
            p =  [MASK] .back();
            --depth;
        }

        // Use rows of Node pointers to populate rows of cell_display structs.
        // All possible slots in the tree get a cell_display struct,
        // so if there is no actual Node at a struct's location,
        // its boolean ""present"" field is set to false.
        // The struct also contains a string representation of
        // its Node's value, created using a std::stringstream object.
        display_rows rows_disp;
        std::stringstream ss;
        for(const auto& row : rows) {
            rows_disp.emplace_back();
            for(Node<T>* pn : row) {
                if(pn) {
                    ss << pn->Key;
                    rows_disp.back().push_back(cell_display(ss.str()));
                    ss = std::stringstream();
                } else {
                    rows_disp.back().push_back(cell_display());
        }   }   }
        return rows_disp;
    }

    // row_formatter takes the vector of rows of cell_display structs
    // generated by get_row_display and formats it into a test representation
    // as a vector of strings
    vector<string> row_formatter(const display_rows& rows_disp) const {
        using s_t = string::size_type;

        // First find the maximum value string length and put it in cell_width
        s_t cell_width = 0;
        for(const auto& row_disp : rows_disp) {
            for(const auto& cd : row_disp) {
                if(cd.present && cd.valstr.length() > cell_width) {
                    cell_width = cd.valstr.length();
        }   }   }

        // make sure the cell_width is an odd number
        if(cell_width % 2 == 0) ++cell_width;

        // allows leaf nodes to be connected when they are
        // all with size of a single character
        if(cell_width < 3) cell_width = 3;

        // formatted_rows will hold the results
        vector<string> formatted_rows;
    
        // some of these counting variables are related,
        // so its should be possible to eliminate some of them.
        s_t row_count = rows_disp.size();

        // this row's element count, a power of two
        s_t row_elem_count = 1 << (row_count-1);

        // left_pad holds the number of space charactes at the beginning of the bottom row
        s_t left_pad = 0;
    
        // Work from the level of maximum depth, up to the root
        // (""formatted_rows"" will need to be reversed when done)
        for(s_t r=0; r<row_count; ++r) {
            const auto& cd_row = rows_disp[row_count-r-1]; // r reverse-indexes the row
            // ""space"" will be the number of rows of slashes needed to get
            // from this row to the next.  It is also used to determine other
            // text offsets.
            s_t space = (s_t(1) << r) * (cell_width + 1) / 2 - 1;
            // ""row"" holds the line of text currently being assembled
            string row;
            // iterate over each element in this row
            for(s_t c=0; c<row_elem_count; ++c) {
                // add padding, more when this is not the leftmost element
                row += string(c ? left_pad*2+1 : left_pad, ' ');
                if(cd_row[c].present) {
                    // This position corresponds to an existing Node
                    const string& valstr = cd_row[c].valstr;
                    // Try to pad the left and right sides of the value string
                    // with the same number of spaces.  If padding requires an
                    // odd number of spaces, right-sided children get the longer
                    // padding on the right side, while left-sided children
                    // get it on the left side.
                    s_t long_padding = cell_width - valstr.length();
                    s_t short_padding = long_padding / 2;
                    long_padding -= short_padding;
                    row += string(c%2 ? short_padding : long_padding, ' ');
                    row += valstr;
                    row += string(c%2 ? long_padding : short_padding, ' ');
                } else {
                    // This position is empty, Nodeless...
                    row += string(cell_width, ' ');
                }
            }
            // A row of spaced-apart value strings is ready, add it to the result vector
            formatted_rows.push_back(row);
        
            // The root has been added, so this loop is finsished
            if(row_elem_count == 1) break;

            // Add rows of forward- and back- slash characters, spaced apart
            // to ""connect"" two rows' Node value strings.
            // The ""space"" variable counts the number of rows needed here.
            s_t left_space  = space + 1;
            s_t right_space = space - 1;
            for(s_t sr=0; sr<space; ++sr) {
                string row;
                for(s_t c=0; c<row_elem_count; ++c) {
                    if(c % 2 == 0) {
                        row += string(c ? left_space*2 + 1 : left_space, ' ');
                        row += cd_row[c].present ? '/' : ' ';
                        row += string(right_space + 1, ' ');
                    } else {
                        row += string(right_space, ' ');
                        row += cd_row[c].present ? '\\' : ' ';
                    }
                }
                formatted_rows.push_back(row);
                ++left_space;
                --right_space;
            }
            left_pad += space + 1;
            row_elem_count /= 2;
        }

        // Reverse the result, placing the root node at the beginning (top)
        std::reverse(formatted_rows.begin(), formatted_rows.end());
    
        return formatted_rows;
    }

    // Trims an equal number of space characters from
    // the beginning of each string in the vector.
    // At least one string in the vector will end up beginning
    // with no space characters.
    static void trim_rows_left(vector<string>& rows) {
        if(!rows.size()) return;
        auto min_space = rows.front().length();
        for(const auto& row : rows) {
            auto i = row.find_first_not_of(' ');
            if(i==string::npos) i = row.length();
            if(i == 0) return;
            if(i < min_space) min_space = i;
        }
        for(auto& row : rows) {
            row.erase(0, min_space);
    }   }

    // Dumps a representation of the tree to cout
    void PrintBST() const {
        const int d = get_max_depth();
    
        // If this tree is empty, tell someone
        if(d == 0) {
            cout << "" <empty tree>\n"";
            return;
        }

        // This tree is not empty, so get a list of node values...
        const auto rows_disp = get_row_display();
        // then format these into a text representation...
        auto formatted_rows = row_formatter(rows_disp);
        // then trim excess space characters from the left sides of the text...
        trim_rows_left(formatted_rows);
        // then dump the text to cout.
        for(const auto& row : formatted_rows) {
            std::cout << ' ' << row << '\n';
        }
    }
};

// Constructor
template <typename T>
BST<T>::BST() {

    numOfElements = 0;
    root = NULL;
    numOfElements = 0;
}

// Destructor
template <typename T>
BST<T>::~BST() {

    delete root;
}

// Protected: Insert
template <typename T>
Node<T> *BST<T>::Insert(Node<T> *node, T key) {

    // If BST doesn't exist
    // create a new node as root
    // or it's reached when
    // there's no any child node
    // so we can insert a new node here
    if(node == NULL) {

        node         = new Node<T>();
        node->Key    = key;
        node->Left   = NULL;
        node->Right  = NULL;
        node->Parent = NULL;
    }

    // If the given key is greater than
    // node's key then go to right subtree
    else if(node->Key < key) {

        node->Right = Insert(node->Right, key);
        node->Right->Parent = node;
    }

    // If the given key is smaller than
    // node's key then go to left subtree
    else {
        
        node->Left = Insert(node->Left, key);
        node->Left->Parent = node;
    }
    return node;
}

// Public: Insert
template <typename T>
void BST<T>::Insert(T key) {

    // Invoking Insert() function
    // and passing root node and given key
    root = Insert(root, key);
    numOfElements++;
}

// Protected: PrintTreeInOrder
template <typename T>
void BST<T>::PrintTreeInOrder(Node<T> *node) {

    // Stop printing if no node found
    if(node == NULL)
        return;

    // Get the smallest key first
    // which is in the left subtree
    PrintTreeInOrder(node->Left);

    // Print the key
    std::cout << node->Key << "" "";

    // Continue to the greatest key
    // which is in the right subtree
    PrintTreeInOrder(node->Right);
}

// Public: PrintTreeInOrder
template <typename T>
void BST<T>::PrintTreeInOrder() {

    // Traverse the BST
    // from root node
    // then print all keys
    PrintTreeInOrder(root);
    std::cout << std::endl;
}

// Protected: Search
template <typename T>
Node<T> * BST<T>::Search(Node<T> *node, T key) {

    // The given key is
    // not found in BST
    if (node == NULL)
        return NULL;
    // The given key is found
    else if(node->Key == key)
        return node;
    // The given is greater than
    // current node's key
    else if(node->Key < key)
        return Search(node->Right, key);
    // The given is smaller than
    // current node's key
    else
        return Search(node->Left, key);
}

// Public: Search
template <typename T>
bool BST<T>::Search(T key) {

    // Invoking Search() operation
    // and passing root node
    Node<T> * result = Search(root, key);

    // If key is found, returns TRUE
    // otherwise returns FALSE
    return result == NULL ? false : true;
}

// Protected: FindMin
template <typename T>
T BST<T>::FindMin(Node<T> * node) {

    if(node == NULL)
        return NULL;
    else if(node->Left == NULL)
        return node->Key;
    else
        return FindMin(node->Left);
}

// Public: FindMin
template <typename T>
T BST<T>::FindMin() {

    return FindMin(root);
}

// Protected: FindMax
template <typename T>
T BST<T>::FindMax(Node<T> * node) {

    if(node == NULL)
        return NULL;
    else if(node->Right == NULL)
        return node->Key;
    else
        return FindMax(node->Right);
}

// Public: FindMax
template <typename T>
T BST<T>::FindMax() {

    return FindMax(root);
}

// Protected: Successor
template <typename T>
T BST<T>::Successor(Node<T> *node) {

    // The successor is the minimum key value
    // of right subtree
    if (node->Right != NULL) {

        return FindMin(node->Right);
    }
    // If no any right subtree
    else {

        Node<T> *parentNode  = node->Parent;
        Node<T> *currentNode = node;

        // If currentNode is not root and
        // currentNode is its right children
        // continue moving up
        while ((parentNode != NULL) &&
            (currentNode == parentNode->Right)) {

            currentNode = parentNode;
            parentNode = currentNode->Parent;
        }

        // If parentNode is not NULL
        // then the key of parentNode is
        // the successor of node
        return parentNode == NULL ?
            -1 :
            parentNode->Key;
    }
}

// Public: Successor
template <typename T>
T BST<T>::Successor(T key) {

    // Search the key's node first
    Node<T> *keyNode = Search(root, key);

    // Return the key.
    // If the key is not found or
    // successor is not found,
    // return -1
    return keyNode == NULL ? NULL : Successor(keyNode);
}

// Protected: Predecessor
template <typename T>
T BST<T>::Predecessor(Node<T> *node) {

    // The predecessor is the maximum key value
    // of left subtree
    if (node->Left != NULL) {

        return FindMax(node->Left);
    }
    // If no any left subtree
    else {

        Node<T> * parentNode  = node->Parent;
        Node<T> * currentNode = node;

        // If currentNode is not root and
        // currentNode is its left children
        // continue moving up
        while ((parentNode != NULL) &&
            (currentNode == parentNode->Left)) {

            currentNode = parentNode;
            parentNode  = currentNode->Parent;
        }

        // If parentNode is not NULL
        // then the key of parentNode is
        // the predecessor of node
        return parentNode == NULL ? NULL : parentNode->Key;
    }
}

// Public: Predecessor
template <typename T>
T BST<T>::Predecessor(T key) {

    // Search the key's node first
    Node<T> *keyNode = Search(root, key);

    // Return the key.
    // If the key is not found or
    // predecessor is not found,
    // return -1
    return keyNode == NULL ? NULL : Predecessor(keyNode);
}

// Protected: Remove
template <typename T>
Node<T> * BST<T>::Remove( Node<T> *node, T key) {

    // The given node is
    // not found in BST
    if (node == NULL)
        return NULL;

    // Target node is found
    if (node->Key == key) {

        // If the node is a leaf node
        // The node can be safely removed
        if (node->Left == NULL && node->Right == NULL)
            node = NULL;
        // The node have only one child at right
        else if (node->Left == NULL && node->Right != NULL) {

            // The only child will be connected to
            // the parent's of node directly
            node->Right->Parent = node->Parent;

            // Bypass node
            node = node->Right;
        }
        // The node have only one child at left
        else if (node->Left != NULL && node->Right == NULL) {

            // The only child will be connected to
            // the parent's of node directly
            node->Left->Parent = node->Parent;

            // Bypass node
            node = node->Left;
        }
        // The node have two children (left and right)
        else {

            // Find successor or predecessor to avoid quarrel
            int successorKey = Successor(key);

            // Replace node's key with successor's key
            node->Key = successorKey;

            // Delete the old successor's key
            node->Right = Remove(node->Right, successorKey);
        }
    }
    // Target node's key is smaller than
    // the given key then search to right
    else if (node->Key < key)
        node->Right = Remove(node->Right, key);
    // Target node's key is greater than
    // the given key then search to left
    else
        node->Left = Remove(node->Left, key);

    // Return the updated BST
    return node;
}

// Public: Remove
template <typename T>
void BST<T>::Remove(T key) {

    root = Remove(root, key);
    numOfElements--;
}

// Public: ConvertToArray
template <typename T>
T* BST<T>::ConvertToArray() {

    static T arr[100];
    Node<T> *node = Search(root, FindMin(root));
    int i=0;
    while (node != NULL) {

        arr[i] = node->Key;
        node = Search(root,Successor(node));
        i++;
    }
    return arr;
}


#endif
",traversal_stack
764,"/*
 * Copyright (c) 2018-2020, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 *
 * See COPYRIGHT.txt for license information
 */

#include ""coll_test.h""
int coll_max_iters = BARRIER_MAX_ITERS;

int main(int c, char *v[]) {
    int status = 0;
    int mype;
    size_t size = 1;
    int iters = BARRIER_MAX_ITERS;
    int skip = BARRIER_MAX_SKIP;
    float ms;
    double latency_value;
    cudaStream_t stream;
    cudaEvent_t  [MASK] , stop_event;

    init_wrapper(&c, &v);

    mype = nvshmem_my_pe();
#ifdef _NVSHMEM_DEBUG
    int npes = nvshmem_n_pes();
#endif
    CUDA_CHECK(cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking));
    CUDA_CHECK(cudaEventCreate(& [MASK] ));
    CUDA_CHECK(cudaEventCreate(&stop_event));

    DEBUG_PRINT(""SHMEM: [%d of %d] hello shmem world! \n"", mype, npes);

    for (iters = 0; iters < skip; iters++) {
        nvshmemx_barrier_on_stream(NVSHMEM_TEAM_WORLD, stream);
    }
    CUDA_CHECK(cudaStreamSynchronize(stream));
    nvshmem_barrier_all();

    CUDA_CHECK(cudaEventRecord( [MASK] , stream));
    for (iters = 0; iters < coll_max_iters; iters++) {
        nvshmemx_barrier_on_stream(NVSHMEM_TEAM_WORLD, stream);
    }
    CUDA_CHECK(cudaEventRecord(stop_event, stream));
    CUDA_CHECK(cudaStreamSynchronize(stream));
    CUDA_CHECK(cudaEventElapsedTime(&ms,  [MASK] , stop_event));

    if (!mype) {
        latency_value = (ms / coll_max_iters) * 1000;
        print_table_basic(""barrier_on_stream"", ""None"", ""size (Bytes)"", ""latency"", ""us"", '-', &size,
                          &latency_value, 1);
    }

    nvshmem_barrier_all();

    CUDA_CHECK(cudaStreamDestroy(stream));
    CUDA_CHECK(cudaEventDestroy( [MASK] ));
    CUDA_CHECK(cudaEventDestroy(stop_event));

    finalize_wrapper();

    return status;
}
",start_event
765,"#include <algorithm>
#include <chrono>
#include <cstddef>
#include <cstdlib>
#include <fmt/format.h>
#include <tb_client.hpp>

inline auto get_time_ms() noexcept {
  return std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::steady_clock::now().time_since_epoch())
      .count();
}

int main([[maybe_unused]] int argc, [[maybe_unused]] char **argv) {
  fmt::print(""TigerBeetle C++ Sample\n"");
  fmt::print(""Connecting...\n"");

  auto address = []() -> std::string_view {
    if (const char *env_address = std::getenv(""TB_ADDRESS""); env_address) {
      return env_address;
    }
    return ""3001"";
  }();

  tigerbeetle::Client client(address);

  if (client.initStatus() != tigerbeetle::TB_INIT_SUCCESS) {
    fmt::println(""Failed to initialize tb_client"");
    return EXIT_FAILURE;
  }

  tigerbeetle::CompletionContext ctx{};
  tigerbeetle::tb_packet_t packet{};

  ////////////////////////////////////////////////////////////
  // Submitting a batch of accounts
  ////////////////////////////////////////////////////////////

  static constexpr size_t ACCOUNTS_LEN = 2;
  auto accounts = tigerbeetle::make_account<ACCOUNTS_LEN>();

  // Fully initialize all fields in declaration order
  accounts[0] = tigerbeetle::tb_account_t{.id = 1,
                                          .debits_pending = 0,
                                          .debits_posted = 0,
                                          .credits_pending = 0,
                                          .credits_posted = 0,
                                          .user_data_128 = 0,
                                          .user_data_64 = 0,
                                          .user_data_32 = 0,
                                          .reserved = 0,
                                          .ledger = 777,
                                          .code = 2,
                                          .flags = 0,
                                          .timestamp = 0};
  accounts[1] = tigerbeetle::tb_account_t{.id = 2,
                                          .debits_pending = 0,
                                          .debits_posted = 0,
                                          .credits_pending = 0,
                                          .credits_posted = 0,
                                          .user_data_128 = 0,
                                          .user_data_64 = 0,
                                          .user_data_32 = 0,
                                          .reserved = 0,
                                          .ledger = 777,
                                          .code = 2,
                                          .flags = 0,
                                          .timestamp = 0};

  packet.operation = tigerbeetle::TB_OPERATION_CREATE_ACCOUNTS;
  packet.data = accounts.data();
  packet.data_size = sizeof(tigerbeetle::tb_account_t) * ACCOUNTS_LEN;
  packet.user_data = &ctx;
  packet.status = tigerbeetle::TB_PACKET_OK;

  fmt::print(""Creating accounts...\n"");
  client.send_request(packet, &ctx);

  if (packet.status != tigerbeetle::TB_PACKET_OK) {
    fmt::print(""Error calling create_accounts (ret={})\n"", packet.status);
    return EXIT_FAILURE;
  }

  if (ctx.size != 0) {
    std::span<const tigerbeetle::tb_create_accounts_result_t> results(
        reinterpret_cast<const tigerbeetle::tb_create_accounts_result_t *>(
            ctx.reply.data()),
        ctx.size / sizeof(tigerbeetle::tb_create_accounts_result_t));
    fmt::print(""create_account results:\n"");
    for (const auto &result : results) {
      fmt::print(""index={}, ret={}\n"", result.index,
                 static_cast<int>(result.result));
    }
    return EXIT_FAILURE;
  }

  fmt::print(""Accounts created successfully\n"");

  ////////////////////////////////////////////////////////////
  // Submitting multiple batches of transfers
  ////////////////////////////////////////////////////////////

  fmt::print(""Creating transfers...\n"");
  static constexpr auto MAX_BATCHES = 100;
  static constexpr auto TRANSFERS_PER_BATCH =
      tigerbeetle::MAX_MESSAGE_SIZE / sizeof(tigerbeetle::tb_transfer_t);
  long max_latency_ms = 0;
  long  [MASK]  = 0;

  for (int i = 0; i < MAX_BATCHES; ++i) {
    auto transfers = tigerbeetle::make_transfer<TRANSFERS_PER_BATCH>();

    // Initialize transfers using ranges, fixing lambda to modify in-place
    size_t baseID = i * TRANSFERS_PER_BATCH + 1;
    size_t j = 0;
    std::ranges::for_each(transfers, [&](auto &transfer) {
      transfer.id = baseID + j++;
      transfer.debit_account_id = accounts[0].id;
      transfer.credit_account_id = accounts[1].id;
      transfer.amount = 1;
      transfer.pending_id = 0;
      transfer.user_data_128 = 0;
      transfer.user_data_64 = 0;
      transfer.user_data_32 = 0;
      transfer.timeout = 0;
      transfer.ledger = 777;
      transfer.code = 2;
      transfer.flags = 0;
      transfer.timestamp = 0;
    });

    packet.operation = tigerbeetle::TB_OPERATION_CREATE_TRANSFERS;
    packet.data = transfers.data();
    packet.data_size = sizeof(tigerbeetle::tb_transfer_t) * TRANSFERS_PER_BATCH;
    packet.user_data = &ctx;
    packet.status = tigerbeetle::TB_PACKET_OK;

    auto start = std::chrono::steady_clock::now();
    client.send_request(packet, &ctx);
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                          std::chrono::steady_clock::now() - start)
                          .count();

    if (elapsed_ms > max_latency_ms)
      max_latency_ms = elapsed_ms;
     [MASK]  += elapsed_ms;

    if (packet.status != tigerbeetle::TB_PACKET_OK) {
      fmt::print(""Error calling create_transfers (ret={})\n"", packet.status);
      return EXIT_FAILURE;
    }

    if (ctx.size != 0) {
      std::span<const tigerbeetle::tb_create_transfers_result_t> results(
          reinterpret_cast<const tigerbeetle::tb_create_transfers_result_t *>(
              ctx.reply.data()),
          ctx.size / sizeof(tigerbeetle::tb_create_transfers_result_t));
      fmt::print(""create_transfers results:\n"");
      for (const auto &result : results) {
        fmt::print(""index={}, ret={}\n"", result.index,
                   static_cast<int>(result.result));
      }
      return EXIT_FAILURE;
    }
  }

  fmt::print(""Transfers created successfully\n"");
  fmt::print(""============================================\n"");
  fmt::print(""{} transfers per second\n"",
             (MAX_BATCHES * TRANSFERS_PER_BATCH * 1000) /  [MASK] );
  fmt::print(""create_transfers max p100 latency per {} transfers = {}ms\n"",
             TRANSFERS_PER_BATCH, max_latency_ms);
  fmt::print(""total {} transfers in {}ms\n"", MAX_BATCHES * TRANSFERS_PER_BATCH,
              [MASK] );
  fmt::print(""\n"");

  ////////////////////////////////////////////////////////////
  // Looking up accounts
  ////////////////////////////////////////////////////////////

  fmt::print(""Looking up accounts ...\n"");
  std::array<tigerbeetle::tb_uint128_t, ACCOUNTS_LEN> ids = {accounts[0].id,
                                                             accounts[1].id};

  packet.operation = tigerbeetle::TB_OPERATION_LOOKUP_ACCOUNTS;
  packet.data = ids.data();
  packet.data_size = sizeof(tigerbeetle::tb_uint128_t) * ACCOUNTS_LEN;
  packet.user_data = &ctx;
  packet.status = tigerbeetle::TB_PACKET_OK;

  client.send_request(packet, &ctx);

  if (packet.status != tigerbeetle::TB_PACKET_OK) {
    fmt::print(""Error calling lookup_accounts (ret={})\n"", packet.status);
    return EXIT_FAILURE;
  }

  if (ctx.size == 0) {
    fmt::print(""No accounts found\n"");
    return EXIT_FAILURE;
  } else {
    std::span<const tigerbeetle::tb_account_t> results(
        reinterpret_cast<const tigerbeetle::tb_account_t *>(ctx.reply.data()),
        ctx.size / sizeof(tigerbeetle::tb_account_t));
    fmt::print(""{} Account(s) found\n"", results.size());
    fmt::print(""============================================\n"");

    std::ranges::for_each(results, [](const auto &result) {
      fmt::print(""id={}\n"", static_cast<std::size_t>(result.id));
      fmt::print(""debits_posted={}\n"", result.debits_posted);
      fmt::print(""credits_posted={}\n"", result.credits_posted);
    });
  }

  return EXIT_SUCCESS;
}",total_time_ms
766,"#pragma region Includes

// Application configuration.
#include ""Configuration.h""

// DHT library for DHT11 sensor.
#include <DHT.h>

// LCD library for interacting with a screen.
#include <LiquidCrystal_I2C.h>

#pragma endregion

#pragma region Variables

DHT dht(DHT_PIN, DHT_TYPE);

LiquidCrystal_I2C lcd(LCD_I2C_ADDRESS, LCD_COLUMNS, LCD_ROWS);

#pragma endregion

#pragma region Core Functions

/*
 * @brief Ran once at startup.
 */
void setup() {

	// Start the DHT sensor.
	dht.begin();

	// Initialize the LCD.
	lcd.init();
	

	// Configure PIR input.
#ifdef USE_PI

	pinMode(PIR_PIN, INPUT);

#else

	lcd.backlight();

#endif


	// Set static text on LCD.
#ifdef DISPLAY_TEMPERATURE

	lcd.setCursor(0, TEMPERATURE_LCD_ROW);
	lcd.print(""Temperature:"");

#endif

#ifdef DISPLAY_RELATIVE_HUMIDITY

	lcd.setCursor(0, RELATIVE_HUMIDITY_LCD_ROW);
	lcd.print(""Rel. humidity:"");

#endif

#if defined(DISPLAY_ABSOLUTE_HUMIDITY) && defined(DISPLAY_TEMPERATURE) && defined(DISPLAY_RELATIVE_HUMIDITY)

	lcd.setCursor(0, ABSOLUTE_HUMIDITY_LCD_ROW);
	lcd.print(""Abs. humidity:"");

#endif
}

unsigned long nextHygroReading_Millis;

/*
 * @brief Runs continuously.
 */
void loop() {

#ifdef USE_PIR

	if (digitalRead(PIR_PIN) == HIGH)
		lcd.backlight();

	else
		lcd.noBacklight();

#endif

	unsigned long now = millis();

	if (now < nextHygroReading_Millis)
		return;

#ifdef DISPLAY_TEMPERATURE

	float temperature = displayTemperature(13, TEMPERATURE_LCD_ROW);

#endif

#ifdef DISPLAY_RELATIVE_HUMIDITY

	uint8_t relativeHumidity = displayRelativeHumidity(15, RELATIVE_HUMIDITY_LCD_ROW);

#endif

#if defined(DISPLAY_ABSOLUTE_HUMIDITY) && defined(DISPLAY_TEMPERATURE) && defined(DISPLAY_RELATIVE_HUMIDITY)

	displayAbsoluteHumidity(15, ABSOLUTE_HUMIDITY_LCD_ROW, relativeHumidity, temperature);

#endif

	nextHygroReading_Millis = now + HYGRO_READING_INTERVAL_MILLIS;
}

#pragma endregion

#pragma region Value Displaying Functions

/*
 * @brief Calculates and displays the latest absolute humidity reading on the LCD.
 * @param column The starting column for printing values.
 * @param row The row to print values on.
 * @param relativeHumidity The latest relative humidity reading.
 * @param temperature_X10 The latest temperature reading.
 */
void displayAbsoluteHumidity(uint8_t column, uint8_t row, uint8_t relativeHumidity, float temperature) {

	// Absolute humidity can't be calculated without both values.
	if (isnan(relativeHumidity) || isnan(temperature))
		return;

	// Formula for calculating absolute humidity sourced from:
	// https://carnotcycle.wordpress.com/2012/08/04/how-to-convert-relative-humidity-to-absolute-humidity/
	
	// Absolute humidity calculated in grams/m^3.
	float absoluteHumidity = (6.112 * pow(2.71828, (17.67 * temperature) / (temperature + 243.5)) * (relativeHumidity / 100.0) * 2.1674) / (273.15 + temperature);

	// Separate the whole number from the decimals.
	uint8_t absoluteHumidity_Int = (uint8_t)absoluteHumidity;
	uint8_t absoluteHumidity_Decimals = (absoluteHumidity - absoluteHumidity_Int) * 100;

	lcd.setCursor(column, row);
	lcd.print(absoluteHumidity_Int);

	column += absoluteHumidity_Int >= 10 ? 2 : 1;

	lcd.setCursor(column, row);

	if (absoluteHumidity_Decimals != 0) {

		lcd.print(""."");

		column++;
		lcd.setCursor(column, row);

		if (absoluteHumidity_Decimals == 10)
			lcd.print(""1"");

		else {

			if (absoluteHumidity_Decimals < 10) {

				lcd.print(""0"");

				column++;

				lcd.setCursor(column, row);
			}

			lcd.print(absoluteHumidity_Decimals);
		}

		// If the absolute humidity only has one decimal place, it will be a multiple of 10 when multiplied by 100.
		column += absoluteHumidity_Decimals % 10 == 0 ? 1 : 2;

		lcd.setCursor(column, row);
	}

	// Clear the remaining columns.
	while (column < LCD_COLUMNS) {

		lcd.setCursor(column, row);
		lcd.print("" "");

		column++;
	}
}

/*
 * @brief Displays the latest relative humidity reading on the LCD.
 * @param column The starting column for printing values.
 * @param row The row to print values on.
 * @returns Returns the relative humidity reading.
 */
uint8_t displayRelativeHumidity(uint8_t column, uint8_t row) {

	uint8_t relativeHumidity = dht.readHumidity();

	if (isnan(relativeHumidity))
		return NAN;

	lcd.setCursor(column, row);
	lcd.print(relativeHumidity);

	// Increment the column by the character count of the value.
	// Relative humidity is shown as a percentage, so we only need to be concered with values 0 - 100.
	if (relativeHumidity == 100)
		column += 3;

	else if (relativeHumidity > 10)
		column += 2;

	else
		column++;

	lcd.setCursor(column, row);
	lcd.print(""%"");

	column++;

	// Clear the remaining columns.
	while (column < LCD_COLUMNS) {

		lcd.setCursor(column, row);
		lcd.print("" "");

		column++;
	}

	return relativeHumidity;
}

/*
 * @brief Displays the latest temperature reading on the LCD.
 * @param column The starting column for printing values.
 * @param row The row to print values on.
 * @returns Returns the temperature reading.
 */
float displayTemperature(uint8_t column, uint8_t row) {

	float temperature = dht.readTemperature();

	if (isnan(temperature))
		return NAN;

	// Get the original temperature with no decimals. We'll use this to separate the decimal value from the whole value.
	int16_t  [MASK]  = (int16_t)temperature;

	lcd.setCursor(column, row);
	lcd.print( [MASK] );

	// The next column will differ depending on the character count of the temperature reading. For example:
	// 0 - 9: one character;
	// -1 - -9, 10 - 99: two characters;
	// -10 - -99: three characters.
	// The DHT11 and DHT22 can't read high or low enough for triple digits, so we only need to be concerned with the above.
	if ( [MASK]  <= -10)
		column += 3;

	else if ( [MASK]  >= 10 ||  [MASK]  < 0)
		column += 2;

	else
		column++;

	lcd.setCursor(column, row);

	// Isolate the decimal value. The value must also be absolute, as we don't care whether it's negative at this point.
	uint8_t temperature_Decimal = abs(temperature -  [MASK] ) * 10;

	if (temperature_Decimal != 0) {

		lcd.print(""."");

		column++;

		lcd.setCursor(column, row);
		lcd.print(temperature_Decimal);

		column++;

		lcd.setCursor(column, row);
	}

	lcd.print((char)223);		// Prints the degree symbol.

	column++;

	lcd.setCursor(column, row);
	lcd.print(""C"");

	column++;

	// Clear the remaining columns.
	while (column < LCD_COLUMNS) {

		lcd.setCursor(column, row);
		lcd.print("" "");

		column++;
	}

	return temperature;
}

#pragma endregion
",temperature_Int
767,"#include <adbase/Config.hpp>

namespace adbase {
// {{{ bool IniConfig::hasSection()

bool IniConfig::hasSection(const std::string &sectionName) const {
    if (config.find(sectionName) == config.end()) {
        return false;
    }

    return true;
}

// }}}
// {{{ bool IniConfig::hasOption()

bool IniConfig::hasOption(const std::string &sectionName, const std::string &optionName) const {
    if (!hasSection(sectionName)) {
        return false;
    }
    std::map<std::string, std::string> options = config.at(sectionName);
    if (options.find(optionName) == options.end()) {
        return false;
    }

    return true;
}

// }}}
// {{{ std::string IniConfig::getOption()

std::string IniConfig::getOption(const std::string &sectionName, const std::string &optionName) const {
    validateOption(sectionName, optionName);

    return config.at(sectionName).at(optionName);
}

// }}}
// {{{ uint32_t IniConfig::getOptionUint32()

uint32_t IniConfig::getOptionUint32(const std::string &sectionName, const std::string &optionName) {
	std::string value = getOption(sectionName, optionName);

	errno = 0;
	uint32_t ivalue = static_cast<uint32_t>(strtoul(value.c_str(), nullptr, 10));
	if (errno != 0) {
		std::string msg = ""Section ("" + sectionName + ""), Option ("" + optionName + "") type is invalid"";
		throw InvalidOptionException(msg.c_str());
	}
    return ivalue;
}

// }}}
// {{{ uint64_t IniConfig::getOptionUint64()

uint64_t IniConfig::getOptionUint64(const std::string &sectionName, const std::string &optionName) {
	std::string value = getOption(sectionName, optionName);

	errno = 0;
	uint64_t ivalue = static_cast<uint64_t>(strtoull(value.c_str(), nullptr, 10));
	if (errno != 0) {
		std::string msg = ""Section ("" + sectionName + ""), Option ("" + optionName + "") type is invalid"";
		throw InvalidOptionException(msg.c_str());
	}
    return ivalue;
}

// }}}
// {{{ bool IniConfig::getOptionBool()

bool IniConfig::getOptionBool(const std::string &sectionName, const std::string &optionName) {
	std::string value = getOption(sectionName, optionName);
	if (value.compare(""yes"") == 0) {
		return true;
	} else {
		return false;
	}
}

// }}}
// {{{ std::vector<std::string> IniConfig::sections() const

std::vector<std::string> IniConfig::sections() const {
    std::vector<std::string> sections;
    std::map<std::string, std::map<std::string, std::string> >::const_iterator i = config.begin();
    for (; i != config.end(); ++i) {
        sections.push_back(i->first);
    }
    return sections;
}

// }}}
// {{{ std::vector<std::string> IniConfig::options()

std::vector<std::string> IniConfig::options(const std::string &sectionName) const {
    validateSection(sectionName);

    std::map<std::string, std::string> opts = config.at(sectionName);
    std::vector<std::string> options;
    std::map<std::string, std::string>::const_iterator i = opts.begin();
    for (; i != opts.end(); ++i) {
        options.push_back(i->first);
    }

    return options;
}

// }}}
// {{{ void IniConfig::setOption()

void IniConfig::setOption(const std::string &sectionName, const std::string &optionName, const std::string &optionValue) {
    validateOption(sectionName, optionName);

    std::map<std::string, std::string> &options = config[sectionName];
    options[optionName] = optionValue;
}

// }}}
// {{{ void IniConfig::removeSection()

void IniConfig::removeSection(const std::string &sectionName) {
    validateSection(sectionName);

    config.erase(sectionName);
}

// }}}
// {{{ void IniConfig::removeOption()

void IniConfig::removeOption(const std::string &sectionName, const std::string &optionName) {
    validateOption(sectionName, optionName);

    config[sectionName].erase(optionName);
}

// }}}
// {{{ void IniConfig::addSection()

void IniConfig::addSection(const std::string &sectionName) {
    if (hasSection(sectionName)) {
        std::string msg = ""Duplicate section ("" + sectionName + "") found"";
        throw DuplicateSectionException(msg.c_str());
    }

    std::map<std::string, std::string>  [MASK] ;
    config[sectionName] =  [MASK] ;
}

// }}}
// {{{ void IniConfig::addOption()

void IniConfig::addOption(const std::string &sectionName, const std::string &optionName, const std::string &optionValue) {
    validateSection(sectionName);

    std::map<std::string, std::string> &options = config[sectionName];
    if (hasOption(sectionName, optionName)) {
        std::string msg = ""Duplicate option ("" + optionName + "") found"";
        throw DuplicateOptionException(msg.c_str());
    }
    options[optionName] = optionValue;
}

// }}}
// {{{ void IniConfig::validateOption()

void IniConfig::validateOption(const std::string &sectionName, const std::string &optionName) const {
    if (!hasOption(sectionName, optionName)) {
        std::string msg = ""Section ("" + sectionName + ""), Option ("" + optionName + "") not found"";
        throw InvalidOptionException(msg.c_str());
    }
}

// }}}
// {{{ void IniConfig::validateSection()

void IniConfig::validateSection(const std::string &sectionName) const {
    if (!hasSection(sectionName)) {
        std::string msg = ""Section ("" + sectionName + "") not found"";
        throw InvalidSectionException(msg.c_str());
    }
}

// }}}
}

",emptyMap
768,"

//------------------ add_glitter() ---------------
void add_glitter()
{
  int chance_of_glitter =  10;        //percent of the time that we add glitter
  int number_of_glitters = 5;         //number of glitter sparkles to add

  int r = random8(100);
  if ( r < chance_of_glitter ) {
    for ( int j = 0; j < number_of_glitters; j++) {
      int pos = random16( NUM_LEDS);
      leds[pos] = glitterColor;        //very bright glitter
    }
  }
}


//----------------- top_glitter --------------
void top_glitter() {
  //Blink the top white at random
  static unsigned long  [MASK]  = 100ul;                //How long the top is white.
  unsigned int topInterval = random(10000ul);           //How long between blinks
  static int i = random8(TOP_NUM_LEDS);

  //White end?
  if (millis() - endTime >  [MASK]  and state == 0) {
    //Yes, set all to topColor
    for (int i = 0; i < TOP_NUM_LEDS; i++) {
      topper[i] = topColor;
    }
    FastLED.show();
    endTime = millis();
    state = 1;
  }

  //Time for another blink?
  if (millis() - endTime > topInterval and state == 1) {
    endTime = millis();
    i = random8(TOP_NUM_LEDS);                                    //Random LED
    topper[i] = glitterColor;
    FastLED.show();
    state = 0;
  }
}
",whiteTime
769,"#define /*PORT_NAME*/_NB_SOFT_TIMER /*NB_SOFT_TIMER*/
uint32_t /*PORT_NAME*/_timer[/*PORT_NAME*/_NB_SOFT_TIMER];
uint32_t  /*PORT_NAME*/_prev_1sec = 0;

/*FLAGS*/

void externalMessageEnqueue(uint8_t * msg, uint8_t msgSize, uint16_t listener_id);

/*INTERRUPT_COUNTER*/
/*INTERRUPT_VECTOR*/

//struct /*PORT_NAME*/_instance_type {
//    uint16_t listener_id;
//    /*INSTANCE_INFORMATION*/
//} /*PORT_NAME*/_instance;

struct /*PORT_NAME*/_instance_type /*PORT_NAME*/_instance;


void /*PORT_NAME*/_setup() {
	/*INITIALIZATION*/

	/*PORT_NAME*/_prev_1sec = millis() + 1000;
}

void /*PORT_NAME*/_set_listener_id(uint16_t id) {
	/*PORT_NAME*/_instance.listener_id = id;
}

/*INSTRUCTIONS*/



void /*PORT_NAME*/_read() {
    uint32_t  [MASK]  = millis();
    /*POLL*/
    if (/*PORT_NAME*/_prev_1sec <  [MASK] ) {
        /*PORT_NAME*/_prev_1sec += 1000;
    }
    /*FLAGS_HANDLING*/
}
",tms
770,"#include <chrono>

#include ""benchmark/benchmark.h""

#include ""pp.h""
#include ""generate.h""
#include ""min_max.h""



template<typename T, template<typename> class Src, template<typename> class MinMax>
static void BM_MinMax(benchmark::State& state)
{
    size_t size = state.range(0);
    std::vector<T>  [MASK]  = Src<T>::generate(size);

    double elapsed_total = 0.0;
    size_t items_total = 0;

    Stats<T> tmp;

    for (auto _ : state) {
        StatsConsumer<T, MinMax> consumer;

        auto started = std::chrono::high_resolution_clock::now();
        consumer.consume( [MASK] );
        auto finished = std::chrono::high_resolution_clock::now();

        benchmark::DoNotOptimize(tmp = consumer.stats);

        double elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(finished - started).count();
        state.SetIterationTime(elapsed);

        elapsed_total += elapsed;
        items_total +=  [MASK] .size();
    }

    state.counters[""items/s""] = double(items_total) / elapsed_total;
    state.counters[""bytes/s""] = double(items_total) * sizeof(T) / elapsed_total;
    state.counters[""ns/item""] = elapsed_total * 1000'000'000 / items_total;
}

/*
 * We have 4 sources, 4 int types, 2 float types, 6 int minmax functions, 4 float minmax functions.
 * To cover all combinations need to call
 *     BENCHMARK_TEMPLATE(BM_MinMax, <TYPE>, <SOURCE>, <MINMAX>)
 * 4*4*6 + 4*2*4 = 128 times.
 * Let's use some Boost preprocessor magic for that.
 */

#define INT_TYPES (uint32_t, int32_t, uint64_t, int64_t)
#define FLOAT_TYPES (double, float)
#define SOURCES (Falling, Growing, Constant, Random)
#define INT_MINMAX (Ternary, StdRangeMinMax, Std, StdMinMax, XorAnd, SubsShift, Abs)
#define FLOAT_MINMAX (Ternary, StdRangeMinMax, Std, StdMinMax, Abs)


static const int64_t min_vector_size = 100;
static const int64_t max_vector_size = 100'000;
static const int64_t range_multiplier = 10;

#define BM_MIN_MAX(TYPE_ARG, SOURCE_ARG, MINMAX_ARG) \
    BENCHMARK_TEMPLATE(BM_MinMax, TYPE_ARG, SOURCE_ARG, MINMAX_ARG) \
    ->UseManualTime() \
    ->RangeMultiplier(range_multiplier) \
    ->Range(min_vector_size, max_vector_size)


#define CALL_BM_MIN_MAX(r, SEQ) APPLY_SEQ(BM_MIN_MAX, SEQ)

APPLY_PRODUCT(CALL_BM_MIN_MAX, FLOAT_TYPES, SOURCES, FLOAT_MINMAX);
APPLY_PRODUCT(CALL_BM_MIN_MAX, INT_TYPES, SOURCES, INT_MINMAX);


BENCHMARK_MAIN();
",values
771,"#include ""ESP32_ping.hpp""


void setup () {
    Serial.begin (115200);
    while (!Serial) 
        delay (10);
    delay (1000);

    WiFi.begin (""YourSSID"",""YourPassword""); // use your WiFi credentials

    Serial.print (""\nConnecting "");
    while (WiFi.status () != WL_CONNECTED) {
        delay (500);
        Serial.print (""."");
    }
    Serial.print (""\nConnected, STAtion IP: "");
    Serial.print (WiFi.localIP ());
    Serial.print("", router's IP: "");
    Serial.println (WiFi.gatewayIP ());


    // example 1: simple router pinging
    Serial.println ();
    esp32_ping simplePing;

    Serial.printf (""Please wait ...\n"");
    simplePing.ping (WiFi.gatewayIP ().toString ().c_str ());
    if (simplePing.errText () != NULL) {
        Serial.printf (""Error %%\n"", simplePing.errText ());
    } else {
        Serial.printf (""Ping statistics for %s:\n""
                      ""    Packets: Sent = %i, Received = %i, Lost = %i"", simplePing.target (), simplePing.sent (), simplePing.received (), simplePing.lost ());
        if (simplePing.sent ()) {
            Serial.printf ("" (%.2f%% loss)\nRound trip:\n""
                          ""   Min = %.3fms, Max = %.3fms, Avg = %.3fms, Stdev = %.3fms\n"", (float) simplePing.lost () / (float) simplePing.sent () * 100, simplePing.min_time (), simplePing.max_time (), simplePing.mean_time (), sqrt (simplePing.var_time () / simplePing.received ()));
        } else {
            Serial.printf (""\n"");
        }
    }


    // example 2: ping and capture intermentidate results by overloading onReceive function
    Serial.println ();
    class capture_ping : public esp32_ping {
        void onReceive (int bytes) {
            if (elapsed_time ())
                Serial.printf (""Reply from %s: bytes = %i time = %.3fms\n"", target (), size (), elapsed_time ());
            else
                Serial.printf (""Reply from %s: time-out\n"", target ());
        }
    };
    capture_ping  [MASK] ;

     [MASK] .ping (""github.com"");
    if ( [MASK] .errText () != NULL) {
        Serial.printf (""Error %%\n"",  [MASK] .errText ());
    } else {
        Serial.printf (""Ping statistics for %s:\n""
                      ""    Packets: Sent = %i, Received = %i, Lost = %i"",  [MASK] .target (),  [MASK] .sent (),  [MASK] .received (),  [MASK] .lost ());
        if ( [MASK] .sent()) {
            Serial.printf ("" (%.2f%% loss)\nRound trip:\n""
                          ""   Min = %.3fms, Max = %.3fms, Avg = %.3fms, Stdev = %.3fms\n"", (float)  [MASK] .lost () / (float)  [MASK] .sent () * 100,  [MASK] .min_time (),  [MASK] .max_time (),  [MASK] .mean_time (), sqrt ( [MASK] .var_time () /  [MASK] .received ()));
        } else {
            Serial.printf (""\n"");
        }
    }


    // example 3: simultaneous pinging from different tasks
    Serial.println ();
    capture_ping githubPing;

                xTaskCreate ([] (void *param)  {
                    delay (3500);
                    capture_ping routerPing;
                    routerPing.ping (WiFi.gatewayIP ().toString ().c_str (), 10);
                    if (routerPing.errText () != NULL) {
                        Serial.printf (""%s\n"", routerPing.errText ());
                    } else {
                        Serial.printf (""Ping statistics for %s:\n""
                                      ""    Packets: Sent = %i, Received = %i, Lost = %i"", routerPing.target (), routerPing.sent (), routerPing.received (), routerPing.lost ());
                        if (routerPing.sent()) {
                            Serial.printf ("" (%.2f%% loss)\nRound trip:\n""
                                          ""   Min = %.3fms, Max = %.3fms, Avg = %.3fms, Stdev = %.3fms\n"", (float) routerPing.lost () / (float) routerPing.sent () * 100, routerPing.min_time (), routerPing.max_time (), routerPing.mean_time (), sqrt (routerPing.var_time () / routerPing.received ()));
                        } else {
                            Serial.printf (""\n"");
                        }
                    }
                    vTaskDelete (NULL);
                }, 
                ""ping_task"", 4068, NULL, 1, NULL);


    githubPing.ping (""github.com"", 10);
    if (githubPing.errText () != NULL) {
        Serial.printf (""Error %%\n"", githubPing.errText ());
    } else {
        Serial.printf (""Ping statistics for %s:\n""
                      ""    Packets: Sent = %i, Received = %i, Lost = %i"", githubPing.target (), githubPing.sent (), githubPing.received (), githubPing.lost ());
        if (githubPing.sent ()) {
            Serial.printf ("" (%.2f%% loss)\nRound trip:\n""
                          ""   Min = %.3fms, Max = %.3fms, Avg = %.3fms, Stdev = %.3fms\n"", (float) githubPing.lost () / (float) githubPing.sent () * 100, githubPing.min_time (), githubPing.max_time (), githubPing.mean_time (), sqrt (githubPing.var_time () / githubPing.received ()));
        } else {
            Serial.printf (""\n"");
        }
    }

}

void loop () {
  
}
",capturePing
772,"//
// Created by apgra on 8/31/2023.
//

#include ""Application.h""
#include ""BoxParticle.h""
#include ""World.h""
#include ""Random.h""

#include <stdexcept>
#include <iostream>
#include <glm/gtx/string_cast.hpp>

#include <imgui.h>
#include <imgui_impl_glfw.h>
#include <imgui_impl_opengl3.h>


std::unique_ptr<Camera> camera;

float deltaTime = 0.0f;
float lastFrame = 0.0f;

glm::vec3 color = glm::vec3(1.0f);

//Toggles
bool clickToPlaceParticle = false;



void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods);
void mouse_button_callback(GLFWwindow* window, int button, int action, int mods);
void window_resize_callback(GLFWwindow* window, int width, int height);




Application::Application(const char *title, int width, int height) : m_Title(title), WindowSize(width, height) {
    setupWindow();
}

void Application::setupWindow() {
    glfwInit();

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    m_Window = glfwCreateWindow(WindowSize.x, WindowSize.y, m_Title, nullptr, nullptr);
    glfwSetWindowUserPointer(m_Window, this);

    if(!m_Window){
        glfwTerminate();
        throw std::runtime_error(""ERROR: Failed to create GLFW window"");
    }
    glfwMakeContextCurrent(m_Window);


    if(!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress)){
        throw std::runtime_error(""ERROR: Failed to initialize GLAD"");
    }
}

void Application::Run() {
    camera = std::make_unique<Camera>(glm::vec3(0.0f, 0.0f, 10.0f), WindowSize.x, WindowSize.y);

    //GLFW Callbacks
    glfwSetKeyCallback(m_Window, key_callback);
    glfwSetMouseButtonCallback(m_Window, mouse_button_callback);
    glfwSetWindowSizeCallback(m_Window, window_resize_callback);



    //Setup IMGUI
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO &io = ImGui::GetIO(); (void)io;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;

    ImGui::StyleColorsDark();

    const char* glsl_version = ""#version 460"";
    ImGui_ImplGlfw_InitForOpenGL(m_Window, true);
    ImGui_ImplOpenGL3_Init(glsl_version);

    //Create Barriers
    World::getInstance()->createBarrier(
            {0.0f, WindowSize.y / 2},
            {WindowSize.x, 2.0f}
            );


    glViewport(0, 0, WindowSize.x, WindowSize.y);
    while(!glfwWindowShouldClose(m_Window)){
        glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        processInput();

        //Update Particles
        World::getInstance()->update(deltaTime);

        //Render scene
        ParticleDrawer::getInstance()->drawBarriers(camera->viewProjection(), World::getInstance()->GetBarriers());
        ParticleDrawer::getInstance()->drawParticles(camera->viewProjection(), World::getInstance()->GetBoxParticles());


        //Draw ImGui Windows
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();


        ImGui::Begin(""Config Window"");
        onImGUIRender();



        ImGui::End();
        ImGui::Render();
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        World::getInstance()->update(deltaTime);


        float currentFrame = static_cast<float>(glfwGetTime());
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        glfwSwapBuffers(m_Window);
        glfwPollEvents();
    }

    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();
}


void Application::onImGUIRender() {
    if(ImGui::Button(""Clear particles"")){
        World::getInstance()->clearParticles();
    }

    ImGui::Checkbox(""Click To Place"", &clickToPlaceParticle);

    if(ImGui::CollapsingHeader(""Particle Configs"")){
        ImGui::Indent();
        ImGui::Checkbox(""Gravity"", &particleConfig.hasGravity);
        ImGui::SliderFloat2(""Size"", &particleConfig.size.x, 0.5f, 10);
        ImGui::SliderFloat2(""Velocity"", &particleConfig.velocity.x, -10, 10);
        ImGui::SliderFloat2(""Velocity Variation"", &particleConfig.velocityVariation.x, -2.0f, 2.0f);
    }

    if(ImGui::CollapsingHeader(""Manual Particle Config"")){
        ImGui::Indent();
        if (ImGui::Button(""Create Particle"")) {
            World::getInstance()->createBoxParticle();
        }


        auto& boxParticles = World::getInstance()->GetBoxParticles();
        for(int i = 0; i < boxParticles.size(); i++){
            if(ImGui::CollapsingHeader((""Particle #"" + std::to_string(i)).c_str())){
                ImGui::Indent();
                ImGui::SliderFloat2(""position"", &boxParticles[i].rigidBody->position.x, -10.0f, 10.0f);
                ImGui::SliderFloat2(""Velocity"", &boxParticles[i].rigidBody->velocity.x, -2.0f, 2.0f);
            }
        }
    }

    if(ImGui::CollapsingHeader(""Particle Line"")){
        ImGui::SliderInt(""Length"", &lineConfig.length, 1, 50);
        ImGui::SliderInt2(""position"", &lineConfig.pos.x, -10, 10);
        ImGui::Checkbox(""Vertical"", &lineConfig.isVertical);


        if(ImGui::Button(""Create Line"")){
            CreateLine();
        }
    }

    if(ImGui::CollapsingHeader(""Particle Grid"")){
        ImGui::SliderInt2(""Size"", &gridConfig.size.x, 1, 50);
        ImGui::SliderInt2(""Position"", &lineConfig.pos.x, -10, 10);

        if(ImGui::Button(""Create Grid"")){
            CreateGrid();
        }
    }


}
void Application::CreateLine() {
    AABB aabb(-particleConfig.size / glm::vec2(2.0f), particleConfig.size / glm::vec2(2.0f));


    for(int i = -lineConfig.length / 2; i < lineConfig.length / 2; i++){
        glm::vec2 position = {(i + lineConfig.pos.x) * particleConfig.size.x, lineConfig.pos.y * particleConfig.size.y};

        if(lineConfig.isVertical){
            position = {lineConfig.pos.x, i + lineConfig.pos.y};
        }

        World::getInstance()->createBoxParticle(1.0f, particleConfig.size, position, glm::vec2(0.0f));
    }
}

void Application::CreateGrid() {
    AABB aabb(-particleConfig.size / glm::vec2(2.0f), particleConfig.size / glm::vec2(2.0f));


    for(int y = -gridConfig.size.y / 2; y < gridConfig.size.y / 2; y++) {
        for (int x = -gridConfig.size.x / 2; x < gridConfig.size.x / 2; x++) {
            glm::vec2 position = {(x + lineConfig.pos.x) * particleConfig.size.x, (y + lineConfig.pos.y) * particleConfig.size.y};

            World::getInstance()->createBoxParticle(1.0f, particleConfig.size, position, glm::vec2(0.0f));
        }
    }
}

void Application::updateWindowSize(int width, int height) {
    WindowSize.x = width;
    WindowSize.y = height;
}

glm::vec2 screenSpaceToWorldSpace(glm::vec2  [MASK] , glm::mat4 viewProj, glm::vec2 windowSize){
    glm::mat4 invViewProj = glm::mat4(1.0f) / viewProj;
    glm::vec4 In = {
            2.0f * ( [MASK] .x / windowSize.x) - 1.0f,
            1.0f - (2.0f *  [MASK] .y / windowSize.y),
            0.0f,
            1.0f
    };

    auto pos = In * invViewProj;

    pos.w = 1 / pos.w;

    pos.x *= pos.w;
    pos.y *= pos.w;
    pos.z *= pos.w;

    return pos;
}



void Application::processInput(){
    if (glfwGetKey(m_Window, GLFW_KEY_A)){
        color -= glm::vec3(1.0f, 1.0f, 0.0f);
        camera->move(Left, deltaTime);
    }

    if (glfwGetKey(m_Window, GLFW_KEY_D)){
        color += glm::vec3(1.0f, 0.0f, 1.0f);
        camera->move(Right, deltaTime);
    }

    if (glfwGetKey(m_Window, GLFW_KEY_S)){
        camera->move(Down, deltaTime);
    }

    if (glfwGetKey(m_Window, GLFW_KEY_W)){
        camera->move(Up, deltaTime);
    }

    if (glfwGetKey(m_Window, GLFW_KEY_LEFT_CONTROL)){
        camera->move(Back, deltaTime);
    }

    if (glfwGetKey(m_Window, GLFW_KEY_LEFT_SHIFT)){
        camera->move(Forward, deltaTime);
    }    
}

//Callbacks
void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods) {
    if(key == GLFW_KEY_ESCAPE && action == GLFW_PRESS){
        glfwSetWindowShouldClose(window, true);
    }
}

void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
{
    if(clickToPlaceParticle && button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS)
    {
        double xpos, ypos;
        //getting cursor position
        glfwGetCursorPos(window, &xpos, &ypos);
        glm::vec2 worldCoord = screenSpaceToWorldSpace({xpos, ypos}, camera->viewProjection(), {1280, 720});

        World::getInstance()->createBoxParticle(1.0f, glm::vec2(1.0f), worldCoord, glm::vec2(0.0f));
    }
}

void window_resize_callback(GLFWwindow* window, int width, int height){
    Application* app = (Application*)(glfwGetWindowUserPointer(window));

    glViewport(0, 0, width, height);
    app->updateWindowSize(width, height);
}
",screenCoords
773,"/* 
   <NAME>, 22 janvier 2016
   
   An Http endpoint
*/

#pragma once

#include <pistache/listener.h>
#include <pistache/net.h>
#include <pistache/http.h>

namespace Pistache {
namespace Http {

class Endpoint {
public:
    struct Options {
        friend class Endpoint;

        Options& threads(int val);
        Options& flags(Flags<Tcp::Options> flags);
        Options& backlog(int val);

    private:
        int threads_;
        Flags<Tcp::Options> flags_;
        int backlog_;
        Options();
    };
    Endpoint();
    Endpoint(const Address& addr);

    template<typename... Args>
    void initArgs(Args&& ...args) {
        listener.init(std::forward<Args>(args)...);
    }

    void init(const Options& options);
    void setHandler(const std::shared_ptr<Handler>& handler);

    void bind();
    void bind(const Address& addr);

    void serve();
    void serveThreaded();

    void shutdown();

    bool isBound() const {
        return listener.isBound();
    }

    Async::Promise<Tcp::Listener::Load> requestLoad(const Tcp::Listener::Load& old);

    static Options options();

private:

    template<typename Method>
    void serveImpl(Method  [MASK] )
    {
#define CALL_MEMBER_FN(obj, pmf)  ((obj).*(pmf))
        if (!handler_)
            throw std::runtime_error(""Must call setHandler() prior to serve()"");

        listener.setHandler(handler_);

        if (listener.bind()) {
            const auto& addr = listener.address();
            CALL_MEMBER_FN(listener,  [MASK] )();
        }
#undef CALL_MEMBER_FN
    }

    std::shared_ptr<Handler> handler_;
    Tcp::Listener listener;
};

template<typename Handler>
void listenAndServe(Address addr)
{
    auto options = Endpoint::options().threads(1);
    listenAndServe<Handler>(addr, options);
}

template<typename Handler>
void listenAndServe(Address addr, const Endpoint::Options& options)
{
    Endpoint endpoint(addr);
    endpoint.init(options);
    endpoint.setHandler(make_handler<Handler>());
    endpoint.serve();
}


} // namespace Http
} // namespace Pistache
",method
774,"//  Copyright (c) 2021-23, VMware Inc, and the Certifier 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 <gtest/gtest.h>
#include <gflags/gflags.h>

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <openssl/ssl.h>
#include <openssl/rsa.h>
#include <openssl/x509.h>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/hmac.h>
#include <openssl/err.h>

#include <fstream>      // For std::ifstream and std::ofstream
#include <stdexcept>    // For std::exception
#include <cstdlib>      // For system()
#include <string>
#include <exception>

#include ""certifier_framework.h""
#include ""certifier_utilities.h""
#include ""certifier_algorithms.h""

// #include ""bioinformatics.pb.h""
// #include <google/protobuf/text_format.h>

using namespace certifier::framework;
using namespace certifier::utilities;
// using certifier::bioinformatics::BioinformaticsRequest;
// using certifier::bioinformatics::BioinformaticsResponse;

// Ops are: cold-init, get-certified, run-app-as-client, run-app-as-server
DEFINE_bool(print_all, false, ""verbose"");
DEFINE_string(operation, """", ""operation"");

DEFINE_string(policy_host, ""localhost"", ""address for policy server"");
DEFINE_int32(policy_port, 8123, ""port for policy server"");
DEFINE_string(data_dir, ""./app1_data/"", ""directory for application data"");

DEFINE_string(server_app_host, ""localhost"", ""address for app server"");
DEFINE_int32(server_app_port, 8124, ""port for server app server"");

DEFINE_string(policy_store_file, ""store.bin"", ""policy store file name"");

#ifdef SIMPLE_APP
DEFINE_string(platform_file_name, ""platform_file.bin"", ""platform certificate"");
DEFINE_string(platform_attest_endorsement,
              ""platform_attest_endorsement.bin"",
              ""platform endorsement of attest key"");
DEFINE_string(attest_key_file, ""attest_key_file.bin"", ""attest key"");
DEFINE_string(measurement_file, ""example_app.measurement"", ""measurement"");

DEFINE_string(public_key_alg, Enc_method_rsa_2048, ""public key algorithm"");
DEFINE_string(auth_symmetric_key_alg,
              Enc_method_aes_256_cbc_hmac_sha256,
              ""authenticated symmetric key algorithm"");

DEFINE_string(analysis_type, ""sequence_quality"", ""Type of analysis to perform"");
DEFINE_string(repository_url, """", ""URL of data repository"");
DEFINE_string(dataset_name, ""example.fastq"", ""Name of dataset to analyze"");
DEFINE_string(parameters, ""--quiet --threads 2"", ""Analysis parameters"");

static string enclave_type(""simulated-enclave"");

// Helper function to read file contents
std::string read_file_contents(const std::string& file_path) {
    std::ifstream file(file_path, std::ios::binary);
    if (!file.is_open()) {
        return """";
    }
    return std::string((std::istreambuf_iterator<char>(file)), 
                      std::istreambuf_iterator<char>());
}

bool perform_bioinformatics_analysis(const string& analysis_type,
                                   const string& input_file,
                                   const string& parameters,
                                   string* result_output,
                                   string* error_msg) {
    try {
        // Create unique temp directory for results
        string work_dir = ""/tmp/bio_fasta"";
        mkdir(work_dir.c_str(), 0777);
        
        string command;
        if (analysis_type == ""sequence_quality"") {
            command = ""fastqc "" + input_file + "" "" + parameters + "" -o "" + work_dir + "" 2>&1"";
        } else {
            *error_msg = ""Unsupported analysis type: "" + analysis_type;
            return false;
        }

        printf(""Executing: %s\n"", command.c_str());
        
        // Execute and show real-time output
        FILE* pipe = popen(command.c_str(), ""r"");
        if (!pipe) {
            *error_msg = ""Failed to execute analysis command"";
            return false;
        }

        char buffer[128];
        while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
            printf(""%s"", buffer);  // Print output in real-time
        }
        
        int ret = pclose(pipe);
        if (ret != 0) {
            *error_msg = ""Analysis failed with exit code "" + std::to_string(ret);
            return false;
        }

        // Get results file path
        string output_file = work_dir + ""/"" + 
                          input_file.substr(input_file.find_last_of(""/\\"") + 1) + 
                          ""_fastqc.html"";
                          
        *result_output = read_file_contents(output_file);
        // if (result_output->empty()) {
        //     *error_msg = ""No results generated in "" + output_file;
        //     return false;
        // }

        printf(""\nResults saved to: %s\n"", output_file.c_str());
        return true;
    } catch (const std::exception& e) {
        *error_msg = string(""Exception: "") + e.what();
        return false;
    }
}


// Parameters for simulated enclave
bool get_enclave_parameters(string **s, int *n) {

  // serialized attest key, measurement, serialized endorsement, in that order
  string *args = new string[3];
  if (args == nullptr) {
    return false;
  }
  *s = args;

  if (!read_file_into_string(FLAGS_data_dir + FLAGS_attest_key_file,
                             &args[0])) {
    printf(""%s() error, line %d, Can't read attest file\n"", __func__, __LINE__);
    goto err;
  }

  if (!read_file_into_string(FLAGS_data_dir + FLAGS_measurement_file,
                             &args[1])) {
    printf(""%s() error, line %d, Can't read measurement file\n"",
           __func__,
           __LINE__);
    goto err;
  }

  if (!read_file_into_string(FLAGS_data_dir + FLAGS_platform_attest_endorsement,
                             &args[2])) {
    printf(""%s() error, line %d, Can't read endorsement file\n"",
           __func__,
           __LINE__);
    goto err;
  }

  *n = 3;
  return true;

err:
  delete[] args;
  *s = nullptr;
  return false;
}
#endif  // SIMPLE_APP

#ifdef GRAMINE_SIMPLE_APP
DEFINE_string(gramine_cert_file, ""sgx.cert.der"", ""certificate file name"");

static string enclave_type(""gramine-enclave"");

// Parameters for gramine enclave
bool get_enclave_parameters(string **s, int *n) {

  string *args = new string[1];
  if (args == nullptr) {
    return false;
  }
  *s = args;

  if (!read_file_into_string(FLAGS_data_dir + FLAGS_gramine_cert_file,
                             &args[0])) {
    printf(""%s() error, line %d, Can't read cert cert file\n"",
           __func__,
           __LINE__);
    delete[] args;
    *s = nullptr;
    return false;
  }

  *n = 1;
  return true;
}
#endif  // GRAMINE_SIMPLE_APP

#ifdef SEV_SIMPLE_APP
DEFINE_string(ark_cert_file, ""ark_cert.der"", ""ark cert file name"");
DEFINE_string(ask_cert_file, ""ask_cert.der"", ""ask cert file name"");
DEFINE_string(vcek_cert_file, ""vcek_cert.der"", ""vcek cert file name"");

static string enclave_type(""sev-enclave"");

// Parameters for sev enclave for now.
// We will switch to using extended guest requests in the future.
bool get_enclave_parameters(string **s, int *n) {

  // ark cert file, ask cert file, vcek cert file
  string *args = new string[3];
  if (args == nullptr) {
    return false;
  }
  *s = args;

  if (!read_file_into_string(FLAGS_data_dir + FLAGS_ark_cert_file, &args[0])) {
    printf(""%s() error, line %d, Can't read attest file\n"", __func__, __LINE__);
    goto err;
  }

  if (!read_file_into_string(FLAGS_data_dir + FLAGS_ask_cert_file, &args[1])) {
    printf(""%s() error, line %d, Can't read measurement file\n"",
           __func__,
           __LINE__);
    goto err;
  }

  if (!read_file_into_string(FLAGS_data_dir + FLAGS_vcek_cert_file, &args[2])) {
    printf(""%s() error, line %d, Can't read endorsement file\n"",
           __func__,
           __LINE__);
    goto err;
  }

  *n = 3;
  return true;

err:
  delete[] args;
  *s = nullptr;
  return false;
}
#endif  // SEV_SIMPLE_APP

#ifdef ISLET_SIMPLE_APP
DEFINE_string(platform_file_name, ""platform_file.bin"", ""platform certificate"");
DEFINE_string(platform_attest_endorsement,
              ""platform_attest_endorsement.bin"",
              ""platform endorsement of attest key"");
DEFINE_string(attest_key_file, ""attest_key_file.bin"", ""attest key"");
DEFINE_string(measurement_file, ""example_app.measurement"", ""measurement"");

static string enclave_type(""islet-enclave"");

// Parameters not needed for ISLET enclave
bool get_enclave_parameters(string **s, int *n) {
  *s = nullptr;
  *n = 0;
  return true;
}
#endif  // ISLET_SIMPLE_APP

#ifdef KEYSTONE_SIMPLE_APP
DEFINE_string(platform_file_name, ""platform_file.bin"", ""platform certificate"");
DEFINE_string(platform_attest_endorsement,
              ""platform_attest_endorsement.bin"",
              ""platform endorsement of attest key"");
DEFINE_string(attest_key_file, ""attest_key_file.bin"", ""attest key"");
DEFINE_string(measurement_file, ""example_app.measurement"", ""measurement"");

static string enclave_type(""keystone-enclave"");

// Parameters not needed for Keystone enclave
bool get_enclave_parameters(string **s, int *n) {
  *s = nullptr;
  *n = 0;
  return true;
}
#endif  // KEYSTONE_SIMPLE_APP

// The test app performs five possible roles
//    cold-init: This creates application keys and initializes the policy store.
//    get-certified: This obtains the app admission cert naming the public app
//    key from the service. run-app-as-client: This runs the app as a client.
//    run-app-as-server: This runs the app as server.
//    warm-restart:  This retrieves the policy store data. Operation is subsumed
//      under other ops.

#include ""policy_key.cc""

cc_trust_manager *trust_mgr = nullptr;

// -----------------------------------------------------------------------------------------

bool client_application(secure_authenticated_channel &channel) {
    printf(""Client peer id is %s\n"", channel.peer_id_.c_str());

    // Initial handshake with server
    const char *msg = ""Hi from your secret client\n"";
    channel.write(strlen(msg), (byte *)msg);

    string out;
    channel.read(&out);
    printf(""Server response: %s\n"", out.data());
    channel.close();  // Close channel after handshake

    printf(""\n=== Starting Bioinformatics Analysis ===\n"");
    printf(""Analysis type: %s\n"", FLAGS_analysis_type.c_str());
    printf(""Dataset: %s\n"", FLAGS_dataset_name.c_str());

    string result;
    string error;
    bool success = false;
    string input_path;

    try {
        // Setup working directory
        string work_dir = ""/tmp/bio_fasta"";
        
        if (!FLAGS_repository_url.empty()) {
            printf(""Cloning repository...\n"");
            string cmd = ""git clone "" + FLAGS_repository_url + "" "" + work_dir + ""/repo 2>&1"";
            if (system(cmd.c_str()) != 0) {
                throw std::runtime_error(""Git clone failed"");
            }
            input_path = work_dir + ""/repo/"" + FLAGS_dataset_name;
        } else {
            input_path = FLAGS_data_dir + FLAGS_dataset_name;
        }

        // Run analysis
        success = perform_bioinformatics_analysis(
            FLAGS_analysis_type,
            input_path,
            FLAGS_parameters,
            &result,
            &error);

        if (success) {
            printf(""\n=== ANALYSIS COMPLETE ===\n"");
            printf(""First 200 characters of results:\n%.200s...\n"", result.c_str());
        } else {
            printf(""\n=== ANALYSIS FAILED ===\n%s\n"", error.c_str());
        }

    } catch (const std::exception& e) {
        printf(""\nERROR: %s\n"", e.what());
        success = false;
    }

    // Cleanup
    string cleanup_cmd = ""rm -rf /tmp/bio_fasta/repo"";
    int  [MASK]  = system(cleanup_cmd.c_str());
    if ( [MASK]  != 0) {
        printf(""Warning: Cleanup command failed (status %d)\n"",  [MASK] );
    }

    return success;
}
void server_application(secure_authenticated_channel &channel) {
    printf(""Server peer id is %s\n"", channel.peer_id_.c_str());
  // Read message from client over authenticated, encrypted channel
  string out;
  int    n = channel.read(&out);
  printf(""SSL server read: %s\n"", (const char *)out.data());

  // Reply over authenticated, encrypted channel
  const char *msg = ""Hi from your secret server\n"";
  channel.write(strlen(msg), (byte *)msg);
//   channel.close();
}


int main(int an, char **av) {
  string usage(""Simple App"");
  gflags::SetUsageMessage(usage);
  gflags::ParseCommandLineFlags(&an, &av, true);
  an = 1;
  ::testing::InitGoogleTest(&an, av);

  // clang-format off
  if (FLAGS_operation == """") {
    printf(""                                                                            (Defaults)\n"");
    printf(""%s --operation=<op>                                        ; %s"", av[0], ""(See below)"");
    printf(""\n\
                  --policy_host=policy-host-address                       ; %s\n\
                  --policy_port=policy-host-port                          ; %d\n\
                  --server_app_host=my-server-host-address                ; %s\n\
                  --server_app_port=my-server-port-number                 ; %d\n\
                  --data_dir=-directory-for-app-data                      ; %s\n\
                  --policy_cert_file=self-signed-policy-cert-file-name    ; \n\
                  --policy_store_file=policy-store-file-name              ; %s\n\
                  --print_all=true|false"",
                  FLAGS_policy_host.c_str(),
                  FLAGS_policy_port,
                  FLAGS_server_app_host.c_str(),
                  FLAGS_server_app_port,
                  FLAGS_data_dir.c_str(),
                  FLAGS_policy_store_file.c_str());
#ifdef SIMPLE_APP
    printf(""\n\
                  --platform_file_name=platform-cert-bin-file-name        ; %s\n\
                  --platform_attest_endorsement=endorsement-bin-file-name ; %s\n\
                  --measurement_file=measurement-bin-file-name            ; %s\n\
                  --attest_key_file=attest-key-bin-file-name              ; %s\n"",
                  FLAGS_platform_file_name.c_str(),
                  FLAGS_platform_attest_endorsement.c_str(),
                  FLAGS_measurement_file.c_str(),
                  FLAGS_attest_key_file.c_str());
#endif  // SIMPLE_APP

#ifdef SEV_SIMPLE_APP
    printf(""\n\
                  --ark_cert_file=./service/milan_ark_cert.der \n\
                  --ask_cert_file=./service/milan_ask_cert.der \n\
                  --vcek_cert_file=./service/milan_vcek_cert.der "");
#endif  // SEV_SIMPLE_APP
#ifdef GRAMINE_SIMPLE_APP
    printf(""\n\
                  --gramine_cert_file=sgx.cert.der"");
#endif  // GRAMINE_SIMPLE_APP
    printf(""\n\nOperations are: cold-init, get-certified, ""
           ""run-app-as-client, run-app-as-server\n"");

#ifdef SIMPLE_APP

    // clang-format off
    printf(""\nFor the simple_app, you can additionally drive 'cold-init' with different pairs of:\n"");
    printf(""\n\
    --public_key_alg=public-key-algorigthm-name                          : %s\n\
    --auth_symmetric_key_alg=authenticated-symmetric-key-algorigthm-name : %s\n"",
            FLAGS_public_key_alg.c_str(),
            FLAGS_auth_symmetric_key_alg.c_str());
    // clang-format on

    printf(""\nPublic-key algorithms supported:\n"");
    for (int i = 0; i < Num_public_key_algorithms; i++) {
      printf(""  %s\n"", Enc_public_key_algorithms[i]);
    }
    printf(""\nSymmetric-key algorithms supported:\n"");
    for (int i = 0; i < Num_symmetric_key_algorithms; i++) {
      printf(""  %s\n"", Enc_authenticated_symmetric_key_algorithms[i]);
    }

#endif  // SIMPLE_APP
    return 0;
  }
  // clang-format on

  SSL_library_init();
  string purpose(""authentication"");

  string store_file(FLAGS_data_dir);
  store_file.append(FLAGS_policy_store_file);
  trust_mgr = new cc_trust_manager(enclave_type, purpose, store_file);
  if (trust_mgr == nullptr) {
    printf(""%s() error, line %d, couldn't initialize trust object\n"",
           __func__,
           __LINE__);
    return 1;
  }

  // Init policy key info
  if (!trust_mgr->init_policy_key(initialized_cert, initialized_cert_size)) {
    printf(""%s() error, line %d, Can't init policy key\n"", __func__, __LINE__);
    return 1;
  }

  // Get parameters
  string *params = nullptr;
  int     n = 0;
  if (!get_enclave_parameters(&params, &n)) {
    printf(""%s() error, line %d, get enclave parameters\n"", __func__, __LINE__);
    return 1;
  }

  // Init simulated enclave
  if (!trust_mgr->initialize_enclave(n, params)) {
    printf(""%s() error, line %d, Can't init enclave\n"", __func__, __LINE__);
    return 1;
  }
  if (params != nullptr) {
    delete[] params;
    params = nullptr;
  }

  // clang-format off

  // Use specified algorithms for the enclave            Defaults:
#ifdef SIMPLE_APP
  // We support --public_key_alg and --auth_symmetric_key_alg only for simple_app
  // (as a way to exercise tests w/ different pairs of algorithms).
  string public_key_alg(FLAGS_public_key_alg);                  // Enc_method_rsa_2048
  string auth_symmetric_key_alg(FLAGS_auth_symmetric_key_alg);  // Enc_method_aes_256_cbc_hmac_sha256
  if (FLAGS_print_all) {
      printf(""measurement file='%s', "", FLAGS_measurement_file.c_str());
  }
#else
  string public_key_alg(Enc_method_rsa_2048);
  string auth_symmetric_key_alg(Enc_method_aes_256_cbc_hmac_sha256);
#endif  // SIMPLE_APP

  // clang-format on

  if (FLAGS_print_all && (FLAGS_operation == ""cold-init"")) {
    printf(""public_key_alg='%s', authenticated_symmetric_key_alg='%s\n"",
           public_key_alg.c_str(),
           auth_symmetric_key_alg.c_str());
  }

  // Carry out operation
  int ret = 0;
  if (FLAGS_operation == ""cold-init"") {
    if (!trust_mgr->cold_init(public_key_alg,
                              auth_symmetric_key_alg,
                              ""simple-app-home_domain"",
                              FLAGS_policy_host,
                              FLAGS_policy_port,
                              FLAGS_server_app_host,
                              FLAGS_server_app_port)) {
      printf(""%s() error, line %d, cold-init failed\n"", __func__, __LINE__);
      ret = 1;
      goto done;
    }
    // Debug
#ifdef DEBUG
    trust_mgr->print_trust_data();
#endif  // DEBUG
  } else if (FLAGS_operation == ""get-certified"") {
    if (!trust_mgr->warm_restart()) {
      printf(""%s() error, line %d, warm-restart failed\n"", __func__, __LINE__);
      ret = 1;
      goto done;
    }
    if (!trust_mgr->certify_me()) {
      printf(""%s() error, line %d, certification failed\n"", __func__, __LINE__);
      ret = 1;
      goto done;
    }
    // Debug
#ifdef DEBUG
    trust_mgr->print_trust_data();
#endif  // DEBUG
  } else if (FLAGS_operation == ""run-app-as-client"") {
    string                       my_role(""client"");
    secure_authenticated_channel channel(my_role);

    if (!trust_mgr->warm_restart()) {
      printf(""%s() error, line %d, warm-restart failed\n"", __func__, __LINE__);
      ret = 1;
      goto done;
    }

    printf(""Running App as client\n"");
    if (!trust_mgr->cc_auth_key_initialized_
        || !trust_mgr->cc_policy_info_initialized_) {
      printf(""%s() error, line %d, trust data not initialized\n"",
             __func__,
             __LINE__);
      ret = 1;
      goto done;
    }

    if (!trust_mgr->primary_admissions_cert_valid_) {
      printf(""%s() error, line %d, primary admissions cert not valid\n"",
             __func__,
             __LINE__);
      ret = 1;
      goto done;
    }
    if (!channel.init_client_ssl(FLAGS_server_app_host,
                                 FLAGS_server_app_port,
                                 *trust_mgr)) {
      printf(""%s() error, line %d, Can't init client app\n"",
             __func__,
             __LINE__);
      ret = 1;
      goto done;
    }

    // This is the actual application code.
    if (!client_application(channel)) {
      printf(""%s() error, line %d, client_application failed\n"",
             __func__,
             __LINE__);
      ret = 1;
      goto done;
    }
  } else if (FLAGS_operation == ""run-app-as-server"") {
    if (!trust_mgr->warm_restart()) {
      printf(""%s() error, line %d, warm-restart failed\n"", __func__, __LINE__);
      ret = 1;
      goto done;
    }
    printf(""Running App as server\n"");
    if (!server_dispatch(FLAGS_server_app_host,
                         FLAGS_server_app_port,
                         *trust_mgr,
                         server_application)) {
      ret = 1;
      goto done;
    }
  } else {
    printf(""%s() error, line %d, Unknown operation\n"", __func__, __LINE__);
  }

done:
  // trust_mgr->print_trust_data();
  trust_mgr->clear_sensitive_data();
  if (trust_mgr != nullptr) {
    delete trust_mgr;
  }
  return ret;
}",cleanup_status
775,"#include ""NoteWindows.h""
#include ""imgui.h""
#include ""Core/Note.h""
#include <unordered_map>
#include <iostream>

void RenderNoteVaultWindow(Core::NoteManager& noteManager) {
    static bool  [MASK]  = true;
    if ( [MASK] ) {
        ImVec2 noteVaultPos = ImVec2(750, 200);  // Set starting position for NoteVault window
        ImVec2 noteVaultSize = ImVec2(500, 400);  // Set size for NoteVault window
        ImGui::SetNextWindowPos(noteVaultPos);
        ImGui::SetNextWindowSize(noteVaultSize);
         [MASK]  = false;
    }

    ImGui::Begin(""NoteVault"");

    // If a note is selected (for editing)
    if (selectedNoteId != -1) {
        ImGui::Text(""Editing Note ID: %d"", selectedNoteId);
    }
    else {
        ImGui::Text(""Creating a New Note"");
    }

    // Input for the note content
    ImGui::InputTextMultiline(""##editContent"", input_text, IM_ARRAYSIZE(input_text), ImVec2(-FLT_MIN, ImGui::GetTextLineHeight() * 6));

    // Submit button
    if (ImGui::Button(""Submit"")) {
        std::string creationDate = ""2024-10-22"";
        if (selectedNoteId != -1) {
            // Editing an existing note
            Core::Note editedNote(selectedNoteId, ""Untitled"", input_text, currentTags, creationDate);
            std::cout << ""note: "" << editedNote.id << "" Now has content: "" << editedNote.content << std::endl;
            noteManager.addNote(editedNote);    // Update the existing note
        }
        else {
            // Creating a new note
            Core::Note newNote(""Untitled"", input_text, currentTags, creationDate);
            noteManager.addNote(newNote);       // Add new note
        }

        // Clear after submission
        currentTags.clear();
        input_text[0] = '\0';            // Clear note input buffer
        submitted_text.clear();          // Clear submitted text
        selectedNoteId = -1;  // Reset to no selection
    }

    ImGui::End();
}

void RenderNoteExplorerWindow(Core::NoteManager& noteManager) {
    static bool firstFrameExplorer = true;
    if (firstFrameExplorer) {
        ImVec2 explorerPos = ImVec2(200, 200);  // Set starting position for Note Explorer window
        ImVec2 explorerSize = ImVec2(500, 400);  // Set size for Note Explorer window
        ImGui::SetNextWindowPos(explorerPos);
        ImGui::SetNextWindowSize(explorerSize);
        firstFrameExplorer = false;
    }

    std::vector<Core::Note> notes = noteManager.getAllNotes();
    ImGui::Begin(""Note Explorer"");

    // Button to add a new note
    if (ImGui::Button(""Add Note"")) {
        selectedNoteId = -1;  // No note selected for editing
        currentNoteContent = """";
        currentTags.clear();
        input_text[0] = '\0';            // Clear note input buffer
        submitted_text.clear();          // Clear submitted text
        selectedNoteId = -1;  // Reset to no selection
    }

    // Display existing notes
    for (auto& note : notes) {
        ImGui::PushID(note.id);

        // Create a selectable region for the note's content
        std::string noteDisplay = note.content;
        if (ImGui::Selectable(noteDisplay.c_str(), false, ImGuiSelectableFlags_SpanAllColumns, ImVec2(0, 30))) {
            // When clicked, load the note for editing in NoteVault
            selectedNoteId = note.id;
            currentNoteContent = note.content;
            currentTags = note.tags;
            std::strncpy(input_text, currentNoteContent.c_str(), sizeof(input_text));
        }

        ImGui::Separator();
        ImGui::PopID();
    }

    ImGui::End();
}
",firstFrameVault
776,"#include <udsc2/phoneme/phoneme.h>
#include ""phoneme.hpp""
#include ""util/bit.h""

#include <limits>

namespace udsc2::api
{

int phoneme_difference(const api::PhonemeProperties pLeft, const api::PhonemeProperties pRight,
                       const api::PhonemeProperties  [MASK] )
{
    // These are tecnical 'Phonemes' such as start, end or whitespace. Only comparison that
    // we need is whether their types are same.
    if (pLeft.type < 8 || pRight.type < 8) {
        return pLeft.type == pRight.type ? 0 : std::numeric_limits<int>::max();
    }

    // Custom comparison methods that is defined by extension writers.
    for (auto f : udsc2::Phoneme::comparators) {
        int i = f(pLeft, pRight,  [MASK] );
        if (i != -1) return i;
    }

    // If types are not same directly get out. Note that this is not before the custom
    // comparators because extensions may need cross-type differences (such as vowel-semivowel
    // comparison).
    if (pLeft.type != pRight.type) {
        return std::numeric_limits<int>::max();
    }

    int ret = 0;
    switch (pLeft.type) {
    case api::TYP_VOWEL:
        if ( [MASK] .roundness == api::ROU_NONE && pLeft.roundness != pRight.roundness) {
            return std::numeric_limits<int>::max();
        }

        if ( [MASK] .height == api::HEI_NONE) {
            ret += std::abs(pLeft.height - pRight.height);
        }

        if ( [MASK] .backness == api::BAC_NONE) {
            ret += std::abs(pLeft.backness - pRight.backness);
        }
    case api::TYP_CONSONANT:
        if ( [MASK] .release == api::REL_NORMAL && pLeft.release != pRight.release) {
            if (pLeft.release == api::REL_NORMAL) {
                ret += 1;
            } else {
                return std::numeric_limits<int>::max();
            }
        }

        if ( [MASK] .voicing == api::VOI_NONE && pLeft.voicing != pRight.voicing) {
            ++ret;
        }

        ret += util::popcount(( pLeft.poa ^ pRight.poa ) & ~ [MASK] .poa);
        ret += util::popcount(( pLeft.moa ^ pRight.moa ) & ~ [MASK] .moa);

        return ret;
    }

    return std::numeric_limits<int>::max();
}

}
",ignore
777,"/******************************************************************************\
 * This example illustrates how to use aout.                                  *
\ ******************************************************************************/

#include <random>
#include <chrono>
#include <cstdlib>
#include <iostream>

#include ""caf/all.hpp""

using namespace caf;
using std::endl;

int main() {
  for (int i = 1; i <= 50; ++i) {
    spawn<blocking_api>([i](blocking_actor* self) {
      aout(self) << ""Hi there! This is actor nr. ""
                 << i << ""!"" << endl;
      std::random_device rd;
      std::default_random_engine re(rd());
      std::chrono::milliseconds  [MASK] {re() % 10};
      self->delayed_send(self,  [MASK] , atom(""done""));
      self->receive(others() >> [i, self] {
        aout(self) << ""Actor nr. ""
                   << i << "" says goodbye!"" << endl;
      });
    });
  }
  // wait until all other actors we've spawned are done
  await_all_actors_done();
  // done
  shutdown();
  return 0;
}
",tout
778,"/*
##########################################################################
# If not stated otherwise in this file or this component's LICENSE
# file the following copyright and licenses apply:
#
# Copyright 2019 RDK Management
#
# 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 ""DingNotification.h""
extern ""C""
{
#include ""secure_wrapper.h""
}

DingNotification* DingNotification::m_Instance = NULL;
volatile bool DingNotification::m_termFlag = false;
volatile bool DingNotification::m_confRefreshed = true;
int DingNotification::waitInterval = 1 ;

/** @description: Constructor
 *  @param[in] void
 *  @return: void
*/

DingNotification::DingNotification():
				m_httpClient(NULL),
				m_tnHttpClient(NULL),
				m_uploadReady(false),
                                m_DingTNuploadStatus(false),
				m_quiteTime(DEFAULT_QUITE_TIME),
				m_dnsCacheTimeout(DEFAULT_DNS_CACHE_TIMEOUT),
    				m_snapShotHeight(HEIGHT),
    				m_snapShotWidth(WIDTH)
{
    memset(&m_dingTime, 0, sizeof(m_dingTime));
    memset(m_dingNotifUploadURL, 0, sizeof(m_dingNotifUploadURL));
    memset(m_dingNotifAuthCode, 0, sizeof(m_dingNotifAuthCode));
    memset(m_snapShotUploadURL,0,sizeof(m_snapShotUploadURL));
    memset(m_snapShotAuthCode, 0,sizeof(m_snapShotAuthCode));
    memset(m_modelName, 0, sizeof(m_modelName));
    memset(m_macAddress, 0, sizeof(m_macAddress));
    memset(m_firmwareName, 0, sizeof(m_firmwareName));
    RDK_LOG( RDK_LOG_DEBUG,""LOG.RDK.BUTTONMGR"",""%s(%d): DingNotification constructor invoked.\n"", __FUNCTION__, __LINE__);
}

/** @description: Destructor
 *  @param[in] void
 *  @return: void
 */
DingNotification::~DingNotification()
{
   RDK_LOG( RDK_LOG_DEBUG,""LOG.RDK.BUTTONMGR"",""%s(%d): DingNotification destructor invoked.\n"", __FUNCTION__, __LINE__);
   memset(m_dingNotifUploadURL, 0, sizeof(m_dingNotifUploadURL));
   memset(m_dingNotifAuthCode, 0, sizeof(m_dingNotifAuthCode));
   memset(m_modelName, 0, sizeof(m_modelName));
   memset(m_macAddress, 0, sizeof(m_macAddress));
   memset(m_firmwareName, 0, sizeof(m_firmwareName));
    
   if(m_httpClient)
   {
	m_httpClient->close();
	delete m_httpClient;
   }
   if(m_tnHttpClient)
   {
	m_tnHttpClient->close();
        delete m_tnHttpClient;
   }
}
/** @description: creates the instance for DingNotification
 *  @param[in] void
 *  @return: pointer to instance of DingNotification
 */
DingNotification *DingNotification::getInstance()
{
    RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Creating smart thumbnail instance.\n"", __FUNCTION__, __LINE__);
    if (!m_Instance) {
        m_Instance =  new DingNotification();
    }
    RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Smart thumbnail instance created.\n"", __FUNCTION__, __LINE__);

    return m_Instance;
}

void DingNotification::init(char* modelName,char* mac,char* firmware)
{
   snprintf(m_macAddress, sizeof(m_macAddress), ""%s"",mac);	
   snprintf(m_modelName, sizeof(m_modelName), ""%s"",modelName);	
   snprintf(m_firmwareName, sizeof(m_firmwareName), ""%s"",firmware);	
   m_httpClient = new HttpClient(); 
   m_tnHttpClient = new HttpClient(); 
   //Initialize upload routine
   RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Creating Ding Notification upload thread.\n"", __FUNCTION__, __LINE__);
   std::thread uploadDingNotifThread(monitorDingNotification);
   uploadDingNotifThread.detach();
}

bool DingNotification::waitForDing()
{
    bool status = false;
    {
        std::unique_lock<std::mutex> lock(m_dingMutex);
        m_cv.wait(lock, [this] {return (m_uploadReady || m_termFlag);});

        if(!m_termFlag) {
            RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Wait over due to uploadReady flag!!\n"",__FUNCTION__,__LINE__);
            status = m_uploadReady;
            m_uploadReady = false;
        } else {
            RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Wait over due to term flag!!\n"",__FUNCTION__,__LINE__);
            status = false;
        }

        lock.unlock();
    }
    return status;
}

bool DingNotification::signalDing(bool status,struct timespec currTime)
{
    m_dingTime = currTime;
    {
        std::unique_lock<std::mutex> lock(m_dingMutex);
        m_uploadReady = status;
        lock.unlock();
    }

    m_cv.notify_one();
    return RDKC_SUCCESS;
}

int  DingNotification::getQuiteTime()
{
	getDingConf();
	return m_quiteTime;
}


int  DingNotification::getDingConf()
{
    ding_config_info_t *dingCfg = NULL;
    bool retry = true;

    // Read Thumbnail config.
    dingCfg = (ding_config_info_t*) malloc(sizeof(ding_config_info_t));

    if (NULL == dingCfg) {
        RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Error allocating memory.\n"", __FILE__, __LINE__);
        return RDKC_FAILURE;
    }

    while (retry) {
        if (RDKC_SUCCESS != readDingConfig(dingCfg)) {
            RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Error reading TNConfig.\n"", __FILE__, __LINE__);
        } else {
            break;
        }
        //Sleep 10 sec before retrying
        sleep(10);
    }

    // get url and auth
    snprintf(m_dingNotifUploadURL, sizeof(m_dingNotifUploadURL), ""%s"",dingCfg->url);
    snprintf(m_dingNotifAuthCode, sizeof(m_dingNotifAuthCode), ""%s"",dingCfg->auth_token);
    if (strlen(dingCfg->quite_interval) > 0) {
       m_quiteTime = atoi(dingCfg->quite_interval);
    }

    if (dingCfg) {
        free(dingCfg);
        dingCfg = NULL;
    }

    return RDKC_SUCCESS;

}
/** @description: Get snap shot upload conf
 *  @param[in] void
 *  @return: RDKC_SUCCESS on success, RDKC_ERROR otherwise
 */
int DingNotification::getTnUploadConf()
{
    tn_provision_info_t *stnCfg = NULL;
    bool retry = true;

    // Read Thumbnail config.
    stnCfg = (tn_provision_info_t*) malloc(sizeof(tn_provision_info_t));

    if (NULL == stnCfg) {
        RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Error allocating memory.\n"", __FILE__, __LINE__);
        return RDKC_FAILURE;
    }
    
    if (RDKC_SUCCESS != readTNConfig(stnCfg)) {
            RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Error reading TNConfig.\n"", __FILE__, __LINE__);
	    return RDKC_FAILURE;
    }

    // get url and auth
    strcpy(m_snapShotUploadURL, stnCfg -> url);
    strcpy(m_snapShotAuthCode, stnCfg -> auth_token);
    m_snapShotHeight = atoi(stnCfg -> height);
    m_snapShotWidth = atoi(stnCfg -> width);

    if (stnCfg) {
        free(stnCfg);
        stnCfg = NULL;
    }

    return RDKC_SUCCESS;
}

bool  DingNotification::monitorDingNotification()
{
   while (!m_termFlag)
   {
	if(m_confRefreshed){
            RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Fetching new URL and auth token\n"", __FUNCTION__, __LINE__);
	    memset(m_Instance->m_dingNotifUploadURL, 0, sizeof(m_Instance->m_dingNotifUploadURL));
   	    memset(m_Instance->m_dingNotifAuthCode, 0, sizeof(m_Instance->m_dingNotifAuthCode));
            if(RDKC_SUCCESS == m_Instance->getDingConf()) {
               	 RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): getDingConf success m_dingNotifUploadURL=%s m_quiteTime=%d\n"", __FUNCTION__, __LINE__,m_Instance->m_dingNotifUploadURL,m_Instance->m_quiteTime);
            }
            m_confRefreshed = false;
        }
	RDK_LOG(RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Waiting for Ding\n"", __FUNCTION__, __LINE__);
        if(m_Instance->waitForDing()) {
            m_Instance->sendDingNotification();
        }
	RDK_LOG(RDK_LOG_DEBUG,""LOG.RDK.BUTTONMGR"",""%s(%d): Process the Ding\n"", __FUNCTION__, __LINE__);
     }
     RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Exiting smart thumbnail upload thread.\n"",__FUNCTION__,__LINE__);
}

/**
 * @description: This function is used to sleep for some waitingInterval  before next retry.
 *
 * @return: Error code.
 */
int DingNotification::retryAtExpRate()
{
    int ret = RDKC_FAILURE;
    int  [MASK]  = 2;

    if(waitInterval <= UPLOAD_TIME_INTERVAL)
    {
        RDK_LOG( RDK_LOG_DEBUG,""LOG.RDK.BUTTONMGR"",""%s: %d: Waiting for %d seconds!\n"", __FILE__, __LINE__, (int)waitInterval);
        sleep(waitInterval);
        waitInterval *=  [MASK] ;
        ret = RDKC_SUCCESS;
    }
    return ret;
}

void DingNotification::stringifyDateTime(char* strEvtDateTime , size_t evtdatetimeSize, time_t evtDateTime)
{
        struct tm *tv = NULL;

        if(NULL == strEvtDateTime) {
                RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Using invalid memory location!\n"",__FILE__, __LINE__);
                return;
        }

        tv = gmtime(&evtDateTime);

        strftime(strEvtDateTime, evtdatetimeSize,""%FT%T"",tv);
}

/** @description: thread routine to upload DingNotification
 *  @param[in] : time left
 *  @return: void
 */
void DingNotification::sendDingNotification()
{
    int curlCode = 0;
    long response_code = 0;
    char packHead[UPLOAD_DATA_LEN+1];
    int retry = 0;
    int remainingTime = 0;
    const char* data = """";
    char dingT[256]={0};
    char dingTmilliseconds[256]={0};
    struct timespec currTime;
    struct timespec startTime;
    memset(&startTime, 0, sizeof(startTime));
    memset(&currTime, 0, sizeof(currTime));
    stringifyDateTime(dingT,sizeof(dingT),m_dingTime.tv_sec);
    sprintf(dingTmilliseconds,""%s.%03luZ"",dingT,((m_dingTime.tv_nsec)/1000000));
    RDK_LOG( RDK_LOG_DEBUG,""LOG.RDK.BUTTONMGR"",""%s(%d): sendDingNotification: X-EVENT-DATETIME: %s\n"",__FUNCTION__,__LINE__,dingTmilliseconds);
    /* Open the URL */
    if (NULL != m_Instance->m_httpClient) {
         m_Instance->m_httpClient->open(m_Instance->m_dingNotifUploadURL,m_Instance->m_dnsCacheTimeout);
    } else {
        RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Failed to open the URL\n"", __FUNCTION__, __LINE__);
	return;
    }

    //clock the start time
    clock_gettime(CLOCK_REALTIME, &startTime);

    RDK_LOG(RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d):Ding notification with User-Agent (%s,%s,%s)\n"", __FILE__, __LINE__, m_modelName,m_macAddress,m_firmwareName);

    while (true) {
	memset(&currTime, 0, sizeof(currTime));
        clock_gettime(CLOCK_REALTIME, &currTime);

        //Check for max retry or time limit and break if so
        if ( (retry >= MAX_RETRY_COUNT) ||
            ((currTime.tv_sec - startTime.tv_sec) > UPLOAD_TIME_INTERVAL) ) {
            RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"", ""%s(%d): Max retry count/time exceeded, Retry count %d Time spent %d. currTime.tv_sec %d startTime.tv_sec %d Upload failed!!!\n"", __FILE__,__LINE__, retry, (currTime.tv_sec - startTime.tv_sec), currTime.tv_sec, startTime.tv_sec);
            break;
        }


	clock_gettime(CLOCK_REALTIME, &currTime);

	/* Add Header */
        m_Instance->m_httpClient->resetHeaderList();
        m_Instance->m_httpClient->addHeader( ""Expect"", """");   //removing expect header condition by explicitly setting Expect header to """"
        memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""%s"", m_dingNotifAuthCode);
        m_Instance->m_httpClient->addHeader( ""Authorization"", packHead);
        m_Instance->m_httpClient->addHeader( ""X-EVENT-TYPE"", ""ding"");
	//memset(packHead, 0, sizeof(packHead));
        //snprintf(packHead, sizeof(packHead), ""application/json"");
        //m_httpClient->addHeader( ""Content-Type"", packHead);
        memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""Sercomm %s %s %s"", m_modelName, m_firmwareName, m_macAddress);
        m_Instance->m_httpClient->addHeader( ""User-Agent"", packHead);
        memset(packHead, 0, sizeof(packHead));
	snprintf(packHead, sizeof(packHead), ""%s"", dingTmilliseconds);
        m_Instance->m_httpClient->addHeader( ""X-EVENT-DATETIME"", packHead);
	memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""%d"",0);
        m_Instance->m_httpClient->addHeader( ""Content-Length"", packHead);
	RDK_LOG(RDK_LOG_TRACE1,""LOG.RDK.BUTTONMGR"",""%s(%d):Posting Ding notification to  %s \n"", __FILE__, __LINE__,m_dingNotifUploadURL );
	curlCode =  m_httpClient->post(m_dingNotifUploadURL, data, &response_code);
        if ((response_code >= RDKC_HTTP_RESPONSE_OK) && (response_code < RDKC_HTTP_RESPONSE_REDIRECT_START)){	
	    break;
        } 
	else{
            retry++;
           if(RDKC_SUCCESS != retryAtExpRate()){
               RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): retries done with current exp wait interval %d\n"",__FILE__, __LINE__,waitInterval);
               break;
           }
           RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Retrying again for %d times because last try failed  with response code %lu and curl code %d\n"",__FUNCTION__,__LINE__,retry, response_code, curlCode);
        }
    }
    //log success/failure for telemetry
    if ((response_code >= RDKC_HTTP_RESPONSE_OK) && (response_code < RDKC_HTTP_RESPONSE_REDIRECT_START)) {
            RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Posting Ding is successfull with header X-EVENT-DATETIME: %s\n"",__FUNCTION__,__LINE__,dingTmilliseconds);
            t2_event_s(""DING_INFO_Success_split"", ""Posting Ding is successfull with header X-EVENT-DATETIME:"");
    }else {
            RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Posting Ding is failed with response code %lu and curl code %d\n"",__FUNCTION__,__LINE__, response_code, curlCode);
    }
    if (NULL != m_Instance->m_httpClient) {
         m_Instance->m_httpClient->close();
    }
}


void  DingNotification::uploadDingThumbnail() {
   if(RDKC_SUCCESS != getTnUploadConf())
   {
	RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Failed to read the configuration\n"",__FUNCTION__,__LINE__);
	return;
   }

   RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Creating Ding thumbnail upload thread.\n"", __FUNCTION__, __LINE__);
   std::thread uploadDingTNThread(uploadDingSnapShot);
   uploadDingTNThread.detach();
}

void  DingNotification::uploadDingSnapShot()
{
   RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): Triggering Ding thumbnail upload\n"", __FUNCTION__, __LINE__);
   m_Instance->uploadSnapShot();
}

void  DingNotification::uploadSnapShot()
{
        /* get file attribute */
  	int file_fd = 0;
	int file_len = 0;
  	int read_len = 0;
	struct stat file_stat;
  	char read_buf[UPLOAD_DATA_LEN];
  	char *data=NULL;
  	char *ptr = NULL;
	long response_code = 0;
  	int curlCode = 0;
	int uploadRetryCount = 0;
	struct timespec startTime;
        struct timespec currTime;;
        long int uploadDuration = 0;
        long int  totaldinguploadDuration = 0;
	char packHead[UPLOAD_DATA_LEN+1];
	char dingT[256]={0};
        char dingTmilliseconds[256]={0};
        int isCVREnabled = 0;
        m_DingTNuploadStatus = false;
	
  	if (stat(SNAPSHOT_FILE, &file_stat) < 0)
  	{
        	RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): invalid file [%s], errmsg=%s\n"", __FILE__, __LINE__, SNAPSHOT_FILE, strerror(errno));
        	return;
  	}
	
  	file_len = file_stat.st_size;

  	file_fd = open(SNAPSHOT_FILE, O_RDONLY);

  	if (file_fd <= 0)
  	{
		RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d): ERROR 1\n"",__FUNCTION__,__LINE__);
      		RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Failed to Open File :%s !\n"", __FILE__, __LINE__,SNAPSHOT_FILE);
      		return;
  	}
  	data =(char*)malloc(file_len*sizeof(char));
  	if(NULL == data)
        {
                RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Failed to allocate memory :%s !\n"", __FILE__, __LINE__,SNAPSHOT_FILE);
                close(file_fd);
                return;
        }
        memset(data,0,file_len);
        memset(read_buf,0,UPLOAD_DATA_LEN);
        ptr=data;

        while((read_len = read(file_fd, read_buf, sizeof(read_buf))) > 0)
        {
                memcpy(ptr, read_buf, read_len);
                ptr += read_len;
                memset(read_buf,0,UPLOAD_DATA_LEN);
        }
	if (NULL != m_Instance->m_tnHttpClient) {
         	m_Instance->m_tnHttpClient->open(m_Instance->m_snapShotUploadURL,m_Instance->m_dnsCacheTimeout);
    	} 
	else 
	{
        	RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Failed to open the URL\n"", __FUNCTION__, __LINE__);
        	return;
    	}
	stringifyDateTime(dingT,sizeof(dingT),m_dingTime.tv_sec);
        sprintf(dingTmilliseconds,""%s.%03luZ"",dingT,((m_dingTime.tv_nsec)/1000000));
        RDK_LOG( RDK_LOG_DEBUG,""LOG.RDK.BUTTONMGR"",""%s(%d): uploadSnapShot: X-EVENT-DATETIME: %s\n"",__FUNCTION__,__LINE__,dingTmilliseconds);
	m_Instance->m_tnHttpClient->resetHeaderList();
        m_Instance->m_tnHttpClient->addHeader( ""Expect"", """");   //removing expect header condition by explicitly setting Expect header to """"
        m_Instance->m_tnHttpClient->addHeader( ""X-EVENT-TYPE"", ""ding"");
        memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""%s"", m_snapShotAuthCode);
        m_Instance->m_tnHttpClient->addHeader( ""Authorization"", packHead);
        memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""image/jpeg"");
        m_Instance->m_tnHttpClient->addHeader( ""Content-Type"", packHead);
        memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""Sercomm %s %s %s"", m_modelName, m_firmwareName, m_macAddress);
        m_Instance->m_tnHttpClient->addHeader( ""User-Agent"", packHead);
        memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""%s"", dingTmilliseconds);
        m_Instance->m_tnHttpClient->addHeader( ""X-EVENT-DATETIME"", packHead);
        memset(packHead, 0, sizeof(packHead));
        snprintf(packHead, sizeof(packHead), ""%d"",file_len);
        m_Instance->m_tnHttpClient->addHeader( ""Content-Length"", packHead);

        kvs_provision_info_t * cvrConfig = (kvs_provision_info_t*)malloc (sizeof(kvs_provision_info_t));
        if(cvrConfig)
        {
                if (0 == readKVSConfig(cvrConfig))
                {
                        isCVREnabled = atoi(cvrConfig->enable);
                }
                free(cvrConfig);
        }
        memset(packHead, 0, sizeof(packHead));
        if(isCVREnabled)
        {
                snprintf(packHead, sizeof(packHead), ""CVR"");
        }
        else
        {
                snprintf(packHead, sizeof(packHead), ""OFF"");
        }
        m_Instance->m_tnHttpClient->addHeader(""X-VIDEO-RECORDING"", packHead);

	clock_gettime(CLOCK_REALTIME, &startTime);

        while (true) 
	{
		memset(&currTime, 0, sizeof(currTime));
        	clock_gettime(CLOCK_REALTIME, &currTime);

        	//Check for max retry or time limit and break if so
        	if ( (uploadRetryCount >= MAX_RETRY_COUNT) ||((currTime.tv_sec - startTime.tv_sec) > UPLOAD_TIME_INTERVAL) ) 
		{
            		RDK_LOG(RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"", ""%s(%d): Max retry count/time exceeded, Retry count %d Time spent %d. currTime.tv_sec %d startTime.tv_sec %d Upload failed!!!\n"", __FILE__,__LINE__, uploadRetryCount, (currTime.tv_sec - startTime.tv_sec), currTime.tv_sec, startTime.tv_sec);
            		break;
        	}

		/*Uploading the file */
                curlCode =  m_Instance->m_tnHttpClient->post_binary(m_Instance->m_snapShotUploadURL,(char*)data, &response_code, file_len);
  		clock_gettime(CLOCK_REALTIME, &currTime);
                uploadDuration = (currTime.tv_sec - startTime.tv_sec)*1000 + ( currTime.tv_nsec - startTime.tv_nsec)/1000000;

                if ((response_code >= RDKC_HTTP_RESPONSE_OK) && (response_code < RDKC_HTTP_RESPONSE_REDIRECT_START))
                {
			break;
                }
                else
                {
                        RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Data post Failed. Response code = %ld : curl code = %d\n"", __FILE__, __LINE__, response_code,curlCode);
                        t2_event_s(""LC_ERR_UpldFail_split"", ""Data post Failed. Response code ="");
			uploadRetryCount++;
			
			if(RDKC_SUCCESS != retryAtExpRate()){
               			RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): retries done with current exp wait interval %d\n"",__FILE__, __LINE__,waitInterval);
               			break;
           		}
                }
        }
	//log success/failure for telemetry
        if ((response_code >= RDKC_HTTP_RESPONSE_OK) && (response_code < RDKC_HTTP_RESPONSE_REDIRECT_START)) {
                memset(&currTime, 0, sizeof(currTime));
                clock_gettime(CLOCK_REALTIME, &currTime);
                totaldinguploadDuration = (currTime.tv_sec - m_dingTime.tv_sec)*1000 + ( currTime.tv_nsec - m_dingTime.tv_nsec)/1000000;
                if (0 == uploadRetryCount ) {
				RDK_LOG( RDK_LOG_INFO,""LOG.RDK.BUTTONMGR"",""%s(%d):Thumbnail upload corresponding to ding is successful with header X-EVENT-DATETIME: %s uploadDuration=%ld TotaldinguploadDuration=%ld\n"",__FUNCTION__,__LINE__,dingTmilliseconds,uploadDuration,totaldinguploadDuration);
				t2_event_d(""DING_INFO_ThumbnailUpld"", 1);
				t2_event_s(""DINGUpload_split"", ""TotaldinguploadDuration="");
                
                } else {
                                RDK_LOG(RDK_LOG_INFO ,""LOG.RDK.BUTTONMGR"",""%s(%d): Thumbnail upload corresponding to ding is successful after %d retries  with header X-EVENT-DATETIME: %s uploadDuration=%ld TotaldinguploadDuration=%ld\n"", __FILE__, __LINE__,uploadRetryCount,dingTmilliseconds,uploadDuration,totaldinguploadDuration);
                                t2_event_d(""DING_INFO_ThumbnailUpld"", 1);
                                t2_event_s(""DINGUpload_split"", ""TotaldinguploadDuration="");
               }
	}else {
            RDK_LOG( RDK_LOG_ERROR,""LOG.RDK.BUTTONMGR"",""%s(%d): Thumbnail upload corresponding to Ding failed with response code %lu and curl code %d\n"",__FUNCTION__,__LINE__, response_code, curlCode);
    	}

        if(NULL != data)
        {
                free(data);
                data = NULL;
        }
        close(file_fd);
        m_DingTNuploadStatus = true;

	if (NULL != m_Instance->m_tnHttpClient) {
                m_Instance->m_tnHttpClient->close();
	}
	return;
}
",retryFactor
779,"#include ""cp-pch.h""



#include ""core.h""
#include ""log.h""
#include<array>
#include<spdlog/sinks/stdout_color_sinks.h>
#include<spdlog/sinks/basic_file_sink.h>



namespace Capsaicin
{
    bool Log::s_is_initialized{ false };
    Ref<spdlog::logger> Log::s_core_logger;



    void Log::init(spdlog::level::level_enum  [MASK] , const std::filesystem::path& log_file )
    {
        if( !s_is_initialized )
        {
            std::array<spdlog::sink_ptr, 2> sinks{
                create_ref<spdlog::sinks::stdout_color_sink_mt>(),
                create_ref<spdlog::sinks::basic_file_sink_mt>( log_file.string(), true ) };

            sinks[ 0 ]->set_pattern( ""%^[%T] %n: %v%$"" );
            sinks[ 1 ]->set_pattern( ""[%T] [%l] %n: %v"" );

            s_core_logger = create_ref<spdlog::logger>( ""CAPSAICIN"", begin( sinks ), end( sinks ) );
            spdlog::register_logger( s_core_logger );
            s_core_logger->set_level(  [MASK]  );
            s_core_logger->flush_on( spdlog::level::level_enum::warn );

            s_is_initialized = true;
        }
    }



    Ref<spdlog::logger>& Log::get_core_logger()
    {
        return s_core_logger;
    }



    bool Log::is_initialized()
    {
        return s_is_initialized;
    }

    
    
    void Log::set_log_level( spdlog::level::level_enum log_level )
    {
        s_core_logger->set_level( log_level );
    }



    void Log::set_flush_level( spdlog::level::level_enum flush_on )
    {
        s_core_logger->flush_on( flush_on );
    }
}
",show_at_least
780,"// Producer.cpp : 定义控制台应用程序的入口点。
//

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
#include <thread>
#include <chrono>

#ifdef WIN32
#   include <sys/timeb.h>
#   include <process.h>
#else

#   include <unistd.h>
#   include <sys/types.h>
#   include <signal.h>

#endif

#include <DefaultMQProducer.h>
#include <Message.h>
#include <SendResult.h>
#include <MQClientException.h>

inline void MySleep(long millis) {
    std::this_thread::sleep_for(std::chrono::milliseconds(millis));
}

void Usage(const char *program) {
    printf(""Usage:%s [-n] [-c] [-v]\n"", program);
    printf(""\t -n ip:port\n"");
    printf(""\t -c message count\n"");
    printf(""\t -v message size \n"");
}

int main(int argc, char *argv[]) {
    int count = 1;
    int size = 32;
    std::string* name_server_list = nullptr;

    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], ""-n"") == 0) {
            if (i + 1 < argc) {
                name_server_list = new std::string(argv[i + 1]);
                i++;
            } else {
                Usage(argv[0]);
                return 0;
            }

        } else if (strcmp(argv[i], ""-c"") == 0) {
            if (i + 1 < argc) {
                count = atoi(argv[i + 1]);
                i++;
            } else {
                Usage(argv[0]);
                return 0;
            }
        } else if (strcmp(argv[i], ""-v"") == 0) {
            if (i + 1 < argc) {
                size = atoi(argv[i + 1]);
                i++;
            } else {
                Usage(argv[0]);
                return 0;
            }
        } else {
            Usage(argv[0]);
            return 0;
        }
    }

    DefaultMQProducer  [MASK] (""PG_CppClient"");

    if (name_server_list != nullptr) {
         [MASK] .setNamesrvAddr(*name_server_list);
    }

     [MASK] .start();

    std::string tags[] = {""TagA"", ""TagB"", ""TagC"", ""TagD"", ""TagE""};

    char key[16];
    std::string value(""Hello Cpp Client"");

    for (int i = 0; i < count; i++) {
        try {
            sprintf(key, ""KEY%d"", i);
            Message msg(""TopicTest"",// topic
                        tags[i % 5],// tag
                        key,// key
                        value.c_str(),// body
                        value.size());
            SendResult sendResult =  [MASK] .send(msg);
            // MySleep(100);
            printf(""sendresult=%d,msgid=%s\n"", sendResult.getSendStatus(), sendResult.getMsgId().c_str());
        }
        catch (MQClientException &e) {
            std::cout << e << std::endl;
            MySleep(3000);
        }
    }

     [MASK] .shutdown();
    return 0;
}

",producer
781,"#include ""bucket_based_simulation.h""
#include ""error_event.h""

namespace bbsim{

BucketBasedSim::BucketBasedSim(const stim::Circuit& circ, uint k_max_):
                decoding_graph(qrc::to_decoding_graph(circ)), k_max(k_max_){
                n_detectors = circ.count_detectors();
                n_observables = circ.count_observables();
                create_the_sorted_event_vector_calc_prob_k();
                
}
BucketBasedSim::~BucketBasedSim(){
    for(ErrorEvent* ptr : sorted_events_vector)
        delete ptr;
}


void 
BucketBasedSim::combinationsHelper(const std::vector<fp_t>& nums, int k, int start, std::vector<int>& temp, std::vector<std::vector<int>>& result) {
    // base case: we've chosen k elements
    if (k == 0) {
        result.push_back(temp);
        return;
    }
    
    // recursive case: choose elements from start to end
    for (int i = start; i <= nums.size() - k; ++i) {
        temp.push_back(i);
        combinationsHelper(nums, k-1, i+1, temp, result);
        temp.pop_back();
    }
}

std::vector<std::vector<int>> 
BucketBasedSim::combinations(const std::vector<fp_t>& nums, int k) {
    std::vector<std::vector<int>> result;
    std::vector<int> temp;
    combinationsHelper(nums, k, 0, temp, result);
    return result;
}

void 
BucketBasedSim::create_the_sorted_event_vector_calc_prob_k(){
    probab_sum = 0;
    ErrorEvent* ee_ptr;
    qrc::DecodingGraph::Edge * edge_ptr;
    std::vector<qrc::DecodingGraph::Vertex*> list_of_vertices = decoding_graph.vertices();
    uint n_vertices = list_of_vertices.size();
    for(uint i = 0 ; i < n_vertices; i++){
        for(uint j = i+1; j < n_vertices; j++){
            edge_ptr  = decoding_graph.get_edge(list_of_vertices[i], list_of_vertices[j]);
    // uint64_t s = 0;
    //std::cout << ""n_detectors"" << n_detectors << std::endl;
    // for (uint d = 0; d < n_detectors; d++) {
    //     auto v = decoding_graph.get_vertex(d);
    //     for (auto w : decoding_graph.adjacency_list(v)) {
    //         edge_ptr = decoding_graph.get_edge(v, w);
            if(edge_ptr == nullptr){
                continue;
                //std::cout <<""1""<< std::endl;
            }
            // s++;
            // std::cout << s << std::endl;
            probab_sum += edge_ptr->error_probability;
            probability_group[edge_ptr->error_probability]++;
            ee_ptr = new ErrorEvent(edge_ptr->id, edge_ptr->detectors.first, edge_ptr->detectors.second,
                                edge_ptr->edge_weight, edge_ptr->error_probability, edge_ptr->frames);
            //std::cout <<""1""<<std::endl;
            if(ee_ptr == nullptr){
                std::cout << ""Error happened in creating an edge event"";
                sorted_events_vector.clear();
            }

            sorted_events_vector.push_back(ee_ptr); 
            // std::cout <<""2""<<std::endl;
            list_of_error_probabs.push_back(ee_ptr->error_probability);  
            // std::cout <<""3""<<std::endl; 
        }
        // std::cout <<""6""<< std::endl;

    }
    std::sort(sorted_events_vector.begin(), sorted_events_vector.end(), [](const ErrorEvent* e1, const ErrorEvent* e2) {
    return e1->error_probability < e2->error_probability;});
    fp_t cumulative_prob = 0;
    ///
    // uint eventno = 0;
    // std::array<fp_t, 100'000> log_poly;
    // log_poly.fill(1);
    //
    prob_k.resize(k_max+1, 0);
    prob_k[0] = 1;
    for(ErrorEvent* e : sorted_events_vector){
        cumulative_prob += e->error_probability;
        e->set_cumulative_probability(cumulative_prob);
        
        fp_t pj = e->error_probability;
        for(int kk=k_max; kk>=1; kk--) {
            prob_k[kk] = prob_k[kk-1] * pj + prob_k[kk] * (1.0 - pj);
        }
        prob_k[0] *= (1.0 - pj);

        //For calculating the probability of bucket K and 
        // fp_t ep = e->error_probability;
        //     if (eventno == 0) {
        //         log_poly[0] = log(1-ep);
        //         log_poly[1] = log(ep);
        //     } else {
        //         std::array<fp_t, 100'000> log_pa, log_pb;
        //         log_pa.fill(1);
        //         log_pb.fill(1);
        //         for (uint i = 0; i <= eventno; i++) {
        //             log_pa[i] = log_poly[i] + log(1-ep);
        //             log_pb[i+1] = log_poly[i] + log(ep);
        //         }
        //         for (uint i = 0; i < log_poly.size(); i++) {
        //             if (log_pa[i] == 1 && log_pb[i] == 1) {
        //                 log_poly[i] = 1;
        //             } else if (log_pa[i] == 1) {
        //                 log_poly[i] = log_pb[i];
        //             } else if (log_pb[i] == 1) {
        //                 log_poly[i] = log_pa[i];
        //             } else {
        //                 log_poly[i] = log(pow(M_E, log_pa[i]) + pow(M_E, log_pb[i]));
        //             }
        //         }
        //     }
        //     eventno++;
    }
    
    number_of_events = sorted_events_vector.size();

    // for(int i = 0; i<k_max+1; i++){
    //     prob_k.push_back(pow(M_E, log_poly[i]));

    // }
    // for(uint k = 1; k < k_max+1 ; k++){
    //     std::cout << ""k "" << k << std::endl;
    //     std::vector<std::vector<int>> possible_errors = combinations(list_of_error_probabs, k);
    //     fp_t temp = 1;
    //     std::cout << ""possible_errors size "" << possible_errors.size() << std::endl;
    //     for(auto one_of_n_choose_k : possible_errors){
    //         fp_t temp = 1;
    //         for(int l = 0; l < number_of_events; l++){
    //             if(std::find(one_of_n_choose_k.begin(), one_of_n_choose_k.end(), l) != one_of_n_choose_k.end()){
    //                 temp *= list_of_error_probabs[l];
    //             }
    //             else{
    //                 temp *= (1-list_of_error_probabs[l]);
    //             }   
    //         }
    //         buckets_probabs[k] += temp;
    //     }
    // }
}

fp_t BucketBasedSim::return_probab_sum(){return probab_sum;}

void 
BucketBasedSim::print_decoding_graph(){
    std::cout << ""__________print_graph___________"" << std::endl;
    qrc::DecodingGraph::Edge * edge_ptr;
    qrc::DecodingGraph::Vertex* v1, *v2;
    std::vector<qrc::DecodingGraph::Vertex*> list_of_vertices = decoding_graph.vertices();
    uint n_vertices = list_of_vertices.size();
    for(uint i = 0 ; i < n_vertices; i++){
        v1 = list_of_vertices[i];
        for(uint j = i+1; j < n_vertices; j++){
            v2 = list_of_vertices[j];
            edge_ptr  = decoding_graph.get_edge(list_of_vertices[i], list_of_vertices[j]);
            if(edge_ptr == nullptr)
                continue;
            std::cout << ""("" << v1->detector << "", "" << v2->detector << "") - E : [ id="" <<
                        edge_ptr->id << "", w = "" << edge_ptr->edge_weight << "" , er = "" << edge_ptr->error_probability << "" ]"" << std::endl;    
        }
    }
    std::cout << std::endl << ""__________end of print_graph___________"" << std::endl;
}

void 
BucketBasedSim::print_vertices(){
    decoding_graph.set_vertices_features();
    //std::vector<qrc::DecodingGraph::Vertex*> list_of_vertices = decoding_graph.vertices();
    for(uint i = 0; i < n_detectors; i++){
        qrc::DecodingGraph::Vertex* v = decoding_graph.get_vertex(i);
        std::cout <<"" N""<<i <<"" - "" << v->feature << std::endl;
        std::vector<qrc::DecodingGraph::Vertex*> adj_list =  decoding_graph.adjacency_list(v);
        std::cout << ""  Neighbors("" << adj_list.size() << ""):"";
        for(qrc::DecodingGraph::Vertex* v_ : adj_list){
            std::cout << v_->detector << "" - "";
            qrc::DecodingGraph::Edge* e = decoding_graph.get_edge(v, v_);
            if(e == nullptr){
                std::cout << ""This message should not be printed, existed edge with nulptr!"";
            }
            std:: cout << e->error_probability << "", "";
        }
        std::cout << std::endl;
    }
    qrc::DecodingGraph::Vertex* v = decoding_graph.get_vertex(BOUNDARY_INDEX);
        
        std::cout <<"" N""<<n_detectors <<"" - "" << v->feature << ""(degree = "" << v->n_neighbors << "")"" <<std::endl ;
        std::vector<qrc::DecodingGraph::Vertex*> adj_list =  decoding_graph.adjacency_list(v);
        std::cout << ""  Neighbors("" << adj_list.size() << ""):"";
        for(qrc::DecodingGraph::Vertex* v_ : adj_list){
            std::cout << v_->detector << "" - "";
            qrc::DecodingGraph::Edge* e = decoding_graph.get_edge(v, v_);
            if(e == nullptr){
                std::cout << ""This message should not be printed, existed edge with nulptr!"";
            }
            std:: cout << e->error_probability << "", "";
        }
        std::cout << std::endl;
        std::cout << ""________________________________________""<< std::endl;
        std::cout <<""Feature : Number of nodes with that Feature"" << std::endl;
        for(const auto& f : decoding_graph.feature_group){
            std::cout << f.first << "" : "" << f.second << std::endl;
        }
        std::cout << ""________________________________________""<< std::endl;
        std::cout <<""Degree of nodes : Number of nodes with that degree"" << std::endl;
        for(const auto& f : decoding_graph.node_degree_group){
            std::cout << f.first << "" : "" << f.second << std::endl;
        }
        std::cout << ""________________________________________""<< std::endl;
        std::cout <<""(feature, degree of node): Number of nodes with that feature and degree"" << std::endl;
        for(const auto& f : decoding_graph.feature_degree_group){
            std::cout << ""("" << f.first.first <<"", "" << f.first.second << ""): ""
             << f.second;
            // if(f.second == 1){
            //     std::cout << "" v "" << 
            // }
            std::cout << std::endl;
        }
}

void 
BucketBasedSim::print_weight_matrix(){
    uint n_events = sorted_events_vector.size();
    std::vector<qrc::DecodingGraph::Vertex*> list_of_vertices = decoding_graph.vertices();
    uint n_vertices = list_of_vertices.size();
    std::vector<std::vector<fp_t>> m(n_vertices, std::vector<fp_t>(n_vertices, 0));

    auto path_table = qrc::compute_path_table(decoding_graph);
    uint i,j;
    ErrorEvent* ee_ptr;
    for(uint e = 0; e < n_events; e++){
        ee_ptr = sorted_events_vector[e];
        i = ee_ptr->detectors.first ;
        j= ee_ptr->detectors.second;
        if(i == BOUNDARY_INDEX){
            i = n_vertices-1;
        }
        if(j == BOUNDARY_INDEX){
            j = n_vertices-1;
        }
        // std::cout << i << "" ""<<j << std::endl;
        m[i][j] = ee_ptr->error_probability;
        m[j][i] = ee_ptr->error_probability;
    }


    for(uint i = 0; i<n_vertices; i++){
        for(uint j = 0; j< n_vertices; j++){
            std::cout<< m[i][j] << "" "";
        }
        std::cout << std::endl;
    }
    
}

void 
BucketBasedSim::print_path_matrix(){
    std::vector<qrc::DecodingGraph::Vertex*> list_of_vertices = decoding_graph.vertices();
    uint n_vertices = list_of_vertices.size();
    std::vector<std::vector<fp_t>> m(n_vertices, std::vector<fp_t>(n_vertices, 0));

    auto path_table = qrc::compute_path_table(decoding_graph);
    uint i,j;
    for (auto v :decoding_graph.vertices()){
        for(auto w: decoding_graph.vertices()){
            auto v_w = std::make_pair(v,w);
            auto p = path_table[v_w].distance;
            i = v->detector;
            j=w->detector;
            if(v->detector == BOUNDARY_INDEX){
                i = n_vertices-1;
            }
            if(w->detector == BOUNDARY_INDEX){
                j = n_vertices-1;
            }
            // std::cout << i << "" ""<<j << std::endl;
            fp_t x = pow(10,-1*p);
            m[i][j] = x;;;
        }
    }


    for(uint i = 0; i<n_vertices; i++){
        for(uint j = 0; j< n_vertices; j++){
            std::cout<< m[i][j] << "" "";
        }
        std::cout << std::endl;
    }
    
}

void 
BucketBasedSim::print_path_list(){
    std::vector<qrc::DecodingGraph::Vertex*> list_of_vertices = decoding_graph.vertices();
    uint n_vertices = list_of_vertices.size();
    std::vector<std::vector<fp_t>> m(n_vertices, std::vector<fp_t>(n_vertices, 0));
    std::vector<std::vector<std::vector<qrc::DecodingGraph::Vertex*>>>  [MASK] (n_vertices, std::vector<std::vector<qrc::DecodingGraph::Vertex*>>(n_vertices));  
    auto path_table = qrc::compute_path_table(decoding_graph);
    uint i,j;
    for (auto v :decoding_graph.vertices()){
        for(auto w: decoding_graph.vertices()){
            auto v_w = std::make_pair(v,w);
            auto p = path_table[v_w].distance;
            i = v->detector;
            j=w->detector;
            if(v->detector == BOUNDARY_INDEX){
                i = n_vertices-1;
            }
            if(w->detector == BOUNDARY_INDEX){
                j = n_vertices-1;
            }
            // std::cout << i << "" ""<<j << std::endl;
            fp_t x = pow(10,-1*p);
            m[i][j] = x;
             [MASK] [i][j] = path_table[v_w].path;
            
        }
    }


    for(uint i = 0; i<n_vertices; i++){
        for(uint j = i; j< n_vertices; j++){
            std::cout << ""("" << i << "", "" << j << ""): ""<< m[i][j] << "" - "";
            
            for(const auto& p : [MASK] [i][j]){
                if(p != nullptr){
                    std::cout << p->detector << ""-"";
                }
            }
            std::cout <<std::endl;
        }
        std::cout << std::endl;
    }
    
}

void 
BucketBasedSim::print_sorted_event_vector(){
    uint n_events = sorted_events_vector.size();
    ErrorEvent* ee_ptr;
    for(uint i = 0; i < n_events; i++){
        ee_ptr = sorted_events_vector[i];
        std::cout <<"" E""<<i <<"" - "" << ee_ptr->id <<"" : [ ("" << ee_ptr->detectors.first << "", "" << ee_ptr->detectors.second << "") "" << "" , er = "" << ee_ptr->error_probability << "" ]"" << std::endl;    //"" gp = ""<< ee_ptr->cumulative_probability<< //""id= "" <<ee_ptr->id  //"", w = "" << ee_ptr->edge_weight <<
    }
    std::cout << ""______________________________________""<< std::endl;
    std::vector<qrc::DecodingGraph::Vertex*> list_of_vertices = decoding_graph.vertices();
    uint n_vertices = list_of_vertices.size();
    std::cout << ""Total # of Edges (Error Events)= "" << n_events << "" - Total # of Vertices (Syndrome Size) = "" << n_vertices << std::endl;
    std::cout << ""p : probability of edge - n : number of edges with probability p"" << std::endl;
    for(auto p : probability_group){
        std::cout << ""p: "" << p.first << "" - n: "" << p.second << std::endl;
    }
    // std::cout << ""______________________________________""<< std::endl;
    // for( uint i =  0; i< list_of_error_probabs.size(); i++){
    //     std::cout << ""i: "" << i << "" p: "" << list_of_error_probabs[i]<< std::endl;
    // }
    // std::cout << ""______________________________________""<< std::endl;
    // for( uint i =  0; i< buckets_probabs.size(); i++){
    //     std::cout << ""k: "" << i+1 << "" p: "" << buckets_probabs[i]<< std::endl;
    // }
}

std::vector<std::vector<uint8_t>> 
BucketBasedSim::create_syndromes(uint k, uint64_t shots_per_k_, std::mt19937_64& rng, bool print_log){
    std::vector<std::vector<uint8_t>> syndromes_vect;
    std::vector<uint8_t> syndrome;
    uint n_detectors = decoding_graph.vertices().size()-1;
    syndrome.resize(n_detectors+1,((uint8_t)0)); //
    std::vector<bool> selected_event;
    selected_event.resize(sorted_events_vector.size(), false);

    std::uniform_real_distribution<> dis(0.0, probab_sum);
    for(uint i = 0; i< shots_per_k_; i++){
        std::fill(selected_event.begin(), selected_event.end(), false);
        for(uint j = 0; j<k; j++){
            fp_t r;
            uint m;

            // This while is for making sure that we do not select an event multiple times
            while(true){
                r = dis(rng);
                m = 0;
                while (sorted_events_vector[m]->cumulative_probability < r) {
                    m++;
                }
                if(selected_event[m]){
        
                    continue;
                }
                selected_event[m] = true;
                break;
            }
            uint d1 = sorted_events_vector[m]->detectors.first;
            uint d2 = sorted_events_vector[m]->detectors.second;

            if(d1 != BOUNDARY_INDEX){
                syndrome[d1] ^= ((uint8_t)1);//;
            }
            if(d2 != BOUNDARY_INDEX){
                syndrome[d2] ^= ((uint8_t)1);//((uint8_t)1);
            }
            for (uint obs : sorted_events_vector[m]->frames) {
                if (obs >= 0) {
                    syndrome[n_detectors+obs] ^= ((uint8_t)1);//((uint8_t)1);
                }
            }
            if(print_log){
                std::cout << ""k:"" << j << "" d1: "" << d1 << "" d2: "" << d2 << std::endl;
                qpd::print_syndrome(syndrome);
                std::cout << "" --"" << std::endl;
            }    
        }

        syndromes_vect.push_back(syndrome);

        std::fill(syndrome.begin(), syndrome.end(), ((uint8_t)0)); //((uint8_t)0)
    }

    return syndromes_vect;

}

stim::simd_bit_table
BucketBasedSim::create_syndromes_simd(uint k, uint64_t shots_per_k_, std::mt19937_64& rng, bool print_log){

    uint64_t syndrome_size =  n_detectors+ n_observables;
    stim::simd_bit_table syndromes_table(shots_per_k_, syndrome_size);
    std::vector<bool> selected_event;
    selected_event.resize(sorted_events_vector.size(), false);

    std::uniform_real_distribution<> dis(0.0, probab_sum);
    for(uint i = 0; i< shots_per_k_; i++){
        std::fill(selected_event.begin(), selected_event.end(), false);
        for(uint j = 0; j<k; j++){
            fp_t r;
            uint m;

            // This while is for making sure that we do not select an event multiple times
            while(true){
                r = dis(rng);
                m = 0;
                while (sorted_events_vector[m]->cumulative_probability < r) {
                    m++;
                }
                if(selected_event[m]){
        
                    continue;
                }
                selected_event[m] = true;
                break;
            }
            uint d1 = sorted_events_vector[m]->detectors.first;
            uint d2 = sorted_events_vector[m]->detectors.second;

            if(d1 != BOUNDARY_INDEX){
                syndromes_table[i][d1] ^= 1;//;
            }
            if(d2 != BOUNDARY_INDEX){
                syndromes_table[i][d2] ^= 1;//((uint8_t)1);
            }
            for (uint obs : sorted_events_vector[m]->frames) {
                if (obs >= 0) {
                    syndromes_table[i][n_detectors+obs] ^= 1;//((uint8_t)1);
                }
            }
            
            if(print_log){//(((j+1)*2)) < hw
                std::cout << ""********************************&&&&&&&&&&&&&&&&&&""<< std::endl;
                std::vector<uint8_t> sss= qrc::_to_vector(syndromes_table[i], n_detectors, n_observables);
                uint hw = std::accumulate(sss.begin(), sss.begin()+n_detectors, 0);

                std::cout << ""k:"" << k <<"" #err: ""<<j << "" d1: "" << d1 << "" d2: "" << d2 << "" hw:"" << hw<< std::endl;
                //qpd::print_syndrome(sss);
                std::cout << "" --"" << std::endl;
                std::cout << ""********************************&&&&&&&&&&&&&&&&&&""<< std::endl;
            }

        }
    }
    return syndromes_table;
}

void 
BucketBasedSim::set_shots_per_k(fp_t expected_ler, uint64_t max_n_iteration, bool set_shots_to_all, uint64_t filling_n_iterations, uint64_t min_n_iteration){
    double result, exponent, base;
    uint64_t shots;
    shots_per_k.clear();
    shots_per_k.resize(prob_k.size());
    for(int k =0; k<prob_k.size(); k++){
        result = prob_k[k] / expected_ler;
        exponent = std::floor(std::log10(result));
        base = std::round(result / std::pow(10, exponent));
        shots = 4*((uint64_t)base*std::pow(10, exponent));
        // std::cout << k << "" "" << shots << std::endl;
        if(max_n_iteration < shots){
            // if(shots < 10*max_n_iteration){
            //     shots = max_n_iteration;
            // }
            // else if(set_shots_to_all){
            //     shots = filling_n_iterations;
            // }
            // else{
            //     shots = 0;
            // }
            // std::cout << k << "" "" << shots << ""max_n_iteration < shots"" << std::endl;
            if(set_shots_to_all){
                shots = filling_n_iterations;
            }
            else{
                shots = 0;
            }
        }
        else if(shots !=0 && shots < min_n_iteration){
            // std::cout << k << "" "" << shots << ""shots !=0 && shots < min_n_iteration"" << std::endl;
            shots = min_n_iteration;
        }
        shots_per_k[k] = shots;


        // shots_per_k[k] = 0;
        // if(k == 13){
        //     shots_per_k[k] = 10'000'000'000;
        // }
        // else if(k == 14){
        //     shots_per_k[k] = 1'000'000'000;
        // }
        // else if(k == 15){
        //     shots_per_k[k] = 100'000'000;
        // }
        // else if(k == 16){
        //     shots_per_k[k] = 100'000'000;
        // }
    }

}


} //namespace bbsim",paths
782,"#include ""ProcessSMICommand.h""

void ProcessSMICommand::execute()
{
	// header
	std::cout << ""--------------------------------------------"" << ""\n"";
	std::cout << ""| PROCESS-SMI V1.00 DRIVER VERSION 01.00 |"" << ""\n"";
	std::cout << ""--------------------------------------------"" << ""\n"";

    for (CPUWorker* core : CPUManager::getInstance()->getCores()) {
        core->mutex.lock();
    }

    int max_cpu = std::stoi(ConsoleManager::getInstance()->getConfigs()[""num-cpu""]);
    int used_cpu = 0;

    size_t totalMemory = MemoryManager::getInstance()->getTotalMemory();

    auto processMemoryUsage = MemoryManager::getInstance()->getProcessMemoryUsage();
    /* for (auto a : processMemoryUsage) {
        std::cout << a.first << "": "" << a.second << std::endl;
    }*/

    int  [MASK]  = 0;

    for (auto core : CPUManager::getInstance()->getCores()) {
        auto p = core->getProcess();
        if (p) {
            used_cpu++;
        }
    }

    for (auto entry : processMemoryUsage) {
         [MASK]  += entry.second;
    }

    float utilization = (float)used_cpu / (float)max_cpu;

    std::cout << ""CPU-Util: "" << utilization * 100 << ""%\n"";
    std::cout << ""Memory Usage: "" <<  [MASK]  << ""KB / "" << totalMemory << ""KB\n"";
    std::cout << ""Memory Util: "" << ((float)  [MASK] ) / ((float) totalMemory) * 100 << ""%\n\n"";

    std::cout << ""---------------------------------------------\n"";
    std::cout << ""Running processes and memory usage: \n"";
    std::cout << ""---------------------------------------------\n"";

    for (auto core : CPUManager::getInstance()->getCores()) {
        auto p = core->getProcess();
        if (p) {
            auto timeCreated_time_t = std::chrono::system_clock::to_time_t(p->getTimeExecuted());
            int memoryUsage = processMemoryUsage.contains(p->getId())
                ? processMemoryUsage.at(p->getId())
                : 0;
        
            std::cout << p->getName() << "" "" << memoryUsage << ""KB\n"";
        }
    }

    std::cout << ""---------------------------------------------\n"";

    // DEBUG: show whole memory map
    // std::cout << MemoryManager::getInstance()->getAllocator()->visualizeMemory() << std::endl;

    for (CPUWorker* core : CPUManager::getInstance()->getCores()) {
        core->mutex.unlock();
    }
}
",totalMemoryUsage
783,"#include <SoftwareSerial.h>
#include <AltSoftSerial.h>
#include <TinyGPS++.h>
#include <Wire.h>

// Nomor Telepon yang Diizinkan
const String AUTHORIZED_PHONE = ""+6282199799982"";

// Pin Konfigurasi
#define relayPin 5          // Relay utama (ON/OFF motor)
#define starterRelayPin 4   // Relay starter
#define vibrationPin 6      // Sensor getar
#define alarmRelayPin 12    // Relay alarm / buzzer
#define newRelayPin 7       // Relay tambahan (gunakan NO)

#define rxPin 10
#define txPin 11
SoftwareSerial sim800(rxPin, txPin);
#define gpsRXPin 9
#define gpsTXPin 8
AltSoftSerial gpsSerial(gpsRXPin, gpsTXPin);
TinyGPSPlus gps;

// Variabel
String sender_number, msg;
boolean ignition_status = false;
boolean anti_theft = false;

void setup() {
  Serial.begin(115200);
  sim800.begin(9600);
  gpsSerial.begin(9600);

  pinMode(relayPin, OUTPUT);
  pinMode(starterRelayPin, OUTPUT);
  pinMode(alarmRelayPin, OUTPUT);
  pinMode(newRelayPin, OUTPUT);
  pinMode(vibrationPin, INPUT);

  digitalWrite(relayPin, HIGH);
  digitalWrite(starterRelayPin, HIGH);
  digitalWrite(alarmRelayPin, HIGH);
  digitalWrite(newRelayPin, HIGH);

  initializeSIM800L();
}

void loop() {
  ignition_status = digitalRead(relayPin) == LOW;

  if (anti_theft && digitalRead(vibrationPin) == LOW) {
    digitalWrite(alarmRelayPin, LOW);
    delay(3000);
    digitalWrite(alarmRelayPin, HIGH);
  }

  if (sim800.available()) {
    String input = sim800.readString();
    parseData(input);
  }

  if (Serial.available()) {
    sim800.println(Serial.readString());
  }
}

void initializeSIM800L() {
  delay(7000);
  sendCommand(""AT"");
  sendCommand(""ATE1"");
  sendCommand(""AT+CPIN?"");
  sendCommand(""AT+CMGF=1"");
  sendCommand(""AT+CNMI=1,2,0,0,0"");
}

void sendCommand(String command) {
  sim800.println(command);
  delay(500);
  while (sim800.available()) {
    Serial.write(sim800.read());
  }
}

void parseData(String  [MASK] ) {
  Serial.println(""==> Data Masuk: "" +  [MASK] );

  if ( [MASK] .indexOf(""+CMT:"") != -1) {
    int senderStart =  [MASK] .indexOf(""+CMT: \"""") + 7;
    int senderEnd =  [MASK] .indexOf(""\"",\"""", senderStart);
    sender_number =  [MASK] .substring(senderStart, senderEnd);

    int msgStart =  [MASK] .indexOf(""\n"", senderEnd) + 1;
    msg =  [MASK] .substring(msgStart);
    msg.trim();
    msg.toLowerCase();

    Serial.println(""Pengirim: "" + sender_number);
    Serial.println(""Isi Pesan: "" + msg);

    if (sender_number != AUTHORIZED_PHONE) {
      sendSms(""Nomor tidak diizinkan."");
      return;
    }

    if (msg == ""get location"") {
      handleLocationRequest();
    } else {
      doAction();
    }
  }
}

void doAction() {
  if (msg == ""bike on"") {
    if (digitalRead(newRelayPin) == HIGH) {  // Jika power utama ON (karena NO)
      digitalWrite(relayPin, LOW);
      sendSms(""Motor dinyalakan."");
    } else {
      sendSms(""Power utama belum ON."");
    }
  } else if (msg == ""bike off"") {
    digitalWrite(relayPin, HIGH);
    sendSms(""Motor dimatikan."");
  } else if (msg == ""bike start"") {
    if (ignition_status) {
      startBike();
    } else {
      sendSms(""Hidupkan motor dulu (bike on)."");
    }
  } else if (msg == ""anti theft on"") {
    anti_theft = true;
    sendSms(""Anti-pencurian aktif."");
  } else if (msg == ""anti theft off"") {
    anti_theft = false;
    sendSms(""Anti-pencurian nonaktif."");
  } else if (msg == ""on"") {
    digitalWrite(newRelayPin, HIGH); // ON = HIGH karena NO
    sendSms(""Power ON."");
  } else if (msg == ""off"") {
    digitalWrite(newRelayPin, LOW);  // OFF = LOW karena NO
    sendSms(""Power OFF."");
  } else {
    sendSms(""Perintah tidak dikenali."");
  }
}

void handleLocationRequest() {
  Serial.println(""==> Mengambil lokasi GPS..."");
  boolean newData = false;

  for (unsigned long start = millis(); millis() - start < 10000;) {
    while (gpsSerial.available()) {
      if (gps.encode(gpsSerial.read())) {
        newData = true;
      }
    }
  }

  if (newData && gps.location.isUpdated()) {
    String lokasi = ""http://maps.google.com/maps?q="" +
                    String(gps.location.lat(), 6) + "","" +
                    String(gps.location.lng(), 6);
    sendSms(""Lokasi: "" + lokasi);
  } else {
    sendSms(""GPS tidak tersedia."");
  }
}

void startBike() {
  sendSms(""Memulai starter..."");
  digitalWrite(starterRelayPin, LOW);
  delay(3000);
  digitalWrite(starterRelayPin, HIGH);
  sendSms(""Starter selesai."");
}

void sendSms(String text) {
  Serial.println(""Mengirim SMS ke: "" + sender_number);
  Serial.println(""Isi: "" + text);

  sim800.println(""AT+CMGF=1"");
  delay(1000);

  sim800.print(""AT+CMGS=\"""");
  sim800.print(sender_number);
  sim800.println(""\"""");
  delay(1000);

  sim800.print(text);
  delay(500);
  sim800.write(0x1A);  // Ctrl+Z
  delay(3000);

  Serial.println(""SMS berhasil dikirim."");
}
",buff
784,"#ifndef LOCALSEARCH_H
#define LOCALSEARCH_H
#include <limits.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <math.h>
#include <unistd.h>
#include <string.h>
using namespace std;

//#define format_konect
#define format_dimacs

//#define construct_select_with_step
#define select_with_step

#define init_with_degree
//#define init_with_step

#define greedy_add_construct
//#define no_greedy_add_construct

#define is_simplify

extern unsigned long long * vertex_step;
extern long* add_candidate_index;
extern long* drop_candidate_index;

//clock_t start
extern long vertex_count;
extern long edge_count;

extern int init_num;
extern int last_improved_no;
extern long long add_num;
extern long long swap_num;
extern long long drop_num;
//int degree_weight = 0;

struct weighted_edge {
    long vertex;
    long weight;
};
struct is_add_nei_element {
    long weight;
    bool is_nei;
};

struct best_element {
    long vertex_num;
    long index_num;
};
// The struct to maintain the remaining vertices
struct Remaining_vertex {
    vector<long> vertex;
    vector<vector<long>::size_type> index;

    vector<long>::iterator begin() {
        return vertex.begin();
    }
    vector<long>::iterator end() {
        return vertex.end();
    }
    void init(vector<long>::size_type  [MASK] ) {
        vertex.reserve( [MASK] );
        index.resize( [MASK]  + 1);
        for (vector<long>::size_type i = 1; i <=  [MASK] ; ++i) {
            vertex.push_back((long)i);
            index[i] = i - 1;
        }
    }
    void remove(long v) {
        index[*vertex.rbegin()] = index[v];
        vertex[index[v]] = *vertex.rbegin();
        vertex.pop_back();
    }

    vector<long>::size_type size() {
        return vertex.size();
    }

    bool empty() {
        return vertex.empty();
    }
};
extern Remaining_vertex remaining_vertex;
// Build
extern vector<vector<weighted_edge>> vertex_adjacency_list;
extern long* vertex_edge_weight;
extern long* vertex_degree;

// Construction
extern bool is_new_graph;
extern vector<long> candidates;
extern long* cand_neighbor_weight;
extern bool* is_in_candidates;
extern is_add_nei_element* is_addv_neighbor;
extern int ttt;

extern vector<long> start_vertices;
extern long untest_pointer;
extern long head_p, tail_p;

// Reduction
extern long* vertex_upper_bound;

#define min_num(x, y) (x <= y ? x : y)
//Select vertex
extern best_element* best_add_array;
extern best_element* best_swap_array;
extern best_element* best_drop_array;

// Solutions
extern vector<long> solution;
extern vector<long> best_solution;
extern long solution_weight;
extern long Waim;
extern long best_solution_weight;
extern double best_solution_time;
extern long best_solution_try;

// Main loop
extern bool better_since_cons;
extern long simp_count;

// BMS
extern long start_bms_count;
extern long min_bms_count;
extern long max_bms_count;
extern long real_bms_count;
extern long add_bms_count;
extern long swap_bms_count;

// Definition of global variables
extern long tries;
extern long max_tries;
extern int cutoff_time;
extern int t;


//local search
struct swap_element {
    long v1;
    long v2;
    long score;
};
struct is_neighbor_element
{
    long weight;
    bool is_in_neighbor;
};
struct vertex_connect_clique
{
    int number;
    long weight;
    /* data */
};
struct swap_number {
    long v1;
    long v2;
};
// add 
extern vector<long> add_candidate_set;
extern long* add_vertex_score;
// drop
extern long* drop_vertex_score;
// swap
extern vector<swap_element> swap_candidate_set;

extern bool* is_in_solution;
extern vertex_connect_clique* vertex_num_connect_to_clique; 
extern bool* tmp_is_v1;
extern is_neighbor_element* is_in_neighbor;
extern bool* tmp_v2_in_swap;

extern bool* conf_change;

long soft_upper_bound(long);

void print_solution();

bool comp(const swap_element &a, const swap_element &b);// 

void update_best_solution();

long find_v1_from_solution(long v2);

// index: add_v's index in add_candidate_set
void add(long add_v, vector<long>::size_type index, bool change_conf, char ccc);

//index: del_v's index in solution
void drop(long del_v, vector<long>::size_type index);

void init_add();

void initGreedyConstruct();

void local_search();
#endif
",vertex_size
785,"#include ""capture.hpp""
#include <netinet/if_ether.h>

PacketSniffer::PacketSniffer() {
    sock_raw = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sock_raw < 0) {
        perror(""Socket Error"");
        exit(EXIT_FAILURE);
    }
    std::cout << ""Sniffer démarré..."" << std::endl;
}

PacketSniffer::~PacketSniffer() {
    close(sock_raw);
}

void PacketSniffer::startCapture() {
    unsigned char buffer[65536];
    struct sockaddr saddr;
    socklen_t saddr_size = sizeof(saddr);

    while (true) {
        int data_size = recvfrom(sock_raw, buffer, sizeof(buffer), 0, &saddr, &saddr_size);
        if (data_size < 0) {
            perror(""Recvfrom Error"");
            exit(EXIT_FAILURE);
        }
        processPacket(buffer, data_size);
    }
}

void PacketSniffer::processPacket(unsigned char* buffer, int size) {
    struct iphdr* ip_header = (struct iphdr*)(buffer + 14);
    struct sockaddr_in source,  [MASK] ;
    source.sin_addr.s_addr = ip_header->saddr;
     [MASK] .sin_addr.s_addr = ip_header->daddr;

    std::cout << ""IP Source: "" << inet_ntoa(source.sin_addr)
              << "" -> Destination: "" << inet_ntoa( [MASK] .sin_addr)
              << std::endl;
}
",dest
786,"#ifndef ALGORITHMS_UKF_INCLUDE_UNSCENTED_KALMAN_FILTER_H_
#define ALGORITHMS_UKF_INCLUDE_UNSCENTED_KALMAN_FILTER_H_

#include <cmath>
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>

#include <Eigen/Dense>                        // NOLINT(build/include_order)
#include <Eigen/Geometry>                     // NOLINT(build/include_order)
#include <unsupported/Eigen/MatrixFunctions>  // NOLINT(build/include_order)

// The algorithm is inspired by the following papers:
// - https://kodlab.seas.upenn.edu/uploads/Arun/UKFpaper.pdf
// - https://arxiv.org/pdf/1107.1119.pdf
namespace ukf {

/// Dimensions of the UKF internal state manifold and measurements manifold
const unsigned int kStateDims = 14;
const unsigned int kMeasDims = 10;
using StateVector = Eigen::Matrix<double, kStateDims, 1>;
using MeasVector = Eigen::Matrix<double, kMeasDims, 1>;
using StateVariance = Eigen::Matrix<double, kStateDims, kStateDims>;
using MeasVariance = Eigen::Matrix<double, kMeasDims, kMeasDims>;

/// Generates 2N points on a N-manifold that have the same mean, covariance and skewness
/// than the input distribution determined by the two first moments. These points
/// can then be used to estimate the distribution after a non-linear transformation
/// Note that these points are actually located at the 1-sigma isosurface of gaussian distribution
template <typename ManifoldElement, unsigned int N>
std::vector<ManifoldElement> GenerateSigmaPoints(ManifoldElement m, Eigen::Matrix<double, N, N> M);

//--------------------------------------------------------------------------------------------------
// represent an element of the SO3 lie group
template <typename T>
class SO3 {
  public:
    // methods
    SO3() = default;
    explicit SO3(Eigen::Quaternion<T> element) { element_ = element; }
    void FromEulerAngle(T rx, T ry, T rz);
    void SetElement(Eigen::Quaternion<T> element) { element_ = element; }
    Eigen::Matrix<T, 3, 3> ToRotationMatrix() const;
    Eigen::Quaternion<T> ToQuaternion() const;
    SO3<T> operator+(Eigen::Matrix<T, 3, 1> v) const;
    Eigen::Matrix<T, 3, 1> operator-(SO3 y) const;
    Eigen::Matrix<T, 3, 1> ToAxisAngle() const;

  protected:
    Eigen::Quaternion<T> element_;
};

//--------------------------------------------------------------------------------------------------
/// Represents an element of the manifold of all the possible camera calibrations. This
/// is not a vector space since SO3 has a lie algebra structure but not a vector space structure
class CalibrationStateManifoldElement {
  public:
    CalibrationStateManifoldElement() = default;
    CalibrationStateManifoldElement(Eigen::Vector3d position, SO3<double> orientation,
                                    Eigen::Vector3d angular_velocity, double focal,
                                    double focal_velocity, Eigen::Vector2d principal_point,
                                    double distortion);

    // Addition operator: Manifold x Tangent Vector Space -> Manifold
    CalibrationStateManifoldElement operator+(StateVector v);

    // Subtraction operator: Manifold x Manifold -> Tangent Vector Space
    StateVector operator-(CalibrationStateManifoldElement y);

    // Compute the mean of sample points belonging to the manifold. Since the mean is defined as
    // being the element that minimises the sum of the squared distances, the manifold needs to be
    // Riemannian.
    static CalibrationStateManifoldElement ComputeMean(
            std::vector<CalibrationStateManifoldElement> samples);

    std::string PrintSelf();

    Eigen::Vector3d position_;
    SO3<double> orientation_;
    Eigen::Vector3d angular_velocity_;
    double focal_;
    double focal_velocity_;
    Eigen::Vector2d principal_point_;
    double distortion_;
};

//--------------------------------------------------------------------------------------------------
/// Represents an element of the manifold of all the possible calibration measures. This
/// is not a vector space since SO3 has a lie algebra structure but not a vector space structure
class CalibrationMeasureManifoldElement {
  public:
    CalibrationMeasureManifoldElement() = default;
    CalibrationMeasureManifoldElement(Eigen::Vector3d position, SO3<double> orientation,
                                      double focal, Eigen::Vector2d principal_point,
                                      double distortion);

    // Addition operator: Manifold x Tangent Vector Space -> Manifold
    CalibrationMeasureManifoldElement operator+(MeasVector v);

    // Subtraction operator: Manifold x Manifold -> Tangent Vector Space
    MeasVector operator-(CalibrationMeasureManifoldElement y);

    // Compute the mean of samples points belonging to the manifold. Since the mean is defined as
    // being the element thast minimises sum of the squared distances, the manifold needs to be
    // Riemannian.
    static CalibrationMeasureManifoldElement ComputeMean(
            std::vector<CalibrationMeasureManifoldElement> samples);

    std::string PrintSelf();

    Eigen::Vector3d position_;
    SO3<double> orientation_;
    double focal_;
    Eigen::Vector2d principal_point_;
    double distortion_;
};

//--------------------------------------------------------------------------------------------------
/// Represent the state of an estimation (resp measure) by its element on the manifold and its
/// corresponding variance-covariance matrix defines on the tangent vector space
struct PredictionState {
    CalibrationStateManifoldElement predicted_element;
    StateVariance prediction_variance;
    CalibrationMeasureManifoldElement predicted_measure;
    MeasVariance measure_prediction_variance;
    Eigen::Matrix<double, kStateDims, kMeasDims> cross_covariance;
};

//--------------------------------------------------------------------------------------------------
/// Represents the current state of the broadcast camera estimation. The status is determined
/// by the best estimation which is an element of the calibration state manifold and by the
/// estimation uncertainty represented by the minimal-DoF variance-covariance matrix
template <typename F, typename H>
class BroadcastCameraEstimation {
  public:
    BroadcastCameraEstimation() = default;
    BroadcastCameraEstimation(CalibrationStateManifoldElement element,
                              StateVariance variance_matrix = StateVariance::Identity());

    // Methods
    // Add a measure to the kalman filter. The prediction step will be computed
    void NewMeasure(double dt, CalibrationMeasureManifoldElement measure,
                    MeasVariance measure_variance);

    // Predict the next state of the kalman filter: best estimator and and uncertainty
    PredictionState Prediction(double dt);

    // Generate the variance-covariance matrix of the motion model
    StateVariance GenerateMotionModelUncertainty(double dt);

    // Get / Set element
    CalibrationStateManifoldElement & element() { return element_; }
    const CalibrationStateManifoldElement & element() const { return element_; }

    // Get / Set variance_matrix
    StateVariance & variance_matrix() { return variance_matrix_; }
    const StateVariance & variance_matrix() const { return variance_matrix_; }

    // Get / Set uncertainty parameters
    double & max_angular_acceleration() { return max_angular_acceleration_; }
    const double & max_angular_acceleration() const { return max_angular_acceleration_; }

    double & max_focal_acceleration() { return max_focal_acceleration_; }
    const double & max_focal_acceleration() const { return max_focal_acceleration_; }

  protected:
    // represents the the best estimator and the related uncertainty
    CalibrationStateManifoldElement element_;
    StateVariance variance_matrix_ = StateVariance::Identity();

    // Prediction and measure equations
    F prediction_;
    H measure_;

    // uncertainty of motion model
    double max_angular_acceleration_ = 16.0 * M_PI;
    double position_uncertainty_ = 0.0;
    double angular_velocity_uncertainty_ = 0.0;
    double focal_velocity_uncertainty_ = 0.0;
    double max_focal_acceleration_ = 25.0;
    double distortion_uncertainty_ = 0.00;
    double principal_point_uncertainty_ = 0.0;
};

//--------------------------------------------------------------------------------------------------
class FixedPositionConstantAngularVelocityPrediction {
  public:
    FixedPositionConstantAngularVelocityPrediction() = default;

    CalibrationStateManifoldElement operator()(CalibrationStateManifoldElement X, double dt);
};

//--------------------------------------------------------------------------------------------------
class BundleAdjustmentMeasurement {
  public:
    CalibrationMeasureManifoldElement operator()(CalibrationStateManifoldElement X);
};

//--------------------------------------------------------------------------------------------------
template <typename T>
Eigen::Matrix<T, 3, 3> VectorToSkew(Eigen::Matrix<T, 3, 1> v) {
    Eigen::Matrix<T, 3, 3> skewV;
    skewV << 0, -v(2), v(1), v(2), 0, -v(0), -v(1), v(0), 0;
    return skewV;
}

//--------------------------------------------------------------------------------------------------
template <typename T>
Eigen::Matrix<T, 3, 1> SkewToVector(Eigen::Matrix<T, 3, 3> V) {
    Eigen::Matrix<T, 3, 1> v;
    v << V(2, 1), V(0, 2), V(1, 0);
    return v;
}

//--------------------------------------------------------------------------------------------------
template <typename T>
void SO3<T>::FromEulerAngle(T rx, T ry, T rz) {
    Eigen::Matrix<T, 3, 3> R(Eigen::AngleAxis<T>(rz, Eigen::Matrix<T, 3, 1>::UnitZ()) *
                             Eigen::AngleAxis<T>(ry, Eigen::Matrix<T, 3, 1>::UnitY()) *
                             Eigen::AngleAxis<T>(rx, Eigen::Matrix<T, 3, 1>::UnitX()));

    element_ = Eigen::Quaternion<T>(R);
}

//--------------------------------------------------------------------------------------------------
template <typename T>
Eigen::Matrix<T, 3, 3> SO3<T>::ToRotationMatrix() const {
    return element_.matrix();
}

//--------------------------------------------------------------------------------------------------
template <typename T>
Eigen::Quaternion<T> SO3<T>::ToQuaternion() const {
    return element_;
}

//--------------------------------------------------------------------------------------------------
template <typename T>
SO3<T> SO3<T>::operator+(Eigen::Matrix<T, 3, 1> v) const {
    // TODO(pierreguilbert): replace exponential of skew matrix by rodrigues formula for performance
    Eigen::Matrix<T, 3, 3> skewV = VectorToSkew(v);
    SO3<T> sum;
    sum.SetElement(element_ * Eigen::Quaternion<T>(skewV.exp()));
    return sum;
}

//--------------------------------------------------------------------------------------------------
template <typename T>
Eigen::Matrix<T, 3, 1> SO3<T>::operator-(SO3<T> y) const {
    Eigen::Matrix<T, 3, 3> log = (y.element_.inverse() * element_).matrix().log();
    return SkewToVector(log);
}

//--------------------------------------------------------------------------------------------------
template <typename T>
Eigen::Matrix<T, 3, 1> SO3<T>::ToAxisAngle() const {
    Eigen::AngleAxis<T> ax(element_);
    Eigen::Matrix<T, 3, 1> w = ax.angle() * ax.axis();
    return w;
}

//--------------------------------------------------------------------------------------------------
template <typename F, typename H>
BroadcastCameraEstimation<F, H>::BroadcastCameraEstimation(CalibrationStateManifoldElement element,
                                                           StateVariance variance_matrix) {
    element_ = element;
    variance_matrix_ = variance_matrix;
}

//--------------------------------------------------------------------------------------------------
template <typename F, typename H>
StateVariance BroadcastCameraEstimation<F, H>::GenerateMotionModelUncertainty(double dt) {
    // TODO(pierreguilbert): replace Monte-Carlo by analytic expression for performance
    // estimates it by using monte-carlo method
    StateVariance Q = StateVariance::Zero();

    const unsigned int n_sample = 250;
    for (unsigned int k = 0; k < n_sample; ++k) {
        // angular error
        Eigen::Vector3d angular_acceleration_error =
                max_angular_acceleration_ / std::sqrt(3) * Eigen::Vector3d::Random(3, 1);
        Eigen::Vector3d angular_velocity_error =
                angular_velocity_uncertainty_ * Eigen::Vector3d::Random(3, 1);
        Eigen::Vector3d angular_error =
                angular_velocity_error * dt + 0.5 * angular_acceleration_error * dt * dt;
        // position error
        Eigen::Vector3d position_error = position_uncertainty_ * Eigen::Vector3d::Random(3, 1);
        // focal error
        double focal_acceleration_error =
                max_focal_acceleration_ * Eigen::Vector2d::Random(2, 1)(0);
        double focal_velocity_error =
                focal_velocity_uncertainty_ * Eigen::Vector2d::Random(2, 1)(0);
        double focal_error = focal_velocity_error * dt + 0.5 * focal_acceleration_error * dt * dt;
        // distortion error
        double distortion_error = distortion_uncertainty_ * Eigen::Vector2d::Random(2, 1)(0);
        // principal point error
        Eigen::Vector2d principal_point_error =
                principal_point_uncertainty_ * Eigen::Vector2d::Random(2, 1);

        StateVector X_error;
        X_error.block(0, 0, 3, 1) = position_error;
        X_error.block(3, 0, 3, 1) = angular_error;
        X_error.block(6, 0, 3, 1) = angular_velocity_error + angular_acceleration_error * dt;
        X_error(9) = focal_error;
        X_error(10) = focal_velocity_error + focal_acceleration_error * dt;
        X_error.block(11, 0, 2, 1) = principal_point_error;
        X_error(13) = distortion_error;

        Q += X_error * X_error.transpose();
    }
    Q /= static_cast<double>(n_sample);
    return Q;
}

//--------------------------------------------------------------------------------------------------
template <typename F, typename H>
PredictionState BroadcastCameraEstimation<F, H>::Prediction(double dt) {
    // First add the prediction noise process
    StateVariance Q = GenerateMotionModelUncertainty(dt);
    StateVariance Incetitude = variance_matrix_ + Q;

    // Unscented Transform Prediction:
    // Generate the sigma points. It represents 2N+1 points of the manifold lying to the sigma-iso
    // probability surface with N being the dimension of the manifold
    std::vector<CalibrationStateManifoldElement> sigma_points =
            GenerateSigmaPoints<CalibrationStateManifoldElement, kStateDims>(element_, Incetitude);
    std::vector<StateVector> vect_bis =
            GenerateSigmaPoints<StateVector, kStateDims>(StateVector::Zero(), Incetitude);

    std::vector<StateVector> vect(sigma_points.size());
    for (unsigned int k = 0; k < sigma_points.size(); ++k) {
        vect[k] = sigma_points[k] - element_;

        // perform sanity check between:
        // - the displacement vector computed from the difference
        //   between the sigma points and the central element
        // - the displacement vectors corresponding to the sigma points
        //   generated from the variance covariance
        if ((vect[k] - vect_bis[k]).norm() > 1e-10) {
            std::wcerr << ""UKF prediction sanity test failed. Boundary domain definition reached ""
                          ""this can be due to a too high variance-covariance matrix. This will ""
                          ""result in an underestimation of the internal variance"";
        }
    }

    // apply the non-linear prediction and measurement equations to sigma points
    std::vector<CalibrationStateManifoldElement> prediction_sigma_points(sigma_points.size());
    std::vector<CalibrationMeasureManifoldElement> measurement_sigma_points(sigma_points.size());
    for (unsigned int k = 0; k < sigma_points.size(); ++k) {
        prediction_sigma_points[k] = prediction_(sigma_points[k], dt);
        measurement_sigma_points[k] = measure_(prediction_sigma_points[k]);
    }

    // from the transformed samples, compute the first two moment of the new distribution
    // Note that the mean is an element of the manifold and it should be computed using the
    // defined manifold Riemannian distance
    CalibrationStateManifoldElement mean_prediction =
            CalibrationStateManifoldElement::ComputeMean(prediction_sigma_points);
    CalibrationMeasureManifoldElement mean_measurement =
            CalibrationMeasureManifoldElement::ComputeMean(measurement_sigma_points);

    // Variance-Covariance is defined on the tangent vector space
    StateVariance variance_prediction = StateVariance::Zero();
    MeasVariance  [MASK]  = MeasVariance::Zero();
    Eigen::Matrix<double, kStateDims, kMeasDims> cross_variance =
            Eigen::Matrix<double, kStateDims, kMeasDims>::Zero();
    for (unsigned int k = 0; k < sigma_points.size(); ++k) {
        StateVector V = prediction_sigma_points[k] - mean_prediction;
        variance_prediction += V * V.transpose();

        MeasVector U = measurement_sigma_points[k] - mean_measurement;
         [MASK]  += U * U.transpose();

        cross_variance += V * U.transpose();
    }
    variance_prediction /= static_cast<double>(prediction_sigma_points.size());
     [MASK]  /= static_cast<double>(measurement_sigma_points.size());
    cross_variance /= static_cast<double>(sigma_points.size());

    PredictionState prediction_ret;
    prediction_ret.predicted_element = mean_prediction;
    prediction_ret.prediction_variance = variance_prediction;
    prediction_ret.predicted_measure = mean_measurement;
    prediction_ret.measure_prediction_variance =  [MASK] ;
    prediction_ret.cross_covariance = cross_variance;

    return prediction_ret;
}

//--------------------------------------------------------------------------------------------------
template <typename F, typename H>
void BroadcastCameraEstimation<F, H>::NewMeasure(double dt,
                                                 CalibrationMeasureManifoldElement measure,
                                                 MeasVariance measure_variance) {
    // first predict the next estimation and expected measures using the motion model
    PredictionState predicted_state = Prediction(dt);

    // Compute the gain of the kalman filter
    Eigen::Matrix<double, kStateDims, kMeasDims> K =
            predicted_state.cross_covariance *
            (predicted_state.measure_prediction_variance + measure_variance).inverse();

    // now update the kalman filter state by updating:
    // the estimation
    MeasVector error = measure - predicted_state.predicted_measure;  // manifold subtraction
    StateVector novelty = K * error;
    element_ = predicted_state.predicted_element + novelty;  // manifold addition

    // The variance-covariance
    variance_matrix_ =
            predicted_state.prediction_variance -
            K * (predicted_state.measure_prediction_variance + measure_variance) * K.transpose();
}

//--------------------------------------------------------------------------------------------------
template <unsigned int N>
Eigen::Matrix<double, N, N> MatrixSqrt(Eigen::Matrix<double, N, N> A) {
    // perform diagonalisation of A
    Eigen::SelfAdjointEigenSolver<Eigen::Matrix<double, N, N>> es;
    es.compute(A);

    Eigen::Matrix<double, N, N> sqrtEigVal = Eigen::Matrix<double, N, N>::Zero();
    for (unsigned int k = 0; k < N; ++k) {
        sqrtEigVal(k, k) = std::sqrt(es.eigenvalues()(k));
    }

    // Note that we use transpose instead of inverse because we expect A to be symmetric
    // using spectral theorem, we know that the eigen vectors basis is orthonormal
    return es.eigenvectors() * sqrtEigVal * es.eigenvectors().transpose();
}

//--------------------------------------------------------------------------------------------------
template <typename ManifoldElement, unsigned int N>
std::vector<ManifoldElement> GenerateSigmaPoints(ManifoldElement m, Eigen::Matrix<double, N, N> M) {
    // Get square root decomposition of M
    Eigen::Matrix<double, N, N> C = MatrixSqrt<N>(static_cast<double>(N) * M);
    // Fill sigma points
    std::vector<ManifoldElement> sigma_points(2 * N);
    for (unsigned int k = 0; k < N; ++k) {
        // Nothe that this is the addition define between the manifold and its tangent vector space
        sigma_points[2 * k] = m + C.col(k);
        sigma_points[2 * k + 1] = m + (-1.0 * C.col(k));
    }
    return sigma_points;
}

}  // namespace ukf

#endif  // ALGORITHMS_UKF_INCLUDE_UNSCENTED_KALMAN_FILTER_H_
",variance_measurement
787,"#include <SFML/Graphics.hpp>
#include <Box2D/Box2D.h>
#include ""b2GLDraw.h""

/** We need this to easily convert between pixel and real-world coordinates*/
static const float SCALE = 30.f;

/** Create the base for the boxes to land */
void CreateGround(b2World& World, float X, float Y);

/** Create the boxes */
void CreateBox(b2World& World, int MouseX, int MouseY);

int main()
{
	/** Prepare the window */
	sf::RenderWindow Window(sf::VideoMode(640, 480, 32), ""Test"");
	Window.setFramerateLimit(60);

	/** Prepare the world */
	b2Vec2 Gravity(0.f, 9.8f);
	b2World World(Gravity);
	CreateGround(World, 400.f, 500.f);

	b2GLDraw fooDrawInstance;
	World.SetDebugDraw(&fooDrawInstance);
	uint32 flags = 0;
	flags += b2Draw::e_shapeBit;
	flags += b2Draw::e_jointBit;
	flags += b2Draw::e_aabbBit;
	flags += b2Draw::e_pairBit;
	flags += b2Draw::e_centerOfMassBit;
	fooDrawInstance.SetFlags(flags);

	/** Prepare textures */
	sf::Texture GroundTexture;
	sf::Texture  [MASK] ;
	GroundTexture.loadFromFile(""ground.png"");
	 [MASK] .loadFromFile(""box.png"");

	while (Window.isOpen())
	{
		if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
		{
			int MouseX = sf::Mouse::getPosition(Window).x;
			int MouseY = sf::Mouse::getPosition(Window).y;
			CreateBox(World, MouseX, MouseY);
		}
		World.Step(1 / 60.f, 8, 3);

		Window.clear(sf::Color::White);


		int BodyCount = 0;
		for (b2Body* BodyIterator = World.GetBodyList(); BodyIterator != 0; BodyIterator = BodyIterator->GetNext())
		{
			if (BodyIterator->GetType() == b2_dynamicBody)
			{
				sf::Sprite Sprite;
				Sprite.setTexture( [MASK] );
				Sprite.setOrigin(16.f, 16.f);
				Sprite.setPosition(SCALE * BodyIterator->GetPosition().x, SCALE * BodyIterator->GetPosition().y);
				Sprite.setRotation(BodyIterator->GetAngle() * 180 / b2_pi);
				Window.draw(Sprite);
				++BodyCount;
			}
			else
			{
				sf::Sprite GroundSprite;
				GroundSprite.setTexture(GroundTexture);
				GroundSprite.setOrigin(400.f, 8.f);
				GroundSprite.setPosition(BodyIterator->GetPosition().x * SCALE, BodyIterator->GetPosition().y * SCALE);
				GroundSprite.setRotation(180 / b2_pi * BodyIterator->GetAngle());
				Window.draw(GroundSprite);
			}
		}

		World.DrawDebugData();

		Window.display();
	}

	return 0;
}

void CreateBox(b2World& World, int MouseX, int MouseY)
{
	b2BodyDef BodyDef;
	BodyDef.position = b2Vec2(MouseX / SCALE, MouseY / SCALE);
	BodyDef.type = b2_dynamicBody;
	b2Body* Body = World.CreateBody(&BodyDef);

	b2PolygonShape Shape;
	Shape.SetAsBox((32.f / 2) / SCALE, (32.f / 2) / SCALE);
	b2FixtureDef FixtureDef;
	FixtureDef.density = 1.f;
	FixtureDef.friction = 0.7f;
	FixtureDef.shape = &Shape;
	Body->CreateFixture(&FixtureDef);
}

void CreateGround(b2World& World, float X, float Y)
{
	b2BodyDef BodyDef;
	BodyDef.position = b2Vec2(X / SCALE, Y / SCALE);
	BodyDef.type = b2_staticBody;
	b2Body* Body = World.CreateBody(&BodyDef);

	b2PolygonShape Shape;
	Shape.SetAsBox((800.f / 2) / SCALE, (16.f / 2) / SCALE);
	b2FixtureDef FixtureDef;
	FixtureDef.density = 0.f;
	FixtureDef.shape = &Shape;
	Body->CreateFixture(&FixtureDef);
}
",BoxTexture
788,"#include ""foo/Foo.hpp""

#include <ortools/glop/lp_solver.h>
#include <ortools/lp_data/lp_data.h>
#include <ortools/lp_data/lp_types.h>

#include <iostream>

namespace foo {
using operations_research::glop::ColIndex;
using operations_research::glop::DenseRow;
using operations_research::glop::GlopParameters;
using operations_research::glop::LinearProgram;
using operations_research::glop::LPSolver;
using operations_research::glop::ProblemStatus;
using operations_research::glop::RowIndex;

void helloWorld() {
  std::cout << ""foo::hello()"";

  LinearProgram lp;
  // Create the variables x and y.
  ColIndex col_x = lp.FindOrCreateVariable(""x"");
  lp.SetVariableBounds(col_x, 0.0, 1.0);
  ColIndex col_y = lp.FindOrCreateVariable(""y"");
  lp.SetVariableBounds(col_y, 0.0, 2.0);

  // Create linear constraint: 0 <= x + y <= 2.
  RowIndex row_r1 = lp.FindOrCreateConstraint(""r1"");
  lp.SetConstraintBounds(row_r1, 0.0, 2.0);
  lp.SetCoefficient(row_r1, col_x, 1);
  lp.SetCoefficient(row_r1, col_y, 1);

  // Create objective function: 3 * x + y.
  lp.SetObjectiveCoefficient(col_x, 3);
  lp.SetObjectiveCoefficient(col_y, 1);
  lp.SetMaximizationProblem(true);

  lp.CleanUp();

  std::cout << ""Number of variables = "" << lp.num_variables() << std::endl;
  std::cout << ""Number of constraints = "" << lp.num_constraints() << std::endl;

  LPSolver solver;
  GlopParameters parameters;
  parameters.set_provide_strong_optimal_guarantee(true);
  solver.SetParameters(parameters);

  ProblemStatus  [MASK]  = solver.Solve(lp);
  if ( [MASK]  == ProblemStatus::OPTIMAL) {
    std::cout << ""Optimal solution found !"" << std::endl;
    // The objective value of the solution.
    std::cout << ""Optimal objective value = "" << solver.GetObjectiveValue()
              << std::endl;
    // The value of each variable in the solution.
    const DenseRow& values = solver.variable_values();
    std::cout << ""Solution:"" << std::endl
              << ""x = "" << values[col_x] << std::endl
              << "", y = "" << values[col_y] << std::endl;
  }
}

void Foo::operator()() const { std::cout << ""foo::Foo()()""; }
}  // namespace foo
",status
789,"#include<algorithm>
#include<array>
#include<bitset>
#include<exception>
#include<iomanip>
#include<iostream>
#include<fstream>
#include<tuple>
#include<vector>

inline uint countbits(const uint n) {
    return __builtin_popcount(n);
}

class Sudoku {
    private:
        std::vector<std::tuple<uint,uint>> undostack ;
        long numundo = 0 ;
        bool validation = false ;
        std::array<uint,9> row{};
        std::array<uint,9> col{};
        std::array<uint,9> blk{};
        std::array<std::array<uint,9>,9> sudoku{} ;
        std::array<std::array<uint,9>,9> sudoku_test{} ;

        void iset(int r, int c, int v) {
            const uint vv = 1<<(v-1) ;
            sudoku[r][c] = v ;
            row[r] |= vv ;
            col[c] |= vv ;
            blk[3*int(r/3)+int(c/3)] |= vv ;
            undostack.push_back({r,c});
        }

        void tset(int r, int c, int v) {
            sudoku_test[r][c] = v ;
        }

        void undo() {
            const auto [r,c] = undostack.back() ;
            const auto v = ~(1<<(sudoku[r][c]-1)) ;
            sudoku[r][c] = 0 ;
            row[r] &= v ;
            col[c] &= v ;
            blk[3*int(r/3)+int(c/3)] &= v ;
            undostack.pop_back();
            ++numundo ;
        }

        void clear() {
            undostack.clear();
            row.fill(0);
            col.fill(0);
            blk.fill(0);
            for(auto n = 0 ; n < 9 ; ++n) {
                sudoku[n].fill(0) ;
                sudoku_test[n].fill(0) ;
            }
            numundo = 0;
            validation = false;
        }

    public:
        Sudoku() {}
        virtual ~Sudoku() {}

        void init(std::istream& ins) {
            clear();
            ins >> std::skipws ;
            for(auto r = 1; r < 10; ++r) {
                for(auto c = 1; c < 10; ++c) {
                    int v = 0 ;
                    ins >> v ;
                    set(r, c, v);
                    if (!ins) {
                        throw std::runtime_error(""Sudoku initial state given in invalid format."");
                    }
                }
            }
        }

        void print(std::ostream& out) const {
            for(auto r = 0; r < 9; ++r) {
                for( auto c = 0; c < 9; ++c) {
                    out << std::setw(2) << sudoku[r][c] ;
                }
                out << std::endl ;
            }
        }

        uint countUndo() const {
            return numundo ;
        }

        void set(int r, int c, int v) {
                if (0 < v && v < 10) {
                    iset(r-1,c-1,v);
                    tset(r-1,c-1,v);
                }
                else if (-10 < v && v < 0) {
                    validation=true;
                    tset(r-1,c-1,-v);
                }
                else if (v) {
                    throw std::out_of_range(""invalid entry, values must be between 1 and 9."");
                }
        }

        bool forValidation() const {
            return validation ;
        }

        void verify(std::ostream& out) const {
            uint  [MASK] =0 ;
            for(auto r = 0; r < 9; ++r) {
                for(auto c = 0; c < 9; ++c) {
                    if (sudoku_test[r][c] > 0) {
                        if (sudoku_test[r][c] == sudoku[r][c]) {
                            out << std::setw(2) << sudoku[r][c] ;
                        } else {
                            [MASK] ++;
                           out << std::setw(2) << 'X' ;
                        }
                    } else {
                        out << std::setw(2) << '.' ;
                    }
                }
                out << std::endl ;
            }
        }

        bool solve() {
            uint r_opt = 0 ;
            uint c_opt = 0 ;
            uint m_opt = 0 ;
            uint v_opt = 0 ;
            uint x_opt = 0 ;
            bool done  = true ;
            for(uint r = 0; r < 9; ++r) {
                for(uint c = 0; c < 9; ++c) {
                    if (sudoku[r][c] != 0) {
                        continue ;
                    }
                    done = false ;
                    uint v = (row[r]|col[c]|blk[3*int(r/3)+int(c/3)]) ;
                    uint m = countbits(v);
                    x_opt = std::max(x_opt, 9 - m);
                    if (m > m_opt && m != 9) {
                        r_opt = r ;
                        c_opt = c ;
                        v_opt = v ;
                        m_opt = m ;
                    }
                }
            }
            if (done == true) {
                return true ;
            }
            if (x_opt == 0) {
                return false ;
            }
            for(auto v = 1; v < 10; ++v) {
                if ((v_opt & 1) == 0) {
                    iset(r_opt, c_opt, v);
                    if (solve()) {
                        return true ;
                    }
                    undo();
                }
                v_opt >>= 1;
            }
            return false ;
        }
};

std::ostream& operator<<(std::ostream& out, const Sudoku& sudoku) {
    if (sudoku.forValidation()) {
        sudoku.verify(out);
    } else {
        sudoku.print(out) ;
    }
    return out ;
};

int main(int c, const char* v[]) {
    Sudoku sudoku ;
    sudoku.init(std::cin);
    if (sudoku.solve()) {
        std::cout << sudoku << std::endl;
        std::cout << ""Undo: "" << sudoku.countUndo() << std::endl ;
    } else {
        std::cout << ""no solution"" << std::endl;
    }
    return 0;
}


",numbad
790,"
/*
* Code to read RFID tags and then log an entry to a website
 */

 /*
 * MFRC522 - Library to use ARDUINO RFID MODULE KIT 13.56 MHZ WITH TAGS SPI W AND R BY COOQROBOT.
 * The library file MFRC522.h has a wealth of useful info. Please read it.
 * The functions are documented in MFRC522.cpp.
 *
 * Based on code Dr.Leong   ( WWW.B2CQSHOP.COM )
 * Created by <NAME> (circuitito.com), Jan, 2012.
 * Rewritten by <NAME> (access.thing.dk), fall of 2013 (Translation to English, refactored, comments, anti collision, cascade levels.)
 * Released into the public domain.
 *
 * Sample program showing how to read data from a PICC using a MFRC522 reader on the Arduino SPI interface.
 *----------------------------------------------------------------------------- empty_skull 
 * Aggiunti pin per arduino Mega
 * add pin configuration for arduino mega
 * http://mac86project.altervista.org/
 ----------------------------------------------------------------------------- <NAME>
 * Pin layout should be as follows:
 * Signal     Pin              Pin               Pin
 *            Arduino Uno      Arduino Mega      MFRC522 board
 * ------------------------------------------------------------
 * Reset      9                5                 RST
 * SPI SS     10               53                SDA
 * SPI MOSI   11               51                MOSI
 * SPI MISO   12               50                MISO
 * SPI SCK    13               52                SCK
 *
 * The reader can be found on eBay for around 5 dollars. Search for ""mf-rc522"" on ebay.com. 
 */

#include <SPI.h>
#include <MFRC522.h>
#include <WiFi.h>
#include <string.h>
#include <HomeWiFi.h> //  credentials for wireless network
#include <RFIDSettings.h> // WEBSERVER and TAGINURL settings

#define RST_PIN		9
#define SS_PIN		10

// Although with a Galileo board already on the wifi, I am not sure that
// WiFi.begin is actually required...?

char ssid[] = WIFI_SSID; //  your network SSID (name) 
char pass[] = WIFI_PASSWORD;    // your network password (use for WPA, or use as key for WEP)

char webServer[] = WEBSERVER; // e.g. myserver.com
char webURL[] = TAGINURL; // e.g. cgi-bin/tagin.cgi

int cardID[8];
//int ethansCard[4] = {9, 110, 122, 158};
//byte ethansCard[4] = {0x9, 0x6E, 0x7A, 0x9E };
byte ethansCard[4] = {0xC4, 0x5D, 0xD2, 0xB7 };
byte ronansCard[4] = {0x6A, 0x32, 0x20, 0x2B };
byte ivansCard[4] = { 0x74, 0x1D, 0xDB, 0xB7 };
byte swaglordsTag[4] = { 0x01, 0x1A, 0x35, 0x40 };

int matchStatus;

WiFiClient wirelessClient;
int status = WL_IDLE_STATUS;

MFRC522 mfrc522(SS_PIN, RST_PIN);	// Create MFRC522 instance

void setup() {
	Serial.begin(9600);		// Initialize serial communications with the PC
  while (!Serial);    // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
  
 // No need to connect to Wifi network: on Galileo the board is already connected
 //status = 0;
  /*while (status != WL_CONNECTED) { 
    Serial.print(""Attempting to connect to SSID: "");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
    status = WiFi.begin(ssid, pass);
  
    // wait for connection:
    delay(2000);
  } 
  Serial.println(""Connected to wifi"");  */
  //printWifiStatus();
  
	
	SPI.begin();			// Init SPI bus
	mfrc522.PCD_Init();		// Init MFRC522
	ShowReaderDetails();	// Show details of PCD - MFRC522 Card Reader details
	Serial.println(F(""Scan tag to check in to class...""));
}

void loop() {
	// Look for new cards
	if ( ! mfrc522.PICC_IsNewCardPresent()) {
		delay(100);
	}

	// Select one of the cards
	if ( ! mfrc522.PICC_ReadCardSerial()) {
		return;
	}
  Serial.print(""This card has UID: "");
  printCardUID(mfrc522.uid.uidByte,mfrc522.uid.size);

  if (memcmp(mfrc522.uid.uidByte, ethansCard, 4) == 0) {
    Serial.println(""Welcome Ethan :)"");
    TagIn(""ethan"");
  } else if (memcmp(mfrc522.uid.uidByte, ronansCard, 4)==0) {
    Serial.println(""Welcome Ronan :)"");
    TagIn(""ronan"");
  } else if (memcmp(mfrc522.uid.uidByte, ivansCard, 4)==0) {
    Serial.println(""Welcome Ronan :)"");
    TagIn(""ivan"");
  } else if (memcmp(mfrc522.uid.uidByte, swaglordsTag, 4)==0) {
    Serial.println(""Welcome swaglord"");
    TagIn(""swaglord"");
  } else {
    Serial.println(""This tag is unknown!"");
  }
  
  delay(300);

  
	// Dump debug info about the card; PICC_HaltA() is automatically called
	//mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
}

void printCardUID(byte IDarray[10], int  [MASK] ) {
  
  for (byte i = 0; i <  [MASK] ; i++) {
    if(IDarray[i] < 0x10)
      Serial.print(F("" 0""));
    else
      Serial.print(F("" ""));
      Serial.print(IDarray[i], HEX);
      cardID[i] = IDarray[i];
  } 
  Serial.println();
}

void TagIn(char *tagname) {
  char URLString[100];
	char HOSTLine[100];
	
  WiFiClient client;
  //Serial.print(""TagIn function: You have asked me to tag in the user: "");
  //Serial.println(tagname);
  
   Serial.print(""\nStarting connection to "");
   Serial.println(webServer);
  
  if (client.connect(webServer, 80)) {
    Serial.println(""connected to server successfully. "");
    
    // Construct the HTTP request:
    sprintf(URLString,""GET %s?name=%s HTTP/1.0"",TAGINURL,tagname);
	  sprintf(HOSTLine,""Host: %s"",WEBSERVER);

    client.println(URLString);

    client.println(HOSTLine);
    
    client.println(""Connection: close"");
    client.println();
    
    Serial.print(""Sent tag-in request for "");
    Serial.println(tagname);
    // Print out any response from the server...
    //while (client.available()) {
      //char c = client.read();
      //Serial.write(c);
    //}
  } else {
    Serial.print(""Connection to webserver "");
    Serial.print(webServer);
    Serial.println("" failed!"");
  }
  
  //client.stop();  This SEGFAULTs
  
  
}



void printCardID(int cardID[4]) {
  for (byte i = 0; i < 8; i++) {
    if(cardID[i] < 0x10)
      Serial.print(F("" 0""));
    else
      Serial.print(F("" ""));
      Serial.print(cardID[i], HEX);
  } 
  Serial.println();
}

void ShowReaderDetails() {
	// Get the MFRC522 software version
	byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg);
	Serial.print(F(""MFRC522 Software Version: 0x""));
	Serial.print(v, HEX);
	if (v == 0x91)
		Serial.print(F("" = v1.0""));
	else if (v == 0x92)
		Serial.print(F("" = v2.0""));
	else
		Serial.print(F("" (unknown)""));
	Serial.println("""");
	// When 0x00 or 0xFF is returned, communication probably failed
	if ((v == 0x00) || (v == 0xFF)) {
		Serial.println(F(""WARNING: Communication failure, is the MFRC522 properly connected?""));
	}
}
",IDsize
791,"#include <iostream>
#include <string>
#include <boost/lexical_cast.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/filter/bzip2.hpp>
#include <boost/timer/timer.hpp>

int main(int argc, char* argv[])
{
	using std::cout;
	using std::string;
	using boost::lexical_cast;
	using namespace boost::filesystem;
	using namespace boost::iostreams;
	using namespace boost::timer;

	if (argc != 3)
	{
		cout << ""boostzip stem.gz offset\n"";
		return 0;
	}

	const path p = argv[1];
	const string ext = p.extension().string();
	string line;
/*
	const size_t max_size = 4 * 12171187; // 46.5MB
	float* h_mwt = (float*)malloc(max_size);
	float* h_lgp = (float*)malloc(max_size);
	float* h_nrb = (float*)malloc(max_size);
	float* h_hbd = (float*)malloc(max_size);
	float* h_hba = (float*)malloc(max_size);
	float* h_chg = (float*)malloc(max_size);
	float* h_ads = (float*)malloc(max_size);
	float* h_pds = (float*)malloc(max_size);
	float* h_psa = (float*)malloc(max_size);

	size_t num_ligands = 0;
	auto_cpu_timer t;
*/

	ifstream in(p);
	filtering_istream  [MASK] ;
	if (ext == "".gz"")  [MASK] .push(gzip_decompressor()); else if (ext == "".bz2"")  [MASK] .push(bzip2_decompressor());
	 [MASK] .push(in);
	in.seekg(lexical_cast<size_t>(argv[2]));
	for (size_t i = 0; i < 1; ++i)
	{
		getline( [MASK] , line);
		cout << line << '\n';
/*
		const size_t t1 = line.find_first_of('\t', 3);
		const size_t t2 = line.find_first_of('\t', t1 + 5);
		const size_t t3 = line.find_first_of('\t', t2 + 2);
		const size_t t4 = line.find_first_of('\t', t3 + 2);
		const size_t t5 = line.find_first_of('\t', t4 + 2);
		const size_t t6 = line.find_first_of('\t', t5 + 2);
		const size_t t7 = line.find_first_of('\t', t6 + 2);
		const size_t t8 = line.find_first_of('\t', t7 + 2);
		const float mwt = lexical_cast<float>(line.substr(0, t1));
		const float lgp = lexical_cast<float>(line.substr(t1 + 1, t2 - t1 - 1));
		const float ads = lexical_cast<float>(line.substr(t2 + 1, t3 - t2 - 1));
		const float pds = lexical_cast<float>(line.substr(t3 + 1, t4 - t3 - 1));
		const int hbd = lexical_cast<int>(line.substr(t4 + 1, t5 - t4 - 1));
		const int hba = lexical_cast<int>(line.substr(t5 + 1, t6 - t5 - 1));
		const float psa = lexical_cast<float>(line.substr(t6 + 1, t7 - t6 - 1));
		const int chg = lexical_cast<int>(line.substr(t7 + 1, t8 - t7 - 1));
		const int nrb = lexical_cast<int>(line.substr(t8 + 1));
		h_mwt[num_ligands] = mwt;
		h_lgp[num_ligands] = lgp;
		h_nrb[num_ligands] = nrb;
		h_hbd[num_ligands] = hbd;
		h_hba[num_ligands] = hba;
		h_chg[num_ligands] = chg;
		h_ads[num_ligands] = ads;
		h_pds[num_ligands] = pds;
		h_psa[num_ligands] = psa;
		++num_ligands;
*/
	}
	in.seekg(lexical_cast<size_t>(argv[3]));
	for (size_t i = 0; i < 1; ++i)
	{
		getline( [MASK] , line);
		cout << line << '\n';
	}
/*
	free(h_mwt);
	free(h_lgp);
	free(h_nrb);
	free(h_hbd);
	free(h_hba);
	free(h_chg);
	free(h_ads);
	free(h_pds);
	free(h_psa);
*/
	return 0;
}
",fis
792,"#include ""gbConfig.h""
#include ""osd.h""
#include ""gbGlobals.h""

#include ""PS2Kbd.h""

#include ""keys.h""
#include ""hardware.h""
#include ""gb_sdl_font8x8.h""
#include <string.h>


#ifdef use_lib_vga8colors
 #define ID_COLOR_BLACK 0 //Negro
 #define ID_COLOR_WHITE 7 //Blanco
 //#define ID_COLOR_MAGENTA 6 //Magenta
 #define ID_COLOR_MAGENTA 3 //Magenta
#else
// #define ID_COLOR_BLACK 0 //Negro
// #define ID_COLOR_WHITE 7 //Blanco
// //#define ID_COLOR_MAGENTA 6 //Magenta
// #define ID_COLOR_MAGENTA 3 //Magenta

 #define ID_COLOR_BLACK 0 //Negro
 #define ID_COLOR_WHITE 255 //Blanco
 #define ID_COLOR_MAGENTA 6 //Magenta 
#endif 

volatile unsigned char gb_show_osd_main_menu=0;

//********************************************************************
void SDLClear()
{
 unsigned int a32= gb_cache_color[0];
 a32= a32|(a32<<8)|(a32<<16)|(a32<<24);
 for (int y=0; y<gb_topeY; y++){
  for (int x=0; x<gb_topeX_div4; x++){
   gb_buffer_vga32[y][x]= a32;
  }
 }
}


#define max_gb_main_menu 5
const char * gb_main_menu[max_gb_main_menu]={
 ""Load or Run ROM"",
 ""Speed"",
 ""Reset"",
 ""Exit"",
 ""Return""
};

#define max_gb_speed_uzebox 2
const char * gb_speed_uzebox[max_gb_speed_uzebox]={
 ""Normal"",
 ""Turbo""
};

#define max_list_romextra 5
const char * gb_list_romextra_title[max_list_romextra]={
 ""Tutorial"",
 ""ControllerTester"",
 ""BitmapDemo"",
 ""Chess4uzebox"",
 ""MegaSokoban""
};


#define gb_pos_x_menu 60
#define gb_pos_y_menu 50
#define gb_osd_max_rows 10

void jj_fast_putpixel(int x,int y,unsigned char c)
{
 gb_buffer_vga[y][x^2]= gb_cache_color[c];
}


//*************************************************************************************
void SDLprintCharOSD(char car,int x,int y,unsigned char color,unsigned char backcolor)
{ 
// unsigned char aux = gb_sdl_font_6x8[(car-64)];
 int auxId = car << 3; //*8
 unsigned char aux;
 unsigned char auxBit,auxColor;
 for (unsigned char j=0;j<8;j++)
 {
  aux = gb_sdl_font_8x8[auxId + j];
  for (int i=0;i<8;i++)
  {
   auxColor= ((aux>>i) & 0x01);
   //SDLputpixel(surface,x+(6-i),y+j,(auxColor==1)?color:backcolor);
   jj_fast_putpixel(x+(6-i),y+j,(auxColor==1)?color:backcolor);
  }
 }
}

void SDLprintText(const char *cad,int x, int y, unsigned char color,unsigned char backcolor)
{
//SDL_Surface *surface,
// gb_sdl_font_6x8
 int auxLen= strlen(cad);
 if (auxLen>50)
  auxLen=50;
 for (int i=0;i<auxLen;i++)
 {
  SDLprintCharOSD(cad[i],x,y,color,backcolor);
  x+=7;
 }
}

void OSDMenuRowsDisplayScroll(const char **ptrValue,unsigned char currentId,unsigned char aMax)
{//Dibuja varias lineas
 //jjvga vga.setTextColor(WHITE,BLACK);
 for (int i=0;i<gb_osd_max_rows;i++)
 {
  //jjvga vga.setCursor(gb_pos_x_menu, gb_pos_y_menu+8+(i<<3));
  //jjvga vga.print(""                    "");
  SDLprintText(""                    "",gb_pos_x_menu,gb_pos_y_menu+8+(i<<3),ID_COLOR_BLACK,ID_COLOR_BLACK);
 }
 
 for (int i=0;i<gb_osd_max_rows;i++)
 {
  if (currentId >= aMax)
   break;
//jjvga   if (i == 0)
//jjvga    vga.setTextColor(CYAN,BLUE);
//jjvga   else
//jjvga    vga.setTextColor(WHITE,BLACK);
//jjvga   vga.setCursor(gb_pos_x_menu, gb_pos_y_menu+8+(i<<3));
//jjvga   vga.print(ptrValue[currentId]);
  SDLprintText(ptrValue[currentId],gb_pos_x_menu,gb_pos_y_menu+8+(i<<3),((i==0)?ID_COLOR_WHITE:ID_COLOR_WHITE),((i==0)?ID_COLOR_MAGENTA:ID_COLOR_BLACK));
  currentId++;
 }     
}



//Maximo 256 elementos
unsigned char ShowTinyMenu(const char *cadTitle,const char **ptrValue,unsigned char aMax)
{
 unsigned char aReturn=0;
 unsigned char salir=0; 
//jjvga  #ifdef use_lib_vga320x240
//jjvga   vga.clear(BLACK);
//jjvga   vga.fillRect(0,0,320,240,BLACK);
//jjvga   vga.fillRect(0,0,320,240,BLACK);//Repeat Fix visual defect   
//jjvga  #else
//jjvga   #ifdef use_lib_vga320x200
//jjvga    vga.clear(BLACK);
//jjvga    vga.fillRect(0,0,320,200,BLACK);
//jjvga    vga.fillRect(0,0,320,200,BLACK);//Repeat Fix visual defect 
//jjvga   #else
//jjvga    #ifdef use_lib_vga360x200
//jjvga     vga.clear(BLACK);
//jjvga     vga.fillRect(0,0,360,200,BLACK);
//jjvga     vga.fillRect(0,0,360,200,BLACK);//Repeat Fix visual defect 
//jjvga    #endif
//jjvga   #endif  
//jjvga  #endif
 //jjvga vTaskDelay(2);
 //jjvga vga.setTextColor(WHITE,BLACK);
 //jjvga vga.setCursor((gb_pos_x_menu-(32)), gb_pos_y_menu-16); 
 //jjvga vga.print(""Mod ZXESPectrum by Ackerman"");
 //jjvga vga.setTextColor(BLACK,WHITE);
 //SDLClear(gb_osd_sdl_surface);   

 SDLClear(); 
 SDLprintText(""ESP32 UZEBOX by Ackerman"",(gb_pos_x_menu-(32)),(gb_pos_y_menu-16),ID_COLOR_WHITE,ID_COLOR_BLACK);
 //for (int i=0;i<20;i++)
 for (int i=0;i<14;i++)
 { 
  SDLprintCharOSD(' ',gb_pos_x_menu+(i<<3),gb_pos_y_menu,ID_COLOR_BLACK,ID_COLOR_WHITE);
  //SDLprintChar(gb_osd_sdl_surface,' ',gb_pos_x_menu+(i<<3),gb_pos_y_menu,BLACK,WHITE,1);
  //jjvga vga.setCursor((gb_pos_x_menu+(i*6)), gb_pos_y_menu);
  //jjvga vga.print("" "");
 } 
 //SDLprintText(gb_osd_sdl_surface,cadTitle,gb_pos_x_menu,gb_pos_y_menu,BLACK,WHITE,1);
 //jjvga vga.setCursor(gb_pos_x_menu,gb_pos_y_menu);
 //jjvga vga.print(cadTitle);  
 //for (int i=0;i<aMax;i++)
 //{     
 // //SDLprintText(gb_osd_sdl_surface,ptrValue[i],gb_pos_x_menu,gb_pos_y_menu+8+(i<<3),((i==0)?CYAN:WHITE),((i==0)?BLUE:BLACK),1);  
 // vga.setTextColor(((i==0)?CYAN:WHITE),((i==0)?BLUE:BLACK));
 // vga.setCursor(gb_pos_x_menu,(gb_pos_y_menu+8+(i<<3)));
 // vga.print(ptrValue[i]);
 //}
 SDLprintText(cadTitle,gb_pos_x_menu,gb_pos_y_menu,ID_COLOR_BLACK,ID_COLOR_WHITE);
 OSDMenuRowsDisplayScroll(ptrValue,0,aMax);
 //SDL_Flip(gb_osd_sdl_surface); 
 while (salir == 0)
 {             
  //case SDLK_UP:  
  if (checkAndCleanKey(KEY_CURSOR_LEFT))
  {
   if (aReturn>10) aReturn-=10;
   OSDMenuRowsDisplayScroll(ptrValue,aReturn,aMax);       
  }
  if (checkAndCleanKey(KEY_CURSOR_RIGHT))
  {
   if (aReturn<(aMax-10)) aReturn+=10;
   OSDMenuRowsDisplayScroll(ptrValue,aReturn,aMax);       
  }  
  if (checkAndCleanKey(KEY_CURSOR_UP))
  {
   if (aReturn>0) aReturn--;
   OSDMenuRowsDisplayScroll(ptrValue,aReturn,aMax);
  }
  if (checkAndCleanKey(KEY_CURSOR_DOWN))
  {
   if (aReturn < (aMax-1)) aReturn++;
   OSDMenuRowsDisplayScroll(ptrValue,aReturn,aMax);
  }
  if (checkAndCleanKey(KEY_ENTER))
  {
   salir= 1;
  }
  //case SDLK_KP_ENTER: case SDLK_RETURN: salir= 1;break;
  if (checkAndCleanKey(KEY_ESC))
  {
   salir=1; aReturn= 255;    
  }
  //case SDLK_ESCAPE: salir=1; aReturn= 255; break;
  //default: break;    
 }
 gb_show_osd_main_menu= 0;
 return aReturn;
}


//Menu velocidad emulador
void ShowTinySpeedMenu()
{
 unsigned char aSelNum,aSelNumSpeed;
 
 #ifdef use_lib_log_serial
  Serial.printf(""ShowTinySpeedMenu\n"");
 #endif
 
 aSelNum = ShowTinyMenu(""SPEED CPU"",gb_speed_uzebox,max_gb_speed_uzebox);
 if (aSelNum == 255)
  return;
 gb_speed_turbo = aSelNum;
}

void ShowTinyLoadROMMenu()
{

 unsigned char  [MASK] ;
  [MASK] = ShowTinyMenu(""Load ROM"",gb_list_romextra_title,max_list_romextra);
 if ( [MASK] ==255){
  return; 
 }
 gb_id_cur_rom=  [MASK] ;
 gb_load_new_rom= 1;
 
 #ifdef use_lib_log_serial
  Serial.printf(""ShowTinyLoadROMMenu id:%d\n"",gb_id_cur_rom);
 #endif  
}



void do_tinyOSD() 
{
 unsigned char aSelNum;
// SDLprintText(""Ackerman Mod ZXESP32 Win32 Emulator"",10,250,BLACK,WHITE);
 if (gb_show_osd_main_menu == 1)
 {
  delay(50);
  aSelNum = ShowTinyMenu(""MAIN MENU"",gb_main_menu,max_gb_main_menu);
  switch (aSelNum)
  {
   //case 0: ShowTinyMachineMenu(); break;
   case 0: ShowTinyLoadROMMenu(); break;
   case 1: ShowTinySpeedMenu(); break;

   case 2: break;
   case 3: gb_done=1; break;
   default: break;
  }
 }
}",aSelLoadROM
793,"const int selectPin[] = { 10, 11, 12, 9 };
const int dataPin[] = { 8, 7, 6, 5, 4, 3, 2 };

int keyNote[4][7];
int keyNoteOld[4][7];

long lastDebounceTime[4][7];
long debounceDelay = 20;

void noteOn(int  [MASK] , int pitch, int velocity) {
  Serial.write( [MASK] );
  Serial.write(pitch);
  Serial.write(velocity);
}

void initPins(){

    for (int i = 0; i < 4; i++){
      pinMode(selectPin[i], OUTPUT);
    }
    for (int i = 0; i < 7; i++){
      pinMode(dataPin[i], INPUT);
    }
    
    //for (int s = 0; s < 6; s++) {
    //  for (int d = 0; d < 12; d++) {
    //    lastDebounceTime[s][d] = 0;
    //  }
    //}
    
}

void readNote(){
    //select
    for (int s = 0; s < 4; s++) {
        digitalWrite(selectPin[s], HIGH);

        //data
        for (int d = 0; d < 7; d++) {
            keyNote[s][d] = digitalRead(dataPin[d]);
            //if (keyNote[s][d] != keyNoteOld[s][d]){
            //  lastDebounceTime[s][d] = millis();
            //}
        }
        digitalWrite(selectPin[s], LOW);
    }
}

void setup()   {                
  Serial.begin(31250);
  //Serial.begin(9600);
  initPins();
}

void loop() {
  readNote();
  
  for (int s = 0; s < 4; s++){
    for (int d = 0; d < 7; d++){
     // if ((millis() - lastDebounceTime[s][d]) > debounceDelay) {
      if (keyNote[s][d] == 1 && keyNote[s][d] != keyNoteOld[s][d]){
        
        if ((millis() - lastDebounceTime[s][d]) > debounceDelay) {
        //Serial.print(s);
        //Serial.print("":"");
        //Serial.print(d);
        //Serial.println(""=1"");
        //usbMIDI.sendNoteOn(35+s*5+d, 100, s+1);
        if (s == 3 && d == 6){
          noteOn(0x90, d+(s*7)+48-1, 0);
          //Serial.print(d+(s*7)+48-1);
        }
        else {
          noteOn(0x90, d+(s*7)+48, 0);
          //Serial.print(d+(s*7)+48);
        }
        //delay(100);
        keyNoteOld[s][d] = keyNote[s][d];
        lastDebounceTime[s][d] = millis();
        }
      }
        else if (keyNote[s][d] == 0 && keyNote[s][d] != keyNoteOld[s][d]){
          if ((millis() - lastDebounceTime[s][d]) > debounceDelay) {
        //Serial.print(s);
        //Serial.print("":"");
        //Serial.print(d);
        //Serial.println(""=0"");
        //usbMIDI.sendNoteOff(35+s*5+d, 100, s+1);
        if (s == 3 && d == 6){
        noteOn(0x90, d+(s*7)+48-1, 0x4F);
        //Serial.print(d+(s*7)+48-1);
        }
        else {
        noteOn(0x90, d+(s*7)+48, 0x4F);
        //Serial.print(d+(s*7)+48);
        }
        //delay(100);
        keyNoteOld[s][d] = keyNote[s][d];
        lastDebounceTime[s][d] = millis();
        }
      }
    }
  }
}
",cmd
794,"#include <iostream>
#include <Eigen/Dense>
#include <cmath>
#include <stdexcept>
#include <complex>

using namespace Eigen;
using namespace std;

// Аналитическая модель решения задачи Data Reconciliation
VectorXd AnalyticalModel(const VectorXd& x, const MatrixXd& A_y, const VectorXd& b_y, const VectorXd& c_y, double r2_y) {
    // Гауссова модель распределения погрешностей.
    
    // x - вектор уточняемых результатов измерений,
    // A_y - система линейных ограничений на уравнения связи для результатов уточнения, by - вектор правых частей этих уравнений: A_y*y=b_y;
    //     т.к. y=x+dx, то A_y*(x+dx)=b_y. Следовательно, A_y*dx=b_y-A_y*x. Значит, в модели Ефремова-Козлова А=A_y, b=b_y-A_y*x.
    // с_y и r2_y - совокупное ограничение неравенством (y-c_y)'*(y-c_y)<r2_y. Т.к. y=x+dx, то (x+dx-c_y)'*(x+dx-c_y)<r2_y. 
    // Следовательно, (dx-(c_y-x))'*(dx-(c_y-x))<r2_y. Значит, в модели Ефремова-Козлова c=c_y-x, r2=r2_y.
    // y - результат уточнения
    
    VectorXd x_col = x;  // принудительное приведение к вектор-столбцу
    VectorXd b_y_col = b_y;
    VectorXd c_y_col = c_y;

    MatrixXd A = A_y;
    VectorXd b = A_y * x_col - b_y_col;
    VectorXd c = x_col - c_y_col;
    double r2 = r2_y;

    // Проверки:
    int n = x.size();
    if (c.size() != n) {
        throw invalid_argument(""Размерность векторов х и с должны совпадать."");
    }
    if (A.cols() != n) {
        throw invalid_argument(""Число столбцов в матрице А должно совпадать с числом элементов в х."");
    }
    if (A.rows() != b.size()) {
        throw invalid_argument(""Число строк в матрице А должно совпадать с числом элементов в b."");
    }

    MatrixXd P;
    try {
        P = A.transpose() * (A * A.transpose()).inverse();
    } catch (const exception& e) {
        throw invalid_argument(""Матрица A*A^T вырождена, невозможно вычислить обратную матрицу"");
    }

    MatrixXd D = MatrixXd::Identity(n, n) - P * A;

    double a = (b.transpose() * P.transpose() * P * b
                - b.transpose() * P.transpose() * c
                - c.transpose() * P * b
                + c.transpose() * c
                - c.transpose() * D * c
                - r2).value();
    double h = 2 * a;
    double d = (a + c.transpose() * D * c).value();

    // Решение квадратного уравнения
    double discriminant = h * h - 4 * a * d;
    double  [MASK]  = (-h + sqrt(discriminant)) / (2 * a);
    double root2 = (-h - sqrt(discriminant)) / (2 * a);
    VectorXd roots(2);
    roots <<  [MASK] , root2;

    MatrixXd dx(n, 2);
    for (int i = 0; i < 2; ++i) {
        double lbd = roots(i);
        dx.col(i) = P * b + lbd * (D * c) / (1 + lbd);
    }

    // Выбор решения с минимальной нормой
    int idx = 0;
    double min_norm = dx.col(0).squaredNorm();
    if (dx.col(1).squaredNorm() < min_norm) {
        idx = 1;
    }
    VectorXd y = x_col - dx.col(idx);

    return y;
}

VectorXd GetUncertainty(const VectorXd& x, const VectorXd& dx, const MatrixXd& A_y, const VectorXd& b_y, const VectorXd& c_y, double r2_y) {
    // Все обозначения - те же, что и для AnalyticalModel,
    // dx - массив-вектор cell неопределенностей, формализованных по одному из типов.
    int n = dx.size();
    // Оценка частных производных
    double alpha = 1e-100;
    MatrixXd dy_dx = MatrixXd::Zero(n, n);

    for (int i = 0; i < n; ++i) {
        VectorXcd d = VectorXcd::Zero(n);
        d(i) = complex<double>(0, alpha);  // Добавление мнимой части
        VectorXcd perturbed = AnalyticalModel(x.cast<complex<double>>() + d, A_y, b_y, c_y, r2_y);
        dy_dx.col(i) = perturbed.imag() / alpha;
    }

    // Цикл по операциям сложения и умножения по типу неопределенности
    VectorXd dy = VectorXd::Zero(n);
    for (int i = 0; i < n; ++i) {
        dy(i) = abs(dy_dx(i, 0)) * dx(0) + abs(dy_dx(i, 1)) * dx(1);
        for (int j = 2; j < n; ++j) {
            dy(i) += abs(dy_dx(i, j)) * dx(j);
        }
    }

    return dy;
}

int main() {
    // Пример использования:
    // x = [x1;x2]; результат измерения x = [1.0; 0.9; 0.9];
    // линейная связь вида 2*x1+3*x2=5; 1*x1+1*x2+1*x3=3
    // групповое ограничение: недопустимо R2 при отклонении от столбца [1.0;1.0;1.0], большее, чем 0.2.

    VectorXd x(3);
    x << 1.0, 0.9, 0.9;

    MatrixXd A(1, 3);
    A << 2, 3, 0;

    VectorXd b(1);
    b << 5;

    VectorXd c(3);
    c << 0.7, 2.7, 0.7;

    double r2 = 2.0;

    // Уточненный результат Data Reconciliation
    VectorXd y = AnalyticalModel(x, A, b, c, r2);

    VectorXd dx(3);
    dx << 0.1, 0.1, 0.1;  // пределы абсолютной погрешности (FuzzyInterval)
    VectorXd dy = GetUncertainty(x, dx, A, b, c, r2);

    cout << ""Уточненные значения: "" << y.transpose() << endl;
 
    return 0;
}",root1
795,"#ifndef MATHLIB_EXAMPLES_PATHTRACER_SCENE_HPP
#define MATHLIB_EXAMPLES_PATHTRACER_SCENE_HPP

#include ""Base.hpp""
#include ""Camera.hpp""
#include ""Light.hpp""
#include ""Material.hpp""

#include <memory>
#include <span>

namespace PathTracer
{
    class Scene
    {
    public:
        using Interval = Math::Geometry::Interval<f32>;
        struct Intersection
        {
            bool IsValid() const;

            f32 Distance;
            Vector3f Normal;
            const Material* Material;
            const Light* Light;
        };

        class Object
        {
        public:
            struct Intersection
            {
                bool IsValid() const;

                f32 Distance;
                Vector3f Normal;
                SizeType MaterialIndex;
            };

            struct GenericObject
            {
            public:
                virtual Intersection Intersect(const Ray& ray, const Interval& interval) const noexcept = 0;
                virtual bool HasIntersection(const Ray& ray, const Interval& interval) const noexcept = 0;
                virtual ~GenericObject() noexcept {}
            };

            template <typename ObjectType>
            struct ObjectContainer : public GenericObject
            {
            public:
                ObjectContainer(const ObjectType& object)
                    : mObject(object)
                {}

                Intersection Intersect(const Ray& ray, const Interval& interval) const noexcept override
                {
                    using BasicIntersection = Math::Geometry::Intersection<f32>;
                    BasicIntersection nearest = Math::Geometry::NearestIntersection(ray, interval, mObject);
                    return {
                        .Distance = nearest.Distance,
                        .Normal = mObject.SurfaceNormal(ray.Project(nearest.Distance)),
                        .MaterialIndex = 0,
                    };
                }

                bool HasIntersection(const Ray& ray, const Interval& interval) const noexcept override
                {
                    return Math::Geometry::NearestIntersection(ray, interval, mObject).IsValid();
                }
            private:
                ObjectType mObject;
            };

            template <typename ObjectType>
            Object(const ObjectType& object, SizeType  [MASK] )
                : mObject(std::make_unique<ObjectContainer<ObjectType>>(object)), mMaterialIndex( [MASK] )
            {}

            Intersection Intersect(const Ray& ray, const Interval& interval) const noexcept;
            bool HasIntersection(const Ray& ray, const Interval& interval) const noexcept;
        private:
            // Note(3011): It might make sense to replace this
            // with a small buffer that can store the objects directly
            // in case they fit, and only use allocations when the object
            // is too large. About 64B should be enough, since that's the
            // size of a cache line, and we don't want to waste too much
            // memory purely on alignment. (8B for vtable (64bit) ptr overhead,
            // 56B of useable space (14 floats ~ 3 points + change).)
            std::unique_ptr<GenericObject> mObject;
            SizeType mMaterialIndex;
        };

        Scene(const Vector2sz& resolution);

        Intersection Intersect(const Ray& ray, const Interval& interval) const;
        bool HasIntersection(const Ray& ray, const Interval& interval) const;

        const Camera& GetCamera() const;
        std::span<const Light> GetLights() const;
    private:
        Camera mCamera;
        std::vector<Object> mObjects;
        std::vector<Light> mLights;
        std::vector<Material> mMaterials;
    };
}

#endif //MATHLIB_EXAMPLES_PATHTRACER_SCENE_HPP
",materialIndex
796,"/*
 basic servo control via USB-serial
 ESP32
 PWM via PCA9685 I2C
 * GND
 * 5V
 * pin 21 = SDA
 * pin 22 = SDL
*/

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(); //default address 0x40

//#define SERVOMIN  150 // This is the 'minimum' pulse length count (out of 4096)
//#define SERVOMAX  600 // This is the 'maximum' pulse length count (out of 4096)

#define USMIN  600 // This is the rounded 'minimum' microsecond length based on the minimum pulse of 150
#define USMAX  2400 // This is the rounded 'maximum' microsecond length based on the maximum pulse of 600
#define SERVO_FREQ 50 // Analog servos run at ~50 Hz updates


int minp = 70;
int maxp = 480;
int i;
int back;
int pulselen;
int serialv = 0;

int percent;

uint8_t servonum = 0;
String command;

void setup() {
  Serial.begin(115200);
  pwm.begin();
  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(SERVO_FREQ);  // Analog servos run at ~50 Hz updates
  delay(10);
}

void turn(uint8_t servo, int per) { // expect 0-100
  int  [MASK]  =  ( 100 - per ) * ( maxp - minp ) / 100 + minp;
  Serial.print(""percent:"");
  Serial.print(per);
  Serial.print("" pwm:"");
  Serial.println( [MASK] );
  pwm.setPWM(servo, 0,  [MASK] );
}

void readserial() {
  if (Serial.available()) {
    command = Serial.readStringUntil('\n');
    command.trim();
    serialv = command.toInt();
    turn(0, serialv);
    turn(1, serialv);
  }
}

void loop() {
  readserial();
  
  delay(10);

}
",pwmv
797,"// Copyright (c) 2016-2018 LG Electronics, Inc.
//
// 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.
//
// SPDX-License-Identifier: Apache-2.0

#include <stdlib.h>
#include <string.h>
#include <time.h>

#include ""ActivityManagerApp.h""

static long original_timezone_offset;

static void switch_to_utc()
{
    /* Make sure the time globals are set */
    tzset();

    /* Determine current timezone.  Whether to use daylight time can be
     * found in the 'daylight' global.  (glibc isn't computing it automatically
     * if you set tm_isdst to -1.  Ouch.) */

    /* Time can shift backwards or forwards... put 24 hours on the clock! */
    time_t base_local_time = 24*60*60;

    struct tm utctm;
    memset(&utctm, 0, sizeof(tm));

    /* No conversions... mktime will do that */
    gmtime_r(&base_local_time, &utctm);

    /* -1 does not appear to work under test, but daylight is set properly */
    utctm.tm_isdst = daylight;

    /* When local time was 'base_local_time', UTC was... */
    time_t  [MASK]  = mktime(&utctm);

    /* Store original timezone offset */
    original_timezone_offset = (base_local_time -  [MASK] );

    /* Now set time processing to happen in UTC. */
    /* Since almost everything already is, this basically just fixes
     * mktime(3) */
    setenv(""TZ"", """", 1);
    tzset();
}

int main(int argc, char** argv)
{
    switch_to_utc();

    ActivityManagerApp app;
    int mainResult = app.main(argc, argv);

    return mainResult;
}
",utc_time
798,"/* ---------------------------------------------------------------------------
** This software is in the public domain, furnished ""as is"", without technical
** support, and with no warranty, express or implied, as to its usefulness for
** any purpose.
**
** rtspvideocapturer.h
**
** -------------------------------------------------------------------------*/

#ifndef RTSPVIDEOCAPTURER_H_
#define RTSPVIDEOCAPTURER_H_

#include <string.h>
#include <vector>

#include ""environment.h""
#include ""rtspconnectionclient.h""

#include ""rtc_base/thread.h""
#include ""api/video_codecs/video_decoder.h""
#include ""media/base/videocapturer.h""
#include ""media/engine/internaldecoderfactory.h""

#include ""h264_stream.h""

class RTSPVideoCapturer : public cricket::VideoCapturer, public RTSPConnection::Callback, public rtc::Thread, public webrtc::DecodedImageCallback
{
	public:
		RTSPVideoCapturer(const std::string & uri, int timeout, const std::string & rtptransport);
		virtual ~RTSPVideoCapturer();

		// overide RTSPConnection::Callback
		virtual bool onNewSession(const char* id, const char* media, const char* codec, const char* sdp);
		virtual bool onData(const char* id, unsigned char* buffer, ssize_t size, struct timeval presentationTime);
		virtual ssize_t onNewBuffer(unsigned char* buffer, ssize_t size);
                virtual void    onConnectionTimeout(RTSPConnection& connection) {
                        connection.start();
                }
                virtual void    onDataTimeout(RTSPConnection& connection)       {
                        connection.start();
                }
                virtual void    onError(RTSPConnection& connection,const char* erro)       {
                        connection.start();
                }		

		// overide webrtc::DecodedImageCallback
		virtual int32_t Decoded(webrtc::VideoFrame& decodedImage);

		// overide rtc::Thread
		virtual void Run();

		// overide cricket::VideoCapturer
		virtual cricket::CaptureState Start(const cricket::VideoFormat& format);
		virtual void Stop();
		virtual bool GetPreferredFourccs(std::vector<unsigned int>* fourccs);
		virtual bool IsScreencast() const { return false; };
		virtual bool IsRunning() { return this->capture_state() == cricket::CS_RUNNING; }


	private:
		Environment                           m_env;
		RTSPConnection                        m_connection;
		cricket::InternalDecoderFactory       m_factory;
		std::unique_ptr<webrtc::VideoDecoder> m_decoder;
		std::vector<uint8_t>                  m_cfg;
		std::string                           m_codec;
                h264_stream_t*                        m_h264;
};


#include ""pc/localaudiosource.h""
#include ""api/audio_codecs/builtin_audio_decoder_factory.h""
#include <iostream>

class RTSPAudioSource : public webrtc::Notifier<webrtc::AudioSourceInterface>, public rtc::Thread, public RTSPConnection::Callback {
	public:
		static rtc::scoped_refptr<RTSPAudioSource> Create(rtc::scoped_refptr<webrtc::AudioDecoderFactory> audioDecoderFactory, const std::string & uri) {
			rtc::scoped_refptr<RTSPAudioSource> source(new rtc::RefCountedObject<RTSPAudioSource>(audioDecoderFactory, uri));
			return source;
		}

		SourceState state() const override { return kLive; }
		bool remote() const override { return true; }
		
		void AddSink(webrtc::AudioTrackSinkInterface* sink) override {
			std::cout << ""=> AddSink"" << std::endl;
			m_sink = sink;
		}
		void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {
			std::cout << ""=> RemoveSink"" << std::endl;
			m_sink = NULL;
		}
		
		// overide rtc::Thread
		virtual void Run() { m_env.mainloop(); } 		

		// overide RTSPConnection::Callback
		virtual bool onNewSession(const char* id, const char* media, const char* codec, const char* sdp) {
			std::cout << ""=> onNewSession "" << media << ""/"" << codec << "" sdp:"" << sdp << std::endl;
			
			// parse sdp to extract freq and channel
			std::string fmt(sdp);
			size_t pos = fmt.find(codec);
			if (pos != std::string::npos) {
				fmt.erase(0, pos+strlen(codec));
				fmt.erase(fmt.find_first_of("" \r\n""));
				std::istringstream is (fmt);
				std::string dummy;
				std::getline(is, dummy, '/');
				std::string freq;
				std::getline(is, freq, '/');
				if (!freq.empty()) {
					m_freq = std::stoi(freq);
				}
				std::string channel;
				std::getline(is, channel, '/');
				if (!channel.empty()) {
					m_channel = std::stoi(channel);
				}
			}
			std::cout << ""=> m_freq:"" << m_freq << "" m_channel:"" << m_channel << std::endl;
			
			bool success = false;
			if ( (strcmp(media, ""audio"") == 0) && (strcmp(codec, ""PCMU"") == 0) )
			{
				m_decoder = m_factory->MakeAudioDecoder(webrtc::SdpAudioFormat(codec, m_freq, m_channel));
				success = true;
			}
			else if ( (strcmp(media, ""audio"") == 0) && (strcmp(codec, ""OPUS"") == 0) )
			{
				m_decoder = m_factory->MakeAudioDecoder(webrtc::SdpAudioFormat(codec, m_freq, m_channel));
				success = true;
			}
			else if ( (strcmp(media, ""audio"") == 0) && (strcmp(codec, ""L16"") == 0) )
			{
				m_decoder = m_factory->MakeAudioDecoder(webrtc::SdpAudioFormat(codec, m_freq, m_channel));
				success = true;
			}
			return success;			
		}
		
		virtual bool onData(const char* id, unsigned char* buffer, ssize_t size, struct timeval presentationTime) {
			bool success = false;
			int  [MASK]  = m_freq/100;
			if (m_sink) {								
				if (m_decoder.get() != NULL) {				
					int16_t decoded[size];
					webrtc::AudioDecoder::SpeechType speech_type;
					int res = m_decoder->Decode(buffer, size, m_freq, sizeof(decoded), decoded, &speech_type);
//					std::cout << ""=> onData size:"" << size << "" decoded:"" << res << std::endl;
					if (res > 0) {
						for (int i = 0 ; i < res*m_channel; ++i) {
							m_buffer.push(decoded[i]);
						}
					} else {
						std::cout << ""Decode Audio failed"" << std::endl;
					}																
					while (m_buffer.size() >  [MASK] *m_channel) {
//						std::cout << ""pop size:"" << m_buffer.size() << std::endl;
						int16_t outbuffer[ [MASK] *m_channel];
						for (int i=0; i< [MASK] *m_channel; ++i) {
							uint16_t value = m_buffer.front();
							outbuffer[i] = value;
							m_buffer.pop();
						}
						m_sink->OnData(outbuffer, 16, m_freq, m_channel,  [MASK] );
					}
					success = true;
				} else {
					std::cout << ""No Audio decoder"" << std::endl;
				}
			} else {
				std::cout << ""No Audio Sink"" << std::endl;
			}
			return success;
		}

	protected:
		RTSPAudioSource(rtc::scoped_refptr<webrtc::AudioDecoderFactory> audioDecoderFactory, const std::string & uri) : m_connection(m_env, this, uri.c_str()), m_factory(audioDecoderFactory), m_sink(NULL), m_freq(8000), m_channel(1) { rtc::Thread::Start(); }
		virtual ~RTSPAudioSource() override { m_env.stop(); rtc::Thread::Stop(); }


	private:
		Environment                             m_env;
		RTSPConnection                          m_connection; 
		rtc::scoped_refptr<webrtc::AudioDecoderFactory> m_factory;
		std::unique_ptr<webrtc::AudioDecoder>   m_decoder;
		webrtc::AudioTrackSinkInterface*        m_sink;
		int                                     m_freq;
		int                                     m_channel;
		std::queue<uint16_t>                    m_buffer;
};


#endif

",segmentLength
799,"// PURPOSE: VixenLights 3.8 processing with Pullstar8 I2C Servo Motor Board on Arduino UNO
//          I2C and UART modified functions derived from <NAME>`s library.
// LICENSE: Apache-2.0 (https://www.apache.org/licenses/LICENSE-2.0.txt)
// 
//     URL: https://github.com/ioprojecton/vixen
//
// HISTORY:
// Surepic - Original version(12/14/2019)
// 
// 
#include <inttypes.h>
#include <compat/twi.h>
#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU 16000000UL
#endif

#define UART_BAUD_RATE 115200UL

#define UART_BUFFER_OVERFLOW  0x0200

#define UART_NO_DATA          0x0100

#define IODIR 0x00

#define IOCON 0x05

#define mcp_address 0b01000000

#define SCL_CLOCK  400000UL

#define OLAT 0x0A

#define DELIM 0x3C

#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1)

#define UART_RX_BUFFER_SIZE 16

#define SET_BIT(_byte,_position) (_byte |= 1 << 7 - _position)

#define ZERO_OUT(_array) memset(_array,0,sizeof(_array))

unsigned int uart_getc(void);

void i2c_write( unsigned char data );

void i2c_stop(void);

void i2c_start(unsigned char address);

unsigned int input_buffer[8];

static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];

static volatile unsigned char UART_RxHead;

static volatile unsigned char UART_RxTail;

static volatile unsigned char UART_LastRxError;

unsigned char v;

void setup() {
  // put your setup code here, to run once:
  TWSR = 0;

  TWBR = ((F_CPU / SCL_CLOCK) - 16) / 2;

  UART_RxHead = 0;

  UART_RxTail = 0;

  UCSR0A = _BV(U2X0);

  UBRR0H = 0;

  UBRR0L = 16;

  UCSR0B = _BV(RXCIE0) | _BV(RXEN0);

  UCSR0C = _BV(UCSZ01) | _BV(UCSZ00);

  sei();

  i2c_start(mcp_address);

  i2c_write(IODIR);

  i2c_write(0x00);

  i2c_stop();

  i2c_start(mcp_address);

  i2c_write(IOCON);

  i2c_write(0x020);

  i2c_stop();
}

void loop() {

  ZERO_OUT(input_buffer);

  v = 0;

  while ((unsigned char)uart_getc() != DELIM);

  for (unsigned char i = 0; i < 8; i++) {

    if ((input_buffer[i] = uart_getc()) & UART_NO_DATA) {
      i--;
      continue;
    }

    if (input_buffer[i]) SET_BIT(v, i);
  }

  i2c_start(mcp_address);

  i2c_write(OLAT);

  i2c_write(v);

  i2c_stop();
}

ISR (USART_RX_vect)
{
  unsigned char tmphead;

  unsigned char lastRxError;

  lastRxError = UCSR0A & (_BV(FE0) | _BV(DOR0) | _BV(UPE0) );

  tmphead = (UART_RxHead + 1) & UART_RX_BUFFER_MASK;

  UART_RxHead = tmphead;

  UART_RxBuf[tmphead] = UDR0;

  UART_LastRxError |= lastRxError;
}

unsigned int uart_getc(void)
{
  unsigned char  [MASK] ;
  unsigned char lastRxError;

  if ( UART_RxHead == UART_RxTail ) return UART_NO_DATA;

   [MASK]  = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;

  lastRxError = UART_LastRxError;

  UART_RxTail =  [MASK] ;

  UART_LastRxError = 0;

  return (lastRxError << 8) + UART_RxBuf[ [MASK] ];
}

void i2c_start(unsigned char address)
{

  TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);

  while (!(TWCR & _BV(TWINT)));

  TWDR = address;

  TWCR = _BV(TWINT) | _BV(TWEN);

  while (!(TWCR & _BV(TWINT)));
}

void i2c_stop(void)
{
  TWCR = _BV(TWINT) | _BV(TWEN) | _BV(TWSTO);

  while (TWCR & _BV(TWSTO));
}

void i2c_write( unsigned char data )
{
  TWDR = data;

  TWCR = _BV(TWINT) | _BV(TWEN);

  while (!(TWCR & _BV(TWINT)));
}
",tmptail
800,"#include <atomic>
#include <iostream>

#include <wing/WingMySQL.hpp>

static std::atomic<uint64_t> count { 0 };
static std::atomic<uint64_t> errors { 0 };

static std::chrono::seconds duration;
static size_t threads;
static size_t connections;
static std::string hostname;
static uint16_t port;
static std::string user;
static std::string password;
static std::string db;
static wing::Statement statement;

using namespace std::chrono_literals;
using namespace std::placeholders;

static auto print_stats(
    uint64_t duration_s,
    uint64_t threads,
    uint64_t  [MASK] ,
    uint64_t total_error) -> void
{
    auto total =  [MASK]  + total_error;
    std::cout << ""  Thread Stats    Avg\n"";
    std::cout << ""    Req/sec     "" << (total / static_cast<double>(threads) / duration_s) << ""\n"";

    std::cout << ""  "" << total << "" requests in "" << duration_s << ""s\n"";
    if (total_error > 0) {
        std::cout << ""  "" << total_error << "" errors\n"";
    }
    std::cout << ""Requests/sec: "" << (total / static_cast<double>(duration_s)) << ""\n"";
}

static auto on_complete(wing::QueryHandle request, wing::Executor& executor) -> void
{
    ++count;
    if (request->Error().has_value()) {
        ++errors;
        std::cout << ""ERROR: "" << wing::to_string(request->QueryStatus()) << "" "" << request->Error().value() << ""\n"";
    }

    if (request->QueryStatus() == wing::QueryStatus::SUCCESS) {
        (void)executor.StartQuery(
            statement,
            1000ms,
            [&executor](wing::QueryHandle qh) {
                on_complete(std::move(qh), executor);
            });
    } else {
        /// libwingmysql doesn't let you restart a failed request
        (void)executor.StartQuery(statement, 1000ms, [&executor](wing::QueryHandle qh) {
            on_complete(std::move(qh), executor);
        });
    }
}

int main(int argc, char* argv[])
{
    if (argc < 10) {
        std::cout << argv[0] << "" <duration_seconds> <threads> <connections> <hostname> <port> <user> <password> <db> <query>\n"";
        return 1;
    }

    duration = std::chrono::seconds(std::stoul(argv[1]));
    threads = std::stoul(argv[2]);
    connections = std::stoul(argv[3]);
    hostname = argv[4];
    port = static_cast<uint16_t>(std::stoi(argv[5]));
    user = argv[6];
    password = argv[7];
    db = argv[8];
    statement << argv[9];

    wing::ConnectionInfo connection { hostname, port, user, password, db, 0 };
    wing::Executor executor { std::move(connection), threads };

    for (size_t i = 0; i < connections; ++i) {
        (void)executor.StartQuery(statement, 1000ms, [&executor](wing::QueryHandle qh) {
            on_complete(std::move(qh), executor);
        });
    }

    std::this_thread::sleep_for(duration);

    executor.Stop();

    print_stats(static_cast<uint64_t>(duration.count()), threads, count, errors);

    return 0;
}
",total_success
801,"#include ""StringsAndDirectories.h""
#include <iostream>
#include <windows.h>
#include <sstream>
#include <fstream>
#include <string>

#pragma once


// Logger: handles receiving and then writing logs to a file
//===========================================================

class Logger
{
private:
    HANDLE hFile;

public:
    typedef std::ostream& (*ManipFn)(std::ostream&);
    std::wstring m_strFQLogFilename;
    FILE* m_fileLogFile;

    Logger(std::wstring strLogFile=L"""")
    {
        
        // Initialization
        hFile = 0x0;
        m_fileLogFile = nullptr;

        
        m_strFQLogFilename = strLogFile;
    }

    /**
     * Retrieves the fully qualified path for the file that contains the current 
     * module.The module must have been loaded by the current process.
     * 
     * @param null.
     * @return void.
     */
    void SetPathExePath()
    {
        wchar_t exeName[MAX_PATH] = { 0 };
        GetModuleFileName(NULL, exeName, MAX_PATH);

        std::wstring strPath;
        std::wstring strFilename;
        std::wstring  [MASK] ;
        std::wstring strExtension;
        int bytes = GetModuleFileName(NULL, exeName, MAX_PATH);
        GetPathAndFilenameW(exeName, &strPath, &strFilename, & [MASK] , &strExtension);

        m_strFQLogFilename = strPath;
    }

    /**
     * Retrieves the fully qualified path for the file that contains the current
     * module.The module must have been loaded by the current process.
     *
     * @param null.
     * @return void.
     */
    void SetPathUserProfileA(std::string strFilename="""")
    {
        char* base_path;
        size_t len;
        errno_t err = _dupenv_s(&base_path, &len, ""USERPROFILE"");
        std::string s(base_path);
        s += ""\\"" + strFilename;
        std::wstring ws(s.begin(), s.end());
        m_strFQLogFilename = ws;
    }

    void SetPathUserProfile(std::wstring strFilename=L"""")
    {
        wchar_t* base_path;
        size_t len;
        errno_t err = _wdupenv_s(&base_path, &len, L""USERPROFILE"");
        std::wstring ws(base_path);
        ws += L""\\"" + strFilename;
        m_strFQLogFilename = ws;
    }

    void Open()
    {
        m_fileLogFile = _wfopen(m_strFQLogFilename.c_str(), L""a+"");
    }

    void Flush()
    {
        fflush(m_fileLogFile);
    }

    void Close()
    {
        fclose(m_fileLogFile);
    }
};


",strFilenameNoExtension
802,"/**
 * @file glsl-test.cpp
 * @brief Simple testing application for GLSL.
 */

#include ""image_gpu.h""

#include <cstdio>
#include <cstdlib>
#include <chrono>
#include <thread>
#include <opencv2/opencv.hpp>

#define TIMEDIFF(start) (duration_cast<microseconds>(steady_clock::now() - start).count())

using std::this_thread::sleep_for;
using std::chrono::microseconds;
using std::chrono::milliseconds;
using std::chrono::steady_clock;
using std::chrono::duration_cast;

using namespace picopter;

int main(int argc, char *argv[]) {
    cv::VideoCapture capture(-1);

    int width = 640,  [MASK]  = 480, framecount = 200, processed = 0;

    if (argc >= 3) {
        width = atoi(argv[1]);
         [MASK]  = atoi(argv[2]);
    }

    if (argc >= 4) {
        framecount = atoi(argv[3]);
    }

    //Open the camera (testing only)
    if (!capture.isOpened()) {
        printf(""Cannot open camera\n"");
        return 1;
    }
    //We can try to set these, but the camera may ignore this anyway...
#if (CV_MAJOR_VERSION < 3)
    capture.set(CV_CAP_PROP_FRAME_WIDTH, width);
    capture.set(CV_CAP_PROP_FRAME_HEIGHT,  [MASK] );
    capture.set(CV_CAP_PROP_FPS, 30);
#else
    capture.set(cv::CAP_PROP_FRAME_WIDTH, width);
    capture.set(cv::CAP_PROP_FRAME_HEIGHT,  [MASK] );
    capture.set(cv::CAP_PROP_FPS, 30);
#endif // (CV_MAJOR_VERSION < 3)
    
    auto totstart = steady_clock::now();
    cv::Mat image, out;
    //FILE *fp = fopen(""log.txt"", ""w"");
    
#if (CV_MAJOR_VERSION < 3)
    GLThreshold t(capture.get(CV_CAP_PROP_FRAME_WIDTH), capture.get(CV_CAP_PROP_FRAME_HEIGHT));
#else
    GLThreshold t(capture.get(cv::CAP_PROP_FRAME_WIDTH), capture.get(cv::CAP_PROP_FRAME_HEIGHT));
#endif // (CV_MAJOR_VERSION < 3)
    
    for(int i = 0; i < framecount; i++) {
        capture >> image;
        auto start = steady_clock::now();
        t.Threshold(image, out);
        printf(""Processed frame %4d (%4d ms)\r"", i+1, (int)TIMEDIFF(start)/1000);
        fflush(stdout);
    }
}",height
803,"//
//  main.cpp
//  SectorReverser
//
//  Created by <NAME> on 8/8/22.
//

#include <stdio.h>
#include <fstream>
#include <vector>
#include <iostream>
#include <unordered_map>
#include ""boost/algorithm/string.hpp""
#include ""boost/json/src.hpp""
#include <string>

const std::unordered_map<uint32_t, std::string> outdoorFlippable = std::unordered_map<uint32_t, std::string> {
  // Dirt
  std::make_pair(0, std::string(""drt"")),
  // Grass
  std::make_pair(1, std::string(""grs"")),
  std::make_pair(2, std::string(""rck"")),
  std::make_pair(3, std::string(""snw"")),
  std::make_pair(4, std::string(""dg1"")),
  std::make_pair(5, std::string(""bg1"")),
  std::make_pair(6, std::string(""bg2"")),
  std::make_pair(7, std::string(""bog"")),
  std::make_pair(8, std::string(""sw1"")),
  std::make_pair(9, std::string(""sw2"")),
  std::make_pair(10, std::string(""sw3"")),
  std::make_pair(11, std::string(""swr"")),
  std::make_pair(12, std::string(""dwr"")),
  std::make_pair(13, std::string(""rok"")),
  std::make_pair(14, std::string(""WK1"")),
  std::make_pair(15, std::string(""WK2"")),
  std::make_pair(16, std::string(""ST1"")),
  std::make_pair(17, std::string(""WD3"")),
  std::make_pair(18, std::string(""Dst"")),
  std::make_pair(19, std::string(""ssd"")),
  std::make_pair(20, std::string(""dIs"")),
  std::make_pair(21, std::string(""Jdt"")),
  std::make_pair(22, std::string(""Jgr"")),
  std::make_pair(23, std::string(""SxW"")),
  std::make_pair(24, std::string(""sod"")),
  std::make_pair(25, std::string(""TS1"")),
  std::make_pair(26, std::string(""TS2"")),
  std::make_pair(27, std::string(""TDt"")),
  std::make_pair(28, std::string(""Blk"")),
  std::make_pair(29, std::string(""VDR"")),
  std::make_pair(30, std::string(""FOG""))
};

const std::unordered_map<uint32_t, std::string> outdoorNonFlippable = std::unordered_map<uint32_t, std::string> {
  std::make_pair(0, std::string(""TST"")),
  std::make_pair(1, std::string(""Prh"")),
  std::make_pair(2, std::string(""Dks"")),
  std::make_pair(3, std::string(""TLa"")),
  std::make_pair(4, std::string(""VWK"")),
  std::make_pair(5, std::string(""ICE""))
};

const std::unordered_map<uint32_t, std::string> indoorFlippable = std::unordered_map<uint32_t, std::string> {
  std::make_pair(0, std::string(""fl1"")),
  std::make_pair(1, std::string(""wod""))
};

const std::unordered_map<uint32_t, std::string> indoorNonFlippable = std::unordered_map<uint32_t, std::string> {
  std::make_pair(0, std::string(""Dn1"")),
  std::make_pair(1, std::string(""WI1"")),
  std::make_pair(2, std::string(""Dn2"")),
  std::make_pair(3, std::string(""CF1"")),
  std::make_pair(4, std::string(""WD1"")),
  std::make_pair(5, std::string(""Sew"")),
  std::make_pair(6, std::string(""WD2"")),
  std::make_pair(7, std::string(""ILL"")),
  std::make_pair(8, std::string(""Dir"")),
  std::make_pair(9, std::string(""cf2"")),
  std::make_pair(10, std::string(""STD"")),
  std::make_pair(11, std::string(""VFL"")),
  std::make_pair(12, std::string(""JIN""))
};

const std::unordered_map<uint32_t, std::string> edges = std::unordered_map<uint32_t, std::string> {
  std::make_pair(0, std::string(""drtgrs"")),
  std::make_pair(1, std::string(""drtrck"")),
  std::make_pair(2, std::string(""rcksnw"")),
  std::make_pair(3, std::string(""drtdg1"")),
  std::make_pair(4, std::string(""drtbg1"")),
  std::make_pair(5, std::string(""bg1bg2"")),
  std::make_pair(6, std::string(""bg2bog"")),
  std::make_pair(7, std::string(""drtsw1"")),
  std::make_pair(8, std::string(""sw1sw2"")),
  std::make_pair(9, std::string(""sw2sw3"")),
  std::make_pair(10, std::string(""sw3swr"")),
  std::make_pair(11, std::string(""swrdwr"")),
  std::make_pair(12, std::string(""drtrok"")),
  std::make_pair(13, std::string(""drtWK1"")),
  std::make_pair(14, std::string(""drtWK2"")),
  std::make_pair(15, std::string(""drtST1"")),
  std::make_pair(16, std::string(""drtWD3"")),
  std::make_pair(17, std::string(""drtDst"")),
  std::make_pair(18, std::string(""swrssd"")),
  std::make_pair(19, std::string(""ssddIs"")),
  std::make_pair(20, std::string(""dIsJdt"")),
  std::make_pair(21, std::string(""JdtJgr"")),
  std::make_pair(22, std::string(""drtsod"")),
  std::make_pair(23, std::string(""drtSxW"")),
  std::make_pair(24, std::string(""drtTS1"")),
  std::make_pair(25, std::string(""TS1TS2"")),
  std::make_pair(26, std::string(""drtTDt"")),
  std::make_pair(27, std::string(""drtBlk"")),
  std::make_pair(28, std::string(""drtTST"")),
  std::make_pair(29, std::string(""drtPrh"")),
  std::make_pair(30, std::string(""dwrDks"")),
  std::make_pair(31, std::string(""dIsTLa"")),
  std::make_pair(32, std::string(""DrtFOG"")),
  std::make_pair(33, std::string(""DrtVDR"")),
  std::make_pair(34, std::string(""VDRVWK"")),
  std::make_pair(35, std::string(""SnwICE""))
};

/**
 Read up to 4 bytes starting from a specified position in a file.
 
 Note: this method moves the file pointer by a number of bytes read
 
 @param file - file to read from
 @param start - position in a file to read from inclusively
 @param length - number of bytes to read.
 @returns 4-byte unsigned integer
 */
uint32_t readUpTo4Bytes(std::ifstream & file, const uint32_t start, const uint32_t length) {
  file.seekg(start, std::ios::beg);
  std::vector<uint8_t> container = std::vector<uint8_t>(length);
  file.read(reinterpret_cast<char*>(container.data()), length);
  uint32_t result {};
  memcpy(& result, container.data(), length);
  return result;
}

const std::string getOutdoorFlippableArtPrefix(const uint32_t & tileId) {
  const std::unordered_map<uint32_t, std::string>::const_iterator pIter = outdoorFlippable.find(tileId);
  if (pIter != outdoorFlippable.end()) {
	std::string artPrefix = pIter->second + ""bse"";
	boost::algorithm::to_lower(artPrefix);
	return artPrefix;
  } else {
	throw std::runtime_error(""Couldn't map tileId1 to art prefix."");
  }
}

const std::string getOutdoorFlippableEdgeArtPrefix(const uint32_t & tileId1, const uint32_t & tileId2) {
  std::string artPrefix1 {};
  std::string artPrefix2 {};
  const std::unordered_map<uint32_t, std::string>::const_iterator pIter1 = outdoorFlippable.find(tileId1);
  if (pIter1 != outdoorFlippable.end()) {
	artPrefix1 = pIter1->second;
	boost::algorithm::to_lower(artPrefix1);
  } else {
	throw std::runtime_error(""Couldn't map tileId1 to art prefix."");
  }
  
  const std::unordered_map<uint32_t, std::string>::const_iterator  [MASK]  = outdoorFlippable.find(tileId2);
  if ( [MASK]  != outdoorFlippable.end()) {
	artPrefix2 =  [MASK] ->second;
	boost::algorithm::to_lower(artPrefix2);
  } else {
	throw std::runtime_error(""Couldn't map tileId2 to art prefix."");
  }
  
  const std::string artPrefix = artPrefix1 + artPrefix2;
  return artPrefix;
}

uint32_t shr1C(uint32_t val) {
  return val >> 0x1C;
}

int main(int argc, const char * argv[]) {
  std::ifstream file(""Resources/86570436012.sec"", std::ifstream::in);
  const uint16_t numTilesInSector = 4096;
  boost::json::array tiles;
  tiles.reserve(numTilesInSector);
  if (file.is_open()) {
	try {
	  uint16_t currentTile {1};
	  // Read all 4096 tiles from sector
	  while (currentTile <= numTilesInSector) {
		uint32_t tile = readUpTo4Bytes(file, currentTile * 4, 4);
		const uint32_t originalTile = tile;
		uint32_t leastSignificantBit {0};
		uint32_t shiftedTile = shr1C(tile);
		// Default tile if unknown
		std::string art {""drttst9a_0""};
		if (shiftedTile <= 0xE) {
		  if (shiftedTile != 0x9) {
			if (shiftedTile != 0xB) {
			  if (shiftedTile == 0x0) {
				tile = tile & 0xFFFFFFF0;
				uint32_t tileId1 = (tile >> 0x16) & 0x3F;
				uint32_t tileId2 = (tile >> 0x10) & 0x3F;
				uint32_t shiftedTile3 = (tile >> 0xC) & 0xF;
				uint32_t char2Value = (tile >> 0x9) & 0x7;
				uint32_t isOutdoor = (tile >> 0x8) & 0x1;
				uint32_t isFlippable = (tile >> 0x7) & 0x1;
				uint32_t shiftedTile5 = (tile >> 0x6) & 0x1;
				if ((isFlippable & isFlippable) != 0x0) {
				  leastSignificantBit = originalTile & 0x0000000F;
				  if ((isOutdoor & isOutdoor) != 0x0) {
					if ((shiftedTile5 & shiftedTile5) != 0x0) {
					  if (tileId2 < 0x1F) {
						char2Value = char2Value < 0x8 ? char2Value : char2Value - 0x8;
						if (shiftedTile3 != 0xF) {
						  const std::string char1Str = std::string(""06b489237ea5dc10"");
						  uint32_t char2 = char2Value + 0x61;
						  uint32_t char1 = char1Str.at(shiftedTile3);
						  char char1Ascii = static_cast<char>(char1);
						  char char2Ascii = static_cast<char>(char2);
						  if (tileId1 == tileId2) {
							try {
							  // For this type of a tile tileId1 == tileId2, so it doesnt matter which one we use
							  const std::string artPrefix = getOutdoorFlippableArtPrefix(tileId1);
							  art = artPrefix + char1Ascii + char2Ascii + ""_0"";
							} catch (std::system_error & e) {
							  std::cout << e.code().message() << "" tileId1 = "" << tileId1 << "". Original tile = "" << std::hex << originalTile << std::endl;
							}
						  } else {
							try {
							  const std::string artPrefix = getOutdoorFlippableEdgeArtPrefix(tileId1, tileId2);
							  art = artPrefix + char1Ascii + char2Ascii + ""_0"";
							} catch (std::system_error & e) {
							  std::cout << e.code().message() << "" tileId1 = "" << tileId1 << "". tileId2 = "" << tileId2 << "". Original tile = "" << std::hex << originalTile << std::endl;
							}
						  }
						} else {
						  std::cout << ""shiftedTile3 is = 0xF. Original tile = "" << std::hex << originalTile << std::endl;
						}
					  } else {
						std::cout << ""tileId2 is >= 0x1F. Original tile = "" << std::hex << originalTile << std::endl;
					  }
					} else {
					  std::cout << ""shiftedTile5 == 0x0. Original tile = "" << std::hex << originalTile << std::endl;
					}
				  } else {
					std::cout << ""Tile is not outdoor. Original tile = "" << std::hex << originalTile << std::endl;
				  }
				} else {
				  std::cout << ""Tile is not flippable. Original tile = "" << std::hex << originalTile << std::endl;
				}
			  } else {
				std::cout << ""Shifted tile is != 0x0. Original tile = "" << std::hex << originalTile << std::endl;
			  }
			} else {
			  std::cout << ""Shifted tile is = 0xB. Original tile = "" << std::hex << originalTile << std::endl;
			}
		  } else {
			std::cout << ""Shifted tile is = 0x9. Original tile = "" << std::hex << originalTile << std::endl;
		  }
		} else {
		  std::cout << ""Shifted tile is > than 0xE. Original tile = "" << std::hex << originalTile << std::endl;
		}
		
		
		boost::json::object tileObj;
		tileObj[""instanceId""] = currentTile - 1;
		tileObj[""textureName""] = art;
		tileObj[""shouldFlip""] = (leastSignificantBit & leastSignificantBit) != 0x0 ? ""1"" : ""0"";
		tiles.push_back(tileObj);
		
		++currentTile;
	  }
	} catch (std::system_error & e) {
	  if (file.is_open())
		file.close();
	  std::cerr << e.code().message() << std::endl;
	  throw;
	}
  }
  file.close();
  
  boost::json::object json;
  json[""tiles""] = tiles;
  std::ofstream outFile(""/opt/projects/SectorReverser/SectorReverser/Resources/86570436012"", std::ofstream::out);
  if (outFile.is_open()) {
	try {
	  outFile << json << std::endl;
	  outFile.flush();
	} catch (std::system_error & e) {
	  if (outFile.is_open())
		outFile.close();
	  std::cerr << e.code().message() << std::endl;
	  throw;
	}
	outFile.close();
  }
  
  return 0;
}
",pIter2
804,"// coronet - An experimental networking library that supports both the
//           Universal Model of the Networking TS and the coroutines of
//           the Coroutines TS.
//
//  Copyright <NAME> 2017
//  Copyright <NAME> 2017
//
//  Use, modification and distribution is subject to the
//  Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/coronet
//
#ifndef CORONET_DETAIL_NOOP_COROUTINE_HPP
#define CORONET_DETAIL_NOOP_COROUTINE_HPP

#include <experimental/coroutine>

namespace coronet
{
    namespace detail
    {
        class _noop_coroutine_gen final
        {
        public:
            struct promise_type final
            {
                _noop_coroutine_gen get_return_object() noexcept;
                std::experimental::suspend_never initial_suspend() noexcept
                {
                    return {};
                }
                std::experimental::suspend_never final_suspend() noexcept
                {
                    return {};
                }
                void unhandled_exception() noexcept {}
                void return_void() noexcept {}
            };

            static std::experimental::coroutine_handle<> value() noexcept
            {
                static const auto  [MASK]  = coroutine().coro_;
                return  [MASK] ;
            }

        private:
            explicit _noop_coroutine_gen(promise_type& p) noexcept
              : coro_(std::experimental::coroutine_handle<
                      promise_type>::from_promise(p))
            {}

            static _noop_coroutine_gen coroutine()
            {
                for(;;)
                {
                    co_await std::experimental::suspend_always{};
                }
            }

            const std::experimental::coroutine_handle<> coro_;
        };

        inline _noop_coroutine_gen _noop_coroutine_gen::promise_type::
            get_return_object() noexcept
        {
            return _noop_coroutine_gen{*this};
        }
    } // namespace detail

    inline std::experimental::coroutine_handle<> noop_coroutine()
    {
        return detail::_noop_coroutine_gen::value();
    }
}

#endif
",s_value
805,"/*
   Register access functions for RISC-V system registers.
   SPDX-License-Identifier: Unlicense

   https://five-embeddev.com/

*/

#include ""riscv-csr.hpp""

static volatile riscv::csr::uint_xlen_t saved_mtvec;

int main(void) {

    riscv::csr::all  [MASK] ;

    auto cause =  [MASK] .mcause.read();
    if (cause & riscv::csr::mcause_data::interrupt::BIT_MASK) {
        // Interrupt
        auto mip =  [MASK] .mip.read();
    } else {
        // Exception
        // Read the source of the exception
        auto mepc =  [MASK] .mepc.read();
        // Pointless save to mscratch
         [MASK] .mscratch.write(mepc);
    }
    // Enable MIE.MSI    
     [MASK] .mie.msi.set();
    // Enable MIE.MTI
     [MASK] .mie.mti.set();
    // Clear mode and read mtvec.
    auto old_mtvec =  [MASK] .mtvec.read_clr_bits_const<riscv::csr::mtvec_data::mode::ALL_SET_MASK>();
    if (old_mtvec & riscv::csr::mtvec_data::mode::ALL_SET_MASK) {
        // Remove mode bits
        old_mtvec &= riscv::csr::mtvec_data::base::ALL_SET_MASK;
    }
    saved_mtvec = old_mtvec;

    // ----
    // Try writing const values

    // Write via a register value to the MTVEC
     [MASK] .mtvec.write(0x10);
    // Write an immediate value to the MTVEC
     [MASK] .mtvec.write_const<0x10>();
    // Write via a register value to the MTVEC
     [MASK] .mtvec.write_const<0x100000>();

    // ----
    // Try out the operators

    // Read mcycle via default operator
    auto mcycle =  [MASK] .mcycle();

#if 0 // TODO - upgrade to gcc that supports these CSRs
    // Disable all the counters
     [MASK] .mcountinhibit |= 0xFFFFFFFF;

    // Enable the instruction retired count
     [MASK] .mcountinhibit.ir.clr();
    // Enable the cycle count
     [MASK] .mcountinhibit.cy.write(0);
    // Enable the hpm count
     [MASK] .mcountinhibit.hpm.clr();
#endif
}
",csrs
806,"/*
 * Copyright 2017 Cisco Systems, Inc.
 * 
 * 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 ""CUnit.h""
#include ""Basic.h""
#include ""Automated.h""

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int start_vnf_proc(int port)
{
	char port_str[10];
	sprintf(port_str, ""%d"", port);

	const char *argv[]  = {""vnfsim"", port_str, ""../xml/vnf_A.xml"", NULL};
	int pid = fork();

	if(pid == 0)
	{
		int result = execv(""../vnf_sim/vnfsim"", (char* const*)argv); //, env_args);
		if(result == -1)
		{
			printf(""Failed to exec vnf process %d\n"", errno);
		}
		exit(0);
	}
	else
	{
		return pid;
	}
}

int start_pnf_proc(const char* addr, int port, const char* file)
{
	char port_str[10];
	sprintf(port_str, ""%d"", port);

	char filename[256];
	sprintf(filename, ""../xml/%s"", file);

	const char * argv[] = {""pnfsim"", addr, port_str, filename, NULL};
	int pid = fork();

	if(pid == 0)
	{
		int result = execv(""../pnf_sim/pnfsim"", (char* const*)argv); //, env_args);
		if(result == -1)
		{
			printf(""Failed to exec pnf process %d\n"", errno);
		}
		exit(0);
	}
	else
	{
		return pid;
	}
}

int kill_proc(int pid)
{
	kill(pid, SIGKILL);

	int status;
	int  [MASK]  = waitpid(pid, &status, 0);

	return  [MASK] ;
}


void test_1()
{

	int pnf_port = 5655;
	const char* pnf_addr = ""localhost"";

	printf(""**** starting vnf *****\n"");
	int vnf_pid = start_vnf_proc(pnf_port);

	printf(""**** starting pnf *****\n"");
	int pnf1_pid = start_pnf_proc(pnf_addr, pnf_port, ""pnf_phy_1_A.xml"");


	sleep(10);

	printf (""*** Terminating ****\n"");
	kill_proc(vnf_pid);
	kill_proc(pnf1_pid);
}
void test_1a()
{

	int pnf_port = 5655;
	const char* pnf_addr = ""localhost"";

	printf(""**** starting vnf *****\n"");
	int vnf_pid = start_vnf_proc(pnf_port);

	printf(""**** starting pnf *****\n"");
	int pnf1_pid = start_pnf_proc(pnf_addr, pnf_port, ""pnf_phy_2_A.xml"");


	sleep(10);

	printf (""*** Terminating ****\n"");
	kill_proc(vnf_pid);
	kill_proc(pnf1_pid);
}


void test_2()
{
	int pnf_port = 5655;
	const char* pnf_addr = ""127.0.0.1"";

	int vnf_pid = start_vnf_proc(pnf_port);
	sleep(2);

	int pnf1_pid = start_pnf_proc(pnf_addr, pnf_port, ""pnf_phy_1_A.xml"");	
	int pnf2_pid = start_pnf_proc(pnf_addr, pnf_port, ""pnf_phy_1_A.xml"");	

	sleep(2);

	kill_proc(pnf2_pid);
	kill_proc(pnf1_pid);
	kill_proc(vnf_pid);
}

void test_32()
{
	int pnf_count = 32;
	int pnf_pid[pnf_count];

	int pnf_port = 5655;
	const char* pnf_addr = ""127.0.0.1"";

	int vnf_pid = start_vnf_proc(pnf_port);
	sleep(2);

	for(int i = 0; i < pnf_count; ++i)
	{
		pnf_pid[i] = start_pnf_proc(pnf_addr, pnf_port, ""pnf_phy_1_A.xml"");
	}

	sleep(5);

	printf (""*** Terminating pnfs\n"");

	for(int i = 0; i < pnf_count; ++i)
	{
		kill_proc(pnf_pid[i]);
	}
	printf (""*** Terminating vnf\n"");
	kill_proc(vnf_pid);
}


int init_suite()
{
	return 0;
}

int clean_suite()
{
	return 0;
}

int main ( void )
{
   CU_pSuite pSuite = NULL;

   /* initialize the CUnit test registry */
   if ( CUE_SUCCESS != CU_initialize_registry() )
      return CU_get_error();

   /* add a suite to the registry */
   pSuite = CU_add_suite( ""integration_test_suite"", init_suite, clean_suite );
   if ( NULL == pSuite ) 
   {
      CU_cleanup_registry();
      return CU_get_error();
   }

        //(NULL == CU_add_test(pSuite, ""vnf_test_start_connect_2"", vnf_test_start_connect_2)) 
   /* add the tests to the suite */
   if ( (NULL == CU_add_test(pSuite, ""test_1a"", test_1a))
//        (NULL == CU_add_test(pSuite, ""test_2"", test_2)) ||
//        (NULL == CU_add_test(pSuite, ""test_32"", test_32))
      )
   {
      CU_cleanup_registry();
      return CU_get_error();
   }

   // Run all tests using the basic interface
   CU_basic_set_mode(CU_BRM_VERBOSE);
   CU_set_output_filename(""vnf_unit_test_results.xml"");
   CU_basic_run_tests();

	CU_pSuite s = CU_get_registry()->pSuite;
	int count = 0;
	while(s)
	{
		CU_pTest t = s->pTest;
		while(t)
		{
			count++;
			t = t->pNext;
		}
		s = s->pNext;
	}

	printf(""%d..%d\n"", 1, count);



	s = CU_get_registry()->pSuite;
	count = 1;
	while(s)
	{
		CU_pTest t = s->pTest;
		while(t)
		{
			int pass = 1;
			CU_FailureRecord* failures = CU_get_failure_list();
			while(failures)
			{
				if(strcmp(failures->pSuite->pName, s->pName) == 0 &&
				   strcmp(failures->pTest->pName, t->pName) == 0)
				{
					pass = 0;
					failures = 0;
				}
				else
				{
					failures = failures->pNext;
				}
			}

			if(pass)
				printf(""ok %d - %s:%s\n"", count, s->pName, t->pName);
			else 
				printf(""not ok %d - %s:%s\n"", count, s->pName, t->pName);

			count++;
			t = t->pNext;
		}
		s = s->pNext;
	}

   CU_cleanup_registry();
   return CU_get_error();

}
",waitpid_result
807,"/* ---------------------------------------------------------------------
 *
 * Copyright (C) 1999 - 2019 by the deal.II authors
 *
 * This file is part of the deal.II library.
 *
 * The deal.II library is free software; you can use it, 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.
 * The full text of the license can be found in the file LICENSE.md at
 * the top level of the deal.II distribution.
 *
 * ---------------------------------------------------------------------
 *
 * based on deal.II step-1
 */


#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/grid_out.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>

#include <cmath>
#include <fstream>
#include <iostream>

using namespace dealii;


//! Generate a hypercube, and output it as an svg file.
void
first_grid(Triangulation<2> &triangulation)
{
  GridGenerator::hyper_cube(triangulation);

  std::cout << ""Number of original vertices: "" << triangulation.n_vertices()
            << std::endl;

  triangulation.refine_global(4);

  std::cout << ""Number of vertices after 4 refinements: ""
            << triangulation.n_vertices() << std::endl;
  {
    std::ofstream out(""grid-1.svg"");
    GridOut       grid_out;
    grid_out.write_svg(triangulation, out);
    std::cout << ""Grid written to grid-1.svg"" << std::endl;
  }
  {
    std::ofstream out(""grid-1.vtk"");
    GridOut       grid_out;
    grid_out.write_vtk(triangulation, out);
    std::cout << ""Grid written to grid-1.vtk"" << std::endl;
  }
}


//! Generate a locally refined hyper_shell, and output it as an svg file.
void
second_grid(Triangulation<2> &triangulation)
{
  const Point<2> center(1, 0);
  const double   inner_radius = 0.5,  [MASK]  = 1.0;
  GridGenerator::hyper_shell(
    triangulation, center, inner_radius,  [MASK] , 10);

  // triangulation.reset_all_manifolds();

  for (unsigned int step = 0; step < 5; ++step)
    {
      std::ofstream out(""grid-2-"" + std::to_string(step) + "".vtk"");
      GridOut       grid_out;
      grid_out.write_vtk(triangulation, out);

      for (auto &cell : triangulation.active_cell_iterators())
        {
          for (const auto v : cell->vertex_indices())
            {
              const double distance_from_center =
                center.distance(cell->vertex(v));

              if (std::fabs(distance_from_center - inner_radius) <=
                  1e-6 * inner_radius)
                {
                  cell->set_refine_flag();
                  break;
                }
            }
        }

      triangulation.execute_coarsening_and_refinement();
    }
}

//! Create an L-shaped domain with one global refinement, and write it on
// `third_grid.vtk`.  Refine the L-shaped mesh adaptively around the re-entrant
// corner three times (after the global refinement you already did), but with a
// twist: refine all cells with the distance between the center of the cell and
// re-entrant corner is smaller than 1/3.
void
third_grid(Triangulation<2> &)
{
  // Insert code here
}

//! Returns a tuple with number of levels, number of cells, number of active
// cells. Test this with all of  your meshes.
std::tuple<unsigned int, unsigned int, unsigned int>
get_info(const Triangulation<2> &)
{
  // Insert code here
  return std::make_tuple(0, 0, 0);
}

int
main()
{
  {
    Triangulation<2> triangulation;
    first_grid(triangulation);
  }
  {
    Triangulation<2> triangulation;
    second_grid(triangulation);
  }
}
",outer_radius
808,"//
// Created by Liming on 2023/6/21.
//

#include ""BooleanCalculation.h""
#include ""ConstantRegion.h""
#include ""BracketsCalculationTwo.h""
#include ""MExceptional.h""

static ME::BracketsCalculationTwo BRACKETS_CALCULATION_2;

std::string ME::BooleanCalculation::formatStr(std::string string) {
    return std::regex_replace(string, ALL_INVISIBLE_CHARACTERS_PATTERN, NO_CHAR);
}

void ME::BooleanCalculation::check(std::string string) {
    // 先按照表达式的比较运算符进行一个切分
    std::sregex_token_iterator rit(string.begin(), string.end(),
                                   ME::REGULAR_COMPARISON_OPERATOR_PATTERN, -1);
    std::sregex_token_iterator  [MASK] ;
    std::vector<std::string> res;
    // 存储进vector
    while (rit !=  [MASK] ) {
        std::string r = rit++->str();
        res.push_back(r);
    }
    // 判断是否属于布尔表达式，使用切分之后是否有两个表达式判断
    unsigned int length = res.size();
    if (length == 2) {
        // 检查表达式两边是否符合条件
        std::string left = res[0], right = res[1];
        if (!std::equal(STRING_NULL.begin(), STRING_NULL.end(), left.begin())) {
            BRACKETS_CALCULATION_2.check(left);
        }
        if (!std::equal(STRING_NULL.begin(), STRING_NULL.end(), right.begin())) BRACKETS_CALCULATION_2.check(right);
    } else {
        // 如果比较运算符两边的表达式不是2个，说明不是一个布尔表达式
        std::string data = ""发生了错误，您的布尔表达式中，存在着数量不正确的比较运算符\n"";
        data.append(""An error has occurred. There is an incorrect number of comparison operators in your Boolean expression\n"")
                .append(""Number of comparison operators ["").append(to_string((length - 1))).append(""]"");
        throw ME::WrongFormat(data);
    }

}

std::string ME::BooleanCalculation::getName() {
    return ""BooleanCalculation"";
}




",rend
809,"#include ""kmeans.h""
#include <iostream>
#include <limits>

namespace kmeans {

void Kmeans::pick_center() {
    centers_.reset(new std::vector<Sample>);
    centers_->resize(k_);
    for (int i = 0; i != k_; ++i) {
        size_t index = rand() % samples_->size();
        (*centers_)[i] = (*samples_)[index];
    }
}

void Kmeans::point_clustering() {
    for (auto& sample : *samples_) {
        float min_dis = std::numeric_limits<float>::max();
        for (size_t i = 0; i != centers_->size(); ++i) {
            auto& center = (*centers_)[i];
            float dis = sample.distance(center);
            if (dis < min_dis) {
                min_dis = dis;
                sample.set_center_id(i);
            }
        }
    }
}

void Kmeans::mean_center() {
    centers_.reset(new std::vector<Sample>);
    centers_->resize(k_);
    for (auto& sample : *samples_) {
        sample.add_to_center(&(*centers_)[sample.id()]);
    }
    for (auto& center : *centers_) {
        center.mean();
    }
}

void Kmeans::run(int epoch) {
    pick_center();
    for (int i = 0; i != epoch; ++i) {
        point_clustering();
        mean_center();
        std::cout << ""epoch "" << i << "" finished"" << std::endl;
    }
}

void Kmeans::save(const std::string& filename) const {
    std::ofstream output(filename);
    for (auto& center : *centers_) {
        center.save(&output);
    }
    std::ofstream  [MASK] (filename + "".data"");
    for (auto& sample : *samples_) {
        sample.save(& [MASK] );
    }
}

}
",output_data
810,"//
// Created by lars on 2024-10-08.
//
#include <string>
#include <iostream>
#include ""kedelkloppersprook.h""


// Funktion, um das nächste Wort in einer Zeile zu extrahieren
std::string nextWord(std::string& line) {
    std::string word;

   int endWord = line.find_first_of("" .,"");

   if (endWord == 0) {
       word = line.substr(0,1);
       line.erase(0,1);
       return word;
   }

   if (endWord != std::string::npos) {
       word = line.substr(0, endWord);
       line.erase(0, endWord);
       return word;
   }

   word = line;
   line.erase(0, endWord);

    return word;
}

// Übersetzt ein Wort gemäß den Regeln der Keddelkloppersprook-Sprache
std::string translateWord(std::string& word) {
    // Findet die Position des ersten Vokals im Wort
    //size_t vowelPosition = word.find_first_of(""aeiou"");
    int vowelPosition = 0;

    vowelPosition = word.find_first_of(""aeiou"");

    // Wenn kein Vokal gefunden wurde oder das Wort leer ist, bleibt es unverändert
    if (vowelPosition == std::string::npos || word.empty()) {
        return word;
    }

    // Teilt das Wort in den Teil vor dem ersten Vokal und den Rest des Wortes
    std::string beforeVowel = word.substr(0, vowelPosition);
    std::string afterVowel = word.substr(vowelPosition);

    // Übersetzt das Wort, indem die Teile vertauscht und ein 'i' hinzugefügt wird
    std::string  [MASK]  = afterVowel + beforeVowel + ""i"";

    //Satzzeichen aus wort entfernen
    int pos = 0;
    char punct = '\0';
    for (char c:  [MASK] ) {
        if (ispunct(c)) {
             [MASK] .erase(pos, 1);
            punct = c;
        }
        pos++;
    }

    //Wenn ein satzzeichen entfernt wurde dies hinten anhängen, wenn keins entfernt wurde ist punct = '\0' (NULL)
    if (punct != '\0') {
         [MASK]  += punct;
    }

    return  [MASK] ;
}

std::string assembleSentence(std::string& line) {
    std::string sentence;
    std::string word;

    while (line.length() > 0) {
        word = nextWord(line);
        sentence += translateWord(word);
    }

    return sentence;
}

void toLowercase(std::string &word) {
    for (char &c : word)
    {
        c = tolower(c);
    }
}

std::string toKedelkloppersprook(std::string line) {
    toLowercase(line);
    return assembleSentence(line);
}",translation
811,"// ~~ Task ~~
// There is a matrix filled with water. There are mines in some random places.
// Ship must move from left down corner (start point) to right up corner (end
// point). Ship can move only up and right with 1/2 probability for each
// direction. When ship moves to cell with mine - it is destroyed. Use Monte
// Carlo method to get probability of ship successfully reaching end point.

#include <array>
#include <cstdio>
#include <iostream>
#include <random>

constexpr int sea_size = 20;
using Matrix = std::array<std::array<char, sea_size>, sea_size>;
std::mt19937 generator;
std::random_device seed;

void fillMatrix(Matrix& sea, const char fill_symbol) {
    for (int i = 0; i != sea.size(); ++i) {
        for (int j = 0; j != sea.size(); ++j) {
            sea[i][j] = fill_symbol;
        }
    }
}

void generateRandomElements(Matrix& sea, const char element_symbol,
                            const int elements_count) {
    generator.seed(seed());
    std::uniform_int_distribution<int> dist(0, sea.size() - 1);

    int x = 0;
    int y = 0;
    for (int i = 0; i != elements_count; ++i) {
        x = dist(generator);
        y = dist(generator);
        while (sea[x][y] == element_symbol) {
            x = dist(generator);
            y = dist(generator);
        }

        sea[x][y] = element_symbol;
    }
}

bool movementTill(Matrix& sea, const char  [MASK] ,
                  const char failure_symbol) {
    generator.seed(seed());
    std::bernoulli_distribution ber_dist;

    int x = 0;
    int y = 0;
    constexpr int movement_limit = 50000;
    for (int i = 0; i < movement_limit; ++i) {
        if (sea[x][y] == failure_symbol) return false;
        if (sea[x][y] ==  [MASK] ) return true;

        if (x == sea.size() - 1) {
            ++y;
            continue;
        }
        if (y == sea.size() - 1) {
            ++x;
            continue;
        }

        if (ber_dist(generator)) {
            ++x;
        } else {
            ++y;
        }
    }

    return false;
}

int main() {
    Matrix sea;

    constexpr int tests = 100000;
    int successes = 0;
    for (int i = 0; i != tests; ++i) {
        constexpr char water_symbol = '~';
        fillMatrix(sea, water_symbol);

        constexpr char mine_symbol = '*';
        constexpr int mines_count = 6;
        generateRandomElements(sea, mine_symbol, mines_count);

        constexpr char end_symbol = 'E';
        sea[sea.size() - 1][sea.size() - 1] = end_symbol;

        if (movementTill(sea, end_symbol, mine_symbol)) ++successes;
    }

    const float success_probability =
        (static_cast<float>(successes) / tests) * 100;

    std::cout << ""Number of tests: "" << tests << std::endl;
    std::cout << ""Number of successes: "" << successes << std::endl;
    std::cout << ""Probability of ship reaching the end: "" << success_probability
              << ""%"" << std::endl;

    // Keep console window open until you press any key.
    std::getchar();
}
",destination_symbol
812,"/*
 * Copyright 2021 WebAssembly Community Group participants
 *
 * 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 wasm_ir_gc_type_utils_h
#define wasm_ir_gc_type_utils_h

#include ""wasm.h""

namespace wasm {

namespace GCTypeUtils {

// Helper code to evaluate a reference at compile time and check if it is of a
// certain kind. Various wasm instructions check if something is a function or
// data etc., and that code is shared here.

enum Kind { Func, Data, I31, Other };

enum EvaluationResult {
  // The result is not known at compile time.
  Unknown,
  // The evaluation is known to succeed (i.e., we find what we are looking
  // for), or fail, at compile time.
  Success,
  Failure
};

// Given an instruction that checks if the child reference is of a certain kind
// (like br_on_func checks if it is a function), see if type info lets us
// determine that at compile time.
// This ignores nullability - it just checks the kind.
inline EvaluationResult evaluateKindCheck(Expression* curr) {
  Kind expected;
  Expression* child;

  // Some operations flip the condition.
  bool flip = false;

  if (auto* br = curr->dynCast<BrOn>()) {
    switch (br->op) {
      // We don't check nullability here.
      case BrOnNull:
      case BrOnNonNull:
      // Casts can only be known at runtime using RTTs.
      case BrOnCast:
      case BrOnCastFail:
        return Unknown;
      case BrOnNonFunc:
        flip = true;
        [[fallthrough]];
      case BrOnFunc:
        expected = Func;
        break;
      case BrOnNonData:
        flip = true;
        [[fallthrough]];
      case BrOnData:
        expected = Data;
        break;
      case BrOnNonI31:
        flip = true;
        [[fallthrough]];
      case BrOnI31:
        expected = I31;
        break;
      default:
        WASM_UNREACHABLE(""unhandled BrOn"");
    }
    child = br->ref;
  } else if (auto* is = curr->dynCast<RefIs>()) {
    switch (is->op) {
      // We don't check nullability here.
      case RefIsNull:
        return Unknown;
      case RefIsFunc:
        expected = Func;
        break;
      case RefIsData:
        expected = Data;
        break;
      case RefIsI31:
        expected = I31;
        break;
      default:
        WASM_UNREACHABLE(""unhandled BrOn"");
    }
    child = is->value;
  } else if (auto* as = curr->dynCast<RefAs>()) {
    switch (as->op) {
      // We don't check nullability here.
      case RefAsNonNull:
        return Unknown;
      case RefAsFunc:
        expected = Func;
        break;
      case RefAsData:
        expected = Data;
        break;
      case RefAsI31:
        expected = I31;
        break;
      default:
        WASM_UNREACHABLE(""unhandled BrOn"");
    }
    child = as->value;
  } else {
    WASM_UNREACHABLE(""invalid input to evaluateKindCheck"");
  }

  auto childType = child->type;

  Kind actual;

  if (childType.isFunction()) {
    actual = Func;
  } else if (childType.isData()) {
    actual = Data;
  } else if (childType.getHeapType() == HeapType::i31) {
    actual = I31;
  } else {
    return Unknown;
  }

  auto  [MASK]  = actual == expected;
  if (flip) {
     [MASK]  = ! [MASK] ;
  }
  return  [MASK]  ? Success : Failure;
}

} // namespace GCTypeUtils

} // namespace wasm

#endif // wasm_ir_gc_type_utils_h
",success
813,"/*
 *
 * Copyright © 2017 <NAME>(<NAME>)/<EMAIL>.
 *
 * 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 <gprpc/common.h>
#include <cli_conn.h>
#include <gprpc/rpc_client.h>
#include <gprpc/rpc_channel.h>
#include <rpc_debug.h>
#include <gprpc/rpc_controller.h>
#include <rpc_controller_imp.h>
#include <rpc_channel_impl.h>


gprpc::client::cli_conn::cli_conn(gprpc::client::rpc_channel_impl& channel,
                                Closure& done,
                                gprpc::rpc_controller& controller,
                                Message* response)
    : sync_call_(false),
      tr_(NO_TIMEOUT),
      channel_impl_(channel),
      socket_(*channel.get_client().get_nios()),
      total_deadline_(*channel.get_client().get_wios()),
      deadline_(*channel.get_client().get_wios()),
//      connect_retry_num_(2),
      wios_(channel.get_client().get_wios()),
      done_(done),
      controller_(controller),
      response_(response){
    if (response_ == NULL) {
        sync_call_ = true;
    }
}
gprpc::client::cli_conn::~cli_conn() {
}

void gprpc::client::cli_conn::handle_total_timeout(const boost::system::error_code &e) {
    if (!e) {
        tr_ = TOTAL_TIMEOUT;
        channel_impl_.get_resolver().cancel();
//        deadline_.cancel();
        boost::system::error_code ignored_ec;
        socket_.close(ignored_ec);
    }
}

void gprpc::client::cli_conn::handle_resolve_timeout(const boost::system::error_code &e) {
    if (!e) {
        tr_ = RESOLVE_TIMEOUT;
        channel_impl_.get_resolver().cancel();
//        total_deadline_.cancel();
    }
}

void gprpc::client::cli_conn::handle_conn_timeout(const boost::system::error_code &e) {
    if (!e) {
        tr_ = CONNECT_TIMEOUT;
        boost::system::error_code ignored_ec;
        socket_.close(ignored_ec);
    }
}

void gprpc::client::cli_conn::handle_sock_timeout(const boost::system::error_code &e, timout_reason tr) {
    if (!e) {
        tr_ = tr;
        boost::system::error_code ignored_ec;
        socket_.close(ignored_ec);
//        total_deadline_.cancel();
    }
}

void gprpc::client::cli_conn::start() {
    set_start_time(get_time_stamp());
    seq_++;
    tcp::resolver::iterator end;

    uint32_t total_timeout = controller_.get_total_timeout();
    if (total_timeout > 0) {
        total_deadline_.expires_from_now(boost::posix_time::milliseconds(total_timeout));
        total_deadline_.async_wait(boost::bind(&gprpc::client::cli_conn::handle_total_timeout, shared_from_this(),
                                               boost::asio::placeholders::error));
    }

    if (channel_impl_.get_it_ep() != end) {
        it_ep_ = channel_impl_.get_it_ep();
        connect();
    } else {
        resolve();
    }
    i_log << ""rpc call "" << get_tag() << "" started,"" << "" sts: "" << get_start_time();
}

tcp::socket &gprpc::client::cli_conn::socket() {
    return socket_;
}

void gprpc::client::cli_conn::set_buffer(std::string& data) {
    uint32_t ori_data_len = header_.data_len;
    uint32_t data_len = htonl(header_.data_len);
	header_.data_len = data_len;
    size_t header_size = sizeof(header_);
    memcpy(buffer_.data(), &header_, header_size);
    memcpy(buffer_.data() + header_size, data.c_str(), data.size());
	header_.data_len = ori_data_len;
}

gprpc::rpc_header &gprpc::client::cli_conn::get_header() {
    return header_;
}

void gprpc::client::cli_conn::send() {
    uint32_t write_timeout = controller_.get_write_timeout();
    if (write_timeout > 0) {
        deadline_.expires_from_now(boost::posix_time::milliseconds(write_timeout));
        deadline_.async_wait(boost::bind(&gprpc::client::cli_conn::handle_sock_timeout, shared_from_this(),
                                         boost::asio::placeholders::error, SEND_TIMEOUT));
    } else {
        deadline_.cancel();
    }
    d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", start sending request..."";
    size_t size = sizeof(header_) + header_.data_len;
    async_write(socket_, buffer(buffer_), transfer_exactly(size),
                bind(&gprpc::client::cli_conn::handle_send, shared_from_this(),
                     boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}

void gprpc::client::cli_conn::handle_send(const boost::system::error_code &e, size_t bytes_trans) {
    if (!e) {
        if (bytes_trans != sizeof(header_) + header_.data_len) {
            done(-4, ""request message not sent completely"");
        } else {
            d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", request sent."";
            rcv_rsp_header();
        }

    } else {
        std::stringstream ss;
        ss << e.message();
        if (e == boost::asio::error::operation_aborted) {
            ss << "", "" << get_timeout_reason();
        }
        done(-4, ss.str());
    }
}

void gprpc::client::cli_conn::done(int32_t err_code, std::string  [MASK] ) {
    deadline_.cancel();
    total_deadline_.cancel();

    if (err_code != 0) {
        controller_.impl_->set_failed(err_code);
        controller_.impl_->set_error_detail( [MASK] );
    }

    std::stringstream ss;
    if (err_code == 0) {
        ss << ""Rpc call: ""
               << controller_.impl_->get_call_tag()
               << "" rpc data receiving successfully: ""
               << controller_.ErrorCode()
               << "", ""
               << controller_.ErrorText();
        if (! [MASK] .empty()) {
            ss << "", "" <<  [MASK] ;
        }
        i_log << ss.str();
    } else {
        ss << ""Rpc call: ""
               << controller_.impl_->get_call_tag()
               << "" failed, error code: ""
               << controller_.ErrorCode()
               << "", ""
               << controller_.ErrorText();
        if (! [MASK] .empty()) {
            ss << "", "" <<  [MASK] ;
        }
        e_log << ss.str();
//        wios_->post(boost::bind(&Closure::Run, &done_));
    }

    if (sync_call_) {
        done_.Run();
    } else {
        wios_->post(boost::bind(&gprpc::client::rpc_channel_impl::handle_rpc_response, &channel_impl_, shared_from_this()));
    }
}

void gprpc::client::cli_conn::handle_connect(const boost::system::error_code &e) {
    if (!e) {
        d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", connected!"";
        send();
    } else {
        std::stringstream ss;
        ss << ""address: "" << channel_impl_.get_address() << "", port: "" << channel_impl_.get_port() << e.message();
        if (e == boost::asio::error::operation_aborted) {
//            ss << "", time out!"";
            ss << "", "" << get_timeout_reason();
        }

//        channel_impl_.get_it_ep()++;
        it_ep_++;
//        if (channel_impl_.get_it_ep() != tcp::resolver::iterator()) {
        if (it_ep_ != tcp::resolver::iterator()) {
            e_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", connect failed,"" << ss.str();
            connect();
        } else {
//            total_deadline_.cancel();
            done(-3, ss.str());
        }
    }
}
void gprpc::client::cli_conn::handle_resolve(const boost::system::error_code &e, tcp::resolver::iterator ep_it) {
    if (!e) {
        d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", resolving done!"";
        //todo:lock? Nah, won't cause serious problem, just leave it be.
        //todo:IT WILL!
//        it_ep_ = ep_it;
//        channel_impl_.set_it_ep(ep_it);
        channel_impl_.set_it_ep_if_empty(ep_it);
        it_ep_ = channel_impl_.get_it_ep();
        connect();
    } else {
        std::stringstream ss;
        ss << ""address: "" << channel_impl_.get_address() << "", port: "" << channel_impl_.get_port() << e.message();
        if (e == boost::asio::error::operation_aborted) {
//            ss << "", time out!"";
            ss << "", "" << get_timeout_reason();
        }
        done(-2, ss.str());
    }
}

void gprpc::client::cli_conn::connect() {
//    if (channel_impl_.get_it_ep() != tcp::resolver::iterator()) {
    if (it_ep_ != tcp::resolver::iterator()) {
        uint32_t connect_timeout = controller_.get_connect_timeout();
        if (connect_timeout > 0) {
            deadline_.expires_from_now(boost::posix_time::milliseconds(connect_timeout));
            deadline_.async_wait(boost::bind(&gprpc::client::cli_conn::handle_conn_timeout, shared_from_this(),
                                             boost::asio::placeholders::error));
        } else {
            deadline_.cancel();
        }

        d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", start connecting..."";
//        boost::asio::async_connect(socket_, channel_impl_.get_it_ep(),
//                                   bind(&gprpc::client::cli_conn::handle_connect, shared_from_this(), boost::asio::placeholders::error));
        boost::asio::async_connect(socket_, it_ep_,
                                   bind(&gprpc::client::cli_conn::handle_connect, shared_from_this(), boost::asio::placeholders::error));
    } else {
        e_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", no resolved endpoints available!"";
    }
}

void gprpc::client::cli_conn::resolve() {
    uint32_t resolve_timeout = controller_.get_resolve_timeout();
    if (resolve_timeout > 0) {
        deadline_.expires_from_now(boost::posix_time::milliseconds(resolve_timeout));
        deadline_.async_wait(boost::bind(&gprpc::client::cli_conn::handle_resolve_timeout, shared_from_this(),
                                         boost::asio::placeholders::error));
    } else {
        deadline_.cancel();
    }

    d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", start resolving..."";
    tcp::resolver::query query(channel_impl_.get_address(), channel_impl_.get_port());
    channel_impl_.get_resolver().async_resolve(query, bind(&gprpc::client::cli_conn::handle_resolve, shared_from_this(),
                                        boost::asio::placeholders::error, boost::asio::placeholders::iterator));
}

void gprpc::client::cli_conn::rcv_rsp_header() {

    uint32_t read_timeout = controller_.get_read_timeout();
    if (read_timeout > 0) {
        deadline_.expires_from_now(boost::posix_time::milliseconds(read_timeout));
        deadline_.async_wait(boost::bind(&gprpc::client::cli_conn::handle_sock_timeout, shared_from_this(),
                                         boost::asio::placeholders::error, RECEIVE_TIMEOUT));
    } else {
        deadline_.cancel();
    }

    d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", start receiving response header...."";
    async_read(socket_, buffer(buffer_), transfer_exactly(sizeof(rpc_header)),
               bind(&gprpc::client::cli_conn::handle_rsp_header, shared_from_this(),
                    boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}

void gprpc::client::cli_conn::handle_rsp_header(const boost::system::error_code &e, size_t bytes_trans) {
    if (!e) {
        if (bytes_trans != sizeof(rpc_header)) {
            done(-5);
            return;
        }
        memcpy(&header_, buffer_.data(), bytes_trans);
        if (memcmp(header_.magic, rpc_magic, 4) != 0) {
            done(-6, ""rpc_magic error"");
            return;
        }
        uint32_t data_len = ntohl(header_.data_len);
        header_.data_len = data_len;
        if (header_.data_len > conn_buf_size_) {
            done(-7);
            return;
        }
        d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", response header received!"";
        rcv_rsp_data();
    } else {
        std::stringstream ss;
        ss << e.message();
        if (e == boost::asio::error::operation_aborted) {
//            ss << "", time out!"";
            ss << "", "" << get_timeout_reason();
        }
        done(-5, ss.str());
    }
}

void gprpc::client::cli_conn::rcv_rsp_data() {
    //inherit the previous read deadline timer, if any, from rcv_rsp_header()
    d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", start receiving response data...."";
    async_read(socket_, buffer(buffer_), transfer_exactly(header_.data_len),
               bind(&gprpc::client::cli_conn::handle_rsp_data, shared_from_this(),
                    boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}

void gprpc::client::cli_conn::handle_rsp_data(const boost::system::error_code &e, size_t bytes_trans) {
    if (!e) {
        if (bytes_trans != header_.data_len) {
            done(-8, ""size of the received data is wrong"");
            return;
        }
        d_log << ""Rpc call: "" << controller_.impl_->get_call_tag() << "", response data received!"";
//        wios_->post(boost::bind(&gprpc::client::rpc_channel_impl::handle_rpc_response, channel_.impl_, shared_from_this()));
        done(0);
    } else {
        std::stringstream ss;
        ss << e.message();
        if (e == boost::asio::error::operation_aborted) {
//            ss << "", time out!"";
            ss << "", "" << get_timeout_reason();
        }
        done(-8, e.message());
    }
}

Closure &gprpc::client::cli_conn::get_done() {
    return done_;
}

gprpc::rpc_controller &gprpc::client::cli_conn::get_controller() {
    return controller_;
}

Message* gprpc::client::cli_conn::get_response() {
    return response_;
}

const char *gprpc::client::cli_conn::get_buffer() {
    return buffer_.data();
}

const gprpc::rpc_header &gprpc::client::cli_conn::get_header() const {
    return header_;
}

bool gprpc::client::cli_conn::is_sync_call() {
    return sync_call_;
}

namespace gprpc {
    namespace client {
        const std::string total_to = ""Total time out reached!"";
        const std::string resolve_to = ""Resolving time out reached!"";
        const std::string conn_to = ""Connecting time out reached!"";
        const std::string recv_to = ""Receiving time out reached!"";
        const std::string send_to = ""Sending time out reached!"";
        const std::string no_to = ""No time out"";
    }
}

const std::string& gprpc::client::cli_conn::get_timeout_reason() {
    using namespace gprpc::client;
    switch (tr_) {
        case TOTAL_TIMEOUT:
            return total_to;
        case RESOLVE_TIMEOUT:
            return resolve_to;
        case CONNECT_TIMEOUT:
            return conn_to;
        case RECEIVE_TIMEOUT:
            return recv_to;
        case SEND_TIMEOUT:
            return send_to;
        case NO_TIMEOUT:
            return no_to;
        default:
            return no_to;
    }
}
",extra_err_msg
814,"#ifndef VALEAN_CREF_
#define VALEAN_CREF_

#include <utility>

template<typename T>
class cowned;

template<typename T>
class cref;

template<typename T>
class cref_guard;

template<typename T>
class cref {
public:
  cref(cowned<T>* own_) :
      own(own_) {
    own->refCount++;
  }
  ~cref() {
  	own->refCount--;
  }

  cref_guard<T> open() {
    return cref_guard<T>(own);
  }

private:
  cowned<T>* own;
};

template<typename T>
class cref_guard {
public:
  cref_guard(cowned<T>* own_) :
      own(own_) {
    assert(own->present);
    own->present = false;
  }
  ~cref_guard() {
    own->present = true;
  }

  T& operator*() { return own->contents; }
  const T& operator*() const { return own->contents; }
  T* operator->() { return &own->contents; }
  const T* operator->() const { return &own->contents; }

private:
  cowned<T>* own;
};

template<typename T>
class cowned {
public:
  cowned(T  [MASK] ) :
      present(true),
      refCount(0),
      contents(std::move( [MASK] )) {}
  ~cowned() {
  	assert(present);
  	assert(refCount == 0);
  }

  cref<T> ref() {
  	return cref<T>(this);
  }

private:
  friend class cref<T>;
  friend class cref_guard<T>;

  bool present : 1;
  size_t refCount : 63;
  T contents;
};

template<typename T, typename... P>
cowned<T> make_cowned(P&&... params) {
  return cowned<T>(T(std::forward<P>(params)...));
}

#endif
",contents_
815,"#include <array>

#include <memory>
#include <string>
#include <utility>

#include ""everybot_node/sensors/joint_state.hpp""

using everybot::everybot::sensors::JointState;

JointState::JointState(
  std::shared_ptr<rclcpp::Node> & nh,
  const std::string & topic_name,
  const std::string & frame_id)
: Sensors(nh, frame_id)
{
  pub_ = nh->create_publisher<sensor_msgs::msg::JointState>(topic_name, this->qos_);

  RCLCPP_INFO(nh_->get_logger(), ""Succeeded to create joint state publisher"");
}

void JointState::publish(
  const rclcpp::Time & now,
  std::shared_ptr<DynamixelSDKWrapper> & dxl_sdk_wrapper)
{
  auto msg = std::make_unique<sensor_msgs::msg::JointState>();

  static std::array<int32_t, JOINT_NUM> last_diff_position,  [MASK] ;

  std::array<int32_t, JOINT_NUM> position =
  {dxl_sdk_wrapper->get_data_from_device<int32_t>(
      extern_control_table.present_position_left.addr,
      extern_control_table.present_position_left.length),
    dxl_sdk_wrapper->get_data_from_device<int32_t>(
      extern_control_table.present_position_right.addr,
      extern_control_table.present_position_right.length)};

  std::array<int32_t, JOINT_NUM> velocity =
  {dxl_sdk_wrapper->get_data_from_device<int32_t>(
      extern_control_table.present_velocity_left.addr,
      extern_control_table.present_velocity_left.length),
    dxl_sdk_wrapper->get_data_from_device<int32_t>(
      extern_control_table.present_velocity_right.addr,
      extern_control_table.present_velocity_right.length)};

  // std::array<int32_t, JOINT_NUM> current =
  //   {dxl_sdk_wrapper->get_data_from_device<int32_t>(
  //     extern_control_table.resent_current_left.addr,
  //     extern_control_table.resent_current_left.length),
  //   dxl_sdk_wrapper->get_data_from_device<int32_t>(
  //     extern_control_table.resent_current_right.addr,
  //     extern_control_table.resent_current_right.length)};

  msg->header.frame_id = this->frame_id_;
  msg->header.stamp = now;

  msg->name.push_back(""wheel_left_joint"");
  msg->name.push_back(""wheel_right_joint"");

  msg->position.push_back(TICK_TO_RAD * last_diff_position[0]);
  msg->position.push_back(TICK_TO_RAD * last_diff_position[1]);

  msg->velocity.push_back(RPM_TO_MS * velocity[0]);
  msg->velocity.push_back(RPM_TO_MS * velocity[1]);

  // msg->effort.push_back(current[0]);
  // msg->effort.push_back(current[1]);

  last_diff_position[0] += (position[0] -  [MASK] [0]);
  last_diff_position[1] += (position[1] -  [MASK] [1]);

   [MASK]  = position;

  pub_->publish(std::move(msg));
}
",last_position
816,"// FalconX FC
// Functions library
// <NAME>	Dec 4th 2018

#include ""functions.h""
#include ""utils/defines.h""
#include ""motorControl.h""
#include ""variables.h""
#include ""Arduino.h""

void mixer(int throttle, int pitch, int roll, int yaw) {
	/* ---------- PITCH CONTROL ---------- */
	if (pitch > MID_VAL) {
		motorWrite(0, throttle);
		motorWrite(1, throttle);
		motorWrite(2, throttle + diff(pitch));
		motorWrite(3, throttle + diff(pitch));
	}
	if (pitch < MID_VAL) {
		motorWrite(0, throttle + diff(pitch));
		motorWrite(1, throttle + diff(pitch));
		motorWrite(2, throttle);
		motorWrite(3, throttle);
	}

	/* ---------- ROLL CONTROL ---------- */
	if (roll > MID_VAL) {
		motorWrite(0, throttle + diff(roll));
		motorWrite(1, throttle);
		motorWrite(2, throttle + diff(roll));
		motorWrite(3, throttle);
	}
	if (roll < MID_VAL) {
		motorWrite(0, throttle);
		motorWrite(1, throttle + diff(roll));
		motorWrite(2, throttle);
		motorWrite(3, throttle + diff(roll));
	}

	/* ---------- YAW CONTROL ---------- */
	if (yaw > MID_VAL) {
		motorWrite(0, throttle - diff(yaw));
		motorWrite(1, throttle + diff(yaw));
		motorWrite(2, throttle + diff(yaw));
		motorWrite(3, throttle - diff(yaw));
	}
	if (yaw < MID_VAL) {
		motorWrite(0, throttle + diff(yaw));
		motorWrite(1, throttle - diff(yaw));
		motorWrite(2, throttle - diff(yaw));
		motorWrite(3, throttle + diff(yaw));
	}

	/* ---------- DEFAULT CONTROLS ---------- */
	if (pitch == MID_VAL && roll == MID_VAL && yaw == MID_VAL) {
		writeAllMotors(throttle);
	}
}

inline int combine(int var1, int  [MASK] ) {
	if ( [MASK]  > MIN_VAL)  [MASK]  -= MIN_VAL;
	return var1 +  [MASK] ;
}

inline int diff(int var)
{
	if (var > MID_VAL) return var - MID_VAL;
	if (var < MID_VAL) return MID_VAL - var;
	if (var == MID_VAL) return MID_VAL;
}

#if defined(debug)
long now, old;
inline void initCycTime() {
	now = millis();
}
inline void getCycTime(double val) {
	val = now - old;
	old = now;
}
#endif


inline double mapper(int var, int fromMin, int fromMax, int toMin, int toMax) {
	return ((var - fromMin) * (toMax - toMin) / (fromMax - fromMin)) + toMin;
}",var2
817,"#include <Maths.h>

inline Vector2D Vector2D::operator-()
{
    return Vector2D{ -x, -y };
}

inline Vector2D Vector2D::operator+(Vector2D const other)
{
    return Vector2D{ x + other.x, y + other.y };
}

inline Vector2D Vector2D::operator-(Vector2D const other) const
{
    return Vector2D{ x - other.x, y - other.y };
}

inline Vector2D Vector2D::operator*(float k)
{
    Vector2D result = { 0.f, 0.f };
    result.x = x * k;
    result.y = y * k;
    return result;
}

inline Vector2D Vector2D::operator/(float k)
{
    x /= k;
    y /= k;
    return *this;
}

inline bool Vector2D::operator==(Vector2D const other)
{
    if (x != other.x) return false;
    if (y != other.y) return false;
    return true;
}

inline bool Vector2D::operator==(Vector2D const other) const
{
    if (x != other.x) return false;
    if (y != other.y) return false;
    return true;
}

inline bool Vector2D::operator!=(Vector2D const other)
{
    if (x != other.x) return true;
    if (y != other.y) return true;
    return false;
}

inline Vector2D Vector2D::operator+=(Vector2D const other)
{
    this->x += other.x;
    this->y += other.y;
    return *this;
}

inline Vector2D Vector2D::operator-=(Vector2D const other)
{
    this->x -= other.x;
    this->y -= other.y;
    return *this;
}

inline Vector2D Vector2D::operator/=(float const k)
{
    this->x /= k;
    this->y /= k;
    return *this;
}

inline const Vector2D Vector2D::operator*(const float n) const
{
    const Vector2D  [MASK]  = { x * n, y * n };
    return  [MASK] ;
}

inline Vector2D Vector2D::GetDirection(Vector2D other)
{
    return other - *this;
}

inline float Vector2D::DotProduct(Vector2D other)
{
    return x * other.x + y * other.y;
}

inline float Vector2D::Determinant(Vector2D other)
{
    return x * other.y - y * other.x;
}

inline float Vector2D::Magnitude() const
{
    return sqrt(x * x + y * y);
}

inline void Vector2D::Normalize()
{
    *this /= this->Magnitude();
}

inline Vector2D Vector2D::Normal()
{
    return Vector2D{ y, -x };
}

inline float DotProduct2D(Vector2D vecA, Vector2D vecB)
{
    return vecA.x * vecB.x + vecA.y * vecB.y;
}

inline Vector2D GetDirection(Vector2D vecA, Vector2D vecB)
{
    return vecB - vecA;
}

inline float GetDeterminant(Vector2D vecA, Vector2D vecB)
{
    return vecA.x * vecB.y - vecA.y * vecB.x;
}

inline float DistanceAB(Vector2D A, Vector2D B)
{
    return (B - A).Magnitude();
}

////////////////////////////////////////////////////////////////////////////////////////////////////

inline bool Vector3D::operator==(const Vector3D other)
{
    if (other.x != x) return false;
    if (other.y != y) return false;
    if (other.z != z) return false;
    return true;
}

inline bool Vector3D::operator==(const Vector3D other) const
{
    if (other.x != x) return false;
    if (other.y != y) return false;
    if (other.z != z) return false;
    return true;
}

inline Vector3D operator+(Vector3D lhs,Vector3D rhs)
{
    return Vector3D{ lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z };
}

inline Vector3D Vector3D::operator-(const Vector3D other)
{
    return Vector3D{ x - other.x, y - other.y, z - other.z };
}

inline Vector3D Vector3D::operator*(const float k)
{
    return Vector3D{ x * k, y * k, z * k };
}

inline Vector3D Vector3D::operator*(const Vector3D other)
{
    return Vector3D{ x * other.x, y * other.y, z * other.z };
}

inline Vector3D Vector3D::operator*(const float k) const
{
    return Vector3D{ x * k, y * k, z * k };
}

inline Vector3D Vector3D::operator+=(const Vector3D other)
{
    x += other.x;
    y += other.y;
    z += other.z;
    return *this;
}

inline Vector3D Vector3D::operator*=(float const k)
{
    this->x *= k;
    this->y *= k;
    this->z *= k;
    return *this;
}

inline Vector3D Vector3D::operator/=(float const k)
{
    this->x /= k;
    this->y /= k;
    this->z /= k;
    return *this;
}

inline float Vector3D::Magnitude() const
{
    return sqrt(x * x + y * y + z * z);
}

inline Vector3D Vector3D::ConvertVector3ToRadians(Vector3D vec)
{
    vec.x = DEG2RAD(vec.x);
    vec.y = DEG2RAD(vec.y);
    vec.z = DEG2RAD(vec.z);
    return vec;
}

inline Vector3D Vector3D::ConvertRadVec3ToDegree(Vector3D vec)
{
    vec.x = RAD2DEG(vec.x);
    vec.y = RAD2DEG(vec.y);
    vec.z = RAD2DEG(vec.z);
    return vec;
}


inline void Vector3D::Normalize()
{
    *this /= this->Magnitude();
}

inline Vector3D Vector3D::Normalize(Vector3D vec)
{
    return vec /= vec.Magnitude();
}

inline float DotProduct3D(Vector3D vecA, Vector3D vecB)
{
    return vecA.x * vecB.x + vecA.y * vecB.y + vecA.z * vecB.z;
}

inline float DistanceAB(Vector3D A, Vector3D B)
{
    return (B - A).Magnitude();
}

////////////////////////////////////////////////////////////////////////////////////////////////////

inline Vector4D Vector4D::operator+(const Vector4D other)
{
    return Vector4D{ x + other.x, y + other.y, z + other.z, w + other.w };
}

inline Vector4D Vector4D::operator-(const Vector4D other)
{
    return Vector4D{ x - other.x, y - other.y, z - other.z, w - other.w };
}

inline Vector4D Vector4D::operator*(const float k)
{
    return Vector4D{ x * k, y * k, z * k, w * k };
}

inline Vector4D Vector4D::operator/=(float const k)
{
    this->w /= k;
    this->x /= k;
    this->y /= k;
    this->z /= k;
    return *this;
}

inline Vector4D& Vector4D::operator=(const Vector3D other)
{
    x = other.x;
    y = other.y;
    z = other.z;
    w = 1.f;
    return *this;
}

inline bool Vector4D::operator==(const Vector4D other)
{
    if (other.x != x) return false;
    if (other.y != y) return false;
    if (other.z != z) return false;
    if (other.w != w) return false;

    return true;
}

inline bool Vector4D::operator!=(const Vector4D other)
{
    if (other.x != x) return true;
    if (other.y != y) return true;
    if (other.z != z) return true;
    if (other.w != w) return true;

    return false;
}

inline void Vector4D::Homogenize()
{
    if (w != 0)
    {
        x /= w;
        y /= w;
        z /= w;
        w /= w;
    }
    else
    {
        std::cout << ""Divide by zero"" << __FILE__ << __LINE__ << std::endl;
    }
}

inline float Vector4D::Magnitude() const
{
    return sqrt(x * x + y * y + z * z + w * w);
}

inline void Vector4D::Normalize()
{
    *this /= this->Magnitude();
}

////////////////////////////////////////////////////////////////////////////////////////////////////

inline float Matrix4D::operator[](const unsigned int index)
{
    return coord[index % 4][index / 4];
}

inline Matrix4D Matrix4D::operator+(const Matrix4D mat)
{
    Matrix4D result;
    for (int j = 0; j < 4; j++)
        for (int i = 0; i < 4; i++)
            result.coord[j][i] = coord[j][i] + mat.coord[j][i];

    return result;
}

inline Matrix4D Matrix4D::operator-(const Matrix4D mat)
{
    Matrix4D result;
    for (int j = 0; j < 4; j++)
        for (int i = 0; i < 4; i++)
            result.coord[j][i] = coord[j][i] - mat.coord[j][i];

    return result;
}

inline Vector3D Matrix4D::operator*(Vector3D vec)
{
    Vector4D v2 = { vec.x, vec.y, vec.z, 1.f };
    Vector4D result = { 0.f, 0.f, 0.f, 0.f };

    for (int j = 0; j < 4; j++)
        for (int i = 0; i < 4; i++)
            result.coord[j] += coord[i][j] * v2.coord[i];

    Vector3D res = { result.x, result.y, result.z };
    return res;
}

inline Vector4D Matrix4D::operator*(Vector4D vec)
{
    Vector4D result = { 0.f, 0.f, 0.f, 0.f };

    for (int j = 0; j < 4; j++)
        for (int i = 0; i < 4; i++)
            result.coord[j] += coord[i][j] * vec.coord[i];

    return result;
}

inline Matrix4D Matrix4D::operator*(const Matrix4D mat)
{
    Matrix4D multMatrix;

    for (int k = 0; k < 4; k++)
        for (int j = 0; j < 4; j++)
            for (int i = 0; i < 4; i++)
                multMatrix.coord[j][k] += coord[i][k] * mat.coord[j][i];

    return multMatrix;
}

inline bool Matrix4D::operator==(const Matrix4D matrix)
{
        for (int j = 0; j < 4; j++)
            for (int i = 0; i < 4; i++)
                if(coord[j][i] != matrix.coord[j][i])
                    return false;
    return true;
}

inline bool Matrix4D::operator!=(const Matrix4D matrix)
{
    for (int j = 0; j < 4; j++)
        for (int i = 0; i < 4; i++)
            if (coord[j][i] != matrix.coord[j][i])
                return true;
    return false;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

inline bool Quaternion::operator==(const Quaternion other)
{
    if (other.x != x) return false;
    if (other.y != y) return false;
    if (other.z != z) return false;
    if (other.w != w) return false;

    return true;
}

inline Quaternion Quaternion::operator+(const Quaternion other)
{
    Quaternion quat = Quaternion();
    quat.scalar = this->scalar + other.scalar;
    quat.imaginaries = this->imaginaries + other.imaginaries;
    return quat;
}

inline Quaternion Quaternion::operator-(const Quaternion other)
{
    Quaternion quat = Quaternion();
    quat.scalar = this->scalar - other.scalar;
    quat.imaginaries = this->imaginaries - other.imaginaries;
    return quat;
}

inline Quaternion Quaternion::operator*(float k)
{
    Quaternion quat = Quaternion();
    quat.scalar = this->scalar * k;
    quat.imaginaries = this->imaginaries * k;
    return quat;
}

inline Quaternion Quaternion::operator*(float k) const
{
    Quaternion quat = Quaternion();
    quat.scalar = this->scalar * k;
    quat.imaginaries = this->imaginaries * k;
    return quat;
}

inline Quaternion Quaternion::operator*(const Quaternion other)
{
    return Quaternion(w * other.w - x * other.x - y * other.y - z * other.z,
        w * other.x + x * other.w + y * other.z - z * other.y,
        w * other.y - x * other.z + y * other.w + z * other.x,
        w * other.z + x * other.y - y * other.x + z * other.w);
}

inline void Quaternion::operator+=(const Quaternion other)
{
    this->scalar += other.scalar;
    this->imaginaries = this->imaginaries + other.imaginaries;
}

inline void Quaternion::operator-=(const Quaternion other)
{
    this->scalar -= other.scalar;
    this->imaginaries = this->imaginaries - other.imaginaries;
}

inline void Quaternion::operator*=(const Quaternion other)
{
    Quaternion q(w, x, y, z);
    w = q.w * other.w - q.x * other.x - q.y * other.y - q.z * other.z;
    x = q.w * other.x + q.x * other.w + q.y * other.z - q.z * other.y;
    y = q.w * other.y - q.x * other.z + q.y * other.w + q.z * other.x;
    z = q.w * other.z + q.x * other.y - q.y * other.x + q.z * other.w;
}

inline void Quaternion::operator*=(float k)
{
    this->scalar *= k;
    this->imaginaries = this->imaginaries * k;
}

inline Vector3D Quaternion::operator*(Vector3D other)
{
    Quaternion quat = Quaternion(1.f, other);
    return ((*this) * quat * (*this).GetInversedQuat()).imaginaries;
}

inline float Quaternion::DotProduct(const Quaternion other) const
{
    return x * other.x + y * other.y + z * other.z + w * other.w;
}

inline float Quaternion::GetNorm()
{
    float a = 0.f;
    for (size_t i = 0; i < 4; i++)
        a += pow(this->coord[i], 2.f);

    return sqrt(a);
}

inline void Quaternion::Normalize()
{
    *this *= 1 / this->GetNorm();
}

inline Quaternion Quaternion::GetNormalizedQuat()
{
    Quaternion quat = *this;
    quat.Normalize();
    return quat;
}

inline void Quaternion::Conjugate()
{
    this->imaginaries = this->imaginaries * -1;
}

inline Quaternion Quaternion::GetConjugatedQuat()
{
    Quaternion quat = *this;
    quat.Conjugate();
    return quat;
}

inline void Quaternion::Inverse()
{
    *this = this->GetConjugatedQuat() * (1.f / pow(this->GetNorm(), 2.f));
}

inline Quaternion Quaternion::GetInversedQuat()
{
    Quaternion quat = *this;
    quat.Inverse();
    return quat;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

template <typename T>
inline T Min(T x, T y)
{
    return x <= y ? x : y;
}

template <typename T>
inline T Max(T x, T y)
{
    return x >= y ? x : y;
}

template <typename T>
inline T Sign(T x)
{
    return x >= 0 ? 1 : -1;
}

template <typename T>
inline T Absolute(T x)
{
    return x >= 0 ? x : -x;
}

template <typename T>
inline T Lerp(T start, T end, const float& t)
{
    return (end - start) * t + start;
}

inline float Lerp(const float& start, const float& end, const float& t)
{
    return (end - start) * t + start;
}

inline Vector2D Lerp(const Vector2D& start, const Vector2D& end, const float& t)
{
    return (end - start) * t + start;
}

inline int Clamp(int n, int min, int max)
{
    n = n > max ? max : n;
    n = n < min ? min : n;
    return n;
}

inline float Clamp(float k, float min, float max)
{
    return Min(Max(k, min), max);
}",newVec
818,"#include <iostream>
#include <sys/time.h>
#include <unistd.h>
#include <unbound_array.hpp>

using namespace datastructures;
using namespace std;

template<typename T, size_t ALPHA, size_t BETA>
auto testArray(UnboundArray<T, ALPHA, BETA> &a, int num) -> void;

auto main(int argc, char** argv) -> int
{

	int num = 1000000;

	std::cout << ""Test of datastruct UnboundArray<int, 4, 2>"" << std::endl;
	UnboundArray<int, 4, 2> a;
	testArray(a, num);
	
	std::cout << ""Test of datastruct UnboundArray<int, 3, 2>"" << std::endl;
	UnboundArray<int, 4, 2> b;
	testArray(b, num);
	
	std::cout << ""Test of datastruct UnboundArray<int, 5, 3>"" << std::endl;
	UnboundArray<int, 4, 2> c;
	testArray(c, num);

	return 0;
}

template<typename T, size_t ALPHA = 4, size_t BETA = 2>
auto testArray(UnboundArray<T, ALPHA, BETA> &a, int num) -> void 
{
	struct timeval start, end;
	//std::cout << std::endl << ""Size is "" << a.size() << std::endl << std::endl;

	gettimeofday(&start, NULL);
	for (int i = 0; i < num; ++i)
	{
		a.pushBack(i);
		//std::cout << ""Adding "" << i << "" to UnboundArray."" << std::endl;
	}

	//std::cout << std::endl << ""Size is "" << a.size() << std::endl;

	//for (int i = 0; i < num; ++i) {
	//std::cout << ""array["" << i << ""] = "" << a->operator [](i) << std::endl;
	//}

	for (int i = num - 1; i >= 0; i--)
	{
		a.popBack();
		//int c = a.popBack();
		//std::cout << ""Popping "" << c << std::endl;
	}
	gettimeofday(&end, NULL);
	long mtime, seconds,  [MASK] ;

	seconds = end.tv_sec - start.tv_sec;
	 [MASK]  = end.tv_usec - start.tv_usec;

	mtime = ((seconds) * 10000000 +  [MASK] ) / 1000;

	//std::cout << std::endl << ""Size is "" << a.size() << std::endl << std::endl;
	std::cout << ""Time elapsed: "" << mtime << ""ms."" << std::endl;
}",useconds
819,"#include ""DeviceInfoLedger.h""


DeviceConfigLedger *DeviceConfigLedger::_instance;
DeviceInfoLedger *DeviceInfoLedger::_instance;

static Logger _deviceInfoLog(""app.devinfo"");

//
// DeviceConfigLedger
//
// [static]
DeviceConfigLedger &DeviceConfigLedger::instance() {
    if (!_instance) {
        _instance = new DeviceConfigLedger();
    }
    return *_instance;
}

DeviceConfigLedger::DeviceConfigLedger() {
}

DeviceConfigLedger::~DeviceConfigLedger() {
}

void DeviceConfigLedger::setup() {
#ifndef UNITTEST
    // Set up ledgers

    if (configDefaultLedgerEnabled) {
        configDefaultLedger = Particle.ledger(configDefaultLedgerName);
        configDefaultLedger.onSync([this](Ledger ledger) {
            defaultConfig = ledger.get();
        });
        defaultConfig = configDefaultLedger.get();
    }


    if (configDeviceLedgerEnabled) {
        configDeviceLedger = Particle.ledger(configDeviceLedgerName);
        configDeviceLedger.onSync([this](Ledger ledger) {
            deviceConfig = ledger.get();
        });
        deviceConfig = configDeviceLedger.get();
    }

#endif // UNITTEST

}

void DeviceConfigLedger::callUpdateCallbacks() {
    for(auto cb : updateCallbacks) {
        cb();
    }
}


Variant DeviceConfigLedger::getConfigVariant(const char *key, Variant defaultValue) const {
    Variant result;

    // sources is lowest priority first; later ones overwrite earlier keys
    Vector<Variant> sources;
    if (localConfig.has(key)) {
        sources.append(localConfig.get(key));
    }
    if (defaultConfig.has(key)) {
        sources.append(defaultConfig.get(key));
    }
    if (deviceConfig.has(key)) {
        sources.append(deviceConfig.get(key));
    }

    for(Variant source : sources) {
        if (source.isMap()) {
            for(Map<String,Variant>::Entry entry : source.asMap().entries()) {
                result.set(entry.first, entry.second);
            }
        }  
        else
        if (source.isArray()) {
            for(int ii = 0; ii < source.size(); ii++) {
                result.append(source.at(ii));
            }
        }
        else {
            result = source;
        }
    }

    return result;
}

void DeviceConfigLedger::clear() {
    defaultConfig = LedgerData();
    localConfig = LedgerData();
    deviceConfig = LedgerData();
}



//
// DeviceInfoLedger
//

// [static]
DeviceInfoLedger &DeviceInfoLedger::instance() {
    if (!_instance) {
        _instance = new DeviceInfoLedger();
    }
    return *_instance;
}

DeviceInfoLedger::DeviceInfoLedger() {
}

DeviceInfoLedger::~DeviceInfoLedger() {
}

void DeviceInfoLedger::setup() {
#ifndef UNITTEST
    if (setupComplete) {
        // Cannot call setup more than once
        return;
    }

    DeviceConfigLedger::instance().withUpdateCallback([this]() { updateConfig(); });

    resetReason = System.resetReason();
    if (resetReason ==  RESET_REASON_USER) {
        resetReasonData = System.resetReasonData();
    }

    // Set up ledgers
    infoLedger = Particle.ledger(infoLedgerName);

    // If the ledger is cached locally, the update callback won't be called
    updateConfig();

    // Check retained buffer
    if (retainedBuffer && retainedBufferSize && retainedBufferSize > sizeof(RetainedBufferHeader)) {
        retainedHdr = (RetainedBufferHeader *)retainedBuffer;
        retainedData = &retainedBuffer[sizeof(RetainedBufferHeader)];
        retainedDataSize = retainedBufferSize - sizeof(RetainedBufferHeader);

        if (retainedHdr->magic == retainedMagicBytes && retainedHdr->size == retainedBufferSize && retainedHdr->headerSize == sizeof(RetainedBufferHeader)) {
            _deviceInfoLog.info(""retained buffer valid"");

            if (retainedHdr->offset > 0) {
                size_t size = retainedHdr->offset;
                if (size > retainedDataSize) {
                    size = retainedDataSize;
                }
                int lastRunLogConfig = getConfigLastRunLog();
                if (lastRunLogConfig > 0) {
                    if (size > (size_t)lastRunLogConfig) {
                        size = (size_t)lastRunLogConfig;
                    }
                    lastRunLog = new char[size + 1];
                    if (lastRunLog) {
                        for(size_t ii = 0; ii < size; ii++) {
                            lastRunLog[ii] = retainedData[(retainedHdr->offset - size + ii) % retainedDataSize];
                        }
                        lastRunLog[size] = 0;
                    }

                }


                retainedHdr->offset = 0;
            }
        }
        else {
            // Reinitialize header
            _deviceInfoLog.info(""retained buffer reinitialized"");
            retainedHdr->magic = retainedMagicBytes;
            retainedHdr->size = retainedBufferSize;
            retainedHdr->headerSize = sizeof(RetainedBufferHeader);
            retainedHdr->reserved1 = 0;
            retainedHdr->offset = 0;
        }
    }
    else {
        // Invalid parameters
        retainedBuffer = nullptr;
        retainedBufferSize = 0;
    }

    setupComplete = true;
#endif // UNITTEST

}

void DeviceInfoLedger::loop() {
#ifndef UNITTEST

    if (Network.ready()) {
        if (!isNetworkConnected) {
            isNetworkConnected = true;
        }
    }
    else {
        if (isNetworkConnected) {
            isNetworkConnected = false;
        }

    }
#if Wiring_Cellular
    if (Cellular.ready()) {
        if (!isCellularConnected) {
            isCellularConnected = true;
        }
    }
    else {
        if (isCellularConnected) {
            isCellularConnected = false;
        }

    }
#endif
#if Wiring_WiFi
    if (WiFi.ready()) {
        if (!isWiFiConnected) {
            isWiFiConnected = true;
        }
    }
    else {
        if (isWiFiConnected) {
            isWiFiConnected = false;
        }
    }
#endif

    // TODO: Ethernet?

    if (Particle.connected()) {
        if (!isCloudConnected) {
            isCloudConnected = true;
            connectionCount++;

            onCloudConnection();
        }
    }
    else {
        if (isCloudConnected) {
            isCloudConnected = false;
            writeToConnectionLog = true;
        }
    }
#endif // UNITTEST
}




DeviceInfoLedger &DeviceInfoLedger::withLocalConfigLogLevel(LogLevel level, LogCategoryFilters filters) {
    bool result;
    
    result = setLocalConfigString(""logLevel"", logLevelToString(level));

    Variant  [MASK] ;
    for(LogCategoryFilter &filter: filters) {
         [MASK] .set(filter.category(), Variant(logLevelToString(filter.level())));
    }
    if ( [MASK] .isMap()) {
        result = setLocalConfigVariant(""logFilters"",  [MASK] );
    }

    return *this;
}


void DeviceInfoLedger::updateConfig() {

    _deviceInfoLog.info(""updateConfig lastRunLog=%d connectionLog=%d logLevel=%s"", 
        DeviceInfoLedger::instance().getConfigLastRunLog(),
        DeviceInfoLedger::instance().getConfigConnectionLog(),
        DeviceInfoLedger::instance().getConfigString(""logLevel"").c_str());

    configureLogHandler();


    // Allocate log buffer
    connectionLogSize = DeviceInfoLedger::instance().getConfigConnectionLog();
    if (connectionLogBuffer) {
        delete[] connectionLogBuffer;
        connectionLogBuffer = nullptr;
    }
    if (connectionLogSize) {
        connectionLogBuffer = new uint8_t[connectionLogSize];
    }
    connectionLogOffset = 0;

}

const char *DeviceInfoLedger::logLevelToString(LogLevel level) const {
    const char *levelName = ""NONE"";
    switch(level) {
        // LOG_LEVEL_ALL has the same numeric value (1) as LOG_LEVEL_TRACE
        /*
        case LOG_LEVEL_ALL:
            levelName = ""ALL"";
            break;
        */

        case LOG_LEVEL_TRACE:
            levelName = ""TRACE"";
            break;

        case LOG_LEVEL_INFO:
            levelName = ""INFO"";
            break;

        case LOG_LEVEL_WARN:
            levelName = ""WARN"";
            break;

        case LOG_LEVEL_ERROR:
            levelName = ""ERROR"";
            break;

        case LOG_LEVEL_PANIC:
            levelName = ""PANIC"";
            break;

        default:
            break;
    }    
    return levelName;
}

LogLevel DeviceInfoLedger::stringToLogLevel(const char *levelStr) const {
    LogLevel level = LOG_LEVEL_NONE;

    if (strstr(levelStr, ""ALL"") != 0) {
        level = LOG_LEVEL_ALL;
    }
    else
    if (strstr(levelStr, ""TRACE"") != 0) {
        level = LOG_LEVEL_TRACE;
    }
    else
    if (strstr(levelStr, ""INFO"") != 0) {
        level = LOG_LEVEL_INFO;
    }
    else
    if (strstr(levelStr, ""WARN"") != 0) {
        level = LOG_LEVEL_WARN;
    }
    else
    if (strstr(levelStr, ""ERROR"") != 0) {
        level = LOG_LEVEL_ERROR;
    }
    else
    if (strstr(levelStr, ""PANIC"") != 0) {
        level = LOG_LEVEL_PANIC;
    }
    else {
        level = LOG_LEVEL_NONE;
    }
    

    return level;
}

void DeviceInfoLedger::getLogLevelFilters(LogLevel &level, LogCategoryFilters &filters) const {
    level = stringToLogLevel(getConfigString(""logLevel"").c_str());
    // _deviceInfoLog.info(""level %d"", level);

    filters.clear();
    Variant logFilters = getConfigVariant(""logFilters"");

    // _deviceInfoLog.trace(""logFilters JSON %s"", logFilters.toJSON().c_str());

    if (logFilters.isMap()) {
        for(Map<String,Variant>::Entry entry : logFilters.asMap().entries()) {
            String category = entry.first;
            LogLevel level = stringToLogLevel(entry.second.toString().c_str());    
            // _deviceInfoLog.trace(""filter %d %s"", level, category.c_str());       
            filters.append(LogCategoryFilter(category, level));         
        }
    }

}

void DeviceInfoLedger::configureLogHandler() {
#ifndef UNITTEST
    if (logHandler) {
        LogManager::instance()->removeHandler(logHandler);
        delete logHandler;
        logHandler = nullptr;
    }

    LogLevel level;
    LogCategoryFilters filters;
    getLogLevelFilters(level, filters);

    logHandler = new DeviceInfoLedgerLogHandler(level, filters);

	// Add this handler into the system log manager
	LogManager::instance()->addHandler(logHandler);
#endif

}



void DeviceInfoLedger::write(uint8_t c) {
    if (!setupComplete) {
        return;
    }

    if (c == '\r') {
        // Log lines are terminated by CRLF, but remove the CR here. Maybe make this configurable.
        return;
    }

    if (retainedBuffer) {
        retainedData[retainedHdr->offset++ % retainedDataSize] = c;
    }

    if (writeToConnectionLog && connectionLogSize && connectionLogBuffer) {
        connectionLogBuffer[connectionLogOffset++ % connectionLogSize] = c;
    }

}


void DeviceInfoLedger::onCloudConnection() {

    bool isFirstConnection = (connectionCount == 1);


#ifndef UNITTEST
    Variant data;

    // Save connection log
    uint32_t offset = connectionLogOffset;
    if (offset) {
        size_t size = offset;
        if (size > connectionLogSize) {
            size = connectionLogSize;
        }
        // _deviceInfoLog.info(""connectionLog offset=%lu size=%u"", offset, size);

        char *buf = new char[size + 1];
        if (buf) {
            for(size_t ii = 0; ii < size; ii++) {
                buf[ii] = (char) connectionLogBuffer[(offset - size + ii) % connectionLogSize];
            }
            buf[size] = 0;
            
            data.set(""connLog"", buf);

            delete[] buf;
        }
        writeToConnectionLog = false;
        connectionLogOffset = 0;
    }

    // Save last run log
    if (lastRunLog) {
        data.set(""lastRun"", lastRunLog);
    }

    // Save reset reason. Value stored in member variable in setup().
    if (resetReason != RESET_REASON_NONE) {
        data.set(""resetReason"", resetReason);
        if (resetReason ==  RESET_REASON_USER) {
            data.set(""resetReasonData"", resetReasonData);
        }
    }

    // Save device diagnostics if enabled
    if (getConfigIncludeDiag()) {
    	String jsonStr;

	    jsonStr.reserve(256);

        struct {
            static bool appender(void* appender, const uint8_t* data, size_t size) {
                String *s = (String *)appender;
                return (bool) s->concat(String((const char *)data, size));
            }
        } Callback;

        system_format_diag_data(nullptr, 0, 0, Callback.appender, &jsonStr, nullptr);
        // _deviceInfoLog.info(""diag %s "", jsonStr.c_str());

        data.set(""diag"", Variant::fromJSON(jsonStr));
    }

#if Wiring_Cellular
    // Save cell tower information if cellular, and enabled
    if (getConfigIncludeTower()) {
        CellularGlobalIdentity cgi = {0};
        cgi.size = sizeof(CellularGlobalIdentity);
        cgi.version = CGI_VERSION_LATEST;

        cellular_result_t res = cellular_global_identity(&cgi, NULL);
        if (res == SYSTEM_ERROR_NONE) {
            Variant tower;
            tower.set(""mcc"", cgi.mobile_country_code);
            tower.set(""mnc"", cgi.mobile_network_code);
            tower.set(""cid"", cgi.cell_id);
            tower.set(""lac"", cgi.location_area_code);

            data.set(""tower"", tower);
            _deviceInfoLog.trace(""Cellular Info: cid=%lu lac=%u mcc=%u mnc=%u"", cgi.cell_id, cgi.location_area_code, cgi.mobile_country_code, cgi.mobile_network_code);
        }
        else {
            _deviceInfoLog.info(""cellular_global_identity failed %d"", res);
        }
    }
    // Add modem information here?
    // Things like ICCID are stored in the cloud
#endif

    if (getConfigIncludeGeneral()) {
        data.set(""sysver"", System.version().c_str());        
    }

    infoLedger.set(data, Ledger::REPLACE); // Ledger::REPLACE Ledger::MERGE

    _deviceInfoLog.trace(""infoLedger updated"");
#endif // UNITTEST

}

#ifndef UNITTEST
DeviceInfoLedgerLogHandler::DeviceInfoLedgerLogHandler(LogLevel level, LogCategoryFilters filters) : StreamLogHandler(*this, level, filters) {

}

DeviceInfoLedgerLogHandler::~DeviceInfoLedgerLogHandler() {

}

size_t DeviceInfoLedgerLogHandler::write(uint8_t c) {
    DeviceInfoLedger::instance().write(c);
    return 1;
}
#endif // UNITTEST



",map
820,"#include <SPI.h>

#include <ESP8266WiFi.h>
#include <PubSubClient.h> // See https://pubsubclient.knolleary.net/

//The following libraries must be installed into your arduino libraries folder
#include <MFRC522.h>     //from the library manager, search for frc and install MFRC522 By GithubCommunity Version 1.4.3
#include <SimpleTimer.h> //from github, https://github.com/schinken/SimpleTimer, download the cpp and h files (raw) and place into a folder named ""SimpleTimer"" in the arduino libraries folder

#include ""secrets.h"" // This contains the ""SSID"", ""PASSWORD"" and ""MQTT_SERVER"" values.

// RFID reader config
#define SS_PIN 15 // D8 => GPIO 15
#define RST_PIN 0 // D3 => GPIO 0
#define CARD_READ_INTERVAL (200)

#define DEVICE_TYPE ""rfid-reader"" // That's me

WiFiClient espClient;
PubSubClient mqtt_client(espClient);

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
SimpleTimer timer;                //a timer object to handle periodic tasks without blocking delay()

const bool debugRfid = false;
const bool debugMQTT = false;

// the setup function runs once when you press reset or power the board
void setup()
{
    initializeSerial();
    initializeWiFi();
    initializeMQTT();
    initializeRfidReader();
}

void loop()
{
    timer.run();
}

void initializeSerial()
{
    Serial.begin(115200);
    while (!Serial)
    {
        ; // wait for serial attach
    }
}

void initializeWiFi()
{

    delay(100);

    // We start by connecting to a WiFi network
    Serial.println();
    Serial.print(""Connecting to "");
    Serial.println(SSID);
    WiFi.begin(SSID, PASSWORD);
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(500);
        Serial.print(""."");
    }
    randomSeed(micros());

    Serial.println("""");
    Serial.println(""WiFi connected"");
    Serial.println(""IP address: "");
    Serial.println(WiFi.localIP());
}

void initializeMQTT()
{
    mqtt_client.setServer(MQTT_SERVER, 1883);

    timer.setInterval(100, runMQTT);
}

void initializeRfidReader()
{
    Serial.println(F(""Init rfid reader""));
    SPI.begin();        // Init SPI bus
    mfrc522.PCD_Init(); // Init MFRC522

    if (debugRfid)
    {
        mfrc522.PCD_DumpVersionToSerial(); // Show details of PCD - MFRC522 Card Reader details
        Serial.println(F(""Scan PICC to see UID, SAK, type, and data blocks...""));
    }
    timer.setInterval(CARD_READ_INTERVAL, readRfidToSerial);
}

void readRfidToSerial()
{

    if (!mfrc522.PICC_IsNewCardPresent())
    {
        if (debugRfid)
        {
            Serial.println(F(""No card present""));
        }
        return;
    }
    if (debugRfid)
    {
        Serial.println(F(""Card present""));
    }

    // Select one of the cards
    if (!mfrc522.PICC_ReadCardSerial())
    {
        if (debugRfid)
        {
            Serial.println(F(""Failed to select card""));
        }
        return;
    }

    // Dump debug info about the card; PICC_HaltA() is automatically called
    //   mfrc522.PICC_DumpToSerial(&(mfrc522.uid));

    String  [MASK]  = """";
    for (byte i = 0; i < mfrc522.uid.size; i++)
    {
         [MASK] .concat(String(mfrc522.uid.uidByte[i] < 0x10 ? ""0"" : """"));
         [MASK] .concat(String(mfrc522.uid.uidByte[i], HEX));
    }
     [MASK] .toUpperCase();
    publishCard( [MASK] .c_str());

    if (debugRfid)
    {
        Serial.print(""UID tag:"");
        Serial.println( [MASK] );
    }
}

void reconnect()
{
    // Loop until we're reconnected
    while (!mqtt_client.connected())
    {
        Serial.print(""Attempting MQTT connection..."");
        // Create a random client ID
        String clientId = ""ESP8266Client-"";
        clientId += String(random(0xffff), HEX);
        // Attempt to connect
        if (mqtt_client.connect(clientId.c_str()))
        {
            Serial.println(""connected"");
            // Register to the server
            publishRegistration();
        }
        else
        {
            Serial.print(""failed, rc="");
            Serial.print(mqtt_client.state());
            Serial.println("" try again in 5 seconds"");
            // Wait 5 seconds before retrying
            delay(5000);
        }
    }
}

void runMQTT()
{
    if (!mqtt_client.connected())
    {
        reconnect();
    }
    mqtt_client.loop();
}

void publishCard(const char *uid)
{
    publishTopic(""card"", uid);
}

void publishRegistration()
{
    publishTopic(""register"", DEVICE_TYPE);
}

void getMac(char mac[13])
{
    String s = WiFi.macAddress();
    for (int i = 0, j = 0; i < 12; i += 1)
    {
        mac[i] = s.charAt(j);
        if (s.charAt(j + 1) == ':')
        {
            j += 2;
        }
        else
        {
            j += 1;
        }
    }
    mac[12] = 0x00;
}

void publishTopic(const char *cmd, const char *value)
{
    char pub_topic[128];
    char mac[13];
    getMac(mac);
    snprintf(pub_topic, sizeof(pub_topic), ""/device/%s/%s"", mac, cmd);

    mqtt_client.publish(pub_topic, value);

    if (debugMQTT)
    {
        Serial.print(""Published '"");
        Serial.print(value);
        Serial.print(""' to topic: "");
        Serial.println(pub_topic);
    }
}
",rfidUIDValue
821,"/*
 * lock-free queue 
 */

#include ""common.h""
#include <stdio.h>

#ifndef _RING_H
#define _RING_H
namespace valois {
namespace base {

template<typename T>
class Ring {
public:
    Ring():_arr(nullptr), _head(0), _tail(0), len(0) {};
    Ring(long ring_len):_head(0), _tail(0), len(ring_len) {
        if(createRing(ring_len) == false) {
            std::cout << ""create ring failed"" << std::endl;
        }
    }

    ~Ring() {
        delete[] _arr;
    }

    bool createRing(long ring_len) {
        _arr = new T[len];
        if(_arr == nullptr) return false;
        for(int i = 0; i < len; ++i) {
            _arr[i] = nullptr;
        }
        return true;
    }

    bool resizeRing(long ring_len) {
        std::lock_guard<std::mutex> lock(_arr_lock);
        if(len > ring_len) return false;
        T *_new_arr = new T[ring_len];
        int _new_head = ring_len - 1;
        int  [MASK]  = ring_len - 1;
        while(false != isEmpty()) {
            _new_arr[ [MASK] ] = _arr[_head];
            -- [MASK] ;
            _arr[_head] = nullptr;
            _head = (_head - 1 + len) % len;
        }
        _head = _new_head;
        _tail =  [MASK] ;
        len = ring_len;
        delete[] _arr;
        _arr = _new_arr;
        return true;
    }

    bool isEmpty() {
        return (_head - _tail - 1 + len) % len == 0;
    }

    bool isFull() {
        return (_head - _tail + 1 + len) % len == 0;
    }

    long size() {
        return (_head - _tail - 1 + len) % len;
    }

    T pop() {
        ScopeSpinLock _lock;
        if((_head - _tail - 1 + len) % len == 0) return nullptr;
        //std::cout << ""head "" << _head << std::endl;
        //std::cout << ""pop "" << _arr[_head] << std::endl;
        T cur = _arr[_head];
        _arr[_head] = nullptr;
        _head = (_head - 1 + len) % len;
        return cur;
    }

    bool push(const T &tp) {
        ScopeSpinLock _lock;
        if((_head - _tail + 1 + len) % len == 0) return false;
        if(_head == _tail) {
            if(nullptr == _arr[_head]) {
                _arr[_tail] = tp;
                return true;
            }
        }
        _tail = (_tail - 1 + len) % len;
        _arr[_tail] = tp;
        //std::cout << ""push success "" << tp << "" head = "" << _head << "" tail = "" << _tail << std::endl;
        return true;
    }

private:
    T *_arr;
    std::mutex _arr_lock;
    int _head;
    int _tail;
    long len;
};

}
}
#endif",_new_tail
822,"#include <gui/screen2_screen/Screen2View.hpp>
#include <gui/screen2_screen/Screen2Presenter.hpp>
#include <gui/common/FrontendApplication.hpp>
#include <touchgfx/Application.hpp>

Screen2Presenter::Screen2Presenter(Screen2View& v)
    : view(v)
{

}

void Screen2Presenter::activate()
{
    // Start the countdown when Screen2 becomes active
    if (model)
    {
        model->startCounting();
    }
}

void Screen2Presenter::deactivate()
{

}

void Screen2Presenter::updateCounter(int  [MASK] )
{
    // Forward the counter update to the view
    view.displayCounter( [MASK] );
}

void Screen2Presenter::gameEnded()
{
    // Reset the game in the view
    view.resetGame();
    
    // Stop counting
    if (model)
    {
        model->stopCounting();
    }
    
    // Go back to Screen1 with transition
    static_cast<FrontendApplication*>(touchgfx::Application::getInstance())->gotoScreen1ScreenSlideTransitionEast();
}",newCount
823,"/*
  Wifi secure connection example for ESP32
  Running on TLS 1.2 using mbedTLS
  2017 - <NAME> - Apache 2.0 License.
*/

#include <WiFiClientSecure.h>

const char* ssid     = ""YourSSID"";     // your network SSID (name of wifi network)
const char* password = ""<PASSWORD>""; // your network password

const char*  server = ""api.pushover.net"";  // Server URL

// api.pushover.net root certificate authority
// SHA1 fingerprint is broken now!
const char* test_root_ca= \
     ""-----BEGIN CERTIFICATE-----\n"" \
     ""<KEY>"" \
     ""<KEY>"" \
     ""<KEY>"" \
     ""QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT\n"" \
     ""<KEY>"" \
     ""b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG\n"" \
     ""9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB\n"" \
     ""CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97\n"" \
     ""nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt\n"" \
     ""<KEY>"" \
     ""<KEY>"" \
     ""<KEY>"" \
     ""<KEY>EB<KEY>DVR0TAQH/<KEY>NVbR\n"" \
     ""TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw\n"" \
     ""DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr\n"" \
     ""hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg\n"" \
     ""06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF\n"" \
     ""PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls\n"" \
     ""YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk\n"" \
     ""CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=\n"" \
     ""-----END CERTIFICATE-----\n"";

// You can use x.509 client certificates if you want
//const char* test_client_key = """";   //to verify the client
//const char* test_client_cert = """";  //to verify the client


WiFiClientSecure client;

#define LED 2    // onboard LED
#define IN_PIN 5 // peephole connected to digital pin 5

int pinState = 1;

void setup() {
  pinMode(IN_PIN, INPUT); // sets the digital pin 5 as input
  pinMode(LED, OUTPUT);   // onboard LED
  
  digitalWrite(LED, HIGH); // Turn onboard LED off
  
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  delay(100);

  Serial.print(""Attempting to connect to SSID: "");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  // attempt to connect to Wifi network:
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(""."");
    // wait 1 second for re-trying
    delay(1000);
  }

  Serial.print(""Connected to "");
  Serial.println(ssid);

  sendPush(""Bereit"");
}

void loop() {
  int  [MASK]  = digitalRead(IN_PIN);     // read the input pin

  if(pinState !=  [MASK] ) {
    Serial.print(""Old state: "");
    Serial.println(pinState);
    Serial.print(""New state: "");
    Serial.println( [MASK] );

    pinState =  [MASK] ;

    if( [MASK]  == 0) {
      digitalWrite(LED, LOW);
      sendPush(""Message!"");
      digitalWrite(LED, HIGH);
      delay(5000);
    }
  }
  
  delay(1000);
}

void sendPush(String message) {
  client.setCACert(test_root_ca);
  //client.setCertificate(test_client_key); // for client verification
  //client.setPrivateKey(test_client_cert);  // for client verification

  Serial.println(""\nStarting connection to server..."");
  if (!client.connect(server, 443))
    Serial.println(""Connection failed!"");
  else {
    Serial.println(""Connected to server!"");

    String content = ""token=abcdefg&user=abcdefg&device=iPhone&title=PushNotfier&message="" + message;
    
    // Make a HTTP request:
    client.println(""POST /1/messages.json HTTP/1.1"");
    client.println(""Host: api.pushover.net"");
    client.println(""Content-Type: application/x-www-form-urlencoded"");
    client.println(""Connection: close"");
    client.println(""Content-Length: "" + String(content.length()));
    client.println();
    client.println(content);
    client.println();

    while (client.connected()) {
      String line = client.readStringUntil('\n');
      if (line == ""\r"") {
        Serial.println(""headers received"");
        break;
      }
    }
    // if there are incoming bytes available
    // from the server, read them and print them:
    while (client.available()) {
      char c = client.read();
      Serial.write(c);
    }

    client.stop();
  }
}

",newState
824,"/** 
 *  @file   big_int.cc
 *  @brief  Main source file for the big int library
 *
 *  This file contains the source code and the DS used in the big int library
 *
 *  @author         <NAME>   https://tonyjosi97.github.io/profile/
 *  @copyright      Copyright (C) 2021 <NAME>
 *  @bug            No known bugs.
 */

#include <stdexcept>
#include <algorithm>
#include <string.h>
#include <memory>
#include <cstdio>
#include <random>
#include <iostream>
#include <mutex>
#include <atomic>
#include <vector>
#include <thread>

#include ""big_int.hpp""
#include ""big_int_lib_log.hpp""
#include ""big_int_inline_defs.hpp""
#include ""big_int_base_converter.hpp""

const char *bin_num_set = ""01"";
const char *dec_num_set = ""0123456789"";
const char *hex_num_set = ""0123456789ABCDEF"";

int bi::big_int::big_int_from_string(const std::string &str_num_arg, bi_base target_base) {

    std::string str_num(str_num_arg);

    bool is_neg = false;
    if (str_num[0] == '-') {
        is_neg = true;
        str_num = str_num.substr(1);
    }

    size_t n = str_num.find_first_not_of('0');
    if (n != std::string::npos) {
        str_num = str_num.substr(n);
    }
    else {
        str_num = ""0"";
    }

    std::string hex_str;
    switch (target_base) {
        case bi_base::BI_BIN: {
            BaseConverter bin_to_hex(bin_num_set, hex_num_set);
            hex_str = bin_to_hex.Convert(str_num);
            break;
        }
        case bi_base::BI_DEC: {
            BaseConverter dec_to_hex(dec_num_set, hex_num_set);
            hex_str = dec_to_hex.Convert(str_num);
            break;
        }
        case bi_base::BI_HEX:
            hex_str = str_num;
            break;
        default:
            throw std::invalid_argument(""Invalid base"");
    }

    if (is_neg) {
        hex_str.insert(0, ""-"");
    }

    return _big_int_from_string(hex_str);;
}

int bi::big_int::big_int_from_base_type(const BI_BASE_TYPE &bt_val, const bool is_neg) {

    big_int_clear();
    _data[_top++] = bt_val;
    _neg = is_neg;
    return 0;

}

int bi::big_int::big_int_unsigned_add(const bi::big_int &b) {

    int max_data_len, min_data_len;

    if (_top > b._top) {
        min_data_len = b._top;
        max_data_len = _top;
    } else {
        min_data_len = _top;
        max_data_len = b._top;
    }

    int i;

    BI_DOUBLE_BASE_TYPE sum = 0;
    BI_BASE_TYPE carry = 0;
    for(i = 0; i < min_data_len; ++i) {
        sum = static_cast<BI_DOUBLE_BASE_TYPE>(b._data[i]) + _data[i] + carry;
        carry = static_cast<BI_BASE_TYPE>((sum) >> BI_BASE_TYPE_TOTAL_BITS);
        _data[i] = sum & BI_BASE_TYPE_MAX;
    }

    if(max_data_len >= _total_data) {
        _big_int_expand(BI_DEFAULT_EXPAND_COUNT + max_data_len);
    }
    
    int top_cntr = 0;
    for(; i < max_data_len; ++i) {
        if(i >= _top) {
            ++top_cntr;
        }
        if(i < _top) {
            sum = static_cast<BI_DOUBLE_BASE_TYPE>(_data[i]) + carry;
        } else {
            sum = static_cast<BI_DOUBLE_BASE_TYPE>(b._data[i]) + carry;
        }
        carry = static_cast<BI_BASE_TYPE>((sum) >> BI_BASE_TYPE_TOTAL_BITS);
        _data[i] = sum & BI_BASE_TYPE_MAX;
    }
    _top += top_cntr;
    
    if (carry) {
        if(i >= _total_data) {
            _big_int_expand(BI_DEFAULT_EXPAND_COUNT);
        }
        _data[_top++] = carry;
    }

    return 0;

}

int bi::big_int::big_int_unsigned_add(const bi::big_int &b, bi::big_int &res) {

    res.big_int_clear();
    res.big_int_unsigned_add(b);
    res.big_int_unsigned_add(*this);
    return 0;

}

int bi::big_int::big_int_signed_add(const bi::big_int &b) {

    bi::big_int temp;
    big_int_signed_add(b, temp);
    _big_int_swap(temp);
    return 0;

}

int bi::big_int::big_int_signed_add(const bi::big_int &b, bi::big_int &res) {

    res.big_int_clear();
    /* If the operands are of same sign. */
    if (_neg == b._neg) {

        big_int_unsigned_add(b, res);
        res._neg = _neg;

    }
    /* If operands are of different sign. */
    else {

        /* Convert to same type. */
        _neg = !_neg;
        int comp_stat = big_int_compare(b);
        if (comp_stat == 1) {
            if (_neg) {
                b.big_int_unsigned_sub(*this, res);
                res._neg = b._neg;
            } else {
                big_int_unsigned_sub(b, res);
                res._neg = !_neg;
            }
        } else if (comp_stat == 0) {
            res.big_int_set_zero();
        } else {
            if (_neg) {
                big_int_unsigned_sub(b, res);
                res._neg = !_neg;
            } else {
                b.big_int_unsigned_sub(*this, res);
                res._neg = b._neg;
            }
        }

        /* Set back to previous type. */
        _neg = !_neg;

    }

    /* Remove any preceding zeroes if any. */
    res._big_int_remove_preceding_zeroes();

    return 0;

}

int bi::big_int::big_int_left_shift_word(int shift_words) {

    if (shift_words < 0) {
        return -1;
    }

    if (shift_words == 0) {
        return 0;
    }

    if (_top + shift_words >= _total_data) {
        _big_int_expand(BI_DEFAULT_EXPAND_COUNT + shift_words);
    }
    
    for (int i = _top - 1; i >= 0; --i) {
        _data[i + shift_words] = _data[i];
    }
    _top += shift_words;

    for (int i = 0; i < shift_words; ++i) {
        _data[i] = 0;
    }
    return 0;

}

int bi::big_int::big_int_signed_sub(const bi::big_int &b) {

    int ret_val;
    bi::big_int temp_val;
    ret_val = big_int_signed_sub(b, temp_val);
    _big_int_swap(temp_val);
    return ret_val;

}

int bi::big_int::big_int_signed_sub(const bi::big_int &b, bi::big_int &res) {

    int comp_stat = big_int_compare(b);
    if (comp_stat == 0) {
        return res.big_int_set_zero();
    } else {

        // TODO: avoid expensive (might be) copy here
        bi::big_int temp_sub(b);
        temp_sub._neg = !temp_sub._neg;
        return big_int_signed_add(temp_sub, res);
    }

}

int bi::big_int::big_int_set_zero() {

    big_int_clear();
    if (_total_data > 0) {
        _top = 1;
    } else {
        return -1;
    }
    return 0;

}

int bi::big_int::big_int_unsigned_sub(const bi::big_int &b, bi::big_int &res) const {

    int max, min;
    max = _top;
    min = b._top;

    int diff = big_int_unsigned_compare(b);
    if(diff < 0) {
        throw std::length_error(""First param should be larger"");
    }

    res.big_int_clear();
    BI_BASE_TYPE borrow = _big_int_sub_base_type(b._data, min, res);

    if((max - min) >= res._total_data) {
        res._big_int_expand(BI_DEFAULT_EXPAND_COUNT + (max - min));
    }

    for(int i = min; i < max; i++) {
        if(compare_bi_base_type(_data[i], borrow)) {
            res._data[(res._top)++] = _data[i] - borrow;
            borrow = 0;
        } else {
            res._data[(res._top)++] = \
            static_cast<BI_BASE_TYPE>((static_cast<BI_DOUBLE_BASE_TYPE>(BI_BASE_TYPE_MAX) + 1 - borrow));
            borrow = 1;
        }
    }

    res._big_int_remove_preceding_zeroes();

    return 0;

}

int bi::big_int::big_int_unsigned_sub(const bi::big_int &b) {

    bi::big_int temp;
    big_int_unsigned_sub(b, temp);
    temp._neg = this->_neg;
    _big_int_swap(temp);
    return 0;

}

int bi::big_int::big_int_multiply(const bi::big_int &b, bi::big_int &res) {

    bi::big_int temp_bi;

    res.big_int_set_zero();

    if(big_int_is_zero() || b.big_int_is_zero()) {
        /* If any/both of the opreands is zero set result as zero and exit */
        return 0;
    }

    res._neg = _neg ^ b._neg;
    
    for (int i = 0; i < b._top; ++i) {
        temp_bi.big_int_clear();
        _big_int_unsigned_multiply_bi_base_type(b._data[i], temp_bi);
        temp_bi.big_int_left_shift_word(i);
        res.big_int_unsigned_add(temp_bi);
    }
    return 0;

}

int bi::big_int::big_int_unsigned_multiply_base_type(const BI_BASE_TYPE &b, bi::big_int &res) const {

    return _big_int_unsigned_multiply_bi_base_type(b, res);

}

int bi::big_int::big_int_clear() {

    memset(_data, 0, static_cast<size_t>(_total_data) * sizeof(BI_BASE_TYPE));
    _top            = 0;
    _neg            = false;
    return 0;
}

std::string     bi::big_int::big_int_to_string(bi::bi_base base) {

    std::string tmp_op_str, hex_str = _big_int_to_string();

    bool is_neg = false;
    if (hex_str[0] == '-') {
        is_neg = true;
        hex_str = hex_str.substr(1);
    }

    size_t n = hex_str.find_first_not_of('0');
    if (n != std::string::npos) {
        hex_str = hex_str.substr(n);
    }
    else {
        hex_str = ""0"";
    }

    switch (base) {
        case bi_base::BI_BIN: {
            BaseConverter hex_to_bin(hex_num_set, bin_num_set);
            tmp_op_str = hex_to_bin.Convert(hex_str);
            break;
        }
        case bi_base::BI_DEC: {
            BaseConverter hex_to_dec(hex_num_set, dec_num_set);
            tmp_op_str = hex_to_dec.Convert(hex_str);
            break;
        }
        case bi_base::BI_HEX:
            tmp_op_str = hex_str;
            break;
        default:
            throw std::invalid_argument(""Invalid base"");
    }   

    if (is_neg) {
        tmp_op_str.insert(0, ""-"");
    }

    return tmp_op_str;

}

int bi::big_int::big_int_set_negetive(bool set_unset) {

    if (big_int_is_zero()) {
        return -1;
    }
    _neg = set_unset;
    return 0;

}

bool bi::big_int::big_int_is_zero() const {

    if (_top > 1) {
        return false;
    } else if (_top == 1) {
        if (_data[0] == 0) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }

}


bool bi::big_int::big_int_is_negetive() const {

    return _neg;

}

int bi::big_int::big_int_unsigned_compare(const bi::big_int &other) const {

    return _big_int_compare_bi_base_type_n_top(other);

}

int bi::big_int::big_int_compare(const bi::big_int &other) const {

    if (_neg == other._neg) {
        if (_neg == 1) {
            return -1 * _big_int_compare_bi_base_type_n_top(other);
        } else {
            return _big_int_compare_bi_base_type_n_top(other);
        }
    } else {
        if (_neg == 1) {
            return -1;
        } else {
            return 1;
        }
    }
}

int bi::big_int::big_int_left_shift(int bits) {

    int ret_val = 0;
    int word_shifts = bits / BI_BASE_TYPE_TOTAL_BITS;
    int bit_shifts = bits % BI_BASE_TYPE_TOTAL_BITS;
    if (word_shifts > 0) {
        ret_val = big_int_left_shift_word(word_shifts);
    }
    if (bit_shifts > 0) {
        ret_val += _big_int_left_shift_below_32bits(bit_shifts);
    }
    return ret_val;

}

int bi::big_int::big_int_left_shift(int bits, bi::big_int &res) {

    int ret_val;
    big_int temp_val(*this);
    ret_val = temp_val.big_int_left_shift(bits);
    temp_val._big_int_swap(res);
    return ret_val;

}

int bi::big_int::big_int_left_shift_word(int shift_words, bi::big_int &res) {

    int ret_val;
    big_int temp_val(*this);
    ret_val = temp_val.big_int_left_shift_word(shift_words);
    temp_val._big_int_swap(res);
    return ret_val;

}

int bi::big_int::big_int_right_shift_word(int shift_words) {

    if (shift_words >= _top) {
        return big_int_set_zero();
    }

    int i = 0;
    for (; i < _top - shift_words; ++i) {
        _data[i] = _data[i + shift_words];
    }
    for (int j = 0; j < shift_words; ++j) {
        _data[i + j] = 0;
    }

    _top -= shift_words;

    return 0;

}

int bi::big_int::big_int_right_shift_word(int shift_words, bi::big_int &res) {

    int ret_val;
    big_int temp_val(*this);
    ret_val = temp_val.big_int_right_shift_word(shift_words);
    temp_val._big_int_swap(res);
    return ret_val;

}

int bi::big_int::big_int_right_shift(int bits) {

    int ret_val = 0;
    int word_shifts = bits / BI_BASE_TYPE_TOTAL_BITS;
    int bit_shifts = bits % BI_BASE_TYPE_TOTAL_BITS;
    if (word_shifts > 0) {
        ret_val = big_int_right_shift_word(word_shifts);
    }
    if (bit_shifts > 0) {
        ret_val += _big_int_right_shift_below_32bits(bit_shifts);
    }
    return ret_val;

}

int bi::big_int::big_int_right_shift(int bits, bi::big_int &res) {

    int ret_val;
    big_int temp_val(*this);
    ret_val = temp_val.big_int_right_shift(bits);
    temp_val._big_int_swap(res);
    return ret_val;

}

int bi::big_int::big_int_get_num_of_hex_chars() const {

    return _big_int_get_num_of_hex_chars();

}

int bi::big_int::big_int_push_back_hex_chars(const BI_BASE_TYPE &hex_chars) {

    return _big_int_push_back_hex_chars(hex_chars);

}

int bi::big_int::big_int_divide_once(const bi::big_int &divisor, BI_BASE_TYPE &op_quotient, bi::big_int &op_remainder) {

    return _big_int_divide_once(divisor, op_quotient, op_remainder);

}

int bi::big_int::big_int_div(const bi::big_int &divisor, bi::big_int &op_quotient, bi::big_int &op_remainder) {

    if (divisor.big_int_is_zero()) {
        // throw std::length_error(""Division by zero undefined"");
        return -1;
    }

    bool result_sign = big_int_is_negetive() ^ divisor.big_int_is_negetive();

    if (big_int_is_zero()) {
        /* Set remainder and quotient as zero if dividend is zero. */
        op_remainder.big_int_set_zero();
        op_quotient.big_int_set_zero();
        return 0;
    }

    int comp_res = big_int_unsigned_compare(divisor);
    switch (comp_res) {
    case -1:
        /* Divisor is greater than dividend, set quotient as zero 
        and remainder as dividend */
        op_remainder = *this;
        /* Remainder takes the sign of dividend. */
        op_remainder.big_int_set_negetive(_neg);
        op_quotient.big_int_set_zero();
        return 0;
    case 0:
        /* Both dividend and divisor are same, so set quotient as 1 and remainder as zero. */
        op_quotient.big_int_from_base_type(static_cast<BI_BASE_TYPE>(1), result_sign);
        op_remainder.big_int_set_zero();
        return 0;
    case 1:

        /* Clear quotient and remainder big ints. */
        op_quotient.big_int_set_zero();

        BI_BASE_TYPE temp_div_once_quotient, temp_new_hex_rem_lsb = 0;
        bi::big_int temp_div_once_dividend, temp_div_once_remainder; 
        int divisor_length = divisor._big_int_get_num_of_hex_chars();
        int dividend_length = _big_int_get_num_of_hex_chars();
        int ret_code = big_int_right_shift((dividend_length - divisor_length) * 4, temp_div_once_dividend);
        int divide_cntr = 0;
        
        do {
        
            /* Divide once. */
            temp_div_once_quotient = 0;
            temp_div_once_remainder.big_int_clear();
            ret_code += temp_div_once_dividend._big_int_divide_once(divisor, temp_div_once_quotient, temp_div_once_remainder);
            ret_code += op_quotient._big_int_push_back_hex_chars(temp_div_once_quotient);

            if ((dividend_length - divisor_length - divide_cntr - 1) >= 0) {
                ret_code += _big_int_get_hex_char_from_lsb(dividend_length - divisor_length - divide_cntr - 1, temp_new_hex_rem_lsb);
            } 
            
            temp_div_once_dividend = temp_div_once_remainder;
            ret_code += temp_div_once_dividend.big_int_push_back_hex_chars(temp_new_hex_rem_lsb);
            ++divide_cntr;
        
        } while ((dividend_length - divisor_length + 1 - divide_cntr) > 0 && ret_code == 0);
        
        op_remainder = temp_div_once_remainder;
        op_quotient.big_int_set_negetive(result_sign);

        /* Remainder takes the sign of dividend. */
        op_remainder.big_int_set_negetive(_neg);

        return ret_code;

    }

    /* Should't reach here. */
    return -1;

}

int bi::big_int::big_int_power_base_type(const BI_BASE_TYPE &exponent, big_int &result) {

    int ret_val = 0;

    if (big_int_is_zero()) {
        if (exponent == 0) {
            /* pow(0, 0) = 1 */
            return result.big_int_from_base_type(1, false);
        } else {
            /* pow(0, anything except 0) = 0 */
            return result.big_int_set_zero();
        }
    }
    
    ret_val += result.big_int_from_base_type(1, false);

    big_int temp_val;
    for (BI_BASE_TYPE i = 0; i < exponent; ++i) {
        ret_val += big_int_multiply(result, temp_val);
        result = temp_val;
    }

    return ret_val;

}

int bi::big_int::big_int_modulus(const big_int &modulus, big_int &result) {

    big_int temp_quo, temp_rem;
    int ret_val = 0;

    ret_val += big_int_div(modulus, temp_quo, temp_rem);
    if (modulus.big_int_is_negetive() == false) {
        if (temp_rem.big_int_is_negetive() == true) {
            ret_val += modulus.big_int_unsigned_sub(temp_rem, result);
        } else {
            result = temp_rem;
        }
    } else {
        if ((temp_rem.big_int_is_negetive() == false) && (temp_rem.big_int_is_zero() == false)) {
            ret_val += modulus.big_int_unsigned_sub(temp_rem, result);   
        } else {
            result = temp_rem;
        }
        if (result.big_int_is_zero() == false) {
            ret_val += result.big_int_set_negetive(true);
        }
    }
    return ret_val;

}

bool bi::big_int::big_int_is_even() const {

    if (_top > 0) {
        if (_data[0] % 2 == 0) {
            return true;
        } else {
            return false;
        }
    } else {
        /* TODO: catch error. */
        return true;
    }

}


/*

    Fast modular exponentiation algorithm
    -------------------------------------
    
    [refer](https://stackoverflow.com/questions/40578553/fast-modular-exponentiation-help-me-find-the-mistake)
    [refer](http://homepages.math.uic.edu/~leon/cs-mcs401-s08/handouts/fastexp.pdf)

    Algorithm - python:
    -------------------

        def pow_h(base, power, modulus):
            a = 1
            while power:
                power, d = power // 2, power % 2
                if d:
                    a = a * base % modulus
                base = base * base % modulus
            return a

    Example:    8 ^ 5 mod 7

    Result is initialized to 1
    prev_base = 7, initial base during first iteration
    n_base => next base

    +----------------------+----------------------+----------------------+----------------------+
    | Itertion             | Exponent bit         | Calculation          | Result               |
    +----------------------+----------------------+----------------------+----------------------+
    | 1                    | 1                    | prev_base = 7        | 1 * 8 mod 7 = 1      | 
    |                      |                      | n_base = 8 mod 7 = 1 |                      |
    +----------------------+----------------------+----------------------+----------------------+
    | 2                    | 0                    | n_base = 8 ^ 2 mod 7 | No result calc. if   |
    |                      |                      | = 1 * 1 mod 7 = 1    | exponent bit is zero |
    +----------------------+----------------------+----------------------+----------------------+
    | 3                    | 1                    | n_base = 8 ^ 4 mod 7 | 1 * 1 mod 7 = 1      |
    |                      |                      | = 8 ^ 2 * 8 ^ 2 mod 7|                      |
    |                      |                      | = 1 * 1 mod 7 = 1    |                      |
    +----------------------+----------------------+----------------------+----------------------+

*/

int bi::big_int::big_int_fast_modular_exponentiation(const big_int &exponent, const big_int &modulus, big_int &result) {

    int ret_val = 0;

    big_int bi_1;
    bi_1.big_int_from_base_type(1, false);
    /* Compare modulus with one. */
    int comp_res = modulus.big_int_unsigned_compare(bi_1);
    /* Compare exponent with one. */
    int exp_comp_res = exponent.big_int_unsigned_compare(bi_1);

    if (exp_comp_res == 0) {
        if (exponent.big_int_is_negetive() == false) {
            /* Compare exponent with 1, return early with mod of base. */
            return (*this).big_int_modulus(modulus, result);
        } else {
            /* Compare exponent with -1, return early with inverse of base. */
            try {
                ret_val += (*this).big_int_modular_inverse_extended_euclidean_algorithm(modulus, result);
            } catch (...) {
                throw;
            }
            return ret_val;
        }
    }
    
    if (modulus.big_int_is_zero() == true) {
        /* If modulus is zero throw error. */
        throw std::range_error(""Modulus cannot be zero."");
    } else if (comp_res == 0) {
        /* Modulus is +/-1 */
        return result.big_int_set_zero();
    } else if ((*this).big_int_is_zero() == true) {
        /* Handle base = 0 */
        if (exponent.big_int_is_negetive() == false && exponent.big_int_is_zero() == false) {
            return result.big_int_set_zero();
        } else if (exponent.big_int_is_negetive() == true) {
            throw std::range_error(""Given base (0) doesn't have inverse. "");
        } else if (exponent.big_int_is_zero() == true) {
            if (modulus.big_int_is_negetive() == false) {
                result = bi_1;
            } else {
                ret_val += modulus.big_int_unsigned_sub(bi_1, result);  
                ret_val += result.big_int_set_negetive(true);
            }
            return ret_val;
        }
    }
    
    if (exponent.big_int_is_negetive() == false) {
        /* +ve exponent, follow usual algorithm. */
        ret_val += (*this)._big_int_fast_modular_exponentiation(exponent, modulus, result);
    } else {
        /* -ve exponent,  find inverse of base first. */
        big_int temp_inverse;
        try {
            ret_val += (*this).big_int_modular_inverse_extended_euclidean_algorithm(modulus, temp_inverse);
        } catch (...) {
            throw;
        }
        big_int us_exp(exponent);
        us_exp.big_int_set_negetive(false);
        /* Do modular exponentiation on inverse of the original base to get the final result. */
        ret_val += temp_inverse.big_int_fast_modular_exponentiation(us_exp, modulus, result);
    }
    return ret_val;

}

/*

    GCD - Euclidean algorithm
    -------------------------

    [refer](https://en.wikipedia.org/wiki/Euclidean_algorithm)

    For illustration, the Euclidean algorithm can be used to find the greatest common divisor of a = 1071 and b = 462. 
    To begin, multiples of 462 are subtracted from 1071 until the remainder is less than 462. Two such multiples can be subtracted (q0 = 2), 
    leaving a remainder of 147:

        1071 = 2 × 462 + 147.
    
    Then multiples of 147 are subtracted from 462 until the remainder is less than 147. Three multiples can be subtracted (q1 = 3), leaving a remainder of 21:

        462 = 3 × 147 + 21.
    
    Then multiples of 21 are subtracted from 147 until the remainder is less than 21. Seven multiples can be subtracted (q2 = 7), leaving no remainder:

        147 = 7 × 21 + 0.
    
    Since the last remainder is zero, the algorithm ends with 21 as the greatest common divisor of 1071 and 462. 

*/

int bi::big_int::big_int_gcd_euclidean_algorithm(const big_int &b, big_int &op_gcd) {

    if (((*this).big_int_is_zero() & b.big_int_is_zero()) == true) {
        /* If both numbers are zero gcd is zero. */
        return op_gcd.big_int_set_zero();
    } else if ((*this).big_int_is_zero()) {
        /* If one of the number is zero and other is non zero then gcd is the non
        zero number. */
        op_gcd = b;
        return  op_gcd.big_int_set_negetive(false);
    } else if (b.big_int_is_zero()) {
        /* If one of the number is zero and other is non zero then gcd is the non
        zero number. */
        op_gcd = (*this);
        return op_gcd.big_int_set_negetive(false);    
    }

    /* Temp working variables. */
    big_int temp_greater, temp_lower, temp_quo, temp_rem, prev_rem;

    /* Compare and assign greater and lower big int temp variables. */
    int ret_code = 0, comp_stat = (*this).big_int_unsigned_compare(b);
    if (comp_stat == 0) {
        /* If both numbers are equal then gcd is equal to the +ve number. */
        op_gcd = (*this);
        return op_gcd.big_int_set_negetive(false);
    } else if (comp_stat == 1) {
        temp_greater = (*this);
        temp_lower = b;
    } else {
        temp_greater = b;
        temp_lower = (*this);
    }

    /* Set the numbers as positve as the gcd is +ve. */
    temp_greater.big_int_set_negetive(false); temp_lower.big_int_set_negetive(false);

    /* Initialse the temp_rem and thus prev_rem with the lower number so that,
    the gcd will be the lower number when both numbers are multiples. */
    temp_rem = temp_lower;
    do {
        /* GCD Euclidean algorithm (refer func. docs.) */
        prev_rem = temp_rem;
        ret_code += temp_greater.big_int_div(temp_lower, temp_quo, temp_rem);
        temp_greater = temp_lower;
        temp_lower = temp_rem;
    } while(temp_rem.big_int_is_zero() == false);

    /* Assign previous remainder as the gcd. */
    op_gcd = prev_rem;
    return ret_code;

}

/*

    The Extended Euclidean Algorithm
    --------------------------------

[refer](http://www-math.ucdenver.edu/~wcherowi/courses/m5410/exeucalg.html)

We will number the steps of the Euclidean algorithm starting with step 0. 
The quotient obtained at step i will be denoted by qi. As we carry out each 
step of the Euclidean algorithm, we will also calculate an auxillary number, pi. 
For the first two steps, the value of this number is given: p0 = 0 and p1 = 1. 
For the remainder of the steps, we recursively calculate pi = [pi-2 - (pi-1 * qi-2)] (mod n). 
Continue this calculation for one step beyond the last step of the Euclidean algorithm.

The algorithm starts by ""dividing"" n by x. If the last non-zero remainder occurs at step k, 
then if this remainder is 1, x has an inverse and it is pk+2. (If the remainder is not 1, then x does not have an inverse.) 
Here is an example:

Find the inverse of 15 mod 26.

    Step 0:	26 = 1(15) + 11	        p0 = 0
    Step 1:	15 = 1(11) + 4	        p1 = 1
    Step 2:	11 = 2(4) + 3	        p2 = 0 - 1( 1) mod 26   = 25
    Step 3:	4  = 1(3) + 1	        p3 = 1 - 25( 1) mod 26  = -24 mod 26 = 2
    Step 4:	3  = 3(1) + 0	        p4 = 25 - 2( 2) mod 26  = 21
                                    p5 = 2 - 21( 1) mod 26  = -19 mod 26 = 7

*/

int bi::big_int::big_int_modular_inverse_extended_euclidean_algorithm(const big_int &ip_modulus, big_int &inverse) {

    big_int bi_1;
    bi_1.big_int_from_base_type(1, false);

    /* Extended euclidean algorithm (EEA) working variables */
    big_int pk_0, pk_1, pk_temp_1, pk_temp_2;
    int step_cntr = 0;
    /* Temp working variables. */
    big_int temp_greater, temp_lower, temp_quo, temp_rem, prev_rem, prev_quo[2];

    /* Temporary working copies. */
    big_int ip_num(*this), modulus(ip_modulus);
    int ret_code = 0;

    /* Do calculation as if they are +ve numbers. */
    ip_num.big_int_set_negetive(false);
    modulus.big_int_set_negetive(false);
    int comp_stat = ip_num.big_int_compare(modulus);

    if (modulus.big_int_is_zero() == true) {
        /* No inverse if modulus is equal to zero. */
        throw std::range_error(""The number is not invertible for the given modulus"");
    } else if (ip_modulus.big_int_unsigned_compare(bi_1) == 0) {
        /* If modulus is 1 or -1 then inverse is zero. */
        return inverse.big_int_set_zero();
    } else if ((*this).big_int_unsigned_compare(bi_1) == 0) {
        /* If the number is 1 set the inverse 1, follow the sign based inverse change. */
        pk_1.big_int_from_base_type(1, false);
        goto change_inverse_based_on_arg_sign;
    }

    if (comp_stat == 0 || ip_num.big_int_is_zero() == true) {
        /* No inverse if number is equal to zero. */
        throw std::range_error(""The number is not invertible for the given modulus"");
    } else if (comp_stat > 0) {
        /* If greater then reduce. */
        big_int temp_res;
        ret_code += ip_num.big_int_modulus(modulus, temp_res);
        ip_num = temp_res;
    }

    /* Init the variables to 0 and 1. */
    pk_1.big_int_from_base_type(1, false);

    temp_greater = modulus;
    temp_lower = ip_num;
    temp_rem = temp_lower;

    /* Extended euclidean algorithm */
    do {
        ++step_cntr;
        prev_rem = temp_rem;
        prev_quo[0] = prev_quo[1];
        prev_quo[1] = temp_quo;
        ret_code += temp_greater.big_int_div(temp_lower, temp_quo, temp_rem);
        temp_greater = temp_lower;
        temp_lower = temp_rem;
        if (step_cntr > 2) {
            /* pi = [pi-2 - (pi-1 * qi-2)] (mod n) */
            ret_code += pk_1.big_int_multiply(prev_quo[0], pk_temp_1);
            ret_code += pk_0.big_int_signed_sub(pk_temp_1, pk_temp_2);
            pk_0 = pk_1;
            ret_code += pk_temp_2.big_int_modulus(modulus, pk_1);
        }
    } while(temp_rem.big_int_is_zero() == false);

    if (prev_rem.big_int_compare(bi_1) != 0) {
        /* Throw if the GCD of the args is not 1, which means, the
        numbers are not co - primes. */ 
        throw std::range_error(""The number is not invertible for the given modulus"");
    }

    /* Final iteration. */
    ret_code += pk_1.big_int_multiply(prev_quo[1], pk_temp_1);
    ret_code += pk_0.big_int_signed_sub(pk_temp_1, pk_temp_2);
    ret_code += pk_temp_2.big_int_modulus(modulus, pk_1);

change_inverse_based_on_arg_sign:
    /* Use the argument signs to change final pk_1. 
    Sign convention is similar to big_int_modulus() */
    if (ip_modulus.big_int_is_negetive() == false) {
        if ((*this).big_int_is_negetive() == true) {
            ret_code += modulus.big_int_unsigned_sub(pk_1, inverse);
        } else {
            inverse = pk_1;
        }
    } else {
        if (((*this).big_int_is_negetive() == false) && ((*this).big_int_is_zero() == false)) {
            ret_code += modulus.big_int_unsigned_sub(pk_1, inverse);   
        } else {
            inverse = pk_1;
        }
        ret_code += inverse.big_int_set_negetive(true);
    }

    return ret_code;

}


int bi::big_int::big_int_get_random_unsigned(int bits) {

    std::random_device dev;
    std::mt19937 rng(dev());
    std::uniform_int_distribution<BI_BASE_TYPE> rand_dist(0, 0xFFFFFFFF);

    return _big_int_generate_random_unsigned(bits, rng, rand_dist);

}

int bi::big_int::big_int_fast_divide_by_power_of_two(int power, big_int &remainder, big_int &quotient) const {

    /* Take the remainder. */
    int ret_val = 0;
    int word_cnt = power / BI_BASE_TYPE_TOTAL_BITS;
    int bit_cont = power % BI_BASE_TYPE_TOTAL_BITS;

    if (word_cnt >= _top) {
        ret_val += quotient.big_int_set_zero();
        remainder = *this;
        return ret_val;
    } 

    remainder.big_int_clear();

    int i = 0; 
    for (; i < word_cnt; ++i) {
        remainder._data[(remainder._top)++] = (*this)._data[i];
    }

    BI_DOUBLE_BASE_TYPE temp_dbase = (*this)._data[i];
    temp_dbase <<= (BI_BASE_TYPE_TOTAL_BITS - bit_cont);
    temp_dbase &= BI_BASE_TYPE_MAX;
    remainder._data[(remainder._top)++] = static_cast<BI_BASE_TYPE>(temp_dbase >> (BI_BASE_TYPE_TOTAL_BITS - bit_cont)); 
    remainder.big_int_set_negetive((*this)._neg);

    quotient = (*this);
    return quotient.big_int_right_shift(power); 

}

int bi::big_int::big_int_fast_multiply_by_power_of_two(int power, big_int &result) const {

    result = (*this);
    return result.big_int_left_shift(power);

}

int bi::big_int::big_int_get_num_of_bits() const {

    return 4 * big_int_get_num_of_hex_chars();

}

int bi::big_int::big_int_get_random_unsigned_between(const big_int &low, const big_int &high) {


    std::random_device rd;                              // only used once to initialise (seed) engine
    std::mt19937 rng(rd());                             // random-number engine used (Mersenne-Twister in this case)
    std::uniform_int_distribution<BI_BASE_TYPE> uni_dist(0, 0xFFFFFFFF);
    std::uniform_int_distribution<int> get_rand_bits(low.big_int_get_num_of_bits(), high.big_int_get_num_of_bits());    

    return _big_int_get_random_unsigned_between(rng, uni_dist, get_rand_bits, low, high);

}

int bi::big_int::big_int_get_random_unsigned_prime_rabin_miller(int bits, int reqd_rabin_miller_iterations) {

    int ret_val = 0;

    std::random_device rd;
    std::mt19937 rng(rd()); 
    std::uniform_int_distribution<BI_BASE_TYPE> uni_dist(0, 0xFFFFFFFF);
    
    while (ret_val == 0) {

        big_int candidate_num, bi_1, bi_2, candidate_num_sub_1, candidate_num_sub_1_copy, prev_candidate_num_sub_1;
        ret_val += candidate_num._big_int_generate_random_probable_prime(bits, rng, uni_dist, -1); /* -1 -> Use all prime numbers in the array. */ 
        ret_val += bi_1.big_int_from_base_type(1, false);
        ret_val += bi_2.big_int_from_base_type(2, false);
        std::uniform_int_distribution<int> uni_dist_rand_bits(bi_2.big_int_get_num_of_bits(), candidate_num.big_int_get_num_of_bits());

        int max_div_by_two = 0;
        BI_BASE_TYPE div_2_rem;
        ret_val += candidate_num.big_int_unsigned_sub(bi_1, candidate_num_sub_1);
        candidate_num_sub_1_copy = candidate_num_sub_1;

        prev_candidate_num_sub_1 = candidate_num_sub_1;
        ret_val += candidate_num_sub_1._big_int_fast_divide_by_two(div_2_rem);
        while (div_2_rem == 0) {
            ++max_div_by_two;
            prev_candidate_num_sub_1 = candidate_num_sub_1;
            ret_val += candidate_num_sub_1._big_int_fast_divide_by_two(div_2_rem);
        }

        //std::cout<<""d: ""<<max_div_by_two<<"" num: ""<<prev_candidate_num_sub_1.big_int_to_string(bi_base::BI_HEX)<<""\n"";
        //break;
        int i = 0;
        for (; i < reqd_rabin_miller_iterations; ++i) {
            big_int this_round_random_bi;
            ret_val += this_round_random_bi._big_int_get_random_unsigned_between(rng, uni_dist, uni_dist_rand_bits, bi_2, candidate_num);

            big_int mod_exp_res;
            bool composite_test = true;
            ret_val += this_round_random_bi.big_int_fast_modular_exponentiation(prev_candidate_num_sub_1, candidate_num, mod_exp_res);
            if (mod_exp_res.big_int_unsigned_compare(bi_1) == 0) {
                composite_test = false;
            }
            else {
                for (int j = 0; j < max_div_by_two; ++j) {
                    big_int temp_exp, fast_mul_bi_1(bi_1);
                    ret_val += fast_mul_bi_1.big_int_left_shift(j);
                    ret_val += prev_candidate_num_sub_1.big_int_multiply(fast_mul_bi_1, temp_exp);
                    ret_val += this_round_random_bi.big_int_fast_modular_exponentiation(temp_exp, candidate_num, mod_exp_res);
                    if (mod_exp_res.big_int_unsigned_compare(candidate_num_sub_1_copy) == 0) {
                        composite_test = false;
                        break;
                    }
                }
            }

            if (composite_test == true) {
                break;
            }
        }

        if (i == reqd_rabin_miller_iterations) {
            (*this) = candidate_num;
            break;
        }

    }

    return ret_val;
    
}

/*
reqd_rabin_miller_iterations -> use 20?
no_of_threads -> number of threads used to run the function, -ve or 0 thread count causes maximum (std::thread::hardware_concurrency();)
                 threads to be used, more than std::thread::hardware_concurrency(); will cause max threads to be std::thread::hardware_concurrency();

*/
int bi::big_int::big_int_get_random_unsigned_prime_rabin_miller_threaded(int bits, int reqd_rabin_miller_iterations, int no_of_threads) {

    std::mutex          final_op_mutex;
    big_int             final_op;
    std::atomic<bool>   stop_thread{false};

    auto  [MASK]  = [&] {

        int ret_val = 0;

        std::random_device rd;
        std::mt19937 rng(rd()); 
        std::uniform_int_distribution<BI_BASE_TYPE> uni_dist(0, 0xFFFFFFFF);
        
        while (ret_val == 0 && !stop_thread) {

            big_int candidate_num, bi_1, bi_2, candidate_num_sub_1, candidate_num_sub_1_copy, prev_candidate_num_sub_1;
            ret_val += candidate_num._big_int_generate_random_probable_prime(bits, rng, uni_dist, -1); /* -1 -> Use all prime numbers in the array. */ 
            ret_val += bi_1.big_int_from_base_type(1, false);
            ret_val += bi_2.big_int_from_base_type(2, false);
            std::uniform_int_distribution<int> uni_dist_rand_bits(bi_2.big_int_get_num_of_bits(), candidate_num.big_int_get_num_of_bits());

            int max_div_by_two = 0;
            BI_BASE_TYPE div_2_rem;
            ret_val += candidate_num.big_int_unsigned_sub(bi_1, candidate_num_sub_1);
            candidate_num_sub_1_copy = candidate_num_sub_1;

            prev_candidate_num_sub_1 = candidate_num_sub_1;
            ret_val += candidate_num_sub_1._big_int_fast_divide_by_two(div_2_rem);
            while (div_2_rem == 0 && !stop_thread) {
                ++max_div_by_two;
                prev_candidate_num_sub_1 = candidate_num_sub_1;
                ret_val += candidate_num_sub_1._big_int_fast_divide_by_two(div_2_rem);
            }

            //std::cout<<""d: ""<<max_div_by_two<<"" num: ""<<prev_candidate_num_sub_1.big_int_to_string(bi_base::BI_HEX)<<""\n"";
            //break;
            int i = 0;
            for (; i < reqd_rabin_miller_iterations && !stop_thread; ++i) {
                big_int this_round_random_bi;
                ret_val += this_round_random_bi._big_int_get_random_unsigned_between(rng, uni_dist, uni_dist_rand_bits, bi_2, candidate_num);

                big_int mod_exp_res;
                bool composite_test = true;
                ret_val += this_round_random_bi.big_int_fast_modular_exponentiation(prev_candidate_num_sub_1, candidate_num, mod_exp_res);
                if (mod_exp_res.big_int_unsigned_compare(bi_1) == 0) {
                    composite_test = false;
                }
                else {
                    for (int j = 0; j < max_div_by_two && !stop_thread; ++j) {
                        big_int temp_exp, fast_mul_bi_1(bi_1);
                        ret_val += fast_mul_bi_1.big_int_left_shift(j);
                        ret_val += prev_candidate_num_sub_1.big_int_multiply(fast_mul_bi_1, temp_exp);
                        ret_val += this_round_random_bi.big_int_fast_modular_exponentiation(temp_exp, candidate_num, mod_exp_res);
                        if (mod_exp_res.big_int_unsigned_compare(candidate_num_sub_1_copy) == 0) {
                            composite_test = false;
                            break;
                        }
                    }
                }

                if (composite_test == true) {
                    break;
                }
            }

            if (i == reqd_rabin_miller_iterations) {
                std::unique_lock<std::mutex> op_value_lock(final_op_mutex);
                final_op = candidate_num;
                op_value_lock.unlock();
                stop_thread = true;
                break;
            }

        }

        return ret_val;

    };

    size_t total_thread_count;
    if (no_of_threads <= 0) {
        total_thread_count = std::thread::hardware_concurrency();
    } else if (static_cast<size_t>(no_of_threads) > std::thread::hardware_concurrency()) {
        total_thread_count = std::thread::hardware_concurrency();
    } else {
        total_thread_count = static_cast<size_t>(no_of_threads);
    }

    std::vector<std::thread> rabin_miller_threads;
    rabin_miller_threads.reserve(total_thread_count);
    for(auto i = 0u; i < total_thread_count; ++i) {
        rabin_miller_threads.emplace_back( [MASK] );
    }

    for(auto &t : rabin_miller_threads) {
        t.join();
    }

    (*this) = final_op;
    return 0;

}",rabin_miller_lambda
825,"/*
    Dijkstra's shortest path algo
*/

#include<iostream>
#include<list>
#include<set>
#include<vector>
#include<climits>
using namespace std;

class Node{
    public:
        int dist;
        int cnode;
};

class Comp{
    public:
        bool operator()(const Node &a , const Node &b){
            if(a.dist <= b.dist){
                return true;
            }
            return false;
        }
};

class Graph{
    private:
        int V,E;
        list < pair<int, int > > *adj;

    public:

        int djk_algo(int sr , int ds){

            vector<int> dist(V,INT_MAX);
            set< pair < int , int > > st;

            dist[sr] = 0;
            st.insert({0 , sr});

            while(!st.empty()){

                set< pair<int , int > > ::iterator it = st.begin();
                int cdist = it->first;
                int cnode = it->second;
                st.erase(it);

                list< pair < int , int > > ::iterator it1 = adj[cnode].begin();

                while(it1 != adj[cnode].end()){

                    if(it1->second + cdist < dist[it1->first]){
                        if(st.find({dist[it1->first] , it1->first}) != st.end()){
                            st.erase({dist[it1->first] , it1->first});
                        }
                        dist[it1->first] = it1->second + cdist;
                        st.insert({dist[it1->first] , it1->first});
                    }

                    it1++;

                }

            }

            for(int i = 0 ; i < V ; ++i){
                cout<<i<<"" ""<<dist[i]<<endl;
            }

            return dist[ds];

        }


        int djk2(int sr , int ds){

            vector<int> dist(V,INT_MAX);
            dist[sr] = 0;

            set<pair<int , int > > st;
            

            for(int i = 0 ; i < V ; ++i){
                pair<int , int > p1{dist[i] , i};
                st.insert(p1);
            }

            while(!st.empty()){

                auto it = st.begin();

                int cdist = dist[it->second];
                int cnode = it->second;
                st.erase(it);

                for(auto it1 = adj[cnode].begin() ; it1 != adj[cnode].end() ; ++it1){
                    
                    pair<int ,int > p1{dist[it1->first] , it1->first};


                    auto f = st.find(p1);
                    if(f != st.end()){

                        if(cdist + it1->second < dist[it1->first]){

                            st.erase(f);
                            p1.first = cdist + it1->second;
                            dist[it1->first] = p1.first;
                            st.insert(p1);
                        }

                    }

                }

            }


            for(int i = 0 ; i < V ; ++i){
                cout<<i<<"" ""<<dist[i]<<endl;
            }

            return dist[ds];
        }

        void add_edge(int u , int v , int wt){
            adj[u].push_back({v , wt});
            adj[v].push_back({u , wt});
        }

        Graph(int v , int e):V(v),E(e){
            adj = new list<pair<int,int> > [V];
        }

        ~Graph(){
            delete []adj;
        }

};

int main(){

    int v,e;
    cout<<""Enter no of vertices and edges: "";
    cin>>v>>e;
    Graph g1(v,e);

    cout<<""Enter vertice 1 , vertice 2 , weight of edge: "";
    for(int i = 0 ; i < e ; ++i){
        int v1,v2,wt;
        cin>>v1>>v2>>wt;
        g1.add_edge(v1,v2,wt);
    }

    int sr, [MASK] ;
    cout<<""Enter source and dest: "";
    cin>>sr>> [MASK] ;
    
    int distance = g1.djk_algo(sr, [MASK] );
    cout<<""Minimum distance between ""<<sr<<"" and ""<< [MASK] <<"" is ""<<distance<<endl;

    distance = g1.djk2(sr, [MASK] );
    cout<<""Minimum distance between ""<<sr<<"" and ""<< [MASK] <<"" is ""<<distance;


    return 0;
}",dst
826,"#include ""define.h""
#include ""utils.h""

const int N_TURNS = 5;
const int N_VERTICES_PER_TURN = 360;
const int N_VERTICES_MAX = N_VERTICES_PER_TURN * N_TURNS;

Window window{};

void SetupWindow() {
    window.title = ""Spiral Artifacts"";
    SetupDefaultWindow();
    window.display_mode = GLUT_SINGLE | GLUT_RGB;
}

vertex2 vertices[N_VERTICES_MAX];
unsigned int n_vertices = 0;

void Init() {
    glClearColor(0.0, 0.0, 0.0, 0.0);

    // OpenGL legacy stuff, avoid use in real applications
    glColor3f(1.0, 0.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-500.0, 500.0, -500.0, 500.0);
    glMatrixMode(GL_MODELVIEW);

    double center_x = 0.0, center_y = 0.0, radius = 0.0;

    double  [MASK]  = 0.2;  // radius step size
    double alpha = 2.0 * PI / (double)N_VERTICES_PER_TURN;  // auto angle step size
    double theta = 103.0 * PI / 180.0;                      // fixed angle step size

    while ((n_vertices < N_VERTICES_MAX) && (radius < 400.0)) {
        // draw spiral with auto angle step size
        //vertices[n_vertices][0] = center_x + radius * cos(alpha * n_vertices);
        //vertices[n_vertices][1] = center_y + radius * sin(alpha * n_vertices);

        // draw nice patterns and artifacts with fixed angle step size
        vertices[n_vertices][0] = center_x + radius * cos(theta * n_vertices);
        vertices[n_vertices][1] = center_y + radius * sin(theta * n_vertices);

        n_vertices++;
        radius +=  [MASK] ;
    }
}

void Display() {
    glClear(GL_COLOR_BUFFER_BIT);

    // OpenGL legacy stuff, avoid use in real applications
    glColor3f(1.0, 0.0, 0.0);
    glPointSize(1);
    glLineWidth(0.7f);

    glBegin(GL_LINE_STRIP);
    for (int k = 0; k < n_vertices; k++) {
        glVertex2fv(vertices[k]);
    }
    glEnd();

    glFlush();
}

void Reshape(int width, int height) {
    DefaultReshapeCallback(width, height);
}

void Keyboard(unsigned char key, int x, int y) {
    DefaultKeyboardCallback(key, x, y);
}

void Mouse(int button, int state, int x, int y) {}
void Idle(void) {}
void Motion(int x, int y) {}
void PassiveMotion(int x, int y) {}
void Cleanup() {}",delta
827,"#include ""process.hpp""
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/select.h>
#include <fcntl.h>

Process::~Process() {
  if (infd >= 0) close(infd);
  if (outfd >= 0) close(outfd);
  if (errfd >= 0) close(errfd);
  if (inpipe >= 0) close(inpipe);
  if (outpipe >= 0) close(outpipe);
  if (errpipe >= 0) close(errpipe);
}

Process&& Process::in(std::filesystem::path path) && {
  infd = open(path.c_str(), O_RDONLY);
  if (infd == -1) throw std::runtime_error(""Could not open input stream for reading"");
  return std::move(*this);
}

Process&& Process::in(std::span<const uint8_t>& data) && {
  int fd_pair[2];
  pipe2(fd_pair, O_NONBLOCK);
  infd = fd_pair[0];
  inpipe = fd_pair[1];
  indata = data;
  return std::move(*this);
}

Process&& Process::out(std::filesystem::path path) && {
  outfd = open(path.c_str(), O_WRONLY | O_TRUNC | O_CREAT, 0644);
  if (outfd == -1) throw std::runtime_error(""Could not open output stream for writing"");
  return std::move(*this);
}

Process&& Process::out(std::vector<uint8_t>& data) && {
  int fd_pair[2];
  pipe2(fd_pair, O_NONBLOCK);
  outpipe = fd_pair[0];
  outfd = fd_pair[1];
  outdata = &data;
  return std::move(*this);
}

Process&& Process::err(std::filesystem::path path) && {
  errfd = open(path.c_str(), O_WRONLY | O_TRUNC | O_CREAT, 0644);
  if (errfd == -1) throw std::runtime_error(""Could not open error stream for writing"");
  return std::move(*this);
}

Process&& Process::err(std::vector<uint8_t>& data) && {
  int fd_pair[2];
  pipe2(fd_pair, O_NONBLOCK);
  errpipe = fd_pair[0];
  errfd = fd_pair[1];
  errdata = &data;
  return std::move(*this);
}

Process&& Process::setwd(std::filesystem::path newPath) && {
  wd = newPath;
  return std::move(*this);
}

int RunController(pid_t pid, Process& process) {
  int status;
  int id = waitpid(pid, &status, WNOHANG);
  while (id == 0) {
    fd_set r, w;

    FD_ZERO(&w);
    FD_ZERO(&r);
    Process* current = &process;
    while (current) {
      if (current->inpipe != -1) FD_SET(current->inpipe, &w);
      if (current->outpipe != -1) FD_SET(current->outpipe, &r);
      if (current->errpipe != -1) FD_SET(current->errpipe, &r);
      current = current->prev;
    }
    timeval timeout = {1, 0};
    int rv = select(1023, &r, &w, nullptr, &timeout);
    (void)rv;
    
    current = &process;
    while (current) {
      if (FD_ISSET(current->inpipe, &w)) {
        int written = write(current->inpipe, current->indata.data() + current->inoffset, current->indata.size() - current->inoffset);
        if (written >= 0) {
          current->inoffset += written;
          if (current->inoffset == current->indata.size()) {
            close(current->inpipe);
          }
        } else {
          // Some error
        }
      }
      if (FD_ISSET(current->outpipe, &r)) {
        int bytesread = 0;
        do {
          current->outdata->resize(current->outoffset + 16384);
          bytesread = read(current->outpipe, current->outdata->data() + current->outoffset, 16384);
          if (bytesread >= 0) {
            current->outoffset += bytesread;
          } else {
            // Some error
          }
        } while (bytesread == 16384);
      }
      if (FD_ISSET(current->errpipe, &r)) {
        int bytesread = 0;
        do {
          current->errdata->resize(current->erroffset + 16384);
          bytesread = read(current->errpipe, current->errdata->data() + current->erroffset, 16384);
          if (bytesread >= 0) {
            current->erroffset += bytesread;
          } else {
            // Some error
          }
        } while (bytesread == 16384);
      }
      current = current->prev;
    }
    id = waitpid(pid, &status, WNOHANG);
  }
  return status;
}

[[noreturn]] void RunProcess(Process& process) {
  if (process.prev) {
    int p[2];
    pipe(p);
    pid_t newPid = fork();
    if (newPid == 0) {
      close(p[0]);
      process.prev->outfd = p[1];
      RunProcess(*process.prev);
    } else {
      process.infd = p[0];
      close(p[1]);
    }
  }

  close(0);
  if (process.infd != -1) {
    dup2(process.infd, 0);
  }

  close(1);
  if (process.outfd != -1) {
    dup2(process.outfd, 1);
  }

  close(2);
  if (process.errfd != -1) {
    dup2(process.errfd, 2);
  }
  for (size_t n = 3; n < 1024; n++) {
    close(n);
  }

  std::filesystem::current_path(process.wd);

  std::vector<const char*>  [MASK] ;
   [MASK] .push_back(process.command.c_str());
  for (auto& arg : process.commandLine)  [MASK] .push_back(arg.c_str());
   [MASK] .push_back(nullptr);

  execvp( [MASK] [0], (char* const*) [MASK] .data());
  std::abort();
}

int Run(Process&& process) {
  pid_t newPid = fork();
  if (newPid) {
    return RunController(newPid, process);
  } else {
    RunProcess(process);
  }
}


",argv
828,"
#include <vector>
#include <string>
#include ""Utils.cpp""
#include ""Types.cpp""
#include ""Diagnostics.cpp""

using namespace std;

namespace L10ns {

static Flag help_flag = Flag(FlagKind::Help, ""--help"", ""-h"", ""Print help description."", /*has_value*/ false);
static Flag language_flag = Flag(FlagKind::Language, ""--language"", ""-l"", ""Specify language."", false);
static Flag root_dir = Flag(FlagKind::RootDir, ""--rootDir"", ""-rd"", ""Specify current root dir(mainly for testing purposes)."", /*has_value*/ true);

static vector<Flag> default_flags = {
    help_flag,
    root_dir,
    Flag(FlagKind::Version, ""--version"", """", ""Print current version."", /*has_value*/ false),
};

static vector<Flag> help_flags = {
    help_flag,
};

static vector<Flag> set_flags = {
    Flag(FlagKind::Key, ""--key"", ""-k"", ""Specify localization key."", /*has_value*/ true),
    Flag(FlagKind::Value, ""--value"", ""-v"", ""Specify localization value."", /*has_value*/ true),
    Flag(FlagKind::Value, ""--log-index"", ""-li"", ""Specify log index."", /*has_value*/ true),
    Flag(FlagKind::Value, ""--search-index"", ""-se"", ""Specify latest search index."", /*has_value*/ true),
    language_flag,
};

static vector<Flag> log_flags = {
    language_flag,
};

static vector<Flag> extension_run_tests_flags = {
    Flag(FlagKind::Grep, ""--grep"", ""-g"", ""Grep test."", /*has_value*/ true),
};

static const char * init_info =
    ""Initialize a L10ns project. This command creates a 'l10ns.json' ""
    ""file, with sane default options applied.\n\n""
    ""Usage: l10ns init"";

static const char * sync_info =
    ""Synchronize your keys between source code and storage.\n\n""
    ""Usage: l10ns sync"";

static const char * log_info =
    ""Show latest localizations.\n\n""
    ""Usage: l10ns log [options]\n""
    ""       l10ns log\n""
    ""       l10ns log --language en-US"";

static const char * set_info =
    ""Set new localizations.\n\n""
    ""Usage: l10ns set --key <key> --value <value> [options]\n""
    ""       l10ns set --key LOGIN_TEXT --value \""Please login.\""\n""
    ""       l10ns set --log-index 1 --value \""Please login.\""\n""
    ""       l10ns set --search-index 1 --value \""Please login.\"""";

static const char * extension_run_tests_info =
    ""Run extension tests.\n\n""
    ""Usage: l10ns extension-run-tests\n""
    ""Usage: l10ns extension-run-tests --grep \""some-test-case\""\n"";

static const char * extension_accept_baselines_info =
    ""Accept baselines.\n\n""
    ""Usage: l10ns extension-accept-baselines\n"";

static vector<Command> commands = {
    Command(CommandKind::Init, ""init"", ""Initialize project."", init_info, NULL),
    Command(CommandKind::Sync, ""sync"", ""Synchronize localization keys."", sync_info, NULL),
    Command(CommandKind::Log, ""log"", ""Show latest added localizations."", log_info, &log_flags),
    Command(CommandKind::Set, ""set"", ""Set localization."", set_info, &set_flags),
    Command(CommandKind::Extension_RunTests, ""extension-run-tests"", ""Run extension tests."", extension_run_tests_info, &extension_run_tests_flags),
    Command(CommandKind::Extension_AcceptBaselines, ""extension-accept-baselines"", ""Accept baselines."", extension_accept_baselines_info, NULL),
};

vector<Flag>* get_command_flags(CommandKind kind) {
    switch (kind) {
        case CommandKind::Init:
            return &help_flags;
        case CommandKind::Sync:
            return &help_flags;
        case CommandKind::Log:
            return &log_flags;
        case CommandKind::Set:
            return &set_flags;
        case CommandKind::Extension_RunTests:
            return &extension_run_tests_flags;
        case CommandKind::Extension_AcceptBaselines:
            return NULL;
        default:
            throw invalid_argument(""Could not get action flag."");
    }
}

void set_command_flag(Session* session, const Flag* flag, char* value = NULL) {
    switch (flag->kind) {
        case FlagKind::Help:
            session->is_requesting_help = true;
            return;
        case FlagKind::Version:
            session->is_requesting_version = true;
            return;
        case FlagKind::RootDir:
            string* root_dir;
            if (value[0] == '/') {
                root_dir = new string(value);
            }
            else {
                root_dir = new string(join_paths((*session->root_dir).c_str(), value) + ""/"");
            }
            delete session->root_dir;
            session->root_dir = root_dir;
            return;
        default:
            throw invalid_argument(""Unknown command flag."");
    }
}

Session* parse_command_args(int argc, char* argv[]) {
    Session* session = new Session();
    session->root_dir = new string(get_cwd());

    // Flag to optimize parsing.
    bool has_command = false;

    // The option flag that is pending for a value.
    const Flag* flag_which_awaits_value = NULL;
    vector<Flag> all_flags(default_flags);

    auto add_command = [&](const char* command) -> void {
        if (has_command) {
            add_diagnostic(session, D::You_cannot_run_several_commands);
            return;
        }

        for (auto const& c : commands) {
            if (strcmp(c.name->c_str(), command) == 0) {
                session->command = c.kind;
                if (c.flags != NULL) {
                    all_flags.insert(all_flags.end(), c.flags->begin(), c.flags->end());
                }
                has_command = true;
                return;
            }
        }

        // We can only reach here if the command is unknown.
        add_diagnostic(session, D::Unknown_command, command);
    };

    auto add_command_flag = [&](const char* arg) -> bool {
        for (auto const& flag : all_flags) {
            if (strcmp(flag.name->c_str(), arg) == 0 || (flag.alias->length() != 0 && strcmp(flag.name->c_str(), arg) == 0)) {
                if (flag.has_value) {
                    flag_which_awaits_value = &flag;
                }
                else {
                    set_command_flag(session, &flag);
                }
                return true;
            }
        }

        return false;
    };

    auto for_each_arg = [&](std::function<void (char*)> callback) -> void {
        for (int arg_index = 1; arg_index < argc; arg_index++) {
            callback(argv[arg_index]);
        }
    };

    for_each_arg([&](char* arg) -> void {
        if (flag_which_awaits_value == NULL) {
            if (arg[0] != '-') {
                add_command(arg);
            }
            else if (!add_command_flag(arg)) {
                add_diagnostic(session, D::Unknown_command_flag, arg);
            }
        }
        else {
            set_command_flag(session, flag_which_awaits_value, arg);
            flag_which_awaits_value = NULL;
        }
    });

    bool  [MASK]  = file_exists(*session->root_dir + ""l10ns.json"");
    bool is_requesting_help_or_version = (session->is_requesting_help || session->is_requesting_version);
    bool is_running_extension_command = (session->command == CommandKind::Extension_RunTests || session->command == CommandKind::Extension_AcceptBaselines);
    if (! [MASK]  && !is_requesting_help_or_version && !is_running_extension_command) {
        add_diagnostic(session, D::You_are_not_inside_a_L10ns_project);
    }

    return session;
}
} // L10ns
",has_project_file
829,"#include ""icvar.h""
#include <map>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <iostream>
#include <iomanip>

static_assert(sizeof(ConCommandHandle) == 8, ""unexpected size for ConCommandHandle"");
static_assert(sizeof(ConVarHandle) == 8, ""unexpected size for ConVarHandle"");

static ConCommandRefAbstract cvar_unhide_ref;
static void cvar_unhide_callback(const CCommand& args);
ConCommand cvar_unhide(&cvar_unhide_ref, ""zcvar_unhide"", cvar_unhide_callback, ""Removes flags from commands"");
//ConCommand cvarlist_md(&cvarlist_md_ref, ""cvarlist_md"", cvarlist_md_callback, ""List all convars/concmds in Markdown format. Format: [hidden]"");
static void cvar_unhide_callback(const CCommand& args)
{
	uint64 flagsToRemove = (FCVAR_HIDDEN | FCVAR_DEVELOPMENTONLY | FCVAR_MISSING3);
	//uint64 flagsToRemove = (FCVAR_NONE | FCVAR_LINKED_CONCOMMAND | FCVAR_DEVELOPMENTONLY | FCVAR_GAMEDLL | FCVAR_CLIENTDLL | FCVAR_HIDDEN | FCVAR_PROTECTED | FCVAR_SPONLY | FCVAR_ARCHIVE | FCVAR_NOTIFY | FCVAR_USERINFO | FCVAR_MISSING0 | FCVAR_UNLOGGED | FCVAR_MISSING1 | FCVAR_REPLICATED | FCVAR_CHEAT | FCVAR_PER_USER | FCVAR_DEMO | FCVAR_DONTRECORD | FCVAR_MISSING2 | FCVAR_RELEASE | FCVAR_MENUBAR_ITEM | FCVAR_MISSING3 | FCVAR_NOT_CONNECTED | FCVAR_VCONSOLE_FUZZY_MATCHING | FCVAR_SERVER_CAN_EXECUTE | FCVAR_CLIENT_CAN_EXECUTE | FCVAR_SERVER_CANNOT_QUERY | FCVAR_VCONSOLE_SET_FOCUS | FCVAR_CLIENTCMD_CAN_EXECUTE | FCVAR_EXECUTE_PER_TICK);

	int unhiddenConCmds = 0;
	int unhiddenConVars = 0;

	ConCommandHandle cmdHandle{};
	auto invalidConcmd = g_pCVar->GetCommand(cmdHandle);
	int cmdIdx = 0;
	for (;;)
	{
		cmdHandle.Set(cmdIdx++);
		auto concmd = g_pCVar->GetCommand(cmdHandle);
		if (concmd == invalidConcmd)
			break;

		if (concmd->GetFlags() & flagsToRemove)
		{
			Msg(""- %s\n"", concmd->GetName());
			concmd->RemoveFlags(flagsToRemove);
			unhiddenConCmds++;
		}
	}
	ConColorMsg(Color(255, 0, 255, 255), ""Removed hidden flags from %d concommands\n"", unhiddenConCmds);

	ConVarHandle cvarHandle{};
	auto invalidCvar = g_pCVar->GetConVar(cvarHandle);
	int cvarIdx = 0;
	for (;;)
	{
		cvarHandle.Set(cvarIdx++);
		auto convar = g_pCVar->GetConVar(cvarHandle);
		if (convar == invalidCvar)
			break;

		if (convar->flags & flagsToRemove)
		{
			Msg(""- %s\n"", convar->m_pszName);
			convar->flags &= ~flagsToRemove;
			unhiddenConVars++;
		}
	}
	ConColorMsg(Color(255, 0, 255, 255), ""Removed hidden flags from %d cvars\n"", unhiddenConVars);
}

void string_replace(std::string& data, std::string toSearch, std::string replaceStr)
{
	// Get the first occurrence
	size_t pos = data.find(toSearch);

	// Repeat till end is reached
	while (pos != std::string::npos)
	{
		// Replace this occurrence of Sub String
		data.replace(pos, toSearch.size(), replaceStr);
		// Get the next occurrence from the current position
		pos = data.find(toSearch, pos + replaceStr.size());
	}
}
struct ConEntry_t
{
	ConEntry_t() : pszName(nullptr), defaultValue(nullptr), conVarType(EConVarType_Invalid), flags(0), pszDescription(nullptr)
	{
	}

	ConEntry_t(const char* pszName, const CVValue_t* defaultValue, EConVarType conVarType, int flags, const char* pszDescription) : pszName(pszName), defaultValue(defaultValue), conVarType(conVarType), flags(flags), pszDescription(pszDescription)
	{
	}

	const char* pszName;
	const CVValue_t* defaultValue;
	EConVarType conVarType;
	int flags;
	const char* pszDescription;
};

std::string FormatCVValue(const CVValue_t& value, EConVarType type) {
	std::ostringstream oss;

	switch (type) {
	case EConVarType_Bool:
		return value.m_bValue ? ""true"" : ""false"";
	case EConVarType_Int16:
		oss << value.m_i16Value;
		break;
	case EConVarType_UInt16:
		oss << value.m_u16Value;
		break;
	case EConVarType_Int32:
		oss << value.m_i32Value;
		break;
	case EConVarType_UInt32:
		oss << value.m_u32Value;
		break;
	case EConVarType_Int64:
		oss << value.m_i64Value;
		break;
	case EConVarType_UInt64:
		oss << value.m_u64Value;
		break;
	case EConVarType_Float32:
		oss << value.m_flValue;
		break;
	case EConVarType_Float64:
		oss << value.m_dbValue;
		break;
	case EConVarType_String:
		oss << (value.m_szValue != nullptr ? value.m_szValue : """");
		break;
	case EConVarType_Color:
		oss << value.m_clrValue.r() << "" "" << value.m_clrValue.g() << "" ""
			<< value.m_clrValue.b() << "" "" << value.m_clrValue.a();
		break;
	case EConVarType_Vector2:
		oss << value.m_vec2Value.x << "" "" << value.m_vec2Value.y;
		break;
	case EConVarType_Vector3:
		oss << value.m_vec3Value.x << "" "" << value.m_vec3Value.y << "" "" << value.m_vec3Value.z;
		break;
	case EConVarType_Vector4:
		oss << value.m_vec4Value.x << "" "" << value.m_vec4Value.y << "" "" << value.m_vec4Value.z
			<< "" "" << value.m_vec4Value.w;
		break;
	case EConVarType_Qangle:
		oss << value.m_angValue.x << "" "" << value.m_angValue.y << "" "" << value.m_angValue.z;
		break;
	default:
		return ""(unknown type)"";
	}

	return oss.str();
}

static std::string ConvarFlagsString(int unFlags)
{
	std::vector<std::string> flags;

	if (unFlags & FCVAR_NONE)
	flags.push_back(""FCVAR_NONE"");
	if (unFlags & FCVAR_LINKED_CONCOMMAND)
	flags.push_back(""FCVAR_LINKED_CONCOMMAND"");
	if (unFlags & FCVAR_DEVELOPMENTONLY)
	flags.push_back(""FCVAR_DEVELOPMENTONLY"");
	if (unFlags & FCVAR_GAMEDLL)
	flags.push_back(""FCVAR_GAMEDLL"");
	if (unFlags & FCVAR_CLIENTDLL)
	flags.push_back(""FCVAR_CLIENTDLL"");
	if (unFlags & FCVAR_HIDDEN)
	flags.push_back(""FCVAR_HIDDEN"");
	if (unFlags & FCVAR_PROTECTED)
	flags.push_back(""FCVAR_PROTECTED"");
	if (unFlags & FCVAR_SPONLY)
	flags.push_back(""FCVAR_SPONLY"");
	if (unFlags & FCVAR_ARCHIVE)
	flags.push_back(""FCVAR_ARCHIVE"");
	if (unFlags & FCVAR_NOTIFY)
	flags.push_back(""FCVAR_NOTIFY"");
	if (unFlags & FCVAR_USERINFO)
	flags.push_back(""FCVAR_USERINFO"");
	if (unFlags & FCVAR_MISSING0)
	flags.push_back(""FCVAR_MISSING0"");
	if (unFlags & FCVAR_UNLOGGED)
	flags.push_back(""FCVAR_UNLOGGED"");
	if (unFlags & FCVAR_MISSING1)
	flags.push_back(""FCVAR_MISSING1"");
	if (unFlags & FCVAR_REPLICATED)
	flags.push_back(""FCVAR_REPLICATED"");
	if (unFlags & FCVAR_CHEAT)
	flags.push_back(""FCVAR_CHEAT"");
	if (unFlags & FCVAR_PER_USER)
	flags.push_back(""FCVAR_PER_USER"");
	if (unFlags & FCVAR_DEMO)
	flags.push_back(""FCVAR_DEMO"");
	if (unFlags & FCVAR_DONTRECORD)
	flags.push_back(""FCVAR_DONTRECORD"");
	if (unFlags & FCVAR_MISSING2)
	flags.push_back(""FCVAR_MISSING2"");
	if (unFlags & FCVAR_RELEASE)
	flags.push_back(""FCVAR_RELEASE"");
	if (unFlags & FCVAR_MENUBAR_ITEM)
	flags.push_back(""FCVAR_MENUBAR_ITEM"");
	if (unFlags & FCVAR_MISSING3)
	flags.push_back(""FCVAR_MISSING3"");
	if (unFlags & FCVAR_NOT_CONNECTED)
	flags.push_back(""FCVAR_NOT_CONNECTED"");
	if (unFlags & FCVAR_VCONSOLE_FUZZY_MATCHING)
	flags.push_back(""FCVAR_VCONSOLE_FUZZY_MATCHING"");
	if (unFlags & FCVAR_SERVER_CAN_EXECUTE)
	flags.push_back(""FCVAR_SERVER_CAN_EXECUTE"");
	if (unFlags & FCVAR_CLIENT_CAN_EXECUTE)
	flags.push_back(""FCVAR_CLIENT_CAN_EXECUTE"");
	if (unFlags & FCVAR_SERVER_CANNOT_QUERY)
	flags.push_back(""FCVAR_SERVER_CANNOT_QUERY"");
	if (unFlags & FCVAR_VCONSOLE_SET_FOCUS)
	flags.push_back(""FCVAR_VCONSOLE_SET_FOCUS"");
	if (unFlags & FCVAR_CLIENTCMD_CAN_EXECUTE)
	flags.push_back(""FCVAR_CLIENTCMD_CAN_EXECUTE"");
	if (unFlags & FCVAR_EXECUTE_PER_TICK)
	flags.push_back(""FCVAR_EXECUTE_PER_TICK"");

	std::string result;
	bool bFirst = true;

	for (auto flag : flags)
	{
		if (bFirst)
			bFirst = false;
		else
			//result += "", "";
			result += ""<br>"";

		result += flag;
	}

	return result;
}

static std::string ConvarFlagsStringShort(int unFlags)
{
	std::vector<std::string> flags;

	if (unFlags & FCVAR_NONE)
		flags.push_back("""");
	if (unFlags & FCVAR_LINKED_CONCOMMAND)
		flags.push_back(""linked_concommand"");
	if (unFlags & FCVAR_DEVELOPMENTONLY)
		flags.push_back(""devonly"");
	if (unFlags & FCVAR_GAMEDLL)
		flags.push_back(""sv"");
	if (unFlags & FCVAR_CLIENTDLL)
		flags.push_back(""cl"");
	if (unFlags & FCVAR_HIDDEN)
		flags.push_back(""hidden"");
	if (unFlags & FCVAR_PROTECTED)
		flags.push_back(""prot"");
	if (unFlags & FCVAR_SPONLY)
		flags.push_back(""sp"");
	if (unFlags & FCVAR_ARCHIVE)
		flags.push_back(""a"");
	if (unFlags & FCVAR_NOTIFY)
		flags.push_back(""nf"");
	if (unFlags & FCVAR_USERINFO)
		flags.push_back(""user"");
	if (unFlags & FCVAR_MISSING0)
		flags.push_back(""missing0"");
	if (unFlags & FCVAR_UNLOGGED)
		flags.push_back(""unlogged"");
	if (unFlags & FCVAR_MISSING1)
		flags.push_back(""missing1"");
	if (unFlags & FCVAR_REPLICATED)
		flags.push_back(""rep"");
	if (unFlags & FCVAR_CHEAT)
		flags.push_back(""cheat"");
	if (unFlags & FCVAR_PER_USER)
		flags.push_back(""per_user"");
	if (unFlags & FCVAR_DEMO)
		flags.push_back(""demo"");
	if (unFlags & FCVAR_DONTRECORD)
		flags.push_back(""norecord"");
	if (unFlags & FCVAR_MISSING2)
		flags.push_back(""missing2"");
	if (unFlags & FCVAR_RELEASE)
		flags.push_back(""release"");
	if (unFlags & FCVAR_MENUBAR_ITEM)
		flags.push_back(""menubar_item"");
	if (unFlags & FCVAR_MISSING3)
		flags.push_back(""missing3"");
	if (unFlags & FCVAR_NOT_CONNECTED)
		flags.push_back(""notconnected"");
	if (unFlags & FCVAR_VCONSOLE_FUZZY_MATCHING)
		flags.push_back(""vconsole_fuzzy_matching"");
	if (unFlags & FCVAR_SERVER_CAN_EXECUTE)
		flags.push_back(""server_can_execute"");
	if (unFlags & FCVAR_CLIENT_CAN_EXECUTE)
		flags.push_back(""client_can_execute"");
	if (unFlags & FCVAR_SERVER_CANNOT_QUERY)
		flags.push_back(""server_cannot_query"");
	if (unFlags & FCVAR_VCONSOLE_SET_FOCUS)
		flags.push_back(""vconsole_set_focus"");
	if (unFlags & FCVAR_CLIENTCMD_CAN_EXECUTE)
		flags.push_back(""clientcmd_can_execute"");
	if (unFlags & FCVAR_EXECUTE_PER_TICK)
		flags.push_back(""per_tick"");

	std::string result;
	bool bFirst = true;

	for (auto flag : flags)
	{
		if (bFirst)
			bFirst = false;
		else
			result += "", "";
			//result += ""<br>"";

		result += flag;
	}

	return result;
}


std::string MarkdownEscape(const std::string& str)
{
	std::string escaped{ str };

	string_replace(escaped, ""\\"", ""\\\\"");
	string_replace(escaped, ""<"", ""&lt;"");
	string_replace(escaped, "">"", ""&gt;"");
	string_replace(escaped, ""["", ""\\["");
	string_replace(escaped, ""]"", ""\\]"");
	string_replace(escaped, ""\n"", ""<br>"");
	string_replace(escaped, ""|"", ""\\|"");

	return escaped;
}

std::string NewLineEscape(const std::string& str) {
	
	std::string escaped{ str };

	string_replace(escaped, ""\n"", ""\\n"");

	return escaped;
}

static ConCommandRefAbstract cvarlist_md_ref;
static void cvarlist_md_callback(const CCommand& args);
ConCommand cvarlist_md(&cvarlist_md_ref, ""zcvarlist_md"", cvarlist_md_callback, ""List all convars/concmds in Markdown format. Format: [hidden]"");
static void cvarlist_md_callback(const CCommand& args)
{
	std::map<std::string, ConEntry_t> allEntries;

	ConCommandHandle cmdHandle{};
	auto invalidConcmd = g_pCVar->GetCommand(cmdHandle);
	int cmdIdx = 0;
	for (;;)
	{
		cmdHandle.Set(cmdIdx++);
		auto concmd = g_pCVar->GetCommand(cmdHandle);
		if (concmd == invalidConcmd)
			break;

		allEntries[concmd->GetName()] = ConEntry_t(concmd->GetName(), nullptr, EConVarType_Invalid, concmd->GetFlags(), concmd->GetHelpText());
	}

	ConVarHandle cvarHandle{};
	auto invalidCvar = g_pCVar->GetConVar(cvarHandle);
	int cvarIdx = 0;
	for (;;)
	{
		cvarHandle.Set(cvarIdx++);
		auto convar = g_pCVar->GetConVar(cvarHandle);
		if (convar == invalidCvar)
			break;

		allEntries[convar->m_pszName] = ConEntry_t(convar->m_pszName, convar->m_cvvDefaultValue, convar->m_eVarType, convar->flags, convar->m_pszHelpString);
	}

	auto bShowHidden = !V_stricmp(args.Arg(1), ""hidden"");

	CUtlString outputPath(Plat_GetGameDirectory());
	outputPath.Append(""\\csgo\\cvarlist.md"");
	outputPath.FixSlashes();

	CUtlString  [MASK] (Plat_GetGameDirectory());
	 [MASK] .Append(""\\csgo\\cvarlist.log"");
	 [MASK] .FixSlashes();

	std::ofstream file(outputPath.GetForModify());
	std::ofstream file2( [MASK] .GetForModify());

	file << ""Name | Flags | Description\n"";
	file << ""---- | ----- | -----------\n"";

	file2 << ""cvar list\n"";
	file2 << ""--------------\n"";

	int nWritten = 0;
	for (auto& pair : allEntries)
	{
		const std::string& name = pair.first;
		auto cmd = pair.second;

		//if (!bShowHidden && (cmd.flags & (FCVAR_DEVELOPMENTONLY | FCVAR_HIDDEN | FCVAR_MISSING3)))
		//	continue;
		//if (!bShowHidden && (cmd.flags & (FCVAR_NONE | FCVAR_LINKED_CONCOMMAND | FCVAR_DEVELOPMENTONLY | FCVAR_GAMEDLL | FCVAR_CLIENTDLL | FCVAR_HIDDEN | FCVAR_PROTECTED | FCVAR_SPONLY | FCVAR_ARCHIVE | FCVAR_NOTIFY | FCVAR_USERINFO | FCVAR_MISSING0 | FCVAR_UNLOGGED | FCVAR_MISSING1 | FCVAR_REPLICATED | FCVAR_CHEAT | FCVAR_PER_USER | FCVAR_DEMO | FCVAR_DONTRECORD | FCVAR_MISSING2 | FCVAR_RELEASE | FCVAR_MENUBAR_ITEM | FCVAR_MISSING3 | FCVAR_NOT_CONNECTED | FCVAR_VCONSOLE_FUZZY_MATCHING | FCVAR_SERVER_CAN_EXECUTE | FCVAR_CLIENT_CAN_EXECUTE | FCVAR_SERVER_CANNOT_QUERY | FCVAR_VCONSOLE_SET_FOCUS | FCVAR_CLIENTCMD_CAN_EXECUTE | FCVAR_EXECUTE_PER_TICK)))
		//	continue;

		auto flagsStr = ConvarFlagsString(cmd.flags);
		auto flagsStr_ = ConvarFlagsStringShort(cmd.flags);
		auto helpText = MarkdownEscape(cmd.pszDescription);
		auto helpText_ = NewLineEscape(cmd.pszDescription);

		int name_setw = (82 - name.length() >= 0) ? (82 - name.length()) : 0;
		int flags_setw = (38 - flagsStr_.length() >= 0) ? (38 - flagsStr_.length()) : 0;

		//file << name << "" | "" << flagsStr << "" | "";
		
		if (cmd.defaultValue != nullptr) // there is a def value
		{
			auto defaultValue = MarkdownEscape(FormatCVValue(*cmd.defaultValue, cmd.conVarType));
			auto defaultValue_ = NewLineEscape(FormatCVValue(*cmd.defaultValue, cmd.conVarType));
			//file << ""Default: "" << defaultValue << ""<br>"";
			//file << name << "" "" << defaultValue << "" | "" << flagsStr << "" | "" << helpText << ""\n"";
			int def_setw = (20 - defaultValue.length() >= 0) ? (20 - defaultValue.length()) : 0;

			file << name << "" | "" << flagsStr << "" | "" << ""**Default:** "" << defaultValue << ""<br>"" << helpText << ""\n"";
			file2 << name << std::setw(name_setw) << "": "" << defaultValue_ << std::setw(def_setw) << "" : "" << flagsStr_ << std::setw(flags_setw) << "" : "" << helpText_ << ""\n"";
		}
		else { // no def value
			file << name <<  "" | "" << flagsStr << "" | "" << helpText << ""\n"";
			//file2 << name << ""\t\t\t\t\t\t\t: "" << ""cmd"" << ""\t\t: "" << flagsStr_ << ""\t\t\t\t\t: "" << helpText_ << ""\n"";
			int name_setw2 = name_setw + 3;
			file2 << name << std::setw(name_setw2) << "": cmd"" << std::setw(17) << "" : "" << flagsStr_ << std::setw(flags_setw) << "" : "" << helpText_ << ""\n"";
		}
		
		//file << helpText << ""\n"";
		nWritten++;
	}

	file.close();
	file2.close();

	Msg(""Wrote %d entries to %s\n"", nWritten, outputPath.GetForModify());
}
",outputPath2
830,"#include <stdio.h>
#include ""Socket.h""
#include ""Common.h""
#include ""LogWrite.h""



#define PROGRAM ""TEST""
#define node ""test""
#define topic ""odom""


int main(int argc,char*argv[])
{   
    auto set = [](int sfd)->void{
        srand(time(0));
        int  [MASK]  = rand() % 10;
        Fson request;
        request.setStr(""method"", ""SET"");
        request.setStr(""node"", node);
        request.setStr(""topic"", topic);
        request.setInt(""value"",  [MASK] );
        sendRequest(sfd, request);
        request.print();

        Fson response;
        recvRequest(sfd, response);
        response.getInt(""code""); 
        response.print(); 
    };

    auto get = [](int sfd)->void{
        Fson request;
        request.setStr(""method"", ""GET"");
        request.setStr(""node"", node);
        request.setStr(""topic"", topic);
        request.print();
        sendRequest(sfd, request);

        Fson response;
        recvRequest(sfd, response);
        int code = response.getInt(""code""); 
        response.print(); 
        if(code != 200)
            throw ""-1"";
        int ret = response.getInt(""value"");
        logWrite(""ret = %d\n"", ret);
    };


    nbSendToServer(""127.0.0.1"", ""12345"", set);
    nbSendToServer(""127.0.0.1"", ""12345"", get);

    return 0;
}


















",randnum
831,"/*
 * Copyright (c) 2023-2025, NVIDIA CORPORATION.  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.
 *
 * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */

#ifdef AFTERMATH_AVAILABLE
#include <chrono>
#include <filesystem>
#include <nvutils/file_operations.hpp>
#include <nvutils/logger.hpp>
#endif

#include ""aftermath.hpp""


AftermathCrashTracker& AftermathCrashTracker::getInstance()
{
  static AftermathCrashTracker instance;
  return instance;
}

void AftermathCrashTracker::initialize()
{
  initAftermath();
}

#ifdef AFTERMATH_AVAILABLE
GpuCrashTracker& AftermathCrashTracker::getGpuCrashTracker()
{
  return *m_tracker;
}
#endif

void AftermathCrashTracker::addShaderBinary(const std::span<const uint32_t>& data)
{
#ifdef AFTERMATH_AVAILABLE
  m_tracker->addShaderBinary(data);
#endif
}

void AftermathCrashTracker::errorCallback(VkResult result)
{
#ifdef AFTERMATH_AVAILABLE
  if(result == VK_ERROR_DEVICE_LOST)
  {
    // Device lost notification is asynchronous to the NVIDIA display
    // driver's GPU crash handling. Give the Nsight Aftermath GPU crash dump
    // thread some time to do its work before terminating the process.
    auto tdr_termination_timeout = std::chrono::seconds(5);
    auto t_start                 = std::chrono::steady_clock::now();
    auto t_elapsed               = std::chrono::milliseconds::zero();

    GFSDK_Aftermath_CrashDump_Status status = GFSDK_Aftermath_CrashDump_Status_Unknown;
    AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_GetCrashDumpStatus(&status));

    while(status != GFSDK_Aftermath_CrashDump_Status_CollectingDataFailed
          && status != GFSDK_Aftermath_CrashDump_Status_Finished && t_elapsed < tdr_termination_timeout)
    {
      // Sleep 50ms and poll the status again until timeout or Aftermath finished processing the crash dump.
      std::this_thread::sleep_for(std::chrono::milliseconds(50));
      AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_GetCrashDumpStatus(&status));

      auto t_end = std::chrono::steady_clock::now();
      t_elapsed  = std::chrono::duration_cast<std::chrono::milliseconds>(t_end - t_start);
    }

    if(status != GFSDK_Aftermath_CrashDump_Status_Finished)
    {
      std::stringstream err_msg;
      LOGE(""Unexpected crash dump status: %d"", status);
      // ERR_EXIT(err_msg.str().c_str(), ""Aftermath Error"");
    }

    LOGOK(""\n\nAftermath file dumped under:\n\t%s"", nvutils::utf8FromPath(std::filesystem::current_path()).c_str());

    // Terminate on failure
    //#ifdef _WIN32
    //      err_msg << ""\n\n\nSave path to clipboard?"";
    //      int ret = MessageBox(nullptr, err_msg.str().c_str(), ""Nsight Aftermath"", MB_YESNO | MB_ICONEXCLAMATION);
    //      if(ret == IDYES)
    //      {
    //        // ImGui::SetClipboardText(nvutils::utf8FromPath(std::filesystem::current_path()).c_str());
    //      }
    //#else
    //      printf(""%s\n"", err_msg.str().c_str());
    //#endif

    exit(1);
  }
#endif
}

AftermathCrashTracker::AftermathCrashTracker()
{
#ifdef AFTERMATH_AVAILABLE
  m_tracker = std::make_unique<::GpuCrashTracker>(m_marker);
#endif  // #ifdef AFTERMATH_AVAILABLE
}

void AftermathCrashTracker::initAftermath()
{
#ifdef AFTERMATH_AVAILABLE
  m_tracker->Initialize();
#endif
}


//--------------------------------------------------------------------------------------------------
// Usage example
//--------------------------------------------------------------------------------------------------
#ifdef AFTERMATH_DEMO_ONLY
static void usage_AftermathCrashTracker()
{

  // Initialize the AftermathCrashTracker
  auto& aftermath = AftermathCrashTracker::getInstance();
  aftermath.initialize();
  aftermath.addExtensions(vkSetup.deviceExtensions);  // Add the Aftermath extension to the device extensions

  // The callback function is called when a validation error is triggered.
  // This will wait to give time to dump the GPU crash.
  //---
  nvvk::CheckError::getInstance().setCallbackFunction([&](VkResult result) { aftermath.errorCallback(result); });


  // Adding the shader binaries to the Aftermath
  //---
#if defined(AFTERMATH_AVAILABLE)
  // This aftermath callback is used to report the shader hash (Spirv) to the Aftermath library.
  m_slangCompiler.setCompileCallback([&](const std::filesystem::path& sourceFile, const uint32_t* spirvCode, size_t  [MASK] ) {
    std::span<const uint32_t> data(spirvCode,  [MASK]  / sizeof(uint32_t));
    AftermathCrashTracker::getInstance().addShaderBinary(data);
  });
#endif
}
#endif",spirvSize
832,"#include<bits/stdc++.h>
#include<sstream>
using namespace std;
int main()
{
    int k = 0, index = 0;
    string  [MASK] ;
    getline(std::cin, [MASK] );
    int length =  [MASK] .length();
    for(int i=0; i<length; i++) {
        if( [MASK] [i] == '%') {
            k = 1;
            index = i;
            break;
        }
        else if( [MASK] [i] == '/') {
            k = 2;
            index = i;
            break;
        }
    }
    string number_1 =  [MASK] .substr(0, index-1);
    string number_2 =  [MASK] .substr(index+2, length-1);

    int int_1 = 0, int_2 = 0;

    stringstream stream_1;
    stream_1 << number_1;
    stream_1 >> int_1;

    stringstream stream_2;
    stream_2 << number_2;
    stream_2 >> int_2;

    int result = 0;

    if(k == 1) {
        result = int_1 % int_2;
    }
    else if(k == 2) {
        result = int_1 / int_2;
    }

    printf(""%d\n"", result);

    return 0;
}
",expression
833,"#include ""anApplication.h""
#include ""Device/anShaders.h""
#include ""Device/anTexture.h""
#include ""anFont.h""
#include ""State/anStateManager.h""

anApplication::anApplication(const anApplicationCreationDescription& desc)
	: mFramesPerSecond(0)
{
	memset(&mApplicationDesc, 0, sizeof(anApplicationCreationDescription));
	mApplicationDesc.Title = desc.Title;
	mApplicationDesc.Width = desc.Width;
	mApplicationDesc.Height = desc.Height;
}

anApplication::~anApplication()
{
}

void anApplication::Start()
{
	mStateManager = new anStateManager(this);

	auto  [MASK]  = [this](const anEvent& event) { AOnEvent(event); };

	mWindow = anCreateWindow(mApplicationDesc.Title, mApplicationDesc.Width, mApplicationDesc.Height,  [MASK] , mApplicationDesc.WindowResizable);
	anTexture::Initialize();
	anFont::Initialize();
	anInitializeShaders();
	mStateManager->Initialize();
	Initialize();

	int fps = 0;
	float elapsedTime = 0.0f;
	while (mWindow->IsRunning())
	{
		const float dt = mTimer.Tick();
		elapsedTime += dt;
		if (elapsedTime >= 1.0f)
		{
			mFramesPerSecond = fps;
			elapsedTime = 0.0f;
			fps = 0;
		}
		++fps;

		mStateManager->Update(dt);
		Update(dt);
		mWindow->Present();
	}
}

void anApplication::AOnEvent(const anEvent& event)
{
	mStateManager->OnEvent(event);
	OnEvent(event);
}

void anApplication::Render(anRenderer& renderer)
{
	mStateManager->Render(renderer);
}

void anApplication::SetCurrentState(anState* state)
{
	mStateManager->SetCurrentState(state);
}

anState* anApplication::GetCurrentState()
{
	return mStateManager->GetCurrentState();
}

anWindow* anApplication::GetWindow()
{
	return mWindow;
}
",onEvent
834,"#include ""island.h""

Island::Island() {
    label = 0;
    team = Team::NONE;
    attackPower = 5;
}

Island::Island(int labelId)
{
    label = labelId;
    team = Team::NONE;
    attackPower = 5;
}

Island::Island(int labelId, Resource *res)
{
    label = labelId;
    resource = res;
    team = Team::NONE;
    attackPower = 5;
}

void Island::addResource(int value)
{
    resource->addNbResources(value);
}

void Island::addPixels(QList<Pixel> px)
{
    for(Pixel p : px)
        addPixel(p);
}

void Island::addPixel(Pixel px)
{
    islandPixel.append(px);
}

void Island::removeAllPixels()
{
    islandPixel.clear();
}

void Island::setResource(Resource *res) {
    resource = res;
}

Team Island::getController() { return team; }

Resource* Island::getResource() { return resource; }

int Island::getNbPixels()
{
    return islandPixel.size();
}

void Island::setQLabel(QOpenGLWidget *mainWidget)
{
    qlabel = new QLabel(mainWidget);
    qlabelR = new QLabel(mainWidget);
}

void Island::setLabel(int id) { label = id; }
void Island::setController(Team  [MASK] ) {
    team =  [MASK] ;
    QString path = "":/img/teams/"";
    switch(team){
        case Team::BLACK:
            path += ""black/"";
            break;
        case Team::BLUE:
            path += ""blue/"";
            break;
        case Team::GREEN:
            path += ""green/"";
            break;
        case Team::RED:
            path += ""red/"";
            break;
        case Team::WHITE:
            path += ""white/"";
            break;
        case Team::YELLOW:
            path += ""yellow/"";
            break;
        default:
            break;
    }
    path += ""flag.png"";

    setPath(path);
    std::cout << path.toStdString() << std::endl;


}
void Island::harvest(int _value)
{
    resource->addNbResources(-_value);
}

void Island::setPath(QString path){
    this->img = QPixmap(path);
}

void Island::drawFlag()
{
    float x = (float)islandPixel[0].py / (float)1280 * (float)900;
    float y = (float)islandPixel[0].px / (float)1280 * (float)900;
    qlabel->setGeometry(x, y, img.width(), img.height());
    qlabel->setPixmap(img);
}


int Island::getAttackPower() const
{
    return attackPower;
}

Pixel Island::getPosition() {
    return islandPixel[0];
}

void Island::drawResource()
{
    float x = ((float)islandPixel[0].py-100) / (float)1280 * (float)900;
    float y = ((float)islandPixel[0].px) / (float)1280 * (float)900;
    qlabelR->setGeometry(x, y, img.width(), img.height());
    qlabelR->setPixmap(resource->getPixmap());
}
",playerTeam
835,"/*     ----------------------------------------------------------------
*
*                               sgp4.cpp
*
*    this file contains the sgp4 procedures for analytical propagation
*    of a satellite. the code was originally released in the 1980 and 1986
*    spacetrack papers. a detailed discussion of the theory and history
*    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
*    and kelso.
*
*                            companion code for
*               fundamentals of astrodynamics and applications
*                                    2013
*                              by <NAME>
*
*     (w) 719-573-2600, email <EMAIL>, <EMAIL>
*
*/

#include ""SGP4.hpp""

/* ----------- local functions - only ever used internally by sgp4 ---------- */
static void dpper
(
double e3, double ee2, double peo, double pgho, double pho,
double pinco, double plo, double se2, double se3, double sgh2,
double sgh3, double sgh4, double sh2, double sh3, double si2,
double si3, double sl2, double sl3, double sl4, double t,
double xgh2, double xgh3, double xgh4, double xh2, double xh3,
double xi2, double xi3, double xl2, double xl3, double xl4,
double zmol, double zmos, double inclo,
char init,
double& ep, double& inclp, double& nodep, double& argpp, double& mp,
char opsmode
);

static void dscom
(
double epoch, double ep, double argpp, double tc, double inclp,
double nodep, double np,
double& snodm, double& cnodm, double& sinim, double& cosim, double& sinomm,
double& cosomm, double& day, double& e3, double& ee2, double& em,
double& emsq, double& gam, double& peo, double& pgho, double& pho,
double& pinco, double& plo, double& rtemsq, double& se2, double& se3,
double& sgh2, double& sgh3, double& sgh4, double& sh2, double& sh3,
double& si2, double& si3, double& sl2, double& sl3, double& sl4,
double& s1, double& s2, double& s3, double& s4, double& s5,
double& s6, double& s7, double& ss1, double& ss2, double& ss3,
double& ss4, double& ss5, double& ss6, double& ss7, double& sz1,
double& sz2, double& sz3, double& sz11, double& sz12, double& sz13,
double& sz21, double& sz22, double& sz23, double& sz31, double& sz32,
double& sz33, double& xgh2, double& xgh3, double& xgh4, double& xh2,
double& xh3, double& xi2, double& xi3, double& xl2, double& xl3,
double& xl4, double& nm, double& z1, double& z2, double& z3,
double& z11, double& z12, double& z13, double& z21, double& z22,
double& z23, double& z31, double& z32, double& z33, double& zmol,
double& zmos
);

static void dsinit
(
//sgp4fix no longer needed pass in xke
//gravconsttype whichconst,
double xke,
double cosim, double emsq, double argpo, double s1, double s2,
double s3, double s4, double s5, double sinim, double ss1,
double ss2, double ss3, double ss4, double ss5, double sz1,
double sz3, double sz11, double sz13, double sz21, double sz23,
double sz31, double sz33, double t, double tc, double gsto,
double mo, double mdot, double no, double nodeo, double nodedot,
double xpidot, double z1, double z3, double z11, double z13,
double z21, double z23, double z31, double z33, double ecco,
double eccsq, double& em, double& argpm, double& inclm, double& mm,
double& nm, double& nodem,
int& irez,
double& atime, double& d2201, double& d2211, double& d3210, double& d3222,
double& d4410, double& d4422, double& d5220, double& d5232, double& d5421,
double& d5433, double& dedt, double& didt, double& dmdt, double& dndt,
double& dnodt, double& domdt, double& del1, double& del2, double& del3,
double& xfact, double& xlamo, double& xli, double& xni
);

static void dspace
(
int irez,
double d2201, double d2211, double d3210, double d3222, double d4410,
double d4422, double d5220, double d5232, double d5421, double d5433,
double dedt, double del1, double del2, double del3, double didt,
double dmdt, double dnodt, double domdt, double argpo, double argpdot,
double t, double tc, double gsto, double xfact, double xlamo,
double no,
double& atime, double& em, double& argpm, double& inclm, double& xli,
double& mm, double& xni, double& nodem, double& dndt, double& nm
);

static void initl
(
// not needeed. included in satrec if needed later 
// int satn,      
// sgp4fix assin xke and j2
// gravconsttype whichconst,
double xke, double j2,
double ecco, double epoch, double inclo, double& no,
char& method,
double& ainv, double& ao, double& con41, double& con42, double& cosio,
double& cosio2, double& eccsq, double& omeosq, double& posq,
double& rp, double& rteosq, double& sinio, double& gsto, char opsmode
);


/* -----------------------------------------------------------------------------
*
*                           procedure dpper
*
*  this procedure provides deep space long period periodic contributions
*    to the mean elements.  by design, these periodics are zero at epoch.
*    this used to be dscom which included initialization, but it's really a
*    recurring function.
*
*  author        : <NAME>                  719-573-2600   28 jun 2005
*
*  inputs        :
*    e3          -
*    ee2         -
*    peo         -
*    pgho        -
*    pho         -
*    pinco       -
*    plo         -
*    se2 , se3 , sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4 -
*    t           -
*    xh2, xh3, xi2, xi3, xl2, xl3, xl4 -
*    zmol        -
*    zmos        -
*    ep          - eccentricity                           0.0 - 1.0
*    inclo       - inclination - needed for lyddane modification
*    nodep       - right ascension of ascending node
*    argpp       - argument of perigee
*    mp          - mean anomaly
*
*  outputs       :
*    ep          - eccentricity                           0.0 - 1.0
*    inclp       - inclination
*    nodep        - right ascension of ascending node
*    argpp       - argument of perigee
*    mp          - mean anomaly
*
*  locals        :
*    alfdp       -
*    betdp       -
*    cosip  , sinip  , cosop  , sinop  ,
*    dalf        -
*    dbet        -
*    dls         -
*    f2, f3      -
*    pe          -
*    pgh         -
*    ph          -
*    pinc        -
*    pl          -
*    sel   , ses   , sghl  , sghs  , shl   , shs   , sil   , sinzf , sis   ,
*    sll   , sls
*    xls         -
*    xnoh        -
*    zf          -
*    zm          -
*
*  coupling      :
*    none.
*
*  references    :
*    hoots, roehrich, norad spacetrack report #3 1980
*    hoots, norad spacetrack report #6 1986
*    hoots, schumacher and glover 2004
*    vallado, crawford, hujsak, kelso  2006
----------------------------------------------------------------------------*/

static void dpper
(
double e3, double ee2, double peo, double pgho, double pho,
double pinco, double plo, double se2, double se3, double sgh2,
double sgh3, double sgh4, double sh2, double sh3, double si2,
double si3, double sl2, double sl3, double sl4, double t,
double xgh2, double xgh3, double xgh4, double xh2, double xh3,
double xi2, double xi3, double xl2, double xl3, double xl4,
double zmol, double zmos, double inclo,
char init,
double& ep, double& inclp, double& nodep, double& argpp, double& mp,
char opsmode
)
{
/* --------------------- local variables ------------------------ */
const double twopi = 2.0 * pi;
    double alfdp = 0, betdp = 0, cosip = 0, cosop = 0, dalf = 0, dbet = 0, dls,
    f2 = 0, f3 = 0, pe = 0, pgh = 0, ph = 0, pinc = 0, pl,
    sel = 0, ses = 0, sghl = 0, sghs = 0, shll = 0, shs = 0, sil,
    sinip = 0, sinop = 0, sinzf = 0, sis = 0, sll = 0, sls = 0, xls,
    xnoh = 0, zf = 0, zm = 0, zel = 0, zes = 0, znl = 0, zns = 0;
/* ---------------------- constants ----------------------------- */
zns = 1.19459e-5;
zes = 0.01675;
znl = 1.5835218e-4;
zel = 0.05490;

/* --------------- calculate time varying periodics ----------- */
zm = zmos + zns * t;
// be sure that the initial call has time set to zero
if (init == 'y')
zm = zmos;
zf = zm + 2.0 * zes * sin(zm);
sinzf = sin(zf);
f2 = 0.5 * sinzf * sinzf - 0.25;
f3 = -0.5 * sinzf * cos(zf);
ses = se2* f2 + se3 * f3;
sis = si2 * f2 + si3 * f3;
sls = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
sghs = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
shs = sh2 * f2 + sh3 * f3;
zm = zmol + znl * t;
if (init == 'y')
zm = zmol;
zf = zm + 2.0 * zel * sin(zm);
sinzf = sin(zf);
f2 = 0.5 * sinzf * sinzf - 0.25;
f3 = -0.5 * sinzf * cos(zf);
sel = ee2 * f2 + e3 * f3;
sil = xi2 * f2 + xi3 * f3;
sll = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
sghl = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
shll = xh2 * f2 + xh3 * f3;
pe = ses + sel;
pinc = sis + sil;
pl = sls + sll;
pgh = sghs + sghl;
ph = shs + shll;

if (init == 'n')
{
pe = pe - peo;
pinc = pinc - pinco;
pl = pl - plo;
pgh = pgh - pgho;
ph = ph - pho;
inclp = inclp + pinc;
ep = ep + pe;
sinip = sin(inclp);
cosip = cos(inclp);

/* ----------------- apply periodics directly ------------ */
//  sgp4fix for lyddane choice
//  strn3 used original inclination - this is technically feasible
//  gsfc used perturbed inclination - also technically feasible
//  probably best to readjust the 0.2 limit value and limit discontinuity
//  0.2 rad = 11.45916 deg
//  use next line for original strn3 approach and original inclination
//  if (inclo >= 0.2)
//  use next line for gsfc version and perturbed inclination
if (inclp >= 0.2)
{
ph = ph / sinip;
pgh = pgh - cosip * ph;
argpp = argpp + pgh;
nodep = nodep + ph;
mp = mp + pl;
}
else
{
/* ---- apply periodics with lyddane modification ---- */
sinop = sin(nodep);
cosop = cos(nodep);
alfdp = sinip * sinop;
betdp = sinip * cosop;
dalf = ph * cosop + pinc * cosip * sinop;
dbet = -ph * sinop + pinc * cosip * cosop;
alfdp = alfdp + dalf;
betdp = betdp + dbet;
nodep = fmod(nodep, twopi);
//  sgp4fix for afspc written intrinsic functions
// nodep used without a trigonometric function ahead
if ((nodep < 0.0) && (opsmode == 'a'))
nodep = nodep + twopi;
xls = mp + argpp + cosip * nodep;
dls = pl + pgh - pinc * nodep * sinip;
xls = xls + dls;
xnoh = nodep;
nodep = atan2(alfdp, betdp);
//  sgp4fix for afspc written intrinsic functions
// nodep used without a trigonometric function ahead
if ((nodep < 0.0) && (opsmode == 'a'))
nodep = nodep + twopi;
                if (fabs(xnoh - nodep) > pi) {
                    if (nodep < xnoh) {
                        nodep = nodep + twopi;
                    } else {
                        nodep = nodep - twopi;
                        mp = mp + pl;
                        argpp = xls - mp - cosip * nodep;
                    }
                }
}
}   // if init == 'n'

//#include ""debug1.cpp""
}  // dpper

/*-----------------------------------------------------------------------------
*
*                           procedure dscom
*
*  this procedure provides deep space common items used by both the secular
*    and periodics subroutines.  input is provided as shown. this routine
*    used to be called dpper, but the functions inside weren't well organized.
*
*  author        : <NAME>                  719-573-2600   28 jun 2005
*
*  inputs        :
*    epoch       -
*    ep          - eccentricity
*    argpp       - argument of perigee
*    tc          -
*    inclp       - inclination
*    nodep       - right ascension of ascending node
*    np          - mean motion
*
*  outputs       :
*    sinim  , cosim  , sinomm , cosomm , snodm  , cnodm
*    day         -
*    e3          -
*    ee2         -
*    em          - eccentricity
*    emsq        - eccentricity squared
*    gam         -
*    peo         -
*    pgho        -
*    pho         -
*    pinco       -
*    plo         -
*    rtemsq      -
*    se2, se3         -
*    sgh2, sgh3, sgh4        -
*    sh2, sh3, si2, si3, sl2, sl3, sl4         -
*    s1, s2, s3, s4, s5, s6, s7          -
*    ss1, ss2, ss3, ss4, ss5, ss6, ss7, sz1, sz2, sz3         -
*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
*    xgh2, xgh3, xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4         -
*    nm          - mean motion
*    z1, z2, z3, z11, z12, z13, z21, z22, z23, z31, z32, z33         -
*    zmol        -
*    zmos        -
*
*  locals        :
*    a1, a2, a3, a4, a5, a6, a7, a8, a9, a10         -
*    betasq      -
*    cc          -
*    ctem, stem        -
*    x1, x2, x3, x4, x5, x6, x7, x8          -
*    xnodce      -
*    xnoi        -
*    zcosg  , zsing  , zcosgl , zsingl , zcosh  , zsinh  , zcoshl , zsinhl ,
*    zcosi  , zsini  , zcosil , zsinil ,
*    zx          -
*    zy          -
*
*  coupling      :
*    none.
*
*  references    :
*    hoots, roehrich, norad spacetrack report #3 1980
*    hoots, norad spacetrack report #6 1986
*    hoots, schumacher and glover 2004
*    vallado, crawford, hujsak, kelso  2006
----------------------------------------------------------------------------*/

static void dscom
(
double epoch, double ep, double argpp, double tc, double inclp,
double nodep, double np,
double& snodm, double& cnodm, double& sinim, double& cosim, double& sinomm,
double& cosomm, double& day, double& e3, double& ee2, double& em,
double& emsq, double& gam, double& peo, double& pgho, double& pho,
double& pinco, double& plo, double& rtemsq, double& se2, double& se3,
double& sgh2, double& sgh3, double& sgh4, double& sh2, double& sh3,
double& si2, double& si3, double& sl2, double& sl3, double& sl4,
double& s1, double& s2, double& s3, double& s4, double& s5,
double& s6, double& s7, double& ss1, double& ss2, double& ss3,
double& ss4, double& ss5, double& ss6, double& ss7, double& sz1,
double& sz2, double& sz3, double& sz11, double& sz12, double& sz13,
double& sz21, double& sz22, double& sz23, double& sz31, double& sz32,
double& sz33, double& xgh2, double& xgh3, double& xgh4, double& xh2,
double& xh3, double& xi2, double& xi3, double& xl2, double& xl3,
double& xl4, double& nm, double& z1, double& z2, double& z3,
double& z11, double& z12, double& z13, double& z21, double& z22,
double& z23, double& z31, double& z32, double& z33, double& zmol,
double& zmos
)
{
/* -------------------------- constants ------------------------- */
const double zes = 0.01675;
const double zel = 0.05490;
const double c1ss = 2.9864797e-6;
const double c1l = 4.7968065e-7;
const double zsinis = 0.39785416;
const double zcosis = 0.91744867;
const double zcosgs = 0.1945905;
const double zsings = -0.98088458;
const double twopi = 2.0 * pi;

/* --------------------- local variables ------------------------ */
int lsflg;
    double a1 = 0, a2 = 0, a3 = 0, a4 = 0, a5 = 0, a6 = 0, a7,
    a8 = 0, a9 = 0, a10 = 0, betasq = 0, cc = 0, ctem = 0, stem,
    x1 = 0, x2 = 0, x3 = 0, x4 = 0, x5 = 0, x6 = 0, x7,
    x8 = 0, xnodce = 0, xnoi = 0, zcosg = 0, zcosgl = 0, zcosh = 0, zcoshl,
    zcosi = 0, zcosil = 0, zsing = 0, zsingl = 0, zsinh = 0, zsinhl = 0, zsini,
    zsinil = 0, zx = 0, zy = 0;

nm = np;
em = ep;
snodm = sin(nodep);
cnodm = cos(nodep);
sinomm = sin(argpp);
cosomm = cos(argpp);
sinim = sin(inclp);
cosim = cos(inclp);
emsq = em * em;
betasq = 1.0 - emsq;
rtemsq = sqrt(betasq);

/* ----------------- initialize lunar solar terms --------------- */
peo = 0.0;
pinco = 0.0;
plo = 0.0;
pgho = 0.0;
pho = 0.0;
day = epoch + 18261.5 + tc / 1440.0;
xnodce = fmod(4.5236020 - 9.2422029e-4 * day, twopi);
stem = sin(xnodce);
ctem = cos(xnodce);
zcosil = 0.91375164 - 0.03568096 * ctem;
zsinil = sqrt(1.0 - zcosil * zcosil);
zsinhl = 0.089683511 * stem / zsinil;
zcoshl = sqrt(1.0 - zsinhl * zsinhl);
gam = 5.8351514 + 0.0019443680 * day;
zx = 0.39785416 * stem / zsinil;
zy = zcoshl * ctem + 0.91744867 * zsinhl * stem;
zx = atan2(zx, zy);
zx = gam + zx - xnodce;
zcosgl = cos(zx);
zsingl = sin(zx);

/* ------------------------- do solar terms --------------------- */
zcosg = zcosgs;
zsing = zsings;
zcosi = zcosis;
zsini = zsinis;
zcosh = cnodm;
zsinh = snodm;
cc = c1ss;
xnoi = 1.0 / nm;

for (lsflg = 1; lsflg <= 2; lsflg++)
{
a1 = zcosg * zcosh + zsing * zcosi * zsinh;
a3 = -zsing * zcosh + zcosg * zcosi * zsinh;
a7 = -zcosg * zsinh + zsing * zcosi * zcosh;
a8 = zsing * zsini;
a9 = zsing * zsinh + zcosg * zcosi * zcosh;
a10 = zcosg * zsini;
a2 = cosim * a7 + sinim * a8;
a4 = cosim * a9 + sinim * a10;
a5 = -sinim * a7 + cosim * a8;
a6 = -sinim * a9 + cosim * a10;

x1 = a1 * cosomm + a2 * sinomm;
x2 = a3 * cosomm + a4 * sinomm;
x3 = -a1 * sinomm + a2 * cosomm;
x4 = -a3 * sinomm + a4 * cosomm;
x5 = a5 * sinomm;
x6 = a6 * sinomm;
x7 = a5 * cosomm;
x8 = a6 * cosomm;

z31 = 12.0 * x1 * x1 - 3.0 * x3 * x3;
z32 = 24.0 * x1 * x2 - 6.0 * x3 * x4;
z33 = 12.0 * x2 * x2 - 3.0 * x4 * x4;
z1 = 3.0 *  (a1 * a1 + a2 * a2) + z31 * emsq;
z2 = 6.0 *  (a1 * a3 + a2 * a4) + z32 * emsq;
z3 = 3.0 *  (a3 * a3 + a4 * a4) + z33 * emsq;
z11 = -6.0 * a1 * a5 + emsq *  (-24.0 * x1 * x7 - 6.0 * x3 * x5);
z12 = -6.0 *  (a1 * a6 + a3 * a5) + emsq *
(-24.0 * (x2 * x7 + x1 * x8) - 6.0 * (x3 * x6 + x4 * x5));
z13 = -6.0 * a3 * a6 + emsq * (-24.0 * x2 * x8 - 6.0 * x4 * x6);
z21 = 6.0 * a2 * a5 + emsq * (24.0 * x1 * x5 - 6.0 * x3 * x7);
z22 = 6.0 *  (a4 * a5 + a2 * a6) + emsq *
(24.0 * (x2 * x5 + x1 * x6) - 6.0 * (x4 * x7 + x3 * x8));
z23 = 6.0 * a4 * a6 + emsq * (24.0 * x2 * x6 - 6.0 * x4 * x8);
z1 = z1 + z1 + betasq * z31;
z2 = z2 + z2 + betasq * z32;
z3 = z3 + z3 + betasq * z33;
s3 = cc * xnoi;
s2 = -0.5 * s3 / rtemsq;
s4 = s3 * rtemsq;
s1 = -15.0 * em * s4;
s5 = x1 * x3 + x2 * x4;
s6 = x2 * x3 + x1 * x4;
s7 = x2 * x4 - x1 * x3;

/* ----------------------- do lunar terms ------------------- */
if (lsflg == 1)
{
ss1 = s1;
ss2 = s2;
ss3 = s3;
ss4 = s4;
ss5 = s5;
ss6 = s6;
ss7 = s7;
sz1 = z1;
sz2 = z2;
sz3 = z3;
sz11 = z11;
sz12 = z12;
sz13 = z13;
sz21 = z21;
sz22 = z22;
sz23 = z23;
sz31 = z31;
sz32 = z32;
sz33 = z33;
zcosg = zcosgl;
zsing = zsingl;
zcosi = zcosil;
zsini = zsinil;
zcosh = zcoshl * cnodm + zsinhl * snodm;
zsinh = snodm * zcoshl - cnodm * zsinhl;
cc = c1l;
}
}

zmol = fmod(4.7199672 + 0.22997150  * day - gam, twopi);
zmos = fmod(6.2565837 + 0.017201977 * day, twopi);

/* ------------------------ do solar terms ---------------------- */
se2 = 2.0 * ss1 * ss6;
se3 = 2.0 * ss1 * ss7;
si2 = 2.0 * ss2 * sz12;
si3 = 2.0 * ss2 * (sz13 - sz11);
sl2 = -2.0 * ss3 * sz2;
sl3 = -2.0 * ss3 * (sz3 - sz1);
sl4 = -2.0 * ss3 * (-21.0 - 9.0 * emsq) * zes;
sgh2 = 2.0 * ss4 * sz32;
sgh3 = 2.0 * ss4 * (sz33 - sz31);
sgh4 = -18.0 * ss4 * zes;
sh2 = -2.0 * ss2 * sz22;
sh3 = -2.0 * ss2 * (sz23 - sz21);

/* ------------------------ do lunar terms ---------------------- */
ee2 = 2.0 * s1 * s6;
e3 = 2.0 * s1 * s7;
xi2 = 2.0 * s2 * z12;
xi3 = 2.0 * s2 * (z13 - z11);
xl2 = -2.0 * s3 * z2;
xl3 = -2.0 * s3 * (z3 - z1);
xl4 = -2.0 * s3 * (-21.0 - 9.0 * emsq) * zel;
xgh2 = 2.0 * s4 * z32;
xgh3 = 2.0 * s4 * (z33 - z31);
xgh4 = -18.0 * s4 * zel;
xh2 = -2.0 * s2 * z22;
xh3 = -2.0 * s2 * (z23 - z21);

//#include ""debug2.cpp""
}  // dscom

/*-----------------------------------------------------------------------------
*
*                           procedure dsinit
*
*  this procedure provides deep space contributions to mean motion dot due
*    to geopotential resonance with half day and one day orbits.
*
*  author        : <NAME>                  719-573-2600   28 jun 2005
*
*  inputs        :
*    xke         - reciprocal of tumin
*    cosim, sinim-
*    emsq        - eccentricity squared
*    argpo       - argument of perigee
*    s1, s2, s3, s4, s5      -
*    ss1, ss2, ss3, ss4, ss5 -
*    sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33 -
*    t           - time
*    tc          -
*    gsto        - greenwich sidereal time                   rad
*    mo          - mean anomaly
*    mdot        - mean anomaly dot (rate)
*    no          - mean motion
*    nodeo       - right ascension of ascending node
*    nodedot     - right ascension of ascending node dot (rate)
*    xpidot      -
*    z1, z3, z11, z13, z21, z23, z31, z33 -
*    eccm        - eccentricity
*    argpm       - argument of perigee
*    inclm       - inclination
*    mm          - mean anomaly
*    xn          - mean motion
*    nodem       - right ascension of ascending node
*
*  outputs       :
*    em          - eccentricity
*    argpm       - argument of perigee
*    inclm       - inclination
*    mm          - mean anomaly
*    nm          - mean motion
*    nodem       - right ascension of ascending node
*    irez        - flag for resonance           0-none, 1-one day, 2-half day
*    atime       -
*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433    -
*    dedt        -
*    didt        -
*    dmdt        -
*    dndt        -
*    dnodt       -
*    domdt       -
*    del1, del2, del3        -
*    ses  , sghl , sghs , sgs  , shl  , shs  , sis  , sls
*    theta       -
*    xfact       -
*    xlamo       -
*    xli         -
*    xni
*
*  locals        :
*    ainv2       -
*    aonv        -
*    cosisq      -
*    eoc         -
*    f220, f221, f311, f321, f322, f330, f441, f442, f522, f523, f542, f543  -
*    g200, g201, g211, g300, g310, g322, g410, g422, g520, g521, g532, g533  -
*    sini2       -
*    temp        -
*    temp1       -
*    theta       -
*    xno2        -
*
*  coupling      :
*    getgravconst- no longer used
*
*  references    :
*    hoots, roehrich, norad spacetrack report #3 1980
*    hoots, norad spacetrack report #6 1986
*    hoots, schumacher and glover 2004
*    vallado, crawford, hujsak, kelso  2006
----------------------------------------------------------------------------*/

static void dsinit
(
// sgp4fix just send in xke as a constant and eliminate getgravconst call
// gravconsttype whichconst,
double xke,
double cosim, double emsq, double argpo, double s1, double s2,
double s3, double s4, double s5, double sinim, double ss1,
double ss2, double ss3, double ss4, double ss5, double sz1,
double sz3, double sz11, double sz13, double sz21, double sz23,
double sz31, double sz33, double t, double tc, double gsto,
double mo, double mdot, double no, double nodeo, double nodedot,
double xpidot, double z1, double z3, double z11, double z13,
double z21, double z23, double z31, double z33, double ecco,
double eccsq, double& em, double& argpm, double& inclm, double& mm,
double& nm, double& nodem,
int& irez,
double& atime, double& d2201, double& d2211, double& d3210, double& d3222,
double& d4410, double& d4422, double& d5220, double& d5232, double& d5421,
double& d5433, double& dedt, double& didt, double& dmdt, double& dndt,
double& dnodt, double& domdt, double& del1, double& del2, double& del3,
double& xfact, double& xlamo, double& xli, double& xni
)
{
/* --------------------- local variables ------------------------ */
const double twopi = 2.0 * pi;

    double ainv2 = 0, aonv = 0, cosisq = 0, eoc = 0, f220 = 0, f221 = 0, f311,
    f321 = 0, f322 = 0, f330 = 0, f441 = 0, f442 = 0, f522 = 0, f523,
    f542 = 0, f543 = 0, g200 = 0, g201 = 0, g211 = 0, g300 = 0, g310,
    g322 = 0, g410 = 0, g422 = 0, g520 = 0, g521 = 0, g532 = 0, g533,
    ses = 0, sgs = 0, sghl = 0, sghs = 0, shs = 0, shll = 0, sis,
    sini2 = 0, sls = 0, temp = 0, temp1 = 0, theta = 0, xno2 = 0, q22,
    q31 = 0, q33 = 0, root22 = 0, root44 = 0, root54 = 0, rptim = 0, root32,
    root52 = 0, x2o3 = 0, znl = 0, emo = 0, zns = 0, emsqo = 0;

q22 = 1.7891679e-6;
q31 = 2.1460748e-6;
q33 = 2.2123015e-7;
root22 = 1.7891679e-6;
root44 = 7.3636953e-9;
root54 = 2.1765803e-9;
rptim = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
root32 = 3.7393792e-7;
root52 = 1.1428639e-7;
x2o3 = 2.0 / 3.0;
znl = 1.5835218e-4;
zns = 1.19459e-5;

// sgp4fix identify constants and allow alternate values
// just xke is used here so pass it in rather than have multiple calls
// getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );

/* -------------------- deep space initialization ------------ */
irez = 0;
if ((nm < 0.0052359877) && (nm > 0.0034906585))
irez = 1;
if ((nm >= 8.26e-3) && (nm <= 9.24e-3) && (em >= 0.5))
irez = 2;

/* ------------------------ do solar terms ------------------- */
ses = ss1 * zns * ss5;
sis = ss2 * zns * (sz11 + sz13);
sls = -zns * ss3 * (sz1 + sz3 - 14.0 - 6.0 * emsq);
sghs = ss4 * zns * (sz31 + sz33 - 6.0);
shs = -zns * ss2 * (sz21 + sz23);
// sgp4fix for 180 deg incl
if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
shs = 0.0;
if (sinim != 0.0)
shs = shs / sinim;
sgs = sghs - cosim * shs;

/* ------------------------- do lunar terms ------------------ */
dedt = ses + s1 * znl * s5;
didt = sis + s2 * znl * (z11 + z13);
dmdt = sls - znl * s3 * (z1 + z3 - 14.0 - 6.0 * emsq);
sghl = s4 * znl * (z31 + z33 - 6.0);
shll = -znl * s2 * (z21 + z23);
// sgp4fix for 180 deg incl
if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
shll = 0.0;
domdt = sgs + sghl;
dnodt = shs;
if (sinim != 0.0)
{
domdt = domdt - cosim / sinim * shll;
dnodt = dnodt + shll / sinim;
}

/* ----------- calculate deep space resonance effects -------- */
dndt = 0.0;
theta = fmod(gsto + tc * rptim, twopi);
em = em + dedt * t;
inclm = inclm + didt * t;
argpm = argpm + domdt * t;
nodem = nodem + dnodt * t;
mm = mm + dmdt * t;
//   sgp4fix for negative inclinations
//   the following if statement should be commented out
//if (inclm < 0.0)
//  {
//    inclm  = -inclm;
//    argpm  = argpm - pi;
//    nodem = nodem + pi;
//  }

/* -------------- initialize the resonance terms ------------- */
if (irez != 0)
{
aonv = pow(nm / xke, x2o3);

/* ---------- geopotential resonance for 12 hour orbits ------ */
if (irez == 2)
{
cosisq = cosim * cosim;
emo = em;
em = ecco;
emsqo = emsq;
emsq = eccsq;
eoc = em * emsq;
g201 = -0.306 - (em - 0.64) * 0.440;

if (em <= 0.65)
{
g211 = 3.616 - 13.2470 * em + 16.2900 * emsq;
g310 = -19.302 + 117.3900 * em - 228.4190 * emsq + 156.5910 * eoc;
g322 = -18.9068 + 109.7927 * em - 214.6334 * emsq + 146.5816 * eoc;
g410 = -41.122 + 242.6940 * em - 471.0940 * emsq + 313.9530 * eoc;
g422 = -146.407 + 841.8800 * em - 1629.014 * emsq + 1083.4350 * eoc;
g520 = -532.114 + 3017.977 * em - 5740.032 * emsq + 3708.2760 * eoc;
}
else
{
g211 = -72.099 + 331.819 * em - 508.738 * emsq + 266.724 * eoc;
g310 = -346.844 + 1582.851 * em - 2415.925 * emsq + 1246.113 * eoc;
g322 = -342.585 + 1554.908 * em - 2366.899 * emsq + 1215.972 * eoc;
g410 = -1052.797 + 4758.686 * em - 7193.992 * emsq + 3651.957 * eoc;
g422 = -3581.690 + 16178.110 * em - 24462.770 * emsq + 12422.520 * eoc;
if (em > 0.715)
g520 = -5149.66 + 29936.92 * em - 54087.36 * emsq + 31324.56 * eoc;
else
g520 = 1464.74 - 4664.75 * em + 3763.64 * emsq;
}
if (em < 0.7)
{
g533 = -919.22770 + 4988.6100 * em - 9064.7700 * emsq + 5542.21  * eoc;
g521 = -822.71072 + 4568.6173 * em - 8491.4146 * emsq + 5337.524 * eoc;
g532 = -853.66600 + 4690.2500 * em - 8624.7700 * emsq + 5341.4  * eoc;
}
else
{
g533 = -37995.780 + 161616.52 * em - 229838.20 * emsq + 109377.94 * eoc;
g521 = -51752.104 + 218913.95 * em - 309468.16 * emsq + 146349.42 * eoc;
g532 = -40023.880 + 170470.89 * em - 242699.48 * emsq + 115605.82 * eoc;
}

sini2 = sinim * sinim;
f220 = 0.75 * (1.0 + 2.0 * cosim + cosisq);
f221 = 1.5 * sini2;
f321 = 1.875 * sinim  *  (1.0 - 2.0 * cosim - 3.0 * cosisq);
f322 = -1.875 * sinim  *  (1.0 + 2.0 * cosim - 3.0 * cosisq);
f441 = 35.0 * sini2 * f220;
f442 = 39.3750 * sini2 * sini2;
f522 = 9.84375 * sinim * (sini2 * (1.0 - 2.0 * cosim - 5.0 * cosisq) +
0.33333333 * (-2.0 + 4.0 * cosim + 6.0 * cosisq));
f523 = sinim * (4.92187512 * sini2 * (-2.0 - 4.0 * cosim +
10.0 * cosisq) + 6.56250012 * (1.0 + 2.0 * cosim - 3.0 * cosisq));
f542 = 29.53125 * sinim * (2.0 - 8.0 * cosim + cosisq *
(-12.0 + 8.0 * cosim + 10.0 * cosisq));
f543 = 29.53125 * sinim * (-2.0 - 8.0 * cosim + cosisq *
(12.0 + 8.0 * cosim - 10.0 * cosisq));
xno2 = nm * nm;
ainv2 = aonv * aonv;
temp1 = 3.0 * xno2 * ainv2;
temp = temp1 * root22;
d2201 = temp * f220 * g201;
d2211 = temp * f221 * g211;
temp1 = temp1 * aonv;
temp = temp1 * root32;
d3210 = temp * f321 * g310;
d3222 = temp * f322 * g322;
temp1 = temp1 * aonv;
temp = 2.0 * temp1 * root44;
d4410 = temp * f441 * g410;
d4422 = temp * f442 * g422;
temp1 = temp1 * aonv;
temp = temp1 * root52;
d5220 = temp * f522 * g520;
d5232 = temp * f523 * g532;
temp = 2.0 * temp1 * root54;
d5421 = temp * f542 * g521;
d5433 = temp * f543 * g533;
xlamo = fmod(mo + nodeo + nodeo - theta - theta, twopi);
xfact = mdot + dmdt + 2.0 * (nodedot + dnodt - rptim) - no;
em = emo;
emsq = emsqo;
}

/* ---------------- synchronous resonance terms -------------- */
if (irez == 1)
{
g200 = 1.0 + emsq * (-2.5 + 0.8125 * emsq);
g310 = 1.0 + 2.0 * emsq;
g300 = 1.0 + emsq * (-6.0 + 6.60937 * emsq);
f220 = 0.75 * (1.0 + cosim) * (1.0 + cosim);
f311 = 0.9375 * sinim * sinim * (1.0 + 3.0 * cosim) - 0.75 * (1.0 + cosim);
f330 = 1.0 + cosim;
f330 = 1.875 * f330 * f330 * f330;
del1 = 3.0 * nm * nm * aonv * aonv;
del2 = 2.0 * del1 * f220 * g200 * q22;
del3 = 3.0 * del1 * f330 * g300 * q33 * aonv;
del1 = del1 * f311 * g310 * q31 * aonv;
xlamo = fmod(mo + nodeo + argpo - theta, twopi);
xfact = mdot + xpidot - rptim + dmdt + domdt + dnodt - no;
}

/* ------------ for sgp4, initialize the integrator ---------- */
xli = xlamo;
xni = no;
atime = 0.0;
nm = no + dndt;
}

//#include ""debug3.cpp""
}  // dsinit

/*-----------------------------------------------------------------------------
*
*                           procedure dspace
*
*  this procedure provides deep space contributions to mean elements for
*    perturbing third body.  these effects have been averaged over one
*    revolution of the sun and moon.  for earth resonance effects, the
*    effects have been averaged over no revolutions of the satellite.
*    (mean motion)
*
*  author        : <NAME>                  719-573-2600   28 jun 2005
*
*  inputs        :
*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433 -
*    dedt        -
*    del1, del2, del3  -
*    didt        -
*    dmdt        -
*    dnodt       -
*    domdt       -
*    irez        - flag for resonance           0-none, 1-one day, 2-half day
*    argpo       - argument of perigee
*    argpdot     - argument of perigee dot (rate)
*    t           - time
*    tc          -
*    gsto        - gst
*    xfact       -
*    xlamo       -
*    no          - mean motion
*    atime       -
*    em          - eccentricity
*    ft          -
*    argpm       - argument of perigee
*    inclm       - inclination
*    xli         -
*    mm          - mean anomaly
*    xni         - mean motion
*    nodem       - right ascension of ascending node
*
*  outputs       :
*    atime       -
*    em          - eccentricity
*    argpm       - argument of perigee
*    inclm       - inclination
*    xli         -
*    mm          - mean anomaly
*    xni         -
*    nodem       - right ascension of ascending node
*    dndt        -
*    nm          - mean motion
*
*  locals        :
*    delt        -
*    ft          -
*    theta       -
*    x2li        -
*    x2omi       -
*    xl          -
*    xldot       -
*    xnddt       -
*    xndt        -
*    xomi        -
*
*  coupling      :
*    none        -
*
*  references    :
*    hoots, roehrich, norad spacetrack report #3 1980
*    hoots, norad spacetrack report #6 1986
*    hoots, schumacher and glover 2004
*    vallado, crawford, hujsak, kelso  2006
----------------------------------------------------------------------------*/

static void dspace
(
int irez,
double d2201, double d2211, double d3210, double d3222, double d4410,
double d4422, double d5220, double d5232, double d5421, double d5433,
double dedt, double del1, double del2, double del3, double didt,
double dmdt, double dnodt, double domdt, double argpo, double argpdot,
double t, double tc, double gsto, double xfact, double xlamo,
double no,
double& atime, double& em, double& argpm, double& inclm, double& xli,
double& mm, double& xni, double& nodem, double& dndt, double& nm
)
{
const double twopi = 2.0 * pi;
int iretn, iret;
double delt, ft, theta, x2li, x2omi, xl, xldot, xnddt, xndt, xomi, g22, g32,
g44, g52, g54, fasx2, fasx4, fasx6, rptim, step2, stepn, stepp;

fasx2 = 0.13130908;
fasx4 = 2.8843198;
fasx6 = 0.37448087;
g22 = 5.7686396;
g32 = 0.95240898;
g44 = 1.8014998;
g52 = 1.0508330;
g54 = 4.4108898;
rptim = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
stepp = 720.0;
stepn = -720.0;
step2 = 259200.0;

/* ----------- calculate deep space resonance effects ----------- */
dndt = 0.0;
theta = fmod(gsto + tc * rptim, twopi);
em = em + dedt * t;

inclm = inclm + didt * t;
argpm = argpm + domdt * t;
nodem = nodem + dnodt * t;
mm = mm + dmdt * t;

/* - update resonances : numerical (euler-maclaurin) integration - */
/* ------------------------- epoch restart ----------------------  */
//   sgp4fix for propagator problems
//   the following integration works for negative time steps and periods
//   the specific changes are unknown because the original code was so convoluted

// sgp4fix take out atime = 0.0 and fix for faster operation
ft = 0.0;
if (irez != 0)
{
// sgp4fix streamline check
if ((atime == 0.0) || (t * atime <= 0.0) || (fabs(t) < fabs(atime)))
{
atime = 0.0;
xni = no;
xli = xlamo;
}
// sgp4fix move check outside loop
if (t > 0.0)
delt = stepp;
else
delt = stepn;

iretn = 381; // added for do loop
while (iretn == 381)
{
/* ------------------- dot terms calculated ------------- */
/* ----------- near - synchronous resonance terms ------- */
if (irez != 2)
{
xndt = del1 * sin(xli - fasx2) + del2 * sin(2.0 * (xli - fasx4)) +
del3 * sin(3.0 * (xli - fasx6));
xldot = xni + xfact;
xnddt = del1 * cos(xli - fasx2) +
2.0 * del2 * cos(2.0 * (xli - fasx4)) +
3.0 * del3 * cos(3.0 * (xli - fasx6));
xnddt = xnddt * xldot;
}
else
{
/* --------- near - half-day resonance terms -------- */
xomi = argpo + argpdot * atime;
x2omi = xomi + xomi;
x2li = xli + xli;
xndt = d2201 * sin(x2omi + xli - g22) + d2211 * sin(xli - g22) +
d3210 * sin(xomi + xli - g32) + d3222 * sin(-xomi + xli - g32) +
d4410 * sin(x2omi + x2li - g44) + d4422 * sin(x2li - g44) +
d5220 * sin(xomi + xli - g52) + d5232 * sin(-xomi + xli - g52) +
d5421 * sin(xomi + x2li - g54) + d5433 * sin(-xomi + x2li - g54);
xldot = xni + xfact;
xnddt = d2201 * cos(x2omi + xli - g22) + d2211 * cos(xli - g22) +
d3210 * cos(xomi + xli - g32) + d3222 * cos(-xomi + xli - g32) +
d5220 * cos(xomi + xli - g52) + d5232 * cos(-xomi + xli - g52) +
2.0 * (d4410 * cos(x2omi + x2li - g44) +
d4422 * cos(x2li - g44) + d5421 * cos(xomi + x2li - g54) +
d5433 * cos(-xomi + x2li - g54));
xnddt = xnddt * xldot;
}

/* ----------------------- integrator ------------------- */
// sgp4fix move end checks to end of routine
if (fabs(t - atime) >= stepp)
{
iretn = 381;
}
else // exit here
{
ft = t - atime;
iretn = 0;
}

if (iretn == 381)
{
xli = xli + xldot * delt + xndt * step2;
xni = xni + xndt * delt + xnddt * step2;
atime = atime + delt;
}
}  // while iretn = 381

nm = xni + xndt * ft + xnddt * ft * ft * 0.5;
xl = xli + xldot * ft + xndt * ft * ft * 0.5;
if (irez != 1)
{
mm = xl - 2.0 * nodem + 2.0 * theta;
dndt = nm - no;
}
else
{
mm = xl - nodem - argpm + theta;
dndt = nm - no;
}
nm = no + dndt;
}

}  // dsspace

/*-----------------------------------------------------------------------------
*
*                           procedure initl
*
*  this procedure initializes the spg4 propagator. all the initialization is
*    consolidated here instead of having multiple loops inside other routines.
*
*  author        : <NAME>                  719-573-2600   28 jun 2005
*
*  inputs        :
*    satn        - satellite number - not needed, placed in satrec
*    xke         - reciprocal of tumin
*    j2          - j2 zonal harmonic
*    ecco        - eccentricity                           0.0 - 1.0
*    epoch       - epoch time in days from jan 0, 1950. 0 hr
*    inclo       - inclination of satellite
*    no          - mean motion of satellite
*
*  outputs       :
*    ainv        - 1.0 / a
*    ao          - semi major axis
*    con41       -
*    con42       - 1.0 - 5.0 cos(i)
*    cosio       - cosine of inclination
*    cosio2      - cosio squared
*    eccsq       - eccentricity squared
*    method      - flag for deep space                    'd', 'n'
*    omeosq      - 1.0 - ecco * ecco
*    posq        - semi-parameter squared
*    rp          - radius of perigee
*    rteosq      - square root of (1.0 - ecco*ecco)
*    sinio       - sine of inclination
*    gsto        - gst at time of observation               rad
*    no          - mean motion of satellite
*
*  locals        :
*    ak          -
*    d1          -
*    del         -
*    adel        -
*    po          -
*
*  coupling      :
*    getgravconst- no longer used
*    gstime      - find greenwich sidereal time from the julian date
*
*  references    :
*    hoots, roehrich, norad spacetrack report #3 1980
*    hoots, norad spacetrack report #6 1986
*    hoots, schumacher and glover 2004
*    vallado, crawford, hujsak, kelso  2006
----------------------------------------------------------------------------*/

static void initl
(
// sgp4fix satn not needed. include in satrec in case needed later
// int satn,
// sgp4fix just pass in xke and j2
// gravconsttype whichconst,
double xke, double j2,
double ecco, double epoch, double inclo, double no_kozai, char opsmode,
char& method, double& ainv, double& ao, double& con41, double& con42, double& cosio,
double& cosio2, double& eccsq, double& omeosq, double& posq,
double& rp, double& rteosq, double& sinio, double& gsto, double& no_unkozai
)
{
/* --------------------- local variables ------------------------ */
double ak = 0, d1 = 0, del = 0, adel = 0, po = 0, x2o3 = 0;

// sgp4fix use old way of finding gst
double ds70;
double ts70, tfrac, c1, thgr70, fk5r, c1p2p;
const double twopi = 2.0 * pi;

/* ----------------------- earth constants ---------------------- */
// sgp4fix identify constants and allow alternate values
// only xke and j2 are used here so pass them in directly
// getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
x2o3 = 2.0 / 3.0;

/* ------------- calculate auxillary epoch quantities ---------- */
eccsq = ecco * ecco;
omeosq = 1.0 - eccsq;
rteosq = sqrt(omeosq);
cosio = cos(inclo);
cosio2 = cosio * cosio;

/* ------------------ un-kozai the mean motion ----------------- */
ak = pow(xke / no_kozai, x2o3);
d1 = 0.75 * j2 * (3.0 * cosio2 - 1.0) / (rteosq * omeosq);
del = d1 / (ak * ak);
adel = ak * (1.0 - del * del - del *
(1.0 / 3.0 + 134.0 * del * del / 81.0));
del = d1 / (adel * adel);
no_unkozai = no_kozai / (1.0 + del);

ao = pow(xke / (no_unkozai), x2o3);
sinio = sin(inclo);
po = ao * omeosq;
con42 = 1.0 - 5.0 * cosio2;
con41 = -con42 - cosio2 - cosio2;
ainv = 1.0 / ao;
posq = po * po;
rp = ao * (1.0 - ecco);
method = 'n';

// sgp4fix modern approach to finding sidereal time
//   if (opsmode == 'a')
//      {
// sgp4fix use old way of finding gst
// count integer number of days from 0 jan 1970
ts70 = epoch - 7305.0;
ds70 = floor(ts70 + 1.0e-8);
tfrac = ts70 - ds70;
// find greenwich location at epoch
c1 = 1.72027916940703639e-2;
thgr70 = 1.7321343856509374;
fk5r = 5.07551419432269442e-15;
c1p2p = c1 + twopi;
double gsto1 = fmod(thgr70 + c1*ds70 + c1p2p*tfrac + ts70*ts70*fk5r, twopi);
if (gsto1 < 0.0)
gsto = gstime(epoch + 2433281.5);
}  // initl

/*-----------------------------------------------------------------------------
*
*                             procedure sgp4init
*
*  this procedure initializes variables for sgp4.
*
*  author        : <NAME>                  719-573-2600   28 jun 2005
*
*  inputs        :
*    opsmode     - mode of operation afspc or improved 'a', 'i'
*    whichconst  - which set of constants to use  72, 84
*    satn        - satellite number
*    bstar       - sgp4 type drag coefficient              kg/m2er
*    ecco        - eccentricity
*    epoch       - epoch time in days from jan 0, 1950. 0 hr
*    argpo       - argument of perigee (output if ds)
*    inclo       - inclination
*    mo          - mean anomaly (output if ds)
*    no          - mean motion
*    nodeo       - right ascension of ascending node
*
*  outputs       :
*    satrec      - common values for subsequent calls
*    return code - non-zero on error.
*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
*                   2 - mean motion less than 0.0
*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
*                   4 - semi-latus rectum < 0.0
*                   5 - epoch elements are sub-orbital
*                   6 - satellite has decayed
*
*  locals        :
*    cnodm  , snodm  , cosim  , sinim  , cosomm , sinomm
*    cc1sq  , cc2    , cc3
*    coef   , coef1
*    cosio4      -
*    day         -
*    dndt        -
*    em          - eccentricity
*    emsq        - eccentricity squared
*    eeta        -
*    etasq       -
*    gam         -
*    argpm       - argument of perigee
*    nodem       -
*    inclm       - inclination
*    mm          - mean anomaly
*    nm          - mean motion
*    perige      - perigee
*    pinvsq      -
*    psisq       -
*    qzms24      -
*    rtemsq      -
*    s1, s2, s3, s4, s5, s6, s7          -
*    sfour       -
*    ss1, ss2, ss3, ss4, ss5, ss6, ss7         -
*    sz1, sz2, sz3
*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
*    tc          -
*    temp        -
*    temp1, temp2, temp3       -
*    tsi         -
*    xpidot      -
*    xhdot1      -
*    z1, z2, z3          -
*    z11, z12, z13, z21, z22, z23, z31, z32, z33         -
*
*  coupling      :
*    getgravconst-
*    initl       -
*    dscom       -
*    dpper       -
*    dsinit      -
*    sgp4        -
*
*  references    :
*    hoots, roehrich, norad spacetrack report #3 1980
*    hoots, norad spacetrack report #6 1986
*    hoots, schumacher and glover 2004
*    vallado, crawford, hujsak, kelso  2006
----------------------------------------------------------------------------*/
bool sgp4init(gravconsttype whichconst, char opsmode, const char satn[9], const double epoch, const double xbstar, const double xndot, const double xnddot, const double xecco, const double xargpo, const double xinclo, const double xmo, const double xno_kozai, const double xnodeo, elsetrec* satrec) {
/* --------------------- local variables ------------------------ */
    double ao = 0, ainv = 0, con42 = 0, cosio = 0, sinio = 0, cosio2 = 0, eccsq,
    omeosq = 0, posq = 0, rp = 0, rteosq,
    cnodm = 0, snodm = 0, cosim = 0, sinim = 0, cosomm = 0, sinomm = 0, cc1sq,
    cc2 = 0, cc3 = 0, coef = 0, coef1 = 0, cosio4 = 0, day = 0, dndt,
    em = 0, emsq = 0, eeta = 0, etasq = 0, gam = 0, argpm = 0, nodem,
    inclm = 0, mm = 0, nm = 0, perige = 0, pinvsq = 0, psisq = 0, qzms24,
    rtemsq = 0, s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0, s6,
    s7 = 0, sfour = 0, ss1 = 0, ss2 = 0, ss3 = 0, ss4 = 0, ss5,
    ss6 = 0, ss7 = 0, sz1 = 0, sz2 = 0, sz3 = 0, sz11 = 0, sz12,
    sz13 = 0, sz21 = 0, sz22 = 0, sz23 = 0, sz31 = 0, sz32 = 0, sz33,
    tc = 0, temp = 0, temp1 = 0, temp2 = 0, temp3 = 0, tsi = 0, xpidot,
    xhdot1 = 0, z1 = 0, z2 = 0, z3 = 0, z11 = 0, z12 = 0, z13,
    z21 = 0, z22 = 0, z23 = 0, z31 = 0, z32 = 0, z33,
    qzms2t = 0, ss = 0, x2o3 = 0, r[3] = {0, 0, 0}, v[3],
     [MASK]  = 0, qzms2ttemp = 0, qzms24temp = 0;

/* ------------------------ initialization --------------------- */
// sgp4fix divisor for divide by zero check on inclination
// the old check used 1.0 + cos(pi-1.0e-9), but then compared it to
// 1.5 e-12, so the threshold was changed to 1.5e-12 for consistency
const double temp4 = 1.5e-12;

/* ----------- set all near earth variables to zero ------------ */
satrec->isimp = 0;   satrec->method = 'n'; satrec->aycof = 0.0;
    satrec->con41 = 0.0; satrec->cc1 = 0.0; satrec->cc4 = 0.0;
    satrec->cc5 = 0.0; satrec->d2 = 0.0; satrec->d3 = 0.0;
satrec->d4 = 0.0; satrec->delmo = 0.0; satrec->eta = 0.0;
satrec->argpdot = 0.0; satrec->omgcof = 0.0; satrec->sinmao = 0.0;
satrec->t = 0.0; satrec->t2cof = 0.0; satrec->t3cof = 0.0;
satrec->t4cof = 0.0; satrec->t5cof = 0.0; satrec->x1mth2 = 0.0;
satrec->x7thm1 = 0.0; satrec->mdot = 0.0; satrec->nodedot = 0.0;
satrec->xlcof = 0.0; satrec->xmcof = 0.0; satrec->nodecf = 0.0;

/* ----------- set all deep space variables to zero ------------ */
satrec->irez = 0;   satrec->d2201 = 0.0; satrec->d2211 = 0.0;
satrec->d3210 = 0.0; satrec->d3222 = 0.0; satrec->d4410 = 0.0;
satrec->d4422 = 0.0; satrec->d5220 = 0.0; satrec->d5232 = 0.0;
satrec->d5421 = 0.0; satrec->d5433 = 0.0; satrec->dedt = 0.0;
satrec->del1 = 0.0; satrec->del2 = 0.0; satrec->del3 = 0.0;
satrec->didt = 0.0; satrec->dmdt = 0.0; satrec->dnodt = 0.0;
satrec->domdt = 0.0; satrec->e3 = 0.0; satrec->ee2 = 0.0;
satrec->peo = 0.0; satrec->pgho = 0.0; satrec->pho = 0.0;
satrec->pinco = 0.0; satrec->plo = 0.0; satrec->se2 = 0.0;
satrec->se3 = 0.0; satrec->sgh2 = 0.0; satrec->sgh3 = 0.0;
satrec->sgh4 = 0.0; satrec->sh2 = 0.0; satrec->sh3 = 0.0;
satrec->si2 = 0.0; satrec->si3 = 0.0; satrec->sl2 = 0.0;
satrec->sl3 = 0.0; satrec->sl4 = 0.0; satrec->gsto = 0.0;
satrec->xfact = 0.0; satrec->xgh2 = 0.0; satrec->xgh3 = 0.0;
satrec->xgh4 = 0.0; satrec->xh2 = 0.0; satrec->xh3 = 0.0;
satrec->xi2 = 0.0; satrec->xi3 = 0.0; satrec->xl2 = 0.0;
satrec->xl3 = 0.0; satrec->xl4 = 0.0; satrec->xlamo = 0.0;
satrec->zmol = 0.0; satrec->zmos = 0.0; satrec->atime = 0.0;
satrec->xli = 0.0; satrec->xni = 0.0;

/* ------------------------ earth constants ----------------------- */
// sgp4fix identify constants and allow alternate values
// this is now the only call for the constants
getgravconst(whichconst, &satrec->tumin, &satrec->mus, &satrec->radiusearthkm, &satrec->xke,
&satrec->j2, &satrec->j3, &satrec->j4, &satrec->j3oj2);

//-------------------------------------------------------------------------

satrec->error = 0;
satrec->operationmode = opsmode;
// new alpha5 or 9-digit number
   strcpy(satrec->satnum, satn);

satrec->bstar = xbstar;
// sgp4fix allow additional parameters in the struct
satrec->ndot = xndot;
satrec->nddot = xnddot;
satrec->ecco = xecco;
satrec->argpo = xargpo;
satrec->inclo = xinclo;
satrec->mo = xmo;
// sgp4fix rename variables to clarify which mean motion is intended
satrec->no_kozai = xno_kozai;
satrec->nodeo = xnodeo;

// single averaged mean elements
satrec->am = satrec->em = satrec->im = satrec->Om = satrec->mm = satrec->nm = 0.0;

/* ------------------------ earth constants ----------------------- */
// sgp4fix identify constants and allow alternate values no longer needed
// getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
ss = 78.0 / satrec->radiusearthkm + 1.0;
// sgp4fix use multiply for speed instead of pow
qzms2ttemp = (120.0 - 78.0) / satrec->radiusearthkm;
qzms2t = qzms2ttemp * qzms2ttemp * qzms2ttemp * qzms2ttemp;
x2o3 = 2.0 / 3.0;

satrec->init = 'y';
satrec->t = 0.0;

// sgp4fix remove satn as it is not needed in initl
initl
(satrec->xke, satrec->j2, satrec->ecco, epoch, satrec->inclo, satrec->no_kozai, satrec->operationmode,
satrec->method, ainv, ao, satrec->con41, con42, cosio, cosio2, eccsq, omeosq,
posq, rp, rteosq, sinio, satrec->gsto, satrec->no_unkozai);
satrec->a = pow(satrec->no_unkozai * satrec->tumin, (-2.0 / 3.0));
satrec->alta = satrec->a * (1.0 + satrec->ecco) - 1.0;
satrec->altp = satrec->a * (1.0 - satrec->ecco) - 1.0;
satrec->error = 0;

if ((omeosq >= 0.0) || (satrec->no_unkozai >= 0.0))
{
satrec->isimp = 0;
if (rp < (220.0 / satrec->radiusearthkm + 1.0))
satrec->isimp = 1;
sfour = ss;
qzms24 = qzms2t;
perige = (rp - 1.0) * satrec->radiusearthkm;

/* - for perigees below 156 km, s and qoms2t are altered - */
if (perige < 156.0)
{
sfour = perige - 78.0;
if (perige < 98.0)
sfour = 20.0;
// sgp4fix use multiply for speed instead of pow
qzms24temp = (120.0 - sfour) / satrec->radiusearthkm;
qzms24 = qzms24temp * qzms24temp * qzms24temp * qzms24temp;
sfour = sfour / satrec->radiusearthkm + 1.0;
}
pinvsq = 1.0 / posq;

tsi = 1.0 / (ao - sfour);
satrec->eta = ao * satrec->ecco * tsi;
etasq = satrec->eta * satrec->eta;
eeta = satrec->ecco * satrec->eta;
psisq = fabs(1.0 - etasq);
coef = qzms24 * pow(tsi, 4.0);
coef1 = coef / pow(psisq, 3.5);
cc2 = coef1 * satrec->no_unkozai * (ao * (1.0 + 1.5 * etasq + eeta *
(4.0 + etasq)) + 0.375 * satrec->j2 * tsi / psisq * satrec->con41 *
(8.0 + 3.0 * etasq * (8.0 + etasq)));
satrec->cc1 = satrec->bstar * cc2;
cc3 = 0.0;
if (satrec->ecco > 1.0e-4)
cc3 = -2.0 * coef * tsi * satrec->j3oj2 * satrec->no_unkozai * sinio / satrec->ecco;
satrec->x1mth2 = 1.0 - cosio2;
satrec->cc4 = 2.0* satrec->no_unkozai * coef1 * ao * omeosq *
(satrec->eta * (2.0 + 0.5 * etasq) + satrec->ecco *
(0.5 + 2.0 * etasq) - satrec->j2 * tsi / (ao * psisq) *
(-3.0 * satrec->con41 * (1.0 - 2.0 * eeta + etasq *
(1.5 - 0.5 * eeta)) + 0.75 * satrec->x1mth2 *
(2.0 * etasq - eeta * (1.0 + etasq)) * cos(2.0 * satrec->argpo)));
satrec->cc5 = 2.0 * coef1 * ao * omeosq * (1.0 + 2.75 *
(etasq + eeta) + eeta * etasq);
cosio4 = cosio2 * cosio2;
temp1 = 1.5 * satrec->j2 * pinvsq * satrec->no_unkozai;
temp2 = 0.5 * temp1 * satrec->j2 * pinvsq;
temp3 = -0.46875 * satrec->j4 * pinvsq * pinvsq * satrec->no_unkozai;
satrec->mdot = satrec->no_unkozai + 0.5 * temp1 * rteosq * satrec->con41 + 0.0625 *
temp2 * rteosq * (13.0 - 78.0 * cosio2 + 137.0 * cosio4);
satrec->argpdot = -0.5 * temp1 * con42 + 0.0625 * temp2 *
(7.0 - 114.0 * cosio2 + 395.0 * cosio4) +
temp3 * (3.0 - 36.0 * cosio2 + 49.0 * cosio4);
xhdot1 = -temp1 * cosio;
satrec->nodedot = xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * cosio2) +
2.0 * temp3 * (3.0 - 7.0 * cosio2)) * cosio;
xpidot = satrec->argpdot + satrec->nodedot;
satrec->omgcof = satrec->bstar * cc3 * cos(satrec->argpo);
satrec->xmcof = 0.0;
if (satrec->ecco > 1.0e-4)
satrec->xmcof = -x2o3 * coef * satrec->bstar / eeta;
satrec->nodecf = 3.5 * omeosq * xhdot1 * satrec->cc1;
satrec->t2cof = 1.5 * satrec->cc1;
// sgp4fix for divide by zero with xinco = 180 deg
if (fabs(cosio + 1.0) > 1.5e-12)
satrec->xlcof = -0.25 * satrec->j3oj2 * sinio * (3.0 + 5.0 * cosio) / (1.0 + cosio);
else
satrec->xlcof = -0.25 * satrec->j3oj2 * sinio * (3.0 + 5.0 * cosio) / temp4;
satrec->aycof = -0.5 * satrec->j3oj2 * sinio;
// sgp4fix use multiply for speed instead of pow
 [MASK]  = 1.0 + satrec->eta * cos(satrec->mo);
satrec->delmo =  [MASK]  *  [MASK]  *  [MASK] ;
satrec->sinmao = sin(satrec->mo);
satrec->x7thm1 = 7.0 * cosio2 - 1.0;

/* --------------- deep space initialization ------------- */
if ((2 * pi / satrec->no_unkozai) >= 225.0)
{
satrec->method = 'd';
satrec->isimp = 1;
tc = 0.0;
inclm = satrec->inclo;

dscom
(
epoch, satrec->ecco, satrec->argpo, tc, satrec->inclo, satrec->nodeo,
satrec->no_unkozai, snodm, cnodm, sinim, cosim, sinomm, cosomm,
day, satrec->e3, satrec->ee2, em, emsq, gam,
satrec->peo, satrec->pgho, satrec->pho, satrec->pinco,
satrec->plo, rtemsq, satrec->se2, satrec->se3,
satrec->sgh2, satrec->sgh3, satrec->sgh4,
satrec->sh2, satrec->sh3, satrec->si2, satrec->si3,
satrec->sl2, satrec->sl3, satrec->sl4, s1, s2, s3, s4, s5,
s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, sz1, sz2, sz3,
sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33,
satrec->xgh2, satrec->xgh3, satrec->xgh4, satrec->xh2,
satrec->xh3, satrec->xi2, satrec->xi3, satrec->xl2,
satrec->xl3, satrec->xl4, nm, z1, z2, z3, z11,
z12, z13, z21, z22, z23, z31, z32, z33,
satrec->zmol, satrec->zmos
);
dpper
(
satrec->e3, satrec->ee2, satrec->peo, satrec->pgho,
satrec->pho, satrec->pinco, satrec->plo, satrec->se2,
satrec->se3, satrec->sgh2, satrec->sgh3, satrec->sgh4,
satrec->sh2, satrec->sh3, satrec->si2, satrec->si3,
satrec->sl2, satrec->sl3, satrec->sl4, satrec->t,
satrec->xgh2, satrec->xgh3, satrec->xgh4, satrec->xh2,
satrec->xh3, satrec->xi2, satrec->xi3, satrec->xl2,
satrec->xl3, satrec->xl4, satrec->zmol, satrec->zmos, inclm, satrec->init,
satrec->ecco, satrec->inclo, satrec->nodeo, satrec->argpo, satrec->mo,
satrec->operationmode
);

argpm = 0.0;
nodem = 0.0;
mm = 0.0;

dsinit
(
satrec->xke,
cosim, emsq, satrec->argpo, s1, s2, s3, s4, s5, sinim, ss1, ss2, ss3, ss4,
ss5, sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33, satrec->t, tc,
satrec->gsto, satrec->mo, satrec->mdot, satrec->no_unkozai, satrec->nodeo,
satrec->nodedot, xpidot, z1, z3, z11, z13, z21, z23, z31, z33,
satrec->ecco, eccsq, em, argpm, inclm, mm, nm, nodem,
satrec->irez, satrec->atime,
satrec->d2201, satrec->d2211, satrec->d3210, satrec->d3222,
satrec->d4410, satrec->d4422, satrec->d5220, satrec->d5232,
satrec->d5421, satrec->d5433, satrec->dedt, satrec->didt,
satrec->dmdt, dndt, satrec->dnodt, satrec->domdt,
satrec->del1, satrec->del2, satrec->del3, satrec->xfact,
satrec->xlamo, satrec->xli, satrec->xni
);
}

/* ----------- set variables if not deep space ----------- */
if (satrec->isimp != 1)
{
cc1sq = satrec->cc1 * satrec->cc1;
satrec->d2 = 4.0 * ao * tsi * cc1sq;
temp = satrec->d2 * tsi * satrec->cc1 / 3.0;
satrec->d3 = (17.0 * ao + sfour) * temp;
satrec->d4 = 0.5 * temp * ao * tsi * (221.0 * ao + 31.0 * sfour) *
satrec->cc1;
satrec->t3cof = satrec->d2 + 2.0 * cc1sq;
satrec->t4cof = 0.25 * (3.0 * satrec->d3 + satrec->cc1 *
(12.0 * satrec->d2 + 10.0 * cc1sq));
satrec->t5cof = 0.2 * (3.0 * satrec->d4 +
12.0 * satrec->cc1 * satrec->d3 +
6.0 * satrec->d2 * satrec->d2 +
15.0 * cc1sq * (2.0 * satrec->d2 + cc1sq));
}
} // if omeosq = 0 ...

/* finally propogate to zero epoch to initialize all others. */
// sgp4fix take out check to let satellites process until they are actually below earth surface
sgp4(satrec, 0.0, r, v);

satrec->init = 'n';

//sgp4fix return boolean. satrec->error contains any error codes
return true;
}  // sgp4init

/*-----------------------------------------------------------------------------
*
*                             procedure sgp4
*
*  this procedure is the sgp4 prediction model from space command. this is an
*    updated and combined version of sgp4 and sdp4, which were originally
*    published separately in spacetrack report #3. this version follows the
*    methodology from the aiaa paper (2006) describing the history and
*    development of the code.
*
*  author        : <NAME>                  719-573-2600   28 jun 2005
*
*  inputs        :
*    satrec - initialised structure from sgp4init() call.
*    tsince - time since epoch (minutes)
*
*  outputs       :
*    r           - position vector                     km
*    v           - velocity                            km/sec
*  return code - non-zero on error.
*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
*                   2 - mean motion less than 0.0
*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
*                   4 - semi-latus rectum < 0.0
*                   5 - epoch elements are sub-orbital
*                   6 - satellite has decayed
*
*  locals        :
*    am          -
*    axnl, aynl        -
*    betal       -
*    cosim   , sinim   , cosomm  , sinomm  , cnod    , snod    , cos2u   ,
*    sin2u   , coseo1  , sineo1  , cosi    , sini    , cosip   , sinip   ,
*    cosisq  , cossu   , sinsu   , cosu    , sinu
*    delm        -
*    delomg      -
*    dndt        -
*    eccm        -
*    emsq        -
*    ecose       -
*    el2         -
*    eo1         -
*    eccp        -
*    esine       -
*    argpm       -
*    argpp       -
*    omgadf      -c
*    pl          -
*    r           -
*    rtemsq      -
*    rdotl       -
*    rl          -
*    rvdot       -
*    rvdotl      -
*    su          -
*    t2  , t3   , t4    , tc
*    tem5, temp , temp1 , temp2  , tempa  , tempe  , templ
*    u   , ux   , uy    , uz     , vx     , vy     , vz
*    inclm       - inclination
*    mm          - mean anomaly
*    nm          - mean motion
*    nodem       - right asc of ascending node
*    xinc        -
*    xincp       -
*    xl          -
*    xlm         -
*    mp          -
*    xmdf        -
*    xmx         -
*    xmy         -
*    nodedf      -
*    xnode       -
*    nodep       -
*    np          -
*
*  coupling      :
*    getgravconst- no longer used. Variables are conatined within satrec
*    dpper
*    dpspace
*
*  references    :
*    hoots, roehrich, norad spacetrack report #3 1980
*    hoots, norad spacetrack report #6 1986
*    hoots, schumacher and glover 2004
*    vallado, crawford, hujsak, kelso  2006
----------------------------------------------------------------------------*/

bool sgp4
(
elsetrec* satrec, double tsince,
double r[3], double v[3]
)
{
    double am = 0, axnl = 0, aynl = 0, betal = 0, cosim = 0, cnod,
        cos2u = 0, coseo1 = 0, cosi = 0, cosip = 0, cosisq = 0, cossu = 0, cosu,
        delm = 0, delomg = 0, em = 0, emsq = 0, ecose = 0, el2 = 0, eo1,
        ep = 0, esine = 0, argpm = 0, argpp = 0, argpdf = 0, pl = 0, mrt = 0.0,
        mvt = 0, rdotl = 0, rl = 0, rvdot = 0, rvdotl = 0, sinim,
        sin2u = 0, sineo1 = 0, sini = 0, sinip = 0, sinsu = 0, sinu,
        snod = 0, su = 0, t2 = 0, t3 = 0, t4 = 0, tem5 = 0, temp,
        temp1 = 0, temp2 = 0, tempa = 0, tempe = 0, templ = 0, u = 0, ux,
        uy = 0, uz = 0, vx = 0, vy = 0, vz = 0, inclm = 0, mm,
        nm = 0, nodem = 0, xinc = 0, xincp = 0, xl = 0, xlm = 0, mp,
        xmdf = 0, xmx = 0, xmy = 0, nodedf = 0, xnode = 0, nodep = 0, tc = 0, dndt,
        twopi = 0, x2o3 = 0, vkmpersec = 0, delmtemp = 0;
    int ktr;

    /* ------------------ set mathematical constants --------------- */
    // sgp4fix divisor for divide by zero check on inclination
    // the old check used 1.0 + cos(pi-1.0e-9), but then compared it to
    // 1.5 e-12, so the threshold was changed to 1.5e-12 for consistency
    const double temp4 = 1.5e-12;
    twopi = 2.0 * pi;
    x2o3 = 2.0 / 3.0;
    // sgp4fix identify constants and allow alternate values
    // getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
    vkmpersec = satrec->radiusearthkm * satrec->xke / 60.0;

    /* --------------------- clear sgp4 error flag ----------------- */
    satrec->t = tsince;
    satrec->error = 0;

    /* ------- update for secular gravity and atmospheric drag ----- */
    xmdf = satrec->mo + satrec->mdot * satrec->t;
    argpdf = satrec->argpo + satrec->argpdot * satrec->t;
    nodedf = satrec->nodeo + satrec->nodedot * satrec->t;
    argpm = argpdf;
    mm = xmdf;
    t2 = satrec->t * satrec->t;
    nodem = nodedf + satrec->nodecf * t2;
    tempa = 1.0 - satrec->cc1 * satrec->t;
    tempe = satrec->bstar * satrec->cc4 * satrec->t;
    templ = satrec->t2cof * t2;

    if (satrec->isimp != 1)
    {
        delomg = satrec->omgcof * satrec->t;
        // sgp4fix use mutliply for speed instead of pow
        delmtemp = 1.0 + satrec->eta * cos(xmdf);
        delm = satrec->xmcof *
            (delmtemp * delmtemp * delmtemp -
            satrec->delmo);
        temp = delomg + delm;
        mm = xmdf + temp;
        argpm = argpdf - temp;
        t3 = t2 * satrec->t;
        t4 = t3 * satrec->t;
        tempa = tempa - satrec->d2 * t2 - satrec->d3 * t3 -
            satrec->d4 * t4;
        tempe = tempe + satrec->bstar * satrec->cc5 * (sin(mm) -
            satrec->sinmao);
        templ = templ + satrec->t3cof * t3 + t4 * (satrec->t4cof +
            satrec->t * satrec->t5cof);
    }

    nm = satrec->no_unkozai;
    em = satrec->ecco;
    inclm = satrec->inclo;
    if (satrec->method == 'd')
    {
        tc = satrec->t;
        dspace
            (
            satrec->irez,
            satrec->d2201, satrec->d2211, satrec->d3210,
            satrec->d3222, satrec->d4410, satrec->d4422,
            satrec->d5220, satrec->d5232, satrec->d5421,
            satrec->d5433, satrec->dedt, satrec->del1,
            satrec->del2, satrec->del3, satrec->didt,
            satrec->dmdt, satrec->dnodt, satrec->domdt,
            satrec->argpo, satrec->argpdot, satrec->t, tc,
            satrec->gsto, satrec->xfact, satrec->xlamo,
            satrec->no_unkozai, satrec->atime,
            em, argpm, inclm, satrec->xli, mm, satrec->xni,
            nodem, dndt, nm
            );
    } // if method = d

    if (nm <= 0.0)
    {
        //         printf(""# error nm %f\n"", nm);
        satrec->error = 2;
        // sgp4fix add return
        return false;
    }
    am = pow((satrec->xke / nm), x2o3) * tempa * tempa;
    nm = satrec->xke / pow(am, 1.5);
    em = em - tempe;

    // fix tolerance for error recognition
    // sgp4fix am is fixed from the previous nm check
    if ((em >= 1.0) || (em < -0.001)/* || (am < 0.95)*/)
    {
        //         printf(""# error em %f\n"", em);
        satrec->error = 1;
        // sgp4fix to return if there is an error in eccentricity
        return false;
    }
    // sgp4fix fix tolerance to avoid a divide by zero
    if (em < 1.0e-6)
        em = 1.0e-6;
    mm = mm + satrec->no_unkozai * templ;
    xlm = mm + argpm + nodem;
    emsq = em * em;
    temp = 1.0 - emsq;

    nodem = fmod(nodem, twopi);
    argpm = fmod(argpm, twopi);
    xlm = fmod(xlm, twopi);
    mm = fmod(xlm - argpm - nodem, twopi);

    // sgp4fix recover singly averaged mean elements
    satrec->am = am;
    satrec->em = em;
    satrec->im = inclm;
    satrec->Om = nodem;
    satrec->om = argpm;
    satrec->mm = mm;
    satrec->nm = nm;

    /* ----------------- compute extra mean quantities ------------- */
    sinim = sin(inclm);
    cosim = cos(inclm);

    /* -------------------- add lunar-solar periodics -------------- */
    ep = em;
    xincp = inclm;
    argpp = argpm;
    nodep = nodem;
    mp = mm;
    sinip = sinim;
    cosip = cosim;
    if (satrec->method == 'd')
    {
        dpper
            (
            satrec->e3, satrec->ee2, satrec->peo,
            satrec->pgho, satrec->pho, satrec->pinco,
            satrec->plo, satrec->se2, satrec->se3,
            satrec->sgh2, satrec->sgh3, satrec->sgh4,
            satrec->sh2, satrec->sh3, satrec->si2,
            satrec->si3, satrec->sl2, satrec->sl3,
            satrec->sl4, satrec->t, satrec->xgh2,
            satrec->xgh3, satrec->xgh4, satrec->xh2,
            satrec->xh3, satrec->xi2, satrec->xi3,
            satrec->xl2, satrec->xl3, satrec->xl4,
            satrec->zmol, satrec->zmos, satrec->inclo,
            'n', ep, xincp, nodep, argpp, mp, satrec->operationmode
            );
        if (xincp < 0.0)
        {
            xincp = -xincp;
            nodep = nodep + pi;
            argpp = argpp - pi;
        }
        if ((ep < 0.0) || (ep > 1.0))
        {
            //            printf(""# error ep %f\n"", ep);
            satrec->error = 3;
            // sgp4fix add return
            return false;
        }
    } // if method = d

    /* -------------------- long period periodics ------------------ */
    if (satrec->method == 'd')
    {
        sinip = sin(xincp);
        cosip = cos(xincp);
        satrec->aycof = -0.5*satrec->j3oj2*sinip;
        // sgp4fix for divide by zero for xincp = 180 deg
        if (fabs(cosip + 1.0) > 1.5e-12)
            satrec->xlcof = -0.25 * satrec->j3oj2 * sinip * (3.0 + 5.0 * cosip) / (1.0 + cosip);
        else
            satrec->xlcof = -0.25 * satrec->j3oj2 * sinip * (3.0 + 5.0 * cosip) / temp4;
    }
    axnl = ep * cos(argpp);
    temp = 1.0 / (am * (1.0 - ep * ep));
    aynl = ep* sin(argpp) + temp * satrec->aycof;
    xl = mp + argpp + nodep + temp * satrec->xlcof * axnl;

    /* --------------------- solve kepler's equation --------------- */
    u = fmod(xl - nodep, twopi);
    eo1 = u;
    tem5 = 9999.9;
    ktr = 1;
    //   sgp4fix for kepler iteration
    //   the following iteration needs better limits on corrections
    while ((fabs(tem5) >= 1.0e-12) && (ktr <= 10))
    {
        sineo1 = sin(eo1);
        coseo1 = cos(eo1);
        tem5 = 1.0 - coseo1 * axnl - sineo1 * aynl;
        tem5 = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5;
        if (fabs(tem5) >= 0.95)
            tem5 = tem5 > 0.0 ? 0.95 : -0.95;
        eo1 = eo1 + tem5;
        ktr = ktr + 1;
    }

    /* ------------- short period preliminary quantities ----------- */
    ecose = axnl*coseo1 + aynl*sineo1;
    esine = axnl*sineo1 - aynl*coseo1;
    el2 = axnl*axnl + aynl*aynl;
    pl = am*(1.0 - el2);
    if (pl < 0.0)
    {
        //         printf(""# error pl %f\n"", pl);
        satrec->error = 4;
        // sgp4fix add return
        return false;
    }
    else
    {
        rl = am * (1.0 - ecose);
        rdotl = sqrt(am) * esine / rl;
        rvdotl = sqrt(pl) / rl;
        betal = sqrt(1.0 - el2);
        temp = esine / (1.0 + betal);
        sinu = am / rl * (sineo1 - aynl - axnl * temp);
        cosu = am / rl * (coseo1 - axnl + aynl * temp);
        su = atan2(sinu, cosu);
        sin2u = (cosu + cosu) * sinu;
        cos2u = 1.0 - 2.0 * sinu * sinu;
        temp = 1.0 / pl;
        temp1 = 0.5 * satrec->j2 * temp;
        temp2 = temp1 * temp;

        /* -------------- update for short period periodics ------------ */
        if (satrec->method == 'd')
        {
            cosisq = cosip * cosip;
            satrec->con41 = 3.0*cosisq - 1.0;
            satrec->x1mth2 = 1.0 - cosisq;
            satrec->x7thm1 = 7.0*cosisq - 1.0;
        }
        mrt = rl * (1.0 - 1.5 * temp2 * betal * satrec->con41) +
            0.5 * temp1 * satrec->x1mth2 * cos2u;
        su = su - 0.25 * temp2 * satrec->x7thm1 * sin2u;
        xnode = nodep + 1.5 * temp2 * cosip * sin2u;
        xinc = xincp + 1.5 * temp2 * cosip * sinip * cos2u;
        mvt = rdotl - nm * temp1 * satrec->x1mth2 * sin2u / satrec->xke;
        rvdot = rvdotl + nm * temp1 * (satrec->x1mth2 * cos2u +
            1.5 * satrec->con41) / satrec->xke;

        /* --------------------- orientation vectors ------------------- */
        sinsu = sin(su);
        cossu = cos(su);
        snod = sin(xnode);
        cnod = cos(xnode);
        sini = sin(xinc);
        cosi = cos(xinc);
        xmx = -snod * cosi;
        xmy = cnod * cosi;
        ux = xmx * sinsu + cnod * cossu;
        uy = xmy * sinsu + snod * cossu;
        uz = sini * sinsu;
        vx = xmx * cossu - cnod * sinsu;
        vy = xmy * cossu - snod * sinsu;
        vz = sini * cossu;

        /* --------- position and velocity (in km and km/sec) ---------- */
        r[0] = (mrt * ux)* satrec->radiusearthkm;
        r[1] = (mrt * uy)* satrec->radiusearthkm;
        r[2] = (mrt * uz)* satrec->radiusearthkm;
        v[0] = (mvt * ux + rvdot * vx) * vkmpersec;
        v[1] = (mvt * uy + rvdot * vy) * vkmpersec;
        v[2] = (mvt * uz + rvdot * vz) * vkmpersec;
    }  // if pl > 0

    // sgp4fix for decaying satellites
    if (mrt < 1.0)
    {
        satrec->error = 6;
        return false;
    }

    return true;
}  // sgp4

/* -----------------------------------------------------------------------------
*
*                           function gstime
*
*  this function finds the greenwich sidereal time.
*
*  author        : <NAME>                  719-573-2600    1 mar 2001
*
*  inputs          description                    range / units
*    jdut1       - julian date in ut1             days from 4713 bc
*
*  outputs       :
*    gstime      - greenwich sidereal time        0 to 2pi rad
*
*  locals        :
*    temp        - temporary variable for doubles   rad
*    tut1        - julian centuries from the
*                  jan 1, 2000 12 h epoch (ut1)
*
*  coupling      :
*    none
*
*  references    :
*    vallado       2004, 191, eq 3-45
* --------------------------------------------------------------------------- */

double  gstime
        (          double jdut1) {
     const double twopi = 2.0 * pi;
     const double deg2rad = pi / 180.0;
     double       temp, tut1;

     tut1 = (jdut1 - 2451545.0) / 36525.0;
     temp = -6.2e-6* tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1 +
             (876600.0*3600 + 8640184.812866) * tut1 + 67310.54841;  // sec
     temp = floatmod(temp * deg2rad / 240.0, twopi); //360/86400 = 1/240, to deg, to rad

     // ------------------------ check quadrants ---------------------
     if (temp < 0.0)
         temp += twopi;

     return temp;
   }  // end gstime

/* -----------------------------------------------------------------------------
*
*                           function getgravconst
*
*  this function gets constants for the propagator. note that mu is identified to
*    facilitiate comparisons with newer models. the common useage is wgs72.
*
*  author        : <NAME>                  719-573-2600   21 jul 2006
*
*  inputs        :
*    whichconst  - which set of constants to use  wgs72old, wgs72, wgs84
*
*  outputs       :
*    tumin       - minutes in one time unit
*    mu          - earth gravitational parameter
*    radiusearthkm - radius of the earth in km
*    xke         - reciprocal of tumin
*    j2, j3, j4  - un-normalized zonal harmonic values
*    j3oj2       - j3 divided by j2
*
*  locals        :
*
*  coupling      :
*    none
*
*  references    :
*    norad spacetrack report #3
*    vallado, crawford, hujsak, kelso  2006
--------------------------------------------------------------------------- */

void getgravconst
(
gravconsttype whichconst,
double* tumin,
double* mus,
double* radiusearthkm,
double* xke,
double* j2,
double* j3,
double* j4,
double* j3oj2
)
{

switch (whichconst)
{
// -- wgs-72 low precision str#3 constants --
case wgs72old:
*mus = 398600.79964;        // in km3 / s2
*radiusearthkm = 6378.135;     // km
*xke = 0.0743669161;        // reciprocal of tumin
*tumin = 1.0 / *xke;
*j2 = 0.001082616;
*j3 = -0.00000253881;
*j4 = -0.00000165597;
*j3oj2 = (*j3) / (*j2);
break;
// ------------ wgs-72 constants ------------
case wgs72:
*mus = 398600.8;            // in km3 / s2
*radiusearthkm = 6378.135;     // km
*xke = 60.0 / sqrt((*radiusearthkm)*(*radiusearthkm)*(*radiusearthkm) / *mus);
*tumin = 1.0 / *xke;
*j2 = 0.001082616;
*j3 = -0.00000253881;
*j4 = -0.00000165597;
*j3oj2 = (*j3) / (*j2);
break;
case wgs84:
// ------------ wgs-84 constants ------------
*mus = 398600.5;            // in km3 / s2
*radiusearthkm = 6378.137;     // km
*xke = 60.0 / sqrt((*radiusearthkm)*(*radiusearthkm)*(*radiusearthkm) / (*mus));
*tumin = 1.0 / (*xke);
*j2 = 0.00108262998905;
*j3 = -0.00000253215306;
*j4 = -0.00000161098761;
*j3oj2 = (*j3) / (*j2);
break;
default:
fprintf(stderr, ""unknown gravity option (%d)\n"", whichconst);
break;
}

}   // getgravconst

// older sgp4io methods
/* -----------------------------------------------------------------------------
*
*                           function twoline2rv
*
*  this function converts the two line element set character string data to
*    variables and initializes the sgp4 variables. several intermediate varaibles
*    and quantities are determined. note that the result is a structure so multiple
*    satellites can be processed simaltaneously without having to reinitialize. the
*    verification mode is an important option that permits quick checks of any
*    changes to the underlying technical theory. this option works using a
*    modified tle file in which the start, stop, and delta time values are
*    included at the end of the second line of data. this only works with the
*    verification mode. the catalog mode simply propagates from -1440 to 1440 min
*    from epoch and is useful when performing entire catalog runs.
*    update for alpha 5 numbering system. 4 mar 2021.
*
*  author        : <NAME>                  719-573-2600    1 mar 2001
*
*  inputs        :
*    longstr1    - first line of the tle
*    longstr2    - second line of the tle
*    typerun     - type of run                    verification 'v', catalog 'c',
*                                                 manual 'm'
*    typeinput   - type of manual input           mfe 'm', epoch 'e', dayofyr 'd'
*    opsmode     - mode of operation afspc or improved 'a', 'i'
*    whichconst  - which set of constants to use  72, 84
*
*  outputs       :
*    satrec      - structure containing all the sgp4 satellite information
*
*  coupling      :
*    getgravconst-
*    days2mdhms  - conversion of days to month, day, hour, minute, second
*    jday        - convert day month year hour minute second into julian date
*    sgp4init    - initialize the sgp4 variables
*
*  references    :
*    norad spacetrack report #3
*    vallado, crawford, hujsak, kelso  2006
--------------------------------------------------------------------------- */

void twoline2rv
(
char longstr1[130], char longstr2[130],
char typerun, char typeinput, char opsmode,
gravconsttype whichconst,
double& startmfe, double& stopmfe, double& deltamin,
elsetrec& satrec
)
{
const double deg2rad = pi / 180.0;         //   0.0174532925199433
const double xpdotp = 1440.0 / (2.0 *pi);  // 229.1831180523293

double sec;
double startsec, stopsec, startdayofyr, stopdayofyr, jdstart, jdstop, jdstartF, jdstopF;
int startyear, stopyear, startmon, stopmon, startday, stopday,
starthr, stophr, startmin, stopmin;
int cardnumb, j;
// sgp4fix include in satrec
// long revnum = 0, elnum = 0;
// char classification, intldesg[11];
int year = 0;
int mon, day, hr, minute, nexp, ibexp;

// sgp4fix no longer needed
// getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );

satrec.error = 0;

// set the implied decimal points since doing a formated read
// fixes for bad input data values (missing, ...)
for (j = 10; j <= 15; j++)
if (longstr1[j] == ' ')
longstr1[j] = '_';

if (longstr1[44] != ' ')
longstr1[43] = longstr1[44];
longstr1[44] = '.';
if (longstr1[7] == ' ')
longstr1[7] = 'U';
if (longstr1[9] == ' ')
longstr1[9] = '.';
for (j = 45; j <= 49; j++)
if (longstr1[j] == ' ')
longstr1[j] = '0';
if (longstr1[51] == ' ')
longstr1[51] = '0';
if (longstr1[53] != ' ')
longstr1[52] = longstr1[53];
longstr1[53] = '.';
longstr2[25] = '.';
for (j = 26; j <= 32; j++)
if (longstr2[j] == ' ')
longstr2[j] = '0';
if (longstr1[62] == ' ')
longstr1[62] = '0';
if (longstr1[68] == ' ')
longstr1[68] = '0';
sscanf(longstr1, ""%2d %5s %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld "",
&cardnumb, satrec.satnum, &satrec.classification, satrec.intldesg, &satrec.epochyr,
&satrec.epochdays, &satrec.ndot, &satrec.nddot, &nexp, &satrec.bstar,
&ibexp, &satrec.ephtype, &satrec.elnum);
if (typerun == 'v')  // run for specified times from the file
{
if (longstr2[52] == ' ')
{
sscanf(longstr2, ""%2d %5s %9lf %9lf %8lf %9lf %9lf %10lf %6ld %lf %lf %lf \n"",
&cardnumb, satrec.satnum, &satrec.inclo,
&satrec.nodeo, &satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no_kozai,
&satrec.revnum, &startmfe, &stopmfe, &deltamin);
}
else
{
sscanf(longstr2, ""%2d %5s %9lf %9lf %8lf %9lf %9lf %11lf %6ld %lf %lf %lf \n"",
&cardnumb, satrec.satnum, &satrec.inclo,
&satrec.nodeo, &satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no_kozai,
&satrec.revnum, &startmfe, &stopmfe, &deltamin);
}
}
else  // simply run -1 day to +1 day or user input times
{
if (longstr2[52] == ' ')
{
sscanf(longstr2, ""%2d %5s %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n"",
&cardnumb, satrec.satnum, &satrec.inclo,
&satrec.nodeo, &satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no_kozai,
&satrec.revnum);
}
else
{
sscanf(longstr2, ""%2d %5s %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n"",
&cardnumb, satrec.satnum, &satrec.inclo,
&satrec.nodeo, &satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no_kozai,
&satrec.revnum);
}
}

// ---- find no, ndot, nddot ----
satrec.no_kozai = satrec.no_kozai / xpdotp; //* rad/min
satrec.nddot = satrec.nddot * pow(10.0, nexp);
// could multiply by 0.00001, but implied decimal is set in the longstr1 above
satrec.bstar = satrec.bstar * pow(10.0, ibexp);

// ---- convert to sgp4 units ----
// satrec.a    = pow( satrec.no_kozai*tumin , (-2.0/3.0) );
satrec.ndot = satrec.ndot / (xpdotp*1440.0);  //* ? * minperday
satrec.nddot = satrec.nddot / (xpdotp*1440.0 * 1440);

// ---- find standard orbital elements ----
satrec.inclo = satrec.inclo  * deg2rad;
satrec.nodeo = satrec.nodeo  * deg2rad;
satrec.argpo = satrec.argpo  * deg2rad;
satrec.mo = satrec.mo     * deg2rad;

// sgp4fix not needed here
// ----------------------------------------------------------------
// find sgp4epoch time of element set
// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
// and minutes from the epoch (time)
// ----------------------------------------------------------------

// ---------------- temp fix for years from 1957-2056 -------------------
// --------- correct fix will occur when year is 4-digit in tle ---------
if (satrec.epochyr < 57)
year = satrec.epochyr + 2000;
else
year = satrec.epochyr + 1900;

days2mdhms(year, satrec.epochdays, &mon, &day, &hr, &minute, &sec);
jday(year, mon, day, hr, minute, sec, &satrec.jdsatepoch, &satrec.jdsatepochF);

// ---- input start stop times manually
if ((typerun != 'v') && (typerun != 'c'))
{
// ------------- enter start/stop ymd hms values --------------------
if (typeinput == 'e')
{
printf(""input start prop year mon day hr min sec \n"");
// make sure there is no space at the end of the format specifiers in scanf!
scanf(""%i %i %i %i %i %lf"", &startyear, &startmon, &startday, &starthr, &startmin, &startsec);
fflush(stdin);
jday(startyear, startmon, startday, starthr, startmin, startsec, &jdstart, &jdstartF);

printf(""input stop prop year mon day hr min sec \n"");
scanf(""%i %i %i %i %i %lf"", &stopyear, &stopmon, &stopday, &stophr, &stopmin, &stopsec);
fflush(stdin);
jday(stopyear, stopmon, stopday, stophr, stopmin, stopsec, &jdstop, &jdstopF);

startmfe = (jdstart - satrec.jdsatepoch) * 1440.0 + (jdstartF - satrec.jdsatepochF) * 1440.0;
stopmfe = (jdstop - satrec.jdsatepoch) * 1440.0 + (jdstopF - satrec.jdsatepochF) * 1440.0;

printf(""input time step in minutes \n"");
scanf(""%lf"", &deltamin);
}
// -------- enter start/stop year and days of year values -----------
if (typeinput == 'd')
{
printf(""input start year dayofyr \n"");
scanf(""%i %lf"", &startyear, &startdayofyr);
printf(""input stop year dayofyr \n"");
scanf(""%i %lf"", &stopyear, &stopdayofyr);

days2mdhms(startyear, startdayofyr, &mon, &day, &hr, &minute, &sec);
jday(startyear, mon, day, hr, minute, sec, &jdstart, &jdstartF);
days2mdhms(stopyear, stopdayofyr, &mon, &day, &hr, &minute, &sec);
jday(stopyear, mon, day, hr, minute, sec, &jdstop, &jdstopF);

startmfe = (jdstart - satrec.jdsatepoch) * 1440.0 + (jdstartF - satrec.jdsatepochF) * 1440.0;
stopmfe = (jdstop - satrec.jdsatepoch) * 1440.0 + (jdstopF - satrec.jdsatepochF) * 1440.0;

printf(""input time step in minutes \n"");
scanf(""%lf"", &deltamin);
}
// ------------------ enter start/stop mfe values -------------------
if (typeinput == 'm')
{
printf(""input start min from epoch \n"");
scanf(""%lf"", &startmfe);
printf(""input stop min from epoch \n"");
scanf(""%lf"", &stopmfe);
printf(""input time step in minutes \n"");
scanf(""%lf"", &deltamin);
}
}

// ------------ perform complete catalog evaluation, -+ 1 day -----------
if (typerun == 'c')
{
startmfe = -1440.0;
stopmfe = 1440.0;
deltamin = 10.0;
}

// ---------------- initialize the orbit at sgp4epoch -------------------
sgp4init(whichconst, opsmode, satrec.satnum, (satrec.jdsatepoch + satrec.jdsatepochF) - 2433281.5, satrec.bstar,
satrec.ndot, satrec.nddot, satrec.ecco, satrec.argpo, satrec.inclo, satrec.mo, satrec.no_kozai,
satrec.nodeo, &satrec);
    
} // twoline2rv

/* -----------------------------------------------------------------------------
*
*                           function asinh
*
*  this function evaluates the inverse hyperbolic sine function.
*
*  author        : <NAME>                  719-573-2600    1 mar 2001
*
*  inputs          description                    range / units
*    xval        - angle value                                  any real
*
*  outputs       :
*    arcsinh     - result                                       any real
*
*  locals        :
*    none.
*
*  coupling      :
*    none.
* --------------------------------------------------------------------------- */

double  asinh
(
double xval
)
{
return log(xval + sqrt(xval*xval + 1.0));
}  // asinh

double  sgn(double x){
if (x < 0.0)
{
return -1.0;
}
else
{
return 1.0;
}

}  // sgn

double  mag
        (
          double x[3]
        )
   {
     return sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
   }  // end mag

void    cross
        (
          double vec1[3], double vec2[3], double outvec[3]
        )
   {
     outvec[0]= vec1[1]*vec2[2] - vec1[2]*vec2[1];
     outvec[1]= vec1[2]*vec2[0] - vec1[0]*vec2[2];
     outvec[2]= vec1[0]*vec2[1] - vec1[1]*vec2[0];
   }  // end cross

double  dot
        (
          double x[3], double y[3]
        )
   {
     return (x[0]*y[0] + x[1]*y[1] + x[2]*y[2]);
   }  // end dot

double  angle
        (
          double vec1[3],
          double vec2[3]
        )
   {
     double small, undefined, magv1, magv2, temp;
     small     = 0.00000001;
     undefined = 999999.1;

     magv1 = mag(vec1);
     magv2 = mag(vec2);

     if (magv1*magv2 > small*small)
       {
         temp= dot(vec1,vec2) / (magv1*magv2);
         if (fabs( temp ) > 1.0)
             temp= sgn(temp) * 1.0;
         return acos( temp );
       }
       else
         return undefined;
   }  // end angle

/* -----------------------------------------------------------------------------
*
*                           function newtonnu
*
*  this function solves keplers equation when the true anomaly is known.
*    the mean and eccentric, parabolic, or hyperbolic anomaly is also found.
*    the parabolic limit at 168 is arbitrary. the hyperbolic anomaly is also
*    limited. the hyperbolic sine is used because it's not double valued.
*
*  author        : <NAME>                  719-573-2600   27 may 2002
*
*  revisions
*    vallado     - fix small                                     24 sep 2002
*
*  inputs          description                    range / units
*    ecc         - eccentricity                   0.0  to
*    nu          - true anomaly                   -2pi to 2pi rad
*
*  outputs       :
*    e0          - eccentric anomaly              0.0  to 2pi rad       153.02
*    m           - mean anomaly                   0.0  to 2pi rad       151.7425
*
*  locals        :
*    e1          - eccentric anomaly, next value  rad
*    sine        - sine of e
*    cose        - cosine of e
*    ktr         - index
*
*  coupling      :
*    asinh       - arc hyperbolic sine
*
*  references    :
*    vallado       2007, 85, alg 5
* --------------------------------------------------------------------------- */

void newtonnu
     (
       double ecc, double nu,
       double* e0, double* m
     )
     {
       double small, sine, cose;

     // ---------------------  implementation   ---------------------
     *e0= 999999.9;
     *m = 999999.9;
     small = 0.00000001;

     // --------------------------- circular ------------------------
     if ( fabs( ecc ) < small  )
       {
         *m = nu;
         *e0= nu;
       }
       else
         // ---------------------- elliptical -----------------------
         if ( ecc < 1.0-small  )
           {
             sine= ( sqrt( 1.0 -ecc*ecc ) * sin(nu) ) / ( 1.0 +ecc*cos(nu) );
             cose= ( ecc + cos(nu) ) / ( 1.0  + ecc*cos(nu) );
             *e0  = atan2( sine,cose );
             *m   = *e0 - ecc*sin(*e0);
           }
           else
             // -------------------- hyperbolic  --------------------
             if ( ecc > 1.0 + small  )
               {
                 if ((ecc > 1.0 ) && (fabs(nu)+0.00001 < pi-acos(1.0 /ecc)))
                   {
                     sine= ( sqrt( ecc*ecc-1.0  ) * sin(nu) ) / ( 1.0  + ecc*cos(nu) );
                     *e0  = asinh( sine );
                     *m   = ecc*sinh(*e0) - *e0;
                   }
                }
               else
                 // ----------------- parabolic ---------------------
                 if ( fabs(nu) < 168.0*pi/180.0  )
                   {
                     *e0= tan( nu*0.5  );
                     *m = *e0 + (*e0)*(*e0)*(*e0)/3.0;
                   }

     if ( ecc < 1.0  )
       {
         *m = floatmod( *m,2.0 *pi );
         if ( *m < 0.0  )
             *m = *m + 2.0 *pi;
         *e0 = floatmod( *e0,2.0 *pi );
       }
   }  // end newtonnu

/* -----------------------------------------------------------------------------
*
*                           function rv2coe
*
*  this function finds the classical orbital elements given the geocentric
*    equatorial position and velocity vectors.
*
*  author        : <NAME>                  719-573-2600   21 jun 2002
*
*  revisions
*    vallado     - fix special cases                              5 sep 2002
*    vallado     - delete extra check in inclination code        16 oct 2002
*    vallado     - add constant file use                         29 jun 2003
*    vallado     - add mu                                         2 apr 2007
*
*  inputs          description                    range / units
*    r           - ijk position vector            km
*    v           - ijk velocity vector            km / s
*    mu          - gravitational parameter        km3 / s2
*
*  outputs       :
*    p           - semilatus rectum               km
*    a           - semimajor axis                 km
*    ecc         - eccentricity
*    incl        - inclination                    0.0  to pi rad
*    omega       - longitude of ascending node    0.0  to 2pi rad
*    argp        - argument of perigee            0.0  to 2pi rad
*    nu          - true anomaly                   0.0  to 2pi rad
*    m           - mean anomaly                   0.0  to 2pi rad
*    arglat      - argument of latitude      (ci) 0.0  to 2pi rad
*    truelon     - true longitude            (ce) 0.0  to 2pi rad
*    lonper      - longitude of periapsis    (ee) 0.0  to 2pi rad
*
*  locals        :
*    hbar        - angular momentum h vector      km2 / s
*    ebar        - eccentricity     e vector
*    nbar        - line of nodes    n vector
*    c1          - v**2 - u/r
*    rdotv       - r dot v
*    hk          - hk unit vector
*    sme         - specfic mechanical energy      km2 / s2
*    i           - index
*    e           - eccentric, parabolic,
*                  hyperbolic anomaly             rad
*    temp        - temporary variable
*    typeorbit   - type of orbit                  ee, ei, ce, ci
*
*  coupling      :
*    mag         - magnitude of a vector
*    cross       - cross product of two vectors
*    angle       - find the angle between two vectors
*    newtonnu    - find the mean anomaly
*
*  references    :
*    vallado       2007, 126, alg 9, ex 2-5
* --------------------------------------------------------------------------- */

void rv2coe
     (
       double r[3], double v[3], double mu,
       double* p, double* a, double* ecc, double* incl, double* omega, double* argp,
       double* nu, double* m, double* arglat, double* truelon, double* lonper
     )
     {
       double undefined, small, hbar[3], nbar[3], magr, magv, magn, ebar[3], sme,
              rdotv, infinite, temp, c1, hk, twopi, magh, halfpi, e;

       int i;
       char typeorbit[3];

     twopi  = 2.0 * pi;
     halfpi = 0.5 * pi;
     small  = 0.00000001;
     undefined = 999999.1;
     infinite  = 999999.9;

     // -------------------------  implementation   -----------------
     magr = mag( r );
     magv = mag( v );

     // ------------------  find h n and e vectors   ----------------
     cross( r,v, hbar );
     magh = mag( hbar );
     if ( magh > small )
       {
         nbar[0]= -hbar[1];
         nbar[1]=  hbar[0];
         nbar[2]=   0.0;
         magn = mag( nbar );
         c1 = magv*magv - (mu) /magr;
         rdotv = dot( r,v );
         for (i= 0; i <= 2; i++)
             ebar[i]= (c1*r[i] - rdotv*v[i])/mu;
         *ecc = mag( ebar );

         // ------------  find a e and semi-latus rectum   ----------
         sme= ( magv*magv*0.5  ) - ( mu /magr );
         if ( fabs( sme ) > small )
             *a = -(mu) / (2.0 * sme);
           else
             *a= infinite;
         *p = magh*magh/(mu);

         // -----------------  find inclination   -------------------
         hk= hbar[2]/magh;
         *incl= acos( hk );

         // --------  determine type of orbit for later use  --------
         // ------ elliptical, parabolic, hyperbolic inclined -------
         strcpy(typeorbit,""ei"");
         if ( *ecc < small )
           {
             // ----------------  circular equatorial ---------------
             if  ((*incl<small) | (fabs(*incl-pi)<small))
                 strcpy(typeorbit,""ce"");
               else
                 // --------------  circular inclined ---------------
                 strcpy(typeorbit,""ci"");
           }
           else
           {
             // - elliptical, parabolic, hyperbolic equatorial --
             if  ((*incl<small) | (fabs(*incl-pi)<small))
                 strcpy(typeorbit,""ee"");
           }

         // ----------  find longitude of ascending node ------------
         if ( magn > small )
           {
             temp= nbar[0] / magn;
             if ( fabs(temp) > 1.0  )
                 temp= sgn(temp);
             *omega= acos(temp);
             if ( nbar[1] < 0.0  )
                 *omega= twopi - (*omega);
           }
           else
             *omega= undefined;

         // ---------------- find argument of perigee ---------------
         if ( strcmp(typeorbit,""ei"") == 0 )
           {
             *argp = angle(nbar,ebar);
             if ( ebar[2] < 0.0  )
                 *argp= twopi - (*argp);
           }
           else
             *argp= undefined;

         // ------------  find true anomaly at epoch    -------------
         if ( typeorbit[0] == 'e' )
           {
             *nu =  angle( ebar,r);
             if ( rdotv < 0.0  )
                 *nu= twopi - (*nu);
           }
           else
             *nu= undefined;

         // ----  find argument of latitude - circular inclined -----
         if ( strcmp(typeorbit,""ci"") == 0 )
           {
             *arglat = angle( nbar,r );
             if ( r[2] < 0.0  )
                 *arglat= twopi - (*arglat);
             *m = *arglat;
           }
           else
             *arglat= undefined;

         // -- find longitude of perigee - elliptical equatorial ----
         if  (( *ecc>small ) && (strcmp(typeorbit,""ee"") == 0))
           {
             temp= ebar[0]/(*ecc);
             if ( fabs(temp) > 1.0  )
                 temp= sgn(temp);
             *lonper= acos( temp );
             if ( ebar[1] < 0.0  )
                 *lonper= twopi - (*lonper);
             if ( *incl > halfpi )
                 *lonper= twopi - (*lonper);
           }
           else
             *lonper= undefined;

         // -------- find true longitude - circular equatorial ------
         if  (( magr>small ) && ( strcmp(typeorbit,""ce"") == 0 ))
           {
             temp= r[0]/magr;
             if ( fabs(temp) > 1.0  )
                 temp= sgn(temp);
             *truelon= acos( temp );
             if ( r[1] < 0.0  )
                 *truelon= twopi - (*truelon);
             if ( *incl > halfpi )
                 *truelon= twopi - (*truelon);
             *m = *truelon;
           }
           else
             *truelon= undefined;

         // ------------ find mean anomaly for all orbits -----------
         if ( typeorbit[0] == 'e' )
             newtonnu(*ecc,*nu,  &e, m);
     }
      else
     {
        *p    = undefined;
        *a    = undefined;
        *ecc  = undefined;
        *incl = undefined;
        *omega= undefined;
        *argp = undefined;
        *nu   = undefined;
        *m    = undefined;
        *arglat = undefined;
        *truelon= undefined;
        *lonper = undefined;
     }
   }  // end rv2coe

/* -----------------------------------------------------------------------------
*
*                           procedure jday
*
*  this procedure finds the julian date given the year, month, day, and time.
*    the julian date is defined by each elapsed day since noon, jan 1, 4713 bc.
*
*  algorithm     : calculate the answer in one step for efficiency
*
*  author        : <NAME>                  719-573-2600    1 mar 2001
*  changed by     : <NAME>
*
*  inputs          description                    range / units
*    year        - year                           1900 .. 2100
*    mon         - month                          1 .. 12
*    day         - day                            1 .. 28,29,30,31
*    hr          - time hour                      0 .. 23
*    min         - time min                          0 .. 59
*    sec         - time sec                          0.0 .. 59.999
*    timezone     - hours from utc                 -11 .. 14
*     daylighsaving                                  true/false
*
*  outputs       :
*    jd          - julian date                    days from 4713 bc
*
*  locals        :
*    none.
*
*  coupling      :
*    none.
*
*  references    :
*    vallado       2007, 189, alg 14, ex 3-14
*
* --------------------------------------------------------------------------- */

void    jday
(
int year, int mon, int day, int hr, int minute, double sec,
double* jd, double* jdFrac
)
{
*jd = 367.0 * year -
floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25) +
floor(275 * mon / 9.0) +
day + 1721013.5;  // use - 678987.0 to go to mjd directly
*jdFrac = (sec + minute * 60.0 + hr * 3600.0) / 86400.0;

// check that the day and fractional day are correct
if (fabs(*jdFrac) > 1.0)
{
double dtt = floor(*jdFrac);
*jd = *jd + dtt;
*jdFrac = *jdFrac - dtt;
}
}  // jday


/* -----------------------------------------------------------------------------
*
*                           procedure days2mdhms
*
*  this procedure converts the day of the year, days, to the equivalent month
*    day, hour, minute and second.
*
*  algorithm     : set up array for the number of days per month
*                  find leap year - use 1900 because 2000 is a leap year
*                  loop through a temp value while the value is < the days
*                  perform int conversions to the correct day and month
*                  convert remainder into h m s using type conversions
*
*  author        : <NAME>                  719-573-2600    1 mar 2001
*
*  inputs          description                    range / units
*    year        - year                           1900 .. 2100
*    days        - julian day of the year         0.0  .. 366.0
*
*  outputs       :
*    mon         - month                          1 .. 12
*    day         - day                            1 .. 28,29,30,31
*    hr          - hour                           0 .. 23
*    min         - minute                         0 .. 59
*    sec         - second                         0.0 .. 59.999
*
*  locals        :
*    dayofyr     - day of year
*    temp        - temporary extended values
*    inttemp     - temporary int value
*    i           - index
*    lmonth[12]  - int array containing the number of days per month
*
*  coupling      :
*    none.
* --------------------------------------------------------------------------- */

void    days2mdhms
        (
          int year, double days,
          int* mon, int* day, int* hr, int* minute, double* sec
        )
   {
     int i, inttemp, dayofyr;
     double    temp;
     int lmonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

     dayofyr = (int)floor(days);
     /* ----------------- find month and day of month ---------------- */
     if ( (year % 4) == 0 )
       lmonth[1] = 29;

     i = 1;
     inttemp = 0;
     while ((dayofyr > inttemp + lmonth[i-1]) && (i < 12))
     {
       inttemp = inttemp + lmonth[i-1];
       i++;
     }
     *mon = i;
     *day = dayofyr - inttemp;

     /* ----------------- find hours minutes and seconds ------------- */
     temp = (days - dayofyr) * 24.0;
     *hr   = (int)floor(temp);
     temp = (temp - *hr) * 60.0;
     *minute  = (int)floor(temp);
     *sec  = (temp - *minute) * 60.0;
   }  // end days2mdhms

/* -----------------------------------------------------------------------------
*
*                           procedure invjday
*
*  this procedure finds the year, month, day, hour, minute and second
*  given the julian date. tu can be ut1, tdt, tdb, etc.
*
*  algorithm     : set up starting values
*                  find leap year - use 1900 because 2000 is a leap year
*                  find the elapsed days through the year in a loop
*                  call routine to find each individual value
*
*  author        : <NAME>                  719-573-2600    1 mar 2001
*
*  inputs          description                    range / units
*    jd          - julian date                    days from 4713 bc
*
*  outputs       :
*    year        - year                           1900 .. 2100
*    mon         - month                          1 .. 12
*    day         - day                            1 .. 28,29,30,31
*    hr          - hour                           0 .. 23
*    min         - minute                         0 .. 59
*    sec         - second                         0.0 .. 59.999
*
*  locals        :
*    days        - day of year plus fractional
*                  portion of a day               days
*    tu          - julian centuries from 0 h
*                  jan 0, 1900
*    temp        - temporary double values
*    leapyrs     - number of leap years from 1900
*
*  coupling      :
*    days2mdhms  - finds month, day, hour, minute and second given days and year
*
*  references    :
*    vallado       2007, 208, alg 22, ex 3-13
* --------------------------------------------------------------------------- */

void    invjday
        (
          double jd, int timezone, bool daylightsaving,
          int* year, int* mon, int* day,
          int* hr, int* minute, double* sec
        )
   {
     int leapyrs;
     double    days, tu, temp;

     jd += (double)timezone / 24.0;

     /* --------------- find year and days of the year --------------- */
     temp = jd - 2415019.5;
     tu      = temp / 365.25;
     *year    = 1900 + (int)floor(tu);
     leapyrs = (int)floor((*year - 1901) * 0.25);

     // optional nudge by 8.64x10-7 sec to get even outputs
     days    = temp - ((*year - 1900) * 365.0 + leapyrs) + 0.00000000001;

     /* ------------ check for case of beginning of a year ----------- */
     if (days < 1.0)
       {
         *year = *year - 1;
         leapyrs = (int)floor((*year - 1901) * 0.25);
         days    = temp - ((*year - 1900) * 365.0 + leapyrs);
       }

     /* ----------------- find remaing data  ------------------------- */
     days2mdhms(*year, days, mon, day, hr, minute, sec);
     if (daylightsaving && summertime(*year, *mon, *day, *hr, timezone)) {
         days2mdhms(*year, days + 1.0/24.0, mon, day, hr, minute, sec);
     }
     *sec = *sec - 0.00000086400;
   }  // end invjday

float floatmod(float a, float b)
{
    return (a - b * floor(a / b));
}

double floatmod(double a, double b)
{
    return (a - b * floor(a / b));
}

bool summertime(int year, int month, int day, int hour, int tzHours)
// input parameters: ""normal time"" for year, month, day, hour and tzHours (0=UTC, 1=MEZ)
{
    if (month<3 || month>10) return false; // keine Sommerzeit in Jan, Feb, Nov, Dez
    if (month>3 && month<10) return true; // Sommerzeit in Apr, Mai, Jun, Jul, Aug, Sep
    if (((month == 3) && ((hour + 24 * day) >= (1 + tzHours + 24 * (31 - (5 * year / 4 + 4) % 7))))
      || ((month == 10) && ((hour + 24 * day) < (1 + tzHours + 24 * (31 - (5 * year / 4 + 1) % 7)))))
        return true;
    else
        return false;
}


/*
teme2ecef

This function transforms a vector from a true equator mean equinox (TEME)
frame to an earth-centered, earth-fixed (ECEF) frame.

Author: <NAME>, 2007
Ported to C++ by <NAME> with some modifications, July 2015.

INPUTS          DESCRIPTION                     RANGE/UNITS
rteme           Position vector (TEME)          km
vteme           Velocity vector (TEME)          km/s
jdut1           Julian date                     days

OUTPUTS         DESCRIPTION                     RANGE/UNITS
recef           Position vector (ECEF)          km
vecef           Velocity vector (ECEF)          km/s
*/
void teme2ecef(double rteme[3], double jdut1, double recef[3])
{
    double gmst;
    double st[3][3];
    double rpef[3];
    double pm[3][3];
    
    //Get Greenwich mean sidereal time
    gmst = gstime(jdut1);
    
    //st is the pef - tod matrix
    st[0][0] = cos(gmst);
    st[0][1] = -sin(gmst);
    st[0][2] = 0.0;
    st[1][0] = sin(gmst);
    st[1][1] = cos(gmst);
    st[1][2] = 0.0;
    st[2][0] = 0.0;
    st[2][1] = 0.0;
    st[2][2] = 1.0;
    
    //Get pseudo earth fixed position vector by multiplying the inverse pef-tod matrix by rteme
    rpef[0] = st[0][0] * rteme[0] + st[1][0] * rteme[1] + st[2][0] * rteme[2];
    rpef[1] = st[0][1] * rteme[0] + st[1][1] * rteme[1] + st[2][1] * rteme[2];
    rpef[2] = st[0][2] * rteme[0] + st[1][2] * rteme[1] + st[2][2] * rteme[2];
    
    //Get polar motion vector
    polarm(jdut1, pm);
    
    //ECEF postion vector is the inverse of the polar motion vector multiplied by rpef
    recef[0] = pm[0][0] * rpef[0] + pm[1][0] * rpef[1] + pm[2][0] * rpef[2];
    recef[1] = pm[0][1] * rpef[0] + pm[1][1] * rpef[1] + pm[2][1] * rpef[2];
    recef[2] = pm[0][2] * rpef[0] + pm[1][2] * rpef[1] + pm[2][2] * rpef[2];
    
    //Earth's angular rotation vector (omega)
    //Note: I don't have a good source for LOD. Historically it has been on the order of 2 ms so I'm just using that as a constant. The effect is very small.
    //omegaearth[0] = 0.0;
    //omegaearth[1] = 0.0;
    //omegaearth[2] = 7.29211514670698e-05 * (1.0  - 0.0015563/86400.0);
    
    //Pseudo Earth Fixed velocity vector is st'*vteme - omegaearth X rpef
    //vpef[0] = st[0][0] * vteme[0] + st[1][0] * vteme[1] + st[2][0] * vteme[2] - (omegaearth[1]*rpef[2] - omegaearth[2]*rpef[1]);
    //vpef[1] = st[0][1] * vteme[0] + st[1][1] * vteme[1] + st[2][1] * vteme[2] - (omegaearth[2]*rpef[0] - omegaearth[0]*rpef[2]);
    //vpef[2] = st[0][2] * vteme[0] + st[1][2] * vteme[1] + st[2][2] * vteme[2] - (omegaearth[0]*rpef[1] - omegaearth[1]*rpef[0]);
    
    //ECEF velocty vector is the inverse of the polar motion vector multiplied by vpef
    //vecef[0] = pm[0][0] * vpef[0] + pm[1][0] * vpef[1] + pm[2][0] * vpef[2];
    //vecef[1] = pm[0][1] * vpef[0] + pm[1][1] * vpef[1] + pm[2][1] * vpef[2];
    //vecef[2] = pm[0][2] * vpef[0] + pm[1][2] * vpef[1] + pm[2][2] * vpef[2];
}

void teme2ecefOptimised(double rteme[3], double jdut1, double gmstCos, double gmstSin, double recef[3])
{
    double st[3][3];
    double rpef[3];
    double pm[3][3];
    

    //st is the pef - tod matrix
    st[0][0] = gmstCos;
    st[0][1] = -gmstSin;
    st[0][2] = 0.0;
    st[1][0] = gmstSin;
    st[1][1] = gmstCos;
    st[1][2] = 0.0;
    st[2][0] = 0.0;
    st[2][1] = 0.0;
    st[2][2] = 1.0;
    
    //Get pseudo earth fixed position vector by multiplying the inverse pef-tod matrix by rteme
    rpef[0] = st[0][0] * rteme[0] + st[1][0] * rteme[1] + st[2][0] * rteme[2];
    rpef[1] = st[0][1] * rteme[0] + st[1][1] * rteme[1] + st[2][1] * rteme[2];
    rpef[2] = st[0][2] * rteme[0] + st[1][2] * rteme[1] + st[2][2] * rteme[2];
    
    //Get polar motion vector
    polarm(jdut1, pm);
    
    //ECEF postion vector is the inverse of the polar motion vector multiplied by rpef
    recef[0] = pm[0][0] * rpef[0] + pm[1][0] * rpef[1] + pm[2][0] * rpef[2];
    recef[1] = pm[0][1] * rpef[0] + pm[1][1] * rpef[1] + pm[2][1] * rpef[2];
    recef[2] = pm[0][2] * rpef[0] + pm[1][2] * rpef[1] + pm[2][2] * rpef[2];
    
    //Earth's angular rotation vector (omega)
    //Note: I don't have a good source for LOD. Historically it has been on the order of 2 ms so I'm just using that as a constant. The effect is very small.
    //omegaearth[0] = 0.0;
    //omegaearth[1] = 0.0;
    //omegaearth[2] = 7.29211514670698e-05 * (1.0  - 0.0015563/86400.0);
    
    //Pseudo Earth Fixed velocity vector is st'*vteme - omegaearth X rpef
    //vpef[0] = st[0][0] * vteme[0] + st[1][0] * vteme[1] + st[2][0] * vteme[2] - (omegaearth[1]*rpef[2] - omegaearth[2]*rpef[1]);
    //vpef[1] = st[0][1] * vteme[0] + st[1][1] * vteme[1] + st[2][1] * vteme[2] - (omegaearth[2]*rpef[0] - omegaearth[0]*rpef[2]);
    //vpef[2] = st[0][2] * vteme[0] + st[1][2] * vteme[1] + st[2][2] * vteme[2] - (omegaearth[0]*rpef[1] - omegaearth[1]*rpef[0]);
    
    //ECEF velocty vector is the inverse of the polar motion vector multiplied by vpef
    //vecef[0] = pm[0][0] * vpef[0] + pm[1][0] * vpef[1] + pm[2][0] * vpef[2];
    //vecef[1] = pm[0][1] * vpef[0] + pm[1][1] * vpef[1] + pm[2][1] * vpef[2];
    //vecef[2] = pm[0][2] * vpef[0] + pm[1][2] * vpef[1] + pm[2][2] * vpef[2];
}

/*
polarm

This function calculates the transformation matrix that accounts for polar
motion. Polar motion coordinates are estimated using IERS Bulletin
rather than directly input for simplicity.

Author: <NAME>, 2007
Ported to C++ by <NAME> with some modifications, July 2015.

INPUTS          DESCRIPTION                     RANGE/UNITS
jdut1           Julian date                     days

OUTPUTS         DESCRIPTION
pm              Transformation matrix for ECEF - PEF
*/

void polarm(double jdut1, double pm[3][3])
{
    double MJD; //Julian Date - 2,400,000.5 days
    double A;
    double C;
    double xp; //Polar motion coefficient in radians
    double yp; //Polar motion coefficient in radians
    
    //Predict polar motion coefficients using IERS Bulletin - A (Vol. XXVIII No. 030)
    MJD = jdut1 - 2400000.5;
    A = 2 * pi * (MJD - 57226) / 365.25;
    C = 2 * pi * (MJD - 57226) / 435;
    
    xp = (0.1033 + 0.0494*cos(A) + 0.0482*sin(A) + 0.0297*cos(C) + 0.0307*sin(C)) * 4.84813681e-6;
    yp = (0.3498 + 0.0441*cos(A) - 0.0393*sin(A) + 0.0307*cos(C) - 0.0297*sin(C)) * 4.84813681e-6;
    
    pm[0][0] = cos(xp);
    pm[0][1] = 0.0;
    pm[0][2] = -sin(xp);
    pm[1][0] = sin(xp) * sin(yp);
    pm[1][1] = cos(yp);
    pm[1][2] = cos(xp) * sin(yp);
    pm[2][0] = sin(xp) * cos(yp);
    pm[2][1] = -sin(yp);
    pm[2][2] = cos(xp) * cos(yp);
}

/*
ijk2ll

This function calulates the latitude, longitude and altitude
given the ECEF position matrix.

Author: <NAME>, 2007
Ported to C++ by <NAME> with some modifications, July 2015.

INPUTS          DESCRIPTION                     RANGE/UNITS
r               Position matrix (ECEF)          km

OUTPUTS         DESCRIPTION
latlongh        Latitude, longitude, and altitude (rad, rad, and km)
*/

void ijk2ll(double r[3], double latlongh[3])
{
    double twopi = 2.0*pi;
    double small = 0.00000001;          //small value for tolerances
    double re = 6378.137;               //radius of earth in km
    double eesqrd = 0.006694385000;     //eccentricity of earth sqrd
    double magr, temp, rtasc;
    
    magr = mag(r);
    temp = sqrt(r[0]*r[0] + r[1]*r[1]);
 
    if(fabs(temp) < small)
    {
        rtasc = sgn(r[2]) * pi * 0.5;
    }
    else
    {
        rtasc = atan2(r[1], r[0]);
    }
    
    latlongh[1] = rtasc;
    
    if (fabs(latlongh[1]) >= pi)
    {
        if (latlongh[1] < 0.0)
        {
            latlongh[1] += twopi;
        }
        else
        {
            latlongh[1] -= twopi;
        }
    }
    
    latlongh[0] = asin(r[2] / magr);
    
    //Iterate to find geodetic latitude
    int i = 1;
    double olddelta = latlongh[0] + 10.0;
    double sintemp, c = 0;
    
    while ( (fabs(olddelta - latlongh[0]) >= small) && (i < 10) )
    {
        olddelta = latlongh[0];
        sintemp = sin(latlongh[0]);
        c = re / sqrt(1.0 - eesqrd*sintemp*sintemp);
        latlongh[0] = atan( (r[2] + c*eesqrd*sintemp) / temp );
        i++;
    }
    
    if (0.5*pi - fabs(latlongh[0]) > pi/180.0)
    {
        latlongh[2] = (temp/cos(latlongh[0])) - c;
    }
    else
    {
        latlongh[2] = r[2]/sin(latlongh[0]) - c*(1.0 - eesqrd);
    }
}

/*
site

This function finds the position and velocity vectors for a site. The
outputs are in the ECEF coordinate system. Note that the velocity vector
is zero because the coordinate system rotates with the earth.

Author: <NAME>, 2007
Ported to C++ by <NAME> with some modifications, July 2015.

INPUTS          DESCRIPTION                     RANGE/UNITS
latgd           Site geodetic latitude          -pi/2 to pi/2 in radians
lon             Longitude                       -2pi to 2pi in radians
alt             Site altitude                   km

OUTPUTS         DESCRIPTION
rs              Site position vector            km
vs              Site velocity vector            km/s
*/

//void site(double latgd, double lon, double alt, double rs[3], double vs[3])
void site(double latgd, double lon, double alt, double rs[3])
{
    double sinlat, re, eesqrd, cearth, rdel, rk;
    re = 6378.137;              //radius of earth in km
    eesqrd = 0.006694385000;    //eccentricity of earth sqrd
    
    //Find rdel and rk components of site vector
    sinlat = sin(latgd);
    cearth = re / sqrt( 1.0 - (eesqrd*sinlat*sinlat) );
    rdel = (cearth + alt) * cos(latgd);
    rk = ((1.0 - eesqrd) * cearth + alt ) * sinlat;
    
    //Find site position vector (ECEF)
    rs[0] = rdel * cos( lon );
    rs[1] = rdel * sin( lon );
    rs[2] = rk;
    
    //Velocity of site is zero because the coordinate system is rotating with the earth
    //vs[0] = 0.0;
    //vs[1] = 0.0;
    //vs[2] = 0.0;
}


/*
rv2azel

This function calculates the range, elevation, and azimuth (and their rates)
from the TEME vectors output by the SGP4 function.

Author: <NAME>, 2007
Ported to C++ by <NAME> with some modifications, July 2015.

INPUTS          DESCRIPTION                     RANGE/UNITS
ro              Sat. position vector (TEME)     km
vo              Sat. velocity vector (TEME)     km/s
latgd           Site geodetic latitude          -pi/2 to pi/2 in radians
lon             Site longitude                  -2pi to 2pi in radians
alt             Site altitude                   km
jdut1           Julian date                     days

OUTPUTS         DESCRIPTION
razel           Range, azimuth, and elevation matrix
razelrates      Range rate, azimuth rate, and elevation rate matrix
*/

//void rv2azel(double ro[3], double vo[3], double latgd, double lon, double alt, double jdut1, double razel[3], double razelrates[3])
void rv2azel(double ro[3], double latgd, double lon, double alt, double jdut1, double razel[3])
{
    //Locals
    double halfpi = pi * 0.5;
    double small  = 0.00000001;
    double temp;
    double rs[3];
    //double vs[3];
    double recef[3];
    //double vecef[3];
    double rhoecef[3];
    //double drhoecef[3];
    double tempvec[3];
    double rhosez[3];
    //double drhosez[3];
    double magrhosez;
    double rho, az, el;
    //double drho, daz, del;
    
    //Get site vector in ECEF coordinate system
    //site(latgd, lon, alt, rs, vs);
    site(latgd, lon, alt, rs);
    
    //Convert TEME vectors to ECEF coordinate system
    //teme2ecef(ro, vo, jdut1, recef, vecef);
    teme2ecef(ro, jdut1, recef);
    
    //Find ECEF range vectors
    for (int i = 0; i < 3; i++)
    {
        rhoecef[i] = recef[i] - rs[i];
        //drhoecef[i] = vecef[i];
    }
    rho = mag(rhoecef); //Range in km
    
    //Convert to SEZ (topocentric horizon coordinate system)
    rot3(rhoecef, lon, tempvec);
    rot2(tempvec, (halfpi-latgd), rhosez);
    
    //rot3(drhoecef, lon, tempvec);
    //rot2(tempvec, (halfpi-latgd), drhosez);
    
    //Calculate azimuth, and elevation
    temp = sqrt(rhosez[0]*rhosez[0] + rhosez[1]*rhosez[1]);
    if (temp < small)
    {
        el = sgn(rhosez[2]) * halfpi;
        //az = atan2(drhosez[1], -drhosez[0]);
        az = NAN;
    }
    else
    {
        magrhosez = mag(rhosez);
        el = asin(rhosez[2]/magrhosez);
        az = atan2(rhosez[1], -rhosez[0]);
    }
    
    //Calculate rates for range, azimuth, and elevation
    /**
    drho = dot(rhosez,drhosez) / rho;
    
    if(fabs(temp*temp) > small)
    {
        daz = (drhosez[0]*rhosez[1] - drhosez[1]*rhosez[0]) / (temp * temp);
    }
    else
    {
        daz = 0.0;
    }
    
    if(fabs(temp) > small)
    {
        del = (drhosez[2] - drho*sin(el)) / temp;
    }
    else
    {
        del = 0.0;
    }
    ***/
    //Move values to output vectors
    razel[0] = rho;             //Range (km)
    razel[1] = az;              //Azimuth (radians)
    razel[2] = el;              //Elevation (radians)
    
    //razelrates[0] = drho;       //Range rate (km/s)
    //razelrates[1] = daz;        //Azimuth rate (rad/s)
    //razelrates[2] = del;        //Elevation rate (rad/s)
}

void rot3(double invec[3], double xval, double outvec[3])
{
    double temp = invec[1];
    double c = cos(xval);
    double s = sin(xval);
    
    outvec[1] = c*invec[1] - s*invec[0];
    outvec[0] = c*invec[0] + s*temp;
    outvec[2] = invec[2];
}

void rot2(double invec[3], double xval, double outvec[3])
{
    double temp = invec[2];
    double c = cos(xval);
    double s = sin(xval);
    
    outvec[2] = c*invec[2] + s*invec[0];
    outvec[0] = c*invec[0] - s*temp;
    outvec[1] = invec[1];
}

/*
getJulianFromUnix

returns the Julian Date from Unix Time
*/

double getJulianFromUnix(double unixSecs)
{
   return ( unixSecs / 86400.0 ) + 2440587.5;
}


unsigned long getUnixFromJulian(double julian)
{
    return (unsigned long)((julian - 2440587.5)*86400.0 + 0.5);
}
",delmotemp
836,"/**
 * @file main.cpp
 * @date 12/7/2022
 *
 * @brief MapApp program
 */

#include <QGuiApplication>
#include <QQmlApplicationEngine>

#include <QLocale>
#include <QTranslator>

#include ""gridmap.h""

int main(int argc, char *argv[])
{
    // registering needs to be called before QGuiApplication!
    qmlRegisterType<GridMap>(""mapapp.gridmap"", 1, 0, ""GridMap"");
    QGuiApplication app(argc, argv);

    QTranslator translator;
    const QStringList uiLanguages = QLocale::system().uiLanguages();
    for (const QString &locale : uiLanguages) {
        const QString baseName = ""map-app_"" + QLocale(locale).name();
        if (translator.load("":/i18n/"" + baseName)) {
            app.installTranslator(&translator);
            break;
        }
    }

    QQmlApplicationEngine  [MASK] ;
    const QUrl url(u""qrc:/map-app/main.qml""_qs);
    QObject::connect(& [MASK] , &QQmlApplicationEngine::objectCreated,
                     &app, [url](QObject *obj, const QUrl &objUrl) {
        if (!obj && url == objUrl)
            QCoreApplication::exit(-1);
    }, Qt::QueuedConnection);
     [MASK] .load(url);

    return app.exec();
}
",engine
837,"//
// Convex Hull Trick
//
// verified
//   COLOCON 2018 Final C - スペースエクスプローラー高橋君
//     https://beta.atcoder.jp/contests/colopl2018-final-open/tasks/colopl2018_final_c
//


#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
using namespace std;


// Convex Hull Trick
/*
    直線の傾きに単調性を仮定しない
    - MIN: クエリ x の取りうる最小値
    - MAX: クエリ x の取りうる最大値
    - INF: 最大値
 
    - insert (a, b): add y = ax + b
    - query (x): min_i{ l_i->get(x) }
*/
template<class T> struct CHT {
    struct Line {
        T a, b;
        Line(T a = 0,T b = 0) : a(a), b(b) { }
        T get(T x) {
            return a*x + b;
        }
    };
    
    struct Node {
        Line line;
        Node *left, *right;
        Node(Line line) : line(line), left(nullptr), right(nullptr){}
    };
    
    const T MIN, MAX, INF;
    Node* root;
    
    CHT(T MIN, T MAX, T INF) : MIN(MIN), MAX(MAX), INF(INF), root(nullptr) { }
    Node* insert(Node* p, T low, T high, Line& l){
        if(!p) return new Node(l);
        if (p->line.get(low) <= l.get(low) && p->line.get(high) <= l.get(high)) return p;
        if (p->line.get(low) >= l.get(low) && p->line.get(high) >= l.get(high)) {
            p->line = l;
            return p;
        }
        T mid = (low + high) / 2;
        if (p->line.get(mid) > l.get(mid)) swap(p->line , l);
        if (p->line.get(low) >= l.get(low)) p->left = insert(p->left, low, mid, l);
        else p->right = insert(p->right, mid, high, l);
        return p;      
    }
    void insert(T a, T b){
        Line l(a, b);
        root = insert(root, MIN, MAX, l);
    }
    T query(Node* p, T low, T high, T x){
        if(!p) return INF;
        if(low == high) return p->line.get(x);
        T mid = (low + high) / 2;
        if (x <= mid) return min(p->line.get(x), query(p->left, low, mid, x));
        else return min(p->line.get(x), query(p->right, mid, high, x));
    }
    T query(T x){
        return query(root, MIN, MAX, x);
    }
};


int main() {
    long long N; cin >> N;
    vector<long long> a(N), res(N);
    for (int i = 0; i < N; ++i) cin >> a[i];
    CHT<long long>  [MASK] (0, 210000, 1LL<<60);
    for (long long i = 0; i < N; ++i)  [MASK] .insert(-2LL*i, a[i] + i*i);
    for (long long i = 0; i < N; ++i) res[i] =  [MASK] .query(i) + i*i;
    for (int i = 0; i < N; ++i) cout << res[i] << endl;
}
",cht
838,"#include <vector>
#include <iostream>
#include <math.h>
#include <chrono>
#include <thread>
using namespace std;

bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;
    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i += 6)
    {
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }
    return true;
}

class Timer
{
public:
    Timer()
    {
        start = chrono::high_resolution_clock::now();
    }
    ~Timer()
    {
        chrono::time_point<chrono::high_resolution_clock> end = chrono::high_resolution_clock::now();
        ;

        printf(""Time %d\n"", chrono::duration_cast<chrono::nanoseconds>(end - start));
    }

protected:
    chrono::time_point<chrono::high_resolution_clock> start;
};



int main()
{
    vector<int>  [MASK] (5000);
    {
        Timer t;
        for (int i = 0; i < 5000; ++i)
        {
            if (isPrime(i))
            {
                 [MASK] .push_back(i);

            }
        }
    }


    printf(""done\n"");
    return 0;
}",primes
839,"// Copyright 2021
//
// 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.
//
// Authors: <NAME>


#include <chrono>
#include <cstdio>
#include <memory>
#include <string>

#include ""ros2_camera/picam_streamer.hpp""

using namespace camera;
using namespace std::chrono_literals;


Streamer::Streamer() : 
      Node(""picam_streamer"")
{

  RCLCPP_INFO(this->get_logger(), ""Picam streamer ON"");

  this->declare_parameter(""configuration.cap_width"");
  this->declare_parameter(""configuration.cap_height"");
  this->declare_parameter(""configuration.fame_id"");
  this->declare_parameter(""configuration.camera_name"");
  this->declare_parameter(""configuration.width"");
  this->declare_parameter(""configuration.height"");
  this->declare_parameter(""configuration.framerate"");
  this->declare_parameter(""configuration.flip_mode"");
  this->declare_parameter(""configuration.camera_calibration_file"");

  this->get_parameter_or<int>(""configuration.cap_width"", configuration_.cap_width, 1280);
  this->get_parameter_or<int>(""configuration.cap_height"", configuration_.cap_height, 720);
  this->get_parameter_or<std::string>(""configuration.frame_id"", configuration_.frame_id, ""camera"");
  this->get_parameter_or<std::string>(""configuration.camera_name"", configuration_.camera_name, ""raspicam"");
  this->get_parameter_or<int>(""configuration.display_width"", configuration_.display_width, 640);
  this->get_parameter_or<int>(""configuration.display_height"", configuration_.display_height, 480);
  this->get_parameter_or<double>(""configuration.framerate"", configuration_.framerate, 90);
  this->get_parameter_or<int>(""configuration.flip_mode"", configuration_.flip_mode, 2);
  this->get_parameter_or<std::string>(""configuration.camera_calibration_file"", configuration_.camera_calibration_file, ""package://ros2_camera/config/picam_calibration.yaml"");

  // Image transport publisher
  camera_transport_pub_ = image_transport::create_camera_publisher(this, ""/image_raw"");
  
  // Set camera configuration
  cinfo_manager_ = std::make_shared<camera_info_manager::CameraInfoManager>(this, configuration_.camera_name, configuration_.camera_calibration_file);
 
  // Get pipeline
  std::string pipeline = gstreamer_pipeline(configuration_.cap_width,
                                            configuration_.cap_height,
                                            configuration_.display_width, 
                                            configuration_.display_height, 
                                            configuration_.framerate, 
                                            configuration_.flip_mode);

  // Capture video using gstreamer
  cap = cv::VideoCapture(pipeline, cv::CAP_GSTREAMER);

  // Timer to imageCallback
  last_frame_ = std::chrono::steady_clock::now();
  timer_ = this->create_wall_timer(1ms, std::bind(&Streamer::ImageCallback, this));
}

// gstreamer as tested on ros2_camera/bash/local.sh
std::string Streamer::gstreamer_pipeline (int capture_width, int  [MASK] , int display_width, int display_height, int framerate, int flip_method)
{
    return ""nvarguscamerasrc sensor_id=0 ! video/x-raw(memory:NVMM), width=(int)"" + std::to_string(capture_width) + "", height=(int)"" +
            std::to_string( [MASK] ) + "", format=(string)NV12, framerate=(fraction)"" + std::to_string(framerate) +
            ""/1 ! nvvidconv flip-method="" + std::to_string(flip_method) + "" ! video/x-raw, width=(int)"" + std::to_string(display_width) + "", height=(int)"" +
            std::to_string(display_height) + "", format=(string)BGRx ! videoconvert ! video/x-raw, format=(string)BGR ! appsink"";
}

void Streamer::ImageCallback()
{
    // Frame
    cap >> frame;
    
    auto now = std::chrono::steady_clock::now();

    if (!frame.empty() &&
        std::chrono::duration_cast<std::chrono::milliseconds>(now - last_frame_).count() > 1/configuration_.framerate*1000)
    {
        last_frame_ = now;

        // Convert to a ROS2 image
        if (configuration_.flip_mode == 0)
        {
            // Flip the frame if needed
            cv::flip(frame, flipped_frame, 1);
        }

        std_msgs::msg::Header header_;
        sensor_msgs::msg::Image ros_image;

        // Make sure output in the size the user wants even if it is not native
        if(frame.rows != configuration_.display_width || frame.cols != configuration_.display_height){
            cv::resize(frame, frame, cv::Size(configuration_.display_width, configuration_.display_height));
        }

        /* To remove CV-bridge and boost-python3 dependencies, this is pretty much a copy of the toImageMsg method in cv_bridge. */
        ros_image.header = header_;
        ros_image.height = frame.rows;
        ros_image.width = frame.cols;
        ros_image.encoding = ""bgr8"";
        ros_image.is_bigendian = false;
        ros_image.step = frame.cols * frame.elemSize();
        size_t size = ros_image.step * frame.rows;
        ros_image.data.resize(size);

        if (frame.isContinuous())
        {
            memcpy(reinterpret_cast<char *>(&ros_image.data[0]), frame.data, size);
        }
        else
        {
            // Copy by row by row
            uchar *ros_data_ptr = reinterpret_cast<uchar *>(&ros_image.data[0]);
            uchar *cv_data_ptr = frame.data;
            for (int i = 0; i < frame.rows; ++i)
            {
                memcpy(ros_data_ptr, cv_data_ptr, ros_image.step);
                ros_data_ptr += ros_image.step;
                cv_data_ptr += frame.step;
            }
        }

        image_msg_ = std::make_shared<sensor_msgs::msg::Image>(ros_image);

        // Put the message into a queue to be processed by the middleware.
        // This call is non-blocking.
        sensor_msgs::msg::CameraInfo::SharedPtr camera_info_(
            new sensor_msgs::msg::CameraInfo(cinfo_manager_->getCameraInfo()));

        rclcpp::Time timestamp = this->get_clock()->now();

        // Publish image and camera info
        image_msg_->header.stamp = timestamp;
        image_msg_->header.frame_id = configuration_.frame_id;
        camera_info_->header.stamp = timestamp;
        camera_info_->header.frame_id = configuration_.frame_id;
        camera_transport_pub_.publish(image_msg_, camera_info_);

    }

}

/*****************************************************************************
** Main
*****************************************************************************/
int main(int argc, char *argv[])
{
  rclcpp::init(argc, argv);
  rclcpp::spin(std::make_shared<camera::Streamer>());
  rclcpp::shutdown();

  return 0;
}
",capture_height
840,"#include ""Joint/modules/Window.h""
#include <iostream>
#include ""Joint/core/Application.h""

namespace Joint {

    Window::Window(int width, int  [MASK] , const char* title)
        : window{nullptr } {
        static bool glfwInitialized{ false };

        // Initialize GLFW
        if (!glfwInitialized) {
            glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
            glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
            glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

            if (__APPLE__)
                glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

            if (!glfwInit())
                std::cout << ""Failed to initialize glfw!\n""; // TODO: assertion

            glfwInitialized = true;
        }

        // Create window
        window = glfwCreateWindow(width,  [MASK] , title, nullptr, nullptr);

        if (!window)
            std::cout << ""Failed to create a window!\n""; // TODO: assertion

        glfwMakeContextCurrent(window);

        if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress))
            std::cout << ""Failed to initialize glad!\n""; // TODO: assertion
    }

    Window::~Window() {
        glfwDestroyWindow(window);
        glfwTerminate(); // TODO: Call this in the last module of the engine
    }

    void Window::OnStartUp() {
        std::cout << ""Window created!\n"";
    }

    void Window::OnUpdate() {
        OnInput();
        std::cout << ""Updating window!\n"";
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    void Window::OnShutDown() {
        std::cout << ""Window destroyed!\n"";
    }

    void Window::OnInput() {
        if (glfwWindowShouldClose(window)) {
            Application::IsRunning(false);
        }

        if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
            glfwSetWindowShouldClose(window, true);
            Application::IsRunning(false);
        }
    }

}",height
841,"/*
 
NonBlockingBreathingLed 0.1
by <NAME> - 2015
edited by CodingSpiderFox 2017-10-28
12 May 2015
http://www.arduinoelettronica.com/
https://arduinoelectronics.wordpress.com/
http://minibianpi.wodpress.com/
 
Use a exp + sin function to recreate a
non-blocking breathing led effect
 
Released under GPL v.2 license

*/
#include <WiFiClientSecure.h>
#include <WiFiClient.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include ""TimerObject.h""

TimerObject *timer3 = new TimerObject(500);
TimerObject *everySec = new TimerObject(1000);

//MQTT related
const char* ssid = ""berlin.freifunk.net"";
const char* password = """";
const char* mqtt_server = ""10.230.145.13"";
const char* mqtt_userName = ""SCLight"";
const char* mqtt_password = ""<PASSWORD>"";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;
int timeout = 200;

#define BRIGHT    300     //max led intensity (1-500)
#define INHALE    1250    //Inhalation time in milliseconds.
#define PULSE     INHALE*1000/BRIGHT
#define REST      1000    //Rest Between Inhalations.
#define MOTIONSENSOR D4
#define ledPin D8

int i=0;
int breathe_delay = 15, message_delay = 200;   // delay between loops
unsigned long breathe_time = millis();
unsigned long message_time = millis();

void sendMQTTMessage() {
  ++value;
  snprintf(msg, 175, ""hello worldAAAAsaaawo#%ld"", value);
  
  Serial.print(""Publish message: "");
  Serial.println(msg);
  client.publish(""outTopic"", msg);
}

void setup_wifi() {
  Serial.print(""Connecting to "");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(""."");
  }

  Serial.println("""");
  Serial.println(""WiFi connected"");
  Serial.println(""IP address: "");
  Serial.println(WiFi.localIP()); 
}

void reconnect_mqtt() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print(""Attempting MQTT connection..."");
    // Attempt to connect
    if (client.connect(""SmartClockLight"", mqtt_userName, mqtt_password)) {
      Serial.println(""connected"");
      // Once connected, publish an announcement...
      client.publish(""outSCLight"", ""hello world"");
      // ... and resubscribe
      client.subscribe(""inSCLight"");
    }
    else {
      Serial.print(""failed, rc="");
      Serial.print(client.state());
      Serial.println("" try again in 5 seconds"");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void everySecFunc() {

}

void setup()
{
  Serial.begin(115200);
  
  pinMode(ledPin, OUTPUT);   // LED pin as output.
  pinMode(MOTIONSENSOR, INPUT);
  
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  Serial.println(""Start task1"");
  timer3->setOnTimer(&sendMQTTMessage);
  timer3->Start();

  everySec->setOnTimer(&everySecFunc);
  everySec->Start();
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print(""Message arrived ["");
  Serial.print(topic);
  Serial.print(""] "");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  /* Switch on the LED if an 1 was received as first character
  Serial.print((char)payload[0]);
  if ((char)payload[0] == '1') {
    digitalWrite(LEDPIN, LOW);   // Turn the LED on (Note that LOW is the voltage level
                      // but actually the LED is on; this is because
                      // it is acive low on the ESP-01)
  }
  else {
    digitalWrite(LEDPIN, HIGH);  // Turn the LED off by making the voltage HIGH
  }
  */
}

bool CheckKey(byte  [MASK] , byte num){ //0, 1, 2, 3
  return  [MASK]  & (1 << num);
}


void handleInterrupt () {
   if( (message_time + message_delay) < millis() ){
     message_time = millis();
     Serial.println(""handleInterrupt"");
   }

  timer3->Update();
  everySec->Update();
}
 
void loop()
{
  handleInterrupt();

  if (!client.connected()) {
    reconnect_mqtt();
  }
  
  client.loop();
  
  nonBlockingBreath();  // call the nonblocking function
  // yourOtherCodeHere();
}
 
void nonBlockingBreath()
{
  if( (breathe_time + breathe_delay) < millis() ){
    breathe_time = millis();
    float val = (exp(sin(i/2000.0*PI*10)) - 0.36787944)*108.0; 
    // this is the math function recreating the effect
    analogWrite(ledPin, val);  // PWM
    i=i+1;
    handleInterrupt();
  }
  handleInterrupt();
}
",key
842,"#include <iostream>
#include <priority_queue.hpp>
#include <timer.h>
#include <types.h>

int main() {
    yb::PriorityQueue<yb::TimerEvent, yb::TimerEvent::ComparatorAsc> queue;

    yb::TimerEvent data(false, 3_s,std::bind([](int i) {
        std::cout << ""Function with int parameter: "" << i << std::endl;
    }, 10));


    yb::TimerEvent data2(false, 5_s,std::bind([](float i) {
        std::cout << ""Function with float  parameter: "" << i << std::endl;
    }, 10));


    yb::TimerEvent data3(false, 1_s,std::bind([](double i) {
        std::cout << ""Function with double  parameter: "" << i << std::endl;
    }, 10));

    yb::TimerEvent data4(false, 0_s,std::bind([](char x) {
        std::cout << ""Function with char  parameter: "" << x << std::endl;
    }, 'a'));

    yb::TimerEvent  [MASK] (false, 0_s,std::bind([](char x, int z, double b) {
        std::cout << ""Function with char  parameter: "" << x << z << b << std::endl;
    }, 'a', 3, 5.2));

    queue.emplace(std::move(data));
    queue.emplace(std::move(data2));
    queue.emplace(std::move(data3));
    queue.emplace(std::move(data4));
    queue.emplace(std::move( [MASK] ));

    queue.emplace(yb::TimerEvent{false, 30_s,std::bind([](char x, int z, double b) {
        std::cout << ""Function with prvalue"";
    }, 'a', 3, 5.2)});

    /*
    yb::types::TimerEvent> ndata(std::move(*x), 3, true, 3_s, z);
    int *y = new int(32);
    yb::types::TimerEvent  ndata2(std::move(*y), 3, true, 3_s, z);

    queue.emplace(std::move(ndata));
    queue.emplace(std::move(ndata2));

    */

    queue[0].invokeCallBack();
    queue[1].invokeCallBack();
    queue[5].invokeCallBack();

    std::cout << ""HELLO WORLD !"";
    return 0;
}
",data5
843,"#include <initializer_list>
#include <iostream>
#include <memory>
#include <utility>

template <typename tkey, typename tvalue>
class BinarySearchTree {
   public:
    class BinarySearchTreeNode {
       public:
        BinarySearchTreeNode(tkey key, tvalue value)
            : key_(key), value_(value), left_(nullptr), right_(nullptr) {}

        ~BinarySearchTreeNode() {
            std::cout << ""Destructed node with key "" << key_ << "" ""
                      << "" value "" << value_ << std::endl;
        }

        tkey getKey() { return key_; }
        tvalue getValue() { return value_; }
        std::unique_ptr<BinarySearchTreeNode>& getLeft() { return left_; }
        std::unique_ptr<BinarySearchTreeNode>& getRight() { return right_; }

       private:
        tkey key_;
        tvalue value_;
        std::unique_ptr<BinarySearchTreeNode> left_;
        std::unique_ptr<BinarySearchTreeNode> right_;
    };
    using Node = BinarySearchTreeNode;

   public:
    BinarySearchTree() : root_(nullptr) {}

    BinarySearchTree(std::initializer_list<std::pair<tkey, tvalue>> init_list)
        : root_(nullptr) {
        const std::pair<tkey, tvalue>* it = init_list.begin();
        const std::pair<tkey, tvalue>* const end = init_list.end();
        for (; it != end; ++it) {
            addNode(it->first, it->second);
        }
    }

    void addNode(tkey key, tvalue value) {
        if (!root_) {
            root_ = std::make_unique<Node>(key, value);
            return;
        }

        addNode(key, value, root_.get());
    }

    Node* searchNode(tkey key) {
        if (!root_) {
            std::cout << ""Tree empty"" << std::endl;
            return nullptr;
        }

        return searchNode(key, root_.get());
    }

    void showNode(Node* node) const {
        if (node) {
            std::cout << ""Node with key "" << node->getKey() << "" and value ""
                      << node->getValue() << std::endl;
        } else {
            std::cout << ""Node empty."" << std::endl;
        }
    }

    void printPreOrder() {
        if (!root_) {
            std::cout << ""Tree empty."" << std::endl;
            return;
        }
        printPreOrder(root_.get());
    }

    void printInOrder() {
        if (!root_) {
            std::cout << ""Tree empty."" << std::endl;
            return;
        }
        printInOrder(root_.get());
    }

   private:
    void addNode(tkey key, tvalue value, Node* node) {
        if (key > node->getKey()) {
            if (!node->getRight()) {
                node->getRight() = std::make_unique<Node>(key, value);
            } else {
                addNode(key, value, node->getRight().get());
            }
        } else {
            if (!node->getLeft()) {
                node->getLeft() = std::make_unique<Node>(key, value);
            } else {
                addNode(key, value, node->getLeft().get());
            }
        }
    }

    Node* searchNode(tkey key, Node* node) {
        if (node) {
            if (key == node->getKey()) {
                return node;
            } else if (key > node->getKey()) {
                if (node->getRight()) {
                    return searchNode(key, node->getRight().get());
                }
            } else {
                if (node->getLeft()) {
                    return searchNode(key, node->getLeft().get());
                }
            }
        } else {
            return nullptr;
        }
    }

    void printPreOrder(Node* node) {
        if (node) {
            std::cout << ""Key -> "" << node->getKey() << "" Value -> ""
                      << node->getValue() << std::endl;
            printPreOrder(node->getLeft().get());
            printPreOrder(node->getRight().get());
        }
    }

    void printInOrder(Node* node) {
        if (node) {
            printInOrder(node->getLeft().get());
            std::cout << ""Key -> "" << node->getKey() << "" Value -> ""
                      << node->getValue() << std::endl;
            printInOrder(node->getRight().get());
        }
    }

    std::unique_ptr<Node> root_;
};

int main(int argc, char** argv) {
    BinarySearchTree<int, int> bst;
    bst.addNode(1, 21);
    bst.addNode(5, 22);
    bst.addNode(3, 23);
    bst.addNode(30, 24);
    bst.addNode(7, 25);
    bst.addNode(17, 26);
    bst.addNode(800, 27);
    bst.addNode(50, 28);
    bst.printInOrder();
    BinarySearchTree<int, int>::Node* node = bst.searchNode(7);
    bst.showNode(node);

    // Initializer list
    BinarySearchTree<int, int>  [MASK]  = {
        {1, 2}, {4, 3}, {5, 6}, {7, 8}};
     [MASK] .printInOrder();

    return 0;
}
",list_initialized_bst
844,"// Copyright 2022 The IREE Authors
//
// Licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include ""iree/compiler/Codegen/Common/GPU/CommonGPUPasses.h""
#include ""iree/compiler/Codegen/PassDetail.h""
#include ""iree/compiler/Codegen/Utils/Utils.h""
#include ""mlir/Dialect/Affine/IR/AffineOps.h""
#include ""mlir/Dialect/Func/IR/FuncOps.h""
#include ""mlir/Dialect/GPU/TransformOps/GPUTransformOps.h""
#include ""mlir/Dialect/GPU/Transforms/Passes.h""
#include ""mlir/Support/MathExtras.h""

#define DEBUG_TYPE ""iree-codegen-gpu-distribute""

namespace mlir {
namespace iree_compiler {

namespace {
struct GPUDistributePass : public GPUDistributeBase<GPUDistributePass> {
  void getDependentDialects(DialectRegistry& registry) const override {
    registry.insert<affine::AffineDialect, gpu::GPUDialect>();
  }
  void runOnOperation() override {
    auto funcOp = getOperation();
    if (!isEntryPoint(funcOp)) return;

    auto workgroupSize = llvm::map_to_vector(
        getEntryPoint(funcOp)->getWorkgroupSize().value(),
        [&](Attribute attr) { return llvm::cast<IntegerAttr>(attr).getInt(); });

    IRRewriter  [MASK] (funcOp->getContext());
     [MASK] .setInsertionPointToStart(&funcOp.getBody().front());
    DiagnosedSilenceableFailure result =
        mlir::transform::gpu::mapNestedForallToThreadsImpl(
             [MASK] , std::nullopt, funcOp, workgroupSize, /*warpDims=*/{},
            false);
    if (!result.succeeded()) return signalPassFailure();
  }
};
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> createGPUDistribute() {
  return std::make_unique<GPUDistributePass>();
}

}  // namespace iree_compiler
}  // namespace mlir
",rewriter
845,"// Copyright 2024 The Hay Authors
//
// Licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include ""device.h""

#include <cstring>

#ifdef __HIP__
#include <fmt/format.h>
#include <hip/hip_runtime.h>

void hip_check_impl(hipError_t  [MASK] , const char *condstr,
                    const char *file, int line) {
  if ( [MASK]  != hipSuccess) {
    fmt::print(stderr, ""HIP Error \""{}\"" produced by `{}` at {}:{}\n"",
               hipGetErrorString( [MASK] ), condstr, file, line);
    exit(EXIT_FAILURE);
  }
}

#define HIP_CHECK(expr) hip_check_impl(expr, #expr, __FILE__, __LINE__)
#endif

DevicePtr<void> deviceAllocBytes(ssize_t size) {
  void *ptr = nullptr;
#ifdef __HIP__
  HIP_CHECK(hipMalloc(&ptr, size));
#else
  ptr = malloc(size);
#endif
  return {ptr};
}

void deviceDeallocBytes(DevicePtr<void> ptr) {
#ifdef __HIP__
  HIP_CHECK(hipFree(ptr.val));
#else
  free(ptr.val);
#endif
}

void copyBytes(DevicePtr<void> dst, const void *src, ssize_t size) {
#ifdef __HIP__
  HIP_CHECK(hipMemcpy(dst.val, src, size, hipMemcpyHostToDevice));
#else
  memcpy(dst.val, src, size);
#endif
}

void copyBytes(void *dst, const DevicePtr<const void> src, ssize_t size) {
#ifdef __HIP__
  HIP_CHECK(hipMemcpy(dst, src.val, size, hipMemcpyDeviceToHost));
#else
  memcpy(dst, src.val, size);
#endif
}
",hip_error_code
846,"//===- Main.cpp -----------------------------------------------------------===//
//
// 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 the main file of BiquadOp benchmark.
//
//===----------------------------------------------------------------------===//

#include ""Utils.hpp""
#include <benchmark/benchmark.h>

using namespace std;

// -----------------------------------------------------------------------------
// Benchmark Configuration. Modify the numbers here for a custom benchmark.
// -----------------------------------------------------------------------------

#define _NUM_ITER 10
#define _IN_OUT_SIZE 2000000
#define _PRINT true

// -----------------------------------------------------------------------------
// Global Variables and Functions. Please do not modify the code here.
// -----------------------------------------------------------------------------

biquad_params<float> bq;
univector<float, _IN_OUT_SIZE> biquadInput;
univector<float, _IN_OUT_SIZE> biquadOutput;
univector<float, 6> kernel;

intptr_t sizeofAud[1] = {_IN_OUT_SIZE};
intptr_t sizeofKernel[1] = {6};

MemRef<float, 1> audRef(sizeofAud);
MemRef<float, 1> resRef(sizeofAud);
MemRef<float, 1> kernelRef(sizeofKernel);

using MLIRFunctionType = void (*)(MemRef<float, 1> *, MemRef<float, 1> *,
                                  MemRef<float, 1> *);

// Benchmarking function for MLIR based Biquad method.
void DAP_OPS_Biquad(benchmark::State &state, MLIRFunctionType func) {
  MemRef<float, 1> resRef(sizeofAud, 0.0);
  for (auto _ : state) {
    func(&audRef, &kernelRef, &resRef);
  }
  benchmark::DoNotOptimize(resRef);
}

// Benchmarking function for KFR Biquad method.
static void KFR_Biquad(benchmark::State &state) {
  for (auto _ : state) {
    biquadOutput = kfr::biquad(bq, biquadInput);
  }
}

// Verifies the result of an MLIR-based function against expected output.
void Verification(const univector<float, _IN_OUT_SIZE> &outputExpected,
                  MLIRFunctionType MLIRFunc, const std::string &name) {
  // Initialize MemRef with all zeros.
  MemRef<float, 1>  [MASK] (sizeofAud, 0.0);
  MLIRFunc(&audRef, &kernelRef, & [MASK] );
  biquadOp::printMemRef( [MASK] , name, /*doPrint=*/_PRINT);
  biquadOp::verify(outputExpected,  [MASK] , _IN_OUT_SIZE, name);
}

// -----------------------------------------------------------------------------
// Register Benchmark.
// -----------------------------------------------------------------------------

BENCHMARK_CAPTURE(DAP_OPS_Biquad, mlir_biquad, _mlir_ciface_mlir_biquad)
    ->Unit(benchmark::kMillisecond)
    ->Iterations(_NUM_ITER);
BENCHMARK_CAPTURE(DAP_OPS_Biquad, buddy_biquad, dap::biquad<float, 1>)
    ->Unit(benchmark::kMillisecond)
    ->Iterations(_NUM_ITER);
BENCHMARK(KFR_Biquad)->Unit(benchmark::kMillisecond)->Iterations(_NUM_ITER);

// -----------------------------------------------------------------------------
// Main Function.
// -----------------------------------------------------------------------------

int main(int argc, char **argv) {
  // Initialize univectors and MemRefs.
  biquadOp::initializeKFRBiquad(biquadInput, bq, kernel);
  audRef = std::move(MemRef<float, 1>(biquadInput.data(), sizeofAud));
  kernelRef = std::move(MemRef<float, 1>(kernel.data(), sizeofKernel));
  resRef = std::move(MemRef<float, 1>(sizeofAud, 0.0));

  // Run benchmarks.
  ::benchmark::Initialize(&argc, argv);
  ::benchmark::RunSpecifiedBenchmarks();

  std::cout << ""\033[34m---------- Verification ----------\033[0m"" << std::endl;
  // Obtain KFR output results as expected results in verification.
  biquadOutput = kfr::biquad(bq, biquadInput);
  biquadOp::printUnivector(biquadOutput, /*doPrint=*/_PRINT);

  // Verify the correctness of all methods.
  Verification(biquadOutput, dap::biquad<float, 1>, ""Buddy"");
  Verification(biquadOutput, _mlir_ciface_mlir_biquad, ""MLIR"");

  return 0;
}
",outputGenerated
847,"#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

const string FREE_WORKER_LABEL          = ""Free"";
const string WORKING_WORKER_LABEL       = ""Working"";
const string SECCESSFUL_MESSAGE         = ""OK"";
const string ADD_STAGE_COMMAND          = ""add_stage"";
const string ADD_CAR_COMMAND            = ""add_car"";
const string ADVANCE_TIME_COMMAND       = ""advance_time"";
const string SHOW_STAGE_INFO_COMMAND    = ""show_stage_info"";
const string SHOW_CARWASH_INFO_COMMAND  = ""show_carwash_info"";
const string FINISH_COMMAND             = ""finish"";

void print_error(string message) { cerr << message << endl; }

class Car {
   public:
    Car(int _id, int _luxury_coefficient) {
        id = _id;
        luxury_coefficient = _luxury_coefficient;
    }
    int get_id() { return id; }
    int get_luxury_coefficient() { return luxury_coefficient; }
    int get_timeleft() { return timeleft; }
    void increase_timeleft() { timeleft += 1; }
    void set_timeleft(int worker_time_coefficient) {
        timeleft = worker_time_coefficient * luxury_coefficient;
    }
    void being_washed() {
        if (timeleft > 0) timeleft -= 1;
    }

    string car_info(bool  [MASK] ) {
        ostringstream outstring;
        outstring << ""Car ID: "" << id << endl;
        outstring << ""Luxury coefficient: "" << luxury_coefficient << endl;
        if ( [MASK] ) {
            outstring << ""Time left: "" << timeleft << endl;
        }
        return outstring.str();
    }

   private:
    int id;
    int luxury_coefficient;
    int timeleft;
};

class Worker {
   public:
    Worker(int worker_id, int worker_time_coefficient) {
        id = worker_id;
        time_coefficient = worker_time_coefficient;
        status = FREE_WORKER_LABEL;
    }
    int get_id() { return id; }
    int get_time_coefficient() { return time_coefficient; }
    string get_status() { return status; }
    void toggle_status() {
        if (status == FREE_WORKER_LABEL)
            status = WORKING_WORKER_LABEL;
        else
            status = FREE_WORKER_LABEL;
    }
    Car* get_working_car() { return working_car; }
    void set_working_car(Car* _working_car) {
        if (status == FREE_WORKER_LABEL) {
            toggle_status();
            working_car = _working_car;
        }
    }
    void wash_the_car() { working_car->being_washed(); }

    string worker_info() {
        ostringstream outstring;
        outstring << ""Worker ID: "" << id << endl;
        if (status == FREE_WORKER_LABEL) {
            outstring << FREE_WORKER_LABEL << endl;
        } else {
            outstring << working_car->car_info(true);
        }
        return outstring.str();
    }

   private:
    int id;
    int time_coefficient;
    string status;
    Car* working_car;
};

class Stage {
   public:
    void add_worker(int worker_id, int worker_time_coefficient) {
        Worker worker(worker_id, worker_time_coefficient);
        workers.push_back(worker);
    }
    vector<Worker> get_workers() { return workers; }

    void add_car_to_stage(Car* waiting_car) {
        Worker* free_worker = get_free_worker();
        if (free_worker == NULL)
            waiting_queue.push_back(waiting_car);
        else if (waiting_queue.size() == 0) {
            waiting_car->set_timeleft(free_worker->get_time_coefficient());
            free_worker->set_working_car(waiting_car);
        }
    }

    void add_worker_to_car(Worker* worker, Car* car) {
        car->set_timeleft(worker->get_time_coefficient());
        worker->set_working_car(car);
    }

    void add_a_car_from_queue() {
        Worker* free_worker = get_free_worker();
        if (waiting_queue.size() > 0 && free_worker != NULL) {
            add_worker_to_car(free_worker, waiting_queue.front());
            waiting_queue.erase(waiting_queue.begin());
        }
    }

    vector<Car*> get_waiting_cars() { return waiting_queue; }

    void wash_the_cars() {
        for (int i = 0; i < workers.size(); i++)
            if (workers[i].get_status() == WORKING_WORKER_LABEL) {
                workers[i].wash_the_car();
            }
    }

    Car* find_finished_car() {
        Worker* finished_worker = find_finished_worker();
        if (finished_worker == NULL) return NULL;
        finished_worker->toggle_status();
        return finished_worker->get_working_car();
    }

    string stage_info() {
        ostringstream outstring;
        for (auto worker : workers) {
            outstring << worker.worker_info();
        }
        outstring << ""Cars in waiting queue: "" << endl;
        for (auto waiting_car : waiting_queue) {
            outstring << waiting_car->car_info(false);
        }
        return outstring.str();
    }

   private:
    Worker* find_finished_worker() {
        for (int i = 0; i < workers.size(); i++) {
            if (workers[i].get_status() == WORKING_WORKER_LABEL &&
                workers[i].get_working_car()->get_timeleft() == 0) {
                return &workers[i];
            }
        }
        return NULL;
    }

    Worker* get_free_worker() {
        for (int i = 0; i < workers.size(); i++)
            if (workers[i].get_status() == FREE_WORKER_LABEL)
                return &workers[i];
        return NULL;
    }
    vector<Worker> workers;
    vector<Car*> waiting_queue;
};

class Carwash {
   public:
    Carwash() {
        number_of_workers = 0;
        passed_time = 0;
    }
    void add_stage(Stage stage) { stages.push_back(stage); }
    int get_new_worker_id() {
        number_of_workers += 1;
        return number_of_workers - 1;
    }

    vector<Stage> get_stages() { return stages; }

    void add_car(int car_luxury_coefficient) {
        Car new_car(cars.size(), car_luxury_coefficient);
        cars.push_back(new Car(new_car));
        waiting_queue.push_back(cars.back());
    }

    vector<Car*> get_cars() { return cars; }

    void add_a_car_to_first_stage() {
        if (waiting_queue.size() > 0) {
            stages.front().add_car_to_stage(waiting_queue.front());
            waiting_queue.erase(waiting_queue.begin());
        }
    }

    void add_a_waiting_car_to_stage() {
        add_a_car_to_first_stage();
        for (int i = 0; i < stages.size(); i++)
            stages[i].add_a_car_from_queue();
    }

    void add_car_to_finished_cars(Car* finished_car) {
        finished_cars.push_back(finished_car);
    }

    void advance_cars_to_next_step() {
        for (int i = 0; i < stages.size(); i++) {
            Car* finished_car = stages[i].find_finished_car();
            if (finished_car != NULL) {
                if (i == stages.size() - 1)
                    add_car_to_finished_cars(finished_car);
                else {
                    stages[i + 1].add_car_to_stage(finished_car);
                    finished_car->increase_timeleft();
                }
            }
        }
    }

    void advance_time() {
        passed_time += 1;
        advance_cars_to_next_step();
        for (int i = 0; i < stages.size(); i++) {
            stages[i].wash_the_cars();
        }
        add_a_waiting_car_to_stage();
    }

    Stage get_stage_by_id(int stage_id) { return stages[stage_id]; }

    void finish() {
        while (finished_cars.size() != cars.size()) {
            advance_time();
        }
    }

    string carwash_info() {
        ostringstream outstring;
        outstring << ""Passed time: "" << passed_time << endl;
        outstring << ""Cars waiting: "" << endl;
        for (auto waiting_car : waiting_queue) {
            outstring << waiting_car->car_info(false);
        }
        outstring << ""Stages info: "" << endl;
        for (int i = 0; i < stages.size(); i++) {
            outstring << ""Stage ID: "" << i << endl;
            outstring << stages[i].stage_info();
        }
        outstring << ""Cars finished: "" << endl;
        for (auto finished_car : finished_cars) {
            outstring << finished_car->car_info(false);
        }
        return outstring.str();
    }

   private:
    int number_of_workers;
    vector<Stage> stages;
    vector<Car*> cars;
    vector<Car*> waiting_queue;
    int passed_time;
    vector<Car*> finished_cars;
};

//****************************************************************

Carwash add_stage_command(Carwash carwash) {
    int number_of_stage_workers;
    cin >> number_of_stage_workers;
    Stage stage;
    for (int i = 0; i < number_of_stage_workers; i++) {
        int worker_time_coefficient;
        cin >> worker_time_coefficient;
        stage.add_worker(carwash.get_new_worker_id(), worker_time_coefficient);
    }
    carwash.add_stage(stage);
    return carwash;
}

Carwash add_car_command(Carwash carwash) {
    int car_luxury_coefficient;
    cin >> car_luxury_coefficient;
    carwash.add_car(car_luxury_coefficient);
    return carwash;
}

Carwash advance_time_command(Carwash carwash) {
    int time_step;
    cin >> time_step;
    while (time_step > 0) {
        carwash.advance_time();
        time_step -= 1;
    }
    return carwash;
}

void show_stage_info_command(Carwash carwash) {
    int stage_id;
    cin >> stage_id;
    Stage the_stage = carwash.get_stage_by_id(stage_id);
    cout << ""Stage ID: "" << stage_id << endl;
    cout << the_stage.stage_info();
}

void show_carwash_info_command(Carwash carwash) {
    cout << carwash.carwash_info();
}

void print_OK() { cout << SECCESSFUL_MESSAGE << endl; }

Carwash handle_user_commands(Carwash carwash) {
    string command;
    while (cin >> command) {
        if (!command.compare(ADD_STAGE_COMMAND)) {
            carwash = add_stage_command(carwash);
            print_OK();
        }
        if (!command.compare(ADD_CAR_COMMAND)) {
            carwash = add_car_command(carwash);
            print_OK();
        }
        if (!command.compare(ADVANCE_TIME_COMMAND)) {
            carwash = advance_time_command(carwash);
            print_OK();
        }
        if (!command.compare(SHOW_STAGE_INFO_COMMAND)) {
            show_stage_info_command(carwash);
        }
        if (!command.compare(SHOW_CARWASH_INFO_COMMAND)) {
            show_carwash_info_command(carwash);
        }
        if (!command.compare(FINISH_COMMAND)) {
            carwash.finish();
            print_OK();
        }
    }
    return carwash;
}

int main() {
    Carwash carwash;
    carwash = handle_user_commands(carwash);
    // for (Stage s : carwash.get_stages()) {
    // vector<Worker> workers = s.get_workers();
    // cout << ""stage\t""
    //      << ""count: "" << workers.size() << endl;
    // for (Worker w : workers) {
    //     cout << w.get_id() << "" "" << w.get_time_coefficient() << endl;
    // }
    // for (auto c : s.get_wating_cars()) {
    //     cout << ""w: "" << c->get_luxury_coefficient() << endl;
    // }
    // }
    // for(Car c:carwash.get_cars()){
    //     cout<<c.get_id()<<"" : ""<<c.get_luxury_coefficient()<<endl;
    // }

    return 0;
}",need_timeleft
848,"/**
 * Given two strings s and t, return true if t is an anagram of s, and false
otherwise.

An Anagram is a word or phrase formed by rearranging the letters of a different
word or phrase, typically using all the original letters exactly once.



Example 1:

Input: s = ""anagram"", t = ""nagaram""
Output: true
Example 2:

Input: s = ""rat"", t = ""car""
Output: false


Constraints:

1 <= s.length, t.length <= 5 * 104
s and t consist of lowercase English letters.


Follow up: What if the inputs contain Unicode characters? How would you adapt
your solution to such a case?
 */

#include ""string""
#include ""unordered_map""

using namespace std;

class Solution {
public:
  bool isAnagram(string s, string t) {

    // If both strings are not equal in length
    if (s.size() != t.size()) {
      return false;
    }

    std::unordered_map<char, int>  [MASK] ;
    // Count the frequency of each character in s
    for (const char c : s) {
       [MASK] [c]++;
    }

    /**
        Reduce count every time a known character is encountered in t.
        If any unknown character is encountered return false.
    */
    for (const char c : t) {
      if ( [MASK] .find(c) ==  [MASK] .end())
        return false;

       [MASK] [c]--;
    }

    // Check if any character has count greater than 0
    for (const auto &val :  [MASK] ) {
      if (val.second != 0)
        return false;
    }

    return true;
  }
};
",count_map
849,"#include <Ufox.h>
#include <LowPower.h>
#include <SoftwareSerial.h>
#include <Arduino.h>
#include <SensorModbusMaster.h>

//Pines empleados
#define btn          13
#define RXLED        17 
#define LED          9 
#define PwrSensor    A0  //pin para encender max485 y elevador de voltaje para sensor 
#define PinRX_485    16 
#define PinTX_485    10
#define PinDERE_485  15
#define PinFRAUD      8  //reed switch a GND
#define Pin_b5        7  //
#define Pin_b4        6  //
#define Pin_b3        5  //
#define Pin_b2        4  //
#define Pin_b1        14  //

Ufox wisol;
SoftwareSerial mySerial(4, 5); //(RX,TX)

bool reboot=0;
    bool rsv1=0;
    bool fraud=0;;
    bool b4=0;
    bool b3=0;
    bool b2=0;
    bool b1=0;
    bool b0=0;

int val=0; //variable contador
float tmp = 80 ; //tiempo que permanecera apagado (Minutos) =  82 *8/60 = 10.9 min


// Define the sensor's modbus address
byte modbusAddress = 0x01;   // The sensor's modbus address, or SlaveID
long modbusBaudRate = 9600;

// Define pin number variables
const int sensorPwrPin = -10;     // The pin sending power to the sensor
const int adapterPwrPin = -22;    // The pin sending power to the RS485 adapter  //encender RS485
const int DEREPin = PinDERE_485;  // The pin controlling Recieve Enable and Driver Enable
                                  // on the RS485 adapter, if applicable (else, -1)
                                  // Setting HIGH enables the driver (arduino) to send text
                                  // Setting LOW enables the receiver (sensor) to send text


const int SSRxPin = PinRX_485; //10; // Recieve pin for software serial (Rx on RS485 adapter)
const int SSTxPin = PinTX_485; //15; // Send pin for software serial (Tx on RS485 adapter)
SoftwareSerial modbusSerial(SSRxPin, SSTxPin);

bool success;
int16_t direccion;
int16_t baud ;
int16_t unit;
int16_t measure;
////////////////////
modbusMaster modbus;

void setup()
{
  pinMode(btn,INPUT);
  pinMode(RXLED,OUTPUT);
  pinMode(PinFRAUD,INPUT_PULLUP); 
  delay(4000);
  Serial.println(""Boot"");
  Serial.println(""Boot"");
    
  Serial.begin(115200);
  wisol.begin(9600);
  mySerial.begin(9600); //iniciar serial de usuario pin 5-TX
  mySerial.println(""Iniciando Dispositivo Ufox!"");
  pinMode(PwrSensor,OUTPUT);
  
    // Set various pins as needed
    if (DEREPin >= 0)
    {
        pinMode(DEREPin, OUTPUT);
    }
    if (sensorPwrPin >= 0)
    {
        pinMode(sensorPwrPin, OUTPUT);
        digitalWrite(sensorPwrPin, HIGH);
    }
    if (adapterPwrPin >= 0)
    {
        pinMode(adapterPwrPin, OUTPUT);
        digitalWrite(adapterPwrPin, HIGH);
    }

    // Turn on the ""main"" serial port for debugging via USB Serial Monitor
  
   // while(!Serial);
       
  Serial.print(""ID: "");
  Serial.println(wisol.ID());
    
  Serial.print(""PAC: "");
  Serial.println(wisol.PAC());

  modbusSerial.begin(modbusBaudRate);
  modbus.begin(modbusAddress, modbusSerial, DEREPin);
  delay(1000);

  wisol.SLEEP();
  pinMode(LED,OUTPUT);
  pinMode(RXLED,OUTPUT);
  
  for(int i=0; i<10;i++){
    digitalWrite(RXLED,LOW);
    delay(30);
    digitalWrite(RXLED,HIGH);  
    delay(30);
    }
    
  reboot=1; //bandera que indica reinicio
   if(digitalRead(PinFRAUD)==1)fraud=0;
   if(digitalRead(PinFRAUD)==0)fraud=1;
  TASK(); //realizar tareas, lectura de sensores, actuadores, enviar por sigfox, recibir de sigfox,etc...
  
  mySerial.print(""Apagar UFOX (Min): "");
  mySerial.println((tmp*8)/60);

  
}

// ---------------------------------------------------------------------------
// Main setup function
// ---------------------------------------------------------------------------
void loop()
{
 val++;
 mySerial.print(""."");
 if(digitalRead(PinFRAUD)==1)fraud=0;
 if(digitalRead(PinFRAUD)==0)fraud=1;

 if(val >= tmp){  //preguntar si es tiempo de enviar
     digitalWrite(LED,LOW);
     mySerial.println(""Despertar UFOX! "");

     //reboot=0,rsv1=0,rsv2=0,b4=0,b3=0,b2=0,b1=0,b0=0;
     reboot=0;

   rsv1=0;
   
   if(digitalRead(PinFRAUD)==1)fraud=0;
   if(digitalRead(PinFRAUD)==0)fraud=1;
   
   b4=0;
   b3=0;
   b2=0;
   b1=0;
   b0=0;
   
     TASK(); //realizar tareas, lectura de sensor, actuadores, enviar por sigfox, recibir de sigfox,etc...
 
     val=0;
     mySerial.print(""Apagar UFOX (Min): "");
     mySerial.println((tmp*8)/60);
     LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); //APAGAR
  }   
     LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); //APAGAR
}


void TASK(){
  
    wisol.RST(); //reinicializar (despertar) radio sigfox
      //digitalWrite(RXLED,LOW); //encender led
    mySerial.println(""Enviar dato Sigfox..."");  
    digitalWrite(PwrSensor,HIGH); //ENCEDER TRANSISTOR
    
    for(int i=0; i<3;i++){TXLED0;  delay(100); TXLED1;   delay(100);}
  Serial.print(""ID: "");
  Serial.println(wisol.ID());  
  Serial.print(""PAC: "");
  Serial.println(wisol.PAC());
  
    meassure_rs485(); //leer RS485
    
    digitalWrite(PwrSensor,LOW); //APAGAR TRANSISTOR
    digitalWrite(DEREPin,HIGH);
       
   uint32_t S1 = measure;   //int24=24bits=3bytes  nivel de agua en mm 
   uint32_t S2 = 0;        //uint24=24bits=3bytes
   uint16_t S3 = 0;          //uint16=16bits=2bytes
   uint16_t S4 = 0;       //uint16=16bits=2bytes   
   
   uint16_t  volt =  wisol.VOLT();
   volt = volt/100;
   uint8_t  [MASK]  = volt;     //int=8bits=2bytes  0.0V -4.5V

   Serial.print(""Voltaje:  "");
   Serial.println( [MASK] );
  
    uint8_t SumBit = SumBit<<1 |reboot;  //1bytes
    SumBit = SumBit<<1 |rsv1;
    SumBit = SumBit<<1 |fraud;
    SumBit = SumBit<<1 |b4;
    SumBit = SumBit<<1 |b3;
    SumBit = SumBit<<1 |b2;
    SumBit = SumBit<<1 |b1;
    SumBit = SumBit<<1 |b0;

    Serial.print(""S1:"");Serial.print(S1);Serial.print("" S2:"");Serial.print(S2);Serial.print("" S3:"");Serial.print(S3);Serial.print("" S4:"");Serial.println(S4);
    Serial.print("" Reboot:"");Serial.print(reboot); Serial.print("" Fraude:"");Serial.print(fraud);Serial.print("" Battery:"");Serial.println( [MASK] );  
   
    //SumBit=255;
    char buff[30]="""";
    //formatear a cadena, convertir los datos a valores hexagesimales
    sprintf(buff,""%06lx%06lx%04x%04x%02x%02x"",S1,S2,S3,S4,SumBit, [MASK] );  
    Serial.println(buff);
    //String valor2 =""10"";
    Serial.println(wisol.SEND(buff)); 
     //digitalWrite(RXLED,HIGH);

    for(int i=0; i<3;i++){TXLED1;  delay(100);TXLED0;   delay(100);}
    wisol.SLEEP();//apagar radio sigfox
}


void meassure_rs485(){
Serial.print(""Status:"");
success = modbus.getRegisters(0x03, 0x04, 2);
Serial.print(success);
Serial.print(""  "");

Serial.print(""Address:"");
direccion = modbus.int16FromRegister(0x03, 0x00, bigEndian);
Serial.print(direccion);
Serial.print("" "");

Serial.print(""Baud:"");
baud = modbus.int16FromRegister(0x03, 0x01, bigEndian);
Serial.print(baud);
Serial.print("" "");

Serial.print(""Unit:"");
unit = modbus.int16FromRegister(0x03, 0x02, bigEndian);
Serial.print(unit);
Serial.print("" "");

Serial.print(""Measure (mm):"");
measure = modbus.int16FromRegister(0x03, 0x04, bigEndian);
Serial.print(measure);
Serial.println("" "");

delay(500);
}
",bateria
850,"#include <array>
#include <iostream>
#include <orge.h>
#include <vector>

#define TRY(n) \
	if (!(n)) { \
		std::cout << orgeGetErrorMessage() << std::endl; \
		return 1; \
	}

#define CHECK(n) \
	if (!(n)) { \
		std::cout << orgeGetErrorMessage() << std::endl; \
		continue; \
	}

const std::vector<float> VERTICES{
	-1.0f, 1.0f, 0.0f,
	0.0f, 1.0f,
	-1.0f, -1.0f, 0.0f,
	0.0f, 0.0f,
	1.0f, -1.0f, 0.0f,
	1.0f, 0.0f,
	1.0f, 1.0f, 0.0f,
	1.0f, 1.0f,
};
const std::vector<uint32_t> INDICES{0, 1, 2, 0, 2, 3};

const std::vector<unsigned char> PIXELS{
	255, 0, 0, 255,
	0, 255, 0, 255,
	0, 255, 0, 255,
	255, 0, 0, 255,
};

const std::vector<uint32_t> SET_INDICES{0, 0};

int main() {
	TRY(orgeInitializeWith(""config.yml""));
	TRY(orgeCreateMesh(
		""square"",
		static_cast<uint32_t>(VERTICES.size()),
		VERTICES.data(),
		static_cast<uint32_t>(INDICES.size()),
		INDICES.data())
	);

	TRY(orgeCreateBuffer(""transform"", static_cast<uint64_t>(sizeof(float) * 16), 0));
	TRY(orgeCreateBuffer(""sampler-index"", static_cast<uint64_t>(sizeof(uint32_t)), 0));
	TRY(orgeCreateImage(""texture"", 2, 2, PIXELS.data()));
	TRY(orgeCreateSampler(""nearest"", 0, 0, 0));
	TRY(orgeCreateSampler(""linear"",  1, 1, 0));

	std::array<float, 16> transform{
		0.5f, 0.0f, 0.0f, 0.0f,
		0.0f, 0.5f, 0.0f, 0.0f,
		0.0f, 0.0f, 1.0f, 0.0f,
		0.0f, 0.0f, 0.0f, 1.0f,
	};
	uint32_t  [MASK]  = 0;

	while (orgeUpdate()) {
		if (orgeGetKeyState(static_cast<uint32_t>(ORGE_SCANCODE_RETURN)) == 1) {
			 [MASK]  = ( [MASK]  + 1) % 2;
		}
		if (orgeGetKeyState(static_cast<uint32_t>(ORGE_SCANCODE_I)) > 0) {
			transform[0] += 0.01f;
			transform[5] += 0.01f;
		}
		if (orgeGetKeyState(static_cast<uint32_t>(ORGE_SCANCODE_O)) > 0) {
			transform[0] -= 0.01f;
			transform[5] -= 0.01f;
			if (transform[0] < 0.0f) {
				transform[0] = 0.0f;
			}
			if (transform[5] < 0.0f) {
				transform[5] = 0.0f;
			}
		}

		CHECK(orgeUpdateBuffer(""transform"", transform.data()));
		CHECK(orgeUpdateBuffer(""sampler-index"", & [MASK] ));

		CHECK(orgeUpdateBufferDescriptor(""transform"", ""PL"", 0, 0, 0, 0));
		CHECK(orgeUpdateBufferDescriptor(""sampler-index"", ""PL"", 1, 0, 0, 0));
		CHECK(orgeUpdateImageDescriptor(""texture"", ""PL"", 1, 0, 1, 0));
		CHECK(orgeUpdateSamplerDescriptor(""nearest"", ""PL"", 1, 0, 2, 0));
		CHECK(orgeUpdateSamplerDescriptor(""linear"",  ""PL"", 1, 0, 2, 1));

		CHECK(orgeBeginRender());
		CHECK(orgeBindDescriptorSets(""PL"", SET_INDICES.data()));
		CHECK(orgeDraw(""PL"", ""square"", 1, 0));
		CHECK(orgeEndRender());
	}

	orgeTerminate();
	return 0;
}
",samplerIndex
851,"/*
www.sourceforge.net/projects/tinyxml
Original code (2.0 and earlier )copyright (c) 2000-2006 <NAME> (www.grinninglizard.com)

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.

Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source
distribution.
*/

// This line can be deleted
#pragma clang diagnostic push
// This line can be deleted
#pragma ide diagnostic ignored ""OCUnusedGlobalDeclarationInspection""
#pragma ide diagnostic ignored ""modernize-use-nodiscard""

#ifndef TINYXML_INCLUDED
#define TINYXML_INCLUDED

#include <cstring>
#include <cassert>
#include <cstdio>
#include <cctype>

#include <string>
#include <iostream>
#include <sstream>
#include <array>

// Deprecated library function hell. Compilers want to use the
// new safe versions. This probably doesn't fully address the problem,
// but it gets closer. There are too many compilers for me to fully
// test. If you get compilation troubles, undefine TIXML_SAFE
#define TIXML_SAFE

#ifdef TIXML_SAFE
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
// Microsoft visual studio, version 2005 and higher.
#define TIXML_SNPRINTF _snprintf_s
#define TIXML_SNSCANF  _snscanf_s
#define TIXML_SSCANF   sscanf_s
#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
// Microsoft visual studio, version 6 and higher.
//#pragma message( ""Using _sn* functions."" )
#define TIXML_SNPRINTF _snprintf
#define TIXML_SNSCANF  _snscanf
#define TIXML_SSCANF   sscanf
#elif defined(__GNUC__) && (__GNUC__ >= 3)
// GCC version 3 and higher.s
//#warning( ""Using sn* functions."" )
#define TIXML_SNPRINTF snprintf
#define TIXML_SNSCANF  snscanf
#define TIXML_SSCANF   sscanf
#else
#define TIXML_SSCANF   sscanf
#endif
#endif

namespace Ana
{
	class TiXmlVisitor;

	class Document;

	class Element;

	class Comment;

	class Unknown;

	class Attribute;

	class Text;

	class Declaration;

	class StylesheetReference;

	class ParsingData;

	constexpr float ANA_VERSION = 2020.0204;

	/*	Internal structure for tracking location of items
	in the XML file.
*/
	struct TiXmlCursor
	{
		TiXmlCursor()
		{
			Clear();
		}

		void Clear()
		{
			row = col = -1;
		}

		int row;    // 0 based.
		int col;    // 0 based.
	};


// Only used by Attribute::Query functions
	enum
	{
		TIXML_SUCCESS,
		TIXML_NO_ATTRIBUTE,
		TIXML_WRONG_TYPE
	};


// Used by the parsing routines.
	enum class Encoding : char
	{
		Unknow,
		UTF8,
		Legacy
	};

	constexpr Encoding DEFAULT_ENCODING = Encoding::Unknow;

/** TiXmlBase is a base class for every class in TinyXml.
	It does little except to establish that TinyXml classes
	can be printed and provide some utility functions.

	In XML, the document and elements can contain
	other elements and other types of nodes.

	@verbatim
	A Document can contain:	Element	(container or leaf)
							Comment (leaf)
							Unknown (leaf)
							Declaration( leaf )

	An Element can contain:	Element (container or leaf)
							Text	(leaf)
							Attributes (not on tree)
							Comment (leaf)
							Unknown (leaf)

	A Decleration contains: Attributes (not on tree)
	@endverbatim
*/

	class TiXmlBase
	{
		friend class TiXmlNode;

		friend class Element;

		friend class Document;

	public:

		TiXmlBase() : userData(nullptr)
		{
		}

		virtual ~TiXmlBase() = default;

		/**	All TinyXml classes can print themselves to a filestream
			or the string class (TiXmlString in non-STL mode, std::string
			in STL mode.) Either or both cfile and str can be null.

			This is a formatted print, and will insert
			tabs and newlines.

			(For an unformatted stream, use the << operator.)
		*/
		virtual void Print(FILE* cfile, int depth) const = 0;

		/**	The world does not agree on whether white space should be kept or
			not. In order to make everyone happy, these global, static functions
			are provided to set whether or not TinyXml will condense all white space
			into a single space or not. The default is to condense. Note changing this
			value is not thread safe.
		*/
		static void SetCondenseWhiteSpace(bool condense)
		{
			condenseWhiteSpace = condense;
		}

		/// Return the current white space setting.
		static bool IsWhiteSpaceCondensed()
		{
			return condenseWhiteSpace;
		}

		/** Return the position, in the original source file, of this node or attribute.
			The row and column are 1-based. (That is the first row and first column is
			1,1). If the returns values are 0 or less, then the parser does not have
			a row and column value.

			Generally, the row and column value will be set when the Document::Load(),
			Document::LoadFile(), or any TiXmlNode::Parse() is called. It will NOT be set
			when the DOM was created from operator>>.

			The values reflect the initial load. Once the DOM is modified programmatically
			(by adding or changing nodes and attributes) the new values will NOT update to
			reflect changes in the document.

			There is a minor performance cost to computing the row and column. Computation
			can be disabled if Document::SetTabSize() is called with 0 as the value.

			@sa Document::SetTabSize()
		*/
		int Row() const
		{
			return location.row + 1;
		}

		int Column() const
		{
			return location.col + 1;
		}    ///< See Row()

		void SetUserData(void* user)
		{
			userData = user;
		}    ///< Set a pointer to arbitrary user data.
		void* GetUserData()
		{
			return userData;
		}    ///< Get a pointer to arbitrary user data.
		const void* GetUserData() const
		{
			return userData;
		}    ///< Get a pointer to arbitrary user data.

		// Table that returs, for a given lead byte, the total number of bytes
		// in the UTF-8 sequence.
		static const std::array <int, 256> UTF8_BYTE_TABLE;

		virtual const char* Parse(const char* p,
				ParsingData* data,
				Encoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;

		/** Expands entities in a string. Note this should not contian the tag's '<', '>', etc,
			or they will be transformed into entities!
		*/
		static void EncodeString(const std::string& str, std::string* out);

		enum
		{
			TIXML_NO_ERROR = 0,
			TIXML_ERROR,
			TIXML_ERROR_OPENING_FILE,
			TIXML_ERROR_OUT_OF_MEMORY,
			TIXML_ERROR_PARSING_ELEMENT,
			TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
			TIXML_ERROR_READING_ELEMENT_VALUE,
			TIXML_ERROR_READING_ATTRIBUTES,
			TIXML_ERROR_PARSING_EMPTY,
			TIXML_ERROR_READING_END_TAG,
			TIXML_ERROR_PARSING_UNKNOWN,
			TIXML_ERROR_PARSING_COMMENT,
			TIXML_ERROR_PARSING_DECLARATION,
			TIXML_ERROR_DOCUMENT_EMPTY,
			TIXML_ERROR_EMBEDDED_NULL,
			TIXML_ERROR_PARSING_CDATA,
			TIXML_ERROR_DOCUMENT_TOP_ONLY,

			TIXML_ERROR_STRING_COUNT
		};

	protected:

		static const char* SkipWhiteSpace(const char*, Encoding encoding);

		inline static bool IsWhiteSpace(char c)
		{
			return (isspace((unsigned char)c) || c == '\n' || c == '\r');
		}

		inline static bool IsWhiteSpace(int c)
		{
			if (c < 256)
			{
				return IsWhiteSpace((char)c);
			}
			return false;    // Again, only truly correct for English/Latin...but usually works.
		}

		static bool StreamWhiteSpace(std::istream* in, std::string* tag);

		static bool StreamTo(std::istream* in, int character, std::string* tag);

		/*	Reads an XML name into the string provided. Returns
			a pointer just past the last character of the name,
			or 0 if the function has an error.
		*/
		static const char* ReadName(const char* p, std::string* name, Encoding encoding);

		/*	Reads text. Returns a pointer past the given end tag.
			Wickedly complex options, but it keeps the (sensitive) code in one place.
		*/
		static const char* ReadText(const char* in,                // where to start
				std::string* text,            // the string read
				bool ignoreWhiteSpace,        // whether to keep the white space
				const char* endTag,            // what ends this text
				bool ignoreCase,            // whether to ignore case in the end tag
				Encoding encoding);    // the current encoding

		// If an entity has been found, transform it into a character.
		static const char* GetEntity(const char* in, char* value, int* length, Encoding encoding);

		// Get a character, while interpreting entities.
		// The length can be from 0 to 4 bytes.
		inline static const char* GetChar(const char* p, char* _value, int* length, Encoding encoding)
		{
			assert(p);
			if (encoding == Encoding::UTF8)
			{
				*length = UTF8_BYTE_TABLE[*((const unsigned char*)p)];
				assert(*length >= 0 && *length < 5);
			}
			else
			{
				*length = 1;
			}

			if (*length == 1)
			{
				if (*p == '&')
				{
					return GetEntity(p, _value, length, encoding);
				}
				*_value = *p;
				return p + 1;
			}
			else if (*length)
			{
				//strncpy( _value, p, *length );	// lots of compilers don't like this function (unsafe),
				// and the null terminator isn't needed
				for (int i = 0; p[i] && i < *length; ++i)
				{
					_value[i] = p[i];
				}
				return p + (*length);
			}
			else
			{
				// Not valid text.
				return nullptr;
			}
		}

		// Return true if the next characters in the stream are any of the endTag sequences.
		// Ignore case only works for english, and should only be relied on when comparing
		// to English words: StringEqual( p, ""version"", true ) is fine.
		static bool StringEqual(const char* p,
				const char* endTag,
				bool ignoreCase,
				Encoding encoding);

		static const char* errorString[TIXML_ERROR_STRING_COUNT];

		TiXmlCursor location;

		/// Field containing a generic user pointer
		void* userData;

		// None of these methods are reliable for any language except English.
		// Good for approximation, not great for accuracy.
		static int IsAlpha(unsigned char anyByte, Encoding encoding);

		static int IsAlphaNum(unsigned char anyByte, Encoding encoding);

		inline static int ToLower(int v, Encoding encoding)
		{
			if (encoding == Encoding::UTF8)
			{
				if (v < 128)
				{ return tolower(v); }
				return v;
			}
			else
			{
				return tolower(v);
			}
		}

		static void ConvertUTF32ToUTF8(unsigned long input, char* output, int* length);

	private:
		TiXmlBase(const TiXmlBase&);                // not implemented.
		void operator=(const TiXmlBase& base);    // not allowed.

		struct Entity
		{
			const char* str;
			unsigned int strLength;
			char chr;
		};
		enum
		{
			NUM_ENTITY = 5,
			MAX_ENTITY_LENGTH = 6

		};
		static Entity entity[NUM_ENTITY];
		static bool condenseWhiteSpace;
	};


/** The parent class for everything in the Document Object Model.
	(Except for attributes).
	Nodes have siblings, a parent, and children. A node can be
	in a document, or stand on its own. The type of a TiXmlNode
	can be queried, and it can be cast to its more defined type.
*/
	class TiXmlNode : public TiXmlBase
	{
		friend class Document;

		friend class Element;

	public:

		/** An input stream operator, for every class. Tolerant of newlines and
			formatting, but doesn't expect them.
		*/
		friend std::istream& operator>>(std::istream& in, TiXmlNode& base);

		/** An output stream operator, for every class. Note that this outputs
			without any newlines or formatting, as opposed to Print(), which
			includes tabs and new lines.

			The operator<< and operator>> are not completely symmetric. Writing
			a node to a stream is very well defined. You'll get a nice stream
			of output, without any extra whitespace or newlines.

			But reading is not as well defined. (As it always is.) If you create
			a Element (for example) and read that from an input stream,
			the text needs to define an element or junk will result. This is
			true of all input streams, but it's worth keeping in mind.

			A Document will read nodes until it reads a root element, and
			all the children of that root element.
		*/
		friend std::ostream& operator<<(std::ostream& out, const TiXmlNode& base);

		/// Appends the XML node or attribute to a std::string.
		friend std::string& operator<<(std::string& out, const TiXmlNode& base);

		/** The types of XML nodes supported by TinyXml. (All the
				unsupported types are picked up by UNKNOWN.)
		*/
		enum NodeType
		{
			DOCUMENT,
			ELEMENT,
			COMMENT,
			UNKNOWN,
			TEXT,
			DECLARATION,
			STYLESHEETREFERENCE,
			TYPECOUNT
		};

		~TiXmlNode() override;

		/** The meaning of 'value' changes for the specific type of
			TiXmlNode.
			@verbatim
			Document:	filename of the xml file
			Element:	name of the element
			Comment:	the comment text
			Unknown:	the tag contents
			Text:		the text string
			@endverbatim

			The subclasses will wrap this function.
		*/
		const char* GetValue() const
		{
			return value.c_str();
		}

		/** Return Value() as a std::string. If you only use STL,
			this is more efficient than calling Value().
			Only available in STL mode.
		*/
		const std::string& GetValueStr() const
		{
			return value;
		}

		const std::string& GetValueTStr() const
		{
			return value;
		}

		/** Changes the value of the node. Defined as:
			@verbatim
			Document:	filename of the xml file
			Element:	name of the element
			Comment:	the comment text
			Unknown:	the tag contents
			Text:		the text string
			@endverbatim
		*/
		void SetValue(const char* _value)
		{
			value = _value;
		}

		/// STL std::string form.
		void SetValue(const std::string& _value)
		{
			value = _value;
		}

		/// Delete all the children of this node. Does not affect 'this'.
		void Clear();

		/// One step up the DOM.
		TiXmlNode* Parent()
		{
			return parent;
		}

		const TiXmlNode* Parent() const
		{
			return parent;
		}

		const TiXmlNode* FirstChild() const
		{
			return firstChild;
		}    ///< The first child of this node. Will be null if there are no children.
		TiXmlNode* FirstChild()
		{
			return firstChild;
		}

		const TiXmlNode* FirstChild(
				const char* value) const;            ///< The first child of this node with the matching 'value'. Will be null if none found.
		/// The first child of this node with the matching 'value'. Will be null if none found.
		TiXmlNode* FirstChild(const char* _value)
		{
			// Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe)
			// call the method, cast the return back to non-const.
			return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild(_value));
		}

		const TiXmlNode* LastChild() const
		{
			return lastChild;
		}        /// The last child of this node. Will be null if there are no children.
		TiXmlNode* LastChild()
		{
			return lastChild;
		}

		const TiXmlNode* LastChild(
				const char* value) const;            /// The last child of this node matching 'value'. Will be null if there are no children.
		TiXmlNode* LastChild(const char* _value)
		{
			return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild(_value));
		}

		const TiXmlNode* FirstChild(const std::string& _value) const
		{
			return FirstChild(_value.c_str());
		}    ///< STL std::string form.
		TiXmlNode* FirstChild(const std::string& _value)
		{
			return FirstChild(_value.c_str());
		}    ///< STL std::string form.
		const TiXmlNode* LastChild(const std::string& _value) const
		{
			return LastChild(_value.c_str());
		}    ///< STL std::string form.
		TiXmlNode* LastChild(const std::string& _value)
		{
			return LastChild(_value.c_str());
		}    ///< STL std::string form.

		/** An alternate way to walk the children of a node.
			One way to iterate over nodes is:
			@verbatim
				for( child = parent->FirstChild(); child; child = child->NextSibling() )
			@endverbatim

			IterateChildren does the same thing with the syntax:
			@verbatim
				child = 0;
				while( child = parent->IterateChildren( child ) )
			@endverbatim

			IterateChildren takes the previous child as input and finds
			the next one. If the previous child is null, it returns the
			first. IterateChildren will return null when done.
		*/
		const TiXmlNode* IterateChildren(const TiXmlNode* previous) const;

		TiXmlNode* IterateChildren(const TiXmlNode* previous)
		{
			return const_cast< TiXmlNode* >((const_cast< const TiXmlNode* >(this))->IterateChildren(previous));
		}

		/// This flavor of IterateChildren searches for children with a particular 'value'
		const TiXmlNode* IterateChildren(const char* value, const TiXmlNode* previous) const;

		TiXmlNode* IterateChildren(const char* _value, const TiXmlNode* previous)
		{
			return const_cast< TiXmlNode* >((const_cast< const TiXmlNode* >(this))->IterateChildren(_value, previous));
		}

		const TiXmlNode* IterateChildren(const std::string& _value, const TiXmlNode* previous) const
		{
			return IterateChildren(_value.c_str(), previous);
		}    ///< STL std::string form.
		TiXmlNode* IterateChildren(const std::string& _value, const TiXmlNode* previous)
		{
			return IterateChildren(_value.c_str(), previous);
		}    ///< STL std::string form.

		/** Add a new node related to this. Adds a child past the LastChild.
			Returns a pointer to the new object or NULL if an error occured.
		*/
		TiXmlNode* InsertEndChild(const TiXmlNode& addThis);


		/** Add a new node related to this. Adds a child past the LastChild.

			NOTE: the node to be added is passed by pointer, and will be
			henceforth owned (and deleted) by tinyXml. This method is efficient
			and avoids an extra copy, but should be used with care as it
			uses a different memory model than the other insert functions.

			@sa InsertEndChild
		*/
		TiXmlNode* LinkEndChild(TiXmlNode* addThis);

		/** Add a new node related to this. Adds a child before the specified child.
			Returns a pointer to the new object or NULL if an error occured.
		*/
		TiXmlNode* InsertBeforeChild(TiXmlNode* beforeThis, const TiXmlNode& addThis);

		/** Add a new node related to this. Adds a child after the specified child.
			Returns a pointer to the new object or NULL if an error occured.
		*/
		TiXmlNode* InsertAfterChild(TiXmlNode* afterThis, const TiXmlNode& addThis);

		/** Replace a child of this node.
			Returns a pointer to the new object or NULL if an error occured.
		*/
		TiXmlNode* ReplaceChild(TiXmlNode* replaceThis, const TiXmlNode& withThis);

		/// Delete a child of this node.
		bool RemoveChild(TiXmlNode* removeThis);

		/// Navigate to a sibling node.
		const TiXmlNode* PreviousSibling() const
		{
			return prev;
		}

		TiXmlNode* PreviousSibling()
		{
			return prev;
		}

		/// Navigate to a sibling node.
		const TiXmlNode* PreviousSibling(const char*) const;

		TiXmlNode* PreviousSibling(const char* _prev)
		{
			return const_cast< TiXmlNode* >((const_cast< const TiXmlNode* >(this))->PreviousSibling(_prev));
		}

		const TiXmlNode* PreviousSibling(const std::string& _value) const
		{
			return PreviousSibling(_value.c_str());
		}    ///< STL std::string form.
		TiXmlNode* PreviousSibling(const std::string& _value)
		{
			return PreviousSibling(_value.c_str());
		}    ///< STL std::string form.
		const TiXmlNode* NextSibling(const std::string& _value) const
		{
			return NextSibling(_value.c_str());
		}    ///< STL std::string form.
		TiXmlNode* NextSibling(const std::string& _value)
		{
			return NextSibling(_value.c_str());
		}    ///< STL std::string form.

		/// Navigate to a sibling node.
		const TiXmlNode* NextSibling() const
		{
			return next;
		}

		TiXmlNode* NextSibling()
		{
			return next;
		}

		/// Navigate to a sibling node with the given 'value'.
		const TiXmlNode* NextSibling(const char*) const;

		TiXmlNode* NextSibling(const char* _next)
		{
			return const_cast< TiXmlNode* >((const_cast< const TiXmlNode* >(this))->NextSibling(_next));
		}

		/** Convenience function to get through elements.
			Calls NextSibling and ToElement. Will skip all non-Element
			nodes. Returns 0 if there is not another element.
		*/
		const Element* NextSiblingElement() const;

		Element* NextSiblingElement()
		{
			return const_cast< Element* >((const_cast< const TiXmlNode* >(this))->NextSiblingElement());
		}

		/** Convenience function to get through elements.
			Calls NextSibling and ToElement. Will skip all non-Element
			nodes. Returns 0 if there is not another element.
		*/
		const Element* NextSiblingElement(const char*) const;

		Element* NextSiblingElement(const char* _next)
		{
			return const_cast< Element* >((const_cast< const TiXmlNode* >(this))->NextSiblingElement(_next));
		}

		const Element* NextSiblingElement(const std::string& _value) const
		{
			return NextSiblingElement(_value.c_str());
		}    ///< STL std::string form.
		Element* NextSiblingElement(const std::string& _value)
		{
			return NextSiblingElement(_value.c_str());
		}    ///< STL std::string form.

		/// Convenience function to get through elements.
		const Element* FirstChildElement() const;

		Element* FirstChildElement()
		{
			return const_cast< Element* >((const_cast< const TiXmlNode* >(this))->FirstChildElement());
		}

		/// Convenience function to get through elements.
		const Element* FirstChildElement(const char* _value) const;

		Element* FirstChildElement(const char* _value)
		{
			return const_cast< Element* >((const_cast< const TiXmlNode* >(this))->FirstChildElement(_value));
		}

		const Element* FirstChildElement(const std::string& _value) const
		{
			return FirstChildElement(_value.c_str());
		}    ///< STL std::string form.
		Element* FirstChildElement(const std::string& _value)
		{
			return FirstChildElement(_value.c_str());
		}    ///< STL std::string form.

		/** Query the type (as an enumerated value, above) of this node.
			The possible types are: DOCUMENT, ELEMENT, COMMENT,
									UNKNOWN, TEXT, and DECLARATION.
		*/
		int Type() const
		{
			return type;
		}

		/** Return a pointer to the Document this node lives in.
			Returns null if not in a document.
		*/
		const Document* GetDocument() const;

		Document* GetDocument()
		{
			return const_cast< Document* >((const_cast< const TiXmlNode* >(this))->GetDocument());
		}

		/// Returns true if this node has no children.
		bool NoChildren() const
		{
			return !firstChild;
		}

		virtual const Document* ToDocument() const
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual const Element* ToElement() const
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual const Comment* ToComment() const
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual const Unknown* ToUnknown() const
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual const Text* ToText() const
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual const Declaration* ToDeclaration() const
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual const StylesheetReference* ToStylesheetReference() const
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.

		virtual Document* ToDocument()
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual Element* ToElement()
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual Comment* ToComment()
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual Unknown* ToUnknown()
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual Text* ToText()
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual Declaration* ToDeclaration()
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.
		virtual StylesheetReference* ToStylesheetReference()
		{
			return nullptr;
		} ///< Cast to a more defined type. Will return null if not of the requested type.

		/** Create an exact duplicate of this node and return it. The memory must be deleted
			by the caller.
		*/
		virtual TiXmlNode* Clone() const = 0;

		/** Accept a hierchical visit the nodes in the TinyXML DOM. Every node in the
			XML tree will be conditionally visited and the host will be called back
			via the TiXmlVisitor interface.

			This is essentially a SAX interface for TinyXML. (Note however it doesn't re-parse
			the XML for the callbacks, so the performance of TinyXML is unchanged by using this
			interface versus any other.)

			The interface has been based on ideas from:

			- http://www.saxproject.org/
			- http://c2.com/cgi/wiki?HierarchicalVisitorPattern

			Which are both good references for ""visiting"".

			An example of using Accept():
			@verbatim
			TiXmlPrinter printer;
			tinyxmlDoc.Accept( &printer );
			const char* xmlcstr = printer.CStr();
			@endverbatim
		*/
		virtual bool Accept(TiXmlVisitor* visitor) const = 0;

		// The real work of the input operator.
		virtual void StreamIn(std::istream* in, std::string* tag) = 0;

	protected:

		explicit TiXmlNode(NodeType _type);

		// Copy to the allocated object. Shared functionality between Clone, Copy constructor,
		// and the assignment operator.
		void CopyTo(TiXmlNode* target) const;

		// Figure out what is at *p, and parse it. Returns null if it is not an xml node.
		TiXmlNode* Identify(const char* start, Encoding encoding);

		TiXmlNode* parent;
		NodeType type;

		TiXmlNode* firstChild;
		TiXmlNode* lastChild;

		std::string value;

		TiXmlNode* prev;
		TiXmlNode* next;

	private:
		TiXmlNode(const TiXmlNode&);                // not implemented.
		void operator=(const TiXmlNode& base);    // not allowed.
	};


/** An attribute is a name-value pair. Elements have an arbitrary
	number of attributes, each with a unique name.

	@note The attributes are not TiXmlNodes, since they are not
		  part of the tinyXML document object model. There are other
		  suggested ways to look at this problem.
*/
	class Attribute : public TiXmlBase
	{
		friend class TiXmlAttributeSet;

	public:
		/// Construct an empty attribute.
		Attribute() : TiXmlBase()
		{
			document = nullptr;
			prev = next = nullptr;
		}

		/// std::string constructor.
		Attribute(const std::string& _name, const std::string& _value)
		{
			name = _name;
			value = _value;
			document = nullptr;
			prev = next = nullptr;
		}

		/// Construct an attribute with a name and value.
		Attribute(const char* _name, const char* _value)
		{
			name = _name;
			value = _value;
			document = nullptr;
			prev = next = nullptr;
		}

		const char* Name() const
		{
			return name.c_str();
		}        ///< Return the name of this attribute.
		const char* Value() const
		{
			return value.c_str();
		}        ///< Return the value of this attribute.

		const std::string& ValueStr() const
		{
			return value;
		}                ///< Return the value of this attribute.

		int
		IntValue() const;                                    ///< Return the value of this attribute, converted to an integer.
		double
		DoubleValue() const;                                ///< Return the value of this attribute, converted to a double.

		// Get the tinyxml string representation
		const std::string& NameTStr() const
		{
			return name;
		}

		/** QueryIntValue examines the value string. It is an alternative to the
			IntValue() method with richer error checking.
			If the value is an integer, it is stored in 'value' and
			the call returns TIXML_SUCCESS. If it is not
			an integer, it returns TIXML_WRONG_TYPE.

			A specialized but useful call. Note that for success it returns 0,
			which is the opposite of almost all other TinyXml calls.
		*/
		int QueryIntValue(int* _value) const;

		/// QueryDoubleValue examines the value string. See QueryIntValue().
		int QueryDoubleValue(double* _value) const;

		void SetName(const char* _name)
		{
			name = _name;
		}                ///< Set the name of this attribute.
		void SetValue(const char* _value)
		{
			value = _value;
		}                ///< Set the value.

		void SetIntValue(int _value);                                        ///< Set the value from an integer.
		void SetDoubleValue(double _value);                                ///< Set the value from a double.

		/// STL std::string form.
		void SetName(const std::string& _name)
		{
			name = _name;
		}

		/// STL std::string form.
		void SetValue(const std::string& _value)
		{
			value = _value;
		}

		/// Get the next sibling attribute in the DOM. Returns null at end.
		const Attribute* Next() const;

		Attribute* Next()
		{
			return const_cast< Attribute* >((const_cast< const Attribute* >(this))->Next());
		}

		/// Get the previous sibling attribute in the DOM. Returns null at beginning.
		const Attribute* Previous() const;

		Attribute* Previous()
		{
			return const_cast< Attribute* >((const_cast< const Attribute* >(this))->Previous());
		}

		bool operator==(const Attribute& rhs) const
		{
			return rhs.name == name;
		}

		bool operator<(const Attribute& rhs) const
		{
			return name < rhs.name;
		}

		bool operator>(const Attribute& rhs) const
		{
			return name > rhs.name;
		}

		/*	Attribute parsing starts: first letter of the name
							 returns: the next char after the value end quote
		*/
		const char* Parse(const char* p, ParsingData* data, Encoding encoding) override;

		// Prints this Attribute to a FILE stream.
		void Print(FILE* cfile, int depth) const override
		{
			Print(cfile, depth, nullptr);
		}

		void Print(FILE* cfile, int depth, std::string* str) const;

		// [internal use]
		// Set the document pointer so the attribute can report errors.
		void SetDocument(Document* doc)
		{
			document = doc;
		}

	private:
		Attribute(const Attribute&);                // not implemented.
		void operator=(const Attribute& base);    // not allowed.

		Document* document;    // A pointer back to a document, for error reporting.
		std::string name;
		std::string value;
		Attribute* prev;
		Attribute* next;
	};


/*	A class used to manage a group of attributes.
	It is only used internally, both by the ELEMENT and the DECLARATION.

	The set can be changed transparent to the Element and Declaration
	classes that use it, but NOT transparent to the Attribute
	which has to implement a next() and previous() method. Which makes
	it a bit problematic and prevents the use of STL.

	This version is implemented with circular lists because:
		- I like circular lists
		- it demonstrates some independence from the (typical) doubly linked list.
*/
	class TiXmlAttributeSet
	{
	public:
		TiXmlAttributeSet();

		~TiXmlAttributeSet();

		void Add(Attribute* attribute);

		void Remove(Attribute* attribute);

		const Attribute* First() const
		{
			return (sentinel.next == &sentinel) ? nullptr : sentinel.next;
		}

		Attribute* First()
		{
			return (sentinel.next == &sentinel) ? nullptr : sentinel.next;
		}

		const Attribute* Last() const
		{
			return (sentinel.prev == &sentinel) ? nullptr : sentinel.prev;
		}

		Attribute* Last()
		{
			return (sentinel.prev == &sentinel) ? nullptr : sentinel.prev;
		}

		const Attribute* Find(const char* _name) const;

		Attribute* Find(const char* _name)
		{
			return const_cast< Attribute* >((const_cast< const TiXmlAttributeSet* >(this))->Find(_name));
		}

		const Attribute* Find(const std::string& _name) const;

		Attribute* Find(const std::string& _name)
		{
			return const_cast< Attribute* >((const_cast< const TiXmlAttributeSet* >(this))->Find(_name));
		}

	private:
		//*ME:	Because of hidden/disabled copy-construktor in Attribute (sentinel-element),
		//*ME:	this class must be also use a hidden/disabled copy-constructor !!!
		TiXmlAttributeSet(const TiXmlAttributeSet&);    // not allowed
		void operator=(const TiXmlAttributeSet&);    // not allowed (as Attribute)

		Attribute sentinel;
	};


/** The element is a container class. It has a value, the element name,
	and can contain other elements, text, comments, and unknowns.
	Elements also contain an arbitrary number of attributes.
*/
	class Element : public TiXmlNode
	{
	public:
		/// Construct an element.
		explicit Element(const char* in_value);

		/// std::string constructor.
		explicit Element(const std::string& _value);

		Element(const Element&);

		void operator=(const Element& base);

		~Element() override;

		/** Given an attribute name, Attribute() returns the value
			for the attribute of that name, or null if none exists.
		*/
		const char* GetAttribute(const char* name) const;

		/** Given an attribute name, Attribute() returns the value
			for the attribute of that name, or null if none exists.
			If the attribute exists and can be converted to an integer,
			the integer value will be put in the return 'i', if 'i'
			is non-null.
		*/
		const char* GetAttribute(const char* name, int* i) const;

		/** Given an attribute name, Attribute() returns the value
			for the attribute of that name, or null if none exists.
			If the attribute exists and can be converted to an double,
			the double value will be put in the return 'd', if 'd'
			is non-null.
		*/
		const char* GetAttribute(const char* name, double* d) const;

		/** QueryIntAttribute examines the attribute - it is an alternative to the
			Attribute() method with richer error checking.
			If the attribute is an integer, it is stored in 'value' and
			the call returns TIXML_SUCCESS. If it is not
			an integer, it returns TIXML_WRONG_TYPE. If the attribute
			does not exist, then TIXML_NO_ATTRIBUTE is returned.
		*/
		int QueryIntAttribute(const char* name, int* _value) const;

		/// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
		int QueryDoubleAttribute(const char* name, double* _value) const;

		/// QueryFloatAttribute examines the attribute - see QueryIntAttribute().
		int QueryFloatAttribute(const char* name, float* _value) const
		{
			double d;
			int result = QueryDoubleAttribute(name, &d);
			if (result == TIXML_SUCCESS)
			{
				*_value = (float)d;
			}
			return result;
		}

		/** Template form of the attribute query which will try to read the
			attribute into the specified type. Very easy, very powerful, but
			be careful to make sure to call this with the correct type.

			NOTE: This method doesn't work correctly for 'string' types.

			@return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE
		*/
		template <typename T>
		int QueryValueAttribute(const std::string& name, T* outValue) const
		{
			const Attribute* node = attributeSet.Find(name);
			if (!node)
			{
				return TIXML_NO_ATTRIBUTE;
			}

			std::stringstream sstream(node->ValueStr());
			sstream >> *outValue;
			if (!sstream.fail())
			{
				return TIXML_SUCCESS;
			}
			return TIXML_WRONG_TYPE;
		}
		/*
		 This is - in theory - a bug fix for ""QueryValueAtribute returns truncated std::string""
		 but template specialization is hard to get working cross-compiler. Leaving the bug for now.

		// The above will fail for std::string because the space character is used as a seperator.
		// Specialize for strings. Bug [ 1695429 ] QueryValueAtribute returns truncated std::string
		template<> int QueryValueAttribute( const std::string& name, std::string* outValue ) const
		{
			const Attribute* node = attributeSet.Find( name );
			if ( !node )
				return TIXML_NO_ATTRIBUTE;
			*outValue = node->ValueStr();
			return TIXML_SUCCESS;
		}
		*/

		/** Sets an attribute of name to a given value. The attribute
			will be created if it does not exist, or changed if it does.
		*/
		void SetAttribute(const char* name, const char* _value);

		const std::string* GetAttribute(const std::string& name) const;

		const std::string* GetAttribute(const std::string& name, int* i) const;

		const std::string* GetAttribute(const std::string& name, double* d) const;

		int QueryIntAttribute(const std::string& name, int* _value) const;

		int QueryDoubleAttribute(const std::string& name, double* _value) const;

		/// STL std::string form.
		void SetAttribute(const std::string& name, const std::string& _value);

		///< STL std::string form.
		void SetAttribute(const std::string& name, int _value);

		/** Sets an attribute of name to a given value. The attribute
			will be created if it does not exist, or changed if it does.
		*/
		void SetAttribute(const char* name, int value);

		/** Sets an attribute of name to a given value. The attribute
			will be created if it does not exist, or changed if it does.
		*/
		void SetDoubleAttribute(const char* name, double value);

		/** Deletes an attribute with the given name.
		*/
		void RemoveAttribute(const char* name);

		void RemoveAttribute(const std::string& name)
		{
			RemoveAttribute(name.c_str());
		}    ///< STL std::string form.

		const Attribute* FirstAttribute() const
		{
			return attributeSet.First();
		}        ///< Access the first attribute in this element.
		Attribute* FirstAttribute()
		{
			return attributeSet.First();
		}

		const Attribute* LastAttribute() const
		{
			return attributeSet.Last();
		}        ///< Access the last attribute in this element.
		Attribute* LastAttribute()
		{
			return attributeSet.Last();
		}

		/** Convenience function for easy access to the text inside an element. Although easy
			and concise, GetText() is limited compared to getting the Text child
			and accessing it directly.

			If the first child of 'this' is a Text, the GetText()
			returns the character string of the Text node, else null is returned.

			This is a convenient method for getting the text of simple contained text:
			@verbatim
			<foo>This is text</foo>
			const char* str = fooElement->GetText();
			@endverbatim

			'str' will be a pointer to ""This is text"".

			Note that this function can be misleading. If the element foo was created from
			this XML:
			@verbatim
			<foo><b>This is text</b></foo>
			@endverbatim

			then the value of str would be null. The first child node isn't a text node, it is
			another element. From this XML:
			@verbatim
			<foo>This is <b>text</b></foo>
			@endverbatim
			GetText() will return ""This is "".

			WARNING: GetText() accesses a child node - don't become confused with the
					 similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are
					 safe type casts on the referenced node.
		*/
		const char* GetText() const;

		/// Creates a new Element and returns it - the returned element is a copy.
		TiXmlNode* Clone() const override;

		// Print the Element to a FILE stream.
		void Print(FILE* cfile, int depth) const override;

		/*	Attribtue parsing starts: next char past '<'
							 returns: next char past '>'
		*/
		const char* Parse(const char* p, ParsingData* data, Encoding encoding) override;

		const Element* ToElement() const override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.
		Element* ToElement() override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.

		/** Walk the XML tree visiting this node and all of its children.
		*/
		bool Accept(TiXmlVisitor* visitor) const override;

	protected:

		void CopyTo(Element* target) const;

		void ClearThis();    // like clear, but initializes 'this' object as well

		// Used to be public [internal use]

		void StreamIn(std::istream* in, std::string* tag) override;

		/*	[internal use]
			Reads the ""value"" of the element -- another element, or text.
			This should terminate with the current end tag.
		*/
		const char* ReadValue(const char* in, ParsingData* prevData, Encoding encoding);

	private:

		TiXmlAttributeSet attributeSet;
	};


/**	An XML comment.
*/
	class Comment : public TiXmlNode
	{
	public:
		/// Constructs an empty comment.
		Comment() : TiXmlNode(TiXmlNode::COMMENT)
		{
		}

		/// Construct a comment from text.
		explicit Comment(const char* _value) : TiXmlNode(TiXmlNode::COMMENT)
		{
			SetValue(_value);
		}

		Comment(const Comment&);

		void operator=(const Comment& base);

		~Comment() override = default;

		/// Returns a copy of this Comment.
		TiXmlNode* Clone() const override;

		// Write this Comment to a FILE stream.
		void Print(FILE* cfile, int depth) const override;

		/*	Attribtue parsing starts: at the ! of the !--
							 returns: next char past '>'
		*/
		const char* Parse(const char* p, ParsingData* data, Encoding encoding) override;

		const Comment* ToComment() const override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.
		Comment* ToComment() override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.

		/** Walk the XML tree visiting this node and all of its children.
		*/
		bool Accept(TiXmlVisitor* visitor) const override;

	protected:
		void CopyTo(Comment* target) const;

		// used to be public
		void StreamIn(std::istream* in, std::string* tag) override;

//	virtual void StreamOut( TIXML_OSTREAM * out ) const;

	private:

	};


/** XML text. A text node can have 2 ways to output the next. ""normal"" output
	and CDATA. It will default to the mode it was parsed from the XML file and
	you generally want to leave it alone, but you can change the output mode with
	SetCDATA() and query it with CDATA().
*/
	class Text : public TiXmlNode
	{
		friend class Element;

	public:
		/** Constructor for text element. By default, it is treated as
			normal, encoded text. If you want it be output as a CDATA text
			element, set the parameter _cdata to 'true'
		*/
		explicit Text(const char* initValue) : TiXmlNode(TiXmlNode::TEXT)
		{
			SetValue(initValue);
			cdata = false;
		}

		~Text() override = default;

		/// Constructor.
		explicit Text(const std::string& initValue) : TiXmlNode(TiXmlNode::TEXT)
		{
			SetValue(initValue);
			cdata = false;
		}

		Text(const Text& copy) : TiXmlNode(TiXmlNode::TEXT)
		{
			copy.CopyTo(this);
		}

		void operator=(const Text& base)
		{
			base.CopyTo(this);
		}

		// Write this text object to a FILE stream.
		void Print(FILE* cfile, int depth) const override;

		/// Queries whether this represents text using a CDATA section.
		bool CDATA() const
		{
			return cdata;
		}

		/// Turns on or off a CDATA representation of text.
		void SetCDATA(bool _cdata)
		{
			cdata = _cdata;
		}

		const char* Parse(const char* p, ParsingData* data, Encoding encoding) override;

		const Text* ToText() const override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.
		Text* ToText() override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.

		/** Walk the XML tree visiting this node and all of its children.
		*/
		bool Accept(TiXmlVisitor* content) const override;

	protected :
		///  [internal use] Creates a new Element and returns it.
		TiXmlNode* Clone() const override;

		void CopyTo(Text* target) const;

		bool Blank() const;    // returns true if all white space and new lines
		// [internal use]

		void StreamIn(std::istream* in, std::string* tag) override;

	private:
		bool cdata{ };            // true if this should be input and output as a CDATA style text element
	};


/** In correct XML the declaration is the first entry in the file.
	@verbatim
		<?xml version=""1.0"" standalone=""yes""?>
	@endverbatim

	TinyXml will happily read or write files without a declaration,
	however. There are 3 possible attributes to the declaration:
	version, encoding, and standalone.

	Note: In this version of the code, the attributes are
	handled as special cases, not generic attributes, simply
	because there can only be at most 3 and they are always the same.
*/
	class Declaration : public TiXmlNode
	{
	public:
		/// Construct an empty declaration.
		Declaration() : TiXmlNode(TiXmlNode::DECLARATION)
		{
		}

		/// Constructor.
		Declaration(const std::string& _version,
				const std::string& _encoding,
				const std::string& _standalone);

		/// Construct.
		Declaration(const char* _version,
				const char* _encoding,
				const char* _standalone);

		Declaration(const Declaration& copy);

		void operator=(const Declaration& copy);

		~Declaration() override = default;

		/// GetVersion. Will return an empty string if none was found.
		const char* GetVersion() const
		{
			return version.c_str();
		}

		/// GetEncoding. Will return an empty string if none was found.
		const char* GetEncoding() const
		{
			return encoding.c_str();
		}

		/// Is this a standalone document?
		const char* GetStandalone() const
		{
			return standalone.c_str();
		}

		/// Creates a copy of this Declaration and returns it.
		TiXmlNode* Clone() const override;

		// Print this declaration to a FILE stream.
		virtual void Print(FILE* cfile, int depth, std::string* str) const;

		void Print(FILE* cfile, int depth) const override
		{
			Print(cfile, depth, nullptr);
		}

		const char* Parse(const char* p, ParsingData* data, Encoding encoding) override;

		const Declaration* ToDeclaration() const override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.
		Declaration* ToDeclaration() override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.

		/** Walk the XML tree visiting this node and all of its children.
		*/
		bool Accept(TiXmlVisitor* visitor) const override;

	protected:
		void CopyTo(Declaration* target) const;
		// used to be public

		void StreamIn(std::istream* in, std::string* tag) override;

	private:

		std::string version;
		std::string encoding;
		std::string standalone;
	};

/** A stylesheet reference looks like this:
	@verbatim
		<?xml-stylesheet type=""text/xsl"" href=""style.xsl""?>
	@endverbatim

	Note: In this version of the code, the attributes are
	handled as special cases, not generic attributes, simply
	because there can only be at most 2 and they are always the same.
*/
	class StylesheetReference : public TiXmlNode
	{
	public:
		/// Construct an empty declaration.
		StylesheetReference() : TiXmlNode(TiXmlNode::STYLESHEETREFERENCE)
		{
		}

		/// Constructor.
		StylesheetReference(const std::string& _type,
				const std::string& _href);

		/// Construct.
		StylesheetReference(const char* _type,
				const char* _href);

		StylesheetReference(const StylesheetReference& copy);

		void operator=(const StylesheetReference& copy);

		~StylesheetReference() override = default;

		/// Type. Will return an empty string if none was found.
		const char* Type() const
		{
			return type.c_str();
		}

		/// Href. Will return an empty string if none was found.
		const char* Href() const
		{
			return href.c_str();
		}

		/// Creates a copy of this StylesheetReference and returns it.
		TiXmlNode* Clone() const override;

		// Print this declaration to a FILE stream.
		virtual void Print(FILE* cfile, int depth, std::string* str) const;

		void Print(FILE* cfile, int depth) const override
		{
			Print(cfile, depth, 0);
		}

		const char* Parse(const char* p, ParsingData* data, Encoding encoding) override;

		const StylesheetReference* ToStylesheetReference() const override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.
		StylesheetReference* ToStylesheetReference() override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.

		/** Walk the XML tree visiting this node and all of its children.
		*/
		bool Accept(TiXmlVisitor* visitor) const override;

	protected:
		void CopyTo(StylesheetReference* target) const;
		// used to be public

		void StreamIn(std::istream* in, std::string* tag) override;

	private:

		std::string type;
		std::string href;
	};

/** Any tag that tinyXml doesn't recognize is saved as an
	unknown. It is a tag of text, but should not be modified.
	It will be written back to the XML, unchanged, when the file
	is saved.

	DTD tags get thrown into TiXmlUnknowns.
*/
	class Unknown : public TiXmlNode
	{
	public:
		Unknown() : TiXmlNode(TiXmlNode::UNKNOWN)
		{
		}

		~Unknown() override = default;

		Unknown(const Unknown& copy) : TiXmlNode(TiXmlNode::UNKNOWN)
		{
			copy.CopyTo(this);
		}

		void operator=(const Unknown& copy)
		{
			copy.CopyTo(this);
		}

		/// Creates a copy of this Unknown and returns it.
		TiXmlNode* Clone() const override;

		// Print this Unknown to a FILE stream.
		void Print(FILE* cfile, int depth) const override;

		const char* Parse(const char* p, ParsingData* data, Encoding encoding) override;

		const Unknown* ToUnknown() const override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.
		Unknown* ToUnknown() override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.

		/** Walk the XML tree visiting this node and all of its children.
		*/
		bool Accept(TiXmlVisitor* content) const override;

	protected:
		void CopyTo(Unknown* target) const;

		void StreamIn(std::istream* in, std::string* tag) override;

	private:

	};


/** Always the top level node. A document binds together all the
	XML pieces. It can be saved, loaded, and printed to the screen.
	The 'value' of a document node is the xml file name.
*/
	class Document : public TiXmlNode
	{
	public:
		/// Create an empty document, that has no name.
		Document();

		/// Create a document with a name. The name of the document is also the filename of the xml.
		explicit Document(const char* documentName);

		/// Constructor.
		explicit Document(const std::string& documentName);

		Document(const Document& copy);

		void operator=(const Document& copy);

		~Document() override = default;

		/** Load a file using the current document value.
			Returns true if successful. Will delete any existing
			document data before loading.
		*/
		bool LoadFile(Encoding encoding = DEFAULT_ENCODING);

		/// Save a file using the current document value. Returns true if successful.
		bool SaveFile() const;

		/// Load a file using the given filename. Returns true if successful.
		bool LoadFile(const char* filename, Encoding encoding = DEFAULT_ENCODING);

		/// Save a file using the given filename. Returns true if successful.
		bool SaveFile(const char* filename) const;

		/** Load a file using the given FILE*. Returns true if successful. Note that this method
			doesn't stream - the entire object pointed at by the FILE*
			will be interpreted as an XML file. TinyXML doesn't stream in XML from the current
			file location. Streaming may be added in the future.
		*/
		bool LoadFile(FILE*, Encoding encoding = DEFAULT_ENCODING);

		/// Save a file using the given FILE*. Returns true if successful.
		bool SaveFile(FILE*) const;

		bool LoadFile(const std::string& filename,
				Encoding encoding = DEFAULT_ENCODING)            ///< STL std::string version.
		{
//		StringToBuffer f( filename );
//		return ( f.buffer && LoadFile( f.buffer, encoding ));
			return LoadFile(filename.c_str(), encoding);
		}

		bool SaveFile(const std::string& filename) const        ///< STL std::string version.
		{
//		StringToBuffer f( filename );
//		return ( f.buffer && SaveFile( f.buffer ));
			return SaveFile(filename.c_str());
		}

		/** Parse the given null terminated block of xml data. Passing in an encoding to this
			method (either TIXML_ENCODING_LEGACY or TIXML_ENCODING_UTF8 will force TinyXml
			to use that encoding, regardless of what TinyXml might otherwise try to detect.
		*/
		const char*
		Parse(const char* p, ParsingData* data = 0, Encoding encoding = DEFAULT_ENCODING) override;

		/** Get the root element -- the only top level element -- of the document.
			In well formed XML, there should only be one. TinyXml is tolerant of
			multiple elements at the document level.
		*/
		const Element* RootElement() const
		{
			return FirstChildElement();
		}

		Element* RootElement()
		{
			return FirstChildElement();
		}

		/** If an error occurs, Error will be set to true. Also,
			- The ErrorId() will contain the integer identifier of the error (not generally useful)
			- The ErrorDesc() method will return the name of the error. (very useful)
			- The ErrorRow() and ErrorCol() will return the location of the error (if known)
		*/
		bool Error() const
		{
			return error;
		}

		/// Contains a textual (english) description of the error if one occurs.
		const char* ErrorDesc() const
		{
			return errorDesc.c_str();
		}

		/** Generally, you probably want the error string ( ErrorDesc() ). But if you
			prefer the ErrorId, this function will fetch it.
		*/
		int ErrorId() const
		{
			return errorId;
		}

		/** Returns the location (if known) of the error. The first column is column 1,
			and the first row is row 1. A value of 0 means the row and column wasn't applicable
			(memory errors, for example, have no row/column) or the parser lost the error. (An
			error in the error reporting, in that case.)

			@sa SetTabSize, Row, Column
		*/
		int ErrorRow() const
		{
			return errorLocation.row + 1;
		}

		int ErrorCol() const
		{
			return errorLocation.col + 1;
		}    ///< The column where the error occured. See ErrorRow()

		/** SetTabSize() allows the error reporting functions (ErrorRow() and ErrorCol())
			to report the correct values for row and column. It does not change the output
			or input in any way.

			By calling this method, with a tab size
			greater than 0, the row and column of each node and attribute is stored
			when the file is loaded. Very useful for tracking the DOM back in to
			the source file.

			The tab size is required for calculating the location of nodes. If not
			set, the default of 4 is used. The tabsize is set per document. Setting
			the tabsize to 0 disables row/column tracking.

			Note that row and column tracking is not supported when using operator>>.

			The tab size needs to be enabled before the parse or load. Correct usage:
			@verbatim
			Document doc;
			doc.SetTabSize( 8 );
			doc.Load( ""myfile.xml"" );
			@endverbatim

			@sa Row, Column
		*/
		void SetTabSize(int  [MASK] )
		{
			tabsize =  [MASK] ;
		}

		int TabSize() const
		{
			return tabsize;
		}

		/** If you have handled the error, it can be reset with this call. The error
			state is automatically cleared if you Parse a new XML block.
		*/
		void ClearError()
		{
			error = false;
			errorId = 0;
			errorDesc = """";
			errorLocation.row = errorLocation.col = 0;
			//errorLocation.last = 0;
		}

		/** Write the document to standard out using formatted printing (""pretty print""). */
		void Print() const
		{
			Print(stdout, 0);
		}

		/* Write the document to a string using formatted printing (""pretty print""). This
			will allocate a character array (new char[]) and return it as a pointer. The
			calling code pust call delete[] on the return char* to avoid a memory leak.
		*/
		//char* PrintToMemory() const;

		/// Print this Document to a FILE stream.
		void Print(FILE* cfile, int depth = 0) const override;

		// [internal use]
		void SetError(int err, const char* errorLocation, ParsingData* prevData, Encoding encoding);

		const Document* ToDocument() const override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.
		Document* ToDocument() override
		{
			return this;
		} ///< Cast to a more defined type. Will return null not of the requested type.

		/** Walk the XML tree visiting this node and all of its children.
		*/
		bool Accept(TiXmlVisitor* content) const override;

	protected :
		// [internal use]
		TiXmlNode* Clone() const override;

		void StreamIn(std::istream* in, std::string* tag) override;

	private:
		void CopyTo(Document* target) const;

		bool error;
		int errorId;
		std::string errorDesc;
		int tabsize;
		TiXmlCursor errorLocation;
		bool useMicrosoftBOM;        // the UTF-8 BOM were found when read. Note this, and try to write.
	};

}

#endif",_tabsize
852,"/*
 * common.cpp
 * 公共方法接口
 *
 *  Created on: 2018年1月1日
 *      Author: Lzy
 */
#include ""common.h""
#include <QWidget>
#include <QHeaderView>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <QApplication>



void cm_ClipBoardSet(const QString &str)
{
    QClipboard *board = QApplication::clipboard();//使用 QApplication::clipboard() 函数获得系统剪贴板对象。这个函数的返回值是 QClipboard 指针。
    board->setText(str); //通过 setText()，setImage() 或者 setPixmap() 函数可以将数据放置到剪贴板内，也就是通常所说的剪贴或者复制的操作；
}

QString cm_ClipBoardGet()
{
    QClipboard *board = QApplication::clipboard();
    return board->text(); //使用text()，image() 或者 pixmap() 函数则可以从剪贴板获得数据，也就是粘贴
}

/***
  *判断一个字符串是否为纯数字
  */
bool cm_isDigitStr(const QString &src)
{
    QByteArray ba = src.toLatin1();//QString 转换为 char*
    const char *s = ba.data();

    while(*s && *s>='0' && *s<='9') s++;

    if (*s) //不是纯数字
        return false;

    return true;
}

/**
 * @brief 是否为IP地址
 * @param ip
 * @return
 */
bool cm_isIPaddress(const QString& ip)
{
    QRegExp  [MASK] (""\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b"");
    if( [MASK] .exactMatch(ip))
        return true ;

    return false;
}


/**
 * @brief 转16进制
 * @param array
 * @return
 */
QString cm_ByteArrayToHexStr(const QByteArray &array)
{
    QString strArray = array.toHex().toUpper(); // 十六进制
    for(int i=0; i<array.size(); ++i)
        strArray.insert(2+3*i, ' '); // 插入空格
    return strArray;
}

/**
 * @brief 转十进制
 * @param array
 * @return
 */
QString cm_ByteArrayToUcharStr(const QByteArray &array)
{
    QString strArray ;
    for(int i=0; i<array.size(); ++i)
        strArray += QString::number((uchar)array.at(i)) + "" "";  // 十进制
    return strArray;
}



",regExp
853,"#include ""Game.h""
#include ""GameObject.h""
#include ""PerlinNoiseGenerator.h""

GameObject* player;
const char* playerFilePath;
GameObject* clipboardObject;
const char* clipboardFilePath;
SDL_Renderer* Game::renderer = nullptr;

// Perlin Noise
PerlinNoiseGenerator* noise1D;
PerlinNoiseGenerator* noise2D;

// Game constructor
Game::Game()
{
	isRunning = false;
}

// Game destructor
Game::~Game()
{

}

// We made an init function to ""start"" the Game class
void Game::init(const char* title, int  [MASK] , int ypos, bool fullscreen)
{
	playerFilePath = ""assets/Alien_Robot.png"";
	clipboardFilePath = ""assets/Clipboard.png"";

	// Set screen dimensions to our Game Instance so it can be used elsewhere

	int flags = 0;
	// If the fullscreen parameter in the call to init above is true,
	// make the flags == fullscreen to pass into SDL_CreateWindow()
	if (fullscreen)
	{
		flags = SDL_WINDOW_FULLSCREEN;
	}

	if (SDL_Init(SDL_INIT_EVERYTHING) == 0)
	{
		std::cout << ""Subsystems Initialized..."" << std::endl;
		// Create window
		window = SDL_CreateWindow(title,  [MASK] , ypos, Game::width, Game::height, flags);
		// Check window was created successfully
		if (window)
		{
			std::cout << ""Window created..."" << std::endl;
		}

		// Create the renderer
		renderer = SDL_CreateRenderer(window, -1, 0);
		// Check renderer was created successfully
		if (renderer)
		{
			// Set the render color (to white in this case)
			SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
			std::cout << ""Renderer created..."" << std::endl;
		}

		isRunning = true;
	}
	else {
		isRunning = false;
	}

	player = new GameObject(playerFilePath, 50, 50);
	clipboardObject = new GameObject(clipboardFilePath, 200, 200);

	// Perlin noise business
	//noise1D = new PerlinNoiseGenerator();
	//noise1D->Draw1DNoise();
	noise2D = new PerlinNoiseGenerator();
	noise2D->Draw2DNoise();

	for (int i = 0; i < Game::width / noise2D->divider * Game::height / noise2D->divider; i++)
	{
		noise2D->objectArray2D[i]->Update();
	}
}

void Game::handleEvents()
{
	// Create an SDL_Event and Poll the event
	SDL_Event event;

	// While there are events in the que, SDL_PollEvent() will return 1
	// When there are no events left in the que, SDL_PollEvent() returns 0;
	// So while there are still events in the que, we poll them one at a time and check them
	while (SDL_PollEvent(&event))
	{
		// Check what type of event it is
		switch (event.type)
		{
		case SDL_QUIT:
			isRunning = false;
			break;

		case SDL_KEYDOWN:
			switch (event.key.keysym.scancode)
			{
			case 89:
				std::cout << ""Pressed 1"" << std::endl;
				break;

			case 90:
				std::cout << ""Pressed 2"" << std::endl;
				break;

			case 91:
				std::cout << ""Pressed 3"" << std::endl;
				break;

			case 92:
				std::cout << ""Pressed 4"" << std::endl;
				noise2D->Draw2DNoise();

				for (int i = 0; i < Game::width / noise2D->divider * Game::height / noise2D->divider; i++)
				{
					noise2D->objectArray2D[i]->Update();
				}
				break;
			}
			break;

		case SDL_MOUSEMOTION:

			break;
		default:
			break;
		}
	}
}

void Game::update()
{
	// Call the Update function of our gameObjects
	//player->Update();
	//clipboardObject->Update();
	//for (int i = 0; i < 256; i++)
	//{
	//	noise1D->objectArray1D[i]->Update();
	//}
}

void Game::render()
{
	// Clear the renderer of what's already on it
	SDL_RenderClear(renderer);
	
	// Call the Render functions of gameObjects
	//player->Render();
	//clipboardObject->Render();

	//for (int i = 0; i < 256; i++)
	//{
	//	noise1D->objectArray1D[i]->Render();
	//}

	for (int i = 0; i < Game::width / noise2D->divider * Game::height / noise2D->divider; i++)
	{
		noise2D->objectArray2D[i]->Render();
	}



	// Add new stuff to the renderer
	SDL_RenderPresent(renderer);
	//std::cout << ""Delaying 20000"" << std::endl;
	//SDL_Delay(20000);
}

void Game::clean()
{
	// Destroy the window and renderer and then quit on clean();
	SDL_DestroyWindow(window);
	SDL_DestroyRenderer(renderer);
	SDL_Quit();
	std::cout << ""Game cleaned..."" << std::endl;
}

bool Game::running() { return isRunning; }
",xpos
854,"#include<string>
#include<iostream>
#include<vector>
#include<fstream>
#include<sstream>
#include<cstdlib>
#include<ctime>
using namespace std;



int main()
{

	/*
		srand(time(NULL));
		string temp;
		string file_name;
		string out_file_name;
		int set_effect;
		cout << ""What .ppm file should I open?"" << endl;
		cin >> file_name;
		cout << endl;
		cout << ""What file should be our destination?"" << endl;
		cin >> out_file_name;


		ofstream fout;
		fout.open(out_file_name);
		ifstream fin;
		fin.open(file_name);

		fout.good();

		string starting_info;

		getline(fin, starting_info);
		fout << starting_info << endl;
		getline(fin, starting_info, ' ');
		fout << starting_info << ' ';
		getline(fin, starting_info);
		fout << starting_info << endl;
		getline(fin, starting_info);
		fout << starting_info << endl;


		vector<string> data{};

		while (fin.good() == true)
		{
			getline(fin, temp);

			data.push_back(temp);
		}

		vector<string> numbers{};
		vector<string> separated{};
		int i = 0;
		string number;

		while (i < (data.size()-1))
		{
			stringstream ss;
			ss << data[i];
			while (ss.good() == true)
			{
				getline(ss, number, ' ');

				separated.push_back(number);
			}

			i++;
		}
		i = 0;

		while (i < (separated.size() -1))
		{
			if (separated[i] != "" "" && separated[i] != """")
			{
				numbers.push_back(separated[i]);
			}
			i++;
		}
		*/
	srand(time(NULL));
	string temp;
	string file_name;
	string out_file_name;
	int set_effect;
	cout << ""What .ppm file should I open?"" << endl;
	cin >> file_name;
	cout << endl;
	cout << ""What file should be our destination?"" << endl;
	cin >> out_file_name;


	ofstream fout;
	fout.open(out_file_name);
	ifstream fin;
	fin.open(file_name);

	fout.good();

	string file_type;
	string width;
	string height;
	string max_val;
	getline(fin, file_type);
	fout << file_type << endl;
	getline(fin, width, ' ');
	getline(fin, height);
	getline(fin, max_val);
	
	
	int tot_width = stoi(width) * 3;

	vector<vector<string>> numbers{};
	temp = """";
	int i = 1;
	int x = 0;
	string temporary;
	vector<string> data{};
	while (fin.good())
	{
		getline(fin, temp);
		stringstream ss;
		ss << temp;
		while (ss.good())
		{
			getline(ss, temporary, ' ');
			if (temporary != "" "" && temporary != """")
			{
				data.push_back(temporary);

				if (data.size() == tot_width)
				{
					numbers.push_back(data);
					data = vector<string>{};
				}
				
			}
		}
		
	}


	int flip_width;
	bool  [MASK]  = true;
	char user_input = 'y';
	int flip_counter = 0;
	int j = 0;
	while ( [MASK] )
	{

		cout << ""What should I do to the image?"" << endl;
		cout << ""1. Remove Red"" << endl << ""2. Remove Blue"" << endl;
		cout << ""3. Remove Green"" << endl << ""4. Negate Red"" << endl;
		cout << ""5. Negate Blue"" << endl << ""6. Negate Green"" << endl;
		cout << ""7. Set to Grayscale"" << endl << ""8. Random noise"" << endl;
		cout << ""9. High contrast"" << endl << ""10. Flip horizontally"" << endl;
		cout << ""11. Flip vertically"" << endl << ""12. blur"" << endl;
		cout << ""13. Pixilate"" << endl << ""14. Rotate right"" << endl;
		cout << ""15. ??? (note: use as last effect only)"" << endl;
		cin >> set_effect;

		i = 0;
		j = 0;
		if (set_effect == 1)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < (stoi(width) * 3))
				{
					if (j % 3 == 0)
					{
						numbers[i][j] = '0';
					}
					j++;
				}
				i++;
			}
		}

		i = 0;
		j = 0;
		if (set_effect == 2)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if ((j - 1) % 3 == 0)
					{
						numbers[i][j] = '0';
					}
					j++;
				}

				i++;
			}
		}

		i = 0;
		j = 0;
		if (set_effect == 3)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if ((j - 2) % 3 == 0)
					{
						numbers[i][j] = '0';
					}
					j++;
				}

				i++;
			}
		}


		i = 0;
		j = 0;
		if (set_effect == 4)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if ((j) % 3 == 0)
					{

						int temp_num = (255 - stoi(numbers[i][j]));
						numbers[i][j] = to_string(temp_num);
					}
					j++;
				}
				i++;
			}
		}



		i = 0;
		j = 0;
		if (set_effect == 5)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if ((j - 1) % 3 == 0)
					{
						int temp_num = (255 - stoi(numbers[i][j]));
						numbers[i][j] = to_string(temp_num);
					}
					j++;
				}
				i++;
			}
		}


		i = 0;
		j = 0;
		if (set_effect == 6)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if ((j - 2) % 3 == 0)
					{
						int temp_num = (255 - stoi(numbers[i][j]));
						numbers[i][j] = to_string(temp_num);
					}
					j++;
				}
				i += 1;
			}
		}


		i = 0;
		j = 0;
		if (set_effect == 7)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if (j % 3 == 0)
					{
						int temp_num = ((stoi(numbers[i][j]) + stoi(numbers[i][j + 1]) + stoi(numbers[i][j + 2])) / 3);

						numbers[i][j] = temp_num;
						numbers[i][j + 1] = temp_num;
						numbers[i][j + 2] = temp_num;
					}
					j++;
				}
				i++;
			}
		}

		int rand_num = 0;
		int num_1;
		int num_2;
		int num_3;

		i = 0;
		j = 0;
		if (set_effect == 8)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if (j % 3 == 0)
					{
						rand_num = ((rand() % 14) - 7);
						num_1 = stoi(numbers[i][j]) + rand_num;
						num_2 = stoi(numbers[i][j + 1]) + rand_num;
						num_3 = stoi(numbers[i][j + 2]) + rand_num;

						if (num_1 < 0)
						{
							num_1 = 0;
						}
						else if (num_1 > 255)
						{
							num_1 = 255;
						}

						if (num_2 < 0)
						{
							num_2 = 0;
						}
						else if (num_2 > 255)
						{
							num_2 = 255;
						}

						if (num_3 < 0)
						{
							num_3 = 0;
						}
						else if (num_3 > 255)
						{
							num_3 = 255;
						}

						numbers[i][j] = to_string(num_1);
						numbers[i][j + 1] = to_string(num_2);
						numbers[i][j + 2] = to_string(num_3);
					}
					j++;
				}
				i++;
			}
		}

		i = 0;
		j = 0;
		if (set_effect == 9)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				while (j < tot_width)
				{
					if (stoi(numbers[i][j]) > 127)
					{
						numbers[i][j] = ""255"";
					}
					else
					{
						numbers[i][j] = ""0"";
					}
					j++;
				}
				i++;
			}
		}

		i = 0;

		if (set_effect == 10)
		{
			while (i < (numbers.size() - 1))
			{
				j = 0;
				vector<string> tp;
				while (j < tot_width)
				{
					if (j % 3 == 0)
					{
						tp.push_back(numbers[i][tot_width - (j + 3)]);
						tp.push_back(numbers[i][tot_width - (j + 2)]);
						tp.push_back(numbers[i][tot_width - (j + 1)]);
					}

					j++;
				}
				numbers[i] = tp;
				i++;
			}
		}


		i = 0;
		int p = 0;
		if (set_effect == 11)
		{
			vector<vector<string>> other;
			while (i < numbers.size())
			{
				j = 0;
				vector<string> tp;
				while (j < tot_width)
				{
					tp.push_back(numbers[numbers.size() - (i + 1)][j]);
					j++;
				}
				other.push_back(tp);
				i++;
			}
			i = 0;
			while (i < numbers.size())
			{
				numbers[i] = other[i];
				i++;
			}
		}

		i = 0;
		j = 0;
		if (set_effect == 12)
		{
			while (i < numbers.size())
			{
				j = 0;
				while (j < tot_width)
				{
					if (j <= 2)
					{
						numbers[i][j] = to_string((stoi(numbers[i][j]) + stoi(numbers[i][3])) / 2);
					}
					else if (j > tot_width - 4)
					{
						numbers[i][j] = to_string((stoi(numbers[i][j]) + stoi(numbers[i][j - 3])) / 2);
					}
					else
					{
						numbers[i][j] = to_string( (stoi(numbers[i][j]) + stoi(numbers[i][j + 3]) + stoi(numbers[i][j - 3])) / 3);
					}
					j++;
				}
				i++;
			}

			i = 0;
			while (i < numbers.size())
			{
				j = 0;
				while (j < tot_width)
				{
					if (i == 0)
					{
						numbers[i][j] = to_string((stoi(numbers[i][j]) + stoi(numbers[1][j])) / 2);
					}
					else if (i == numbers.size() - 1)
					{
						numbers[i][j] = to_string( (stoi(numbers[i][j]) + stoi(numbers[i - 1][j]) ) / 2);
					}
					else
					{
						numbers[i][j] = to_string( (stoi(numbers[i][j]) + stoi(numbers[i - 1][j]) + stoi(numbers[i + 1][j])) / 3);
					}
					j++;
				}
				i++;
			}
		}
	
		flip_width = numbers.size();

		i = 0;
		j = 0;
		if (set_effect == 13)
		{
			while (i < numbers.size())
			{
				if (i % 2 == 0)
				{
					j = 0;
					while (j < tot_width - 1)
					{
						if (j % 6 == 0)
						{
							string pix_val=numbers[i][j];
							string pix_val2 = numbers[i][j + 1];
							string pix_val3 = numbers[i][j + 2];
							numbers[i][j + 3] = pix_val;
							numbers[i][j + 4] = pix_val2;
							numbers[i][j + 5] = pix_val3;
							numbers[i + 1][j] = pix_val;
							numbers[i + 1][j + 1] = pix_val2;
							numbers[i + 1][j + 2] = pix_val3;
							numbers[i + 1][j + 3] = pix_val;
							numbers[i + 1][j + 4] = pix_val2;
							numbers[i + 1][j + 5] = pix_val3;
						
						}
						j++;
					}
				}
				i++;
			}
		}
		int j_counter;
		if (flip_counter % 2 == 0)
		{
			j_counter = tot_width;
		}
		else
		{
			j_counter = stoi(height)*3;
		}


		vector<vector<string>> temp_;
		j = 0;
		if (set_effect == 14)
		{

			
			while (j < j_counter)
			{
				vector<string> rot_;
				i = numbers.size()-1;
				
					while (i >= 0)
					{
						if (j % 3 == 0) 
						{
							rot_.push_back(numbers[i][j]);
							rot_.push_back(numbers[i][j + 1]);
							rot_.push_back(numbers[i][j + 2]);
						}
						i--;
					}
					if (j % 3 == 0)
					{
						temp_.push_back(rot_);
					}
					j++;
			}

			numbers = temp_;
			flip_counter++;
		}
		cout << ""would you like to continue? (y to continue anything else to quit)"" << endl;
		cin >> user_input;

		if (user_input != 'y')
		{
			 [MASK]  = false;
		}

	}

	i = 0;
	j = 0;
	if(set_effect == 15)
	{
		fout << width << "" "" << height << endl;
		fout << max_val << endl;
		for (i = 0; i < numbers.size(); i++)
		{
			j = 0;
			while (j < tot_width - 3)
			{
				fout << numbers[i][j] << "" "";
				j++;
			}
			fout << endl;
		}
	}
	else if (flip_counter % 2 == 0)
	{
		fout << width << "" "" << height << endl;
		fout << max_val << endl;
		for (i = 0; i < numbers.size(); i++)
		{
			j = 0;
			while (j < tot_width)
			{
				fout << numbers[i][j] << "" "";


				j++;
			}
			fout << endl;
		}
	}
	else
	{
		fout << height << "" "" << width << endl;
		fout << max_val << endl;
		for (i = 0; i < numbers.size(); i++)
		{
			j = 0;
			while (j < flip_width*3)
			{
				fout << numbers[i][j] << "" "";
				j++;
			}
		fout << endl;
		}
	}

	





	fin.close();
	fout.close();


	return 0;
}",_continue
855,"#pragma once
#include <thread>

#if _WIN32
#include ""platform/windows/host_info.hpp""
namespace asa { namespace api = windows; }
#elif _AIX
#include ""platform/aix/host_info.hpp""
namespace asa { namespace api = aix; }
#else
#include ""platform/posix/host_info.hpp""
namespace asa { namespace api = posix; }
#endif

namespace asa {

class host {
public:
    using network_card_t = api::network_card_t;
    using card_flow = api::card_flow;
    using card_name = api::card_name;
    using cpu_occupy = api::cpu_occupy;
    using disk_info = api::disk_info;

public:
    auto os_info(std::error_code& ec) {
        return api::get_os_info(ec);
    }

    auto hostname(std::error_code& ec) {
        return api::get_hostname(ec);
    }

    auto get_cpu_occupy(std::error_code& ec) {
        return api::get_cpu_occupy(ec);
    }

    auto calculate_cpu_usage(const cpu_occupy& pre, const cpu_occupy& now) {
        return api::calculate_cpu_usage(pre, now);
    }

    auto memory_usage(std::error_code& ec) {
        return api::get_memory_usage(ec);
    }

    auto network_card(std::error_code& ec) {
        return api::get_network_card(ec);
    }

    auto is_physics_network_card(const std::string& card_name) {
        return api::is_physics(card_name);
    }

    auto calculate_network_card_speed(uint32_t  [MASK] ,
        const card_flow& pre_flow, const card_flow& now_flow)
    {
        card_flow speed;
        for (const auto& [name, pair] : pre_flow) {
            auto it = now_flow.find(name);
            if (it == now_flow.end()) {
                continue; //network_card not match
            }
            auto& now = it->second;
            auto& pre = pair;
#if _WIN32
            auto recive = (static_cast<DWORD>(now.first) - static_cast<DWORD>(pre.first)) /  [MASK] ; //recive
            auto transmit = (static_cast<DWORD>(now.second) - static_cast<DWORD>(pre.second)) /  [MASK] ; //transmit
#else
            auto recive = (now.first - pre.first) /  [MASK] ; //recive
            auto transmit = (now.second - pre.second) /  [MASK] ; //transmit
#endif        
            speed.emplace(name, std::pair{ recive, transmit });
        }
        return speed;
    }

    auto get_network_card_flow(const card_name& names, std::error_code& ec) {
        return api::get_network_card_flow(names, ec);
    }

    auto get_network_card_flow(const network_card_t& cards, std::error_code& ec) {
        return api::get_network_card_flow(cards, ec);
    }

    auto get_disk_info(std::string_view name, std::error_code& ec) {
        return api::get_disk_info(name, ec);
    }

    auto get_route_table(std::error_code& ec) {
        return api::get_route_table(ec);
    }

    auto get_tcp_used_port(std::error_code& ec) {
        return api::tcp_used_port(ec);
    }

    auto get_env(std::string_view name, std::error_code& ec) {
        return api::get_environment_variable(name, ec);
    }
};

}
",interval_s
856,"#ifndef ANIMATIONCOMPONENT_H
#define ANIMATIONCOMPONENT_H

class AnimationComponent
{
private:
	class Animation
	{
	public:
		//Variables
		Sprite& sprite;
		Texture& textureSheet;
		float animationTimer;
		float timer;
		bool done;
		int width;
		int height;
		IntRect startRect;
		IntRect currentRect;
		IntRect endRect;

		Animation(Sprite& sprite, Texture& texture_sheet, 
			float animation_timer, 
			int start_frame_x, int start_frame_y, int frames_x, int frames_y, int width, int height)
			: sprite(sprite), textureSheet(texture_sheet), 
			animationTimer(animation_timer), timer(0.f), done(false),
			width(width), height(height)
		{
			this->startRect = IntRect(start_frame_x * width, start_frame_y * height, width, height);
			this->currentRect = this->startRect;
			this->endRect = IntRect(frames_x * width, frames_y * height, width, height);

			this->sprite.setTexture(this->textureSheet, true);
			this->sprite.setTextureRect(this->startRect);
		}

		//Accessor
		const bool& isDone() const
		{
			return this->done;
		}

		//Functions
		const bool& play(const float& dt)
		{
			//Update timer
			this->done = false;
			this->timer += 100.f * dt;
			if (this->timer >= this->animationTimer)
			{
				//reset timer
				this->timer = 0.f;

				//Animate
				if (this->currentRect != this->endRect)
				{
					this->currentRect.left += this->width;
				}
				else //Reset
				{
					this->currentRect.left = this->startRect.left;
					this->done = true;
				}

				this->sprite.setTextureRect(this->currentRect);
			}

			return this->done;
		}

		const bool& play(const float& dt, float  [MASK] )
		{
			//Update timer
			if ( [MASK]  < 0.5f)
				 [MASK]  = 0.5f;

			this->done = false;
			this->timer +=  [MASK]  * 100.f * dt;
			if (this->timer >= this->animationTimer)
			{
				//reset timer
				this->timer = 0.f;

				//Animate
				if (this->currentRect != this->endRect)
				{
					this->currentRect.left += this->width;
				}
				else //Reset
				{
					this->currentRect.left = this->startRect.left;
					this->done = true;
				}

				this->sprite.setTextureRect(this->currentRect);
			}

			return this->done;
		}

		void reset()
		{
			this->timer = this->animationTimer;
			this->currentRect = this->startRect;
		}
	};

	Sprite& sprite;
	Texture& textureSheet;
	map<string, Animation*> animations;
	Animation* lastAnimation;
	Animation* priorityAnimation;

public:
	AnimationComponent(Sprite& sprite, Texture& texture_sheet);
	virtual ~AnimationComponent();

	//Accessor
	const bool& isDone(const string key);

	//Functions
	void addAnimation(const string key, 
		float animation_timer,
		int start_frame_x, int start_frame_y, int frames_x, int frames_y, int width, int height);

	const bool& play(const string key, const float& dt, const bool priority = false);
	const bool& play(const string key, const float& dt, const float& modifier, const float& modifier_max, const bool priority = false);
};

#endif
",mod_percent
857,"// Dummy CPU intensive app

extern ""C"" {
#include <base/hash.h>
#include <base/log.h>
#include <runtime/runtime.h>
#include <runtime/smalloc.h>
#include <runtime/storage.h>
}

#include ""thread.h""
#include ""timer.h""

#include <iostream>

uint64_t g_runtime_sec;

void MainHandler(void */*arg*/)
{
    barrier();
    auto start_ts = microtime();
    barrier();
  
    uint64_t stop_ts = start_ts + (g_runtime_sec+5)*1000000LL;

    rt::Sleep(5 * 1000 * 1000);

    uint64_t  [MASK]  = 0;
    while(true)
    {
         [MASK] ++;
        if( [MASK]  % 1000000LL == 0)
        {
            barrier();
            auto ts = microtime();
            barrier();

            if(ts >= stop_ts)
            {
                break;
            }
        }
    }

    printf(""spins/sec: %lf\n"", ((double)  [MASK] )/((double) g_runtime_sec));
}


int main(int argc, char *argv[]) {
  if (argc < 3) {
    fprintf(stderr,
            ""usage: ./cpu_intensive [cfg] [runtime-in-secs]\n"");
    return -EINVAL;
  }

  g_runtime_sec = std::strtoll(argv[2], nullptr, 0);
  

  int ret = runtime_init(argv[1], MainHandler, NULL);
  if (ret) printf(""failed to start runtime\n"");

  return ret;
}",spin_cnt
858,"#include <limits>
#include<algorithm>
#include <iostream>
#include ""ray-tracer.h""
#include <opencv2/opencv.hpp>

namespace MD {

  void make_ray(const raytracer & context, int x, int y, ray3 & ray) {

    double nx = context.width;
    double ny = context.height;

    double l =  -nx / (2 * nx);
    double r =   nx / (2 * nx);
    double b =  -ny / (2 * nx);
    double t =   ny / (2 * nx);

    double d = .5;

    double u = l + (r-l)*(x + .5) / nx;
    double v = b + (t-b)*(y + .5) / ny;

    ray.origin = context.location;

    ray.direction = (context.basis[2] * d) +
      (context.basis[0] * u) +
      (context.basis[1] * v);

    ray.direction.normalize();

  }



  int trace_pixel(const raytracer & context, int x, int y, color & result) {

    ray3 ray;
    make_ray(context, x, y, ray);
    int obj_index = -1;
    double min_distance = std::numeric_limits<double>::max();
    vec3 normal;
    vec3 intersection_point;

    for (int i = 0; i< context.objects.size(); i++) {
      double distance = std::numeric_limits<double>::max();
      vec3 tmp_normal;
      vec3 tmp_intersection_point;
      if (context.objects[i]->intersect(ray,  distance, tmp_normal, tmp_intersection_point)) {
        if (distance < min_distance) {
          normal = tmp_normal;
          intersection_point = tmp_intersection_point;
          min_distance = distance;
          obj_index = i;
        }
      }
    }

    if(obj_index == -1) {

      result.red = 128;
      result.green = 128;
      result.blue = 128;

    } else {
      vec3 v = ray.origin - intersection_point;
      double intensity = 0.0;
      for (int i = 0; i < context.sources.size(); i++) {
        vec3 light = (context.sources[i].position - intersection_point);

        vec3 h = (light + v) * (1/ (light.mag() + v.mag()));

        light.normalize();
        h.normalize();
        normal.normalize();
        double blinn_phong = .2*pow(normal * h, 2);
        if (blinn_phong < 0.0) blinn_phong = 0.0;

        intensity += (.5*std::max(0.0, (light * normal))) + blinn_phong;
      }
      result = context.objects[obj_index]->get_color();
      result.brighten(intensity + .2);
    }

    return 0;
  }

  void render(const raytracer & context) {
    cv::Mat image(context.height, context.width, CV_8UC3);
    cv::Mat imageDownsize(context.height/2, context.width/2, CV_8UC3);
    for (int x = 0; x < context.width; x++) {
      for (int y = 0; y < context.height; y++) {
        color c;

        cv::Vec3b color = image.at<cv::Vec3b>(cv::Point(x,y));

        color.val[0] = c.red;
        color.val[1] = c.green;
        color.val[2] = c.blue;

        trace_pixel(context, x, y, c);
        image.at<cv::Vec3b>(cv::Point(x,y)) = color;

      }
    }
    cv::resize(image, imageDownsize, imageDownsize.size(), cv::INTER_CUBIC);
    cv::imwrite(""output.tiff"", imageDownsize);

  }


}

int main(int argc, char ** argv) {
  MD::raytracer tracer;

  tracer.location = {0, -2, 0};

  tracer.basis[0] = {1,0,0};
  tracer.basis[1] = {0,0,1};
  tracer.basis[2] = {0,1,0};

  tracer.height = 500*2;
  tracer.width = 500*2;

  MD::color red =  {0x10, 0x10, 0xff};
  MD::color blue = {0xff, 0x10, 0x10};

  MD::vec3 origin =  {-2,5,0};
  MD::vec3 origin2 = {4,8,0};

  MD::vec3 frame000 = {0, 0, 0};
  MD::vec3 frame001 = {0, 0, 1};
  MD::vec3  [MASK]  = {0, 1, 0};
  MD::vec3 frame100 = {1, 0, 0};

  MD::sphere s1 = {origin,  1, red};
  MD::sphere s2 = {origin2, 1, blue};

  MD::sphere o =  {frame000,  .1, red};
  MD::sphere ax = {frame001,  .1, red};
  MD::sphere ay = { [MASK] ,  .1, red};
  MD::sphere az = {frame100,  .1, red};


  MD::triangle t1{ red,
    {0,  0, -.5 },
    {0,  1, -.5},
    {-1,  0, -.5}
  };

  MD::triangle t2{ red,
    {0,  0, -1 },
    {2,  0, -.5},
    {2,  2, -.5}
  };


  MD::vec3 l1_loc = {-4, 0, 7};
  MD::color white = {255, 255, 255};

  MD::lightsource l1 = {l1_loc, white};

  tracer.objects.push_back(&s1);
  tracer.objects.push_back(&s2);
  tracer.objects.push_back(&t1);
  tracer.objects.push_back(&t2);

  /*
     tracer.objects.push_back(&o);
     tracer.objects.push_back(&ax);
     tracer.objects.push_back(&ay);
     tracer.objects.push_back(&az);
   */

  tracer.sources.push_back(l1);
  MD::render(tracer);
}
",frame010
859,"/**
 * \file iconproxymodel.cpp
 * Implement the `IconProxyModel` class
 * 
 * \author <NAME>
 * 
 * \copyright Copyright <NAME> 2018 Distributed under the Boost
 * Software License, Version 1.0. (See accompanying file ../LICENSE_1_0.txt
 * or copy at https://www.boost.org/LICENSE_1_0.txt
 */

#include <QFileSystemModel>
#include <QPixmap>

#include ""iconproxymodel.h""

IconProxyModel::IconProxyModel(QObject* parent) :
        QIdentityProxyModel(parent)
        , m_iconMap()
{
    connect(
        this
        , &IconProxyModel::hasIcon
        , this
        , &IconProxyModel::onIcon);
}

QVariant IconProxyModel::data(const QModelIndex & index, int  [MASK] ) const
{
    // Only substitute an Icon when a File Icon is requested
    if ( [MASK]  == QFileSystemModel::FileIconRole)
    {
        // Grab the path data, and if we already have an icon for this file
        // in our map, return that one.
        auto path = index.data(QFileSystemModel::FilePathRole).toString();
        auto it = m_iconMap.find(path);

        if (it != m_iconMap.end())
        {
            if (! it->isNull()) return *it;
            return QIdentityProxyModel::data(index,  [MASK] );
        }
        else
        {
            // We don't have the icon in our map, so load it asynchronously.
            // For now, we return an empty variant. When the image icon has
            // been loaded, `hasIcon` will be emitted.
            QPersistentModelIndex pIndex{index};
            QtConcurrent::run([this,path,pIndex]{
                emit hasIcon(
                    path
                    , QIcon(QPixmap(path))
                    , pIndex);
            });

            return QVariant{};
        }
    }
    else return QIdentityProxyModel::data(index,  [MASK] );
}   // end data method

void IconProxyModel::onIcon(
        const QString& path
        , const QIcon& icon
        , const QPersistentModelIndex& index)
    {
        m_iconMap.insert(path, icon);
        emit dataChanged(
            index
            , index
            , QVector<int>{QFileSystemModel::FileIconRole});
    }        
",role
860,"#include""SceneNode.hpp""

void SceneNode::attachChild(ScenePtr child) {
    child->mParent = this;
    mChildren.push_back(std::move(child));
}


SceneNode::ScenePtr SceneNode::detachChild(const SceneNode& node) {
    auto  [MASK]  = std::find_if(mChildren.begin(), mChildren.end(),
    [&] (ScenePtr& p) -> bool { return p.get() == &node; });

    assert( [MASK]  != mChildren.end());

    ScenePtr result = std::move(* [MASK] );
    result->mParent = nullptr;
    mChildren.erase( [MASK] );
    return result;
}

void SceneNode::draw(sf::RenderTarget& target, sf::RenderStates states) const {
    states.transform *= getTransform();

    drawCurrent(target, states);

    for (const ScenePtr& child : mChildren) {
        child->draw(target, states);
    }
}

void SceneNode::drawCurrent(sf::RenderTarget& target, sf::RenderStates states) const {
    target.draw(mSprite, states);
}

void SceneNode::update(sf::Time dt) {
    updateCurrent(dt);
    updateChildren(dt);
}

void SceneNode::updateCurrent(sf::Time dt) {

}

void SceneNode::updateChildren(sf::Time dt) {
    for (auto& child : mChildren) {
        child->update(dt);
    }
}

sf::Transform SceneNode::getWorldTransform() const {
    sf::Transform transform = sf::Transform::Identity;

    for (const SceneNode* node = this; node != nullptr; node = node->mParent) {
        transform = node->getTransform() * transform;
    }

    return transform;
}

sf::Vector2f SceneNode::getWorldPosition() const {
    return getWorldTransform() * sf::Vector2f();
}",found
861,"/*
 * Copyright (C) PrivateWeb Software (https://github.com/PrivateWebSoftware) - All Rights Reserved
 *
 * Licensed under the Apache License 2.0 (the ""License""). You may not use
 * this file except in compliance with the License. You can obtain a copy
 * in the file LICENSE in the source distribution
 */

#include <QGuiApplication>
#include <QQmlApplicationEngine>

#include <PWLottieItem.h>

int main(int argc, char* argv[])
{
    QGuiApplication app(argc, argv);

    QQmlApplicationEngine  [MASK] ;
    QObject::connect(
        & [MASK] , &QQmlApplicationEngine::objectCreationFailed, &app, []() {
            QCoreApplication::exit(-1);
        },
        Qt::QueuedConnection);

    /* Initialize PWLottieControllers if we need them */
    initializePWLottieControllers;

     [MASK] .loadFromModule(""PWLottieExample"", ""Main"");

    return app.exec();
}
",engine
862,"/*
 * Copyright (C) 2015 The Scorpion Programming Language
 *
 * 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.
 *
 * Portions of the code surrounded by ""// Begin Dalvik code"" and
 * ""// END Delvik code"" are copyrighted and licensed separately, as
 * follows:
 *
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. The ASF licenses this file to You
 * 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 ALOG
#define ALOG

#include <string>
#include <iostream>
#include <sstream>
#include ""Log.h""
#include ""../clib/filestream.h""
using namespace std;

 
 #define SCORPION_DEVELOPMENT

 class ALog {
   int precedence;
   string file, stackmsg, Class, BaseClass;
   bool on;
   long bufferthreshold;
   
   public:
     void setup(int p){
         string SCORPION_LOG_OUTPUT;
         #ifdef SCORPION_DEVELOPMENT
            SCORPION_LOG_OUTPUT = ""/usr/share/scorpion/vm/log/out.log"";
         #endif
         #ifdef SCORPION_RUNTIME
            SCORPION_LOG_OUTPUT = ""/usr/share/scorpion/sre/vm/log/out.log"";
         #endif
         
         file = SCORPION_LOG_OUTPUT;
         bufferthreshold = 126 * (1000);  // 126 kb
         Class = ""System"";
         BaseClass = Class;
         on = true;

         int  [MASK]  = FileStream::out(file.c_str(), """");

         if( [MASK]  != 0){
            cout << ""warning: I/O err, unable to open system log file!\n"";
            on = false; // we do this to skip logging
            return;
         }
         else if(p == ASSERT+1)
            on=false;
            
         precedence = p;
         stackmsg = """";
         stackmsg += ""=======System Dev Log begin=======\n"";
     }
     void setClass(string name){
         Class = name;
     }
     string getFile(){
        return file;
     }
     void ALOGA(string message){
         stackmsg = Log::a(Class, message, file, on, stackmsg, precedence);
         if(stackmsg.size() >= bufferthreshold)
            stackmsg = """";
         Class = BaseClass;
     }
     void ALOGE(string message){
         stackmsg = Log::e(Class, message, file, on, stackmsg, precedence);
         if(stackmsg.size() >= bufferthreshold)
            stackmsg = """";
         Class = BaseClass;
     }
     void ALOGW(string message){
         stackmsg = Log::w(Class, message, file, on, stackmsg, precedence);  
         if(stackmsg.size() >= bufferthreshold)
            stackmsg = """";
         Class = BaseClass;
     }
     void ALOGI(string message){
         stackmsg = Log::i(Class, message, file, on, stackmsg, precedence);
         if(stackmsg.size() >= bufferthreshold)
            stackmsg = """";
         Class = BaseClass; 
     }
     void ALOGD(string message){
         stackmsg = Log::d(Class, message, file, on, stackmsg, precedence);
         if(stackmsg.size() >= bufferthreshold)
            stackmsg = """";
         Class = BaseClass;  
     }
     void ALOGV(string message){
         stackmsg = Log::v(Class, message, file, on, stackmsg, precedence);  
         if(stackmsg.size() >= bufferthreshold)
            stackmsg = """";
         Class = BaseClass;
     }
 };

 extern ALog alog;

#endif // ALOG
",status
863,"
extern ""C"" {
#include ""ffplay.h""

#define MAX_AUDIO_FRME_SIZE  2 * 44100

/**
 * flush pkt
 */
static AVPacket flush_pkt;

static int av_sync_type = AV_SYNC_AUDIO_MASTER;

void global_init() {
    /**
     * register
     */
    av_register_all();

    avformat_network_init();

    /**
     * init flush pkt
     */
    av_init_packet(&flush_pkt);

    flush_pkt.data = (uint8_t *) &flush_pkt;
}

static void packet_queue_flush(PacketQueue *q) {
    MyAVPacketList *pkt, *pkt1;

    SDL_LockMutex(q->mutex);
    for (pkt = q->first_pkt; pkt; pkt = pkt1) {
        pkt1 = pkt->next;
        av_free_packet(&pkt->pkt);
        av_freep(&pkt);
    }
    q->last_pkt = NULL;
    q->first_pkt = NULL;
    q->nb_packets = 0;
    q->size = 0;
    SDL_UnlockMutex(q->mutex);
}

static void packet_queue_destroy(PacketQueue *q) {
    packet_queue_flush(q);
    SDL_DestroyMutex(q->mutex);
    SDL_DestroyCond(q->cond);
}

static void frame_queue_unref_item(Frame *vp) {
    av_frame_unref(vp->frame);
    avsubtitle_free(&vp->sub);
}

static void free_picture(Frame *vp) {
    if (vp->bmp) {
//        SDL_FreeYUVOverlay(vp->bmp);
        vp->bmp = NULL;
    }
}

static void frame_queue_destory(FrameQueue *f) {
    int i;
    for (i = 0; i < f->max_size; i++) {
        Frame *vp = &f->queue[i];
        frame_queue_unref_item(vp);
        av_frame_free(&vp->frame);
        free_picture(vp);
    }
    SDL_DestroyMutex(f->mutex);
    SDL_DestroyCond(f->cond);
}

static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last) {
    int i;
    memset(f, 0, sizeof(FrameQueue));
    if (!(f->mutex = SDL_CreateMutex()))
        return AVERROR(ENOMEM);
    if (!(f->cond = SDL_CreateCond()))
        return AVERROR(ENOMEM);
    f->pktq = pktq;
    f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
    f->keep_last = !!keep_last;
    for (i = 0; i < f->max_size; i++)
        if (!(f->queue[i].frame = av_frame_alloc()))
            return AVERROR(ENOMEM);
    return 0;
}

/* packet queue handling */
static void packet_queue_init(PacketQueue *q) {
    memset(q, 0, sizeof(PacketQueue));
    q->mutex = SDL_CreateMutex();
    q->cond = SDL_CreateCond();
    q->abort_request = 1;
}

static void stream_close(VideoState *is) {
    /* XXX: use a special url_shutdown call to abort parse cleanly */
    is->abort_request = 1;
    SDL_WaitThread(is->read_tid, NULL);
    packet_queue_destroy(&is->videoq);
    packet_queue_destroy(&is->audioq);
    packet_queue_destroy(&is->subtitleq);

    /* free all pictures */
    frame_queue_destory(&is->pictq);
    frame_queue_destory(&is->sampq);
    frame_queue_destory(&is->subpq);
    SDL_DestroyCond(is->continue_read_thread);
#if !CONFIG_AVFILTER
    sws_freeContext(is->img_convert_ctx);
#endif
    av_free(is);
}

static void set_clock_at(Clock *c, double pts, int serial, double time) {
    c->pts = pts;
    c->last_updated = time;
    c->pts_drift = c->pts - time;
    c->serial = serial;
}

static void set_clock(Clock *c, double pts, int serial) {
    double time = av_gettime_relative() / 1000000.0;
    set_clock_at(c, pts, serial, time);
}

static void init_clock(Clock *c, int *queue_serial) {
    c->speed = 1.0;
    c->paused = 0;
    c->queue_serial = queue_serial;
    set_clock(c, NAN, -1);
}

/* this thread gets the stream from the disk or the network */
static int read_thread(void *arg) {

}

static VideoState *stream_open(const char *filename, AVInputFormat *iformat) {
    VideoState *is;
    is = (VideoState *) av_mallocz(sizeof(VideoState));
    if (!is)
        return NULL;
    av_strlcpy(is->filename, filename, sizeof(is->filename));
    is->iformat = iformat;
    is->ytop = 0;
    is->xleft = 0;

    /* start video display */
    if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
        goto fail;
    if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
        goto fail;
    if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
        goto fail;

    packet_queue_init(&is->videoq);
    packet_queue_init(&is->audioq);
    packet_queue_init(&is->subtitleq);

    is->continue_read_thread = SDL_CreateCond();

    init_clock(&is->vidclk, &is->videoq.serial);
    init_clock(&is->audclk, &is->audioq.serial);
    init_clock(&is->extclk, &is->extclk.serial);
    is->audio_clock_serial = -1;
    is->av_sync_type = av_sync_type;
    is->read_tid = SDL_CreateThreadEx(&is->_read_tid, read_thread, is, ""ff_read"");

    if (!is->read_tid) {
        fail:
        stream_close(is);
        return NULL;
    }
    return is;
}

/**
 * just for learning
 *
 * @param env
 * @param jobj
 * @param url
 * @param surface
 * @return
 */
jint TestPlay(JNIEnv *env, jobject jobj, jstring url, jobject surface) {
    int i;

    AVCodecContext *vCodecCtx;
    AVCodecContext *aCodecCtx;

    AVPacket *avPacket;
    AVFrame *avFrame, *pFrameRGBA;
    SwsContext *img_convert_ctx;
    AVFormatContext *pFormatCtx;

    ANativeWindow *nativeWindow;
    ANativeWindow_Buffer windowBuffer;
    uint8_t *v_out_buffer;

    AVCodec *vCodec;
    AVCodec *aCodec;

    char input_str[3000] = {0};
    //读取输入的视频频文件地址
    sprintf(input_str, ""%s"", env->GetStringUTFChars(url, NULL));
    //初始化
    av_register_all();
    //分配一个AVFormatContext结构
    pFormatCtx = avformat_alloc_context();
    //打开文件
    LOGI(""TestPlay input_str:%s"", input_str);
    if (avformat_open_input(&pFormatCtx, input_str, NULL, NULL) != 0) {
        LOGD(""Couldn't open input stream.\n"");
        return -1;
    }
    //查找文件的流信息
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        LOGD(""Couldn't find stream information.\n"");
        return -1;
    }
    //在流信息中找到视频流
    int videoindex = -1;
    int audioindex = -1;

    for (i = 0; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoindex = i;
            LOGD(""find videoindex %d.\n"", videoindex);
        }
        if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            audioindex = i;
            LOGD(""find audioindex %d.\n"", audioindex);
        }
    }

    if (videoindex == -1) {
        LOGD(""Couldn't find a video stream.\n"");
        return -1;
    }

    if (audioindex == -1) {
        LOGD(""Couldn't find a audio stream.\n"");
        return -1;
    }

    //获取相应视频流的解码器
    vCodecCtx = pFormatCtx->streams[videoindex]->codec;
    vCodec = avcodec_find_decoder(vCodecCtx->codec_id);

    aCodecCtx = pFormatCtx->streams[audioindex]->codec;
    aCodec = avcodec_find_decoder(aCodecCtx->codec_id);

    assert(vCodec != NULL);
    assert(aCodec != NULL);

    LOGD(""avcodec_find_decoder vCodec name:%s\n"", vCodec->name);
    LOGD(""avcodec_find_decoder aCodec name:%s\n"", aCodec->name);

    LOGD(""read container width-height:%d-%d\n"", vCodecCtx->width, vCodecCtx->height);

    //打开解码器
    if (avcodec_open2(vCodecCtx, vCodec, NULL) < 0) {
        LOGE(""Couldn't open codec.\n"");
        return -1;
    }

    //打开解码器
    if (avcodec_open2(aCodecCtx, aCodec, NULL) < 0) {
        LOGE(""Couldn't open codec.\n"");
        return -1;
    }

    //获取界面传下来的surface
    nativeWindow = ANativeWindow_fromSurface(env, surface);
    if (0 == nativeWindow) {
        LOGE(""Couldn't get native window from surface.\n"");
        return -1;
    }

    int width = vCodecCtx->width;
    int height = vCodecCtx->height;

    LOGD(""width-height:%d-%d\n"", width, height);
    //分配一个帧指针，指向解码后的原始帧
    avFrame = av_frame_alloc();
    avPacket = (AVPacket *) av_malloc(sizeof(AVPacket));
    pFrameRGBA = av_frame_alloc();
    //绑定输出buffer
    int numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGBA, width, height, 1);
    v_out_buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
    av_image_fill_arrays(pFrameRGBA->data, pFrameRGBA->linesize, v_out_buffer, AV_PIX_FMT_RGBA,
                         width, height, 1);
    img_convert_ctx = sws_getContext(width, height, vCodecCtx->pix_fmt,
                                     width, height, AV_PIX_FMT_RGBA, SWS_BICUBIC, NULL, NULL, NULL);
    if (0 >
        ANativeWindow_setBuffersGeometry(nativeWindow, width, height, WINDOW_FORMAT_RGBA_8888)) {
        LOGE(""Couldn't set buffers geometry.\n"");
        ANativeWindow_release(nativeWindow);
        return -1;
    }

    //frame->16bit  44100 PCM 统一音频采样格式与采样率
    SwrContext *swrCtx = swr_alloc();

    //输入采样率格式
    enum AVSampleFormat in_sample_fmt = aCodecCtx->sample_fmt;
    //输出采样率格式16bit PCM
    enum AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;
    //输入采样率
    int in_sample_rate = aCodecCtx->sample_rate;
    //输出采样率
    int out_sample_rate = 44100;
    //获取输入的声道布局
    //根据声道个数获取默认的声道布局(2个声道，默认立体声)
    //av_get_default_channel_layout(pCodeCtx->channels);
    uint64_t in_ch_layout = aCodecCtx->channel_layout;
    //输出的声道布局
    uint64_t out_ch_layout = AV_CH_LAYOUT_STEREO;


    swr_alloc_set_opts(swrCtx, out_ch_layout, out_sample_fmt, out_sample_rate, in_ch_layout,
                       in_sample_fmt, in_sample_rate, 0, NULL);


    swr_init(swrCtx);

    //获取输入输出的声道个数
    int out_channel_nb = av_get_channel_layout_nb_channels(out_ch_layout);
    LOGI(""out_count:%d"", out_channel_nb);

    jclass cls = env->FindClass(""com/theo/nexplayer/jni/AudioUtil"");
    //jmethodID
    jmethodID constructor_mid = env->GetMethodID(cls, ""<init>"", ""()V"");

    //实例化一个AudioUtil对象(可以在constructor_mid后加参)
    jobject audioutil_obj = env->NewObject(cls,
                                           constructor_mid);   //类似于AudioUtil audioutil =new AudioUtil();

    //AudioTrack对象
    jmethodID create_audio_track_mid = env->GetMethodID(cls, ""createAudioTrack"",
                                                        ""(II)Landroid/media/AudioTrack;"");
    jobject audio_track = env->CallObjectMethod(audioutil_obj, create_audio_track_mid,
                                                out_sample_rate, out_channel_nb);

    //调用AudioTrack.play方法
    jclass audio_track_class = env->GetObjectClass(audio_track);
    jmethodID  [MASK]  = env->GetMethodID(audio_track_class, ""play"", ""()V"");
    env->CallVoidMethod(audio_track,  [MASK] );

    //AudioTrack.write
    jmethodID audio_track_write_mid = env->GetMethodID(audio_track_class, ""write"", ""([BII)I"");

    //16bit 44100 PCM 数据
    uint8_t *out_buffer = (uint8_t *) av_malloc(MAX_AUDIO_FRME_SIZE);

    int got_frame = 0, framecount = 0, ret;
    //读取帧
    while (av_read_frame(pFormatCtx, avPacket) >= 0) {
        LOGD(""av_read_frame"");
        //output audio
        if (avPacket->stream_index == audioindex) {
//解码
            ret = avcodec_decode_audio4(aCodecCtx, avFrame, &got_frame, avPacket);

            if (ret < 0) {
                LOGI(""%s"", ""解码完成"");
                break;
            }
            //非0，正在解码
            if (got_frame > 0) {
                LOGI(""解码：%d"", framecount++);
                swr_convert(swrCtx, &out_buffer, MAX_AUDIO_FRME_SIZE,
                            (const uint8_t **) avFrame->data, avFrame->nb_samples);
                //获取sample的size
                int out_buffer_size = av_samples_get_buffer_size(NULL, out_channel_nb,
                                                                 avFrame->nb_samples,
                                                                 out_sample_fmt, 1);
                //out_buffer 缓冲区数据，转换成byte数组
                jbyteArray audio_sample_array = env->NewByteArray(out_buffer_size);

                jbyte *sample_byte = env->GetByteArrayElements(audio_sample_array, NULL);

                //将out_buffer的数据复制到sample_byte
                memcpy(sample_byte, out_buffer, out_buffer_size);

                //同步数据 同时释放sample_byte
                env->ReleaseByteArrayElements(audio_sample_array, sample_byte, 0);

                //AudioTrack.write PCM数据
                env->CallIntMethod(audio_track, audio_track_write_mid, audio_sample_array, 0,
                                   out_buffer_size);

                //释放局部引用  否则报错JNI ERROR (app bug): local reference table overflow (max=512)
                env->DeleteLocalRef(audio_sample_array);
            }

        }

        //output video
        if (avPacket->stream_index == videoindex) {
            //视频解码
            int ret = avcodec_send_packet(vCodecCtx, avPacket);
            if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
                LOGD(""avcodec_send_packet failed"");
                return -1;
            }
            ret = avcodec_receive_frame(vCodecCtx, avFrame);
            if (ret < 0 && ret != AVERROR_EOF) {
                if (ret == AVERROR(EAGAIN)) {
                    continue;
                }
                LOGD(""avcodec_receive_frame failed ret:%d,%d,%d"", ret, AVERROR_EOF,
                     AVERROR(EAGAIN));
                return -1;
            }
            //转化格式
            sws_scale(img_convert_ctx, (const uint8_t *const *) avFrame->data, avFrame->linesize, 0,
                      vCodecCtx->height,
                      pFrameRGBA->data, pFrameRGBA->linesize);
            if (ANativeWindow_lock(nativeWindow, &windowBuffer, NULL) < 0) {
                LOGD(""cannot lock window"");
            } else {
                //将图像绘制到界面上，注意这里pFrameRGBA一行的像素和windowBuffer一行的像素长度可能不一致
                //需要转换好，否则可能花屏
                uint8_t *dst = (uint8_t *) windowBuffer.bits;
                for (int h = 0; h < height; h++) {
                    memcpy(dst + h * windowBuffer.stride * 4,
                           v_out_buffer + h * pFrameRGBA->linesize[0],
                           pFrameRGBA->linesize[0]);
                }
                ANativeWindow_unlockAndPost(nativeWindow);

            }
        }
        av_packet_unref(avPacket);
    }
    //释放内存
    sws_freeContext(img_convert_ctx);
    av_free(avPacket);
    av_free(avFrame);
    av_free(pFrameRGBA);
    avcodec_close(vCodecCtx);
    avcodec_close(aCodecCtx);
    avformat_close_input(&pFormatCtx);
    return 0;
}

}",audio_track_play_mid
864,"/**
 * @file buffer.cpp
 * @brief  buffer
 * @author Ichheit, <<EMAIL>>
 * @date 2022-08-18
 */
#include ""buffer.h""

#define ERR_EXIT(msg) do { fprintf(stderr, ""[buffer error]: %s\n"", msg); exit(EXIT_FAILURE); } while (0)
#define NOT_ERR_EXIT(exp, msg) do { if (!(exp)) { ERR_EXIT(msg); } } while (0)

namespace wsv
{

Buffer::Buffer(int initBuffSize) : _buffer(initBuffSize, 0), _readPos(0), _writePos(0) {  }

size_t Buffer::writableBytes() const { return _buffer.size() - _writePos; }

size_t Buffer::readableBytes() const { return _writePos-_readPos; }

size_t Buffer::prependableBytes() const { return _readPos; }

char* Buffer::_beginPtr() { return &(*_buffer.begin()); }
const char* Buffer::_beginPtr() const { return &(*_buffer.begin()); }

const char* Buffer::beginWriteConst() const { return _beginPtr() + _writePos; }
char* Buffer::beginWrite() { return _beginPtr() + _writePos; }

void Buffer::_makeSpace(size_t len) {
    if (writableBytes() + prependableBytes() < len) {
        _buffer.resize(_writePos+len+1);
    } else {
        size_t readable = readableBytes();
        std::copy(_beginPtr() + _readPos, _beginPtr()+_writePos, _beginPtr()); // i i o
        _readPos = 0;
        _writePos = _readPos + readable;
        NOT_ERR_EXIT(readable == readableBytes(), ""readable == readableBytes()"");
    }
}

const char* Buffer::peek() const { return _beginPtr() + _readPos; }

void Buffer::ensureWritable(size_t len) { 
    if (writableBytes() < len) 
        _makeSpace(len); 
    NOT_ERR_EXIT(writableBytes() >= len, ""writableBytes() >= len""); 
}

void Buffer::hasWritten(size_t len) { _writePos += len; }

void Buffer::retrieve(size_t len) { 
    NOT_ERR_EXIT(len <= readableBytes(), ""len <= readableBytes()"");
    _readPos += len;
}

void Buffer::retrieveUntil(const char *end) {
    NOT_ERR_EXIT(peek() <= end, ""peek() <= end"");
    retrieve(end - peek());
}

void Buffer::retrieveAll() {
    // memset(&_buffer, 0, _buffer.size());
    _buffer.clear();
    _readPos = 0;
    _writePos = 0;
}

std::string Buffer::retrieveAllToStr() {
    std::string str(peek(), readableBytes());
    retrieveAll();
    return str;
}

// origin
void Buffer::append(const char *str, size_t len) {
    NOT_ERR_EXIT(str, ""append str"");
    ensureWritable(len);
    std::copy(str, str+len, beginWrite()); // to beginWrite()
    hasWritten(len);
}

void Buffer::append(const std::string &str) {
    append(str.data(), str.length());
}

void Buffer::append(const void *data, size_t len) {
    NOT_ERR_EXIT(data, ""append data"");
    append(static_cast<const char*>(data), len);
}

void Buffer::append(const Buffer &buff) { // to buff
    append(buff.peek(), buff.readableBytes());
}

ssize_t Buffer::readFd(int fd, int *Errno) {
    char buff[65535];
    struct iovec iov[2];
    const size_t writable = writableBytes();
    // 分散读
    iov[0].iov_base = _beginPtr() + _writePos;
    iov[0].iov_len = writable;
    iov[1].iov_base = buff;
    iov[1].iov_len = sizeof(buff);

    const ssize_t len = readv(fd, iov, 2);
    if (len < 0) {
        *Errno = errno;
    } else if (static_cast<size_t>(len) <= writable) {
        _writePos += len;
    } else {
        _writePos = _buffer.size();
        append(buff, len - writable);
    }
    return len;
}

ssize_t Buffer::writeFd(int fd, int *Errno) {
    size_t  [MASK]  = readableBytes();
    ssize_t len = write(fd, peek(),  [MASK] );
    if (len < 0) {
        *Errno = errno;
        return len;
    }
    _readPos += len;
    return len;
}

}
",readSize
865,"#ifndef UTILS_H 
#define UTILS_H

#include <string>
#include <vector>
#include <memory>
#include <functional>
#include <fstream>
#include <regex>

namespace Utils
{
    std::vector<std::string> readInput(std::string filePath) {
        std::ifstream file(filePath);
        std::vector<std::string>  [MASK] ;

        while (true) {
            std::string line;
            std::getline(file, line);

            if (!file.eof())  [MASK] .push_back(line);
            else break;
        }

        file.close();

        return  [MASK] ;
    }

    std::string* matches(std::string haystack, std::string needle, int &size) {
        std::smatch matches;

        if (!std::regex_search(haystack, matches, std::regex(needle))) return nullptr;
        
        std::string* ret = new std::string[matches.size()];
        
        for (int i = 0; i < matches.size(); ++i) ret[i] = matches[i];

        size = matches.size();

        return ret;
    }

    template <typename T = std::string>
    std::vector<T> splitString(std::string input,
                               char delimiter = ' ',
                               std::function<T(std::string)> conversionFunction = [](const std::string &str) { return str; } ) {
        std::vector<T> ret;
        std::string builder = """";
        T builderConverted;

        for (char c : input) {
            if (c == delimiter) {
                T builderConverted = conversionFunction(builder);
                ret.push_back(builderConverted);
                builder = """";
                continue;
            }

            builder += c;
        }

        if (input.at(input.length()-1) != delimiter) {
            T builderConverted = conversionFunction(builder);
            ret.push_back(builderConverted);
        }

        return ret;
    }
}

#endif
",lines
866,"#pragma comment(lib, ""comsupp.lib"")
#include ""MSWord.h""
#include ""ComOperate.h""
#include <Ole2.h>
#include <comutil.h>


/*
 * === 特别注意 ===
 * 在使用AutoWrap函数时，如果使用DISPATCH_METHOD,并且带有参数，需要将参数顺序倒过来！
 * 再说一遍，顺序倒过来！
 *
 * MSDN上关于word的VBA操作说明：
 * https://msdn.microsoft.com/EN-US/library/office/ff837519.aspx
 * 声明：MFC生成的部分逻辑在这里不能用！不能用！不能用！因为在功能名的生成过程中，它改名字了！
 * 至于为什么MFC能用，因为它根本就没有执行GetIDsOfNames函数，而是直接传入了DISPID值！
 *
 * 通过COM操作Word的过程中，索引号从1开始，而不是一般编程时候的从0开始！
 */


MSWord::MSWord(bool Visable) : 
	COMInitilized(FALSE),
	Application(NULL),
	Documents(NULL),
	Document(NULL)
{

	// Initialize COM for this thread...
	CoInitialize(NULL);

	// Get CLSID for our server...
	CLSID clsid;
	HRESULT hr = CLSIDFromProgID(L""Word.Application"", &clsid);

	if (FAILED(hr)) {

		::MessageBox(NULL, ""CLSIDFromProgID() failed"", ""Error"", 0x10010);
		return;
	}

	IDispatch * pApp;
	// Start Word.Application by COM
	hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&pApp);
	Application = new ComOperate(pApp);
	Application->pDispatch;
	

	if (FAILED(hr)) {
		::MessageBox(NULL, ""Word not registered properly"", ""Error"", 0x10010);
		return;
	}

	// Make it visible (i.e. app.visible = 1)
	if(Visable)
	{
		VARIANT x;
		x.vt = VT_I4;
		x.lVal = 1;
		AutoWrap(DISPATCH_PROPERTYPUT, NULL, Application->pDispatch, L""Visible"", 1, x);
	}

	// Get Documents collection
	{
		VARIANT result;
		VariantInit(&result);
		AutoWrap(DISPATCH_PROPERTYGET, &result, Application->pDispatch, L""Documents"", 0);

		Documents = new ComOperate(result.pdispVal);
	}

	COMInitilized = true;
}


bool MSWord::Open(WCHAR * FileName) {

	if (!COMInitilized) {
		return false;
	}
	else {
		VARIANT result;
		VariantInit(&result);

		AutoWrap(DISPATCH_METHOD, &result, Documents->pDispatch, L""Open"", 1, _variant_t(FileName));
		Document = new ComOperate(result.pdispVal);

		return result.pdispVal == NULL;
	}
}

IDispatch * MSWord::GoToBookmarkSection(WCHAR * BookmarkName) {

	IDispatch * pSelection = this->GetSelection();

	VARIANT result;
	VariantInit(&result);

	short GoToBookmark = -1;
	AutoWrap(DISPATCH_METHOD, &result, pSelection, L""GoTo"", 4, _variant_t(BookmarkName), vtMissing, vtMissing, _variant_t(GoToBookmark));

	SafeRelease(pSelection);

	return result.pdispVal;
}

void MSWord::InsertText(WCHAR * Text, int FontBold, float FontSize, WCHAR * FontName) {

	IDispatch * pSelection = this->GetSelection(false);

	IDispatch * pFont;
	{
		VARIANT result;
		VariantInit(&result);

		AutoWrap(DISPATCH_PROPERTYGET, &result, pSelection, L""Font"", 0);
		pFont = result.pdispVal;
	}

	AutoWrap(DISPATCH_PROPERTYPUT, NULL, pFont, L""Name"", 1, _variant_t(FontName));

	AutoWrap(DISPATCH_PROPERTYPUT, NULL, pFont, L""Size"", 1, _variant_t(FontSize));

	AutoWrap(DISPATCH_PROPERTYPUT, NULL, pFont, L""Bold"", 1, _variant_t(FontBold));

	AutoWrap(DISPATCH_METHOD, NULL, pSelection, L""TypeText"", 1, _variant_t(Text));

	SafeRelease(pSelection);
}

void MSWord::InsertTextAtBookmark(WCHAR * BookmarkName, WCHAR * Text, int FontBold, float FontSize, WCHAR * FontName) {
	
	IDispatch * pBookmark = this->GoToBookmarkSection(BookmarkName);
	InsertText(Text, FontBold, FontSize, FontName);
	
	SafeRelease(pBookmark);
}

void MSWord::InsertPicture(WCHAR * BookmarkName, WCHAR * FileName, int index, WCHAR * PictureExplaination) {

	WCHAR * Expression = (WCHAR *)malloc(sizeof(WCHAR) * (lstrlenW(PictureExplaination)+3));

	lstrcpynW(Expression, L""\r\n"", 3);
	for (int index = 0; index < lstrlenW(PictureExplaination); index++) Expression[index + 2] = PictureExplaination[index];
	Expression[lstrlenW(PictureExplaination) + 2] = '\0';

	IDispatch *pBookmark = GoToBookmarkSection(BookmarkName);
	this->InsertText(Expression);

	ComOperate InlineShapes = Document->GetSubProperty(L""InlineShapes"");

	AutoWrap(DISPATCH_METHOD, NULL, InlineShapes.pDispatch, L""AddPicture"", 4, _variant_t(pBookmark), _variant_t(true), _variant_t(false), _variant_t(FileName));

	free(Expression);
	SafeRelease(pBookmark);
}

void MSWord::InsertTable(IDispatch * pRange, string_table &DoubleTable) {

	int RowsCount = DoubleTable.capacity();
	int ColumnsCount = DoubleTable[0].capacity();

	ComOperate Tables = Document->GetSubProperty(L""Tables"");

	VARIANT result;
	VariantInit(&result);
	AutoWrap(DISPATCH_METHOD, &result, Tables.pDispatch, L""Add"", 3, _variant_t(ColumnsCount), _variant_t(RowsCount), _variant_t(this->GoToBookmarkSection(L""PID"")));
	ComOperate Table(result.pdispVal);

	Table.GetSubProperty(L""Borders"").SetSimpleProperty(L""Enable"", _variant_t(1));

	ComOperate Range = Table.GetSubProperty(L""Range"");
	Range.GetSubProperty(L""Font"").SetSimpleProperty(L""Size"", _variant_t(10));
	Range.GetSubProperty(L""Font"").SetSimpleProperty(L""Name"", _variant_t(L""宋体""));
	Range.GetSubProperty(L""ParagraphFormat"").SetSimpleProperty(L""Alignment"", _variant_t((short)1));//设置段落对齐
	Range.GetSubProperty(L""Cells"").SetSimpleProperty(L""VerticalAlignment"", _variant_t((short)1));//设置表格元素垂直对齐
	Table.GetSubProperty(L""Rows"").SetSimpleProperty(L""Alignment"", _variant_t((short)1));//表格居中

	for (int RowIndex = 0; RowIndex < RowsCount; RowIndex++) {
		for (int ColumnIndex = 0; ColumnIndex < ColumnsCount; ColumnIndex++) {

			AutoWrap(DISPATCH_METHOD, &result, Table.pDispatch, L""Cell"", 2, _variant_t(ColumnIndex + 1), _variant_t(RowIndex + 1));
			ComOperate Cell(result.pdispVal);

			AutoWrap(DISPATCH_METHOD, NULL, Cell.GetSubProperty(L""Range"").pDispatch, L""InsertAfter"", 1, _variant_t(DoubleTable[RowIndex][ColumnIndex]));
		}
	}
}

bool MSWord::StringFindAndReplace(IDispatch *pRange, WCHAR * Find, WCHAR * Replace, bool WholeContent) {

	if (true == WholeContent) {
		pRange = Document->GetSubProperty(L""Content"").pDispatch;
	}
	
	ComOperate WordFind= ComOperate(pRange).GetSubProperty(L""Find"");

	AutoWrap(DISPATCH_METHOD, NULL, WordFind.pDispatch, L""ClearFormatting"", 0);

	VARIANT result;
	VariantInit(&result);

	const short wdReplaceAll = -2;

	AutoWrap(DISPATCH_METHOD, &result, WordFind.pDispatch, L""Execute"", 11, _variant_t(wdReplaceAll), _variant_t(Replace), vtMissing, vtMissing, vtMissing,
		_variant_t(false), _variant_t(false), vtMissing, _variant_t(true), vtMissing, _variant_t(Find));

	return result.bVal;
}

void MSWord::ReplaceHeaderAndFooter(WCHAR * Find, WCHAR * Replace) {

	ComOperate Sections = Document->GetSubProperty(L""Sections"");

	int SectionsCount;
	VARIANT result;
	VariantInit(&result);
	AutoWrap(DISPATCH_PROPERTYGET, &result, Sections.pDispatch, L""Count"", 0);
	SectionsCount = result.intVal;

	for (int index = 1; index < SectionsCount + 1; index++) {

		// Get section
		AutoWrap(DISPATCH_METHOD, &result, Sections.pDispatch, L""Item"", 1, _variant_t((long)index));
		
		// Get HeadersFooters
		AutoWrap(DISPATCH_PROPERTYGET, &result, result.pdispVal, L""Headers"", 0);

		// Get HeaderFotter
		AutoWrap(DISPATCH_METHOD, &result, result.pdispVal, L""Item"", 1, _variant_t(1));

		// Get Range
		AutoWrap(DISPATCH_PROPERTYGET, &result, result.pdispVal, L""Range"", 0);

		this->StringFindAndReplace(result.pdispVal, Find, Replace, false);
	}
}

void MSWord::UpdateContent() {

	ComOperate TablesOfContents = Document->GetSubProperty(L""TablesOfContents"");

	VARIANT result;
	VariantInit(&result);

	int  [MASK]  = 0;
	AutoWrap(DISPATCH_PROPERTYGET, &result, TablesOfContents.pDispatch, L""Count"", 0);
	 [MASK]  = result.intVal;

	for (int index = 1; index <  [MASK]  + 1; index++) {

		AutoWrap(DISPATCH_METHOD, &result, TablesOfContents.pDispatch, L""Item"", 1, _variant_t((long)index));

		AutoWrap(DISPATCH_METHOD, NULL, result.pdispVal, L""Update"", 0);

		VariantClear(&result);
	}
}

void MSWord::SaveAs(WCHAR * FileName) {
	AutoWrap(DISPATCH_METHOD, NULL, Document->pDispatch, L""SaveAs"", 1, _variant_t(FileName));
}

void MSWord::Quit() {

	const short wdDoNotSaveChanges = 0;
	const short wdOriginalDocumentFormat = 1;

	NULL != Document ? AutoWrap(DISPATCH_METHOD, NULL, Document->pDispatch, L""Close"", 0) : NothingTodo();
	NULL != Application ? AutoWrap(DISPATCH_METHOD, NULL, Application->pDispatch, L""Quit"", 0) : NothingTodo();
}

MSWord::~MSWord() {

	nullptr != Document ? free(Document) : NothingTodo();
	nullptr != Documents ? free(Documents) : NothingTodo();
	nullptr != Application ? free(Application) : NothingTodo();

	// Uninitialize COM for this thread...
	CoUninitialize();
}

IDispatch * MSWord::GetActiveWindow() {

	VARIANT result;
	VariantInit(&result);
	AutoWrap(DISPATCH_PROPERTYGET, &result, Document->pDispatch, L""ActiveWindow"", 0);
	return result.pdispVal;
}

IDispatch * MSWord::GetSelection(bool FromActiveWindow) {

	VARIANT result;
	VariantInit(&result);

	if (FromActiveWindow) {
		IDispatch * pActiveWindow = GetActiveWindow();
		AutoWrap(DISPATCH_PROPERTYGET, &result, pActiveWindow, L""Selection"", 0);
		SafeRelease(pActiveWindow);
	}
	else {
		AutoWrap(DISPATCH_PROPERTYGET, &result, Application->pDispatch, L""Selection"", 0);
	}

	return result.pdispVal;
}


",TableOfContentsCount
867,"/*
Copyright 2018 <NAME>
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.
*/

/// <summary>
/// VERY rudimentary and hacky example of a BLE peripheral.
/// Broadcasts and accepts connection, has a single service
/// (Device Information Service profile) with a single characteristic
/// (Manufacturer Name String).
/// 
/// As much of the setup is done at compile time as possible using
/// C++ templates, with data structures allocated statically.
/// </summary>

#include <nvs_flash.h>
#include <cstring>
#include ""HCIPacket.h""

#include ""RingBufCPP.h""

// queue for send_packet calls
RingBufCPP<void(*)(), 64> ble_cb;

void setup() {
	pinMode(BUILTIN_LED, OUTPUT);
	Serial.begin(921600);
	nvs_flash_init();

	static const esp_vhci_host_callback_t cb = {
		// notify_host_send_available
		[]() {
		},
		// notify_host_recv
		[](uint8_t *data, uint16_t len) -> int {
			if (data[0] == HCIT_TYPE_EVENT) {
				const auto _event = *(EventHeader *)data;

				switch (_event.packet.eventcode) {
				case HCI_DISCONNECTION_COMP_EVT:
					//adv_enable_cmd.send_packet();
					ble_cb.add([]() {
						adv_enable_cmd.send_packet();
					});
					break;
				default:
					break;
				}
			}
			else if (data[0] == HCIT_TYPE_ACL_DATA) {
				auto header = *(ATTHeader *)(data);
				switch (header.packet.data.payload.opcode)
				{
				case GATT_REQ_MTU:
					Serial.println(""GATT_REQ_MTU"");
					ble_cb.add([]() {
						mtu_response.send_packet();
					});
					break;
				case GATT_REQ_READ_BY_GRP_TYPE: {
					Serial.println(""GATT_REQ_READ_BY_GRP_TYPE"");
					auto req = *(TransportPacket<ACLDataPacket<L2CAPPacket<ATTPacket<ReadByGrpReq>>>> *)(data);
					Serial.println();
					if (req.packet.data.payload.parameters.start_handle > 0x0002) {
						ble_cb.add([]() {
							static auto err = error_response;
							err.packet.data.payload.parameters.req_opcode = GATT_REQ_READ_BY_GRP_TYPE;
							err.packet.data.payload.parameters.req_handle = 0x0003;
							err.packet.data.payload.parameters.error_code = GATT_NOT_FOUND;
							err.send_packet();
						});
					}
					static TransportPacket<ACLDataPacket<L2CAPPacket<ATTPacket<ReadByGrpResponse>>>> response;
					response.hci_packet_type = HCIT_TYPE_ACL_DATA;
					response.packet.data.payload.opcode = GATT_RSP_READ_BY_GRP_TYPE;
					response.packet.data.payload.parameters.data = { 0x0001, 0x0003, 0x180a };
					ble_cb.add([]() {
						response.send_packet();
					});
					break;
				}
				case GATT_REQ_FIND_TYPE_VALUE:
					Serial.println(""GATT_REQ_FIND_TYPE_VALUE"");
					break;
				case GATT_REQ_READ_BY_TYPE: {
					Serial.println(""GATT_REQ_READ_BY_TYPE"");
					auto req = *(TransportPacket<ACLDataPacket<L2CAPPacket<ATTPacket<ReadByTypeReq>>>> *)(data);
					Serial.println(req.packet.data.payload.parameters.start_handle, HEX);
					Serial.println(req.packet.data.payload.parameters.end_handle, HEX);
					Serial.println(req.packet.data.payload.parameters.uuid16, HEX);

					if (req.packet.data.payload.parameters.uuid16 == 0x2803 && req.packet.data.payload.parameters.start_handle <= 0x0002)
					{
						ble_cb.add([]() {
							static TransportPacket<ACLDataPacket<L2CAPPacket<ATTPacket<ReadByTypeResponse<Characteristic>>>>> response;
							response.hci_packet_type = HCIT_TYPE_ACL_DATA;
							response.packet.data.payload.opcode = GATT_RSP_READ_BY_TYPE;
							response.packet.data.payload.parameters.data = { 0x0002, 0x02, 0x0003, 0x2A29 };
							response.send_packet();
						});
					}
					else {
						ble_cb.add([]() {
							static auto err = error_response;
							err.packet.data.payload.parameters.req_opcode = GATT_REQ_READ_BY_GRP_TYPE;
							err.packet.data.payload.parameters.req_handle = 0x0003;
							err.packet.data.payload.parameters.error_code = GATT_NOT_FOUND;
							err.send_packet();
						});

					}

					break;
				}
				case GATT_REQ_FIND_INFO:
					Serial.println(""GATT_REQ_FIND_INFO"");
					break;
				case GATT_REQ_READ: {
					struct {
						char name[100] = ""CompanyName"";
					} name;
					static TransportPacket<ACLDataPacket<L2CAPPacket<ATTPacket<ReadByTypeResponse<decltype(name)>>>>> response;
					response.hci_packet_type = HCIT_TYPE_ACL_DATA;
					response.packet.data.payload.opcode = GATT_RSP_READ;
					response.packet.data.payload.parameters.data = name;
					response.send_packet();
					break;
				}
				default:
					Serial.print(""GATT_REQ_UNSUPPORTED: "");
					Serial.println(header.packet.data.payload.opcode, HEX);
					error_response.packet.data.payload.parameters.req_opcode = header.packet.data.payload.opcode;
					//error_response.send_packet();
					ble_cb.add([]() {
						error_response.send_packet();
					});
					break;
				}
			}
			return 0;
	} };
	esp_vhci_host_register_callback(&cb);

	esp_bt_controller_config_t  [MASK]  = BT_CONTROLLER_INIT_CONFIG_DEFAULT()
		;

	esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT);
	esp_bt_controller_init(& [MASK] );
	esp_bt_controller_enable(ESP_BT_MODE_BLE);

	reset_cmd.send_packet();

	adv_param_cmd.send_packet();
	//adv_data_cmd.packet.parameters.append_gap_data(0xff, ""\xff\xfftestdata"");
	adv_data_cmd.packet.parameters.append_gap_data(0x09, ""BLE_test"");
	adv_data_cmd.send_packet();
	adv_enable_cmd.send_packet();
	write_data_length_cmd.send_packet();
}

void loop() {
	
	/// Send packets outside of the VHCI callbacks
	/// since they run on CPU0 and will hang forever
	/// waiting for the previous packet to finish.
	while (!ble_cb.isEmpty()) {
		void(*p)(void);
		ble_cb.pull(&p);
		p();
	}
}
",bt_cfg
868,"/*
*@file : Date.cpp
*
*@author (A) : <NAME>.
*@version : 25-2-2016
*
*Implementation of the Date.h header file
*
*This work is licensed under the
*Creative Commons Attribution-NonCommercial-ShareAlike 4.0
*International License. To view a copy of this license,
*visit http://creativecommons.org/licenses/by-nc-sa/4.0/.
*
*/

#include <iostream>
#include ""Date.h""
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <iomanip>
#include <cstdio>

using namespace std;

DateFormat Date::format;

DateFormat::DateFormat(const char *dateFormat, const char *monthFormat, const char *yearFormat)
{
  //memory allocation
  this->dateFormat=new char[3];
  this->monthFormat=new char[4];
  this->yearFormat=new char[5];
  strcpy(this->dateFormat,dateFormat);
  strcpy(this->monthFormat,monthFormat);
  strcpy(this->yearFormat,yearFormat);
}

DateFormat::DateFormat(const char *format)
{
  char *s;
  char *c1=new char[20];
  strcpy(c1,format);
  char *c=c1;
  int j;
  j=0;
  s=new char[3];
  while(*c!='-')//Storing value till first '-' comes into the day array and covert it to int using atoi()
    {
      s[j++]=*c;
      c++;
    }
  c++;
  s[j]='\0';
  this->dateFormat=s;
  j=0;
  s=new char[4];
  while(*c!='-')//store month similar to storage of day
    {
      s[j++]=*c;
      c++;
    }
  c++;
  s[j]='\0';
  this->monthFormat=s;
  j=0;
  s=new char[5];
  while(*c!='\0')
    {
      s[j++]=*c;
      c++;
    }
  s[j]='\0';
  this->yearFormat=s;
  delete[] c1;
}


DateFormat::DateFormat()
{
  this->dateFormat=new char[3];
  this->monthFormat=new char[4];
  this->yearFormat=new char[5];
  strcpy(this->dateFormat,""dd"");
  strcpy(this->monthFormat,""mmm"");
  strcpy(this->yearFormat,""yy"");
}

DateFormat::~DateFormat()
{
  delete[] this->dateFormat;
  delete[] this->monthFormat;
  delete[] this->yearFormat;
}

char* DateFormat::getdateFormat()
{
  char *temp=new char[5];
  strcpy(temp,this->dateFormat);
  return temp;
}

char* DateFormat::getmonthFormat()
{
  char *temp=new char[5];
  strcpy(temp,this->monthFormat);
  return temp;
}

char* DateFormat::getyearFormat()
{
  char *temp=new char[5];
  strcpy(temp,this->yearFormat);
  return temp;
}

void DateFormat::copy(DateFormat& df)
{
  strcpy(this->dateFormat,df.dateFormat);
  strcpy(this->monthFormat,df.monthFormat);
  strcpy(this->yearFormat,df.yearFormat);
}

Date::Date(Day d, Month m, Year y)
{
  this->day=d;
  this->mon=m;
  this->year=y;
  if(d>31) throw invalid_argument((char*)""Date > 31"");
  if(d<1) throw invalid_argument((char*)""Date < 1"");
  if(m>12) throw invalid_argument((char*)""Month > 12"");
  if(m<1) throw invalid_argument((char*)""Month < 1"");
  if(y>2049||y<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");
  if(d==31&&(m==2||m==4||m==6||m==9||m==11)) throw domain_error((char*)""Date cannot be 31 for given month"");
  if(d==30&&m==2) throw domain_error((char*)""Date cannot be 30 for February"");
  if(d==29&&m==2&&y%4!=0) throw domain_error((char*)""Date can be 29 in February only for leap years"");
}

Date::Date(const char *date)
{
  char c[20];
  char d[8]; //To store the day part of date
  char m[8]; //To store the month part of date
  char yr[8];//To store the year part of date
  strcpy(c,date);
  int j;
  char *s=c;
  char tempV[5];
  j=0;
  while(*s!='-')
    {
      tempV[j]=*s;
      j++;
      s++;
    }
  s++;
  tempV[j]='\0';
  strcpy(d,tempV);
  j=0;
  while(*s!='-')
    {
      tempV[j]=*s;
      j++;
      s++;
    }
  s++;
  tempV[j]='\0';
  strcpy(m,tempV);
  j=0;
  while(*s!='\0')
    {
      tempV[j]=*s;
      j++;
      s++;
    }
  tempV[j]='\0';
  strcpy(yr,tempV);
  
  this->day=Day(atoi(d));

  char* yf=Date::format.getyearFormat();
  char* df=Date::format.getdateFormat();
  char* mf=Date::format.getmonthFormat();

  if(strcmp(mf,""m"")==0
     ||strcmp(mf,""mm"")==0)
    this->mon=Month(atoi(m));
  else if(strcmp(mf,""mmm"")==0)
    { 
      this->mon=cToMon(m);
    }

  if(strcmp(yf,""yy"")==0)
    {
      int y=atoi(yr);
      this->year=(y>=50)?y+=1900:y+=2000;
    }
  else if(strcmp(yf,""yyyy"")==0)
    this->year=atoi(yr);

  delete[] df;
  delete[] mf;
  delete[] yf;

  if(this->day>31) throw invalid_argument((char*)""Date > 31"");
  if(this->day<1) throw invalid_argument((char*)""Date < 1"");
  if(this->mon>12) throw invalid_argument((char*)""Month > 12"");
  if(this->mon<1) throw invalid_argument((char*)""Month < 1"");
  if(this->year>2049||this->year<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");
  if(this->day==31&&(this->mon==2||this->mon==4||this->mon==6||this->mon==9||this->mon==11)) throw domain_error((char*)""Date cannot be 31 for given month"");
  if(this->day==30&&this->mon==2) throw domain_error((char*)""Date cannot be 30 for February"");
  if(this->day==29&&this->mon==2&&(this->year%4!=0)) throw domain_error((char*)""Date can be 29 in February only for leap years"");

}

Date::Date()
{
  time_t t;
  time(&t);
  struct tm *temp_time=localtime(&t);
  this->day=Day(temp_time->tm_mday);
  this->mon=Month(temp_time->tm_mon+1);
  this->year=temp_time->tm_year+1900;
  
  if(this->year>2049||this->year<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");
  if(this->day==31&&(this->mon==2||this->mon==4||this->mon==6||this->mon==9||this->mon==11)) throw domain_error((char*)""Date cannot be 31 for given month"");
  if(this->day==30&&this->mon==2) throw domain_error((char*)""Date cannot be 30 for February"");
  if(this->day==29&&this->mon==2&&this->year%4!=0) throw domain_error((char*)""Date can be 29 in February only for leap years"");
}

Date::Date(const Date& date)
{
  this->day=date.day;
  this->mon=date.mon;
  this->year=date.year;
}

Date::~Date()
{}

Date& Date::operator =(const Date& date)
{
  this->day=date.day;
  this->mon=date.mon;
  this->year=date.year;
  return *this;
}

Date& Date::operator ++()
{
  if(this->day<28){//all dates less than 28 can increase by one day and still remain in that month
    this->day=Day((int)this->day+1);
  }
  else if(this->day==28&&(this->year%4==0||this->mon!=2))
    {
      this->day=Day(29);
    }
  else if(this->day==28&&this->mon==2)
    {
      this->day=Day(1);
        this->mon=Month(3);
    }
    else if(this->day==29&&this->mon==2)
    {
        this->day=Day(1);
        this->mon=Month(3);
    }
    else if(this->day==29)
    {
        this->day=Day(30);
    }
    else if(this->day==30&&(this->mon==4||this->mon==6||this->mon==9||this->mon==11))
    {
        this->day=Day(1);
        this->mon=Month((int)this->mon+1);
    }
    else if(this->day==31&&(this->mon!=12))
    {
        this->day=Day(1);
        this->mon=Month((int)this->mon+1);
    }
    else if(this->day==31)
    {
        this->mon=Month(1);
        this->day=Day(1);
        this->year++;
    }
    else
    {
        this->day=Day(31);
    }

    if(this->year>2049||this->year<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");

    return *this;
}

Date& Date::operator ++(int i)
{
    if(this->day<22){
        this->day=Day((int)this->day+7);
    }
    else if(this->day==22&&(this->year%4==0||this->mon!=2))
    {
        this->day=Day(29);
    }
    else if(this->day==22&&this->mon==2)
    {
        this->day=Day(1);
        this->mon=Month(3);
    }
    else if(this->mon==2&&this->year%4==0)
    {
        this->day=Day((int)this->day-29+7);
        this->mon=Month(3);
    }
    else if(this->mon==2)
    {
        this->day=Day((int)this->day-28+7);
        this->mon=Month(3);
    }
    else if(this->day==23)
    {
        this->day=Day(30);
    }
    else if(this->mon==4||this->mon==6||this->mon==9||this->mon==11)
    {
        this->day=Day((int)this->day-30+7);
        this->mon=Month((int)this->mon+1);
    }
    else if(this->day==24)
    {
        this->day=Day(31);
    }
    else if(this->mon==12)
    {
        this->mon=Month(1);
        this->day=Day((int)this->day-31+7);
        this->year++;
    }
    else
    {
        this->day=Day((int)this->day-31+7);
        this->mon=Month((int)this->mon+1);
    }

    if(this->year>2049||this->year<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");

    return *this;
}

Date& Date::operator--()
{
   if(this->day>1)
     {
       this->day=Day((int)this->day-1);
     }
   else if(this->year%4==0&&this->mon==3)
     {
       this->day=Day(29);
       this->mon=Month(2);
     }
   else if(this->mon==3)
     {
       this->day=Day(28);
       this->mon=Month(2);
     }
   else if(this->mon==5||this->mon==7||this->mon==10||this->mon==12)
     {
       this->day=Day(30);
       this->mon=Month((int)this->mon-1);
     }
   else if(this->mon!=1)
     {
       this->day=Day(31);
       this->mon=Month((int)this->mon-1);
     }
   else
     {
       this->day=Day(31);
       this->mon=Month(12);
       this->year--;
     }

    if(this->year>2049||this->year<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");

   return *this;
}

Date& Date::operator--(int)
{

  if(this->day>7)
    {
      this->day=Day((int)this->day-7);
    }
  else if(this->year%4==0&&this->mon==3)
    {
      this->day=Day(29+(int)this->day-7);
      this->mon=Month(2);
    }
  else if(this->mon==3)
    {
      this->day=Day(28+(int)this->day-7);
      this->mon=Month(2);
    }
  else if(this->mon==5||this->mon==7||this->mon==10||this->mon==12)
    {
      this->day=Day((int)this->day+30-7);
      this->mon=Month((int)this->mon-1);
    }
  else if(this->mon!=1)
    {
      this->mon=Month((int)this->mon-1);
      this->day=Day((int)this->day+31-7);
    }
  else
    {
      this->day=Day((int)this->day+31-7);
      this->mon=Month(12);
      this->year--;
    }

  if(this->year>2049||this->year<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");

  return *this;
}

Date Date::operator+(int  [MASK] )
{
  Date date(*this);
  if( [MASK] >0)
    {
      for(int i=0;i< [MASK] /7;i++)//date++ increases date by 7 so 7*(no_of_days)/7 times
	{
	  date++;
	}
      for(int i=0;i< [MASK] %7;i++)//++date increase date by 1 so no_of_days%7 times
	{
	  ++date;
	}
    } //So totally no_of_days times
  else
    {
       [MASK] *=-1;
      for(int i=0;i< [MASK] /7;i++)
	{
	  date--;
	}
      for(int i=0;i< [MASK] %7;i++)
	{
	  --date;
	}
    }
  
  if(date.year>2049||date.year<1950) throw out_of_range((char*)""Year must be between 1950 and 2049"");
  if(date.day==31&&(date.mon==2||date.mon==4||date.mon==6||date.mon==9||date.mon==11)) throw domain_error((char*)""Date cannot be 31 for given month"");
  if(date.day==30&&date.mon==2) throw domain_error((char*)""Date cannot be 30 for February"");
  if(date.day==29&&date.mon==2&&date.year%4!=0) throw domain_error((char*)""Date can be 29 in February only for leap years"");
  return date;
}

unsigned int Date::operator-(const Date& date)
{
  Date otherDate(date);
  unsigned int days;
  if(otherDate<(*this))
    {
      days=365*(this->year-otherDate.year);
      days+=(this->year-1949)/4-(otherDate.year-1949)/4; //now days = Date(1,1,this->year)-Date(1,1,date.year);
      switch(this->mon)
	{
	case Dec:
	  days+=30;
	case Nov:
	  days+=31;
	case Oct:
	  days+=30;
	case Sep:
	  days+=31;            //Cummulatively adds all the months
	case Aug:
	  days+=31;
	case Jul:
	  days+=30;
	case Jun:
	  days+=31;
	case May:
	  days+=30;
	case Apr:
	  days+=31;
	case Mar:
	  days+=((this->year)%4==0)?29:28;
	case Feb:
	  days+=31;
	case Jan:
	  days+=this->day;
	  break;
	}
      switch(otherDate.mon)
	{
	case Dec:
	  days-=30;
	case Nov:
	  days-=31;
	case Oct:
	  days-=30;
	case Sep:
	  days-=31;
	case Aug:
	  days-=31;
	case Jul:
	  days-=30;
	case Jun:                //Cummulatively deletes all the days from the Smallest year
	  days-=31;
	case May:
	  days-=30;
	case Apr:
	  days-=31;
	case Mar:
	  days-=((otherDate.year)%4==0)?29:28;
	case Feb:
	  days-=31;
	case Jan:
	  days-=otherDate.day;
	  break;
	}
      return days;
    }
  else if(*this==otherDate) return 0;
  else 
    {
      return (otherDate-(*this));
    }
}


Date::operator WeekNumber() const
{
  if(this->mon==12)
    {
      Date temp1(Day(1),Month(1),Year(this->year+1));
      if(WeekDay(temp1)==2&&this->day==31) return WeekNumber(1);
      if(WeekDay(temp1)==3&&this->day>=30) return WeekNumber(1);
      if(WeekDay(temp1)==4&&this->day>=29) return WeekNumber(1);
    }
  Date temp(Day(1),Month(1),this->year);
  unsigned int days=temp-*this;
  int years=this->year-1950;
  int x=7; //Since jan 1 1950 is Sunday x=7
  while(years!=0)
    {
      years--;x++;
      if(years==0) break;
      years--;x++;
      if(years==0) break;
      years--;x++;x++;           //every year day changes by one except when its leap year where it changes by 2
      if(years==0) break;
      years--;x++;
      if(years==0) break;
    }
  WeekDay d=WeekDay((x%7==0)?7:x%7);
  switch(d){
  case Mon:
    x=0;break;
  case Tue:
    x=1;break;
  case Wed:
    x=2;break;
  case Thu:
    x=3;break;
  case Fri:
    x=-3;break;
  case Sat:
    x=-2;break;
  case Sun:
    x=-1;break;
  }
  x+=days;
  if(x<0) return WeekNumber(Date(*this)+(-(x+7))); //For the first few days which are not in the first week of the year
  x/=7;
  return WeekNumber(x+1);
}

Date::operator Month() const
{
  return this->mon;
}

Date::operator WeekDay() const
{
  Date temp(Day(1),Month(1),this->year);
  unsigned int days=temp-*this;
  int years=this->year-1950;
  int x=7; //Since jan 1 1950 is Sunday x=7
  while(years!=0)
    {
      years--;x++;
      if(years==0) break;
      years--;x++;
      if(years==0) break;
      years--;x++;x++;
      if(years==0) break;
      years--;x++;
      if(years==0) break;
    }
  x+=days;
  x=x%7;
  return WeekDay((x==0)?7:x);
}

bool Date::leapYear() const
{
  if((int)this->year%4==0)
    return true;
  else return false;
}

bool Date::operator==(const Date& d)
{
  if(this->day==d.day&&this->mon==d.mon
     &&this->year==d.year)
    return true;
  else return false;
}

bool Date::operator!=(const Date& d)
{
  Date d1(d);
  return !(d1==*this);
}

bool Date::operator<(const Date& date)
{
  Date d(date);
  if(this->year<d.year) return true;
  else if(this->year==d.year)
    {
      if(this->mon<d.mon) return true;
      else if(this->mon==d.mon&&this->day<d.day)return true;
      else return false;
    }
  else return false;
}

bool Date::operator<=(const Date& date)
{
  Date d(date);
  return !(*this>d);
}

bool Date::operator>(const Date& date)
{
  Date d(date);
  if(this->year>d.year) return true;
  else if(this->year==d.year)
    {
      if(this->mon>d.mon) return true;
      else if(this->mon==d.mon&&this->day>d.day)return true;
      else return false;
    }
  else return false;
}

bool Date::operator>=(const Date& date)
{
  Date d(date);
  return !(*this<d);
}

ostream& operator<<(ostream& os,const Date& date)
{

  char* yf=Date::format.getyearFormat();
  char* df=Date::format.getdateFormat();
  char* mf=Date::format.getmonthFormat();

  if(strcmp(df,""d"")==0) //if dateFormat is equal to ""d"" day can be either single digit or double digit
    os<<date.day;
  else if(strcmp(df,""dd"")==0)// if dateFormat is equal to ""dd"" day width must be double digit
    os<<right<<setfill('0')<<setw(2)<<date.day; //setw() decides the width of the day Here it is 2 and setfill() decides what
                                                //to fill it with Here it is 0
  os<<""-"";

  if(strcmp(mf,""m"")==0)
    os<<date.mon;
  else if(strcmp(mf,""mm"")==0) //Similar to day
    os<<right<<setfill('0')<<setw(2)<<date.mon;
  else if(strcmp(mf,""mmm"")==0)
    os<<mstr(date.mon);//prints mon as String

  os<<""-"";

  if(strcmp(yf,""yy"")==0)
    os<<right<<setfill('0')<<setw(2)<<(((int)date.year<2000)?date.year-1900:date.year-2000);
  else if(strcmp(yf,""yyyy"")==0)
    os<<date.year;

  delete[] yf;
  delete[] mf;
  delete[] df;

  return os;
}

istream& operator>>(istream& is,Date& date)
{
  char * input=new char[20];
  is>>input; //takes Date as input string in DateFormat format it is better to print DateFormat whenever asking for input
  Date d(input);
  date.day=d.day;
  date.mon=d.mon;
  date.year=d.year;

  delete[] input;

  return is;
}

void Date::setFormat(DateFormat& df)
{
  Date::format.copy(df);
}

DateFormat& Date::getFormat()
{
  return Date::format;
}

char* mstr(Month m)//To output the Month as char*
{
  switch(m)
    {
    case Jan:return (char*)""Jan"";
    case Feb:return (char*)""Feb"";
    case Mar:return (char*)""Mar"";
    case Apr:return (char*)""Apr"";
    case May:return (char*)""May"";
    case Jun:return (char*)""Jun"";
    case Jul:return (char*)""Jul"";
    case Aug:return (char*)""Aug"";
    case Sep:return (char*)""Sep"";
    case Oct:return (char*)""Oct"";
    case Nov:return (char*)""Nov"";
    case Dec:return (char*)""Dec"";
    }
}

char* wstr(WeekDay w)//To output WeekDay as char*
{
  switch(w)
    {
    case Sun:return (char*)""Sun"";
    case Mon:return (char*)""Mon"";
    case Tue:return (char*)""Tue"";
    case Wed:return (char*)""Wed"";
    case Thu:return (char*)""Thu"";
    case Fri:return (char*)""Fri"";
    case Sat:return (char*)""Sat"";
    }
}

Month cToMon(char * m) //To take the input char* as month
{
  if(strcasecmp(m,""Jan"")==0) return (Month)Jan;
  else if(strcasecmp(m,""Feb"")==0) return (Month)Feb;
  else if(strcasecmp(m,""Mar"")==0) return (Month)Mar;
  else if(strcasecmp(m,""Apr"")==0) return (Month)Apr;
  else if(strcasecmp(m,""May"")==0) return (Month)May;
  else if(strcasecmp(m,""Jun"")==0) return (Month)Jun;
  else if(strcasecmp(m,""Jul"")==0) return (Month)Jul;
  else if(strcasecmp(m,""Aug"")==0) return (Month)Aug;
  else if(strcasecmp(m,""Sep"")==0) return (Month)Sep;
  else if(strcasecmp(m,""Oct"")==0) return (Month)Oct;
  else if(strcasecmp(m,""Nov"")==0) return (Month)Nov;
  else return (Month)Dec;
}

invalid_argument::invalid_argument()
{
  this->error=new char[100];
  strcpy(this->error,""invalid_argument error: One or more of the arguments d or m is/are invalid"");
}

invalid_argument::invalid_argument(char* error)
{
  this->error=new char[100];
  sprintf(this->error,""invalid_argument error: %s"",error);
}

invalid_argument::~invalid_argument() throw()
{
  delete [] this->error;
}

ostream& operator<<(ostream& os,invalid_argument& i_a)
{
  os<<i_a.error<<endl;
  return os;
}

domain_error::domain_error()
{
  this->error=new char[100];
  strcpy(this->error,""domain_error error: (d, m, y) as a triplet does not define a valid date"");
}

domain_error::domain_error(char* error)
{
  this->error=new char[100];
  sprintf(this->error,""domain_error error: %s"",error);
}

domain_error::~domain_error() throw()
{
  delete [] this->error;
}

ostream& operator<<(ostream& os,domain_error& d_e)
{
  os<<d_e.error<<endl;
  return os;
}

out_of_range::out_of_range()
{
  this->error=new char[100];
  strcpy(this->error,""out_of_range error: Date is out of range"");
}

out_of_range::out_of_range(char* error)
{
  this->error=new char[100];
  sprintf(this->error,""out_of_range error: %s"",error);
}

out_of_range::~out_of_range() throw()
{
  delete [] this->error;
}

ostream& operator<<(ostream& os,out_of_range& o_o_r)
{
  os<<o_o_r.error<<endl;
  return os;
}
",noOfDays
869,"//
// Created by huailiang on 2022/5/2.
//

#include ""astc.h""

//#define _DEBUG

int ReadDim(ifstream &ifs) {
    uint8_t dim[3];
    ifs.read((char *) (&dim[0]), sizeof(uint8_t));
    ifs.read((char *) (&dim[1]), sizeof(uint8_t));
    ifs.read((char *) (&dim[2]), sizeof(uint8_t));
    int  [MASK]  = dim[0] + (dim[1] << 8) + (dim[2] << 16);
    return  [MASK] ;
}

bool ReadAstc(const char *path, Astc *astc) {
    ifstream ifs;
    ifs.exceptions(ifstream::failbit | ifstream::badbit);
    try {
        ifs.open(path, ifstream::binary | std::ios::in);
        ifs.clear();
        ifs.seekg(0, ios::beg);
        uint8_t magic[4];
        ifs.read((char *) &magic[0], sizeof(uint8_t));
        ifs.read((char *) &magic[1], sizeof(uint8_t));
        ifs.read((char *) &magic[2], sizeof(uint8_t));
        ifs.read((char *) &magic[3], sizeof(uint8_t));
        if (magic[0] == 0x13 && magic[1] == 0xab && magic[2] == 0xa1 && magic[3] == 0x5c) {
            ifs.read((char *) (&astc->block_x), sizeof(uint8_t));
            ifs.read((char *) (&astc->block_y), sizeof(uint8_t));
            ifs.read((char *) (&astc->block_z), sizeof(uint8_t));
            astc->dim_x = ReadDim(ifs);
            astc->dim_y = ReadDim(ifs);
            astc->dim_z = ReadDim(ifs);
#ifdef _DEBUG
            cout << ""dim x: "" << astc->dim_x << "" y: "" << astc->dim_y << "" z: "" << astc->dim_z << endl;
#endif
            streampos pos = ifs.tellg(); // save current position
            ifs.seekg(0, ios::end);
            astc->size = (int) (ifs.tellg() - pos);
#ifdef _DEBUG
            cout << ""file length = "" << astc->size << endl;
#endif
            ifs.seekg(pos);
            astc->ptr = new char[astc->size];
            ifs.read((char *) (astc->ptr), astc->size * sizeof(char));
            return true;
        }
        ifs.close();
    }
    catch (ifstream::failure e) {
#ifdef _DEBUG
        cout << ""read table error "" << path << std::endl;
#endif
        ifs.close();
    }
    return false;
}

void Dispose(Astc *astc) {
    if (astc) {
        delete[] astc->ptr;
        delete astc;
        astc = nullptr;
    }
}

extern ""C""
{
bool astc_read(const char *path, Astc *ptr) {
    return ReadAstc(path, ptr);
}

void astc_dispose(Astc *ptr) {
    Dispose(ptr);
}
}",decoded_dim
870,"/**
 * 带头结点
 **/

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;

typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

bool InitList(LinkList &L) {
    L = (LNode *)malloc(sizeof(LNode));
    if (L == nullptr) {
        return false;
    }
    L->next = nullptr;
    return true;
}

bool Empty(LinkList L) { return L->next == nullptr; }

LNode *GetElem(LinkList L, int index) {
    if (index < 0) {
        return nullptr;
    }
    LNode *p;
    int i = 0;
    p = L;
    while (p != nullptr && i < index) {
        p = p->next;
        ++i;
    }
    return p;
}

// 在p结点之后插入元素e
bool InsertNextNode(LNode *p, ElemType e) {
    if (p == nullptr) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == nullptr) {
        return false;
    }
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

bool ListInsert(LinkList &L, int index, ElemType e) {
    if (index < 1) {
        return false;
    }
    // LNode *p;
    // int i = 0;
    // p = L;
    // while (p != nullptr && i < index - 1) {
    //     p = p->next;
    //     ++i;
    // }
    LNode *p = GetElem(L, index - 1);
    // if (p == nullptr) {
    //     return false;
    // }
    // LNode *s = (LNode *)malloc(sizeof(LNode));
    // s->data = e;
    // s->next = p->next;
    // p->next = s;
    // return true;
    return InsertNextNode(p, e);
}

// 前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p, ElemType e) {
    if (p == nullptr) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == nullptr) {
        return false;
    }
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}

// 前插操作：在p结点之前插入结点s
bool InsertPriorNode(LNode *p, LNode *s) {
    if (p == nullptr || s == nullptr) {
        return false;
    }
    s->next = p->next;
    p->next = s;
    ElemType temp = p->data;
    p->data = s->data;
    s->data = temp;
    return true;
}

bool ListDelete(LinkList &L, int index, ElemType &e) {
    if (index < 1) {
        return false;
    }
    // LNode *p;
    // int i = 0;
    // p = L;
    // while (p != nullptr && i < index - 1) {
    //     p = p->next;
    //     ++i;
    // }
    LNode *p = GetElem(L, index - 1);
    if (p == nullptr) {
        return false;
    }
    if (p->next == nullptr) {
        return false;
    }
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

// 有bug，如果p结点是最后一个节点，则会出错！
bool DeleteNode(LNode *p) {
    if (p == nullptr) {
        return false;
    }
    LNode *q = p->next;
    p->data = p->next->data; // bug
    p->next = q->next;
    free(q);
    return true;
}

LNode *LocateElem(LinkList L, ElemType e) {
    LNode *p = L->next;
    while (p != nullptr && p->data != e) {
        p = p->next;
    }
    return p;
}

int Length(LinkList L) {
    int  [MASK]  = 0;
    LNode *p = L;
    while (p->next != nullptr) {
        p = p->next;
        ++ [MASK] ;
    }
    return  [MASK] ;
}

LinkList ListTailInsert(LinkList &L) {
    int x;
    L = (LinkList)malloc(sizeof(LNode));
    LNode *s, *r = L;
    scanf(""%d"", &x);
    while (x != 9999) {
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        scanf(""%d"", &x);
    }
    r->next = nullptr;
    return L;
}

LinkList ListHeadInsert(LinkList &L) {
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));
    L->next = nullptr;
    scanf(""%d"", &x);
    while (x != 9999) {
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf(""%d"", &x);
    }
    return L;
}

int main() {
    LinkList L;
    InitList(L);
    return 0;
}",len
871,"/*
 *  Fid_Bass.cpp
 *  Prototipo3
 *
 *  Created by Limulo.
 *  http://www.limulo.net 
 */

#include ""Fid_Bass.h""


// COSTRUTTORE /////////////////////////////////////////////////
Fid_Bass::Fid_Bass(int _fid, int _sid)
{
	std::cout << ""Constructiong derived!\n"" << std::endl;
	
	fid = _fid;
	sid = _sid;
	
	c_innerRadius = FIDUCIAL_R;
	bass_level = 0.0;
	fid_pos.set(0.0f, 0.0f);
		
	transparency	= 0;
	stato = STABLE;
	alive = false;
	
	// variabili utili per l'animazione del trigger
	// ossia quando la playhead raggiunge la posizione del fiducial
	bTrigger = false;
	bExpand = false;
	bCollapse = false;
	tExpand = 10;		// valore temporale (espresso in frames) per l'espansione
	tCollapse = 480;	// valore temporale (espresso in frames) per il ritorno alle normali dimensioni
	aTrigger = 80;		// ampiezza di dilatazione della forma del fiducial quando venga triggerato
	startFrame = 0;
	marginTrigger = 30;	// raggio di un cerchio immaginario, tracciato contrandolo sulla posizione del fiducial. 
	
}


// SETUP ///////////////////////////////////////////////////////
void Fid_Bass::setup(ofVec2f *_fid_pos, ofVec2f *_ctr_pos, float _fid_angle, ofColor  [MASK] )
{
	// SETUP POSITION --------------------------------------------------------------
	fid_pos.set(_fid_pos->x, _fid_pos->y);

	fid_angle = _fid_angle;
	ofSetCircleResolution(CIRCLE_RES);
	
	fr =  [MASK] .r;
	fg =  [MASK] .g;
	fb =  [MASK] .b;	
}

// ADDED ///////////////////////////////////////////////////////
void Fid_Bass::added(void)
{
	stato = FADE_IN;
	alive = true;
}


// UPDATES /////////////////////////////////////////////////////
void Fid_Bass::update_interrupt(ofVec2f *_fid_pos, ofVec2f *_ctr_pos, float _fid_angle, float _fid_rot_vel)
{
	// UPDATE POSITION --------------------------------------------------------------
	fid_pos.set(_fid_pos->x, _fid_pos->y);
	fid_angle = _fid_angle;
	
}

void Fid_Bass::update_continuos(int bass_level_) 
{
	
	// STATE UPDATE -----------------------------------------------
	if (stato == FADE_IN) 
	{
		transparency += STEP_IN;
		if(transparency > 255 )
		{ 
			transparency = 255;
			stato = STABLE;
		} 
		
	} else if (stato == FADE_OUT) 
	{
		transparency -= STEP_OUT;
		if (transparency < 0)
		{
			stato = STABLE;
			transparency = 0;
			alive = false;
		} 
		
	} 
	else 
	{
		// se sono in stato STABLE modifico il valore bass_level in accordo qon il valore ricevuto dall'esterno
		bass_level = bass_level_ * BASS_MAX_AMP * 0.10;
	}
	
	f_color.set(fr, fg, fb, transparency);
}



// REMOVED /////////////////////////////////////////////////////
void Fid_Bass::removed(void)
{
	//state_actual = false;
	stato = FADE_OUT;
}


// DRAW ////////////////////////////////////////////////////////
void Fid_Bass::draw(void)
{
	ofPushStyle();
	ofEnableAlphaBlending();
	
	float raggio = 0.0;
	if(transparency != 0) 
	{
		//l'ampiezza del fiducial varia su base del livello di volume che viene inviato al metodo 'update_continuos' direttamente da PureData
		
		// FIDUCIAL: disegno del fiducial --------------------------
		ofSetColor(f_color);
		ofFill();
		ofCircle(fid_pos, FIDUCIAL_R + bass_level );
		ofNoFill();
		ofCircle(fid_pos, FIDUCIAL_R + bass_level );
		
	}
	
	ofDisableAlphaBlending();
	ofPopStyle();
}


// GETTERS /////////////////////////////////////////////////////
ofVec2f* Fid_Bass::getFidPos() 
{
	return &fid_pos;
}

bool Fid_Bass::isAlive() 
{
	return alive;
}



// OTHER ///////////////////////////////////////////////////////
void Fid_Bass::inside(ofVec2f *p)
{
	// non usato
}



void Fid_Bass::debug() {
	
	// TESTO a schermo ------------------------------------------
	ofPushMatrix();
	ofPushStyle();
	ofTranslate(fid_pos);
	
	ofSetHexColor(0x000000);
	
	// RIQUADRO 1 -----------------------------------------------
	ofPushMatrix(); 
	ofTranslate(-50, -120 , 0);
	ofDrawBitmapString(""BASS\nFid_Pos X: "" + ofToString(fid_pos.x) + ""\nFid_Pos Y: "" + ofToString(fid_pos.y) + ""\nFid_Angle: "" + ofToString(fid_angle), 0, 0);
	ofPopMatrix();
	
	// RIQUADRO 4 -----------------------------------------------
	ofPushMatrix();
	ofTranslate(-50, 80 , 0);
	
	ofDrawBitmapString(""f-id: "" + ofToString((int)fid) + "";\t s-id: "" + ofToString((int)sid), 0, 0);
	
	if (alive)
		ofDrawBitmapString(""alive!\n"", 0, 13);
	
	switch (stato){
		case STABLE:
			ofDrawBitmapString(""state: STABLE\n"", 0, 26);
			break;
		case FADE_IN:
			ofDrawBitmapString(""state: FADE IN\n"", 0, 26);
			break;
		case FADE_OUT:
			ofDrawBitmapString(""state: FADE OUT\n"", 0, 26);
			break;
		default:
			ofDrawBitmapString(""NOTHING\n"", 0, 26);
	}
	
	ofDrawBitmapString(""transparency: "" + ofToString((int)transparency), 0, 39); 
	
	ofPopMatrix();
	ofPopStyle();
	ofPopMatrix();
}







",_fColor
872,"/** MQTT Publish von Sensordaten */
#include  ""mbed.h""
#include ""OLEDDisplay.h""
// #include ""Motor.h""
// #include ""Servo.h""
#include ""MbedJSONValue.h""
#include ""http_request.h""
#include ""config.cpp""

#if MBED_CONF_IOTKIT_HTS221_SENSOR == true
#include ""HTS221Sensor.h""
#endif
#if MBED_CONF_IOTKIT_BMP180_SENSOR == true
#include ""BMP180Wrapper.h""
#endif
#include ""MFRC522.h""

#ifdef TARGET_K64F
#include ""QEI.h""

//Use X2 encoding by default.
QEI wheel (MBED_CONF_IOTKIT_BUTTON2, MBED_CONF_IOTKIT_BUTTON3, NC, 624);
#endif

#include <MQTTClientMbedOs.h>
#include <MQTTNetwork.h>
#include <MQTTClient.h>
#include <MQTTmbed.h> // Countdown

// Sensoren wo Daten fuer Topics produzieren
static DevI2C devI2c( MBED_CONF_IOTKIT_I2C_SDA, MBED_CONF_IOTKIT_I2C_SCL );
#if MBED_CONF_IOTKIT_HTS221_SENSOR == true
static HTS221Sensor hum_temp(&devI2c);
#endif
#if MBED_CONF_IOTKIT_BMP180_SENSOR == true
static BMP180Wrapper hum_temp( &devI2c );
#endif
AnalogIn hallSensor( MBED_CONF_IOTKIT_HALL_SENSOR );
DigitalIn button( MBED_CONF_IOTKIT_BUTTON1 );

// Topic's publish
char* topicTEMP = (char*) ""8x3ebv3f4w3EUchR/sensor"";
char* topicLOGIN = (char*) ""8x3ebv3f4w3EUchR/login"";
char* topicREGISTER = (char*) ""8x3ebv3f4w3EUchR/register"";
char* topicTEST = (char*) ""8x3ebv3f4w3EUchR/test"";
// Topic's subscribe
char* topicAll = (char*) ""8x3ebv3f4w3EUchR/#"";
char* topicANSWER = (char*) ""8x3ebv3f4w3EUchR/answer"";

// MQTT Brocker
char* hostname = (char*) BROKER_BASE_URL;
int port = 1883;
// MQTT Message
MQTT::Message message;
// I/O Buffer
char buf[100];
char uUID[2000];

// Klassifikation 
// char cls[3][10] = { ""low"", ""middle"", ""high"" };
int type = 0;

// UI
OLEDDisplay oled( MBED_CONF_IOTKIT_OLED_RST, MBED_CONF_IOTKIT_OLED_SDA, MBED_CONF_IOTKIT_OLED_SCL );
DigitalOut alert( MBED_CONF_IOTKIT_LED3 );

// Aktore(n)
PwmOut speaker( MBED_CONF_IOTKIT_BUZZER );
// Motor m1( MBED_CONF_IOTKIT_MOTOR2_PWM, MBED_CONF_IOTKIT_MOTOR2_FWD, MBED_CONF_IOTKIT_MOTOR2_REV ); // PWM, Vorwaerts, Rueckwarts
// NFC/RFID Reader (SPI)
MFRC522    rfidReader( MBED_CONF_IOTKIT_RFID_MOSI, MBED_CONF_IOTKIT_RFID_MISO, MBED_CONF_IOTKIT_RFID_SCLK, MBED_CONF_IOTKIT_RFID_SS, MBED_CONF_IOTKIT_RFID_RST ); 

/** Hilfsfunktion zum Publizieren auf MQTT Broker */
void publish( MQTTNetwork &mqttNetwork, MQTT::Client<MQTTNetwork, Countdown> &client, char* topic ){
    MQTT::Message message;    
    oled.cursor( 2, 0 );
    oled.printf( ""Topi: %s\n"", topic );
    oled.cursor( 3, 0 );    
    oled.printf( ""Push: %s\n"", buf );
    message.qos = MQTT::QOS0;
    message.retained = false;
    message.dup = false;
    message.payload = (void*) buf;
    message.payloadlen = strlen(buf)+1;
    client.publish( topic, message);
}

/** Daten empfangen von MQTT Broker */
void messageArrived( MQTT::MessageData& md ) {
// Connect to the network with the default networking interface
    // if you use WiFi: see mbed_app.json for the credentials
    WiFiInterface *wifi = WiFiInterface::get_default_instance();
    if ( !wifi ) 
    {
        printf(""ERROR: No WiFiInterface found.\n"");
        oled.printf( ""ERROR: No WiFiInterface found.\r\n"" );
    }
    printf(""\nConnecting to %s...\n"", WIFI_SSID);
    int ret = wifi->connect( WIFI_SSID, WIFI_PASSWORD, NSAPI_SECURITY_WPA_WPA2 );
    if ( ret != 0 ) 
    {
        printf(""\nConnection error: %d\n"", ret);
        oled.printf( ""Connection error: %d\r\n"" );
    }    

    // TCP/IP und MQTT initialisieren (muss in main erfolgen)
    MQTTNetwork mqttNetwork( wifi );
    MQTT::Client<MQTTNetwork, Countdown> client(mqttNetwork);

    printf(""Connecting to %s:%d\r\n"", hostname, port);
    int rc = mqttNetwork.connect(hostname, port);
    if (rc != 0)
        printf(""rc from TCP connect is %d\r\n"", rc);


    oled.clear();

    float value;
    MQTT::Message &message = md.message;
    oled.clear();
    // oled.printf(""Message arrived: qos %d, retained %d, dup %d, packetid %d\n"", message.qos, message.retained, message.dup, message.id);
    // oled.printf(""Topic %.*s, "", md.topicName.lenstring.len, (char*) md.topicName.lenstring.data );
    oled.printf(""Payload %.*s\n"", message.payloadlen, (char*) message.payload);
    
    // thread_sleep_for( 30000 );

    if((char*) message.payload == ""exist""){
        oled.clear();
        oled.printf(""exist"");

        // Temperator
        uint8_t id;
        float temp, hum;
        hum_temp.read_id(&id);  
        hum_temp.get_temperature(&temp);    
        if  ( type == 0 ){
            temp -= 5.0f;
        } else if  ( type == 2 ){
            temp += 5.0f;
        }
        // sprintf( buf, ""'uid':'%s','temp':'%2.2f'"", buf, temp); 
        sprintf( buf, ""%2.2f"", temp);
        type++;
        if  ( type > 2 )
            type = 0;       
        publish( mqttNetwork, client, topicTEMP );
        //send to db
        

    } else if ((char*) message.payload == ""notexist"") {
        oled.clear();
        oled.printf(""not exist"");
        oled.clear();
        // Magnet Sensor
        oled.printf(""Attach Magnet\n"");
        bool magnet_away = true;
        while(magnet_away) {
            // oled.clear();
            float value = hallSensor.read();
            // oled.cursor( 1, 0 );
            // oled.printf( ""value %1.4f\r\n"", value );
            // printf( ""Hall Sensor %f\r\n"", value );
            if ( value > 0.6f ){
                oled.clear();
                oled.printf(""Magnet erkannt!"");
                publish( mqttNetwork, client, topicREGISTER );

                magnet_away = false;
            }
            //Loop wartet hier eine Sekunde lang
            thread_sleep_for( 1000 );
        }
    }         
}

/** Hauptprogramm */
int main()
{
    uint8_t id;
    float temp, hum;
    int  [MASK] ;
    alert = 0;
    // servo2 = 0.5f;
    
    oled.clear();
    oled.printf( ""MQTTPublish\r\n"" );
    oled.printf( ""host: %s:%s\r\n"", hostname, port );
    
    oled.clear();
    printf(""\nConnecting to %s...\n"", WIFI_SSID);
    oled.printf( ""SSID: %s\r\n"", WIFI_SSID );
    oled.clear();
    
    // Connect to the network with the default networking interface
    // if you use WiFi: see mbed_app.json for the credentials
    WiFiInterface *wifi = WiFiInterface::get_default_instance();
    if ( !wifi ) 
    {
        printf(""ERROR: No WiFiInterface found.\n"");
        oled.printf( ""ERROR: No WiFiInterface found.\r\n"" );
        return -1;
    }
    printf(""\nConnecting to %s...\n"", WIFI_SSID);
    int ret = wifi->connect( WIFI_SSID, WIFI_PASSWORD, NSAPI_SECURITY_WPA_WPA2 );
    if ( ret != 0 ) 
    {
        printf(""\nConnection error: %d\n"", ret);
        oled.printf( ""Connection error: %d\r\n"" );
        return -1;
    }    

    // TCP/IP und MQTT initialisieren (muss in main erfolgen)
    MQTTNetwork mqttNetwork( wifi );
    MQTT::Client<MQTTNetwork, Countdown> client(mqttNetwork);

    printf(""Connecting to %s:%d\r\n"", hostname, port);
    int rc = mqttNetwork.connect(hostname, port);
    if (rc != 0)
        printf(""rc from TCP connect is %d\r\n"", rc); 

    // Zugangsdaten - der Mosquitto Broker ignoriert diese
    MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
    data.MQTTVersion = 3;
    data.clientID.cstring = (char*) wifi->get_mac_address(); // muss Eindeutig sein, ansonsten ist nur 1ne Connection moeglich
    data.username.cstring = (char*) wifi->get_mac_address(); // User und Password ohne Funktion
    data.password.cstring = (char*) ""<PASSWORD>"";
    if ((rc = client.connect(data)) != 0)
        printf(""rc from MQTT connect is %d\r\n"", rc);           

    // MQTT Subscribe!
    client.subscribe( topicANSWER, MQTT::QOS0, messageArrived );
    printf(""MQTT subscribe %s\n"", topicAll );
    
    /* Init all sensors with default params */
    hum_temp.init(NULL);
    hum_temp.enable(); 
    // RFID Reader initialisieren
    rfidReader.PCD_Init();

    oled.clear();
    oled.printf(""Attach NFC-Card\n"");
    while   ( 1 ){
        // RFID Reader
        if ( rfidReader.PICC_IsNewCardPresent())
            if ( rfidReader.PICC_ReadCardSerial()) {
                // Print Card UID (2-stellig mit Vornullen, Hexadecimal)
                printf(""Card UID: "");
                for ( int i = 0; i < rfidReader.uid.size; i++ )
                    printf(""%02X:"", rfidReader.uid.uidByte[i]);
                printf(""\n"");
                
                // Print Card type
                int piccType = rfidReader.PICC_GetType(rfidReader.uid.sak);
                printf(""PICC Type: %s \n"", rfidReader.PICC_GetTypeName(piccType) );
                
                //save uid
                sprintf( buf, ""%02X:%02X:%02X:%02X"", rfidReader.uid.uidByte[0], rfidReader.uid.uidByte[1], rfidReader.uid.uidByte[2], rfidReader.uid.uidByte[3] );
                publish( mqttNetwork, client, topicLOGIN );
                // sprintf( uUID, ""%02X:%02X:%02X:%02X"", rfidReader.uid.uidByte[0], rfidReader.uid.uidByte[1], rfidReader.uid.uidByte[2], rfidReader.uid.uidByte[3] );
                // HttpRequest* post_req = new HttpRequest(wifi, HTTP_POST, API_BASE_URL);
                //     // HttpResponse* get_res = get_req->send();
                //     char body[] = """";
                //     // sprintf( body, ""%s"", ""{\""uid\"":\""12345\""}\n"",);
                //     sprintf( body, ""%s%s%s"", ""{\""uid\"":\"""", uUID, ""\""}\n"");
                //     printf(""BODY: %s\n"", body);
                //     post_req->set_header(""Content-Type"", ""application/json"");
                //     HttpResponse* post_res = post_req->send(body, strlen(body));
                    
                //     // send request
                //     oled.printf(""sending request...\n"");

                //     //success response
                //     if (post_res){
                //         oled.printf(""Login sended\n"");
                //     }
                //     // Error
                //     else{
                //         printf(""HttpRequest failed (error code %d)\n"", post_req->get_error());
                //         oled.printf(""HttpRequest failed (error code %d)\n"", post_req->get_error());
                //         return 1;
                //     }
                //     delete post_req;
                oled.clear();
                // Temperator
                uint8_t id;
                float temp, hum;
                hum_temp.read_id(&id);  
                hum_temp.get_temperature(&temp);    
                if  ( type == 0 ){
                    temp -= 5.0f;
                } else if  ( type == 2 ){
                    temp += 5.0f;
                }
                oled.printf( ""Temp: %2.2f \n"", temp);
                oled.printf(""Login sended\n"");
            }         

#ifdef TARGET_K64F
        // Encoder
         [MASK]  = wheel.getPulses();
        sprintf( buf, ""%d"",  [MASK]  );
        publish( mqttNetwork, client, topicENCODER );
#endif
        client.yield    ( 1000 );                   // MQTT Client darf empfangen
        thread_sleep_for( 500 );
    }
    // Verbindung beenden
    if ((rc = client.disconnect()) != 0)
        printf(""rc from disconnect was %d\r\n"", rc);

    mqttNetwork.disconnect();    
}
",encoder
873,"#pragma once

#include <THString.h>
#include <THDllLoader.h>
#include <THTime.h>
#include <THSystem.h>
#include <THThread.h>

extern ""C""
{
typedef HANDLE (__stdcall *OpenCommPort)(int nPort,int nBaudRate);
typedef BOOL (__stdcall *ClosePortHandle)(HANDLE hPort);
typedef BOOL (__stdcall *CallClock)(HANDLE hPort,int nClockId);
typedef BOOL (__stdcall *UnCallClock)(HANDLE hPort);
typedef BOOL (__stdcall *ReadICCard)(HANDLE hPort,char* pCardNo,char *pCardName,int* nMoney,int* nTimes,int *nVer);
typedef BOOL (__stdcall *WriteICCard)(HANDLE hPort,char* pCardNo,char *pCardName,int nMoney,int nTimes,int nVer);
typedef BOOL (__stdcall *ReadICCardSerialNo)(HANDLE hPort,__int64 *buf,BOOL bLong);
}

#define CARDSTYLE_UNKNOWN	0
#define CARDSTYLE_IDCARD	1
#define CARDSTYLE_STDCARD	830
#define CARDSTYLE_NEWCARD	880
#define CARDSTYLE_690CARD	690
/**
* @brief EastRiver读卡器封装类
* @author Barry(<EMAIL>,QQ:20962493)
* @2007-11-18 新建类
*/
/**<pre>
用法：
	OpenPort/ClosePort 用于打开/关闭串口
	OpenClock/CloseClock 用于打开/关闭设备,注意设备在打开后,进行刷卡设备没有响应,因此每次都需要OpenClock,读取完成后就CloseClock
</pre>*/
class THERIcCardDll : public THDllLoader
{
public:
	THERIcCardDll():THDllLoader(_T(""EastRiver.dll""))
	{
		m_hPort=INVALID_HANDLE_VALUE;
		m_bCallClock=FALSE;
		m_nClockid=0;
		EmptyDllPointer();
	}

	virtual ~THERIcCardDll(){FreeDll();}

	virtual BOOL OnFreeDll()
	{
		ClosePort();
		return THDllLoader::OnFreeDll();
	}

	virtual void EmptyDllPointer()
	{
		openport=NULL;
		closeport=NULL;
		callclock=NULL;
		uncallclock=NULL;
		readcard=NULL;
		writecard=NULL;
		cardserialno=NULL;
	}

	virtual BOOL InitDllPoinier()
	{
		openport=(OpenCommPort)GetProcAddress(m_module,""OpenCommPort"");
		closeport=(ClosePortHandle)GetProcAddress(m_module,""ClosePortHandle"");
		callclock=(CallClock)GetProcAddress(m_module,""CallClock"");
		uncallclock=(UnCallClock)GetProcAddress(m_module,""UnCallClock"");
		readcard=(ReadICCard)GetProcAddress(m_module,""ReadICCard"");
		writecard=(WriteICCard)GetProcAddress(m_module,""WriteICCard"");
		cardserialno=(ReadICCardSerialNo)GetProcAddress(m_module,""ReadICCardSerialNo"");
		if (!openport || !closeport || !callclock || !uncallclock ||
			!readcard || !writecard || !cardserialno)
			return FALSE;
		return TRUE;
	}

	BOOL OpenPort(int nInt,int nClockid)
	{
		m_nClockid=nClockid;
		if (!ClosePort()) return FALSE;
		if (!openport) return FALSE;
		m_hPort=openport(nInt,9600);
		if (m_hPort==(HANDLE)0 || m_hPort==(HANDLE)-1)
		{
			m_hPort=INVALID_HANDLE_VALUE;
			return FALSE;
		}
		return TRUE;
	}

	BOOL OpenClock()
	{
		if (!CloseClock()) return FALSE;
		if (!callclock) return FALSE;
		m_bCallClock=TRUE;
		return callclock(m_hPort,m_nClockid);
	}

	BOOL CloseClock()
	{
		if (!InitDll()) return FALSE;
		if (m_hPort==INVALID_HANDLE_VALUE) return FALSE;
		if (!m_bCallClock) return TRUE;
		if (!uncallclock) return FALSE;
		m_bCallClock=FALSE;
		return uncallclock(m_hPort);
	}

	BOOL ClosePort()
	{
		if (!InitDll()) return FALSE;
		if (m_hPort==INVALID_HANDLE_VALUE) return TRUE;
		if (!CloseClock()) return FALSE;
		if (!closeport) return FALSE;
		if (!closeport(m_hPort)) return FALSE;
		m_hPort=INVALID_HANDLE_VALUE;
		return TRUE;
	}

	BOOL IsPortOpened(){return m_hPort!=INVALID_HANDLE_VALUE;}
	BOOL IsPortCalled(){return m_bCallClock;}

	BOOL ReadCard(THString *sCardNo,THString *sCardName=NULL,int* nMoney=NULL,int *nTimes=NULL,int *nVer=NULL)
	{
		if (!InitDll()) return FALSE;
		if (m_hPort==INVALID_HANDLE_VALUE) return FALSE;
		if (!readcard) return FALSE;
		if (!OpenClock()) return FALSE;
		char buf[1024];
		char buf1[1024];
		memset(buf,0,1024);
		memset(buf1,0,1024);
		int  [MASK] =0;
		int tmpTimes=0;
		int tmpVer=0;
		BOOL ret=readcard(m_hPort,buf,buf1,& [MASK] ,&tmpTimes,&tmpVer);
		if (!ret)
		{
			CloseClock();
			return FALSE;
		}
		if (sCardNo) *sCardNo=THCharset::a2t(buf);
		if (sCardName) *sCardName=THCharset::a2t(buf1);
		if (nMoney) *nMoney= [MASK] ;
		if (nTimes) *nTimes=tmpTimes;
		if (nVer) *nVer=tmpVer;
		if (!CloseClock()) return FALSE;
		return TRUE;
	}

	BOOL WriteCard(THString sCardNo,THString sCardName=_T(""""),int nMoney=0,int nTimes=0,int nVer=CARDSTYLE_690CARD)
	{
		if (!InitDll()) return FALSE;
		if (m_hPort==INVALID_HANDLE_VALUE) return FALSE;
		if (!writecard) return FALSE;
		if (!OpenClock()) return FALSE;
		char *buf=THCharset::t2a(sCardNo);
		char *buf1=THCharset::t2a(sCardName);
		BOOL ret=FALSE;
		if (buf && buf1)
			ret=writecard(m_hPort,buf,buf1,nMoney,nTimes,nVer);
		if (buf) THCharset::free(buf);
		if (buf1) THCharset::free(buf1);
		if (!CloseClock()) return FALSE;
		return ret;
	}

	THString ReadCardSerialNo()
	{
		THString ret;
		if (!InitDll()) return ret;
		if (m_hPort==INVALID_HANDLE_VALUE) return ret;
		if (!cardserialno) return ret;
		if (!OpenClock()) return FALSE;
		__int64 buf;
		if (!cardserialno(m_hPort,&buf,TRUE))
		{
			CloseClock();
			return ret;
		}
		ret.Format(_T(""%I64d""),buf);
		if (!CloseClock()) return FALSE;
		return ret;
	}
private:
	OpenCommPort openport;
	ClosePortHandle closeport;
	CallClock callclock;
	UnCallClock uncallclock;
	ReadICCard readcard;
	WriteICCard writecard;
	ReadICCardSerialNo cardserialno;
	HANDLE m_hPort;
	int m_nClockid;
	BOOL m_bCallClock;
};

extern ""C""
{
	typedef int (__stdcall *MCOpenPort)(char *PortName,int *PortHandle);
	typedef int (__stdcall *MCSelectPort)(int PortHandle);
	typedef int (__stdcall *MCClosePort)();
	typedef int (__stdcall *MCReaderVersion)();
	typedef int (__stdcall *MCPowerOn)();
	typedef int (__stdcall *MCPowerOff)();
	typedef int (__stdcall *MCCardPresent)();
	typedef int (__stdcall *MCCardChanged)();
	typedef int (__stdcall *MCGetCardType)(char *ATRBuffer);
	//typedef char* (__stdcall *MCGetCardName)(int CardType);
	//typedef void (__stdcall *MCDes64)(unsigned char *input,unsigned char *output,unsigned char *key,int Encrypt);
	typedef int (__stdcall *MCOpenReader)(char *ComStr,HWND NotifyWindow,UINT NotifyMsg);
	typedef int (__stdcall *MCCloseReader)();
	//	SLE4442 
	typedef int (__stdcall *MCRead_4442_NO_PB)(int StartPos,int NOB,unsigned char *Bfr);
	typedef int (__stdcall *MCWrite_4442_Array)(int StartPos,int NOB,const unsigned char *Bfr,const unsigned char *PBSetFlag);
	typedef int (__stdcall *MCVerify_4442_PSC)(char PSC1,char PSC2,char PSC3);
	typedef int (__stdcall *MCWrite_4442_SM)(int SMAddress,char SMByte);
}

/**
* @brief MC900读卡器封装类
* @author Barry(<EMAIL>,QQ:20962493)
* @2007-11-22 新建类
*/
/**<pre>
	SLE4442卡片简介
		256字节EEPROM
		32位保护存储器
		3字节用户密码，密码错误计数：3次。
		至少10万次擦写
		至少10年数据保存期
		密码核对正确前，全部数据均可读，如果有需要，可对数据进行适当加密。核对密码正确后可写入或修改数据。
		三字节的用户密码，校验通过后，至卡下电一直有效。校验通过后密码本身可更改。注意：密码区另外编址，不在0～256字节内。
		密码出错计数器。地址是1021。
		密码出错计数器，初始值为3，密码核对出错1次，便减1，若计数器值为0，则卡自动锁死，数据只可读出，不可再进行更改也无法再进行密码核对；若不为零时，有一次密码核对正确，可恢复到初始值。
		写保护区（前32个字节）的每一字节可单独进行写保护，进行写保护后，内容不可再更改（即固化数据）。
		字节地址0x15～0x1A为用户代码，SIEMENS公司可为大用户在此专设一个全球唯一代码，以便用户统一发行使用（所有的卡出厂后不可再修改）。
		字节地址0～7出厂前已由厂家写好，不可更改。
		卡片存储区内的起始地址是0x20
		出厂密码是<PASSWORD>
		首先测试是否有SLE4442卡插入读写器。若有，核对密码并读取错误计数，然后改写密码并回读，比较两次操作数据是否相同，若相同，返回操作正确。
</pre>*/
class THMC900IcCardReader : public THDllLoader,public THThread
{
public:
	THMC900IcCardReader():THDllLoader(_T(""lx900.dll""))
	{
		m_buf[0]='\0';
		m_hComm=INVALID_HANDLE_VALUE;
		m_hWnd=NULL;
		m_Msg=0;
		EmptyDllPointer();
	}

	virtual ~THMC900IcCardReader(){FreeDll();}

	virtual BOOL OnFreeDll()
	{
		ClosePort();
		return THDllLoader::OnFreeDll();
	}

	virtual void EmptyDllPointer()
	{
		openport=NULL;
		selectport=NULL;
		closeport=NULL;
		poweron=NULL;
		poweroff=NULL;
		cardpresent=NULL;
		cardchanged=NULL;
		cardtype=NULL;
		openreader=NULL;
		closereader=NULL;
		readdata4442=NULL;
		writedata4442=NULL;
		verifyps4442=NULL;
		writesm4442=NULL;
		readerversion=NULL;
	}

	virtual BOOL InitDllPoinier()
	{
		openport=(MCOpenPort)GetProcAddress(m_module,""OpenPort"");
		selectport=(MCSelectPort)GetProcAddress(m_module,""SelectPort"");
		closeport=(MCClosePort)GetProcAddress(m_module,""ClosePort"");
		poweron=(MCPowerOn)GetProcAddress(m_module,""PowerOn"");
		poweroff=(MCPowerOff)GetProcAddress(m_module,""PowerOff"");
		cardpresent=(MCCardPresent)GetProcAddress(m_module,""CardPresent"");
		cardchanged=(MCCardChanged)GetProcAddress(m_module,""CardChanged"");
		cardtype=(MCGetCardType)GetProcAddress(m_module,""GetCardType"");
		openreader=(MCOpenReader)GetProcAddress(m_module,""OpenReader"");
		closereader=(MCCloseReader)GetProcAddress(m_module,""CloseReader"");
		readerversion=(MCReaderVersion)GetProcAddress(m_module,""ReaderVersion"");
		readdata4442=(MCRead_4442_NO_PB)GetProcAddress(m_module,""Read_4442_NO_PB"");
		writedata4442=(MCWrite_4442_Array)GetProcAddress(m_module,""Write_4442_Array"");
		verifyps4442=(MCVerify_4442_PSC)GetProcAddress(m_module,""Verify_4442_PSC"");
		writesm4442=(MCWrite_4442_SM)GetProcAddress(m_module,""Write_4442_SM"");
		if (!openport || !selectport || !closeport || !poweron || !poweroff || !cardpresent ||
			!cardchanged || !cardtype || !openreader || !closereader || !readerversion || !readdata4442 || !writedata4442 ||
            !verifyps4442 || !writesm4442)
			return FALSE;
		return TRUE;
	}

	virtual void ThreadFunc(int ThreadId,void *data)
	{
		if (IsCardChanged())
		{
			if (m_hWnd && m_Msg)
				SendMessage(m_hWnd,m_Msg,IsCardPresent(),0);
		}
	}

	BOOL OpenPort(int nInt)
	{
		if (!ClosePort()) return FALSE;
		if (!openport) return FALSE;
		sprintf(m_buf,""COM%d"",nInt);
		int ret;
		int fret=openport(m_buf,&ret);
		if (fret!=ERR_SUCCESS) return FALSE;
		m_hComm=(HANDLE)(INT_PTR)ret;
		if (m_hComm==(HANDLE)0 || m_hComm==(HANDLE)-1)
		{
			m_hComm=INVALID_HANDLE_VALUE;
			return FALSE;
		}
		if (!SetPower(TRUE)) return FALSE;
		return TRUE;
	}

	BOOL ClosePort()
	{
		if (!InitDll()) return FALSE;
		if (m_hComm==INVALID_HANDLE_VALUE) return TRUE;
		if (!SetNotify(FALSE)) return FALSE;
		if (!SetPower(FALSE)) return FALSE;
		if (!closeport) return FALSE;
		if (closeport()!=ERR_SUCCESS)
		{
			m_hComm=INVALID_HANDLE_VALUE;
			return FALSE;
		}
		m_hComm=INVALID_HANDLE_VALUE;
		return TRUE;
	}

	//任何操作之前，应使用SelectPort说明正在对该端口操作
	BOOL SelectPort()
	{
		if (!InitDll()) return FALSE;
		if (!selectport) return FALSE;
		if (m_hComm==INVALID_HANDLE_VALUE) return FALSE;
		selectport((int)(INT_PTR)m_hComm);
		return TRUE;
	}

	BOOL SetPower(BOOL bOpen=TRUE)
	{
		if (!InitDll()) return FALSE;
		if (!poweroff || !poweron) return FALSE;
		if (bOpen)
			poweron();
		else
			poweroff();
		return TRUE;
	}

	BOOL IsPortOpened(){return m_hComm!=INVALID_HANDLE_VALUE;}

	BOOL IsCardPresent()
	{
		if (!InitDll()) return FALSE;
		if (!cardpresent) return FALSE;
		return cardpresent();
	}

	BOOL IsCardChanged()
	{
		if (!InitDll()) return FALSE;
		if (!cardchanged) return FALSE;
		return cardchanged();
	}

	int GetCardType()
	{
		if (!InitDll()) return CT_UNKNOWN;
		if (!cardtype) return CT_UNKNOWN;
		char buf[5];
		return cardtype(buf);
	}

	//设置是否监视串口
	BOOL SetNotify(BOOL bNotify,HWND hNotifyWindow=NULL,UINT nMsg=0)
	{
		if (!InitDll()) return FALSE;
		if (m_hComm==INVALID_HANDLE_VALUE) return FALSE;
		m_hWnd=hNotifyWindow;
		m_Msg=nMsg;
		if (bNotify)
			StartThread(1,NULL,500,TRUE);
		else
			KillThread(1);
		return TRUE;
	}

	int ReaderVersion()
	{
		if (!InitDll()) return 0;
		if (!readerversion) return 0;
		return readerversion();
	}

	//卡片一次读写操作数据长度严禁超过16字节
	BOOL ReadData4442(int nStartPos,int nLen,unsigned char *buf)
	{
		if (!InitDll()) return FALSE;
		if (!readdata4442) return FALSE;
		return (readdata4442(nStartPos,nLen,buf)==ERR_SUCCESS);
	}

	//卡片一次读写操作数据长度严禁超过16字节
	BOOL WriteData4442(int nStartPos,int nLen,const unsigned char *buf,const unsigned char *protect)
	{
		if (!InitDll()) return FALSE;
		if (!writedata4442) return FALSE;
		return (writedata4442(nStartPos,nLen,buf,protect)==ERR_SUCCESS);
	}

	BOOL VerifyPs4442(unsigned char psc1,unsigned char psc2,unsigned char psc3)
	{
		if (!InitDll()) return FALSE;
		if (!verifyps4442) return FALSE;
		return (verifyps4442(psc1,psc2,psc3)==ERR_SUCCESS);
	}

	BOOL WriteSm4442(int nAddr,unsigned char val)
	{
		if (!InitDll()) return FALSE;
		if (!writesm4442) return FALSE;
		return (writesm4442(nAddr,val)==ERR_SUCCESS);
	}

	/**
	* @brief 获取卡片序列号，因4442卡是没有序列号的，因此函数实现仿真写入序列号，流程参照具体说明
	* @return 返回序列号，没有卡或错误返回空
	*/
	/**<pre>
	</pre>*/
	THString ReadCardSerialNo4442()
	{
		THString ret;
		if (SelectPort() && IsCardPresent())
		{
			if (GetCardType()==CT_SLE4442)
			{
				unsigned char buf[16];
				BOOL bRead=FALSE;
				if (ReadData4442(0x20,16,buf))
				{
					if (memcmp(buf,""THMC"",4)==0)
					{
						//已经有卡号
						bRead=TRUE;
					}
					else
					{
						//新卡
						if (VerifyPs4442(0xff,0xff,0xff))
						{
							//write password
							WriteSm4442(1,0xec);
							WriteSm4442(2,0xda);
							WriteSm4442(3,0xc1);
							memcpy(buf,""THMC"",4);
							THTime ti;
							int nti=(int)ti.GetTimeAsTime64();
							memcpy(&buf[8],&nti,4);
							THSysMisc::srand();
							nti=rand()*rand();memcpy(&buf[4],&nti,4);
							nti=rand()*rand();memcpy(&buf[12],&nti,4);
							//write data
							if (WriteData4442(0x20,16,buf,(const unsigned char *)""0000000000000000""))
								bRead=TRUE;
						}
					}
					if (bRead)
					{
						unsigned int *tmp=(unsigned int *)&buf[4];
						ret.Format(_T(""%04x%04x%04x""),*tmp,*(tmp+1),*(tmp+2));
					}
				}
			}
		}
		return ret;
	}

	enum myCardType
	{
		CT_UNKNOWN,
		CT_SLE4432,CT_SLE4442,
		CT_SLE4418,CT_SLE4428,
		CT_SLE4406,CT_SLE4436,
		CT_AT88SC101,CT_AT88SC102,
		CT_SLE44C42S,CT_SLE44C80,
		CT_X76F640,
		CT_AT24C01A,CT_AT24C02,CT_AT24C04,CT_AT24C08,CT_AT24C16,
		CT_AT24C32,CT_AT24C64,CT_AT24C128,CT_AT24C256,CT_AT24C512,
		CT_AT88SC1604,CT_AT88SC1608,CT_AT88SC153,
		CT_AT45D041,
		CT_NO_CARD
	};

	enum myErrorCode
	{
		ERR_SUCCESS = 0,
		ERR_NO_CARD,ERR_TIMEOUT,ERR_COUNTER,
		ERR_PSC1,ERR_PSC2,ERR_LENGTH,
		ERR_NOT_ENOUGH_MEMORY,
		ERR_CREATE_PORT_FILE,
		ERR_GET_COMM_STATE,ERR_SET_COMM_STATE,
		ERR_SET_COMM_MASK,ERR_SET_COMM_TIMEOUTS,
		ERR_CREATE_THREAD,ERR_NULL_PORT_HANDLE,
		RET_COMP_EQUAL = 200,RET_COMP_UNEQUAL
	};
private:
	MCOpenPort openport;
	MCSelectPort selectport;
	MCClosePort closeport;
	MCPowerOn poweron;
	MCPowerOff poweroff;
	MCCardPresent cardpresent;
	MCCardChanged cardchanged;
	MCGetCardType cardtype;
	MCOpenReader openreader;
	MCCloseReader closereader;
	MCReaderVersion readerversion;
	MCRead_4442_NO_PB readdata4442;
	MCWrite_4442_Array writedata4442;
	MCVerify_4442_PSC verifyps4442;
	MCWrite_4442_SM writesm4442;
	HANDLE m_hComm;
	char m_buf[10];
	HWND m_hWnd;
	UINT m_Msg;
};
",tmpMoney
874,"#include <Adafruit_VC0706.h>
#include <SPI.h>
#include <SD.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <Wire.h>
#include <RTClib.h>
#include <EEPROM.h>

#define chipSelect 10
#define cameraTX 3
#define cameraRX 4
#define switchPin 2
#define ledPin 5

//ms betwen photos
#define photoDelayLength 300000 //15 min
//length in us of flashes
#define flashLength 500000 //0.5 sec
//minimum length of on period (length of time on / length of flash)
#define onPeriodMin 10 //5 sec
//maximum length of on period (length of time on / length of flash)
#define onPeriodMax 10 //5 sec
//minimum length of off period in sec
#define offPeriodMin 900 //15 min
//maximum length of off period in sec
#define offPeriodMax 900 //15 min
//amount of time to delete when button is pressed in sec
#define deleteLength 335 //5 min + extra to make sure last photo deleted

SoftwareSerial cameraconnection = SoftwareSerial(cameraTX, cameraRX);
Adafruit_VC0706 cam = Adafruit_VC0706(&cameraconnection);

RTC_DS1307 rtc;

boolean deletePhotoToggle = false;
boolean flashStartToggle = false;
boolean flashEndToggle = false;
boolean flash = false;
char dirName[10] = {""/00000000""};
uint32_t offRandom = 30; //start flashing after 30 sec
uint16_t onRandom = 0;
DateTime flashStart;
DateTime flashEnd;

void setup()
{
	randomSeed(analogRead(0));

	pinMode(ledPin, OUTPUT);
	PORTD |= (1 << ledPin); //set ledPin high
  
	pinMode(switchPin, INPUT);

	Serial.begin(9600);
	Wire.begin();
  rtc.begin();
	
	Serial.println(F(""-----------------------""));
	Serial.println(F(""LifeLogging Camera""));
	Serial.println(F(""-----------------------""));
	Serial.println();

	if (EEPROM.read(0) == 0)
	{
		flash = false;
	}
	else
	{
		flash = true;
	}

	if (digitalRead(switchPin) == HIGH)
	{
		flash = !flash;
		EEPROM.write(0, flash);

		Serial.print(F(""Flashing ""));
		Serial.println(flash);
		Serial.println();
	}
  
	// see if the card is present and can be initialized:
	if (!SD.begin(chipSelect))
	{
		Serial.println(F(""Card failed, or not present""));
		while(1);
	}
	
	// Try to locate the camera
	if (!cam.begin())
	{
		Serial.println(F(""No camera found?""));
		while(1);
	}

	if (!rtc.begin())
	{
		Serial.println(F(""RTC is not running""));
		while (1);
	}

	//rtc.adjust(DateTime(__DATE__, __TIME__));
  DateTime now = rtc.now();
  Serial.println(now.year());

	if (now.year() == 2165)
	{
		Serial.println(F(""RTC communication error""));
		while (1);
	}

	// Set the picture size - 640x480
	cam.setImageSize(VC0706_640x480);

	if (flash == false)
	{
		delay(500);
		PORTD &= ~(1 << ledPin); //set ledPin low
		delay(500);
		PORTD |= (1 << ledPin); //set ledPin high
		delay(500);
	}
	else
	{
		offRandom += now.unixtime();

		Timer1.initialize(flashLength);

		delay(500); //gives components time to start
	}

	PORTD &= ~(1 << ledPin); //set ledPin low

	attachInterrupt(0, deletePhotos, FALLING);
}

void loop()
{
	int32_t timeElapsed =  millis();
	Serial.flush();
	dirGen();
	if (flash == true)
	{
		blinkGenerator();
	}
	takePhoto(timeElapsed);
	deleteBuffer();
	if (flash == true)
	{
		storeFlashTime();
	}

	while((millis() - timeElapsed) < photoDelayLength);
}

void takePhoto(int32_t timeElapsed)
{
	uint32_t timeDifference = 0;
	char charBuff[23];
	strlcpy(charBuff, fileNameGen(rtc.now()), sizeof(charBuff));

	if (!cam.takePicture())
	{
		Serial.println(F(""Failed to take photo""));
		return;
	}
	else
	{
		Serial.println(F(""Picture taken""));
	}
		
	if (SD.exists(charBuff))
	{
		Serial.println(F(""Overwriting""));
	}

	// Open the file for writing
	File  [MASK]  = SD.open(charBuff, FILE_WRITE);

	// Get the size of the image (frame) taken  
	uint16_t jpglen = cam.frameLength();
	Serial.print(F(""Writing image to ""));
	Serial.println(charBuff);
	Serial.print(F(""Storing ""));
	Serial.print(jpglen, DEC);
	Serial.print(F("" byte image.""));

	pinMode(8, OUTPUT);
	// Read all the data up to # bytes!
	byte wCount = 0; // For counting # of writes
	while (jpglen > 0)
	{
		// read 32 bytes at a time;
		uint8_t *buffer;
		uint8_t bytesToRead = min(64, jpglen); // change 64 to 32 if storing photos proves unstable
		buffer = cam.readPicture(bytesToRead);
		 [MASK] .write(buffer, bytesToRead);
		if (++wCount >= 64)
		{
			//Every 2K, give a little feedback so it doesn't appear locked up
			Serial.print('.');
			wCount = 0;
		}
		jpglen -= bytesToRead;
	}
	 [MASK] .close();

	timeDifference = millis() - timeElapsed;
	Serial.println(F(""done!""));
	Serial.print(timeDifference);
	Serial.println(F("" ms elapsed""));
	Serial.println();
	cam.resumeVideo();
}

void logInitialization(char logName[], char title[])
{
	File logFile = SD.open(logName, FILE_WRITE);
	delay(10);
	/*
	logFile.println(F(""-------------------------""));
	logFile.println(F(""LifeLogging Camera""));
	logFile.print(title);
	logFile.print(F("" Log file ""));
	logFile.print(dirName);
	logFile.println();
	logFile.println(F(""-------------------------""));
	*/
	logFile.close();
}

void storeFlashTime()
{
	if ((flashStartToggle * flashEndToggle) == true)
	{
		Serial.println(F(""Updating fla_log.txt""));
		char charBuff[23];

		strlcpy(charBuff, dirName, sizeof(charBuff));
		strcat(charBuff, ""/fla_log.txt"");
		File flashLog = SD.open(charBuff, FILE_WRITE);
		strcpy(charBuff, timeNameGen(flashStart));
		flashLog.print(charBuff);
		flashLog.print(F(""		""));
		strcpy(charBuff, timeNameGen(flashEnd));
		flashLog.println(charBuff);
		flashLog.close();

		flashStartToggle = false;
		flashEndToggle = false;
	}
}

void blinkLED()
{
	if (digitalRead(ledPin) == HIGH)
	{
		PORTD &= ~(1 << ledPin); //set ledPin low
	}
	else
	{
		PORTD |= (1 << ledPin); //set ledPin high
	}
	--onRandom;
	if (onRandom == 0)
	{
		flashEndToggle = true;
		PORTD &= ~(1 << ledPin); //set ledPin low
		Timer1.detachInterrupt();
	}
}

void blinkGenerator()
{
	if ((flashStartToggle + flashEndToggle) == 0)
	{
		uint16_t onRandomTemp = onRandom;
		DateTime timeTemp = rtc.now();

		if (onRandomTemp == 0)
		{	
			if (offRandom == 0)
			{
				offRandom = random(offPeriodMin, (offPeriodMax + 1));
				offRandom += timeTemp.unixtime();
			}
			if (offRandom <= timeTemp.unixtime())
			{
				flashStart = timeTemp;
				flashStartToggle = true;
				onRandomTemp = random(onPeriodMin, (onPeriodMax + 1));
				flashEnd = ((onRandomTemp * flashLength) / 1000000) + timeTemp.unixtime();
				offRandom = 0;
				noInterrupts();
				onRandom = onRandomTemp;
				Timer1.attachInterrupt(blinkLED);
				interrupts();
			}
		}
	}
}

void deletePhotos()
{
	deletePhotoToggle = true;
	detachInterrupt(0);
}

void deleteBuffer()
{
	noInterrupts();
	boolean deletePhotoToggleTemp = deletePhotoToggle;
	interrupts();

	if (deletePhotoToggleTemp == true)
	{
		DateTime now = rtc.now();
		uint32_t startTime = now.unixtime();
		char charBuff[23];

		Serial.println(F(""Updating del_log.txt""));
		strlcpy(charBuff, dirName, sizeof(charBuff));
		strcat(charBuff, ""/del_log.txt"");
		File deleteLog = SD.open(charBuff, FILE_WRITE);
		uint32_t x = 0;
		if (startTime > deleteLength)
		{
			x = (startTime - deleteLength);
		}

		while (x < startTime)
		{
			now = x;
			strlcpy(charBuff, fileNameGen(now), sizeof(charBuff));
			if (SD.exists(charBuff))
			{
				Serial.print(F(""Deleting ""));
				Serial.println(charBuff);
				SD.remove(charBuff);
				deleteLog.println(now.unixtime());
				//deleteLog.println(charBuff);
			}
			++x;
		}
		deleteLog.close();
		deletePhotoToggleTemp = false;
		noInterrupts();
		deletePhotoToggle = false;
		interrupts();
		attachInterrupt(0, deletePhotos, FALLING);
	}
}

char* fileNameGen(DateTime time)
{
	char charBuff[23];
	strlcpy(charBuff, dirName, sizeof(charBuff));
	strcat(charBuff, ""/"");
	strcat(charBuff, timeNameGen(time));
	strcat(charBuff, "".JPG"");
	return charBuff;
}

char* timeNameGen(DateTime time)
{
	char charBuff[9];
	char charShort[3];

	sprintf(charShort, ""%d"", time.hour());
	if (time.hour() < 10)
	{
		strlcpy(charBuff, ""0"", sizeof(charBuff));
		strcat(charBuff, charShort);
	}
	else
	{
		strlcpy(charBuff, charShort, sizeof(charBuff));
	}

	strcat(charBuff, ""_"");

	sprintf(charShort, ""%d"", time.minute());
	if (time.minute() < 10)
	{
		strcat(charBuff, ""0"");
		strcat(charBuff, charShort);
	}
	else
	{
		strcat(charBuff, charShort);
	}

	strcat(charBuff, ""_"");

	sprintf(charShort, ""%d"", time.second());
	if (time.second() < 10)
	{
		strcat(charBuff, ""0"");
		strcat(charBuff, charShort);
	}
	else
	{
		strcat(charBuff, charShort);
	}

	return charBuff;
}

char* dateNameGen(DateTime now)
{
	char charBuff[10] = {""\0""};
	char charShort[5];
	strlcpy(charBuff, ""/"", sizeof(charBuff));

	sprintf(charShort, ""%d"", now.year());
	if (now.year() < 10)
	{
		strcat(charBuff, ""000"");
		strcat(charBuff, charShort);
	}
	else if (now.year() < 100)
	{
		strcat(charBuff, ""00"");
		strcat(charBuff, charShort);
	}
	else if (now.year() < 1000)
	{
		strcat(charBuff, ""0"");
		strcat(charBuff, charShort);
	}
	else
	{
		strcat(charBuff, charShort);
	}

	sprintf(charShort, ""%d"", now.month());
	if (now.month() < 10)
	{
		strcat(charBuff, ""0"");
		strcat(charBuff, charShort);
	}
	else
	{
		strcat(charBuff, charShort);
	}

	sprintf(charShort, ""%d"", now.day());
	if (now.day() < 10)
	{
		strcat(charBuff, ""0"");
		strcat(charBuff, charShort);
	}
	else
	{
		strcat(charBuff, charShort);
	}

	return charBuff;
}

void dirGen()
{
	char charBuff[23];
	strlcpy(charBuff, dateNameGen(rtc.now()), sizeof(charBuff));
	if (dirName != charBuff)
	{
		strlcpy(dirName, charBuff, sizeof(dirName));
		if (!SD.exists(dirName))
		{
			SD.mkdir(dirName);
			strlcpy(charBuff, dirName, sizeof(charBuff));
			strcat(charBuff, ""/del_log.txt"");
			logInitialization(charBuff, ""Deleted Files"");
			strlcpy(charBuff, dirName, sizeof(charBuff));
			strcat(charBuff, ""/fla_log.txt"");
			logInitialization(charBuff, ""Flash Timings"");
			/*
			File flashLog = SD.open(charBuff, FILE_WRITE);
			delay(10);
			flashLog.println(F(""ON\t\t\t\t\tOFF""));
			flashLog.close();
			*/
		}
	}
}
",imgFile
875,"#include <ESP32Servo.h>

// Define joystick pins
const int JOY_X = 35;     // Horizontal (X)
const int JOY_Y = 34;     // Vertical (Y)
const int JOY_BTN = 32;   // Button (SEL)

// Servo objects
Servo servo1;  // Base rotation
Servo servo2;  // Shoulder
Servo servo3;  // Gripper or elbow

// State
int currentServo = 0;
bool lastButtonState = HIGH;

void setup() {
  Serial.begin(115200);

  pinMode(JOY_BTN, INPUT_PULLUP);  // internal pull-up

  // Attach servos with pulse width range (can adjust if needed)
  servo1.attach(12, 500, 2400);
  servo2.attach(13, 500, 2400);
  servo3.attach(14, 500, 2400);
}

void loop() {
  // Read joystick positions
  int xValue = analogRead(JOY_X);  // 0–4095
  int yValue = analogRead(JOY_Y);
  int buttonState = digitalRead(JOY_BTN);

  // Map joystick value to angle 0–180
  int angleX = map(xValue, 0, 4095, 0, 180);
  int  [MASK]  = map(yValue, 0, 4095, 0, 180);

  // Handle button press (debounced)
  if (buttonState == LOW && lastButtonState == HIGH) {
    currentServo = (currentServo + 1) % 3;
    Serial.print(""Switched to Servo "");
    Serial.println(currentServo + 1);
    delay(300);  // Debounce delay
  }
  lastButtonState = buttonState;

  // Control the currently selected servo
  switch (currentServo) {
    case 0:
      servo1.write(angleX);  // X-axis for base
      break;
    case 1:
      servo2.write( [MASK] );  // Y-axis for shoulder
      break;
    case 2:
      servo3.write((angleX +  [MASK] ) / 2);  // Mix for gripper
      break;
  }

  delay(20); // small delay for stability
}
",angleY
876,"/**************************************************************************/
/*!
    @file     GSL1680.cpp
    @author   Skallwar

    @thanks to wolfmanjm for the source code this lib is bassed on : https://github.com/wolfmanjm/GSL1680
*/

#include <Arduino.h>
#include <Wire.h>

#include <stdint.h>

#include ""GSL1680.h""
#include ""gslX680firmware.h""

// Registres
#define I2CADDR 0x40
#define DATA_REG 0x80
#define STATUS_REG 0xE0
#define PAGE_REG 0xF0

//CONST
#define BUFSIZE 32

#define SERIAL_ERROR if(GSL1680_DEBUG_ERROR)Serial
#define SERIAL_INFORMATION if(GSL1680_DEBUG_INFO)Serial

struct Touch_event ts_event;

GSL1680::GSL1680() {
    GSL1680_DEBUG_ERROR = false;
    GSL1680_DEBUG_INFO = false;
}

GSL1680::GSL1680(bool error, bool info) {
    GSL1680_DEBUG_ERROR = error;
    GSL1680_DEBUG_INFO = info;
}

void GSL1680::begin(uint8_t WAKE, uint8_t INTRPT)
{
    SERIAL_INFORMATION.println(""GSL1680: Start boot up sequence"");
    pinMode(WAKE, OUTPUT);          //
    digitalWrite(WAKE, LOW);        //
    pinMode(INTRPT, INPUT_PULLUP);  // Startup sequence PIN part
    delay(100);

  SERIAL_INFORMATION.println(""Toggle Wake"");
	digitalWrite(WAKE, HIGH);
	delay(50);
	digitalWrite(WAKE, LOW);
	delay(50);
	digitalWrite(WAKE, HIGH);
	delay(30);

    Wire.begin();

    // CTP startup sequence
	SERIAL_INFORMATION.println(""Clear reg"");
	clear_reg();
	SERIAL_INFORMATION.println(""Reset chip"");
	reset();
	SERIAL_INFORMATION.println(""GSL1680: Load FW"");
	loadfw();
	//startup_chip();
	SERIAL_INFORMATION.println(""Reset chip 2"");
	reset();
	SERIAL_INFORMATION.println(""Startup Chip"");
    startchip();
	SERIAL_INFORMATION.println(""GSL1680: Boot up complete"");
}

void GSL1680::clear_reg()
{
    uint8_t REG[4] = {0xE0, 0x80, 0xE4, 0xE0};
    uint8_t DATA[4] = {0x88, 0x01, 0x04, 0x00};
    uint8_t TIMER[4] = {20, 5, 5, 20};

    Wire.beginTransmission(I2CADDR);

    int i;
    for (i = 0; i < 4; ++i) {
        Wire.write(REG[i]);
        Wire.write(DATA[i]);
        delay(TIMER[i]);
    }

    int r = Wire.endTransmission();
    if (r != 0){
        SERIAL_ERROR.print(""i2c write error: ""); SERIAL_ERROR.print(r); SERIAL_ERROR.print("" ""); SERIAL_ERROR.println(REG[i], HEX);
    }

}

void GSL1680::reset()
{
    uint8_t REG[2] = {STATUS_REG, 0xE4};
    uint8_t DATA[2] = {0x88, 0x04};
    uint8_t TIMER[2] = {20, 10};

    Wire.beginTransmission(I2CADDR);

    int i;
    for (i = 0; i < 2; ++i) {
        Wire.write(REG[i]);
        Wire.write(DATA[i]);
        delay(TIMER[i]);
    }

    int r = Wire.endTransmission();
    if (r != 0){
        SERIAL_ERROR.print(""i2c write error: ""); SERIAL_ERROR.print(r); SERIAL_ERROR.print("" ""); SERIAL_ERROR.println(REG[i], HEX);
    }

    uint8_t DATA_2[4] = {0};

    datasend (0xBC, DATA_2, 4);
    delay(10);
}

void GSL1680::loadfw()
{
    uint8_t  [MASK] ;
    uint8_t Wrbuf[4];
    size_t source_len = sizeof(GSLX680_FW) / sizeof(struct fw_data);

    for (size_t source_line = 0; source_line < source_len; source_line++) {
         [MASK]  = GSLX680_FW[source_line].offset;
        Wrbuf[0] = (char)(GSLX680_FW[source_line].val & 0x000000ff);
        Wrbuf[1] = (char)((GSLX680_FW[source_line].val & 0x0000ff00) >> 8);
        Wrbuf[2] = (char)((GSLX680_FW[source_line].val & 0x00ff0000) >> 16);
        Wrbuf[3] = (char)((GSLX680_FW[source_line].val & 0xff000000) >> 24);

        datasend( [MASK] , Wrbuf, 4);
    }
}

void GSL1680::startchip()
{
    Wire.beginTransmission(I2CADDR);

    Wire.write(0xE0);   //Registre
    Wire.write(0x00);   //DATA

    int r = Wire.endTransmission();
    if (r != 0){
        SERIAL_ERROR.print(""i2c write error: ""); SERIAL_ERROR.print(r); SERIAL_ERROR.print("" ""); SERIAL_ERROR.println(0xE0, HEX);
    }
}

void GSL1680::sleep()
{

}

void GSL1680::datasend(uint8_t REG, uint8_t DATA[], uint16_t NB)
{
    Wire.beginTransmission(I2CADDR);

    Wire.write(REG);

    for (uint16_t i = 0; i < NB; i++) {
        Wire.write(DATA[i]);
    }

    int r = Wire.endTransmission();
    if (r != 0) {
        SERIAL_ERROR.print(""i2c write error: ""); SERIAL_ERROR.print(r); SERIAL_ERROR.print("" ""); SERIAL_ERROR.println(REG, HEX);
    }
}

uint8_t GSL1680::dataread()
{
    uint8_t TOUCHRECDATA[24] = {0};

    Wire.beginTransmission(I2CADDR);

    Wire.write(DATA_REG);

    int n = Wire.endTransmission();
    if (n != 0) {
        SERIAL_ERROR.print(""i2c write error: ""); SERIAL_ERROR.print(n); SERIAL_ERROR.print("" ""); SERIAL_ERROR.println(DATA_REG, HEX);
    }

    n = Wire.requestFrom(I2CADDR, 24);
    if (n != 24) {
        SERIAL_ERROR.print(""i2c read error: did not get expected count ""); SERIAL_ERROR.print(n); SERIAL_ERROR.print(""/""); SERIAL_ERROR.println(""24"");
    }

    for(int i = 0; i<n; i++) {
        TOUCHRECDATA[i] = Wire.read();
    }

    ts_event.NBfingers = TOUCHRECDATA[0];
    for(int i = 0; i<ts_event.NBfingers; i++) {
        ts_event.fingers[i].x = ( (((uint32_t)TOUCHRECDATA[(i*4)+5])<<8) | (uint32_t)TOUCHRECDATA[(i*4)+4] ) & 0x00000FFF; // 12 bits of X coord
        ts_event.fingers[i].y = ( (((uint32_t)TOUCHRECDATA[(i*4)+7])<<8) | (uint32_t)TOUCHRECDATA[(i*4)+6] ) & 0x00000FFF;
        ts_event.fingers[i].fingerID = (uint32_t)TOUCHRECDATA[(i*4)+7] >> 4; // finger that did the touch
    }

    return ts_event.NBfingers;
}

uint8_t GSL1680::readFingerID(int NB)
{
    return ts_event.fingers[NB].fingerID;
}

uint32_t GSL1680::readFingerX(int NB)
{
    return ts_event.fingers[NB].x;
}

uint32_t GSL1680::readFingerY(int NB)
{
    return ts_event.fingers[NB].y;
}
",addr
877,"#include <iostream>
using namespace std;

class IllegalCoordinateException{
    private:
    int first,second;
    public:
        IllegalCoordinateException(pair<int,int>  [MASK] ){
            first =  [MASK] .first;
            second =  [MASK] .second;
        }
        string theCoordinate() const{
            return to_string(first)+"",""+to_string(second);
        }
    friend ostream& operator<< (ostream& out,IllegalCoordinateException ex){
        return cout << ex.first <<"",""<<ex.second<<endl;
    }
};
class IllegalCharException{
    private:
    char c;
    public:
    IllegalCharException(char someChar){
        c = someChar;
    }
    char theChar() const{
        return c;
    }
    friend ostream& operator<< (ostream& out,IllegalCharException ex){
        return cout << ex.c <<endl;
    }
};",coordinates
878,"#include ""streamdumper.h""

#include <cstdio>
#include <iostream>

using namespace std;

StreamDumper::StreamDumper(const std::string &file_name, int64_t  [MASK]  ) :
    bytes_to_go(  [MASK]  )
{
    if ( file_name == std::string( ""stdout"" ) ) {
        use_stdout = true;
        file = stdout;
    } else {
        use_stdout = false;
        file = fopen( file_name.c_str(), ""wb"" );
    }
    if ( !file ) {
        throw std::runtime_error( ""StreamDumper::StreamDumper() error opening file '"" + file_name + ""'"" );
    }
}

StreamDumper::~StreamDumper() {
    if ( file ) {
        if ( use_stdout ) {
            fflush( stdout );
            cerr << ""Stream was flushed"" << endl;
        } else {
            fclose( file );
            cerr << ""File was closed"" << endl;
        }
    }
}

void StreamDumper::HandleDeviceData(void *data_pointer, size_t size_in_bytes)
{
    char* src = ( char* ) data_pointer;
    std::vector<char>* msg = new std::vector<char>( src, src + size_in_bytes );
    this->ReceiveMessage( msg );
}

DumperStatus_e StreamDumper::GetStatus() {
    std::lock_guard<std::mutex> guard( mtx );
    if ( error_count ) {
        return DS_ERROR;
    }
    if ( bytes_to_go <= 0 ) {
        return DS_DONE;
    }
    return DS_PROCESS;
}

int64_t StreamDumper::GetBytesToGo() {
    std::lock_guard<std::mutex> guard( mtx );
    return bytes_to_go;
}

void StreamDumper::HandleMessageAsync(std::vector<char> *message_ptr, const int current_queue_size, bool &free_ptr_flag) {
    free_ptr_flag = true;
    {
        std::lock_guard<std::mutex> guard( mtx );
        if ( bytes_to_go < 0 ) {
            return;
        }
        bytes_to_go -= message_ptr->size();
    }

    if ( file ) {
        size_t wrote = fwrite( message_ptr->data(), 1, message_ptr->size(), file );
        if ( wrote != message_ptr->size() ) {
            cerr << ""File write error: wrote "" << wrote << "" of "" << message_ptr->size() << "" bytes"" << endl;
            error_count++;
        }
    }
}



",bytes_to_dump
879,"//	Copyright 2017 <NAME>
//	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 ASMITH_PATHFINDING_A_STAR_HPP
#define ASMITH_PATHFINDING_A_STAR_HPP

#include ""basic_pathfinder.hpp""
	
namespace asmith { namespace pathfinding {

	template<class K>
	struct a_star_node {
		K key;
		K parent;
		float g;
		float f;
		bool closed;
	};
	
	template<class K, class C = float>
	class a_star : public basic_pathfinder<K,C, a_star_node<K>> {
	private:
		float(*mHeuristic)(K, K);
		float(*mDistance)(K, K);
	public:
		a_star(float(*aHeuristic)(K, K), float(*aDistance)(K, K)) :
			mHeuristic(aHeuristic),
			mDistance(aDistance)
		{}

		// Inherited from pathfinder 

		std::vector<key_t> find_path(const map<key_t, C>& aMap, const key_t aBegin, const key_t  [MASK] ) const throw() override {
			mStack.clear(); // Open set
			mNodes.clear(); // Closed set

			mNodes.emplace(aBegin, node({ aBegin, aBegin, 0.f, mHeuristic(aBegin,  [MASK] ), false}));
			mStack.push_back(aBegin);

			while(! mStack.empty()) {
				node* n = &mNodes.find(mStack.front())->second;
				size_t index= 0;
				const size_t s = mStack.size();
				for(size_t i = 1; i < s; ++i) {
					node* const tmp = &mNodes.find(mStack[i])->second;
					if(tmp->f < n->f) {
						n = tmp;
						index = i;
					}
				}
				if(n->key ==  [MASK] ) return reconstruct_path(aBegin, *n);
				mStack.erase(mStack.begin() + index);
				n->closed = true;

				size_t count = 0;
				const connection_t* const connections = aMap.get_connections(n->key, count);
				for(size_t i = 0; i < count; ++i) {
					const key_t k = connections[i].first;

					const auto j = mNodes.find(k);
					node& n2 = j == mNodes.end() ?
						mNodes.emplace(k, node({ k, n->key, FLT_MAX, FLT_MAX, false })).first->second :
						j->second;

					if(n2.closed) continue;
					if(std::find(mStack.begin(), mStack.end(), k) == mStack.end()) mStack.push_back(k);

					const float g = n->g + mDistance(n->key, n2.key);
					if(g >= n2.g) continue;
					n2.parent = n->key;
					n2.g = g;
					n2.f = g + mHeuristic(n2.key,  [MASK] );
				}
			}
			return std::vector<key_t>();
		}
	};
}}

#endif",aEnd
880,"/**
 *   @file apps/cda-caen-daq/main.cxx
 *  @short Main file for the cda-caen-daq application
 *
 *         This file stores the code that runs the cda-caen-daq application.
 *         It is rather simple, it reads a few simple command line options,
 *         then sets up CaenDAQWindow to do the rest of the job.
 *
 * @author <NAME> <<EMAIL>>
 */

// Qt include(s):
#include <QApplication>

// CDA include(s):
#include ""CDAVersion.h""
#include ""common/DefaultFont.h""
#include ""common/SplashScreen.h""
#include ""i18n/Loader.h""
#include ""msg/Logger.h""
#include ""msg/Sender.h""
#include ""tclap/CmdLine.h""

// Local include(s):
#include ""Constants.h""
#include ""MainWindow.h""

// Description for the executable:
static const char* description =
    ""Main DAQ program for running CDA on a single machine that does ""
    ""all the work in a CAEN data taking session."";

int main(int argc, char* argv[]) {

   //
   // Create a Qt application and let it remove the Qt-related entries from the
   // command line arguments:
   //
   QApplication app(argc, argv);
   app.setFont(gui::DefaultFont());

   //
   // Read the rest of the command line arguments:
   //
   TCLAP::CmdLine cmd(description, ' ', CDA_VERSION_STRING);
   TCLAP::ValueArg<int> verbosity(""v"", ""verbosity"", ""Level of output verbosity"",
                                  false, 3, ""code"");
   cmd.add(verbosity);
   TCLAP::ValueArg<std::string> config(""c"", ""config"",
                                       ""Name of an XML config file, or ""
                                       ""address of a config server"",
                                       false, """", ""filename/address"");
   cmd.add(config);
   cmd.parse(argc, argv);

   // Set the message server to a fixed address:
   msg::Sender::addAddress(Address(MSG_SERVER_ADDRESS));

   // Logger object used to print messages directly from this function:
   msg::Logger logger(""cda-caen-daq"");

   //
   // Create a splash screen:
   //
   gui::SplashScreen splash(
       QPixmap("":/img/splash.png""),
       Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint);
   splash.show();

   //
   // Load all the available translations:
   //
   i18n::Loader trans_loader;
   if (!trans_loader.loadTranslations()) {
      logger << msg::FATAL
             << qApp->translate(""cda-caen-daq"",
                                ""Couldn't load the translations!"")
             << msg::endmsg;
      return 1;
   }

   //
   // Translate the verbosity option:
   //
   msg::Level  [MASK]  = msg::INFO;
   switch (verbosity.getValue()) {

      case 1:
          [MASK]  = msg::VERBOSE;
         break;
      case 2:
          [MASK]  = msg::DEBUG;
         break;
      case 3:
          [MASK]  = msg::INFO;
         break;
      case 4:
          [MASK]  = msg::WARNING;
         break;
      case 5:
          [MASK]  = msg::ERROR;
         break;
      case 6:
          [MASK]  = msg::FATAL;
         break;
      case 7:
          [MASK]  = msg::ALWAYS;
         break;
      default:
         logger << msg::FATAL
                << qApp->translate(""cda-caen-daq"",
                                   ""Didn't recognise verbosity level setting\n""
                                   ""Terminating..."")
                << msg::endmsg;
         return 1;
   }
   msg::Sender::instance()->setMinLevel( [MASK] );

   //
   // Create and show the main window of the application:
   //
   MainWindow window(config.getValue().c_str(),  [MASK] );
   window.show();
   splash.showMessage(qApp->translate(""cda-caen-daq"", ""CAEN DAQ Ready""),
                      Qt::AlignHCenter | Qt::AlignBottom, Qt::white);

   // Run the main Qt event loop:
   return app.exec();
}
",lvl
881,"/*
* Copyright 2005-2009 WSO2, Inc. http://wso2.com
*
* 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 <stdio.h>
#include <ServiceClient.h>
#include <OMElement.h>
#include <iostream>
#include <WSFault.h>
#include <Environment.h>

using namespace std;
using namespace wso2wsf;

int main(int argc, char *argv[])
{
    Environment::initialize(""echo.log"", AXIS2_LOG_LEVEL_TRACE);
    
    string end_point = ""http://localhost:9090/axis2/services/echo"";

    if (argc > 1)
    {   
        if (string (argv[1]).compare(""-h"") == 0)
        {   
            cout << ""Usage : "" << argv[0] << "" [end_point]"" << endl;
            cout << ""use -h for help"" << endl;
            cout << ""default end_point "" << end_point << endl;
            return 0;
        }   
        else
            end_point = argv[1];
    }   
	ServiceClient sc(end_point);

	cout << endl << ""Using end_point: "" << end_point << endl;

    int  [MASK]  = 1;
    sc.engageModule(AXIS2_MODULE_ADDRESSING);
    for (int i = 0; i <  [MASK] ; i++)
    {
        OMNamespace * ns = new OMNamespace(""http://ws.apache.org/axis2/services/echo"", ""ns1"");
        OMElement * payload = new OMElement(NULL,""echoString"", ns);
        OMElement * child = new OMElement(payload,""text"", NULL);
        child->setText(""Hello World!"");
        cout << endl << ""Request: "" << payload << endl;
        
        try
        {
            OMElement* response = sc.request(payload, ""http://ws.apache.org/axis2/c/samples/echoString"");
            if (response)
            {
                cout << endl << ""Response: "" << response->getFirstElement() << endl;
            }
        }
        catch (WSFault & e)
        {
            if (sc.getLastSOAPFault())
            {
                cout << endl << ""Fault: "" << sc.getLastSOAPFault() << endl;
            }
            else
            {
                cout << endl << ""Error: "" << e << endl;
            }
        }
        delete payload;
    }
}

",iterations
882,"#include <weekend/base/camera.hpp>
#include <weekend/base/hittable.hpp>
#include <weekend/base/hittable_list.hpp>
#include <weekend/base/material.hpp>
#include <weekend/base/sphere.hpp>

using namespace weekend;
using weekend::base::camera;
using weekend::base::dielectric;
using weekend::base::hittable;
using weekend::base::hittable_list;
using weekend::base::lambertian;
using weekend::base::metal;
using weekend::base::sphere;
using weekend::core::color;
using weekend::core::interval;
using weekend::core::point3;
using weekend::core::ray;
using weekend::core::vec3;

using std::make_shared;

int main() {
  hittable_list world;

  auto material_ground = make_shared<lambertian>(color(0.8, 0.8, 0.0));
  auto  [MASK]  = make_shared<lambertian>(color(0.1, 0.2, 0.5));
  auto material_left = make_shared<dielectric>(1.50);
  auto material_bubble = make_shared<dielectric>(1.00 / 1.50);
  auto material_right = make_shared<metal>(color(0.8, 0.6, 0.2), 1.0);

  world.add(
      make_shared<sphere>(point3(0.0, -100.5, -1.0), 100.0, material_ground));
  world.add(make_shared<sphere>(point3(0.0, 0.0, -1.2), 0.5,  [MASK] ));
  world.add(make_shared<sphere>(point3(-1.0, 0.0, -1.0), 0.5, material_left));
  world.add(make_shared<sphere>(point3(-1.0, 0.0, -1.0), 0.4, material_bubble));
  world.add(make_shared<sphere>(point3(1.0, 0.0, -1.0), 0.5, material_right));

  camera cam;

  cam.m_aspect_ratio = 16.0 / 9.0;
  cam.m_image_width = 400;
  cam.m_samples_per_pixel = 100;
  cam.m_max_depth = 50;

  cam.render(world, ""dielectric_scene.ppm"");
}",material_center
883,"// example.cpp
// 
// 正则表达式解析库演示
// 
// 与2004年在北京写于创意鹰翔公司
// 版权申明:
// 作者放弃除著作署名权之外的任何权益。你可以在保留此申明的前提下，自由的，无限制的
// 分发、修改和使用本函数库。
// 如果你有任何建议和BUG汇报，欢迎你联系原始作者:<EMAIL>
//
// 原始作者 : lanzhengpeng(兰征鹏)
// Modify time : 2005-03-12   16:58
// 历史: 参看re_history.txt
//-----------------------------------------------------------------------------

#include <iostream>
#include <fstream>
#include <strstream>
#include <string>

#pragma warning(disable : 4786)

#include ""regular.h""

//抽取出C/C++中的字符串
std::string _get_cpp_string_with_comment(const unsigned char * psz)
{
	re_pattern_mb	p;
	p.parse((unsigned char *)""({\\s}([ \\t\\r\\n]*(\\o|\\p)[ \\t\\r\\n]*)*)+"",NULL,VFX::rf_return);

	re_result_mb	r;
	p.match((unsigned char *)psz,r);

	std::strstream strio;
	strio << ""\"""";
	for(size_t i=0; i<r.GroupCount(); ++i)
	{
		re_match_mb mch = r[i];
		if(mch.id == 0)
		{
			for(const unsigned char * sz=mch.begin+1; sz<mch.end-1; ++sz)
				strio << *sz;
		}
	}
	strio << ""\"""";
	return std::string(strio.str(), (size_t)strio.pcount());
}

template<class CharT>
struct select_re_traits{};
template<> struct select_re_traits<char>{
	typedef VFX::re_traits_a	re_traits;
};
template<> struct select_re_traits<unsigned char>{
	typedef VFX::re_traits_mb	re_traits;
};
template<> struct select_re_traits<wchar_t>{
	typedef VFX::re_traits_w	re_traits;
};

//替换函数
//pszFind:条件表达式。正则表达式
//pszReplaceWith:替换内容表达式。
//				\0表示替换成查找到的内容,
//				\1,\2,...表示替换成条件表达式中第0个，第1个，...组
//				其余部分原封不动的替换
//pszReplace:将要被替换的文本
//strResult:替换的结果文本
//bCase:区分大小写否
template<class CharT>
bool replace(const CharT * pszFind,
			const CharT * pszReplaceWith,
			const CharT * pszReplace,
			std::basic_string<CharT> & strResult,
			bool bCase)
{
	typedef select_re_traits<CharT>::re_traits	re_traits;

	VFX::re_pattern<re_traits>	rpf;
	if(rpf.parse(pszFind,NULL,bCase?VFX::rf_zero:VFX::rf_nocase) != VFX::ree_ok)
		return false;
	VFX::re_result<re_traits>  [MASK] ;
	{
		VFX::re_pattern<re_traits>	rpw;
		rpw.parse((CharT *)""({(\\\\\\z)!*}{\\\\\\z}*)*"");
		rpw.match(pszReplaceWith, [MASK] );
	}

	const CharT * pend = pszReplace + strlen((CharT *)pszReplace);
	VFX::re_result<re_traits>	rr;
	for(const CharT * p = pszReplace; p < pend; )
	{
		if(VFX::ree_ok == rpf.match(p,rr,pend))
		{
			//匹配到表达式
			//输出被跳过的字符
			strResult.append((CharT *)p,rr.m_Match.begin - p);
			for(size_t i=0; i< [MASK] .GroupCount(); ++i)
			{
				VFX::re_match<re_traits> mch =  [MASK] [i];
				if(mch.id == 0)
				{
					strResult.append((CharT *)mch.begin,mch.end - mch.begin);
				}
				else 
				{
					size_t nGroup = _ttoi((CharT *)mch.begin + 1);
					if(nGroup == 0)
					{
						strResult.append((CharT *)rr.m_Match.begin,rr.m_Match.end - rr.m_Match.begin);
					}
					else if(nGroup <= rr.GroupCount())
					{
						mch = rr[nGroup - 1];
						strResult.append((CharT *)mch.begin,mch.end - mch.begin);
					}
				}
			}
			//移动指针
			p = (CharT *)rr.m_Match.end;
		}
		else
		{
			strResult.append((CharT *)p,pend - p);
			//结束
			p = pend;
		}
	}
	
	return true;
}

inline bool __IsCharEq(TCHAR c1,TCHAR c2)
{
	return _totlower(c1) == _totlower(c2);
}

void test_re_swap()
{
	const char* pszReplace =
		""	m_fmCBI.createdate = sc->createdate;\r\n""
		""	m_fmCBI.money = sc->money;\r\n""
		""	m_fmCBI.fame = sc->fame;\r\n""
		""	m_fmCBI.fans_number = sc->fans_number;\r\n""
		""	m_fmCBI.fans_intimate = sc->fans_intimate;\r\n""
		""	m_fmCBI.shirt_index = sc->shirt_index;\r\n""
		""	m_fmCBI.shirt_host_color1 = sc->shirt_host_color1;\r\n""
		""	m_fmCBI.shirt_host_color2 = sc->shirt_host_color2;\r\n""
		""	m_fmCBI.shirt_visiting_color1 = sc->shirt_visiting_color1;\r\n""
		""	m_fmCBI.shirt_visiting_color2 = sc->shirt_visiting_color2;\r\n""
		""	m_fmCBI.flag_index = sc->flag_index;\r\n""
		""	m_fmCBI.flag_color1 = sc->flag_color1;\r\n""
		""	m_fmCBI.flag_color2 = sc->flag_color2;\r\n""
		""	m_fmCBI.logo_index = sc->logo_index;\r\n"";

	std::string strResult;
	VFX::re_pattern<> rep;
	rep.parse(""{m_fmCBI[^ =]+} *= *{[^;]+}"");
	rep.replace(NULL,
		""\\2 = \\1"",
		pszReplace,
		strResult,
		VFX::rf_zero);
	std::cout << strResult;
}

void test_re_get_comment()
{
	std::string str(
		""\""\\r\""							// return\r\n""
		""\""\\t\""							// tab\r\n""
		""\""\\r?\\n\""							// newline\r\n""
		""\""[a-zA-Z0-9]\""						// alpha numeric\r\n""
		""\""[ \\t]\""							// white space (blank)\r\n""
		""\""[a-zA-Z]\""						// alpha\r\n""
		""\""[0-9]\""							// digit\r\n""
		""\""[0-9a-fA-F]\""						// hex digit\r\n""
		""\""(\\\""[^\\\""]*\\\"")|(\'[^\']*\')\""				// quoted string\r\n""
		""/*no implement*/\""test\""					// all right\r\n""
		""\""[a-zA-Z]+\""						// simple word\r\n""
		""\""[0-9]+\""						// integer\r\n""
	);
	std::cout << str << std::endl;
	std::cout << _get_cpp_string_with_comment((unsigned char*)str.c_str());
	std::cout << std::endl;
}

//去掉C++中的注释
void test_re_remove_comment(const char* path)
{
	//分析表达式
	re_pattern_mb	rp;
	rp.parse((unsigned char*)""{\\s}|{(\\o|\\p)}"");
	//打开文件
	std::ifstream	file(path, std::ios::in | std::ios::binary);
	//得到文件长度
	file.seekg(0, std::ios::end);
	size_t nlength = (size_t)file.tellg();
	file.seekg(0, std::ios::beg);
	//根据文件长度分配内存
	unsigned char* const pbuff = new unsigned char[nlength + 1];
	//读文件
	file.read((char*)pbuff, nlength);
	pbuff[nlength] = 0;

	//循环去掉注释
	unsigned char* pend = pbuff + nlength;
	re_result_mb	rr;
	for (unsigned char* p = pbuff; p < pend; )
	{
		if (VFX::ree_ok == rp.match(p, rr, pend))
		{
			//匹配到表达式
			//输出被跳过的字符
			std::cout.write((char*)p, rr.m_Match.begin - p);
			//输出字符串(匹配\s的组)
			if (rr[0].id == 0)
				std::cout.write((char*)rr[0].begin, rr[0].end - rr[0].begin);
			//移动指针
			p = (unsigned char*)rr.m_Match.end;
		}
		else
		{
			//无匹配，输出剩余的字符
			std::cout.write((char*)p, pend - p);
			//结束
			p = pend;
		}
	}
	//清理
	delete[] pbuff;
}

int main(int argc, char* argv[])
{
	if (argc > 1)
		test_re_remove_comment(argv[1]);
	test_re_swap();
	test_re_get_comment();

	return 0;
}
",rrw
884,"#include <vector>
#include <string>

#include ""Lexer.h""


Lexer::Lexer() = default;;

Lexer::Lexer(const Position& p, const ProgramString&) {
    current = p;
};

Lexer::~Lexer() = default;


std::vector<Token> Lexer::next() {
    std::vector<Token> v;
    if (!current.end_of_program()) {
        Position start = current;
        char c = current.get(); //сохранить текущий символ и перейти на следующий
        std::string tmp;

        if (c == '\n' && isProduct) {
            if (product_iter_tokens.size() == product_tokens.size()) {
                isProduct = false;
                for (int i = product_tokens.size() - 1; i >= 0; i--) {
                    v.push_back(product_iter_tokens[i]);
                    v.emplace_back(start, current, SET);
                    v.push_back(product_iter_tokens[i]);
                    v.emplace_back(start, current, ADD);
                    v.emplace_back(start, current, NUMBER, ""1"");
                    v.push_back(product_tokens[i]);
                    v.emplace_back(start, current, ENDB, ""\\end"");
                    v.emplace_back(start, current, ENDB, ""\\end"");
                }
                return v;
            } else {
                std::cout << ""iters != products"";  // не должно выполняться
            }
        } else if (c == '\n' && isSum) {
            if (sum_tokens.size() == sum_iter_tokens.size()) {
                isSum = false;
                for (int i = sum_tokens.size() - 1; i >= 0; i--) {
//                    std::cout << ""iter = "" << i << std::endl;
                    v.push_back(sum_iter_tokens[i]);
                    v.emplace_back(start, current, SET);
                    v.push_back(sum_iter_tokens[i]);
                    v.emplace_back(start, current, ADD);
                    v.emplace_back(start, current, NUMBER, ""1"");
                    v.emplace_back(start, current, ENDB, ""\\end"");
                    v.push_back(sum_tokens[i]);
                    v.emplace_back(start, current, ENDB, ""\\end"");
                }
                return v;
            } else {
                std::cout << ""iters != sums"";  // не должно выполняться
            }
        } else if (isspace(c)) {
            while (isspace(current.cur())) current++;
            v.emplace_back(start, current, SPACE);
            return v;
        } else if (c == '%') { //комментарии игнорируются до следующей строки
            do { current++; } while (!current.is_at_newline());
            v.emplace_back(start, current, SPACE);
            return v;
        } else if (c == '\\') {
            if (!current.end_of_program() && current.cur() == '\\') {
                current++;
                v.emplace_back(start, current, BREAK, ""\\\\"");
                return v;
            }
            for (tmp = c; isalpha(current.cur());) tmp += current.get();

            Tag tmp_tag = KEYWORD;
            auto res = raw_tag.find(tmp);
            if (res != raw_tag.end()) {
                tmp_tag = res->second;
                std::string attrib;
                if (tmp_tag == PLACEHOLDER) {
                    if (current.cur() == '[') {
                        current.get();
                        isPlaceholder = true;

                        auto tmp_cur = current;
                        while (current.cur() != ']') current.get();
                        current.get();
                        if (!get_attribute(attrib)) throw Error(current.start, ""Expected {...}"");

                        v.emplace_back(start, current, PLACEHOLDER, tmp);
                        v.emplace_back(start, tmp_cur, DIV);
                        v.emplace_back(start, tmp_cur, LPAREN);
                        current = tmp_cur;
                        return v;
                    } else {
                        if (!get_attribute(attrib)) throw Error(current.start, ""Expected {...}"");
                        v.emplace_back(start, current, PLACEHOLDER, tmp);
                        return v;
                    }
                }
                if (tmp_tag == BEGIN || tmp_tag == END) {
                    if (!get_attribute(attrib)) throw Error(current.start, ""Expected {...}"");
                    switch (tmp_tag) {
                        case BEGIN:
                            if (attrib == ""{block}"") {
                                v.emplace_back(start, current, BEGINB, tmp);
                                return v;
                            } else if (attrib == ""{caseblock}"") {
                                v.emplace_back(start, current, BEGINC, tmp);
                                return v;
                            } else if (attrib == ""{pmatrix}"") {
                                v.emplace_back(start, current, BEGINM, tmp);
                                return v;
                            }
                        case END:
                            if (attrib == ""{block}"") {
                                v.emplace_back(start, current, ENDB, tmp);
                                return v;
                            } else if (attrib == ""{caseblock}"") {
                                v.emplace_back(start, current, ENDC, tmp);
                                return v;
                            } else if (attrib == ""{pmatrix}"") {
                                v.emplace_back(start, current, ENDM, tmp);
                                return v;
                            }
                        default:
                            break;
                    }
                } else if (tmp_tag == SUM) {
                    current.get(); // прочитали _

                    sumName = ""sum"" + std::to_string(random());

                    v.emplace_back(start, current, BEGINB, ""\\begin"");

                    v.emplace_back(start, current, IDENT, sumName);
                    v.emplace_back(start, current, SET);
                    v.emplace_back(start, current, NUMBER, ""0"");

                    std::string lower_bound;
                    if (!get_attribute(lower_bound)) throw Error(current.start, ""Expected {...}"");
                    std::vector<Token> lower = parse_sum_lower_bound(lower_bound);

                    current.get(); // прочитали ^

                    std::string upper_bound;
                    if (!get_attribute(upper_bound)) throw Error(current.start, ""Expected {...}"");
                    std::vector<Token> upper = parse_sum_upper_bound(upper_bound);

                    v.insert(v.end(), lower.begin(), lower.end());
                    v.emplace_back(start, current, WHILE, ""\\while"");
                    v.emplace_back(start, current, LBRACE);
                    v.push_back(lower[0]);
                    v.emplace_back(start, current, LEQ);
                    v.push_back(upper[0]);
                    v.emplace_back(start, current, RBRACE);
                    v.emplace_back(start, current, BEGINB, ""\\begin"");

                    v.emplace_back(start, current, IDENT, sumName);
                    v.emplace_back(start, current, SET);
                    v.emplace_back(start, current, IDENT, sumName);
                    v.emplace_back(start, current, ADD);
                    sum_tokens.emplace_back(start, current, IDENT, sumName);
                    sum_iter_tokens.push_back(lower[0]);

                    isSum = true;

                    return v;
                } else if (tmp_tag == PRODUCT) {
                    isProduct = true;

                    productName = ""product"" + std::to_string(random());

                    current.get(); // прочитали _


                    v.emplace_back(start, current, BEGINB, ""\\begin"");
                    v.emplace_back(start, current, IDENT, productName);
                    v.emplace_back(start, current, SET);
                    v.emplace_back(start, current, NUMBER, ""1"");

                    std::string lower_bound;
                    if (!get_attribute(lower_bound)) throw Error(current.start, ""Expected {...}"");
                    std::vector<Token> lower = parse_sum_lower_bound(lower_bound);

                    current.get(); // read ^

                    std::string upper_bound;
                    if (!get_attribute(upper_bound)) throw Error(current.start, ""Expected {...}"");
                    std::vector<Token> upper = parse_sum_upper_bound(upper_bound);

                    v.insert(v.end(), lower.begin(), lower.end());
                    v.emplace_back(start, current, PRODUCT, ""\\product"");
                    //cond
                    v.emplace_back(start, current, LBRACE);
                    v.push_back(lower[0]);
                    v.emplace_back(start, current, LEQ);
                    v.push_back(upper[0]);
                    v.emplace_back(start, current, RBRACE);

                    v.emplace_back(start, current, BEGINB, ""\\begin"");
                    v.emplace_back(start, current, IDENT, productName);
                    v.emplace_back(start, current, SET);
                    v.emplace_back(start, current, IDENT, productName);
                    v.emplace_back(start, current, MUL);

                    product_tokens.emplace_back(start, current, IDENT, productName);
                    product_iter_tokens.push_back(lower[0]);

                    return v;
                } else if (tmp_tag == FLOOR) {
                    isFloor = true;

                    current.get(); //read *
                    if (current.get() == '{') {
                        v.emplace_back(start, current, KEYWORD, ""\\floor"");
                        v.emplace_back(start, current, LPAREN);
                    } else throw Error(current.start, ""Expected {...}"");

                    return v;
                } else if (tmp_tag == CEIL) {
                    isCeil = true;

                    current.get(); //read *
                    if (current.get() == '{') {
                        v.emplace_back(start, current, KEYWORD, ""\\ceil"");
                        v.emplace_back(start, current, LPAREN);
                    } else throw Error(current.start, ""Expected {...}"");

                    return v;
                }
            }
            v.emplace_back(start, current, tmp_tag, tmp);
            return v;
        } else if (isalpha(c)) {
            for (tmp = c; isalpha(current.cur()) || isdigit(current.cur());) tmp += current.get();
            auto res = dim_tag.find(tmp);

            if (res != dim_tag.end()) {
                v.emplace_back(start, current, DIMENSION, tmp);
                return v;
            } else if (current.can_peek() && current.cur() == '_' &&
                       current.peek() == '\\') {   //это не может быть индекс, потому что после '_' идет '\'
                tmp += current.get();   //прочитать '_'
                std::string kw;
                kw += current.get();
                while (isalpha(current.cur())) { kw += current.get(); } //прочитать '\text'
                if (kw != ""\\text"") throw Error(current.start, ""Expected \\text{...}"");
                if (!get_attribute(kw)) throw Error(current.start, ""Expected {...}"");
                tmp += kw;
            }
            v.emplace_back(start, current, IDENT, tmp);
            return v;
        } else if (isdigit(c)) {
            tmp = c;
            if (c != '0') while (isdigit(current.cur())) tmp += current.get();
            if (!current.end_of_program() && current.cur() == '.') {
                tmp += current.get();
                while (isdigit(current.cur())) tmp += current.get();
            }
            v.emplace_back(start, current, NUMBER, tmp);
            return v;
        } else {
            switch (c) {
                case '+':
                    v.emplace_back(start, current, ADD);
                    return v;
                case '-':
                    v.emplace_back(start, current, SUB);
                    return v;
                case '*':
                    v.emplace_back(start, current, MUL);
                    return v;
                case '/':
                    v.emplace_back(start, current, DIV);
                    return v;
                case '^':
                    v.emplace_back(start, current, POW);
                    return v;
                case '(':
                    v.emplace_back(start, current, LPAREN);
                    return v;
                case ')':
                    v.emplace_back(start, current, RPAREN);
                    return v;
                case ',':
                    v.emplace_back(start, current, COMMA);
                    return v;
                case '{':
                    if (!isPlaceholder) {
                        v.emplace_back(start, current, LBRACE);
                    } else {
                        v.emplace_back(current, current, SKIP);
                    }
                    return v;
                case '}':
                    if (!isPlaceholder && !isFloor && !isCeil) {
                        v.emplace_back(start, current, RBRACE);
                    } else {
                        if (isPlaceholder) {
                            isPlaceholder = false;
                            v.emplace_back(current, current, SKIP);
                        } else if (isFloor) {
                            isFloor = false;
                            v.emplace_back(start, current, RPAREN);
                        } else {
                            isCeil = false;
                            v.emplace_back(start, current, RPAREN);
                        }
                    }
                    return v;
                case '[':
                    v.emplace_back(start, current, LBRACKET);
                    return v;
                case ']':
                    if (!isPlaceholder) {
                        v.emplace_back(start, current, RBRACKET);
                    } else {
                        v.emplace_back(start, current, RPAREN);
                    }
                    return v;
                case '_':
                    v.emplace_back(start, current, INDEX);
                    return v;
                case '<':
                    v.emplace_back(start, current, LT);
                    return v;
                case '>':
                    v.emplace_back(start, current, GT);
                    return v;
                case '=':
                    v.emplace_back(start, current, EQ);
                    return v;
                case '&':
                    v.emplace_back(start, current, AMP);
                    return v;
                case ':':
                    if (!current.end_of_program() && current.cur() == '=') {
                        v.emplace_back(start, ++current, SET);
                        return v;
                    }
                default:
                    v.emplace_back(start, current);
                    return v;
            }
        }
    }
    v.emplace_back(current, current, NONE);
    return v;
}

std::vector<Token> Lexer::program_to_tokens(const ProgramString& ps) {
    std::vector<Token> res;
    Position::ps = ps;
    current = Position(ps.begin, ps.begin.pos - 1);
    Tag t;
    bool  [MASK]  = false;
    do {
        std::vector<Token> x = next();

        t = x[0]._tag;
        if (t == BEGIN) {
             [MASK]  = true;
        }
        if (! [MASK]  && t != SPACE && t != SKIP) {
            if (t == ERROR) {
                throw Error(x[0].start.start, ""Unexpected symbol"");
            }
            res.insert(res.end(), x.begin(), x.end());
        }
        if (t == END) {
             [MASK]  = false;
        }
    } while (t != NONE);
    return res;
}

bool Lexer::get_attribute(std::string &s) {
    while (isspace(current.cur())) ++current;   //нужно ли скипать пробелы?
    if (current.cur() != '{') return false;
    int lb = 0, rb = 0;
    do {
        char c = current.get();
        if (c == '\\') current.get();
        else if (c == '{') lb++;
        else if (c == '}') rb++;
        s += c;
    } while (lb != rb && !current.end_of_program());
    return lb == rb;
}

std::vector<Token> Lexer::parse_sum_lower_bound(std::string s) {
    Position start = current;
    std::vector<Token> v;
    int i = 1;
    std::string ident;
    std::string bound;

    bool ident_not_found = true;
    bool bound_not_found = true;

    while (i < s.length() && (ident_not_found || bound_not_found)) {
        if (isalpha(s[i])) {
            while (isalpha(s[i])) {
                ident += s[i];
                i++;
            }
            ident_not_found = false;
        } else if (isdigit(s[i])) {
            bound = s[i];
            if (s[i] != '0') {
                i++;
                while (isdigit(s[i])) {
                    bound += s[i];
                    i++;
                }
            }
            if (s[i] == '.') {
                bound += s[i];
                i++;
                while (isdigit(s[i])) {
                    bound += s[i];
                    i++;
                }
            }
            bound_not_found = false;
        }
        i++;
    }
    v.emplace_back(start, current, IDENT, ident);
    v.emplace_back(start, current, SET);
    v.emplace_back(start, current, NUMBER, bound);

    return v;
}

std::vector<Token> Lexer::parse_sum_upper_bound(std::string s) {
    Position start = current;
    std::vector<Token> v;
    int i = 1;
    std::string bound;

    bool bound_not_found = true;

    while (i < s.length() && bound_not_found) {
        if (isdigit(s[i])) {
            bound = s[i];
            if (s[i] != '0') {
                i++;
                while (isdigit(s[i])) {
                    bound += s[i];
                    i++;
                }
            }
            if (s[i] == '.') {
                bound += s[i];
                i++;
                while (isdigit(s[i])) {
                    bound += s[i];
                    i++;
                }
            }
            bound_not_found = false;
            v.emplace_back(start, current, NUMBER, bound);
        } else if (isalpha(s[i])) {
            while (isalpha(s[i])) {
                bound += s[i];
                i++;
            }
            bound_not_found = false;
            v.emplace_back(start, current, IDENT, bound);
        }
        i++;
    }
    return v;
}",skip
885,"/*
 * Copyright (C) 2008, <NAME> and <NAME>, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the names of Stanford University or <NAME>, Inc. nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

// %Tag(FULLTEXT)%
#include ""ros/ros.h""
#include ""k4a/k4a.h""
#include ""std_msgs/String.h""
#include <opencv4/opencv2/core.hpp>
#include <opencv4/opencv2/opencv.hpp>
#include <opencv4/opencv2/highgui.hpp>
#include <opencv4/opencv2/imgproc.hpp>
#include <iostream>

using namespace std;



/**
 * This tutorial demonstrates simple receipt of messages over the ROS system.
 */
// %Tag(CALLBACK)%
void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
  ROS_INFO(""I heard: [%s]"", msg->data.c_str());
}
// %EndTag(CALLBACK)%

int main(int argc, char **argv)
{
  /**
   * The ros::init() function needs to see argc and argv so that it can perform
   * any ROS arguments and name remapping that were provided at the command line.
   * For programmatic remappings you can use a different version of init() which takes
   * remappings directly, but for most command-line programs, passing argc and argv is
   * the easiest way to do it.  The third argument to init() is the name of the node.
   *
   * You must call one of the versions of ros::init() before using any other
   * part of the ROS system.
   */
  ros::init(argc, argv, ""listener"");

  /**
   * NodeHandle is the main access point to communications with the ROS system.
   * The first NodeHandle constructed will fully initialize this node, and the last
   * NodeHandle destructed will close down the node.
   */
  ros::NodeHandle n;

  /**
   * The subscribe() call is how you tell ROS that you want to receive messages
   * on a given topic.  This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing.  Messages are passed to a callback function, here
   * called chatterCallback.  subscribe() returns a Subscriber object that you
   * must hold on to until you want to unsubscribe.  When all copies of the Subscriber
   * object go out of scope, this callback will automatically be unsubscribed from
   * this topic.
   *
   * The second parameter to the subscribe() function is the size of the message
   * queue.  If messages are arriving faster than they are being processed, this
   * is the number of messages that will be buffered up before beginning to throw
   * away the oldest ones.
   */
    cout << ""OpenCV version : "" << CV_VERSION << endl;
    cout << ""Major version : "" << CV_MAJOR_VERSION << endl;
    cout << ""Minor version : "" << CV_MINOR_VERSION << endl;
    cout << ""Subminor version : "" << CV_SUBMINOR_VERSION << endl;
// %Tag(SUBSCRIBER)%
  ros::Subscriber sub = n.subscribe(""chatter"", 1000, chatterCallback);
// %EndTag(SUBSCRIBER)%

    uint32_t count = k4a_device_get_installed_count();
    // Open the first plugged in Kinect device
    k4a_device_t device = NULL;
    k4a_device_open(K4A_DEVICE_DEFAULT, &device);

    // Get the size of the serial number
    size_t  [MASK]  = 0;
    k4a_device_get_serialnum(device, NULL, & [MASK] );
    // Allocate memory for the serial, then acquire it
    char *serial = (char*)(malloc( [MASK] ));
    k4a_device_get_serialnum(device, serial, & [MASK] );
    printf(""Opened device: %s\n"", serial);
    free(serial);

    // Configure a stream of 4096x3072 BRGA color data at 15 frames per second
    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.camera_fps       = K4A_FRAMES_PER_SECOND_30;
    config.color_format     = K4A_IMAGE_FORMAT_COLOR_BGRA32;
    config.color_resolution = K4A_COLOR_RESOLUTION_2160P;
    config.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
    k4a_capture_t capture = NULL;
    // Start the camera with the given configuration
    if (K4A_FAILED(k4a_device_start_cameras(device, &config)))
    {
        printf(""Failed to start cameras!\n"");
        k4a_device_close(device);
        return 1;
    }
    cv::namedWindow(""Camera Stream"", cv::WINDOW_AUTOSIZE);
    // ...Camera capture and application specific code would go here...
    while(true){
        if (K4A_FAILED(k4a_device_get_capture(device, &capture, K4A_WAIT_INFINITE)))
        {
            printf(""Failed to get capture\n"");
            break;
        }

        // Extract the color image from the captured frame
        //k4a_image_t colorImage = k4a_capture_get_color_image(capture);
        k4a_image_t depth_image = k4a_capture_get_depth_image(capture);

        cv::Mat depth_mat(k4a_image_get_height_pixels(depth_image), k4a_image_get_width_pixels(depth_image), CV_16UC1, (void*) k4a_image_get_buffer(depth_image));

        cv::Mat depth_mat_scaled;
        cv::convertScaleAbs(depth_mat, depth_mat_scaled, 255.0 /1000.0);
        cv::imshow(""Camera Stream"", depth_mat_scaled);
        cv::waitKey(1);

        // Convert the color image to OpenCV format
        //int width = k4a_image_get_width_pixels(colorImage);
        //int height = k4a_image_get_height_pixels(colorImage);
        //cv::Mat colorMat(height, width, CV_8UC4, k4a_image_get_buffer(colorImage), cv::Mat::AUTO_STEP);

        // Release the captured frame and color image




        // Display the color image in the window
         //cv::imshow(""Camera Stream"", colorMat);
         //cv::waitKey(1);
         k4a_image_release(depth_image);
         k4a_capture_release(capture);
    }

    // Shut down the camera when finished with application logic
    k4a_device_stop_cameras(device);

  /**
   * ros::spin() will enter a loop, pumping callbacks.  With this version, all
   * callbacks will be called from within this thread (the main one).  ros::spin()
   * will exit when Ctrl-C is pressed, or the node is shutdown by the master.
   */
// %Tag(SPIN)%
  ros::spin();
// %EndTag(SPIN)%
    k4a_device_close(device);
  return 0;
}
// %EndTag(FULLTEXT)%

",serial_size
886,"//===-- ARMBaseInstrInfo.cpp - ARM Instruction Information ----------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the Base ARM implementation of the TargetInstrInfo class.
//
//===----------------------------------------------------------------------===//

#include ""ARM.h""
#include ""ARMBaseInstrInfo.h""
#include ""ARMBaseRegisterInfo.h""
#include ""ARMConstantPoolValue.h""
#include ""ARMFeatures.h""
#include ""ARMHazardRecognizer.h""
#include ""ARMMachineFunctionInfo.h""
#include ""MCTargetDesc/ARMAddressingModes.h""
#include ""llvm/ADT/STLExtras.h""
#include ""llvm/CodeGen/LiveVariables.h""
#include ""llvm/CodeGen/MachineConstantPool.h""
#include ""llvm/CodeGen/MachineFrameInfo.h""
#include ""llvm/CodeGen/MachineInstrBuilder.h""
#include ""llvm/CodeGen/MachineJumpTableInfo.h""
#include ""llvm/CodeGen/MachineMemOperand.h""
#include ""llvm/CodeGen/MachineRegisterInfo.h""
#include ""llvm/CodeGen/SelectionDAGNodes.h""
#include ""llvm/CodeGen/TargetSchedule.h""
#include ""llvm/IR/Constants.h""
#include ""llvm/IR/Function.h""
#include ""llvm/IR/GlobalValue.h""
#include ""llvm/MC/MCAsmInfo.h""
#include ""llvm/MC/MCExpr.h""
#include ""llvm/Support/BranchProbability.h""
#include ""llvm/Support/CommandLine.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/Support/ErrorHandling.h""
#include ""llvm/Support/raw_ostream.h""

using namespace llvm;

#define DEBUG_TYPE ""arm-instrinfo""

#define GET_INSTRINFO_CTOR_DTOR
#include ""ARMGenInstrInfo.inc""

static cl::opt<bool>
EnableARM3Addr(""enable-arm-3-addr-conv"", cl::Hidden,
               cl::desc(""Enable ARM 2-addr to 3-addr conv""));

static cl::opt<bool>
WidenVMOVS(""widen-vmovs"", cl::Hidden, cl::init(true),
           cl::desc(""Widen ARM vmovs to vmovd when possible""));

static cl::opt<unsigned>
SwiftPartialUpdateClearance(""swift-partial-update-clearance"",
     cl::Hidden, cl::init(12),
     cl::desc(""Clearance before partial register updates""));

/// ARM_MLxEntry - Record information about MLA / MLS instructions.
struct ARM_MLxEntry {
  uint16_t MLxOpc;     // MLA / MLS opcode
  uint16_t MulOpc;     // Expanded multiplication opcode
  uint16_t AddSubOpc;  // Expanded add / sub opcode
  bool NegAcc;         // True if the acc is negated before the add / sub.
  bool HasLane;        // True if instruction has an extra ""lane"" operand.
};

static const ARM_MLxEntry ARM_MLxTable[] = {
  // MLxOpc,          MulOpc,           AddSubOpc,       NegAcc, HasLane
  // fp scalar ops
  { ARM::VMLAS,       ARM::VMULS,       ARM::VADDS,      false,  false },
  { ARM::VMLSS,       ARM::VMULS,       ARM::VSUBS,      false,  false },
  { ARM::VMLAD,       ARM::VMULD,       ARM::VADDD,      false,  false },
  { ARM::VMLSD,       ARM::VMULD,       ARM::VSUBD,      false,  false },
  { ARM::VNMLAS,      ARM::VNMULS,      ARM::VSUBS,      true,   false },
  { ARM::VNMLSS,      ARM::VMULS,       ARM::VSUBS,      true,   false },
  { ARM::VNMLAD,      ARM::VNMULD,      ARM::VSUBD,      true,   false },
  { ARM::VNMLSD,      ARM::VMULD,       ARM::VSUBD,      true,   false },

  // fp SIMD ops
  { ARM::VMLAfd,      ARM::VMULfd,      ARM::VADDfd,     false,  false },
  { ARM::VMLSfd,      ARM::VMULfd,      ARM::VSUBfd,     false,  false },
  { ARM::VMLAfq,      ARM::VMULfq,      ARM::VADDfq,     false,  false },
  { ARM::VMLSfq,      ARM::VMULfq,      ARM::VSUBfq,     false,  false },
  { ARM::VMLAslfd,    ARM::VMULslfd,    ARM::VADDfd,     false,  true  },
  { ARM::VMLSslfd,    ARM::VMULslfd,    ARM::VSUBfd,     false,  true  },
  { ARM::VMLAslfq,    ARM::VMULslfq,    ARM::VADDfq,     false,  true  },
  { ARM::VMLSslfq,    ARM::VMULslfq,    ARM::VSUBfq,     false,  true  },
};

ARMBaseInstrInfo::ARMBaseInstrInfo(const ARMSubtarget& STI)
  : ARMGenInstrInfo(ARM::ADJCALLSTACKDOWN, ARM::ADJCALLSTACKUP),
    Subtarget(STI) {
  for (unsigned i = 0, e = array_lengthof(ARM_MLxTable); i != e; ++i) {
    if (!MLxEntryMap.insert(std::make_pair(ARM_MLxTable[i].MLxOpc, i)).second)
      assert(false && ""Duplicated entries?"");
    MLxHazardOpcodes.insert(ARM_MLxTable[i].AddSubOpc);
    MLxHazardOpcodes.insert(ARM_MLxTable[i].MulOpc);
  }
}

// Use a ScoreboardHazardRecognizer for prepass ARM scheduling. TargetInstrImpl
// currently defaults to no prepass hazard recognizer.
ScheduleHazardRecognizer *
ARMBaseInstrInfo::CreateTargetHazardRecognizer(const TargetSubtargetInfo *STI,
                                               const ScheduleDAG *DAG) const {
  if (usePreRAHazardRecognizer()) {
    const InstrItineraryData *II =
        static_cast<const ARMSubtarget *>(STI)->getInstrItineraryData();
    return new ScoreboardHazardRecognizer(II, DAG, ""pre-RA-sched"");
  }
  return TargetInstrInfo::CreateTargetHazardRecognizer(STI, DAG);
}

ScheduleHazardRecognizer *ARMBaseInstrInfo::
CreateTargetPostRAHazardRecognizer(const InstrItineraryData *II,
                                   const ScheduleDAG *DAG) const {
  if (Subtarget.isThumb2() || Subtarget.hasVFP2())
    return (ScheduleHazardRecognizer *)new ARMHazardRecognizer(II, DAG);
  return TargetInstrInfo::CreateTargetPostRAHazardRecognizer(II, DAG);
}

MachineInstr *
ARMBaseInstrInfo::convertToThreeAddress(MachineFunction::iterator &MFI,
                                        MachineBasicBlock::iterator &MBBI,
                                        LiveVariables *LV) const {
  // FIXME: Thumb2 support.

  if (!EnableARM3Addr)
    return nullptr;

  MachineInstr *MI = MBBI;
  MachineFunction &MF = *MI->getParent()->getParent();
  uint64_t TSFlags = MI->getDesc().TSFlags;
  bool isPre = false;
  switch ((TSFlags & ARMII::IndexModeMask) >> ARMII::IndexModeShift) {
  default: return nullptr;
  case ARMII::IndexModePre:
    isPre = true;
    break;
  case ARMII::IndexModePost:
    break;
  }

  // Try splitting an indexed load/store to an un-indexed one plus an add/sub
  // operation.
  unsigned MemOpc = getUnindexedOpcode(MI->getOpcode());
  if (MemOpc == 0)
    return nullptr;

  MachineInstr *UpdateMI = nullptr;
  MachineInstr *MemMI = nullptr;
  unsigned AddrMode = (TSFlags & ARMII::AddrModeMask);
  const MCInstrDesc &MCID = MI->getDesc();
  unsigned NumOps = MCID.getNumOperands();
  bool isLoad = !MI->mayStore();
  const MachineOperand &WB = isLoad ? MI->getOperand(1) : MI->getOperand(0);
  const MachineOperand &Base = MI->getOperand(2);
  const MachineOperand &Offset = MI->getOperand(NumOps-3);
  unsigned WBReg = WB.getReg();
  unsigned BaseReg = Base.getReg();
  unsigned OffReg = Offset.getReg();
  unsigned OffImm = MI->getOperand(NumOps-2).getImm();
  ARMCC::CondCodes Pred = (ARMCC::CondCodes)MI->getOperand(NumOps-1).getImm();
  switch (AddrMode) {
  default: llvm_unreachable(""Unknown indexed op!"");
  case ARMII::AddrMode2: {
    bool isSub = ARM_AM::getAM2Op(OffImm) == ARM_AM::sub;
    unsigned Amt = ARM_AM::getAM2Offset(OffImm);
    if (OffReg == 0) {
      if (ARM_AM::getSOImmVal(Amt) == -1)
        // Can't encode it in a so_imm operand. This transformation will
        // add more than 1 instruction. Abandon!
        return nullptr;
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBri : ARM::ADDri), WBReg)
        .addReg(BaseReg).addImm(Amt)
        .addImm(Pred).addReg(0).addReg(0);
    } else if (Amt != 0) {
      ARM_AM::ShiftOpc ShOpc = ARM_AM::getAM2ShiftOpc(OffImm);
      unsigned SOOpc = ARM_AM::getSORegOpc(ShOpc, Amt);
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrsi : ARM::ADDrsi), WBReg)
        .addReg(BaseReg).addReg(OffReg).addReg(0).addImm(SOOpc)
        .addImm(Pred).addReg(0).addReg(0);
    } else
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrr : ARM::ADDrr), WBReg)
        .addReg(BaseReg).addReg(OffReg)
        .addImm(Pred).addReg(0).addReg(0);
    break;
  }
  case ARMII::AddrMode3 : {
    bool isSub = ARM_AM::getAM3Op(OffImm) == ARM_AM::sub;
    unsigned Amt = ARM_AM::getAM3Offset(OffImm);
    if (OffReg == 0)
      // Immediate is 8-bits. It's guaranteed to fit in a so_imm operand.
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBri : ARM::ADDri), WBReg)
        .addReg(BaseReg).addImm(Amt)
        .addImm(Pred).addReg(0).addReg(0);
    else
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrr : ARM::ADDrr), WBReg)
        .addReg(BaseReg).addReg(OffReg)
        .addImm(Pred).addReg(0).addReg(0);
    break;
  }
  }

  std::vector<MachineInstr*> NewMIs;
  if (isPre) {
    if (isLoad)
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc), MI->getOperand(0).getReg())
        .addReg(WBReg).addImm(0).addImm(Pred);
    else
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc)).addReg(MI->getOperand(1).getReg())
        .addReg(WBReg).addReg(0).addImm(0).addImm(Pred);
    NewMIs.push_back(MemMI);
    NewMIs.push_back(UpdateMI);
  } else {
    if (isLoad)
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc), MI->getOperand(0).getReg())
        .addReg(BaseReg).addImm(0).addImm(Pred);
    else
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc)).addReg(MI->getOperand(1).getReg())
        .addReg(BaseReg).addReg(0).addImm(0).addImm(Pred);
    if (WB.isDead())
      UpdateMI->getOperand(0).setIsDead();
    NewMIs.push_back(UpdateMI);
    NewMIs.push_back(MemMI);
  }

  // Transfer LiveVariables states, kill / dead info.
  if (LV) {
    for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
      MachineOperand &MO = MI->getOperand(i);
      if (MO.isReg() && TargetRegisterInfo::isVirtualRegister(MO.getReg())) {
        unsigned Reg = MO.getReg();

        LiveVariables::VarInfo &VI = LV->getVarInfo(Reg);
        if (MO.isDef()) {
          MachineInstr *NewMI = (Reg == WBReg) ? UpdateMI : MemMI;
          if (MO.isDead())
            LV->addVirtualRegisterDead(Reg, NewMI);
        }
        if (MO.isUse() && MO.isKill()) {
          for (unsigned j = 0; j < 2; ++j) {
            // Look at the two new MI's in reverse order.
            MachineInstr *NewMI = NewMIs[j];
            if (!NewMI->readsRegister(Reg))
              continue;
            LV->addVirtualRegisterKilled(Reg, NewMI);
            if (VI.removeKill(MI))
              VI.Kills.push_back(NewMI);
            break;
          }
        }
      }
    }
  }

  MFI->insert(MBBI, NewMIs[1]);
  MFI->insert(MBBI, NewMIs[0]);
  return NewMIs[0];
}

// Branch analysis.
bool
ARMBaseInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
                                MachineBasicBlock *&FBB,
                                SmallVectorImpl<MachineOperand> &Cond,
                                bool AllowModify) const {
  TBB = nullptr;
  FBB = nullptr;

  MachineBasicBlock::iterator I = MBB.end();
  if (I == MBB.begin())
    return false; // Empty blocks are easy.
  --I;

  // Walk backwards from the end of the basic block until the branch is
  // analyzed or we give up.
  while (isPredicated(I) || I->isTerminator() || I->isDebugValue()) {

    // Flag to be raised on unanalyzeable instructions. This is useful in cases
    // where we want to clean up on the end of the basic block before we bail
    // out.
    bool CantAnalyze = false;

    // Skip over DEBUG values and predicated nonterminators.
    while (I->isDebugValue() || !I->isTerminator()) {
      if (I == MBB.begin())
        return false;
      --I;
    }

    if (isIndirectBranchOpcode(I->getOpcode()) ||
        isJumpTableBranchOpcode(I->getOpcode())) {
      // Indirect branches and jump tables can't be analyzed, but we still want
      // to clean up any instructions at the tail of the basic block.
      CantAnalyze = true;
    } else if (isUncondBranchOpcode(I->getOpcode())) {
      TBB = I->getOperand(0).getMBB();
    } else if (isCondBranchOpcode(I->getOpcode())) {
      // Bail out if we encounter multiple conditional branches.
      if (!Cond.empty())
        return true;

      assert(!FBB && ""FBB should have been null."");
      FBB = TBB;
      TBB = I->getOperand(0).getMBB();
      Cond.push_back(I->getOperand(1));
      Cond.push_back(I->getOperand(2));
    } else if (I->isReturn()) {
      // Returns can't be analyzed, but we should run cleanup.
      CantAnalyze = !isPredicated(I);
    } else {
      // We encountered other unrecognized terminator. Bail out immediately.
      return true;
    }

    // Cleanup code - to be run for unpredicated unconditional branches and
    //                returns.
    if (!isPredicated(I) &&
          (isUncondBranchOpcode(I->getOpcode()) ||
           isIndirectBranchOpcode(I->getOpcode()) ||
           isJumpTableBranchOpcode(I->getOpcode()) ||
           I->isReturn())) {
      // Forget any previous condition branch information - it no longer applies.
      Cond.clear();
      FBB = nullptr;

      // If we can modify the function, delete everything below this
      // unconditional branch.
      if (AllowModify) {
        MachineBasicBlock::iterator DI = std::next(I);
        while (DI != MBB.end()) {
          MachineInstr *InstToDelete = DI;
          ++DI;
          InstToDelete->eraseFromParent();
        }
      }
    }

    if (CantAnalyze)
      return true;

    if (I == MBB.begin())
      return false;

    --I;
  }

  // We made it past the terminators without bailing out - we must have
  // analyzed this branch successfully.
  return false;
}


unsigned ARMBaseInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
  MachineBasicBlock::iterator I = MBB.end();
  if (I == MBB.begin()) return 0;
  --I;
  while (I->isDebugValue()) {
    if (I == MBB.begin())
      return 0;
    --I;
  }
  if (!isUncondBranchOpcode(I->getOpcode()) &&
      !isCondBranchOpcode(I->getOpcode()))
    return 0;

  // Remove the branch.
  I->eraseFromParent();

  I = MBB.end();

  if (I == MBB.begin()) return 1;
  --I;
  if (!isCondBranchOpcode(I->getOpcode()))
    return 1;

  // Remove the branch.
  I->eraseFromParent();
  return 2;
}

unsigned
ARMBaseInstrInfo::InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
                               MachineBasicBlock *FBB,
                               ArrayRef<MachineOperand> Cond,
                               DebugLoc DL) const {
  ARMFunctionInfo *AFI = MBB.getParent()->getInfo<ARMFunctionInfo>();
  int BOpc   = !AFI->isThumbFunction()
    ? ARM::B : (AFI->isThumb2Function() ? ARM::t2B : ARM::tB);
  int BccOpc = !AFI->isThumbFunction()
    ? ARM::Bcc : (AFI->isThumb2Function() ? ARM::t2Bcc : ARM::tBcc);
  bool isThumb = AFI->isThumbFunction() || AFI->isThumb2Function();

  // Shouldn't be a fall through.
  assert(TBB && ""InsertBranch must not be told to insert a fallthrough"");
  assert((Cond.size() == 2 || Cond.size() == 0) &&
         ""ARM branch conditions have two components!"");

  // For conditional branches, we use addOperand to preserve CPSR flags.

  if (!FBB) {
    if (Cond.empty()) { // Unconditional branch?
      if (isThumb)
        BuildMI(&MBB, DL, get(BOpc)).addMBB(TBB).addImm(ARMCC::AL).addReg(0);
      else
        BuildMI(&MBB, DL, get(BOpc)).addMBB(TBB);
    } else
      BuildMI(&MBB, DL, get(BccOpc)).addMBB(TBB)
        .addImm(Cond[0].getImm()).addOperand(Cond[1]);
    return 1;
  }

  // Two-way conditional branch.
  BuildMI(&MBB, DL, get(BccOpc)).addMBB(TBB)
    .addImm(Cond[0].getImm()).addOperand(Cond[1]);
  if (isThumb)
    BuildMI(&MBB, DL, get(BOpc)).addMBB(FBB).addImm(ARMCC::AL).addReg(0);
  else
    BuildMI(&MBB, DL, get(BOpc)).addMBB(FBB);
  return 2;
}

bool ARMBaseInstrInfo::
ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
  ARMCC::CondCodes CC = (ARMCC::CondCodes)(int)Cond[0].getImm();
  Cond[0].setImm(ARMCC::getOppositeCondition(CC));
  return false;
}

bool ARMBaseInstrInfo::isPredicated(const MachineInstr *MI) const {
  if (MI->isBundle()) {
    MachineBasicBlock::const_instr_iterator I = MI;
    MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
    while (++I != E && I->isInsideBundle()) {
      int PIdx = I->findFirstPredOperandIdx();
      if (PIdx != -1 && I->getOperand(PIdx).getImm() != ARMCC::AL)
        return true;
    }
    return false;
  }

  int PIdx = MI->findFirstPredOperandIdx();
  return PIdx != -1 && MI->getOperand(PIdx).getImm() != ARMCC::AL;
}

bool ARMBaseInstrInfo::
PredicateInstruction(MachineInstr *MI, ArrayRef<MachineOperand> Pred) const {
  unsigned Opc = MI->getOpcode();
  if (isUncondBranchOpcode(Opc)) {
    MI->setDesc(get(getMatchingCondBranchOpcode(Opc)));
    MachineInstrBuilder(*MI->getParent()->getParent(), MI)
      .addImm(Pred[0].getImm())
      .addReg(Pred[1].getReg());
    return true;
  }

  int PIdx = MI->findFirstPredOperandIdx();
  if (PIdx != -1) {
    MachineOperand &PMO = MI->getOperand(PIdx);
    PMO.setImm(Pred[0].getImm());
    MI->getOperand(PIdx+1).setReg(Pred[1].getReg());
    return true;
  }
  return false;
}

bool ARMBaseInstrInfo::SubsumesPredicate(ArrayRef<MachineOperand> Pred1,
                                         ArrayRef<MachineOperand> Pred2) const {
  if (Pred1.size() > 2 || Pred2.size() > 2)
    return false;

  ARMCC::CondCodes CC1 = (ARMCC::CondCodes)Pred1[0].getImm();
  ARMCC::CondCodes CC2 = (ARMCC::CondCodes)Pred2[0].getImm();
  if (CC1 == CC2)
    return true;

  switch (CC1) {
  default:
    return false;
  case ARMCC::AL:
    return true;
  case ARMCC::HS:
    return CC2 == ARMCC::HI;
  case ARMCC::LS:
    return CC2 == ARMCC::LO || CC2 == ARMCC::EQ;
  case ARMCC::GE:
    return CC2 == ARMCC::GT;
  case ARMCC::LE:
    return CC2 == ARMCC::LT;
  }
}

bool ARMBaseInstrInfo::DefinesPredicate(MachineInstr *MI,
                                    std::vector<MachineOperand> &Pred) const {
  bool Found = false;
  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    if ((MO.isRegMask() && MO.clobbersPhysReg(ARM::CPSR)) ||
        (MO.isReg() && MO.isDef() && MO.getReg() == ARM::CPSR)) {
      Pred.push_back(MO);
      Found = true;
    }
  }

  return Found;
}

static bool isCPSRDefined(const MachineInstr *MI) {
  for (const auto &MO : MI->operands())
    if (MO.isReg() && MO.getReg() == ARM::CPSR && MO.isDef())
      return true;
  return false;
}

static bool isEligibleForITBlock(const MachineInstr *MI) {
  switch (MI->getOpcode()) {
  default: return true;
  case ARM::tADC:   // ADC (register) T1
  case ARM::tADDi3: // ADD (immediate) T1
  case ARM::tADDi8: // ADD (immediate) T2
  case ARM::tADDrr: // ADD (register) T1
  case ARM::tAND:   // AND (register) T1
  case ARM::tASRri: // ASR (immediate) T1
  case ARM::tASRrr: // ASR (register) T1
  case ARM::tBIC:   // BIC (register) T1
  case ARM::tEOR:   // EOR (register) T1
  case ARM::tLSLri: // LSL (immediate) T1
  case ARM::tLSLrr: // LSL (register) T1
  case ARM::tLSRri: // LSR (immediate) T1
  case ARM::tLSRrr: // LSR (register) T1
  case ARM::tMUL:   // MUL T1
  case ARM::tMVN:   // MVN (register) T1
  case ARM::tORR:   // ORR (register) T1
  case ARM::tROR:   // ROR (register) T1
  case ARM::tRSB:   // RSB (immediate) T1
  case ARM::tSBC:   // SBC (register) T1
  case ARM::tSUBi3: // SUB (immediate) T1
  case ARM::tSUBi8: // SUB (immediate) T2
  case ARM::tSUBrr: // SUB (register) T1
    return !isCPSRDefined(MI);
  }
}

/// isPredicable - Return true if the specified instruction can be predicated.
/// By default, this returns true for every instruction with a
/// PredicateOperand.
bool ARMBaseInstrInfo::isPredicable(MachineInstr *MI) const {
  if (!MI->isPredicable())
    return false;

  if (!isEligibleForITBlock(MI))
    return false;

  ARMFunctionInfo *AFI =
    MI->getParent()->getParent()->getInfo<ARMFunctionInfo>();

  if (AFI->isThumb2Function()) {
    if (getSubtarget().restrictIT())
      return isV8EligibleForIT(MI);
  } else { // non-Thumb
    if ((MI->getDesc().TSFlags & ARMII::DomainMask) == ARMII::DomainNEON)
      return false;
  }

  return true;
}

namespace llvm {
template <> bool IsCPSRDead<MachineInstr>(MachineInstr *MI) {
  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    if (!MO.isReg() || MO.isUndef() || MO.isUse())
      continue;
    if (MO.getReg() != ARM::CPSR)
      continue;
    if (!MO.isDead())
      return false;
  }
  // all definitions of CPSR are dead
  return true;
}
}

/// GetInstSize - Return the size of the specified MachineInstr.
///
unsigned ARMBaseInstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
  const MachineBasicBlock &MBB = *MI->getParent();
  const MachineFunction *MF = MBB.getParent();
  const MCAsmInfo *MAI = MF->getTarget().getMCAsmInfo();

  const MCInstrDesc &MCID = MI->getDesc();
  if (MCID.getSize())
    return MCID.getSize();

  // If this machine instr is an inline asm, measure it.
  if (MI->getOpcode() == ARM::INLINEASM)
    return getInlineAsmLength(MI->getOperand(0).getSymbolName(), *MAI);
  unsigned Opc = MI->getOpcode();
  switch (Opc) {
  default:
    // pseudo-instruction sizes are zero.
    return 0;
  case TargetOpcode::BUNDLE:
    return getInstBundleLength(MI);
  case ARM::MOVi16_ga_pcrel:
  case ARM::MOVTi16_ga_pcrel:
  case ARM::t2MOVi16_ga_pcrel:
  case ARM::t2MOVTi16_ga_pcrel:
    return 4;
  case ARM::MOVi32imm:
  case ARM::t2MOVi32imm:
    return 8;
  case ARM::CONSTPOOL_ENTRY:
  case ARM::JUMPTABLE_INSTS:
  case ARM::JUMPTABLE_ADDRS:
  case ARM::JUMPTABLE_TBB:
  case ARM::JUMPTABLE_TBH:
    // If this machine instr is a constant pool entry, its size is recorded as
    // operand #2.
    return MI->getOperand(2).getImm();
  case ARM::Int_eh_sjlj_longjmp:
    return 16;
  case ARM::tInt_eh_sjlj_longjmp:
    return 10;
  case ARM::Int_eh_sjlj_setjmp:
  case ARM::Int_eh_sjlj_setjmp_nofp:
    return 20;
  case ARM::tInt_eh_sjlj_setjmp:
  case ARM::t2Int_eh_sjlj_setjmp:
  case ARM::t2Int_eh_sjlj_setjmp_nofp:
    return 12;
  case ARM::SPACE:
    return MI->getOperand(1).getImm();
  }
}

unsigned ARMBaseInstrInfo::getInstBundleLength(const MachineInstr *MI) const {
  unsigned Size = 0;
  MachineBasicBlock::const_instr_iterator I = MI;
  MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
  while (++I != E && I->isInsideBundle()) {
    assert(!I->isBundle() && ""No nested bundle!"");
    Size += GetInstSizeInBytes(&*I);
  }
  return Size;
}

void ARMBaseInstrInfo::copyFromCPSR(MachineBasicBlock &MBB,
                                    MachineBasicBlock::iterator I,
                                    unsigned DestReg, bool KillSrc,
                                    const ARMSubtarget &Subtarget) const {
  unsigned Opc = Subtarget.isThumb()
                     ? (Subtarget.isMClass() ? ARM::t2MRS_M : ARM::t2MRS_AR)
                     : ARM::MRS;

  MachineInstrBuilder MIB =
      BuildMI(MBB, I, I->getDebugLoc(), get(Opc), DestReg);

  // There is only 1 A/R class MRS instruction, and it always refers to
  // APSR. However, there are lots of other possibilities on M-class cores.
  if (Subtarget.isMClass())
    MIB.addImm(0x800);

  AddDefaultPred(MIB);

  MIB.addReg(ARM::CPSR, RegState::Implicit | getKillRegState(KillSrc));
}

void ARMBaseInstrInfo::copyToCPSR(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator I,
                                  unsigned SrcReg, bool KillSrc,
                                  const ARMSubtarget &Subtarget) const {
  unsigned Opc = Subtarget.isThumb()
                     ? (Subtarget.isMClass() ? ARM::t2MSR_M : ARM::t2MSR_AR)
                     : ARM::MSR;

  MachineInstrBuilder MIB = BuildMI(MBB, I, I->getDebugLoc(), get(Opc));

  if (Subtarget.isMClass())
    MIB.addImm(0x800);
  else
    MIB.addImm(8);

  MIB.addReg(SrcReg, getKillRegState(KillSrc));

  AddDefaultPred(MIB);

  MIB.addReg(ARM::CPSR, RegState::Implicit | RegState::Define);
}

void ARMBaseInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator I, DebugLoc DL,
                                   unsigned DestReg, unsigned SrcReg,
                                   bool KillSrc) const {
  bool GPRDest = ARM::GPRRegClass.contains(DestReg);
  bool GPRSrc = ARM::GPRRegClass.contains(SrcReg);

  if (GPRDest && GPRSrc) {
    AddDefaultCC(AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::MOVr), DestReg)
                                    .addReg(SrcReg, getKillRegState(KillSrc))));
    return;
  }

  bool SPRDest = ARM::SPRRegClass.contains(DestReg);
  bool SPRSrc = ARM::SPRRegClass.contains(SrcReg);

  unsigned Opc = 0;
  if (SPRDest && SPRSrc)
    Opc = ARM::VMOVS;
  else if (GPRDest && SPRSrc)
    Opc = ARM::VMOVRS;
  else if (SPRDest && GPRSrc)
    Opc = ARM::VMOVSR;
  else if (ARM::DPRRegClass.contains(DestReg, SrcReg) && !Subtarget.isFPOnlySP())
    Opc = ARM::VMOVD;
  else if (ARM::QPRRegClass.contains(DestReg, SrcReg))
    Opc = ARM::VORRq;

  if (Opc) {
    MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(Opc), DestReg);
    MIB.addReg(SrcReg, getKillRegState(KillSrc));
    if (Opc == ARM::VORRq)
      MIB.addReg(SrcReg, getKillRegState(KillSrc));
    AddDefaultPred(MIB);
    return;
  }

  // Handle register classes that require multiple instructions.
  unsigned BeginIdx = 0;
  unsigned SubRegs = 0;
  int Spacing = 1;

  // Use VORRq when possible.
  if (ARM::QQPRRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VORRq;
    BeginIdx = ARM::qsub_0;
    SubRegs = 2;
  } else if (ARM::QQQQPRRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VORRq;
    BeginIdx = ARM::qsub_0;
    SubRegs = 4;
  // Fall back to VMOVD.
  } else if (ARM::DPairRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 2;
  } else if (ARM::DTripleRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 3;
  } else if (ARM::DQuadRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 4;
  } else if (ARM::GPRPairRegClass.contains(DestReg, SrcReg)) {
    Opc = Subtarget.isThumb2() ? ARM::tMOVr : ARM::MOVr;
    BeginIdx = ARM::gsub_0;
    SubRegs = 2;
  } else if (ARM::DPairSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 2;
    Spacing = 2;
  } else if (ARM::DTripleSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 3;
    Spacing = 2;
  } else if (ARM::DQuadSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 4;
    Spacing = 2;
  } else if (ARM::DPRRegClass.contains(DestReg, SrcReg) && Subtarget.isFPOnlySP()) {
    Opc = ARM::VMOVS;
    BeginIdx = ARM::ssub_0;
    SubRegs = 2;
  } else if (SrcReg == ARM::CPSR) {
    copyFromCPSR(MBB, I, DestReg, KillSrc, Subtarget);
    return;
  } else if (DestReg == ARM::CPSR) {
    copyToCPSR(MBB, I, SrcReg, KillSrc, Subtarget);
    return;
  }

  assert(Opc && ""Impossible reg-to-reg copy"");

  const TargetRegisterInfo *TRI = &getRegisterInfo();
  MachineInstrBuilder Mov;

  // Copy register tuples backward when the first Dest reg overlaps with SrcReg.
  if (TRI->regsOverlap(SrcReg, TRI->getSubReg(DestReg, BeginIdx))) {
    BeginIdx = BeginIdx + ((SubRegs - 1) * Spacing);
    Spacing = -Spacing;
  }
#ifndef NDEBUG
  SmallSet<unsigned, 4> DstRegs;
#endif
  for (unsigned i = 0; i != SubRegs; ++i) {
    unsigned Dst = TRI->getSubReg(DestReg, BeginIdx + i * Spacing);
    unsigned Src = TRI->getSubReg(SrcReg, BeginIdx + i * Spacing);
    assert(Dst && Src && ""Bad sub-register"");
#ifndef NDEBUG
    assert(!DstRegs.count(Src) && ""destructive vector copy"");
    DstRegs.insert(Dst);
#endif
    Mov = BuildMI(MBB, I, I->getDebugLoc(), get(Opc), Dst).addReg(Src);
    // VORR takes two source operands.
    if (Opc == ARM::VORRq)
      Mov.addReg(Src);
    Mov = AddDefaultPred(Mov);
    // MOVr can set CC.
    if (Opc == ARM::MOVr)
      Mov = AddDefaultCC(Mov);
  }
  // Add implicit super-register defs and kills to the last instruction.
  Mov->addRegisterDefined(DestReg, TRI);
  if (KillSrc)
    Mov->addRegisterKilled(SrcReg, TRI);
}

const MachineInstrBuilder &
ARMBaseInstrInfo::AddDReg(MachineInstrBuilder &MIB, unsigned Reg,
                          unsigned SubIdx, unsigned State,
                          const TargetRegisterInfo *TRI) const {
  if (!SubIdx)
    return MIB.addReg(Reg, State);

  if (TargetRegisterInfo::isPhysicalRegister(Reg))
    return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
  return MIB.addReg(Reg, State, SubIdx);
}

void ARMBaseInstrInfo::
storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                    unsigned SrcReg, bool isKill, int FI,
                    const TargetRegisterClass *RC,
                    const TargetRegisterInfo *TRI) const {
  DebugLoc DL;
  if (I != MBB.end()) DL = I->getDebugLoc();
  MachineFunction &MF = *MBB.getParent();
  MachineFrameInfo &MFI = *MF.getFrameInfo();
  unsigned Align = MFI.getObjectAlignment(FI);

  MachineMemOperand *MMO =
    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(FI),
                            MachineMemOperand::MOStore,
                            MFI.getObjectSize(FI),
                            Align);

  switch (RC->getSize()) {
    case 4:
      if (ARM::GPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::STRi12))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else if (ARM::SPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTRS))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 8:
      if (ARM::DPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTRD))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else if (ARM::GPRPairRegClass.hasSubClassEq(RC)) {
        if (Subtarget.hasV5TEOps()) {
          MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(ARM::STRD));
          AddDReg(MIB, SrcReg, ARM::gsub_0, getKillRegState(isKill), TRI);
          AddDReg(MIB, SrcReg, ARM::gsub_1, 0, TRI);
          MIB.addFrameIndex(FI).addReg(0).addImm(0).addMemOperand(MMO);

          AddDefaultPred(MIB);
        } else {
          // Fallback to STM instruction, which has existed since the dawn of
          // time.
          MachineInstrBuilder MIB =
            AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::STMIA))
                             .addFrameIndex(FI).addMemOperand(MMO));
          AddDReg(MIB, SrcReg, ARM::gsub_0, getKillRegState(isKill), TRI);
          AddDReg(MIB, SrcReg, ARM::gsub_1, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 16:
      if (ARM::DPairRegClass.hasSubClassEq(RC)) {
        // Use aligned spills if the stack can be realigned.
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1q64))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMQIA))
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addFrameIndex(FI)
                     .addMemOperand(MMO));
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 24:
      if (ARM::DTripleRegClass.hasSubClassEq(RC)) {
        // Use aligned spills if the stack can be realigned.
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1d64TPseudo))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
          AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 32:
      if (ARM::QQPRRegClass.hasSubClassEq(RC) || ARM::DQuadRegClass.hasSubClassEq(RC)) {
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          // FIXME: It's possible to only store part of the QQ register if the
          // spilled def has a sub-register index.
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1d64QPseudo))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
                AddDReg(MIB, SrcReg, ARM::dsub_3, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 64:
      if (ARM::QQQQPRRegClass.hasSubClassEq(RC)) {
        MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                         .addFrameIndex(FI))
                         .addMemOperand(MMO);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_3, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_4, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_5, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_6, 0, TRI);
              AddDReg(MIB, SrcReg, ARM::dsub_7, 0, TRI);
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    default:
      llvm_unreachable(""Unknown reg class!"");
  }
}

unsigned
ARMBaseInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
                                     int &FrameIndex) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::STRrs:
  case ARM::t2STRs: // FIXME: don't use t2STRs to access frame.
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isReg() &&
        MI->getOperand(3).isImm() &&
        MI->getOperand(2).getReg() == 0 &&
        MI->getOperand(3).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::STRi12:
  case ARM::t2STRi12:
  case ARM::tSTRspi:
  case ARM::VSTRD:
  case ARM::VSTRS:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isImm() &&
        MI->getOperand(2).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VST1q64:
  case ARM::VST1d64TPseudo:
  case ARM::VST1d64QPseudo:
    if (MI->getOperand(0).isFI() &&
        MI->getOperand(2).getSubReg() == 0) {
      FrameIndex = MI->getOperand(0).getIndex();
      return MI->getOperand(2).getReg();
    }
    break;
  case ARM::VSTMQIA:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  }

  return 0;
}

unsigned ARMBaseInstrInfo::isStoreToStackSlotPostFE(const MachineInstr *MI,
                                                    int &FrameIndex) const {
  const MachineMemOperand *Dummy;
  return MI->mayStore() && hasStoreToStackSlot(MI, Dummy, FrameIndex);
}

void ARMBaseInstrInfo::
loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                     unsigned DestReg, int FI,
                     const TargetRegisterClass *RC,
                     const TargetRegisterInfo *TRI) const {
  DebugLoc DL;
  if (I != MBB.end()) DL = I->getDebugLoc();
  MachineFunction &MF = *MBB.getParent();
  MachineFrameInfo &MFI = *MF.getFrameInfo();
  unsigned Align = MFI.getObjectAlignment(FI);
  MachineMemOperand *MMO =
    MF.getMachineMemOperand(
                    MachinePointerInfo::getFixedStack(FI),
                            MachineMemOperand::MOLoad,
                            MFI.getObjectSize(FI),
                            Align);

  switch (RC->getSize()) {
  case 4:
    if (ARM::GPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::LDRi12), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));

    } else if (ARM::SPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDRS), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 8:
    if (ARM::DPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDRD), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
    } else if (ARM::GPRPairRegClass.hasSubClassEq(RC)) {
      MachineInstrBuilder MIB;

      if (Subtarget.hasV5TEOps()) {
        MIB = BuildMI(MBB, I, DL, get(ARM::LDRD));
        AddDReg(MIB, DestReg, ARM::gsub_0, RegState::DefineNoRead, TRI);
        AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
        MIB.addFrameIndex(FI).addReg(0).addImm(0).addMemOperand(MMO);

        AddDefaultPred(MIB);
      } else {
        // Fallback to LDM instruction, which has existed since the dawn of
        // time.
        MIB = AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::LDMIA))
                                 .addFrameIndex(FI).addMemOperand(MMO));
        MIB = AddDReg(MIB, DestReg, ARM::gsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
      }

      if (TargetRegisterInfo::isPhysicalRegister(DestReg))
        MIB.addReg(DestReg, RegState::ImplicitDefine);
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 16:
    if (ARM::DPairRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1q64), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMQIA), DestReg)
                       .addFrameIndex(FI)
                       .addMemOperand(MMO));
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 24:
    if (ARM::DTripleRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1d64TPseudo), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                         .addFrameIndex(FI)
                         .addMemOperand(MMO));
        MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
        if (TargetRegisterInfo::isPhysicalRegister(DestReg))
          MIB.addReg(DestReg, RegState::ImplicitDefine);
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
   case 32:
    if (ARM::QQPRRegClass.hasSubClassEq(RC) || ARM::DQuadRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1d64QPseudo), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        MachineInstrBuilder MIB =
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_3, RegState::DefineNoRead, TRI);
        if (TargetRegisterInfo::isPhysicalRegister(DestReg))
          MIB.addReg(DestReg, RegState::ImplicitDefine);
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 64:
    if (ARM::QQQQPRRegClass.hasSubClassEq(RC)) {
      MachineInstrBuilder MIB =
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                     .addFrameIndex(FI))
                     .addMemOperand(MMO);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_3, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_4, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_5, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_6, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_7, RegState::DefineNoRead, TRI);
      if (TargetRegisterInfo::isPhysicalRegister(DestReg))
        MIB.addReg(DestReg, RegState::ImplicitDefine);
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  default:
    llvm_unreachable(""Unknown regclass!"");
  }
}

unsigned
ARMBaseInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
                                      int &FrameIndex) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::LDRrs:
  case ARM::t2LDRs:  // FIXME: don't use t2LDRs to access frame.
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isReg() &&
        MI->getOperand(3).isImm() &&
        MI->getOperand(2).getReg() == 0 &&
        MI->getOperand(3).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::LDRi12:
  case ARM::t2LDRi12:
  case ARM::tLDRspi:
  case ARM::VLDRD:
  case ARM::VLDRS:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isImm() &&
        MI->getOperand(2).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VLD1q64:
  case ARM::VLD1d64TPseudo:
  case ARM::VLD1d64QPseudo:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VLDMQIA:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  }

  return 0;
}

unsigned ARMBaseInstrInfo::isLoadFromStackSlotPostFE(const MachineInstr *MI,
                                             int &FrameIndex) const {
  const MachineMemOperand *Dummy;
  return MI->mayLoad() && hasLoadFromStackSlot(MI, Dummy, FrameIndex);
}

bool
ARMBaseInstrInfo::expandPostRAPseudo(MachineBasicBlock::iterator MI) const {
  MachineFunction &MF = *MI->getParent()->getParent();
  Reloc::Model RM = MF.getTarget().getRelocationModel();

  if (MI->getOpcode() == TargetOpcode::LOAD_STACK_GUARD) {
    assert(getSubtarget().getTargetTriple().getObjectFormat() ==
           Triple::MachO &&
           ""LOAD_STACK_GUARD currently supported only for MachO."");
    expandLoadStackGuard(MI, RM);
    MI->getParent()->erase(MI);
    return true;
  }

  // This hook gets to expand COPY instructions before they become
  // copyPhysReg() calls.  Look for VMOVS instructions that can legally be
  // widened to VMOVD.  We prefer the VMOVD when possible because it may be
  // changed into a VORR that can go down the NEON pipeline.
  if (!WidenVMOVS || !MI->isCopy() || Subtarget.isCortexA15() ||
      Subtarget.isFPOnlySP())
    return false;

  // Look for a copy between even S-registers.  That is where we keep floats
  // when using NEON v2f32 instructions for f32 arithmetic.
  unsigned  [MASK]  = MI->getOperand(0).getReg();
  unsigned SrcRegS = MI->getOperand(1).getReg();
  if (!ARM::SPRRegClass.contains( [MASK] , SrcRegS))
    return false;

  const TargetRegisterInfo *TRI = &getRegisterInfo();
  unsigned DstRegD = TRI->getMatchingSuperReg( [MASK] , ARM::ssub_0,
                                              &ARM::DPRRegClass);
  unsigned SrcRegD = TRI->getMatchingSuperReg(SrcRegS, ARM::ssub_0,
                                              &ARM::DPRRegClass);
  if (!DstRegD || !SrcRegD)
    return false;

  // We want to widen this into a DstRegD = VMOVD SrcRegD copy.  This is only
  // legal if the COPY already defines the full DstRegD, and it isn't a
  // sub-register insertion.
  if (!MI->definesRegister(DstRegD, TRI) || MI->readsRegister(DstRegD, TRI))
    return false;

  // A dead copy shouldn't show up here, but reject it just in case.
  if (MI->getOperand(0).isDead())
    return false;

  // All clear, widen the COPY.
  DEBUG(dbgs() << ""widening:    "" << *MI);
  MachineInstrBuilder MIB(*MI->getParent()->getParent(), MI);

  // Get rid of the old <imp-def> of DstRegD.  Leave it if it defines a Q-reg
  // or some other super-register.
  int ImpDefIdx = MI->findRegisterDefOperandIdx(DstRegD);
  if (ImpDefIdx != -1)
    MI->RemoveOperand(ImpDefIdx);

  // Change the opcode and operands.
  MI->setDesc(get(ARM::VMOVD));
  MI->getOperand(0).setReg(DstRegD);
  MI->getOperand(1).setReg(SrcRegD);
  AddDefaultPred(MIB);

  // We are now reading SrcRegD instead of SrcRegS.  This may upset the
  // register scavenger and machine verifier, so we need to indicate that we
  // are reading an undefined value from SrcRegD, but a proper value from
  // SrcRegS.
  MI->getOperand(1).setIsUndef();
  MIB.addReg(SrcRegS, RegState::Implicit);

  // SrcRegD may actually contain an unrelated value in the ssub_1
  // sub-register.  Don't kill it.  Only kill the ssub_0 sub-register.
  if (MI->getOperand(1).isKill()) {
    MI->getOperand(1).setIsKill(false);
    MI->addRegisterKilled(SrcRegS, TRI, true);
  }

  DEBUG(dbgs() << ""replaced by: "" << *MI);
  return true;
}

/// Create a copy of a const pool value. Update CPI to the new index and return
/// the label UID.
static unsigned duplicateCPV(MachineFunction &MF, unsigned &CPI) {
  MachineConstantPool *MCP = MF.getConstantPool();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();

  const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPI];
  assert(MCPE.isMachineConstantPoolEntry() &&
         ""Expecting a machine constantpool entry!"");
  ARMConstantPoolValue *ACPV =
    static_cast<ARMConstantPoolValue*>(MCPE.Val.MachineCPVal);

  unsigned PCLabelId = AFI->createPICLabelUId();
  ARMConstantPoolValue *NewCPV = nullptr;

  // FIXME: The below assumes PIC relocation model and that the function
  // is Thumb mode (t1 or t2). PCAdjustment would be 8 for ARM mode PIC, and
  // zero for non-PIC in ARM or Thumb. The callers are all of thumb LDR
  // instructions, so that's probably OK, but is PIC always correct when
  // we get here?
  if (ACPV->isGlobalValue())
    NewCPV = ARMConstantPoolConstant::
      Create(cast<ARMConstantPoolConstant>(ACPV)->getGV(), PCLabelId,
             ARMCP::CPValue, 4);
  else if (ACPV->isExtSymbol())
    NewCPV = ARMConstantPoolSymbol::
      Create(MF.getFunction()->getContext(),
             cast<ARMConstantPoolSymbol>(ACPV)->getSymbol(), PCLabelId, 4);
  else if (ACPV->isBlockAddress())
    NewCPV = ARMConstantPoolConstant::
      Create(cast<ARMConstantPoolConstant>(ACPV)->getBlockAddress(), PCLabelId,
             ARMCP::CPBlockAddress, 4);
  else if (ACPV->isLSDA())
    NewCPV = ARMConstantPoolConstant::Create(MF.getFunction(), PCLabelId,
                                             ARMCP::CPLSDA, 4);
  else if (ACPV->isMachineBasicBlock())
    NewCPV = ARMConstantPoolMBB::
      Create(MF.getFunction()->getContext(),
             cast<ARMConstantPoolMBB>(ACPV)->getMBB(), PCLabelId, 4);
  else
    llvm_unreachable(""Unexpected ARM constantpool value type!!"");
  CPI = MCP->getConstantPoolIndex(NewCPV, MCPE.getAlignment());
  return PCLabelId;
}

void ARMBaseInstrInfo::
reMaterialize(MachineBasicBlock &MBB,
              MachineBasicBlock::iterator I,
              unsigned DestReg, unsigned SubIdx,
              const MachineInstr *Orig,
              const TargetRegisterInfo &TRI) const {
  unsigned Opcode = Orig->getOpcode();
  switch (Opcode) {
  default: {
    MachineInstr *MI = MBB.getParent()->CloneMachineInstr(Orig);
    MI->substituteRegister(Orig->getOperand(0).getReg(), DestReg, SubIdx, TRI);
    MBB.insert(I, MI);
    break;
  }
  case ARM::tLDRpci_pic:
  case ARM::t2LDRpci_pic: {
    MachineFunction &MF = *MBB.getParent();
    unsigned CPI = Orig->getOperand(1).getIndex();
    unsigned PCLabelId = duplicateCPV(MF, CPI);
    MachineInstrBuilder MIB = BuildMI(MBB, I, Orig->getDebugLoc(), get(Opcode),
                                      DestReg)
      .addConstantPoolIndex(CPI).addImm(PCLabelId);
    MIB->setMemRefs(Orig->memoperands_begin(), Orig->memoperands_end());
    break;
  }
  }
}

MachineInstr *
ARMBaseInstrInfo::duplicate(MachineInstr *Orig, MachineFunction &MF) const {
  MachineInstr *MI = TargetInstrInfo::duplicate(Orig, MF);
  switch(Orig->getOpcode()) {
  case ARM::tLDRpci_pic:
  case ARM::t2LDRpci_pic: {
    unsigned CPI = Orig->getOperand(1).getIndex();
    unsigned PCLabelId = duplicateCPV(MF, CPI);
    Orig->getOperand(1).setIndex(CPI);
    Orig->getOperand(2).setImm(PCLabelId);
    break;
  }
  }
  return MI;
}

bool ARMBaseInstrInfo::produceSameValue(const MachineInstr *MI0,
                                        const MachineInstr *MI1,
                                        const MachineRegisterInfo *MRI) const {
  unsigned Opcode = MI0->getOpcode();
  if (Opcode == ARM::t2LDRpci ||
      Opcode == ARM::t2LDRpci_pic ||
      Opcode == ARM::tLDRpci ||
      Opcode == ARM::tLDRpci_pic ||
      Opcode == ARM::LDRLIT_ga_pcrel ||
      Opcode == ARM::LDRLIT_ga_pcrel_ldr ||
      Opcode == ARM::tLDRLIT_ga_pcrel ||
      Opcode == ARM::MOV_ga_pcrel ||
      Opcode == ARM::MOV_ga_pcrel_ldr ||
      Opcode == ARM::t2MOV_ga_pcrel) {
    if (MI1->getOpcode() != Opcode)
      return false;
    if (MI0->getNumOperands() != MI1->getNumOperands())
      return false;

    const MachineOperand &MO0 = MI0->getOperand(1);
    const MachineOperand &MO1 = MI1->getOperand(1);
    if (MO0.getOffset() != MO1.getOffset())
      return false;

    if (Opcode == ARM::LDRLIT_ga_pcrel ||
        Opcode == ARM::LDRLIT_ga_pcrel_ldr ||
        Opcode == ARM::tLDRLIT_ga_pcrel ||
        Opcode == ARM::MOV_ga_pcrel ||
        Opcode == ARM::MOV_ga_pcrel_ldr ||
        Opcode == ARM::t2MOV_ga_pcrel)
      // Ignore the PC labels.
      return MO0.getGlobal() == MO1.getGlobal();

    const MachineFunction *MF = MI0->getParent()->getParent();
    const MachineConstantPool *MCP = MF->getConstantPool();
    int CPI0 = MO0.getIndex();
    int CPI1 = MO1.getIndex();
    const MachineConstantPoolEntry &MCPE0 = MCP->getConstants()[CPI0];
    const MachineConstantPoolEntry &MCPE1 = MCP->getConstants()[CPI1];
    bool isARMCP0 = MCPE0.isMachineConstantPoolEntry();
    bool isARMCP1 = MCPE1.isMachineConstantPoolEntry();
    if (isARMCP0 && isARMCP1) {
      ARMConstantPoolValue *ACPV0 =
        static_cast<ARMConstantPoolValue*>(MCPE0.Val.MachineCPVal);
      ARMConstantPoolValue *ACPV1 =
        static_cast<ARMConstantPoolValue*>(MCPE1.Val.MachineCPVal);
      return ACPV0->hasSameValue(ACPV1);
    } else if (!isARMCP0 && !isARMCP1) {
      return MCPE0.Val.ConstVal == MCPE1.Val.ConstVal;
    }
    return false;
  } else if (Opcode == ARM::PICLDR) {
    if (MI1->getOpcode() != Opcode)
      return false;
    if (MI0->getNumOperands() != MI1->getNumOperands())
      return false;

    unsigned Addr0 = MI0->getOperand(1).getReg();
    unsigned Addr1 = MI1->getOperand(1).getReg();
    if (Addr0 != Addr1) {
      if (!MRI ||
          !TargetRegisterInfo::isVirtualRegister(Addr0) ||
          !TargetRegisterInfo::isVirtualRegister(Addr1))
        return false;

      // This assumes SSA form.
      MachineInstr *Def0 = MRI->getVRegDef(Addr0);
      MachineInstr *Def1 = MRI->getVRegDef(Addr1);
      // Check if the loaded value, e.g. a constantpool of a global address, are
      // the same.
      if (!produceSameValue(Def0, Def1, MRI))
        return false;
    }

    for (unsigned i = 3, e = MI0->getNumOperands(); i != e; ++i) {
      // %vreg12<def> = PICLDR %vreg11, 0, pred:14, pred:%noreg
      const MachineOperand &MO0 = MI0->getOperand(i);
      const MachineOperand &MO1 = MI1->getOperand(i);
      if (!MO0.isIdenticalTo(MO1))
        return false;
    }
    return true;
  }

  return MI0->isIdenticalTo(MI1, MachineInstr::IgnoreVRegDefs);
}

/// areLoadsFromSameBasePtr - This is used by the pre-regalloc scheduler to
/// determine if two loads are loading from the same base address. It should
/// only return true if the base pointers are the same and the only differences
/// between the two addresses is the offset. It also returns the offsets by
/// reference.
///
/// FIXME: remove this in favor of the MachineInstr interface once pre-RA-sched
/// is permanently disabled.
bool ARMBaseInstrInfo::areLoadsFromSameBasePtr(SDNode *Load1, SDNode *Load2,
                                               int64_t &Offset1,
                                               int64_t &Offset2) const {
  // Don't worry about Thumb: just ARM and Thumb2.
  if (Subtarget.isThumb1Only()) return false;

  if (!Load1->isMachineOpcode() || !Load2->isMachineOpcode())
    return false;

  switch (Load1->getMachineOpcode()) {
  default:
    return false;
  case ARM::LDRi12:
  case ARM::LDRBi12:
  case ARM::LDRD:
  case ARM::LDRH:
  case ARM::LDRSB:
  case ARM::LDRSH:
  case ARM::VLDRD:
  case ARM::VLDRS:
  case ARM::t2LDRi8:
  case ARM::t2LDRBi8:
  case ARM::t2LDRDi8:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRi12:
  case ARM::t2LDRBi12:
  case ARM::t2LDRSHi12:
    break;
  }

  switch (Load2->getMachineOpcode()) {
  default:
    return false;
  case ARM::LDRi12:
  case ARM::LDRBi12:
  case ARM::LDRD:
  case ARM::LDRH:
  case ARM::LDRSB:
  case ARM::LDRSH:
  case ARM::VLDRD:
  case ARM::VLDRS:
  case ARM::t2LDRi8:
  case ARM::t2LDRBi8:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRi12:
  case ARM::t2LDRBi12:
  case ARM::t2LDRSHi12:
    break;
  }

  // Check if base addresses and chain operands match.
  if (Load1->getOperand(0) != Load2->getOperand(0) ||
      Load1->getOperand(4) != Load2->getOperand(4))
    return false;

  // Index should be Reg0.
  if (Load1->getOperand(3) != Load2->getOperand(3))
    return false;

  // Determine the offsets.
  if (isa<ConstantSDNode>(Load1->getOperand(1)) &&
      isa<ConstantSDNode>(Load2->getOperand(1))) {
    Offset1 = cast<ConstantSDNode>(Load1->getOperand(1))->getSExtValue();
    Offset2 = cast<ConstantSDNode>(Load2->getOperand(1))->getSExtValue();
    return true;
  }

  return false;
}

/// shouldScheduleLoadsNear - This is a used by the pre-regalloc scheduler to
/// determine (in conjunction with areLoadsFromSameBasePtr) if two loads should
/// be scheduled togther. On some targets if two loads are loading from
/// addresses in the same cache line, it's better if they are scheduled
/// together. This function takes two integers that represent the load offsets
/// from the common base address. It returns true if it decides it's desirable
/// to schedule the two loads together. ""NumLoads"" is the number of loads that
/// have already been scheduled after Load1.
///
/// FIXME: remove this in favor of the MachineInstr interface once pre-RA-sched
/// is permanently disabled.
bool ARMBaseInstrInfo::shouldScheduleLoadsNear(SDNode *Load1, SDNode *Load2,
                                               int64_t Offset1, int64_t Offset2,
                                               unsigned NumLoads) const {
  // Don't worry about Thumb: just ARM and Thumb2.
  if (Subtarget.isThumb1Only()) return false;

  assert(Offset2 > Offset1);

  if ((Offset2 - Offset1) / 8 > 64)
    return false;

  // Check if the machine opcodes are different. If they are different
  // then we consider them to not be of the same base address,
  // EXCEPT in the case of Thumb2 byte loads where one is LDRBi8 and the other LDRBi12.
  // In this case, they are considered to be the same because they are different
  // encoding forms of the same basic instruction.
  if ((Load1->getMachineOpcode() != Load2->getMachineOpcode()) &&
      !((Load1->getMachineOpcode() == ARM::t2LDRBi8 &&
         Load2->getMachineOpcode() == ARM::t2LDRBi12) ||
        (Load1->getMachineOpcode() == ARM::t2LDRBi12 &&
         Load2->getMachineOpcode() == ARM::t2LDRBi8)))
    return false;  // FIXME: overly conservative?

  // Four loads in a row should be sufficient.
  if (NumLoads >= 3)
    return false;

  return true;
}

bool ARMBaseInstrInfo::isSchedulingBoundary(const MachineInstr *MI,
                                            const MachineBasicBlock *MBB,
                                            const MachineFunction &MF) const {
  // Debug info is never a scheduling boundary. It's necessary to be explicit
  // due to the special treatment of IT instructions below, otherwise a
  // dbg_value followed by an IT will result in the IT instruction being
  // considered a scheduling hazard, which is wrong. It should be the actual
  // instruction preceding the dbg_value instruction(s), just like it is
  // when debug info is not present.
  if (MI->isDebugValue())
    return false;

  // Terminators and labels can't be scheduled around.
  if (MI->isTerminator() || MI->isPosition())
    return true;

  // Treat the start of the IT block as a scheduling boundary, but schedule
  // t2IT along with all instructions following it.
  // FIXME: This is a big hammer. But the alternative is to add all potential
  // true and anti dependencies to IT block instructions as implicit operands
  // to the t2IT instruction. The added compile time and complexity does not
  // seem worth it.
  MachineBasicBlock::const_iterator I = MI;
  // Make sure to skip any dbg_value instructions
  while (++I != MBB->end() && I->isDebugValue())
    ;
  if (I != MBB->end() && I->getOpcode() == ARM::t2IT)
    return true;

  // Don't attempt to schedule around any instruction that defines
  // a stack-oriented pointer, as it's unlikely to be profitable. This
  // saves compile time, because it doesn't require every single
  // stack slot reference to depend on the instruction that does the
  // modification.
  // Calls don't actually change the stack pointer, even if they have imp-defs.
  // No ARM calling conventions change the stack pointer. (X86 calling
  // conventions sometimes do).
  if (!MI->isCall() && MI->definesRegister(ARM::SP))
    return true;

  return false;
}

bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &MBB,
                    unsigned NumCycles, unsigned ExtraPredCycles,
                    const BranchProbability &Probability) const {
  if (!NumCycles)
    return false;

  // If we are optimizing for size, see if the branch in the predecessor can be
  // lowered to cbn?z by the constant island lowering pass, and return false if
  // so. This results in a shorter instruction sequence.
  const Function *F = MBB.getParent()->getFunction();
  if (F->hasFnAttribute(Attribute::OptimizeForSize) ||
      F->hasFnAttribute(Attribute::MinSize)) {
    MachineBasicBlock *Pred = *MBB.pred_begin();
    if (!Pred->empty()) {
      MachineInstr *LastMI = &*Pred->rbegin();
      if (LastMI->getOpcode() == ARM::t2Bcc) {
        MachineBasicBlock::iterator CmpMI = LastMI;
        if (CmpMI != Pred->begin()) {
          --CmpMI;
          if (CmpMI->getOpcode() == ARM::tCMPi8 ||
              CmpMI->getOpcode() == ARM::t2CMPri) {
            unsigned Reg = CmpMI->getOperand(0).getReg();
            unsigned PredReg = 0;
            ARMCC::CondCodes P = getInstrPredicate(CmpMI, PredReg);
            if (P == ARMCC::AL && CmpMI->getOperand(1).getImm() == 0 &&
                isARMLowRegister(Reg))
              return false;
          }
        }
      }
    }
  }

  // Attempt to estimate the relative costs of predication versus branching.
  unsigned UnpredCost = Probability.getNumerator() * NumCycles;
  UnpredCost /= Probability.getDenominator();
  UnpredCost += 1; // The branch itself
  UnpredCost += Subtarget.getMispredictionPenalty() / 10;

  return (NumCycles + ExtraPredCycles) <= UnpredCost;
}

bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &TMBB,
                    unsigned TCycles, unsigned TExtra,
                    MachineBasicBlock &FMBB,
                    unsigned FCycles, unsigned FExtra,
                    const BranchProbability &Probability) const {
  if (!TCycles || !FCycles)
    return false;

  // Attempt to estimate the relative costs of predication versus branching.
  unsigned TUnpredCost = Probability.getNumerator() * TCycles;
  TUnpredCost /= Probability.getDenominator();

  uint32_t Comp = Probability.getDenominator() - Probability.getNumerator();
  unsigned FUnpredCost = Comp * FCycles;
  FUnpredCost /= Probability.getDenominator();

  unsigned UnpredCost = TUnpredCost + FUnpredCost;
  UnpredCost += 1; // The branch itself
  UnpredCost += Subtarget.getMispredictionPenalty() / 10;

  return (TCycles + FCycles + TExtra + FExtra) <= UnpredCost;
}

bool
ARMBaseInstrInfo::isProfitableToUnpredicate(MachineBasicBlock &TMBB,
                                            MachineBasicBlock &FMBB) const {
  // Reduce false anti-dependencies to let Swift's out-of-order execution
  // engine do its thing.
  return Subtarget.isSwift();
}

/// getInstrPredicate - If instruction is predicated, returns its predicate
/// condition, otherwise returns AL. It also returns the condition code
/// register by reference.
ARMCC::CondCodes
llvm::getInstrPredicate(const MachineInstr *MI, unsigned &PredReg) {
  int PIdx = MI->findFirstPredOperandIdx();
  if (PIdx == -1) {
    PredReg = 0;
    return ARMCC::AL;
  }

  PredReg = MI->getOperand(PIdx+1).getReg();
  return (ARMCC::CondCodes)MI->getOperand(PIdx).getImm();
}


unsigned llvm::getMatchingCondBranchOpcode(unsigned Opc) {
  if (Opc == ARM::B)
    return ARM::Bcc;
  if (Opc == ARM::tB)
    return ARM::tBcc;
  if (Opc == ARM::t2B)
    return ARM::t2Bcc;

  llvm_unreachable(""Unknown unconditional branch opcode!"");
}

/// commuteInstruction - Handle commutable instructions.
MachineInstr *
ARMBaseInstrInfo::commuteInstruction(MachineInstr *MI, bool NewMI) const {
  switch (MI->getOpcode()) {
  case ARM::MOVCCr:
  case ARM::t2MOVCCr: {
    // MOVCC can be commuted by inverting the condition.
    unsigned PredReg = 0;
    ARMCC::CondCodes CC = getInstrPredicate(MI, PredReg);
    // MOVCC AL can't be inverted. Shouldn't happen.
    if (CC == ARMCC::AL || PredReg != ARM::CPSR)
      return nullptr;
    MI = TargetInstrInfo::commuteInstruction(MI, NewMI);
    if (!MI)
      return nullptr;
    // After swapping the MOVCC operands, also invert the condition.
    MI->getOperand(MI->findFirstPredOperandIdx())
      .setImm(ARMCC::getOppositeCondition(CC));
    return MI;
  }
  }
  return TargetInstrInfo::commuteInstruction(MI, NewMI);
}

/// Identify instructions that can be folded into a MOVCC instruction, and
/// return the defining instruction.
static MachineInstr *canFoldIntoMOVCC(unsigned Reg,
                                      const MachineRegisterInfo &MRI,
                                      const TargetInstrInfo *TII) {
  if (!TargetRegisterInfo::isVirtualRegister(Reg))
    return nullptr;
  if (!MRI.hasOneNonDBGUse(Reg))
    return nullptr;
  MachineInstr *MI = MRI.getVRegDef(Reg);
  if (!MI)
    return nullptr;
  // MI is folded into the MOVCC by predicating it.
  if (!MI->isPredicable())
    return nullptr;
  // Check if MI has any non-dead defs or physreg uses. This also detects
  // predicated instructions which will be reading CPSR.
  for (unsigned i = 1, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    // Reject frame index operands, PEI can't handle the predicated pseudos.
    if (MO.isFI() || MO.isCPI() || MO.isJTI())
      return nullptr;
    if (!MO.isReg())
      continue;
    // MI can't have any tied operands, that would conflict with predication.
    if (MO.isTied())
      return nullptr;
    if (TargetRegisterInfo::isPhysicalRegister(MO.getReg()))
      return nullptr;
    if (MO.isDef() && !MO.isDead())
      return nullptr;
  }
  bool DontMoveAcrossStores = true;
  if (!MI->isSafeToMove(/* AliasAnalysis = */ nullptr, DontMoveAcrossStores))
    return nullptr;
  return MI;
}

bool ARMBaseInstrInfo::analyzeSelect(const MachineInstr *MI,
                                     SmallVectorImpl<MachineOperand> &Cond,
                                     unsigned &TrueOp, unsigned &FalseOp,
                                     bool &Optimizable) const {
  assert((MI->getOpcode() == ARM::MOVCCr || MI->getOpcode() == ARM::t2MOVCCr) &&
         ""Unknown select instruction"");
  // MOVCC operands:
  // 0: Def.
  // 1: True use.
  // 2: False use.
  // 3: Condition code.
  // 4: CPSR use.
  TrueOp = 1;
  FalseOp = 2;
  Cond.push_back(MI->getOperand(3));
  Cond.push_back(MI->getOperand(4));
  // We can always fold a def.
  Optimizable = true;
  return false;
}

MachineInstr *
ARMBaseInstrInfo::optimizeSelect(MachineInstr *MI,
                                 SmallPtrSetImpl<MachineInstr *> &SeenMIs,
                                 bool PreferFalse) const {
  assert((MI->getOpcode() == ARM::MOVCCr || MI->getOpcode() == ARM::t2MOVCCr) &&
         ""Unknown select instruction"");
  MachineRegisterInfo &MRI = MI->getParent()->getParent()->getRegInfo();
  MachineInstr *DefMI = canFoldIntoMOVCC(MI->getOperand(2).getReg(), MRI, this);
  bool Invert = !DefMI;
  if (!DefMI)
    DefMI = canFoldIntoMOVCC(MI->getOperand(1).getReg(), MRI, this);
  if (!DefMI)
    return nullptr;

  // Find new register class to use.
  MachineOperand FalseReg = MI->getOperand(Invert ? 2 : 1);
  unsigned       DestReg  = MI->getOperand(0).getReg();
  const TargetRegisterClass *PreviousClass = MRI.getRegClass(FalseReg.getReg());
  if (!MRI.constrainRegClass(DestReg, PreviousClass))
    return nullptr;

  // Create a new predicated version of DefMI.
  // Rfalse is the first use.
  MachineInstrBuilder NewMI = BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                                      DefMI->getDesc(), DestReg);

  // Copy all the DefMI operands, excluding its (null) predicate.
  const MCInstrDesc &DefDesc = DefMI->getDesc();
  for (unsigned i = 1, e = DefDesc.getNumOperands();
       i != e && !DefDesc.OpInfo[i].isPredicate(); ++i)
    NewMI.addOperand(DefMI->getOperand(i));

  unsigned CondCode = MI->getOperand(3).getImm();
  if (Invert)
    NewMI.addImm(ARMCC::getOppositeCondition(ARMCC::CondCodes(CondCode)));
  else
    NewMI.addImm(CondCode);
  NewMI.addOperand(MI->getOperand(4));

  // DefMI is not the -S version that sets CPSR, so add an optional %noreg.
  if (NewMI->hasOptionalDef())
    AddDefaultCC(NewMI);

  // The output register value when the predicate is false is an implicit
  // register operand tied to the first def.
  // The tie makes the register allocator ensure the FalseReg is allocated the
  // same register as operand 0.
  FalseReg.setImplicit();
  NewMI.addOperand(FalseReg);
  NewMI->tieOperands(0, NewMI->getNumOperands() - 1);

  // Update SeenMIs set: register newly created MI and erase removed DefMI.
  SeenMIs.insert(NewMI);
  SeenMIs.erase(DefMI);

  // If MI is inside a loop, and DefMI is outside the loop, then kill flags on
  // DefMI would be invalid when tranferred inside the loop.  Checking for a
  // loop is expensive, but at least remove kill flags if they are in different
  // BBs.
  if (DefMI->getParent() != MI->getParent())
    NewMI->clearKillInfo();

  // The caller will erase MI, but not DefMI.
  DefMI->eraseFromParent();
  return NewMI;
}

/// Map pseudo instructions that imply an 'S' bit onto real opcodes. Whether the
/// instruction is encoded with an 'S' bit is determined by the optional CPSR
/// def operand.
///
/// This will go away once we can teach tblgen how to set the optional CPSR def
/// operand itself.
struct AddSubFlagsOpcodePair {
  uint16_t PseudoOpc;
  uint16_t MachineOpc;
};

static const AddSubFlagsOpcodePair AddSubFlagsOpcodeMap[] = {
  {ARM::ADDSri, ARM::ADDri},
  {ARM::ADDSrr, ARM::ADDrr},
  {ARM::ADDSrsi, ARM::ADDrsi},
  {ARM::ADDSrsr, ARM::ADDrsr},

  {ARM::SUBSri, ARM::SUBri},
  {ARM::SUBSrr, ARM::SUBrr},
  {ARM::SUBSrsi, ARM::SUBrsi},
  {ARM::SUBSrsr, ARM::SUBrsr},

  {ARM::RSBSri, ARM::RSBri},
  {ARM::RSBSrsi, ARM::RSBrsi},
  {ARM::RSBSrsr, ARM::RSBrsr},

  {ARM::t2ADDSri, ARM::t2ADDri},
  {ARM::t2ADDSrr, ARM::t2ADDrr},
  {ARM::t2ADDSrs, ARM::t2ADDrs},

  {ARM::t2SUBSri, ARM::t2SUBri},
  {ARM::t2SUBSrr, ARM::t2SUBrr},
  {ARM::t2SUBSrs, ARM::t2SUBrs},

  {ARM::t2RSBSri, ARM::t2RSBri},
  {ARM::t2RSBSrs, ARM::t2RSBrs},
};

unsigned llvm::convertAddSubFlagsOpcode(unsigned OldOpc) {
  for (unsigned i = 0, e = array_lengthof(AddSubFlagsOpcodeMap); i != e; ++i)
    if (OldOpc == AddSubFlagsOpcodeMap[i].PseudoOpc)
      return AddSubFlagsOpcodeMap[i].MachineOpc;
  return 0;
}

void llvm::emitARMRegPlusImmediate(MachineBasicBlock &MBB,
                               MachineBasicBlock::iterator &MBBI, DebugLoc dl,
                               unsigned DestReg, unsigned BaseReg, int NumBytes,
                               ARMCC::CondCodes Pred, unsigned PredReg,
                               const ARMBaseInstrInfo &TII, unsigned MIFlags) {
  if (NumBytes == 0 && DestReg != BaseReg) {
    BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), DestReg)
      .addReg(BaseReg, RegState::Kill)
      .addImm((unsigned)Pred).addReg(PredReg).addReg(0)
      .setMIFlags(MIFlags);
    return;
  }

  bool isSub = NumBytes < 0;
  if (isSub) NumBytes = -NumBytes;

  while (NumBytes) {
    unsigned RotAmt = ARM_AM::getSOImmValRotate(NumBytes);
    unsigned ThisVal = NumBytes & ARM_AM::rotr32(0xFF, RotAmt);
    assert(ThisVal && ""Didn't extract field correctly"");

    // We will handle these bits from offset, clear them.
    NumBytes &= ~ThisVal;

    assert(ARM_AM::getSOImmVal(ThisVal) != -1 && ""Bit extraction didn't work?"");

    // Build the new ADD / SUB.
    unsigned Opc = isSub ? ARM::SUBri : ARM::ADDri;
    BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg)
      .addReg(BaseReg, RegState::Kill).addImm(ThisVal)
      .addImm((unsigned)Pred).addReg(PredReg).addReg(0)
      .setMIFlags(MIFlags);
    BaseReg = DestReg;
  }
}

static bool isAnySubRegLive(unsigned Reg, const TargetRegisterInfo *TRI,
                      MachineInstr *MI) {
  for (MCSubRegIterator Subreg(Reg, TRI, /* IncludeSelf */ true);
       Subreg.isValid(); ++Subreg)
    if (MI->getParent()->computeRegisterLiveness(TRI, *Subreg, MI) !=
        MachineBasicBlock::LQR_Dead)
      return true;
  return false;
}
bool llvm::tryFoldSPUpdateIntoPushPop(const ARMSubtarget &Subtarget,
                                      MachineFunction &MF, MachineInstr *MI,
                                      unsigned NumBytes) {
  // This optimisation potentially adds lots of load and store
  // micro-operations, it's only really a great benefit to code-size.
  if (!MF.getFunction()->hasFnAttribute(Attribute::MinSize))
    return false;

  // If only one register is pushed/popped, LLVM can use an LDR/STR
  // instead. We can't modify those so make sure we're dealing with an
  // instruction we understand.
  bool IsPop = isPopOpcode(MI->getOpcode());
  bool IsPush = isPushOpcode(MI->getOpcode());
  if (!IsPush && !IsPop)
    return false;

  bool IsVFPPushPop = MI->getOpcode() == ARM::VSTMDDB_UPD ||
                      MI->getOpcode() == ARM::VLDMDIA_UPD;
  bool IsT1PushPop = MI->getOpcode() == ARM::tPUSH ||
                     MI->getOpcode() == ARM::tPOP ||
                     MI->getOpcode() == ARM::tPOP_RET;

  assert((IsT1PushPop || (MI->getOperand(0).getReg() == ARM::SP &&
                          MI->getOperand(1).getReg() == ARM::SP)) &&
         ""trying to fold sp update into non-sp-updating push/pop"");

  // The VFP push & pop act on D-registers, so we can only fold an adjustment
  // by a multiple of 8 bytes in correctly. Similarly rN is 4-bytes. Don't try
  // if this is violated.
  if (NumBytes % (IsVFPPushPop ? 8 : 4) != 0)
    return false;

  // ARM and Thumb2 push/pop insts have explicit ""sp, sp"" operands (+
  // pred) so the list starts at 4. Thumb1 starts after the predicate.
  int RegListIdx = IsT1PushPop ? 2 : 4;

  // Calculate the space we'll need in terms of registers.
  unsigned FirstReg = MI->getOperand(RegListIdx).getReg();
  unsigned RD0Reg, RegsNeeded;
  if (IsVFPPushPop) {
    RD0Reg = ARM::D0;
    RegsNeeded = NumBytes / 8;
  } else {
    RD0Reg = ARM::R0;
    RegsNeeded = NumBytes / 4;
  }

  // We're going to have to strip all list operands off before
  // re-adding them since the order matters, so save the existing ones
  // for later.
  SmallVector<MachineOperand, 4> RegList;
  for (int i = MI->getNumOperands() - 1; i >= RegListIdx; --i)
    RegList.push_back(MI->getOperand(i));

  const TargetRegisterInfo *TRI = MF.getRegInfo().getTargetRegisterInfo();
  const MCPhysReg *CSRegs = TRI->getCalleeSavedRegs(&MF);

  // Now try to find enough space in the reglist to allocate NumBytes.
  for (unsigned CurReg = FirstReg - 1; CurReg >= RD0Reg && RegsNeeded;
       --CurReg) {
    if (!IsPop) {
      // Pushing any register is completely harmless, mark the
      // register involved as undef since we don't care about it in
      // the slightest.
      RegList.push_back(MachineOperand::CreateReg(CurReg, false, false,
                                                  false, false, true));
      --RegsNeeded;
      continue;
    }

    // However, we can only pop an extra register if it's not live. For
    // registers live within the function we might clobber a return value
    // register; the other way a register can be live here is if it's
    // callee-saved.
    // TODO: Currently, computeRegisterLiveness() does not report ""live"" if a
    // sub reg is live. When computeRegisterLiveness() works for sub reg, it
    // can replace isAnySubRegLive().
    if (isCalleeSavedRegister(CurReg, CSRegs) ||
        isAnySubRegLive(CurReg, TRI, MI)) {
      // VFP pops don't allow holes in the register list, so any skip is fatal
      // for our transformation. GPR pops do, so we should just keep looking.
      if (IsVFPPushPop)
        return false;
      else
        continue;
    }

    // Mark the unimportant registers as <def,dead> in the POP.
    RegList.push_back(MachineOperand::CreateReg(CurReg, true, false, false,
                                                true));
    --RegsNeeded;
  }

  if (RegsNeeded > 0)
    return false;

  // Finally we know we can profitably perform the optimisation so go
  // ahead: strip all existing registers off and add them back again
  // in the right order.
  for (int i = MI->getNumOperands() - 1; i >= RegListIdx; --i)
    MI->RemoveOperand(i);

  // Add the complete list back in.
  MachineInstrBuilder MIB(MF, &*MI);
  for (int i = RegList.size() - 1; i >= 0; --i)
    MIB.addOperand(RegList[i]);

  return true;
}

bool llvm::rewriteARMFrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
                                unsigned FrameReg, int &Offset,
                                const ARMBaseInstrInfo &TII) {
  unsigned Opcode = MI.getOpcode();
  const MCInstrDesc &Desc = MI.getDesc();
  unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
  bool isSub = false;

  // Memory operands in inline assembly always use AddrMode2.
  if (Opcode == ARM::INLINEASM)
    AddrMode = ARMII::AddrMode2;

  if (Opcode == ARM::ADDri) {
    Offset += MI.getOperand(FrameRegIdx+1).getImm();
    if (Offset == 0) {
      // Turn it into a move.
      MI.setDesc(TII.get(ARM::MOVr));
      MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
      MI.RemoveOperand(FrameRegIdx+1);
      Offset = 0;
      return true;
    } else if (Offset < 0) {
      Offset = -Offset;
      isSub = true;
      MI.setDesc(TII.get(ARM::SUBri));
    }

    // Common case: small offset, fits into instruction.
    if (ARM_AM::getSOImmVal(Offset) != -1) {
      // Replace the FrameIndex with sp / fp
      MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
      MI.getOperand(FrameRegIdx+1).ChangeToImmediate(Offset);
      Offset = 0;
      return true;
    }

    // Otherwise, pull as much of the immedidate into this ADDri/SUBri
    // as possible.
    unsigned RotAmt = ARM_AM::getSOImmValRotate(Offset);
    unsigned ThisImmVal = Offset & ARM_AM::rotr32(0xFF, RotAmt);

    // We will handle these bits from offset, clear them.
    Offset &= ~ThisImmVal;

    // Get the properly encoded SOImmVal field.
    assert(ARM_AM::getSOImmVal(ThisImmVal) != -1 &&
           ""Bit extraction didn't work?"");
    MI.getOperand(FrameRegIdx+1).ChangeToImmediate(ThisImmVal);
 } else {
    unsigned ImmIdx = 0;
    int InstrOffs = 0;
    unsigned NumBits = 0;
    unsigned Scale = 1;
    switch (AddrMode) {
    case ARMII::AddrMode_i12: {
      ImmIdx = FrameRegIdx + 1;
      InstrOffs = MI.getOperand(ImmIdx).getImm();
      NumBits = 12;
      break;
    }
    case ARMII::AddrMode2: {
      ImmIdx = FrameRegIdx+2;
      InstrOffs = ARM_AM::getAM2Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM2Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 12;
      break;
    }
    case ARMII::AddrMode3: {
      ImmIdx = FrameRegIdx+2;
      InstrOffs = ARM_AM::getAM3Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM3Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 8;
      break;
    }
    case ARMII::AddrMode4:
    case ARMII::AddrMode6:
      // Can't fold any offset even if it's zero.
      return false;
    case ARMII::AddrMode5: {
      ImmIdx = FrameRegIdx+1;
      InstrOffs = ARM_AM::getAM5Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM5Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 8;
      Scale = 4;
      break;
    }
    default:
      llvm_unreachable(""Unsupported addressing mode!"");
    }

    Offset += InstrOffs * Scale;
    assert((Offset & (Scale-1)) == 0 && ""Can't encode this offset!"");
    if (Offset < 0) {
      Offset = -Offset;
      isSub = true;
    }

    // Attempt to fold address comp. if opcode has offset bits
    if (NumBits > 0) {
      // Common case: small offset, fits into instruction.
      MachineOperand &ImmOp = MI.getOperand(ImmIdx);
      int ImmedOffset = Offset / Scale;
      unsigned Mask = (1 << NumBits) - 1;
      if ((unsigned)Offset <= Mask * Scale) {
        // Replace the FrameIndex with sp
        MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
        // FIXME: When addrmode2 goes away, this will simplify (like the
        // T2 version), as the LDR.i12 versions don't need the encoding
        // tricks for the offset value.
        if (isSub) {
          if (AddrMode == ARMII::AddrMode_i12)
            ImmedOffset = -ImmedOffset;
          else
            ImmedOffset |= 1 << NumBits;
        }
        ImmOp.ChangeToImmediate(ImmedOffset);
        Offset = 0;
        return true;
      }

      // Otherwise, it didn't fit. Pull in what we can to simplify the immed.
      ImmedOffset = ImmedOffset & Mask;
      if (isSub) {
        if (AddrMode == ARMII::AddrMode_i12)
          ImmedOffset = -ImmedOffset;
        else
          ImmedOffset |= 1 << NumBits;
      }
      ImmOp.ChangeToImmediate(ImmedOffset);
      Offset &= ~(Mask*Scale);
    }
  }

  Offset = (isSub) ? -Offset : Offset;
  return Offset == 0;
}

/// analyzeCompare - For a comparison instruction, return the source registers
/// in SrcReg and SrcReg2 if having two register operands, and the value it
/// compares against in CmpValue. Return true if the comparison instruction
/// can be analyzed.
bool ARMBaseInstrInfo::
analyzeCompare(const MachineInstr *MI, unsigned &SrcReg, unsigned &SrcReg2,
               int &CmpMask, int &CmpValue) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::CMPri:
  case ARM::t2CMPri:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = 0;
    CmpMask = ~0;
    CmpValue = MI->getOperand(1).getImm();
    return true;
  case ARM::CMPrr:
  case ARM::t2CMPrr:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = MI->getOperand(1).getReg();
    CmpMask = ~0;
    CmpValue = 0;
    return true;
  case ARM::TSTri:
  case ARM::t2TSTri:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = 0;
    CmpMask = MI->getOperand(1).getImm();
    CmpValue = 0;
    return true;
  }

  return false;
}

/// isSuitableForMask - Identify a suitable 'and' instruction that
/// operates on the given source register and applies the same mask
/// as a 'tst' instruction. Provide a limited look-through for copies.
/// When successful, MI will hold the found instruction.
static bool isSuitableForMask(MachineInstr *&MI, unsigned SrcReg,
                              int CmpMask, bool CommonUse) {
  switch (MI->getOpcode()) {
    case ARM::ANDri:
    case ARM::t2ANDri:
      if (CmpMask != MI->getOperand(2).getImm())
        return false;
      if (SrcReg == MI->getOperand(CommonUse ? 1 : 0).getReg())
        return true;
      break;
  }

  return false;
}

/// getSwappedCondition - assume the flags are set by MI(a,b), return
/// the condition code if we modify the instructions such that flags are
/// set by MI(b,a).
inline static ARMCC::CondCodes getSwappedCondition(ARMCC::CondCodes CC) {
  switch (CC) {
  default: return ARMCC::AL;
  case ARMCC::EQ: return ARMCC::EQ;
  case ARMCC::NE: return ARMCC::NE;
  case ARMCC::HS: return ARMCC::LS;
  case ARMCC::LO: return ARMCC::HI;
  case ARMCC::HI: return ARMCC::LO;
  case ARMCC::LS: return ARMCC::HS;
  case ARMCC::GE: return ARMCC::LE;
  case ARMCC::LT: return ARMCC::GT;
  case ARMCC::GT: return ARMCC::LT;
  case ARMCC::LE: return ARMCC::GE;
  }
}

/// isRedundantFlagInstr - check whether the first instruction, whose only
/// purpose is to update flags, can be made redundant.
/// CMPrr can be made redundant by SUBrr if the operands are the same.
/// CMPri can be made redundant by SUBri if the operands are the same.
/// This function can be extended later on.
inline static bool isRedundantFlagInstr(MachineInstr *CmpI, unsigned SrcReg,
                                        unsigned SrcReg2, int ImmValue,
                                        MachineInstr *OI) {
  if ((CmpI->getOpcode() == ARM::CMPrr ||
       CmpI->getOpcode() == ARM::t2CMPrr) &&
      (OI->getOpcode() == ARM::SUBrr ||
       OI->getOpcode() == ARM::t2SUBrr) &&
      ((OI->getOperand(1).getReg() == SrcReg &&
        OI->getOperand(2).getReg() == SrcReg2) ||
       (OI->getOperand(1).getReg() == SrcReg2 &&
        OI->getOperand(2).getReg() == SrcReg)))
    return true;

  if ((CmpI->getOpcode() == ARM::CMPri ||
       CmpI->getOpcode() == ARM::t2CMPri) &&
      (OI->getOpcode() == ARM::SUBri ||
       OI->getOpcode() == ARM::t2SUBri) &&
      OI->getOperand(1).getReg() == SrcReg &&
      OI->getOperand(2).getImm() == ImmValue)
    return true;
  return false;
}

/// optimizeCompareInstr - Convert the instruction supplying the argument to the
/// comparison into one that sets the zero bit in the flags register;
/// Remove a redundant Compare instruction if an earlier instruction can set the
/// flags in the same way as Compare.
/// E.g. SUBrr(r1,r2) and CMPrr(r1,r2). We also handle the case where two
/// operands are swapped: SUBrr(r1,r2) and CMPrr(r2,r1), by updating the
/// condition code of instructions which use the flags.
bool ARMBaseInstrInfo::
optimizeCompareInstr(MachineInstr *CmpInstr, unsigned SrcReg, unsigned SrcReg2,
                     int CmpMask, int CmpValue,
                     const MachineRegisterInfo *MRI) const {
  // Get the unique definition of SrcReg.
  MachineInstr *MI = MRI->getUniqueVRegDef(SrcReg);
  if (!MI) return false;

  // Masked compares sometimes use the same register as the corresponding 'and'.
  if (CmpMask != ~0) {
    if (!isSuitableForMask(MI, SrcReg, CmpMask, false) || isPredicated(MI)) {
      MI = nullptr;
      for (MachineRegisterInfo::use_instr_iterator
           UI = MRI->use_instr_begin(SrcReg), UE = MRI->use_instr_end();
           UI != UE; ++UI) {
        if (UI->getParent() != CmpInstr->getParent()) continue;
        MachineInstr *PotentialAND = &*UI;
        if (!isSuitableForMask(PotentialAND, SrcReg, CmpMask, true) ||
            isPredicated(PotentialAND))
          continue;
        MI = PotentialAND;
        break;
      }
      if (!MI) return false;
    }
  }

  // Get ready to iterate backward from CmpInstr.
  MachineBasicBlock::iterator I = CmpInstr, E = MI,
                              B = CmpInstr->getParent()->begin();

  // Early exit if CmpInstr is at the beginning of the BB.
  if (I == B) return false;

  // There are two possible candidates which can be changed to set CPSR:
  // One is MI, the other is a SUB instruction.
  // For CMPrr(r1,r2), we are looking for SUB(r1,r2) or SUB(r2,r1).
  // For CMPri(r1, CmpValue), we are looking for SUBri(r1, CmpValue).
  MachineInstr *Sub = nullptr;
  if (SrcReg2 != 0)
    // MI is not a candidate for CMPrr.
    MI = nullptr;
  else if (MI->getParent() != CmpInstr->getParent() || CmpValue != 0) {
    // Conservatively refuse to convert an instruction which isn't in the same
    // BB as the comparison.
    // For CMPri w/ CmpValue != 0, a Sub may still be a candidate.
    // Thus we cannot return here.
    if (CmpInstr->getOpcode() == ARM::CMPri ||
       CmpInstr->getOpcode() == ARM::t2CMPri)
      MI = nullptr;
    else
      return false;
  }

  // Check that CPSR isn't set between the comparison instruction and the one we
  // want to change. At the same time, search for Sub.
  const TargetRegisterInfo *TRI = &getRegisterInfo();
  --I;
  for (; I != E; --I) {
    const MachineInstr &Instr = *I;

    if (Instr.modifiesRegister(ARM::CPSR, TRI) ||
        Instr.readsRegister(ARM::CPSR, TRI))
      // This instruction modifies or uses CPSR after the one we want to
      // change. We can't do this transformation.
      return false;

    // Check whether CmpInstr can be made redundant by the current instruction.
    if (isRedundantFlagInstr(CmpInstr, SrcReg, SrcReg2, CmpValue, &*I)) {
      Sub = &*I;
      break;
    }

    if (I == B)
      // The 'and' is below the comparison instruction.
      return false;
  }

  // Return false if no candidates exist.
  if (!MI && !Sub)
    return false;

  // The single candidate is called MI.
  if (!MI) MI = Sub;

  // We can't use a predicated instruction - it doesn't always write the flags.
  if (isPredicated(MI))
    return false;

  switch (MI->getOpcode()) {
  default: break;
  case ARM::RSBrr:
  case ARM::RSBri:
  case ARM::RSCrr:
  case ARM::RSCri:
  case ARM::ADDrr:
  case ARM::ADDri:
  case ARM::ADCrr:
  case ARM::ADCri:
  case ARM::SUBrr:
  case ARM::SUBri:
  case ARM::SBCrr:
  case ARM::SBCri:
  case ARM::t2RSBri:
  case ARM::t2ADDrr:
  case ARM::t2ADDri:
  case ARM::t2ADCrr:
  case ARM::t2ADCri:
  case ARM::t2SUBrr:
  case ARM::t2SUBri:
  case ARM::t2SBCrr:
  case ARM::t2SBCri:
  case ARM::ANDrr:
  case ARM::ANDri:
  case ARM::t2ANDrr:
  case ARM::t2ANDri:
  case ARM::ORRrr:
  case ARM::ORRri:
  case ARM::t2ORRrr:
  case ARM::t2ORRri:
  case ARM::EORrr:
  case ARM::EORri:
  case ARM::t2EORrr:
  case ARM::t2EORri: {
    // Scan forward for the use of CPSR
    // When checking against MI: if it's a conditional code that requires
    // checking of the V bit or C bit, then this is not safe to do.
    // It is safe to remove CmpInstr if CPSR is redefined or killed.
    // If we are done with the basic block, we need to check whether CPSR is
    // live-out.
    SmallVector<std::pair<MachineOperand*, ARMCC::CondCodes>, 4>
        OperandsToUpdate;
    bool isSafe = false;
    I = CmpInstr;
    E = CmpInstr->getParent()->end();
    while (!isSafe && ++I != E) {
      const MachineInstr &Instr = *I;
      for (unsigned IO = 0, EO = Instr.getNumOperands();
           !isSafe && IO != EO; ++IO) {
        const MachineOperand &MO = Instr.getOperand(IO);
        if (MO.isRegMask() && MO.clobbersPhysReg(ARM::CPSR)) {
          isSafe = true;
          break;
        }
        if (!MO.isReg() || MO.getReg() != ARM::CPSR)
          continue;
        if (MO.isDef()) {
          isSafe = true;
          break;
        }
        // Condition code is after the operand before CPSR except for VSELs.
        ARMCC::CondCodes CC;
        bool IsInstrVSel = true;
        switch (Instr.getOpcode()) {
        default:
          IsInstrVSel = false;
          CC = (ARMCC::CondCodes)Instr.getOperand(IO - 1).getImm();
          break;
        case ARM::VSELEQD:
        case ARM::VSELEQS:
          CC = ARMCC::EQ;
          break;
        case ARM::VSELGTD:
        case ARM::VSELGTS:
          CC = ARMCC::GT;
          break;
        case ARM::VSELGED:
        case ARM::VSELGES:
          CC = ARMCC::GE;
          break;
        case ARM::VSELVSS:
        case ARM::VSELVSD:
          CC = ARMCC::VS;
          break;
        }

        if (Sub) {
          ARMCC::CondCodes NewCC = getSwappedCondition(CC);
          if (NewCC == ARMCC::AL)
            return false;
          // If we have SUB(r1, r2) and CMP(r2, r1), the condition code based
          // on CMP needs to be updated to be based on SUB.
          // Push the condition code operands to OperandsToUpdate.
          // If it is safe to remove CmpInstr, the condition code of these
          // operands will be modified.
          if (SrcReg2 != 0 && Sub->getOperand(1).getReg() == SrcReg2 &&
              Sub->getOperand(2).getReg() == SrcReg) {
            // VSel doesn't support condition code update.
            if (IsInstrVSel)
              return false;
            OperandsToUpdate.push_back(
                std::make_pair(&((*I).getOperand(IO - 1)), NewCC));
          }
        } else {
          // No Sub, so this is x = <op> y, z; cmp x, 0.
          switch (CC) {
          case ARMCC::EQ: // Z
          case ARMCC::NE: // Z
          case ARMCC::MI: // N
          case ARMCC::PL: // N
          case ARMCC::AL: // none
            // CPSR can be used multiple times, we should continue.
            break;
          case ARMCC::HS: // C
          case ARMCC::LO: // C
          case ARMCC::VS: // V
          case ARMCC::VC: // V
          case ARMCC::HI: // C Z
          case ARMCC::LS: // C Z
          case ARMCC::GE: // N V
          case ARMCC::LT: // N V
          case ARMCC::GT: // Z N V
          case ARMCC::LE: // Z N V
            // The instruction uses the V bit or C bit which is not safe.
            return false;
          }
        }
      }
    }

    // If CPSR is not killed nor re-defined, we should check whether it is
    // live-out. If it is live-out, do not optimize.
    if (!isSafe) {
      MachineBasicBlock *MBB = CmpInstr->getParent();
      for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
               SE = MBB->succ_end(); SI != SE; ++SI)
        if ((*SI)->isLiveIn(ARM::CPSR))
          return false;
    }

    // Toggle the optional operand to CPSR.
    MI->getOperand(5).setReg(ARM::CPSR);
    MI->getOperand(5).setIsDef(true);
    assert(!isPredicated(MI) && ""Can't use flags from predicated instruction"");
    CmpInstr->eraseFromParent();

    // Modify the condition code of operands in OperandsToUpdate.
    // Since we have SUB(r1, r2) and CMP(r2, r1), the condition code needs to
    // be changed from r2 > r1 to r1 < r2, from r2 < r1 to r1 > r2, etc.
    for (unsigned i = 0, e = OperandsToUpdate.size(); i < e; i++)
      OperandsToUpdate[i].first->setImm(OperandsToUpdate[i].second);
    return true;
  }
  }

  return false;
}

bool ARMBaseInstrInfo::FoldImmediate(MachineInstr *UseMI,
                                     MachineInstr *DefMI, unsigned Reg,
                                     MachineRegisterInfo *MRI) const {
  // Fold large immediates into add, sub, or, xor.
  unsigned DefOpc = DefMI->getOpcode();
  if (DefOpc != ARM::t2MOVi32imm && DefOpc != ARM::MOVi32imm)
    return false;
  if (!DefMI->getOperand(1).isImm())
    // Could be t2MOVi32imm <ga:xx>
    return false;

  if (!MRI->hasOneNonDBGUse(Reg))
    return false;

  const MCInstrDesc &DefMCID = DefMI->getDesc();
  if (DefMCID.hasOptionalDef()) {
    unsigned NumOps = DefMCID.getNumOperands();
    const MachineOperand &MO = DefMI->getOperand(NumOps-1);
    if (MO.getReg() == ARM::CPSR && !MO.isDead())
      // If DefMI defines CPSR and it is not dead, it's obviously not safe
      // to delete DefMI.
      return false;
  }

  const MCInstrDesc &UseMCID = UseMI->getDesc();
  if (UseMCID.hasOptionalDef()) {
    unsigned NumOps = UseMCID.getNumOperands();
    if (UseMI->getOperand(NumOps-1).getReg() == ARM::CPSR)
      // If the instruction sets the flag, do not attempt this optimization
      // since it may change the semantics of the code.
      return false;
  }

  unsigned UseOpc = UseMI->getOpcode();
  unsigned NewUseOpc = 0;
  uint32_t ImmVal = (uint32_t)DefMI->getOperand(1).getImm();
  uint32_t SOImmValV1 = 0, SOImmValV2 = 0;
  bool Commute = false;
  switch (UseOpc) {
  default: return false;
  case ARM::SUBrr:
  case ARM::ADDrr:
  case ARM::ORRrr:
  case ARM::EORrr:
  case ARM::t2SUBrr:
  case ARM::t2ADDrr:
  case ARM::t2ORRrr:
  case ARM::t2EORrr: {
    Commute = UseMI->getOperand(2).getReg() != Reg;
    switch (UseOpc) {
    default: break;
    case ARM::SUBrr: {
      if (Commute)
        return false;
      ImmVal = -ImmVal;
      NewUseOpc = ARM::SUBri;
      // Fallthrough
    }
    case ARM::ADDrr:
    case ARM::ORRrr:
    case ARM::EORrr: {
      if (!ARM_AM::isSOImmTwoPartVal(ImmVal))
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getSOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getSOImmTwoPartSecond(ImmVal);
      switch (UseOpc) {
      default: break;
      case ARM::ADDrr: NewUseOpc = ARM::ADDri; break;
      case ARM::ORRrr: NewUseOpc = ARM::ORRri; break;
      case ARM::EORrr: NewUseOpc = ARM::EORri; break;
      }
      break;
    }
    case ARM::t2SUBrr: {
      if (Commute)
        return false;
      ImmVal = -ImmVal;
      NewUseOpc = ARM::t2SUBri;
      // Fallthrough
    }
    case ARM::t2ADDrr:
    case ARM::t2ORRrr:
    case ARM::t2EORrr: {
      if (!ARM_AM::isT2SOImmTwoPartVal(ImmVal))
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getT2SOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getT2SOImmTwoPartSecond(ImmVal);
      switch (UseOpc) {
      default: break;
      case ARM::t2ADDrr: NewUseOpc = ARM::t2ADDri; break;
      case ARM::t2ORRrr: NewUseOpc = ARM::t2ORRri; break;
      case ARM::t2EORrr: NewUseOpc = ARM::t2EORri; break;
      }
      break;
    }
    }
  }
  }

  unsigned OpIdx = Commute ? 2 : 1;
  unsigned Reg1 = UseMI->getOperand(OpIdx).getReg();
  bool isKill = UseMI->getOperand(OpIdx).isKill();
  unsigned NewReg = MRI->createVirtualRegister(MRI->getRegClass(Reg));
  AddDefaultCC(AddDefaultPred(BuildMI(*UseMI->getParent(),
                                      UseMI, UseMI->getDebugLoc(),
                                      get(NewUseOpc), NewReg)
                              .addReg(Reg1, getKillRegState(isKill))
                              .addImm(SOImmValV1)));
  UseMI->setDesc(get(NewUseOpc));
  UseMI->getOperand(1).setReg(NewReg);
  UseMI->getOperand(1).setIsKill();
  UseMI->getOperand(2).ChangeToImmediate(SOImmValV2);
  DefMI->eraseFromParent();
  return true;
}

static unsigned getNumMicroOpsSwiftLdSt(const InstrItineraryData *ItinData,
                                        const MachineInstr *MI) {
  switch (MI->getOpcode()) {
  default: {
    const MCInstrDesc &Desc = MI->getDesc();
    int UOps = ItinData->getNumMicroOps(Desc.getSchedClass());
    assert(UOps >= 0 && ""bad # UOps"");
    return UOps;
  }

  case ARM::LDRrs:
  case ARM::LDRBrs:
  case ARM::STRrs:
  case ARM::STRBrs: {
    unsigned ShOpVal = MI->getOperand(3).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 1;
    return 2;
  }

  case ARM::LDRH:
  case ARM::STRH: {
    if (!MI->getOperand(2).getReg())
      return 1;

    unsigned ShOpVal = MI->getOperand(3).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 1;
    return 2;
  }

  case ARM::LDRSB:
  case ARM::LDRSH:
    return (ARM_AM::getAM3Op(MI->getOperand(3).getImm()) == ARM_AM::sub) ? 3:2;

  case ARM::LDRSB_POST:
  case ARM::LDRSH_POST: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    return (Rt == Rm) ? 4 : 3;
  }

  case ARM::LDR_PRE_REG:
  case ARM::LDRB_PRE_REG: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rt == Rm)
      return 3;
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 2;
    return 3;
  }

  case ARM::STR_PRE_REG:
  case ARM::STRB_PRE_REG: {
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 2;
    return 3;
  }

  case ARM::LDRH_PRE:
  case ARM::STRH_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (!Rm)
      return 2;
    if (Rt == Rm)
      return 3;
    return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub)
      ? 3 : 2;
  }

  case ARM::LDR_POST_REG:
  case ARM::LDRB_POST_REG:
  case ARM::LDRH_POST: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    return (Rt == Rm) ? 3 : 2;
  }

  case ARM::LDR_PRE_IMM:
  case ARM::LDRB_PRE_IMM:
  case ARM::LDR_POST_IMM:
  case ARM::LDRB_POST_IMM:
  case ARM::STRB_POST_IMM:
  case ARM::STRB_POST_REG:
  case ARM::STRB_PRE_IMM:
  case ARM::STRH_POST:
  case ARM::STR_POST_IMM:
  case ARM::STR_POST_REG:
  case ARM::STR_PRE_IMM:
    return 2;

  case ARM::LDRSB_PRE:
  case ARM::LDRSH_PRE: {
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm == 0)
      return 3;
    unsigned Rt = MI->getOperand(0).getReg();
    if (Rt == Rm)
      return 4;
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 3;
    return 4;
  }

  case ARM::LDRD: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(2).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub) ?4:3;
    return (Rt == Rn) ? 3 : 2;
  }

  case ARM::STRD: {
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub) ?4:3;
    return 2;
  }

  case ARM::LDRD_POST:
  case ARM::t2LDRD_POST:
    return 3;

  case ARM::STRD_POST:
  case ARM::t2STRD_POST:
    return 4;

  case ARM::LDRD_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(3).getReg();
    unsigned Rm = MI->getOperand(4).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(5).getImm()) == ARM_AM::sub) ?5:4;
    return (Rt == Rn) ? 4 : 3;
  }

  case ARM::t2LDRD_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(3).getReg();
    return (Rt == Rn) ? 4 : 3;
  }

  case ARM::STRD_PRE: {
    unsigned Rm = MI->getOperand(4).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(5).getImm()) == ARM_AM::sub) ?5:4;
    return 3;
  }

  case ARM::t2STRD_PRE:
    return 3;

  case ARM::t2LDR_POST:
  case ARM::t2LDRB_POST:
  case ARM::t2LDRB_PRE:
  case ARM::t2LDRSBi12:
  case ARM::t2LDRSBi8:
  case ARM::t2LDRSBpci:
  case ARM::t2LDRSBs:
  case ARM::t2LDRH_POST:
  case ARM::t2LDRH_PRE:
  case ARM::t2LDRSBT:
  case ARM::t2LDRSB_POST:
  case ARM::t2LDRSB_PRE:
  case ARM::t2LDRSH_POST:
  case ARM::t2LDRSH_PRE:
  case ARM::t2LDRSHi12:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRSHpci:
  case ARM::t2LDRSHs:
    return 2;

  case ARM::t2LDRDi8: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(2).getReg();
    return (Rt == Rn) ? 3 : 2;
  }

  case ARM::t2STRB_POST:
  case ARM::t2STRB_PRE:
  case ARM::t2STRBs:
  case ARM::t2STRDi8:
  case ARM::t2STRH_POST:
  case ARM::t2STRH_PRE:
  case ARM::t2STRHs:
  case ARM::t2STR_POST:
  case ARM::t2STR_PRE:
  case ARM::t2STRs:
    return 2;
  }
}

// Return the number of 32-bit words loaded by LDM or stored by STM. If this
// can't be easily determined return 0 (missing MachineMemOperand).
//
// FIXME: The current MachineInstr design does not support relying on machine
// mem operands to determine the width of a memory access. Instead, we expect
// the target to provide this information based on the instruction opcode and
// operands. However, using MachineMemOperand is the best solution now for
// two reasons:
//
// 1) getNumMicroOps tries to infer LDM memory width from the total number of MI
// operands. This is much more dangerous than using the MachineMemOperand
// sizes because CodeGen passes can insert/remove optional machine operands. In
// fact, it's totally incorrect for preRA passes and appears to be wrong for
// postRA passes as well.
//
// 2) getNumLDMAddresses is only used by the scheduling machine model and any
// machine model that calls this should handle the unknown (zero size) case.
//
// Long term, we should require a target hook that verifies MachineMemOperand
// sizes during MC lowering. That target hook should be local to MC lowering
// because we can't ensure that it is aware of other MI forms. Doing this will
// ensure that MachineMemOperands are correctly propagated through all passes.
unsigned ARMBaseInstrInfo::getNumLDMAddresses(const MachineInstr *MI) const {
  unsigned Size = 0;
  for (MachineInstr::mmo_iterator I = MI->memoperands_begin(),
         E = MI->memoperands_end(); I != E; ++I) {
    Size += (*I)->getSize();
  }
  return Size / 4;
}

unsigned
ARMBaseInstrInfo::getNumMicroOps(const InstrItineraryData *ItinData,
                                 const MachineInstr *MI) const {
  if (!ItinData || ItinData->isEmpty())
    return 1;

  const MCInstrDesc &Desc = MI->getDesc();
  unsigned Class = Desc.getSchedClass();
  int ItinUOps = ItinData->getNumMicroOps(Class);
  if (ItinUOps >= 0) {
    if (Subtarget.isSwift() && (Desc.mayLoad() || Desc.mayStore()))
      return getNumMicroOpsSwiftLdSt(ItinData, MI);

    return ItinUOps;
  }

  unsigned Opc = MI->getOpcode();
  switch (Opc) {
  default:
    llvm_unreachable(""Unexpected multi-uops instruction!"");
  case ARM::VLDMQIA:
  case ARM::VSTMQIA:
    return 2;

  // The number of uOps for load / store multiple are determined by the number
  // registers.
  //
  // On Cortex-A8, each pair of register loads / stores can be scheduled on the
  // same cycle. The scheduling for the first load / store must be done
  // separately by assuming the address is not 64-bit aligned.
  //
  // On Cortex-A9, the formula is simply (#reg / 2) + (#reg % 2). If the address
  // is not 64-bit aligned, then AGU would take an extra cycle.  For VFP / NEON
  // load / store multiple, the formula is (#reg / 2) + (#reg % 2) + 1.
  case ARM::VLDMDIA:
  case ARM::VLDMDIA_UPD:
  case ARM::VLDMDDB_UPD:
  case ARM::VLDMSIA:
  case ARM::VLDMSIA_UPD:
  case ARM::VLDMSDB_UPD:
  case ARM::VSTMDIA:
  case ARM::VSTMDIA_UPD:
  case ARM::VSTMDDB_UPD:
  case ARM::VSTMSIA:
  case ARM::VSTMSIA_UPD:
  case ARM::VSTMSDB_UPD: {
    unsigned NumRegs = MI->getNumOperands() - Desc.getNumOperands();
    return (NumRegs / 2) + (NumRegs % 2) + 1;
  }

  case ARM::LDMIA_RET:
  case ARM::LDMIA:
  case ARM::LDMDA:
  case ARM::LDMDB:
  case ARM::LDMIB:
  case ARM::LDMIA_UPD:
  case ARM::LDMDA_UPD:
  case ARM::LDMDB_UPD:
  case ARM::LDMIB_UPD:
  case ARM::STMIA:
  case ARM::STMDA:
  case ARM::STMDB:
  case ARM::STMIB:
  case ARM::STMIA_UPD:
  case ARM::STMDA_UPD:
  case ARM::STMDB_UPD:
  case ARM::STMIB_UPD:
  case ARM::tLDMIA:
  case ARM::tLDMIA_UPD:
  case ARM::tSTMIA_UPD:
  case ARM::tPOP_RET:
  case ARM::tPOP:
  case ARM::tPUSH:
  case ARM::t2LDMIA_RET:
  case ARM::t2LDMIA:
  case ARM::t2LDMDB:
  case ARM::t2LDMIA_UPD:
  case ARM::t2LDMDB_UPD:
  case ARM::t2STMIA:
  case ARM::t2STMDB:
  case ARM::t2STMIA_UPD:
  case ARM::t2STMDB_UPD: {
    unsigned NumRegs = MI->getNumOperands() - Desc.getNumOperands() + 1;
    if (Subtarget.isSwift()) {
      int UOps = 1 + NumRegs;  // One for address computation, one for each ld / st.
      switch (Opc) {
      default: break;
      case ARM::VLDMDIA_UPD:
      case ARM::VLDMDDB_UPD:
      case ARM::VLDMSIA_UPD:
      case ARM::VLDMSDB_UPD:
      case ARM::VSTMDIA_UPD:
      case ARM::VSTMDDB_UPD:
      case ARM::VSTMSIA_UPD:
      case ARM::VSTMSDB_UPD:
      case ARM::LDMIA_UPD:
      case ARM::LDMDA_UPD:
      case ARM::LDMDB_UPD:
      case ARM::LDMIB_UPD:
      case ARM::STMIA_UPD:
      case ARM::STMDA_UPD:
      case ARM::STMDB_UPD:
      case ARM::STMIB_UPD:
      case ARM::tLDMIA_UPD:
      case ARM::tSTMIA_UPD:
      case ARM::t2LDMIA_UPD:
      case ARM::t2LDMDB_UPD:
      case ARM::t2STMIA_UPD:
      case ARM::t2STMDB_UPD:
        ++UOps; // One for base register writeback.
        break;
      case ARM::LDMIA_RET:
      case ARM::tPOP_RET:
      case ARM::t2LDMIA_RET:
        UOps += 2; // One for base reg wb, one for write to pc.
        break;
      }
      return UOps;
    } else if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
      if (NumRegs < 4)
        return 2;
      // 4 registers would be issued: 2, 2.
      // 5 registers would be issued: 2, 2, 1.
      int A8UOps = (NumRegs / 2);
      if (NumRegs % 2)
        ++A8UOps;
      return A8UOps;
    } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
      int A9UOps = (NumRegs / 2);
      // If there are odd number of registers or if it's not 64-bit aligned,
      // then it takes an extra AGU (Address Generation Unit) cycle.
      if ((NumRegs % 2) ||
          !MI->hasOneMemOperand() ||
          (*MI->memoperands_begin())->getAlignment() < 8)
        ++A9UOps;
      return A9UOps;
    } else {
      // Assume the worst.
      return NumRegs;
    }
  }
  }
}

int
ARMBaseInstrInfo::getVLDMDefCycle(const InstrItineraryData *ItinData,
                                  const MCInstrDesc &DefMCID,
                                  unsigned DefClass,
                                  unsigned DefIdx, unsigned DefAlign) const {
  int RegNo = (int)(DefIdx+1) - DefMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    // Def is the address writeback.
    return ItinData->getOperandCycle(DefClass, DefIdx);

  int DefCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // (regno / 2) + (regno % 2) + 1
    DefCycle = RegNo / 2 + 1;
    if (RegNo % 2)
      ++DefCycle;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    DefCycle = RegNo;
    bool isSLoad = false;

    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::VLDMSIA:
    case ARM::VLDMSIA_UPD:
    case ARM::VLDMSDB_UPD:
      isSLoad = true;
      break;
    }

    // If there are odd number of 'S' registers or if it's not 64-bit aligned,
    // then it takes an extra cycle.
    if ((isSLoad && (RegNo % 2)) || DefAlign < 8)
      ++DefCycle;
  } else {
    // Assume the worst.
    DefCycle = RegNo + 2;
  }

  return DefCycle;
}

int
ARMBaseInstrInfo::getLDMDefCycle(const InstrItineraryData *ItinData,
                                 const MCInstrDesc &DefMCID,
                                 unsigned DefClass,
                                 unsigned DefIdx, unsigned DefAlign) const {
  int RegNo = (int)(DefIdx+1) - DefMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    // Def is the address writeback.
    return ItinData->getOperandCycle(DefClass, DefIdx);

  int DefCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // 4 registers would be issued: 1, 2, 1.
    // 5 registers would be issued: 1, 2, 2.
    DefCycle = RegNo / 2;
    if (DefCycle < 1)
      DefCycle = 1;
    // Result latency is issue cycle + 2: E2.
    DefCycle += 2;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    DefCycle = (RegNo / 2);
    // If there are odd number of registers or if it's not 64-bit aligned,
    // then it takes an extra AGU (Address Generation Unit) cycle.
    if ((RegNo % 2) || DefAlign < 8)
      ++DefCycle;
    // Result latency is AGU cycles + 2.
    DefCycle += 2;
  } else {
    // Assume the worst.
    DefCycle = RegNo + 2;
  }

  return DefCycle;
}

int
ARMBaseInstrInfo::getVSTMUseCycle(const InstrItineraryData *ItinData,
                                  const MCInstrDesc &UseMCID,
                                  unsigned UseClass,
                                  unsigned UseIdx, unsigned UseAlign) const {
  int RegNo = (int)(UseIdx+1) - UseMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    return ItinData->getOperandCycle(UseClass, UseIdx);

  int UseCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // (regno / 2) + (regno % 2) + 1
    UseCycle = RegNo / 2 + 1;
    if (RegNo % 2)
      ++UseCycle;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    UseCycle = RegNo;
    bool isSStore = false;

    switch (UseMCID.getOpcode()) {
    default: break;
    case ARM::VSTMSIA:
    case ARM::VSTMSIA_UPD:
    case ARM::VSTMSDB_UPD:
      isSStore = true;
      break;
    }

    // If there are odd number of 'S' registers or if it's not 64-bit aligned,
    // then it takes an extra cycle.
    if ((isSStore && (RegNo % 2)) || UseAlign < 8)
      ++UseCycle;
  } else {
    // Assume the worst.
    UseCycle = RegNo + 2;
  }

  return UseCycle;
}

int
ARMBaseInstrInfo::getSTMUseCycle(const InstrItineraryData *ItinData,
                                 const MCInstrDesc &UseMCID,
                                 unsigned UseClass,
                                 unsigned UseIdx, unsigned UseAlign) const {
  int RegNo = (int)(UseIdx+1) - UseMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    return ItinData->getOperandCycle(UseClass, UseIdx);

  int UseCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    UseCycle = RegNo / 2;
    if (UseCycle < 2)
      UseCycle = 2;
    // Read in E3.
    UseCycle += 2;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    UseCycle = (RegNo / 2);
    // If there are odd number of registers or if it's not 64-bit aligned,
    // then it takes an extra AGU (Address Generation Unit) cycle.
    if ((RegNo % 2) || UseAlign < 8)
      ++UseCycle;
  } else {
    // Assume the worst.
    UseCycle = 1;
  }
  return UseCycle;
}

int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    const MCInstrDesc &DefMCID,
                                    unsigned DefIdx, unsigned DefAlign,
                                    const MCInstrDesc &UseMCID,
                                    unsigned UseIdx, unsigned UseAlign) const {
  unsigned DefClass = DefMCID.getSchedClass();
  unsigned UseClass = UseMCID.getSchedClass();

  if (DefIdx < DefMCID.getNumDefs() && UseIdx < UseMCID.getNumOperands())
    return ItinData->getOperandLatency(DefClass, DefIdx, UseClass, UseIdx);

  // This may be a def / use of a variable_ops instruction, the operand
  // latency might be determinable dynamically. Let the target try to
  // figure it out.
  int DefCycle = -1;
  bool LdmBypass = false;
  switch (DefMCID.getOpcode()) {
  default:
    DefCycle = ItinData->getOperandCycle(DefClass, DefIdx);
    break;

  case ARM::VLDMDIA:
  case ARM::VLDMDIA_UPD:
  case ARM::VLDMDDB_UPD:
  case ARM::VLDMSIA:
  case ARM::VLDMSIA_UPD:
  case ARM::VLDMSDB_UPD:
    DefCycle = getVLDMDefCycle(ItinData, DefMCID, DefClass, DefIdx, DefAlign);
    break;

  case ARM::LDMIA_RET:
  case ARM::LDMIA:
  case ARM::LDMDA:
  case ARM::LDMDB:
  case ARM::LDMIB:
  case ARM::LDMIA_UPD:
  case ARM::LDMDA_UPD:
  case ARM::LDMDB_UPD:
  case ARM::LDMIB_UPD:
  case ARM::tLDMIA:
  case ARM::tLDMIA_UPD:
  case ARM::tPUSH:
  case ARM::t2LDMIA_RET:
  case ARM::t2LDMIA:
  case ARM::t2LDMDB:
  case ARM::t2LDMIA_UPD:
  case ARM::t2LDMDB_UPD:
    LdmBypass = 1;
    DefCycle = getLDMDefCycle(ItinData, DefMCID, DefClass, DefIdx, DefAlign);
    break;
  }

  if (DefCycle == -1)
    // We can't seem to determine the result latency of the def, assume it's 2.
    DefCycle = 2;

  int UseCycle = -1;
  switch (UseMCID.getOpcode()) {
  default:
    UseCycle = ItinData->getOperandCycle(UseClass, UseIdx);
    break;

  case ARM::VSTMDIA:
  case ARM::VSTMDIA_UPD:
  case ARM::VSTMDDB_UPD:
  case ARM::VSTMSIA:
  case ARM::VSTMSIA_UPD:
  case ARM::VSTMSDB_UPD:
    UseCycle = getVSTMUseCycle(ItinData, UseMCID, UseClass, UseIdx, UseAlign);
    break;

  case ARM::STMIA:
  case ARM::STMDA:
  case ARM::STMDB:
  case ARM::STMIB:
  case ARM::STMIA_UPD:
  case ARM::STMDA_UPD:
  case ARM::STMDB_UPD:
  case ARM::STMIB_UPD:
  case ARM::tSTMIA_UPD:
  case ARM::tPOP_RET:
  case ARM::tPOP:
  case ARM::t2STMIA:
  case ARM::t2STMDB:
  case ARM::t2STMIA_UPD:
  case ARM::t2STMDB_UPD:
    UseCycle = getSTMUseCycle(ItinData, UseMCID, UseClass, UseIdx, UseAlign);
    break;
  }

  if (UseCycle == -1)
    // Assume it's read in the first stage.
    UseCycle = 1;

  UseCycle = DefCycle - UseCycle + 1;
  if (UseCycle > 0) {
    if (LdmBypass) {
      // It's a variable_ops instruction so we can't use DefIdx here. Just use
      // first def operand.
      if (ItinData->hasPipelineForwarding(DefClass, DefMCID.getNumOperands()-1,
                                          UseClass, UseIdx))
        --UseCycle;
    } else if (ItinData->hasPipelineForwarding(DefClass, DefIdx,
                                               UseClass, UseIdx)) {
      --UseCycle;
    }
  }

  return UseCycle;
}

static const MachineInstr *getBundledDefMI(const TargetRegisterInfo *TRI,
                                           const MachineInstr *MI, unsigned Reg,
                                           unsigned &DefIdx, unsigned &Dist) {
  Dist = 0;

  MachineBasicBlock::const_iterator I = MI; ++I;
  MachineBasicBlock::const_instr_iterator II = std::prev(I.getInstrIterator());
  assert(II->isInsideBundle() && ""Empty bundle?"");

  int Idx = -1;
  while (II->isInsideBundle()) {
    Idx = II->findRegisterDefOperandIdx(Reg, false, true, TRI);
    if (Idx != -1)
      break;
    --II;
    ++Dist;
  }

  assert(Idx != -1 && ""Cannot find bundled definition!"");
  DefIdx = Idx;
  return II;
}

static const MachineInstr *getBundledUseMI(const TargetRegisterInfo *TRI,
                                           const MachineInstr *MI, unsigned Reg,
                                           unsigned &UseIdx, unsigned &Dist) {
  Dist = 0;

  MachineBasicBlock::const_instr_iterator II = MI; ++II;
  assert(II->isInsideBundle() && ""Empty bundle?"");
  MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();

  // FIXME: This doesn't properly handle multiple uses.
  int Idx = -1;
  while (II != E && II->isInsideBundle()) {
    Idx = II->findRegisterUseOperandIdx(Reg, false, TRI);
    if (Idx != -1)
      break;
    if (II->getOpcode() != ARM::t2IT)
      ++Dist;
    ++II;
  }

  if (Idx == -1) {
    Dist = 0;
    return nullptr;
  }

  UseIdx = Idx;
  return II;
}

/// Return the number of cycles to add to (or subtract from) the static
/// itinerary based on the def opcode and alignment. The caller will ensure that
/// adjusted latency is at least one cycle.
static int adjustDefLatency(const ARMSubtarget &Subtarget,
                            const MachineInstr *DefMI,
                            const MCInstrDesc *DefMCID, unsigned DefAlign) {
  int Adjust = 0;
  if (Subtarget.isCortexA8() || Subtarget.isLikeA9() || Subtarget.isCortexA7()) {
    // FIXME: Shifter op hack: no shift (i.e. [r +/- r]) or [r + r << 2]
    // variants are one cycle cheaper.
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal = DefMI->getOperand(3).getImm();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          (ShImm == 2 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        --Adjust;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt = DefMI->getOperand(3).getImm();
      if (ShAmt == 0 || ShAmt == 2)
        --Adjust;
      break;
    }
    }
  } else if (Subtarget.isSwift()) {
    // FIXME: Properly handle all of the latency adjustments for address
    // writeback.
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal = DefMI->getOperand(3).getImm();
      bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (!isSub &&
          (ShImm == 0 ||
           ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
            ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
        Adjust -= 2;
      else if (!isSub &&
               ShImm == 1 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsr)
        --Adjust;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt = DefMI->getOperand(3).getImm();
      if (ShAmt == 0 || ShAmt == 1 || ShAmt == 2 || ShAmt == 3)
        Adjust -= 2;
      break;
    }
    }
  }

  if (DefAlign < 8 && Subtarget.isLikeA9()) {
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::VLD1q8:
    case ARM::VLD1q16:
    case ARM::VLD1q32:
    case ARM::VLD1q64:
    case ARM::VLD1q8wb_fixed:
    case ARM::VLD1q16wb_fixed:
    case ARM::VLD1q32wb_fixed:
    case ARM::VLD1q64wb_fixed:
    case ARM::VLD1q8wb_register:
    case ARM::VLD1q16wb_register:
    case ARM::VLD1q32wb_register:
    case ARM::VLD1q64wb_register:
    case ARM::VLD2d8:
    case ARM::VLD2d16:
    case ARM::VLD2d32:
    case ARM::VLD2q8:
    case ARM::VLD2q16:
    case ARM::VLD2q32:
    case ARM::VLD2d8wb_fixed:
    case ARM::VLD2d16wb_fixed:
    case ARM::VLD2d32wb_fixed:
    case ARM::VLD2q8wb_fixed:
    case ARM::VLD2q16wb_fixed:
    case ARM::VLD2q32wb_fixed:
    case ARM::VLD2d8wb_register:
    case ARM::VLD2d16wb_register:
    case ARM::VLD2d32wb_register:
    case ARM::VLD2q8wb_register:
    case ARM::VLD2q16wb_register:
    case ARM::VLD2q32wb_register:
    case ARM::VLD3d8:
    case ARM::VLD3d16:
    case ARM::VLD3d32:
    case ARM::VLD1d64T:
    case ARM::VLD3d8_UPD:
    case ARM::VLD3d16_UPD:
    case ARM::VLD3d32_UPD:
    case ARM::VLD1d64Twb_fixed:
    case ARM::VLD1d64Twb_register:
    case ARM::VLD3q8_UPD:
    case ARM::VLD3q16_UPD:
    case ARM::VLD3q32_UPD:
    case ARM::VLD4d8:
    case ARM::VLD4d16:
    case ARM::VLD4d32:
    case ARM::VLD1d64Q:
    case ARM::VLD4d8_UPD:
    case ARM::VLD4d16_UPD:
    case ARM::VLD4d32_UPD:
    case ARM::VLD1d64Qwb_fixed:
    case ARM::VLD1d64Qwb_register:
    case ARM::VLD4q8_UPD:
    case ARM::VLD4q16_UPD:
    case ARM::VLD4q32_UPD:
    case ARM::VLD1DUPq8:
    case ARM::VLD1DUPq16:
    case ARM::VLD1DUPq32:
    case ARM::VLD1DUPq8wb_fixed:
    case ARM::VLD1DUPq16wb_fixed:
    case ARM::VLD1DUPq32wb_fixed:
    case ARM::VLD1DUPq8wb_register:
    case ARM::VLD1DUPq16wb_register:
    case ARM::VLD1DUPq32wb_register:
    case ARM::VLD2DUPd8:
    case ARM::VLD2DUPd16:
    case ARM::VLD2DUPd32:
    case ARM::VLD2DUPd8wb_fixed:
    case ARM::VLD2DUPd16wb_fixed:
    case ARM::VLD2DUPd32wb_fixed:
    case ARM::VLD2DUPd8wb_register:
    case ARM::VLD2DUPd16wb_register:
    case ARM::VLD2DUPd32wb_register:
    case ARM::VLD4DUPd8:
    case ARM::VLD4DUPd16:
    case ARM::VLD4DUPd32:
    case ARM::VLD4DUPd8_UPD:
    case ARM::VLD4DUPd16_UPD:
    case ARM::VLD4DUPd32_UPD:
    case ARM::VLD1LNd8:
    case ARM::VLD1LNd16:
    case ARM::VLD1LNd32:
    case ARM::VLD1LNd8_UPD:
    case ARM::VLD1LNd16_UPD:
    case ARM::VLD1LNd32_UPD:
    case ARM::VLD2LNd8:
    case ARM::VLD2LNd16:
    case ARM::VLD2LNd32:
    case ARM::VLD2LNq16:
    case ARM::VLD2LNq32:
    case ARM::VLD2LNd8_UPD:
    case ARM::VLD2LNd16_UPD:
    case ARM::VLD2LNd32_UPD:
    case ARM::VLD2LNq16_UPD:
    case ARM::VLD2LNq32_UPD:
    case ARM::VLD4LNd8:
    case ARM::VLD4LNd16:
    case ARM::VLD4LNd32:
    case ARM::VLD4LNq16:
    case ARM::VLD4LNq32:
    case ARM::VLD4LNd8_UPD:
    case ARM::VLD4LNd16_UPD:
    case ARM::VLD4LNd32_UPD:
    case ARM::VLD4LNq16_UPD:
    case ARM::VLD4LNq32_UPD:
      // If the address is not 64-bit aligned, the latencies of these
      // instructions increases by one.
      ++Adjust;
      break;
    }
  }
  return Adjust;
}



int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    const MachineInstr *DefMI, unsigned DefIdx,
                                    const MachineInstr *UseMI,
                                    unsigned UseIdx) const {
  // No operand latency. The caller may fall back to getInstrLatency.
  if (!ItinData || ItinData->isEmpty())
    return -1;

  const MachineOperand &DefMO = DefMI->getOperand(DefIdx);
  unsigned Reg = DefMO.getReg();
  const MCInstrDesc *DefMCID = &DefMI->getDesc();
  const MCInstrDesc *UseMCID = &UseMI->getDesc();

  unsigned DefAdj = 0;
  if (DefMI->isBundle()) {
    DefMI = getBundledDefMI(&getRegisterInfo(), DefMI, Reg, DefIdx, DefAdj);
    DefMCID = &DefMI->getDesc();
  }
  if (DefMI->isCopyLike() || DefMI->isInsertSubreg() ||
      DefMI->isRegSequence() || DefMI->isImplicitDef()) {
    return 1;
  }

  unsigned UseAdj = 0;
  if (UseMI->isBundle()) {
    unsigned NewUseIdx;
    const MachineInstr *NewUseMI = getBundledUseMI(&getRegisterInfo(), UseMI,
                                                   Reg, NewUseIdx, UseAdj);
    if (!NewUseMI)
      return -1;

    UseMI = NewUseMI;
    UseIdx = NewUseIdx;
    UseMCID = &UseMI->getDesc();
  }

  if (Reg == ARM::CPSR) {
    if (DefMI->getOpcode() == ARM::FMSTAT) {
      // fpscr -> cpsr stalls over 20 cycles on A8 (and earlier?)
      return Subtarget.isLikeA9() ? 1 : 20;
    }

    // CPSR set and branch can be paired in the same cycle.
    if (UseMI->isBranch())
      return 0;

    // Otherwise it takes the instruction latency (generally one).
    unsigned Latency = getInstrLatency(ItinData, DefMI);

    // For Thumb2 and -Os, prefer scheduling CPSR setting instruction close to
    // its uses. Instructions which are otherwise scheduled between them may
    // incur a code size penalty (not able to use the CPSR setting 16-bit
    // instructions).
    if (Latency > 0 && Subtarget.isThumb2()) {
      const MachineFunction *MF = DefMI->getParent()->getParent();
      if (MF->getFunction()->hasFnAttribute(Attribute::OptimizeForSize))
        --Latency;
    }
    return Latency;
  }

  if (DefMO.isImplicit() || UseMI->getOperand(UseIdx).isImplicit())
    return -1;

  unsigned DefAlign = DefMI->hasOneMemOperand()
    ? (*DefMI->memoperands_begin())->getAlignment() : 0;
  unsigned UseAlign = UseMI->hasOneMemOperand()
    ? (*UseMI->memoperands_begin())->getAlignment() : 0;

  // Get the itinerary's latency if possible, and handle variable_ops.
  int Latency = getOperandLatency(ItinData, *DefMCID, DefIdx, DefAlign,
                                  *UseMCID, UseIdx, UseAlign);
  // Unable to find operand latency. The caller may resort to getInstrLatency.
  if (Latency < 0)
    return Latency;

  // Adjust for IT block position.
  int Adj = DefAdj + UseAdj;

  // Adjust for dynamic def-side opcode variants not captured by the itinerary.
  Adj += adjustDefLatency(Subtarget, DefMI, DefMCID, DefAlign);
  if (Adj >= 0 || (int)Latency > -Adj) {
    return Latency + Adj;
  }
  // Return the itinerary latency, which may be zero but not less than zero.
  return Latency;
}

int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    SDNode *DefNode, unsigned DefIdx,
                                    SDNode *UseNode, unsigned UseIdx) const {
  if (!DefNode->isMachineOpcode())
    return 1;

  const MCInstrDesc &DefMCID = get(DefNode->getMachineOpcode());

  if (isZeroCost(DefMCID.Opcode))
    return 0;

  if (!ItinData || ItinData->isEmpty())
    return DefMCID.mayLoad() ? 3 : 1;

  if (!UseNode->isMachineOpcode()) {
    int Latency = ItinData->getOperandCycle(DefMCID.getSchedClass(), DefIdx);
    if (Subtarget.isLikeA9() || Subtarget.isSwift())
      return Latency <= 2 ? 1 : Latency - 1;
    else
      return Latency <= 3 ? 1 : Latency - 2;
  }

  const MCInstrDesc &UseMCID = get(UseNode->getMachineOpcode());
  const MachineSDNode *DefMN = dyn_cast<MachineSDNode>(DefNode);
  unsigned DefAlign = !DefMN->memoperands_empty()
    ? (*DefMN->memoperands_begin())->getAlignment() : 0;
  const MachineSDNode *UseMN = dyn_cast<MachineSDNode>(UseNode);
  unsigned UseAlign = !UseMN->memoperands_empty()
    ? (*UseMN->memoperands_begin())->getAlignment() : 0;
  int Latency = getOperandLatency(ItinData, DefMCID, DefIdx, DefAlign,
                                  UseMCID, UseIdx, UseAlign);

  if (Latency > 1 &&
      (Subtarget.isCortexA8() || Subtarget.isLikeA9() ||
       Subtarget.isCortexA7())) {
    // FIXME: Shifter op hack: no shift (i.e. [r +/- r]) or [r + r << 2]
    // variants are one cycle cheaper.
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          (ShImm == 2 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        --Latency;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      if (ShAmt == 0 || ShAmt == 2)
        --Latency;
      break;
    }
    }
  } else if (DefIdx == 0 && Latency > 2 && Subtarget.isSwift()) {
    // FIXME: Properly handle all of the latency adjustments for address
    // writeback.
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
           ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        Latency -= 2;
      else if (ShImm == 1 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsr)
        --Latency;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl 0-3 only.
      Latency -= 2;
      break;
    }
    }
  }

  if (DefAlign < 8 && Subtarget.isLikeA9())
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::VLD1q8:
    case ARM::VLD1q16:
    case ARM::VLD1q32:
    case ARM::VLD1q64:
    case ARM::VLD1q8wb_register:
    case ARM::VLD1q16wb_register:
    case ARM::VLD1q32wb_register:
    case ARM::VLD1q64wb_register:
    case ARM::VLD1q8wb_fixed:
    case ARM::VLD1q16wb_fixed:
    case ARM::VLD1q32wb_fixed:
    case ARM::VLD1q64wb_fixed:
    case ARM::VLD2d8:
    case ARM::VLD2d16:
    case ARM::VLD2d32:
    case ARM::VLD2q8Pseudo:
    case ARM::VLD2q16Pseudo:
    case ARM::VLD2q32Pseudo:
    case ARM::VLD2d8wb_fixed:
    case ARM::VLD2d16wb_fixed:
    case ARM::VLD2d32wb_fixed:
    case ARM::VLD2q8PseudoWB_fixed:
    case ARM::VLD2q16PseudoWB_fixed:
    case ARM::VLD2q32PseudoWB_fixed:
    case ARM::VLD2d8wb_register:
    case ARM::VLD2d16wb_register:
    case ARM::VLD2d32wb_register:
    case ARM::VLD2q8PseudoWB_register:
    case ARM::VLD2q16PseudoWB_register:
    case ARM::VLD2q32PseudoWB_register:
    case ARM::VLD3d8Pseudo:
    case ARM::VLD3d16Pseudo:
    case ARM::VLD3d32Pseudo:
    case ARM::VLD1d64TPseudo:
    case ARM::VLD1d64TPseudoWB_fixed:
    case ARM::VLD3d8Pseudo_UPD:
    case ARM::VLD3d16Pseudo_UPD:
    case ARM::VLD3d32Pseudo_UPD:
    case ARM::VLD3q8Pseudo_UPD:
    case ARM::VLD3q16Pseudo_UPD:
    case ARM::VLD3q32Pseudo_UPD:
    case ARM::VLD3q8oddPseudo:
    case ARM::VLD3q16oddPseudo:
    case ARM::VLD3q32oddPseudo:
    case ARM::VLD3q8oddPseudo_UPD:
    case ARM::VLD3q16oddPseudo_UPD:
    case ARM::VLD3q32oddPseudo_UPD:
    case ARM::VLD4d8Pseudo:
    case ARM::VLD4d16Pseudo:
    case ARM::VLD4d32Pseudo:
    case ARM::VLD1d64QPseudo:
    case ARM::VLD1d64QPseudoWB_fixed:
    case ARM::VLD4d8Pseudo_UPD:
    case ARM::VLD4d16Pseudo_UPD:
    case ARM::VLD4d32Pseudo_UPD:
    case ARM::VLD4q8Pseudo_UPD:
    case ARM::VLD4q16Pseudo_UPD:
    case ARM::VLD4q32Pseudo_UPD:
    case ARM::VLD4q8oddPseudo:
    case ARM::VLD4q16oddPseudo:
    case ARM::VLD4q32oddPseudo:
    case ARM::VLD4q8oddPseudo_UPD:
    case ARM::VLD4q16oddPseudo_UPD:
    case ARM::VLD4q32oddPseudo_UPD:
    case ARM::VLD1DUPq8:
    case ARM::VLD1DUPq16:
    case ARM::VLD1DUPq32:
    case ARM::VLD1DUPq8wb_fixed:
    case ARM::VLD1DUPq16wb_fixed:
    case ARM::VLD1DUPq32wb_fixed:
    case ARM::VLD1DUPq8wb_register:
    case ARM::VLD1DUPq16wb_register:
    case ARM::VLD1DUPq32wb_register:
    case ARM::VLD2DUPd8:
    case ARM::VLD2DUPd16:
    case ARM::VLD2DUPd32:
    case ARM::VLD2DUPd8wb_fixed:
    case ARM::VLD2DUPd16wb_fixed:
    case ARM::VLD2DUPd32wb_fixed:
    case ARM::VLD2DUPd8wb_register:
    case ARM::VLD2DUPd16wb_register:
    case ARM::VLD2DUPd32wb_register:
    case ARM::VLD4DUPd8Pseudo:
    case ARM::VLD4DUPd16Pseudo:
    case ARM::VLD4DUPd32Pseudo:
    case ARM::VLD4DUPd8Pseudo_UPD:
    case ARM::VLD4DUPd16Pseudo_UPD:
    case ARM::VLD4DUPd32Pseudo_UPD:
    case ARM::VLD1LNq8Pseudo:
    case ARM::VLD1LNq16Pseudo:
    case ARM::VLD1LNq32Pseudo:
    case ARM::VLD1LNq8Pseudo_UPD:
    case ARM::VLD1LNq16Pseudo_UPD:
    case ARM::VLD1LNq32Pseudo_UPD:
    case ARM::VLD2LNd8Pseudo:
    case ARM::VLD2LNd16Pseudo:
    case ARM::VLD2LNd32Pseudo:
    case ARM::VLD2LNq16Pseudo:
    case ARM::VLD2LNq32Pseudo:
    case ARM::VLD2LNd8Pseudo_UPD:
    case ARM::VLD2LNd16Pseudo_UPD:
    case ARM::VLD2LNd32Pseudo_UPD:
    case ARM::VLD2LNq16Pseudo_UPD:
    case ARM::VLD2LNq32Pseudo_UPD:
    case ARM::VLD4LNd8Pseudo:
    case ARM::VLD4LNd16Pseudo:
    case ARM::VLD4LNd32Pseudo:
    case ARM::VLD4LNq16Pseudo:
    case ARM::VLD4LNq32Pseudo:
    case ARM::VLD4LNd8Pseudo_UPD:
    case ARM::VLD4LNd16Pseudo_UPD:
    case ARM::VLD4LNd32Pseudo_UPD:
    case ARM::VLD4LNq16Pseudo_UPD:
    case ARM::VLD4LNq32Pseudo_UPD:
      // If the address is not 64-bit aligned, the latencies of these
      // instructions increases by one.
      ++Latency;
      break;
    }

  return Latency;
}

unsigned ARMBaseInstrInfo::getPredicationCost(const MachineInstr *MI) const {
   if (MI->isCopyLike() || MI->isInsertSubreg() ||
      MI->isRegSequence() || MI->isImplicitDef())
    return 0;

  if (MI->isBundle())
    return 0;

  const MCInstrDesc &MCID = MI->getDesc();

  if (MCID.isCall() || MCID.hasImplicitDefOfPhysReg(ARM::CPSR)) {
    // When predicated, CPSR is an additional source operand for CPSR updating
    // instructions, this apparently increases their latencies.
    return 1;
  }
  return 0;
}

unsigned ARMBaseInstrInfo::getInstrLatency(const InstrItineraryData *ItinData,
                                           const MachineInstr *MI,
                                           unsigned *PredCost) const {
  if (MI->isCopyLike() || MI->isInsertSubreg() ||
      MI->isRegSequence() || MI->isImplicitDef())
    return 1;

  // An instruction scheduler typically runs on unbundled instructions, however
  // other passes may query the latency of a bundled instruction.
  if (MI->isBundle()) {
    unsigned Latency = 0;
    MachineBasicBlock::const_instr_iterator I = MI;
    MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
    while (++I != E && I->isInsideBundle()) {
      if (I->getOpcode() != ARM::t2IT)
        Latency += getInstrLatency(ItinData, I, PredCost);
    }
    return Latency;
  }

  const MCInstrDesc &MCID = MI->getDesc();
  if (PredCost && (MCID.isCall() || MCID.hasImplicitDefOfPhysReg(ARM::CPSR))) {
    // When predicated, CPSR is an additional source operand for CPSR updating
    // instructions, this apparently increases their latencies.
    *PredCost = 1;
  }
  // Be sure to call getStageLatency for an empty itinerary in case it has a
  // valid MinLatency property.
  if (!ItinData)
    return MI->mayLoad() ? 3 : 1;

  unsigned Class = MCID.getSchedClass();

  // For instructions with variable uops, use uops as latency.
  if (!ItinData->isEmpty() && ItinData->getNumMicroOps(Class) < 0)
    return getNumMicroOps(ItinData, MI);

  // For the common case, fall back on the itinerary's latency.
  unsigned Latency = ItinData->getStageLatency(Class);

  // Adjust for dynamic def-side opcode variants not captured by the itinerary.
  unsigned DefAlign = MI->hasOneMemOperand()
    ? (*MI->memoperands_begin())->getAlignment() : 0;
  int Adj = adjustDefLatency(Subtarget, MI, &MCID, DefAlign);
  if (Adj >= 0 || (int)Latency > -Adj) {
    return Latency + Adj;
  }
  return Latency;
}

int ARMBaseInstrInfo::getInstrLatency(const InstrItineraryData *ItinData,
                                      SDNode *Node) const {
  if (!Node->isMachineOpcode())
    return 1;

  if (!ItinData || ItinData->isEmpty())
    return 1;

  unsigned Opcode = Node->getMachineOpcode();
  switch (Opcode) {
  default:
    return ItinData->getStageLatency(get(Opcode).getSchedClass());
  case ARM::VLDMQIA:
  case ARM::VSTMQIA:
    return 2;
  }
}

bool ARMBaseInstrInfo::
hasHighOperandLatency(const TargetSchedModel &SchedModel,
                      const MachineRegisterInfo *MRI,
                      const MachineInstr *DefMI, unsigned DefIdx,
                      const MachineInstr *UseMI, unsigned UseIdx) const {
  unsigned DDomain = DefMI->getDesc().TSFlags & ARMII::DomainMask;
  unsigned UDomain = UseMI->getDesc().TSFlags & ARMII::DomainMask;
  if (Subtarget.isCortexA8() &&
      (DDomain == ARMII::DomainVFP || UDomain == ARMII::DomainVFP))
    // CortexA8 VFP instructions are not pipelined.
    return true;

  // Hoist VFP / NEON instructions with 4 or higher latency.
  unsigned Latency
    = SchedModel.computeOperandLatency(DefMI, DefIdx, UseMI, UseIdx);
  if (Latency <= 3)
    return false;
  return DDomain == ARMII::DomainVFP || DDomain == ARMII::DomainNEON ||
         UDomain == ARMII::DomainVFP || UDomain == ARMII::DomainNEON;
}

bool ARMBaseInstrInfo::
hasLowDefLatency(const TargetSchedModel &SchedModel,
                 const MachineInstr *DefMI, unsigned DefIdx) const {
  const InstrItineraryData *ItinData = SchedModel.getInstrItineraries();
  if (!ItinData || ItinData->isEmpty())
    return false;

  unsigned DDomain = DefMI->getDesc().TSFlags & ARMII::DomainMask;
  if (DDomain == ARMII::DomainGeneral) {
    unsigned DefClass = DefMI->getDesc().getSchedClass();
    int DefCycle = ItinData->getOperandCycle(DefClass, DefIdx);
    return (DefCycle != -1 && DefCycle <= 2);
  }
  return false;
}

bool ARMBaseInstrInfo::verifyInstruction(const MachineInstr *MI,
                                         StringRef &ErrInfo) const {
  if (convertAddSubFlagsOpcode(MI->getOpcode())) {
    ErrInfo = ""Pseudo flag setting opcodes only exist in Selection DAG"";
    return false;
  }
  return true;
}

// LoadStackGuard has so far only been implemented for MachO. Different code
// sequence is needed for other targets.
void ARMBaseInstrInfo::expandLoadStackGuardBase(MachineBasicBlock::iterator MI,
                                                unsigned LoadImmOpc,
                                                unsigned LoadOpc,
                                                Reloc::Model RM) const {
  MachineBasicBlock &MBB = *MI->getParent();
  DebugLoc DL = MI->getDebugLoc();
  unsigned Reg = MI->getOperand(0).getReg();
  const GlobalValue *GV =
      cast<GlobalValue>((*MI->memoperands_begin())->getValue());
  MachineInstrBuilder MIB;

  BuildMI(MBB, MI, DL, get(LoadImmOpc), Reg)
      .addGlobalAddress(GV, 0, ARMII::MO_NONLAZY);

  if (Subtarget.GVIsIndirectSymbol(GV, RM)) {
    MIB = BuildMI(MBB, MI, DL, get(LoadOpc), Reg);
    MIB.addReg(Reg, RegState::Kill).addImm(0);
    unsigned Flag = MachineMemOperand::MOLoad | MachineMemOperand::MOInvariant;
    MachineMemOperand *MMO = MBB.getParent()->
        getMachineMemOperand(MachinePointerInfo::getGOT(), Flag, 4, 4);
    MIB.addMemOperand(MMO);
    AddDefaultPred(MIB);
  }

  MIB = BuildMI(MBB, MI, DL, get(LoadOpc), Reg);
  MIB.addReg(Reg, RegState::Kill).addImm(0);
  MIB.setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
  AddDefaultPred(MIB);
}

bool
ARMBaseInstrInfo::isFpMLxInstruction(unsigned Opcode, unsigned &MulOpc,
                                     unsigned &AddSubOpc,
                                     bool &NegAcc, bool &HasLane) const {
  DenseMap<unsigned, unsigned>::const_iterator I = MLxEntryMap.find(Opcode);
  if (I == MLxEntryMap.end())
    return false;

  const ARM_MLxEntry &Entry = ARM_MLxTable[I->second];
  MulOpc = Entry.MulOpc;
  AddSubOpc = Entry.AddSubOpc;
  NegAcc = Entry.NegAcc;
  HasLane = Entry.HasLane;
  return true;
}

//===----------------------------------------------------------------------===//
// Execution domains.
//===----------------------------------------------------------------------===//
//
// Some instructions go down the NEON pipeline, some go down the VFP pipeline,
// and some can go down both.  The vmov instructions go down the VFP pipeline,
// but they can be changed to vorr equivalents that are executed by the NEON
// pipeline.
//
// We use the following execution domain numbering:
//
enum ARMExeDomain {
  ExeGeneric = 0,
  ExeVFP = 1,
  ExeNEON = 2
};
//
// Also see ARMInstrFormats.td and Domain* enums in ARMBaseInfo.h
//
std::pair<uint16_t, uint16_t>
ARMBaseInstrInfo::getExecutionDomain(const MachineInstr *MI) const {
  // If we don't have access to NEON instructions then we won't be able
  // to swizzle anything to the NEON domain. Check to make sure.
  if (Subtarget.hasNEON()) {
    // VMOVD, VMOVRS and VMOVSR are VFP instructions, but can be changed to NEON
    // if they are not predicated.
    if (MI->getOpcode() == ARM::VMOVD && !isPredicated(MI))
      return std::make_pair(ExeVFP, (1 << ExeVFP) | (1 << ExeNEON));

    // CortexA9 is particularly picky about mixing the two and wants these
    // converted.
    if (Subtarget.isCortexA9() && !isPredicated(MI) &&
        (MI->getOpcode() == ARM::VMOVRS || MI->getOpcode() == ARM::VMOVSR ||
         MI->getOpcode() == ARM::VMOVS))
      return std::make_pair(ExeVFP, (1 << ExeVFP) | (1 << ExeNEON));
  }
  // No other instructions can be swizzled, so just determine their domain.
  unsigned Domain = MI->getDesc().TSFlags & ARMII::DomainMask;

  if (Domain & ARMII::DomainNEON)
    return std::make_pair(ExeNEON, 0);

  // Certain instructions can go either way on Cortex-A8.
  // Treat them as NEON instructions.
  if ((Domain & ARMII::DomainNEONA8) && Subtarget.isCortexA8())
    return std::make_pair(ExeNEON, 0);

  if (Domain & ARMII::DomainVFP)
    return std::make_pair(ExeVFP, 0);

  return std::make_pair(ExeGeneric, 0);
}

static unsigned getCorrespondingDRegAndLane(const TargetRegisterInfo *TRI,
                                            unsigned SReg, unsigned &Lane) {
  unsigned DReg = TRI->getMatchingSuperReg(SReg, ARM::ssub_0, &ARM::DPRRegClass);
  Lane = 0;

  if (DReg != ARM::NoRegister)
   return DReg;

  Lane = 1;
  DReg = TRI->getMatchingSuperReg(SReg, ARM::ssub_1, &ARM::DPRRegClass);

  assert(DReg && ""S-register with no D super-register?"");
  return DReg;
}

/// getImplicitSPRUseForDPRUse - Given a use of a DPR register and lane,
/// set ImplicitSReg to a register number that must be marked as implicit-use or
/// zero if no register needs to be defined as implicit-use.
///
/// If the function cannot determine if an SPR should be marked implicit use or
/// not, it returns false.
///
/// This function handles cases where an instruction is being modified from taking
/// an SPR to a DPR[Lane]. A use of the DPR is being added, which may conflict
/// with an earlier def of an SPR corresponding to DPR[Lane^1] (i.e. the other
/// lane of the DPR).
///
/// If the other SPR is defined, an implicit-use of it should be added. Else,
/// (including the case where the DPR itself is defined), it should not.
///
static bool getImplicitSPRUseForDPRUse(const TargetRegisterInfo *TRI,
                                       MachineInstr *MI,
                                       unsigned DReg, unsigned Lane,
                                       unsigned &ImplicitSReg) {
  // If the DPR is defined or used already, the other SPR lane will be chained
  // correctly, so there is nothing to be done.
  if (MI->definesRegister(DReg, TRI) || MI->readsRegister(DReg, TRI)) {
    ImplicitSReg = 0;
    return true;
  }

  // Otherwise we need to go searching to see if the SPR is set explicitly.
  ImplicitSReg = TRI->getSubReg(DReg,
                                (Lane & 1) ? ARM::ssub_0 : ARM::ssub_1);
  MachineBasicBlock::LivenessQueryResult LQR =
    MI->getParent()->computeRegisterLiveness(TRI, ImplicitSReg, MI);

  if (LQR == MachineBasicBlock::LQR_Live)
    return true;
  else if (LQR == MachineBasicBlock::LQR_Unknown)
    return false;

  // If the register is known not to be live, there is no need to add an
  // implicit-use.
  ImplicitSReg = 0;
  return true;
}

void
ARMBaseInstrInfo::setExecutionDomain(MachineInstr *MI, unsigned Domain) const {
  unsigned DstReg, SrcReg, DReg;
  unsigned Lane;
  MachineInstrBuilder MIB(*MI->getParent()->getParent(), MI);
  const TargetRegisterInfo *TRI = &getRegisterInfo();
  switch (MI->getOpcode()) {
    default:
      llvm_unreachable(""cannot handle opcode!"");
      break;
    case ARM::VMOVD:
      if (Domain != ExeNEON)
        break;

      // Zap the predicate operands.
      assert(!isPredicated(MI) && ""Cannot predicate a VORRd"");

      // Make sure we've got NEON instructions.
      assert(Subtarget.hasNEON() && ""VORRd requires NEON"");

      // Source instruction is %DDst = VMOVD %DSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      // Change to a %DDst = VORRd %DSrc, %DSrc, 14, %noreg (; implicits)
      MI->setDesc(get(ARM::VORRd));
      AddDefaultPred(MIB.addReg(DstReg, RegState::Define)
                        .addReg(SrcReg)
                        .addReg(SrcReg));
      break;
    case ARM::VMOVRS:
      if (Domain != ExeNEON)
        break;
      assert(!isPredicated(MI) && ""Cannot predicate a VGETLN"");

      // Source instruction is %RDst = VMOVRS %SSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      DReg = getCorrespondingDRegAndLane(TRI, SrcReg, Lane);

      // Convert to %RDst = VGETLNi32 %DSrc, Lane, 14, %noreg (; imps)
      // Note that DSrc has been widened and the other lane may be undef, which
      // contaminates the entire register.
      MI->setDesc(get(ARM::VGETLNi32));
      AddDefaultPred(MIB.addReg(DstReg, RegState::Define)
                        .addReg(DReg, RegState::Undef)
                        .addImm(Lane));

      // The old source should be an implicit use, otherwise we might think it
      // was dead before here.
      MIB.addReg(SrcReg, RegState::Implicit);
      break;
    case ARM::VMOVSR: {
      if (Domain != ExeNEON)
        break;
      assert(!isPredicated(MI) && ""Cannot predicate a VSETLN"");

      // Source instruction is %SDst = VMOVSR %RSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      DReg = getCorrespondingDRegAndLane(TRI, DstReg, Lane);

      unsigned ImplicitSReg;
      if (!getImplicitSPRUseForDPRUse(TRI, MI, DReg, Lane, ImplicitSReg))
        break;

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      // Convert to %DDst = VSETLNi32 %DDst, %RSrc, Lane, 14, %noreg (; imps)
      // Again DDst may be undefined at the beginning of this instruction.
      MI->setDesc(get(ARM::VSETLNi32));
      MIB.addReg(DReg, RegState::Define)
         .addReg(DReg, getUndefRegState(!MI->readsRegister(DReg, TRI)))
         .addReg(SrcReg)
         .addImm(Lane);
      AddDefaultPred(MIB);

      // The narrower destination must be marked as set to keep previous chains
      // in place.
      MIB.addReg(DstReg, RegState::Define | RegState::Implicit);
      if (ImplicitSReg != 0)
        MIB.addReg(ImplicitSReg, RegState::Implicit);
      break;
    }
    case ARM::VMOVS: {
      if (Domain != ExeNEON)
        break;

      // Source instruction is %SDst = VMOVS %SSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      unsigned DstLane = 0, SrcLane = 0, DDst, DSrc;
      DDst = getCorrespondingDRegAndLane(TRI, DstReg, DstLane);
      DSrc = getCorrespondingDRegAndLane(TRI, SrcReg, SrcLane);

      unsigned ImplicitSReg;
      if (!getImplicitSPRUseForDPRUse(TRI, MI, DSrc, SrcLane, ImplicitSReg))
        break;

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      if (DSrc == DDst) {
        // Destination can be:
        //     %DDst = VDUPLN32d %DDst, Lane, 14, %noreg (; implicits)
        MI->setDesc(get(ARM::VDUPLN32d));
        MIB.addReg(DDst, RegState::Define)
           .addReg(DDst, getUndefRegState(!MI->readsRegister(DDst, TRI)))
           .addImm(SrcLane);
        AddDefaultPred(MIB);

        // Neither the source or the destination are naturally represented any
        // more, so add them in manually.
        MIB.addReg(DstReg, RegState::Implicit | RegState::Define);
        MIB.addReg(SrcReg, RegState::Implicit);
        if (ImplicitSReg != 0)
          MIB.addReg(ImplicitSReg, RegState::Implicit);
        break;
      }

      // In general there's no single instruction that can perform an S <-> S
      // move in NEON space, but a pair of VEXT instructions *can* do the
      // job. It turns out that the VEXTs needed will only use DSrc once, with
      // the position based purely on the combination of lane-0 and lane-1
      // involved. For example
      //     vmov s0, s2 -> vext.32 d0, d0, d1, #1  vext.32 d0, d0, d0, #1
      //     vmov s1, s3 -> vext.32 d0, d1, d0, #1  vext.32 d0, d0, d0, #1
      //     vmov s0, s3 -> vext.32 d0, d0, d0, #1  vext.32 d0, d1, d0, #1
      //     vmov s1, s2 -> vext.32 d0, d0, d0, #1  vext.32 d0, d0, d1, #1
      //
      // Pattern of the MachineInstrs is:
      //     %DDst = VEXTd32 %DSrc1, %DSrc2, Lane, 14, %noreg (;implicits)
      MachineInstrBuilder NewMIB;
      NewMIB = BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                       get(ARM::VEXTd32), DDst);

      // On the first instruction, both DSrc and DDst may be <undef> if present.
      // Specifically when the original instruction didn't have them as an
      // <imp-use>.
      unsigned CurReg = SrcLane == 1 && DstLane == 1 ? DSrc : DDst;
      bool CurUndef = !MI->readsRegister(CurReg, TRI);
      NewMIB.addReg(CurReg, getUndefRegState(CurUndef));

      CurReg = SrcLane == 0 && DstLane == 0 ? DSrc : DDst;
      CurUndef = !MI->readsRegister(CurReg, TRI);
      NewMIB.addReg(CurReg, getUndefRegState(CurUndef));

      NewMIB.addImm(1);
      AddDefaultPred(NewMIB);

      if (SrcLane == DstLane)
        NewMIB.addReg(SrcReg, RegState::Implicit);

      MI->setDesc(get(ARM::VEXTd32));
      MIB.addReg(DDst, RegState::Define);

      // On the second instruction, DDst has definitely been defined above, so
      // it is not <undef>. DSrc, if present, can be <undef> as above.
      CurReg = SrcLane == 1 && DstLane == 0 ? DSrc : DDst;
      CurUndef = CurReg == DSrc && !MI->readsRegister(CurReg, TRI);
      MIB.addReg(CurReg, getUndefRegState(CurUndef));

      CurReg = SrcLane == 0 && DstLane == 1 ? DSrc : DDst;
      CurUndef = CurReg == DSrc && !MI->readsRegister(CurReg, TRI);
      MIB.addReg(CurReg, getUndefRegState(CurUndef));

      MIB.addImm(1);
      AddDefaultPred(MIB);

      if (SrcLane != DstLane)
        MIB.addReg(SrcReg, RegState::Implicit);

      // As before, the original destination is no longer represented, add it
      // implicitly.
      MIB.addReg(DstReg, RegState::Define | RegState::Implicit);
      if (ImplicitSReg != 0)
        MIB.addReg(ImplicitSReg, RegState::Implicit);
      break;
    }
  }

}

//===----------------------------------------------------------------------===//
// Partial register updates
//===----------------------------------------------------------------------===//
//
// Swift renames NEON registers with 64-bit granularity.  That means any
// instruction writing an S-reg implicitly reads the containing D-reg.  The
// problem is mostly avoided by translating f32 operations to v2f32 operations
// on D-registers, but f32 loads are still a problem.
//
// These instructions can load an f32 into a NEON register:
//
// VLDRS - Only writes S, partial D update.
// VLD1LNd32 - Writes all D-regs, explicit partial D update, 2 uops.
// VLD1DUPd32 - Writes all D-regs, no partial reg update, 2 uops.
//
// FCONSTD can be used as a dependency-breaking instruction.
unsigned ARMBaseInstrInfo::
getPartialRegUpdateClearance(const MachineInstr *MI,
                             unsigned OpNum,
                             const TargetRegisterInfo *TRI) const {
  if (!SwiftPartialUpdateClearance ||
      !(Subtarget.isSwift() || Subtarget.isCortexA15()))
    return 0;

  assert(TRI && ""Need TRI instance"");

  const MachineOperand &MO = MI->getOperand(OpNum);
  if (MO.readsReg())
    return 0;
  unsigned Reg = MO.getReg();
  int UseOp = -1;

  switch(MI->getOpcode()) {
    // Normal instructions writing only an S-register.
  case ARM::VLDRS:
  case ARM::FCONSTS:
  case ARM::VMOVSR:
  case ARM::VMOVv8i8:
  case ARM::VMOVv4i16:
  case ARM::VMOVv2i32:
  case ARM::VMOVv2f32:
  case ARM::VMOVv1i64:
    UseOp = MI->findRegisterUseOperandIdx(Reg, false, TRI);
    break;

    // Explicitly reads the dependency.
  case ARM::VLD1LNd32:
    UseOp = 3;
    break;
  default:
    return 0;
  }

  // If this instruction actually reads a value from Reg, there is no unwanted
  // dependency.
  if (UseOp != -1 && MI->getOperand(UseOp).readsReg())
    return 0;

  // We must be able to clobber the whole D-reg.
  if (TargetRegisterInfo::isVirtualRegister(Reg)) {
    // Virtual register must be a foo:ssub_0<def,undef> operand.
    if (!MO.getSubReg() || MI->readsVirtualRegister(Reg))
      return 0;
  } else if (ARM::SPRRegClass.contains(Reg)) {
    // Physical register: MI must define the full D-reg.
    unsigned DReg = TRI->getMatchingSuperReg(Reg, ARM::ssub_0,
                                             &ARM::DPRRegClass);
    if (!DReg || !MI->definesRegister(DReg, TRI))
      return 0;
  }

  // MI has an unwanted D-register dependency.
  // Avoid defs in the previous N instructrions.
  return SwiftPartialUpdateClearance;
}

// Break a partial register dependency after getPartialRegUpdateClearance
// returned non-zero.
void ARMBaseInstrInfo::
breakPartialRegDependency(MachineBasicBlock::iterator MI,
                          unsigned OpNum,
                          const TargetRegisterInfo *TRI) const {
  assert(MI && OpNum < MI->getDesc().getNumDefs() && ""OpNum is not a def"");
  assert(TRI && ""Need TRI instance"");

  const MachineOperand &MO = MI->getOperand(OpNum);
  unsigned Reg = MO.getReg();
  assert(TargetRegisterInfo::isPhysicalRegister(Reg) &&
         ""Can't break virtual register dependencies."");
  unsigned DReg = Reg;

  // If MI defines an S-reg, find the corresponding D super-register.
  if (ARM::SPRRegClass.contains(Reg)) {
    DReg = ARM::D0 + (Reg - ARM::S0) / 2;
    assert(TRI->isSuperRegister(Reg, DReg) && ""Register enums broken"");
  }

  assert(ARM::DPRRegClass.contains(DReg) && ""Can only break D-reg deps"");
  assert(MI->definesRegister(DReg, TRI) && ""MI doesn't clobber full D-reg"");

  // FIXME: In some cases, VLDRS can be changed to a VLD1DUPd32 which defines
  // the full D-register by loading the same value to both lanes.  The
  // instruction is micro-coded with 2 uops, so don't do this until we can
  // properly schedule micro-coded instructions.  The dispatcher stalls cause
  // too big regressions.

  // Insert the dependency-breaking FCONSTD before MI.
  // 96 is the encoding of 0.5, but the actual value doesn't matter here.
  AddDefaultPred(BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                         get(ARM::FCONSTD), DReg).addImm(96));
  MI->addRegisterKilled(DReg, TRI, true);
}

bool ARMBaseInstrInfo::hasNOP() const {
  return Subtarget.getFeatureBits()[ARM::HasV6KOps];
}

bool ARMBaseInstrInfo::isSwiftFastImmShift(const MachineInstr *MI) const {
  if (MI->getNumOperands() < 4)
    return true;
  unsigned ShOpVal = MI->getOperand(3).getImm();
  unsigned ShImm = ARM_AM::getSORegOffset(ShOpVal);
  // Swift supports faster shifts for: lsl 2, lsl 1, and lsr 1.
  if ((ShImm == 1 && ARM_AM::getSORegShOp(ShOpVal) == ARM_AM::lsr) ||
      ((ShImm == 1 || ShImm == 2) &&
       ARM_AM::getSORegShOp(ShOpVal) == ARM_AM::lsl))
    return true;

  return false;
}

bool ARMBaseInstrInfo::getRegSequenceLikeInputs(
    const MachineInstr &MI, unsigned DefIdx,
    SmallVectorImpl<RegSubRegPairAndIdx> &InputRegs) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isRegSequenceLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VMOVDRR:
    // dX = VMOVDRR rY, rZ
    // is the same as:
    // dX = REG_SEQUENCE rY, ssub_0, rZ, ssub_1
    // Populate the InputRegs accordingly.
    // rY
    const MachineOperand *MOReg = &MI.getOperand(1);
    InputRegs.push_back(
        RegSubRegPairAndIdx(MOReg->getReg(), MOReg->getSubReg(), ARM::ssub_0));
    // rZ
    MOReg = &MI.getOperand(2);
    InputRegs.push_back(
        RegSubRegPairAndIdx(MOReg->getReg(), MOReg->getSubReg(), ARM::ssub_1));
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}

bool ARMBaseInstrInfo::getExtractSubregLikeInputs(
    const MachineInstr &MI, unsigned DefIdx,
    RegSubRegPairAndIdx &InputReg) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isExtractSubregLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VMOVRRD:
    // rX, rY = VMOVRRD dZ
    // is the same as:
    // rX = EXTRACT_SUBREG dZ, ssub_0
    // rY = EXTRACT_SUBREG dZ, ssub_1
    const MachineOperand &MOReg = MI.getOperand(2);
    InputReg.Reg = MOReg.getReg();
    InputReg.SubReg = MOReg.getSubReg();
    InputReg.SubIdx = DefIdx == 0 ? ARM::ssub_0 : ARM::ssub_1;
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}

bool ARMBaseInstrInfo::getInsertSubregLikeInputs(
    const MachineInstr &MI, unsigned DefIdx, RegSubRegPair &BaseReg,
    RegSubRegPairAndIdx &InsertedReg) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isInsertSubregLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VSETLNi32:
    // dX = VSETLNi32 dY, rZ, imm
    const MachineOperand &MOBaseReg = MI.getOperand(1);
    const MachineOperand &MOInsertedReg = MI.getOperand(2);
    const MachineOperand &MOIndex = MI.getOperand(3);
    BaseReg.Reg = MOBaseReg.getReg();
    BaseReg.SubReg = MOBaseReg.getSubReg();

    InsertedReg.Reg = MOInsertedReg.getReg();
    InsertedReg.SubReg = MOInsertedReg.getSubReg();
    InsertedReg.SubIdx = MOIndex.getImm() == 0 ? ARM::ssub_0 : ARM::ssub_1;
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}
",DstRegS
887,"#include ""Arduino.h""
#include ""touchButton.h""
#include <UTFT.h>
#include <UTouch.h>

touchButton::touchButton(UTFT &glcddev, int x, int y, int xs, int ys, char  [MASK] )
{
  x1 = x;
  y1 = y;
  xsize = xs;
  ysize = ys;
  use =  [MASK] ;
  glcd = &glcddev;
  toggle = false;
}

boolean touchButton::isTouched(int tx, int ty){
  if(tx>= x1 && tx<=(x1+xsize) && ty>= y1 && ty<=(y1+ysize)){
    return(true);
  }
  else {
    return(false);
  }
}

void touchButton::Press(){
  toggle = !toggle;
}

void touchButton::Draw() {
  switch (use) {
    case 'p': /////////////////////////////////////////////////////////////////////////////////////////
      /////////////// POWER TOGGLE

      if (toggle) {
        glcd->setColor(VGA_GREEN);
      }
      else {
        glcd->setColor(VGA_RED);
      }

      glcd->fillRoundRect(x1, y1, x1 + xsize, y1 + ysize);
      glcd->setColor(VGA_BLACK);
      glcd->drawCircle(x1 + (xsize / 2), y1 + (ysize * 0.6), (xsize * 0.2));
      glcd->drawLine(x1 + (xsize / 2), y1 + (ysize * 0.1), x1 + (xsize / 2), y1 + (ysize * 0.6));
      break;

    case 'v': /////////////////////////////////////////////////////////////////////////////////////////
      /////////////// VIDEO TOGGLE
      glcd->setColor(VGA_BLUE);
      glcd->fillRoundRect(x1, y1, x1 + xsize, y1 + ysize);
      glcd->setColor(VGA_BLACK);
      glcd->drawLine(x1 + (xsize / 2), y1 + (ysize * 0.2), x1 + (xsize * 0.3), y1 + (ysize * 0.4)); // ^ LEFT
      glcd->drawLine(x1 + (xsize / 2), y1 + (ysize * 0.2), x1 + (xsize * 0.7), y1 + (ysize * 0.4)); // ^ RIGHT
      if (!toggle) {
        glcd->drawLine(x1 + (xsize / 2), y1 + (ysize * 0.2), x1 + (xsize / 2), y1 + (ysize * 0.8)); // |
        glcd->setColor(VGA_WHITE);
        glcd->setBackColor(VGA_BLUE);
        glcd->print(""1.2"", (x1+xsize*0.7), y1+(ysize*0.7));
      }
      else {
        glcd->drawLine(x1 + (xsize / 2), y1 + (ysize * 0.2), x1 + (xsize * 0.5), y1 + (ysize * 0.6)); // |
        glcd->drawLine(x1 + (xsize / 2), y1 + (ysize *0.6), x1 + (xsize * 0.2), y1 + (ysize * 0.8)); // /
        glcd->setColor(VGA_WHITE);
        glcd->setBackColor(VGA_BLUE);
        glcd->print(""5.8"", (x1+xsize*0.7), y1+(ysize*0.7));
      }


    default:
      x1 = x1 + 1;
      break;
  }


}




",myuse
888,"//
// Copyright 2017 <NAME>
//
// 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 ""CN3Writer.hh""


namespace n3 {
	
	
	const std::string N3PFormatter::SKOLEM_PREFIX(""https://melgi.github.io/.well-known/genid/#"");
	const char N3PFormatter::HEX_CHAR[] = ""0123456789ABCDEF"";
	
	
	void N3PFormatter::visit(const URIResource &resource)
	{
		m_outbuf->sputc('\'');
		m_outbuf->sputc('<');
		outputUri(resource.uri());
		m_outbuf->sputc('>');
		m_outbuf->sputc('\'');
	}
	
	void N3PFormatter::visit(const BlankNode &blankNode)
	{
		const std::string &id = blankNode.id();
		
		if (!rule()) {
			m_outbuf->sputc('\'');
			m_outbuf->sputc('<');
			m_outbuf->sputn(SKOLEM_PREFIX.c_str(), SKOLEM_PREFIX.length());
			m_outbuf->sputn(id.c_str(), id.length());
			if (!m_graphs.empty()) {
				const std::string &suffix = m_graphs.back();
				m_outbuf->sputc('_');
				m_outbuf->sputn(suffix.c_str(), suffix.length());
			}
			m_outbuf->sputc('>');
			m_outbuf->sputc('\'');
		} else {
			// output as universal
			m_outbuf->sputc('V');
			
			std::size_t p = id.find('-');
			if (p != std::string::npos) {
				++p;
				m_outbuf->sputn(id.c_str() + p, id.length() - p);
			} else {
				m_outbuf->sputn(id.c_str(), id.length());
			}
			
			const std::string &suffix = m_graphs.back();
			m_outbuf->sputc('_');
			m_outbuf->sputn(suffix.c_str(), suffix.length());
		}
	}
	
	void N3PFormatter::visit(const Literal &literal)
	{
		m_outbuf->sputn(""literal('"", 9);
		output(literal.lexical());
		m_outbuf->sputn(""',type('<"", 9);
		outputUri(literal.datatype());
		m_outbuf->sputn("">'))"", 4);
	}
	
	void N3PFormatter::visit(const BooleanLiteral &literal)
	{
		const std::string &lexical = literal.value() ? BooleanLiteral::VALUE_TRUE.lexical() : BooleanLiteral::VALUE_FALSE.lexical();
		
		m_outbuf->sputn(lexical.c_str(), lexical.length());
	}
	
	void N3PFormatter::visit(const IntegerLiteral &literal)
	{
		const std::string &lexical = literal.lexical();
		
		m_outbuf->sputn(lexical.c_str(), lexical.length());
	}
	
	void N3PFormatter::visit(const DoubleLiteral &literal)
	{
		const std::string &value = literal.lexical();
		
		// values like .5 and -.5 are not allowed in prolog
		// values like 5. and 5.E0 are not allowed in prolog
		
		bool appendZero = false;
		
		std::string s;
		const std::string *sp = &value;
		
		std::size_t p = value.find('.');
		if (p != std::string::npos) {
			++p;
			if (p == value.length()) {
				appendZero = true;
			} else if (value[p] == 'E' || value[p] == 'e') {
				s.reserve(value.length() + 1);
				s = value;
				s.insert(p, 1, '0');
				sp = &s;
			}
		}
		
		if ((*sp)[0] == '.') {
			m_outbuf->sputc('0');
			m_outbuf->sputn(sp->c_str(), sp->length());
			if (appendZero)
				m_outbuf->sputc('0');
		} else if ((*sp)[0] == '-' && (*sp)[1] == '.') {
			m_outbuf->sputc('-');
			m_outbuf->sputc('0');
			m_outbuf->sputn(sp->c_str() + 1, sp->length() - 1);
			if (appendZero)
				m_outbuf->sputc('0');
		} else {
			m_outbuf->sputn(sp->c_str(), sp->length());
			if (appendZero)
				m_outbuf->sputc('0');
		}
	}
	
	void N3PFormatter::visit(const DecimalLiteral &literal)
	{
		const std::string &value = literal.lexical();
		
		if (m_rdivDecimal) {
			std::size_t p = value.find('.');
			if (p == std::string::npos) {
				m_outbuf->sputn(value.c_str(), value.length());
				m_outbuf->sputn("" rdiv 1"", 7);
			} else {
				m_outbuf->sputn(value.c_str(), p++);
				std::size_t len = value.length() - p;
				m_outbuf->sputn(value.c_str() + p, len);
				m_outbuf->sputn("" rdiv 1"", 7);
				for (std::size_t i = 0; i < len; i++)
					m_outbuf->sputc('0');
			}
		} else {
			// values like .5 and -.5 are not allowed in prolog
			// values like 5. are not allowed in prolog
			
			if (value[0] == '.') {
				m_outbuf->sputc('0');
				m_outbuf->sputn(value.c_str(), value.length());
			} else if (value[0] == '-' && value[1] == '.') {
				m_outbuf->sputc('-');
				m_outbuf->sputc('0');
				m_outbuf->sputn(value.c_str() + 1, value.length() - 1);
			} else {
				m_outbuf->sputn(value.c_str(), value.length());
			}
			
			std::size_t length = value.length();
			if (length > 0 && value[length - 1] == '.')
				m_outbuf->sputc('0');
		}
	}

	void N3PFormatter::visit(const StringLiteral &literal)
	{
		m_outbuf->sputn(""literal('"", 9);
		output(literal.lexical());
		m_outbuf->sputc('\'');
		const std::string &lang = literal.language();
		if (!lang.empty()) {
			m_outbuf->sputn("",lang('"", 7);
			m_outbuf->sputn(lang.c_str(), lang.length());
			m_outbuf->sputc('\'');
			m_outbuf->sputc(')');
		} else {
			m_outbuf->sputn("",type('<"", 8);
			m_outbuf->sputn(StringLiteral::TYPE.c_str(), StringLiteral::TYPE.length());
			m_outbuf->sputc('>');
			m_outbuf->sputc('\'');
			m_outbuf->sputc(')');
		}
		
		m_outbuf->sputc(')');
	}
	
	void N3PFormatter::visit(const RDFList &list)
	{
		m_outbuf->sputc('[');
		if (!list.empty()) {
			auto i = list.begin();
			(*i)->visit(*this);
			++i;
			//m_count += 2;
			while (i != list.end()) {
				m_outbuf->sputc(',');
				(*i)->visit(*this);
				++i;
				//m_count += 2;
			}
		}
		m_outbuf->sputc(']');
	}
	
	void N3PFormatter::visit(const GraphTemplate &graph)
	{
		output(graph, true);
	}
	
	void N3PFormatter::output(const GraphTemplate &graph, bool  [MASK] )
	{
		m_graphs.push_back(graph.id());
		
		switch (graph.size()) {
			case 0: m_outbuf->sputn(""true"", 4); break;
			case 1: {
				const TriplePattern &t = *graph.begin();
				m_writer.outputTriple(t.subject(), t.property(), t.object(), &graph);
				break;
			}
			default: {
				if ( [MASK] )
					m_outbuf->sputc('(');
				
				auto i = graph.begin();
				
				m_writer.outputTriple(i->subject(), i->property(), i->object(), &graph);
				++i;
				
				while (i != graph.end()) {
					m_outbuf->sputc(',');
					m_outbuf->sputc(' ');
					m_writer.outputTriple(i->subject(), i->property(), i->object(), &graph);
					++i;
				}
				
				if ( [MASK] )
					m_outbuf->sputc(')');
			}
		}
		
		m_graphs.pop_back();
		if (m_graphs.empty())
			rule(false);
	}
	
	void N3PFormatter::visit(const Var &var)
	{
		const std::string &name = var.name();
		
		m_outbuf->sputc('_');
		m_outbuf->sputn(name.c_str(), name.length());
	}
	
	void CN3Writer::writePrologue()
	{
//		m_out << "":- style_check(-discontiguous).""; endl();
//		m_out << "":- style_check(-singleton).""; endl();
//		m_out << "":- multifile(exopred/3).""; endl();
//		m_out << "":- multifile(implies/3).""; endl();
//		m_out << "":- multifile(pfx/2).""; endl();
//		m_out << "":- multifile(pred/1).""; endl();
//		m_out << "":- multifile(prfstep/8).""; endl();
//		m_out << "":- multifile(scope/1).""; endl();
//		m_out << "":- multifile(scount/1).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/fl-rules#mu>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/fl-rules#pi>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/fl-rules#sigma>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/log-rules#biconditional>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/log-rules#conditional>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/log-rules#reflexive>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/log-rules#relabel>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/log-rules#tactic>'/2).""; endl();
//		m_out << "":- multifile('<http://eulersharp.sourceforge.net/2003/03swap/log-rules#transaction>'/2).""; endl();
//		m_out << "":- multifile('<http://www.w3.org/1999/02/22-rdf-syntax-ns#first>'/2).""; endl();
//		m_out << "":- multifile('<http://www.w3.org/1999/02/22-rdf-syntax-ns#rest>'/2).""; endl();
//		m_out << "":- multifile('<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>'/2).""; endl();
//		m_out << "":- multifile('<http://www.w3.org/2000/10/swap/log#implies>'/2).""; endl();
//		m_out << "":- multifile('<http://www.w3.org/2000/10/swap/log#outputString>'/2).""; endl();
//		m_out << "":- multifile('<http://www.w3.org/2002/07/owl#sameAs>'/2).""; endl();
		m_out << ""flag('no-skolem', '"" << N3PFormatter::SKOLEM_PREFIX << ""').""; endl();
	}

	void CN3Writer::writeEpilogue()
	{
		m_out << ""scount("" << m_count << "").""; endl();
		m_out << ""end_of_file.""; endl();
		
		m_out << std::flush;
	}

	
//	void CN3Writer::outputProperty(const std::string &uri)
//	{
//#ifdef CARL_N3P_CESU8
//		m_out.write("":- dynamic('<"", 13);
//		m_formatter.outputUri(uri);
//		m_out.write("">'/2)."", 6);
//		endl();
//		m_out.write("":- multifile('<"", 15);
//		m_formatter.outputUri(uri);
//		m_out.write("">'/2)."", 6);
//		endl();
//		m_out.write(""pred('<"", 7);
//		m_formatter.outputUri(uri);
//		m_out.write("">')."", 4);
//		endl();
//#else /* !CARL_N3P_CESU8 */
//		if (uri.find('\'') == std::string::npos) {
//			m_out.write("":- dynamic('<"", 13);
//			m_out.write(uri.c_str(), uri.length());
//			m_out.write("">'/2)."", 6);
//			endl();
//			m_out.write("":- multifile('<"", 15);
//			m_out.write(uri.c_str(), uri.length());
//			m_out.write("">'/2)."", 6);
//			endl();
//			m_out.write(""pred('<"", 7);
//			m_out.write(uri.c_str(), uri.length());
//			m_out.write("">')."", 4);
//			endl();
//		} else {
//			m_out.write("":- dynamic('<"", 13);
//			m_formatter.outputUri(uri);
//			m_out.write("">'/2)."", 6);
//			endl();
//			m_out.write("":- multifile('<"", 15);
//			m_formatter.outputUri(uri);
//			m_out.write("">'/2)."", 6);
//			endl();
//			m_out.write(""pred('<"", 7);
//			m_formatter.outputUri(uri);
//			m_out.write("">')."", 4);
//			endl();
//		}
//#endif /* CARL_N3P_CESU8 */
//	}
	
	
	void CN3Writer::outputTriple(const N3Node &subject, const URIResource &property, const N3Node &object, const GraphTemplate *graph)
	{
		bool implies = false;
		bool backwardsImplies = false;
		
		if (property.uri() == LOG::implies.uri()) {
			m_formatter.rule(true);
			if (graph) {
				m_formatter.visit(LOG::implies);
			} else {
				m_out.write(""implies"", 7);
				implies = true;
			}
			m_out.put('(');
		} else if (property.uri() == LOG::reverseImplies.uri()) {
			m_formatter.rule(true);
			if (subject.isGraphTemplate()) {
				const GraphTemplate &g = static_cast<const GraphTemplate &>(subject);
				Optional<std::string> p = extractPredicate(g);
				if (p) {
					if (!graph) {
						m_out.write(""cpred('<"", 8);
						m_formatter.outputUri(*p);
						m_out.write("">')."", 4);
						endl();
					} else {
						m_out.put('(');
					}
					m_formatter.output(g, true);
					m_out.put(' ');
				}
			} else if (subject.isVar() || subject.isBlankNode()) {
				if (graph) {
					m_out.put('(');
				}
				subject.visit(m_formatter);
				m_out.put(' ');
			}
			m_out.write("":- "", 3);
			backwardsImplies = true;
		} else {
			m_formatter.visit(property);
			m_out.put('(');
		}
		
		if (!backwardsImplies) {
			subject.visit(m_formatter);
			m_out.put(',').put(' ');
			if (implies)
				m_formatter.rule(true);
			object.visit(m_formatter);
		} else {
			m_formatter.rule(true);
			if (!object.isGraphTemplate())
				object.visit(m_formatter);
			else
				m_formatter.output(static_cast<const GraphTemplate &>(object), false);
			
			if (graph) {
				m_out.put(')');
			}
		}

		if (implies) {
			m_out.write("", '<"", 4);
			m_formatter.outputUri(m_source);
			m_out.write("">'"", 2);
		}
		
		if (!backwardsImplies)
			m_out.put(')');
		
		++m_count;
	}
	
	void CN3Writer::outputTriple(const N3Node &subject, const N3Node &property, const N3Node &object, const GraphTemplate *graph)
	{
		if (property.isURIResource()) {
			const URIResource &resource = static_cast<const URIResource &>(property);
			outputTriple(subject, resource, object, graph);
		} else {
			if (property.isVar()) {
				m_out.write(""exopred("", 8);
				property.visit(m_formatter);
				m_out.write("", "", 2);
			} else {
				// TODO throw error here?
				property.visit(m_formatter);
				m_out.put('(');
			}
			
			subject.visit(m_formatter);
			m_out.put(',').put(' ');
			object.visit(m_formatter);
			
			//if (property.isVar())
			m_out.put(')');

			++m_count;
		}
		
	}
	
	
	Optional<std::string> CN3Writer::extractPredicate(const GraphTemplate &graph)
	{
		if (graph.size() != 1)
			return Optional<std::string>::none;
		
		const N3Node &property = graph.begin()->property();
		if (!property.isURIResource())
			return Optional<std::string>::none;
		
		return Optional<std::string>(static_cast<const URIResource &>(property).uri());
	}
	
//	void CN3Writer::handleProperties(const GraphTemplate &graph)
//	{
//		for (const TriplePattern &t : graph) {
//			const N3Node &subject = t.subject();
//			if (subject.isGraphTemplate())
//				handleProperties(static_cast<const GraphTemplate &>(subject));
//			
//			const N3Node &property = t.property();
//			if (property.isURIResource()) {
//				const std::string &uri = static_cast<const URIResource &>(property).uri();
//				if (!(uri == LOG::implies.uri() || uri == LOG::reverseImplies.uri())) {
//					if (m_properties.insert(uri).second)
//						outputProperty(uri);
//				}
//			}
//			
//			const N3Node &object = t.object();
//			if (object.isGraphTemplate())
//				handleProperties(static_cast<const GraphTemplate &>(object));
//		}
//	}
	
}
",wrap
889,"// 作者：卜知道
// 时间：2023 02 13
// 网址：https://www.buzhidao.icu
// 相关主题：math

// time complexity: O(n)
// space complexity: O(1)
class Solution
{
public:
    void check_if_add(char &c, int &af)
    {
        if (c > '1')
        {
            c -= 2;
            af = 1;
        }
        else
            af = 0;
    }

    string addBinary(string a, string b)
    {
        int  [MASK]  = a.size();
        int len_b = b.size();
        if ( [MASK]  < len_b)
            return addBinary(b, a);

        // add b to a
        int add_flag = 0;
        int i = 0;
        for (; i < len_b; ++i)
        {
            int ai =  [MASK]  - 1 - i;
            int bi = len_b - 1 - i;
            a[ai] += b[bi] - '0' + add_flag;
            check_if_add(a[ai], add_flag);
        }

        // add carry
        while (i <  [MASK]  && add_flag)
        {
            ++a[ [MASK]  - 1 - i];
            check_if_add(a[ [MASK]  - 1 - i], add_flag);
            ++i;
        }

        // check if need add other char '1' to a
        return (add_flag ? ""1"" : """") + a;
    }
};",len_a
890,"#include <iostream>
#include ""video.h""
#include ""pelicula.h""
#include ""serie.h""
#include <typeinfo>
using namespace std;
int main() {
    int choice;
    vector<video*> videos;
    videos.push_back(new pelicula(1, ""<NAME>"", 1.5, ""accion"", 4.2));
    videos.push_back(new pelicula(2, ""Witches get stitches"", 2.1, ""misterio"", 3.2));
    videos.push_back(new pelicula(3, ""Aquella vez"", 2.3, ""drama"", 2.2));
    videos.push_back(new serie({1, 2, 3}, {5, 4.3, 4.0}, {""episodio 1"", ""episodio 2"", ""episodio 3""}, {1, 2, 3}, 4,
        ""Soul Train"", 23.0, ""misterio"", 4.3));
    videos.push_back(new serie({1, 2, 3}, {3.2, 2.9, 5.0},
        {""El Inicio"", ""Desarrollo"", ""Conclusión""}, {1, 2, 3}, 5,
        ""Sacred Tears"", 27.0, ""drama"", 3.2));
    videos.push_back(new serie({1, 2, 3}, {2.9, 2.2, 2.4}, {""Machine guns"", ""Crime and punishers"", ""The gun at the end of the tunnel""}, {1, 2, 3}, 6,
        ""Acclimated"", 29.0, ""accion"", 2.5));
    int  [MASK]  = -1;
    while ( [MASK]  != 0) {
        cout << ""\nMENU: "" << ""\n""
            << ""1) Mostrar los videos en general con una cierta calificación o de un cierto género \n""
            << ""2) Mostrar los episodios de una determinada serie con una calificacion determinada \n""
            << ""3) Mostrar las películas con cierta calificacion \n""
            << ""4) Calificar un video \n""
            << ""0) Salir"" << endl;

        cout << ""Opción de usuario: "";
        cin >>  [MASK] ;
        cout << endl;
        switch ( [MASK] ) {
            case 1:
            cout << ""Escoger un género (1. accion, 2. misterio, 3. drama) o calificación(4. 2 o mayor, 5. 3 o mayor 6. 4 o mayor)"" << endl;
            cin >> choice;
            if (choice == 1) {
                for (video* vid : videos) {
                    if (vid->getGenre() == ""accion"") {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 2) {
                for (video* vid : videos) {
                    if (vid->getGenre() == ""misterio"") {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 3) {
                for (video* vid : videos) {
                    if (vid->getGenre() == ""drama"") {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 4) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 2) {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 5) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 3) {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 6) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 4) {
                        vid->mostrarVideo();
                    }
                }
            }
            break;
            case 2:
            cout << ""Serie con calificación determinada"" << endl;
            cout << ""Escoger calificación 1. 2 o mayor, 2. 3 o mayor, 3. 4 o mayor"" << endl;
            cin >> choice;
            if (choice == 1) {
                for (video* vid : videos) {
                    if ((vid->getRatings() >= 2.0) && (typeid(*vid).name() == typeid(serie).name())) {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 2) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 3 && typeid(*vid).name() == typeid(serie).name()) {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 3) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 4 && typeid(*vid).name() == typeid(serie).name()) {
                        vid->mostrarVideo();
                    }
                }
            }
            break;
            case 3:
            cout << ""Películas con cierta calificación"" << endl;
            cout << ""Escoger calificación 1. 2 o mayor, 2. 3 o mayor, 3. 4 o mayor"" << endl;
            cin >> choice;
                if (choice == 1) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 2 && typeid(*vid).name() == typeid(pelicula).name()) {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 2) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 3 && typeid(*vid).name() == typeid(pelicula).name()) {
                        vid->mostrarVideo();
                    }
                }
            } else if (choice == 3) {
                for (video* vid : videos) {
                    if (vid->getRatings() >= 4 && typeid(*vid).name() == typeid(pelicula).name()) {
                        vid->mostrarVideo();
                    }
                }
            }
            break;
            case 4:
            cout << ""calificar un video, escoge un id"" << endl;
            int id;
            cin >> id;
                cout << ""Calificación"" << endl;
            double personalRating;
            cin >> personalRating;
            videos[id]->setRatings(personalRating);
            videos[id]->mostrarVideo();
            break;
            case 0:
            cout << ""Salir del programa."" << endl;
            break;
            default:
            cout << ""No es una opción"" << endl;
        }
    }
    return 0;
}",userInput
891,"#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include ""DHT.h""
#include <SoftwareSerial.h>
#include <String.h>

#define DHTPIN A0
#define DHTTYPE DHT11
#define trigPin 5
#define echoPin 4

DHT dht(DHTPIN, DHTTYPE);
RF24 radio(10, 9); // CE, CSN
SoftwareSerial myserial(3, 2);  

const byte addresses[][6] = {""00001"", ""00002""};
int avgTemp, avgHum, avgLevel;
int calibValue;                 //Measured height after fixing it on a height on street pole
int currentValue;

struct DataGate{
  byte temp;
  byte hum;
  int level;
};
struct DataNode1{
  byte temp;
  byte hum;
  int level;
};

DataNode1 dataN1;
DataGate dataG;

void setup() {
  myserial.begin(9600); 
  Serial.begin(9600);
  SPI.begin();
  radio.begin();
  radio.openWritingPipe(addresses[0]); // 00001
  radio.openReadingPipe(1, addresses[1]); // 00002
  radio.setPALevel(RF24_PA_MIN);
  radio.startListening();
  dht.begin();
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  CalibrationUltra();
}
void ShowSerialData()
{
  while (myserial.available() != 0)
    Serial.write(myserial.read());
  delay(1000);
 
}

// Fucntion for sending data using GET request
void GetRequest(){
  Serial.println("""");
  Serial.println(""********************"");
 
 /*******GSM Communication Starts*******/

  if (myserial.available())
  Serial.write(myserial.read());
 
  myserial.println(""AT"");
  delay(3000);

  myserial.println(""AT+CFUN=?"");
  delay(3000);
 
  myserial.println(""AT+SAPBR=3,1,\""Contype\"",\""GPRS\"""");
  delay(6000);
  ShowSerialData();
 
  myserial.println(""AT+CSTT=\""airtelgprs.com\"",\""\"",\""\"""");
  delay(6000);
  ShowSerialData();
 
  myserial.println(""AT+SAPBR=1,1"");
  delay(6000);
  ShowSerialData();

  myserial.println(""AT+HTTPINIT"");
  delay(6000);
  ShowSerialData();
 
  myserial.println(""AT+HTTPPARA=\""CID\"",1"");
  delay(6000);
  ShowSerialData();

  String str = ""AT+HTTPPARA=\""URL\"",\""http://floodgateway.herokuapp.com/data?gatewayid=1069&temperature=""+String(avgTemp)+""&humadity=""+String(avgHum)+""&waterlevel=""+String(avgLevel)+""\"""";
  //myserial.println(""AT+HTTPPARA=\""URL\"",\""http://floodgateway.herokuapp.com/data?gatewayid=1069&temperature=70&humadity=60&waterlevel=50\""""); //Server address
  myserial.println(str);
  delay(15000);
  ShowSerialData();
 
  myserial.println(""AT+HTTPACTION=0"");
  delay(20000);
  ShowSerialData();
 
  myserial.println(""AT+HTTPREAD"");
  delay(6000);
  ShowSerialData();
 
  myserial.println(""AT+HTTPTERM"");
  delay(10000);
  ShowSerialData;
 
  /*******GSM Communication Stops*******/
  
}

int ultra(){
  int  [MASK] ;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  int duration = pulseIn(echoPin, HIGH);
   [MASK]  = duration*0.034/2;
  return  [MASK] ;
}

void CalibrationUltra(){        //Taking intial measurment 
  int value;
  for(int i =0;i<5;i++){ 
    value = ultra();
    delay(500);
  }
  calibValue = value;
  Serial.print(""Calibrated Value: "");
  Serial.println(calibValue);
}

void loop() {

  dataG.hum = dht.readHumidity();
  dataG.temp = dht.readTemperature();
  currentValue = ultra();
  dataG.level = calibValue-currentValue;
  Serial.print(""Temperature Gate: "");
  Serial.println(dataG.temp);
  Serial.print(""Humidity Gate: "");
  Serial.println(dataG.hum);
  Serial.print(""Distance Gate: "");
  Serial.println(dataG.level);  
  if (radio.available()) {
    radio.read(&dataN1, sizeof(DataNode1));
    Serial.print(""Temperature: "");
    Serial.println(dataN1.temp);
    Serial.print(""Humidity: "");
    Serial.println(dataN1.hum);
    Serial.print(""Distance: "");
    Serial.println(dataN1.level);
  }

  avgTemp = (dataG.temp+dataN1.temp)/2;
  avgHum = (dataG.hum+dataN1.hum)/2;
  avgLevel = (dataG.level + dataN1.level)/2;
  Serial.print(""Average Temprature: "");
  Serial.println(avgTemp);
  Serial.print(""Average Humidity: "");
  Serial.println(avgHum);
  Serial.print(""Average Level: "");
  Serial.println(avgLevel);
  Serial.println(""*****************---------------------********************"");
  delay(4000);
  GetRequest();
}
",distance
892,"#include <iostream>
#include <algorithm>
#include <vector>
#include <unordered_set>

using namespace std;
typedef pair<int,int> iPair;
#define mp make_pair

vector<int> path;
unordered_set<int> graph[100001];
bool visited[100001];

int temp;

int main() {
    int n, m, temp, a, b;
    scanf(""%i %i"", &n, &m);
    for (int i = 0; i < n; i ++) {
        scanf(""%i"", &temp);
        path.push_back(temp);
    }

    for (int i = 0 ; i < m; i ++) {
        scanf(""%i %i"", &a, &b);
        graph[a].insert(b);
        graph[b].insert(a);
    }

    vector<int>  [MASK] ;
     [MASK] .push_back(1);
    bool found = false;
    visited[1] = 1;
    for (int i = 1; i < n; i ++) {
        int target = path[i];
        found = false;
        for (int p =  [MASK] .size() - 1; p >= 0; p --) {
            int parent =  [MASK] [p];
            if (graph[parent].find(target) != graph[parent].end()) {
                 [MASK] .push_back(target);
                found = true;
                visited[target] = 1;
                break;
            } else {
                for (auto it = graph[parent].begin(); it!= graph[parent].end(); it ++) {
                    if (!visited[*it]) {
                        printf(""0"");
                        return 0;
                    }
                }
                 [MASK] .pop_back();
            }
        }
        if (!found) {
            printf(""0"");
            return 0;
        }
    }
    printf(""1"");

}",currpath
893,"#include <GLFW/glfw3.h>
#include <cstdlib>
#include <windows.h>

int main(void)
{

    GLFWwindow* window;

    if (!glfwInit()) return -1;

    glfwWindowHint(GLFW_RESIZABLE, false);

    window = glfwCreateWindow(800, 800, ""joe"", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);

    float x = 0;
    float y = 0;

    bool right = true;

    float red = rand() / (float) RAND_MAX;
    float green = rand() / (float) RAND_MAX;
    float  [MASK]  = rand() / (float) RAND_MAX;

    while (!glfwWindowShouldClose(window))
    {
        glClear(GL_COLOR_BUFFER_BIT);

        glBegin(GL_QUADS);
        glColor3f(red, green,  [MASK] );
        glVertex2d(x-0.05, y+0.05);
        glVertex2d(x+0.05, y+0.05);
        glVertex2d(x+0.05, y-0.05);
        glVertex2d(x-0.05, y-0.05);
        glEnd();

        if (x >= 0.95 || x <= -0.95)  {
            right = !right;
            red = rand() / (float) RAND_MAX;
            green = rand() / (float) RAND_MAX;
             [MASK]  = rand() / (float) RAND_MAX;
        }

        if (y >= 0.95 || y <= -0.95) {
            y = 0;
            Beep(1500, 100);
        }

        if (right) x+=0.01;
        else x-=0.01;

        if (0 + (rand() % (1 - 0 + 1)) == 1) y+=0.005;
        else y-=0.005;

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}",blue
894,"#include<bits/stdc++.h>
using namespace std;
struct node{
	int key;
	node *left, *right;
};

node *newNode(int  [MASK] ){
	node *temp = new node;
	temp->key= [MASK] ;
	temp->left=temp->right=NULL;
	return temp;
}
void inorder(node *root){
	if(root !=NULL){
		inorder(root->left);
		cout<<root->key<<endl;
		inorder(root->right);
	}
}

node* insert( node* node, int key){
	if(node == NULL) return newNode(key);

	if(key<node->key) node->left=insert(node->left,key);
	else if(key>node->key) node->right=insert(node->right,key);
	
	return node;
}

node *minbst(node* root){
	while(root->left!=NULL){
	root = root->left;
	}
	return root;
}
node* deleteNode(node *root, int key){
	//If Empty Tree
	if(root==NULL) return root;
	//If the current node ain't the node to be deleted
	else if(key<root->key) root->left=deleteNode(root->left,key);
	else if(key>root->key) root->right=deleteNode(root->right,key);
	//If the current node is the node to be deleted
	else{
		//If node has 0/1 child
		if(root->left==NULL){
			node *temp = root->right;
			return temp;
		}
		else if(root->right==NULL){
			node *temp = root->left;
			return temp;
		}

		//If node has 2 children find the inorder successor of the right subtree and replace root with it

		node *temp = minbst(root->right);
		root->key=temp->key;
		root->right = deleteNode(root->right,temp->key);
	}
	return root;
}
int main(){
	int c;
	cin>>c;
	int y;
	// initializing first node as the root of the tree
	cin>>y;
	node *root= newNode(y);
	for(int i=0;i<c-1;i++){
		int x;
		cin>>x;
		insert(root,x);
		}
	cout<<""\nInorder Traversal of the BST is: \n"";
	inorder(root);
	cout<<""\nMin Value in BST is:""<<minbst(root)->key<<endl;
	cout<<""\nEnter a node value to delete: "";
	int x;
	cin>>x;
	deleteNode(root,x);
	cout<<""node deleted\n"";
	cout<<""Inorder Traversal of modified BST is: \n"";
	inorder(root);

	
	return 0;

}


",item
895,"/**
 * @file	pipe_pair.h
 * @author	<NAME> <<EMAIL>>
 * @date	2020/08/07
 * @copyright Copyright (C) 2020 jc-lab.\n
 *            This software may be modified and distributed under the terms
 *            of the Apache License 2.0.  See the LICENSE file for details.
 */

#include <atomic>
#include <vector>

#include <stdio.h>
#include <windows.h>
#include <accctrl.h>
#include <aclapi.h>

#include ""pipe_pair.h""

namespace jcu {
namespace process {
namespace windows {

int nextKey() {
  static std::atomic_int v(0);
  return v.fetch_add(1);
}

class CurrentUserToken {
 private:
  std::vector<BYTE> token_user_buf_;

 public:
  CurrentUserToken() {}

  DWORD init() {
    DWORD result = 0;
    HANDLE token_handle = NULL;

    do {
      DWORD buf_size = 0;

      if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token_handle)) {
        result = ::GetLastError();
        break;
      }

      if (!GetTokenInformation(token_handle, TokenUser, NULL, 0, &buf_size) &&
          (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
        result = ::GetLastError();
        break;
      }

      token_user_buf_.resize(buf_size);
      PTOKEN_USER token_user = reinterpret_cast<PTOKEN_USER>( &token_user_buf_[0] );

      //
      // Retrieve the token information in a TOKEN_USER structure
      //
      if (!GetTokenInformation(
          token_handle,
          TokenUser,
          token_user,
          buf_size,
          &buf_size)) {
        result = ::GetLastError();
        break;
      }
    } while (0);

    if (token_handle && (token_handle != INVALID_HANDLE_VALUE)) {
      ::CloseHandle(token_handle);
    }

    return result;
  }

  PTOKEN_USER getTokenUser() const {
    return (PTOKEN_USER) token_user_buf_.data();
  }
};

class SecurityDescriptorHelper {
 public:
  PACL acl_;
  PSECURITY_DESCRIPTOR sd_;

  SecurityDescriptorHelper()
      : acl_(nullptr), sd_(nullptr) {
  }

  ~SecurityDescriptorHelper() {
    cleanup(&sd_, &acl_);
  }

  PSECURITY_DESCRIPTOR getSecurityDescriptor() const {
    return sd_;
  }

  DWORD fromExplicitAccesses(EXPLICIT_ACCESS *ea, int count) {
    DWORD result;
    PACL new_acl = nullptr;
    PSECURITY_DESCRIPTOR  [MASK]  = nullptr;

    do {
      // Create a new ACL that contains the new ACEs.
      result = ::SetEntriesInAcl(count, ea, NULL, &new_acl);
      if (result != ERROR_SUCCESS) {
        break;
      }

      // Initialize a security descriptor.
       [MASK]  = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);
      if (! [MASK] ) {
        result = ::GetLastError();
        break;
      }

      if (!InitializeSecurityDescriptor( [MASK] , SECURITY_DESCRIPTOR_REVISION)) {
        result = ::GetLastError();
        break;
      }

      // Add the ACL to the security descriptor.
      if (!SetSecurityDescriptorDacl(
           [MASK] ,
          TRUE,// bDaclPresent flag
          new_acl,
          FALSE))// not a default DACL
      {
        result = ::GetLastError();
        break;
      }
    } while (0);

    if (result == ERROR_SUCCESS) {
      sd_ =  [MASK] ;
      acl_ = new_acl;
    } else {
      cleanup(& [MASK] , &new_acl);
    }

    return result;
  }

 private:
  void cleanup(PSECURITY_DESCRIPTOR *ppsd, PACL *ppacl) {
    if (ppsd && *ppsd) {
      ::LocalFree(*ppsd);
      *ppsd = nullptr;
    }
    if (ppacl && *ppacl) {
      ::LocalFree(*ppacl);
      *ppacl = nullptr;
    }
  }
};

PipePair::PipePair()
    : err_(0), rd_(nullptr), wr_(nullptr) {
  CurrentUserToken current_user_token;
  SecurityDescriptorHelper sd_helper;
  EXPLICIT_ACCESS ea[1] = {0};

  TCHAR pipename[MAX_PATH];
  // remote process anonymous
  _stprintf_s(pipename, _T(""\\\\.\\pipe\\rpa.%04x%04x%08x%08x""),
              ::GetCurrentProcessId() & 0xffff,
              ::GetCurrentThreadId() & 0xffff,
              ::GetTickCount(),
              nextKey()
  );

  err_ = current_user_token.init();
  if (err_) {
    return;
  }

  PTOKEN_USER token_user = current_user_token.getTokenUser();
  ea[0].grfAccessPermissions = GENERIC_ALL;
  ea[0].grfAccessMode = SET_ACCESS;
  ea[0].grfInheritance = NO_INHERITANCE;
  ea[0].Trustee.TrusteeForm = TRUSTEE_IS_SID;
  ea[0].Trustee.TrusteeType = TRUSTEE_IS_USER;
  ea[0].Trustee.ptstrName = (LPTSTR) token_user->User.Sid;
  err_ = sd_helper.fromExplicitAccesses(ea, 1);
  if (err_) {
    return;
  }

  SECURITY_ATTRIBUTES sa = {0};
  sa.nLength = sizeof(sa);
  sa.lpSecurityDescriptor = sd_helper.getSecurityDescriptor();
  sa.bInheritHandle = FALSE;

  rd_ = ::CreateNamedPipe(
      pipename,
      PIPE_ACCESS_INBOUND,
      PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
      1,
      128,
      128,
      3000,
      &sa
  );
  if (!rd_ || (rd_ == INVALID_HANDLE_VALUE)) {
    err_ = ::GetLastError();
    return;
  }

  wr_ = ::CreateFile(
      pipename,
      GENERIC_WRITE,
      0,
      nullptr,
      OPEN_EXISTING,
      FILE_FLAG_NO_BUFFERING,
      nullptr
  );
  if (!wr_ || (wr_ == INVALID_HANDLE_VALUE)) {
    err_ = ::GetLastError();
    return;
  }
}
PipePair::~PipePair() {
  close();
}
void PipePair::close() {
  if (wr_ && wr_ != INVALID_HANDLE_VALUE) {
    ::CloseHandle(wr_);
    wr_ = nullptr;
  }
  if (rd_ && rd_ != INVALID_HANDLE_VALUE) {
    ::CloseHandle(rd_);
    rd_ = nullptr;
  }
}
HANDLE PipePair::getWriteHandle() {
  return wr_;
}
HANDLE PipePair::getReadHandle() {
  return rd_;
}
HANDLE PipePair::detachWriteHandle() {
  HANDLE h = wr_;
  wr_ = nullptr;
  return h;
}
HANDLE PipePair::detachReadHandle() {
  HANDLE h = rd_;
  rd_ = nullptr;
  return h;
}
HANDLE PipePair::detachInheritableWriteHandle() {
  HANDLE handle = nullptr;
  if (!DuplicateHandle(
      GetCurrentProcess(), wr_,
      GetCurrentProcess(), &handle, 0,
      TRUE, DUPLICATE_SAME_ACCESS)) {
    err_ = ::GetLastError();
    return nullptr;
  }
  wr_ = nullptr;
  return handle;
}
HANDLE PipePair::detachInheritableReadHandle() {
  HANDLE handle = nullptr;
  if (!DuplicateHandle(
      GetCurrentProcess(), rd_,
      GetCurrentProcess(), &handle, 0,
      TRUE, DUPLICATE_SAME_ACCESS)) {
    err_ = ::GetLastError();
    return nullptr;
  }
  rd_ = nullptr;
  return handle;
}

} // namespace windows
} // namespace process
} // namespace jcu
",new_sd
896,"#include <iostream>
#include <cstring>
#include <fstream>
#include <cstdlib>
#include <cmath>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <thread>

using namespace std;

int main(int argc, char const *argv[]) {

  char *nameOrIpAddress = (char*)malloc(1024*sizeof(char));
  char *saveDir = (char*)malloc(1024*sizeof(char));
  char *startingURL = (char*)malloc(1024*sizeof(char));
  int serverPort,  [MASK] , numOfThreads;

  thread *threadPool = (thread)malloc(numOfThreads*sizeof(thread));

  /*Checking arguments*/
  if (argc==9) {
    printf(""Extended arguments provided by user\n"");
    strcpy(nameOrIpAddress,argv[2]);
    serverPort = atoi(argv[4]);
     [MASK]  = atoi(argv[6]);
    numOfThreads = atoi(argv[8]);
    strcpy(saveDir,argv[10]);
    strcpy(startingURL,argv[11]);
  }
  else
    printf(""Incorrect number of arguments. Please execute the program in this way:\n ./mycrawler -h host_or_IP -p port -c command_port -t num_of_threads -d save_dir starting_URL\n Exiting...\n"" );
  /*Finished Checking arguments*/

}
",commandPort
897,"#include <TutorialUtils.hpp>

#ifdef N_MAC_OSX_FRAMEWORKS
	#include <NCore/NCore.hpp>
	#include <NBiometricClient/NBiometricClient.hpp>
	#include <NBiometrics/NBiometrics.hpp>
	#include <NMedia/NMedia.hpp>
	#include <NLicensing/NLicensing.hpp>
#else
	#include <NCore.hpp>
	#include <NBiometricClient.hpp>
	#include <NBiometrics.hpp>
	#include <NMedia.hpp>
	#include <NLicensing.hpp>
#endif
#include <iostream>
#include <fstream>
#include <string>
#include<stdio.h>

using namespace std;
using namespace Neurotec;
using namespace Neurotec::Licensing;
using namespace Neurotec::Biometrics;
using namespace Neurotec::Biometrics::Client;

const NChar title[] = N_T(""VerifyFinger"");
const NChar description[] = N_T(""Demonstrates fingerprint verification."");
const NChar version[] = N_T(""12.2.0.0"");
const NChar copyright[] = N_T(""Copyright (C) 2016-2021 Neurotechnology"");

int usage()
{
	cout << ""usage:"" << endl;
	cout << ""\t"" << title << "" [reference image] [candidate image] "" << endl;
	return 1;
}

static NSubject CreateSubject(const NStringWrapper& fileName, const NStringWrapper& subjectId)
{
	NSubject subject;
	subject.SetId(subjectId);
	NFinger finger;
	finger.SetFileName(fileName);
	subject.GetFingers().Add(finger);
	return subject;
}

int main(int argc, NChar **argv)
{
	OnStart(title, description, version, copyright, argc, argv);
	//=========================================================================
	// CHOOSE LICENCES !!!
	//=========================================================================
	// ONE of the below listed ""licenses"" lines is required for unlocking this sample's functionality. Choose licenses that you currently have on your device.
	// If you are using a TRIAL version - choose any of them.

	const NChar * licenses = { N_T(""FingerMatcher,FingerExtractor"") };
	//const NChar * licenses = { N_T(""FingerMatcher,FingerClient"") };
	//const NChar * licenses = { N_T(""FingerFastMatcher,FingerFastExtractor"") };

	//=========================================================================

	//=========================================================================
	// TRIAL MODE
	//=========================================================================
	// Below code line determines whether TRIAL is enabled or not. To use purchased licenses, don't use below code line.
	// GetTrialModeFlag() method takes value from ""Bin/Licenses/TrialFlag.txt"" file. So to easily change mode for all our examples, modify that file.
	// Also you can just set TRUE to ""TrialMode"" property in code.

	NLicenseManager::SetTrialMode(GetTrialModeFlag());
	cout << ""Trial mode: "" << NLicenseManager::GetTrialMode() << endl;

	//=========================================================================

	int total_identity_evaluated = 5;  // 120
	int  [MASK]  = 3; // 10
	try
	{
		// Obtain licenses
		if (!NLicense::Obtain(N_T(""/local""), N_T(""5000""), licenses))
		{
			NThrowException(NString::Format(N_T(""Could not obtain licenses: {S}""), licenses)); 
		}

		for (int a = 1;a <= total_identity_evaluated;a++) {
			cout << a << endl;
			for (int b = 1;b <=  [MASK] ;b++) {
				string srcdir1 = ""cfpose/""+std::to_string(a) + ""_"" + std::to_string(b) + "".jpg"";
				cout << srcdir1 << endl;
				for (int c = a;c <= total_identity_evaluated;c++) {
					for (int d = 1;d <=  [MASK] ;d++) {
						if (((c == a) && (d > b)) || (c > a)) {
							string srcdir2 = ""cfpose/"" + std::to_string(c) + ""_"" + std::to_string(d) + "".jpg"";

							// NSubject referenceSubject = CreateSubject(argv[1], argv[1]);
							// NSubject candidateSubject = CreateSubject(argv[2], argv[2]);
							NSubject referenceSubject = CreateSubject(srcdir1, srcdir1);
							NSubject candidateSubject = CreateSubject(srcdir2, srcdir2);
							NBiometricClient biometricClient;
							biometricClient.SetMatchingThreshold(30); // 48
							biometricClient.SetFingersMatchingSpeed(nmsHigh); //nmsLow
							NBiometricStatus status = biometricClient.Verify(referenceSubject, candidateSubject);
							if (status == nbsOk || status == nbsMatchNotFound)
							{
								ofstream outfile;
								outfile.open(""data.txt"", ios::app);
								float score = referenceSubject.GetMatchingResults().Get(0).GetScore();
								cout << ""Image score "" << score << "", verification "";
								outfile << a << ""_"" << b << "" ""<< c<<""_"" <<d <<"" "" << score << ""\n"";
								outfile.close();
								if (status == nbsOk)
								{
									cout << ""succeeded"" << endl;
								}
								else
								{
									cout << ""failed"" << endl;
								}
							}
							else
							{
								cout << ""Verification failed. Status: "" << NEnum::ToString(NBiometricTypes::NBiometricStatusNativeTypeOf(), status) << endl;
								return -1;
							}
						}
					}
				}
			}
		}
	}
	
	catch (NError& ex)
	{
		return LastError(ex);
	}
	OnExit();
	return 0;
}
",sample_num_per_identity
898,"#include ""rclcpp/rclcpp.hpp""
#include ""quadruped_gait_planner/GaitPlanner.hpp""

#include <memory>
#include <chrono>
#include <cstdlib>
#include <cmath>

using namespace std::chrono_literals;
using std::placeholders::_1;
using std::placeholders::_2;

GaitPlanner::GaitPlanner() : Node(""gait_planner_node"")
{
  RCLCPP_INFO(this->get_logger(), ""Gait Planner node initialized"");

  _enable_gait_planner_service = this->create_service<std_srvs::srv::Empty>(""enable_gait_planner"",
                                       std::bind(&GaitPlanner::enableGaitPlanner, this, _1, _2));
  _disable_gait_planner_service = this->create_service<std_srvs::srv::Empty>(""disable_gait_planner"",
                                        std::bind(&GaitPlanner::disableGaitPlanner, this, _1, _2));
  _gait_parameters_service = this->create_service<quadruped_gait_planner::srv::GaitParameters>(""set_gait_parameters"", 
                                   std::bind(&GaitPlanner::setGaitParameters, this, _1, _2));

  _cmd_ik_publisher = this->create_publisher<quadruped_kinematics::msg::QuadrupedIK>(""cmd_ik"", 10);
  _publish_ik_timer = this->create_wall_timer(10ms, std::bind(&GaitPlanner::publishIKCallback, this));

  _cmd_vel_subscriber = this->create_subscription<geometry_msgs::msg::Twist>(""cmd_vel"", 10, std::bind(&GaitPlanner::cmdVelCallback, this, _1));

  _last_time = this->get_clock()->now();

  _amplitude_r = Eigen::Vector4d::Random();
  _phase_theta = Eigen::Vector4d::Random();

  _ik_msg.use_feet_transforms = true;  

  std::map<std::string, double>  [MASK]  = { 
    {""coupling_weight"", 1.0},
    {""amplitude"", 1.0},
    {""swing_frequency"", 2.5},
    {""stance_frequency"", 1.5},
    {""convergence_factor"", 50.0},
    {""ground_clearance"", 0.05},
    {""ground_penetration"", 0.005},
  };
  
  this->declare_parameter(""gait_type"", ""trot"");
  this->declare_parameters(""gait_parameters"",  [MASK] );

  this->get_parameter(""gait_type"", _gait_type);
  setGaitType(_gait_type);
  updateGaitParameters();

}

GaitPlanner::~GaitPlanner()
{
}

void GaitPlanner::publishIKCallback()
{
  float dt = this->get_clock()->now().seconds() - _last_time.seconds();

  _amplitude_d2r = _convergence_factor_a.array() * (_convergence_factor_a.array() / 4.0 * (_amplitude_mu.array() - _amplitude_r.array()) - _amplitude_dr.array());
  _amplitude_dr += _amplitude_d2r * dt;

  for (int i=0; i<4; i++)
  {
    _phase_theta(i) < M_PI ? _frequency_omega(i) = 2*M_PI * _gait_parameters[""swing_frequency""] : _frequency_omega(i) = 2*M_PI * _gait_parameters[""stance_frequency""];
    _phase_dtheta(i) = _frequency_omega(i);
    for (int j=0; j<4; j++)
      _phase_dtheta(i) += _amplitude_r(j) * _coupling_weights(i,j) * sin(_phase_theta(j) - _phase_theta(i) - _coupling_matrix(i,j));
  }

  _amplitude_r += _amplitude_dr * dt;
  _phase_theta += _phase_dtheta * dt;

  for (int i=0; i<4; i++)
  {
    _phase_theta(i) = std::fmod(_phase_theta(i), 2*M_PI);
    sin(_phase_theta(i)) > 0 ? _ground_multiplier(i) = _ground_clearance : _ground_multiplier(i) = _ground_penetration;
  }

  Eigen::Vector4d foot_x = -_d_step_x.array() * _amplitude_r.array() * _phase_theta.array().cos();
  Eigen::Vector4d foot_y = -_d_step_y.array() * _amplitude_r.array() * _phase_theta.array().cos();
  Eigen::Vector4d foot_z = _ground_multiplier.array() * _phase_theta.array().sin();

  _ik_msg.front_left_foot.x = foot_x(0);
  _ik_msg.front_left_foot.y = foot_y(0);
  _ik_msg.front_left_foot.z = foot_z(0);

  _ik_msg.front_right_foot.x = foot_x(1);
  _ik_msg.front_right_foot.y = foot_y(1);
  _ik_msg.front_right_foot.z = foot_z(1);

  _ik_msg.rear_left_foot.x = foot_x(2);
  _ik_msg.rear_left_foot.y = foot_y(2);
  _ik_msg.rear_left_foot.z = foot_z(2);

  _ik_msg.rear_right_foot.x = foot_x(3);
  _ik_msg.rear_right_foot.y = foot_y(3);
  _ik_msg.rear_right_foot.z = foot_z(3);
  
  _cmd_ik_publisher->publish(_ik_msg);

  _last_time = this->get_clock()->now();
}

void GaitPlanner::cmdVelCallback(const geometry_msgs::msg::Twist::SharedPtr msg)
{
  _d_step_x.setConstant(msg->linear.x * (1.0/_gait_parameters[""stance_frequency""]) / 4.0);
  _d_step_y.setConstant(msg->linear.y * (1.0/_gait_parameters[""stance_frequency""]) / 4.0);

  float delta_angular = 0.188 * msg->angular.z * (1.0/_gait_parameters[""stance_frequency""]) / 4.0;
  
  _d_step_x(0) -= delta_angular;
  _d_step_y(0) += delta_angular;

  _d_step_x(1) += delta_angular;
  _d_step_y(1) += delta_angular;
  
  _d_step_x(2) -= delta_angular;
  _d_step_y(2) -= delta_angular;
  
  _d_step_x(3) += delta_angular;
  _d_step_y(3) -= delta_angular;

}

void GaitPlanner::enableGaitPlanner(const std_srvs::srv::Empty::Request::SharedPtr request,
                                          std_srvs::srv::Empty::Response::SharedPtr response)
{
  (void) request;
  (void) response;
  _publish_ik_timer->reset();
  RCLCPP_INFO(this->get_logger(), ""Gait planner enabled"");
}

void GaitPlanner::disableGaitPlanner(const std_srvs::srv::Empty::Request::SharedPtr request,
                                           std_srvs::srv::Empty::Response::SharedPtr response)
{
  (void) request;
  (void) response;
  _publish_ik_timer->cancel();
  RCLCPP_INFO(this->get_logger(), ""Gait planner disabled"");
}

void GaitPlanner::setGaitParameters(const std::shared_ptr<quadruped_gait_planner::srv::GaitParameters::Request> request,
                                          std::shared_ptr<quadruped_gait_planner::srv::GaitParameters::Response> response)
{
  this->set_parameters({rclcpp::Parameter(""gait_type"", request->gait_type),
                        rclcpp::Parameter(""coupling_weight"", request->coupling_weight),
                        rclcpp::Parameter(""amplitude"", request->amplitude),
                        rclcpp::Parameter(""swing_frequency"", request->swing_frequency),
                        rclcpp::Parameter(""stance_frequency"", request->stance_frequency),
                        rclcpp::Parameter(""convergence_factor"", request->convergence_factor),
                        rclcpp::Parameter(""ground_clearance"", request->ground_clearance),
                        rclcpp::Parameter(""ground_penetration"", request->ground_penetration)
                      });
  response->success = this->setGaitType(request->gait_type);
  if (response->success)
    this->updateGaitParameters();
}

bool GaitPlanner::setGaitType(std::string gait_type)
{
  if (gait_type == ""trot"")
  {
    _coupling_matrix << 0, M_PI, M_PI, 0,
                       -M_PI, 0, 0, -M_PI,
                       -M_PI, 0, 0, -M_PI,
                        0, M_PI, M_PI, 0;
  }
  else if (gait_type == ""walk"")
  {
    _coupling_matrix << 0, M_PI, M_PI_2, 3*M_PI_2,
                       -M_PI, 0, -M_PI_2, -3*M_PI_2,
                       -M_PI_2, M_PI_2, 0, -M_PI,
                       -3*M_PI_2, 3*M_PI_2, M_PI, 0;
  }
  else if (gait_type == ""pace"")
  {
    _coupling_matrix << 0, M_PI, M_PI, M_PI,
                       -M_PI, 0, -M_PI, 0,
                        0, M_PI, 0, M_PI,
                       -M_PI, 0, -M_PI, 0;
  }
  else if (gait_type == ""gallop"")
  {
    _coupling_matrix << 0, 0, -M_PI, -M_PI,
                        0, 0, -M_PI, -M_PI,
                        M_PI, M_PI, 0, 0,
                        M_PI, M_PI, 0, 0;
  }
  else
  {
    RCLCPP_WARN(this->get_logger(), ""Impossible to set '%s' gait type. Ignoring..."", gait_type.c_str());
    return false;
  }
  return true;
}

void GaitPlanner::updateGaitParameters()
{
  this->get_parameters(""gait_parameters"", _gait_parameters);

  _coupling_weights.setConstant(_gait_parameters[""coupling_weight""]);
  _amplitude_mu.setConstant(_gait_parameters[""amplitude""]);
  _frequency_omega.setConstant(2*M_PI * _gait_parameters[""stance_frequency""]);
  _convergence_factor_a.setConstant(_gait_parameters[""convergence_factor""]);
  _ground_clearance = _gait_parameters[""ground_clearance""];
  _ground_penetration = _gait_parameters[""ground_penetration""];
}

int main(int argc, char **argv)
{
  rclcpp::init(argc, argv);
  auto node = std::make_shared<GaitPlanner>();
  rclcpp::spin(node);
  rclcpp::shutdown();
  return 0;
}
",default_gait_parameters
899,"#pragma once

#include <cstdlib>
#include <vector>
#include <stdexcept>
#include <array>

#include <boost/thread/mutex.hpp>
#include <boost/thread/lock_factories.hpp>

#include <windows.h>

#pragma warning(push)
#pragma warning(disable: 4996)
#include ""./vstsdk2.4/pluginterfaces/vst2.x/aeffectx.h""
#pragma warning(pop)

#include <balor/system/Module.hpp>
#include <balor/String.hpp>
#include <balor/locale/Charset.hpp>
#include <balor/gui/Control.hpp>
#include <balor/io/File.hpp>

#include ""./HostApplication.hpp""


namespace hwm {

//! VSTプラグインを表すクラス
struct VstPlugin
{
    //! VSTプラグインのエントリポイントを表す関数の型
    //! audioMasterCallbackというホスト側のコールバック関数を
    //! 渡してこの関数を呼び出すとAEffect *というVSTプラグインの
    //! Cインターフェースのオブジェクトが返る。
	typedef AEffect * (VstPluginEntryProc)(audioMasterCallback callback);

	VstPlugin(
		balor::String  [MASK] ,
		size_t sampling_rate,
		size_t block_size,
		HostApplication *hostapp )
		:	module_( [MASK] .c_str())
		,	hostapp_(hostapp)
		,	is_editor_opened_(false)
		,	events_(0)
	{
		if(!module_) { throw std::runtime_error(""module not found""); }
		initialize(sampling_rate, block_size);
		directory_ = balor::locale::Charset(932, true).encode(module_.directory());
	}

	~VstPlugin()
	{
		terminate();
	}

public:
	AEffect *GetEffect() { return effect_; }
	AEffect *GetEffect() const { return effect_; }

	bool	IsSynth() const { return (effect_->flags & effFlagsIsSynth) != 0; }
	bool	HasEditor() const { return (effect_->flags & effFlagsHasEditor) != 0; }

	void	OpenEditor(balor::gui::Control &parent)
	{
		parent_ = &parent;
		dispatcher(effEditOpen, 0, 0, parent_->handle(), 0);

        //! プラグインのエディターウィンドウを開く際に指定した親ウィンドウのサイズを
        //! エディターウィンドウに合わせるために、エディターウィンドウのサイズを取得する。
		ERect *rect;
		dispatcher(effEditGetRect, 0, 0, &rect, 0);

		SetWindowSize(rect->right - rect->left, rect->bottom - rect->top);

		parent.visible(true);
		is_editor_opened_ = true;
	}

	void	CloseEditor()
	{
		dispatcher(effEditClose, 0, 0, 0, 0);
		is_editor_opened_ = false;
		parent_ = nullptr;
	}

	bool	IsEditorOpened() const { return is_editor_opened_; }

    //! ホストのコールバック関数にリサイズ要求が来た際は
    //! HostApplicationクラスのハンドラによってこの関数が呼ばれる
	void	SetWindowSize(size_t width, size_t height)
	{
		parent_->size(
			parent_->sizeFromClientSize(balor::Size(width, height))
			);
	}

    //! AEffect *というプラグインのCインターフェースオブジェクトを経由して、
    //! 実際のVSTプラグイン本体に命令を投げるには、
    //! opcodeとそれに付随するパラメータを渡して、
    //! dispatcherという関数を呼び出す。
	VstIntPtr dispatcher(VstInt32 opcode, VstInt32 index, VstIntPtr value, void *ptr, float opt) {
		return effect_->dispatcher(effect_, opcode, index, value, ptr, opt);
	}

	VstIntPtr dispatcher(VstInt32 opcode, VstInt32 index, VstIntPtr value, void *ptr, float opt) const {
		return effect_->dispatcher(effect_, opcode, index, value, ptr, opt);
	}

	HostApplication & GetHost() { return *hostapp_; }
	HostApplication const & GetHost() const { return *hostapp_; }
	std::string	GetEffectName() const { return effect_name_; }
	char const * GetDirectory() const { return directory_.c_str(); }

	size_t GetProgram() const { dispatcher(effGetProgram, 0, 0, 0, 0); }
	void SetProgram(size_t index) { dispatcher(effSetProgram, 0, index, 0, 0); }
	size_t GetNumPrograms() const { return effect_->numPrograms; }
	std::string GetProgramName(size_t index) { return program_names_[index]; }

    //! ノートオンを受け取る
    //! 実際のリアルタイム音楽アプリケーションでは、
    //! ここでノート情報だけはなくさまざまなMIDI情報を
    //! 正確なタイミングで記録するようにする。
    //! 簡単のため、このアプリケーションでは、
    //! ノート情報を随時コンテナに追加し、
    //! 次の合成処理のタイミングで内部VSTプラグイン
    //! にデータが送られることを期待する実装になっている。
	void AddNoteOn(size_t note_number)
	{
		VstMidiEvent event;
		event.type = kVstMidiType;
		event.byteSize = sizeof(VstMidiEvent);
		event.flags = kVstMidiEventIsRealtime;
		event.midiData[0] = static_cast<char>(0x90u);		// note on for 1st channel
		event.midiData[1] = static_cast<char>(note_number);	// note number
		event.midiData[2] = static_cast<char>(0x64u);		// velocity
		event.midiData[3] = 0;				// unused
		event.noteLength = 0;
		event.noteOffset = 0;
		event.detune = 0;
		event.deltaFrames = 0;
		event.noteOffVelocity = 100;
		event.reserved1 = 0;
		event.reserved2 = 0;

		auto lock = get_event_buffer_lock();
		midi_events_.push_back(event);
	}

    //! ノートオンと同じ。
	void AddNoteOff(size_t note_number)
	{
		VstMidiEvent event;
		event.type = kVstMidiType;
		event.byteSize = sizeof(VstMidiEvent);
		event.flags = kVstMidiEventIsRealtime;
		event.midiData[0] = static_cast<char>(0x80u);		// note on for 1st channel
		event.midiData[1] = static_cast<char>(note_number);	// note number
		event.midiData[2] = static_cast<char>(0x64u);		// velocity
		event.midiData[3] = 0;				// unused
		event.noteLength = 0;
		event.noteOffset = 0;
		event.detune = 0;
		event.deltaFrames = 0;
		event.noteOffVelocity = 100;
		event.reserved1 = 0;
		event.reserved2 = 0;

		auto lock = get_event_buffer_lock();
		midi_events_.push_back(event);
	}

    //! オーディオの合成処理に先立ち、
    //! MIDI情報をVSTプラグイン本体に送る。
    //! この処理は下のProcesAudioと同期的に行われるべき。
    //! つまり、送信するべきイベントがある場合は、
    //! ProcessAudioの直前に一度だけこの関数が呼ばれるようにする。
	void ProcessEvents()
	{
		{
			auto lock = get_event_buffer_lock();
            //! 送信用データをVstPlugin内部のバッファに移し替え。
			std::swap(tmp_, midi_events_);
		}

        //! 送信データがなにも無ければ返る。
		if(tmp_.empty()) { return; }

        //! VstEvents型は、内部の配列を可変長配列として扱うので、
        //! 送信したいMIDIイベントの数に合わせてメモリを確保
        //! VstEvents型に、もともとVstEventのポインタ二つ分の領域が含まれているので、
        //! 実際に確保するメモリ量は送信するイベント数から二つ引いたもので計算している。
        //!
		//! ここで確保したメモリは
        //! processReplacingが呼び出された後で解放する。
		size_t const bytes = sizeof(VstEvents) + sizeof(VstEvent *) * std::max<size_t>(tmp_.size(), 2) - 2;
		events_ = (VstEvents *)malloc(bytes);
		for(size_t i = 0; i < tmp_.size(); ++i) {
			events_->events[i] = reinterpret_cast<VstEvent *>(&tmp_[i]);
		}
		events_->numEvents = tmp_.size();
		events_->reserved = 0;

        //! イベントを送信。
		dispatcher(effProcessEvents, 0, 0, events_, 0);
	}
	
    //! オーディオ合成処理
	float ** ProcessAudio(size_t frame)
	{
		BOOST_ASSERT(frame <= output_buffers_[0].size());

        //! 入力バッファ、出力バッファ、合成するべきサンプル時間を渡して
        //! processReplacingを呼び出す。
        //! もしプラグインがdouble精度処理に対応しているならば、
        //! 初期化の段階でeffProcessPrecisionでkVstProcessPrecision64を指定し、
        //! 扱うデータ型もfloatではなくdoubleとし、
        //! ここでprocessReplacingの代わりにprocessReplacingDoubleを使用する。
		effect_->processReplacing(effect_, input_buffer_heads_.data(), output_buffer_heads_.data(), frame);

        //! 合成終了なので
        //! effProcessEventsで送信したデータを解放する。
		tmp_.clear();
		free(events_);
		events_ = nullptr;

		return output_buffer_heads_.data();
	}

private:
    //! プラグインの初期化処理
	void initialize(size_t sampling_rate, size_t block_size)
	{
        //! エントリポイント取得
		VstPluginEntryProc * proc = module_.getFunction<VstPluginEntryProc>(""VSTPluginMain"");
		if(!proc) {
            //! 古いタイプのVSTプラグインでは、
            //! エントリポイント名が""main""の場合がある。
			proc = module_.getFunction<VstPluginEntryProc>(""main"");
			if(!proc) { throw std::runtime_error(""entry point not found""); }
		}

		AEffect *test = proc(&hwm::VstHostCallback);
		if(!test || test->magic != kEffectMagic) { throw std::runtime_error(""not a vst plugin""); }

		effect_ = test;
        //! このアプリケーションでAEffect *を扱いやすくするため
        //! AEffectのユーザーデータ領域にこのクラスのオブジェクトのアドレスを
        //! 格納しておく。
		effect_->user = this;

        //! プラグインオープン
		dispatcher(effOpen, 0, 0, 0, 0);
        //! 設定系
		dispatcher(effSetSampleRate, 0, 0, 0, static_cast<float>(sampling_rate));
		dispatcher(effSetBlockSize, 0, block_size, 0, 0.0);
		dispatcher(effSetProcessPrecision, 0, kVstProcessPrecision32, 0, 0);
        //! プラグインの電源オン
		dispatcher(effMainsChanged, 0, true, 0, 0);
        //! processReplacingが呼び出せる状態に
		dispatcher(effStartProcess, 0, 0, 0, 0);

        //! プラグインの入力バッファ準備
		input_buffers_.resize(effect_->numInputs);
		input_buffer_heads_.resize(effect_->numInputs);
		for(int i = 0; i < effect_->numInputs; ++i) {
			input_buffers_[i].resize(block_size);
			input_buffer_heads_[i] = input_buffers_[i].data();
		}

        //! プラグインの出力バッファ準備
		output_buffers_.resize(effect_->numOutputs);
		output_buffer_heads_.resize(effect_->numOutputs);
		for(int i = 0; i < effect_->numOutputs; ++i) {
			output_buffers_[i].resize(block_size);
			output_buffer_heads_[i] = output_buffers_[i].data();
		}

        //! プラグイン名の取得
		std::array<char, kVstMaxEffectNameLen+1> namebuf = {};
		dispatcher(effGetEffectName, 0, 0, namebuf.data(), 0);
		namebuf[namebuf.size()-1] = '\0';
		effect_name_ = namebuf.data();

        //! プログラム(プラグインのパラメータのプリセット)リスト作成
		program_names_.resize(effect_->numPrograms);
		std::array<char, kVstMaxProgNameLen+1> prognamebuf = {};
		for(int i = 0; i < effect_->numPrograms; ++i) {
			VstIntPtr result = 
				dispatcher(effGetProgramNameIndexed, i, 0, prognamebuf.data(), 0);
			if(result) {
				prognamebuf[prognamebuf.size()-1] = '\0';
				program_names_[i] = std::string(prognamebuf.data());
			} else {
				program_names_[i] = ""unknown"";
			}
		}
	}

    //! 終了処理
	void terminate()
	{
		if(IsEditorOpened()) {
			CloseEditor();
		}
	
		dispatcher(effStopProcess, 0, 0, 0, 0);
		dispatcher(effMainsChanged, 0, false, 0, 0);
		dispatcher(effClose, 0, 0, 0, 0);
	}

private:
	HostApplication *hostapp_;
	balor::system::Module module_;
	balor::gui::Control *parent_;
	AEffect *effect_;

	std::vector<std::vector<float>>	output_buffers_;
	std::vector<std::vector<float>> input_buffers_;
	std::vector<float *>			output_buffer_heads_;
	std::vector<float *>			input_buffer_heads_;
	boost::mutex mutable			event_buffer_mutex_;
	std::vector<VstMidiEvent>		midi_events_;
	bool							is_editor_opened_;
	std::string						effect_name_;
	std::string						directory_;
	std::vector<std::string>		program_names_;
	std::vector<VstMidiEvent> tmp_;
	VstEvents *events_;

	boost::unique_lock<boost::mutex>
			get_event_buffer_lock() const { return boost::make_unique_lock(event_buffer_mutex_); }
};

}

",module_path
900,"#include <vector>
#include <numeric>
#include ""Nutrition.h""

NutritionalValues operator+(const NutritionalValues &lhs, const NutritionalValues &rhs) {
    NutritionalValues temp{};
    temp.calories = lhs.calories + rhs.calories;
    temp.salt = lhs.salt + rhs.salt;
    return temp;
}

struct NutritionalTotals {
    std::vector<NutritionalValues> values;
};

static NutritionalTotals CurrentRunValues;

float GetTotalCalories() {
    float total_cals;
    for (auto &val: CurrentRunValues.values) {
        total_cals += val.calories;
    }
    return total_cals;
}

float GetTotalSalt() {
    float  [MASK] ;
    for (auto &val: CurrentRunValues.values) {
         [MASK]  += val.salt;
    }
    return  [MASK] ;
}


void NewDay() {
    CurrentRunValues.values.clear();
}

void Eat(const NutritionalValues &value) {

    CurrentRunValues.values.push_back(value);
}",total_salt
901,"#pragma once
#include <assert.h>



namespace Gear {
  struct Jump {
    //uint16_t count;
    int64_t count;
    int16_t delta;
    int error;
  };

  // encoder counts where we have our next and previous jumps
  struct Jumps{
    int next;
    int prev;
    int last;
  };


  // need a set nominator/denominator that checks to ensure the slope < 1 for bresenham
  
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored ""-Wnarrowing""  
  // Narrowing comes due to integer promotion in arithmetic operations
  // k, the encoder count delta for the next step pulse, should fit within a short integer
  static int32_t k;

  inline Jump next_jump_forward(int d, int n, int e, int64_t count) {
    //assert(d != 0);
    //assert(n != 0);
    // k = encoder_pulses per step
    k = (d - 2 * e + 2 * n - 1) / (2 * n);
    return {count + k, k, e + k * n - d};
  }

  inline Jump next_jump_reverse(int d, int n, int e, int64_t count) {
    // k = encoder_pulses per step
    k = 1 + ((d + 2 * e) / (2 * n));
    return {count - k, k, e - k * n + d};
  }

  struct State {
    int D, N; // pulse ratio : N/D
    //int err = 0;
    int nerror = 0;
    int perror = 0;
    // what units is this, seems to be encoder tics
    int output_position = 0;
    Jumps jumps = {0,0,0};
    static int next;
    static int prev;
    static int last;

    // TODO: stop using the 2nd arg, it has to be true
    void calc_jumps(int  [MASK] ,bool dir = true){
      if(D == 0 || N == 0){
        //printf(""D: %d N: %d calc_jumps exiting"",N,D);
        // TODO: how to prevent this condition?
        return;
      }
      Jump nx = next_jump_forward(D,N,nerror, [MASK] );
      Jump px = next_jump_reverse(D,N,perror, [MASK] ); 
      next =  nx.count;
      last =  [MASK] ;
      nerror = nx.error;
      if(dir){
          prev = px.count;
          perror = nx.error + D -N;
      }
      // this doesn't seem to work for !dir 
      /*
      else{
        jumps.prev = px.count + 1;
        perror = nx.error + D +N;
      }
      */


    }
    bool setRatio(int nom, int den){
      if (nom > den){
        return false;
      }
      D = den;
      N = nom;
      return true;
    }
    
  };

  

  /*  not using this yet
  Range range;

  template <typename RationalNumber>
  void configure(const RationalNumber& ratio, int32_t start_position) {
    state.D = ratio.denominator();
    state.N = ratio.numerator();
    state.nerror = 0;
    state.perror = 0;
    range.next = next_jump_forward(ratio.denominator(), ratio.numerator(), 0, start_position);
    range.prev = next_jump_reverse(ratio.denominator(), ratio.numerator(), 0, start_position);
  }
  
  inline unsigned phase_delay(int32_t input_period, int e) {
    if (e < 0) e = -e;
    return (input_period * e) / (state.N);
  }
  */
  
}
",encoder_count
902,"#include ""fx.hpp""

// 基底クラス ヘッダー
#include ""fx_base.hpp""

// 各エフェクト 派生クラス ヘッダー
#include ""fx_overdrive.hpp""
#include ""fx_distortion.hpp""
#include ""fx_delay.hpp""
#include ""fx_tremolo.hpp""
#include ""fx_chorus.hpp""
#include ""fx_phaser.hpp""
#include ""fx_reverb.hpp""
#include ""fx_autowah.hpp""
#include ""fx_compressor.hpp""

// 各エフェクト グローバルインスタンス生成
fx_overdrive od1;
fx_distortion ds1;
fx_delay dd1;
fx_tremolo tr1;
fx_chorus ce1;
fx_phaser ph1;
fx_reverb rv1;
fx_autowah aw1;
fx_compressor cp1;

// 各エフェクト用ポインタ配列を生成(&を付ける)
// 使用するエフェクトを記載、順番入れ替え可
fx_base* effect[] = {&od1, &ds1, &dd1, &tr1, &ce1, &ph1, &rv1, &aw1, &cp1};

const uint8_t fxNumMax = sizeof(effect) / sizeof(effect[0]); // エフェクト最大数を自動計算

uint32_t cpuUsageCycleMax[fxNumMax] = {}; // CPU使用サイクル数 各エフェクトごとに最大値を記録
int16_t fxAllData[fxNumMax][20] = {}; // 全てのエフェクトパラメータデータ配列

void fxProcess(float xL[], float xR[])
{
  effect[fxNum]->process(xL, xR);
}

// 初期化処理 パラメータ読込、ディレイ用メモリ確保等
void fxInit()
{
  effect[fxNum]->init();
}

// 終了処理 ディレイ用メモリ削除等
void fxDeinit()
{
  effect[fxNum]->deinit();
}

// エフェクトパラメータ文字列更新処理
void fxSetParamStr(uint8_t  [MASK] )
{
  effect[fxNum]->setParamStr( [MASK] );
}
",paramNum
903,"/**
 * @file      Employee.cpp
 *
 * @brief     Simple realization of
 *            structure Employee
 *
 * @author    <NAME>
 * Contact:   <EMAIL>
 *
 */

#include ""Employee.h""

namespace NSSigns
{
	const char newLine = '\n';
	const char newItem = ';';
	const char space   = ' ';
} 

Employee::Employee(const std::string& info, const std::string& year, const std::string& month, int hour)
{
	name = info; 
	AddInformation(year,month,hour);
}

const std::string& Employee::GetAllTime() 
{
	for (size_t i = 0; i < workHours.size(); i++)
	{
		result += name;
		result += NSSigns::newItem;
		result += workHours[i].GetMonth();
		result += NSSigns::space;
		result += workHours[i].GetYear();
		result += NSSigns::newItem;
		result += std::to_string(workHours[i].GetTime());
		result += NSSigns::newLine;
	}
	return result;
}

void Employee::AddInformation(const std::string& year, const std::string& month, int hour)
{
	bool  [MASK]  = true;
	for (size_t i = 0; i < workHours.size(); ++i)
	{
		if (year  == workHours[i].GetYear() &&
			month == workHours[i].GetMonth())
		{
			workHours[i].AddTime(hour);
			 [MASK]  = false;
		}
	}
	if ( [MASK] )
	{
		workHours.push_back(Time(year, month, hour));
	}
}
",newInformation
904,"#include <iostream>
#include <string>
#include <vector>
#include <curl/curl.h>
#include <nlohmann/json.hpp>
#include <mutex>
#include <thread>
#include <condition_variable>
#include <chrono>

class DiscordWebhookHandler {
public:
    DiscordWebhookHandler(const std::string& webhook_url)
        : webhook_url(webhook_url), auto_flush(true) {}

    void log(const std::string& message, const std::string& level) {
        std::lock_guard<std::mutex> lock(mtx);
        buffer.push_back(formatMessage(message, level));
        if (auto_flush) {
            send();
        }
    }

    void send() {
        std::lock_guard<std::mutex> lock(mtx);
        if (buffer.empty()) return;

        std::string log_message;
        for (const auto& msg : buffer) {
            log_message += msg + ""\n"";
        }

        nlohmann::json  [MASK] ;
         [MASK] [""content""] = ""```diff\n"" + log_message + ""```"";

        CURL* curl = curl_easy_init();
        if (curl) {
            curl_easy_setopt(curl, CURLOPT_URL, webhook_url.c_str());
            curl_easy_setopt(curl, CURLOPT_POST, 1L);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS,  [MASK] .dump().c_str());
            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, nullptr); // header ayarları gerekebilir
            CURLcode res = curl_easy_perform(curl);
            if (res != CURLE_OK) {
                std::cerr << ""curl_easy_perform() failed: "" << curl_easy_strerror(res) << std::endl;
            }
            curl_easy_cleanup(curl);
        }
        buffer.clear();
    }

    private:
    std::string formatMessage(const std::string& message, const std::string& level) {
        return ""["" + level + ""] "" + message;
    }

    std::string webhook_url;
    std::vector<std::string> buffer;
    std::mutex mtx;
    bool auto_flush;
};

int main() {
    std::string webhook_url = ""YOUR_WEBHOOK_URL""; // Webhook URL'nızı buraya yazın
    DiscordWebhookHandler logger(webhook_url);

    logger.log(""Program başlatıldı!"", ""INFO"");

    // Ekstra log mesajları
    logger.log(""Bu bir hata mesajıdır."", ""ERROR"");

    std::this_thread::sleep_for(std::chrono::seconds(1)); // Gecikme eklemek için
    return 0;
}
",json_data
905,"#include ""ncpch.h""
#include ""WindowsWindow.h""
//#include ""../Event/ApplicationEvent.h""
#include ""../Event/ApplicationEvent.h""
#include ""../Event/MouseEvent.h""
#include ""../Event/KeyEvent.h""
#include ""../Log.h""

namespace Nutcracker {

	static bool s_GLFWInitialized = false;

	static void GLFWErrorCallback(int error, const char* description) {
		//NC_CORE_ERROR(""GLFW Error ({0}) : {1}"", error, description);
	}

	Window* Nutcracker::Window::Create(const WindowProps& props) {
		return new WindowsWindow(props);
	}

	WindowsWindow::WindowsWindow(const WindowProps & props)
	{
		Init(props);
	}

	WindowsWindow::~WindowsWindow()
	{
	}

	void WindowsWindow::OnUpdate() const
	{
		glfwPollEvents();
		glfwSwapBuffers(m_Window);
	}

	void WindowsWindow::SetVSync(bool enabled)
	{
		if (enabled) {
			glfwSwapInterval(1);
		}
		else {
			glfwSwapInterval(0);
		}
		m_Data.VSync = enabled;
	}

	bool WindowsWindow::IsVSync() const
	{
		return m_Data.VSync;
	}

	void WindowsWindow::Init(const WindowProps & props)
	{
		m_Data.Title = props.Title;
		m_Data.Width = props.Width;
		m_Data.Height = props.Height;

		NC_CORE_INFO(""Createing window {0} ({1}, {2})"", props.Title, props.Width, props.Height);

		if (!s_GLFWInitialized)
		{
			int success = glfwInit();
			//NC_CORE_ASSERT(success, ""Could not initialize GLFW"");
			glfwSetErrorCallback(GLFWErrorCallback);
			s_GLFWInitialized = true;
		}

		m_Window = glfwCreateWindow((int)props.Width, (int)props.Height, m_Data.Title.c_str(),nullptr,nullptr);
		glfwMakeContextCurrent(m_Window);
		glfwSetWindowUserPointer(m_Window, &m_Data);
		SetVSync(true);


		//Set GLFW callback
		glfwSetWindowSizeCallback(m_Window, [](GLFWwindow* window, int width, int height)
		{
			WindowData* dataPtr = (WindowData*)glfwGetWindowUserPointer(window);
			WindowData& data = *dataPtr;
			data.Width = width;
			data.Height = height;

			WnidowResizeEvent event(width, height);
			data.EventCallback(event);
			
		});


		glfwSetWindowCloseCallback(m_Window, [](GLFWwindow* window)
		{
			WindowData* dataPtr = (WindowData*)glfwGetWindowUserPointer(window);
			WindowData& data = *dataPtr;
			WindowCloseEvent event;
			data.EventCallback(event);
		});


		glfwSetKeyCallback(m_Window, [](GLFWwindow* window, int key, int scanCode, int action, int mods)
		{
			WindowData* dataPtr = (WindowData*)glfwGetWindowUserPointer(window);
			WindowData& data = *dataPtr;
		
			switch (action) {

			case GLFW_PRESS:
			{
				KeyPressedEvent event(key, 0);
				data.EventCallback(event);
				break;
			}
			case GLFW_RELEASE:
			{
				KeyReleasedEvent event(key);
				data.EventCallback(event);
				break;
			}
			case GLFW_REPEAT:
			{
				KeyPressedEvent event(key, 1);
				data.EventCallback(event);
				break;
			}
			}
				
		});

		glfwSetMouseButtonCallback(m_Window, [](GLFWwindow* window, int button, int action, int mods)
		{
			WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);

			switch (action)
			{
			case GLFW_PRESS:
			{
				MouseButtonReleasedEvent event(button);
				data.EventCallback(event);
				break;
			}
			case GLFW_RELEASE:
			{
				MouseButtonReleasedEvent event(button);
				data.EventCallback(event);
				break;
			}
			default:
				break;
			}
		});
	
		glfwSetScrollCallback(m_Window, [](GLFWwindow* window, double xOffset, double  [MASK] )
		{
			WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);

			MouseScrolledEvent event((float)xOffset, (float) [MASK] );
			data.EventCallback(event);
		});

		glfwSetCursorPosCallback(m_Window, [](GLFWwindow* window, double xPos, double yPos)
		{
			WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);

			MouseMoveEvent event((float)xPos, (float)yPos);
			data.EventCallback(event);
		});

	}

	void WindowsWindow::Shutdown()
	{
		glfwDestroyWindow(m_Window);
	}

}
",yOffset
906,"#include ""pch-il2cpp.h""
#include ""hook.h""
#include <Windows.h>
#include ""includes/detours/detours.h""
#include <iostream>
#include ""directx/directx.h""
#include <fstream>
#include ""helpers.h""
#include ""sig_scan.h""

using namespace app;
PVOID* join_original = nullptr;


bool hook(PVOID* ppPointer, PVOID pDetour, const char* functionName) {
	if (const auto error = DetourAttach(ppPointer, pDetour); error != NO_ERROR) {
		std::cout << ""failed to hook "" << functionName << "", error "" << error << std::endl;
		return false;
	}
	std::cout << ""successfully hooked method "" << functionName << std::endl;
	return true;
}

#define HOOKFUNC(n, d) if (!hook(&(PVOID&)n, d, #n)) return;

bool unhook(PVOID* ppPointer, PVOID pDetour, const char* functionName) {
	if (const auto error = DetourDetach(ppPointer, pDetour); error != NO_ERROR) {
		std::cout << ""failed to unhook "" << functionName << "", error "" << error << std::endl;
		return false;
	}
	std::cout << ""successfully unhooked method "" << functionName << std::endl;
	return true;
}

#define UNHOOKFUNC(n, d) if (!unhook(&(PVOID&)n, d, #n)) return;

void perform_hooks()
{
	// present hook for imgui
	do_directx_hooks();

	DetourTransactionBegin();
	DetourUpdateThread(GetCurrentThread());

	HMODULE game_asm = GetModuleHandleA(""GameAssembly.dll"");
	if (game_asm == NULL) {
		std::cout << ""failed to get game assembly module"" << std::endl;
		return;
	}
	
	// method name from game, then provide the function name to your detour.
	// todo: make hooking sys so i can use sigs instead of method names

	HOOKFUNC(u00CDu00CCu00CFu00CDu00CDu00CCu00CCu00CEu00CFu00CFu00CFu00CEu00CDu00CFu00CDu00CDu00CCu00CEu00CFu00CEu00CEu00CCu00CD_u00CDu00CFu00CFu00CCu00CCu00CFu00CCu00CEu00CFu00CFu00CFu00CCu00CFu00CEu00CCu00CCu00CEu00CDu00CEu00CDu00CEu00CDu00CF,
		on_player_join);
		
	HOOKFUNC(u00CDu00CCu00CFu00CDu00CDu00CCu00CCu00CEu00CFu00CFu00CFu00CEu00CDu00CFu00CDu00CDu00CCu00CEu00CFu00CEu00CEu00CCu00CD_u00CEu00CEu00CDu00CFu00CDu00CEu00CDu00CFu00CDu00CEu00CFu00CEu00CEu00CDu00CCu00CCu00CFu00CFu00CCu00CDu00CDu00CDu00CC,
		on_player_leave);	

	HOOKFUNC(u00CDu00CEu00CFu00CCu00CFu00CCu00CCu00CCu00CEu00CFu00CFu00CEu00CEu00CEu00CCu00CFu00CEu00CFu00CEu00CEu00CEu00CCu00CD_u00CFu00CCu00CCu00CEu00CEu00CEu00CCu00CDu00CDu00CCu00CCu00CFu00CFu00CCu00CDu00CDu00CFu00CEu00CDu00CDu00CEu00CEu00CC,
		on_avatar_download);

	HOOKFUNC(InputManager_OnUpdate, update);


	DetourTransactionCommit();
}

// this will get fairly messy when doing lots of hooks, consider splitting into multiple folders/files.

#define join_original(a, b, c) u00CDu00CCu00CFu00CDu00CDu00CCu00CCu00CEu00CFu00CFu00CFu00CEu00CDu00CFu00CDu00CDu00CCu00CEu00CFu00CEu00CEu00CCu00CD_u00CDu00CFu00CFu00CCu00CCu00CFu00CCu00CEu00CFu00CFu00CFu00CCu00CFu00CEu00CCu00CCu00CEu00CDu00CEu00CDu00CEu00CDu00CF(a, b, c)
#define leave_original(a, b, c) u00CDu00CCu00CFu00CDu00CDu00CCu00CCu00CEu00CFu00CFu00CFu00CEu00CDu00CFu00CDu00CDu00CCu00CEu00CFu00CEu00CEu00CCu00CD_u00CEu00CEu00CDu00CFu00CDu00CEu00CDu00CFu00CDu00CEu00CFu00CEu00CEu00CDu00CCu00CCu00CFu00CFu00CCu00CDu00CDu00CDu00CC(a, b, c)
#define avatar_original(a, b, c, d, e) u00CDu00CEu00CFu00CCu00CFu00CCu00CCu00CCu00CEu00CFu00CFu00CEu00CEu00CEu00CCu00CFu00CEu00CFu00CEu00CEu00CEu00CCu00CD_u00CFu00CCu00CCu00CEu00CEu00CEu00CCu00CDu00CDu00CCu00CCu00CFu00CFu00CCu00CDu00CDu00CFu00CEu00CDu00CDu00CEu00CEu00CC(a, b, c, d, e)
extern bool in_room = false;

void on_player_join(u00CDu00CCu00CFu00CDu00CDu00CCu00CCu00CEu00CFu00CFu00CFu00CEu00CDu00CFu00CDu00CDu00CCu00CEu00CFu00CEu00CEu00CCu00CD* class_ptr, u00CCu00CFu00CEu00CCu00CDu00CDu00CEu00CCu00CDu00CFu00CCu00CCu00CCu00CFu00CEu00CCu00CCu00CCu00CCu00CDu00CCu00CEu00CC* player_ptr, MethodInfo* method)
{
	// this is an odd way of doing this, but i was just looking for something i could compare.
	if (APIUser_get_CurrentUser(nullptr)->fields._displayName_k__BackingField == player_ptr->fields._u00CCu00CDu00CDu00CCu00CEu00CDu00CFu00CDu00CDu00CFu00CEu00CEu00CEu00CFu00CEu00CFu00CDu00CDu00CCu00CEu00CEu00CFu00CD_k__BackingField->fields._displayName_k__BackingField)
	{
		in_room = true;
	}

	join_original(class_ptr, player_ptr, method);
}

void on_player_leave(u00CDu00CCu00CFu00CDu00CDu00CCu00CCu00CEu00CFu00CFu00CFu00CEu00CDu00CFu00CDu00CDu00CCu00CEu00CFu00CEu00CEu00CCu00CD* class_ptr, u00CCu00CFu00CEu00CCu00CDu00CDu00CEu00CCu00CDu00CFu00CCu00CCu00CCu00CFu00CEu00CCu00CCu00CCu00CCu00CDu00CCu00CEu00CC* player_ptr, MethodInfo* method)
{
	if (APIUser_get_CurrentUser(nullptr)->fields._displayName_k__BackingField == player_ptr->fields._u00CCu00CDu00CDu00CCu00CEu00CDu00CFu00CDu00CDu00CFu00CEu00CEu00CEu00CFu00CEu00CFu00CDu00CDu00CCu00CEu00CEu00CFu00CD_k__BackingField->fields._displayName_k__BackingField)
	{
		in_room = false;
	}

	leave_original(class_ptr, player_ptr, method);
}

UniTask_1_u00CCu00CEu00CFu00CFu00CCu00CEu00CCu00CDu00CEu00CCu00CFu00CCu00CEu00CFu00CEu00CEu00CFu00CEu00CDu00CCu00CDu00CEu00CE_ on_avatar_download(u00CDu00CEu00CFu00CCu00CFu00CCu00CCu00CCu00CEu00CFu00CFu00CEu00CEu00CEu00CCu00CFu00CEu00CFu00CEu00CEu00CEu00CCu00CD* class_ptr, ApiAvatar* avi_ptr, u00CDu00CEu00CFu00CCu00CFu00CCu00CCu00CCu00CEu00CFu00CFu00CEu00CEu00CEu00CCu00CFu00CEu00CFu00CEu00CEu00CEu00CCu00CD_u00CFu00CEu00CEu00CCu00CCu00CEu00CDu00CFu00CDu00CEu00CFu00CCu00CEu00CEu00CEu00CEu00CFu00CCu00CDu00CCu00CFu00CFu00CE* unk_ptr, bool  [MASK] , MethodInfo* method)
{
	std::cout << ""avihook: name->"" << il2cppi_to_string(avi_ptr->fields._name_k__BackingField) << "" | asset_url->"" << il2cppi_to_string(avi_ptr->fields._assetUrl_k__BackingField) << std::endl;

	// will pipe the results with json pretty print and stuff like that into a file at some point, don't have a lot of time as of this commit.

	return avatar_original(class_ptr, avi_ptr, unk_ptr,  [MASK] , method);
}

bool flying = false;
// this is called on update -- ref: https://docs.unity3d.com/ScriptReference/MonoBehaviour.Update.html
void update(app::InputManager * __this, app::InputUpdateType__Enum updateType, app::InputEventBuffer * eventBuffer, MethodInfo * method)
{
	/* you would want to perform a lot of stuff here
	examples:
	fly, event exploits, anything that requires being set constantly or being called constantly.
	*/

	// toggle for flying, will disable the character controller collider so we can move on our own
	if (Input_GetKeyString(reinterpret_cast<app::String*>(il2cpp_string_new(""left ctrl"")), nullptr) && GetAsyncKeyState(0x46) & 1) // CTRL + F
	{
		flying = !flying;
		// kms
		const auto character_controller = reinterpret_cast<app::Collider*>(
			GameObject_GetComponentByName(
			Networking_get_LocalPlayer(nullptr)->fields.gameObject,
			reinterpret_cast<app::String*>(il2cpp_string_new(""CharacterController"")), nullptr)); 
		Collider_set_enabled(character_controller, !flying, nullptr);
	}

	// the actual flying
	// credits: azurilix
	if (flying && in_room)
	{
		// shit gets kinda ugly here
		const auto player_transform = GameObject_get_transform(Networking_get_LocalPlayer(nullptr)->fields.gameObject, nullptr);
		auto player_pos = Transform_get_position(player_transform, nullptr);
		const auto delta_time = Time_get_deltaTime(nullptr);
		const auto speed = Input_GetKeyString(reinterpret_cast<app::String*>(il2cpp_string_new(""left shift"")), nullptr) ? 10.0f : 5.0f;
		const auto vert_axis = Input_GetAxis(reinterpret_cast<app::String*>(il2cpp_string_new(""Vertical"")), nullptr);
		const auto horz_axis = Input_GetAxis(reinterpret_cast<app::String*>(il2cpp_string_new(""Horizontal"")), nullptr);


		player_pos.x += Transform_get_forward(player_transform, nullptr).x * (delta_time * vert_axis) * (speed * 2);
		player_pos.x += Transform_get_right(player_transform, nullptr).x * (delta_time * horz_axis) * (speed * 2);

		player_pos.y += Transform_get_forward(player_transform, nullptr).y * (delta_time * vert_axis) * (speed * 2);
		player_pos.y += Transform_get_right(player_transform, nullptr).y * (delta_time * horz_axis) * (speed * 2);

		player_pos.z += Transform_get_forward(player_transform, nullptr).z * (delta_time * vert_axis) * (speed * 2);
		player_pos.z += Transform_get_right(player_transform, nullptr).z * (delta_time * horz_axis) * (speed * 2);

		if (Input_GetKeyString(reinterpret_cast<app::String*>(il2cpp_string_new(""q"")), nullptr)) player_pos.y -= delta_time * (speed * 2);
		if (Input_GetKeyString(reinterpret_cast<app::String*>(il2cpp_string_new(""e"")), nullptr)) player_pos.y += delta_time * (speed * 2);

		Transform_set_position(player_transform, player_pos, nullptr);
	}


	InputManager_OnUpdate(__this, updateType, eventBuffer, method);
}",param_3
907,"#include <iostream>

#include <mapbox/variant.hpp>
#include <mapbox/boost_spirit_karma.hpp>
#include <boost/spirit/include/karma.hpp>

typedef mapbox::util::variant<int, bool, std::string, float, long, uint64_t> frame;

struct visitor {
    template <typename T>
    void operator()(T const& val) const
    {
      std::cout << typeid(T).name() << "" "" << val << std::endl;
    }

};

int main(int argc, char** argv) {
  typedef std::back_insert_iterator<std::string> Iterator;

  using namespace boost::spirit::karma;

  rule<Iterator, std::string()>  [MASK]  = *char_;

  rule<Iterator, frame()> r = 
      int_
    | bool_
    |  [MASK] 
  ;

  {
    frame frm = 12;
    std::string buf;
    Iterator iter(buf);
    auto s = generate(iter, r, frm); 

    std::cout << "" success : "" << s << "" - "" << mapbox::util::get<int>(frm) << "" - "" << buf << std::endl;
  }

  {
    frame frm = true;
    std::string buf;
    Iterator iter(buf);
    auto s = generate(iter, r, frm); 

    std::cout << "" success : "" << s << "" - "" << mapbox::util::get<bool>(frm) << "" - "" << buf << std::endl;
  }

  {
    frame frm = std::string{""this is a string""};
    std::string buf;
    Iterator iter(buf);
    auto s = generate(iter, r, frm); 

    std::cout << "" success : "" << s << "" - "" << mapbox::util::get<std::string>(frm) << "" - "" << buf << std::endl;
  }

  return 0;
}
",mystring
908,"// Copyright 2017 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// 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 <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdio.h>
#include <poll.h>
#include <string.h>
#include <termios.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include <arpa/inet.h>

#include ""UDP_node.h""
#include <fastcdr/Cdr.h>
#include <fastcdr/FastCdr.h>
#include <fastcdr/exceptions/Exception.h>
#include <fastrtps/utils/eClock.h>
#include <fastrtps/Domain.h>

#include ""../../micrortps_agent_udp/apps_proc/sensor_combined_Publisher.h""
#include ""../../micrortps_agent_udp/apps_proc/sensor_combined_Subscriber.h""

#define BUFFER_SIZE 1024
#define USLEEP_MS 0

using namespace eprosima;
using namespace eprosima::fastrtps;


UDP_node udp_node;
int sent = 0;

void* t_send(void* data)
{

    // Create subscribers
    sensor_combined_Subscriber sensor_combined_sub;
    if (true == sensor_combined_sub.init()) std::cout << ""sensor_combined subscriber created"" << std::endl;
    else std::cout << ""ERROR creating sensor_combined subscriber"" << std::endl;

    char data_buffer[BUFFER_SIZE] = {};

    while (true)
    {
        // Send subscribed topics over UART
        if (sensor_combined_sub.hasMsg())
        {
            sensor_combined_ msg = sensor_combined_sub.getMsg();
            eprosima::fastcdr::FastBuffer cdrbuffer(data_buffer, sizeof(data_buffer));
            eprosima::fastcdr::Cdr scdr(cdrbuffer);
            msg.serialize(scdr);
            ssize_t len = scdr.getSerializedDataLength();
            printf(""[%d]>> %f\n"", 58, (double)msg.baro_temp_celcius());
            udp_node.write((char) 58, scdr.getBufferPointer(), len);
            ++sent;
        }
        usleep(1);
    }
}

int main(int argc, char *argv[])
{

    if (0 != udp_node.init(2019, 2020))
    {
        printf(""ERROR UDP INIT, EXITING...\n"");
        return -1;
    }

    // create a thread for sending data to the simulator
    pthread_t sender_thread;
    // initialize threads
    pthread_attr_t sender_thread_attr;
    pthread_attr_init(&sender_thread_attr);
    //pthread_attr_setstacksize(&sender_thread_attr, PX4_STACK_ADJUSTED(4000));
    struct sched_param param;
    (void)pthread_attr_getschedparam(&sender_thread_attr, &param);
    /* low priority */
    param.sched_priority = 125;
    (void)pthread_attr_setschedparam(&sender_thread_attr, &param);
    // got data from simulator, now activate the sending thread
    pthread_create(&sender_thread, &sender_thread_attr, t_send, NULL);
    pthread_attr_destroy(&sender_thread_attr);

    // Create publishers
    sensor_combined_Publisher  [MASK] ;
     [MASK] .init();

    char data_buffer[BUFFER_SIZE] = {};
    char topic_ID = 255;
    while (true)
    {
        // Blocking call
        if (0 < udp_node.read(&topic_ID, data_buffer))
        {
            switch (topic_ID)
            {
                case 58:
                {
                    sensor_combined_ st;
                    eprosima::fastcdr::FastBuffer cdrbuffer(data_buffer, sizeof(data_buffer));
                    eprosima::fastcdr::Cdr cdr_des(cdrbuffer);
                    st.deserialize(cdr_des);
                     [MASK] .publish(&st);
                    printf(""                >>[%d] %f\n"", 58, (double)st.baro_temp_celcius());
                }
                break;
            }
        }
    }
    pthread_join(sender_thread, NULL);

    printf(""exiting\n"");
    fflush(stdout);
    return 0;
}
",sensor_combined_pub
909,"// <NAME>
//
// Convert adjacency list to adjacency matrix
//
// TODO:
// * Make out of order adjacencies parse correctly
// * > 2 digit vertex parsing
//
// Usage:
//		./listtomat <adjlist_file>

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#define USAGE ""Usage:\n\t./listtomat <adjlist_file>""
#define MAX_DIGITS 32 // maximum digits in vertex labels

using namespace std;

int main (int argc, char const *argv[]) {
	FILE *fp;
	int c; // char in file
	int temp; // temp memory
	int lookahead;
	int  [MASK]  = 0; // break flag
	int col = 0; // column in matrix line
	int n = 0; // number of vertices in graph
	int first = 1; // spacing
	int result;

	if (argc != 2) {
		perror(""Incorrect number of arguments.\n"");
		perror(USAGE);
		return -1;
	}

	fp = fopen(argv[1], ""r""); // open adjacency list file
	if (fp == NULL) {
		perror(""File does not exist."");
		perror(USAGE);
		return -1;
	}

	// get number of lines (vertices) in file
	c = fgetc(fp);
	while(c != EOF){
		if (c == '\n') {
			n = n + 1;
		}
		c = fgetc(fp);
	}
	// EOF is an empty line
	rewind(fp);

	while (1) { // for each line in adjacency list
		for (int i = 0; i < MAX_DIGITS; ++i) { // parse over vertex label and colon separator
			c=fgetc(fp);
			if (c == ':'){
				c=fgetc(fp); // space
				break;
			}
		}

		while (1) { // for each adjacency
			c = fgetc(fp); // parse adjacency
			temp = c;
			if (temp == '\n') { // vertex with no adjacencies
				for (int i = col; i < n; ++i) { // fill rest of line with 0
					if (first == 1)	{
						printf(""%d"", 0);
						first = 0;
					}
					else {
						printf("" %d"", 0);
					}
				}
				break;
			}
			c = fgetc(fp); // space or second digit

			if (c=='\n'){
				c = temp;
				 [MASK]  = 1;
			}
			else if (c==' ') {
				c = temp;
			}
			else if (c==EOF){
				return 0;
			}
			else if (isdigit(c)){ // double digits
				lookahead=fgetc(fp);

				if (lookahead=='\n') {
					ungetc(lookahead,fp);
					 [MASK]  = 1;
				}
				// else if isdigit(c)
					// > 2 DIGIT VERTEX PARSING
				// else space
				result = (10*(temp-'0'))+c-'0';
				c=result+'0';
			}

			if (c-'0' > n) { 
				perror(""Invalid adjacency parsed\n."");
				perror(USAGE);
				return -1;
			}

			while (1) {
				if (c-'0' == col) { // found correct position in matrix for adjacency (1)
					if (first == 1) {
						printf(""%d"", 1);
						first = 0;
					}
					else {
						printf("" %d"", 1);
					}
					col = col + 1;
					break;
				}
				else { // incorrect position in matrix for adjacency
					if (first == 1) {
						printf(""%d"", 0);
						first = 0;
					}
					else {
						printf("" %d"", 0);
					}
					col = col + 1; // increment position in matrix
				}
			}

			if ( [MASK]  == 1) { // EOL
				if (col != n) { // fill rest of line with 0's
					for (int i = col; i < n; ++i) {
						printf("" %d"", 0);
					}
				}
				 [MASK]  = 0;
				temp = 0;
				break;
			}
		}
		printf(""\n"");
		col = 0;
		temp = 0;
		first = 1;
	}
	fclose(fp);
    return 0;
}",brk
910,"#ifndef WF_STDLIB_MATH_MAT4F_HDR
#define WF_STDLIB_MATH_MAT4F_HDR
#include ""wfMath.h""

#include ""wfVector3f.h""
#include ""wfVector4f.h""

class wfMat4f {
    wfPrivate::wfMathMat4 m_value;
    wfMat4f(const wfPrivate::wfMathMat4 &mat) :
        m_value(mat)
    { };
    
public:
    wfMat4f() { }
    wfMat4f(const wfMat4f &mat) :
        m_value(mat.m_value)
    { };
    
    wfMat4f(
        const wfVector4f &mat_x,
        const wfVector4f &mat_y,
        const wfVector4f &mat_z,
        const wfVector4f &mat_w
    ) :
        m_value(
            wfPrivate::wfMathMat4Create(
                mat_x.m_value,
                mat_y.m_value,
                mat_z.m_value,
                mat_w.m_value
            )
        )
    { };

    /* Please be safe with this and ensure the data is there to do it */
    explicit wfMat4f(const float *array) {
        wfPrivate::wfMathMat4UnalignedLoad(&m_value, array);
    }

    void Load(const float *array) {
        m_value.x = wfPrivate::wfMathVec4UnalignedLoad<4>(array);
        m_value.y = wfPrivate::wfMathVec4UnalignedLoad<4>(array + 4);
        m_value.z = wfPrivate::wfMathVec4UnalignedLoad<4>(array + 8);
        m_value.w = wfPrivate::wfMathVec4UnalignedLoad<4>(array + 12);
    }

    void Store(float *array) const {
        wfPrivate::wfMathVec4UnalignedStore<4>(m_value.x, array);
        wfPrivate::wfMathVec4UnalignedStore<4>(m_value.y, array + 4);
        wfPrivate::wfMathVec4UnalignedStore<4>(m_value.z, array + 8);
        wfPrivate::wfMathVec4UnalignedStore<4>(m_value.w, array + 12);
    }

    static wfMat4f Identity() {
        wfPrivate::wfMathMat4 mat;
        wfPrivate::wfMathMat4Identity(&mat);
        return mat;
    }

    static wfMat4f Perspective(float fovy, float aspect, float znear, float zfar) {
        wfPrivate::wfMathMat4 mat;
        wfPrivate::wfMathMat4Perspective(&mat, fovy, aspect, znear, zfar);
        return mat;
    }

    static wfMat4f Orthographic(float l, float r, float b, float t, float znear, float zfar) {
        wfPrivate::wfMathMat4 mat;
        wfPrivate::wfMathMat4Orthographic(&mat, l, r, b, t, znear, zfar);
        return mat;
    }

    static wfMat4f Look(const wfVector3f &eye, const wfVector3f &center, const wfVector3f &updir) {
        wfPrivate::wfMathMat4 mat;
        wfPrivate::wfMathMat4Look(&mat, eye.m_value, center.m_value, updir.m_value);
        return mat;
    }

    static wfMat4f AxisRotation(float angle, const wfVector3f &axis) {
        wfPrivate::wfMathMat4 mat;
        wfPrivate::wfMathMat4AxisRotation(&mat, angle, axis.m_value);
        return mat;
    }

    static wfMat4f Scale(float  [MASK] ) {
        return wfPrivate::wfMathMat4Create(
                   wfPrivate::wfMathVec4Create( [MASK] , 0.0f,  0.0f,  0.0f),
                   wfPrivate::wfMathVec4Create(0.0f,   [MASK] , 0.0f,  0.0f),
                   wfPrivate::wfMathVec4Create(0.0f,  0.0f,   [MASK] , 0.0f),
                   wfPrivate::wfMathVec4Create(0.0f,  0.0f,  0.0f,  1.0f)
               );
    }

    static wfMat4f Scale(const wfVector3f &vec) {
        return wfPrivate::wfMathMat4Create(
                wfPrivate::wfMathVec4Create(vec.x(), 0.0f,    0.0f,    0.0f),
                wfPrivate::wfMathVec4Create(0.0f,    vec.y(), 0.0f,    0.0f),
                wfPrivate::wfMathVec4Create(0.0f,    0.0f,    vec.z(), 0.0f),
                wfPrivate::wfMathVec4Create(0.0f,    0.0f,    0.0f,    1.0f)
        );
    }

    /*
     * Operators now: these work as you expect them to.
     */
    wfMat4f operator *(const wfMat4f &mat) {
        wfPrivate::wfMathMat4 store;
        wfPrivate::wfMathMat4Mul(&m_value, &mat.m_value, &store);
        return store;
    }

    wfMat4f& operator *=(const wfMat4f &mat) {
        const wfPrivate::wfMathMat4 store = m_value;
        wfPrivate::wfMathMat4Mul(&store, &mat.m_value, &m_value);
        return *this;
    }

    wfVector4f operator *(const wfVector4f &vec) {
        wfVector4f ret;
        wfPrivate::wfMathMat4Vec4Mul(&m_value, &vec.m_value, &ret.m_value);
        return ret;
    }

    /* 
     * TODO: Transform vector for wfVector3f and wfVector4f
     * TODO: Transform point  for wfVector3f and wfVector4f
     * TODO: Orthographic transform for point and vectors (wfVector3f)
     */

    wfMat4f Transpose(const wfMat4f &mat) {
        wfPrivate::wfMathMat4 ret;
        wfPrivate::wfMathMat4Transpose(&m_value, &ret);
        return ret;
    }

    wfMat4f Inverse(const wfMat4f &mat) {
        wfPrivate::wfMathMat4 ret;
        wfPrivate::wfMathMat4Inverse(&m_value, &ret);
        return ret;
    }
};

#endif",scale
911,"/**
 * Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Modified and adapted for use with Delta Debugger
 * P.Beal - 2025/02/22
 */
#include ""quadrature_encoder_substep.hpp""

/**
 * the quadrature encoder code starts here
 */

/**
 * internal helper functions (not to be used by user code)
 */

void substep_state_t::read_pio_data(uint *step, uint *step_us, uint *transition_us, int *forward)
{
    int cycles;

    // get the raw data from the PIO state machine
    quadrature_encoder_substep_get_counts(this->pio, this->sm, step, &cycles, step_us);

    // when the PIO program detects a transition, it sets cycles to either zero
    // (when step is incrementing) or 2^31 (when step is decrementing) and keeps
    // decrementing it on each 13 clock loop. We can use this information to get
    // the time and direction of the last transition
    if (cycles < 0)
    {
        cycles = -cycles;
        *forward = 1;
    }
    else
    {
        cycles = 0x80000000 - cycles;
        *forward = 0;
    }
    *transition_us = *step_us - ((cycles * 13) / this->clocks_per_us);
}

// get the sub-step position of the start of a step
uint substep_state_t::get_step_start_transition_pos(uint step)
{
    return ((step << 6) & 0xFFFFFF00) | this->calibration_data[step & 3];
}

// compute speed in ""sub-steps per 2^20 us"" from a delta substep position and
// delta time in microseconds. This unit is cheaper to compute and use, so we
// only convert to ""sub-steps per second"" once per update, at most
int substep_state_t::substep_calc_speed(int  [MASK] , int delta_us)
{
    return ((int64_t) [MASK]  << 20) / delta_us;
}

/**
 * main functions to be used by user code
 */
substep_state_t::substep_state_t(uint8_t pin_ab)
{
    PIO pio = pio0;
    int sm;
    // Find a free SM on one of the PIO's
    sm = pio_claim_unused_sm(pio, false); // don't panic
    // Try pio1 if SM not found
    if (sm < 0)
    {
        pio = pio1;
        sm = pio_claim_unused_sm(pio, true); // panic if no SM is free
    }

    substep_state_t(pin_ab, pio, sm);
}

substep_state_t::substep_state_t(uint8_t pin_ab, PIO pio, int sm)
{
    this->pin_ab = pin_ab;
    this->pio = pio;
    this->sm = sm;
}

substep_state_t::~substep_state_t()
{
    //free(this);
}

// initialize the substep state structure and start PIO code
void substep_state_t::substep_init()
{
    int forward;

    // set all fields to zero by default
    //memset(this, 0, sizeof(substep_state_t));

    // initialize the PIO program (and save the PIO reference)
    quadrature_encoder_substep_program_init(this->pio, this->sm, this->pin_ab);

    printf(""quadrature encoder substep program init complete\n"");
    
    // start with equal phase size calibration
    this->calibration_data[0] = 0;
    this->calibration_data[1] = 64;
    this->calibration_data[2] = 128;
    this->calibration_data[3] = 192;

    this->idle_stop_samples = 3;

    // start ""stopped"" so that we don't use stale data to compute speeds
    this->stopped = 1;

    // cache the PIO cycles per us
    this->clocks_per_us = (clock_get_hz(clk_sys) + 500000) / 1000000;

    // initialize the ""previous state""
    read_pio_data(&this->raw_step, &this->prev_step_us, &this->prev_trans_us, &forward);

    this->position = get_step_start_transition_pos(this->raw_step) + 32;
}

// read the PIO data and update the speed / position estimate
void substep_state_t::substep_update()
{
    uint step, step_us, transition_us, transition_pos, low, high;
    int forward, speed_high, speed_low;

    // read the current encoder state from the PIO
    read_pio_data(&step, &step_us, &transition_us, &forward);

    // from the current step we can get the low and high boundaries in substeps
    // of the current position
    low = get_step_start_transition_pos(step);
    high = get_step_start_transition_pos(step + 1);

    // if we were not stopped, but the last transition was more than
    // ""idle_stop_samples"" ago, we are stopped now
    if (step == this->raw_step)
        this->idle_stop_sample_count++;
    else
        this->idle_stop_sample_count = 0;

    if (!this->stopped && this->idle_stop_sample_count >= this->idle_stop_samples)
    {
        this->speed = 0;
        this->speed_2_20 = 0;
        this->stopped = 1;
    }

    // when we are at a different step now, there is certainly a transition
    if (this->raw_step != step)
    {
        // the transition position depends on the direction of the move
        transition_pos = forward ? low : high;

        // if we are not stopped, that means there is valid previous transition
        // we can use to estimate the current speed
        if (!this->stopped)
            this->speed_2_20 = substep_calc_speed(transition_pos - this->prev_trans_pos, transition_us - this->prev_trans_us);

        // if we have a transition, we are not stopped now
        this->stopped = 0;
        // save the timestamp and position of this transition to use later to
        // estimate speed
        this->prev_trans_pos = transition_pos;
        this->prev_trans_us = transition_us;
    }

    // if we are stopped, speed is zero and the position estimate remains
    // constant. If we are not stopped, we have to update the position and speed
    if (!this->stopped)
    {
        // although the current step doesn't give us a precise position, it does
        // give boundaries to the position, which together with the last
        // transition gives us boundaries for the speed value. This can be very
        // useful especially in two situations:
        // - we have been stopped for a while and start moving quickly: although
        //   we only have one transition initially, the number of steps we moved
        //   can already give a non-zero speed estimate
        // - we were moving but then stop: without any extra logic we would just
        //   keep the last speed for a while, but we know from the step
        //   boundaries that the speed must be decreasing

        // if there is a transition between the last sample and now, and that
        // transition is closer to now than the previous sample time, we should
        // use the slopes from the last sample to the transition as these will
        // have less numerical issues and produce a tighter boundary
        if (this->prev_trans_us > this->prev_step_us &&
            (int)(this->prev_trans_us - this->prev_step_us) > (int)(step_us - this->prev_trans_us))
        {
            speed_high = substep_calc_speed(this->prev_trans_pos - this->prev_low, this->prev_trans_us - this->prev_step_us);
            speed_low = substep_calc_speed(this->prev_trans_pos - this->prev_high, this->prev_trans_us - this->prev_step_us);
        }
        else
        {
            // otherwise use the slopes from the last transition to now
            speed_high = substep_calc_speed(high - this->prev_trans_pos, step_us - this->prev_trans_us);
            speed_low = substep_calc_speed(low - this->prev_trans_pos, step_us - this->prev_trans_us);
        }
        // make sure the current speed estimate is between the maximum and
        // minimum values obtained from the step slopes
        if (this->speed_2_20 > speed_high)
            this->speed_2_20 = speed_high;
        if (this->speed_2_20 < speed_low)
            this->speed_2_20 = speed_low;

        // convert the speed units from ""sub-steps per 2^20 us"" to ""sub-steps
        // per second""
        this->speed = (this->speed_2_20 * 62500LL) >> 16;

        // estimate the current position by applying the speed estimate to the
        // most recent transition
        this->position = this->prev_trans_pos + (((int64_t)this->speed_2_20 * (step_us - transition_us)) >> 20);

        // make sure the position estimate is between ""low"" and ""high"", as we
        // can be sure the actual current position must be in this range
        if ((int)(this->position - high) > 0)
            this->position = high;
        else if ((int)(this->position - low) < 0)
            this->position = low;
    }

    // save the current values to use on the next sample
    this->prev_low = low;
    this->prev_high = high;
    this->raw_step = step;
    this->prev_step_us = step_us;
}

// function to measure the difference between the different steps on the encoder
void substep_state_t::substep_calibrate_phases(PIO pio, uint sm)
{
#define sample_count 1024
// #define SHOW_ALL_SAMPLES
#ifdef SHOW_ALL_SAMPLES
    static int result[sample_count];
    int i;
#endif
    int index, cycles, clocks_per_us, calib[4];
    uint cur_us, last_us, step_us, step, last_step;
    int64_t sum[4], total;

    memset(sum, 0, sizeof(sum));

    clocks_per_us = (clock_get_hz(clk_sys) + 500000) / 1000000;

    // keep reading the PIO state in a tight loop to get all steps and use the
    // transition measures of the PIO code to measure the time of each step
    last_step = -10;
    index = -10;
    while (index < sample_count)
    {

        quadrature_encoder_substep_get_counts(pio, sm, &step, &cycles, &step_us);

        // wait until we have a transition
        if (step == last_step)
            continue;

        // synchronize the index with the lower 2 bits of the current step
        if (index < 0 && index > -4 && (step & 3) == 1)
            index = 0;

        // convert the ""time since last transition"" to an absolute microsecond
        // timestamp
        if (cycles > 0)
        {
            printf(""error: expected forward motion\n"");
            return;
        }
        cur_us = step_us + (cycles * 13) / clocks_per_us;

        // if the index is already synchronized, use the step size
        if (index >= 0)
        {
#ifdef SHOW_ALL_SAMPLES
            result[index] = cur_us - last_us;
#endif
            sum[(step - 1) & 3] += cur_us - last_us;
        }
        index++;

        last_step = step;
        last_us = cur_us;
    }

#ifdef SHOW_ALL_SAMPLES
    printf(""full sample table:\n"");
    for (i = 0; i < sample_count; i++)
    {
        printf(""%d "", result[i]);
        if ((i & 3) == 3)
            printf(""\n"");
    }
#endif

    // scale the sizes to a total of 256 to be used as sub-steps
    total = sum[0] + sum[1] + sum[2] + sum[3];
    calib[0] = (sum[0] * 256 + total / 2) / total;
    calib[1] = ((sum[0] + sum[1]) * 256 + total / 2) / total;
    calib[2] = ((sum[0] + sum[1] + sum[2]) * 256 + total / 2) / total;

    // print calibration information
    printf(""calibration command:\n\n"");
    printf(""\tsubstep_set_calibration_data(&state, %d, %d, %d);\n\n"",
           calib[0], calib[1], calib[2]);
}

// set the phase size calibration, use the ""substep_calibrate_phases"" function
// to get the values. Many encoders (especially low cost ones) have phases that
// don't have the same size. To get good substep accuracy, the code should know
// about this. This is specially important at low speeds with encoders that have
// big phase size differences
void substep_state_t::substep_set_calibration_data(int step0, int step1, int step2)
{
    this->calibration_data[0] = 0;
    this->calibration_data[1] = step0;
    this->calibration_data[2] = step1;
    this->calibration_data[3] = step2;
}

void substep_state_t::begin(void)
{

    pio_add_program(this->pio, &quadrature_encoder_substep_program);
    substep_init();
}

/*  // example calibration code, uncomment to calibrate the encoder:

    //    // - turn on a DC motor at 50% PWM
    //    init_pwm();
    //    set_pwm(-0.5);
    //    // - wait for the motor to reach a reasonably stable speed
    //    sleep_ms(2000);
    //    // - run the phase size calibration code
    //    substep_calibrate_phases(pio, sm);
    //    // - stop the motor
    //    set_pwm(0);

    // replace this with the output of the calibration function
    substep_set_calibration_data(64, 128, 192);

    uint last_position = 0;
    int last_speed = 0;
    uint last_raw_step = 0;
    while (1)
    {

        // read the PIO and update the state data
        substep_update();

        if (last_position != state.position || last_speed != state.speed || last_raw_step != state.raw_step)
        {
            // print out the result
            printf(""pos: %-10d  speed: %-10d  raw_steps: %-10d\n"", state.position, state.speed, state.raw_step);
            last_position = state.position;
            last_speed = state.speed;
            last_raw_step = state.raw_step;
        }

        // run at roughly 100Hz
        sleep_ms(10);
    }
}
*/",delta_substep
912,"/*
	Copyright 2005-2006 Adobe Systems Incorporated
	Distributed under the MIT License

	Permission is hereby granted, free of charge, to any person obtaining a copy of
	this software and associated documentation files (the ""Software""), to deal in
	the Software without restriction, including without limitation the rights to
	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
	the Software, and to permit persons to whom the Software is furnished to do so,
	subject to the following conditions:
	
	The above copyright notice and this permission notice shall be included in all
	copies or substantial portions of the Software.
	
	THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
	FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
	COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
	IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	
*/

/*************************************************************************************************/

#ifndef ADOBE_UNICODE_HPP
#define ADOBE_UNICODE_HPP

/*************************************************************************************************/

//#include <adobe/config.hpp>
//#include <adobe/algorithm.hpp>
//#include <boost/cstdint.hpp>
//#include <boost/utility/enable_if.hpp>

#include <cassert>
#include <stdexcept>

#include ""string.hpp""

/*************************************************************************************************/

namespace adobe {

// boost::enable_if
template <bool B, class T = void>
struct enable_if_c { typedef T type; };
template <class T>
struct enable_if_c<false, T> {};

template <class Cond, class T = void>
struct enable_if : public enable_if_c<Cond::value, T> {};

//using sqlitepp::utf8_char;
typedef unsigned char utf8_char;
using sqlitepp::utf16_char;
using sqlitepp::utf32_char;


/*************************************************************************************************/

#if !defined(ADOBE_NO_DOCUMENTATION)

/*************************************************************************************************/

template <typename T>
struct is_utf8_type
{ enum { value = sizeof(T) == 1 }; };

/*************************************************************************************************/

template <typename T>
struct is_utf16_type
{ enum { value = sizeof(T) == 2 }; };

/*************************************************************************************************/

template <typename T>
struct is_utf32_type
{ enum { value = sizeof(T) == 4 }; };

/*************************************************************************************************/

template <typename I>
struct is_utf8_iterator_type
{ enum { value = is_utf8_type<typename std::iterator_traits<I>::value_type>::value }; };

/*************************************************************************************************/

template <typename I>
struct is_utf16_iterator_type
{ enum { value = is_utf16_type<typename std::iterator_traits<I>::value_type>::value }; };

/*************************************************************************************************/

template <typename I>
struct is_utf32_iterator_type
{ enum { value = is_utf32_type<typename std::iterator_traits<I>::value_type>::value }; };

/*************************************************************************************************/

namespace implementation {

/*************************************************************************************************/

const utf8_char	    to_utf32_pivot_1_k(128);
const utf8_char     to_utf32_pivot_2_k(192);
const utf8_char     to_utf32_pivot_3_k(224);
const utf8_char     to_utf32_pivot_4_k(240);
const utf8_char     to_utf32_pivot_5_k(248);
const utf8_char     to_utf32_pivot_6_k(252);
const utf8_char     to_utf32_pivot_7_k(254);

const utf32_char	to_utf8_pivot_1_k(1UL << 7);
const utf32_char	to_utf8_pivot_2_k(1UL << 11);
const utf32_char	to_utf8_pivot_3_k(1UL << 16);
const utf32_char	to_utf8_pivot_4_k(1UL << 21);
const utf32_char	to_utf8_pivot_5_k(1UL << 26);

const utf16_char	to_utf16_surrogate_pivot_k(65535);
const utf16_char	utf16_high_surrogate_front_k(0xd800);
const utf16_char	utf16_high_surrogate_back_k(0xdbff);
const utf16_char	utf16_low_surrogate_front_k(0xdc00);
const utf16_char	utf16_low_surrogate_back_k(0xdfff);

/*************************************************************************************************/
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4310)
#endif
template <std::size_t NumBytes> struct utf8_header_t	{ };
template <>						struct utf8_header_t<0>	{ enum { value = char(0x80) }; }; // nonheader
//template <>					struct utf8_header_t<1>	{ enum { value = char(0x00) }; }; // illegal
template <>						struct utf8_header_t<2>	{ enum { value = char(0xC0) }; };
template <>						struct utf8_header_t<3>	{ enum { value = char(0xE0) }; };
template <>						struct utf8_header_t<4>	{ enum { value = char(0xF0) }; };
template <>						struct utf8_header_t<5>	{ enum { value = char(0xF8) }; };
template <>						struct utf8_header_t<6>	{ enum { value = char(0xFC) }; };
#ifdef _MSC_VER
#pragma warning(pop)
#endif
/*************************************************************************************************/

template <char Mask, typename BinaryInteger>
inline char add_mask(BinaryInteger code)
{ return char(code | Mask); }

template <std::size_t NumBytes, bool Header, typename BinaryInteger>
inline char utf8_add_mask(BinaryInteger code)
{ return add_mask<utf8_header_t<Header ? NumBytes : 0>::value>(code); }

/*************************************************************************************************/

template<char Mask, typename BinaryInteger>
inline char strip_mask(BinaryInteger code)
{ return char(code & ~Mask); }

template <std::size_t NumBytes, bool Header, typename BinaryInteger>
inline char utf8_strip_mask(BinaryInteger code)
{ return strip_mask<utf8_header_t<Header ? NumBytes : 0>::value>(code); }

/*************************************************************************************************/

template <std::size_t Position>
inline utf32_char promote_fragment(char fragment)
{ return utf32_char(fragment << ((Position - 1) * 6)); }

template <>
inline utf32_char promote_fragment<1>(char fragment)
{ return utf32_char(fragment); }

template <>
inline utf32_char promote_fragment<0>(char); // unimplemented

/*************************************************************************************************/

template <std::size_t Position>
inline char demote_fragment(utf32_char fragment)
{ return char((fragment >> ((Position - 1) * 6)) & 0x0000003F); }

template <>
inline char demote_fragment<1>(utf32_char fragment)
{ return char(fragment & 0x0000003F); }

template <>
inline char demote_fragment<0>(utf32_char); // unimplemented

/*************************************************************************************************/

template <std::size_t ByteCount, bool Header = true>
struct demotion_engine_t
{
	template <typename OutputIterator>
	inline OutputIterator operator () (utf32_char code, OutputIterator i)
	{
		*i = utf8_add_mask<ByteCount, Header>(demote_fragment<ByteCount>(code));
		return demotion_engine_t<ByteCount - 1, false>()(code, ++i);
	}
};

template <>
struct demotion_engine_t<1, false>
{
	template <typename OutputIterator>
	inline OutputIterator operator () (utf32_char code, OutputIterator i)
	{
		*i = utf8_add_mask<0, false>(demote_fragment<1>(code));
		return ++i;
	}
};

/*************************************************************************************************/

template <std::size_t ByteCount, bool Header = true>
struct promotion_engine_t
{
	template <typename InputIterator>
	inline utf32_char operator () (InputIterator& first, InputIterator last)
	{
		/*
			CodeWarrior 9.4 doesn't like this code composited into one line;
			GCC doesn't seem to have a problem.
		*/

		char			n(*first);
		char			stripped(utf8_strip_mask<ByteCount, Header>(n));
		utf32_char	 [MASK] (promote_fragment<ByteCount>(stripped));

		++first;

		if (first == last)
		{
			throw std::runtime_error(""unicode: utf32 conversion ran out of input"");
		}

		return  [MASK]  | promotion_engine_t<ByteCount - 1, false>()(first, last);
	}
};

template <>
struct promotion_engine_t<1, false>
{
	template <typename InputIterator>
	inline utf32_char operator () (InputIterator& first, InputIterator)
	{
		utf32_char result(promote_fragment<1>(utf8_strip_mask<0, false>(*first)));

		++first;

		return result;
	}
};

/*************************************************************************************************/

template <typename InputIterator, typename DestInteger>
inline typename enable_if<is_utf16_iterator_type<InputIterator>, InputIterator>::type
	to_utf32 (InputIterator first, InputIterator last, DestInteger& result)
{
	utf16_char code(static_cast<utf16_char>(*first));

	++first;

	if (code >= implementation::utf16_high_surrogate_front_k &&
		code <= implementation::utf16_high_surrogate_back_k)
	{
		result = 0;

		if (first == last)
		{
			throw std::runtime_error(""unicode: utf16 high surrogate found without low surrogate"");
		}

		utf16_char low(static_cast<utf16_char>(*first));

		assert (low >= implementation::utf16_low_surrogate_front_k &&
				low <= implementation::utf16_low_surrogate_back_k);

		++first;

		result =	(code - implementation::utf16_high_surrogate_front_k) * 0x400 +
					(low - implementation::utf16_low_surrogate_front_k) + 0x10000;
	}
	else if (	code >= implementation::utf16_low_surrogate_front_k &&
				code <= implementation::utf16_low_surrogate_back_k)
		{ throw std::runtime_error(""unicode: utf16 low surrogate found without high surrogate""); }
	else
		{ result = static_cast<DestInteger>(code); }

	return first;
}

/*************************************************************************************************/

template <typename InputIterator, typename DestInteger>
inline typename enable_if<is_utf8_iterator_type<InputIterator>, InputIterator>::type
	to_utf32 (InputIterator first, InputIterator last, DestInteger& result)
{
	unsigned char n(static_cast<unsigned char>(*first));

	if (n < implementation::to_utf32_pivot_1_k)
	{
		result = static_cast<DestInteger>(n);
		++first;
	}
	else if (n < implementation::to_utf32_pivot_2_k)
	{
		throw std::runtime_error(""unicode: ill-defined utf8 (< 192)"");
	}
	else if (n < implementation::to_utf32_pivot_3_k)
	{
		result = implementation::promotion_engine_t<2>()(first, last);
	}
	else if (n < implementation::to_utf32_pivot_4_k)
	{
		result = implementation::promotion_engine_t<3>()(first, last);
	}
	else if (n < implementation::to_utf32_pivot_5_k)
	{
		result = implementation::promotion_engine_t<4>()(first, last);
	}
	else if (n < implementation::to_utf32_pivot_6_k)
	{
		result = implementation::promotion_engine_t<5>()(first, last);
	}
	else if (n < implementation::to_utf32_pivot_7_k)
	{
		result = implementation::promotion_engine_t<6>()(first, last);
	}
	else
	{
		throw std::runtime_error(""unicode: ill-defined utf8 (>= 254)"");
	}

	return first;
}

/*************************************************************************************************/

} // namespace implementation

/*************************************************************************************************/

#endif

/*************************************************************************************************/
/*
		utf32 -> utf8
			- 1 source value
			- n output values
*/

template <	typename I, // I models Integer; I must be a valid UTF32-encoded code point
			typename O>	// O models OutputIterator
inline typename enable_if<is_utf32_type<I>, O>::type
	to_utf8(I code, O output)
{
	if (code < implementation::to_utf8_pivot_1_k) // UTF-8 is 1 byte long
	{
		*output = static_cast<char>(code);
		++output;
	}
	else if (code < implementation::to_utf8_pivot_2_k) // UTF-8 is 2 bytes long
	{
		output = implementation::demotion_engine_t<2>()(code, output);
	}
	else if (code < implementation::to_utf8_pivot_3_k) // UTF-8 is 3 bytes long
	{
		output = implementation::demotion_engine_t<3>()(code, output);
	}
	else if (code < implementation::to_utf8_pivot_4_k) // UTF-8 is 4 bytes long
	{
		output = implementation::demotion_engine_t<4>()(code, output);
	}
	else if (code < implementation::to_utf8_pivot_5_k) // UTF-8 is 5 bytes long
	{
		output = implementation::demotion_engine_t<5>()(code, output);
	}
	else // UTF-8 is 6 bytes long
	{
		output = implementation::demotion_engine_t<6>()(code, output);
	}

	return output;
}

/*************************************************************************************************/
/*
		utf16 -> utf8
			- 1 source value
			- n output values
*/

template <	typename I, // I models Integer; I must be a valid UTF32-encoded code point
			typename O>	// O models OutputIterator
inline typename enable_if<is_utf16_type<I>, O>::type
	to_utf8(I code, O output)
{
	return to_utf8(static_cast<utf32_char>(code), output);
}

/*************************************************************************************************/
/*
		utf16 -> utf8
			- n source values
			- m output values
*/

template <	typename I, // I models InputIterator
			typename O> // O models OutputIterator
inline typename enable_if<is_utf16_iterator_type<I>, O>::type
	to_utf8(I first, I last, O output)
{
	while (first != last)
	{
		utf32_char	result;

		first = implementation::to_utf32(first, last, result);

		output = to_utf8(result, output);
	}
	return output;
}

/*************************************************************************************************/
/*
		utf32 -> utf8
			- n source values
			- m output values
*/

template <	typename I, // I models InputIterator
			typename O> // O models OutputIterator
inline typename enable_if<is_utf32_iterator_type<I>, O>::type
	to_utf8(I first, I last, O output)
{
    while ( first != last )
    {
        output = to_utf8(*first, output);
        ++first;
    }
	return output;
}

/*************************************************************************************************/
/*
		utf32 -> utf16
			- 1 source value
			- n output values
*/

template <	typename I, // I models Integer; sizeof(I) must equal 4; code must be valid utf32
			typename O>	// O models OutputIterator
inline typename enable_if<is_utf32_type<I>, O>::type
	to_utf16(I code, O output)
{
	if (code <= implementation::to_utf16_surrogate_pivot_k)
	{
		*output = static_cast<utf16_char>(code);
	}
	else
	{
		*output = static_cast<utf16_char>((code - 0x10000) / 0x400 + implementation::utf16_high_surrogate_front_k);

		++output;

		*output = static_cast<utf16_char>((code - 0x10000) % 0x400 + implementation::utf16_low_surrogate_front_k);
	}
	return ++output;
}

/*************************************************************************************************/
/*
		utf8 -> utf16
			- n source values
			- m output values
*/
template <	typename I, // I models InputIterator
			typename O> // O models OutputIterator
inline typename enable_if<is_utf8_iterator_type<I>, O>::type
	to_utf16(I first, I last, O output)
{
	while (first != last)
	{
		utf32_char	result;

		first = implementation::to_utf32(first, last, result);

		output = to_utf16(result, output);
	}
	return output;
}

/*************************************************************************************************/
/*
		utf32 -> utf16
			- n source values
			- m output values
*/
template <	typename I, // I models InputIterator
			typename O> // O models OutputIterator
inline typename enable_if<is_utf32_iterator_type<I>, O>::type
	to_utf16(I first, I last, O output)
{
	while (first != last)
	{
		output = to_utf16(*first, output);
		++first;
	}
	return output;
}

/*************************************************************************************************/
/*
	Precondition: [ first, last ) must convert to exactly one UTF-16 character
*/

template <typename I>
inline typename enable_if<is_utf8_iterator_type<I>, utf16_char>::type
	to_utf16(I first, I last)
{
	utf32_char result;

	implementation::to_utf32(first, last, result);
	return static_cast<utf16_char>(result);
}

/*************************************************************************************************/
/*
		utf16 -> utf32
			- n source values
			- m output values

		utf8 -> utf32
			- n source values
			- m output values
*/

template <	typename I, // I models InputIterator
			typename O>	// O models OutputIterator
inline O to_utf32(I first, I last, O output)
{
	utf32_char result;

	while (first != last)
	{
		first = implementation::to_utf32(first, last, result);

		*output = result;

		++output;
	}
	return output;
}

/*************************************************************************************************/
/*
	Precondition: [ first, last ) must convert to exactly one UTF-32 character
*/

template <typename I> // I models InputIterator
inline utf32_char to_utf32(I first, I last)
{
	utf32_char result;

	implementation::to_utf32(first, last, result);
	return result;
}

/*************************************************************************************************/

} // namespace adobe

/*************************************************************************************************/

#endif

/*************************************************************************************************/
",shifted
913,"#include ""Display.h""

#include <Adafruit_GFX.h>

namespace
{
    GFXglyph *pgm_read_glyph_ptr(const GFXfont *gfxFont, uint8_t c)
    {
#ifdef __AVR__
        return &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
#else
        // expression in __AVR__ section may generate ""dereferencing type-punned pointer will break strict-aliasing rules"" warning
        // In fact, on other platforms (such as STM32) there is no need to do this pointer magic as program memory may be read in a usual way
        // So expression may be simplified
        return gfxFont->glyph + c;
#endif //__AVR__
    }
}

Display::Display() : Adafruit_SSD1306(0)
{
    char_dimension = getCharDimension();
    status_bar_dimension = Dimension{width(), 8};
    print_dimension = Dimension(width(), height() - status_bar_dimension.height);
    print_area = Rectangle(0, status_bar_dimension.height, width(), height() - status_bar_dimension.height);
}

void Display::setup()
{
    begin(SSD1306_SWITCHCAPVCC, 0x3C);
    dim(true);
    setTextSize(1);
    setTextColor(WHITE);
    display();
    setCursor(print_area.x, print_area.y);
    dim(false);
}

void Display::reset()
{
    Rectangle &s = print_area;
    fillRect(s.x, s.y, s.width, s.height, BLACK);
    setCursorPosition(0, 8);
}


void Display::setCursorPosition(int16_t x, int16_t y)
{
    if (x < 0)
    {
        x = width() + x;
    }

    if (y < 0)
    {
        y = height() + y;
    }
    setCursor(x, y);
}

Dimension Display::getCharDimension(char c)
{
    int16_t x = 0, y = 0, minx = 0, miny = 0,  [MASK]  = 0, maxy = 0;
    charBounds(c, &x, &y, &minx, &miny, & [MASK] , &maxy);

    int16_t width =  [MASK]  - minx;
    int16_t height = maxy - miny;

    return Dimension{width, height};
}

void Display::off()
{
    ssd1306_command(SSD1306_DISPLAYOFF);
}

void Display::on()
{
    ssd1306_command(SSD1306_DISPLAYON);
}



",maxx
914,"#include <iostream>

#define N 5
/*
unsigned int graph[N][N] =
{   
    {0, 0, 1, 3, 0}, 
    {0, 0, 0, 0, 5},
    {0, 2, 0, 1, 0},
    {0, 0, 0, 0, 5},
    {0, 0, 0, 5, 0}
};
*/
unsigned int graph[N][N] =
{
    {0, 7, 9, 0, 14},
    {7, 0, 10, 15, 0},
    {9, 10, 0, 11, 2},
    {0, 15, 11, 0, 17},
    {14, 0, 2, 17, 0}
};

// returns index of minimum element in array
size_t find_min(unsigned int* arr, bool* visited)
{
    size_t idx = 0;
    for (size_t i = 1; i < N+1; ++i)
    {
        if (!visited[i-1] && (idx == 0 || arr[idx-1] > arr[i-1]))
        {
            idx = i;
        }
    }
    return idx-1;
}

unsigned int min(unsigned int a, unsigned int b)
{
    return a < b ? a : b;
}

unsigned int* dijkstra(size_t start)
{
    static unsigned int shortest[N];
    bool visited[N];

    size_t  [MASK] ;

    // Init dijkstra
    for (size_t i = 0; i < N; ++i)
    {
        visited[i] = false;
        shortest[i] = UINT32_MAX;
    }

    // Start dijkstra
    shortest[start] = 0;
    for (size_t i = 0; i < N; ++i)
    {
         [MASK]  = find_min(shortest, visited);
        visited[ [MASK] ] = true;
        if (shortest[ [MASK] ] == UINT32_MAX) continue;
        for (size_t j = 0; j < N; ++j)
        {
            if (graph[ [MASK] ][j] != 0)
            {
                shortest[j] = min(shortest[j], shortest[ [MASK] ] + graph[ [MASK] ][j]);
            }
        }
    }
     
    return shortest;
}

void print_graph(void)
{
    for (size_t i = 0; i < N; ++i)
    {
        for (size_t j = 0; j < N; ++j)
        {
            std::cout << graph[i][j] << ' ';
        }
        std::cout << std::endl;
    }
}

int main()
{
    unsigned int* ans;
    size_t start_point;
    std::cout << ""Graph:\n"";
    print_graph();
    std::cout << ""Set start point: "";
    std::cin >> start_point;
    ans = dijkstra(start_point);
    for (size_t i = 0; i < N; ++i)
    {
        std::cout << ans[i] << ' ';
    }
    std::cout << std::endl;
}
",current
915,"
#include <gflags/gflags.h>
#include <butil/logging.h>
#include <butil/time.h>
#include ""client.h""
#include <ctime>

DEFINE_string(ts_ip, ""127.0.0.1"", ""IP of ts server"");
DEFINE_int32(ts_port, 8086, ""TCP Port of ts server"");
DEFINE_string(connection_type, """", ""Connection type. Available values: single, pooled, short"");
DEFINE_int32(timeout_ms, 100, ""RPC timeout in milliseconds"");
DEFINE_int32(max_retry, 3, ""Max retries(not including the first RPC)""); 
DEFINE_int32(interval_ms, 1000, ""Milliseconds between consecutive requests"");

int main(int argc, char* argv[]) 
{
    // Parse gflags. We recommend you to use gflags as well.
    GFLAGS_NS::ParseCommandLineFlags(&argc, &argv, true);
    
    // A Channel represents a communication line to a Server. Notice that 
    // Channel is thread-safe and can be shared by all threads in your program.
    brpc::Channel ts_channel;
  
    // Initialize the influxdb channel
    brpc::ChannelOptions  [MASK] ;
     [MASK] .protocol = brpc::PROTOCOL_HTTP;  // or brpc::PROTOCOL_H2
     [MASK] .connection_type = FLAGS_connection_type;
     [MASK] .timeout_ms = FLAGS_timeout_ms/*milliseconds*/;
     [MASK] .max_retry = FLAGS_max_retry;
    if (ts_channel.Init(FLAGS_ts_ip.c_str() , FLAGS_ts_port /*any url*/, & [MASK] ) != 0) {
     LOG(ERROR) << ""Fail to initialize influxdb channel"";
     return -1;
    }

    InfluxClient client(&ts_channel,""127.0.0.1:8086"",""test"");
    client.BatchTime(5);
    int i = 0;
    while (!brpc::IsAskedToQuit()) 
    {        
        
        TSBatchUpdate(client,""test"", ""VentureZhu"", i, i & 1);
        TSQuery(client,""select * from test where status = 1"");
        i++;
        usleep(FLAGS_interval_ms * 1000L);  
    }

    LOG(INFO) << ""Client is going to quit"";
    return 0;
}
",ts_options
916,"#include ""entities/herbivore.hpp""
#include ""entities/algae.hpp""
#include ""entities/predator.hpp""
#include ""ocean.hpp""
#include ""texture_mgr.hpp""
#include ""utils/rng.hpp""
#include ""constants.hpp""

#include <array>
#include <algorithm>
#include <vector>

namespace {
    const std::array<std::pair<int,int>,4> dirs{{{0,-1},{-1,0},{1,0},{0,1}}};
    auto& rng = Rng::instance().engine();
}

static bool isPred (const Ocean& oc,int x,int y){ return dynamic_cast<Predator* >(oc.entityAt(x,y)); }
static bool isAlgae(const Ocean& oc,int x,int y){ return dynamic_cast<Algae*   >(oc.entityAt(x,y)); }
static Herbivore* getHerb(const Ocean& oc,int x,int y){ return dynamic_cast<Herbivore*>(oc.entityAt(x,y)); }

inline int fishDepthLimit(const Ocean& oc){ return oc.height() - 5; }

void Herbivore::update(Ocean& oc,int x,int y)
{
    ++age_;
    ++hunger_;

    bool  [MASK]  = (hunger_ >= HUNGRY_HERB);
    if(mateReady_ &&  [MASK] ) mateReady_ = false;

    if(age_ >= AGE_LIMIT && oc.population().herb >= MAX_POP){
        oc.clearCell(x,y);
        return;}

    int foodX=-1, foodY=-1, foodD=999;
    if( [MASK] )
        for(int yy=0; yy<fishDepthLimit(oc); ++yy)
            for(int xx=0; xx<oc.width(); ++xx)
                if(isAlgae(oc,xx,yy)){
                    int d = std::abs(xx-x)+std::abs(yy-y);
                    if(d < foodD){ foodD=d; foodX=xx; foodY=yy; }}

    int mateX=-1, mateY=-1, mateD=999;
    if(mateReady_)
        for(int yy=0; yy<fishDepthLimit(oc); ++yy)
            for(int xx=0; xx<oc.width(); ++xx)
                if(auto* h=getHerb(oc,xx,yy))
                    if(h!=this && h->mateReady_){
                        int d = std::abs(xx-x)+std::abs(yy-y);
                        if(d < mateD){ mateD=d; mateX=xx; mateY=yy; }}

    std::array<int,4> order{0,1,2,3};
    std::shuffle(order.begin(),order.end(),rng);

    int bestDir=order[0], bestScore=-9999;
    for(int d:order){
        int nx=x+dirs[d].first, ny=y+dirs[d].second;
        if(nx<0||ny<0||nx>=oc.width()||ny>=fishDepthLimit(oc)) continue;
        if(!oc.isEmpty(nx,ny) && !isAlgae(oc,nx,ny))          continue;

        int score = 0;
        if( [MASK]  && isAlgae(oc,nx,ny)) score += 1000;
        if( [MASK]  && foodX>=0) score -= (std::abs(foodX-nx)+std::abs(foodY-ny));
        if(mateX>=0)           score -= (std::abs(mateX-nx)+std::abs(mateY-ny));

        for(int yy=ny-3; yy<=ny+3; ++yy)
            for(int xx=nx-3; xx<=nx+3; ++xx)
                if(isPred(oc,xx,yy)) score -= 5;

        if(score > bestScore){ bestScore=score; bestDir=d; }}

    int nx=x+dirs[bestDir].first, ny=y+dirs[bestDir].second;

    if(isAlgae(oc,nx,ny)){
        bool top = oc.entityAt(nx,ny-1)==nullptr;
        if( [MASK]  || top){
            oc.clearCell(nx,ny);
            oc.shiftColumnDown(nx,ny-1);
            hunger_=0;
            mateReady_=true;
        }
    }
    if(oc.isEmpty(nx,ny)) oc.moveEntity(x,y,nx,ny);

    if(mateReady_)
    {
        const std::array<std::pair<int,int>,4> nbr{{{0,-1},{-1,0},{1,0},{0,1}}};
        for(int d=0; d<4; ++d){
            int ax=x+nbr[d].first, ay=y+nbr[d].second;
            if(auto* h=getHerb(oc,ax,ay); h && h->mateReady_){
                std::vector<std::pair<int,int>> spots;
                for(auto [ux,uy]:nbr){
                    int sx=x+ux, sy=y+uy;
                    if(oc.isEmpty(sx,sy) && sy<fishDepthLimit(oc)) spots.push_back({sx,sy});
                    sx=ax+ux; sy=ay+uy;
                    if(oc.isEmpty(sx,sy) && sy<fishDepthLimit(oc)) spots.push_back({sx,sy});}
                if(!spots.empty() && Rng::instance().chance(BIRTH_HERB)){
                    std::shuffle(spots.begin(),spots.end(),rng);
                    oc.spawn<Herbivore>(spots.front().first, spots.front().second);}
                mateReady_=h->mateReady_=false;
                break;}}}}

void Herbivore::draw(sf::RenderTarget& tgt,float cell,float gx,float gy) const
{
    static const sf::Texture& tex = TextureMgr::inst().get(""herbivore.png"");
    sf::Sprite spr(tex);
    spr.setScale({cell/tex.getSize().x, cell/tex.getSize().y});
    spr.setPosition({gx*cell, gy*cell});
    tgt.draw(spr);}
",hungry
917,"#include ""databasemanager.h""
#include <QDebug>
#include <QtSql/QSqlQuery>
#include <QtSql/QSqlError>
DatabaseManager::DatabaseManager(QObject *parent) :
    QObject(parent)
{
    m_db = QSqlDatabase::addDatabase(""QMYSQL"");
    m_db.setHostName(""localhost"");
    m_db.setDatabaseName(""appstreet"");
    m_db.setUserName(""root"");
    m_db.setPassword(""<PASSWORD>"");
    if (!m_db.open()) qDebug() << ""Failed to connect to mysql as user testuser"" ;

    QString  [MASK]  =
            ""CREATE  TABLE IF NOT EXISTS `appstreet`.`apps` ( \
            `id` INT NOT NULL AUTO_INCREMENT , \
            `appId` VARCHAR(45) NOT NULL UNIQUE , \
            `bundleId` VARCHAR(256) NULL , \
            `updated` VARCHAR(256) NULL, \
            `appstoreUrl` VARCHAR(512) NULL , \
            `title` VARCHAR(128) NULL , \
            `summary` TEXT NULL , \
            `name` VARCHAR(128) NULL , \
            `alternateAppstoreUrl` VARCHAR(512) NULL , \
            `contentType` VARCHAR(128) NULL , \
            `categoryUrl` VARCHAR(512) NULL , \
            `categoryTerm` VARCHAR(128) NULL , \
            `categoryLabel` VARCHAR(128) NULL , \
            `previewType` VARCHAR(128) NULL , \
            `previewUrl` VARCHAR(512) NULL , \
            `previewDuration` VARCHAR(128) NULL , \
            `artistUrl` VARCHAR(512) NULL , \
            `artist` VARCHAR(128) NULL , \
            `priceAmount` VARCHAR(32) NULL , \
            `priceCurrency` VARCHAR(32) NULL , \
            `priceLabel` VARCHAR(128) NULL , \
            `rights` VARCHAR(128) NULL , \
            `releaseDateLabel` VARCHAR(128) NULL , \
            `releaseDate` VARCHAR(128) NULL , \
            `html` TEXT NULL , \
            `type` VARCHAR(128) NULL , \
            PRIMARY KEY (`id`, `appId`) ) \
            ENGINE = MyISAM \
            DEFAULT CHARACTER SET = utf8 \
            COLLATE = utf8_bin;"";

    QSqlQuery query;
    query.exec( [MASK] );

}

DatabaseManager::~DatabaseManager()
{
    QSqlDatabase::removeDatabase(""QMYSQL"");
}

bool DatabaseManager::insertAppObject(QString type, ITunesAppObject *appObj)
{

    QSqlQuery query;
    query.prepare(""INSERT INTO `appstreet`.`apps` (\
                  appId, \
                  updated, \
                  bundleId, \
                  appstoreUrl, \
                  title, \
                  summary, \
                  name, \
                  alternateAppstoreUrl, \
                  contentType, \
                  categoryTerm, \
                  categoryUrl, \
                  categoryLabel, \
                  previewType, \
                  previewUrl, \
                  previewDuration, \
                  artistUrl, \
                  artist, \
                  priceAmount, \
                  priceCurrency, \
                  priceLabel, \
                  rights, \
                  releaseDateLabel, \
                  releaseDate, \
                  html, \
                  type \
                  ) ""
            ""VALUES (:appId, :updated, :bundleId,:appstoreUrl,:title,  :summary, :name, :alternateAppstoreUrl, :contentType, :categoryTerm, :categoryUrl, :categoryLabel, :previewType, :previewUrl, :previewDuration, :artistUrl, :artist, :priceAmount, :priceCurrency, :priceLabel, :rights, :releaseDateLabel, :releaseDate, :html, :type)"");



//    ON DUPLICATE KEY UPDATE \
//    updated = VALUES(:updated), \
//    bundleId = VALUES(:bundleId), \
//    appstoreUrl = VALUES(:appstoreUrl), \
//    title = VALUES(:title), \
//    summary = VALUES(:summary), \
//    name = VALUES(:name), \
//    alternateAppstoreUrl = VALUES(:alternateAppstoreUrl), \
//    contentType = VALUES(:contentType), \
//    categoryTerm = VALUES(:categoryTerm), \
//    categoryUrl = VALUES(:categoryUrl), \
//    categoryLabel = VALUES(:categoryLabel), \
//    previewType = VALUES(:previewType), \
//    previewUrl = VALUES(:previewUrl), \
//    previewDuration = VALUES(:previewDuration), \
//    artistUrl = VALUES(:artistUrl), \
//    artist = VALUES(:artist), \
//    priceAmount = VALUES(:priceAmount), \
//    priceCurrency = VALUES(:priceCurrency), \
//    priceLabel = VALUES(:priceLabel), \
//    rights = VALUES(:rights), \
//    releaseDateLabel = VALUES(:releaseDateLabel), \
//    releaseDate = VALUES(:releaseDate), \
//    html = VALUES(:html), \
//    type = VALUES(:type)

    query.bindValue("":appId"", appObj->id());
    query.bindValue("":updated"", appObj->updated());
    query.bindValue("":bundleId"", appObj->bundleId());
    query.bindValue("":appstoreUrl"", appObj->appstoreUrl());
    query.bindValue("":title"", appObj->title());
    query.bindValue("":summary"", appObj->summary());
    query.bindValue("":name"", appObj->name());
    query.bindValue("":alternateAppstoreUrl"", appObj->alternateAppstoreUrl());
    query.bindValue("":contentType"", appObj->contentType());
    query.bindValue("":categoryTerm"", appObj->categoryTerm());
    query.bindValue("":categoryUrl"", appObj->categoryUrl());
    query.bindValue("":categoryLabel"", appObj->categoryLabel());
    query.bindValue("":previewType"", appObj->previewType());
    query.bindValue("":previewUrl"", appObj->previewUrl());
    query.bindValue("":previewDuration"", appObj->previewDuration());
    query.bindValue("":artistUrl"", appObj->artistUrl());
    query.bindValue("":artist"", appObj->artist());
    query.bindValue("":priceAmount"", appObj->priceAmount());
    query.bindValue("":priceCurrency"", appObj->priceCurrency());
    query.bindValue("":priceLabel"", appObj->priceLabel());
    query.bindValue("":rights"", appObj->rights());
    query.bindValue("":releaseDateLabel"", appObj->releaseDateLabel());
    query.bindValue("":releaseDate"", appObj->releaseDate());
    query.bindValue("":html"", appObj->html());
    query.bindValue("":type"", type);

    if(query.exec())
        return true;
    qDebug() << query.lastError();
    return false;
}
",queryString
918,"#include ""gdexample.hpp""
#include <godot_cpp/core/class_db.hpp>

using namespace godot;

GDExample::GDExample() {
    // Initialize any variables here.
    time_passed = 0.0;
    amplitude = 10.0;
    speed = 10.0;
}


void GDExample::_process(double  [MASK] ) {
    time_passed += speed *  [MASK] ;

    Vector2 new_position = Vector2(
        amplitude + (amplitude * sin(time_passed * 2.0)),
        amplitude + (amplitude * cos(time_passed * 1.5))
    );

    set_position(new_position);
}

double GDExample::get_amplitude() const {
    return amplitude;
}

void GDExample::set_amplitude(const double p_amplitude) {
    amplitude = p_amplitude;
}

double GDExample::get_speed() const {
    return speed;
}

void GDExample::set_speed(const double p_speed) {
    speed = p_speed;
}

void GDExample::_bind_methods() {
    ClassDB::bind_method(D_METHOD(""get_amplitude""), &GDExample::get_amplitude);
    ClassDB::bind_method(D_METHOD(""set_amplitude"", ""p_amplitude""), &GDExample::set_amplitude);

    ADD_PROPERTY(PropertyInfo(Variant::FLOAT, ""amplitude""), ""set_amplitude"", ""get_amplitude"");

    ClassDB::bind_method(D_METHOD(""get_speed""), &GDExample::get_speed);
    ClassDB::bind_method(D_METHOD(""set_speed"", ""p_speed""), &GDExample::set_speed);

    ADD_PROPERTY(PropertyInfo(Variant::FLOAT, ""speed"", PROPERTY_HINT_RANGE, ""0,20,0.01""), ""set_speed"", ""get_speed"");
}",delta
919,"#include <unordered_map>
#include <curl/curl.h>
#include <iostream>
#include <fstream>
#include <string>


class EnvParser { 
    public:
        EnvParser();
        void load_env(std::string fp);
        uint32_t parse_env(); 
        std::string get_var(std::string key);

    private:
        std::string filepath;
        std::unordered_map<std::string, std::string> env_vars;
};

EnvParser::EnvParser() {}

void EnvParser::load_env(std::string fp) {
    filepath = fp;
}

uint32_t EnvParser::parse_env() {
    env_vars.clear();

    std::ifstream file(filepath);
    if (!file.is_open()) {
        std::cerr << ""file is not open"" << std::endl;
        return 0;
    }

    std::string  [MASK] ;

    while (std::getline(file,  [MASK] )) {
        if ( [MASK] .empty()) 
            break;

        size_t pos =  [MASK] .find('=');

        std::string key =  [MASK] .substr(pos + 1);
        std::string var =  [MASK] .substr(0, pos);

        env_vars[key] = var;
    }
    
    file.close();

    return 1;
}

std::string EnvParser::get_var(std::string key) {
    return env_vars[key];
}

 

",env_line
920,"// Fill out your copyright notice in the Description page of Project Settings.

#include ""CI_BaseAIController_CPP.h""
#include ""PathFinding/CI_PathFollowingComponent_CPP.h""
#include ""CI_BaseAIPawn_CPP.h""
#include ""AI/CI_AIManager_CPP.h""
#include ""AI/GOAP/CI_GOAPWorkerComponent_CPP.h""
#include ""Managers/CI_TimeManager_CPP.h""
#include ""TileMap/CI_TileMapCoordinateMath.h""
#include ""TimerManager.h""

ACI_BaseAIController_CPP::ACI_BaseAIController_CPP()
{
	bAttachToPawn = true;
	bIsPlayerController = false;
	IgnoreLookInput = true;
	IgnoreMoveInput = false;

	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT(""Root""));
	pathFollowingComp = CreateDefaultSubobject<UCI_PathFollowingComponent_CPP>(TEXT(""PathFollowingComponent""));
	AddOwnedComponent(pathFollowingComp);

	goapWorkerComponent = CreateDefaultSubobject<UCI_GOAPWorkerComponent_CPP>(TEXT(""GOAPWorkerComp""));
	AddOwnedComponent(goapWorkerComponent);
}

ACI_BaseAIController_CPP::~ACI_BaseAIController_CPP()
{
	/*if (IsValid(pathFollowingComp))
		pathFollowingComp->DestroyComponent();
	if (IsValid(goapWorkerComponent))
		goapWorkerComponent->DestroyComponent*/
}

void ACI_BaseAIController_CPP::RegisterAI()
{
	ACI_AIManager_CPP::GetInstance(GetWorld())->RegisterAI(possessedCustomBasePawn, this);
}

void ACI_BaseAIController_CPP::GetNewTask()
{
	ACI_AIManager_CPP::GetInstance(GetWorld())->GetNextTask(type, currentTask);

	if (currentTask != nullptr)
	{
		goapWorkerComponent->StartNewPlan(currentTask);
	}
	else
	{
		DoIdle();
	}
}

void ACI_BaseAIController_CPP::TaskEnded_Implementation(bool success)
{
	if (success)
		ACI_AIManager_CPP::GetInstance(GetWorld())->FinishTask(currentTask);
	else
		ACI_AIManager_CPP::GetInstance(GetWorld())->CancelTask(currentTask);

	currentTask = nullptr;
}

void ACI_BaseAIController_CPP::BeginPlay()
{
	Super::BeginPlay();

	goapWorkerComponent->startPath.RemoveDynamic(pathFollowingComp, &UCI_PathFollowingComponent_CPP::GetNewPath);
	goapWorkerComponent->startPath.AddDynamic(pathFollowingComp, &UCI_PathFollowingComponent_CPP::GetNewPath);
	goapWorkerComponent->finishedCallback.RemoveDynamic(this, &ACI_BaseAIController_CPP::TaskEnded);
	goapWorkerComponent->finishedCallback.AddDynamic(this, &ACI_BaseAIController_CPP::TaskEnded);

	pathFollowingComp->pathFinishedDelegate.RemoveDynamic(goapWorkerComponent, &UCI_GOAPWorkerComponent_CPP::PathFinished);
	pathFollowingComp->pathFinishedDelegate.AddDynamic(goapWorkerComponent, &UCI_GOAPWorkerComponent_CPP::PathFinished);

	ACI_TimeManager_CPP::GetInstance(GetWorld())->nextHourDelegate.AddDynamic(this, &ACI_BaseAIController_CPP::HourChanged);
}

void ACI_BaseAIController_CPP::Tick(float  [MASK] ) 
{
	Super::Tick( [MASK] );
}

void ACI_BaseAIController_CPP::Possess(APawn* InPawn)
{
	Super::Possess(InPawn);


	if (InPawn->GetClass()->IsChildOf(ACI_BaseAIPawn_CPP::StaticClass()))
	{
		possessedCustomBasePawn = Cast<ACI_BaseAIPawn_CPP>(InPawn);

		goapWorkerComponent->stateChangedCallback.AddDynamic(possessedCustomBasePawn, &ACI_BaseAIPawn_CPP::StateChanged);
		GetWorldTimerManager().SetTimerForNextTick(this, &ACI_BaseAIController_CPP::RegisterAI);

		possessedCustomBasePawn->aiName = name;

		HourChanged(ACI_TimeManager_CPP::GetInstance(GetWorld())->GetCurrentTime().Y);
	}
}

void ACI_BaseAIController_CPP::UnPossess()
{
	Super::UnPossess();

	if (ACI_AIManager_CPP::GetInstance(GetWorld()).IsValid())
		ACI_AIManager_CPP::GetInstance(GetWorld())->RemoveAI(possessedCustomBasePawn, type);

	possessedCustomBasePawn = nullptr;
}

void ACI_BaseAIController_CPP::EnterMap()
{
	isAway = false;
	possessedCustomBasePawn->SetActorHiddenInGame(false);
}

void ACI_BaseAIController_CPP::LeaveMap()
{
	isAway = true;

	if (goapWorkerComponent->IsActiveState())
	{
		goapWorkerComponent->CancelPlan();
	}

	if (pathFollowingComp->IsActiveState())
	{
		pathFollowingComp->CancelPath();
	}

	pathFollowingComp->GetNewPath(UCI_TileMapCoordinateMath::WorldVectorToTile(possessedCustomBasePawn->GetActorLocation()), ACI_AIManager_CPP::GetInstance(GetWorld())->GetRandomSpawnTile());
}",DeltaSeconds
921,"//===- ARMFrameLowering.cpp - ARM Frame Information -----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains the ARM implementation of TargetFrameLowering class.
//
//===----------------------------------------------------------------------===//
//
// This file contains the ARM implementation of TargetFrameLowering class.
//
// On ARM, stack frames are structured as follows:
//
// The stack grows downward.
//
// All of the individual frame areas on the frame below are optional, i.e. it's
// possible to create a function so that the particular area isn't present
// in the frame.
//
// At function entry, the ""frame"" looks as follows:
//
// |                                   | Higher address
// |-----------------------------------|
// |                                   |
// | arguments passed on the stack     |
// |                                   |
// |-----------------------------------| <- sp
// |                                   | Lower address
//
//
// After the prologue has run, the frame has the following general structure.
// Technically the last frame area (VLAs) doesn't get created until in the
// main function body, after the prologue is run. However, it's depicted here
// for completeness.
//
// |                                   | Higher address
// |-----------------------------------|
// |                                   |
// | arguments passed on the stack     |
// |                                   |
// |-----------------------------------| <- (sp at function entry)
// |                                   |
// | varargs from registers            |
// |                                   |
// |-----------------------------------|
// |                                   |
// | prev_lr                           |
// | prev_fp                           |
// | (a.k.a. ""frame record"")           |
// |                                   |
// |- - - - - - - - - - - - - - - - - -| <- fp (r7 or r11)
// |                                   |
// | callee-saved gpr registers        |
// |                                   |
// |-----------------------------------|
// |                                   |
// | callee-saved fp/simd regs         |
// |                                   |
// |-----------------------------------|
// |.empty.space.to.make.part.below....|
// |.aligned.in.case.it.needs.more.than| (size of this area is unknown at
// |.the.standard.8-byte.alignment.....|  compile time; if present)
// |-----------------------------------|
// |                                   |
// | local variables of fixed size     |
// | including spill slots             |
// |-----------------------------------| <- base pointer (not defined by ABI,
// |.variable-sized.local.variables....|       LLVM chooses r6)
// |.(VLAs)............................| (size of this area is unknown at
// |...................................|  compile time)
// |-----------------------------------| <- sp
// |                                   | Lower address
//
//
// To access the data in a frame, at-compile time, a constant offset must be
// computable from one of the pointers (fp, bp, sp) to access it. The size
// of the areas with a dotted background cannot be computed at compile-time
// if they are present, making it required to have all three of fp, bp and
// sp to be set up to be able to access all contents in the frame areas,
// assuming all of the frame areas are non-empty.
//
// For most functions, some of the frame areas are empty. For those functions,
// it may not be necessary to set up fp or bp:
// * A base pointer is definitely needed when there are both VLAs and local
//   variables with more-than-default alignment requirements.
// * A frame pointer is definitely needed when there are local variables with
//   more-than-default alignment requirements.
//
// In some cases when a base pointer is not strictly needed, it is generated
// anyway when offsets from the frame pointer to access local variables become
// so large that the offset can't be encoded in the immediate fields of loads
// or stores.
//
// The frame pointer might be chosen to be r7 or r11, depending on the target
// architecture and operating system. See ARMSubtarget::getFramePointerReg for
// details.
//
// Outgoing function arguments must be at the bottom of the stack frame when
// calling another function. If we do not have variable-sized stack objects, we
// can allocate a ""reserved call frame"" area at the bottom of the local
// variable area, large enough for all outgoing calls. If we do have VLAs, then
// the stack pointer must be decremented and incremented around each call to
// make space for the arguments below the VLAs.
//
//===----------------------------------------------------------------------===//

#include ""ARMFrameLowering.h""
#include ""ARMBaseInstrInfo.h""
#include ""ARMBaseRegisterInfo.h""
#include ""ARMConstantPoolValue.h""
#include ""ARMMachineFunctionInfo.h""
#include ""ARMSubtarget.h""
#include ""MCTargetDesc/ARMAddressingModes.h""
#include ""MCTargetDesc/ARMBaseInfo.h""
#include ""Utils/ARMBaseInfo.h""
#include ""llvm/ADT/BitVector.h""
#include ""llvm/ADT/STLExtras.h""
#include ""llvm/ADT/SmallPtrSet.h""
#include ""llvm/ADT/SmallVector.h""
#include ""llvm/CodeGen/MachineBasicBlock.h""
#include ""llvm/CodeGen/MachineConstantPool.h""
#include ""llvm/CodeGen/MachineFrameInfo.h""
#include ""llvm/CodeGen/MachineFunction.h""
#include ""llvm/CodeGen/MachineInstr.h""
#include ""llvm/CodeGen/MachineInstrBuilder.h""
#include ""llvm/CodeGen/MachineJumpTableInfo.h""
#include ""llvm/CodeGen/MachineModuleInfo.h""
#include ""llvm/CodeGen/MachineOperand.h""
#include ""llvm/CodeGen/MachineRegisterInfo.h""
#include ""llvm/CodeGen/RegisterScavenging.h""
#include ""llvm/CodeGen/TargetInstrInfo.h""
#include ""llvm/CodeGen/TargetOpcodes.h""
#include ""llvm/CodeGen/TargetRegisterInfo.h""
#include ""llvm/CodeGen/TargetSubtargetInfo.h""
#include ""llvm/IR/Attributes.h""
#include ""llvm/IR/CallingConv.h""
#include ""llvm/IR/DebugLoc.h""
#include ""llvm/IR/Function.h""
#include ""llvm/MC/MCAsmInfo.h""
#include ""llvm/MC/MCContext.h""
#include ""llvm/MC/MCDwarf.h""
#include ""llvm/MC/MCInstrDesc.h""
#include ""llvm/MC/MCRegisterInfo.h""
#include ""llvm/Support/CodeGen.h""
#include ""llvm/Support/CommandLine.h""
#include ""llvm/Support/Compiler.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/Support/ErrorHandling.h""
#include ""llvm/Support/MathExtras.h""
#include ""llvm/Support/raw_ostream.h""
#include ""llvm/Target/TargetMachine.h""
#include ""llvm/Target/TargetOptions.h""
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <utility>
#include <vector>

#define DEBUG_TYPE ""arm-frame-lowering""

using namespace llvm;

static cl::opt<bool>
SpillAlignedNEONRegs(""align-neon-spills"", cl::Hidden, cl::init(true),
                     cl::desc(""Align ARM NEON spills in prolog and epilog""));

static MachineBasicBlock::iterator
skipAlignedDPRCS2Spills(MachineBasicBlock::iterator MI,
                        unsigned NumAlignedDPRCS2Regs);

ARMFrameLowering::ARMFrameLowering(const ARMSubtarget &sti)
    : TargetFrameLowering(StackGrowsDown, sti.getStackAlignment(), 0, Align(4)),
      STI(sti) {}

bool ARMFrameLowering::keepFramePointer(const MachineFunction &MF) const {
  // iOS always has a FP for backtracking, force other targets to keep their FP
  // when doing FastISel. The emitted code is currently superior, and in cases
  // like test-suite's lencod FastISel isn't quite correct when FP is eliminated.
  return MF.getSubtarget<ARMSubtarget>().useFastISel();
}

/// Returns true if the target can safely skip saving callee-saved registers
/// for noreturn nounwind functions.
bool ARMFrameLowering::enableCalleeSaveSkip(const MachineFunction &MF) const {
  assert(MF.getFunction().hasFnAttribute(Attribute::NoReturn) &&
         MF.getFunction().hasFnAttribute(Attribute::NoUnwind) &&
         !MF.getFunction().hasFnAttribute(Attribute::UWTable));

  // Frame pointer and link register are not treated as normal CSR, thus we
  // can always skip CSR saves for nonreturning functions.
  return true;
}

/// hasFP - Return true if the specified function should have a dedicated frame
/// pointer register.  This is true if the function has variable sized allocas
/// or if frame pointer elimination is disabled.
bool ARMFrameLowering::hasFP(const MachineFunction &MF) const {
  const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
  const MachineFrameInfo &MFI = MF.getFrameInfo();

  // ABI-required frame pointer.
  if (MF.getTarget().Options.DisableFramePointerElim(MF))
    return true;

  // Frame pointer required for use within this function.
  return (RegInfo->hasStackRealignment(MF) || MFI.hasVarSizedObjects() ||
          MFI.isFrameAddressTaken());
}

/// isFPReserved - Return true if the frame pointer register should be
/// considered a reserved register on the scope of the specified function.
bool ARMFrameLowering::isFPReserved(const MachineFunction &MF) const {
  return hasFP(MF) || MF.getSubtarget<ARMSubtarget>().createAAPCSFrameChain();
}

/// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
/// not required, we reserve argument space for call sites in the function
/// immediately on entry to the current function.  This eliminates the need for
/// add/sub sp brackets around call sites.  Returns true if the call frame is
/// included as part of the stack frame.
bool ARMFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
  const MachineFrameInfo &MFI = MF.getFrameInfo();
  unsigned CFSize = MFI.getMaxCallFrameSize();
  // It's not always a good idea to include the call frame as part of the
  // stack frame. ARM (especially Thumb) has small immediate offset to
  // address the stack frame. So a large call frame can cause poor codegen
  // and may even makes it impossible to scavenge a register.
  if (CFSize >= ((1 << 12) - 1) / 2)  // Half of imm12
    return false;

  return !MFI.hasVarSizedObjects();
}

/// canSimplifyCallFramePseudos - If there is a reserved call frame, the
/// call frame pseudos can be simplified.  Unlike most targets, having a FP
/// is not sufficient here since we still may reference some objects via SP
/// even when FP is available in Thumb2 mode.
bool
ARMFrameLowering::canSimplifyCallFramePseudos(const MachineFunction &MF) const {
  return hasReservedCallFrame(MF) || MF.getFrameInfo().hasVarSizedObjects();
}

// Returns how much of the incoming argument stack area we should clean up in an
// epilogue. For the C calling convention this will be 0, for guaranteed tail
// call conventions it can be positive (a normal return or a tail call to a
// function that uses less stack space for arguments) or negative (for a tail
// call to a function that needs more stack space than us for arguments).
static int getArgumentStackToRestore(MachineFunction &MF,
                                     MachineBasicBlock &MBB) {
  MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
  bool IsTailCallReturn = false;
  if (MBB.end() != MBBI) {
    unsigned RetOpcode = MBBI->getOpcode();
    IsTailCallReturn = RetOpcode == ARM::TCRETURNdi ||
                       RetOpcode == ARM::TCRETURNri;
  }
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();

  int ArgumentPopSize = 0;
  if (IsTailCallReturn) {
    MachineOperand &StackAdjust = MBBI->getOperand(1);

    // For a tail-call in a callee-pops-arguments environment, some or all of
    // the stack may actually be in use for the call's arguments, this is
    // calculated during LowerCall and consumed here...
    ArgumentPopSize = StackAdjust.getImm();
  } else {
    // ... otherwise the amount to pop is *all* of the argument space,
    // conveniently stored in the MachineFunctionInfo by
    // LowerFormalArguments. This will, of course, be zero for the C calling
    // convention.
    ArgumentPopSize = AFI->getArgumentStackToRestore();
  }

  return ArgumentPopSize;
}

static bool needsWinCFI(const MachineFunction &MF) {
  const Function &F = MF.getFunction();
  return MF.getTarget().getMCAsmInfo()->usesWindowsCFI() &&
         F.needsUnwindTableEntry();
}

// Given a load or a store instruction, generate an appropriate unwinding SEH
// code on Windows.
static MachineBasicBlock::iterator insertSEH(MachineBasicBlock::iterator MBBI,
                                             const TargetInstrInfo &TII,
                                             unsigned Flags) {
  unsigned Opc = MBBI->getOpcode();
  MachineBasicBlock *MBB = MBBI->getParent();
  MachineFunction &MF = *MBB->getParent();
  DebugLoc DL = MBBI->getDebugLoc();
  MachineInstrBuilder MIB;
  const ARMSubtarget &Subtarget = MF.getSubtarget<ARMSubtarget>();
  const ARMBaseRegisterInfo *RegInfo = Subtarget.getRegisterInfo();

  Flags |= MachineInstr::NoMerge;

  switch (Opc) {
  default:
    report_fatal_error(""No SEH Opcode for instruction "" + TII.getName(Opc));
    break;
  case ARM::t2ADDri:   // add.w r11, sp, #xx
  case ARM::t2ADDri12: // add.w r11, sp, #xx
  case ARM::t2MOVTi16: // movt  r4, #xx
  case ARM::tBL:       // bl __chkstk
    // These are harmless if used for just setting up a frame pointer,
    // but that frame pointer can't be relied upon for unwinding, unless
    // set up with SEH_SaveSP.
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_Nop))
              .addImm(/*Wide=*/1)
              .setMIFlags(Flags);
    break;

  case ARM::t2MOVi16: { // mov(w) r4, #xx
    bool Wide = MBBI->getOperand(1).getImm() >= 256;
    if (!Wide) {
      MachineInstrBuilder NewInstr =
          BuildMI(MF, DL, TII.get(ARM::tMOVi8)).setMIFlags(MBBI->getFlags());
      NewInstr.add(MBBI->getOperand(0));
      NewInstr.add(t1CondCodeOp(/*isDead=*/true));
      for (MachineOperand &MO : llvm::drop_begin(MBBI->operands()))
        NewInstr.add(MO);
      MachineBasicBlock::iterator NewMBBI = MBB->insertAfter(MBBI, NewInstr);
      MBB->erase(MBBI);
      MBBI = NewMBBI;
    }
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_Nop)).addImm(Wide).setMIFlags(Flags);
    break;
  }

  case ARM::tBLXr: // blx r12 (__chkstk)
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_Nop))
              .addImm(/*Wide=*/0)
              .setMIFlags(Flags);
    break;

  case ARM::t2MOVi32imm: // movw+movt
    // This pseudo instruction expands into two mov instructions. If the
    // second operand is a symbol reference, this will stay as two wide
    // instructions, movw+movt. If they're immediates, the first one can
    // end up as a narrow mov though.
    // As two SEH instructions are appended here, they won't get interleaved
    // between the two final movw/movt instructions, but it doesn't make any
    // practical difference.
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_Nop))
              .addImm(/*Wide=*/1)
              .setMIFlags(Flags);
    MBB->insertAfter(MBBI, MIB);
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_Nop))
              .addImm(/*Wide=*/1)
              .setMIFlags(Flags);
    break;

  case ARM::t2STR_PRE:
    if (MBBI->getOperand(0).getReg() == ARM::SP &&
        MBBI->getOperand(2).getReg() == ARM::SP &&
        MBBI->getOperand(3).getImm() == -4) {
      unsigned Reg = RegInfo->getSEHRegNum(MBBI->getOperand(1).getReg());
      MIB = BuildMI(MF, DL, TII.get(ARM::SEH_SaveRegs))
                .addImm(1ULL << Reg)
                .addImm(/*Wide=*/1)
                .setMIFlags(Flags);
    } else {
      report_fatal_error(""No matching SEH Opcode for t2STR_PRE"");
    }
    break;

  case ARM::t2LDR_POST:
    if (MBBI->getOperand(1).getReg() == ARM::SP &&
        MBBI->getOperand(2).getReg() == ARM::SP &&
        MBBI->getOperand(3).getImm() == 4) {
      unsigned Reg = RegInfo->getSEHRegNum(MBBI->getOperand(0).getReg());
      MIB = BuildMI(MF, DL, TII.get(ARM::SEH_SaveRegs))
                .addImm(1ULL << Reg)
                .addImm(/*Wide=*/1)
                .setMIFlags(Flags);
    } else {
      report_fatal_error(""No matching SEH Opcode for t2LDR_POST"");
    }
    break;

  case ARM::t2LDMIA_RET:
  case ARM::t2LDMIA_UPD:
  case ARM::t2STMDB_UPD: {
    unsigned Mask = 0;
    bool Wide = false;
    for (unsigned i = 4, NumOps = MBBI->getNumOperands(); i != NumOps; ++i) {
      const MachineOperand &MO = MBBI->getOperand(i);
      if (!MO.isReg() || MO.isImplicit())
        continue;
      unsigned Reg = RegInfo->getSEHRegNum(MO.getReg());
      if (Reg == 15)
        Reg = 14;
      if (Reg >= 8 && Reg <= 13)
        Wide = true;
      else if (Opc == ARM::t2LDMIA_UPD && Reg == 14)
        Wide = true;
      Mask |= 1 << Reg;
    }
    if (!Wide) {
      unsigned NewOpc;
      switch (Opc) {
      case ARM::t2LDMIA_RET:
        NewOpc = ARM::tPOP_RET;
        break;
      case ARM::t2LDMIA_UPD:
        NewOpc = ARM::tPOP;
        break;
      case ARM::t2STMDB_UPD:
        NewOpc = ARM::tPUSH;
        break;
      default:
        llvm_unreachable("""");
      }
      MachineInstrBuilder NewInstr =
          BuildMI(MF, DL, TII.get(NewOpc)).setMIFlags(MBBI->getFlags());
      for (unsigned i = 2, NumOps = MBBI->getNumOperands(); i != NumOps; ++i)
        NewInstr.add(MBBI->getOperand(i));
      MachineBasicBlock::iterator NewMBBI = MBB->insertAfter(MBBI, NewInstr);
      MBB->erase(MBBI);
      MBBI = NewMBBI;
    }
    unsigned SEHOpc =
        (Opc == ARM::t2LDMIA_RET) ? ARM::SEH_SaveRegs_Ret : ARM::SEH_SaveRegs;
    MIB = BuildMI(MF, DL, TII.get(SEHOpc))
              .addImm(Mask)
              .addImm(Wide ? 1 : 0)
              .setMIFlags(Flags);
    break;
  }
  case ARM::VSTMDDB_UPD:
  case ARM::VLDMDIA_UPD: {
    int First = -1, Last = 0;
    for (const MachineOperand &MO : llvm::drop_begin(MBBI->operands(), 4)) {
      unsigned Reg = RegInfo->getSEHRegNum(MO.getReg());
      if (First == -1)
        First = Reg;
      Last = Reg;
    }
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_SaveFRegs))
              .addImm(First)
              .addImm(Last)
              .setMIFlags(Flags);
    break;
  }
  case ARM::tSUBspi:
  case ARM::tADDspi:
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_StackAlloc))
              .addImm(MBBI->getOperand(2).getImm() * 4)
              .addImm(/*Wide=*/0)
              .setMIFlags(Flags);
    break;
  case ARM::t2SUBspImm:
  case ARM::t2SUBspImm12:
  case ARM::t2ADDspImm:
  case ARM::t2ADDspImm12:
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_StackAlloc))
              .addImm(MBBI->getOperand(2).getImm())
              .addImm(/*Wide=*/1)
              .setMIFlags(Flags);
    break;

  case ARM::tMOVr:
    if (MBBI->getOperand(1).getReg() == ARM::SP &&
        (Flags & MachineInstr::FrameSetup)) {
      unsigned Reg = RegInfo->getSEHRegNum(MBBI->getOperand(0).getReg());
      MIB = BuildMI(MF, DL, TII.get(ARM::SEH_SaveSP))
                .addImm(Reg)
                .setMIFlags(Flags);
    } else if (MBBI->getOperand(0).getReg() == ARM::SP &&
               (Flags & MachineInstr::FrameDestroy)) {
      unsigned Reg = RegInfo->getSEHRegNum(MBBI->getOperand(1).getReg());
      MIB = BuildMI(MF, DL, TII.get(ARM::SEH_SaveSP))
                .addImm(Reg)
                .setMIFlags(Flags);
    } else {
      report_fatal_error(""No SEH Opcode for MOV"");
    }
    break;

  case ARM::tBX_RET:
  case ARM::TCRETURNri:
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_Nop_Ret))
              .addImm(/*Wide=*/0)
              .setMIFlags(Flags);
    break;

  case ARM::TCRETURNdi:
    MIB = BuildMI(MF, DL, TII.get(ARM::SEH_Nop_Ret))
              .addImm(/*Wide=*/1)
              .setMIFlags(Flags);
    break;
  }
  return MBB->insertAfter(MBBI, MIB);
}

static MachineBasicBlock::iterator
initMBBRange(MachineBasicBlock &MBB, const MachineBasicBlock::iterator &MBBI) {
  if (MBBI == MBB.begin())
    return MachineBasicBlock::iterator();
  return std::prev(MBBI);
}

static void insertSEHRange(MachineBasicBlock &MBB,
                           MachineBasicBlock::iterator Start,
                           const MachineBasicBlock::iterator &End,
                           const ARMBaseInstrInfo &TII, unsigned MIFlags) {
  if (Start.isValid())
    Start = std::next(Start);
  else
    Start = MBB.begin();

  for (auto MI = Start; MI != End;) {
    auto Next = std::next(MI);
    // Check if this instruction already has got a SEH opcode added. In that
    // case, don't do this generic mapping.
    if (Next != End && isSEHInstruction(*Next)) {
      MI = std::next(Next);
      while (MI != End && isSEHInstruction(*MI))
        ++MI;
      continue;
    }
    insertSEH(MI, TII, MIFlags);
    MI = Next;
  }
}

static void emitRegPlusImmediate(
    bool isARM, MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
    const DebugLoc &dl, const ARMBaseInstrInfo &TII, unsigned DestReg,
    unsigned SrcReg, int NumBytes, unsigned MIFlags = MachineInstr::NoFlags,
    ARMCC::CondCodes Pred = ARMCC::AL, unsigned PredReg = 0) {
  if (isARM)
    emitARMRegPlusImmediate(MBB, MBBI, dl, DestReg, SrcReg, NumBytes,
                            Pred, PredReg, TII, MIFlags);
  else
    emitT2RegPlusImmediate(MBB, MBBI, dl, DestReg, SrcReg, NumBytes,
                           Pred, PredReg, TII, MIFlags);
}

static void emitSPUpdate(bool isARM, MachineBasicBlock &MBB,
                         MachineBasicBlock::iterator &MBBI, const DebugLoc &dl,
                         const ARMBaseInstrInfo &TII, int NumBytes,
                         unsigned MIFlags = MachineInstr::NoFlags,
                         ARMCC::CondCodes Pred = ARMCC::AL,
                         unsigned PredReg = 0) {
  emitRegPlusImmediate(isARM, MBB, MBBI, dl, TII, ARM::SP, ARM::SP, NumBytes,
                       MIFlags, Pred, PredReg);
}

static int sizeOfSPAdjustment(const MachineInstr &MI) {
  int RegSize;
  switch (MI.getOpcode()) {
  case ARM::VSTMDDB_UPD:
    RegSize = 8;
    break;
  case ARM::STMDB_UPD:
  case ARM::t2STMDB_UPD:
    RegSize = 4;
    break;
  case ARM::t2STR_PRE:
  case ARM::STR_PRE_IMM:
    return 4;
  default:
    llvm_unreachable(""Unknown push or pop like instruction"");
  }

  int count = 0;
  // ARM and Thumb2 push/pop insts have explicit ""sp, sp"" operands (+
  // pred) so the list starts at 4.
  for (int i = MI.getNumOperands() - 1; i >= 4; --i)
    count += RegSize;
  return count;
}

static bool WindowsRequiresStackProbe(const MachineFunction &MF,
                                      size_t StackSizeInBytes) {
  const MachineFrameInfo &MFI = MF.getFrameInfo();
  const Function &F = MF.getFunction();
  unsigned StackProbeSize = (MFI.getStackProtectorIndex() > 0) ? 4080 : 4096;

  StackProbeSize =
      F.getFnAttributeAsParsedInteger(""stack-probe-size"", StackProbeSize);
  return (StackSizeInBytes >= StackProbeSize) &&
         !F.hasFnAttribute(""no-stack-arg-probe"");
}

namespace {

struct StackAdjustingInsts {
  struct InstInfo {
    MachineBasicBlock::iterator I;
    unsigned SPAdjust;
    bool BeforeFPSet;
  };

  SmallVector<InstInfo, 4> Insts;

  void addInst(MachineBasicBlock::iterator I, unsigned SPAdjust,
               bool BeforeFPSet = false) {
    InstInfo Info = {I, SPAdjust, BeforeFPSet};
    Insts.push_back(Info);
  }

  void addExtraBytes(const MachineBasicBlock::iterator I, unsigned ExtraBytes) {
    auto Info =
        llvm::find_if(Insts, [&](InstInfo &Info) { return Info.I == I; });
    assert(Info != Insts.end() && ""invalid sp adjusting instruction"");
    Info->SPAdjust += ExtraBytes;
  }

  void emitDefCFAOffsets(MachineBasicBlock &MBB, const DebugLoc &dl,
                         const ARMBaseInstrInfo &TII, bool HasFP) {
    MachineFunction &MF = *MBB.getParent();
    unsigned CFAOffset = 0;
    for (auto &Info : Insts) {
      if (HasFP && !Info.BeforeFPSet)
        return;

      CFAOffset += Info.SPAdjust;
      unsigned CFIIndex = MF.addFrameInst(
          MCCFIInstruction::cfiDefCfaOffset(nullptr, CFAOffset));
      BuildMI(MBB, std::next(Info.I), dl,
              TII.get(TargetOpcode::CFI_INSTRUCTION))
              .addCFIIndex(CFIIndex)
              .setMIFlags(MachineInstr::FrameSetup);
    }
  }
};

} // end anonymous namespace

/// Emit an instruction sequence that will align the address in
/// register Reg by zero-ing out the lower bits.  For versions of the
/// architecture that support Neon, this must be done in a single
/// instruction, since skipAlignedDPRCS2Spills assumes it is done in a
/// single instruction. That function only gets called when optimizing
/// spilling of D registers on a core with the Neon instruction set
/// present.
static void emitAligningInstructions(MachineFunction &MF, ARMFunctionInfo *AFI,
                                     const TargetInstrInfo &TII,
                                     MachineBasicBlock &MBB,
                                     MachineBasicBlock::iterator MBBI,
                                     const DebugLoc &DL, const unsigned Reg,
                                     const Align Alignment,
                                     const bool MustBeSingleInstruction) {
  const ARMSubtarget &AST = MF.getSubtarget<ARMSubtarget>();
  const bool CanUseBFC = AST.hasV6T2Ops() || AST.hasV7Ops();
  const unsigned AlignMask = Alignment.value() - 1U;
  const unsigned NrBitsToZero = Log2(Alignment);
  assert(!AFI->isThumb1OnlyFunction() && ""Thumb1 not supported"");
  if (!AFI->isThumbFunction()) {
    // if the BFC instruction is available, use that to zero the lower
    // bits:
    //   bfc Reg, #0, log2(Alignment)
    // otherwise use BIC, if the mask to zero the required number of bits
    // can be encoded in the bic immediate field
    //   bic Reg, Reg, Alignment-1
    // otherwise, emit
    //   lsr Reg, Reg, log2(Alignment)
    //   lsl Reg, Reg, log2(Alignment)
    if (CanUseBFC) {
      BuildMI(MBB, MBBI, DL, TII.get(ARM::BFC), Reg)
          .addReg(Reg, RegState::Kill)
          .addImm(~AlignMask)
          .add(predOps(ARMCC::AL));
    } else if (AlignMask <= 255) {
      BuildMI(MBB, MBBI, DL, TII.get(ARM::BICri), Reg)
          .addReg(Reg, RegState::Kill)
          .addImm(AlignMask)
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
    } else {
      assert(!MustBeSingleInstruction &&
             ""Shouldn't call emitAligningInstructions demanding a single ""
             ""instruction to be emitted for large stack alignment for a target ""
             ""without BFC."");
      BuildMI(MBB, MBBI, DL, TII.get(ARM::MOVsi), Reg)
          .addReg(Reg, RegState::Kill)
          .addImm(ARM_AM::getSORegOpc(ARM_AM::lsr, NrBitsToZero))
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
      BuildMI(MBB, MBBI, DL, TII.get(ARM::MOVsi), Reg)
          .addReg(Reg, RegState::Kill)
          .addImm(ARM_AM::getSORegOpc(ARM_AM::lsl, NrBitsToZero))
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
    }
  } else {
    // Since this is only reached for Thumb-2 targets, the BFC instruction
    // should always be available.
    assert(CanUseBFC);
    BuildMI(MBB, MBBI, DL, TII.get(ARM::t2BFC), Reg)
        .addReg(Reg, RegState::Kill)
        .addImm(~AlignMask)
        .add(predOps(ARMCC::AL));
  }
}

/// We need the offset of the frame pointer relative to other MachineFrameInfo
/// offsets which are encoded relative to SP at function begin.
/// See also emitPrologue() for how the FP is set up.
/// Unfortunately we cannot determine this value in determineCalleeSaves() yet
/// as assignCalleeSavedSpillSlots() hasn't run at this point. Instead we use
/// this to produce a conservative estimate that we check in an assert() later.
static int getMaxFPOffset(const ARMSubtarget &STI, const ARMFunctionInfo &AFI,
                          const MachineFunction &MF) {
  // For Thumb1, push.w isn't available, so the first push will always push
  // r7 and lr onto the stack first.
  if (AFI.isThumb1OnlyFunction())
    return -AFI.getArgRegsSaveSize() - (2 * 4);
  // This is a conservative estimation: Assume the frame pointer being r7 and
  // pc(""r15"") up to r8 getting spilled before (= 8 registers).
  int MaxRegBytes = 8 * 4;
  if (STI.splitFramePointerPush(MF)) {
    // Here, r11 can be stored below all of r4-r15 (3 registers more than
    // above), plus d8-d15.
    MaxRegBytes = 11 * 4 + 8 * 8;
  }
  int FPCXTSaveSize =
      (STI.hasV8_1MMainlineOps() && AFI.isCmseNSEntryFunction()) ? 4 : 0;
  return -FPCXTSaveSize - AFI.getArgRegsSaveSize() - MaxRegBytes;
}

void ARMFrameLowering::emitPrologue(MachineFunction &MF,
                                    MachineBasicBlock &MBB) const {
  MachineBasicBlock::iterator MBBI = MBB.begin();
  MachineFrameInfo  &MFI = MF.getFrameInfo();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  MachineModuleInfo &MMI = MF.getMMI();
  MCContext &Context = MMI.getContext();
  const TargetMachine &TM = MF.getTarget();
  const MCRegisterInfo *MRI = Context.getRegisterInfo();
  const ARMBaseRegisterInfo *RegInfo = STI.getRegisterInfo();
  const ARMBaseInstrInfo &TII = *STI.getInstrInfo();
  assert(!AFI->isThumb1OnlyFunction() &&
         ""This emitPrologue does not support Thumb1!"");
  bool isARM = !AFI->isThumbFunction();
  Align Alignment = STI.getFrameLowering()->getStackAlign();
  unsigned ArgRegsSaveSize = AFI->getArgRegsSaveSize();
  unsigned NumBytes = MFI.getStackSize();
  const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
  int FPCXTSaveSize = 0;
  bool NeedsWinCFI = needsWinCFI(MF);

  // Debug location must be unknown since the first debug location is used
  // to determine the end of the prologue.
  DebugLoc dl;

  Register FramePtr = RegInfo->getFrameRegister(MF);

  // Determine the sizes of each callee-save spill areas and record which frame
  // belongs to which callee-save spill areas.
  unsigned GPRCS1Size = 0, GPRCS2Size = 0, DPRCSSize = 0;
  int FramePtrSpillFI = 0;
  int D8SpillFI = 0;

  // All calls are tail calls in GHC calling conv, and functions have no
  // prologue/epilogue.
  if (MF.getFunction().getCallingConv() == CallingConv::GHC)
    return;

  StackAdjustingInsts DefCFAOffsetCandidates;
  bool HasFP = hasFP(MF);

  if (!AFI->hasStackFrame() &&
      (!STI.isTargetWindows() || !WindowsRequiresStackProbe(MF, NumBytes))) {
    if (NumBytes != 0) {
      emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes,
                   MachineInstr::FrameSetup);
      DefCFAOffsetCandidates.addInst(std::prev(MBBI), NumBytes, true);
    }
    if (!NeedsWinCFI)
      DefCFAOffsetCandidates.emitDefCFAOffsets(MBB, dl, TII, HasFP);
    if (NeedsWinCFI && MBBI != MBB.begin()) {
      insertSEHRange(MBB, {}, MBBI, TII, MachineInstr::FrameSetup);
      BuildMI(MBB, MBBI, dl, TII.get(ARM::SEH_PrologEnd))
          .setMIFlag(MachineInstr::FrameSetup);
      MF.setHasWinCFI(true);
    }
    return;
  }

  // Determine spill area sizes.
  if (STI.splitFramePointerPush(MF)) {
    for (const CalleeSavedInfo &I : CSI) {
      Register Reg = I.getReg();
      int FI = I.getFrameIdx();
      switch (Reg) {
      case ARM::R11:
      case ARM::LR:
        if (Reg == FramePtr)
          FramePtrSpillFI = FI;
        GPRCS2Size += 4;
        break;
      case ARM::R0:
      case ARM::R1:
      case ARM::R2:
      case ARM::R3:
      case ARM::R4:
      case ARM::R5:
      case ARM::R6:
      case ARM::R7:
      case ARM::R8:
      case ARM::R9:
      case ARM::R10:
      case ARM::R12:
        GPRCS1Size += 4;
        break;
      case ARM::FPCXTNS:
        FPCXTSaveSize = 4;
        break;
      default:
        // This is a DPR. Exclude the aligned DPRCS2 spills.
        if (Reg == ARM::D8)
          D8SpillFI = FI;
        if (Reg < ARM::D8 || Reg >= ARM::D8 + AFI->getNumAlignedDPRCS2Regs())
          DPRCSSize += 8;
      }
    }
  } else {
    for (const CalleeSavedInfo &I : CSI) {
      Register Reg = I.getReg();
      int FI = I.getFrameIdx();
      switch (Reg) {
      case ARM::R8:
      case ARM::R9:
      case ARM::R10:
      case ARM::R11:
      case ARM::R12:
        if (STI.splitFramePushPop(MF)) {
          GPRCS2Size += 4;
          break;
        }
        [[fallthrough]];
      case ARM::R0:
      case ARM::R1:
      case ARM::R2:
      case ARM::R3:
      case ARM::R4:
      case ARM::R5:
      case ARM::R6:
      case ARM::R7:
      case ARM::LR:
        if (Reg == FramePtr)
          FramePtrSpillFI = FI;
        GPRCS1Size += 4;
        break;
      case ARM::FPCXTNS:
        FPCXTSaveSize = 4;
        break;
      default:
        // This is a DPR. Exclude the aligned DPRCS2 spills.
        if (Reg == ARM::D8)
          D8SpillFI = FI;
        if (Reg < ARM::D8 || Reg >= ARM::D8 + AFI->getNumAlignedDPRCS2Regs())
          DPRCSSize += 8;
      }
    }
  }

  MachineBasicBlock::iterator LastPush = MBB.end(), GPRCS1Push, GPRCS2Push;

  // Move past the PAC computation.
  if (AFI->shouldSignReturnAddress())
    LastPush = MBBI++;

  // Move past FPCXT area.
  if (FPCXTSaveSize > 0) {
    LastPush = MBBI++;
    DefCFAOffsetCandidates.addInst(LastPush, FPCXTSaveSize, true);
  }

  // Allocate the vararg register save area.
  if (ArgRegsSaveSize) {
    emitSPUpdate(isARM, MBB, MBBI, dl, TII, -ArgRegsSaveSize,
                 MachineInstr::FrameSetup);
    LastPush = std::prev(MBBI);
    DefCFAOffsetCandidates.addInst(LastPush, ArgRegsSaveSize, true);
  }

  // Move past area 1.
  if (GPRCS1Size > 0) {
    GPRCS1Push = LastPush = MBBI++;
    DefCFAOffsetCandidates.addInst(LastPush, GPRCS1Size, true);
  }

  // Determine starting offsets of spill areas.
  unsigned FPCXTOffset = NumBytes - ArgRegsSaveSize - FPCXTSaveSize;
  unsigned GPRCS1Offset = FPCXTOffset - GPRCS1Size;
  unsigned GPRCS2Offset = GPRCS1Offset - GPRCS2Size;
  Align DPRAlign = DPRCSSize ? std::min(Align(8), Alignment) : Align(4);
  unsigned DPRGapSize = GPRCS1Size + FPCXTSaveSize + ArgRegsSaveSize;
  if (!STI.splitFramePointerPush(MF)) {
    DPRGapSize += GPRCS2Size;
  }
  DPRGapSize %= DPRAlign.value();

  unsigned DPRCSOffset;
  if (STI.splitFramePointerPush(MF)) {
    DPRCSOffset = GPRCS1Offset - DPRGapSize - DPRCSSize;
    GPRCS2Offset = DPRCSOffset - GPRCS2Size;
  } else {
    DPRCSOffset = GPRCS2Offset - DPRGapSize - DPRCSSize;
  }
  int FramePtrOffsetInPush = 0;
  if (HasFP) {
    int FPOffset = MFI.getObjectOffset(FramePtrSpillFI);
    assert(getMaxFPOffset(STI, *AFI, MF) <= FPOffset &&
           ""Max FP estimation is wrong"");
    FramePtrOffsetInPush = FPOffset + ArgRegsSaveSize + FPCXTSaveSize;
    AFI->setFramePtrSpillOffset(MFI.getObjectOffset(FramePtrSpillFI) +
                                NumBytes);
  }
  AFI->setGPRCalleeSavedArea1Offset(GPRCS1Offset);
  AFI->setGPRCalleeSavedArea2Offset(GPRCS2Offset);
  AFI->setDPRCalleeSavedAreaOffset(DPRCSOffset);

  // Move past area 2.
  if (GPRCS2Size > 0 && !STI.splitFramePointerPush(MF)) {
    GPRCS2Push = LastPush = MBBI++;
    DefCFAOffsetCandidates.addInst(LastPush, GPRCS2Size);
  }

  // Prolog/epilog inserter assumes we correctly align DPRs on the stack, so our
  // .cfi_offset operations will reflect that.
  if (DPRGapSize) {
    assert(DPRGapSize == 4 && ""unexpected alignment requirements for DPRs"");
    if (LastPush != MBB.end() &&
        tryFoldSPUpdateIntoPushPop(STI, MF, &*LastPush, DPRGapSize))
      DefCFAOffsetCandidates.addExtraBytes(LastPush, DPRGapSize);
    else {
      emitSPUpdate(isARM, MBB, MBBI, dl, TII, -DPRGapSize,
                   MachineInstr::FrameSetup);
      DefCFAOffsetCandidates.addInst(std::prev(MBBI), DPRGapSize);
    }
  }

  // Move past area 3.
  if (DPRCSSize > 0) {
    // Since vpush register list cannot have gaps, there may be multiple vpush
    // instructions in the prologue.
    while (MBBI != MBB.end() && MBBI->getOpcode() == ARM::VSTMDDB_UPD) {
      DefCFAOffsetCandidates.addInst(MBBI, sizeOfSPAdjustment(*MBBI));
      LastPush = MBBI++;
    }
  }

  // Move past the aligned DPRCS2 area.
  if (AFI->getNumAlignedDPRCS2Regs() > 0) {
    MBBI = skipAlignedDPRCS2Spills(MBBI, AFI->getNumAlignedDPRCS2Regs());
    // The code inserted by emitAlignedDPRCS2Spills realigns the stack, and
    // leaves the stack pointer pointing to the DPRCS2 area.
    //
    // Adjust NumBytes to represent the stack slots below the DPRCS2 area.
    NumBytes += MFI.getObjectOffset(D8SpillFI);
  } else
    NumBytes = DPRCSOffset;

  if (GPRCS2Size > 0 && STI.splitFramePointerPush(MF)) {
    GPRCS2Push = LastPush = MBBI++;
    DefCFAOffsetCandidates.addInst(LastPush, GPRCS2Size);
  }

  bool NeedsWinCFIStackAlloc = NeedsWinCFI;
  if (STI.splitFramePointerPush(MF) && HasFP)
    NeedsWinCFIStackAlloc = false;

  if (STI.isTargetWindows() && WindowsRequiresStackProbe(MF, NumBytes)) {
    uint32_t NumWords = NumBytes >> 2;

    if (NumWords < 65536) {
      BuildMI(MBB, MBBI, dl, TII.get(ARM::t2MOVi16), ARM::R4)
          .addImm(NumWords)
          .setMIFlags(MachineInstr::FrameSetup)
          .add(predOps(ARMCC::AL));
    } else {
      // Split into two instructions here, instead of using t2MOVi32imm,
      // to allow inserting accurate SEH instructions (including accurate
      // instruction size for each of them).
      BuildMI(MBB, MBBI, dl, TII.get(ARM::t2MOVi16), ARM::R4)
          .addImm(NumWords & 0xffff)
          .setMIFlags(MachineInstr::FrameSetup)
          .add(predOps(ARMCC::AL));
      BuildMI(MBB, MBBI, dl, TII.get(ARM::t2MOVTi16), ARM::R4)
          .addReg(ARM::R4)
          .addImm(NumWords >> 16)
          .setMIFlags(MachineInstr::FrameSetup)
          .add(predOps(ARMCC::AL));
    }

    switch (TM.getCodeModel()) {
    case CodeModel::Tiny:
      llvm_unreachable(""Tiny code model not available on ARM."");
    case CodeModel::Small:
    case CodeModel::Medium:
    case CodeModel::Kernel:
      BuildMI(MBB, MBBI, dl, TII.get(ARM::tBL))
          .add(predOps(ARMCC::AL))
          .addExternalSymbol(""__chkstk"")
          .addReg(ARM::R4, RegState::Implicit)
          .setMIFlags(MachineInstr::FrameSetup);
      break;
    case CodeModel::Large:
      BuildMI(MBB, MBBI, dl, TII.get(ARM::t2MOVi32imm), ARM::R12)
        .addExternalSymbol(""__chkstk"")
        .setMIFlags(MachineInstr::FrameSetup);

      BuildMI(MBB, MBBI, dl, TII.get(ARM::tBLXr))
          .add(predOps(ARMCC::AL))
          .addReg(ARM::R12, RegState::Kill)
          .addReg(ARM::R4, RegState::Implicit)
          .setMIFlags(MachineInstr::FrameSetup);
      break;
    }

    MachineInstrBuilder Instr, SEH;
    Instr = BuildMI(MBB, MBBI, dl, TII.get(ARM::t2SUBrr), ARM::SP)
                .addReg(ARM::SP, RegState::Kill)
                .addReg(ARM::R4, RegState::Kill)
                .setMIFlags(MachineInstr::FrameSetup)
                .add(predOps(ARMCC::AL))
                .add(condCodeOp());
    if (NeedsWinCFIStackAlloc) {
      SEH = BuildMI(MF, dl, TII.get(ARM::SEH_StackAlloc))
                .addImm(NumBytes)
                .addImm(/*Wide=*/1)
                .setMIFlags(MachineInstr::FrameSetup);
      MBB.insertAfter(Instr, SEH);
    }
    NumBytes = 0;
  }

  if (NumBytes) {
    // Adjust SP after all the callee-save spills.
    if (AFI->getNumAlignedDPRCS2Regs() == 0 &&
        tryFoldSPUpdateIntoPushPop(STI, MF, &*LastPush, NumBytes))
      DefCFAOffsetCandidates.addExtraBytes(LastPush, NumBytes);
    else {
      emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes,
                   MachineInstr::FrameSetup);
      DefCFAOffsetCandidates.addInst(std::prev(MBBI), NumBytes);
    }

    if (HasFP && isARM)
      // Restore from fp only in ARM mode: e.g. sub sp, r7, #24
      // Note it's not safe to do this in Thumb2 mode because it would have
      // taken two instructions:
      // mov sp, r7
      // sub sp, #24
      // If an interrupt is taken between the two instructions, then sp is in
      // an inconsistent state (pointing to the middle of callee-saved area).
      // The interrupt handler can end up clobbering the registers.
      AFI->setShouldRestoreSPFromFP(true);
  }

  // Set FP to point to the stack slot that contains the previous FP.
  // For iOS, FP is R7, which has now been stored in spill area 1.
  // Otherwise, if this is not iOS, all the callee-saved registers go
  // into spill area 1, including the FP in R11.  In either case, it
  // is in area one and the adjustment needs to take place just after
  // that push.
  // FIXME: The above is not necessary true when PACBTI is enabled.
  // AAPCS requires use of R11, and PACBTI gets in the way of regular pushes,
  // so FP ends up on area two.
  MachineBasicBlock::iterator AfterPush;
  if (HasFP) {
    AfterPush = std::next(GPRCS1Push);
    unsigned PushSize = sizeOfSPAdjustment(*GPRCS1Push);
    int FPOffset = PushSize + FramePtrOffsetInPush;
    if (STI.splitFramePointerPush(MF)) {
      AfterPush = std::next(GPRCS2Push);
      emitRegPlusImmediate(!AFI->isThumbFunction(), MBB, AfterPush, dl, TII,
                           FramePtr, ARM::SP, 0, MachineInstr::FrameSetup);
    } else {
      emitRegPlusImmediate(!AFI->isThumbFunction(), MBB, AfterPush, dl, TII,
                           FramePtr, ARM::SP, FPOffset,
                           MachineInstr::FrameSetup);
    }
    if (!NeedsWinCFI) {
      if (FramePtrOffsetInPush + PushSize != 0) {
        unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::cfiDefCfa(
            nullptr, MRI->getDwarfRegNum(FramePtr, true),
            FPCXTSaveSize + ArgRegsSaveSize - FramePtrOffsetInPush));
        BuildMI(MBB, AfterPush, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
            .addCFIIndex(CFIIndex)
            .setMIFlags(MachineInstr::FrameSetup);
      } else {
        unsigned CFIIndex =
            MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(
                nullptr, MRI->getDwarfRegNum(FramePtr, true)));
        BuildMI(MBB, AfterPush, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
            .addCFIIndex(CFIIndex)
            .setMIFlags(MachineInstr::FrameSetup);
      }
    }
  }

  // Emit a SEH opcode indicating the prologue end. The rest of the prologue
  // instructions below don't need to be replayed to unwind the stack.
  if (NeedsWinCFI && MBBI != MBB.begin()) {
    MachineBasicBlock::iterator End = MBBI;
    if (HasFP && STI.splitFramePointerPush(MF))
      End = AfterPush;
    insertSEHRange(MBB, {}, End, TII, MachineInstr::FrameSetup);
    BuildMI(MBB, End, dl, TII.get(ARM::SEH_PrologEnd))
        .setMIFlag(MachineInstr::FrameSetup);
    MF.setHasWinCFI(true);
  }

  // Now that the prologue's actual instructions are finalised, we can insert
  // the necessary DWARF cf instructions to describe the situation. Start by
  // recording where each register ended up:
  if (GPRCS1Size > 0 && !NeedsWinCFI) {
    MachineBasicBlock::iterator Pos = std::next(GPRCS1Push);
    int CFIIndex;
    for (const auto &Entry : CSI) {
      Register Reg = Entry.getReg();
      int FI = Entry.getFrameIdx();
      switch (Reg) {
      case ARM::R8:
      case ARM::R9:
      case ARM::R10:
      case ARM::R11:
      case ARM::R12:
        if (STI.splitFramePushPop(MF))
          break;
        [[fallthrough]];
      case ARM::R0:
      case ARM::R1:
      case ARM::R2:
      case ARM::R3:
      case ARM::R4:
      case ARM::R5:
      case ARM::R6:
      case ARM::R7:
      case ARM::LR:
        CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
            nullptr, MRI->getDwarfRegNum(Reg, true), MFI.getObjectOffset(FI)));
        BuildMI(MBB, Pos, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
            .addCFIIndex(CFIIndex)
            .setMIFlags(MachineInstr::FrameSetup);
        break;
      }
    }
  }

  if (GPRCS2Size > 0 && !NeedsWinCFI) {
    MachineBasicBlock::iterator Pos = std::next(GPRCS2Push);
    for (const auto &Entry : CSI) {
      Register Reg = Entry.getReg();
      int FI = Entry.getFrameIdx();
      switch (Reg) {
      case ARM::R8:
      case ARM::R9:
      case ARM::R10:
      case ARM::R11:
      case ARM::R12:
        if (STI.splitFramePushPop(MF)) {
          unsigned DwarfReg = MRI->getDwarfRegNum(
              Reg == ARM::R12 ? ARM::RA_AUTH_CODE : Reg, true);
          unsigned Offset = MFI.getObjectOffset(FI);
          unsigned CFIIndex = MF.addFrameInst(
              MCCFIInstruction::createOffset(nullptr, DwarfReg, Offset));
          BuildMI(MBB, Pos, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
              .addCFIIndex(CFIIndex)
              .setMIFlags(MachineInstr::FrameSetup);
        }
        break;
      }
    }
  }

  if (DPRCSSize > 0 && !NeedsWinCFI) {
    // Since vpush register list cannot have gaps, there may be multiple vpush
    // instructions in the prologue.
    MachineBasicBlock::iterator Pos = std::next(LastPush);
    for (const auto &Entry : CSI) {
      Register Reg = Entry.getReg();
      int FI = Entry.getFrameIdx();
      if ((Reg >= ARM::D0 && Reg <= ARM::D31) &&
          (Reg < ARM::D8 || Reg >= ARM::D8 + AFI->getNumAlignedDPRCS2Regs())) {
        unsigned DwarfReg = MRI->getDwarfRegNum(Reg, true);
        unsigned Offset = MFI.getObjectOffset(FI);
        unsigned CFIIndex = MF.addFrameInst(
            MCCFIInstruction::createOffset(nullptr, DwarfReg, Offset));
        BuildMI(MBB, Pos, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
            .addCFIIndex(CFIIndex)
            .setMIFlags(MachineInstr::FrameSetup);
      }
    }
  }

  // Now we can emit descriptions of where the canonical frame address was
  // throughout the process. If we have a frame pointer, it takes over the job
  // half-way through, so only the first few .cfi_def_cfa_offset instructions
  // actually get emitted.
  if (!NeedsWinCFI)
    DefCFAOffsetCandidates.emitDefCFAOffsets(MBB, dl, TII, HasFP);

  if (STI.isTargetELF() && hasFP(MF))
    MFI.setOffsetAdjustment(MFI.getOffsetAdjustment() -
                            AFI->getFramePtrSpillOffset());

  AFI->setFPCXTSaveAreaSize(FPCXTSaveSize);
  AFI->setGPRCalleeSavedArea1Size(GPRCS1Size);
  AFI->setGPRCalleeSavedArea2Size(GPRCS2Size);
  AFI->setDPRCalleeSavedGapSize(DPRGapSize);
  AFI->setDPRCalleeSavedAreaSize(DPRCSSize);

  // If we need dynamic stack realignment, do it here. Be paranoid and make
  // sure if we also have VLAs, we have a base pointer for frame access.
  // If aligned NEON registers were spilled, the stack has already been
  // realigned.
  if (!AFI->getNumAlignedDPRCS2Regs() && RegInfo->hasStackRealignment(MF)) {
    Align MaxAlign = MFI.getMaxAlign();
    assert(!AFI->isThumb1OnlyFunction());
    if (!AFI->isThumbFunction()) {
      emitAligningInstructions(MF, AFI, TII, MBB, MBBI, dl, ARM::SP, MaxAlign,
                               false);
    } else {
      // We cannot use sp as source/dest register here, thus we're using r4 to
      // perform the calculations. We're emitting the following sequence:
      // mov r4, sp
      // -- use emitAligningInstructions to produce best sequence to zero
      // -- out lower bits in r4
      // mov sp, r4
      // FIXME: It will be better just to find spare register here.
      BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVr), ARM::R4)
          .addReg(ARM::SP, RegState::Kill)
          .add(predOps(ARMCC::AL));
      emitAligningInstructions(MF, AFI, TII, MBB, MBBI, dl, ARM::R4, MaxAlign,
                               false);
      BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVr), ARM::SP)
          .addReg(ARM::R4, RegState::Kill)
          .add(predOps(ARMCC::AL));
    }

    AFI->setShouldRestoreSPFromFP(true);
  }

  // If we need a base pointer, set it up here. It's whatever the value
  // of the stack pointer is at this point. Any variable size objects
  // will be allocated after this, so we can still use the base pointer
  // to reference locals.
  // FIXME: Clarify FrameSetup flags here.
  if (RegInfo->hasBasePointer(MF)) {
    if (isARM)
      BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), RegInfo->getBaseRegister())
          .addReg(ARM::SP)
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
    else
      BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVr), RegInfo->getBaseRegister())
          .addReg(ARM::SP)
          .add(predOps(ARMCC::AL));
  }

  // If the frame has variable sized objects then the epilogue must restore
  // the sp from fp. We can assume there's an FP here since hasFP already
  // checks for hasVarSizedObjects.
  if (MFI.hasVarSizedObjects())
    AFI->setShouldRestoreSPFromFP(true);
}

void ARMFrameLowering::emitEpilogue(MachineFunction &MF,
                                    MachineBasicBlock &MBB) const {
  MachineFrameInfo &MFI = MF.getFrameInfo();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
  const ARMBaseInstrInfo &TII =
      *static_cast<const ARMBaseInstrInfo *>(MF.getSubtarget().getInstrInfo());
  assert(!AFI->isThumb1OnlyFunction() &&
         ""This emitEpilogue does not support Thumb1!"");
  bool isARM = !AFI->isThumbFunction();

  // Amount of stack space we reserved next to incoming args for either
  // varargs registers or stack arguments in tail calls made by this function.
  unsigned ReservedArgStack = AFI->getArgRegsSaveSize();

  // How much of the stack used by incoming arguments this function is expected
  // to restore in this particular epilogue.
  int  [MASK]  = getArgumentStackToRestore(MF, MBB);
  int NumBytes = (int)MFI.getStackSize();
  Register FramePtr = RegInfo->getFrameRegister(MF);

  // All calls are tail calls in GHC calling conv, and functions have no
  // prologue/epilogue.
  if (MF.getFunction().getCallingConv() == CallingConv::GHC)
    return;

  // First put ourselves on the first (from top) terminator instructions.
  MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
  DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();

  MachineBasicBlock::iterator RangeStart;
  if (!AFI->hasStackFrame()) {
    if (MF.hasWinCFI()) {
      BuildMI(MBB, MBBI, dl, TII.get(ARM::SEH_EpilogStart))
          .setMIFlag(MachineInstr::FrameDestroy);
      RangeStart = initMBBRange(MBB, MBBI);
    }

    if (NumBytes +  [MASK]  != 0)
      emitSPUpdate(isARM, MBB, MBBI, dl, TII,
                   NumBytes +  [MASK] ,
                   MachineInstr::FrameDestroy);
  } else {
    // Unwind MBBI to point to first LDR / VLDRD.
    if (MBBI != MBB.begin()) {
      do {
        --MBBI;
      } while (MBBI != MBB.begin() &&
               MBBI->getFlag(MachineInstr::FrameDestroy));
      if (!MBBI->getFlag(MachineInstr::FrameDestroy))
        ++MBBI;
    }

    if (MF.hasWinCFI()) {
      BuildMI(MBB, MBBI, dl, TII.get(ARM::SEH_EpilogStart))
          .setMIFlag(MachineInstr::FrameDestroy);
      RangeStart = initMBBRange(MBB, MBBI);
    }

    // Move SP to start of FP callee save spill area.
    NumBytes -= (ReservedArgStack +
                 AFI->getFPCXTSaveAreaSize() +
                 AFI->getGPRCalleeSavedArea1Size() +
                 AFI->getGPRCalleeSavedArea2Size() +
                 AFI->getDPRCalleeSavedGapSize() +
                 AFI->getDPRCalleeSavedAreaSize());

    // Reset SP based on frame pointer only if the stack frame extends beyond
    // frame pointer stack slot or target is ELF and the function has FP.
    if (AFI->shouldRestoreSPFromFP()) {
      NumBytes = AFI->getFramePtrSpillOffset() - NumBytes;
      if (NumBytes) {
        if (isARM)
          emitARMRegPlusImmediate(MBB, MBBI, dl, ARM::SP, FramePtr, -NumBytes,
                                  ARMCC::AL, 0, TII,
                                  MachineInstr::FrameDestroy);
        else {
          // It's not possible to restore SP from FP in a single instruction.
          // For iOS, this looks like:
          // mov sp, r7
          // sub sp, #24
          // This is bad, if an interrupt is taken after the mov, sp is in an
          // inconsistent state.
          // Use the first callee-saved register as a scratch register.
          assert(!MFI.getPristineRegs(MF).test(ARM::R4) &&
                 ""No scratch register to restore SP from FP!"");
          emitT2RegPlusImmediate(MBB, MBBI, dl, ARM::R4, FramePtr, -NumBytes,
                                 ARMCC::AL, 0, TII, MachineInstr::FrameDestroy);
          BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVr), ARM::SP)
              .addReg(ARM::R4)
              .add(predOps(ARMCC::AL))
              .setMIFlag(MachineInstr::FrameDestroy);
        }
      } else {
        // Thumb2 or ARM.
        if (isARM)
          BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), ARM::SP)
              .addReg(FramePtr)
              .add(predOps(ARMCC::AL))
              .add(condCodeOp())
              .setMIFlag(MachineInstr::FrameDestroy);
        else
          BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVr), ARM::SP)
              .addReg(FramePtr)
              .add(predOps(ARMCC::AL))
              .setMIFlag(MachineInstr::FrameDestroy);
      }
    } else if (NumBytes &&
               !tryFoldSPUpdateIntoPushPop(STI, MF, &*MBBI, NumBytes))
      emitSPUpdate(isARM, MBB, MBBI, dl, TII, NumBytes,
                   MachineInstr::FrameDestroy);

    // Increment past our save areas.
    if (AFI->getGPRCalleeSavedArea2Size() && STI.splitFramePointerPush(MF))
      MBBI++;

    if (MBBI != MBB.end() && AFI->getDPRCalleeSavedAreaSize()) {
      MBBI++;
      // Since vpop register list cannot have gaps, there may be multiple vpop
      // instructions in the epilogue.
      while (MBBI != MBB.end() && MBBI->getOpcode() == ARM::VLDMDIA_UPD)
        MBBI++;
    }
    if (AFI->getDPRCalleeSavedGapSize()) {
      assert(AFI->getDPRCalleeSavedGapSize() == 4 &&
             ""unexpected DPR alignment gap"");
      emitSPUpdate(isARM, MBB, MBBI, dl, TII, AFI->getDPRCalleeSavedGapSize(),
                   MachineInstr::FrameDestroy);
    }

    if (AFI->getGPRCalleeSavedArea2Size() && !STI.splitFramePointerPush(MF))
      MBBI++;
    if (AFI->getGPRCalleeSavedArea1Size()) MBBI++;

    if (ReservedArgStack ||  [MASK] ) {
      assert((int)ReservedArgStack +  [MASK]  >= 0 &&
             ""attempting to restore negative stack amount"");
      emitSPUpdate(isARM, MBB, MBBI, dl, TII,
                   ReservedArgStack +  [MASK] ,
                   MachineInstr::FrameDestroy);
    }

    // Validate PAC, It should have been already popped into R12. For CMSE entry
    // function, the validation instruction is emitted during expansion of the
    // tBXNS_RET, since the validation must use the value of SP at function
    // entry, before saving, resp. after restoring, FPCXTNS.
    if (AFI->shouldSignReturnAddress() && !AFI->isCmseNSEntryFunction())
      BuildMI(MBB, MBBI, DebugLoc(), STI.getInstrInfo()->get(ARM::t2AUT));
  }

  if (MF.hasWinCFI()) {
    insertSEHRange(MBB, RangeStart, MBB.end(), TII, MachineInstr::FrameDestroy);
    BuildMI(MBB, MBB.end(), dl, TII.get(ARM::SEH_EpilogEnd))
        .setMIFlag(MachineInstr::FrameDestroy);
  }
}

/// getFrameIndexReference - Provide a base+offset reference to an FI slot for
/// debug info.  It's the same as what we use for resolving the code-gen
/// references for now.  FIXME: This can go wrong when references are
/// SP-relative and simple call frames aren't used.
StackOffset ARMFrameLowering::getFrameIndexReference(const MachineFunction &MF,
                                                     int FI,
                                                     Register &FrameReg) const {
  return StackOffset::getFixed(ResolveFrameIndexReference(MF, FI, FrameReg, 0));
}

int ARMFrameLowering::ResolveFrameIndexReference(const MachineFunction &MF,
                                                 int FI, Register &FrameReg,
                                                 int SPAdj) const {
  const MachineFrameInfo &MFI = MF.getFrameInfo();
  const ARMBaseRegisterInfo *RegInfo = static_cast<const ARMBaseRegisterInfo *>(
      MF.getSubtarget().getRegisterInfo());
  const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  int Offset = MFI.getObjectOffset(FI) + MFI.getStackSize();
  int FPOffset = Offset - AFI->getFramePtrSpillOffset();
  bool isFixed = MFI.isFixedObjectIndex(FI);

  FrameReg = ARM::SP;
  Offset += SPAdj;

  // SP can move around if there are allocas.  We may also lose track of SP
  // when emergency spilling inside a non-reserved call frame setup.
  bool hasMovingSP = !hasReservedCallFrame(MF);

  // When dynamically realigning the stack, use the frame pointer for
  // parameters, and the stack/base pointer for locals.
  if (RegInfo->hasStackRealignment(MF)) {
    assert(hasFP(MF) && ""dynamic stack realignment without a FP!"");
    if (isFixed) {
      FrameReg = RegInfo->getFrameRegister(MF);
      Offset = FPOffset;
    } else if (hasMovingSP) {
      assert(RegInfo->hasBasePointer(MF) &&
             ""VLAs and dynamic stack alignment, but missing base pointer!"");
      FrameReg = RegInfo->getBaseRegister();
      Offset -= SPAdj;
    }
    return Offset;
  }

  // If there is a frame pointer, use it when we can.
  if (hasFP(MF) && AFI->hasStackFrame()) {
    // Use frame pointer to reference fixed objects. Use it for locals if
    // there are VLAs (and thus the SP isn't reliable as a base).
    if (isFixed || (hasMovingSP && !RegInfo->hasBasePointer(MF))) {
      FrameReg = RegInfo->getFrameRegister(MF);
      return FPOffset;
    } else if (hasMovingSP) {
      assert(RegInfo->hasBasePointer(MF) && ""missing base pointer!"");
      if (AFI->isThumb2Function()) {
        // Try to use the frame pointer if we can, else use the base pointer
        // since it's available. This is handy for the emergency spill slot, in
        // particular.
        if (FPOffset >= -255 && FPOffset < 0) {
          FrameReg = RegInfo->getFrameRegister(MF);
          return FPOffset;
        }
      }
    } else if (AFI->isThumbFunction()) {
      // Prefer SP to base pointer, if the offset is suitably aligned and in
      // range as the effective range of the immediate offset is bigger when
      // basing off SP.
      // Use  add <rd>, sp, #<imm8>
      //      ldr <rd>, [sp, #<imm8>]
      if (Offset >= 0 && (Offset & 3) == 0 && Offset <= 1020)
        return Offset;
      // In Thumb2 mode, the negative offset is very limited. Try to avoid
      // out of range references. ldr <rt>,[<rn>, #-<imm8>]
      if (AFI->isThumb2Function() && FPOffset >= -255 && FPOffset < 0) {
        FrameReg = RegInfo->getFrameRegister(MF);
        return FPOffset;
      }
    } else if (Offset > (FPOffset < 0 ? -FPOffset : FPOffset)) {
      // Otherwise, use SP or FP, whichever is closer to the stack slot.
      FrameReg = RegInfo->getFrameRegister(MF);
      return FPOffset;
    }
  }
  // Use the base pointer if we have one.
  // FIXME: Maybe prefer sp on Thumb1 if it's legal and the offset is cheaper?
  // That can happen if we forced a base pointer for a large call frame.
  if (RegInfo->hasBasePointer(MF)) {
    FrameReg = RegInfo->getBaseRegister();
    Offset -= SPAdj;
  }
  return Offset;
}

void ARMFrameLowering::emitPushInst(MachineBasicBlock &MBB,
                                    MachineBasicBlock::iterator MI,
                                    ArrayRef<CalleeSavedInfo> CSI,
                                    unsigned StmOpc, unsigned StrOpc,
                                    bool NoGap, bool (*Func)(unsigned, bool),
                                    unsigned NumAlignedDPRCS2Regs,
                                    unsigned MIFlags) const {
  MachineFunction &MF = *MBB.getParent();
  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
  const TargetRegisterInfo &TRI = *STI.getRegisterInfo();

  DebugLoc DL;

  using RegAndKill = std::pair<unsigned, bool>;

  SmallVector<RegAndKill, 4> Regs;
  unsigned i = CSI.size();
  while (i != 0) {
    unsigned LastReg = 0;
    for (; i != 0; --i) {
      Register Reg = CSI[i-1].getReg();
      if (!(Func)(Reg, STI.splitFramePushPop(MF))) continue;

      // D-registers in the aligned area DPRCS2 are NOT spilled here.
      if (Reg >= ARM::D8 && Reg < ARM::D8 + NumAlignedDPRCS2Regs)
        continue;

      const MachineRegisterInfo &MRI = MF.getRegInfo();
      bool isLiveIn = MRI.isLiveIn(Reg);
      if (!isLiveIn && !MRI.isReserved(Reg))
        MBB.addLiveIn(Reg);
      // If NoGap is true, push consecutive registers and then leave the rest
      // for other instructions. e.g.
      // vpush {d8, d10, d11} -> vpush {d8}, vpush {d10, d11}
      if (NoGap && LastReg && LastReg != Reg-1)
        break;
      LastReg = Reg;
      // Do not set a kill flag on values that are also marked as live-in. This
      // happens with the @llvm-returnaddress intrinsic and with arguments
      // passed in callee saved registers.
      // Omitting the kill flags is conservatively correct even if the live-in
      // is not used after all.
      Regs.push_back(std::make_pair(Reg, /*isKill=*/!isLiveIn));
    }

    if (Regs.empty())
      continue;

    llvm::sort(Regs, [&](const RegAndKill &LHS, const RegAndKill &RHS) {
      return TRI.getEncodingValue(LHS.first) < TRI.getEncodingValue(RHS.first);
    });

    if (Regs.size() > 1 || StrOpc== 0) {
      MachineInstrBuilder MIB = BuildMI(MBB, MI, DL, TII.get(StmOpc), ARM::SP)
                                    .addReg(ARM::SP)
                                    .setMIFlags(MIFlags)
                                    .add(predOps(ARMCC::AL));
      for (unsigned i = 0, e = Regs.size(); i < e; ++i)
        MIB.addReg(Regs[i].first, getKillRegState(Regs[i].second));
    } else if (Regs.size() == 1) {
      BuildMI(MBB, MI, DL, TII.get(StrOpc), ARM::SP)
          .addReg(Regs[0].first, getKillRegState(Regs[0].second))
          .addReg(ARM::SP)
          .setMIFlags(MIFlags)
          .addImm(-4)
          .add(predOps(ARMCC::AL));
    }
    Regs.clear();

    // Put any subsequent vpush instructions before this one: they will refer to
    // higher register numbers so need to be pushed first in order to preserve
    // monotonicity.
    if (MI != MBB.begin())
      --MI;
  }
}

void ARMFrameLowering::emitPopInst(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator MI,
                                   MutableArrayRef<CalleeSavedInfo> CSI,
                                   unsigned LdmOpc, unsigned LdrOpc,
                                   bool isVarArg, bool NoGap,
                                   bool (*Func)(unsigned, bool),
                                   unsigned NumAlignedDPRCS2Regs) const {
  MachineFunction &MF = *MBB.getParent();
  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
  const TargetRegisterInfo &TRI = *STI.getRegisterInfo();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  bool hasPAC = AFI->shouldSignReturnAddress();
  DebugLoc DL;
  bool isTailCall = false;
  bool isInterrupt = false;
  bool isTrap = false;
  bool isCmseEntry = false;
  if (MBB.end() != MI) {
    DL = MI->getDebugLoc();
    unsigned RetOpcode = MI->getOpcode();
    isTailCall = (RetOpcode == ARM::TCRETURNdi || RetOpcode == ARM::TCRETURNri);
    isInterrupt =
        RetOpcode == ARM::SUBS_PC_LR || RetOpcode == ARM::t2SUBS_PC_LR;
    isTrap =
        RetOpcode == ARM::TRAP || RetOpcode == ARM::TRAPNaCl ||
        RetOpcode == ARM::tTRAP;
    isCmseEntry = (RetOpcode == ARM::tBXNS || RetOpcode == ARM::tBXNS_RET);
  }

  SmallVector<unsigned, 4> Regs;
  unsigned i = CSI.size();
  while (i != 0) {
    unsigned LastReg = 0;
    bool DeleteRet = false;
    for (; i != 0; --i) {
      CalleeSavedInfo &Info = CSI[i-1];
      Register Reg = Info.getReg();
      if (!(Func)(Reg, STI.splitFramePushPop(MF))) continue;

      // The aligned reloads from area DPRCS2 are not inserted here.
      if (Reg >= ARM::D8 && Reg < ARM::D8 + NumAlignedDPRCS2Regs)
        continue;
      if (Reg == ARM::LR && !isTailCall && !isVarArg && !isInterrupt &&
          !isCmseEntry && !isTrap && AFI->getArgumentStackToRestore() == 0 &&
          STI.hasV5TOps() && MBB.succ_empty() && !hasPAC &&
          !STI.splitFramePointerPush(MF)) {
        Reg = ARM::PC;
        // Fold the return instruction into the LDM.
        DeleteRet = true;
        LdmOpc = AFI->isThumbFunction() ? ARM::t2LDMIA_RET : ARM::LDMIA_RET;
      }

      // If NoGap is true, pop consecutive registers and then leave the rest
      // for other instructions. e.g.
      // vpop {d8, d10, d11} -> vpop {d8}, vpop {d10, d11}
      if (NoGap && LastReg && LastReg != Reg-1)
        break;

      LastReg = Reg;
      Regs.push_back(Reg);
    }

    if (Regs.empty())
      continue;

    llvm::sort(Regs, [&](unsigned LHS, unsigned RHS) {
      return TRI.getEncodingValue(LHS) < TRI.getEncodingValue(RHS);
    });

    if (Regs.size() > 1 || LdrOpc == 0) {
      MachineInstrBuilder MIB = BuildMI(MBB, MI, DL, TII.get(LdmOpc), ARM::SP)
                                    .addReg(ARM::SP)
                                    .add(predOps(ARMCC::AL))
                                    .setMIFlags(MachineInstr::FrameDestroy);
      for (unsigned i = 0, e = Regs.size(); i < e; ++i)
        MIB.addReg(Regs[i], getDefRegState(true));
      if (DeleteRet) {
        if (MI != MBB.end()) {
          MIB.copyImplicitOps(*MI);
          MI->eraseFromParent();
        }
      }
      MI = MIB;
    } else if (Regs.size() == 1) {
      // If we adjusted the reg to PC from LR above, switch it back here. We
      // only do that for LDM.
      if (Regs[0] == ARM::PC)
        Regs[0] = ARM::LR;
      MachineInstrBuilder MIB =
        BuildMI(MBB, MI, DL, TII.get(LdrOpc), Regs[0])
          .addReg(ARM::SP, RegState::Define)
          .addReg(ARM::SP)
          .setMIFlags(MachineInstr::FrameDestroy);
      // ARM mode needs an extra reg0 here due to addrmode2. Will go away once
      // that refactoring is complete (eventually).
      if (LdrOpc == ARM::LDR_POST_REG || LdrOpc == ARM::LDR_POST_IMM) {
        MIB.addReg(0);
        MIB.addImm(ARM_AM::getAM2Opc(ARM_AM::add, 4, ARM_AM::no_shift));
      } else
        MIB.addImm(4);
      MIB.add(predOps(ARMCC::AL));
    }
    Regs.clear();

    // Put any subsequent vpop instructions after this one: they will refer to
    // higher register numbers so need to be popped afterwards.
    if (MI != MBB.end())
      ++MI;
  }
}

/// Emit aligned spill instructions for NumAlignedDPRCS2Regs D-registers
/// starting from d8.  Also insert stack realignment code and leave the stack
/// pointer pointing to the d8 spill slot.
static void emitAlignedDPRCS2Spills(MachineBasicBlock &MBB,
                                    MachineBasicBlock::iterator MI,
                                    unsigned NumAlignedDPRCS2Regs,
                                    ArrayRef<CalleeSavedInfo> CSI,
                                    const TargetRegisterInfo *TRI) {
  MachineFunction &MF = *MBB.getParent();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  DebugLoc DL = MI != MBB.end() ? MI->getDebugLoc() : DebugLoc();
  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
  MachineFrameInfo &MFI = MF.getFrameInfo();

  // Mark the D-register spill slots as properly aligned.  Since MFI computes
  // stack slot layout backwards, this can actually mean that the d-reg stack
  // slot offsets can be wrong. The offset for d8 will always be correct.
  for (const CalleeSavedInfo &I : CSI) {
    unsigned DNum = I.getReg() - ARM::D8;
    if (DNum > NumAlignedDPRCS2Regs - 1)
      continue;
    int FI = I.getFrameIdx();
    // The even-numbered registers will be 16-byte aligned, the odd-numbered
    // registers will be 8-byte aligned.
    MFI.setObjectAlignment(FI, DNum % 2 ? Align(8) : Align(16));

    // The stack slot for D8 needs to be maximally aligned because this is
    // actually the point where we align the stack pointer.  MachineFrameInfo
    // computes all offsets relative to the incoming stack pointer which is a
    // bit weird when realigning the stack.  Any extra padding for this
    // over-alignment is not realized because the code inserted below adjusts
    // the stack pointer by numregs * 8 before aligning the stack pointer.
    if (DNum == 0)
      MFI.setObjectAlignment(FI, MFI.getMaxAlign());
  }

  // Move the stack pointer to the d8 spill slot, and align it at the same
  // time. Leave the stack slot address in the scratch register r4.
  //
  //   sub r4, sp, #numregs * 8
  //   bic r4, r4, #align - 1
  //   mov sp, r4
  //
  bool isThumb = AFI->isThumbFunction();
  assert(!AFI->isThumb1OnlyFunction() && ""Can't realign stack for thumb1"");
  AFI->setShouldRestoreSPFromFP(true);

  // sub r4, sp, #numregs * 8
  // The immediate is <= 64, so it doesn't need any special encoding.
  unsigned Opc = isThumb ? ARM::t2SUBri : ARM::SUBri;
  BuildMI(MBB, MI, DL, TII.get(Opc), ARM::R4)
      .addReg(ARM::SP)
      .addImm(8 * NumAlignedDPRCS2Regs)
      .add(predOps(ARMCC::AL))
      .add(condCodeOp());

  Align MaxAlign = MF.getFrameInfo().getMaxAlign();
  // We must set parameter MustBeSingleInstruction to true, since
  // skipAlignedDPRCS2Spills expects exactly 3 instructions to perform
  // stack alignment.  Luckily, this can always be done since all ARM
  // architecture versions that support Neon also support the BFC
  // instruction.
  emitAligningInstructions(MF, AFI, TII, MBB, MI, DL, ARM::R4, MaxAlign, true);

  // mov sp, r4
  // The stack pointer must be adjusted before spilling anything, otherwise
  // the stack slots could be clobbered by an interrupt handler.
  // Leave r4 live, it is used below.
  Opc = isThumb ? ARM::tMOVr : ARM::MOVr;
  MachineInstrBuilder MIB = BuildMI(MBB, MI, DL, TII.get(Opc), ARM::SP)
                                .addReg(ARM::R4)
                                .add(predOps(ARMCC::AL));
  if (!isThumb)
    MIB.add(condCodeOp());

  // Now spill NumAlignedDPRCS2Regs registers starting from d8.
  // r4 holds the stack slot address.
  unsigned NextReg = ARM::D8;

  // 16-byte aligned vst1.64 with 4 d-regs and address writeback.
  // The writeback is only needed when emitting two vst1.64 instructions.
  if (NumAlignedDPRCS2Regs >= 6) {
    unsigned SupReg = TRI->getMatchingSuperReg(NextReg, ARM::dsub_0,
                                               &ARM::QQPRRegClass);
    MBB.addLiveIn(SupReg);
    BuildMI(MBB, MI, DL, TII.get(ARM::VST1d64Qwb_fixed), ARM::R4)
        .addReg(ARM::R4, RegState::Kill)
        .addImm(16)
        .addReg(NextReg)
        .addReg(SupReg, RegState::ImplicitKill)
        .add(predOps(ARMCC::AL));
    NextReg += 4;
    NumAlignedDPRCS2Regs -= 4;
  }

  // We won't modify r4 beyond this point.  It currently points to the next
  // register to be spilled.
  unsigned R4BaseReg = NextReg;

  // 16-byte aligned vst1.64 with 4 d-regs, no writeback.
  if (NumAlignedDPRCS2Regs >= 4) {
    unsigned SupReg = TRI->getMatchingSuperReg(NextReg, ARM::dsub_0,
                                               &ARM::QQPRRegClass);
    MBB.addLiveIn(SupReg);
    BuildMI(MBB, MI, DL, TII.get(ARM::VST1d64Q))
        .addReg(ARM::R4)
        .addImm(16)
        .addReg(NextReg)
        .addReg(SupReg, RegState::ImplicitKill)
        .add(predOps(ARMCC::AL));
    NextReg += 4;
    NumAlignedDPRCS2Regs -= 4;
  }

  // 16-byte aligned vst1.64 with 2 d-regs.
  if (NumAlignedDPRCS2Regs >= 2) {
    unsigned SupReg = TRI->getMatchingSuperReg(NextReg, ARM::dsub_0,
                                               &ARM::QPRRegClass);
    MBB.addLiveIn(SupReg);
    BuildMI(MBB, MI, DL, TII.get(ARM::VST1q64))
        .addReg(ARM::R4)
        .addImm(16)
        .addReg(SupReg)
        .add(predOps(ARMCC::AL));
    NextReg += 2;
    NumAlignedDPRCS2Regs -= 2;
  }

  // Finally, use a vanilla vstr.64 for the odd last register.
  if (NumAlignedDPRCS2Regs) {
    MBB.addLiveIn(NextReg);
    // vstr.64 uses addrmode5 which has an offset scale of 4.
    BuildMI(MBB, MI, DL, TII.get(ARM::VSTRD))
        .addReg(NextReg)
        .addReg(ARM::R4)
        .addImm((NextReg - R4BaseReg) * 2)
        .add(predOps(ARMCC::AL));
  }

  // The last spill instruction inserted should kill the scratch register r4.
  std::prev(MI)->addRegisterKilled(ARM::R4, TRI);
}

/// Skip past the code inserted by emitAlignedDPRCS2Spills, and return an
/// iterator to the following instruction.
static MachineBasicBlock::iterator
skipAlignedDPRCS2Spills(MachineBasicBlock::iterator MI,
                        unsigned NumAlignedDPRCS2Regs) {
  //   sub r4, sp, #numregs * 8
  //   bic r4, r4, #align - 1
  //   mov sp, r4
  ++MI; ++MI; ++MI;
  assert(MI->mayStore() && ""Expecting spill instruction"");

  // These switches all fall through.
  switch(NumAlignedDPRCS2Regs) {
  case 7:
    ++MI;
    assert(MI->mayStore() && ""Expecting spill instruction"");
    [[fallthrough]];
  default:
    ++MI;
    assert(MI->mayStore() && ""Expecting spill instruction"");
    [[fallthrough]];
  case 1:
  case 2:
  case 4:
    assert(MI->killsRegister(ARM::R4) && ""Missed kill flag"");
    ++MI;
  }
  return MI;
}

/// Emit aligned reload instructions for NumAlignedDPRCS2Regs D-registers
/// starting from d8.  These instructions are assumed to execute while the
/// stack is still aligned, unlike the code inserted by emitPopInst.
static void emitAlignedDPRCS2Restores(MachineBasicBlock &MBB,
                                      MachineBasicBlock::iterator MI,
                                      unsigned NumAlignedDPRCS2Regs,
                                      ArrayRef<CalleeSavedInfo> CSI,
                                      const TargetRegisterInfo *TRI) {
  MachineFunction &MF = *MBB.getParent();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  DebugLoc DL = MI != MBB.end() ? MI->getDebugLoc() : DebugLoc();
  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();

  // Find the frame index assigned to d8.
  int D8SpillFI = 0;
  for (const CalleeSavedInfo &I : CSI)
    if (I.getReg() == ARM::D8) {
      D8SpillFI = I.getFrameIdx();
      break;
    }

  // Materialize the address of the d8 spill slot into the scratch register r4.
  // This can be fairly complicated if the stack frame is large, so just use
  // the normal frame index elimination mechanism to do it.  This code runs as
  // the initial part of the epilog where the stack and base pointers haven't
  // been changed yet.
  bool isThumb = AFI->isThumbFunction();
  assert(!AFI->isThumb1OnlyFunction() && ""Can't realign stack for thumb1"");

  unsigned Opc = isThumb ? ARM::t2ADDri : ARM::ADDri;
  BuildMI(MBB, MI, DL, TII.get(Opc), ARM::R4)
      .addFrameIndex(D8SpillFI)
      .addImm(0)
      .add(predOps(ARMCC::AL))
      .add(condCodeOp());

  // Now restore NumAlignedDPRCS2Regs registers starting from d8.
  unsigned NextReg = ARM::D8;

  // 16-byte aligned vld1.64 with 4 d-regs and writeback.
  if (NumAlignedDPRCS2Regs >= 6) {
    unsigned SupReg = TRI->getMatchingSuperReg(NextReg, ARM::dsub_0,
                                               &ARM::QQPRRegClass);
    BuildMI(MBB, MI, DL, TII.get(ARM::VLD1d64Qwb_fixed), NextReg)
        .addReg(ARM::R4, RegState::Define)
        .addReg(ARM::R4, RegState::Kill)
        .addImm(16)
        .addReg(SupReg, RegState::ImplicitDefine)
        .add(predOps(ARMCC::AL));
    NextReg += 4;
    NumAlignedDPRCS2Regs -= 4;
  }

  // We won't modify r4 beyond this point.  It currently points to the next
  // register to be spilled.
  unsigned R4BaseReg = NextReg;

  // 16-byte aligned vld1.64 with 4 d-regs, no writeback.
  if (NumAlignedDPRCS2Regs >= 4) {
    unsigned SupReg = TRI->getMatchingSuperReg(NextReg, ARM::dsub_0,
                                               &ARM::QQPRRegClass);
    BuildMI(MBB, MI, DL, TII.get(ARM::VLD1d64Q), NextReg)
        .addReg(ARM::R4)
        .addImm(16)
        .addReg(SupReg, RegState::ImplicitDefine)
        .add(predOps(ARMCC::AL));
    NextReg += 4;
    NumAlignedDPRCS2Regs -= 4;
  }

  // 16-byte aligned vld1.64 with 2 d-regs.
  if (NumAlignedDPRCS2Regs >= 2) {
    unsigned SupReg = TRI->getMatchingSuperReg(NextReg, ARM::dsub_0,
                                               &ARM::QPRRegClass);
    BuildMI(MBB, MI, DL, TII.get(ARM::VLD1q64), SupReg)
        .addReg(ARM::R4)
        .addImm(16)
        .add(predOps(ARMCC::AL));
    NextReg += 2;
    NumAlignedDPRCS2Regs -= 2;
  }

  // Finally, use a vanilla vldr.64 for the remaining odd register.
  if (NumAlignedDPRCS2Regs)
    BuildMI(MBB, MI, DL, TII.get(ARM::VLDRD), NextReg)
        .addReg(ARM::R4)
        .addImm(2 * (NextReg - R4BaseReg))
        .add(predOps(ARMCC::AL));

  // Last store kills r4.
  std::prev(MI)->addRegisterKilled(ARM::R4, TRI);
}

bool ARMFrameLowering::spillCalleeSavedRegisters(
    MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
    ArrayRef<CalleeSavedInfo> CSI, const TargetRegisterInfo *TRI) const {
  if (CSI.empty())
    return false;

  MachineFunction &MF = *MBB.getParent();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();

  unsigned PushOpc = AFI->isThumbFunction() ? ARM::t2STMDB_UPD : ARM::STMDB_UPD;
  unsigned PushOneOpc = AFI->isThumbFunction() ?
    ARM::t2STR_PRE : ARM::STR_PRE_IMM;
  unsigned FltOpc = ARM::VSTMDDB_UPD;
  unsigned NumAlignedDPRCS2Regs = AFI->getNumAlignedDPRCS2Regs();
  // Compute PAC in R12.
  if (AFI->shouldSignReturnAddress()) {
    BuildMI(MBB, MI, DebugLoc(), STI.getInstrInfo()->get(ARM::t2PAC))
        .setMIFlags(MachineInstr::FrameSetup);
  }
  // Save the non-secure floating point context.
  if (llvm::any_of(CSI, [](const CalleeSavedInfo &C) {
        return C.getReg() == ARM::FPCXTNS;
      })) {
    BuildMI(MBB, MI, DebugLoc(), STI.getInstrInfo()->get(ARM::VSTR_FPCXTNS_pre),
            ARM::SP)
        .addReg(ARM::SP)
        .addImm(-4)
        .add(predOps(ARMCC::AL));
  }
  if (STI.splitFramePointerPush(MF)) {
    emitPushInst(MBB, MI, CSI, PushOpc, PushOneOpc, false,
                 &isSplitFPArea1Register, 0, MachineInstr::FrameSetup);
    emitPushInst(MBB, MI, CSI, FltOpc, 0, true, &isARMArea3Register,
                 NumAlignedDPRCS2Regs, MachineInstr::FrameSetup);
    emitPushInst(MBB, MI, CSI, PushOpc, PushOneOpc, false,
                 &isSplitFPArea2Register, 0, MachineInstr::FrameSetup);
  } else {
    emitPushInst(MBB, MI, CSI, PushOpc, PushOneOpc, false, &isARMArea1Register,
                 0, MachineInstr::FrameSetup);
    emitPushInst(MBB, MI, CSI, PushOpc, PushOneOpc, false, &isARMArea2Register,
                 0, MachineInstr::FrameSetup);
    emitPushInst(MBB, MI, CSI, FltOpc, 0, true, &isARMArea3Register,
                 NumAlignedDPRCS2Regs, MachineInstr::FrameSetup);
  }

  // The code above does not insert spill code for the aligned DPRCS2 registers.
  // The stack realignment code will be inserted between the push instructions
  // and these spills.
  if (NumAlignedDPRCS2Regs)
    emitAlignedDPRCS2Spills(MBB, MI, NumAlignedDPRCS2Regs, CSI, TRI);

  return true;
}

bool ARMFrameLowering::restoreCalleeSavedRegisters(
    MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
    MutableArrayRef<CalleeSavedInfo> CSI, const TargetRegisterInfo *TRI) const {
  if (CSI.empty())
    return false;

  MachineFunction &MF = *MBB.getParent();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  bool isVarArg = AFI->getArgRegsSaveSize() > 0;
  unsigned NumAlignedDPRCS2Regs = AFI->getNumAlignedDPRCS2Regs();

  // The emitPopInst calls below do not insert reloads for the aligned DPRCS2
  // registers. Do that here instead.
  if (NumAlignedDPRCS2Regs)
    emitAlignedDPRCS2Restores(MBB, MI, NumAlignedDPRCS2Regs, CSI, TRI);

  unsigned PopOpc = AFI->isThumbFunction() ? ARM::t2LDMIA_UPD : ARM::LDMIA_UPD;
  unsigned LdrOpc =
      AFI->isThumbFunction() ? ARM::t2LDR_POST : ARM::LDR_POST_IMM;
  unsigned FltOpc = ARM::VLDMDIA_UPD;
  if (STI.splitFramePointerPush(MF)) {
    emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
                &isSplitFPArea2Register, 0);
    emitPopInst(MBB, MI, CSI, FltOpc, 0, isVarArg, true, &isARMArea3Register,
                NumAlignedDPRCS2Regs);
    emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
                &isSplitFPArea1Register, 0);
  } else {
    emitPopInst(MBB, MI, CSI, FltOpc, 0, isVarArg, true, &isARMArea3Register,
                NumAlignedDPRCS2Regs);
    emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
                &isARMArea2Register, 0);
    emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
                &isARMArea1Register, 0);
  }

  return true;
}

// FIXME: Make generic?
static unsigned EstimateFunctionSizeInBytes(const MachineFunction &MF,
                                            const ARMBaseInstrInfo &TII) {
  unsigned FnSize = 0;
  for (auto &MBB : MF) {
    for (auto &MI : MBB)
      FnSize += TII.getInstSizeInBytes(MI);
  }
  if (MF.getJumpTableInfo())
    for (auto &Table: MF.getJumpTableInfo()->getJumpTables())
      FnSize += Table.MBBs.size() * 4;
  FnSize += MF.getConstantPool()->getConstants().size() * 4;
  return FnSize;
}

/// estimateRSStackSizeLimit - Look at each instruction that references stack
/// frames and return the stack size limit beyond which some of these
/// instructions will require a scratch register during their expansion later.
// FIXME: Move to TII?
static unsigned estimateRSStackSizeLimit(MachineFunction &MF,
                                         const TargetFrameLowering *TFI,
                                         bool &HasNonSPFrameIndex) {
  const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  const ARMBaseInstrInfo &TII =
      *static_cast<const ARMBaseInstrInfo *>(MF.getSubtarget().getInstrInfo());
  const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
  unsigned Limit = (1 << 12) - 1;
  for (auto &MBB : MF) {
    for (auto &MI : MBB) {
      if (MI.isDebugInstr())
        continue;
      for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
        if (!MI.getOperand(i).isFI())
          continue;

        // When using ADDri to get the address of a stack object, 255 is the
        // largest offset guaranteed to fit in the immediate offset.
        if (MI.getOpcode() == ARM::ADDri) {
          Limit = std::min(Limit, (1U << 8) - 1);
          break;
        }
        // t2ADDri will not require an extra register, it can reuse the
        // destination.
        if (MI.getOpcode() == ARM::t2ADDri || MI.getOpcode() == ARM::t2ADDri12)
          break;

        const MCInstrDesc &MCID = MI.getDesc();
        const TargetRegisterClass *RegClass = TII.getRegClass(MCID, i, TRI, MF);
        if (RegClass && !RegClass->contains(ARM::SP))
          HasNonSPFrameIndex = true;

        // Otherwise check the addressing mode.
        switch (MI.getDesc().TSFlags & ARMII::AddrModeMask) {
        case ARMII::AddrMode_i12:
        case ARMII::AddrMode2:
          // Default 12 bit limit.
          break;
        case ARMII::AddrMode3:
        case ARMII::AddrModeT2_i8neg:
          Limit = std::min(Limit, (1U << 8) - 1);
          break;
        case ARMII::AddrMode5FP16:
          Limit = std::min(Limit, ((1U << 8) - 1) * 2);
          break;
        case ARMII::AddrMode5:
        case ARMII::AddrModeT2_i8s4:
        case ARMII::AddrModeT2_ldrex:
          Limit = std::min(Limit, ((1U << 8) - 1) * 4);
          break;
        case ARMII::AddrModeT2_i12:
          // i12 supports only positive offset so these will be converted to
          // i8 opcodes. See llvm::rewriteT2FrameIndex.
          if (TFI->hasFP(MF) && AFI->hasStackFrame())
            Limit = std::min(Limit, (1U << 8) - 1);
          break;
        case ARMII::AddrMode4:
        case ARMII::AddrMode6:
          // Addressing modes 4 & 6 (load/store) instructions can't encode an
          // immediate offset for stack references.
          return 0;
        case ARMII::AddrModeT2_i7:
          Limit = std::min(Limit, ((1U << 7) - 1) * 1);
          break;
        case ARMII::AddrModeT2_i7s2:
          Limit = std::min(Limit, ((1U << 7) - 1) * 2);
          break;
        case ARMII::AddrModeT2_i7s4:
          Limit = std::min(Limit, ((1U << 7) - 1) * 4);
          break;
        default:
          llvm_unreachable(""Unhandled addressing mode in stack size limit calculation"");
        }
        break; // At most one FI per instruction
      }
    }
  }

  return Limit;
}

// In functions that realign the stack, it can be an advantage to spill the
// callee-saved vector registers after realigning the stack. The vst1 and vld1
// instructions take alignment hints that can improve performance.
static void
checkNumAlignedDPRCS2Regs(MachineFunction &MF, BitVector &SavedRegs) {
  MF.getInfo<ARMFunctionInfo>()->setNumAlignedDPRCS2Regs(0);
  if (!SpillAlignedNEONRegs)
    return;

  // Naked functions don't spill callee-saved registers.
  if (MF.getFunction().hasFnAttribute(Attribute::Naked))
    return;

  // We are planning to use NEON instructions vst1 / vld1.
  if (!MF.getSubtarget<ARMSubtarget>().hasNEON())
    return;

  // Don't bother if the default stack alignment is sufficiently high.
  if (MF.getSubtarget().getFrameLowering()->getStackAlign() >= Align(8))
    return;

  // Aligned spills require stack realignment.
  if (!static_cast<const ARMBaseRegisterInfo *>(
           MF.getSubtarget().getRegisterInfo())->canRealignStack(MF))
    return;

  // We always spill contiguous d-registers starting from d8. Count how many
  // needs spilling.  The register allocator will almost always use the
  // callee-saved registers in order, but it can happen that there are holes in
  // the range.  Registers above the hole will be spilled to the standard DPRCS
  // area.
  unsigned NumSpills = 0;
  for (; NumSpills < 8; ++NumSpills)
    if (!SavedRegs.test(ARM::D8 + NumSpills))
      break;

  // Don't do this for just one d-register. It's not worth it.
  if (NumSpills < 2)
    return;

  // Spill the first NumSpills D-registers after realigning the stack.
  MF.getInfo<ARMFunctionInfo>()->setNumAlignedDPRCS2Regs(NumSpills);

  // A scratch register is required for the vst1 / vld1 instructions.
  SavedRegs.set(ARM::R4);
}

bool ARMFrameLowering::enableShrinkWrapping(const MachineFunction &MF) const {
  // For CMSE entry functions, we want to save the FPCXT_NS immediately
  // upon function entry (resp. restore it immmediately before return)
  if (STI.hasV8_1MMainlineOps() &&
      MF.getInfo<ARMFunctionInfo>()->isCmseNSEntryFunction())
    return false;

  // We are disabling shrinkwrapping for now when PAC is enabled, as
  // shrinkwrapping can cause clobbering of r12 when the PAC code is
  // generated. A follow-up patch will fix this in a more performant manner.
  if (MF.getInfo<ARMFunctionInfo>()->shouldSignReturnAddress(
          true /* SpillsLR */))
    return false;

  return true;
}

static bool requiresAAPCSFrameRecord(const MachineFunction &MF) {
  const auto &Subtarget = MF.getSubtarget<ARMSubtarget>();
  return Subtarget.createAAPCSFrameChainLeaf() ||
         (Subtarget.createAAPCSFrameChain() && MF.getFrameInfo().hasCalls());
}

// Thumb1 may require a spill when storing to a frame index through FP, for
// cases where FP is a high register (R11). This scans the function for cases
// where this may happen.
static bool canSpillOnFrameIndexAccess(const MachineFunction &MF,
                                       const TargetFrameLowering &TFI) {
  const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  if (!AFI->isThumb1OnlyFunction())
    return false;

  for (const auto &MBB : MF)
    for (const auto &MI : MBB)
      if (MI.getOpcode() == ARM::tSTRspi || MI.getOpcode() == ARM::tSTRi)
        for (const auto &Op : MI.operands())
          if (Op.isFI()) {
            Register Reg;
            TFI.getFrameIndexReference(MF, Op.getIndex(), Reg);
            if (ARM::hGPRRegClass.contains(Reg) && Reg != ARM::SP)
              return true;
          }
  return false;
}

void ARMFrameLowering::determineCalleeSaves(MachineFunction &MF,
                                            BitVector &SavedRegs,
                                            RegScavenger *RS) const {
  TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
  // This tells PEI to spill the FP as if it is any other callee-save register
  // to take advantage the eliminateFrameIndex machinery. This also ensures it
  // is spilled in the order specified by getCalleeSavedRegs() to make it easier
  // to combine multiple loads / stores.
  bool CanEliminateFrame = !(requiresAAPCSFrameRecord(MF) && hasFP(MF));
  bool CS1Spilled = false;
  bool LRSpilled = false;
  unsigned NumGPRSpills = 0;
  unsigned NumFPRSpills = 0;
  SmallVector<unsigned, 4> UnspilledCS1GPRs;
  SmallVector<unsigned, 4> UnspilledCS2GPRs;
  const ARMBaseRegisterInfo *RegInfo = static_cast<const ARMBaseRegisterInfo *>(
      MF.getSubtarget().getRegisterInfo());
  const ARMBaseInstrInfo &TII =
      *static_cast<const ARMBaseInstrInfo *>(MF.getSubtarget().getInstrInfo());
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  MachineFrameInfo &MFI = MF.getFrameInfo();
  MachineRegisterInfo &MRI = MF.getRegInfo();
  const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
  (void)TRI;  // Silence unused warning in non-assert builds.
  Register FramePtr = RegInfo->getFrameRegister(MF);

  // Spill R4 if Thumb2 function requires stack realignment - it will be used as
  // scratch register. Also spill R4 if Thumb2 function has varsized objects,
  // since it's not always possible to restore sp from fp in a single
  // instruction.
  // FIXME: It will be better just to find spare register here.
  if (AFI->isThumb2Function() &&
      (MFI.hasVarSizedObjects() || RegInfo->hasStackRealignment(MF)))
    SavedRegs.set(ARM::R4);

  // If a stack probe will be emitted, spill R4 and LR, since they are
  // clobbered by the stack probe call.
  // This estimate should be a safe, conservative estimate. The actual
  // stack probe is enabled based on the size of the local objects;
  // this estimate also includes the varargs store size.
  if (STI.isTargetWindows() &&
      WindowsRequiresStackProbe(MF, MFI.estimateStackSize(MF))) {
    SavedRegs.set(ARM::R4);
    SavedRegs.set(ARM::LR);
  }

  if (AFI->isThumb1OnlyFunction()) {
    // Spill LR if Thumb1 function uses variable length argument lists.
    if (AFI->getArgRegsSaveSize() > 0)
      SavedRegs.set(ARM::LR);

    // Spill R4 if Thumb1 epilogue has to restore SP from FP or the function
    // requires stack alignment.  We don't know for sure what the stack size
    // will be, but for this, an estimate is good enough. If there anything
    // changes it, it'll be a spill, which implies we've used all the registers
    // and so R4 is already used, so not marking it here will be OK.
    // FIXME: It will be better just to find spare register here.
    if (MFI.hasVarSizedObjects() || RegInfo->hasStackRealignment(MF) ||
        MFI.estimateStackSize(MF) > 508)
      SavedRegs.set(ARM::R4);
  }

  // See if we can spill vector registers to aligned stack.
  checkNumAlignedDPRCS2Regs(MF, SavedRegs);

  // Spill the BasePtr if it's used.
  if (RegInfo->hasBasePointer(MF))
    SavedRegs.set(RegInfo->getBaseRegister());

  // On v8.1-M.Main CMSE entry functions save/restore FPCXT.
  if (STI.hasV8_1MMainlineOps() && AFI->isCmseNSEntryFunction())
    CanEliminateFrame = false;

  // Don't spill FP if the frame can be eliminated. This is determined
  // by scanning the callee-save registers to see if any is modified.
  const MCPhysReg *CSRegs = RegInfo->getCalleeSavedRegs(&MF);
  for (unsigned i = 0; CSRegs[i]; ++i) {
    unsigned Reg = CSRegs[i];
    bool Spilled = false;
    if (SavedRegs.test(Reg)) {
      Spilled = true;
      CanEliminateFrame = false;
    }

    if (!ARM::GPRRegClass.contains(Reg)) {
      if (Spilled) {
        if (ARM::SPRRegClass.contains(Reg))
          NumFPRSpills++;
        else if (ARM::DPRRegClass.contains(Reg))
          NumFPRSpills += 2;
        else if (ARM::QPRRegClass.contains(Reg))
          NumFPRSpills += 4;
      }
      continue;
    }

    if (Spilled) {
      NumGPRSpills++;

      if (!STI.splitFramePushPop(MF)) {
        if (Reg == ARM::LR)
          LRSpilled = true;
        CS1Spilled = true;
        continue;
      }

      // Keep track if LR and any of R4, R5, R6, and R7 is spilled.
      switch (Reg) {
      case ARM::LR:
        LRSpilled = true;
        [[fallthrough]];
      case ARM::R0: case ARM::R1:
      case ARM::R2: case ARM::R3:
      case ARM::R4: case ARM::R5:
      case ARM::R6: case ARM::R7:
        CS1Spilled = true;
        break;
      default:
        break;
      }
    } else {
      if (!STI.splitFramePushPop(MF)) {
        UnspilledCS1GPRs.push_back(Reg);
        continue;
      }

      switch (Reg) {
      case ARM::R0: case ARM::R1:
      case ARM::R2: case ARM::R3:
      case ARM::R4: case ARM::R5:
      case ARM::R6: case ARM::R7:
      case ARM::LR:
        UnspilledCS1GPRs.push_back(Reg);
        break;
      default:
        UnspilledCS2GPRs.push_back(Reg);
        break;
      }
    }
  }

  bool ForceLRSpill = false;
  if (!LRSpilled && AFI->isThumb1OnlyFunction()) {
    unsigned FnSize = EstimateFunctionSizeInBytes(MF, TII);
    // Force LR to be spilled if the Thumb function size is > 2048. This enables
    // use of BL to implement far jump.
    if (FnSize >= (1 << 11)) {
      CanEliminateFrame = false;
      ForceLRSpill = true;
    }
  }

  // If any of the stack slot references may be out of range of an immediate
  // offset, make sure a register (or a spill slot) is available for the
  // register scavenger. Note that if we're indexing off the frame pointer, the
  // effective stack size is 4 bytes larger since the FP points to the stack
  // slot of the previous FP. Also, if we have variable sized objects in the
  // function, stack slot references will often be negative, and some of
  // our instructions are positive-offset only, so conservatively consider
  // that case to want a spill slot (or register) as well. Similarly, if
  // the function adjusts the stack pointer during execution and the
  // adjustments aren't already part of our stack size estimate, our offset
  // calculations may be off, so be conservative.
  // FIXME: We could add logic to be more precise about negative offsets
  //        and which instructions will need a scratch register for them. Is it
  //        worth the effort and added fragility?
  unsigned EstimatedStackSize =
      MFI.estimateStackSize(MF) + 4 * (NumGPRSpills + NumFPRSpills);

  // Determine biggest (positive) SP offset in MachineFrameInfo.
  int MaxFixedOffset = 0;
  for (int I = MFI.getObjectIndexBegin(); I < 0; ++I) {
    int MaxObjectOffset = MFI.getObjectOffset(I) + MFI.getObjectSize(I);
    MaxFixedOffset = std::max(MaxFixedOffset, MaxObjectOffset);
  }

  bool HasFP = hasFP(MF);
  if (HasFP) {
    if (AFI->hasStackFrame())
      EstimatedStackSize += 4;
  } else {
    // If FP is not used, SP will be used to access arguments, so count the
    // size of arguments into the estimation.
    EstimatedStackSize += MaxFixedOffset;
  }
  EstimatedStackSize += 16; // For possible paddings.

  unsigned EstimatedRSStackSizeLimit, EstimatedRSFixedSizeLimit;
  bool HasNonSPFrameIndex = false;
  if (AFI->isThumb1OnlyFunction()) {
    // For Thumb1, don't bother to iterate over the function. The only
    // instruction that requires an emergency spill slot is a store to a
    // frame index.
    //
    // tSTRspi, which is used for sp-relative accesses, has an 8-bit unsigned
    // immediate. tSTRi, which is used for bp- and fp-relative accesses, has
    // a 5-bit unsigned immediate.
    //
    // We could try to check if the function actually contains a tSTRspi
    // that might need the spill slot, but it's not really important.
    // Functions with VLAs or extremely large call frames are rare, and
    // if a function is allocating more than 1KB of stack, an extra 4-byte
    // slot probably isn't relevant.
    //
    // A special case is the scenario where r11 is used as FP, where accesses
    // to a frame index will require its value to be moved into a low reg.
    // This is handled later on, once we are able to determine if we have any
    // fp-relative accesses.
    if (RegInfo->hasBasePointer(MF))
      EstimatedRSStackSizeLimit = (1U << 5) * 4;
    else
      EstimatedRSStackSizeLimit = (1U << 8) * 4;
    EstimatedRSFixedSizeLimit = (1U << 5) * 4;
  } else {
    EstimatedRSStackSizeLimit =
        estimateRSStackSizeLimit(MF, this, HasNonSPFrameIndex);
    EstimatedRSFixedSizeLimit = EstimatedRSStackSizeLimit;
  }
  // Final estimate of whether sp or bp-relative accesses might require
  // scavenging.
  bool HasLargeStack = EstimatedStackSize > EstimatedRSStackSizeLimit;

  // If the stack pointer moves and we don't have a base pointer, the
  // estimate logic doesn't work. The actual offsets might be larger when
  // we're constructing a call frame, or we might need to use negative
  // offsets from fp.
  bool HasMovingSP = MFI.hasVarSizedObjects() ||
    (MFI.adjustsStack() && !canSimplifyCallFramePseudos(MF));
  bool HasBPOrFixedSP = RegInfo->hasBasePointer(MF) || !HasMovingSP;

  // If we have a frame pointer, we assume arguments will be accessed
  // relative to the frame pointer. Check whether fp-relative accesses to
  // arguments require scavenging.
  //
  // We could do slightly better on Thumb1; in some cases, an sp-relative
  // offset would be legal even though an fp-relative offset is not.
  int MaxFPOffset = getMaxFPOffset(STI, *AFI, MF);
  bool HasLargeArgumentList =
      HasFP && (MaxFixedOffset - MaxFPOffset) > (int)EstimatedRSFixedSizeLimit;

  bool BigFrameOffsets = HasLargeStack || !HasBPOrFixedSP ||
                         HasLargeArgumentList || HasNonSPFrameIndex;
  LLVM_DEBUG(dbgs() << ""EstimatedLimit: "" << EstimatedRSStackSizeLimit
                    << ""; EstimatedStack: "" << EstimatedStackSize
                    << ""; EstimatedFPStack: "" << MaxFixedOffset - MaxFPOffset
                    << ""; BigFrameOffsets: "" << BigFrameOffsets << ""\n"");
  if (BigFrameOffsets ||
      !CanEliminateFrame || RegInfo->cannotEliminateFrame(MF)) {
    AFI->setHasStackFrame(true);

    if (HasFP) {
      SavedRegs.set(FramePtr);
      // If the frame pointer is required by the ABI, also spill LR so that we
      // emit a complete frame record.
      if ((requiresAAPCSFrameRecord(MF) ||
           MF.getTarget().Options.DisableFramePointerElim(MF)) &&
          !LRSpilled) {
        SavedRegs.set(ARM::LR);
        LRSpilled = true;
        NumGPRSpills++;
        auto LRPos = llvm::find(UnspilledCS1GPRs, ARM::LR);
        if (LRPos != UnspilledCS1GPRs.end())
          UnspilledCS1GPRs.erase(LRPos);
      }
      auto FPPos = llvm::find(UnspilledCS1GPRs, FramePtr);
      if (FPPos != UnspilledCS1GPRs.end())
        UnspilledCS1GPRs.erase(FPPos);
      NumGPRSpills++;
      if (FramePtr == ARM::R7)
        CS1Spilled = true;
    }

    // This is true when we inserted a spill for a callee-save GPR which is
    // not otherwise used by the function. This guaranteees it is possible
    // to scavenge a register to hold the address of a stack slot. On Thumb1,
    // the register must be a valid operand to tSTRi, i.e. r4-r7. For other
    // subtargets, this is any GPR, i.e. r4-r11 or lr.
    //
    // If we don't insert a spill, we instead allocate an emergency spill
    // slot, which can be used by scavenging to spill an arbitrary register.
    //
    // We currently don't try to figure out whether any specific instruction
    // requires scavening an additional register.
    bool ExtraCSSpill = false;

    if (AFI->isThumb1OnlyFunction()) {
      // For Thumb1-only targets, we need some low registers when we save and
      // restore the high registers (which aren't allocatable, but could be
      // used by inline assembly) because the push/pop instructions can not
      // access high registers. If necessary, we might need to push more low
      // registers to ensure that there is at least one free that can be used
      // for the saving & restoring, and preferably we should ensure that as
      // many as are needed are available so that fewer push/pop instructions
      // are required.

      // Low registers which are not currently pushed, but could be (r4-r7).
      SmallVector<unsigned, 4> AvailableRegs;

      // Unused argument registers (r0-r3) can be clobbered in the prologue for
      // free.
      int EntryRegDeficit = 0;
      for (unsigned Reg : {ARM::R0, ARM::R1, ARM::R2, ARM::R3}) {
        if (!MF.getRegInfo().isLiveIn(Reg)) {
          --EntryRegDeficit;
          LLVM_DEBUG(dbgs()
                     << printReg(Reg, TRI)
                     << "" is unused argument register, EntryRegDeficit = ""
                     << EntryRegDeficit << ""\n"");
        }
      }

      // Unused return registers can be clobbered in the epilogue for free.
      int ExitRegDeficit = AFI->getReturnRegsCount() - 4;
      LLVM_DEBUG(dbgs() << AFI->getReturnRegsCount()
                        << "" return regs used, ExitRegDeficit = ""
                        << ExitRegDeficit << ""\n"");

      int RegDeficit = std::max(EntryRegDeficit, ExitRegDeficit);
      LLVM_DEBUG(dbgs() << ""RegDeficit = "" << RegDeficit << ""\n"");

      // r4-r6 can be used in the prologue if they are pushed by the first push
      // instruction.
      for (unsigned Reg : {ARM::R4, ARM::R5, ARM::R6}) {
        if (SavedRegs.test(Reg)) {
          --RegDeficit;
          LLVM_DEBUG(dbgs() << printReg(Reg, TRI)
                            << "" is saved low register, RegDeficit = ""
                            << RegDeficit << ""\n"");
        } else {
          AvailableRegs.push_back(Reg);
          LLVM_DEBUG(
              dbgs()
              << printReg(Reg, TRI)
              << "" is non-saved low register, adding to AvailableRegs\n"");
        }
      }

      // r7 can be used if it is not being used as the frame pointer.
      if (!HasFP || FramePtr != ARM::R7) {
        if (SavedRegs.test(ARM::R7)) {
          --RegDeficit;
          LLVM_DEBUG(dbgs() << ""%r7 is saved low register, RegDeficit = ""
                            << RegDeficit << ""\n"");
        } else {
          AvailableRegs.push_back(ARM::R7);
          LLVM_DEBUG(
              dbgs()
              << ""%r7 is non-saved low register, adding to AvailableRegs\n"");
        }
      }

      // Each of r8-r11 needs to be copied to a low register, then pushed.
      for (unsigned Reg : {ARM::R8, ARM::R9, ARM::R10, ARM::R11}) {
        if (SavedRegs.test(Reg)) {
          ++RegDeficit;
          LLVM_DEBUG(dbgs() << printReg(Reg, TRI)
                            << "" is saved high register, RegDeficit = ""
                            << RegDeficit << ""\n"");
        }
      }

      // LR can only be used by PUSH, not POP, and can't be used at all if the
      // llvm.returnaddress intrinsic is used. This is only worth doing if we
      // are more limited at function entry than exit.
      if ((EntryRegDeficit > ExitRegDeficit) &&
          !(MF.getRegInfo().isLiveIn(ARM::LR) &&
            MF.getFrameInfo().isReturnAddressTaken())) {
        if (SavedRegs.test(ARM::LR)) {
          --RegDeficit;
          LLVM_DEBUG(dbgs() << ""%lr is saved register, RegDeficit = ""
                            << RegDeficit << ""\n"");
        } else {
          AvailableRegs.push_back(ARM::LR);
          LLVM_DEBUG(dbgs() << ""%lr is not saved, adding to AvailableRegs\n"");
        }
      }

      // If there are more high registers that need pushing than low registers
      // available, push some more low registers so that we can use fewer push
      // instructions. This might not reduce RegDeficit all the way to zero,
      // because we can only guarantee that r4-r6 are available, but r8-r11 may
      // need saving.
      LLVM_DEBUG(dbgs() << ""Final RegDeficit = "" << RegDeficit << ""\n"");
      for (; RegDeficit > 0 && !AvailableRegs.empty(); --RegDeficit) {
        unsigned Reg = AvailableRegs.pop_back_val();
        LLVM_DEBUG(dbgs() << ""Spilling "" << printReg(Reg, TRI)
                          << "" to make up reg deficit\n"");
        SavedRegs.set(Reg);
        NumGPRSpills++;
        CS1Spilled = true;
        assert(!MRI.isReserved(Reg) && ""Should not be reserved"");
        if (Reg != ARM::LR && !MRI.isPhysRegUsed(Reg))
          ExtraCSSpill = true;
        UnspilledCS1GPRs.erase(llvm::find(UnspilledCS1GPRs, Reg));
        if (Reg == ARM::LR)
          LRSpilled = true;
      }
      LLVM_DEBUG(dbgs() << ""After adding spills, RegDeficit = "" << RegDeficit
                        << ""\n"");
    }

    // Avoid spilling LR in Thumb1 if there's a tail call: it's expensive to
    // restore LR in that case.
    bool ExpensiveLRRestore = AFI->isThumb1OnlyFunction() && MFI.hasTailCall();

    // If LR is not spilled, but at least one of R4, R5, R6, and R7 is spilled.
    // Spill LR as well so we can fold BX_RET to the registers restore (LDM).
    if (!LRSpilled && CS1Spilled && !ExpensiveLRRestore) {
      SavedRegs.set(ARM::LR);
      NumGPRSpills++;
      SmallVectorImpl<unsigned>::iterator LRPos;
      LRPos = llvm::find(UnspilledCS1GPRs, (unsigned)ARM::LR);
      if (LRPos != UnspilledCS1GPRs.end())
        UnspilledCS1GPRs.erase(LRPos);

      ForceLRSpill = false;
      if (!MRI.isReserved(ARM::LR) && !MRI.isPhysRegUsed(ARM::LR) &&
          !AFI->isThumb1OnlyFunction())
        ExtraCSSpill = true;
    }

    // If stack and double are 8-byte aligned and we are spilling an odd number
    // of GPRs, spill one extra callee save GPR so we won't have to pad between
    // the integer and double callee save areas.
    LLVM_DEBUG(dbgs() << ""NumGPRSpills = "" << NumGPRSpills << ""\n"");
    const Align TargetAlign = getStackAlign();
    if (TargetAlign >= Align(8) && (NumGPRSpills & 1)) {
      if (CS1Spilled && !UnspilledCS1GPRs.empty()) {
        for (unsigned i = 0, e = UnspilledCS1GPRs.size(); i != e; ++i) {
          unsigned Reg = UnspilledCS1GPRs[i];
          // Don't spill high register if the function is thumb.  In the case of
          // Windows on ARM, accept R11 (frame pointer)
          if (!AFI->isThumbFunction() ||
              (STI.isTargetWindows() && Reg == ARM::R11) ||
              isARMLowRegister(Reg) ||
              (Reg == ARM::LR && !ExpensiveLRRestore)) {
            SavedRegs.set(Reg);
            LLVM_DEBUG(dbgs() << ""Spilling "" << printReg(Reg, TRI)
                              << "" to make up alignment\n"");
            if (!MRI.isReserved(Reg) && !MRI.isPhysRegUsed(Reg) &&
                !(Reg == ARM::LR && AFI->isThumb1OnlyFunction()))
              ExtraCSSpill = true;
            break;
          }
        }
      } else if (!UnspilledCS2GPRs.empty() && !AFI->isThumb1OnlyFunction()) {
        unsigned Reg = UnspilledCS2GPRs.front();
        SavedRegs.set(Reg);
        LLVM_DEBUG(dbgs() << ""Spilling "" << printReg(Reg, TRI)
                          << "" to make up alignment\n"");
        if (!MRI.isReserved(Reg) && !MRI.isPhysRegUsed(Reg))
          ExtraCSSpill = true;
      }
    }

    // Estimate if we might need to scavenge a register at some point in order
    // to materialize a stack offset. If so, either spill one additional
    // callee-saved register or reserve a special spill slot to facilitate
    // register scavenging. Thumb1 needs a spill slot for stack pointer
    // adjustments and for frame index accesses when FP is high register,
    // even when the frame itself is small.
    if (!ExtraCSSpill &&
        (BigFrameOffsets || canSpillOnFrameIndexAccess(MF, *this))) {
      // If any non-reserved CS register isn't spilled, just spill one or two
      // extra. That should take care of it!
      unsigned NumExtras = TargetAlign.value() / 4;
      SmallVector<unsigned, 2> Extras;
      while (NumExtras && !UnspilledCS1GPRs.empty()) {
        unsigned Reg = UnspilledCS1GPRs.pop_back_val();
        if (!MRI.isReserved(Reg) &&
            (!AFI->isThumb1OnlyFunction() || isARMLowRegister(Reg))) {
          Extras.push_back(Reg);
          NumExtras--;
        }
      }
      // For non-Thumb1 functions, also check for hi-reg CS registers
      if (!AFI->isThumb1OnlyFunction()) {
        while (NumExtras && !UnspilledCS2GPRs.empty()) {
          unsigned Reg = UnspilledCS2GPRs.pop_back_val();
          if (!MRI.isReserved(Reg)) {
            Extras.push_back(Reg);
            NumExtras--;
          }
        }
      }
      if (NumExtras == 0) {
        for (unsigned Reg : Extras) {
          SavedRegs.set(Reg);
          if (!MRI.isPhysRegUsed(Reg))
            ExtraCSSpill = true;
        }
      }
      if (!ExtraCSSpill && RS) {
        // Reserve a slot closest to SP or frame pointer.
        LLVM_DEBUG(dbgs() << ""Reserving emergency spill slot\n"");
        const TargetRegisterClass &RC = ARM::GPRRegClass;
        unsigned Size = TRI->getSpillSize(RC);
        Align Alignment = TRI->getSpillAlign(RC);
        RS->addScavengingFrameIndex(
            MFI.CreateStackObject(Size, Alignment, false));
      }
    }
  }

  if (ForceLRSpill)
    SavedRegs.set(ARM::LR);
  AFI->setLRIsSpilled(SavedRegs.test(ARM::LR));
}

void ARMFrameLowering::processFunctionBeforeFrameFinalized(
    MachineFunction &MF, RegScavenger *RS) const {
  TargetFrameLowering::processFunctionBeforeFrameFinalized(MF, RS);

  MachineFrameInfo &MFI = MF.getFrameInfo();
  if (!MFI.isCalleeSavedInfoValid())
    return;

  // Check if all terminators do not implicitly use LR. Then we can 'restore' LR
  // into PC so it is not live out of the return block: Clear the Restored bit
  // in that case.
  for (CalleeSavedInfo &Info : MFI.getCalleeSavedInfo()) {
    if (Info.getReg() != ARM::LR)
      continue;
    if (all_of(MF, [](const MachineBasicBlock &MBB) {
          return all_of(MBB.terminators(), [](const MachineInstr &Term) {
            return !Term.isReturn() || Term.getOpcode() == ARM::LDMIA_RET ||
                   Term.getOpcode() == ARM::t2LDMIA_RET ||
                   Term.getOpcode() == ARM::tPOP_RET;
          });
        })) {
      Info.setRestored(false);
      break;
    }
  }
}

void ARMFrameLowering::getCalleeSaves(const MachineFunction &MF,
                                      BitVector &SavedRegs) const {
  TargetFrameLowering::getCalleeSaves(MF, SavedRegs);

  // If we have the ""returned"" parameter attribute which guarantees that we
  // return the value which was passed in r0 unmodified (e.g. C++ 'structors),
  // record that fact for IPRA.
  const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  if (AFI->getPreservesR0())
    SavedRegs.set(ARM::R0);
}

bool ARMFrameLowering::assignCalleeSavedSpillSlots(
    MachineFunction &MF, const TargetRegisterInfo *TRI,
    std::vector<CalleeSavedInfo> &CSI) const {
  // For CMSE entry functions, handle floating-point context as if it was a
  // callee-saved register.
  if (STI.hasV8_1MMainlineOps() &&
      MF.getInfo<ARMFunctionInfo>()->isCmseNSEntryFunction()) {
    CSI.emplace_back(ARM::FPCXTNS);
    CSI.back().setRestored(false);
  }

  // For functions, which sign their return address, upon function entry, the
  // return address PAC is computed in R12. Treat R12 as a callee-saved register
  // in this case.
  const auto &AFI = *MF.getInfo<ARMFunctionInfo>();
  if (AFI.shouldSignReturnAddress()) {
    // The order of register must match the order we push them, because the
    // PEI assigns frame indices in that order. When compiling for return
    // address sign and authenication, we use split push, therefore the orders
    // we want are:
    // LR, R7, R6, R5, R4, <R12>, R11, R10,  R9,  R8, D15-D8
    CSI.insert(find_if(CSI,
                       [=](const auto &CS) {
                         Register Reg = CS.getReg();
                         return Reg == ARM::R10 || Reg == ARM::R11 ||
                                Reg == ARM::R8 || Reg == ARM::R9 ||
                                ARM::DPRRegClass.contains(Reg);
                       }),
               CalleeSavedInfo(ARM::R12));
  }

  return false;
}

const TargetFrameLowering::SpillSlot *
ARMFrameLowering::getCalleeSavedSpillSlots(unsigned &NumEntries) const {
  static const SpillSlot FixedSpillOffsets[] = {{ARM::FPCXTNS, -4}};
  NumEntries = std::size(FixedSpillOffsets);
  return FixedSpillOffsets;
}

MachineBasicBlock::iterator ARMFrameLowering::eliminateCallFramePseudoInstr(
    MachineFunction &MF, MachineBasicBlock &MBB,
    MachineBasicBlock::iterator I) const {
  const ARMBaseInstrInfo &TII =
      *static_cast<const ARMBaseInstrInfo *>(MF.getSubtarget().getInstrInfo());
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
  bool isARM = !AFI->isThumbFunction();
  DebugLoc dl = I->getDebugLoc();
  unsigned Opc = I->getOpcode();
  bool IsDestroy = Opc == TII.getCallFrameDestroyOpcode();
  unsigned CalleePopAmount = IsDestroy ? I->getOperand(1).getImm() : 0;

  assert(!AFI->isThumb1OnlyFunction() &&
         ""This eliminateCallFramePseudoInstr does not support Thumb1!"");

  int PIdx = I->findFirstPredOperandIdx();
  ARMCC::CondCodes Pred = (PIdx == -1)
                              ? ARMCC::AL
                              : (ARMCC::CondCodes)I->getOperand(PIdx).getImm();
  unsigned PredReg = TII.getFramePred(*I);

  if (!hasReservedCallFrame(MF)) {
    // Bail early if the callee is expected to do the adjustment.
    if (IsDestroy && CalleePopAmount != -1U)
      return MBB.erase(I);

    // If we have alloca, convert as follows:
    // ADJCALLSTACKDOWN -> sub, sp, sp, amount
    // ADJCALLSTACKUP   -> add, sp, sp, amount
    unsigned Amount = TII.getFrameSize(*I);
    if (Amount != 0) {
      // We need to keep the stack aligned properly.  To do this, we round the
      // amount of space needed for the outgoing arguments up to the next
      // alignment boundary.
      Amount = alignSPAdjust(Amount);

      if (Opc == ARM::ADJCALLSTACKDOWN || Opc == ARM::tADJCALLSTACKDOWN) {
        emitSPUpdate(isARM, MBB, I, dl, TII, -Amount, MachineInstr::NoFlags,
                     Pred, PredReg);
      } else {
        assert(Opc == ARM::ADJCALLSTACKUP || Opc == ARM::tADJCALLSTACKUP);
        emitSPUpdate(isARM, MBB, I, dl, TII, Amount, MachineInstr::NoFlags,
                     Pred, PredReg);
      }
    }
  } else if (CalleePopAmount != -1U) {
    // If the calling convention demands that the callee pops arguments from the
    // stack, we want to add it back if we have a reserved call frame.
    emitSPUpdate(isARM, MBB, I, dl, TII, -CalleePopAmount,
                 MachineInstr::NoFlags, Pred, PredReg);
  }
  return MBB.erase(I);
}

/// Get the minimum constant for ARM that is greater than or equal to the
/// argument. In ARM, constants can have any value that can be produced by
/// rotating an 8-bit value to the right by an even number of bits within a
/// 32-bit word.
static uint32_t alignToARMConstant(uint32_t Value) {
  unsigned Shifted = 0;

  if (Value == 0)
      return 0;

  while (!(Value & 0xC0000000)) {
      Value = Value << 2;
      Shifted += 2;
  }

  bool Carry = (Value & 0x00FFFFFF);
  Value = ((Value & 0xFF000000) >> 24) + Carry;

  if (Value & 0x0000100)
      Value = Value & 0x000001FC;

  if (Shifted > 24)
      Value = Value >> (Shifted - 24);
  else
      Value = Value << (24 - Shifted);

  return Value;
}

// The stack limit in the TCB is set to this many bytes above the actual
// stack limit.
static const uint64_t kSplitStackAvailable = 256;

// Adjust the function prologue to enable split stacks. This currently only
// supports android and linux.
//
// The ABI of the segmented stack prologue is a little arbitrarily chosen, but
// must be well defined in order to allow for consistent implementations of the
// __morestack helper function. The ABI is also not a normal ABI in that it
// doesn't follow the normal calling conventions because this allows the
// prologue of each function to be optimized further.
//
// Currently, the ABI looks like (when calling __morestack)
//
//  * r4 holds the minimum stack size requested for this function call
//  * r5 holds the stack size of the arguments to the function
//  * the beginning of the function is 3 instructions after the call to
//    __morestack
//
// Implementations of __morestack should use r4 to allocate a new stack, r5 to
// place the arguments on to the new stack, and the 3-instruction knowledge to
// jump directly to the body of the function when working on the new stack.
//
// An old (and possibly no longer compatible) implementation of __morestack for
// ARM can be found at [1].
//
// [1] - https://github.com/mozilla/rust/blob/86efd9/src/rt/arch/arm/morestack.S
void ARMFrameLowering::adjustForSegmentedStacks(
    MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
  unsigned Opcode;
  unsigned CFIIndex;
  const ARMSubtarget *ST = &MF.getSubtarget<ARMSubtarget>();
  bool Thumb = ST->isThumb();
  bool Thumb2 = ST->isThumb2();

  // Sadly, this currently doesn't support varargs, platforms other than
  // android/linux. Note that thumb1/thumb2 are support for android/linux.
  if (MF.getFunction().isVarArg())
    report_fatal_error(""Segmented stacks do not support vararg functions."");
  if (!ST->isTargetAndroid() && !ST->isTargetLinux())
    report_fatal_error(""Segmented stacks not supported on this platform."");

  MachineFrameInfo &MFI = MF.getFrameInfo();
  MachineModuleInfo &MMI = MF.getMMI();
  MCContext &Context = MMI.getContext();
  const MCRegisterInfo *MRI = Context.getRegisterInfo();
  const ARMBaseInstrInfo &TII =
      *static_cast<const ARMBaseInstrInfo *>(MF.getSubtarget().getInstrInfo());
  ARMFunctionInfo *ARMFI = MF.getInfo<ARMFunctionInfo>();
  DebugLoc DL;

  if (!MFI.needsSplitStackProlog())
    return;

  uint64_t StackSize = MFI.getStackSize();

  // Use R4 and R5 as scratch registers.
  // We save R4 and R5 before use and restore them before leaving the function.
  unsigned ScratchReg0 = ARM::R4;
  unsigned ScratchReg1 = ARM::R5;
  uint64_t AlignedStackSize;

  MachineBasicBlock *PrevStackMBB = MF.CreateMachineBasicBlock();
  MachineBasicBlock *PostStackMBB = MF.CreateMachineBasicBlock();
  MachineBasicBlock *AllocMBB = MF.CreateMachineBasicBlock();
  MachineBasicBlock *GetMBB = MF.CreateMachineBasicBlock();
  MachineBasicBlock *McrMBB = MF.CreateMachineBasicBlock();

  // Grab everything that reaches PrologueMBB to update there liveness as well.
  SmallPtrSet<MachineBasicBlock *, 8> BeforePrologueRegion;
  SmallVector<MachineBasicBlock *, 2> WalkList;
  WalkList.push_back(&PrologueMBB);

  do {
    MachineBasicBlock *CurMBB = WalkList.pop_back_val();
    for (MachineBasicBlock *PredBB : CurMBB->predecessors()) {
      if (BeforePrologueRegion.insert(PredBB).second)
        WalkList.push_back(PredBB);
    }
  } while (!WalkList.empty());

  // The order in that list is important.
  // The blocks will all be inserted before PrologueMBB using that order.
  // Therefore the block that should appear first in the CFG should appear
  // first in the list.
  MachineBasicBlock *AddedBlocks[] = {PrevStackMBB, McrMBB, GetMBB, AllocMBB,
                                      PostStackMBB};

  for (MachineBasicBlock *B : AddedBlocks)
    BeforePrologueRegion.insert(B);

  for (const auto &LI : PrologueMBB.liveins()) {
    for (MachineBasicBlock *PredBB : BeforePrologueRegion)
      PredBB->addLiveIn(LI);
  }

  // Remove the newly added blocks from the list, since we know
  // we do not have to do the following updates for them.
  for (MachineBasicBlock *B : AddedBlocks) {
    BeforePrologueRegion.erase(B);
    MF.insert(PrologueMBB.getIterator(), B);
  }

  for (MachineBasicBlock *MBB : BeforePrologueRegion) {
    // Make sure the LiveIns are still sorted and unique.
    MBB->sortUniqueLiveIns();
    // Replace the edges to PrologueMBB by edges to the sequences
    // we are about to add, but only update for immediate predecessors.
    if (MBB->isSuccessor(&PrologueMBB))
      MBB->ReplaceUsesOfBlockWith(&PrologueMBB, AddedBlocks[0]);
  }

  // The required stack size that is aligned to ARM constant criterion.
  AlignedStackSize = alignToARMConstant(StackSize);

  // When the frame size is less than 256 we just compare the stack
  // boundary directly to the value of the stack pointer, per gcc.
  bool CompareStackPointer = AlignedStackSize < kSplitStackAvailable;

  // We will use two of the callee save registers as scratch registers so we
  // need to save those registers onto the stack.
  // We will use SR0 to hold stack limit and SR1 to hold the stack size
  // requested and arguments for __morestack().
  // SR0: Scratch Register #0
  // SR1: Scratch Register #1
  // push {SR0, SR1}
  if (Thumb) {
    BuildMI(PrevStackMBB, DL, TII.get(ARM::tPUSH))
        .add(predOps(ARMCC::AL))
        .addReg(ScratchReg0)
        .addReg(ScratchReg1);
  } else {
    BuildMI(PrevStackMBB, DL, TII.get(ARM::STMDB_UPD))
        .addReg(ARM::SP, RegState::Define)
        .addReg(ARM::SP)
        .add(predOps(ARMCC::AL))
        .addReg(ScratchReg0)
        .addReg(ScratchReg1);
  }

  // Emit the relevant DWARF information about the change in stack pointer as
  // well as where to find both r4 and r5 (the callee-save registers)
  if (!MF.getTarget().getMCAsmInfo()->usesWindowsCFI()) {
    CFIIndex = MF.addFrameInst(MCCFIInstruction::cfiDefCfaOffset(nullptr, 8));
    BuildMI(PrevStackMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
    CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
        nullptr, MRI->getDwarfRegNum(ScratchReg1, true), -4));
    BuildMI(PrevStackMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
    CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
        nullptr, MRI->getDwarfRegNum(ScratchReg0, true), -8));
    BuildMI(PrevStackMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
  }

  // mov SR1, sp
  if (Thumb) {
    BuildMI(McrMBB, DL, TII.get(ARM::tMOVr), ScratchReg1)
        .addReg(ARM::SP)
        .add(predOps(ARMCC::AL));
  } else if (CompareStackPointer) {
    BuildMI(McrMBB, DL, TII.get(ARM::MOVr), ScratchReg1)
        .addReg(ARM::SP)
        .add(predOps(ARMCC::AL))
        .add(condCodeOp());
  }

  // sub SR1, sp, #StackSize
  if (!CompareStackPointer && Thumb) {
    if (AlignedStackSize < 256) {
      BuildMI(McrMBB, DL, TII.get(ARM::tSUBi8), ScratchReg1)
          .add(condCodeOp())
          .addReg(ScratchReg1)
          .addImm(AlignedStackSize)
          .add(predOps(ARMCC::AL));
    } else {
      if (Thumb2) {
        BuildMI(McrMBB, DL, TII.get(ARM::t2MOVi32imm), ScratchReg0)
            .addImm(AlignedStackSize);
      } else {
        auto MBBI = McrMBB->end();
        auto RegInfo = STI.getRegisterInfo();
        RegInfo->emitLoadConstPool(*McrMBB, MBBI, DL, ScratchReg0, 0,
                                   AlignedStackSize);
      }
      BuildMI(McrMBB, DL, TII.get(ARM::tSUBrr), ScratchReg1)
          .add(condCodeOp())
          .addReg(ScratchReg1)
          .addReg(ScratchReg0)
          .add(predOps(ARMCC::AL));
    }
  } else if (!CompareStackPointer) {
    if (AlignedStackSize < 256) {
      BuildMI(McrMBB, DL, TII.get(ARM::SUBri), ScratchReg1)
          .addReg(ARM::SP)
          .addImm(AlignedStackSize)
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
    } else {
      auto MBBI = McrMBB->end();
      auto RegInfo = STI.getRegisterInfo();
      RegInfo->emitLoadConstPool(*McrMBB, MBBI, DL, ScratchReg0, 0,
                                 AlignedStackSize);
      BuildMI(McrMBB, DL, TII.get(ARM::SUBrr), ScratchReg1)
          .addReg(ARM::SP)
          .addReg(ScratchReg0)
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
    }
  }

  if (Thumb && ST->isThumb1Only()) {
    unsigned PCLabelId = ARMFI->createPICLabelUId();
    ARMConstantPoolValue *NewCPV = ARMConstantPoolSymbol::Create(
        MF.getFunction().getContext(), ""__STACK_LIMIT"", PCLabelId, 0);
    MachineConstantPool *MCP = MF.getConstantPool();
    unsigned CPI = MCP->getConstantPoolIndex(NewCPV, Align(4));

    // ldr SR0, [pc, offset(STACK_LIMIT)]
    BuildMI(GetMBB, DL, TII.get(ARM::tLDRpci), ScratchReg0)
        .addConstantPoolIndex(CPI)
        .add(predOps(ARMCC::AL));

    // ldr SR0, [SR0]
    BuildMI(GetMBB, DL, TII.get(ARM::tLDRi), ScratchReg0)
        .addReg(ScratchReg0)
        .addImm(0)
        .add(predOps(ARMCC::AL));
  } else {
    // Get TLS base address from the coprocessor
    // mrc p15, #0, SR0, c13, c0, #3
    BuildMI(McrMBB, DL, TII.get(Thumb ? ARM::t2MRC : ARM::MRC),
            ScratchReg0)
        .addImm(15)
        .addImm(0)
        .addImm(13)
        .addImm(0)
        .addImm(3)
        .add(predOps(ARMCC::AL));

    // Use the last tls slot on android and a private field of the TCP on linux.
    assert(ST->isTargetAndroid() || ST->isTargetLinux());
    unsigned TlsOffset = ST->isTargetAndroid() ? 63 : 1;

    // Get the stack limit from the right offset
    // ldr SR0, [sr0, #4 * TlsOffset]
    BuildMI(GetMBB, DL, TII.get(Thumb ? ARM::t2LDRi12 : ARM::LDRi12),
            ScratchReg0)
        .addReg(ScratchReg0)
        .addImm(4 * TlsOffset)
        .add(predOps(ARMCC::AL));
  }

  // Compare stack limit with stack size requested.
  // cmp SR0, SR1
  Opcode = Thumb ? ARM::tCMPr : ARM::CMPrr;
  BuildMI(GetMBB, DL, TII.get(Opcode))
      .addReg(ScratchReg0)
      .addReg(ScratchReg1)
      .add(predOps(ARMCC::AL));

  // This jump is taken if StackLimit <= SP - stack required.
  Opcode = Thumb ? ARM::tBcc : ARM::Bcc;
  BuildMI(GetMBB, DL, TII.get(Opcode))
      .addMBB(PostStackMBB)
      .addImm(ARMCC::LS)
      .addReg(ARM::CPSR);

  // Calling __morestack(StackSize, Size of stack arguments).
  // __morestack knows that the stack size requested is in SR0(r4)
  // and amount size of stack arguments is in SR1(r5).

  // Pass first argument for the __morestack by Scratch Register #0.
  //   The amount size of stack required
  if (Thumb) {
    if (AlignedStackSize < 256) {
      BuildMI(AllocMBB, DL, TII.get(ARM::tMOVi8), ScratchReg0)
          .add(condCodeOp())
          .addImm(AlignedStackSize)
          .add(predOps(ARMCC::AL));
    } else {
      if (Thumb2) {
        BuildMI(AllocMBB, DL, TII.get(ARM::t2MOVi32imm), ScratchReg0)
            .addImm(AlignedStackSize);
      } else {
        auto MBBI = AllocMBB->end();
        auto RegInfo = STI.getRegisterInfo();
        RegInfo->emitLoadConstPool(*AllocMBB, MBBI, DL, ScratchReg0, 0,
                                   AlignedStackSize);
      }
    }
  } else {
    if (AlignedStackSize < 256) {
      BuildMI(AllocMBB, DL, TII.get(ARM::MOVi), ScratchReg0)
          .addImm(AlignedStackSize)
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
    } else {
      auto MBBI = AllocMBB->end();
      auto RegInfo = STI.getRegisterInfo();
      RegInfo->emitLoadConstPool(*AllocMBB, MBBI, DL, ScratchReg0, 0,
                                 AlignedStackSize);
    }
  }

  // Pass second argument for the __morestack by Scratch Register #1.
  //   The amount size of stack consumed to save function arguments.
  if (Thumb) {
    if (ARMFI->getArgumentStackSize() < 256) {
      BuildMI(AllocMBB, DL, TII.get(ARM::tMOVi8), ScratchReg1)
          .add(condCodeOp())
          .addImm(alignToARMConstant(ARMFI->getArgumentStackSize()))
          .add(predOps(ARMCC::AL));
    } else {
      if (Thumb2) {
        BuildMI(AllocMBB, DL, TII.get(ARM::t2MOVi32imm), ScratchReg1)
            .addImm(alignToARMConstant(ARMFI->getArgumentStackSize()));
      } else {
        auto MBBI = AllocMBB->end();
        auto RegInfo = STI.getRegisterInfo();
        RegInfo->emitLoadConstPool(
            *AllocMBB, MBBI, DL, ScratchReg1, 0,
            alignToARMConstant(ARMFI->getArgumentStackSize()));
      }
    }
  } else {
    if (alignToARMConstant(ARMFI->getArgumentStackSize()) < 256) {
      BuildMI(AllocMBB, DL, TII.get(ARM::MOVi), ScratchReg1)
          .addImm(alignToARMConstant(ARMFI->getArgumentStackSize()))
          .add(predOps(ARMCC::AL))
          .add(condCodeOp());
    } else {
      auto MBBI = AllocMBB->end();
      auto RegInfo = STI.getRegisterInfo();
      RegInfo->emitLoadConstPool(
          *AllocMBB, MBBI, DL, ScratchReg1, 0,
          alignToARMConstant(ARMFI->getArgumentStackSize()));
    }
  }

  // push {lr} - Save return address of this function.
  if (Thumb) {
    BuildMI(AllocMBB, DL, TII.get(ARM::tPUSH))
        .add(predOps(ARMCC::AL))
        .addReg(ARM::LR);
  } else {
    BuildMI(AllocMBB, DL, TII.get(ARM::STMDB_UPD))
        .addReg(ARM::SP, RegState::Define)
        .addReg(ARM::SP)
        .add(predOps(ARMCC::AL))
        .addReg(ARM::LR);
  }

  // Emit the DWARF info about the change in stack as well as where to find the
  // previous link register
  if (!MF.getTarget().getMCAsmInfo()->usesWindowsCFI()) {
    CFIIndex = MF.addFrameInst(MCCFIInstruction::cfiDefCfaOffset(nullptr, 12));
    BuildMI(AllocMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
    CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
        nullptr, MRI->getDwarfRegNum(ARM::LR, true), -12));
    BuildMI(AllocMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
  }

  // Call __morestack().
  if (Thumb) {
    BuildMI(AllocMBB, DL, TII.get(ARM::tBL))
        .add(predOps(ARMCC::AL))
        .addExternalSymbol(""__morestack"");
  } else {
    BuildMI(AllocMBB, DL, TII.get(ARM::BL))
        .addExternalSymbol(""__morestack"");
  }

  // pop {lr} - Restore return address of this original function.
  if (Thumb) {
    if (ST->isThumb1Only()) {
      BuildMI(AllocMBB, DL, TII.get(ARM::tPOP))
          .add(predOps(ARMCC::AL))
          .addReg(ScratchReg0);
      BuildMI(AllocMBB, DL, TII.get(ARM::tMOVr), ARM::LR)
          .addReg(ScratchReg0)
          .add(predOps(ARMCC::AL));
    } else {
      BuildMI(AllocMBB, DL, TII.get(ARM::t2LDR_POST))
          .addReg(ARM::LR, RegState::Define)
          .addReg(ARM::SP, RegState::Define)
          .addReg(ARM::SP)
          .addImm(4)
          .add(predOps(ARMCC::AL));
    }
  } else {
    BuildMI(AllocMBB, DL, TII.get(ARM::LDMIA_UPD))
        .addReg(ARM::SP, RegState::Define)
        .addReg(ARM::SP)
        .add(predOps(ARMCC::AL))
        .addReg(ARM::LR);
  }

  // Restore SR0 and SR1 in case of __morestack() was called.
  // __morestack() will skip PostStackMBB block so we need to restore
  // scratch registers from here.
  // pop {SR0, SR1}
  if (Thumb) {
    BuildMI(AllocMBB, DL, TII.get(ARM::tPOP))
        .add(predOps(ARMCC::AL))
        .addReg(ScratchReg0)
        .addReg(ScratchReg1);
  } else {
    BuildMI(AllocMBB, DL, TII.get(ARM::LDMIA_UPD))
        .addReg(ARM::SP, RegState::Define)
        .addReg(ARM::SP)
        .add(predOps(ARMCC::AL))
        .addReg(ScratchReg0)
        .addReg(ScratchReg1);
  }

  // Update the CFA offset now that we've popped
  if (!MF.getTarget().getMCAsmInfo()->usesWindowsCFI()) {
    CFIIndex = MF.addFrameInst(MCCFIInstruction::cfiDefCfaOffset(nullptr, 0));
    BuildMI(AllocMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
  }

  // Return from this function.
  BuildMI(AllocMBB, DL, TII.get(ST->getReturnOpcode())).add(predOps(ARMCC::AL));

  // Restore SR0 and SR1 in case of __morestack() was not called.
  // pop {SR0, SR1}
  if (Thumb) {
    BuildMI(PostStackMBB, DL, TII.get(ARM::tPOP))
        .add(predOps(ARMCC::AL))
        .addReg(ScratchReg0)
        .addReg(ScratchReg1);
  } else {
    BuildMI(PostStackMBB, DL, TII.get(ARM::LDMIA_UPD))
        .addReg(ARM::SP, RegState::Define)
        .addReg(ARM::SP)
        .add(predOps(ARMCC::AL))
        .addReg(ScratchReg0)
        .addReg(ScratchReg1);
  }

  // Update the CFA offset now that we've popped
  if (!MF.getTarget().getMCAsmInfo()->usesWindowsCFI()) {
    CFIIndex = MF.addFrameInst(MCCFIInstruction::cfiDefCfaOffset(nullptr, 0));
    BuildMI(PostStackMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);

    // Tell debuggers that r4 and r5 are now the same as they were in the
    // previous function, that they're the ""Same Value"".
    CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(
        nullptr, MRI->getDwarfRegNum(ScratchReg0, true)));
    BuildMI(PostStackMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
    CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(
        nullptr, MRI->getDwarfRegNum(ScratchReg1, true)));
    BuildMI(PostStackMBB, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
        .addCFIIndex(CFIIndex);
  }

  // Organizing MBB lists
  PostStackMBB->addSuccessor(&PrologueMBB);

  AllocMBB->addSuccessor(PostStackMBB);

  GetMBB->addSuccessor(PostStackMBB);
  GetMBB->addSuccessor(AllocMBB);

  McrMBB->addSuccessor(GetMBB);

  PrevStackMBB->addSuccessor(McrMBB);

#ifdef EXPENSIVE_CHECKS
  MF.verify();
#endif
}
",IncomingArgStackToRestore
922,"#ifndef _LAUNCHER_H_
#define _LAUNCHER_H_

#include ""../utils/Reader.h""
#include ""../utils/Preprocessor.h""
#include ""EngineWrapper.hpp""

class Launcher {
    public:
        Launcher(Reader *reader, Preprocessor *processor, EngineWrapper *engine) {
            reader_ = reader;
            engine_ = engine;
            if (processor)
                reader_->register_processor(processor);
        }
        ~Launcher() {
			reader_ = 0;
			engine_ = 0;
        }
        void run() {
			unsigned long long id;
            cv::Mat  [MASK]  = reader_->get();
            while (! [MASK] .empty()) {
				TEEImg param;
				param.data =  [MASK] .data;
				param.h =  [MASK] .rows;
				param.w =  [MASK] .cols;
				param.pixfmt = ePixfmtRGB;
				int status = engine_->push(&param, &id);
				if (status != TEE_RET_SUCCESS) {
					// Error
					printf(""Push task. id: %lld ret: %d\n"", id, status);
				}
                 [MASK]  = reader_->get();
            }
			engine_->clear();
        }

    private:
        Reader *reader_;
        EngineWrapper *engine_;
};

#endif  // _LAUNCHER_H_


",img
923,"// BonDecodeApp.cpp : このファイルには 'main' 関数が含まれています。プログラム実行の開始と終了がそこで行われます。
//

#include <iostream>
#include <fstream>
#include <filesystem>
#include <locale>

#include <Windows.h>

#include ""IB25Decoder.h""

using namespace std;

HMODULE hDecoder = nullptr;

IB25Decoder2* LoadDecoder(const std::string& decoderPath);

//for commma sepalated number
class comma_numpunct : public std::numpunct<char>
{
protected:
	virtual char do_thousands_sep() const { return ','; }
	virtual std::string do_grouping() const { return ""\3""; }
};


int main(int argc, char* argv[])
{
	if (argc != 4) {
		cerr << ""Usage: BonDecodeApp.exe <Decoder.dll> <encryptedfile.mmts> <decryptedfile.mmts>"" << endl;
		return EXIT_FAILURE;
	}

	//IB25interface instance
	IB25Decoder2* pDecoder = nullptr;
	try {
		pDecoder = LoadDecoder(argv[1]);
	}
	catch (exception& e) {
		cout << e.what() << endl;
		return EXIT_FAILURE;
	}
	cout << ""Decoder Loaded:"" << argv[1] << endl;

	//in, out files
	ifstream binFile(argv[2], ios::in | ios::binary);
	if (!binFile.is_open()) {
		auto mes = format(""Failed to open read file:{}"", argv[2]);
		cerr << mes << endl;
		return EXIT_FAILURE;
	}

	ofstream outFile(argv[3], ios::out | ios::binary);
	if (!outFile.is_open()) {
		auto mes = format(""Failed to open write file:{}"", argv[3]);
		cerr << mes << endl;
		return EXIT_FAILURE;
	}

	//for commma sepalated number
	cout.imbue(locale(cout.getloc(), new comma_numpunct()));
	cout << setprecision(2) <<fixed;

	// local value initialize
	auto fileSize = filesystem::file_size(argv[2]);
	streamsize  [MASK]  = 0;
	streamsize writeSize = 0;

	BYTE* dstBuffer = nullptr;
	DWORD dstSize = 0;

	auto now = time(nullptr);
	struct tm lt;
	localtime_s(&lt, &now);
	cout << ""START:"" << put_time(&lt, ""%H:%M:%S"") << endl;

	const int BLOCK_SIZE = 1024 * 1024 * 10;
	vector<BYTE> newData(BLOCK_SIZE);

	//Main loop
	while (!binFile.eof()) {
		auto rSize = binFile.read((char*)(newData.data()), BLOCK_SIZE).gcount();
		 [MASK]  += rSize;
		auto res = pDecoder->Decode(newData.data(), (DWORD)rSize, &dstBuffer, &dstSize);
		if (res) {
			outFile.write((char*)dstBuffer, dstSize);
			writeSize += dstSize;
		}
		else {
			outFile.write((char*)newData.data(),  [MASK] );
			writeSize +=  [MASK] ;
		}
		cout << ""\r"" << ""read:"" <<  [MASK]  << ""/"" << fileSize << "" write:"" << writeSize;
	}

	//Finish
	{
		auto res = pDecoder->Flush(&dstBuffer, &dstSize);
		if (res) {
			outFile.write((char*)dstBuffer, dstSize);
			writeSize += dstSize;
		}
		else {
			outFile.write((char*)newData.data(),  [MASK] );
			writeSize +=  [MASK] ;
		}
		cout << ""\r"" << ""read:"" <<  [MASK]  << ""/"" << fileSize << "" write:"" << writeSize;
	}

	now = time(nullptr);
	localtime_s(&lt, &now);
	std::cout << std::endl << ""END:"" << put_time(&lt, ""%H:%M:%S"") << std::endl;

	outFile.flush();
	outFile.close();

	pDecoder->Release();

	return EXIT_SUCCESS;
}


IB25Decoder2* LoadDecoder(const std::string& decoderPath)
{
	if (hDecoder) {
		throw std::runtime_error(""Decoder is already loaded"");
	}

	if (decoderPath.empty()) {
		throw std::invalid_argument(""Decoder path is empty"");
	}

	if (!filesystem::exists(decoderPath)) {
		throw std::invalid_argument(""Decoder file is not exist."");
	}

	hDecoder = LoadLibraryA(decoderPath.c_str());

	if (!hDecoder) {
		throw std::runtime_error(""Could not load Decoder"");
	}

	IB25Decoder2* (*CreateB25Decoder)();
	CreateB25Decoder = (IB25Decoder2 * (*)())GetProcAddress(hDecoder, ""CreateB25Decoder"");

	if (!CreateB25Decoder) {
		FreeLibrary(hDecoder);
		hDecoder = NULL;

		throw std::runtime_error(""Could not get address CreateB25Decoder()"");
	}

	auto pDecoder = CreateB25Decoder();

	if (!pDecoder) {
		FreeLibrary(hDecoder);
		hDecoder = NULL;

		throw std::runtime_error(""Could not get IB25Decoder"");
	}

	if (!pDecoder->Initialize()) {
		FreeLibrary(hDecoder);
		hDecoder = NULL;

		throw std::runtime_error(""Could not initialize IB25Decoder"");
	}

	pDecoder->DiscardNullPacket(true);
	pDecoder->DiscardScramblePacket(false);
	pDecoder->EnableEmmProcess(false);

	return pDecoder;
}
",readSize
924,"#include ""Lexer.hpp""
#include ""Expression.hpp""
#include ""IOperand.hpp""
#include ""OperandFactory.hpp""
#include ""Operators.hpp""
#include ""Exceptions.hpp""
#include ""Parser.hpp""
#include <boost/algorithm/string.hpp>
#include <string>
#include <unordered_map>
#include <regex>

std::string const Lexer::operand_regex = ""\\w+\\((-?\\d+([\\.\\,]\\d+)?)\\)"";

Lexer::Lexer(void) { }

Expression *Lexer::lex(std::string const& line) const
{
	static auto const noop = new Expression(*get_operator(""noop""), new std::vector<IOperand const*>());
	auto const trimmedLine = boost::trim_copy(line.substr(0, line.find(';')));

	if (trimmedLine == """" || trimmedLine.at(0) == ';')
		return noop;

	Parser parser;
	std::vector<std::string> strings;
	boost::split(strings, trimmedLine, boost::is_space());

	auto it = strings.begin();

	auto op = get_operator(*it);
	auto  [MASK]  = new std::vector<eOperandType>();
	auto operands_values = new std::vector<std::string const*>();

	it++;

	for (; it != strings.end(); it++)
	{
		if (it->size() == 0)
			continue ;
		validate_operand_syntax(*it);
		 [MASK] ->push_back(get_operand_type(*it));
		operands_values->push_back(get_operand_value(*it));
	}
	return parser.parse(op, * [MASK] , *operands_values);
}

Operator const *Lexer::get_operator(std::string const& op) const
{
	//TODO utiliser le nom qui est dans l'op
	static const std::unordered_map<std::string, Operator *> operators = {
		{ ""push"", new Push() },
		{ ""pop"", new Pop() },
		{ ""dump"", new Dump() },
		{ ""assert"", new Assert() },
		{ ""add"", new Add() },
		{ ""sub"", new Sub() },
		{ ""mul"", new Mul() },
		{ ""div"", new Div() },
		{ ""mod"", new Mod() },
		{ ""print"", new Print() },
		{ ""exit"", new Exit() },
		{ ""noop"", new NoOp() },
	};
	
	if (operators.count(op) == 0)
		throw UnknowOperatorException(op);
	return operators.at(op);
}

eOperandType Lexer::get_operand_type(std::string const& operand) const
{
	static auto const operand_regex = std::regex(""(\\w)+"");
	static const std::unordered_map<std::string, eOperandType> operands = {
		{ ""int8"", eOperandType::Int8 },
		{ ""int16"", eOperandType::Int16 },
		{ ""int32"", eOperandType::Int32 },
		{ ""float"", eOperandType::Float },
		{ ""double"", eOperandType::Double },
	};
	std::smatch match;

	std::regex_search(operand, match, operand_regex);

	auto const o = match[0].str();
	if (operands.count(o) == 0)
		throw UnknowOperandException(o);
	return operands.at(o);
}

std::string const *Lexer::get_operand_value(std::string const& operand) const
{
	auto const operand_regex = std::regex(Lexer::operand_regex);
	std::smatch match;

	std::regex_search(operand, match, operand_regex);
	return (new std::string(match[1].str()));
}

void Lexer::validate_operand_syntax(std::string const& operand) const
{
	auto const operand_regex = std::regex(Lexer::operand_regex);

	if (!std::regex_match(operand, operand_regex))
		throw SyntaxErrorException(operand);
}
",operands_types
925,"// https://leetcode.com/problems/two-sum/
//
// Status: Accepted
// Runtime: 28 ms
// Score: 99.00%
//

#include <iostream>
#include <map>
#include <vector>
#include <stack>
#include <cmath>

#include <gtest/gtest.h>
#include ""args.h""
#include ""macros.h""

using namespace std;

// Defined in problem
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution
{
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2)
    {
        // Handle case when one of the numbers is null
        if (!l1 && !l2)
        {
            cout << ""somebody was null"" << endl;
            return nullptr;
        }

        ListNode *answer = nullptr;
        ListNode *ln = nullptr;

        int carryover = 0;

        // go through and add numbers, linked lists may not be the same length
        do
        {
            int sum = carryover;
            if (l1)
            {
                sum += l1->val;
            }
            if (l2)
            {
                sum += l2->val;
            }

            int remainder = sum % 10;
            carryover = sum / 10;

            ListNode *node = new ListNode(remainder);
            if (answer == nullptr)
            {
                answer = node;
                ln = node;
            }
            else
            {
                ln->next = node;
                ln = node;
            }
            if (l1)
            {
                l1 = l1->next;
            }
            if (l2)
            {
                l2 = l2->next;
            }
        } while (l1 || l2);

        // Finally, it is possible the answer may be longer than either of the original
        // linked lists, as indicated by carryover, so add that if carryover is not 0
        if (carryover)
        {
            ListNode *node = new ListNode(carryover);
            ln->next = node;
        }

        return answer;
    }
};

namespace addTwoNumbers
{
    namespace test
    {
        // Create a new list node, don't forget to free
        ListNode *create(int number)
        {
            ListNode *first = nullptr;
            ListNode *prev = nullptr;

            do
            {
                ListNode *ln = new ListNode(number % 10);
                number /= 10;

                if (first == nullptr)
                {
                    first = ln;
                }
                if (prev != nullptr)
                {
                    prev->next = ln;
                }
                prev = ln;

            } while (number);

            return first;
        }

        // Turn the ListNode back into an int
        int unpack(ListNode *listNode)
        {
            if (listNode == nullptr)
            {
                throw ""unpack: nullptr passed in"";
            }

            int number = 0;
            int i = 0;
            ListNode *ln = listNode;
            while (ln != nullptr)
            {
                number += (ln->val * pow(10, i));
                ln = ln->next;
                i++;
            }

            return number;
        }

        // Free the allocated memory
        void free(ListNode *ln)
        {
            if (ln == nullptr)
            {
                throw ""unpack: nullptr passed in"";
            }

            while (ln != nullptr)
            {
                ListNode *next = ln->next;
                delete ln;
                ln = next;
            }
        }
    }; // namespace test
};     // namespace addTwoNumbers

TEST(AddTwoNumbersTest, CorrectSample)
{
    const int firstNumber = 342;
    const int secondNumber = 465;

    ListNode *first = addTwoNumbers::test::create(firstNumber);
    ListNode *second = addTwoNumbers::test::create(secondNumber);
    Solution  [MASK] ;

    int answerInteger = 0;
    int lookingFor = firstNumber + secondNumber;

    try
    {
        ListNode *answer =  [MASK] .addTwoNumbers(first, second);
        answerInteger = addTwoNumbers::test::unpack(answer);
        addTwoNumbers::test::free(answer);
        addTwoNumbers::test::free(first);
        addTwoNumbers::test::free(second);
    }
    catch (...)
    {
        cout << ""TwoSumsTest.CorrectSample:: Caught exception"" << endl;
    }

    ASSERT_EQ(answerInteger, lookingFor);
}
",solution
926,"/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   Contact.class.cpp                                  :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: ncoden <<EMAIL>>              +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2015/06/15 13:59:20 by ncoden            #+#    #+#             */
/*   Updated: 2015/06/16 19:47:06 by ncoden           ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include <cstring>
#include <iomanip>
#include ""Contact.class.hpp""

Contact::Contact(void){
	return;
}

Contact::~Contact(void){
	return;
}

void	Contact::print(void){
	static int	 [MASK] ;
	static int	i;

	 [MASK]  = 0;
	i = 0;
	while (i < 9)
	{
		std::cout << ' ';
		i++;
	}
	std::cout << index << '|';
	if (( [MASK]  = std::strlen(first_name)) < 10)
	{
		 [MASK]  = 10 -  [MASK] ;
		std::cout << std::string( [MASK] , ' ') << first_name << '|';
	}
	else
	{
		i = 0;
		while (i < 9)
		{
			std::cout << first_name[i];
			i++;
		}
		std::cout << '.' << '|';
	}
	if (( [MASK]  = std::strlen(last_name)) < 10)
	{
		 [MASK]  = 10 -  [MASK] ;
		std::cout << std::string( [MASK] , ' ') << last_name << '|';
	}
	else
	{
		i = 0;
		while (i < 9)
		{
			std::cout << first_name[i];
			i++;
		}
		std::cout << '.' << '|';
	}
	if (( [MASK]  = std::strlen(nickname)) < 10)
	{
		 [MASK]  = 10 -  [MASK] ;
		std::cout << std::string( [MASK] , ' ') << nickname << '|';
	}
	else
	{
		i = 0;
		while (i < 9)
		{
			std::cout << first_name[i];
			i++;
		}
		std::cout << '.' << '|' << '\n';
	}
}

void	Contact::print_info(void) {
	std::cout << first_name << std::endl;
	std::cout << last_name << std::endl;
	std::cout << nickname << std::endl;
	std::cout << login << std::endl;
	std::cout << postal_adress << std::endl;
	std::cout << email_adress << std::endl;
	std::cout << phone_number << std::endl;
	std::cout << birthday << std::endl;
	std::cout << favorite_meal << std::endl;
	std::cout << underwear_color << std::endl;
	std::cout << darkest_secret << std::endl;
}
",space_number
927,"#include <cstdlib>
#include <fstream>
#include <iostream>
#include <memory>
#include <vector>
#include ""Engine.hpp""
#include ""Item.hpp""
#include ""OgmoTile.hpp""
#include ""Tile.hpp""
#include ""Utilities.hpp""

terra::Engine::Engine(){
	// Just setting up some variables
	ConsoleOpen = false;
	Initialized = false;
}

void terra::Engine::Error(const std::string &ErrorMessage){
	// Keep an error log, mark errors with id 2 for color-coding
	ConsoleLog.push_back(std::pair<unsigned int, std::string>(2, ErrorMessage));
}

terra::Engine &terra::Engine::Get(){
	// Keeps a singleton (no use of new, C++0x requires proper initialization in multithreaded environments, iirc)
	static terra::Engine Singleton;
	return Singleton;
}

std::shared_ptr<terra::Layer> terra::Engine::GetLayer(std::string Name){
	// Give a null pointer if the layer doesn't exist
	if (NamedLayers.find(Name) == NamedLayers.end())
		return std::shared_ptr<terra::Layer>(nullptr);

	// Give the correct layer otherwise
	return NamedLayers[Name];
}

std::string terra::Engine::GetLevelValue(std::string Name){
	if (LevelValues.find(Name) == LevelValues.end()){
		Warning(std::string(""Level Value of name \"""") + Name + ""\"" does not exist\n"");
		return """";
	}
	return LevelValues[Name];
}

std::string terra::Engine::GetLevelValueType(std::string Name){
	if (ValueTypes.find(Name) == ValueTypes.end()){
		Warning(std::string(""Level Value of name \"""") + Name + ""\"" does not exist\n"");
		return """";
	}
	return ValueTypes[Name];
}

sf::RenderWindow &terra::Engine::GetWindow(){
	return Window;
}

void terra::Engine::Initialize(const int argc, char *argv[]){
	// Some initial values
	unsigned int Width = 640, Height = 480, Framerate = 60;
	std::string Title = ""Terra Game Engine"", InitialLevel = ""res/levels/Title.oel"";

	// Parse the boot file
	ParseBoot(Width, Height, Framerate, Title, InitialLevel);

	// Parse the command line
	ParseCommandLine(argc, argv, Width, Height);

	// Begin the actual initialization
	NewLevel = true;
	NextLevelName = InitialLevel;

	// Parse the game's Ogmo Editor project to extract any needed info
	ParseProject();

	// Finish initialization
	Window.Create(sf::VideoMode(Width, Height, 32), Title);
	Initialized = true;
}

const bool terra::Engine::IsConsoleOpen() const{
	return ConsoleOpen;
}

void terra::Engine::LoadLevel(std::string Filename){
	// Don't actually load the level, but prepare for loading at the beginning of the next frame
	NewLevel = true;
	NextLevelName = Filename;
}

int terra::Engine::Main(){
	// Check if the developer forgot to initialize the engine
	if (!Initialized){
		Error(""Game attempted to run before initialization!\n"");
		return -1;
	}

	// Prepare the console
	sf::Font ConsoleFont;
	if (!ConsoleFont.LoadFromFile(""res/fonts/DejaVuSansMono.ttf"")){
		Warning(""Unable to locate the console font. Going with default Arial."");
		ConsoleFont = sf::Font::GetDefaultFont();
	}

	// Main Loop
	while (Window.IsOpened()){
		// Main gameplay
		if (!ConsoleOpen){
			// Level loading
			if (NewLevel)
				ParseLevel();

			// Event handling
			sf::Event Event;
			while (Window.PollEvent(Event)){
				if (Event.Type == sf::Event::Closed)
					Window.Close();
				else if (Event.Type == sf::Event::KeyPressed && Event.Key.Code == sf::Key::Escape)
					ConsoleOpen = true;
				else
					for (auto i = Layers.begin(); i != Layers.end(); ++i)
						for (auto j = (*i)->Begin(); j != (*i)->End(); ++j)
							(*j)->OnEvent(Event);
			}

			// Game Logic
			for (auto i = Layers.begin(); i != Layers.end(); ++i)
				for (auto j = (*i)->Begin(); j != (*i)->End(); ++j)
					(*j)->OnFrame();

			// Game Rendering
			Window.Clear();
			for (auto i = Layers.begin(); i != Layers.end(); ++i)
				for (auto j = (*i)->Begin(); j != (*i)->End(); ++j)
					(*j)->OnRender(Window);
			Window.Display();
		}
		// Console Control
		else{
			// Event handling
			sf::Event Event;
			while (Window.PollEvent(Event)){
				if (Event.Type == sf::Event::Closed)
					Window.Close();
				else if (Event.Type == sf::Event::KeyPressed && Event.Key.Code == sf::Key::Escape)
					ConsoleOpen = false;
			}

			// Render the game's objects as if they were floating in the background
			Window.Clear();
			for (auto i = Layers.begin(); i != Layers.end(); ++i)
				for (auto j = (*i)->Begin(); j != (*i)->End(); ++j)
					(*j)->OnRender(Window);

			// Darken the screen
			sf::View Temp = Window.GetView();
			sf::View Replacement(sf::FloatRect(0, 0, Window.GetWidth(), Window.GetHeight()));
			Window.SetView(Replacement);
			Window.Draw(sf::Shape::Rectangle(0., 0., Window.GetWidth(), Window.GetHeight(), sf::Color(0, 0, 0, 170)));

			// Draw the console output
			unsigned int LineCounter = 0;
			unsigned int LineMax = Window.GetHeight()/20;
			for (auto i = ConsoleLog.rbegin(); i != ConsoleLog.rend(); ++i){
				// End the console rendering if too many lines
				if (LineCounter >= LineMax)
					break;

				// Prepare the text
				unsigned int LineY = Window.GetHeight()-(LineCounter+1)*20;
				sf::Text Line(i->second, ConsoleFont, 16);

				// Color code warnings and errors
				if (i->first == 1)
					Line.SetColor(sf::Color::Yellow);
				else if (i->first == 2)
					Line.SetColor(sf::Color::Red);

				// Set the positions
				Line.SetX(2);
				Line.SetY(LineY);

				// And Render!
				Window.Draw(Line);
				++LineCounter;
			}
			Window.Display();
			Window.SetView(Temp);
		}
	}
	return 0;
}

void terra::Engine::Message(const std::string &TheMessage){
	ConsoleLog.push_back(std::pair<unsigned int, std::string>(0, TheMessage));
}

void terra::Engine::ParseBoot(unsigned int &Width, unsigned int &Height, unsigned int &Framerate, std::string &Title, std::string &InitialLevel){
	// Open up the Boot file and parse it with RapidXML
	std::vector<char> Contents = terra::ReadFile(""res/cfg/Boot.cfg"");
	rapidxml::xml_document<> Boot;
	Boot.parse<0>(&Contents[0]);

	// Check for the root
	rapidxml::xml_node<> *Root = Boot.first_node(""config"");
	if (Root == nullptr || Root->type() != rapidxml::node_element){
		Error(""Boot file \""res/cfg/Boot.cfg\"" has no root node\n"");
		return;
	}

	// Parse the window properties
	rapidxml::xml_node<> *WindowAttributes = Root->first_node(""window"");
	if (WindowAttributes != nullptr && WindowAttributes->type() == rapidxml::node_element){
		// Read in the properties
		rapidxml::xml_node<> *WindowWidth = WindowAttributes->first_node(""width"");
		rapidxml::xml_node<> *WindowHeight = WindowAttributes->first_node(""height"");
		rapidxml::xml_node<> *WindowFramerate = WindowAttributes->first_node(""framerate"");
		rapidxml::xml_node<> *WindowTitle = WindowAttributes->first_node(""title"");

		// Translate strings into numbers
		if (WindowWidth != nullptr && WindowWidth->type() == rapidxml::node_element && WindowWidth->first_node()->type() == rapidxml::node_data){
			int Temp = atoi(WindowWidth->first_node()->value());
			Width = Temp > 0 ? Temp : Width;
		}
		if (WindowHeight != nullptr && WindowHeight->type() == rapidxml::node_element && WindowHeight->first_node()->type() == rapidxml::node_data){
			int Temp = atoi(WindowHeight->first_node()->value());
			Height = Temp > 0 ? Temp : Height;
		}
		if (WindowFramerate != nullptr && WindowFramerate->type() == rapidxml::node_element && WindowFramerate->first_node()->type() == rapidxml::node_data){
			int Temp = atoi(WindowFramerate->first_node()->value());
			Framerate = Temp > 0 ? Temp : Framerate;
		}
		if (WindowTitle != nullptr && WindowTitle->type() == rapidxml::node_element && WindowTitle->first_node()->type() == rapidxml::node_data)
			Title = WindowTitle->first_node()->value();
	}

	// We also need the initial level's filename
	if (Root->first_node(""level"") != nullptr && Root->first_node(""level"")->type() == rapidxml::node_element && Root->first_node(""level"")->first_node() != nullptr && Root->first_node(""level"")->first_node()->type() == rapidxml::node_data)
		InitialLevel = Root->first_node(""level"")->first_node()->value();
}

void terra::Engine::ParseCommandLine(const int argc, char *argv[], unsigned int &Width, unsigned int &Height){
	// Translate the command line arguments into a list
	std::list<std::string> ArgumentList;
	for (int i = 1; i < argc; ++i)
		ArgumentList.push_back(argv[i]);

	// Translate the commands into values
	for (auto i = ArgumentList.begin(); i != ArgumentList.end(); ++i){
		if (*i == ""-width""){
			int Temp = atoi((++i)->c_str());
			Width = Temp > 0 ? Temp : Width;
		}
		else if (*i == ""-height""){
			int Temp = atoi((++i)->c_str());
			Height = Temp > 0 ? Temp : Height;
		}
	}
}

void terra::Engine::ParseLayers(rapidxml::xml_node<> *Root){
	for (auto Layers = Root->first_node(""layers""); Layers != nullptr; Layers = Layers->next_sibling(""layers"")){
		// Skip invalid layers
		if (Layers->type() != rapidxml::node_element)
			continue;

		// Parse Tile Layers
		for (auto LayerIterator = Layers->first_node(""tiles""); LayerIterator != nullptr; LayerIterator = LayerIterator->next_sibling(""tiles"")){
			if (LayerIterator->type() != rapidxml::node_element)
				continue;
			ParseTileLayer(LayerIterator);
		}

		// Parse Object Layers
		for (auto LayerIterator = Layers->first_node(""objects""); LayerIterator != nullptr; LayerIterator = LayerIterator->next_sibling(""objects"")){
			if (LayerIterator->type() != rapidxml::node_element)
				continue;
			ParseObjectLayer(LayerIterator);
		}
	}
}

void terra::Engine::ParseLevel(){
	// Clear out the old level and tell the engine that the level has loaded (or at least tried to)
	for (auto i = Layers.begin(); i != Layers.end(); ++i)
		(*i)->Clear();
	LevelValues = DefaultLevelValues;
	NewLevel = false;

	// Read in the level file and parse it with RapidXML
	std::vector<char> Contents = terra::ReadFile(NextLevelName);
	rapidxml::xml_document<> Level;
	Level.parse<0>(&Contents[0]);

	// Check for the root node
	rapidxml::xml_node<> *LevelRoot = Level.first_node(""level"");
	if (LevelRoot == nullptr || LevelRoot->type() != rapidxml::node_element){
		Error(std::string(""Level file \"""") + NextLevelName + ""\"" has no root node\n"");
		return;
	}

	// Parse the level's values
	for (auto i = LevelRoot->first_attribute(); i != nullptr; i = i->next_attribute()){
		// Get the value properties
		std::string Name = i->name();
		std::string Value = i->value();

		// Validate that the value exists
		if (LevelValues.find(Name) == LevelValues.end()){
			Warning(std::string(""Level value of name \"""") + Name + ""\"" does not exist\n"");
			continue;
		}

		// Set the value
		LevelValues[Name] = Value;
	}

	// Begin parsing the layers that were registered in the project file
	for (auto i = NamedLayers.begin(); i != NamedLayers.end(); ++i){
		// Check if the layer exists
		rapidxml::xml_node<> *LayerIterator = LevelRoot->first_node(i->first.c_str());
		if (LayerIterator == nullptr || LayerIterator->type() != rapidxml::node_element)
			continue;

		// Parse the Tile Layers
		if (i->second->GetStoredType() == terra::Item::Tile)
			ParseLevelTileLayer(LayerIterator);

		// Parse the Object Layers
		if (i->second->GetStoredType() == terra::Item::Object)
			ParseLevelObjectLayer(LayerIterator);
	}
}

void terra::Engine::ParseLevelObjectLayer(rapidxml::xml_node<> *ObjectLayer){
	// Process each object in the layer
	for (auto Object = ObjectLayer->first_node(); Object != nullptr; Object = Object->next_sibling()){
		// Verify that the object is valid
		if (Object->type() != rapidxml::node_element || Object->first_attribute(""x"") == nullptr || Object->first_attribute(""y""))
			continue;

		// Verify that the object exists
		if (OgmoObjects.find(Object->name()) == OgmoObjects.end()){
			Warning(std::string(""Object of name \"""") + Object->name() + ""\"" does not exist\n"");
			continue;
		}

		// Parse the properties of the object
		terra::OgmoObject NewObject;
		NewObject.Name = Object->name();
		NewObject.Position = sf::Vector2f(atof(Object->first_attribute(""x"")->value()), atof(Object->first_attribute(""y"")->value()));
		if (NewObject.ResizableX && Object->first_attribute(""width"") != nullptr)
			NewObject.Size.x = atoi(Object->first_attribute(""width"")->value());
		if (NewObject.ResizableY && Object->first_attribute(""height"") != nullptr)
			NewObject.Size.y = atoi(Object->first_attribute(""height"")->value());

		// Parse the values of the object
		for (auto i = Object->first_attribute(); i != nullptr; i = i->next_attribute()){
			// Skip non-values
			if (i->name() == ""x"" || i->name() == ""y"" || i->name() == ""width"" || i->name() == ""height"")
				continue;

			// Get the properties
			std::string Name = i->name();
			std::string Value = i->value();

			// Verify that the value exists
			if (NewObject.Values.find(Name) == NewObject.Values.end()){
				Warning(std::string(""Value of name \"""") + Name + ""\"" does not exist\n"");
				continue;
			}

			// Update the value
			NewObject.Values[Name] = Value;
		}

		// Parse the object's nodes
		for (auto i = Object->first_node(""node""); i != nullptr; i = i->next_sibling(""node"")){
			// Validate the node
			if (i->type() != rapidxml::node_element || i->first_attribute(""x"") == nullptr || i->first_attribute(""y"") == nullptr)
				continue;

			// Add the node
			NewObject.Nodes.push_back(sf::Vector2f(atof(i->first_attribute(""x"")->value()), atof(i->first_attribute(""y"")->value())));
		}

		// Validate that the object is registered
		if (Callbacks.find(NewObject.Name) == Callbacks.end()){
			Warning(std::string(""Object of name\"""") + NewObject.Name + ""\"" is not registered\n"");
			continue;
		}

		// Insert the object
		NamedLayers[ObjectLayer->name()]->AddItem(Callbacks[NewObject.Name](NewObject));
	}
}

void terra::Engine::ParseLevelTileLayer(rapidxml::xml_node<> *TileLayer){
	// Give up if the tileset is needed but not given
	if (TileLayer->first_attribute(""set"") == nullptr && !OgmoTileLayers[TileLayer->name()].MultipleTilesets)
		return;

	// Prepare the tileset name (if needed)
	std::string Set;
	if (!OgmoTileLayers[TileLayer->name()].MultipleTilesets){
		Set = TileLayer->first_attribute(""set"")->value();
		if (OgmoTilesets.find(Set) == OgmoTilesets.end() || !GetTexture(Set))
			return;
	}

	// Read in the tile size (if needed)
	unsigned int TileWidth;
	unsigned int TileHeight;
	if (OgmoTileLayers[TileLayer->name()].ExportTileSize){
		if (TileLayer->first_attribute(""tileWidth"") == nullptr || TileLayer->first_attribute(""tileHeight"") == nullptr)
			return;
		TileWidth = atoi(TileLayer->first_attribute(""tileWidth"")->value());
		TileHeight = atoi(TileLayer->first_attribute(""tileHeight"")->value());
	}
	else if (!OgmoTileLayers[TileLayer->name()].MultipleTilesets){
		TileWidth = OgmoTilesets[Set].TileWidth;
		TileHeight = OgmoTilesets[Set].TileHeight;
	}

	// And now we parse the tiles
	for (auto TileIterator = TileLayer->first_node(""tile""); TileIterator != nullptr; TileIterator = TileIterator->next_sibling(""tile"")){
		// First check if the tile is valid
		if (TileIterator->type() != rapidxml::node_element || TileIterator->first_attribute(""x"") == nullptr || TileIterator->first_attribute(""y"") == nullptr)
			continue;

		// Now read in the position
		sf::Vector2f Position = sf::Vector2f(atof(TileIterator->first_attribute(""x"")->value()), atof(TileIterator->first_attribute(""y"")->value()));
		sf::Vector2<unsigned int> TilePosition;

		// Check if the needed information about tilesets is given or not (if needed)
		if (OgmoTileLayers[TileLayer->name()].MultipleTilesets){
			if (TileIterator->first_attribute(""set"") == nullptr)
				continue;
			Set = TileIterator->first_attribute(""set"")->value();
			if (OgmoTilesets.find(Set) == OgmoTilesets.end() || !GetTexture(Set))
				continue;
		}
		if (!OgmoTileLayers[TileLayer->name()].ExportTileSize && OgmoTileLayers[TileLayer->name()].MultipleTilesets){
			TileWidth = OgmoTilesets[Set].TileWidth;
			TileHeight = OgmoTilesets[Set].TileHeight;
		}

		// Parse the position of the tile in the tileset
		if (OgmoTileLayers[TileLayer->name()].ExportTileIDs){
			// Check if the tile id is given
			if (TileIterator->first_attribute(""id"") == nullptr)
				continue;

			// Parse some information such as the id number and the size of each tile id
			unsigned int ID = atoi(TileIterator->first_attribute(""id"")->value());
			unsigned int IDWidth = (GetTexture(Set)->GetWidth()-GetTexture(Set)->GetWidth()%TileWidth)/TileWidth;
			unsigned int IDHeight = (GetTexture(Set)->GetHeight()-GetTexture(Set)->GetHeight()%TileHeight)/TileHeight;

			// Ensure that the id isn't too large
			if (ID >= IDWidth*IDHeight)
				continue;

			// Finally, calculate the tile position
			TilePosition.x = ID%IDWidth*TileWidth;
			TilePosition.y = (ID-ID%IDWidth)/IDWidth*TileHeight;
		}
		else{
			// Check if the tile position is given
			if (TileIterator->first_attribute(""tx"") == nullptr || TileIterator->first_attribute(""ty"") == nullptr)
				continue;

			// We don't have to do math here like we did with ided tiles. Yay
			TilePosition.x = atoi(TileIterator->first_attribute(""tx"")->value());
			TilePosition.y = atoi(TileIterator->first_attribute(""ty"")->value());
		}

		// Prepare the tile for insertion
		terra::OgmoTile NextTile;
		NextTile.Tileset = Set;
		NextTile.TilePosition = TilePosition;
		NextTile.TileSize = sf::Vector2<unsigned int>(TileWidth, TileHeight);
		NextTile.Position = Position;

		// Insert the tile into the layer
		NamedLayers[TileLayer->name()]->AddItem(std::shared_ptr<terra::Item>(new terra::Tile(NextTile)));
	}
}

void terra::Engine::ParseObjects(rapidxml::xml_node<> *Root){
	// Just a wrapper to parse all object folders
	for (auto Folder = Root->first_node(""objects""); Folder != nullptr; Folder = Folder->next_sibling(""objects""))
		ParseObjectFolder(Folder);
}

void terra::Engine::ParseObjectFolder(rapidxml::xml_node<> *Folder){
	// Parse all subfolders
	for (auto NextFolder = Folder->first_node(""folder""); NextFolder != nullptr; NextFolder = NextFolder->next_sibling(""folder""))
		ParseObjectFolder(NextFolder);

	// Then parse all objects
	for (auto Object = Folder->first_node(""object""); Object != nullptr; Object = Object->next_sibling(""object"")){
		// Make sure the object is safe
		if (Object->type() != rapidxml::node_element || Object->first_attribute(""name"") == nullptr || Object->first_attribute(""width"") == nullptr || Object->first_attribute(""height"") == nullptr)
			continue;

		// Prepare the object for use in future object creations
		terra::OgmoObject NextObject;
		NextObject.Name = Object->first_attribute(""name"")->value();
		NextObject.Size = sf::Vector2<unsigned int>(atoi(Object->first_attribute(""width"")->value()), atoi(Object->first_attribute(""height"")->value()));
		bool ResizableX = false;
		bool ResizableY = false;
		if (Object->first_attribute(""resizableX"") != nullptr && Object->first_attribute(""resizableX"")->value() == ""true"")
			ResizableX = true;
		if (Object->first_attribute(""resizableY"") != nullptr && Object->first_attribute(""resizableY"")->value() == ""true"")
			ResizableY = true;
		NextObject.ResizableX = ResizableX;
		NextObject.ResizableY = ResizableY;

		// Parse the default values
		for (auto ValueContainer = Object->first_node(""values""); ValueContainer != nullptr; ValueContainer = ValueContainer->next_sibling(""values"")){
			// Verify that the value container is valid
			if (ValueContainer->type() != rapidxml::node_element)
				continue;

			// Parse all values
			for (auto Value = ValueContainer->first_node(); Value != nullptr; Value = Value->next_sibling()){
				// Validate the value
				if (Value->type() != rapidxml::node_element || (Value->name() != ""boolean"" && Value->name() != ""integer"" && Value->name() != ""number"" && Value->name() != ""string"" && Value->name() != ""text"") || Value->first_attribute(""name"") == nullptr || Value->first_attribute(""default"") == nullptr)
					continue;

				// Get the value's properties
				std::string Name = Value->first_attribute(""name"")->value();
				std::string Default = Value->first_attribute(""default"")->value();

				// Validate that it isn't a duplicate
				if (NextObject.Values.find(Name) != NextObject.Values.end()){
					Warning(std::string(""Value of name \"""") + Name + ""\"" already exists\n"");
					continue;
				}

				// Add the value to the default values
				NextObject.Values[Name] = Default;
				NextObject.ValueTypes[Name] = Value->name();
			}
		}

		// Make sure the object isn't duplicated
		if (OgmoObjects.find(NextObject.Name) != OgmoObjects.end()){
			Warning(std::string(""Object of name \"""") + NextObject.Name + ""\"" already exists\n"");
			continue;
		}

		// Make sure the object is registered
		if (Callbacks.find(NextObject.Name) == Callbacks.end()){
			Warning(std::string(""Object of name\"""") + NextObject.Name + ""\"" hasn't been registered\n"");
			continue;
		}

		// And insert
		OgmoObjects[NextObject.Name] = NextObject;
	}
}

void terra::Engine::ParseObjectLayer(rapidxml::xml_node<> *ObjectLayer){
	// Verify that the layer is valid
	if (ObjectLayer->first_attribute(""name"") == nullptr)
		return;

	// Extract the name
	std::string Name = ObjectLayer->first_attribute(""name"")->value();

	// Verify that the layer isn't a duplicate
	if (NamedLayers.find(Name) != NamedLayers.end()){
		Warning(std::string(""Layer of name \"""") + Name + ""\"" already exists\n"");
		return;
	}

	// Store the new layer
	std::shared_ptr<terra::Layer> NewLayer(new terra::Layer(terra::Item::Object));
	NamedLayers[Name] = NewLayer;
	Layers.push_back(NewLayer);
}

void terra::Engine::ParseProject(){
	// Read the project file in and parse it with RapidXML
	std::vector<char> Contents = terra::ReadFile(""res/cfg/Levels.oep"");
	rapidxml::xml_document<> Project;
	Project.parse<0>(&Contents[0]);

	// Get the project root
	rapidxml::xml_node<> *ProjectRoot = Project.first_node(""project"");

	// Make sure the project is valid
	if (ProjectRoot == nullptr || ProjectRoot->type() != rapidxml::node_element){
		Error(""Project file \""res/cfg/Levels.oep\"" has no root node\n"");
		return;
	}

	// Parse default values
	for (auto ValueContainer = ProjectRoot->first_node(""values""); ValueContainer != nullptr; ValueContainer = ValueContainer->next_sibling(""values"")){
		// Verify that the value container is valid
		if (ValueContainer->type() != rapidxml::node_element)
			continue;

		// Parse all values
		for (auto Value = ValueContainer->first_node(); Value != nullptr; Value = Value->next_sibling()){
			// Validate the value
			if (Value->type() != rapidxml::node_element || (Value->name() != ""boolean"" && Value->name() != ""integer"" && Value->name() != ""number"" && Value->name() != ""string"" && Value->name() != ""text"") || Value->first_attribute(""name"") == nullptr || Value->first_attribute(""default"") == nullptr)
				continue;

			// Get the value's properties
			std::string Name = Value->first_attribute(""name"")->value();
			std::string Default = Value->first_attribute(""default"")->value();

			// Validate that it isn't a duplicate
			if (DefaultLevelValues.find(Name) != DefaultLevelValues.end()){
				Warning(std::string(""Level value of name \"""") + Name + ""\"" already exists\n"");
				continue;
			}

			// Add the value to the default values
			DefaultLevelValues[Name] = Default;
			ValueTypes[Name] = Value->name();
		}
	}

	// Parse everything
	ParseTilesets(ProjectRoot);
	ParseObjects(ProjectRoot);
	ParseLayers(ProjectRoot);
}

void terra::Engine::ParseTileLayer(rapidxml::xml_node<> *TileLayer){
	// Validate the layer
	if (TileLayer->first_attribute(""name"") == nullptr)
		return;

	// Some Initial Values
	std::string Name = TileLayer->first_attribute(""name"")->value();
	bool MultipleTilesets = false;
	bool ExportTileSize = false;
	bool ExportTileIDs = false;

	// Get the optional values
	if (TileLayer->first_attribute(""multipleTilesets"") != nullptr && TileLayer->first_attribute(""multipleTilesets"")->value() == ""true"")
		MultipleTilesets = true;
	if (TileLayer->first_attribute(""exportTileSize"") != nullptr && TileLayer->first_attribute(""exportTileSize"")->value() == ""true"")
		ExportTileSize = true;
	if (TileLayer->first_attribute(""exportTileIDs"") != nullptr && TileLayer->first_attribute(""exportTileIDs"")->value() == ""true"")
		ExportTileIDs = true;

	// Ensure that the layer isn't a duplicate
	if (NamedLayers.find(Name) != NamedLayers.end()){
		Warning(std::string(""Layer of name \"""") + Name + ""\"" already exists\n"");
		return;
	}

	// Prepare the new layer for storage
	terra::OgmoTileLayer  [MASK] ;
	 [MASK] .MultipleTilesets = MultipleTilesets;
	 [MASK] .ExportTileSize = ExportTileSize;
	 [MASK] .ExportTileIDs = ExportTileIDs;

	// Store the new layer
	OgmoTileLayers[Name] =  [MASK] ;
	std::shared_ptr<terra::Layer> NewLayer(new terra::Layer(terra::Item::Tile));
	NamedLayers[Name] = NewLayer;
	Layers.push_back(NewLayer);
}

void terra::Engine::ParseTilesets(rapidxml::xml_node<> *Root){
	// Parse the working directory
	std::string WorkingDirectory = ""res/cfg/"";
	for (auto Settings = Root->first_node(""settings""); Settings != nullptr; Settings = Settings->next_sibling(""settings"")){
		// Validate the settings node
		if (Settings->type() != rapidxml::node_element)
			continue;

		// Hunt for the working directory
		bool Found = false;
		for (auto WorkingDirectoryNode = Settings->first_node(""workingDirectory""); WorkingDirectoryNode != nullptr; WorkingDirectoryNode = WorkingDirectoryNode->next_sibling(""workingDirectory"")){
			// Validate the Working Directory Node
			if (WorkingDirectoryNode->type() != rapidxml::node_element || WorkingDirectoryNode->first_node() == nullptr || WorkingDirectoryNode->first_node()->type() != rapidxml::node_data)
				continue;

			// Update the working directory then evacuate
			WorkingDirectory += WorkingDirectoryNode->first_node()->value();
			Found = true;
			break;
		}
		if (Found)
			break;
	}

	// Parse the tilesets
	for (auto i = Root->first_node(""tilesets""); i != nullptr; i = i->next_sibling(""tilesets"")){
		// Validate the tileset container node
		if (i->type() != rapidxml::node_element)
			continue;

		// Parse each tileset in the list
		for (auto j = i->first_node(""tileset""); j != nullptr; j = j->next_sibling(""tileset"")){
			// Validate the tileset
			if (j->type() != rapidxml::node_element || j->first_attribute(""name"") == nullptr || j->first_attribute(""image"") == nullptr || j->first_attribute(""tileWidth"") == nullptr || j->first_attribute(""tileHeight"") == nullptr)
				continue;

			// Parse the values of the tileset
			std::string TilesetName = j->first_attribute(""name"")->value();
			std::string TilesetImage = WorkingDirectory + j->first_attribute(""image"")->value();
			unsigned int TileWidth = atoi(j->first_attribute(""tileWidth"")->value());
			unsigned int TileHeight = atoi(j->first_attribute(""tileHeight"")->value());

			// Verify that the tileset isn't a duplicate
			if (OgmoTilesets.find(TilesetName) != OgmoTilesets.end()){
				Warning(std::string(""Tileset of name \"""") + TilesetName + ""\"" already exists\n"");
				continue;
			}

			// Prepare the tileset for storage
			terra::OgmoTileset NewTileset;
			NewTileset.Image = TilesetImage;
			NewTileset.TileWidth = TileWidth;
			NewTileset.TileHeight = TileHeight;

			// Store the tileset
			OgmoTilesets[TilesetName] = NewTileset;
		}
	}
}

void terra::Engine::RegisterObject(std::string Name, std::shared_ptr<terra::Item> (*Callback)(const terra::OgmoObject &)){
	if (Callbacks.find(Name) != Callbacks.end()){
		Warning(std::string(""Object with name \"""") + Name + ""\"" already registered\n"");
		return;
	}
	Callbacks.insert(std::pair<std::string, std::shared_ptr<terra::Item> (*)(const terra::OgmoObject &)>(Name, Callback));
}

void terra::Engine::Warning(const std::string &WarningMessage){
	ConsoleLog.push_back(std::pair<unsigned int, std::string>(1, WarningMessage));
}

terra::Engine::~Engine(){
}
",NewTileLayer
928,"/***************************************************************************
 *   Copyright (c) 2020-present Bitplane AG Zuerich                        *
 *                                                                         *
 *   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 imp   *
 *   See the License for the specific language governing permissions and   *
 *   limitations under the License.                                        *
 ***************************************************************************/
#include ""bpBCommandLine.h""

#define bpCommandLine bpBCommandLine

#include ""ImarisWriter/interface/bpImageConverter.h""

#include <random>

#if defined(_WIN32)
#include <windows.h>
#elif defined(__APPLE__)
#include <mach/mach.h>
#include <mach/mach_time.h>
#else
#include <time.h>
#endif

#include <fstream>
#include <iostream>
#include <map>
#include <list>

#include <string>
#include <cstdint>
#include <chrono>
#include <algorithm>
#include <random>

void RecordProgress(bpFloat aProgress, bpUInt64 aTotalBytesWritten, int& aOldProgress)
{
  int vProgress = (int)(aProgress * 100);
  if (vProgress - aOldProgress < 5) {
    return;
  }
  if (aTotalBytesWritten < 10 * 1024 * 1024) {
    std::cout << ""Progress: "" << vProgress << ""% ["" << (aTotalBytesWritten / 1024) << ""KB]"" << std::endl;
  }
  else {
    std::cout << ""Progress: "" << vProgress << ""% ["" << (aTotalBytesWritten / (1024 * 1024)) << ""MB]"" << std::endl;
  }
  aOldProgress = vProgress;
}

bpUInt64 PerformanceCounter()
{
#if defined(_WIN32)
  LARGE_INTEGER vTime;
  QueryPerformanceCounter(&vTime);
  return static_cast<bpUInt64>(vTime.QuadPart);
#else
  struct timespec  [MASK] ;
  clock_gettime(CLOCK_MONOTONIC, & [MASK] );
  return  [MASK] .tv_sec +  [MASK] .tv_nsec / 1000000000.0;
#endif
}

bpUInt64 PerformanceFrequency()
{
#if defined(_WIN32)
  LARGE_INTEGER vFrequency;
  QueryPerformanceFrequency(&vFrequency);
  return static_cast<bpUInt64>(vFrequency.QuadPart);
#else
  return 1;
#endif
}

int main(int argc, char* argv[])
{

  try {
    bpCommandLine vCommandLine(0, 1);
    vCommandLine.allowArgument(""sizex"", ""Image Size X (default 1024)"", 1);
    vCommandLine.allowArgument(""sizey"", ""Image Size Y (default 1024)"", 1);
    vCommandLine.allowArgument(""sizez"", ""Image Size Z (default 1)"", 1);
    vCommandLine.allowArgument(""sizet"", ""Image Size T (default 1)"", 1);
    vCommandLine.allowArgument(""sizec"", ""Image Size C (default 1)"", 1);
    vCommandLine.allowArgument(""threads"", ""Number of Threads (default 8)"", 1);
    vCommandLine.allowArgument(""compression"", ""Compression type and level (default 2)"", 1);
    vCommandLine.allowArgument(""logfile"", ""Log File Path"", 1);
    vCommandLine.allowArgument(""type"", ""DataType 8bit or 16bit"", 1);
    vCommandLine.allowArgument(""outputpath"", ""Set the output folder"", 1);
    vCommandLine.allowArgument(""randseed"", ""Fix seed for random number to reproduce results"", 1);
    vCommandLine.allowArgument(""z1"", ""Force block size Z = 1 (optional flag, no argument values)"", 0);

    vCommandLine.Parse(argc, argv);

    bpString vFileName = vCommandLine.GetOutFileName();
    if (vFileName.empty()) {
      throw bpArgumentException(""No OutFile specified."");
    }

    std::string vOutpath = """";
    if (vCommandLine.Found(""outputpath"")) {
      vCommandLine.GetValue(""outputpath"", vOutpath);
    }

    bpString vOutputFilePath = vOutpath + ""/"" + vFileName;

    bpSize vSizeX(1024);
    if (vCommandLine.Found(""sizex"")) {
      vCommandLine.GetValue(""sizex"", vSizeX);
    }
    else {
      std::cerr << ""Using default sizex 1024\n"";
    }
    bpSize vSizeY(1024);
    if (vCommandLine.Found(""sizey"")) {
      vCommandLine.GetValue(""sizey"", vSizeY);
    }
    else {
      std::cerr << ""Using default sizey 1024\n"";
    }
    bpSize vSizeZ(1);
    if (vCommandLine.Found(""sizez"")) {
      vCommandLine.GetValue(""sizez"", vSizeZ);
    }
    else {
      std::cerr << ""Using default sizez 1\n"";
    }
    bpSize vSizeT(1);
    if (vCommandLine.Found(""sizet"")) {
      vCommandLine.GetValue(""sizet"", vSizeT);
    }
    else {
      std::cerr << ""Using default sizet 1\n"";
    }
    bpSize vSizeC(1);
    if (vCommandLine.Found(""sizec"")) {
      vCommandLine.GetValue(""sizec"", vSizeC);
    }
    else {
      std::cerr << ""Using default sizec 1\n"";
    }

    bpSize vNumberOfThreads(8);
    if (vCommandLine.Found(""threads"")) {
      vCommandLine.GetValue(""threads"", vNumberOfThreads);
    }
    else {
      std::cerr << ""Using default "" << vNumberOfThreads << "" threads\n"";
    }

    bpSize vCompression(2);
    if (vCommandLine.Found(""compression"")) {
      vCommandLine.GetValue(""compression"", vCompression);
    }
    else {
      std::cerr << ""Using default compression level "" << vCompression << ""\n"";
    }

    bpString vLogFilePath;
    if (vCommandLine.Found(""logfile"")) {
      vCommandLine.GetValue(""logfile"", vLogFilePath);
    }

    bpString vDataType(""16bit"");
    if (vCommandLine.Found(""type"")) {
      vCommandLine.GetValue(""type"", vDataType);
    }
    else {
      std::cerr << ""Using default type 16bit\n"";
    }

    bool vForceFileBlockSizeZ1 = vCommandLine.Found(""z1"");

    bpUInt32 vRandSeed(0);
    if (vCommandLine.Found(""randseed"")) {
      bpSize vValue(0);
      vCommandLine.GetValue(""randseed"", vValue);
      vRandSeed = (bpUInt32)vValue;
    }
    else {
      std::random_device rd;
      vRandSeed = rd();
      std::cerr << ""Using random seed "" << vRandSeed << ""\n"";
    }

    int vProgress = -5;
    bpConverterTypes::tProgressCallback vProgressCallback = [&vProgress](bpFloat aProgress, bpUInt64 aTotalBytesWritten) {
      RecordProgress(aProgress, aTotalBytesWritten, vProgress);
    };

    bpConverterTypes::cOptions vOptions;
    vOptions.mForceFileBlockSizeZ1 = vForceFileBlockSizeZ1;
    vOptions.mNumberOfThreads = vNumberOfThreads;
    vOptions.mCompressionAlgorithmType = bpConverterTypes::eCompressionAlgorithmGzipLevel2;
    bpConverterTypes::tCompressionAlgorithmType vAlgorithmType = (bpConverterTypes::tCompressionAlgorithmType) vCompression;
    switch (vAlgorithmType) {
    case bpConverterTypes::eCompressionAlgorithmGzipLevel1:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel2:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel3:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel4:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel5:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel6:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel7:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel8:
    case bpConverterTypes::eCompressionAlgorithmGzipLevel9:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel1:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel2:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel3:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel4:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel5:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel6:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel7:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel8:
    case bpConverterTypes::eCompressionAlgorithmShuffleGzipLevel9:
    case bpConverterTypes::eCompressionAlgorithmLZ4:
    case bpConverterTypes::eCompressionAlgorithmShuffleLZ4:
      vOptions.mCompressionAlgorithmType = vAlgorithmType;
      break;
    default:
      vOptions.mCompressionAlgorithmType = bpConverterTypes::eCompressionAlgorithmNone;
    }
    bpConverterTypes::tSize5D vImageSize(bpConverterTypes::X, vSizeX, bpConverterTypes::Y, vSizeY, bpConverterTypes::Z, vSizeZ, bpConverterTypes::C, vSizeC, bpConverterTypes::T, vSizeT);

    if (vDataType == bpString(""16bit"")) {
      std::cout << ""Starting writer test "" << "" using "" << vNumberOfThreads << "" thread(s)""<< std::endl;

      bpConverterTypes::cImageExtent vImageExtent{ 0,0,0,10,10,10 };
      bpConverterTypes::tDataType vImageDataType = bpConverterTypes::bpUInt16Type;
      bpConverterTypes::tDimensionSequence5D vDimensionSequence(bpConverterTypes::X, bpConverterTypes::Y, bpConverterTypes::Z, bpConverterTypes::C, bpConverterTypes::T);
      //bpConverterTypes::tDimensionSequence5D vDimensionSequence(bpConverterTypes::X, bpConverterTypes::Y, bpConverterTypes::Z, bpConverterTypes::C, bpConverterTypes::T);
      bpConverterTypes::tSize5D vSample(bpConverterTypes::X, 1, bpConverterTypes::Y, 1, bpConverterTypes::Z, 1, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      //bpConverterTypes::tSize5D vInputBlockSize5D(bpConverterTypes::X, 256, bpConverterTypes::Y, 64, bpConverterTypes::Z, 32, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      bpConverterTypes::tSize5D vInputBlockSize5D(bpConverterTypes::X, 256, bpConverterTypes::Y, 256, bpConverterTypes::Z, 8, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      //bpConverterTypes::tSize5D vInputBlockSize5D(bpConverterTypes::X, 512, bpConverterTypes::Y, 512, bpConverterTypes::Z, 1, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      bpSize vInputBlockSize = vInputBlockSize5D[bpConverterTypes::X] * vInputBlockSize5D[bpConverterTypes::Y] * vInputBlockSize5D[bpConverterTypes::Z] * vInputBlockSize5D[bpConverterTypes::C] * vInputBlockSize5D[bpConverterTypes::T];
      bpSize vNBlocksX = (vImageSize[bpConverterTypes::X] - 1) / vInputBlockSize5D[bpConverterTypes::X] + 1;
      bpSize vNBlocksY = (vImageSize[bpConverterTypes::Y] - 1) / vInputBlockSize5D[bpConverterTypes::Y] + 1;
      bpSize vNBlocksZ = (vImageSize[bpConverterTypes::Z] - 1) / vInputBlockSize5D[bpConverterTypes::Z] + 1;
      bpSize vNBlocksC = (vImageSize[bpConverterTypes::C] - 1) / vInputBlockSize5D[bpConverterTypes::C] + 1;
      bpSize vNBlocksT = (vImageSize[bpConverterTypes::T] - 1) / vInputBlockSize5D[bpConverterTypes::T] + 1;
      bpSize vImageSizePixels = vImageSize[bpConverterTypes::X] * vImageSize[bpConverterTypes::Y] * vImageSize[bpConverterTypes::Z] * vImageSize[bpConverterTypes::C] * vImageSize[bpConverterTypes::T];
      bpSize vImageSizeInMB = vImageSizePixels * sizeof(bpUInt16) / 1024 / 1024 ;
      bpString vOutputFile = vOutputFilePath;

      bpUInt16* vFileBlock = new bpUInt16[2 * vInputBlockSize];
      std::mt19937 mt(vRandSeed);
      std::normal_distribution<> dist(100.0, 40.0);
      std::uniform_int_distribution<> uniform(0, vInputBlockSize);
      double vPrevious = dist(mt);
      bpFloat vCorrelationCoefficient = 0.7f;
      for (bpSize vVoxelIndex = 0; vVoxelIndex < 2 * vInputBlockSize; ++vVoxelIndex) {
        double vRandom = (1 - vCorrelationCoefficient) * dist(mt) + vCorrelationCoefficient * vPrevious;
        vFileBlock[vVoxelIndex] = vRandom > 0 ? (vRandom < (1 << 12) ? vRandom : (1<<12)) : 0;
      }
      bpUInt64 vFrequency = PerformanceFrequency();
      bpUInt64 vStartTime = 0;
      bpUInt64 vEndTime = vStartTime;
      bpSize vTimeInMilliSeconds = 0;

      {
        std::cout << ""Input block size XYZCT: "" << vInputBlockSize5D[bpConverterTypes::X] << "" "" << vInputBlockSize5D[bpConverterTypes::Y] << "" "" <<
          vInputBlockSize5D[bpConverterTypes::Z] << "" "" << vInputBlockSize5D[bpConverterTypes::C] << "" "" << vInputBlockSize5D[bpConverterTypes::T] << std::endl;

        vStartTime = PerformanceCounter();
        bpImageConverter<bpUInt16> vImageConverter(
          vImageDataType, vImageSize, vSample, vDimensionSequence, vInputBlockSize5D,
          vOutputFile, vOptions, ""ImarisWriterTest"", ""1.0"", vProgressCallback);
        bpConverterTypes::tIndex5D vBlockIndex(bpConverterTypes::X, 0, bpConverterTypes::Y, 0, bpConverterTypes::Z, 0, bpConverterTypes::C, 0, bpConverterTypes::T, 0);
        for (bpSize vBlockIndexT = 0; vBlockIndexT < vNBlocksT; vBlockIndexT++) {
          vBlockIndex[bpConverterTypes::T] = vBlockIndexT;
          for (bpSize vBlockIndexC = 0; vBlockIndexC < vNBlocksC; vBlockIndexC++) {
            vBlockIndex[bpConverterTypes::C] = vBlockIndexC;
            for (bpSize vBlockIndexZ = 0; vBlockIndexZ < vNBlocksZ; vBlockIndexZ++) {
              vBlockIndex[bpConverterTypes::Z] = vBlockIndexZ;
              for (bpSize vBlockIndexY = 0; vBlockIndexY < vNBlocksY; vBlockIndexY++) {
                vBlockIndex[bpConverterTypes::Y] = vBlockIndexY;
                for (bpSize vBlockIndexX = 0; vBlockIndexX < vNBlocksX; vBlockIndexX++) {
                  vBlockIndex[bpConverterTypes::X] = vBlockIndexX;
                  bpSize vRandomOffset = uniform(mt);
                  vImageConverter.CopyBlock(vFileBlock + vRandomOffset, vBlockIndex);
                }
              }
            }
          }
        }

        bpConverterTypes::tColorInfoVector vColorInfoPerChannel(vImageSize[bpConverterTypes::C]);
        bpConverterTypes::tTimeInfoVector vTimeInfoPerTimePoint;
        bpConverterTypes::tParameters vParameters;
        vParameters[""Image""][""ImageSizeInMB""] = vImageSizeInMB;
        vImageConverter.Finish(vImageExtent, vParameters, vTimeInfoPerTimePoint, vColorInfoPerChannel, false);

        vEndTime = PerformanceCounter();
        vTimeInMilliSeconds = (vEndTime - vStartTime) * 1000 / vFrequency;
      }

      std::cout << ""Writer: "" << ""  MB: "" << vImageSizeInMB << ""     Time[ms]: "" << vTimeInMilliSeconds << ""\n"";

      delete[] vFileBlock;

      //Sleep(500);
    } else
    if (vDataType == bpString(""8bit"")) {
      std::cout << ""Starting writer test "" << "" using "" << vNumberOfThreads << "" thread(s)"" << std::endl;

      bpConverterTypes::cImageExtent vImageExtent{ 0,0,0,10,10,10 };
      bpConverterTypes::tDataType vImageDataType = bpConverterTypes::bpUInt8Type;
      bpConverterTypes::tDimensionSequence5D vDimensionSequence(bpConverterTypes::X, bpConverterTypes::Y, bpConverterTypes::Z, bpConverterTypes::C, bpConverterTypes::T);
      //bpConverterTypes::tDimensionSequence5D vDimensionSequence(bpConverterTypes::X, bpConverterTypes::Y, bpConverterTypes::Z, bpConverterTypes::C, bpConverterTypes::T);
      bpConverterTypes::tSize5D vSample(bpConverterTypes::X, 1, bpConverterTypes::Y, 1, bpConverterTypes::Z, 1, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      //bpConverterTypes::tSize5D vInputBlockSize5D(bpConverterTypes::X, 256, bpConverterTypes::Y, 64, bpConverterTypes::Z, 32, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      bpConverterTypes::tSize5D vInputBlockSize5D(bpConverterTypes::X, 512, bpConverterTypes::Y, 512, bpConverterTypes::Z, 1, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      bpSize vInputBlockSize = vInputBlockSize5D[bpConverterTypes::X] * vInputBlockSize5D[bpConverterTypes::Y] * vInputBlockSize5D[bpConverterTypes::Z] * vInputBlockSize5D[bpConverterTypes::C] * vInputBlockSize5D[bpConverterTypes::T];
      bpSize vNBlocksX = (vImageSize[bpConverterTypes::X] - 1) / vInputBlockSize5D[bpConverterTypes::X] + 1;
      bpSize vNBlocksY = (vImageSize[bpConverterTypes::Y] - 1) / vInputBlockSize5D[bpConverterTypes::Y] + 1;
      bpSize vNBlocksZ = (vImageSize[bpConverterTypes::Z] - 1) / vInputBlockSize5D[bpConverterTypes::Z] + 1;
      bpSize vNBlocksC = (vImageSize[bpConverterTypes::C] - 1) / vInputBlockSize5D[bpConverterTypes::C] + 1;
      bpSize vNBlocksT = (vImageSize[bpConverterTypes::T] - 1) / vInputBlockSize5D[bpConverterTypes::T] + 1;
      bpSize vNBlocks = vNBlocksX * vNBlocksY * vNBlocksZ * vNBlocksC * vNBlocksT;
      bpSize vImageSizePixels = vImageSize[bpConverterTypes::X] * vImageSize[bpConverterTypes::Y] * vImageSize[bpConverterTypes::Z] * vImageSize[bpConverterTypes::C] * vImageSize[bpConverterTypes::T];
      bpSize vImageSizeInMB = vImageSizePixels * sizeof(bpUInt8) / 1024 / 1024;
      bpString vOutputFile = vOutputFilePath;

      bpUInt8* vFileBlock = new bpUInt8[2 * vInputBlockSize];
      std::mt19937 mt(vRandSeed);
      std::normal_distribution<> dist(100.0, 40.0);
      std::uniform_int_distribution<> uniform(0, vInputBlockSize);
      double vPrevious = dist(mt);
      bpFloat vCorrelationCoefficient = 0.7f;
      for (bpSize vVoxelIndex = 0; vVoxelIndex < 2 * vInputBlockSize; ++vVoxelIndex) {
        double vRandom = (1 - vCorrelationCoefficient) * dist(mt) + vCorrelationCoefficient * vPrevious;
        vFileBlock[vVoxelIndex] = vRandom > 0 ? (vRandom < (1 << 12) ? vRandom : (1 << 12)) : 0;
      }
      bpUInt64 vFrequency = PerformanceFrequency();
      bpUInt64 vStartTime = 0;
      bpUInt64 vEndTime = vStartTime;
      bpSize vTimeInMilliSeconds = 0;

      {
        std::cout << ""Input block size XYZCT: "" << vInputBlockSize5D[bpConverterTypes::X] << "" "" << vInputBlockSize5D[bpConverterTypes::Y] << "" "" <<
          vInputBlockSize5D[bpConverterTypes::Z] << "" "" << vInputBlockSize5D[bpConverterTypes::C] << "" "" << vInputBlockSize5D[bpConverterTypes::T] << std::endl;

        vStartTime = PerformanceCounter();
        bpImageConverter<bpUInt8> vImageConverter(
          vImageDataType, vImageSize, vSample, vDimensionSequence, vInputBlockSize5D,
          vOutputFile, vOptions, ""ImarisWriterTest"", ""1.0"", vProgressCallback);
        bpConverterTypes::tIndex5D vBlockIndex(bpConverterTypes::X, 0, bpConverterTypes::Y, 0, bpConverterTypes::Z, 0, bpConverterTypes::C, 0, bpConverterTypes::T, 0);
        for (bpSize vIndex = 0; vIndex < vNBlocks; vIndex++) {
          bpSize vRandomOffset = uniform(mt);
          vImageConverter.CopyBlock(vFileBlock + vRandomOffset, vBlockIndex);
        }

        bpConverterTypes::tColorInfoVector vColorInfoPerChannel;
        bpConverterTypes::tTimeInfoVector vTimeInfoPerTimePoint;
        bpConverterTypes::tParameters vParameters;

        for (bpSize vChannelId = 0; vChannelId < vImageSize[bpConverterTypes::C]; ++vChannelId) {
          vColorInfoPerChannel.push_back(bpConverterTypes::cColorInfo());
        }
        vImageConverter.Finish(vImageExtent, vParameters, vTimeInfoPerTimePoint, vColorInfoPerChannel, false);

        vEndTime = PerformanceCounter();
        vTimeInMilliSeconds = (vEndTime - vStartTime) * 1000 / vFrequency;
      }

      std::cout << ""Writer: "" << ""  MB: "" << vImageSizeInMB << ""     Time[ms]: "" << vTimeInMilliSeconds << ""\n"";

      delete[] vFileBlock;

      //Sleep(500);
    } else
    if (vDataType == bpString(""32bit"")) {
      std::cout << ""Starting writer test ""  << "" using "" << vNumberOfThreads << "" thread(s)"" << std::endl;

      bpConverterTypes::cImageExtent vImageExtent{ 0,0,0,10,10,10 };
      bpConverterTypes::tDataType vImageDataType = bpConverterTypes::bpUInt32Type;
      bpConverterTypes::tDimensionSequence5D vDimensionSequence(bpConverterTypes::X, bpConverterTypes::Y, bpConverterTypes::Z, bpConverterTypes::C, bpConverterTypes::T);
      //bpConverterTypes::tDimensionSequence5D vDimensionSequence(bpConverterTypes::X, bpConverterTypes::Y, bpConverterTypes::Z, bpConverterTypes::C, bpConverterTypes::T);
      bpConverterTypes::tSize5D vSample(bpConverterTypes::X, 1, bpConverterTypes::Y, 1, bpConverterTypes::Z, 1, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      //bpConverterTypes::tSize5D vInputBlockSize5D(bpConverterTypes::X, 256, bpConverterTypes::Y, 64, bpConverterTypes::Z, 32, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      bpConverterTypes::tSize5D vInputBlockSize5D(bpConverterTypes::X, 512, bpConverterTypes::Y, 512, bpConverterTypes::Z, 1, bpConverterTypes::C, 1, bpConverterTypes::T, 1);
      bpSize vInputBlockSize = vInputBlockSize5D[bpConverterTypes::X] * vInputBlockSize5D[bpConverterTypes::Y] * vInputBlockSize5D[bpConverterTypes::Z] * vInputBlockSize5D[bpConverterTypes::C] * vInputBlockSize5D[bpConverterTypes::T];
      bpSize vNBlocksX = (vImageSize[bpConverterTypes::X] - 1) / vInputBlockSize5D[bpConverterTypes::X] + 1;
      bpSize vNBlocksY = (vImageSize[bpConverterTypes::Y] - 1) / vInputBlockSize5D[bpConverterTypes::Y] + 1;
      bpSize vNBlocksZ = (vImageSize[bpConverterTypes::Z] - 1) / vInputBlockSize5D[bpConverterTypes::Z] + 1;
      bpSize vNBlocksC = (vImageSize[bpConverterTypes::C] - 1) / vInputBlockSize5D[bpConverterTypes::C] + 1;
      bpSize vNBlocksT = (vImageSize[bpConverterTypes::T] - 1) / vInputBlockSize5D[bpConverterTypes::T] + 1;
      bpSize vNBlocks = vNBlocksX * vNBlocksY * vNBlocksZ * vNBlocksC * vNBlocksT;
      bpSize vImageSizePixels = vImageSize[bpConverterTypes::X] * vImageSize[bpConverterTypes::Y] * vImageSize[bpConverterTypes::Z] * vImageSize[bpConverterTypes::C] * vImageSize[bpConverterTypes::T];
      bpSize vImageSizeInMB = vImageSizePixels * sizeof(bpUInt32) / 1024 / 1024;
      bpString vOutputFile = vOutputFilePath;

      bpUInt32* vFileBlock = new bpUInt32[2 * vInputBlockSize];
      std::mt19937 mt(vRandSeed);
      std::normal_distribution<> dist(3000.0, 400.0);
      std::uniform_int_distribution<> uniform(0, vInputBlockSize);
      double vPrevious = dist(mt);
      bpFloat vCorrelationCoefficient = 0.7f;
      for (bpSize vVoxelIndex = 0; vVoxelIndex < 2 * vInputBlockSize; ++vVoxelIndex) {
        double vRandom = (1 - vCorrelationCoefficient) * dist(mt) + vCorrelationCoefficient * vPrevious;
        vFileBlock[vVoxelIndex] = vRandom > 0 ? (vRandom < (1 << 12) ? vRandom : (1 << 12)) : 0;
      }
      bpUInt64 vFrequency = PerformanceFrequency();
      bpUInt64 vStartTime = 0;
      bpUInt64 vEndTime = vStartTime;
      bpSize vTimeInMilliSeconds = 0;

      {
        std::cout << ""Input block size XYZCT: "" << vInputBlockSize5D[bpConverterTypes::X] << "" "" << vInputBlockSize5D[bpConverterTypes::Y] << "" "" <<
          vInputBlockSize5D[bpConverterTypes::Z] << "" "" << vInputBlockSize5D[bpConverterTypes::C] << "" "" << vInputBlockSize5D[bpConverterTypes::T] << std::endl;

        vStartTime = PerformanceCounter();
        bpImageConverter<bpUInt32> vImageConverter(
          vImageDataType, vImageSize, vSample, vDimensionSequence, vInputBlockSize5D,
          vOutputFile, vOptions, ""ImarisWriterTest"", ""1.0"", vProgressCallback);
        bpConverterTypes::tIndex5D vBlockIndex(bpConverterTypes::X, 0, bpConverterTypes::Y, 0, bpConverterTypes::Z, 0, bpConverterTypes::C, 0, bpConverterTypes::T, 0);
        for (bpSize vIndex = 0; vIndex < vNBlocks; vIndex++) {
          bpSize vRandomOffset = uniform(mt);
          vImageConverter.CopyBlock(vFileBlock + vRandomOffset, vBlockIndex);
        }

        bpConverterTypes::tColorInfoVector vColorInfoPerChannel(vImageSize[bpConverterTypes::C]);
        bpConverterTypes::tTimeInfoVector vTimeInfoPerTimePoint;
        bpConverterTypes::tParameters vParameters;

        vImageConverter.Finish(vImageExtent, vParameters, vTimeInfoPerTimePoint, vColorInfoPerChannel, false);

        vEndTime = PerformanceCounter();
        vTimeInMilliSeconds = (vEndTime - vStartTime) * 1000 / vFrequency;
      }

      std::cout << ""Writer: ""  << ""  MB: "" << vImageSizeInMB << ""     Time[ms]: "" << vTimeInMilliSeconds << ""\n"";

      delete[] vFileBlock;

      //Sleep(500);
    }
    else {
      std::cout << ""could run test here"";
      //RunTests<bpUInt8>(vRuns, vSizeX, vSizeY, vSizeZ, vSizeT, vSizeC, vLogFilePath, vOutputFilePath, vIOSystem, vMultiresolution);
    }

  }
  catch (bpArgumentException& err) {
    std::cout << err.what() << std::endl;
  }

  return 0;
}


",vTimeSpec
929,"//
//  DynVect.cpp
//  Vect
//
//  Created by asd on 16/03/2019.
//  Copyright © 2019 voicesync. All rights reserved.
//

//#define NDEBUG

#include ""DynVect.hpp""
#include ""Timer.h""
#include <vector>
#include <math.h>
#include <chrono>



void testDynVect() {
    
    size_t n=1e7;
    double x=10.001, err=1e-3;
    auto v=DynVect<double>::rnd(n);
    char lin[100];
    
//    assert( v.mtsort() == v.sort() );
   
    sprintf(lin, ""DynVect test for %ld items\n"",n);
    Timer().chrono(lin, [&](){

        Timer().chrono(""apply func...\n"", [=](){
            DynVect<double>v1(n);
            auto ts=Timer().chrono(""single thread..."",   [&](){ v1.stapply([n, x] { return x*x; });});
            auto tm=Timer().chrono(""multiple thread..."", [&](){ v1._apply ([n, x] { return x*x; });});
            
            printf(""s/m ratio: %.1f:\n"", 1.*ts/tm);
            assert(v1==x*x);
        });
        
        Timer().chrono(""fill...\n"", [=](){
            DynVect<double>v1(n);
            auto ts=Timer().chrono(""single thread..."",      [&v1,n,x](){    v1.stfill(x); });  // use mutable faster mode
            auto tm=Timer().chrono(""multiple thread..."",    [&v1,n,x](){    v1._fill(x+2); });
            
            printf(""s/m ratio: %.1f:\n"", 1.*ts/tm);
            assert(v1 == x+2);
        });
        
        Timer().chrono(""zero size vectors...\n"", [&](){
            
            DynVect<double>vv1, vv2;
            assert(vv1==vv2);
            vv1+=3;
            
            DynVect<double>::LambdaBool fbool = [](double x)->bool{return x>0.5 && x<0.6;};
            auto  [MASK] =vv1(fbool).sort();
             [MASK] +=vv1;
        });
                       
        Timer().chrono(""(func)...\n"", [&](){
            DynVect<double>::Lambda _sin=[](double x)->double{ return sin(x); };
            
            auto vsel=v( (DynVect<double>::LambdaBool)[](double x)->bool{ return x>=0 && x<=1;} );
            assert(vsel.count()>0);
            
            auto vf=v(_sin);
            assert(vf==v(_sin));
            
            DynVect<double>::LambdaBool fbool = [](double x)->bool{return x>0.5 && x<0.6;};
            vsel=v(fbool);
            
            for (auto d:vsel) assert(fbool(d));
    
            assert(vsel.sort() == v(fbool).sort()); // no necessarily equal as order can be different
        });
        
        Timer().chrono(""sort & selection...\n"", [&]() { // sort
            DynVect<double>::LambdaBool fbool = [](double x)->bool{return x>0.5 && x<0.6;};
            auto vsel=v(fbool);
            assert(v.sort().isSorted());
            assert(vsel.sort() == vsel.sort()); // mtsort experimental!
            assert(vsel.sort() == v(fbool).sort()); // no necessarily equal as order can be different
        });
        
        Timer().chrono(""operators...\n"", [&]() {
            // non mutable
            auto v1=v+v;
            assert(v1==v+v && v1.sum()==v.sum()*2.);
            v1=v*v;
            assert(v1==v*v && v1.sum()==(v*v).sum());
            v+=1; // avoid zero division
            printf(""(v/v).sum=%f\n"", (v/v).sum());
            assert((v/v+1).sum()==v.length()*2);
            assert((v-v).sum()==0);
            
            // mutable
            v1=v;
            v+=v; assert(v==v1*2);
            v-=v; assert(v==v1*0);
            v=v1;
            v/=v; assert(v.sum()==v.length());
            v*=v; assert(v.sum()==v.length());
            v=v1;
            assert(v*2 == v1/0.5);
            assert(v+2 == v1-(-2));
        });
        
        Timer().chrono(""sum...\n"", [&]() {
            double sm, ss;
            auto ts=Timer().chrono(""stsum...\n"", [&]() {
                sm=v.stsum();
            });
            auto tm=Timer().chrono(""sum...\n"", [&]() {
                ss=v.sum();
            });
            
            printf(""(%f - %f = %f) s/m ratio: %.1f\n"", sm, ss, abs(sm-ss), 1.*ts/tm);
            assert(abs(sm-ss) < err);
        });
        
        Timer().chrono(""accumulate vs. kahan sum...\n"", [&]() { // sort
            auto sa=std::accumulate(v.begin(), v.end(), 0.0);
            v._reverse();
            auto ths=DynVect<double>::Thread(&v).sum(), vs=v.sum();
            printf(""diff acc & acc reversed: %g, rec: %g == %g, diff=%g\n"", sa-std::accumulate(v.begin(), v.end(), 0.0), vs, ths, abs(vs-ths));
            printf(""diff sum & sum reversed: %g\n"", v.sum() - v.reverse().sum());
        });
        
        
        
        Timer().chrono(""shuffle...\n"", [&]() {
            auto vorg=v;
            assert(v.shuffle()!=v); // non mutator func
            assert(v.shuffle()!=vorg);
            assert(vorg == vorg.reverse().reverse());
        });
        
        Timer().chrono(""find...\n"", [&]() {
            auto vv=DynVect<double>::rnd(4000), vvv=vv;
            assert(vv == vvv.reverse().reverse());
            for (auto d:vv)
                assert(vvv.find(d) != -1);
            
            DynVect<double>::LambdaBool fbool = [](double x)->bool{return x>0.5 && x<0.5001;};
            auto vsel=v(fbool);
            for (auto i=0; i<std::min<size_t>(10, vsel.length()); i++)
                assert( v.find(vsel[i]) != -1);
        });
        
        Timer().chrono(""iterator...\n"", [&]() {
            double s=0., ss=0., vs=v.sum();
            for (auto d:v) s+=d;
            for (auto i=0; i<v.length(); i++) ss+=v[i];
            assert( abs(s-vs) < err && abs(ss-vs) < err && s==ss);
        });
        
      
        
       
        
        Timer().chrono(""rnd performance in st/mt...\n"", [=](){
            auto ts=Timer().chrono(""single thread..."",  [n](){ auto v=DynVect<double>::strnd(n); });
            auto tm=Timer().chrono(""multi thread..."",   [n](){ auto v=DynVect<double>::rnd(n);   });
            printf(""s/m ratio: %.1f:\n"", 1.*ts/tm);
        });
        
   
        
        Timer().chrono(""sum performance in st/mt...\n"", [n,x](){
            auto v=DynVect<double>::rnd(n);
            double ss=0, sm=0;
            
            auto ts=Timer().chrono(""single thread..."", [&v, &ss](){ ss = v.stsum();  });
            auto tm=Timer().chrono(""multi thread..."",  [&v, &sm](){ sm = v.sum();    });
            
            printf(""checking..."");
            
            assert(abs(ss-sm)<1e-5);
            assert(v==v);
            assert(v!=v+1);
            
            printf(""s/m ratio: %.1f:\n"", 1.*ts/tm);
        });
        
        
        Timer().chrono(""iterator vs. index\n"", [=](){
            
            auto ti=Timer().chrono(""iterator..."", [=](){
                DynVect<double>v1(n);
                v1.set(x);
                assert(v1==x && abs(v1.sum()-n*x) < err);
            });
            
            Timer().chrono(""index..."", [=](){
                DynVect<double>v1(n);
                v1=v1.fill(x);
                assert(v1==x && abs(v1.sum()-n*x)<err);
            });
            
            auto tf=Timer().chrono(""fast index..."", [=](){
                DynVect<double>v1(n);
                v1.setFast(x);
                assert(v1==x && abs(v1.sum()-n*x)<err);
            });
            
            
            printf(""ratio iterator/fast index: %.2f\n"",1. *ti/tf);
        });
        
        Timer().chrono(""testing operators..."", [](){
            size_t n=1e6;
            DynVect<double>dv, dv1(n), dv2(n);
            
            dv = dv1+1;
            assert(dv.sum() == n);
            
            dv2 = dv+1;
            
            assert(dv+1==dv2);
            assert(dv.sum() == dv2.sum()-n);
            
            assert(dv1+1 == dv1+1);
            dv1=dv1-1;
            
            dv.zero(); dv1.zero();
            dv=3; dv1=2; dv1.set(2);
            assert(dv*dv1 == dv*2);
            
            auto v=DynVect<double>::rnd(n), v1=DynVect<double>::rnd(n); // randoms
            assert(v+v != v1+v1);
            assert(v+v == v*2);
            
        });
        
        
        
        Timer().chrono(""testing append, assign, ==, !=..."", [](){
            DynVect<double>dv;
            
            size_t n=1e6;
            for (auto i=0; i<n; i++) dv << i << i+1; // items
            
            assert(dv.length() == n*2);
            for (auto i=0; i<n; i++) {
                assert(dv[i*2+0]==i);
                assert(dv[i*2+1]==i+1);
            }
            
            DynVect<double>dv1; // dynvect's
            dv1 << dv;
            
            assert(dv1==dv); // ==, !=
            assert(!(dv1!=dv));
            
            dv1 = dv; //  test assign
            auto dv2=dv;
            
            assert(dv1==dv);
            assert(dv2==dv);
            
            dv1.clear();
            dv2.clear();
            for (int i=0; i<100000; i++) dv1 << i; // this with more blocks than other
            for (int i=0; i<100; i++) dv2 << i;
            
            dv1=dv2; // dv1 has more blocks than dv2
            assert(dv1==dv2);
            
            dv=dv;
            assert(dv==dv);
            
            dv2 = dv;
            assert(dv2==dv);
            
        });
        
        Timer().chrono(""testing constructor & index access..."", [](){
            DynVect<double>dv, dv1(10000), dv2(10);
            
            double s=0, sv=0, sv1=0;
            for (auto i=0; i<dv1.length(); i++) //  test index mutable & accessor
            { dv1[i]=i; s+=i; sv+=dv1[i]; }
            
            for (auto i=0; i<dv1.length(); i++) sv1+=dv1[i];
            assert(s==sv && sv==sv1);
        });
        
    });
}
",vv3
930,"// --------------------------------------------------------------------------------------------------------------------
//   Copyright © 2013 BitterSkittles.
//   This program is free software. It comes without any warranty, to
//   the extent permitted by applicable law. You can redistribute it
//   and/or modify it under the terms of the Do What The Fuck You Want
//   To Public License, Version 2, as published by Sam Hocevar. See
//   http://www.wtfpl.net/ for more details.
// --------------------------------------------------------------------------------------------------------------------

#include ""contentcontrol.h""

#include <QQmlContext>
#include <QQmlEngine>

ContentControl::ContentControl(QQuickItem *parent) :
    QQuickItem(parent),
    m_content(NULL)
{
}

ContentControl::~ContentControl()
{
    this->setContent(NULL);
}

QQuickItem *ContentControl::content() const
{
    return this->m_content;
}

QVariant ContentControl::model() const
{
    return this->m_model;
}

void ContentControl::setContent(QQuickItem *value)
{
    if (this->m_content == value)
    {
        return;
    }

    this->disconnectContent();
    this->m_content = value;
    this->connectContent();
    emit contentChanged();
}

void ContentControl::setModel(const QVariant& value)
{
    if (this->m_model == value)
    {
        return;
    }

    this->m_model = value;
    this->onModelChanged();
    emit modelChanged();
}

void ContentControl::onModelChanged()
{
    if (this->m_model.isValid() == false)
    {
        this->setContent(NULL);
        return;
    }

    QObject *viewModel = qvariant_cast<QObject*>(this->m_model);
    if (viewModel == NULL)
    {
        this->setContent(NULL);
        return;
    }

    QString viewFilename = this->findViewFor(viewModel);
    if (viewFilename.isNull())
    {
        this->setContent(NULL);
        return;
    }

    QQuickItem *view = this->initializeView(viewFilename, this->m_model);
    if (view == NULL)
    {
        this->setContent(NULL);
        return;
    }

    this->setContent(view);
}

void ContentControl::connectContent()
{
    if  (this->m_content == NULL)
    {
        return;
    }

    this->m_content->setParentItem(this);
    this->doUpdate();

    static int heightChangedSignalIdx = -1;
    static int widthChangedSignalIdx = -1;
    static int doUpdateSlotIdx = -1;

    if (widthChangedSignalIdx < 0)
        widthChangedSignalIdx = QMetaMethod::fromSignal(&QQuickItem::widthChanged).methodIndex();
    if (heightChangedSignalIdx < 0)
        heightChangedSignalIdx = QMetaMethod::fromSignal(&QQuickItem::heightChanged).methodIndex();
    if (doUpdateSlotIdx < 0)
        doUpdateSlotIdx = ContentControl::staticMetaObject.indexOfSlot(""doUpdate()"");
    QMetaObject::connect(this->m_content, widthChangedSignalIdx, this, doUpdateSlotIdx);
    QMetaObject::connect(this->m_content, heightChangedSignalIdx, this, doUpdateSlotIdx);
}

void ContentControl::disconnectContent()
{
    if  (this->m_content == NULL)
    {
        return;
    }

    QQuickItem* oldContent = this->m_content;
    this->m_content = NULL;
    oldContent->setParentItem(NULL);
    delete oldContent;
}

QString ContentControl::findViewFor(const QObject *obj)
{
    QString modelName(obj->metaObject()->className());

    QString viewModelConvention = QStringLiteral(""ViewModel"");

    if (modelName.endsWith(viewModelConvention) == false)
    {
        return QString();
    }

    QString viewName = QString(modelName)
            .replace(
                modelName.length() - viewModelConvention.length(),
                viewModelConvention.length(),
                ""View"")
            .replace(""ViewModels::"", ""Views::"");

    QString viewFilename = ""qml/"" + QString(viewName).replace(""::"", ""/"") + "".qml"";

    return viewFilename;
}

QQuickItem *ContentControl::initializeView(const QString &viewFilename, const QVariant &model)
{
    QQmlEngine engine;
    QQmlContext context(&engine, this);
    context.setContextProperty(""dataContext"", model);

    QQmlComponent  [MASK] (&engine, QUrl::fromLocalFile(viewFilename));
    QQuickItem* view = qobject_cast<QQuickItem*>( [MASK] .create(&context));

    return view;
}

void ContentControl::doUpdate()
{
    if (this->m_content == NULL)
    {
        return;
    }

    this->setImplicitWidth(this->m_content->width());
    this->setImplicitHeight(this->m_content->height());
}
",component
931,"// mar: Minimal ASCII reader for C++
// licence: Apache, see LICENCE file
// file: AsciiLineReader.cpp - AsciiLineReader class implementation
// author: <NAME>

#define ASCII_LINE_READER_CPP
#include ""mar/AsciiLineReader.h""

namespace MAR {
    AsciiLineReader::AsciiLineReader(const std::string &_file_name, size_t  [MASK] , const std::string &_end) :
        AsciiStreamReader(_file_name,  [MASK] , _end), m_rd_ptr(m_buffer) {}


    AsciiLineReader::AsciiLineReader(AsciiLineReader &&_alr) noexcept :
        m_line_beg(_alr.m_line_beg),
        m_line_end(_alr.m_line_end),
        m_rd_ptr(_alr.m_rd_ptr) {}


    bool AsciiLineReader::_NextLine() {
        char *new_end = nullptr;

        // line ending is saved
        if(m_line_end != 0 && m_line_end + 1 < m_buffer + m_last_read) {
            new_end = std::strchr(m_line_end + 1, static_cast<int>('\n'));
            if(!new_end) new_end = m_buffer + m_last_read;
            m_line_beg = m_line_end + 1;
            m_line_end = new_end;
        }

        else if(m_line_end + 1 >= m_buffer + m_last_read)
            return false;

        else {
            // no line ending is saved
            m_line_beg = m_buffer;
            m_line_end = std::strchr(m_line_beg, static_cast<int>('\n'));
            if(!m_line_end) m_line_end = m_buffer + m_last_read;
        }
        return true;
    }


    std::vector<std::string> AsciiLineReader::_ReadStatementArgs() {
        std::vector<std::string> args;
        while(true) {
            char *end = nullptr;
            _SkipSkippableCharacters();
            if(m_rd_ptr >= m_line_end) break;
            
            end = _ExtractWord();
            std::string arg = std::string(m_rd_ptr, end - m_rd_ptr);
            m_rd_ptr = end;
            if(arg == ""\\\\"") {
                _NextLine();
                m_rd_ptr = m_line_beg;
                continue;
            }

            args.push_back(arg);
        }

        return args;
    }


    void AsciiLineReader::_SkipSkippableCharacters(bool _skip_nl) {
        // skip all whitespaces till keyword is found
        for(; m_rd_ptr < m_line_end; m_rd_ptr++) {
            if(!_skip_nl) {
                if(*m_rd_ptr != ' ' && *m_rd_ptr != 0x00 && *m_rd_ptr != '\t' && *m_rd_ptr != '\r')
                    break;
             } else {
                if(*m_rd_ptr != ' ' && *m_rd_ptr != 0x00 && *m_rd_ptr != '\t' && *m_rd_ptr != '\r' && *m_rd_ptr != '\n')
                    break;
             }
        }
    }


    bool AsciiLineReader::_SkipData(const size_t _skip_val) {
        if(m_buffer + m_last_read <= m_rd_ptr + _skip_val) {
            if(_ReadNewChunk()) {
                m_rd_ptr = m_buffer;
                return true;
            }

            return false;
        }

        m_rd_ptr += _skip_val;
        return true;
    }


    char *AsciiLineReader::_ExtractWord() {
        char *end = m_rd_ptr;
        while(end < m_line_end && end < m_buffer + m_last_read) {
            if(*end == ' ' || *end == 0x00 || *end == '\t' || *end == '\n' || *end == '\r')
                break;

            end++;
        }

        return end;
    }

    
    std::string AsciiLineReader::_ExtractString() {
        char *end = m_rd_ptr + 1;
        bool br = false;

        do {
            end = strchr(end, static_cast<int>('\""'));
            
            if(end == m_buffer || *(end - 1) != '\\')
                br = true;
            else end++;
        } while(!br);

        std::string str_val = std::string(m_rd_ptr, end - m_rd_ptr + 1);

        // check if quotation marks can be avoided
        if(str_val.size() > 2)
            str_val = str_val.substr(1, str_val.size() - 2);

        m_rd_ptr = end + 1;
        return str_val;
    }


    char *AsciiLineReader::_ExtractBlob(uint32_t _size, char *_data) {
        // allocate memory if _data is a nullptr
        bool is_alloc = false;
        if(!_data) {
            _data = reinterpret_cast<char*>(std::malloc(static_cast<size_t>(_size)));
            is_alloc = true;
        }

        char *data_ptr = _data;
        size_t rem = static_cast<size_t>(_size);
        while(rem != 0) {
            // remaining size is larger than remaining data in buffer
            if(m_last_read - (m_rd_ptr - m_buffer) <= rem) {
                std::memcpy(data_ptr, m_rd_ptr, m_last_read - (m_rd_ptr - m_buffer));
                data_ptr += m_last_read - (m_rd_ptr - m_buffer);
                rem -= m_last_read - (m_rd_ptr - m_buffer);
                bool is_read = _ReadNewChunk();

                // return from the subroutine if chunk reading failed
                if(!is_read) {
                    if(is_alloc) std::free(_data);
                    return nullptr;
                }

                _SetReadPtr(m_buffer);

            } else {
                std::memcpy(data_ptr, m_rd_ptr, rem);
                m_rd_ptr += rem;
                rem = 0;
            }
        }

        return _data;
    }


    char *AsciiLineReader::_GetReadPtr() {
        return m_rd_ptr;
    }


    std::pair<char*, char*> AsciiLineReader::_GetLineBounds() {
        return std::make_pair(m_line_beg, m_line_end);
    }


    void AsciiLineReader::_SetReadPtr(char *_ptr) {
        m_rd_ptr = _ptr;
    }


    void AsciiLineReader::_SetLineBounds(const std::pair<char*, char*> &_bounds) {
        m_line_beg = _bounds.first;
        m_line_end = _bounds.second;
    }
}
",_chunk_size
932,"
//          Copyright <NAME> 2012 - 2013.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#pragma once

#include <mpi.h>
#include <shiva\error.h>

#ifndef SHIVA_VERSION
#define SHIVA_VERSION 4
#endif

namespace shiva {

class environment 
{
public:
	environment()
	{
		if (! this->is_initialized()) {
			call_mpi( MPI_Init(0,0) );
		}
	}
	~environment()
	{
		if (this->is_initialized()) {
			MPI_Finalize();
		}
	}
	bool is_initialized()
	{
		int is_initialized = 0;
		call_mpi( MPI_Initialized(&is_initialized) );
		if (is_initialized == 0)
			return false;
		else
			return true;
	}

	std::string get_processor_name()
	{
		char name[MPI_MAX_PROCESSOR_NAME];
		int  [MASK] ;
		call_mpi(MPI_Get_processor_name(name, & [MASK] ));
		return std::string(name,  [MASK] );
	}

};



}",len
933,"/*
	Name: Exception.hpp
	Copyright: Apache 2.0
	Author: CLimber-Rong
	Date: 24/08/23 18:09
	Description: 异常处理的实现
*/
#pragma once

#include""stmlib.hpp""
#include""String.hpp""
//该库不依赖平台，无需移植

char* ExceptionMessage;

/*
	CATCH的使用方法：
	CATCH {
		//在这里写上捕捉异常的代码
	}
	THROW(message)用于抛出异常，异常信息为message
	THROW_S的作用与THROW相近，通常用于抛出“运行时才能决定异常信息”的异常
	ERROR是异常信息
*/ 

/*
 * 这里了经过改装
 * 开发者只需要在当前代码所在的作用域中定义STMException* ex
 * 即可使用以下的宏
 * 之前的异常实现是全局性的
 * 但是考虑到今后要尝试多线程运行，所以我将异常实现变成面向对象的
*/

#define THROW(message) ex->Throw(String((char*)message));
//THROW当中的message是char*
#define THROW_S(message_s) ex->Throw(message_s);
//THROW_S当中的message_s是String
#define CATCH if(ex->isError)
#define ERROR (ex->getError())

class STMException {
		String ExceptionMessage;
	public:
		bool isError = false;

		void Throw(String  [MASK] ) {
			ExceptionMessage =  [MASK] ;
			isError = true;
		}

		String getError() {
			return ExceptionMessage;
		}
		
};",msg
934,"/// file: extended_kalman_filter_demo.cpp
///
/// In this demo a 3D state is simulated.
/// The 3D state evolves according to a non-linear
/// state transition function f.
/// Further, a noisy 3D measurement sensor of this
/// 3D state is available. The measurement process
/// is described by a non-linear 3D function h.
///
/// The task of the Extended Kalman Filter (EKF)
/// here is to estimate the 3D state vector.
/// For this, the EKF approximates the non-linear
/// functions f and h in the update formulas using
/// a Taylor series approximation of the first order,
/// i.e. using a linear approximation. The Taylor
/// series approximation for high-dimensional functions
/// corresponds to the Jacobi-matrix.
///
/// ---
/// by Prof. Dr. <NAME>, www.juergenbrauer.org
///


#include ""opencv2/core.hpp""
#include ""opencv2/imgproc.hpp""
#include ""opencv2/highgui.hpp""
#include ""opencv2/videoio.hpp""

#include <iostream>
#include <conio.h>
#include <random>                 // for random numbers & 1D normal distribution
#define _USE_MATH_DEFINES
#include <math.h>                 // for M_PI

#include ""mvnrnd.h""               // for random number generator following a n-dimensional normal distribution

#include ""params.h""


using namespace cv;
using namespace std;


vector<Point2d> traj_gt;               // ground truth trajectory
vector<Point2d> traj_est_predonly;     // trajectory based on prediction only
vector<Point2d> traj_est_EKF;          // trajectory based on EKF estimate

Mat image;

// Macro for mapping a 3D matrix/vector to a 2D point
#define m2p(M) Point((int)M.at<float>(1,0), (int)M.at<float>(2,0))


// some non-linear function f that maps 3D states µ to new 3D states µ'
Mat f(Mat µ)
{ 
  float µ1 = µ.at<float>(0, 0);
  float µ2 = µ.at<float>(1, 0);
  float µ3 = µ.at<float>(2, 0);
  Mat µ_prime =
    (Mat_<float>(3, 1) <<
       µ1 + 1, 400 + 200 * cos(µ1 / 40.0), 400 + 200 * sin(µ1 / 20.0));
  
  return µ_prime;
}


// some non-linear function h that maps 3D states µ to 3D measurements z
Mat h(Mat µ)
{
  float µ1 = µ.at<float>(0, 0);
  float µ2 = µ.at<float>(1, 0);
  float µ3 = µ.at<float>(2, 0);

  
  Mat measurement_vec =
    (Mat_<float>(3, 1) << µ1*µ1, µ2*µ2, µ3*µ3);
  

  /*
  Mat measurement_vec =
     (Mat_<float>(3, 1) << µ1+µ2, cos(µ2), sin(µ3));
  */

  return measurement_vec;
}



int main()
{
  // 1. create visualization image
  image = Mat(IMG_HEIGHT, IMG_WIDTH, CV_8UC3);
  

  // 2. initialize vectors and covariance matrices

  // 2.1 state vector µ: the 2D car is in middle of image at start
  cv::Mat µ_gt = (Mat_<float>(3, 1) << 0, IMG_WIDTH/2, IMG_HEIGHT/2);

  // 2.2 covariance matrix P: initial uncertainty about the state
  cv::Mat P = (Mat_<float>(3, 3) << 10.0,  0.0, 0.0,
                                     0.0, 10.0, 0.0,
                                     0.0,  0.0, 10.0);

  // 2.3 process noise covariance matrix: describes randomness of state
  //     transitions per dimension
  cv::Mat Q = (Mat_<float>(3, 3) <<  5.0,   0.0,   0.0,
                                     0.0,    50.0,  0.0,
                                     0.0,    0.0,  200.0);

  // 2.4 measurement noise covariance matrix: describes randomness of
  //     measurements per dimension
  cv::Mat R = (Mat_<float>(3, 3) <<  5e8,   0.0,   0.0,
                                     0.0,   5e8,   0.0,
                                     0.0,    0.0,  5e8);
  

  // 3. prepare random number generators for simulating process & measurement noise
  
  // prepare random number generator for process noise
  cv::Mat mean_vec = (Mat_<float>(3, 1) << 0,0,0 );
  mvnrnd rnd_generator_process_noise = mvnrnd(mean_vec, Q);

  // prepare random number generator for measurement noise
  cv::Mat mean_vec2 = (Mat_<float>(3, 1) << 0,0,0);
  mvnrnd rnd_generator_measurement_noise = mvnrnd(mean_vec2, R);

  
  

  // initialize estimated state vectors
  // with estimation just by prediction and
  // with estimation based on EKF
  Mat µ_est_predonly = µ_gt.clone();
  Mat µ_est          = µ_gt.clone();  

  float avg_error_µ_est_predonly = 0.0;  
  float avg_error_µ_est = 0.0;
  int  [MASK]  = 0;

  while (true)
  {
    // 1. clear screen & visualization image
    system(""cls"");
    printf(""Simulation step : %d\n"",  [MASK] );
    image = 0;


    // 2. simulate new ground truth state
    //    that is computed by some non-linear function
    Mat rnd_vec1 = rnd_generator_process_noise.get_next_random_vector();
    if (SHOW_DEBUG_INFO)
    {
      printf(""rnd_vec1 = (%.2f,%.2f,%.2f)\n"",
        rnd_vec1.at<float>(0, 0), rnd_vec1.at<float>(1, 0), rnd_vec1.at<float>(2, 0));
    }
    µ_gt = f(µ_gt) + rnd_vec1;
    

    
    // 3. simulate sensor data / vector    
    Mat rnd_vec2 = rnd_generator_measurement_noise.get_next_random_vector();    
    Mat gt_measurement_vec = h(µ_gt);
    Mat z = gt_measurement_vec + rnd_vec2;
    if (SHOW_DEBUG_INFO)
    {
      printf(""rnd_vec2 that will be added to measurement vec = (%.2f,%.2f,%.2f)\n"",
        rnd_vec2.at<float>(0, 0), rnd_vec2.at<float>(1, 0), rnd_vec2.at<float>(2, 0) );
      printf(""gt_measurement_vec = (%.2f,%.2f,%.2f)\n"",
        gt_measurement_vec.at<float>(0, 0), gt_measurement_vec.at<float>(1, 0), gt_measurement_vec.at<float>(2, 0));
      printf(""z = (%.2f,%.2f,%.2f)\n"",
        z.at<float>(0, 0), z.at<float>(1, 0), z.at<float>(2, 0));
    }

    
    // 4. update state estimate just based on prediction
    µ_est_predonly = f(µ_est_predonly);
    



    
    // 5.1 predict new state using EKF & update error covariance matrix    
    µ_est = f(µ_est);
    
    // compute Jacobi matrix of f at location a=µ_est
    float µ1 = µ_est.at<float>(0, 0);    
    float µ2 = µ_est.at<float>(1, 0);
    float µ3 = µ_est.at<float>(2, 0);    
    
    Mat F = (Mat_<float>(3, 3) <<                              1.0, 0.0, 0.0,
                                  -200.0 * sin(µ1/40.0) * 1.0/40.0, 0.0, 0.0,
                                   200.0 * cos(µ1/20.0) * 1.0/20.0, 0.0, 0.0);                                   
    /*
    Mat F = (Mat_<float>(3, 3) << 1.0, 0.0, 3.0,
                                  0.0, 2.0, 4.0,
                                  0.0, 0.0, 5.0
                                  );
    */

    P = F*P*F.t() + Q;


    
    // 5.2 correct predicted state & covariance matrix using measurement    
    cv::Mat y = z - h(µ_est);

    // compute Jacobi matrix of h at location a=µ_est    
    Mat H = (Mat_<float>(3, 3) << 2*µ1,  0.0, 0.0,
                                  0.0,  2*µ2, 0.0,
                                  0.0,   0.0, 2*µ3);
    
    /*
    Mat H = (Mat_<float>(3, 3) << 1,         1,      0,
                                  0,  -sin(µ2),      0,
                                  0,         0, cos(µ3));
    */
    //H = cv::Mat::eye(3, 3, CV_32FC1);

    // compute residual covariance matrix S
    cv::Mat S = H*P*H.t() + R;

    // compute Kalman gain matrix
    // the Kalman gain matrix tells us how strongly to correct
    // each dimension of the predicted state vector by the help
    // of the measurement
    cv::Mat K = P * H.t() * S.inv();

    // correct previously predicted new state vector
    µ_est = µ_est + K*y;

    // update uncertainty covariance matrix
    P = P - K*H*P;


    // 6. show ground truth & estimated trajectories

    // 6.1 update trajectories
    traj_gt.push_back          ( m2p(µ_gt)           );
    traj_est_predonly.push_back( m2p(µ_est_predonly) );
    traj_est_EKF.push_back     ( m2p(µ_est)          );
    const int MAX_NR_TRAJECTORY_POINTS = 100;
    if (traj_gt.size() > MAX_NR_TRAJECTORY_POINTS)
    {
      traj_gt          .erase(traj_gt.begin()          );
      traj_est_predonly.erase(traj_est_predonly.begin());
      traj_est_EKF     .erase(traj_est_EKF.begin()     );
    }

    // 6.2 draw trajectories
    for (unsigned int i = 1; i < traj_gt.size(); i++)
    {
      line(image, traj_gt.at(i - 1), traj_gt.at(i), COL_GT, 2);

      if (SHOW_NAIVE_ESTIMATION)
         line(image, traj_est_predonly.at(i - 1), traj_est_predonly.at(i), COL_NAIVE, 2);

      if (SHOW_EKF_ESTIMATION)
        line(image, traj_est_EKF.at(i - 1), traj_est_EKF.at(i), CV_RGB(255, 0, 0), 2);
    }

    // 6.3 draw current ground truth state & state estimates
    const int line_width = 2;
    const int circle_size = 10;
    circle(image, traj_gt.back(), circle_size, COL_GT, line_width);
    if (SHOW_NAIVE_ESTIMATION)
      circle(image, traj_est_predonly.back(), circle_size, COL_NAIVE, line_width);
    if (SHOW_EKF_ESTIMATION)
       circle(image, traj_est_EKF.back(), circle_size, COL_EKF, line_width);

    // 6.4 show current measurement?
    //     No, it does not make sense!
    //     If state is (x1,x2,x3) sensor value is about (x1*x1,x2*x2,x3*x3)!
    //circle(image, Point((int)z.at<float>(1, 0), (int)z.at<float>(2, 0)), circle_size, COL_MEASUREMENT, line_width);

    // 7. show visualization image
    imshow(""Extended Kalman Filter Demo"", image);

    // 8. display gt state vector and estimated state vectors
    if (SHOW_DEBUG_INFO)
    {
       printf(""gt = (%.1f,%.1f,%.1f)\n"",
          µ_gt.at<float>(0, 0), µ_gt.at<float>(1, 0), µ_gt.at<float>(2, 0));
       printf(""est_predonly = (%.1f,%.1f,%.1f)\n"",
          µ_est_predonly.at<float>(0, 0), µ_est_predonly.at<float>(1, 0), µ_est_predonly.at<float>(2, 0));
       printf(""est = (%.1f,%.1f,%.1f)\n"",
          µ_est.at<float>(0, 0), µ_est.at<float>(1, 0), µ_est.at<float>(2, 0));
    }

    // 9. update error estimates
    float N = (float) [MASK] ;
    avg_error_µ_est_predonly = (avg_error_µ_est_predonly*N + (float)norm(µ_est_predonly - µ_gt)) / (N + 1.0f);
    avg_error_µ_est          = (avg_error_µ_est         *N + (float)norm(µ_est          - µ_gt)) / (N + 1.0f);
    printf(""\n"");
    printf(""avg error est predonly = %.3f\n"", avg_error_µ_est_predonly);
    printf(""avg error EKF est      = %.3f\n"", avg_error_µ_est);
    

    // 10. wait for user input
    printf(""Press any key to go next simulation step!\n"");
    int c = waitKey();
    if (c == 29) // ESC pressed?
      break;

    // 11. time goes by...
     [MASK] ++;

  } // while


} // main",simulation_step
935,"//
// Created by KV on 26 february, 2017.
// On the platform Linux (Ubuntu Xenial xerus) 64Bit
//
// <EMAIL>
//

#include ""event_loop.h""
#include ""log.h""
#include ""input_event.h""
#include ""handle_command.h""



/*
 * In the below data we are first initializing constructor and after that we are passing the data to the private member.
 * by doing this when a member function or variable will be called the data will be automatically initialized before the process of
 * the member function starts, this is the highly importantance of object oriented programming.
 *
 * Using a class type syntax or class type coding structure make a program more easy to understand and easy to debug.
 * Sometime writing all programming code in only one file make somewhat hard for understanding.
 *
 * We will follow this pattern in the all coming samples.
 *
 */
event_loop::event_loop(android_app *app):
e_application(app),
inputEvent(inputEvent),
handleCommand(handleCommand)
{
    e_application->onInputEvent = inputEvent.android_custom_input_event;
    e_application->onAppCmd = handleCommand.processCommand;
}




void event_loop::run(android_app* application) {

   app_dummy();

    int32_t  [MASK] , result;
    struct android_poll_source* source;
    LOG_WARN(""Starting a loop"");
    while(1) {

        while((result = ALooper_pollAll(-1, NULL, & [MASK] , (void**)&source))>=0) {
            if(source!=NULL)
                source->process(application,source);
            if(application->destroyRequested!=0)
            {
                LOG_WARN(""We are exiting"");
                return;
            }
        }
    }
}






",events
936,"#ifndef TEST_H
#define TEST_H

#include <cstddef>
#include <cstdint>
#include <cstdlib>

#include ""gtest/gtest.h""

// https://stackoverflow.com/a/10062016/523079
template <typename T, size_t size>
::testing::AssertionResult ArraysMatch(const T (&expected)[size], const T (&actual)[size]) {
    for (size_t i(0); i < size; ++i) {
        if (expected[i] != actual[i]) {
            return ::testing::AssertionFailure()
                   << ""expected["" << i << ""] ("" << +expected[i] << "") != actual["" << i << ""] ("" << +actual[i] << "")"";
        }
    }

    return ::testing::AssertionSuccess();
}

template <class T1, class T2>
::testing::AssertionResult ArraysMatch(const T1 *expected, const T2 *actual, size_t  [MASK] ) {
    for (size_t i(0); i <  [MASK] ; ++i) {
        if (expected[i] != actual[i]) {
            return ::testing::AssertionFailure()
                   << ""expected["" << i << ""] ("" << +expected[i] << "") != actual["" << i << ""] ("" << +actual[i] << "")"";
            ;
        }
    }

    return ::testing::AssertionSuccess();
}

static inline void gen_random(uint16_t v[], size_t length) {
    for (size_t i = 0; i < length; i++) {
        v[i] = rand() & 0xFFFF;
    }
}

static inline void ref_poly_mul_mod_65536_u16_nxn_coeffs(uint16_t xy[], uint16_t x[], uint16_t y[], size_t n) {
    memset(xy, 0, 2 * n * sizeof(uint16_t));

    for (size_t i = 0; i < n; i++) {
        for (size_t j = 0; j < n; j++) {
            xy[i + j] += x[i] * y[j];
        }
    }
}

static inline void ref_poly_mul_mod_65536_mod_x_d_minus_1_u16_nxn_coeffs(uint16_t xy[], uint16_t x[], uint16_t y[],
                                                                         size_t d) {
    memset(xy, 0, d * sizeof(uint16_t));

    for (size_t i = 0; i < d; i++) {
        for (size_t j = 0; j < d; j++) {
            xy[(i + j) % d] += x[i] * y[j];
        }
    }
}

#endif  // TEST_H
",array_len
937,"//
// Created by <NAME> on 25.05.23.
//
#pragma once

#include <string>
#include <curl/curl.h>
#include <functional>
#include <utility>

void serializeString(const std::string &str, char *&ptr, size_t padding_length);

struct MemoryStruct {
    char *memory;
    size_t size;
};

class Connection;

class Station {

public:
    [[maybe_unused]] explicit Station(std::string name);

    std::string m_name;
    std::string m_id;

private:

    int start_curl_request(const std::string &url, struct MemoryStruct &chunk, const std::function<int()> &callback_func);
//    void free_curl_request(struct MemoryStruct &chunk);
    int get_id_from_server();
    int get_cons_from_server();
    void write_connections_to_buffer(void* buffer) const;
    void write_connections_to_file(FILE * file) const;
    CURL *m_curl_handle{};
    std::vector<Connection> m_cons;
};

class Connection {
public:
    Connection()= default;

    void setType(std::string type) {
        m_type = std::move(type);
    }
    void setDepartureTime(std::string departureTime) {
        m_departure_time =  std::move(departureTime);
    }

    void setPlannedTime(std::string plannedTime) {
        m_planned_time =  std::move(plannedTime);
    }

    void setDelay(uint32_t  [MASK] ) {
        m_delay =  [MASK] ;
    }

    void setPlatform(std::string platform) {
        m_platform = std::move(platform);
    }

    void setDestination(std::string destination) {
        m_destination = std::move(destination);
    }

    void setLine(std::string line) {
        m_line = std::move(line);
    }

    void print_connection();

    void serialize_connection(char* &buffer) const;

private:

    std::string m_type;
    std::string m_departure_time;
    std::string m_planned_time;
    int16_t m_delay{};
    std::string m_line;
    std::string m_destination;
    std::string m_platform;


//    uint8_t m_byte_couter = 0;
};




",mDelay
938,"#include ""clang/Driver/Options.h""
#include ""clang/AST/AST.h""
#include ""clang/AST/ASTContext.h""
#include ""clang/AST/ASTConsumer.h""
#include ""clang/AST/RecursiveASTVisitor.h""
#include ""clang/Frontend/ASTConsumers.h""
#include ""clang/Frontend/FrontendActions.h""
#include ""clang/Frontend/CompilerInstance.h""
#include ""clang/Tooling/CommonOptionsParser.h""
#include ""clang/Tooling/Tooling.h""
#include ""clang/Rewrite/Core/Rewriter.h""
#include ""clang/ASTMatchers/ASTMatchers.h""
#include ""clang/ASTMatchers/ASTMatchFinder.h""
#include <set>
#include <sstream>
#include <vector>
#include <map>
#include <tuple>

using namespace std;
using namespace clang;
using namespace clang::driver;
using namespace clang::tooling;
using namespace clang::ast_matchers;
using namespace llvm;

/** Options **/
static cl::OptionCategory CPP2CCategory(""CPP2C options"");
static std::unique_ptr<opt::OptTable> Options(createDriverOptTable());
static cl::opt<std::string> OutputFilename(""o"", cl::desc(Options->getOptionHelpText((options::OPT_o))));

/** Classes to be mapped to C **/
struct OutputStreams{
	string headerString;
	string bodyString;

	llvm::raw_string_ostream HeaderOS;
	llvm::raw_string_ostream BodyOS;

	OutputStreams() : headerString(""""), bodyString(""""), HeaderOS(headerString), BodyOS(bodyString){};
};


vector<string> ClassList = {""uThread"", ""kThread"", ""Cluster"", ""Connection"", ""Mutex"", ""OwnerLock"", ""ConditionVariable"", ""Semaphore"", ""uThreadPool""};

map<string, int> funcList;

/** Matchers **/

/** Handlers **/
class classMatchHandler: public MatchFinder::MatchCallback{
public:
	classMatchHandler(OutputStreams& os): OS(os){}

	tuple<string, string, bool, bool> determineCType(const QualType& qt){

		string CType = """";
		string  [MASK]  = """"; //whether this should be casted or not
		bool 	isPointer = false;
		bool 	shoulReturn = true;

		//if it is builtint type use it as is
		if(qt->isBuiltinType() || (qt->isPointerType() && qt->getPointeeType()->isBuiltinType())){
			CType = qt.getAsString();
			if(qt->isVoidType())
				shoulReturn = false;
		//if it is a CXXrecordDecl then return a pointer to WName*
		}else if(qt->isRecordType()){
			const CXXRecordDecl* crd = qt->getAsCXXRecordDecl();
			string recordName = crd->getNameAsString();
			CType = ""W"" + recordName + ""*"";
			 [MASK]  = recordName+ ""*"";

		}else if( (qt->isReferenceType() || qt->isPointerType()) && qt->getPointeeType()->isRecordType()){
			isPointer = true; //to properly differentiate among cast types
			const CXXRecordDecl* crd = qt->getPointeeType()->getAsCXXRecordDecl();
			string recordName = crd->getNameAsString();
			if ( std::find(ClassList.begin(), ClassList.end(), recordName) != ClassList.end() ){
				CType = ""W"" + recordName + ""*"";
				 [MASK]  = recordName + ""*"";
			}else{
				CType = recordName+""*"";
			}

		}
		return make_tuple(CType,  [MASK] , isPointer, shoulReturn);

	}

	virtual void run(const MatchFinder::MatchResult &Result){
		if (const CXXMethodDecl *cmd = Result.Nodes.getNodeAs<CXXMethodDecl>(""publicMethodDecl"")){
			string methodName = """";
			string className = cmd->getParent()->getDeclName().getAsString();
			string returnType = """";
			string returnCast = """";
			bool shouldReturn, isPointer;
			string self = ""W"" + className + ""* self"";
			string separator = "", "";
			string bodyEnd = """";

			std::stringstream functionBody;

			//ignore operator overloadings
			if(cmd->isOverloadedOperator())
				return;

			//constructor
			if (const CXXConstructorDecl* ccd = dyn_cast<CXXConstructorDecl>(cmd)) {
				if(ccd->isCopyConstructor() || ccd->isMoveConstructor()) return;
				methodName = ""_create"";
				returnType = ""W"" + className + ""*"";
				self = """";
				separator = """";
				functionBody << ""return reinterpret_cast<""<< returnType << "">( new "" << className << ""("";
				bodyEnd += ""))"";
			}else if (isa<CXXDestructorDecl>(cmd)) {
				methodName = ""_destroy"";
				returnType = ""void"";
				functionBody << "" delete reinterpret_cast<""<<className << ""*>(self)"";
			}else{
				methodName = ""_"" + cmd->getNameAsString();
				const QualType qt = cmd->getReturnType();
				std::tie(returnType, returnCast, isPointer, shouldReturn) = determineCType(qt);

				//should this function return?
				if(shouldReturn)
					functionBody << ""return "";

				if(returnCast != """"){
					//if not pointer and it needs to be casted, then return the pointer
					if(!isPointer)
						functionBody << ""&"";
					functionBody << ""reinterpret_cast<""<< returnType << "">("";
					bodyEnd += "")"";
				}

				//if Static call it properly
				if(cmd->isStatic())
					functionBody <<className << ""::"" << cmd->getNameAsString() << ""("";
				//if not  use the passed object to call the method
				else
					functionBody << ""reinterpret_cast<""<<className<<""*>(self)->"" << cmd->getNameAsString() << ""("";

				bodyEnd += "")"";
			}


			std::stringstream funcname;
			funcname << returnType << "" "" << className << methodName;

			auto it = funcList.find(funcname.str());

			if(it != funcList.end()){
				it->second++;
				funcname << ""_"" << it->second ;
			}else{
				funcList[funcname.str()] = 0;
			}

			funcname << ""("" << self;

			for(unsigned int i=0; i<cmd->getNumParams(); i++)
			{
				const QualType qt = cmd->parameters()[i]->getType();
				std::tie(returnType, returnCast, isPointer, shouldReturn) = determineCType(qt);
				funcname << separator << returnType << "" "";
			    funcname << cmd->parameters()[i]->getQualifiedNameAsString() << """";

			    if(i !=0 )
			    	functionBody << separator;
			    if(returnCast == """")
			    	functionBody << cmd->parameters()[i]->getQualifiedNameAsString();
			    else{
			    	if(!isPointer)
			    		functionBody << ""*"";
			    	functionBody << ""reinterpret_cast<"" << returnCast << "">(""<< cmd->parameters()[i]->getQualifiedNameAsString() << "")"";

			    }

			    string separator = "", "";

			}
			funcname << "")"";

			OS.HeaderOS << funcname.str() << "";\n"";

			OS.BodyOS << funcname.str() << ""{\n    "";
			OS.BodyOS << functionBody.str();
			OS.BodyOS << bodyEnd << ""; \n}\n"" ;
		}
	}
	virtual void onEndOfTranslationUnit(){}
private:
	OutputStreams& OS;

};


/****************** /Member Functions *******************************/
// Implementation of the ASTConsumer interface for reading an AST produced
// by the Clang parser. It registers a couple of matchers and runs them on
// the AST.
class MyASTConsumer: public ASTConsumer {
public:
	MyASTConsumer(OutputStreams& os) : OS(os),
			HandlerForClassMatcher(os){
		// Add a simple matcher for finding 'if' statements.

		for(string& className : ClassList){
			OS.HeaderOS << ""struct      W""<< className << ""; \n""
						   ""typedef     struct W""<< className << "" W""<< className << "";\n"";
			//oss.push_back(std::move(os))

			DeclarationMatcher classMatcher = cxxMethodDecl(isPublic(), ofClass(hasName(className))).bind(""publicMethodDecl"");
			Matcher.addMatcher(classMatcher, &HandlerForClassMatcher);
		}

	}

	void HandleTranslationUnit(ASTContext &Context) override {
		// Run the matchers when we have the whole TU parsed.
		Matcher.matchAST(Context);
	}

private:
	OutputStreams& OS;
	classMatchHandler HandlerForClassMatcher;

	MatchFinder Matcher;
};

// For each source file provided to the tool, a new FrontendAction is created.
 class MyFrontendAction: public ASTFrontendAction {
public:
	MyFrontendAction() {
		OS.HeaderOS << 	""#ifndef UTHREADS_CWRAPPER_H\n""
						""#define UTHREADS_CWRAPPER_H_\n""
						""#include <pthread.h>\n""
						""#include <sys/types.h>\n""
						""#include <sys/socket.h>\n""
						""#include <inttypes.h>\n\n""

						""#ifdef __cplusplus\n""
						""extern \""C\""{\n""
						""#endif\n""
						""#include <stdbool.h>\n"";
		OS.BodyOS << ""#include \""generic/basics.h\""\n""
					""#include \""cwrapper.h\""\n""
					""#include \""runtime/uThread.h\""\n""
					""#include \""runtime/uThreadPool.h\""\n""
					""#include \""runtime/kThread.h\""\n""
					""#include \""io/Network.h\""\n""
						""#ifdef __cplusplus\n""
						""extern \""C\""{\n""
						""#endif\n"";

	}

	void EndSourceFileAction() override {

		StringRef headerFile(""cwrapper.h"");
		StringRef bodyFile(""cwrapper.cpp"");

        // Open the output file
        std::error_code EC;
        llvm::raw_fd_ostream HOS(headerFile, EC, llvm::sys::fs::F_None);
        if (EC) {
            llvm::errs() << ""while opening '"" << headerFile<< ""': ""
            << EC.message() << '\n';
            exit(1);
        }
        llvm::raw_fd_ostream BOS(bodyFile, EC, llvm::sys::fs::F_None);
        if (EC) {
            llvm::errs() << ""while opening '"" << bodyFile<< ""': ""
            << EC.message() << '\n';
            exit(1);
        }


		OS.HeaderOS << ""#ifdef __cplusplus\n""
						""}\n""
						""#endif\n""
						""#endif /* UTHREADS_CWRAPPER_H_ */\n"";

		OS.BodyOS<< ""#ifdef __cplusplus\n""
						""}\n""
						""#endif\n"";

		OS.HeaderOS.flush();
		OS.BodyOS.flush();
		HOS<< OS.headerString << ""\n"";
		BOS<< OS.bodyString << ""\n"";

	}

	std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
			StringRef file) override {

		return llvm::make_unique<MyASTConsumer>(OS);
	}

private:
	OutputStreams OS;
};

int main(int argc, const char **argv) {
	// parse the command-line args passed to your code
	CommonOptionsParser op(argc, argv, CPP2CCategory);
	// create a new Clang Tool instance (a LibTooling environment)
	ClangTool Tool(op.getCompilations(), op.getSourcePathList());


	// run the Clang Tool, creating a new FrontendAction
	return Tool.run(newFrontendActionFactory<MyFrontendAction>().get());
}
",CastType
939,"// openmsg by <NAME>
//
// To the extent possible under law, the person who associated CC0 with
// openmsg has waived all copyright and related or neighboring rights
// to openmsg.
//
// You should have received a copy of the CC0 legalcode along with this
// work.  If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.

#pragma once

#if (__cplusplus < 202002L) && !defined(_HAS_CXX20)
#error C++20 or more is needed
#endif

#include ""openmsg/concepts.hpp""
#include ""openmsg/type_traits.hpp""

#include <inttypes.h>
#include <bit>
#include <concepts>
#include <type_traits>

#if defined(__GNUC__) || defined(__clang__)
#include <byteswap.h>
#elif defined(_MSC_VER)
#include <stdlib.h>
#endif

namespace openmsg {

namespace detail_constexpr {

template<std::integral T>
constexpr T __bswap(T value) noexcept
{
    if constexpr (sizeof(T) == 1)
        return value;
    using U = as_uint_type_t<T>;
    using H = as_half_size_t<T>;
    constexpr U shift = sizeof(T) * 4;
    U  [MASK]  = static_cast<U>(value);
    auto msw = __bswap(static_cast<H>( [MASK] ));
    auto lsw = __bswap(static_cast<H>( [MASK]  >> shift));
    return static_cast<T>(static_cast<U>(msw) << shift | static_cast<U>(lsw));
}

template<swappable T>
constexpr T bswap(T value) noexcept
{
    using U = as_uint_type_t<T>;
    return std::bit_cast<T>(__bswap(std::bit_cast<U>(value)));
}

}  // namespace detail_constexpr

template<swappable T>
constexpr T bswap(T x) noexcept
{
    if (std::is_constant_evaluated())
        return detail_constexpr::bswap(x);
    if constexpr (sizeof(T) == 1)
        return x;
    using U = as_uint_type_t<T>;
#if defined(__GNUC__) || defined(__clang__)
    if constexpr (sizeof(T) == 2)
        return std::bit_cast<T>(bswap_16(std::bit_cast<U>(x)));
    if constexpr (sizeof(T) == 4)
        return std::bit_cast<T>(bswap_32(std::bit_cast<U>(x)));
    if constexpr (sizeof(T) == 8)
        return std::bit_cast<T>(bswap_64(std::bit_cast<U>(x)));
#elif defined(_MSC_VER)
    if constexpr (sizeof(T) == 2)
        return std::bit_cast<T>(_byteswap_ushort(std::bit_cast<U>(x)));
    if constexpr (sizeof(T) == 4)
        return std::bit_cast<T>(_byteswap_ulong(std::bit_cast<U>(x)));
    if constexpr (sizeof(T) == 8)
        return std::bit_cast<T>(_byteswap_uint64(std::bit_cast<U>(x)));
#else
    return detail_constexpr::bswap(x);
#endif
}

}  // namespace openmsg
",unsigned_value
940,"/*                  运算符重载
返回类型 operator 运算符符号（形式参数列表）
{
    函数体
}
1.运算符重载为类中的成员函数，此时运算符函数的形式参数个数比运算符规定的个数要少一个，原因是非静态成员
函数都有一个隐含的this指针，运算符函数可以用this指针隐式的访问类对象的成员，因此这个对象自身的数据可以
直接访问，不需要放到形式参数列表里面，少了的运算对象就是对象本身
    双目运算符重载为类函数的定义形式
    返回类型 类名：：operator op（const 所属类型 &obj2）
    {
        ......//this指针指向第一个对象obj1
    }
    obj1 op obj2==obj1.operator（obj2）
2.运算符重载为类的友元函数
函数的形式参数列表的个数不变
3.注意：
前置单目运算符参数只有一个，后置单目运算符在参数列表中要加个int，以区分
4.对流插入和流提取运算符重载具有固定的格式
ostream& operator<<(ostream& os，const 类类型&obj)流提取
{
    os<<.....
    return os;
}
istream& operator>>(istream& is，const 类类型&obj)流插入
{
    is>>......
    return is;
}
//不能作为成员函数
5.类型转换运算符的重载
比如对double的转换，注意不用指定返回类型，和类型运算符保持一致就行
*/
#include<iostream>
using namespace std;
class complex
{
public:
    complex(double a,double b);
    complex()
    {
        cout<<""ok"";
    }
    void output()
    {
        cout<<real<<"" ""<<imag<<endl;
    }
    complex operator-(const complex& obj);
    complex operator++(int);//后置运算符
private:
    double real;
    double imag;
    friend complex operator+(const complex&a,const complex&b);
    friend ostream& operator<<(ostream& os,const complex&obj);
    friend istream& operator>>(istream& is,complex& obj);
};
complex::complex(double a,double b):real(a),imag(b)
{
    cout<<""ok""<<endl;
}
complex operator+(const complex&a,const complex&b)
{
    double real=a.real+b.real;
    double imag=a.imag+b.imag;
    complex result(real,imag);
    return result;
}
complex complex::operator-(const complex&obj)
{
    complex result;
    result.real=this->real-obj.real;
    result.imag=this->imag-obj.imag;
    return result;
}
complex complex::operator++(int)
{
    complex result;
    result.real=real;
    result.imag=imag;
    real++;
    imag++;
    return result;
}
ostream& operator<<(ostream& os,const complex&obj)
{
    os<<""实部为：""<<obj.real<<""虚部为：""<<obj.imag;
    return os;
}
istream& operator>>(istream& is,complex& obj)
{
    char  [MASK] ,ch2;
    is>>obj.real>> [MASK] >>obj.imag>>ch2;
    return is;
}
int main()
{
    complex a(1,2),b(2,2),c;
    c=a+b;
    c.output();
    a++;
    a.output();
    return 0;
}",ch1
941,"#include ""Console.h""

Console::Console(uint32_t width, uint32_t height, uint32_t fontSize) {
	this->width = width;
	this->height = height;
	buffer = new wchar_t[width * height];
	handle = CreateConsoleScreenBuffer(GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
	SetConsoleActiveScreenBuffer(handle);

	CONSOLE_FONT_INFOEX font;
	wcscpy_s(font.FaceName, L""Lucida Console"");
	font.cbSize = sizeof(font);
	font.dwFontSize.X = fontSize;
	font.dwFontSize.Y = fontSize;
	font.FontFamily = FF_DONTCARE;
	font.FontWeight = FW_NORMAL;
	font.nFont = 0;

	SetCurrentConsoleFontEx(handle, false, &font);
}

Console::~Console() {
	delete buffer;
}

void Console::setChar(uint32_t x, uint32_t y, wchar_t chr, bool  [MASK] ) {
	if (x < 0 || x >= width || y < 0 || y >= height) return;
	buffer[y * width + x] = chr;
	if ( [MASK] ) {
		DWORD bytesWritten = 0;
		WriteConsoleOutputCharacter(handle, buffer + width * y + x, 1, { (SHORT)x, (SHORT)y }, &bytesWritten);
	}
}

void Console::flush() {
	DWORD bytesWritten = 0;
	for (uint32_t y = 0; y < height; ++y)
		WriteConsoleOutputCharacter(handle, buffer + width * y, width, { 0, (SHORT)y }, &bytesWritten);
}",updateNow
942,"#include <ctime>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <stdexcept>
#include ""BinarySearchTree.h""

using namespace std;

int getKey_efficiency(int  [MASK] ) {
	return  [MASK] ;
}

int counter;
int compareKeys_efficiency(int keyA, int keyB) {
	counter++;
	return keyA-keyB;
}

class Person {
public:
	string name;
	int age;
	Person(string name, int age):name(name),age(age){}
};

string getKey_usability(Person *person) {
	return person->name;
}

int compareKeys_usability(string nameA, string nameB) {
	return strcmp(nameA.c_str(),nameB.c_str());
}

int main() {
	
	printf(""Testing efficiency.\n"");

	srand(time(NULL));
	
	BinarySearchTree<int,int> *bst_efficiency = new BinarySearchTree<int,int>(getKey_efficiency,compareKeys_efficiency);
	
	int n = 20;
	int N = 1<<n;
	
	counter = 0;	
	for (int i = 0; i < N; i++) bst_efficiency->addContent(rand());
	printf(""Average of %.2lf comparisions to add 2^%d numbers.\n"", (double)counter/(double)N, n);
	
	counter = 0;	
	for (int i = 0; i < N; i++) bst_efficiency->hasKey(rand());
	printf(""Average of %.2lf comparisions to search 2^%d numbers.\n"", (double)counter/(double)N, n);
	
	counter = 0;
	for (int i = 0; i < N; i++) bst_efficiency->removeByKey(rand());
	printf(""Average of %.2lf comparisions to remove 2^%d numbers.\n"", (double)counter/(double)N, n);
	
	delete bst_efficiency;
	
	printf(""\nShowing usability.\n"");
	
	BinarySearchTree<Person*,string> *bst_usability = new BinarySearchTree<Person*,string>(getKey_usability,compareKeys_usability);
	
	Person *p1 = new Person(""ana"", 21),
		*p2 = new Person(""boris"", 23),
		*p3 = new Person(""carl"", 22),
		*p4 = new Person(""darwin"", 24);
	
	bst_usability->addContent(p3);
	bst_usability->addContent(p1);
	bst_usability->addContent(p2);
	bst_usability->addContent(p4);
	
	if (!bst_usability->hasKey(""sean"")) printf(""'sean' has not been found\n"");
	if (bst_usability->hasKey(""ana"")) printf(""'ana' has been found\n"");
	
	bst_usability->removeByKey(""ana"");
	if (!bst_usability->hasKey(""ana"")) printf(""'ana' has not been found\n"");
	
	Person *p = bst_usability->getContentByKey(""boris"");
	printf(""boris is %d years old.\n"", p->age);
	if (bst_usability->hasKey(""boris"")) printf(""'boris' has been found\n"");
	
	p = bst_usability->extractContentByKey(""carl"");
	printf(""carl is %d years old.\n"", p->age);
	if (!bst_usability->hasKey(""carl"")) printf(""'carl' has not been found\n"");
	
	try {
		p = bst_usability->getContentByKey(""carl"");
	} catch (const std::invalid_argument& e) {
		printf(""Exception caught: %s\n"",e.what());
	}
	
	return 0;
}
",content
943,"/*
 * Copyright (C) 2019 Lakoja on github.com
 *
 * 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 __ACTIVITY_MONITOR_H__
#define __ACTIVITY_MONITOR_H__

class ActivityMonitor
{
  static const int LENGTH = 24*4;
private:
  byte values[LENGTH];
  int maximumLength;
  int pointer = 0;
  long sum = 0;
  int count = 0;

public:
  ActivityMonitor(int maxLen)
  {
    maximumLength = min(maxLen, LENGTH);
    memset(values, 0, sizeof(values));
  }

  String dump()
  {
    String s;
    for (int i=0; i<maximumLength; i++) {
      s += String(values[i]) + "" "";
    }

    return s;
  }

  bool record(byte value, int index = -1, bool raiseOnly = false)
  {
    bool internalUsed = true;
    if (index != -1) {
      if (index >= maximumLength || index < -1) {
        Serial.println(""!!!! Illegal index value ""+String(index)+"" vs maximum ""+String(maximumLength));
        return;
      }
      
      internalUsed = false;
    } else {
      index = pointer;
    }

    bool doSomething = !raiseOnly;
    bool valueChanged = false;
    
    if (raiseOnly && value > values[index]) {
      doSomething = true;
    }

    if (doSomething) {
      if (value != values[index]) {
        valueChanged = true;
      }
      
      if (values[index] > 0) {
        sum -= values[index];
        values[index] = 0;
        count--;
      }
      
      values[index] = value;
  
      if (value > 0) {
        sum += value;
        count++;
      }
    }

    if (internalUsed) {
      pointer = (pointer + 1) % maximumLength;
    }

    return valueChanged;
  }

  byte current(int index = -1)
  {
    if (index == -1) {
      int index = pointer - 1;
      if (index < 0) {
        index = index + maximumLength;
      }
    }

    return values[index];
  }

  int countValues()
  {
    return count;
  }

  int countLightBack(int steps)
  {
    int  [MASK]  = 0;
    
    for (int i=0; i<steps; i++) {
      int p = pointer - 1 - i;
      if (p < 0) {
        p = p + maximumLength;
      }

      // TODO this is rather specific knowledge here; and see ino:isDay()
      if (values[p] > 0 && values[p] < 10) {
         [MASK] ++;
      }
    }

    return  [MASK] ;
  }

  long sumValues()
  {
    return sum;
  }

  int maximumCount() {
    return maximumLength;
  }
};

#endif
",lightCounter
944,"#include ""Streaming.h""
#include ""SerialReceiver.h""

SerialReceiver::SerialReceiver() {
    error = SR_ERR_NONE;
    resetState();
    startChar = SR_DFLT_START_CHAR;
    stopChar = SR_DFLT_STOP_CHAR;
    sepChar = SR_DFLT_SEP_CHAR;
    resetState();
}

bool SerialReceiver::messageReady() {
    if (state == SR_STATE_MESSAGE) {
        return true;
    }
    else {
        return false;
    }
}

uint8_t SerialReceiver::numberOfItems() {
    if (state == SR_STATE_MESSAGE) {
        return itemCnt;
    }
    else {
        return 0;
    }
}

char SerialReceiver::readChar(uint8_t itemNum, uint8_t ind) {
    char  [MASK] ;
    if (checkItemRange(itemNum)) {
        if (ind < itemLenBuffer[itemNum]) {
             [MASK]  = itemBuffer[itemNum][ind];
        }
        else {
             [MASK]  = 0;
        }
    }
    else {
         [MASK]  = 0;
    }
    return  [MASK] ;
}

int SerialReceiver::readInt(uint8_t itemNum) {
    if (checkItemRange(itemNum)) {
        return atoi(itemBuffer[itemNum]);
    }
    else {
        return 0;
    }
}

long SerialReceiver::readLong(uint8_t itemNum) {
    if (checkItemRange(itemNum)) {
        return atol(itemBuffer[itemNum]);
    }
    else {
        return 0;
    }
}

double SerialReceiver::readDouble(uint8_t itemNum) {
    if(checkItemRange(itemNum)) {
        return atof(itemBuffer[itemNum]);
    }
    else {
        return 0;
    }
}

float SerialReceiver::readFloat(uint8_t itemNum) {
    return (float) readDouble(itemNum);
}

void SerialReceiver::copyString(uint8_t itemNum, char* string, uint8_t size) {
    if (checkItemRange(itemNum)) {
        strlcpy(string,itemBuffer[itemNum],size);
    }
    else {
        if (size >= 0) {
            string[0] = '\0';
        }
    }
}


bool SerialReceiver::checkItemRange(uint8_t itemNum) {
    if ((state==SR_STATE_MESSAGE) && (itemNum >=0) && (itemNum < itemCnt)) {
        return true;
    }
    else {
        return false;
    }
}

void SerialReceiver::process(int serialByte) {
    if (serialByte > 0){
        switch (state) {
            case SR_STATE_IDLE:
                processNewMsg(serialByte);
                break;
            case SR_STATE_RECEIVING:
                processCurMsg(serialByte);
                break;
            case SR_STATE_MESSAGE:
                break;
            default:
                break;

        }
    }
}

void SerialReceiver::processNewMsg(int serialByte) {
    if (serialByte == startChar) {
        resetItems();
        state = SR_STATE_RECEIVING;
        error = SR_ERR_NONE;
    }
    else if ((serialByte == '\n') || (serialByte == ' ')) {
        return;
    }
    else {
        error = SR_ERR_ILLEGAL_CHAR;
        resetState();
    }
}

void SerialReceiver::processCurMsg(int serialByte) {
    if (serialByte == startChar) {
        handleStartChar(serialByte);
    }
    else if (serialByte == stopChar) {
        handleStopChar(serialByte);
    }

    else if (serialByte == sepChar) {
        handleSepChar(serialByte);
    }

    else {
        handleNewChar(serialByte);
    }
}

void SerialReceiver::handleStartChar(int serialByte) {
    resetState();
    error = SR_ERR_ILLEGAL_CHAR;
}

void SerialReceiver::handleStopChar(int serialByte) {
    if (itemPos > 0) {
        itemBuffer[itemCnt][itemPos] = '\0';
        itemLenBuffer[itemCnt] = itemPos;
        itemCnt++;
    }
    // Check message checksum here .... if not OK reset.
    state = SR_STATE_MESSAGE;
}

void SerialReceiver::handleSepChar(int serialByte) {
    if (itemPos > 0) {
        if (itemCnt == SR_MAX_ITEMS-1) {
            resetState();
            error = SR_ERR_MESSAGE_LENGTH;
        }
        else {
            itemBuffer[itemCnt][itemPos] = '\0';
            itemLenBuffer[itemCnt] = itemPos;
            itemCnt++;
            itemPos = 0;
        }
    }
    else {
        resetState();
        error = SR_ERR_ITEM_LENGTH;
    }
}

void SerialReceiver::handleNewChar(int serialByte) {
    if (itemPos == SR_MAX_ITEM_SZ) {
        resetState();
        error = SR_ERR_ITEM_LENGTH;
    }
    else {
        if ((serialByte == '\n') || (serialByte == ' ')) {
            return;
        }
        itemBuffer[itemCnt][itemPos] = serialByte;
        itemPos++;
    }
}

void SerialReceiver::reset() {
    resetState();
    error = SR_ERR_NONE;
}

void SerialReceiver::resetState() {
    resetItems();
    state = SR_STATE_IDLE;
}

void SerialReceiver::resetItems() {
    itemCnt = 0;
    itemPos = 0;
    for (int i=0; i<SR_MAX_ITEMS;i++) {
        itemBuffer[i][0] = '\0';
        itemLenBuffer[i] = 0;
    }
}

void SerialReceiver::printInfo() {
    Serial << ""Current Message Info"" << endl;
    Serial << ""--------------------"" << endl;
    Serial << ""state:   "" << _DEC(state) << endl;
    Serial << ""error:   "" << _DEC(error) << endl;
    Serial << ""itemCnt: "" << _DEC(itemCnt) << endl;
    Serial << ""itemPos: "" << _DEC(itemPos) << endl;
    for (int i=0; i<itemCnt; i++) {
        Serial << ""buf["" << _DEC(i) << ""] = "" << itemBuffer[i] << endl;
    }
    Serial << endl;
}

void SerialReceiver::printMessageInfo() {
    Serial << ""Message = "" << endl;
    for (int i=0; i<itemCnt; i++) {
        Serial << ""buf["" << _DEC(i) << ""] = "" << itemBuffer[i] << "", len = "" << _DEC(itemLenBuffer[i]) << endl;
    }
    Serial << endl;
}

void SerialReceiver::printMessage() {
    for (int i=0; i<itemCnt; i++) {
        if (i < itemCnt-1) {
            Serial << itemBuffer[i] << "" "";
        }
        else {
            Serial << itemBuffer[i];
        }
    }
    Serial << endl;
}
",rval
945,"
#include ""my_player.h""

#include <godot_cpp/classes/input.hpp>

void MyPlayer::_bind_methods() {
	ClassDB::bind_method(D_METHOD(""set_speed"", ""speed""), &MyPlayer::set_speed);
	ClassDB::bind_method(D_METHOD(""get_speed""), &MyPlayer::get_speed);

	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, ""speed""), ""set_speed"", ""get_speed"");
}

void MyPlayer::_physics_process(double p_delta) {
	Input *input = Input::get_singleton();

	Vector2 velocity;
    if (input->is_action_pressed(""ui_up"")) {
		velocity.y -= 1.0;
    } else if (input->is_action_pressed(""ui_down"")) {
		velocity.y += 1.0;
	} else if (input->is_action_pressed(""ui_left"")) {
		velocity.x -= 1.0;
	} else if (input->is_action_pressed(""ui_right"")) {
		velocity.x += 1.0;
	}
	set_velocity(velocity.normalized() * speed);

	move_and_slide();
}

void MyPlayer::set_speed(float  [MASK] ) {
	speed =  [MASK] ;
}

float MyPlayer::get_speed() const {
	return speed;
}

MyPlayer::MyPlayer() {
}
",p_speed
946,"#include ""coinbutton.h""
#include <QPainter>
CoinButton::CoinButton(QWidget *parent) : QPushButton (parent)
{
     this->setStat(0);

    this->setStyleSheet(""QPushButton{border:0px;}"");

    connect(&this->mTimer,&QTimer::timeout,[=](){
        if (this->mStat){
            this->mFrame--;

        }
        else {
                   this->mFrame++;

        }
        QString frameName =  QString("":/res/Coin000%1.png"").arg(QString::number( this->mFrame));
       this->setIcon(QIcon(frameName));
        if(this->mFrame==8 || this->mFrame == 1 ){
            this->mTimer.stop();
        }


    });
}

int CoinButton::stat() const
{
    return mStat;
}

void CoinButton::setStat(int stat)
{
    mStat = stat;
    if(mStat == 1){
        //金币
        this->setIcon(QIcon( "":/res/Coin0001.png""));

    }
    else {
        //银币
        this->setIcon(QIcon( "":/res/Coin0008.png""));

    }
    this->setIconSize(this->size());


}

void CoinButton::setStatWithAnimation(int stat)
{
    //金币翻银币的过程
    this->setStat(stat);
    if (this->stat())
    {
        this->mFrame = 8;

    }
    else {
        this->mFrame = 1;

    }
    this->mTimer.start(30);




}

void CoinButton::flip()
{
     //this->setStat( 1 - this->stat());


    this->setStatWithAnimation(!this->stat());
}

void CoinButton::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    QPixmap  [MASK] ;

     [MASK] .load("":/res/BoardNode.png"");

    painter.drawPixmap(0,0,this->width(),this->height(), [MASK] );
    QPushButton::paintEvent(event);
}
",pix
947,"#include ""Alarm.hpp""

namespace kjc
{
	Alarm::Alarm() noexcept : _type{ Type::Unknown }
	{
	}

	Alarm::Alarm(Type t) noexcept
		: _type{ t }
	{
	}

	Alarm::Alarm(Type t, String description) noexcept
		: _type{ t }
		, _description{ std::move(description) }
	{
	}

	bool Alarm::operator==(const Alarm& other) const noexcept
	{
		return _type == other.type();
	}

	bool Alarm::operator!=(const Alarm& other) const noexcept
	{
		return !(*this == other);
	}

	Alarm::Type Alarm::type() const noexcept
	{
		return _type;
	}

	const wchar_t* Alarm::as_string() const
	{
		return type_to_string(_type);
	}

	const String& Alarm::description() const
	{
		return _description;
	}

	const wchar_t* Alarm::type_to_string(Type t)
	{
		if (!type_is_valid(t)) {
			return L""Invalid"";
		}

		static constexpr auto name_lookup = std::array{
			L""Unknown"",
			L""Warning"",
			L""Caution"",
			L""Advisory""
		};

		static_assert(Type::TypeCount == Type(3), ""Invalid type count. Check array above"");

		return gsl::at(name_lookup, 1 + static_cast<gsl::index>(t));
	}

	constexpr bool Alarm::type_is_valid(Type t)
	{
		return static_cast<gsl::index>(t) < static_cast<gsl::index>(Type::TypeCount) && static_cast<gsl::index>(t) >= -1;
	}

	Alarm make_alarm(Alarm::Type t)
	{
		static const auto  [MASK]  = std::map<Alarm::Type, String>{
			{Alarm::Type::Advisory, L""This is an advisory alarm. Can be ignored safely, but something is not quite right"" },
			{Alarm::Type::Caution, L""Take care!""},
			{Alarm::Type::Warning, L""Warn!""}
		};

		return Alarm{ t,  [MASK] .at(t) };
	}

	Alarm make_random_alarm(std::mt19937_64& rng)
	{
		return make_alarm( Alarm::Type{ std::uniform_int_distribution<>{0, static_cast<int>(Alarm::Type::TypeCount) - 1}(rng)} );
	}
}
",descriptions
948,"// Copyright (c) 2009-2010 <NAME>
// Copyright (c) 2009-2018 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef BCEX_STRENCODINGS_H
#define BCEX_STRENCODINGS_H

#include <cstdint>
#include <iterator>
#include <string>
#include <vector>

// Used by SanitizeString()
enum SafeChars
{
    SAFE_CHARS_DEFAULT,     //!< The full set of allowed chars
    SAFE_CHARS_UA_COMMENT,  //!< BIP-0014 subset
    SAFE_CHARS_FILENAME,    //!< Chars allowed in filenames
    SAFE_CHARS_URI,         //!< Chars allowed in URIs (RFC 3986)
};

std::string SanitizeString(const std::string& str,int rule = SAFE_CHARS_DEFAULT);
std::vector<unsigned char> ParseHex(const char* psz);
std::vector<unsigned char> ParseHex(const std::string& str);
signed char HexDigit(char c);

bool IsHex(const std::string& str);

bool IsHexNumber(const std::string& str);

std::vector<unsigned char> DecodeBase64(const char* p,bool* pf_invalid = nullptr);
std::string DecodeBase64(const std::string& str,bool* pf_invalid = nullptr);
std::string EncodeBase64(const unsigned char* pch,size_t len);
std::string EncodeBase64(const std::string& str);

std::vector<unsigned char> DecodeBase32(const char* p, bool* pf_invalid = nullptr);
std::string DecodeBase32(const std::string& str, bool* pf_invalid = nullptr);
std::string EncodeBase32(const unsigned char* pch, size_t len);
std::string EncodeBase32(const std::string& str);

void SplitHostPort(std::string in,int &portOut,std::string &hostOut);

std::string i64toStr(int64_t n);
std::string itoStr(int n);
int64_t atoi64(const char* psz);
int64_t atoi64(const std::string& str);
int atoi(const std::string& str);

// 是否是数字
constexpr bool IsDigit(char c)
{
    return c >= '0' && c <= '9';
}

// 判断空格
constexpr inline bool IsSpace(char c) noexcept
{
    return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v';
}

bool ParseInt32(const std::string& str,int32_t *out);
bool ParseInt64(const std::string& str,int64_t *out);
bool ParseUInt32(const std::string& str, uint32_t *out);
bool ParseUInt64(const std::string& str, uint64_t *out);
bool ParseDouble(const std::string& str, double *out);

template<typename T>
std::string HexStr(const T itbegin, const T itend)
{
    std::string rv;
    static const char hexmap[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
                                     '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
    rv.reserve(std::distance(itbegin, itend) * 2);
    for(T it = itbegin; it < itend; ++it)
    {
        unsigned char val = (unsigned char)(*it);
        rv.push_back(hexmap[val>>4]);
        rv.push_back(hexmap[val&15]);
    }
    return rv;
}

template<typename T>
inline std::string HexStr(const T& vch)
{
    return HexStr(vch.begin(), vch.end());
}

std::string FormatParagraph(const std::string& in, size_t width = 79, size_t indent = 0);


template <typename T>
bool TimingResistantEqual(const T& a, const T& b)
{
    if (b.size() == 0) return a.size() == 0;
    size_t  [MASK]  = a.size() ^ b.size();
    for (size_t i = 0; i < a.size(); i++)
         [MASK]  |= a[i] ^ b[i%b.size()];
    return  [MASK]  == 0;
}

bool ParseFixedPoint(const std::string &val, int decimals, int64_t *amount_out);

template<int frombits, int tobits, bool pad, typename O, typename I>
bool ConvertBits(const O& outfn, I it, I end) {
    size_t acc = 0;
    size_t bits = 0;
    constexpr size_t maxv = (1 << tobits) - 1;
    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
    while (it != end) {
        acc = ((acc << frombits) | *it) & max_acc;
        bits += frombits;
        while (bits >= tobits) {
            bits -= tobits;
            outfn((acc >> bits) & maxv);
        }
        ++it;
    }
    if (pad) {
        if (bits) outfn((acc << (tobits - bits)) & maxv);
    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
        return false;
    }
    return true;
}

constexpr char ToLower(char c)
{
    return (c >= 'A' && c <= 'Z' ? (c - 'A') + 'a' : c);
}

constexpr char ToUpper(char c)
{
    return (c >= 'a' && c <= 'z' ? (c - 'a') + 'A' : c);
}

void Downcase(std::string& str);

std::string Capitalize(std::string str);


#endif // BCEX_STRENCODINGS_H
",accumulator
949,"
#include <mdrTreeStyleTabs/ITabWidget.hpp>
#include <mdrTreeStyleTabs/Node.hpp>
#include <mdrTreeStyleTabs/TabWidgetFactory.hpp>
#include <mdrTreeStyleTabs/TreeStyleTabs.hpp>

#include <QtWidgets/QApplication>
#include <QtWidgets/QMainWindow>
#include <QtWidgets/QPushButton>
#include <QtGui/QMouseEvent>
#include <QtGui/QDrag>
#include <QtCore/QMimeData>
#include <QtCore/QList>
#include <QtGui/QFrame>
#include <QtCore/QtAlgorithms>
#include <QtGui/QPainter>
#include <QtWidgets/QScrollArea>
#include <QtCore/QObject>

#include <iostream>
#include <stdexcept>

#define SAVE

int main(int argc, char *argv[]) {
    using namespace mdr;

    QApplication app(argc, argv);

    QMainWindow main_window;

    auto  [MASK]  = std::make_shared<TabWidgetFactory>();

    TreeStyleTabs tree_style_tabs(&main_window,  [MASK] );

    QObject::connect(&tree_style_tabs, &TreeStyleTabs::tabCloseRequested,
                     &tree_style_tabs, &TreeStyleTabs::close);

    main_window.setCentralWidget(&tree_style_tabs);
#ifdef SAVE
    Node* root = tree_style_tabs.getRoot();

    Node* child1 = tree_style_tabs.create();
    child1->getWidget()->setText(""Hello1"");
    child1->getWidget()->setIcon(QIcon("":/icons/close.png""));

    Node* child2 = tree_style_tabs.create();
    child2->getWidget()->setText(""Hello2"");

    Node* child3 = tree_style_tabs.create();
    child3->getWidget()->setText(""Hello3"");
    child3->setParent(child2);

    // child1->getWidget()->setEnabled(false);

    // child2->getWidget()->setCollapsed();
    // tree_style_tabs.close(child3);

    for(int i = 0; i < 10; ++i) {
        Node* child = tree_style_tabs.create();
        child->getWidget()->setText(""Tab"" + QString::number(i));
    }

    tree_style_tabs.updateTabWidgets();

    main_window.show();
    tree_style_tabs.show();

    // tree_style_tabs.setTabHeight(40);
    // tree_style_tabs.setShiftPerDepth(20);
    // tree_style_tabs.setAlignment(Qt::AlignLeft);

    QFile file(""file.dat"");
    file.open(QIODevice::WriteOnly);
    QDataStream out(&file);

    out << tree_style_tabs;
#else /* SAVE */
    QFile file(""file.dat"");
    file.open(QIODevice::ReadOnly);
    QDataStream in(&file);

    in >> tree_style_tabs;

    main_window.show();
    tree_style_tabs.show();
#endif /* SAVE */

    return app.exec();
}
",widget_factory
950,"#include ""Building.h""

#include <assert.h>
#include <cmath>

#include ""Game.h""

const uint32_t Building::UPGRADE_COLORS[MAX_UPGRADE] { 0xFFFF00FF, 0x00FF00FF, 0x00FFFFFF, 0xFF00FFFF, 0xFF0000FF };
const int Building::LIFE_VALUES[MAX_UPGRADE] { 8, 10, 13, 15, 17 };

Building::Building(Game* game, sf::Vector2i pos, sf::Vector2i size, sf::Texture* colorBase, sf::Texture* base, int upgradeCost, int lifeMultiplyer) :
    level(1),
    upgradeCostMultiplyer(upgradeCost),
    game(game),
    pos(pos),
    size(size),
    lifeMultiplyer(lifeMultiplyer),
    maxLife(lifeMultiplyer * LIFE_VALUES[level - 1])
{
    assert(size.x > 0 && size.y > 0);
    assert(maxLife > 0);

    regen();

    colorBaseSprite.setTexture(*colorBase);
    colorBaseSprite.scale(4.f, 4.f);
    colorBaseSprite.setPosition(sf::Vector2f(32.f * pos.x + 100.f, 32.f * pos.y + 100.f));
    colorBaseSprite.setColor(sf::Color(UPGRADE_COLORS[level - 1]));

    baseSprite.setTexture(*base);
    baseSprite.scale(4.f, 4.f);
    baseSprite.setPosition(sf::Vector2f(32.f * pos.x + 100.f, 32.f * pos.y + 100.f));
    baseSprite.setColor(sf::Color::White);

    healthBarBase.setSize(sf::Vector2f(30.f, 5.f));
    healthBarBase.setPosition(sf::Vector2f(32.f * pos.x + 100.f + 1.f + (size.x - 1) * 16.f, 32.f * pos.y + 100.f + 26.f  + (size.y - 1) * 32.f));
    healthBarBase.setFillColor(sf::Color::Black);

    healthBar.setSize(sf::Vector2f(30.f, 5.f));
    healthBar.setPosition(sf::Vector2f(32.f * pos.x + 100.f + 1.f + (size.x - 1) * 16.f, 32.f * pos.y + 100.f + 26.f + (size.y - 1) * 32.f));
    healthBar.setFillColor(sf::Color::Green);

    center = baseSprite.getPosition() + sf::Vector2f(16.f * size.x, 16.f * size.y);
}

Building::~Building()
{
    //dtor
}

void Building::baseDraw(sf::RenderTarget& target) const
{
    target.draw(colorBaseSprite);
    target.draw(baseSprite);
}

void Building::drawHealthbar(sf::RenderTarget& target) const
{
    if (life == maxLife)
        return;
    target.draw(healthBarBase);
    if (life < 0)
        return;
    target.draw(healthBar);
}

void Building::drawMore(sf::RenderTarget& target) const {}

void Building::update(float delta)
{
    updateLife();
}

void Building::updateLife()
{
    if (dead)
        return;
    healthBar.setSize(sf::Vector2f(30.f * ((float)life / maxLife), 5.f));
    if (life <= 0)
    {
        dead = true;
        setColor(sf::Color::Black);
        game->getLevel()->removeBuilding(this);
    }
}

bool Building::canBeUpgraded() const
{
     return (level < MAX_UPGRADE && game->money >= level * upgradeCostMultiplyer && (this == game->getTreasure() || level < game->getTreasure()->getLevel()));
}

bool Building::upgrade()
{
    if (canBeUpgraded())
    {
        game->money -= level * upgradeCostMultiplyer;
        level++;
        colorBaseSprite.setColor(sf::Color(UPGRADE_COLORS[level - 1]));
        maxLife = lifeMultiplyer * LIFE_VALUES[level - 1];
        regen();
        return true;
    }
    else
        return false;
}

float Building::getAngularPos(sf::Vector2f target) const
{
    sf::Vector2f rpos = target - getCenter();
    float dist = sqrt(rpos.x * rpos.x + rpos.y * rpos.y);
    float xdist = rpos.x / dist;
    float pangl = toDegrees(acos(xdist));
    if (rpos.y < 0)
    {
        pangl = -pangl;
    }
    return pangl;
}

float Building::toDegrees(float  [MASK] )
{
    return ( [MASK]  / (2.f * 3.141592f)) * 360.f;
}

float Building::toRads(float degrees)
{
    return (degrees / 360.f) * (2.f * 3.141592f);
}

",rads
951,"/****************************************************************************
 * Copyright 2016 BlueMasters
 *
 * 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 <Arduino.h>

#include ""AsnLMsg.h""
#include ""App.h""
#include ""AsnLWriter.h""
#include ""AsnLParser.h""
#include <EEPROM.h>

#define CONF0_MAGIC        0x576D1D52
#define CONF0_EEPROM_START 0x0000

#define CONF0_MAGIC_ADDR               (CONF0_EEPROM_START)         // uint32
#define CONF0_PIN_ADDR                 (CONF0_EEPROM_START + 4)     // String
#define CONF0_DI_ADDR                  (CONF0_EEPROM_START + 28)    // uint16
#define CONF0_DF_ADDR                  (CONF0_EEPROM_START + 30)    // uint16

#define CONF0_IDLE_COLOR_ON_ADDR       (CONF0_EEPROM_START + 32)    // uint32
#define CONF0_IDLE_COLOR_OFF_ADDR      (CONF0_EEPROM_START + 36)    // uint32
#define CONF0_IDLE_TIME_ON_ADDR        (CONF0_EEPROM_START + 40)    // uint16
#define CONF0_IDLE_TIME_OFF_ADDR       (CONF0_EEPROM_START + 42)    // uint16

#define CONF0_MAX_PIN_LEN (CONF0_DF_ADDR - CONF0_PIN_ADDR - 1)

#define CONF0_ENQ          '>'
#define CONF0_ACK          '!'
#define CONF0_REACTION_TIME 500
#define CONF0_BUFFER_SIZE   64

int conf0ReadEEPROM() {
    uint32_t magic;
    char buffer[CONF0_MAX_PIN_LEN + 1];
    EEPROM.get(CONF0_MAGIC_ADDR, magic);
    if (magic == CONF0_MAGIC) {
        int i = 0;
        while (i < CONF0_MAX_PIN_LEN) {
            char c = EEPROM[CONF0_PIN_ADDR + i];
            if (c == 0) break;
            buffer[i++] = c;
        }
        buffer[i] = '\x00';
        app.pinCode = String(buffer);
        EEPROM.get(CONF0_DI_ADDR, app.DI);
        EEPROM.get(CONF0_DF_ADDR, app.DF);
        EEPROM.get(CONF0_IDLE_COLOR_ON_ADDR, app.idleColorOn);
        EEPROM.get(CONF0_IDLE_COLOR_OFF_ADDR, app.idleColorOff);
        EEPROM.get(CONF0_IDLE_TIME_ON_ADDR, app.idleTicksOn);
        EEPROM.get(CONF0_IDLE_TIME_OFF_ADDR, app.idleTicksOff);
        return 0;
    } else {
        return -1;
    }
}

int conf0WriteEEPROM() {
    uint32_t magic = CONF0_MAGIC;
    char buffer[CONF0_MAX_PIN_LEN + 1];
    app.pinCode.toCharArray(buffer, CONF0_MAX_PIN_LEN + 1);

    EEPROM.put(CONF0_MAGIC_ADDR, magic);
    int i = 0;
    while (i < CONF0_MAX_PIN_LEN) {
        char c = buffer[i];
        EEPROM[CONF0_PIN_ADDR + i] = c;
        if (c == 0) break;
        i++;
    }
    EEPROM[CONF0_PIN_ADDR + i] = 0;
    EEPROM.put(CONF0_DI_ADDR, app.DI);
    EEPROM.put(CONF0_DF_ADDR, app.DF);
    EEPROM.put(CONF0_IDLE_COLOR_ON_ADDR, app.idleColorOn);
    EEPROM.put(CONF0_IDLE_COLOR_OFF_ADDR, app.idleColorOff);
    EEPROM.put(CONF0_IDLE_TIME_ON_ADDR, app.idleTicksOn);
    EEPROM.put(CONF0_IDLE_TIME_OFF_ADDR, app.idleTicksOff);
    return 0;
}

int conf0GetChar() {
    while (Serial.available() <= 0) {};
    return Serial.read();
}

int conf0GetCharTimeout(unsigned long  [MASK] ) {
    unsigned long now = millis();
    while ((millis() - now) <  [MASK] ) {
        if (Serial.available()) {
            return Serial.read();
        }
    };
    return -1;
}

bool checkToken(AsnLParser& p, int token) {
    int t = p.nextToken();
    return t == token;
}

void result(AsnLParser& p, AsnLWriter& w, int code) {
    p.close();
    w.init();
    w.structure();
    w.integer(1, code);
    w.endStructure();
    w.msg().writeToSerial();
}

void dumpVars(AsnLParser& p, AsnLWriter& w) {
    if (!checkToken(p, ASNL_END_STRUCT)) {
        result(p, w, 0); return;
    }
    if (!checkToken(p, ASNL_NIL)) {
        result(p, w, 0); return;
    }

    w.init();
    w.structure();
    w.integer(1, 1); // Status OK
    w.structure();
    w.string(app.pinCode);
    w.integer(2, app.DI);
    w.integer(2, app.DF);
    w.integer(4, app.idleColorOn);
    w.integer(4, app.idleColorOff);
    w.integer(2, app.idleTicksOn);
    w.integer(2, app.idleTicksOff);
    w.endStructure();
    w.endStructure();

    w.msg().writeToSerial();
    digitalWrite(13, LOW);

}

static void setPinCode(AsnLParser& p, AsnLWriter& w) {
    char pinCode[8];
    if (checkToken(p, ASNL_STRING)) {
        if (!p.readString(pinCode, 8)) {
            result(p, w, 0); return; // failed to read string
        }
    } else {
        result(p, w, 0); return; // not a string
    }
    if (!checkToken(p, ASNL_END_STRUCT)) {
        result(p, w, 0); return;
    }
    if (!checkToken(p, ASNL_NIL)) {
        result(p, w, 0); return;
    }
    app.pinCode = String(pinCode);
    result(p, w, 1);
}

static int16_t extractInt16(AsnLParser& p, AsnLWriter& w) {
    int16_t value;
    if (checkToken(p, ASNL_INT)) {
        if (p.readInt(&value) != 0) {
            result(p, w, 0); return -1; // failed to read int
        }
    } else {
        result(p, w, 0); return -1; // not an int
    }
    if (!checkToken(p, ASNL_END_STRUCT)) {
        result(p, w, 0); return -1;
    }
    if (!checkToken(p, ASNL_NIL)) {
        result(p, w, 0); return -1;
    }
    result(p, w, 1);
    return value;
}

static int32_t extractInt32(AsnLParser& p, AsnLWriter& w) {
    int32_t value;
    if (checkToken(p, ASNL_INT)) {
        if (p.readInt(&value) != 0) {
            result(p, w, 0); return -1; // failed to read int
        }
    } else {
        result(p, w, 0); return -1; // not an int
    }
    if (!checkToken(p, ASNL_END_STRUCT)) {
        result(p, w, 0); return -1;
    }
    if (!checkToken(p, ASNL_NIL)) {
        result(p, w, 0); return -1;
    }
    result(p, w, 1);
    return value;
}

static void save(AsnLParser& p, AsnLWriter& w, bool dirty) {
    if (dirty) {
        conf0WriteEEPROM();
    }
    result(p, w, 1);
}

static void conf0Dialog() {
    bool dirty = false;

    AsnLMsg msg = AsnLMsg(CONF0_BUFFER_SIZE);
    AsnLParser p = AsnLParser(msg);
    AsnLWriter w = AsnLWriter(msg);
    while (1) {
        msg.readFromSerial();
        p.init();
        if (!checkToken(p, ASNL_STRUCT)) { // invalid message (not a structure)
            result(p, w, 0);
            continue;
        }
        if (!checkToken(p, ASNL_INT)) { // invalid message (not and integer)
            result(p, w, 0);
            continue;
        }
        int command;
        p.readInt(&command);
        switch (command) {
        case 'd': dumpVars(p, w); break;
        case 'p': setPinCode(p, w); dirty = true; break;
        case 'i': app.DI = extractInt16(p, w); dirty = true; break;
        case 'f': app.DF = extractInt16(p, w); dirty = true; break;
        case 'l': app.idleColorOn = extractInt32(p, w); dirty = true; break;
        case 'm': app.idleColorOff = extractInt32(p, w); dirty = true; break;
        case '1': app.idleTicksOn = extractInt16(p, w); dirty = true; break;
        case '0': app.idleTicksOff = extractInt16(p, w); dirty = true; break;
        case 's': save(p, w, dirty); dirty = false; break;
        case 'x': result(p, w, 1); return; // exit
        default: result(p, w, 0); break; // invalid command
        }
    }
}

void conf0Configure() {
    app.pinCode = ""000"";
    app.DI = 1000;
    app.DF = 2000;
    app.idleColorOn  = 0x333333;
    app.idleColorOff = 0x111111;
    app.idleTicksOn   = 20;
    app.idleTicksOff  = -1;
    conf0ReadEEPROM();
    Serial.write(CONF0_ENQ);
    int res = conf0GetCharTimeout(CONF0_REACTION_TIME);
    if (res == CONF0_ACK) {
        conf0Dialog();
    }
}
",timeout
952,"#ifndef ASHKAL_BOUNDING_BOX_HPP
#define ASHKAL_BOUNDING_BOX_HPP
#include <cmath>
#include <ostream>
#include ""Ashkal/Matrix.hpp""
#include ""Ashkal/Point.hpp""
#include ""Ashkal/Vector.hpp""

namespace Ashkal {

  /**
   * Represents an axis-aligned box defined by minimum and maximum corner
   * points.
   */
  class BoundingBox {
    public:

      /** Constructs a unit cube centered at the origin. */
      BoundingBox();

      /**
       * Constructs a BoundingBox along two corners.
       * @param minimum The minimum corner.
       * @param maximum The maximum corner.
       */
      BoundingBox(const Point& minimum, const Point& maximum);

      /** Returns the minimum (corner) point of the bounding box. */
      const Point& get_minimum() const;

      /** Returns the maximum (corner) point of the bounding box. */
      const Point& get_maximum() const;

      /**
       * Applies an affine transformation to the bounding box and updates its
       * axis-aligned bounds.
       * @param transformation The matrix representing the affine transform.
       */
      void apply(const Matrix& transformation);

    private:
      Point m_minimum;
      Point m_maximum;
  };

  /**
   * Computes the bounding box that encloses two input boxes.
   * @param a The first bounding box.
   * @param b The second bounding box.
   * @return A BoundingBox that fully contains both input boxes.
   */
  inline BoundingBox merge(const BoundingBox& a, const BoundingBox& b) {
    auto min_x = std::min(a.get_minimum().m_x, b.get_minimum().m_x);
    auto  [MASK]  = std::min(a.get_minimum().m_y, b.get_minimum().m_y);
    auto min_z = std::min(a.get_minimum().m_z, b.get_minimum().m_z);
    auto max_x = std::max(a.get_maximum().m_x, b.get_maximum().m_x);
    auto max_y = std::max(a.get_maximum().m_y, b.get_maximum().m_y);
    auto max_z = std::max(a.get_maximum().m_z, b.get_maximum().m_z);
    return BoundingBox(Point(min_x,  [MASK] , min_z), Point(max_x, max_y, max_z));
  }

  /**
   * Tests whether two bounding boxes overlap.
   * @param a First bounding box.
   * @param b Second bounding box.
   * @return True iff boxes intersect on all three axes.
   */
  inline bool intersects(const BoundingBox& a, const BoundingBox& b) {
    return a.get_minimum().m_x <= b.get_maximum().m_x &&
      a.get_maximum().m_x >= b.get_minimum().m_x &&
      a.get_minimum().m_y <= b.get_maximum().m_y &&
      a.get_maximum().m_y >= b.get_minimum().m_y &&
      a.get_minimum().m_z <= b.get_maximum().m_z &&
      a.get_maximum().m_z >= b.get_minimum().m_z;
  }

  /**
   * Tests if a point lies within or on the boundary of a bounding box.
   * @param box The bounding box to test.
   * @param point The point to check.
   * @return True iff the point is inside or on the box.
   */
  inline bool contains(const BoundingBox& box, const Point& point) {
    return point.m_x >= box.get_minimum().m_x &&
      point.m_x <= box.get_maximum().m_x &&
      point.m_y >= box.get_minimum().m_y &&
      point.m_y <= box.get_maximum().m_y &&
      point.m_z >= box.get_minimum().m_z && point.m_z <= box.get_maximum().m_z;
  }

  inline std::ostream& operator <<(std::ostream& out, const BoundingBox& box) {
    return out << ""BoundingBox("" << box.get_minimum() << "", "" <<
      box.get_maximum() << ')';
  }

  inline BoundingBox::BoundingBox()
    : BoundingBox(Point(-0.5f, -0.5f, -0.5f), Point(0.5f, 0.5f, 0.5f)) {}

  inline BoundingBox::BoundingBox(const Point& minimum, const Point& maximum)
    : m_minimum(minimum),
      m_maximum(maximum) {}

  inline const Point& BoundingBox::get_minimum() const {
    return m_minimum;
  }

  inline const Point& BoundingBox::get_maximum() const {
    return m_maximum;
  }

  inline void BoundingBox::apply(const Matrix& transformation) {
    auto center = Point((m_minimum.m_x + m_maximum.m_x) * 0.5f,
      (m_minimum.m_y + m_maximum.m_y) * 0.5f,
      (m_minimum.m_z + m_maximum.m_z) * 0.5f);
    auto half_point = Vector((m_maximum.m_x - m_minimum.m_x) * 0.5f,
      (m_maximum.m_y - m_minimum.m_y) * 0.5f,
      (m_maximum.m_z - m_minimum.m_z) * 0.5f);
    auto new_center = transformation * center;
    auto vx = transformation * Vector(half_point.m_x, 0, 0);
    auto vy = transformation * Vector(0, half_point.m_y, 0);
    auto vz = transformation * Vector(0, 0, half_point.m_z);
    auto new_half_point =
      Vector(std::abs(vx.m_x) + std::abs(vy.m_x) + std::abs(vz.m_x),
        std::abs(vx.m_y) + std::abs(vy.m_y) + std::abs(vz.m_y),
        std::abs(vx.m_z) + std::abs(vy.m_z) + std::abs(vz.m_z));
    m_minimum.m_x = new_center.m_x - new_half_point.m_x;
    m_minimum.m_y = new_center.m_y - new_half_point.m_y;
    m_minimum.m_z = new_center.m_z - new_half_point.m_z;
    m_maximum.m_x = new_center.m_x + new_half_point.m_x;
    m_maximum.m_y = new_center.m_y + new_half_point.m_y;
    m_maximum.m_z = new_center.m_z + new_half_point.m_z;
  }
}

#endif
",min_y
953,"#include""tgepch.h""
#include""Editor2D.h""
#include""imgui/imgui.h""
#include <glm/gtc/type_ptr.hpp>
#include""TurboGE/Events/AppEvent.h""
#include""TurboGE/Renderer/Renderer2D.h""
#include""TurboGE/Application.h""
#include""TurboGE/Scene/Components.h""
#include""TurboGE/Scene/SceneSerializer.h""
#include""TurboGE/Utils/PlatformUtils.h""
#include""ImGuizmo.h""
namespace TurboGE
{
    void Editor2D::OnAttach()
    {
        m_Renderer = Renderer::Create();
        m_Renderer->Init();
        renderer2DInstance.Init();

        m_Scene = std::make_shared<Scene>(m_ViewportSize);
        entityPanel(m_Scene);

        FrameBufferSpec fbSpec;
        fbSpec.formats = { FrameBufferFormat::RGBA8, FrameBufferFormat::RED_INT, FrameBufferFormat::DEPTH24_STENCIL8 };
        fbSpec.width = 1920;
        fbSpec.height = 1080;
        m_FrameBuffer = FrameBuffer::Create(fbSpec);
    }

    void Editor2D::onUpdate(Time delta)
    {
        if (FrameBufferSpec spec = m_FrameBuffer->GetSpecification();
            m_ViewportSize.x > 0.0f && m_ViewportSize.y > 0.0f && // zero sized framebuffer is invalid
            (spec.width != m_ViewportSize.x || spec.height != m_ViewportSize.y))
        {
            m_FrameBuffer->SetFrameSpec({ (uint32_t)m_ViewportSize.x, (uint32_t)m_ViewportSize.y });
            m_EditorCamera.SetViewportSize((uint32_t)m_ViewportSize.x, (uint32_t)m_ViewportSize.y);
            m_Scene->OnResize((uint32_t)m_ViewportSize.x, (uint32_t)m_ViewportSize.y);

        }

        TGE_PROFILE_FUNCTION();
        renderer2DInstance.ResetStats();
        {
            TGE_PROFILE_SCOPE(""Render prep"");
            m_FrameBuffer->Bind();
            m_Renderer->setClearColor();
            m_Renderer->Clear();
            m_FrameBuffer->ClearEntityAttachment(1, -1);
        }

        {
            TGE_PROFILE_SCOPE(""Draw Render"");

            if (playPanel.isPlay)
            {
                if (playPanel.toggle)
                {
                    tempData = Serialize(); //SAVE CURRENT CONFIG
                    m_Physics = std::make_shared<Physics2D>(m_Scene);
                }
                m_Scene->onUpdatePlay(delta, m_Physics, m_ShowPhysicsColliders);
            }
            else
            {
                m_EditorCamera.OnUpdate(delta);
                m_Scene->onUpdateEditor(delta, m_EditorCamera, m_ShowPhysicsColliders);
                if (playPanel.toggle)
                {
                    m_Physics.reset();
                    Deserialize(); //LOAD CURRENT CONFIG
                }
            }

            auto [mx, my] = ImGui::GetMousePos();
            mx -= m_BoundsArray[0].x;
            my -= m_BoundsArray[0].y;

            glm::vec2 viewportSize = m_BoundsArray[1] - m_BoundsArray[0];
            my = viewportSize.y - my;
            int mouseX = (int)mx;
            int mouseY = (int)my;
            if (mouseX >= 0 && mouseY >= 0 && mouseX < (int)viewportSize.x && mouseY < (int)viewportSize.y)
            {
                int pixelData = m_FrameBuffer->GetPixelData(1, mouseX, mouseY);
                m_ClickedEntity = pixelData == -1 ? Entity{} : Entity{ (entt::entity)pixelData, m_Scene.get() };
            }

            m_FrameBuffer->Unbind();
        }
    }

    void Editor2D::onEvent(Event& e)
    {
        //RENDER NEW AREAS AFTER SIZE IS INCREASED
        
        if (e.getEventType() == EventType::WindowSizeEvent)
        {
            auto& winEvent = dynamic_cast<WindowSizeEvent&>(e);
            m_Renderer->setViewPort(winEvent.GetWidth(), winEvent.GetHeight());
        }

        if (e.getEventType() == EventType::MouseScrollEvent)
        {
            m_EditorCamera.OnEvent(e);
        }
        if (e.getEventType() == EventType::MousePressEvent)
        {
            auto& mousePressEvent = dynamic_cast<MousePressEvent&>(e);
            if (mousePressEvent.getMouseButton() == (int)MouseCode::ButtonLeft && m_ViewportHovered && !Input::isKeyPressed(Key::LeftAlt) && !ImGuizmo::IsOver())
            {
                entityPanel.SetSelectedEntity(m_ClickedEntity);
                m_Scene->HighlightEntity((int)m_ClickedEntity);
            }
        }

        //KEY PRESS

        //SHORTCUTS
        if (Input::isKeyPressed(Key::LeftControl) && Input::isKeyPressed(Key::O))
        {
            if (m_DialogDone)
            {
                m_DialogDone = false;
                LoadScene();
            }
        }
        if (Input::isKeyPressed(Key::LeftControl) && Input::isKeyPressed(Key::N))
        {
            NewScene();

        }
        if (Input::isKeyPressed(Key::LeftControl) && Input::isKeyPressed(Key::LeftAlt) && Input::isKeyPressed(Key::S))
        {
            if (m_DialogDone)
            {
                m_DialogDone = false;
                SaveScene();
            }
            

        }
        else if (Input::isKeyPressed(Key::LeftControl) && Input::isKeyPressed(Key::S))
        {
            if (m_CurrentSceneFile.empty())
            {
                if (m_DialogDone)
                {
                    m_DialogDone = false;
                    SaveScene();
                }
            }
            else
            {
                SaveScene(m_CurrentSceneFile);
            }
        }

        //GIZMOS

        if (Input::inputViewPort == Input::InputViewport::EDITOR)
        {
            if (Input::isKeyPressed(Key::G))
            {
                m_TransformGizmo = (int)ImGuizmo::OPERATION::TRANSLATE;
            }
            else if (Input::isKeyPressed(Key::R))
            {
                m_TransformGizmo = (int)ImGuizmo::OPERATION::ROTATE;
            }
            else if (Input::isKeyPressed(Key::S)) //TODO::Change S in Zoom
            {
                m_TransformGizmo = (int)ImGuizmo::OPERATION::SCALE;
            }

            //SNAP
            if (Input::isKeyPressed(Key::LeftControl))
            {
                m_Snap = !m_Snap; //TODO:: Disable snap when ctrl+O for opening file
            }
        }

    }

    void Editor2D::renderCustom()
    {
        TGE_PROFILE_FUNCTION();


        bool v = true;
        bool* p_open = &v;
        static bool opt_fullscreen = true;
        static bool opt_padding = false;
        static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_None;

        // We are using the ImGuiWindowFlags_NoDocking flag to make the parent window not dockable into,
        // because it would be confusing to have two docking targets within each others.
        ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
        if (opt_fullscreen)
        {
            const ImGuiViewport* viewport = ImGui::GetMainViewport();
            ImGui::SetNextWindowPos(viewport->WorkPos);
            ImGui::SetNextWindowSize(viewport->WorkSize);
            ImGui::SetNextWindowViewport(viewport->ID);
            ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
            ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
            window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
            window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
        }
        else
        {
            dockspace_flags &= ~ImGuiDockNodeFlags_PassthruCentralNode;
        }

        // When using ImGuiDockNodeFlags_PassthruCentralNode, DockSpace() will render our background
        // and handle the pass-thru hole, so we ask Begin() to not render a background.
        if (dockspace_flags & ImGuiDockNodeFlags_PassthruCentralNode)
            window_flags |= ImGuiWindowFlags_NoBackground;

        // Important: note that we proceed even if Begin() returns false (aka window is collapsed).
        // This is because we want to keep our DockSpace() active. If a DockSpace() is inactive,
        // all active windows docked into it will lose their parent and become undocked.
        // We cannot preserve the docking relationship between an active window and an inactive docking, otherwise
        // any change of dockspace/settings would lead to windows being stuck in limbo and never being visible.
        if (!opt_padding)
            ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
        ImGui::Begin(""DockSpace Demo"", p_open, window_flags);
        if (!opt_padding)
            ImGui::PopStyleVar();

        if (opt_fullscreen)
            ImGui::PopStyleVar(2);

        // Submit the DockSpace
        ImGuiIO& io = ImGui::GetIO();
        ImGuiStyle& style = ImGui::GetStyle();
        float  [MASK]  = style.WindowMinSize.x;
        style.WindowMinSize.x = 370.0f;
        if (io.ConfigFlags & ImGuiConfigFlags_DockingEnable)
        {
            ImGuiID dockspace_id = ImGui::GetID(""MyDockSpace"");
            ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags);
        }
        style.WindowMinSize.x =  [MASK] ;
        if (ImGui::BeginMenuBar())
        {
            if (ImGui::BeginMenu(""File""))
            {
                if (ImGui::MenuItem(""New"", ""ctrl+N""))
                {
                    NewScene();
                }
                if (ImGui::MenuItem(""Save as..."", ""ctrl+alt+S""))
                {
                    SaveScene();
                }
                else if (ImGui::MenuItem(""Save"", ""ctrl+S""))
                {
                    if (m_CurrentSceneFile.empty())
                    {
                        SaveScene();
                    }
                    else
                    {
                        SaveScene(m_CurrentSceneFile);
                    }
                }
                if (ImGui::MenuItem(""Open.."", ""ctrl+O""))
                {
                    LoadScene();
                }
                if (ImGui::MenuItem(""Close"", NULL, false, p_open != NULL))
                {
                    Application::Get().Close();
                    *p_open = false;
                }
                ImGui::EndMenu();
            }

            ImGui::SetCursorPosX(ImGui::GetWindowSize().x - 30 * 3); // Adjust the width and spacing according to your needs
            if (ImGui::Button(""-"", ImVec2(30, 0)))
            {
                Application::Get().Minimize();
            }
            ImGui::SameLine(0, 0);
            if (ImGui::Button(""[ ]"", ImVec2(30, 0)))
            {
                m_RestoreDown == true ? Application::Get().RestoreDown() : Application::Get().RestoreUp();
                m_RestoreDown = !m_RestoreDown;
            }
            ImGui::SameLine(0, 0);
            if (ImGui::Button(""X"", ImVec2(30, 0)))
            {
                Application::Get().Close();
            }

            ImGui::EndMenuBar();
        }

        entityPanel.OnImGuiRender();
        browserPanel.OnImGuiRender();

        playPanel.OnImGuiRender();



        uint32_t textureID = m_FrameBuffer->GetID();
        ImGui::Begin(""Color settings"");
        ImGui::Text(""Draw calls: %d"", renderer2DInstance.GetStats().drawCalls);
        ImGui::Text(""Quad count: %d"", renderer2DInstance.GetStats().quadCount);

        ImGui::Separator();
        ImGui::End();

        ImGui::Begin(""Settings"");
        ImGui::Checkbox(""Show physics colliders"", &m_ShowPhysicsColliders);
        ImGui::End();

        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2{ 0, 0 });
        ImGui::Begin(""Editor View"");

        //READ PIXEL
        auto viewportMinBound = ImGui::GetWindowContentRegionMin(); //GET LOWEST VIEWPORT PIXEL X AND Y (0 for x and an offset for y because of the option bar
        auto viewportMaxBound = ImGui::GetWindowContentRegionMax(); //GET HIGHEST VIEWPORT PIXEL OF X AND Y (Y will also include the pixel height of option bar

        m_ViewportFocused = ImGui::IsWindowFocused();
        m_ViewportHovered = ImGui::IsWindowHovered();

        m_ViewportFocused == true ? Input::inputViewPort = Input::InputViewport::EDITOR : Input::inputViewPort = Input::InputViewport::PANEL;

        ImVec2 viewportPanelSize = ImGui::GetContentRegionAvail(); //PIXEL WIDTH AND HEIGHT OF VIEWPORT EXCLUDING HEIGHT OF option BAR
        auto viewportOffset = ImGui::GetWindowPos(); //GET OFFSET FROM ACTUAL SCREEN COORD TO VIEWPORT COORD TOP LEFT
        m_ViewportSize = { viewportPanelSize.x, viewportPanelSize.y };

        //BELOW WILL CONVERT VIEWPORT COORD TO FULL SCREEN COORD
        m_BoundsArray[0] = { viewportMinBound.x + viewportOffset.x, viewportMinBound.y + viewportOffset.y };
        m_BoundsArray[1] = { viewportMaxBound.x + viewportOffset.x, viewportMaxBound.y + viewportOffset.y };

        ImGui::Image((void*)textureID, viewportPanelSize, ImVec2{ 0,1 }, ImVec2{ 1,0 });

        if (ImGui::BeginDragDropTarget())
        {
            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(""DRAG_DROP""))
            {
                
                const char* path = (const char*)payload->Data;
                std::string loadFile(path);
                LoadScene(loadFile);
            }
            ImGui::EndDragDropTarget();
        }

        //GIZMOS

        auto selectedEntity = entityPanel.GetSelectedEntity();
        if (selectedEntity && m_TransformGizmo != -1)
        {
            ImGuizmo::SetOrthographic(false);
			ImGuizmo::SetDrawlist();

            ImGuizmo::SetRect(m_BoundsArray[0].x, m_BoundsArray[0].y, m_BoundsArray[1].x - m_BoundsArray[0].x, m_BoundsArray[1].y - m_BoundsArray[0].y);
            
            const glm::mat4& cameraProjection = m_EditorCamera.GetProjection();
            glm::mat4 cameraView = m_EditorCamera.GetView();

            //ENTITY

            auto& tc = selectedEntity.GetComponent<TransformComponent>();
            glm::mat4 transform = tc();

            //SNAPPING
            if (m_Snap)
            {
                float snapValue = 0.5f;
                if (ImGuizmo::OPERATION::ROTATE == (ImGuizmo::OPERATION)m_TransformGizmo)
                {
                    snapValue = 45.0f;
                }

                float snapValues[3] = { snapValue, snapValue, snapValue };
                ImGuizmo::Manipulate(glm::value_ptr(cameraView), glm::value_ptr(cameraProjection),
                    (ImGuizmo::OPERATION)m_TransformGizmo, ImGuizmo::LOCAL, glm::value_ptr(transform), nullptr, m_Snap ? snapValues : nullptr);
            }
            else //NO SNAPPING
            {
                ImGuizmo::Manipulate(glm::value_ptr(cameraView), glm::value_ptr(cameraProjection),
                    (ImGuizmo::OPERATION)m_TransformGizmo, ImGuizmo::LOCAL, glm::value_ptr(transform));
            }

            if (ImGuizmo::IsUsing())
            {
                glm::vec3 translation, rotation, scale;
                ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(transform), glm::value_ptr(translation), glm::value_ptr(rotation), glm::value_ptr(scale));

                tc.translate = translation;
                tc.rotate = rotation;
                tc.scale = scale;
            }
        }

        ImGui::End();
        ImGui::PopStyleVar();

        ImGui::End();
    }

    void Editor2D::LoadScene()
    {
        std::optional<std::string> filepath = FileDialogs::OpenFile(""Turbo Scene (*.turbo)\0*.turbo\0"");
        if (filepath)
        {
            m_DialogDone = true;
            LoadScene(*filepath);
        }
    }

    void Editor2D::LoadScene(const std::string& filePath)
    {
        if (filePath == ""C"")
            return;
        m_CurrentSceneFile = filePath;
        m_Scene = std::make_shared<Scene>(m_ViewportSize);
        entityPanel(m_Scene);
        SceneSerializer deserializer(m_Scene);
        deserializer.Load(filePath);

    }

    void Editor2D::SaveScene()
    {

        std::optional<std::string> filepath = FileDialogs::SaveFile(""Turbo Scene (*.turbo)\0*.turbo\0"");
        if (filepath)
        {
            m_DialogDone = true;
            SaveScene(*filepath);
        }
    }

    void Editor2D::SaveScene(const std::string& filePath)
    {
        if (filePath == ""C"")
            return;
        SceneSerializer serializer(m_Scene);
        serializer.Save(filePath);
    }

    std::string Editor2D::Serialize()
    {
        SceneSerializer serializer(m_Scene);
        return serializer.Serialize();
    }

    void Editor2D::Deserialize()
    {
        m_Scene = std::make_shared<Scene>(m_ViewportSize);
        entityPanel(m_Scene);
        SceneSerializer deserializer(m_Scene);
        deserializer.Load(tempData, false);
    }

    void Editor2D::NewScene()
    {
        m_Scene = std::make_shared<Scene>(m_ViewportSize);
        entityPanel(m_Scene);
    }

    Editor2D* Editor2D::getLayer()
    {
        return this;
    }
}",minWinSizeX
954,"// SPDX-FileCopyrightText: 2012 <NAME> <<EMAIL>>
//
// SPDX-License-Identifier: LGPL-2.1-or-later

#include ""example_2_rosterHandling.h""

#include ""QXmppMessage.h""
#include ""QXmppRosterManager.h""

#include <QCoreApplication>

xmppClient::xmppClient(QObject *parent)
    : QXmppClient(parent),
      m_rosterManager(findExtension<QXmppRosterManager>())
{
    connect(this, &QXmppClient::connected,
            this, &xmppClient::clientConnected);

    connect(m_rosterManager, &QXmppRosterManager::rosterReceived,
            this, &xmppClient::rosterReceived);

    /// Then QXmppRoster::presenceChanged() is emitted whenever presence of
    /// someone in roster changes
    connect(m_rosterManager, &QXmppRosterManager::presenceChanged,
            this, &xmppClient::presenceChanged);
}

xmppClient::~xmppClient() = default;

void xmppClient::clientConnected()
{
    qDebug(""example_2_rosterHandling:: CONNECTED"");
}

void xmppClient::rosterReceived()
{
    qDebug(""example_2_rosterHandling:: Roster received"");
    const QStringList  [MASK]  = m_rosterManager->getRosterBareJids();
    for (const QString &bareJid :  [MASK] ) {
        QString name = m_rosterManager->getRosterEntry(bareJid).name();
        if (name.isEmpty()) {
            name = ""-"";
        }
        qDebug(""example_2_rosterHandling:: Roster received: %s [%s]"", qPrintable(bareJid), qPrintable(name));
    }
}

void xmppClient::presenceChanged(const QString &bareJid,
                                 const QString &resource)
{
    qDebug(""example_2_rosterHandling:: Presence changed %s/%s"", qPrintable(bareJid), qPrintable(resource));
}

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    xmppClient client;
    client.connectToServer(""<EMAIL>"", ""qxmpp123"");

    return app.exec();
}
",jids
955,"//
// Created by Alex on 8/27/2020.
//

#ifndef HEILANG_CODEGEN_H
#define HEILANG_CODEGEN_H

#include ""visitor.h""
#include ""types.h""
#include <llvm/IR/IRBuilder.h>

using namespace llvm;

class ErrorReport {
public:
    void report(const char *msg) {
        std::cout << msg;
    }
};

struct CompileContext {
    LLVMContext context;
    IRBuilder<> builder;
    TypeChecker checker;
    ErrorReport error;
    Value *bool_true = ConstantInt::getTrue(context);
    Value *bool_false = ConstantInt::getFalse(context);
    Type *i8 = IntegerType::getInt8Ty(context);
    Type *i32 = IntegerType::getInt32Ty(context);
    Type *i64 = IntegerType::getInt64Ty(context);
    Type *f32 = IntegerType::getFloatTy(context);
    Type *f64 = IntegerType::getDoubleTy(context);
    Type *b = IntegerType::getInt1Ty(context);
    Type *v = IntegerType::getVoidTy(context);
    CompileContext() : builder(context), checker(context) {}
};

class CodeGen : public Walker<Value *> {
public:
    CompileContext &context;
    CodeGen(CompileContext &context) : context(context) {}
    Value *walk_string(json &node) override {
        auto str = node[""value""].get<std::string>();
        auto *global = context.builder.CreateGlobalString(str.substr(1, str.length() - 2));
        Value *zero = context.builder.getInt32(0);
        Value *idxs[] = {zero, zero};
        return context.builder.CreateInBoundsGEP(global, idxs);
    }
    Value *walk_number(json &node) override {
        return context.builder.getInt32(std::stol(node[""value""].get<std::string>()));
    }
    Value *walk_binary(json &node) override {
        static std::map<std::tuple<std::string, int>, Instruction::BinaryOps>  [MASK]  = {
                {std::pair(""+"", 0),  Instruction::BinaryOps::Add},
                {std::pair(""-"", 0),  Instruction::BinaryOps::Sub},
                {std::pair(""*"", 0),  Instruction::BinaryOps::Mul},
                {std::pair(""/"", 0),  Instruction::BinaryOps::SDiv},
                {std::pair(""|"", 0),  Instruction::BinaryOps::Or},
                {std::pair(""<<"", 0), Instruction::BinaryOps::Shl},
                {std::pair("">>"", 0), Instruction::BinaryOps::LShr},
                {std::pair(""+"", 1),  Instruction::BinaryOps::FAdd},
                {std::pair(""-"", 1),  Instruction::BinaryOps::FSub},
                {std::pair(""*"", 1),  Instruction::BinaryOps::FMul},
                {std::pair(""/"", 1),  Instruction::BinaryOps::FDiv},
                {std::pair(""/"", 2),  Instruction::BinaryOps::UDiv},
        };

        auto op = node[""op""].get<std::string>();
        return context.builder.CreateBinOp(
                 [MASK] [std::pair(op, 0)],
                walk(node[""left""]),
                walk(node[""right""]), ""temp""
        );

    }

};


#endif //HEILANG_CODEGEN_H
",ops
956,"#include ""traceroute.h""

// seconds to wait before sending another packet
const int TTL_TIMEOUT = 15;
const int PAYLOAD_SIZE = 36;
const int FIRST_TTL = 2;
const int TOTAL_OUT = 30;
const int PACKET_LEN = 64; // this is all th eoutgoing packets

// Function to print ICMP header -debug only because it clogs the output
void print_icmp_header (struct icmphdr* icmp_header) {
    std::cout << ""---- ICMP Header ----"" << std::endl;
    std::cout << ""Memory address: "" << static_cast<void*> (icmp_header) << std::endl;
    std::cout << ""Type: "" << (int)icmp_header->type << std::endl;
    std::cout << ""Code: "" << (int)icmp_header->code << std::endl;
    std::cout << ""Checksum: 0x"" << std::hex << ntohs (icmp_header->checksum) << std::dec << std::endl;
    std::cout << ""Identifier (ID): "" << ntohs (icmp_header->un.echo.id) << std::endl;
    std::cout << ""Sequence Number: "" << ntohs (icmp_header->un.echo.sequence) << std::endl;
    std::cout << ""--------------------\n"";
}

// funciton to print ip header, same as icmp debug only
void print_ip_header (struct iphdr* ip_header) {
    char source_ip[INET_ADDRSTRLEN];
    char dest_ip[INET_ADDRSTRLEN];

    inet_ntop (AF_INET, &ip_header->saddr, source_ip, INET_ADDRSTRLEN);
    inet_ntop (AF_INET, &ip_header->daddr, dest_ip, INET_ADDRSTRLEN);

    std::cout << ""---- IP Header ----\n"";
    std::cout << ""Memory address: "" << static_cast<void*> (ip_header) << std::endl;
    std::cout << ""Version: "" << (unsigned int)ip_header->version << ""\n"";
    std::cout << ""Header Length: "" << (unsigned int)ip_header->ihl * 4 << "" bytes\n"";
    std::cout << ""Type of Service: "" << (unsigned int)ip_header->tos << ""\n"";
    std::cout << ""Total Length: "" << ntohs (ip_header->tot_len) << "" bytes\n"";
    std::cout << ""Identification: "" << ntohs (ip_header->id) << ""\n"";
    std::cout << ""Fragment Offset: "" << (ntohs (ip_header->frag_off) & 0x1FFF) << ""\n"";
    std::cout << ""Time to Live: "" << (unsigned int)ip_header->ttl << ""\n"";
    std::cout << ""Protocol: "" << (unsigned int)ip_header->protocol << ""\n"";
    std::cout << ""Header Checksum: "" << ntohs (ip_header->check) << ""\n"";
    std::cout << ""Source IP: "" << source_ip << ""\n"";
    std::cout << ""Destination IP: "" << dest_ip << ""\n"";
    std::cout << ""--------------------\n"";
}

// ****************************************************************************
// * Compute the Internet Checksum over an arbitrary buffer.
// * (written with the help of ChatGPT 3.5)
// ****************************************************************************
uint16_t checksum (unsigned short* buffer, int size) {
    DEBUG << ""Calculating checksum of buffer at "" << static_cast<void*> (buffer) << "" with size ""
          << size << ENDL;
    unsigned long sum = 0;
    while (size > 1) {
        sum += *buffer++;
        size -= 2;
    }
    if (size == 1) {
        sum += *(unsigned char*)buffer;
    }
    sum = (sum >> 16) + (sum & 0xFFFF);
    sum += (sum >> 16);
    return (unsigned short)(~sum);
}

// Function to calculate the ICMP checksum
unsigned short calculate_checksum (void* buffer, int length) {
    unsigned short* data = (unsigned short*)buffer;
    unsigned long sum = 0;

    while (length > 1) {
        sum += *data++;
        length -= 2;
    }
    if (length == 1) {
        sum += *(unsigned char*)data;
    }
    sum = (sum >> 16) + (sum & 0xFFFF);
    sum += (sum >> 16);

    return ~sum;
}

// function to fill in the ip values initially
void fill_in_IP_header (char* packet) {

    struct iphdr* ip = (struct iphdr*)packet;
    ip->version = 4; // ipv4
    ip->ihl = 5; // Header length in 32-bit words (5 * 4 = 20 bytes)
    ip->tos = 0; // tyupe of Service
    ip->tot_len = htons (64); // Total length (to be set later when data is added)
    // \\ip->id = htons (getpid ()); // Identification will be set by kerbel
    ip->frag_off = 0; // frafgment offset, not sure what this is actually
    ip->ttl = 64; // Time to Live (common default value) in case we forget to set down the line for some reason
    ip->protocol = IPPROTO_ICMP; // Protocol (TCP in this example)
    INFO << ""Filled in IP header at address "" << static_cast<void*> (packet) << ENDL;
}

// function to fill in the icmp values initially
void fill_in_ICMP_header (char* packet) {

    struct icmphdr* icmp_header = (struct icmphdr*)packet;
    icmp_header->type = ICMP_ECHO; // Echo request
    icmp_header->code = 0;
    icmp_header->un.echo.id = htons (getpid ()); // Identifier
    icmp_header->un.echo.sequence = htons (1);   // Sequence number

    INFO << ""Filled in ICMP header at address "" << static_cast<void*> (packet) << ENDL;
}


int main (int argc, char* argv[]) {
    std::string destIP;

    // process cmd line args
    int opt = 0;
    while ((opt = getopt (argc, argv, ""d:v:"")) != -1) {

        switch (opt) {
        case 'd': destIP = optarg; break;
        case 'v':
            LOG_LEVEL = atoi (optarg);
            ;
            break;
        case ':':
        case '?':
        default:
            std::cout << ""useage: "" << argv[0] << "" -d [destination ip] -v [Log Level]"" << std::endl;
            exit (-1);
        }
    }

    int length = PACKET_LEN; // hardcode packet length to make it easier
    char* packet = new char[length](); // buffer for sending
    char* icmp_hd = ((packet + sizeof (struct iphdr))); // super weird memory issues without this 
    memset (packet, 0, length); // set all of packet to 0s
    fill_in_IP_header (packet); 
    fill_in_ICMP_header (icmp_hd);

    // Create send socket
    int send_socket = socket (AF_INET, SOCK_RAW, IPPROTO_RAW);
    if (send_socket < 0) {
        ERROR << ""Send socket creation failed"" << ENDL;
        return 1;
    }

    else {
        INFO << ""Send socket creation success"" << ENDL;
    }

    // Create receive socket
    int rcv_socket = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
    if (rcv_socket < 0) {
        ERROR << ""Receive socket creation failed"" << ENDL;
        return 1;
    }

    else {
        INFO << ""Receive socket creation success"" << ENDL;
    }

    bool  [MASK]  = false;
    int current_ttl = FIRST_TTL;

    // this is the main loop of the prgoram
    // it ends when the destination answers an echo OR when we sent max amt of ackets 
    while (current_ttl <= (FIRST_TTL + TOTAL_OUT) && ! [MASK] ) {

        // Set up the destination address
        struct sockaddr_in dest;
        dest.sin_family = AF_INET;
        dest.sin_addr.s_addr = inet_addr (destIP.c_str ()); // Destination IP

        // Set the TTL field to current ttl
        struct iphdr* ip = (struct iphdr*)packet; // Cast to iphdr
        ip->ttl = current_ttl;                    // Update the TTL value
        DEBUG << ""Setting IP TTL to: "" << current_ttl << ENDL;
        ip->daddr = inet_addr (destIP.c_str ()); // Set destination IP

        // Calculate ICMP checksum
        struct icmphdr* icmp_header = ((struct icmphdr*)icmp_hd); // cast to ICMP header
        icmp_header->checksum = calculate_checksum ((void*)icmp_hd, sizeof (struct icmphdr*) + PAYLOAD_SIZE);
        DEBUG << ""Setting ICMP checksum to: "" << icmp_header->checksum << ENDL;

        bool first_check = false;

        // Send the packet
        if (sendto (send_socket, packet, 64, 0, (struct sockaddr*)&dest, sizeof (dest)) < 0) {
            ERROR << ""sendto failed"" << ENDL;
            close (send_socket);
            return 1;
        }

        else {
            // Issue a timestamp to debug packets arriving before listenign
            auto now = std::chrono::system_clock::now ();
            std::time_t current_time_t = std::chrono::system_clock::to_time_t (now);
            auto now_us =
            std::chrono::duration_cast<std::chrono::microseconds> (now.time_since_epoch ()) % 1000000;

            // Format the time
            INFO << ""Sent packet: "" << std::put_time (std::localtime (&current_time_t), ""%Y-%m-%d %H:%M:%S"")
                 << ""."" << std::setfill ('0') << std::setw (6) << now_us.count ()
                 << "" (microseconds)"" << ENDL;
        }

        bool packet_received = false;

        while (true) {

            // Use select() to monitor the raw socket
            fd_set read_fds;
            struct timeval timeout;
            char buffer[1024]; // not a pointer woohoo
            struct sockaddr_in source_addr;
            socklen_t addr_len = sizeof (source_addr);
            timeout.tv_sec = 5; // stimeout to 5 seconds
            timeout.tv_usec = 0;

            FD_ZERO (&read_fds);            // cear the set
            FD_SET (rcv_socket, &read_fds); // add raw socket to the set

            if (!first_check) {
                first_check = true;

                // again show timestamp to debug certain issue with timing of packet arrivals
                auto now = std::chrono::system_clock::now ();
                std::time_t current_time_t = std::chrono::system_clock::to_time_t (now);
                auto now_us =
                std::chrono::duration_cast<std::chrono::microseconds> (now.time_since_epoch ()) % 1000000;

                // formmat the time and show it
                INFO << ""Started listening for replies: ""
                     << std::put_time (std::localtime (&current_time_t), ""%Y-%m-%d %H:%M:%S"") << "".""
                     << std::setfill ('0') << std::setw (6) << now_us.count () << "" (microseconds)"" << ENDL;
            }

            // wait for activity on the socket
            int activity = select (rcv_socket + 1, &read_fds, nullptr, nullptr, &timeout);

            if (activity < 0) {
                perror (""Select error"");
                break;
            }

            else if (activity == 0) {
                INFO << TTL_TIMEOUT << "" sec time out for TTL "" << current_ttl << ENDL;

                if (!packet_received) {
                    std::cout << ""\n\033[33m""
                              << ""No response with TTL of "" << current_ttl << ""\033[0m""
                              << ""\n"";
                }
                break;
            }

            if (FD_ISSET (rcv_socket, &read_fds)) {
                // receive the incoming packet
                memset (buffer, 0, sizeof (buffer));
                int bytes_received = recvfrom (
                rcv_socket, buffer, sizeof (buffer), 0, (struct sockaddr*)&source_addr, &addr_len);
                if (bytes_received < 0) {
                    perror (""Failed to receive data"");
                    continue;
                }

                // extract ip header by casting it
                struct iphdr* ip_header = (struct iphdr*)buffer;

                // get IP address
                char source_ip[INET_ADDRSTRLEN];
                inet_ntop (AF_INET, &ip_header->saddr, source_ip, sizeof (source_ip));

                INFO << ""Packet from "" << source_ip << "" received with size: "" << bytes_received << "" bytes""
                     << "" and type "" << ip_header->protocol << ENDL;

                // Verify is ICMP
                if (ip_header->protocol != IPPROTO_ICMP) {
                    WARNING << ""Received non-ICMP packet"" << ENDL;
                }

                else {

                    // similar to IP extract the ICMP header (after the IP header)
                    size_t ip_header_length = ip_header->ihl * 4; // ihl is in 32-bit words
                    struct icmphdr* icmp_header = (struct icmphdr*)(buffer + ip_header_length);

                    // Print ICMP type
                    INFO << ""Received ICMP packet of type: "" << (int)icmp_header->type << ENDL;

                    if ((int)icmp_header->type == ICMP_ECHOREPLY) {
                         [MASK]  = true; // this will exit our big loop which leads to exit program
                        packet_received = true;

                        // print nice message to command line
                        std::cout << ""\n\033[1;36m""
                                  << ""Packet reached destination "" << destIP << ""\033[0m"" << ""\n\n"";

                    }

                    else if ((int)icmp_header->type == (int)ICMP_TIME_EXCEEDED) {
                        packet_received = true;

                        // print nice msg to comamn line
                        std::cout << ""\n\033[33m"" << source_ip << ""\033[0m""
                                  << ""\n"";

                        break;
                    }
                }
            }
        }

        current_ttl++;
    }

    // Close the sockets
    delete[] packet;
    close (send_socket);
    close (rcv_socket);
    return 0;
}
",reply_received
957,"#include ""AppDelegate.h""

#include ""cocos2d.h""
#include ""SimpleAudioEngine.h""
using namespace CocosDenshion;


#include ""GameScene/CGameLogo.h""
#include ""loader/CClientLoader.h""
#include ""sql/CSqliteManager.h""
#include ""Platform/CCNd91Mng.h""

using namespace cocos2d;

AppDelegate::AppDelegate()
{

}

AppDelegate::~AppDelegate()
{
    SimpleAudioEngine::end();
	CC_SAFE_DELETE( g_pClientLoader );
	CSqliteManager::GetInstance()->Release();
}

bool AppDelegate::initInstance() 
{
    bool  [MASK]  = false;
    do 
    {
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
        // Initialize OpenGLView instance, that release by CCDirector when application terminate.
        // The HelloWorld is designed as HVGA.
        CCEGLView * pMainWnd = new CCEGLView();
        CC_BREAK_IF(! pMainWnd
            || ! pMainWnd->Create(TEXT(""MagicPet""), 320, 480));
#endif  // CC_PLATFORM_WIN32

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)

        // OpenGLView initialized in testsAppDelegate.mm on ios platform, nothing need to do here.

#endif  // CC_PLATFORM_IOS

#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)

        // Android doesn't need to do anything.

#endif  // CC_PLATFORM_ANDROID

#if (CC_TARGET_PLATFORM == CC_PLATFORM_WOPHONE)
        // Initialize OpenGLView instance, that release by CCDirector when application terminate.
        // The HelloWorld is designed as HVGA.
        // Use GetScreenWidth() and GetScreenHeight() get screen width and height.
        CCEGLView * pMainWnd = new CCEGLView(this);
        CC_BREAK_IF(! pMainWnd
            || ! pMainWnd->Create(320, 480));

#if !defined(_TRANZDA_VM_)
        // set the resource zip file
        // on wophone emulator, we copy resources files to Work7/TG3/APP/ folder instead of zip file
        CCFileUtils::setResource(""MagicPet.zip"");
#endif

#endif  // CC_PLATFORM_WOPHONE

         [MASK]  = true;
    } while (0);
    return  [MASK] ;
    
}

bool AppDelegate::applicationDidFinishLaunching()
{
    // initialize director
    CCDirector *pDirector = CCDirector::sharedDirector();
    pDirector->setOpenGLView(&CCEGLView::sharedOpenGLView());

    // sets landscape mode
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
    pDirector->setDeviceOrientation(kCCDeviceOrientationLandscapeLeft);
#endif  
    // turn on display FPS
#if COCOS2D_DEBUG
    //pDirector->setDisplayFPS(true);
#endif

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
    if( pDirector->getWinSize().width >= 1024 && pDirector->getWinSize().height >= 768 )
    {
       pDirector->enableRetinaDisplay( false );
    }
    else
    {
        pDirector->enableRetinaDisplay( true );
    }
#endif
    
    // set FPS. the default value is 1.0/60 if you don't call this
    pDirector->setAnimationInterval(1.0 / 60);

    // create a scene. it's an autorelease object
    CCScene *pScene = CGameLogo::scene();

    // run
    pDirector->runWithScene(pScene);
    return true;
}

// This function will be called when the app is inactive. When comes a phone call,it's be invoked too
void AppDelegate::applicationDidEnterBackground()
{
    CCDirector::sharedDirector()->pause();

    SimpleAudioEngine::sharedEngine()->pauseBackgroundMusic();
    
    CSqliteManager::GetInstance()->SaveSql();
    
    CCLog(""applicationDidEnterBackground"");
}

// this function will be called when the app is active again
void AppDelegate::applicationWillEnterForeground()
{
    CCDirector::sharedDirector()->resume();
    SimpleAudioEngine::sharedEngine()->resumeBackgroundMusic();
    
    CNd91Mng::login91Platform();
}
",bRet
958,"#include ""vtk_representation.h""
#include ""model.h""
#include ""parameters_sim.h""
//#include <omp.h>
#include <algorithm>
#include <iostream>
#include <spdlog/spdlog.h>

icy::VisualRepresentation::VisualRepresentation()
{
    int nLut = sizeof lutArrayTemperatureAdj / sizeof lutArrayTemperatureAdj[0];
//    hueLut->SetNumberOfTableValues(nLut);
//    for ( int i=0; i<nLut; i++)
//        hueLut->SetTableValue(i, lutArrayTemperatureAdj[i][0],
//                              lutArrayTemperatureAdj[i][1],
//                              lutArrayTemperatureAdj[i][2], 1.0);

    nLut = sizeof lutArrayPastel / sizeof lutArrayPastel[0];
    hueLut_pastel->SetNumberOfTableValues(nLut);
    for ( int i=0; i<nLut; i++)
        hueLut_pastel->SetTableValue(i, lutArrayPastel[i][0],
                              lutArrayPastel[i][1],
                              lutArrayPastel[i][2], 1.0);
    hueLut_pastel->SetTableRange(0,40);

    nLut = sizeof lutArrayMPMColors / sizeof lutArrayMPMColors[0];
    lutMPM->SetNumberOfTableValues(nLut);
    for ( int i=0; i<nLut; i++)
        lutMPM->SetTableValue(i, lutArrayMPMColors[i][0],
                              lutArrayMPMColors[i][1],
                              lutArrayMPMColors[i][2], 1.0);

    hueLut_four->SetNumberOfColors(5);
    hueLut_four->SetTableValue(0, 0.3, 0.3, 0.3);
    hueLut_four->SetTableValue(1, 1.0, 0, 0);
    hueLut_four->SetTableValue(2, 0, 1.0, 0);
    hueLut_four->SetTableValue(3, 0, 0, 1.0);
    hueLut_four->SetTableValue(4, 0, 0.5, 0.5);
    hueLut_four->SetTableRange(0,4);


    indenterMapper->SetInputConnection(indenterSource->GetOutputPort());
    actor_indenter->SetMapper(indenterMapper);

    indenterSource->GeneratePolygonOff();
    indenterSource->SetNumberOfSides(50);

    indenterMapper->SetInputConnection(indenterSource->GetOutputPort());
    actor_indenter->SetMapper(indenterMapper);
    actor_indenter->GetProperty()->LightingOff();
    actor_indenter->GetProperty()->EdgeVisibilityOn();
    actor_indenter->GetProperty()->VertexVisibilityOff();
    actor_indenter->GetProperty()->SetColor(0.1,0.1,0.1);
    actor_indenter->GetProperty()->SetEdgeColor(90.0/255.0, 90.0/255.0, 97.0/255.0);
    actor_indenter->GetProperty()->ShadingOff();
    actor_indenter->GetProperty()->SetInterpolationToFlat();
    actor_indenter->PickableOff();
    actor_indenter->GetProperty()->SetLineWidth(3);


    // points
    points_polydata->SetPoints(points);
    points_polydata->GetPointData()->AddArray(visualized_values);
    visualized_values->SetName(""visualized_values"");
    points_polydata->GetPointData()->SetActiveScalars(""visualized_values"");

    points_filter->SetInputData(points_polydata);
    points_filter->Update();

    points_mapper->SetInputData(points_filter->GetOutput());
    points_mapper->UseLookupTableScalarRangeOn();
    points_mapper->SetLookupTable(lutMPM);

    actor_points->SetMapper(points_mapper);
    actor_points->GetProperty()->SetPointSize(2);
    actor_points->GetProperty()->SetVertexColor(1,0,0);
    actor_points->GetProperty()->SetColor(0,0,0);
    actor_points->GetProperty()->LightingOff();
    actor_points->GetProperty()->ShadingOff();
    actor_points->GetProperty()->SetInterpolationToFlat();
    actor_points->PickableOff();


    grid_mapper->SetInputData(structuredGrid);
//    grid_mapper->SetLookupTable(hueLut);

    actor_grid->SetMapper(grid_mapper);
    actor_grid->GetProperty()->SetEdgeVisibility(true);
    actor_grid->GetProperty()->SetEdgeColor(0.8,0.8,0.8);
    actor_grid->GetProperty()->LightingOff();
    actor_grid->GetProperty()->ShadingOff();
    actor_grid->GetProperty()->SetInterpolationToFlat();
    actor_grid->PickableOff();
    actor_grid->GetProperty()->SetColor(0.95,0.95,0.95);

    scalarBar->SetLookupTable(lutMPM);
    scalarBar->SetMaximumWidthInPixels(130);
    scalarBar->SetBarRatio(0.07);
    scalarBar->SetMaximumHeightInPixels(200);
    scalarBar->GetPositionCoordinate()->SetCoordinateSystemToNormalizedDisplay();
    scalarBar->GetPositionCoordinate()->SetValue(0.01,0.015, 0.0);
    scalarBar->SetLabelFormat(""%.1e"");
    scalarBar->GetLabelTextProperty()->BoldOff();
    scalarBar->GetLabelTextProperty()->ItalicOff();
    scalarBar->GetLabelTextProperty()->ShadowOff();
    scalarBar->GetLabelTextProperty()->SetColor(0.1,0.1,0.1);

    // text
    vtkTextProperty* txtprop = actorText->GetTextProperty();
    txtprop->SetFontFamilyToArial();
    txtprop->BoldOff();
    txtprop->SetFontSize(14);
    txtprop->ShadowOff();
    txtprop->SetColor(0,0,0);
    actorText->SetDisplayPosition(500, 30);
}



void icy::VisualRepresentation::SynchronizeTopology()
{
    spdlog::info(""SynchronizeTopology()"");
    points->SetNumberOfPoints(model->prms.nPts);
    visualized_values->SetNumberOfValues(model->prms.nPts);
    indenterSource->SetRadius(model->prms.IndDiameter/2.f);

    SynchronizeValues();

    int &gx = model->prms.GridX;
    int &gy = model->prms.GridY;
    double &h = model->prms.cellsize;
    structuredGrid->SetDimensions(model->prms.GridX, model->prms.GridY, 1);

    grid_points->SetNumberOfPoints(gx*gy);
    for(int idx_y=0; idx_y<gy; idx_y++)
        for(int idx_x=0; idx_x<gx; idx_x++)
        {
            float x = idx_x * h;
            float y = idx_y * h;
            double pt_pos[3] {x, y, -1.0};
            grid_points->SetPoint((vtkIdType)(idx_x+idx_y*gx), pt_pos);
        }
    structuredGrid->SetPoints(grid_points);
}


void icy::VisualRepresentation::SynchronizeValues()
{
    spdlog::info(""SynchronizeValues() npts {}"", model->prms.nPts);
    double indenter_x = model->prms.indenter_x;
    double indenter_y = model->prms.indenter_y;
    indenterSource->SetCenter(indenter_x, indenter_y, 1);

    for(int i=0;i<model->prms.nPts;i++)
    {
        Eigen::Vector2d pos = icy::Point::getPos(model->gpu.tmp_transfer_buffer, model->prms.nPtsPitch, i);
        points->SetPoint((vtkIdType)i, pos[0], pos[1], 0);
    }
    points->Modified();

    double centerVal = 0;
    double range = std::pow(10,ranges[VisualizingVariable]);

    actor_points->GetProperty()->SetPointSize(model->prms.ParticleViewSize);
    points_filter->Update();

    if(VisualizingVariable == VisOpt::NACC_case)
    {
        scalarBar->VisibilityOn();
        points_mapper->ScalarVisibilityOn();
        points_mapper->SetColorModeToMapScalars();
        points_mapper->UseLookupTableScalarRangeOn();
        points_mapper->SetLookupTable(hueLut_four);
        scalarBar->SetLookupTable(hueLut_four);
        hueLut->SetTableRange(centerVal-range, centerVal+range);

        for(int i=0;i<model->prms.nPts;i++)
            visualized_values->SetValue((vtkIdType)i,
                                        icy::Point::getCrushedStatus(model->gpu.tmp_transfer_buffer, model->prms.nPtsPitch, i));
        visualized_values->Modified();
    }
    else if(VisualizingVariable == VisOpt::Jp_inv)
    {
        scalarBar->VisibilityOn();
        points_mapper->ScalarVisibilityOn();
        points_mapper->SetColorModeToMapScalars();
        points_mapper->UseLookupTableScalarRangeOn();
        points_mapper->SetLookupTable(lutMPM);
        scalarBar->SetLookupTable(lutMPM);
        lutMPM->SetTableRange(centerVal-range, centerVal+range);

        visualized_values->SetNumberOfValues(model->prms.nPts);
        for(int i=0;i<model->prms.nPts;i++)
            visualized_values->SetValue((vtkIdType)i,
                                        icy::Point::getJp_inv(model->gpu.tmp_transfer_buffer, model->prms.nPtsPitch, i)-1);
        visualized_values->Modified();
    }
    else if(VisualizingVariable == VisOpt::grains)
    {
        scalarBar->VisibilityOn();
        points_mapper->ScalarVisibilityOn();
        points_mapper->SetColorModeToMapScalars();
        points_mapper->UseLookupTableScalarRangeOn();
        points_mapper->SetLookupTable(hueLut_pastel);
        scalarBar->SetLookupTable(hueLut_pastel);

        visualized_values->SetNumberOfValues(model->prms.nPts);
        for(int i=0;i<model->prms.nPts;i++)
        {
            int value = 40;
            uint8_t crushed = icy::Point::getCrushedStatus(model->gpu.tmp_transfer_buffer, model->prms.nPtsPitch, i);
            if(!crushed) value = icy::Point::getGrain(model->gpu.tmp_transfer_buffer, model->prms.nPtsPitch, i)%40;
            visualized_values->SetValue((vtkIdType)i, (float)value);
        }
        visualized_values->Modified();
    }
    else if(VisualizingVariable == VisOpt::special_count)
    {
        scalarBar->VisibilityOn();
        points_mapper->ScalarVisibilityOn();
        points_mapper->SetColorModeToMapScalars();
        points_mapper->UseLookupTableScalarRangeOn();
        points_mapper->SetLookupTable(hueLut);
        scalarBar->SetLookupTable(hueLut);
        hueLut->SetTableRange(0,8);

        visualized_values->SetNumberOfValues(model->prms.nPts);
        for(int i=0;i<model->prms.nPts;i++)
        {
            int value = 40;
            char* ptr_intact = (char*)(&model->gpu.tmp_transfer_buffer[model->prms.nPtsPitch*icy::SimParams::idx_utility_data]);
            uint8_t* ptr_special_count = (uint8_t*)(&ptr_intact[model->prms.nPtsPitch*3]);
            value = ptr_special_count[i];
            visualized_values->SetValue((vtkIdType)i, (float)value);
        }
        visualized_values->Modified();
    }
    else
    {
        points_mapper->ScalarVisibilityOff();
//        points_polydata->GetPointData()->RemoveArray(0);
        scalarBar->VisibilityOff();
    }
    /*

*/

    /*
    actor_points->GetProperty()->SetPointSize(model->prms.ParticleViewSize);

    model->hostside_data_update_mutex.lock();
//#pragma omp parallel
    for(int i=0;i<model->points.size();i++)
    {
        const icy::Point &p = model->points[i];
        double x[3] {p.pos[0], p.pos[1], 0};
        points->SetPoint((vtkIdType)i, x);
      }

    double centerVal = 0;
    double range = std::pow(10,ranges[VisualizingVariable]);
    points_mapper->SetLookupTable(lutMPM);
    scalarBar->SetLookupTable(lutMPM);


    if(VisualizingVariable == VisOpt::none)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, 0);
    }
    else if(VisualizingVariable == VisOpt::NACC_case)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].q);
        points_mapper->SetLookupTable(hueLut_four);
        scalarBar->SetLookupTable(hueLut_four);
    }
    else if(VisualizingVariable == VisOpt::NACC_case_first)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].case_when_Jp_first_changes);
        points_mapper->SetLookupTable(hueLut_four);
        scalarBar->SetLookupTable(hueLut_four);
    }
    else if(VisualizingVariable == VisOpt::Jp)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].Jp_inv-1);
    }
    else if(VisualizingVariable == VisOpt::Jp_positive)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].Jp_inv>1 ? 1. : 0.);
    }
    else if(VisualizingVariable == VisOpt::zeta)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].zeta-1);
    }
    else if(VisualizingVariable == VisOpt::p0)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].visualize_p0);
        //centerVal = model->prms.IceCompressiveStrength;
        points_mapper->SetLookupTable(hueLut);
        scalarBar->SetLookupTable(hueLut);
    }
    else if(VisualizingVariable == VisOpt::q_limit)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].visualize_q_limit);
        points_mapper->SetLookupTable(hueLut);
        scalarBar->SetLookupTable(hueLut);
    }
    else if(VisualizingVariable == VisOpt::p_tr)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].visualize_p);
//        centerVal = (model->prms.IceCompressiveStrength-model->prms.IceTensileStrength)/2;
        points_mapper->SetLookupTable(hueLut);
        scalarBar->SetLookupTable(hueLut);
    }
    else if(VisualizingVariable == VisOpt::q_tr)
    {
        for(int i=0;i<model->points.size();i++) visualized_values->SetValue((vtkIdType)i, model->points[i].visualize_q);
        points_mapper->SetLookupTable(hueLut);
        scalarBar->SetLookupTable(hueLut);
    }


//    float minmax[2];
//    visualized_values->GetValueRange(minmax);
    lutMPM->SetTableRange(centerVal-range, centerVal+range);
    hueLut->SetTableRange(centerVal-range, centerVal+range);

    points->Modified();
    visualized_values->Modified();
    points_filter->Update();
    indenterSource->SetCenter(model->prms.indenter_x, model->prms.indenter_y, 1);

*/
}


void icy::VisualRepresentation::ChangeVisualizationOption(int  [MASK] )
{
    VisualizingVariable = (VisOpt) [MASK] ;
    SynchronizeTopology();
}

",option
959,"#include <iostream>
#include <string>
#include <vector>
#include <ctime>
#include <fstream>
using namespace std;

void print(string msg, bool borderTop= true, bool borderBottom= true)
{
	bool  [MASK]  = true;

	if (borderTop)
	{
		cout << ""+---------------------------------------------+"" << endl;
		cout << ""|"";
	}
	else
	{
		cout << ""|"";
	}

	for (int i = msg.length(); i < 45; i++)
	{
		if ( [MASK] )
		{
			msg = "" "" + msg;
		}
		else
		{
			msg = msg + "" "";
		}
		 [MASK]  = ! [MASK] ;
	}
	cout << msg;
	
	if (borderBottom)
	{
		cout << ""|"" << endl;
		cout << ""+---------------------------------------------+"" << endl;
	}
	else
	{
		cout << ""|"" << endl;
	}
}

void drawMan(int guess = 0)
{
	if (guess >= 1)
		print(""|"", false, false);
	else
		print("""", false, false);

	if (guess >= 2)
		print(""|"", false, false);
	else
		print("""", false, false);

	if (guess >= 3)
		print(""O"", false, false);
	else
		print("""", false, false);

	if (guess == 4)
		print(""/  "", false, false);

	if (guess == 5)
		print(""/| "", false, false);

	if (guess >= 6)
		print(""/|\\"", false, false);
	else
		print("""", false, false);

	if (guess >= 7)
		print(""|"", false, false);
	else
		print("""", false, false);

	if (guess == 8)
		print(""/  "", false, false);

	if (guess >= 9)
	{
		print(""/ \\"", false, false);
		print(""+---------------+"", false, false);
		print(""|_______________|"", false, false);
	}
	else
		print("""", false, false);
}

void Alphabets(string guess, char from, char to)
{
	string s;
	for (char i = from; i <= to; i++)
	{
		if (guess.find(i) == string::npos)
		{
			s += i;
			s += "" "";
		}
		else
		{
			s += ""  "";
		}
	}
	print(s, false, false);
}

void printAlphabet(string usedLetter)
{
	print(""AVAILABLE LETTERS"", true, true);
	Alphabets(usedLetter, 'A', 'M');
	Alphabets(usedLetter, 'N', 'Z');
}

bool wordCheck(string word, string guessed)
{
	bool won = true;
	string x;
	print(""GUESS THE WORD"", true, true);
	for (int i = 0; i < word.length(); i++)
	{
		if (guessed.find(word[i]) == string::npos)
		{
			won = false;
			x += ""_ "";
		}
		else
		{
			x += word[i];
			x += "" "";
		}
	}
	print(x, false, true);
	return won;
}

string loadWords(string path)
{
	int line = 0;
	string word;
	vector<string> wordfile;
	ifstream reader(path);
	if (reader.is_open())
	{
		while (std::getline(reader, word))
		{
			wordfile.push_back(word);
		}

		int randomWord = rand() % wordfile.size();
		word = wordfile.at(randomWord);
		reader.close();
	}
	return word;
}

int ChancesLeft(string word, string guessed)
{
	int error = 0;
	for (int i = 0; i < guessed.length(); i++)
	{
		if (word.find(guessed[i]) == string::npos)
		{
			error++;
		}
	}
	return error;
}

int main()
{
beginning:
	srand(time(0));
	string guess;
	string words=loadWords(""words.txt"");
	int guesses = 0;
	bool win = false;
	int options;

	srand(time(0));
	print(""HANGMAN OPTIONS"");
	print(""1. PLAY"", false, false);
	print(""2. EXIT"", false, true);
	cin >> options;
	switch (options)
	{
	case 1: goto play;
		break;
	case 2: return 0;
		break;
	}
	system(""CLS"");

	do
	{
	play:
		system(""CLS"");
		print(""HANGMAN"");
		drawMan(guesses);
		printAlphabet(guess);
		win=wordCheck(words, guess);

		if (win)
			break;
		


		char input;
		cout << ""Enter the answer: "";
		cin >> input;
		if (guess.find(input) == string::npos)
		{
			guess += input;
		}

		guesses = ChancesLeft(words, guess);
	} while (guesses <=9);

	if (win)
		print(""YOU WON!!"");
	else if(guesses>=9)
		print(""GAME OVER :("");

	system(""pause"");
	system(""ClS"");
	goto beginning;
	getchar();

	return 0;
}
",frontSpace
960,"#include <cstdlib>
#include <deque>
#include <iostream>
#include <system_error>
#include <thread>

#include <asio.hpp>
#include ""message.hpp""

using asio::ip::tcp;
using std::error_code;

typedef std::deque<message> message_queue;

class client {
public:

  client(asio::io_service& io, tcp::resolver::iterator endpoint_iterator)
    : io_(io), socket_(io) {
    do_connect(endpoint_iterator);
  }

  void write(const message& msg) {
    io_.post([this, msg]()
    {
      auto  [MASK]  = !write_msgs_.empty();
      write_msgs_.push_back(msg);
      if (! [MASK] ) {
        do_write();
      }
    });
  }

  void close() {
    io_.post([this]() {socket_.close(); });
  }
private:
  void do_connect(const tcp::resolver::iterator endpoint_iterator) {
    asio::async_connect(socket_, endpoint_iterator, [this](error_code error, const tcp::resolver::iterator /*endpoint_iterator*/)
    {
      if (!error) {
        do_read_header();
      }
    });
  }

  void do_read_header() {
    auto buffer = header_buffer(read_msg_);
    asio::async_read(socket_, buffer, [this](error_code error, std::size_t /*length*/)
    {
      if (!error && read_msg_.decode_header()) {
        do_read_body();
      }
      else {
        socket_.close();
      }
    });
  }

  void do_read_body() {
    auto buffer = body_buffer(read_msg_);
    asio::async_read(socket_, buffer, [this](error_code error, std::size_t /*length*/)
    {
      if (!error) {
        std::cout.write(read_msg_.body(), read_msg_.body_length());
        std::cout << std::endl;
        do_read_header();
      }
    });
  }

  void do_write() {
    auto buffer = message_buffer(write_msgs_.front());
    asio::async_write(socket_, buffer, [this](error_code error, std::size_t /*length*/)
    {
      if (!error) {
        write_msgs_.pop_front();
        if (!write_msgs_.empty()) {
          do_write();
        }
      }
      else {
        socket_.close();
      }
    });
  }

  asio::io_service& io_;
  tcp::socket socket_;
  message read_msg_;
  message_queue write_msgs_;
};

int main(int argc, char* argv[]) {
  try {
    if (argc != 3) {
      std::cerr << ""Usage: chat-client <host> <port>"" << std::endl;
      return 1;
    }
    asio::io_service io;
    tcp::resolver resolver(io);
    auto endpoint_iterator = resolver.resolve({ argv[1], argv[2] });
    client c(io, endpoint_iterator);
    std::thread t([&io]() {io.run(); });

    char line[message::max_body_length + 1];
    while (std::cin.getline(line, message::max_body_length + 1)) {
      message msg;
      msg.set_body_length(strlen(line));
      std::memcpy(msg.body(), line, msg.body_length());
      msg.encode_header();
      c.write(msg);
    }
  }
  catch (std::exception& e) {
    std::cerr << ""Exception: "" << e.what() << std::endl;
  }
  return 0;
}
",write_in_progress
961,"#include <Servo.h>
Servo myservo0;

int Echo = A4;
int Trig = A5;




  // Motor control pins : L298N H bridge

  #define enAPin  5 // Left motor PWM speed control
  #define in1Pin  7 // Left motor Direction 1
  #define in2Pin  8 // Left motor Direction 2
  #define in3Pin  9 // Right motor Direction 1
  #define in4Pin  11 // Right motor Direction 2
  #define enBPin  6 // Right motor PWM speed control

  #define carSpeed 150

  int rightDistance = 0, leftDistance = 0, middleDistance = 0;
  
void forward(){

  analogWrite (enAPin, carSpeed);
  analogWrite (enBPin, 160);
  digitalWrite (in1Pin, HIGH);
  digitalWrite (in2Pin, LOW);
  digitalWrite (in3Pin, LOW);
  digitalWrite (in4Pin, HIGH);

  
}

void back(){

  analogWrite (enAPin, carSpeed);
  analogWrite (enBPin, carSpeed);
  digitalWrite (in1Pin, LOW);
  digitalWrite (in2Pin, HIGH);
  digitalWrite (in3Pin, HIGH);
  digitalWrite (in4Pin, LOW);  
}

void left(){

    analogWrite (enAPin, 100);
  analogWrite (enBPin, 100);
  digitalWrite (in1Pin, LOW);
  digitalWrite (in2Pin, HIGH);
  digitalWrite (in3Pin, LOW);
  digitalWrite (in4Pin, HIGH);
}


void right(){

    analogWrite (enAPin, 100);
  analogWrite (enBPin, 100);
  digitalWrite (in1Pin, HIGH);
  digitalWrite (in2Pin, LOW);
  digitalWrite (in3Pin, HIGH);
  digitalWrite (in4Pin, LOW);
}

void stop(){

  digitalWrite (enAPin, LOW);
  digitalWrite (enBPin, LOW);
  
}


// UltraSonic Distance measurement SUB FUNCTION

int Distance_test(){
  digitalWrite(Trig, LOW);
  delayMicroseconds(2);
  digitalWrite(Trig, HIGH);
  delayMicroseconds(20);
  digitalWrite(Trig, LOW);
  float  [MASK]  = pulseIn(Echo,HIGH);
   [MASK]  =  [MASK]  / 58;
  return (int) [MASK] ;
  
}

  void setup() 
  { 
myservo0.attach(3);
Serial.begin(9600);

  pinMode(Echo, INPUT);
  pinMode(Trig, OUTPUT);

  pinMode(enAPin, OUTPUT);
  pinMode(in1Pin, OUTPUT);
  pinMode(in2Pin, OUTPUT);
  pinMode(in3Pin, OUTPUT);
  pinMode(in4Pin, OUTPUT);
  pinMode(enBPin, OUTPUT);
  stop();
  
  } 

  
  void loop() 
  { 

myservo0.write(90);
delay(500);
middleDistance = Distance_test();

if (middleDistance <= 50){
  stop();
  delay(500);
  myservo0.write(10);
  delay(1000);
  rightDistance = Distance_test();

  delay(500);
  myservo0.write(90);
  delay(1000);
  myservo0.write(180);
  delay(1000);
  leftDistance = Distance_test();

  delay(500);
  myservo0.write(90);
  delay(100);
  if(rightDistance < leftDistance){
    right();
    delay(100);
  }
  else if (rightDistance > leftDistance){
    left();
    delay(100);
  }
  else if ((rightDistance <= 20) || (leftDistance <= 20)){
    back();
    delay(300);
  }
else{
  forward();
  }
}
else{
  forward();
  }
}


",Fdistance
962,"// SPDX-License-Identifier: GPL-2.0-or-later
// SPDX-FileCopyrightText: 2020 <NAME> <<EMAIL>>

#include ""ufwlogmodel.h""
#include <QDebug>

UfwLogModel::UfwLogModel(QObject *parent)
    : LogListModel(parent)
{
}

// Regexp failed me, parsing it is.
std::map<QString, QString> parseString(const QString &line)
{
    // We can find a line we are not interested.:
    // ""-- Journal begins at Sun 2020-09-20 11:37:15 BST, ends at Wed 2020-12-09 18:45:16 GMT. --""
    if (line.startsWith(QLatin1String(""-- Journal begins at ""))) {
        return {};
    }

    // indices
    // 0    1   2        3          4       5    6    7
    // Dec 06 17:42:45 tomatoland kernel: [UFW BLOCK] IN=wlan0 OUT= MAC= SRC=192.168.50.181
    // DST=172.16.31.10 LEN=56 TOS=0x00 PREC=0x00 TTL=255 ID=52151 PROTO=UDP SPT=5355 DPT=5355 LEN=36
    //
    // We are interested in the dates, (0, 1, 2), and then starting on 7.
    std::map<QString, QString> results;
    QStringList splited = line.split(' ');
    if (splited.size() < 7) {
        return {};
    }

    results[QStringLiteral(""date"")] = splited[0] + "" "" + splited[1];
    results[QStringLiteral(""time"")] = splited[3];

    // We can drop now everything up to 7.
    splited.erase(std::begin(splited), std::begin(splited) + 7);
    for (const QString &element : std::as_const(splited)) {
        for (const QString &key :
             {QStringLiteral(""IN""), QStringLiteral(""SRC""), QStringLiteral(""DST""), QStringLiteral(""PROTO""), QStringLiteral(""STP""), QStringLiteral(""DPT"")}) {
            if (element.startsWith(key)) {
                results[key] = element.mid(element.indexOf('=') + 1);
            }
        }
    }

    return results;
}

void UfwLogModel::addRawLogs(const QStringList &rawLogsList)
{
    QList<LogData>  [MASK] ;
     [MASK] .reserve(rawLogsList.count());
    for (const QString &log : rawLogsList) {
        auto map = parseString(log);

        LogData logDetails{.sourceAddress = map[""SRC""],
                           .sourcePort = map[""SPT""],
                           .destinationAddress = map[""DST""],
                           .destinationPort = map[""DPT""],
                           .protocol = map[""PROTO""],
                           .interface = map[""IN""],
                           .action = """",
                           .time = map[""time""],
                           .date = map[""date""]};
         [MASK] .append(logDetails);
    }
    qDebug() << ""Number of logs"" <<  [MASK] .count();
    appendLogData( [MASK] );
}
",newLogs
963,"/*
 * stateLed.h
 *
 *  Created on: 2019. 6. 23.
 *      Author: colson
 */

#ifndef INC_PERIPHGPIO_H_
#define INC_PERIPHGPIO_H_

#include ""main.h""

class PeriphGPIO {
protected:
	GPIO_TypeDef *GPIOx;			/**< GPIOx*/
	uint16_t GPIO_Pin;				/**< GPIOx_Pin*/
	GPIO_PinState PinState;			/**< GPIOx_State*/
	uint16_t period;				/**< GPIOx_period (uint 1ms)*/
	uint32_t nowtick;				/**< GPIOx_time control*/
	uint32_t pasttick;				/**< GPIOx_time control*/

public:

	PeriphGPIO(){	}
	PeriphGPIO(GPIO_TypeDef *GPIOx_, uint16_t  [MASK] , uint16_t period_):
		GPIOx(GPIOx_), GPIO_Pin( [MASK] ), PinState(GPIO_PIN_RESET), period(period_){
	}

	void init(){reset();}

	void re(void){period = 1000;}

	void setPeriod(uint16_t period_){period = period_;}

	void toggle(void){HAL_GPIO_TogglePin(GPIOx, GPIO_Pin);}

	void set(void){HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_SET);}

	void reset(void){HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_RESET);}

	GPIO_PinState read(void){return HAL_GPIO_ReadPin(GPIOx, GPIO_Pin);}

	void run(void){
		nowtick = HAL_GetTick();
		if(period == 0)
		{
		}
		else if(nowtick - pasttick > period)
		{
			toggle();
			pasttick = nowtick;
		}
	}
};




#endif /* INC_PERIPHGPIO_H_ */
",GPIO_Pin_
964,"#include ""config.h""

#include <assert.h>

#include <any>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>

Config::Config() {
    // Default configuration
    node_[""column_limit""] = 80;
    node_[""indent_width""] = 4;
    node_[""use_tab""] = false;
    node_[""tab_width""] = 4;
    node_[""continuation_indent_width""] = 4;
    node_[""spaces_before_call""] = 1;

    node_[""keep_simple_control_block_one_line""] = true;
    node_[""keep_simple_function_one_line""] = true;

    node_[""align_args""] = true;
    node_[""break_after_functioncall_lp""] = false;
    node_[""break_before_functioncall_rp""] = false;

    node_[""align_parameter""] = true;
    node_[""chop_down_parameter""] = false;
    node_[""break_after_functiondef_lp""] = false;
    node_[""break_before_functiondef_rp""] = false;

    node_[""align_table_field""] = true;
    node_[""break_after_table_lb""] = true;
    node_[""break_before_table_rb""] = true;
    node_[""chop_down_table""] = false;
    node_[""chop_down_kv_table""] = true;
    node_[""table_sep""] = "","";
    node_[""extra_sep_at_table_end""] = false;
    node_[""column_table_limit""] = node_[""column_limit""];

    node_[""break_after_operator""] = true;

    node_[""double_quote_to_single_quote""] = false;
    node_[""single_quote_to_double_quote""] = false;

    // Validators
    // validate integer without 0s as configuration value
    auto validate_integer = [](std::string key, std::any elem) {
        int value = std::any_cast<int>(elem);
        if (value > 0) {
            return value;
        }
        std::cerr << ""[ERROR] Processing "" << key << "" failed"" << std::endl;
        throw domain_error(
            ""[ERROR] Configuration value is out of range. Must be a positive ""
            ""integer greater than 0."");
    };

    // validate integer with 0s as configuration value
    auto validate_integer_zero = [](std::string key, std::any elem) {
        int value = std::any_cast<int>(elem);
        if (value >= 0) {
            return value;
        }
        std::cerr << ""[ERROR] Processing "" << key << "" failed"" << std::endl;
        throw domain_error(
            ""[ERROR] Configuration value is out of range. Must be a positive ""
            ""integer."");
    };
    auto validate_boolean = [](std::string key, std::any elem) {
        bool value = std::any_cast<bool>(elem);
        return value;
    };
    auto  [MASK]  = [](std::string key, std::any elem) {
        char value = std::any_cast<char>(elem);
        return value;
    };
    auto validate_quote = [&](std::string key, std::any elem) {
        bool value = std::any_cast<bool>(elem);
        if (key == ""double_quote_to_single_quote"") {
            if (value && (node_[""single_quote_to_double_quote""]).as<bool>()) {
                throw logic_error(
                    ""[ERROR] Configuration value of ""
                    ""double_quote_to_single_quote is ""
                    ""conflicting with the value of ""
                    ""single_quote_to_double_quote"");
            }
        } else if (key == ""single_quote_to_double_quote"") {
            if (value && (node_[""double_quote_to_single_quote""]).as<bool>()) {
                throw logic_error(
                    ""[ERROR] Configuration value of ""
                    ""single_quote_to_double_quote is ""
                    ""conflicting with the value of ""
                    ""double_quote_to_single_quote"");
            }
        }
        return value;
    };
    auto validate_use_tab = [&](std::string key, std::any elem) {
        bool value = std::any_cast<bool>(elem);
        if (value && (node_[""tab_width""]).as<int>() == false) {
            throw logic_error(
                ""[ERROR] Configuration value of use_tab is conflicting with ""
                ""the ""
                ""value of tab_width"");
        }
        return value;
    };
    auto validate_tab_width = [&](std::string key, std::any elem) {
        int value = std::any_cast<int>(elem);
        if (value < 0) {
            throw domain_error(
                ""[ERROR] Configuration value of tab_width is out ""
                ""of range. Must be a ""
                ""positive integer."");
        } else if (value == false && (node_[""use_tab""]).as<bool>()) {
            throw logic_error(
                ""[ERROR] Configuration value of tab_width is conflicting with ""
                ""the ""
                ""value of use_tab"");
        }
        return value;
    };

    validators[""spaces_before_call""] = validate_integer_zero;
    validators[""column_limit""] = validate_integer;
    validators[""indent_width""] = validate_integer_zero;
    validators[""tab_width""] = validate_tab_width;
    validators[""continuation_indent_width""] = validate_integer_zero;
    validators[""column_table_limit""] = validate_integer;
    validators[""use_tab""] = validate_use_tab;
    validators[""keep_simple_control_block_one_line""] = validate_boolean;
    validators[""keep_simple_function_one_line""] = validate_boolean;
    validators[""align_args""] = validate_boolean;
    validators[""break_after_functioncall_lp""] = validate_boolean;
    validators[""break_before_functioncall_rp""] = validate_boolean;
    validators[""align_parameter""] = validate_boolean;
    validators[""chop_down_parameter""] = validate_boolean;
    validators[""break_after_functiondef_lp""] = validate_boolean;
    validators[""break_before_functiondef_rp""] = validate_boolean;
    validators[""align_table_field""] = validate_boolean;
    validators[""break_after_table_lb""] = validate_boolean;
    validators[""break_before_table_rb""] = validate_boolean;
    validators[""chop_down_table""] = validate_boolean;
    validators[""chop_down_kv_table""] = validate_boolean;
    validators[""extra_sep_at_table_end""] = validate_boolean;
    validators[""break_after_operator""] = validate_boolean;
    validators[""double_quote_to_single_quote""] = validate_quote;
    validators[""single_quote_to_double_quote""] = validate_quote;
    validators[""table_sep""] =  [MASK] ;

    // DataType of every configuration field
    datatype[""spaces_before_call""] = 'i';
    datatype[""column_limit""] = 'i';
    datatype[""indent_width""] = 'i';
    datatype[""tab_width""] = 'i';
    datatype[""continuation_indent_width""] = 'i';
    datatype[""column_table_limit""] = 'i';
    datatype[""use_tab""] = 'b';
    datatype[""keep_simple_control_block_one_line""] = 'b';
    datatype[""keep_simple_function_one_line""] = 'b';
    datatype[""align_args""] = 'b';
    datatype[""break_after_functioncall_lp""] = 'b';
    datatype[""break_before_functioncall_rp""] = 'b';
    datatype[""align_parameter""] = 'b';
    datatype[""chop_down_parameter""] = 'b';
    datatype[""break_after_functiondef_lp""] = 'b';
    datatype[""break_before_functiondef_rp""] = 'b';
    datatype[""align_table_field""] = 'b';
    datatype[""break_after_table_lb""] = 'b';
    datatype[""break_before_table_rb""] = 'b';
    datatype[""chop_down_table""] = 'b';
    datatype[""chop_down_kv_table""] = 'b';
    datatype[""extra_sep_at_table_end""] = 'b';
    datatype[""break_after_operator""] = 'b';
    datatype[""double_quote_to_single_quote""] = 'b';
    datatype[""single_quote_to_double_quote""] = 'b';
    datatype[""table_sep""] = 'c';
}

void Config::readFromFile(const string& file) {
    std::filesystem::file_status status = std::filesystem::status(file);
    std::filesystem::perms perm = status.permissions();

    if (!std::filesystem::is_regular_file(status)) {
        cerr << file << "": Not a file."" << endl;
        exit(-1);
    }

    if ((perm & std::filesystem::perms::owner_read) ==
        std::filesystem::perms::none) {
        cerr << file << "": No access to read."" << endl;
        exit(-1);
    }

    YAML::Node n = YAML::LoadFile(file);

    // Keys are always strings
    bool given = false;
    string CTL = ""column_table_limit"";
    string CL = ""column_limit"";
    for (auto kv : n) {
        auto key = kv.first.as<string>();
        if (node_[key]) {
            switch (datatype[key]) {
                case 'i': {
                    auto value = kv.second.as<int>();
                    node_[key] =
                        std::any_cast<int>(validators[key](key, value));
                    break;
                }
                case 'b': {
                    auto value = kv.second.as<bool>();
                    node_[key] =
                        std::any_cast<bool>(validators[key](key, value));
                    break;
                }
                case 'c': {
                    auto value = kv.second.as<char>();
                    node_[key] =
                        std::any_cast<char>(validators[key](key, value));
                    break;
                }
            }
        }
        if (key == CTL) {
            given = true;
        }
    }
    if (!given) {
        node_[CTL] = node_[CL];
    }
}

void Config::readFromMap(map<string, any>& mp) {
    bool given = false;
    string CTL = ""column_table_limit"";
    string CL = ""column_limit"";
    for (auto kv : mp) {
        auto key = kv.first;
        if (node_[key]) {
            switch (datatype[key]) {
                case 'i': {
                    assert(strcmp(kv.second.type().name(), ""i"") == 0);
                    node_[key] =
                        std::any_cast<int>(validators[key](key, kv.second));
                    break;
                }
                case 'b': {
                    assert(strcmp(kv.second.type().name(), ""b"") == 0);
                    node_[key] =
                        std::any_cast<bool>(validators[key](key, kv.second));
                    break;
                }
                case 'c': {
                    assert(strcmp(kv.second.type().name(), ""c"") == 0);
                    node_[key] =
                        std::any_cast<char>(validators[key](key, kv.second));
                    break;
                }
            }
        }
        if (key == CTL) {
            given = true;
        }
    }
    if (!given) {
        node_[CTL] = node_[CL];
    }
}

void Config::dumpCurrent(ofstream& fout) { fout << node_ << endl; }
void Config::dumpCurrent(ostream& out) { out << node_ << endl; }
",validate_character
965,"// Copyright 2016 Open Source Robotics Foundation, Inc.
//
// 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 <functional>
#include <memory>

#include ""rclcpp/rclcpp.hpp""
#include ""cipher_interfaces/msg/cipher_message.hpp""
#include ""cipher_interfaces/srv/cipher_answer.hpp""
using std::placeholders::_1;
using namespace std::chrono_literals;

std::string caesar_decipher(const std::string &text, int key)
{
  std::string result = text;
  for (char &c : result) {
    if (std::isalpha(c)) {
      // Determine the base (depending on if the character is lowercase or uppercase).
      char base = std::islower(c) ? 'a' : 'A';
      // Subtract the key from the character's position while handling wrap-around.
      c = base + (c - base - key + 26) % 26;
    }
  }
  return result;
}

class CipherSubscriber : public rclcpp::Node
{
public:
  CipherSubscriber()
  : Node(""cipher_subscriber"")
  {
    subscription_ = this->create_subscription<cipher_interfaces::msg::CipherMessage>(
      ""cipher_topic"", 10, std::bind(&CipherSubscriber::topic_callback, this, _1));

    client_ = this->create_client<cipher_interfaces::srv::CipherAnswer>(""verify_decoded"");
  }

private:
  void topic_callback(const cipher_interfaces::msg::CipherMessage & msg) const
  {
    RCLCPP_INFO(this->get_logger(), ""Recieved encoded message: '%s', key: %d"", msg.message.c_str(), msg.key);
  
    std::string decoded_message = caesar_decipher(msg.message, msg.key);
    RCLCPP_INFO(this->get_logger(), ""Decoded message: '%s'"", decoded_message.c_str());

    // Wait for the verification service to be available.
    if (!client_->wait_for_service(1s)) {
      RCLCPP_WARN(this->get_logger(), ""Service 'verify_decoded' not available, skipping verification."");
      return;
    }

    // Create a service request with the decoded message.
    auto request = std::make_shared<cipher_interfaces::srv::CipherAnswer::Request>();
    request->answer = decoded_message;

    // Asynchronously send the request to the verification service.
    auto future_result = client_->async_send_request(
      request,
      [this, decoded_message](rclcpp::Client<cipher_interfaces::srv::CipherAnswer>::SharedFuture future)
      {
        auto  [MASK]  = future.get();
        if ( [MASK] ->result) {
          RCLCPP_INFO(this->get_logger(), ""Verification: The decoded message '%s' is CORRECT."",
                      decoded_message.c_str());
        } else {
          RCLCPP_INFO(this->get_logger(), ""Verification: The decoded message '%s' is INCORRECT."",
                      decoded_message.c_str());
        }
      });
  }
  rclcpp::Subscription<cipher_interfaces::msg::CipherMessage>::SharedPtr subscription_;
  rclcpp::Client<cipher_interfaces::srv::CipherAnswer>::SharedPtr client_;

};

int main(int argc, char * argv[])
{
  rclcpp::init(argc, argv);
  rclcpp::spin(std::make_shared<CipherSubscriber>());
  rclcpp::shutdown();
  return 0;
}
",response
966,"
#include ""EnemyManager.h""
#include ""util.h""

USING_NS_CC;

bool EnemyManager::init() {
  if (!Node::init()) { return false; }

  enemys_.resize(50);
  for (size_t i = 0; i < enemys_.size(); ++i) {
    auto enemy = Enemy::create();
    enemy->setVisible(false);
    enemys_[i] = enemy;

    addChild(enemy);
  }

  auto action1 = DelayTime::create(1.0f);
  auto action2 = CallFunc::create([this]() {
    // x軸は真ん中から-200 <= x <= 200の範囲でランダム生成
    // y軸は一番上から
    auto rand = RandomHelper::random_int(-200, 200);
    enable(Vec2(util::mid().x + rand, util::size().height));
    CCLOG(""Spawing Enemy"");
  });
  auto  [MASK]  = Sequence::create(action1, action2, NULL);
  auto re = RepeatForever::create( [MASK] );
  this->runAction(re);

  return true;
}

void EnemyManager::update() {
  for (size_t i = 0; i < enemys_.size(); ++i) {
    auto enemy = enemys_[i];
    enemy->update();

    auto pos = enemy->getPosition();
    if (pos.y < 0) {
      enemy->disable();
    }
  }
}

void EnemyManager::enable(const Vec2& position) {
  for (size_t i = 0; i < enemys_.size(); ++i) {
    auto enemy = enemys_[i];
    if (enemy->isVisible()) { continue; }

    enemy->enable(position);
    return;
  }
}

const std::vector<Enemy*>& EnemyManager::getEnemys() {
  return enemys_;
}",seq
967,"#include <pluginlib/class_list_macros.h>

#include <laser_odometry_core/laser_odometry_utils.h>
#include <laser_odometry_libpointmatcher/laser_odometry_libpointmatcher.h>

#include <tf_conversions/tf_eigen.h>

#include <fstream>

namespace laser_odometry {

bool LaserOdometryLibPointMatcher::configureImpl()
{
  std::string  [MASK] ;
  private_nh_.searchParam(""libpointmatcher_config"",  [MASK] );

  if (private_nh_.hasParam( [MASK] ))
  {
    std::string libpointmatcher_config;
    private_nh_.getParam( [MASK] , libpointmatcher_config);

    std::ifstream ifs(libpointmatcher_config.c_str());
    if (ifs.good())
    {
      icp_.loadFromYaml(ifs);
      ROS_INFO_STREAM(""Load config from YAML file "" << libpointmatcher_config);
    }
    else
    {
      ROS_ERROR_STREAM(""Cannot load config from YAML file "" << libpointmatcher_config);
      icp_.setDefault();
    }

    ifs.close();
  }
  else
  {
    ROS_WARN_STREAM(""No config file specified, using default ICP chain."");
    icp_.setDefault();
  }

  Scalar kf_dist_linear;
  kf_dist_linear        = private_nh_.param(""dist_threshold"",    0.3);
  kf_dist_angular_      = private_nh_.param(""rot_threshold"",     0.17);
  estimated_overlap_th_ = private_nh_.param(""overlap_threshold"", 0.65);
  match_ratio_th_       = private_nh_.param(""ratio_threshold"",   0.65);

  kf_dist_linear_sq_ = kf_dist_linear * kf_dist_linear;

  return true;
}

bool LaserOdometryLibPointMatcher::processImpl(const sensor_msgs::LaserScanConstPtr& scan_msg,
                                               const Transform& prediction)
{
  convert<sensor_msgs::LaserScan>(scan_msg, source_cloud_);

  return icp(source_cloud_, prediction);
}

bool LaserOdometryLibPointMatcher::processImpl(const sensor_msgs::PointCloud2ConstPtr& cloud_msg,
                                               const Transform& prediction)
{
  convert<sensor_msgs::PointCloud2>(cloud_msg, source_cloud_);

  return icp(source_cloud_, prediction);
}

bool LaserOdometryLibPointMatcher::icp(const DataPointsPtr& src_cloud,
                                       const Transform& prediction)
{
  if (src_cloud->features.cols() == 0)
  {
    ROS_ERROR(""No good points in the cloud"");
    return false;
  }

  bool icp_valid = false;

  // Call ICP
  Matcher::TransformationParameters transform;
  try
  {
    transform = icp_(*src_cloud, *ref_cloud_, prediction.matrix());

    icp_valid = true;
  }
  catch (const Matcher::ConvergenceError& error)
  {
    ROS_ERROR_STREAM(""ICP failed to converge: "" << error.what());
    return false;
  }

  if (icp_valid)
  {
    increment_ = Eigen::Matrix<Scalar, 4, 4>(transform);

    /// @todo this damn cov is full of NaNs in 2D...
//    ROS_ERROR_STREAM(""icp_.errorMinimizer->getCovariance()\n""
//                     << icp_.errorMinimizer->getCovariance());

//    increment_covariance_ = icp_.errorMinimizer->getCovariance();

    assert(increment_covariance_.rows()==6 &&
           increment_covariance_.cols()==6);
  }
  else
  {
    increment_.setIdentity();
    ROS_WARN(""libpointmatcher could not align scans."");
  }

  return true;
}

void LaserOdometryLibPointMatcher::isKeyFrame()
{
  /// @todo what's best?
  std::swap(ref_cloud_, source_cloud_);
//  Matcher::swapDataPoints(*ref_cloud_, *source_cloud_);
}

bool LaserOdometryLibPointMatcher::initialize(const sensor_msgs::LaserScanConstPtr& scan_msg)
{
  convert<sensor_msgs::LaserScan>(scan_msg, ref_cloud_);

  if (ref_cloud_->features.cols() == 0)
  {
    ROS_ERROR(""initialize: No good points in the cloud"");
    return false;
  }

  current_time_ = scan_msg->header.stamp;

  return true;
}

bool LaserOdometryLibPointMatcher::initialize(const sensor_msgs::PointCloud2ConstPtr& cloud_msg)
{
  convert<sensor_msgs::PointCloud2>(cloud_msg, ref_cloud_);

  if (ref_cloud_->features.cols() == 0)
  {
    ROS_ERROR(""initialize: No good points in the cloud"");
    return false;
  }

  current_time_ = cloud_msg->header.stamp;

  return true;
}

bool LaserOdometryLibPointMatcher::isKeyFrame(const Transform& tf)
{
  if (std::abs(utils::getYaw(tf.rotation())) > kf_dist_angular_)
  {
    ROS_DEBUG_STREAM(""Angular key-frame: "" << std::abs(utils::getYaw(tf.rotation())));
    return true;
  }

  if (tf.translation().squaredNorm() > kf_dist_linear_sq_)
  {
    ROS_DEBUG_STREAM(""Linear key-frame: "" << tf.translation().squaredNorm());
    return true;
  }

  if (icp_.errorMinimizer->getOverlap() < estimated_overlap_th_)
  {
    ROS_DEBUG_STREAM(""Overlap key-frame: "" << icp_.errorMinimizer->getOverlap());
    return true;
  }

  return false;
}

OdomType LaserOdometryLibPointMatcher::odomType() const noexcept
{
  /// @todo @note depending on the icp_->errorMinimizer
  /// the returned covariance is either an actual covariance
  /// or identity.
  return OdomType::Odom3DCov;
}

} /* namespace laser_odometry */

PLUGINLIB_EXPORT_CLASS(laser_odometry::LaserOdometryLibPointMatcher, laser_odometry::LaserOdometryBase);
",libpointmatcher_config_name
968,"/* HM-LGW emulation for HM-MOD-RPI
 *
 * Copyright (c) 2015 <NAME>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the ""Software""), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>

#include ""hmframe.h""


int writeall( int fd, const void *buffer, int len )
{
    int result = 0;
    while( len )
    {
        int r = write( fd, buffer, len );
        if( r == -1 )
        {
            result = r;
            break;
        }
        result += r;
        len -= r;
    }
    return result;
}

static const unsigned char enterBootloader[] =
    {
        0xfd, 0x00, 0x03, 0x00, 0x00, 0x03, 0x18, 0x0a 
    };
    
static const unsigned char bootloaderReply[] =
    {
        0xfd, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x5f, 0x43, 0x50, 0x55, 0x5f, 0x42, 0x4c, 0x72, 0x51 
    };

int sendEnterBootloader( int fd )
{
    int result = -1;
    while( 1 )
    {
        char buffer[80];
        tcflush(fd, TCIOFLUSH);
        result =writeall( fd, enterBootloader, sizeof( enterBootloader ) );
        if( result <= 0 )
        {
            break;
        }
        result = readBidcosFrame( fd, buffer, sizeof( buffer ) );
        if( result <= 0 )
        {
            break;
        }
        if( isBootloaderReply( buffer, result ) )
        {
            break;
        }
    }
    return result;
}

int sendBootloaderReply( int fd )
{
    return writeall( fd, bootloaderReply, sizeof( bootloaderReply ) );
}

bool isBootloaderReply( const void *buffer, int len )
{
    if( len != sizeof(bootloaderReply) )
        return false;
        
    return (memcmp( buffer, bootloaderReply, len ) == 0);
}


int readBidcosFrame( int fd, char *buffer, int bufsize )
{
    int result = 0;
    int msgLen = 0;
    int escaped = 0;
    int count = bufsize;
    unsigned char *buf = (unsigned char *)buffer;
    char  [MASK]  = 0x00;
    bool haveLength = false;
    
    while ( count )
    {
        int r = read( fd, buf, 1 );
        if( r <= 0 )
        {
            result = r;
            perror( ""ERROR: readBidcosFrame"" );
            break;
        }
        if( *buf == 0xFD ) // sync byte
        {
            result = 0;
            msgLen = 0;
            escaped = 0;
            count = bufsize;
            buf = (unsigned char *)buffer;
             [MASK]  = 0x00;
            haveLength = false;
            // fprintf( stderr,  ""readBidcosFrame reset\n"" );
        }
        else if( result == 0 )
        {
            fprintf( stderr,  ""ERROR: readBidcosFrame sync error %2.2x\n"", *buf );
            // No sync at beginning? Not good...
            break;
        }
        
        result += r;
        
        if( *buf == 0xFC && result > 1 ) // escape byte
        {
            escaped++;
             [MASK]  = 0x80;
            // fprintf( stderr,  ""ESCAPE msgLen set %d result %d\n"", msgLen, result );
        }
        else
        {
             [MASK]  = 0x00;
        }

        if( false == haveLength )
        {
            if( result == 2 + escaped )
            {
                msgLen = *buf; // MSB
                msgLen |=  [MASK] ;
                msgLen = msgLen<<8;
            }
            else if( result == 3 + escaped )
            {
                msgLen |= *buf; // LSB
                msgLen |=  [MASK] ;
                haveLength = true;
                // fprintf( stderr,  ""readBidcosFrame msgLen set %d result %d\n"", msgLen, result );
            }
        }
        else if( result >= msgLen + escaped + 5 )
        {
            // fprintf( stderr,  ""readBidcosFrame done, msgLen %d result %d\n"", msgLen, result );
            break;
        }
        
        count -= r;
        buf+=r;
    }

    return result;
}
",escapeValue
969,"#include ""Compositor.h""

namespace WPEFramework {
namespace Plugin {
    SERVICE_REGISTRATION(Compositor, 1, 0);

    static Core::ProxyPoolType<Web::Response> responseFactory(4);
    static Core::ProxyPoolType<Web::JSONBodyType<Compositor::Data> > jsonResponseFactory(4);

    Compositor::Compositor()
        : _adminLock()
        , _skipURL()
        , _notification(this)
        , _resourceCenter(nullptr)
        , _composition(nullptr)
        , _service(nullptr)
        , _pid()
    {
    }

    Compositor::~Compositor()
    {
    }

    /* virtual */ const string Compositor::Initialize(PluginHost::IShell* service)
    {
        printf(""Compositor::Initialize\n""); fflush(stdout);
        string message(EMPTY_STRING);
        string result;

        ASSERT(service != nullptr);
        ASSERT(_resourceCenter == nullptr);

        Compositor::Config config;
        config.FromString(service->ConfigLine());

        _skipURL = service->WebPrefix().length();

        // See if the mandatory XDG environment variable is set, otherwise we will set it.
        if (Core::SystemInfo::GetEnvironment(_T(""XDG_RUNTIME_DIR""), result) == false) {

            string runTimeDir((config.WorkDir.Value()[0] == '/') ? config.WorkDir.Value() : service->PersistentPath() + config.WorkDir.Value());

            Core::SystemInfo::SetEnvironment(_T(""XDG_RUNTIME_DIR""), runTimeDir);

            TRACE(Trace::Information, (_T(""XDG_RUNTIME_DIR is set to %s ""), runTimeDir));
        }

        if (config.OutOfProcess.Value() == true) {
            printf(""Compositor start out-of-process\n""); fflush(stdout);
            _resourceCenter = service->Instantiate<Exchange::IResourceCenter>(
                2000, _T(""PlatformImplementation""), static_cast<uint32_t>(~0), _pid, config.Locator.Value());
            TRACE(Trace::Information,
                (_T(""Compositor started out of process %s implementation""), config.Locator.Value().c_str()));
        }
        else {
            printf(""Compositor start in-process\n""); fflush(stdout);
            Core::Library resource(config.Locator.Value().c_str());
            if (!resource.IsLoaded())
            {
                string path = service->DataPath() + config.Locator.Value();
                resource = Core::Library(path.c_str());
            }
            if (resource.IsLoaded() == true) {
                _resourceCenter = Core::ServiceAdministrator::Instance().Instantiate<Exchange::IResourceCenter>(
                    resource, _T(""PlatformImplementation""), static_cast<uint32_t>(~0));
                TRACE(Trace::Information,
                    (_T(""Compositor started in process %s implementation""), config.Locator.Value().c_str()));
            }
            else {
                message = _T(""Could not load the PlatformPlugin library ["") + config.Locator.Value() + _T(""]"");
            }
        }

        if (_resourceCenter == nullptr) {
            message = ""Instantiating the compositor failed. Could not load: "" + config.Locator.Value();
        }
        else {
            _service = service;

            _composition = _resourceCenter->QueryInterface<Exchange::IComposition>();

            _notification.Initialize(service, _composition);

            _resourceCenter->Configure(_service);

            // We would actually need to handle setting the Graphics event in the PlatformImplementation. For now, we do it here.
            PluginHost::ISubSystem* subSystems = _service->SubSystems();

            ASSERT(subSystems != nullptr);

            if (subSystems != nullptr) {
                // Set Graphics event. We need to set up a handler for this at a later moment
                subSystems->Set(PluginHost::ISubSystem::GRAPHICS, nullptr);
                subSystems->Release();
            }
        }

        // On succes return empty, to indicate there is no error text.
        return message;
    }
    /* virtual */ void Compositor::Deinitialize(PluginHost::IShell* service)
    {
        ASSERT(service == _service);

        // We would actually need to handle setting the Graphics event in the PlatformImplementation. For now, we do it here.
        PluginHost::ISubSystem* subSystems = _service->SubSystems();

        ASSERT(subSystems != nullptr);

        if (subSystems != nullptr) {
            // Set Graphics event. We need to set up a handler for this at a later moment
            subSystems->Set(PluginHost::ISubSystem::NOT_GRAPHICS, nullptr);
            subSystems->Release();
        }
 
        if (_resourceCenter != nullptr) {
            _resourceCenter->Release();
            _resourceCenter = nullptr;
        }

        _notification.Deinitialize();
    }
    /* virtual */ string Compositor::Information() const
    {
        // No additional info to report.
        return (_T(""""));
    }

    /* virtual */ void Compositor::Inbound(Web::Request& /* request */)
    {
    }
    /* virtual */ Core::ProxyType<Web::Response> Compositor::Process(const Web::Request& request)
    {
        ASSERT(_skipURL <= request.Path.length());

        Core::ProxyType<Web::Response> result(responseFactory.Element());
        Core::TextSegmentIterator
            index(Core::TextFragment(request.Path, _skipURL, request.Path.length() - _skipURL), false, '/');

        // If there is an entry, the first one will always be a '/', skip this one..
        index.Next();

        result->ErrorCode = Web::STATUS_OK;
        result->Message = ""OK"";

        // <GET> ../
        if (request.Verb == Web::Request::HTTP_GET) {
            Core::ProxyType<Web::JSONBodyType<Data> > response(jsonResponseFactory.Element());
            // http://<ip>/Service/Compositor/
            if (index.Next() == false) {
                Clients(response->Clients);
            }

            // http://<ip>/Service/Compositor/Clients
            else if (index.Current() == ""Clients"") {
                Clients(response->Clients);
            }

            result->ContentType = Web::MIMETypes::MIME_JSON;
            result->Body(Core::proxy_cast<Web::IBody>(response));
        }
        else if (request.Verb == Web::Request::HTTP_POST) {
            Core::ProxyType<Web::JSONBodyType<Data> > response(jsonResponseFactory.Element());

            if (index.Next() == true) {
                string clientName(index.Current().Text());

                if (index.Next() == true) {
                    if (index.Current().Text() == ""Kill"") { /* http://<ip>/Service/Compositor/Netflix/Kill */
                        Kill(clientName);
                    }
                    if (index.Current().Text() == ""Opacity"" && index.Next() == true) { /* http://<ip>/Service/Compositor/Netflix/Opacity/128 */
                        const uint32_t opacity(std::stoi(index.Current().Text()));
                        Opacity(clientName, opacity);
                    }
                    if (index.Current().Text() == ""Visible"" && index.Next() == true) { /* http://<ip>/Service/Compositor/Netflix/Visible/Hide */
                        if (index.Current().Text() == _T(""Hide"")) {
                            Visible(clientName, false);
                        }
                        else if (index.Current().Text() == _T(""Show"")) {
                            Visible(clientName, true);
                        }
                    }
                    if (index.Current().Text() == ""Geometry"") { /* http://<ip>/Service/Compositor/Netflix/Geometry/0/0/1280/720 */
                        uint32_t x(0), y(0), width(0), height(0);

                        if (index.Next() == true) {
                            x = std::stoi(index.Current().Text());
                        }
                        if (index.Next() == true) {
                            y = std::stoi(index.Current().Text());
                        }
                        if (index.Next() == true) {
                            width = std::stoi(index.Current().Text());
                        }
                        if (index.Next() == true) {
                            height = std::stoi(index.Current().Text());
                        }

                        Geometry(clientName, x, y, width, height);
                    }
                    if (index.Current().Text() == ""Top"") { /* http://<ip>/Service/Compositor/Netflix/Top */
                        Top(clientName);
                    }
                    if (index.Current().Text() == ""Input"") { /* http://<ip>/Service/Compositor/Netflix/Input */
                        Input(clientName);
                    }
                }
            }

            result->ContentType = Web::MIMETypes::MIME_JSON;
            result->Body(Core::proxy_cast<Web::IBody>(response));
        }
        else {
            result->ErrorCode = Web::STATUS_BAD_REQUEST;
            result->Message = string(_T(""Unsupported request for the service.""));
        }
        // <PUT> ../Server/[start,stop]
        return result;
    }

    void Compositor::Attached(Exchange::IComposition::IClient* client)
    {
        ASSERT(client != nullptr);

        string name(client->Name());

        _adminLock.Lock();
        std::map<string, Exchange::IComposition::IClient*>::iterator it = _clients.find(name);

        if (it != _clients.end()) {
            it->second->Release();
            _clients.erase(it);
        }

        _clients[name] = client;
        client->AddRef();

        _adminLock.Unlock();

        TRACE(Trace::Information, (_T(""Client %s attached""), name.c_str()));
    }
    void Compositor::Detached(Exchange::IComposition::IClient* client)
    {
        ASSERT(client != nullptr);

        string name(client->Name());

        _adminLock.Lock();
        std::map<string, Exchange::IComposition::IClient*>::iterator it = _clients.find(name);

        if (it != _clients.end()) {
            it->second->Release();
            _clients.erase(it);
        }
        _adminLock.Unlock();

        TRACE(Trace::Information, (_T(""Client %s detached""), name.c_str()));
    }
    void Compositor::Clients(Core::JSON::ArrayType<Core::JSON::String>& clients) const
    {
        _adminLock.Lock();
        for (auto const& client : _clients) {
            TRACE(Trace::Information, (_T(""Client %s added to the JSON array""), client.first.c_str()));
            Core::JSON::String& element(clients.Add());
            element = client.first;
        }
        _adminLock.Unlock();
    }
    void Compositor::Kill(const string& client) const
    {
        ASSERT(_composition != nullptr);

        if (_composition != nullptr) {
            Exchange::IComposition::IClient* composition = _composition->Client(client);
            if (composition != nullptr) {
                composition->Kill();
            }
            else {
                TRACE(Trace::Information, (_T(""Client %s not found.""), client.c_str()));
            }
        }
    }
    void Compositor::Opacity(const string& client, const uint32_t value) const
    {
        ASSERT(_composition != nullptr);

        if (_composition != nullptr) {
            Exchange::IComposition::IClient* composition = _composition->Client(client);
            if (composition != nullptr) {
                composition->Opacity(value);
            }
            else {
                TRACE(Trace::Information, (_T(""Client %s not found.""), client.c_str()));
            }
        }
    }

    void Compositor::Geometry(const string& client, const uint32_t x, const uint32_t y, const uint32_t width, const uint32_t height) const
    {
        ASSERT(_composition != nullptr);

        if (_composition != nullptr) {
            Exchange::IComposition::IClient* composition = _composition->Client(client);
            if (composition != nullptr) {
                composition->Geometry(x, y, width, height);
            }
            else {
                TRACE(Trace::Information, (_T(""Client %s not found.""), client.c_str()));
            }
        }
    }

    void Compositor::Visible(const string& client, const bool  [MASK] ) const
    {
        ASSERT(_composition != nullptr);

        if (_composition != nullptr) {
            Exchange::IComposition::IClient* composition = _composition->Client(client);
            if (composition != nullptr) {
                composition->Visible( [MASK] );
            }
            else {
                TRACE(Trace::Information, (_T(""Client %s not found.""), client.c_str()));
            }
        }
    }
    void Compositor::Top(const string& client) const
    {
        ASSERT(_composition != nullptr);

        if (_composition != nullptr) {
            Exchange::IComposition::IClient* composition = _composition->Client(client);
            if (composition != nullptr) {
                composition->SetTop();
            }
            else {
                TRACE(Trace::Information, (_T(""Client %s not found.""), client.c_str()));
            }
        }
    }
    void Compositor::Input(const string& client) const
    {
        ASSERT(_composition != nullptr);

        if (_composition != nullptr) {
            Exchange::IComposition::IClient* composition = _composition->Client(client);
            if (composition != nullptr) {
                composition->SetInput();
            }
            else {
                TRACE(Trace::Information, (_T(""Client %s not found.""), client.c_str()));
            }
        }
    }

} // namespace Plugin
} // namespace WPEFramework
",visible
970,"//
//  Map.cpp
//  maproom-robot
//
//  Created by <NAME> on 2/20/17.
//
//

#include ""Map.h""

Map::Map(float width, float height, float offsetX, float offsetY, ofRectangle crop):
	widthM(width), heightM(height),
	offsetX(offsetX), offsetY(offsetY),
	origOffsetX(offsetX), origOffsetY(offsetY),
	svgExtentMin(10000), svgExtentMax(-10000),
	storeCount(0), pathCount(0),
	cropBox(crop)
{}

void Map::storePath(string lineType, float startX, float startY, float destX, float destY) {
    // be wary of strings with types of the same first two letters

    pathSegment segment;
	segment.prescaleStart = ofVec2f(startX, startY);
	segment.prescaleEnd = ofVec2f(destX, destY);
    
    MapPath  [MASK]  = {storeCount++, false, false, lineType, segment};

	if (!mapPathStore[lineType].size()) {
		pathTypes.push_back(lineType);
		activePaths[lineType] = true;
	}
	mapPathStore[lineType].push_back( [MASK] );

	if (segment.prescaleStart.x > svgExtentMax.x) {
		svgExtentMax.x = segment.prescaleStart.x;
	}
	if (segment.prescaleStart.y > svgExtentMax.y) {
		svgExtentMax.y = segment.prescaleStart.y;
	}
	if (segment.prescaleStart.x < svgExtentMin.x) {
		svgExtentMin.x = segment.prescaleStart.x;
	}
	if (segment.prescaleStart.y < svgExtentMin.y) {
		svgExtentMin.y = segment.prescaleStart.y;
	}

	if (segment.prescaleEnd.x > svgExtentMax.x) {
		svgExtentMax.x = segment.prescaleEnd.x;
	}
	if (segment.prescaleEnd.y > svgExtentMax.y) {
		svgExtentMax.y = segment.prescaleEnd.y;
	}
	if (segment.prescaleEnd.x < svgExtentMin.x) {
		svgExtentMin.x = segment.prescaleEnd.x;
	}
	if (segment.prescaleEnd.y < svgExtentMin.y) {
		svgExtentMin.y = segment.prescaleEnd.y;
	}
}

// TODO: reincorporate this somewhere
//bool shouldStore = true;
//if ((segment.end - segment.start).length() < 0.005f) {
//	shouldStore = false;
//}
//for (auto &path : mapPathStore[lineType]) {
//	if (!shouldStore) {
//		break;
//	}
//
//	const float kEpsilon = 0.001; // 1mm
//	if (path.segment.start.distance(segment.start) < kEpsilon && path.segment.end.distance(segment.end) < kEpsilon) {
//		shouldStore = false;
//	} else if (path.segment.end.distance(segment.start) < kEpsilon && path.segment.start.distance(segment.end) < kEpsilon) {
//		shouldStore = false;
//	}
//}

void Map::setPathActive(string lineType, bool active) {
	if (mapPathStore.find(lineType) != mapPathStore.end()) {
		activePaths[lineType] = active;
	} else {
		cout << lineType << "" is not in activePaths"" << endl;
	}
}

int Map::getActivePathCount() {
	int count = 0;
	for (auto &i : mapPathStore) {
		if (activePaths[i.first]) {
			for (auto &j : i.second) {
				count++;
			}
		}
	}
	return count;
}

int Map::getDrawnPaths() {
	int count = 0;
	for (auto &i : mapPathStore) {
		if (activePaths[i.first]) {
			for (auto &j : i.second) {
				if (j.drawn) count++;
			}
		}
	}
	return count;
}

int Map::getPathCount() {
	int count = 0;
	for (auto type: pathTypes) {
		for (auto path: mapPathStore[type]) {
			count++;
		}
	}
	return count;
}

int Map::getPathCount(string type) {
	int count = 0;
	for (auto path: mapPathStore[type]) {
		count++;
	}
	return count;
}

float getAngle(ofVec2f start, ofVec2f end) {
    return atan2(end.x - start.x, end.y - start.y)*180/3.14159;
}

void Map::optimizePaths(float percentDiff) {
    const float kEpsilon = 0.001; // 1mm
    int toRemoveCount = 0;
    for (auto type: pathTypes) {
        for (int i=0; i<mapPathStore[type].size(); i++) {
            pathSegment cur = mapPathStore[type][i].segment;

            for (int j=0; j<mapPathStore[type].size(); j++) {
                if (i != j) {
                    pathSegment tar = mapPathStore[type][j].segment;
                    bool endToStart = cur.end.distance(tar.start) < kEpsilon;
                    bool startToEnd = cur.start.distance(tar.end) < kEpsilon;
                    bool endToEnd = cur.end.distance(tar.end) == kEpsilon;
                    bool startToStart = cur.start.distance(tar.start) == kEpsilon;

                    if((endToStart || startToEnd || endToEnd || startToStart) && !mapPathStore[type][i].drawn && !mapPathStore[type][j].drawn && !mapPathStore[type][i].claimed && !mapPathStore[type][j].claimed) {
                        float curAngle;
                        float tarAngle;
                        float newAngle;
                        if (endToEnd) {
                            curAngle = getAngle(cur.end, cur.start);
                            tarAngle = getAngle(tar.start, tar.end);
                        } else if (endToStart) {
                            curAngle = getAngle(cur.end, cur.start);
                            tarAngle = getAngle(tar.end, tar.start);
                        } else if (startToStart) {
                            curAngle = getAngle(cur.start, cur.end);
                            tarAngle = getAngle(tar.end, tar.start);
                        } else if (startToEnd) {
                            curAngle = getAngle(cur.start, cur.end);
                            tarAngle = getAngle(tar.start, tar.end);
                        }
                        
                        
                        MapPath tmp = mapPathStore[type][i];
                        
                        float diff = ((curAngle+360) - (tarAngle+360));
                        if (abs(fmod((diff+360),360.0)) < percentDiff) {
//                            
//                            cout << ""cur "" <<  cur.start << "","" << cur.end << endl;
//                            cout << ""curAngle "" << curAngle << endl;
//                            cout << ""tar "" <<  tar.start << "","" << tar.end << endl;
//                            cout << ""tarAngle "" << tarAngle << endl;
//                            cout << ""diff: "" << diff << endl;
                            
                            if (startToStart) {
                                mapPathStore[type][i].segment.end = mapPathStore[type][j].segment.end;
                            } else if (startToEnd) {
                                mapPathStore[type][i].segment.start = mapPathStore[type][j].segment.start;
                            } else if (endToStart) {
                                mapPathStore[type][i].segment.end = mapPathStore[type][j].segment.end;
                            } else if (endToEnd) {
                                mapPathStore[type][i].segment.end = mapPathStore[type][j].segment.start;
                            }

//                            cout << ""similar degrees"" << endl;
                            mapPathStore[type][j].claimed = true;
                            toRemoveCount++;
//                            break;
                        }
                    }
                }
            }
        }
    }



    // remove all claimed path
    int removedPaths = 0;
    while(toRemoveCount > 0) {
        for (auto type: pathTypes) {
            for (int i=0; i<mapPathStore[type].size(); i++) {
                if (mapPathStore[type][i].claimed) {
                    mapPathStore[type].erase(mapPathStore[type].begin() + i);
                    toRemoveCount--;
                    removedPaths++;
                    break;
                }
                
            }
        }
    }
    cout << ""removed paths "" << removedPaths << endl;
}

void Map::clearStore() {
	activePaths.clear();
	mapPathStore.clear();
    pathTypes.clear();
}

string Map::getMostRecentMap(string filePath) {
    // TODO: make this not absolute path, or change username
    ofDirectory dir(filePath);
    dir.allowExt(""svg"");
    dir.listDir();

    string mostRecentTime = """";
    string file = """";

    for(int i = 0; i < dir.size(); i++){
        string fileName = ofToString(dir.getPath(i));
        regex r(""maproom-(.+)\\.svg"");
        smatch m;
        regex_search(fileName, m, r);
        for(auto v: m) {
            if (ofToString(v).size() == 24) {
                if (mostRecentTime != """") {
                    mostRecentTime = v;
                    file = fileName;
                } else if(v.compare(mostRecentTime) > 0) {
                    mostRecentTime = v;
                    file = fileName;
                }
            }
        }
    }
    return file;
}

void Map::loadMap(const string filename) {
	currentMap.clear();
    currentMap.loadFile(filename);
	scaleX = 1.0;
	scaleY = 1.0;
	offsetX = 0.0;
	offsetY = 0.0;
	svgExtentMin = ofVec2f(10000);
	svgExtentMax = ofVec2f(-10000);

    clearStore();
    
    currentMap.pushTag(""svg"");
    int firstLevel = currentMap.getNumTags(""g"");
    for (int i = 0; i < firstLevel; i++) {
        currentMap.pushTag(""g"", i);
        int secondLevel = currentMap.getNumTags(""g"");
        for (int j = 0; j < secondLevel; j++) {
            string lineType = ofToString(currentMap.getAttribute(""g"", ""id"", """", j));
            currentMap.pushTag(""g"", j);
            int thirdLevel = currentMap.getNumTags(""path"");
            for (int k = 0; k < thirdLevel; k++) {
                string path = ofToString(currentMap.getAttribute(""path"", ""d"", """", k));
                int startIndex, endIndex, firstX, firstY;
                float move_x, move_y, dest_x, dest_y, last_x, last_y;
                int state = 1;
                
                for (int l = 0; l < path.size(); l++) {
                    switch (state) {
                        case 1: // M -> comma
                            if (path[l] == 'M') {
                                startIndex = l+1;
                            }
                            if (path[l] == ',') {
                                endIndex = l-1;
                                move_x = stof(path.substr(startIndex, endIndex));
                                startIndex = l+1;
                                state = 2;
                            }
                            break;
                        case 2: // comma -> L [after M]
                            if (path[l] == 'L') {
                                endIndex = l-1;
                                // store incase there is a Z
                                move_y = stof(path.substr(startIndex, endIndex));
								firstX = move_x;
								firstY = move_y;
                                startIndex = l+1;
                                state = 3;
                            }
                            break;
                        case 3: // L -> comma [after M -> comma]
                            if (path[l] == ',') {
                                endIndex = l-1;
                                dest_x = stof(path.substr(startIndex, endIndex));
                                startIndex = l+1;
                                state = 4;
                            }
                            break;
                        case 4: // comma -> (L || M) [after M -> comma -> L]
                            if (path[l] == 'L') {
                                endIndex = l-1;
                                dest_y = stof(path.substr(startIndex, endIndex));
                                storePath(lineType, move_x, move_y, dest_x, dest_y);
                                pathCount++;
                                last_x = dest_x;
                                last_y = dest_y;
                                startIndex = l+1;
                                state = 5;
                            } else if (path[l] == 'M') {
                                endIndex = l-1;
                                dest_y = stof(path.substr(startIndex, endIndex));
                                storePath(lineType, move_x, move_y, dest_x, dest_y);
                                pathCount++;
                                startIndex = l+1;
                                state = 1;
                            }
                            break;
                        case 5: // L -> comma [after L]
                            if (path[l] == ',') {
                                endIndex = l-1;
                                dest_x = stof(path.substr(startIndex, endIndex));
                                startIndex = l+1;
                                state = 6;
                            }
                            break;
                        case 6: // comma -> L || M [after L -> comma]
                            if (path[l] == 'L') {
                                endIndex = l-1;
                                dest_y = stof(path.substr(startIndex, endIndex));
                                storePath(lineType, last_x, last_y, dest_x, dest_y);
                                pathCount++;
                                last_x = dest_x;
                                last_y = dest_y;
                                startIndex = l+1;
                                state = 5;
                            } else if (path[l] == 'M') {
                                endIndex = l-1;
                                dest_y = stof(path.substr(startIndex, endIndex));
                                storePath(lineType, last_x, last_y, dest_x, dest_y);
                                pathCount++;
                                startIndex = l+1;
                                state = 1;
                            } else if (path[l] == 'Z') {
                                endIndex = l-1;
                                dest_y = stof(path.substr(startIndex, endIndex));
                                storePath(lineType, dest_x, dest_y, firstX, firstY);
                                pathCount++;
                                state = 1;
                            }
                            break;
                        default:
                            cout << ""unknown state reached in Map.cpp"" << endl;
                            break;
                    }
                    // reaches end of string
                    if (l == path.size()-1) {
                        endIndex = l;
                        dest_y = stof(path.substr(startIndex, endIndex));
                        if (state == 6) {
                            storePath(lineType, last_x, last_y, dest_x, dest_y);
                            pathCount++;
                        } else {
                            storePath(lineType, move_x, move_y, dest_x, dest_y);
                            pathCount++;
                        }
                    }
                }
            }
            currentMap.popTag();
        }
        currentMap.popTag();
    }
    currentMap.popTag();

	rescaleMap(widthM, heightM, origOffsetX, origOffsetY);
}

void Map::rescaleMap(float width, float height, float newOffsetX, float newOffsetY) {
	widthM = width;
	heightM = height;

	float svgWidth = svgExtentMax.x - svgExtentMin.x;
	float svgHeight = svgExtentMax.y - svgExtentMin.y;

	scaleX = 1.0 / svgWidth * widthM;
	scaleY = 1.0 / svgHeight * heightM;
	const ofVec2f scale(scaleX, scaleY);

	offsetX = newOffsetX - svgExtentMin.x * scaleX;
	offsetY = newOffsetY - svgExtentMin.y * scaleY;
	const ofVec2f offset(offsetX, offsetY);

	for (auto &path : pathTypes) {
		if (mapPathStore.find(path) == mapPathStore.end()) {
			continue;
		}

		for (auto mapPathIt = mapPathStore[path].begin(); mapPathIt != mapPathStore[path].end(); /* no increment */)
		{
			MapPath &mapPath = *mapPathIt;

			if (mapPath.claimed || mapPath.drawn) {
				continue;
			}

			mapPath.segment.start = mapPath.segment.prescaleStart * scale + offset;
			mapPath.segment.end = mapPath.segment.prescaleEnd * scale + offset;

			bool success = CohenSutherlandLineClip(mapPath.segment.start, mapPath.segment.end, cropBox);

			static const float kEpsilon = 0.005;
			for (auto &otherMapPath : mapPathStore[path]) {
				if (otherMapPath.id == mapPath.id) {
					continue;
				}

				if ((mapPath.segment.start.distance(otherMapPath.segment.start) < kEpsilon && mapPath.segment.end.distance(otherMapPath.segment.end) < kEpsilon)
					|| (mapPath.segment.start.distance(otherMapPath.segment.end) < kEpsilon && mapPath.segment.end.distance(otherMapPath.segment.start) < kEpsilon)) {
					success = false;
					break;
				}
			}

			if (!success) {
				mapPathIt = mapPathStore[path].erase(mapPathIt);
			} else {
				++mapPathIt;
			}
		}
	}
    
//    cout << ""pre optimize count: "" << getPathCount() << endl;
//    cout << ""optimize SVG"" << endl;
//    float optPercent = 6;
//    optimizePaths(optPercent);
//    cout << ""post optimize count: "" << getPathCount() << endl;
}

MapPath* Map::nextPath(const ofVec2f &pos, int robotId, float lastHeading, const set<string> &pathTypes) {
    MapPath *next = NULL;
    vector<MapPath*> contenders;
    float minDist = INFINITY;
    
    int checkedPath = 0;
    for (auto &pathType : pathTypes) {
        if (mapPathStore.find(pathType) == mapPathStore.end()) {
            continue;
        }
    
        // check if path is active and that the robot id can draw it
		if (!activePaths[pathType] || pathTypes.find(pathType) == pathTypes.end()) {
            continue;
        }

        // check if robot has that
        for (auto &mapPath : mapPathStore[pathType]) {
            if (mapPath.claimed || mapPath.drawn) {
                continue;
            }
            checkedPath++;
            
            float startDist = mapPath.segment.start.distance(pos);
            float endDist = mapPath.segment.end.distance(pos);

            if (startDist < minDist) {
                minDist = startDist;
                contenders.clear();
                contenders.push_back(&mapPath);
            } else if (endDist < minDist) {
                minDist = endDist;
                contenders.clear();
                contenders.push_back(&mapPath);
            } else if (abs(endDist-minDist) < 0.0001) {
                contenders.push_back(&mapPath);
            } else if (abs(startDist-minDist) < 0.0001) {
                contenders.push_back(&mapPath);
            }
        }
    }
    if (contenders.size() > 1) {
        // pick path with heading closest to last path
        float minAngleDiff = INFINITY;
        for (int i=0; i<contenders.size(); i++) {
            MapPath p = *contenders[i];
            float angle = getAngle(p.segment.start, p.segment.end);
            float angleDiff = abs(fmod(((angle+360)-(lastHeading+360)), 360.0));
            if (angleDiff < minAngleDiff) {
                minAngleDiff = angleDiff;
                next = contenders[i];
            }
        }
        return next;
    } else if (contenders.size() == 1) {
        return contenders[0];
    } else {
     	return next;
    }
}

",toStore
971,"#include <ros/ros.h>
#include <image_transport/image_transport.h>
#include <sensor_msgs/image_encodings.h>
#include <pylon/PylonIncludes.h>
#include <pylon/usb/BaslerUsbInstantCamera.h>
#include <camera_info_manager/camera_info_manager.h>

class PylonUSBCamera {
    private:
        // This smart pointer will receive the grab result data.
        Pylon::CGrabResultPtr ptrGrabResult;
        Pylon::CBaslerUsbInstantCamera * camera;
    public:
        PylonUSBCamera() {
            Pylon::PylonInitialize();
            // Create an instant camera object with the camera device found first.
            camera = new Pylon::CBaslerUsbInstantCamera(Pylon::CTlFactory::GetInstance().CreateFirstDevice());
            camera->Open();
            // Print the model name of the camera.
            ROS_INFO(""Using device %s"", camera->GetDeviceInfo().GetModelName().c_str());
            // The parameter MaxNumBuffer can be used to control the count of buffers
            // allocated for grabbing. The default value of this parameter is 10.
            camera->MaxNumBuffer = 5;
            camera->PixelFormat.SetValue(Basler_UsbCameraParams::PixelFormat_RGB8);
            //camera->Width.SetValue(640);
            //camera->Height.SetValue(480);
            //camera->OffsetX.SetValue(0);
            //camera->OffsetY.SetValue(0);
            //camera->BinningHorizontal.SetValue(2);
            //camera->BinningVertical.SetValue(2);
            // Start the grabbing.
            // The camera device is parameterized with a default configuration which
            // sets up free-running continuous acquisition.
            camera->StartGrabbing(/*Pylon::GrabStrategy_LatestImageOnly*/);
        }
        ~PylonUSBCamera() {
            delete camera;
            Pylon::PylonTerminate(); 
        }
     Pylon::CGrabResultPtr & grab_frame() {
        if (camera->IsGrabbing())
        {
            // Wait for an image and then retrieve it. A timeout of 1000 ms is used.
            camera->RetrieveResult(1000, ptrGrabResult, Pylon::TimeoutHandling_ThrowException);
            // Image grabbed successfully?
            if (ptrGrabResult->GrabSucceeded())
            {
                return ptrGrabResult;
            }
            else
            {
                throw std::runtime_error(
                    std::string(ptrGrabResult->GetErrorDescription())
                );
            }
        }
        else
        {
            throw std::runtime_error(""Camera is not grabbing."");
        }
    }
};

sensor_msgs::Image pylon_result_to_image_message(Pylon::CGrabResultPtr & ptrGrabResult) {
    // Access the image data.
    const uint8_t *pImageBuffer = (uint8_t *) ptrGrabResult->GetBuffer();
    const size_t  [MASK]  = ptrGrabResult->GetPayloadSize();
    sensor_msgs::Image img_raw_msg;
    img_raw_msg.header.stamp = ros::Time::now(); 
    img_raw_msg.width = ptrGrabResult->GetWidth();
    img_raw_msg.height = ptrGrabResult->GetHeight();
    img_raw_msg.encoding = sensor_msgs::image_encodings::RGB8; // TODO: check if this actually matches the camera settings
    img_raw_msg.step = img_raw_msg.width * 3; // TODO: see above
    img_raw_msg.data.assign(pImageBuffer,pImageBuffer+ [MASK] );
    return img_raw_msg;
    }

int main(int argc, char **argv)
{
    ros::init(argc, argv, ""pylon_camera_node"");
    ros::NodeHandle nh(""~"");
    image_transport::ImageTransport it(nh);
    image_transport::CameraPublisher publisher = it.advertiseCamera(""image_raw"", 1);
    camera_info_manager::CameraInfoManager cim(nh);
    std::string camera_info_url;
    if (nh.getParam(""camera_info_url"", camera_info_url))
    {
        cim.loadCameraInfo(camera_info_url);
    }
    else
    {
        ROS_WARN(""camera_info_url not supplied in configuration. Camera info will be unavailable. Rectification is not possible."");
    }
    sensor_msgs::CameraInfo cam_info = cim.getCameraInfo();
    PylonUSBCamera camera;
    while(ros::ok()) {
        sensor_msgs::Image img = pylon_result_to_image_message(camera.grab_frame());
        cam_info.header.stamp = img.header.stamp;
        publisher.publish(img, cam_info);
        ros::spinOnce();
    };
    return EXIT_SUCCESS;
}
",payloadSize
972,"// pololu-cartographer.cpp
// Developed by: <NAME>, ID: 17982686
// ENSE504 2018 Assignment 1 program code
// Requires encoder.cpp and encoder.h as a library in the project.

#include ""mbed.h""
#include ""m3pimaze.h""
#include ""encoder.h""
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <map>

using namespace std;

// PI is not defined in the mbed math files
const double PI = 3.1415926535897931;

// define the m3pi (robot) and Serial (wixel) objects
m3pi robot(p23, p9, p10);
Serial wixel(p28, p27);

// create timer
Timer timer;

int main() {

    // CHANGE MOTOR SPEED HERE
    const float motorSpeeds[] = {0.7, 0.4}; // motor speeds for robot from left to right motor

    // define constants
    const int calcBreak_ms = 50; // time between calculations in ms
    const int pulsePerRev = 45; // wheel pulese/revolution
    const float axle_cm = 9.6; // axle length in cm
    const float  [MASK]  = 3.6; // wheel diameter in cm
    const double pulseDistance = PI * ( [MASK]  / pulsePerRev);

    // define variables
    int runTime_ms = 0; // time since started main operation started in milliseconds
    int nextCalcTime_ms; // time for next calculation in ms
    int encoder_l = 0; // left rotary encoder value
    int encoder_r = 0; // right rotary encoder value
    float runTime_s = 0.00; // time since main operation started in seconds
    float roboVoltage; // robots battery voltage
    float roboH_change; // change in heading after movement & recalculation
    float roboH_degrees; // robots heading in degrees
    float roboR; // distance of robot to graph origin (path radius)

    // associative array ('map' or 'dictionary') of robot position for easier handling
    map<string,float> roboPosition;
    roboPosition[""X""] = 0.0; // robot X co-ordinate
    roboPosition[""Y""] = 0.0; // robot Y co-ordinate
    roboPosition[""H""] = 0.0; // robot heading
    
    // display the 'active' message on robot LCD on boot (program title too long)
    for (int i = 0; i < 3; i++) {

        robot.cls();
        wait(.5);
        robot.locate(0, 0);
        robot.printf(""Mapping!"");
        wait(.5);
    }
   
    // set the Wixel communication speed (baud rate / bitrate)
    wixel.baud(115200);

    // display the program title on the PC
    wixel.printf(""Pololu Cartographer\r\n"");

    // get and display the battery voltage
    roboVoltage = robot.battery();
    wixel.printf(""Battery voltage: %.3f\r\n"", roboVoltage);

    // display the wheel speeds
    wixel.printf(""Wheel speeds: Right = %.2f, Left = %.2f\r\n\r\n"", motorSpeeds[1], motorSpeeds[0]);

    // display the PC column headings
    wixel.printf(""Position log: \r\n"");
    wixel.printf(""___|___X___|___Y___|___H___|___T__|_L_|_R_|\r\n""); // print formatted column-headers

    // transmit the initial robot position to the PC
    roboH_degrees = roboPosition[""H""] * (180 / PI); // convert robo heading to degrees
    wixel.printf(""POS,%7.2f,%7.2f,%7.2f,%6.2f,%3d,%3d\r\n"", roboPosition[""X""], roboPosition[""Y""], roboH_degrees, runTime_s, encoder_l, encoder_r);
    
    // initialise the encoders
    InitEncoder();   
    // pause for 2 seconds before starting
    wait(2);
    
    // turn the motors on, at the required speeds
    robot.left_motor(motorSpeeds[0]);
    robot.right_motor(motorSpeeds[1]);
    // motor speeds swapped because left/right mixup in 3pi library

    // start the timer
    timer.start();
    // set the time for the first calculation
    nextCalcTime_ms = calcBreak_ms;
    
    // the main loop   
    while(1) {

        // wait until it is time for next calculation
        do {

            runTime_ms = timer.read_ms();

        } while (runTime_ms < nextCalcTime_ms);
        // set time for the next calculation
        nextCalcTime_ms += calcBreak_ms;

        // get the encoder pulse counts
        encoder_l = LeftEncoder();
        encoder_r = RightEncoder();
      
        // display the pulse count values on the LCD left value = left encoder, right value = right encoder
        robot.locate(0, 1);
        robot.printf(""%3d  %3d"", encoder_l, encoder_r);

        // if the wheels moved
        if (encoder_l != 0 || encoder_r != 0) {

            // calculate the change in the robot position
            if (encoder_l == encoder_r) { // if encoder_l equals encoder_r

                roboPosition[""X""] = (encoder_l * pulseDistance * cos(roboPosition[""H""]));
                roboPosition[""Y""] = (encoder_l * pulseDistance * sin(roboPosition[""H""]));

            } else { // otherwise, encoder_l does not equal encoder_r

                roboR = (0.5 * axle_cm * (encoder_r + encoder_l) / (encoder_r - encoder_l));
                roboH_change = ((encoder_r - encoder_l) * pulseDistance / axle_cm);
                roboPosition[""X""] += (roboR * (sin(roboPosition[""H""] + roboH_change) - sin(roboPosition[""H""])));
                roboPosition[""Y""] += (roboR * (cos(roboPosition[""H""]) - cos(roboPosition[""H""] + roboH_change)));

            }
            
            // calculate the new robot heading
            roboPosition[""H""] += roboH_change;

            // if necessary, adjust the heading
            if (roboPosition[""H""] < -PI) {

                roboPosition[""H""] += 2 * PI;

            } else if (roboPosition[""H""] > PI) {

                roboPosition[""H""] -= 2 * PI;

            }
        }

        // add one 5ms period to run time for 1 complete calculation
        runTime_s += 0.05; // plain number instead of variable&math for less processor cycles

        // convert robo heading to degrees
        roboH_degrees = roboPosition[""H""] * (180 / PI);

        // transmit the new robot position + data to the PC
        wixel.printf(""POS,%7.2f,%7.2f,%7.2f,%6.2f,%3d,%3d\r\n"", roboPosition[""X""], roboPosition[""Y""], roboH_degrees, runTime_s, encoder_l, encoder_r);
    }
}


",wheel_cm
973,"#include ""core/application.h""
#include ""core/time_delta.h""

#include ""rendering/renderer_2d.h""
#include ""rendering/render_command.h""

#include ""events/mouse_event.h""

#include <Windows.h>

Application* Application::s_instance = nullptr;

Application::Application(const std::string& name, uint32_t width, uint32_t height)
{
	s_instance = this;

	WindowProps  [MASK] {};
	 [MASK] .title = name;
	 [MASK] .width = width;
	 [MASK] .height = height;

	m_window = Window::create( [MASK] );
	m_window->set_event_callback(std::bind(&Application::on_event, this, std::placeholders::_1));

	RenderCommand::init();

	Renderer2D::init();
}

Application::~Application()
{
	Renderer2D::shutdown();
}

void Application::push_layer(Layer* layer)
{
	m_layer_stack.push_layer(layer);
	layer->on_attach();
}

void Application::on_event(Event& e)
{
	EventDispatcher dispatcher(e);
	dispatcher.dispatch<WindowCloseEvent>(std::bind(&Application::on_window_close, this, std::placeholders::_1));
	dispatcher.dispatch<WindowResizeEvent>(std::bind(&Application::on_window_resize, this, std::placeholders::_1));

	for (auto it = m_layer_stack.rbegin(); it != m_layer_stack.rend(); ++it)
	{
		if (e.m_handled)
			break;
		(*it)->on_event(e);
	}
}

void Application::run()
{	
	while (m_running)
	{
		float time = m_window->get_time();
		TimeDelta time_delta = time - m_last_frame_time;
		m_last_frame_time = time;

		if (!m_minimized)
		{
			RenderCommand::clear();

			// update layer stack
			for (Layer* layer : m_layer_stack)
				layer->on_update(time_delta);
		}

		m_window->on_update();
	}
}

bool Application::on_window_close(WindowCloseEvent& e)
{
	CORE_INFO(""received WindowCloseEvent()"");
	m_running = false;
	return true;
}

bool Application::on_window_resize(WindowResizeEvent& e)
{
	CORE_INFO(""received WindowResizeEvent()"");
	if (e.get_width() == 0 || e.get_height() == 0)
	{
		m_minimized = true;
		return false;
	}

	m_minimized = false;
	Renderer2D::on_window_resize(e.get_width(), e.get_height());

	return false;
}
",properties
974,"#include ""HistogramHelper.h""
#include <opencv2/opencv.hpp>
#include <tuple>
#include <iterator>
#include <map>
#include <omp.h>
#include <math.h>
#include <iostream>
const int PIXEL_RANGE = 256;
const int MAX_PIXEL_VAL = 255;

int *ExtractHistogram(cv::Mat img, int *count, int x_start, int x_end, int y_start, int y_end, int *histt, int sw)
{
    if (histt == NULL)
    {
        histt = new int[PIXEL_RANGE]();
    }
    else
    {
        if (x_start < 0 || x_end > img.size().height || y_start < 0 || y_end > img.size().width)
        {
            return NULL;
        }
    }
    int height = img.size().height;
    int width = img.size().width;
    if (x_start < 0)
        x_start = 0;
    if (x_end > height)
        x_end = height;
    if (y_start < 0)
        y_start = 0;
    if (y_end > width)
        y_end = width;

    for (auto i = x_start; i < x_end; i++)
    {
        for (auto j = y_start; j < y_end; j++)
        {
            *count += sw;
            histt[img.at<uchar>(i, j)] += sw;
        }
    }
    return histt;
}

int *ExtractHistogramRGB(cv::Mat img, int *count, int x_start, int x_end, int y_start, int y_end, short channel, int *histt, int sw)
{
    if (histt == NULL)
    {
        histt = new int[PIXEL_RANGE]();
    }
    else if (x_start < 0 || x_end > img.size().height || y_start < 0 || y_end > img.size().width)
        return NULL;

    int height = img.size().height;
    int width = img.size().width;
    if (x_start < 0)
        x_start = 0;
    if (x_end > height)
        x_end = height;
    if (y_start < 0)
        y_start = 0;
    if (y_end > width)
        y_end = width;

    for (auto i = x_start; i < x_end; i++)
        for (auto j = y_start; j < y_end; j++)
        {
            *count += sw;
            histt[img.at<cv::Vec3b>(i, j)[channel]] += sw;
        }
    return histt;
}

double *CalculateProbability(int *hist, int total_pixels)
{
    double *prob = new double[PIXEL_RANGE]();
    for (auto i = 0; i < PIXEL_RANGE; i++)
    {
        prob[i] = (double)hist[i] / total_pixels;
    }
    return prob;
}

double *BuildLookUpTable(double *prob)
{
    double *lut = new double[PIXEL_RANGE]();

    for (auto i = 0; i < PIXEL_RANGE; i++)
    {
        for (auto j = 0; j <= i; j++)
        {
            lut[i] += prob[j] * MAX_PIXEL_VAL;
        }
    }
    return lut;
}

double *BuildLookUpTableRGB(int *hist_blue, int *hist_green, int *hist_red, int count, bool  [MASK] )
{
    double *prob_blue = CalculateProbability(hist_blue, count);
    double *lut_blue = BuildLookUpTable(prob_blue);
    delete[] prob_blue;

    double *prob_green = CalculateProbability(hist_green, count);
    double *lut_green = BuildLookUpTable(prob_green);
    delete[] prob_green;

    double *prob_red = CalculateProbability(hist_red, count);
    double *lut_red = BuildLookUpTable(prob_red);
    delete[] prob_red;

    double *lut_final = new double[PIXEL_RANGE]();

    for (auto i = 0; i < PIXEL_RANGE; i++)
    {
        lut_final[i] = (lut_blue[i] + lut_green[i] + lut_red[i]) / 3.0;
    }
    if ( [MASK] )
    {
        delete[] lut_blue;
        delete[] lut_green;
        delete[] lut_red;
    }
    return lut_final;
}",free_sw
975,"#include ""Arduino.h""

#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <WiFiClient.h>
#include <ArduinoOTA.h>
#include <ThingSpeak.h>
#include <DHT.h>


#include ""settings.h""

const char* ssid = SETTINGS_SSID;
const char* password = SETTINGS_<PASSWORD>;

float f;
float h;

#define DHTPIN 2
#define DHTTYPE DHT11

void setupTempSensor(void);
void readTemp(void);
void postValues(void);
String convertFloatToString(float n);

WiFiClient client;
DHT dht(DHTPIN, DHTTYPE);

int main() {
  setup();
  for(;;) {
    loop();
  }
}

void setup() {
  Serial.begin(115200);
  Serial.println(""Booting"");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println(""Connection Failed! Rebooting..."");
    delay(5000);
    ESP.restart();
  }

  // Port defaults to 8266
  // ArduinoOTA.setPort(8266);

  // Hostname defaults to esp8266-[ChipID]
  // ArduinoOTA.setHostname(""myesp8266"");

  // No authentication by default
  // ArduinoOTA.setPassword((const char *)""123"");

  ArduinoOTA.onStart([]() {
    Serial.println(""Start"");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println(""\nEnd"");
  });
  ArduinoOTA.onProgress([](unsigned int  [MASK] , unsigned int total) {
    Serial.printf(""Progress: %u%%\r"", ( [MASK]  / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf(""Error[%u]: "", error);
    if (error == OTA_AUTH_ERROR) Serial.println(""Auth Failed"");
    else if (error == OTA_BEGIN_ERROR) Serial.println(""Begin Failed"");
    else if (error == OTA_CONNECT_ERROR) Serial.println(""Connect Failed"");
    else if (error == OTA_RECEIVE_ERROR) Serial.println(""Receive Failed"");
    else if (error == OTA_END_ERROR) Serial.println(""End Failed"");
  });
  ArduinoOTA.begin();
  Serial.println(""Ready OTA"");
  Serial.print(""IP address: "");
  Serial.println(WiFi.localIP());
  
  setupTempSensor();
  delay(2000);
  ThingSpeak.begin(client);
  delay(100);
}

int counter;

void loop() {
  counter++;
  // 1200 * 100 - this should be about 2 min, but not sure how long ArduinoOTA.handle() takes...
  if (counter > 1200) { 
    readTemp();
    postValues();
    counter = 0;
  }
  ArduinoOTA.handle();
  delay(100);
}

void postValues(void) {
  if (!isnan(f)) {
    Serial.println(""posting: f: "" + convertFloatToString(f) + "" h: "" + convertFloatToString(h));
    ThingSpeak.setField(1,f);
    ThingSpeak.setField(3,h);
    ThingSpeak.writeFields(SETTINGS_THINGSPEAK_CHANNEL, SETTINGS_THINGSPEAK_KEY);
  } 
  else {
    Serial.println(""dht read error"");
  }
  delay(60000);
}

void readTemp(void) {
  f = dht.readTemperature(true);
  delay(2000);
  h = dht.readHumidity();
  delay(2000);
}

void setupTempSensor(void) {
  dht.begin();
  delay(100);
}

String convertFloatToString(float n) {
  char buf2[16];
  return dtostrf(n, 5, 2, buf2);
}






",progress
976,"import std;
import modlog;

auto main() -> int {
  using namespace modlog;
  using modlog::LogLevel::Debug;
  using modlog::LogLevel::Error;
  using modlog::LogLevel::Info;
  using modlog::LogLevel::Silent;

  Log(Info) << ""Hello World!"";
  Log(Error) << ""Hello World! Again..."";
  Log() << ""Hello World! (this is INFO)"";
  Log(Silent) << ""Hello World! (Silent: does not appear...)"";
  Log(Debug) << ""Hello World! (Debug: does not appear...)"";

  VLog(0) << ""Hello World! (this is INFO too)"" << std::endl;
  VLog(1) << ""Hello World! (this does not appear...)"" << std::endl;

  // enable JSON logging
  modlog::modlog_default.fprefixdata = modlog::json_prefix;

  Log(Info) << ""Hello World!"";
  // finish json!
  *modlog::modlog_default.os << ""\""}"";

  // ==================================
  // enable personalized logfmt logging
  // ==================================
  using modlog::LogLevel::Warning;

  modlog::modlog_default.fprefixdata =
      [](std::ostream& os, LogLevel l, std::tm local_tm,
         std::chrono::microseconds us, std::uintptr_t tid,
         std::string_view  [MASK] , int line, bool debug) -> std::ostream& {
    os << std::endl;  // always break line
    std::string slevel;
    if (l == LogLevel::Debug)
      slevel = ""debug"";
    else if (l == LogLevel::Info)
      slevel = ""info"";
    else if (l == LogLevel::Warning)
      slevel = ""warn"";
    else if (l == LogLevel::Error)
      slevel = ""error"";
    if (debug) slevel = ""debug"";

    os << std::format(
        ""level={} time={:04}-{:02}-{:02}T{:02}:{:02}:{:02}.{:03} thread={} ""
        ""caller={}:{} msg="",
        slevel, local_tm.tm_year + 1900, local_tm.tm_mon + 1, local_tm.tm_mday,
        local_tm.tm_hour, local_tm.tm_min, local_tm.tm_sec, us.count() / 1000,
        tid,  [MASK] , line);

    return os;
  };

  Log(Info) << ""Hello "" << ""World!"";
  Log(Warning) << ""Hello World!"";
  VLog(0) << ""Hi Debug as Info!"";
  VLog(1) << ""Hi Debug, again! (does not appear...)"";
  Log(Debug) << ""Hi Debug, again! (does not appear...)"";

  return 0;
}",short_file
977,"#pragma once
#include <chrono>
#include <functional>
#include <thread>
#include <atomic>

class Timeout {
public:
    Timeout() : expired(true), try_to_expire(false) {}

    Timeout(const Timeout&) = delete;
    Timeout& operator=(const Timeout&) = delete;

    ~Timeout() {
        Expire();
        // 等待定时器线程结束
        if (thd.joinable()) {
            thd.join();
        }
    }

    // 开始定时器
    void Start(unsigned int interval, std::function<void()> task) {
        if (expired == false) {
            // 定时器已经开始，不允许重复开始
            return;
        }
        expired = false;
        expire_time = std::chrono::system_clock::now() + std::chrono::milliseconds(interval);
        std::thread([this, interval, task](){
            while (!try_to_expire) {
                // 等待interval，如果期间没有收到过期信号，则执行任务
                std::this_thread::sleep_for(std::chrono::milliseconds(interval));
                if (!try_to_expire) {
                    task();
                }
            }
        // 任务执行完毕，设置expired为true
        expired = true;
            }).swap(thd);
    }


    // 停止定时器
    void Expire() {
        if (expired) {
            // 定时器已经过期，不需要再设置过期信号
            return;
        }
        if (try_to_expire) {
            // 已经发送过过期信号，不需要再次发送
            return;
        }
        try_to_expire = true;
    }

    // 计算剩余时间（毫秒）
    unsigned int LeftTime() {
        using namespace std::chrono;
        auto now = system_clock::now();
        auto  [MASK]  = duration_cast<milliseconds>(expire_time - now).count();
        return  [MASK]  > 0 ?  [MASK]  : 0;
    }

private:
    std::atomic<bool> expired; // 定时器是否已经过期
    std::atomic<bool> try_to_expire; // 是否尝试让定时器过期
    std::thread thd; // 定时器线程
    std::chrono::system_clock::time_point expire_time; // 定时器过期时间
};
",left
978,"#include ""tensorflow/core/framework/op.h""
#include ""tensorflow/core/framework/op_kernel.h""
#include <iostream>

REGISTER_OP(""ShiftCorr"")
    .Input(""in0: float"")
    .Input(""in1: float"")
    .Attr(""max_disp: int"")
    .Output(""output: float"");

REGISTER_OP(""ShiftCorrGrad"")
    .Input(""in0: float"")
    .Input(""in1: float"")
    .Input(""grad: float"")
    .Attr(""max_disp: int"")
    .Output(""output0: float"")
    .Output(""output1: float"");


using namespace tensorflow;

void ShiftCorrKernelLauncher(const float *vals0, const float *vals1, const int max_disp,
        const int batch_size, const int n_channels, const int in_h, const int in_w, float *out);

class ShiftCorrOp : public OpKernel {
public:
    int max_disp_;
    explicit ShiftCorrOp(OpKernelConstruction* context) : OpKernel(context) {
        OP_REQUIRES_OK(context,
                    context->GetAttr(""max_disp"", &max_disp_));
    }

    void Compute(OpKernelContext* context) override {
        // Grab the input tensor
        const Tensor& in0 = context->input(0);
        const Tensor& in1 = context->input(1);
        auto values0 = in0.flat<float>();
        auto values1 = in1.flat<float>();

        // Create an output tensor
        TensorShape in_shape = in0.shape();  // input in NHWC
        TensorShape  [MASK]  = in_shape;
         [MASK] .set_dim(1, max_disp_ * 2 + 1);
         [MASK] .set_dim(2, in_shape.dim_size(1));
         [MASK] .set_dim(3, in_shape.dim_size(2) - 2*max_disp_);  // output in NCHW
        Tensor* output_tensor = nullptr;
        OP_REQUIRES_OK(context, context->allocate_output(0,  [MASK] ,
                    &output_tensor));
        auto output = output_tensor->flat<float>();

        ShiftCorrKernelLauncher(values0.data(), values1.data(), max_disp_,
                    in_shape.dim_size(0), in_shape.dim_size(1), in_shape.dim_size(2),
                    in_shape.dim_size(3), output.data());
    }
};
REGISTER_KERNEL_BUILDER(Name(""ShiftCorr"").Device(DEVICE_GPU), ShiftCorrOp);

void ShiftCorrGradKernelLauncher(const float *input0, const float *input1, const float *grad,
        const int max_disp_, const int batch_size, const int height, const int width,
        const int channels, float *out0, float *out1);

class ShiftCorrGradOp : public OpKernel {
public:
    int max_disp_;
    explicit ShiftCorrGradOp(OpKernelConstruction* context) : OpKernel(context) {
	OP_REQUIRES_OK(context,
                    context->GetAttr(""max_disp"", &max_disp_));
    }

    void Compute(OpKernelContext* context) override {
        // Grab the input tensor
        const Tensor& in0 = context->input(0);
        const Tensor& in1 = context->input(1);
        const Tensor& grad = context->input(2);
        auto values0 = in0.flat<float>();
        auto values1 = in0.flat<float>();
        auto grad_values = grad.flat<float>();

        // Create an output tensor
        Tensor* out0 = nullptr;
        Tensor* out1 = nullptr;
        TensorShape in_shape = in0.shape();
        OP_REQUIRES_OK(context, context->allocate_output(0, in_shape, &out0));
        OP_REQUIRES_OK(context, context->allocate_output(1, in_shape, &out1));
        auto out_values0 = out0->flat<float>();
        auto out_values1 = out1->flat<float>();

        ShiftCorrGradKernelLauncher(values0.data(), values1.data(), grad_values.data(),
                    max_disp_, in_shape.dim_size(0), in_shape.dim_size(1), in_shape.dim_size(2),
                    in_shape.dim_size(3), out_values0.data(), out_values1.data());
    }
};
REGISTER_KERNEL_BUILDER(Name(""ShiftCorrGrad"").Device(DEVICE_GPU), ShiftCorrGradOp);
",out_shape
979,"#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <iomanip>

using namespace std;

#define TEXTNAME ""./audio_string.txt""

string one_mora = ""BA DA FA GA HA JA KA LA MA NA PA SA TA YA ZA BE CE DE FE GE JE KE LE ME NE PE SE TE ZE AH BH CH DH FH GH IH KH LH MH NH OH PH RH SH TH UH ZH BI CI DI FI GI HI KI MI NI OI PI RI SI UI ZI BO CO DO FO GO HO JO KO MO NO PO RO SO TO YO ZO BU DU FU GU HU JU KU LU MU NU OU PU SU TU YU ZU BY CY DY GY HY KY LY MY NY PY SY TY"";
//string one_mora = ""BA CA DA FA GA HA JA KA LA MA NA PA RA SA TA YA ZA BY CY DY GY HY KY LY MY NY PY SY TY AH BH CH DH EH FH GH IH KH MH NH OH PH RH SH TH UH ZH BE CE DE FE GE HE JE KE LE ME NE PE SE TE YE ZE BO CO DO FO GO HO JO KO LO MO NO PO RO SO TO YO ZO BI CI DI FI GI HI KI MI NI PI RI SI TI ZI BU CU DU FU GU HU JU KU LU MU NU OU PU SU TU ZU"";



int main() {

	ifstream ifs(TEXTNAME);
	string str;
	int num = 0;
	int  [MASK]  = 0;
	int mora_sum_all = 0;
	int str_letter_all = 0;
	int mora_distribution[7] = {};

	if (ifs.fail()) {
		cerr<<""Failed to open file.""<<endl;
		return -1;
	}
	while (getline(ifs, str)) {
		num++;
		string str_copy;
		string cout_disp = """";
		vector<string> str_pair;
		vector<int> mora_count;
		int mora_sum = 0;
		int one_mora_count = 0;

		str_copy = str;

		if (str.size() % 2 == 1) {
			cout << num << ""行目が奇数です。"" << endl;
			return -1;
		}

		while (str_copy.size() > 0) {
			str_pair.push_back(str_copy.substr(0,2));
			str_copy.erase(0, 2);
		}

		cout << setw(3) << right << num << "":"" << setw(12) << left << str;
		cout << "" -----> "";
		for (int i = 0; i < str_pair.size(); i++) {
			if (one_mora.rfind(str_pair[i]) == string::npos)
				mora_count.push_back(2);
			else {
				mora_count.push_back(1);
				one_mora_count++;
			}

			//cout << str_pair[i] <<"":""<<mora_count[i] << "" "";
			cout_disp += str_pair[i] + "":"" + to_string(mora_count[i]) + "" "";
			mora_sum += mora_count[i];
		}
		cout << setw(30) << left << cout_disp;
		cout << ""-----> "" << setw(2) << right << mora_sum << "" mora"" << endl;
		//cout << one_mora_count << endl;
		mora_distribution[one_mora_count]++;
		 [MASK]  += one_mora_count;
		mora_sum_all+=mora_sum;
		str_letter_all += str.size();

	}

	cout << endl << endl;
	cout <<num<<""ソルブ合計:"" << mora_sum_all << "" mora, "" << str_letter_all << "" letter"" << endl;
	cout << ""1moraペアが出現した数: "" <<  [MASK]  << "", 1ソルブあたり "" << setprecision(2) << double( [MASK] ) / double(num) << "" 回出現"" << endl;
	cout << ""1moraペアがx回出現したソルブ数  "";
	for (int i = 0; i < 7; i++) {
		cout << i << ""回: "" << mora_distribution[i] << "", "";
	}
	cout << endl;
	cout << ""音削減率: "" << setprecision(4) << 100 - double(mora_sum_all) / double(str_letter_all) * 100 << ""%"" << endl;

	return 0;
}",one_mora_count_all
980,"#ifndef DRsimSteppingAction_h
#define DRsimSteppingAction_h 1

#include ""DRsimInterface.h""
#include ""DRsimEventAction.hh""

#include ""G4UserSteppingAction.hh""
#include ""G4LogicalVolume.hh""
#include ""G4Step.hh""

using namespace std;

class DRsimSteppingAction : public G4UserSteppingAction {
public:
  DRsimSteppingAction(DRsimEventAction* eventAction);
  virtual ~DRsimSteppingAction();
  virtual void UserSteppingAction(const G4Step*);

private:
  DRsimEventAction* fEventAction;
  DRsimInterface::DRsimEdepData fEdep;
  DRsimInterface::DRsimLeakageData fLeak;
  
  G4VPhysicalVolume* GetMotherTower(G4TouchableHandle touchable) { return touchable->GetVolume(touchable->GetHistoryDepth()-1); }

  G4int GetTowerITheta(G4String towerName) {
    G4int towerITheta_ = std::stoi(towerName.substr(3));
    bool  [MASK]  = (towerName.find(""R"")==std::string::npos) ? false : true;
    bool IsB = (towerName.find(""B"")==std::string::npos) ? false : true;
    if(!IsB) towerITheta_ += 52;
    if(! [MASK] ) towerITheta_ = -towerITheta_-1;

    return towerITheta_;
  }

  G4int GetTowerIPhi(G4VPhysicalVolume* motherTower_) {
    return motherTower_->GetCopyNo();
  }
};

#endif
",IsR
981,"/* ---------------------------------------------------------------------------
** This software is in the public domain, furnished ""as is"", without technical
** support, and with no warranty, express or implied, as to its usefulness for
** any purpose.
**
** main.cpp
** 
** -------------------------------------------------------------------------*/

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <linux/videodev2.h>
#include <signal.h>

#include <stdio.h>

#include ""logger.h""

#include ""V4l2Capture.h""
#include ""V4l2Output.h""
#include ""v4l2web.h""

/* ---------------------------------------------------------------------------
**  end condition
** -------------------------------------------------------------------------*/
int stop=0;

/* ---------------------------------------------------------------------------
**  SIGINT handler
** -------------------------------------------------------------------------*/
void sighandler(int)
{ 
       printf(""SIGINT\n"");
       stop =1;
}

/* ---------------------------------------------------------------------------
**  main
** -------------------------------------------------------------------------*/
int main(int argc, char* argv[]) 
{	
	int verbose=0;
	const char *dev_name = ""/dev/video0,/dev/video0"";	
	int width = 640;
	int height = 480;	
	int fps = 25;	
	int c = 0;
	const char * port = ""8080"";
	std::string httpSslCertificate;
	std::string rtspSslKeyCert;	
	int rtspport = 8554;
	V4l2IoType ioTypeIn = IOTYPE_MMAP;
	V4l2IoType ioTypeOut = IOTYPE_MMAP;
	std::string webroot = ""vuejs/dist"";
	std::string nbthreads;
	unsigned int format = ~0;
	std::list<unsigned int> videoformatList;	
	std::string out_devname;	
	unsigned int outFormat = V4L2_PIX_FMT_H264;

#ifdef HAVE_ALSA	
	int audioFreq = 44100;
	int  [MASK]  = 2;
	std::list<snd_pcm_format_t> audioFmtList;
#endif	
	
	while ((c = getopt (argc, argv, ""hv::"" ""f::W:H:F:G:"" ""O:"" ""rw"" ""P:c:p:N:R:x:"" ""A:c:a:"")) != -1)
	{
		switch (c)
		{
			case 'v': verbose = 1; if (optarg && *optarg=='v') verbose++;  break;

			case 'f': format = V4l2Device::fourcc(optarg); if (format) {videoformatList.push_back(format);};  break;
			case 'G': sscanf(optarg,""%dx%dx%d"", &width, &height, &fps); break;
			
			case 'O': outFormat = V4l2Device::fourcc(optarg); break;

			case 'r': ioTypeIn = IOTYPE_READWRITE; break;
			case 'w': ioTypeOut = IOTYPE_READWRITE; break;				

			case 'P': port = optarg; break;
			case 'c': httpSslCertificate = optarg; break;
			case 'R': rtspport = atoi(optarg); break;
			case 'N': nbthreads = optarg; break;
			case 'p': webroot = optarg; break;		

#ifdef HAVE_ALSA	
			case 'A':	audioFreq = atoi(optarg); break;
			case 'C':	 [MASK]  = atoi(optarg); break;
			case 'a':	if (V4l2RTSPServer::decodeAudioFormat(optarg) != SND_PCM_FORMAT_UNKNOWN) {audioFmtList.push_back(V4l2RTSPServer::decodeAudioFormat(optarg));} ; break;
#endif	

#ifndef NO_OPENSSL
			case 'x':	rtspSslKeyCert              = optarg; break;
#endif	

			case 'h':
			{
				std::cout << argv[0] << "" [-v[v]] [-P httpport] [-c sslkeycert] [-R rtspport] [-W width] [-H height] [-F fps] [-G <w>x<h>x<f>] [device]"" << std::endl;
				std::cout << ""\t -v               : verbose "" << std::endl;
				std::cout << ""\t -v v             : very verbose "" << std::endl;
				std::cout << ""\t -P port          : server port (default ""<< port << "")"" << std::endl;
				std::cout << ""\t -p path          : server root path (default ""<< webroot << "")"" << std::endl;
				std::cout << ""\t -c sslkeycert    : path to private key and certificate for HTTPS"" << std::endl;
				std::cout << ""\t -R port          : RTSP server port (default ""<< rtspport << "")"" << std::endl;
#ifndef NO_OPENSSL
				std::cout << ""\t -x <sslkeycert>  : key & certificate for SRTP/RTSPS""                                                                                      << std::endl;
#endif							

				std::cout << ""\t -f format        : V4L2 capture using format"" << std::endl;
				std::cout << ""\t -G <w>x<h>[x<f>] : V4L2 capture format (default ""<< width << ""x"" << height << ""x"" << fps << "")""  << std::endl;

				std::cout << ""\t -r               : V4L2 capture using memory mapped buffers (default use read interface)"" << std::endl;
				std::cout << ""\t -w               : V4L2 capture using write interface (default use memory mapped buffers)"" << std::endl;				

#ifdef HAVE_ALSA	
				std::cout << ""\t ALSA options""                                                                                               << std::endl;
				std::cout << ""\t -A freq          : ALSA capture frequency and channel (default "" << audioFreq << "")""                                << std::endl;
				std::cout << ""\t -C channels      : ALSA capture channels (default "" <<  [MASK]  << "")""                                       << std::endl;
				std::cout << ""\t -a fmt           : ALSA capture audio format (default S16_BE)""                                                      << std::endl;
#endif
		
				std::cout << ""\t device           : V4L2 capture device (default ""<< dev_name << "")"" << std::endl;
				exit(0);
			}
		}
	}
	if (optind<argc)
	{
		dev_name = argv[optind];
		optind++;
	}	
	if (optind<argc)
	{
		out_devname = argv[optind];
		optind++;
	}	

	// initialize log4cpp
	initLogger(verbose);

	// init V4L2 capture interface
	if ((videoformatList.empty()) && (format!=0)) {
		videoformatList.push_back(V4L2_PIX_FMT_H264);
		videoformatList.push_back(V4L2_PIX_FMT_MJPEG);
		videoformatList.push_back(V4L2_PIX_FMT_JPEG);
		videoformatList.push_back(V4L2_PIX_FMT_NV12);
		videoformatList.push_back(0);
	}
#ifdef HAVE_ALSA	
	// default audio format tries
	if (audioFmtList.empty()) {
		audioFmtList.push_back(SND_PCM_FORMAT_S16_LE);
		audioFmtList.push_back(SND_PCM_FORMAT_S16_BE);
	}
#endif	
	std::unique_ptr<DeviceInterface> audioCapture;
	std::istringstream is(dev_name);
	std::string videoDev, audioDev;
	getline(is, videoDev, ',');						
	getline(is, audioDev);	
	V4L2DeviceParameters param(videoDev.c_str(), videoformatList, width, height, fps, ioTypeIn);
	std::unique_ptr<V4l2Capture> videoCapture(V4l2Capture::create(param));
	if (!videoCapture)
	{	
		LOG(WARN) << ""Cannot create V4L2 capture interface for device:"" << audioDev; 
	}
	else
	{	
#ifdef HAVE_ALSA	
		std::string audioDevice = V4l2RTSPServer::getV4l2Alsa(audioDev);
		ALSACaptureParameters param(audioDevice.c_str(), audioFmtList, audioFreq,  [MASK] );
		audioCapture.reset(ALSACapture::createNew(param));
#endif	

		// output	
		std::unique_ptr<V4l2Output> videoOutput;
		if (!out_devname.empty()) {
			V4L2DeviceParameters outparam(out_devname.c_str(), outFormat, width, height, fps, ioTypeOut);
			videoOutput.reset(V4l2Output::create(outparam));
		}

		// http options
		std::vector<std::string> options;
		options.push_back(""document_root"");
		options.push_back(webroot);
		options.push_back(""enable_directory_listing"");
		options.push_back(""no"");
		options.push_back(""additional_header"");
		options.push_back(""X-Frame-Options: SAMEORIGIN"");
		options.push_back(""access_control_allow_origin"");
		options.push_back(""*"");		
		options.push_back(""listening_ports"");
		options.push_back(port);
		if (!httpSslCertificate.empty()) {
			options.push_back(""ssl_certificate"");
			options.push_back(httpSslCertificate);
		}		
		if (!nbthreads.empty()) {
			options.push_back(""num_threads"");
			options.push_back(nbthreads);
		}		
		
		// api server
		V4l2web v4l2web(videoCapture.release(), audioCapture.get(), videoOutput.get(), options, rtspport, rtspSslKeyCert);
		if (v4l2web.getContext() == NULL)
		{
			LOG(WARN) << ""Cannot listen on port:"" << port; 
		}
		else
		{		
			LOG(NOTICE) << ""Started on port:"" << port << "" webroot:"" << webroot;
			signal(SIGINT,sighandler);	 
			while (!stop) {
				sleep(1); 
			}
		}
	}
	
	return 0;
}
",audioNbChannels
982,"/**
    @file
    @author  <NAME>
    @author  <NAME>
    @copyright 2014-2017 INRIA, 2014-2015 CNRS. Licensed under the Apache
    License, Version 2.0. (see @ref LICENSE or http://www.apache.org/licenses/LICENSE-2.0)

    @brief
*/

#pragma once

namespace humoto
{
    namespace wpg03
    {
        const char * COMJERK_VARIABLES_ID   = ""comjerk"";
        const char * FOOTPOS_VARIABLES_ID   = ""footpos"";
        const char * EXTWRENCH_VARIABLES_ID   = ""extwrench"";


        /**
         * @brief Possible states of the model
         */
        enum ModelStateType
        {
            /// Undefined
            STATE_UNDEFINED = 0,

            /// Double support
            STATE_DS = 1,

            /// Left single support
            STATE_LSS = 2,

            /// Right single support
            STATE_RSS = 3,

            /// Transitional double support
            STATE_TDS = 4
        };


        class ModelState : public humoto::ModelState
        {
            public:
                bool                            next_support_set_;
                etools::Vector2                 next_support_position_;
                etools::Matrix2                 next_support_rotation_;

                Eigen::Matrix<double, 6, 1>     cstate_;

                humoto::wpg03::ModelStateType   state_type_;
                humoto::wpg03::ModelStateType   next_state_type_;


                ModelState()
                {
                    next_support_set_ = false;
                    next_support_position_ << 0.0, 0.0;
                    next_support_rotation_ << 0.0, 0.0, 0.0, 0.0;

                    cstate_ << 0.0, 0.0, 0.0, 0.0, 0.0, 0.0;

                    state_type_         = humoto::wpg03::STATE_UNDEFINED;
                    next_state_type_    = humoto::wpg03::STATE_UNDEFINED;
                }


                void log(   humoto::Logger &logger,
                            const LogEntryName &parent = LogEntryName(),
                            const std::string &name = ""model_state"") const
                {
                    LogEntryName  [MASK]  = parent;  [MASK] .add(name);

                    logger.log(LogEntryName( [MASK] ).add(""state_type"")       , state_type_     );
                    logger.log(LogEntryName( [MASK] ).add(""next_state_type"")  , next_state_type_);

                    logger.log(LogEntryName( [MASK] ).add(""next_support_set"") , next_support_set_);

                    logger.log(LogEntryName( [MASK] ).add(""cstate""), cstate_);

                    logger.log(LogEntryName( [MASK] ).add(""next_support_position""), next_support_position_);
                    logger.log(LogEntryName( [MASK] ).add(""next_support_rotation""), next_support_rotation_);
                }
        };



        /**
         * @brief Parameters of an MPC problem. [set_parameters_mpc.m]
         */
        class MPCParameters
        {
            private:
                /// Number of subsamples per sample (TN)
                unsigned int subsamples_num_;

                /// Number of subsamples per doubles support sample (TN_tds)
                unsigned int tds_subsamples_num_;

                /// Sampling time in seconds (T)
                double sampling_time_;

                /// Subsampling time in seconds (Ts)
                double subsampling_time_;

                /// Sampling time of a transitional double support in
                /// seconds (Ttds)
                double tds_sampling_time_;


            public:
                /// Length of the preview horizon (N)
                unsigned int preview_horizon_length_;

                /// Sampling time in milliseconds (T_ms)
                unsigned int sampling_time_ms_;

                /// Subsampling time in milliseconds (Ts_ms)
                unsigned int subsampling_time_ms_;

                /// Sampling time of a transitional double support in
                /// milliseconds (Ttds_ms)
                unsigned int tds_sampling_time_ms_;


                /**
                 * @brief Constructor.
                 *
                 * @param[in] preview_horizon_len   Length of the preview horizon
                 * @param[in] sampling_time_ms      Sampling time in milliseconds
                 * @param[in] subsampling_time_ms   Subsampling time in milliseconds
                 * @param[in] tds_sampling_time_ms  Sampling time of a transitional double support in milliseconds
                 */
                MPCParameters(  const unsigned int preview_horizon_len = 16,
                                const unsigned int sampling_time_ms = 100,
                                const unsigned int subsampling_time_ms = 100,
                                const unsigned int tds_sampling_time_ms = 100)
                {
                    preview_horizon_length_         = preview_horizon_len;
                    sampling_time_ms_               = sampling_time_ms;
                    subsampling_time_ms_            = subsampling_time_ms;
                    tds_sampling_time_ms_           = tds_sampling_time_ms;
                }


                void finalize()
                {
                    if (sampling_time_ms_ % subsampling_time_ms_ == 0)
                    {
                        subsamples_num_ = sampling_time_ms_ / subsampling_time_ms_;
                    }
                    else
                    {
                        HUMOTO_THROW_MSG(""Sampling time should be a multiple of subsampling time."");
                    }


                    if (tds_sampling_time_ms_ % subsampling_time_ms_ == 0)
                    {
                        tds_subsamples_num_ = tds_sampling_time_ms_ / subsampling_time_ms_;
                    }
                    else
                    {
                        HUMOTO_THROW_MSG(""Transitional double support samplig time should be a multiple of subsampling time."");
                    }

                    // convert milliseconds to seconds
                    sampling_time_      = convertMillisecondToSecond(sampling_time_ms_);
                    subsampling_time_   = convertMillisecondToSecond(subsampling_time_ms_);
                    tds_sampling_time_  = convertMillisecondToSecond(tds_sampling_time_ms_);
                }


                double getTDSSamplingTime () const
                {
                    return (tds_sampling_time_);
                }


                double getSamplingTime () const
                {
                    return (sampling_time_);
                }

                double getSubsamplingTime () const
                {
                    return (subsampling_time_);
                }
        };
    }
}
",subname
983,"#include <stdio.h>
#include <string.h>
#include <math.h>
#include <vector>
#include <exception>
#include <typeinfo>
#include <float.h>
#include <malloc.h>
#include ""Calibration.h""

#define MATRIX_SIZE 7
#define u8 unsigned char

class sample{
public:
	double m_x;
	double m_y;
	double m_z;
};

static std::vector<sample> s_samples;
static double m_matrix[MATRIX_SIZE][MATRIX_SIZE+1];
static int m = MATRIX_SIZE;	
static int n = MATRIX_SIZE+1;
static double m_result[MATRIX_SIZE];

static void DispMatrix(void);

static double Abs(double a)
{
	return a<0 ? -a : a;
}

static u8 Equal(double a,double b)
{
	return Abs(a-b) < 1e-6;
}

static void ResetMatrix(void)
{
	int row , column;
	
	for(row = 0 ; row<m ; row++){
		for(column = 0 ; column<n ; column++)
			m_matrix[row][column] = 0.0f;
	}
}
	
static void CalcData_Input(double x , double y , double z)
{
	double V[MATRIX_SIZE];
	int row , column;
	
	V[0] = x*x;
    V[1] = y*y;
    V[2] = z*z;
    V[3] = x;
    V[4] = y;
    V[5] = z;
    V[6] = 1.0;
	
	//构建VxVt矩阵(Vt为V的转置)，并进行累加
	for(row = 0 ; row<MATRIX_SIZE ; row++){
		for(column = 0 ; column<MATRIX_SIZE ; column++){
			m_matrix[row][column] += V[row]*V[column];
		}
	}
}

static void SwapRow(int row1 , int row2)
{
	int column;
	double tmp;
	
	for(column = 0 ; column<n ; column++){
		tmp = m_matrix[row1][column];
		m_matrix[row1][column] = m_matrix[row2][column];
		m_matrix[row2][column] = tmp;
	}
}

static void MoveBiggestElement2Top(int s_row , int s_column)
{
	int row,column;
	
	for(row = s_row+1 ; row<m ; row++){
		if( Abs(m_matrix[s_row][s_column])<Abs(m_matrix[row][s_column])){
			SwapRow(s_row , row);
		}
	}
}

//高斯消元法，求行阶梯型矩阵
static u8 Matrix_GaussElimination(void)
{
	int row,column,i,j;
	double tmp;
	
	for(row = 0,column=0 ; row<m-1 && column<n-1 ; row++,column++){
		//将当前列最大的一行移上来
		MoveBiggestElement2Top(row , column);
		
		//整列都为0
		if(Equal(m_matrix[row][column],0.0f)){
			LOGD(""qiyi matrix:%d %d\r\n"" , row , column);
			//DispMatrix();
			//return 0;
			row--;
			continue;
		}
		
		//高斯消元
		for(i = row+1 ; i<m ; i++){	
			if(Equal(m_matrix[i][column],0.0f))
				continue;	//为0，无需处理
			
			tmp = m_matrix[i][column]/m_matrix[row][column];
			
			for(j = column ; j<n ; j++){
				m_matrix[i][j] -= m_matrix[row][j]*tmp;
			}
		}

		DispMatrix();
		LOGD(""\r\n"");
	}

	return 1;
}

//求行最简型矩阵
static int Matrix_RowSimplify(void)
{
    int c = n;//返回值，表示(解的任意常量数+1)；
    //
    int row,column,k,s,t;
    double tmp;
    //
    for(row=0,column=0;row<m && column<n;row++,column++)
    {
        if(Equal(m_matrix[row][column],0))//平移，找出本行第一个非零；
        {
            row--;
            continue;
        }
        //
        c--;//少一个常量；
        //
        //化a[i][j]为1；
        tmp = 1 / m_matrix[row][column];
        for(k=column;k<n;k++)//前面的""0""就不处理了；
            m_matrix[row][k] *= tmp;
        //
        //化a[s][j]为0
        for(s=0;s<row;s++)//下面的0也不用处理；
        {
            if(Equal(m_matrix[s][column],0))
                continue;//已经为0；
            //
            tmp = m_matrix[s][column] / m_matrix[row][column];
            for(t=column;t<n;t++)
                m_matrix[s][t] -= m_matrix[row][t]*tmp;
            //
        }
    }
    //
    return c;
}

static void Matrix_Solve(double* C , double* sol)
{
	int row,column,i;
	int any_sol[MATRIX_SIZE];

	//找出任意解的位置
	memset(any_sol , 0 , MATRIX_SIZE);
	for(row=0,column=0 ; row<m && column<n-1 ; row++,column++){
		if(Equal(m_matrix[row][column] , 0.0f)){
			any_sol[column] = 1;	//记录任意解的位置
			row--;	//右移1列
		}
	}

	//求解
	row = 0;
	for(column = 0 ; column<n-1 ; column++){
		if(any_sol[column] == 1){	//任意解
			sol[column] = C[column];
		}else{
			sol[column] = m_matrix[row][n-1];
			//加上任意解
			for(i = column+1 ; i<n-1 ; i++){
				if(any_sol[i]==1 && !Equal(m_matrix[row][i],0.0f)){
					sol[column] -= m_matrix[row][i]*C[i];
				}
			}	
			row++;
		}
	}
}

static void DispMatrix(void)
{
	int row,column;
	
	for(row = 0 ; row<m ; row++){
		for(column = 0 ; column<n ; column++){
			LOGD(""%.3f	"" , m_matrix[row][column]);
		}
		LOGD(""\r\n"");
	}
}

bool IsFiniteNumber(double x)
{
	return (x <= DBL_MAX && x >= -DBL_MAX);
}

bool Calc_Process(double radius, double p[6])
{
	double C[MATRIX_SIZE];
	double Res[MATRIX_SIZE];
	int i;
	double k;
	bool bRet = true;

	ResetMatrix();

	//输入任意个数磁场测量点坐标，请尽量保证在椭球上分布均匀
	/*CalcData_Input(245.0,-815.4,164.7);
	CalcData_Input(239.1,-818.0,165.4);
	CalcData_Input(237.1,-822.9,165.5);
	CalcData_Input(235.6,-829.1,166.6);
	CalcData_Input(239.2,-834.0,167.7);
	CalcData_Input(245.3,-838.6,166.9);
	CalcData_Input(252.2,-838.8,168.3);
	CalcData_Input(258.8,-835.1,167.1);
	CalcData_Input(261.2,-831.9,167.6);
	CalcData_Input(260.9,-823.9,165.8);
	CalcData_Input(257.2,-816.4,165.5);
	CalcData_Input(251.2,-814.9,163.9);*/
	for (int i = 0; i < s_samples.size(); i++)
	{
		CalcData_Input(s_samples.at(i).m_x, s_samples.at(i).m_y, s_samples.at(i).m_z);
	}

	Matrix_GaussElimination();
	Matrix_RowSimplify();

    //赋值任意解参数值
	for(i = 0 ; i<MATRIX_SIZE ; i++){
		C[i] = 1.0f;
	}

	Matrix_Solve(C , Res);

	LOGD(""a:%.2f b:%.2f c:%.2f d:%.2f e:%.2f f:%.2f g:%.2f\r\n"" , Res[0],Res[1],Res[2],Res[3],Res[4],Res[5],Res[6]);

	k = (Res[3]*Res[3]/Res[0]+Res[4]*Res[4]/Res[1]+Res[5]*Res[5]/Res[2] - 4*Res[6])/(4*radius*radius);

	m_result[0] = sqrt(Res[0] / k);
    m_result[1] = sqrt(Res[1] / k);
    m_result[2] = sqrt(Res[2] / k);
    m_result[3] = Res[3] / (2 * Res[0]);
    m_result[4] = Res[4] / (2 * Res[1]);
    m_result[5] = Res[5] / (2 * Res[2]);

	for (int i = 0; i < sizeof(m_result); i++)
	{
		if(!IsFiniteNumber(m_result[i]))
		{
			bRet = false;
			break;
		}
	}
	
	if(bRet)
	{
		LOGD(""Xo:%f Yo:%f Zo:%f Xg:%f Yg:%f Zg:%f k:%f\r\n"" , m_result[3],m_result[4],m_result[5],m_result[0],m_result[1],m_result[2],k);
		/*p.m_ox = m_result[3];
		p.m_oy = m_result[4];
		p.m_oz = m_result[5];
		p.m_gx = m_result[0];
		p.m_gy = m_result[1];
		p.m_gz = m_result[2];*/
		p[0] = m_result[3];
		p[1] = m_result[4];
		p[2] = m_result[5];
		p[3] = m_result[0];
		p[4] = m_result[1];
		p[5] = m_result[2];
	}
	
	return bRet;
}

bool addSample(double x, double y, double z)
{
	sample tmp;
	tmp.m_x = x;
	tmp.m_y = y;
	tmp.m_z = z;
	s_samples.push_back(tmp);

	LOGD(""addSample(%f %f %f) \n"",x, y, z);
	return true;
}

extern ""C"" void Matrix_x_Its_Transpose(double *, double *, int, int);
extern ""C"" void Get_Submatrix(double *, int, int, double *, int, int, int);
extern ""C"" int Choleski_LU_Decomposition(double *, int);
extern ""C"" int Choleski_LU_Inverse(double *, int);
extern ""C"" void Multiply_Matrices(double *, double *, int, int, double *, int);
extern ""C"" int Hessenberg_Form_Elementary(double *, double *, int);
extern ""C"" int QR_Hessenberg_Matrix(double *, double *, double[], double[], int, int);
extern ""C"" void Transpose_Square_Matrix(double *, int);

int ellipsoid_fitting(double params[6])
{
    int 			nlines = 0;
    char			buf[120];
    double *		D, *S, *C, *S11, *S12, *S12t, *S22, *S22_1, *S22a, *S22b, *SS, *E, *d, *U, *SSS;
    double *		eigen_real, *eigen_imag, *v1, *v2, *v, *Q, *Q_1, *B, *QB, J, hmb, *SSSS;
    int *			p;
    int 			i, index;
    double			maxval, norm, btqb, *eigen_real3, *eigen_imag3, *Dz, *vdz, *SQ, *A_1, hm, norm1, norm2,  [MASK] ;
    double			x, y, z;

    nlines              = s_samples.size();
    D					= (double *)malloc(10 * nlines * sizeof(double));

    for (i = 0; i < nlines; i++)
    {
        x = s_samples[i].m_x;
        y = s_samples[i].m_y;
        z = s_samples[i].m_z;
        D[i]				= x * x;
        D[nlines + i]		= y * y;
        D[nlines * 2 + i]	= z * z;
        D[nlines * 3 + i]	= 2.0 * y * z;
        D[nlines * 4 + i]	= 2.0 * x * z;
        D[nlines * 5 + i]	= 2.0 * x * y;
        D[nlines * 6 + i]	= 2.0 * x;
        D[nlines * 7 + i]	= 2.0 * y;
        D[nlines * 8 + i]	= 2.0 * z;
        D[nlines * 9 + i]	= 1.0;
    }

    // allocate memory for matrix S
    S					= (double *)malloc(10 * 10 * sizeof(double));
    Matrix_x_Its_Transpose(S, D, 10, nlines);

    // Create pre-inverted constraint matrix C
    C					= (double *)malloc(6 * 6 * sizeof(double));
    C[0]				= 0.0;
    C[1]				= 0.5;
    C[2]				= 0.5;
    C[3]				= 0.0;
    C[4]				= 0.0;
    C[5]				= 0.0;
    C[6]				= 0.5;
    C[7]				= 0.0;
    C[8]				= 0.5;
    C[9]				= 0.0;
    C[10]				= 0.0;
    C[11]				= 0.0;
    C[12]				= 0.5;
    C[13]				= 0.5;
    C[14]				= 0.0;
    C[15]				= 0.0;
    C[16]				= 0.0;
    C[17]				= 0.0;
    C[18]				= 0.0;
    C[19]				= 0.0;
    C[20]				= 0.0;
    C[21]				= -0.25;
    C[22]				= 0.0;
    C[23]				= 0.0;
    C[24]				= 0.0;
    C[25]				= 0.0;
    C[26]				= 0.0;
    C[27]				= 0.0;
    C[28]				= -0.25;
    C[29]				= 0.0;
    C[30]				= 0.0;
    C[31]				= 0.0;
    C[32]				= 0.0;
    C[33]				= 0.0;
    C[34]				= 0.0;
    C[35]				= -0.25;

    S11 				= (double *)malloc(6 * 6 * sizeof(double));
    Get_Submatrix(S11, 6, 6, S, 10, 0, 0);
    S12 				= (double *)malloc(6 * 4 * sizeof(double));
    Get_Submatrix(S12, 6, 4, S, 10, 0, 6);
    S12t				= (double *)malloc(4 * 6 * sizeof(double));
    Get_Submatrix(S12t, 4, 6, S, 10, 6, 0);
    S22 				= (double *)malloc(4 * 4 * sizeof(double));
    Get_Submatrix(S22, 4, 4, S, 10, 6, 6);

    S22_1				= (double *)malloc(4 * 4 * sizeof(double));

    for (i = 0; i < 16; i++)
        S22_1[i] = S22[i];

    Choleski_LU_Decomposition(S22_1, 4);
    Choleski_LU_Inverse(S22_1, 4);

    // Calculate S22a = S22_1 * S12t   4*6 = 4x4 * 4x6	 C = AB
    S22a				= (double *)malloc(4 * 6 * sizeof(double));
    Multiply_Matrices(S22a, S22_1, 4, 4, S12t, 6);

    // Then calculate S22b = S12 * S22a 	 ( 6x6 = 6x4 * 4x6)
    S22b				= (double *)malloc(6 * 6 * sizeof(double));
    Multiply_Matrices(S22b, S12, 6, 4, S22a, 6);

    // Calculate SS = S11 - S22b
    SS					= (double *)malloc(6 * 6 * sizeof(double));

    for (i = 0; i < 36; i++)
        SS[i] = S11[i] -S22b[i];

    E					= (double *)malloc(6 * 6 * sizeof(double));
    Multiply_Matrices(E, C, 6, 6, SS, 6);
    SSS 				= (double *)malloc(6 * 6 * sizeof(double));
    Hessenberg_Form_Elementary(E, SSS, 6);

    eigen_real			= (double *)malloc(6 * sizeof(double));
    eigen_imag			= (double *)malloc(6 * sizeof(double));

    QR_Hessenberg_Matrix(E, SSS, eigen_real, eigen_imag, 6, 100);

    index				= 0;
    maxval				= eigen_real[0];

    for (i = 1; i < 6; i++)
    {
        if (eigen_real[i] > maxval)
        {
            maxval				= eigen_real[i];
            index				= i;
        }
    }

    v1					= (double *)malloc(6 * sizeof(double));

    v1[0]				= SSS[index];
    v1[1]				= SSS[index + 6];
    v1[2]				= SSS[index + 12];
    v1[3]				= SSS[index + 18];
    v1[4]				= SSS[index + 24];
    v1[5]				= SSS[index + 30];

    // normalize v1
    norm				= sqrt(v1[0] *v1[0] +v1[1] *v1[1] +v1[2] *v1[2] +v1[3] *v1[3] +v1[4] *v1[4] +v1[5] *v1[5]);
    v1[0]				/= norm;
    v1[1]				/= norm;
    v1[2]				/= norm;
    v1[3]				/= norm;
    v1[4]				/= norm;
    v1[5]				/= norm;

    if (v1[0] < 0.0)
    {
        v1[0]				= -v1[0];
        v1[1]				= -v1[1];
        v1[2]				= -v1[2];
        v1[3]				= -v1[3];
        v1[4]				= -v1[4];
        v1[5]				= -v1[5];
    }

    // Calculate v2 = S22a * v1 	 ( 4x1 = 4x6 * 6x1)
    v2					= (double *)malloc(4 * sizeof(double));
    Multiply_Matrices(v2, S22a, 4, 6, v1, 1);

    v					= (double *)malloc(10 * sizeof(double));

    v[0]				= v1[0];
    v[1]				= v1[1];
    v[2]				= v1[2];
    v[3]				= v1[3];
    v[4]				= v1[4];
    v[5]				= v1[5];
    v[6]				= -v2[0];
    v[7]				= -v2[1];
    v[8]				= -v2[2];
    v[9]				= -v2[3];

    Q					= (double *)malloc(3 * 3 * sizeof(double));

    Q[0]				= v[0];
    Q[1]				= v[5];
    Q[2]				= v[4];
    Q[3]				= v[5];
    Q[4]				= v[1];
    Q[5]				= v[3];
    Q[6]				= v[4];
    Q[7]				= v[3];
    Q[8]				= v[2];

    U					= (double *)malloc(3 * sizeof(double));

    U[0]				= v[6];
    U[1]				= v[7];
    U[2]				= v[8];

    Q_1 				= (double *)malloc(3 * 3 * sizeof(double));

    for (i = 0; i < 9; i++)
        Q_1[i] = Q[i];

    Choleski_LU_Decomposition(Q_1, 3);
    Choleski_LU_Inverse(Q_1, 3);

    // Calculate B = Q-1 * U   ( 3x1 = 3x3 * 3x1)
    B					= (double *)malloc(3 * sizeof(double));
    Multiply_Matrices(B, Q_1, 3, 3, U, 1);

    B[0]				= -B[0];					// x-axis combined bias
    B[1]				= -B[1];					// y-axis combined bias
    B[2]				= -B[2];					// z-axis combined bias

    for (i = 0; i < 3; i++){
        params[i] = B[i];
        LOGD(""%lf\r\n"", B[i]);
    }

    params[3] = params[4] = params[5] = 1;

    // First calculate QB = Q * B	( 3x1 = 3x3 * 3x1)
    QB					= (double *)malloc(3 * sizeof(double));
    Multiply_Matrices(QB, Q, 3, 3, B, 1);

    // Then calculate btqb = BT * QB	( 1x1 = 1x3 * 3x1)
    Multiply_Matrices(&btqb, B, 1, 3, QB, 1);

    // Calculate hmb = sqrt(btqb - J).
    J					= v[9];
    hmb 				= sqrt(btqb - J);

    // Calculate SQ, the square root of matrix Q
    SSSS				= (double *)malloc(3 * 3 * sizeof(double));
    Hessenberg_Form_Elementary(Q, SSSS, 3);

    eigen_real3 		= (double *)malloc(3 * sizeof(double));
    eigen_imag3 		= (double *)malloc(3 * sizeof(double));
    QR_Hessenberg_Matrix(Q, SSSS, eigen_real3, eigen_imag3, 3, 100);

    // normalize eigenvectors
    norm1				= sqrt(SSSS[0] *SSSS[0] +SSSS[3] *SSSS[3] +SSSS[6] *SSSS[6]);
    SSSS[0] 			/= norm1;
    SSSS[3] 			/= norm1;
    SSSS[6] 			/= norm1;
    norm2				= sqrt(SSSS[1] *SSSS[1] +SSSS[4] *SSSS[4] +SSSS[7] *SSSS[7]);
    SSSS[1] 			/= norm2;
    SSSS[4] 			/= norm2;
    SSSS[7] 			/= norm2;
     [MASK] 				= sqrt(SSSS[2] *SSSS[2] +SSSS[5] *SSSS[5] +SSSS[8] *SSSS[8]);
    SSSS[2] 			/=  [MASK] ;
    SSSS[5] 			/=  [MASK] ;
    SSSS[8] 			/=  [MASK] ;

    Dz					= (double *)malloc(3 * 3 * sizeof(double));

    for (i = 0; i < 9; i++)
        Dz[i] = 0.0;

    Dz[0]				= sqrt(eigen_real3[0]);
    Dz[4]				= sqrt(eigen_real3[1]);
    Dz[8]				= sqrt(eigen_real3[2]);

    vdz 				= (double *)malloc(3 * 3 * sizeof(double));
    Multiply_Matrices(vdz, SSSS, 3, 3, Dz, 3);

    Transpose_Square_Matrix(SSSS, 3);

    SQ					= (double *)malloc(3 * 3 * sizeof(double));
    Multiply_Matrices(SQ, vdz, 3, 3, SSSS, 3);

    hm					= 0.569;
    A_1 				= (double *)malloc(3 * 3 * sizeof(double));

    for (i = 0; i < 9; i++)
        A_1[i] = SQ[i] *hm / hmb;

    for (i = 0; i < 3; i++)
        LOGD(""%lf %lf %lf\r\n"", A_1[i * 3], A_1[i * 3 + 1], A_1[i * 3 + 2]);

    free(D);
    free(S);
    free(C);
    free(S11);
    free(S12);
    free(S12t);
    free(S22);
    free(S22_1);
    free(S22a);
    free(S22b);
    free(SS);
    free(E);
    free(U);
    free(SSS);
    free(eigen_real);
    free(eigen_imag);
    free(v1);
    free(v2);
    free(v);
    free(Q);
    free(Q_1);
    free(B);
    free(QB);
    free(SSSS);
    free(eigen_real3);
    free(eigen_imag3);
    free(Dz);
    free(vdz);
    free(SQ);
    free(A_1);
    return 0;
}

#ifdef TEST_MAIN
int main(int argc, char* argv[])
{
	double samples[12][3] = 
	{{245.0,-815.4,164.7},
	{239.1,-818.0,165.4},
	{237.1,-822.9,165.5},
	{235.6,-829.1,166.6},
	{239.2,-834.0,167.7},
	{245.3,-838.6,166.9},
	{252.2,-838.8,168.3},
	{258.8,-835.1,167.1},
	{261.2,-831.9,167.6},
	{260.9,-823.9,165.8},
	{257.2,-816.4,165.5},
	{251.2,-814.9,163.9}
	};
	//params p;
	double p[6];
	
	LOGD(""array size : %d \n"" , sizeof(samples)/sizeof(samples[0]));
	for (int i = 0; i < sizeof(samples)/sizeof(samples[0]); i++)
	{
		sample tmp;
		tmp.m_x = samples[i][0];
		tmp.m_y = samples[i][1];
		tmp.m_z = samples[i][2];
		addSample(samples[i][0], samples[i][1], samples[i][2]);
		LOGD(""push x: %f, y: %f, z:%f \n"",tmp.m_x,tmp.m_y,tmp.m_z);
	}

	//if(!Calc_Process(13.0, p))
	if(!Calc_Process(13.0, p))
	{
		LOGD(""There is not enough data for calc! \n"" );
	}
	
	//LOGD(""Xo:%f Yo:%f Zo:%f Xg:%f Yg:%f Zg:%f \r\n"" , p.m_ox,p.m_oy, p.m_oz, p.m_gx, p.m_gy, p.m_gz);
	LOGD(""Xo:%f Yo:%f Zo:%f Xg:%f Yg:%f Zg:%f \r\n"" , p[3],p[4], p[5], p[0], p[1], p[2]);
	
	return 0;
}
#endif
",norm3
984,"/*
 * SampleDecoder.cpp
 *
 *  Created on: Jan 14, 2011
 *      Author: rtoso
 */
#include <iostream>
#include <vector>
#include <new>
#include <float.h>
#include <string>
#include <fstream>
#include <sstream>
#include <limits.h>
#include <math.h>
#include <list>
#include <algorithm>
#include ""SampleDecoder.h""
#include <iomanip>
#include <stdlib.h>
#include ""Structures.h""
#include ""Utility.h""
#include ""MTRand.h""

#define _USE_MATH_DEFINES
 
#include <cmath>


const double EulerConstant = std::exp(1.0);

using namespace std;

SampleDecoder::SampleDecoder(string _fileName) {
	//cout<<""Entrou no metodo construtor!!!""<<endl;

	

	quantidadeAliquotas = 8;
	quantidadeDadosIPTU = 3;

  	fileName= _fileName;

  	dataFileRead.open( fileName.c_str(), fstream::in);

	//cout<<""Passou pela abertura!!!""<<endl;

  	if(dataFileRead.is_open()){
  	  dataFileRead.seekg(0, ios::beg);
  	  //Aqui!!! cout<<""Operation successfully performed Aqui!!!""<<endl;
  	} else{
  	    //cout<<""Não foi possivel abrir o arquivo!""<<endl;
  	    dataFileRead.clear();
  	    exit(1);
  	}

	valorTotalIptu = 0;

	for(int i=0; i<quantidadeAliquotas; i++) {

		tabelaDados.push_back( vector<double>() );

		for(int j=0; j<quantidadeDadosIPTU; j++) {

			dataFileRead >> readerDouble;
			tabelaDados[i].push_back( readerDouble );

			if (j==0) {
				listaNumero.push_back( readerDouble ); // Antes listaNumero era int
			} else if (j==1) {
				listaValorVenal.push_back(readerDouble);
			} else if (j==2) {
				listaValorIptu.push_back(readerDouble);
				valorTotalIptu = valorTotalIptu + readerDouble;
			}

		}
	}

	dataFileRead.clear();
	dataFileRead.close();

	//printMatrix(tabelaDados);

  seed = 1480813184;
  

}

SampleDecoder::~SampleDecoder() {

}

void SampleDecoder::cleanMemory() {
	
}

double SampleDecoder::getSeed(){
  return seed;
}

void SampleDecoder::printMatrix(vector< vector<double> > _matrix) {

	for(int i=0; i<_matrix.size(); i++) {
		for(int j=0; j<_matrix[i].size(); j++) {
			cout<<""  ""<<_matrix[i][j];
		}
		cout<<endl;
	}

}

// double SampleDecoder::construirSolucao(std::vector< double > &chromosome,vector< unsigned > &permutation) const
double SampleDecoder::construirSolucao(bool &verificacao, std::vector< double > &chromosome) const {
	double fitness = 0, valortotalvenal, readleDouble = 0;
	double theta1, theta2; // parâmetros usados pelos modelo e obtidos pela leitura do cromossomo
	double Xi; 
	double listaAliquotas[quantidadeAliquotas];
	// randInt( const uint32 n ); // integer in [0,n] for n < 2^32
	int randomValue, interval;
	double randomValueDouble;

	Xi = chromosome[0];
	theta1 = chromosome[1]; // theta1 deve ser maior ou igual a 0.00042 e menor ou igual a 0.00098
	theta2 = chromosome[2]; // theta2 deve ser maior ou igual a 0.26670 e menor ou igual a 0.62230

	//cout<<""\n\n\n=== Construir Solucao ===""<<endl;

	//cout<<""EulerConstant = ""<<EulerConstant<<endl;

	//cout<<""Valores originais""<<endl;
	//cout<<theta1<<"";""<<theta2<<"";""<<Xi<<endl;


    // theta1 deve ser maior ou igual a 0.00042 e menor ou igual a 0.00098
	if ( (theta1 >= 0.42) && (theta1 <= 0.98) ) {
		//cout<<""Entrou if de theta1""<<endl;
		theta1 = theta1/1000.0;
	} else if (theta1 < 0.42) {
			theta1 = 0.42/1000.0;
	} else if (theta1 > 0.98) {
			theta1 = 0.98/1000.0;
	}
	
	
	// theta2 deve ser maior ou igual a 0.26670 e menor ou igual a 0.62230
	if (theta2 < 0.26670) {
		theta2 = 0.26670;
	} else if (theta2 > 0.62230) {
			theta2 = 0.62230;
	}


	// X1 deve ser maior ou igual a 0.0010 e menor ou igual a 0.0020
	// if ( (Xi == 1) && (Xi <= 1)) {
	// 	Xi = 1;
	// } else {        
	// 	Xi = 1;
	// }	

	// Aqui!!! Xi = 1;

	// X1 deve ser maior ou igual a 0.0010 e menor ou igual a 0.0020
	listaAliquotas[ 0 ] = theta1 * pow(EulerConstant, theta2 * Xi); // X1 deve ser maior ou igual a 0.0010 e menor ou igual a 0.0020

	if (listaAliquotas[ 0 ] < 0.0010) {
		listaAliquotas[ 0 ] = 0.0010;
    } else if (listaAliquotas[ 0 ] > 0.0020) {
			listaAliquotas[ 0 ] = 0.0020;
	}


	// cout<<""=== Aliquotas ===""<<endl;
	// cout<<""X1 = ""<<listaAliquotas[ 0 ]<<endl;
	for(int i=1; i < quantidadeAliquotas; i++) {
		listaAliquotas[i] = listaAliquotas[ i-1 ] * pow( EulerConstant,  theta2 * Xi);
		// cout<<""X""<<i+1<<"" = ""<<listaAliquotas[i]<<endl;
	}

	if ( listaAliquotas[ quantidadeAliquotas -1 ] > 0.0140 ) {
		listaAliquotas[ quantidadeAliquotas -1 ] = 0.0140;
	}


	// cout<<""=== Aliquotas ===""<<endl;
	// for(int i=0; i < quantidadeAliquotas; i++) {
	//  cout<<""X""<<i+1<<"" = ""<<listaAliquotas[i]<<endl;
	// }


	// cout<<""Xi = ""<<Xi<<endl;
	// cout<<""theta1 = ""<<theta1<<endl;
	// cout<<""theta2 = ""<<theta2<<endl;
	
	for(int i=0; i<listaValorVenal.size(); i++) {
		fitness = fitness + ( listaValorVenal[ i ] * listaAliquotas[ i ] );
		// cout<<""X""<<i+1<<"" = ""<<listaAliquotas[i]<<endl;
	}


    bool teste = true;
	for(int i=0; i < quantidadeAliquotas-1; i++) {
		if(listaAliquotas[i] > listaAliquotas[i + 1]) {
			// cout<<""Entrou no if de restrição""<<endl;
			// cout<<listaAliquotas[i] <<"" > ""<< listaAliquotas[i + 1]<<endl;
			teste = false;
			break;
		}
	}

	verificacao = teste;
	
	return fitness;
}

// Runs in \Theta(n \log n): // Exemplo consultado em brkga API
double SampleDecoder::decode(std::vector< double > &chromosome) const {
	double myFitness = 0.0;
	double  [MASK]  = 100.0;
	double penalidade = (valorTotalIptu* [MASK] )/100.0; // Penalidade de 50% relativo ao valor total do IPTU
	bool verificacao = false;

	// cout<<""\n\n\n=== Decode ===""<<endl;


	myFitness = construirSolucao(verificacao, chromosome);
	
	// cout<<std::setprecision(21)<<myFitness<<endl;
	// cout<<""myFitness      = ""<<std::setprecision(12)<<myFitness<<endl;
	// cout<<""valorTotalIptu = ""<<std::setprecision(12)<<valorTotalIptu<<endl;
	// cout<<""penalidade = ""<<std::setprecision(12)<<penalidade<<endl;

	// if (myFitness> valorTotalIptu)
	//  cout<<""myFitness maior""<<endl;
	

	// cout<<""Verificacao ""<<verificacao<<endl;
	// string msg = (verificacao==true)? ""verdadeiro"":""falso"";
	// cout<<""Verificacao: ""<<msg<<endl;

	// cout<<""Penalidade ""<<std::setprecision(21)<<penalidade<<endl;


	if (verificacao == false) {
		//cout<<""Entrou no if de restrição decode""<<endl;
		//cout<<verificacao<<endl;
		//cout<<std::setprecision(21)<<myFitness<<endl;
		penalidade = (myFitness*75)/100.0;
		myFitness = myFitness - penalidade;
		//cout<<std::setprecision(21)<<myFitness<<endl;

		// * cout<<""penalidade = ""<<std::setprecision(12)<<penalidade<<endl;
		// * cout<<""myFitness depois da penalidade   = ""<<std::setprecision(12)<<myFitness<<endl;
	}

	myFitness = myFitness * -1.0;

	// * cout<<""\n\n\n"";

	return myFitness;
}


void SampleDecoder::verificarSolucao(std::vector< double > &chromosome, int execucao) const {
	double fitness = 0, valortotalvenal, readleDouble = 0;
	double theta1, theta2; // parâmetros usados pelos modelo e obtidos pela leitura do cromossomo
	double Xi; 
	double listaAliquotas[quantidadeAliquotas];
	// randInt( const uint32 n ); // integer in [0,n] for n < 2^32
	int randomValue, interval;
	double randomValueDouble;


	bool verificacao = false;



	Xi = chromosome[0];
	theta1 = chromosome[1]; // theta1 deve ser maior ou igual a 0.00042 e menor ou igual a 0.00098
	theta2 = chromosome[2]; // theta2 deve ser maior ou igual a 0.26670 e menor ou igual a 0.62230

	//cout<<""\n\n\n=== Construir Solucao ===""<<endl;

	//cout<<""EulerConstant = ""<<EulerConstant<<endl;

	//cout<<""Valores originais""<<endl;
	//cout<<theta1<<"";""<<theta2<<"";""<<Xi<<endl;


    // theta1 deve ser maior ou igual a 0.00042 e menor ou igual a 0.00098
	if ( (theta1 >= 0.42) && (theta1 <= 0.98) ) {
		//cout<<""Entrou if de theta1""<<endl;
		theta1 = theta1/1000.0;
	} else if (theta1 < 0.42) {
			theta1 = 0.42/1000.0;
	} else if (theta1 > 0.98) {
			theta1 = 0.98/1000.0;
	}
	
	
	// theta2 deve ser maior ou igual a 0.26670 e menor ou igual a 0.62230
	if (theta2 < 0.26670) {
		theta2 = 0.26670;
	} else if (theta2 > 0.62230) {
			theta2 = 0.62230;
	}


	// X1 deve ser maior ou igual a 0.0010 e menor ou igual a 0.0020
	// if ( (Xi == 1) && (Xi <= 1)) {
	// 	Xi = 1;
	// } else {        
	// 	Xi = 1;
	// }	

	// Aqui!!! Xi = 1;


	// X1 deve ser maior ou igual a 0.0010 e menor ou igual a 0.0020
	listaAliquotas[ 0 ] = theta1 * pow(EulerConstant, theta2 * Xi); // X1 deve ser maior ou igual a 0.0010 e menor ou igual a 0.0020


	// if ( (listaAliquotas[ 0 ] < 0.0010) || (listaAliquotas[ 0 ] > 0.0020)) {
	// 	cout<<""X1 não atende""<<endl;
	// 	interval = 20 - 10;
	// 	randomValue = rng.randInt(interval);
	// 	randomValueDouble = 10 + randomValue;
	// 	randomValueDouble = randomValueDouble/10000.0;
	// 	listaAliquotas[ 0 ] = randomValueDouble;
	// 	cout<<""X1"" <<"" = ""<<listaAliquotas[0]<<endl;
    // } 

	if (listaAliquotas[ 0 ] < 0.0010) {
		listaAliquotas[ 0 ] = 0.0010;
    } else if (listaAliquotas[ 0 ] > 0.0020) {
			listaAliquotas[ 0 ] = 0.0020;
	}


	// cout<<""=== Aliquotas ===""<<endl;
	// cout<<""X1 = ""<<listaAliquotas[ 0 ]<<endl;
	for(int i=1; i < quantidadeAliquotas; i++) {
		listaAliquotas[i] = listaAliquotas[ i-1 ] * pow( EulerConstant,  theta2 * Xi);
		// cout<<""X""<<i+1<<"" = ""<<listaAliquotas[i]<<endl;
	}

	if ( listaAliquotas[ quantidadeAliquotas -1 ] > 0.0140 ) {
		listaAliquotas[ quantidadeAliquotas -1 ] = 0.0140;
	}


	// cout<<""=== Aliquotas ===""<<endl;
	// for(int i=0; i < quantidadeAliquotas; i++) {
	//  cout<<""X""<<i+1<<"" = ""<<listaAliquotas[i]<<endl;
	// }


	// cout<<""Xi = ""<<Xi<<endl;
	// cout<<""theta1 = ""<<theta1<<endl;
	// cout<<""theta2 = ""<<theta2<<endl;
	
	for(int i=0; i<listaValorVenal.size(); i++) {
		fitness = fitness + ( listaValorVenal[ i ] * listaAliquotas[ i ] );
		// cout<<""X""<<i+1<<"" = ""<<listaAliquotas[i]<<endl;
	}


    bool teste = true;
	for(int i=0; i < quantidadeAliquotas-1; i++) {
		if(listaAliquotas[i] > listaAliquotas[i + 1]) {

			// cout<<""Entrou no if de restrição""<<endl;
			// cout<<listaAliquotas[i] <<"" > ""<< listaAliquotas[i + 1]<<endl;
			teste = false;
			break;
		}
	}



	verificacao = teste;


	double penalidade = 0.0;

	if(verificacao == false)
	{
		//cout<<""Entrou no if de restrição decode""<<endl;
		//cout<<verificacao<<endl;
		//cout<<std::setprecision(21)<<fitness<<endl;
		penalidade = (fitness*75)/100.0;
		fitness = fitness - penalidade;
		//cout<<std::setprecision(21)<<fitness<<endl;

		// * cout<<""penalidade = ""<<std::setprecision(12)<<penalidade<<endl;
		// * cout<<""fitness depois da penalidade   = ""<<std::setprecision(12)<<fitness<<endl;
	}



	ofstream dataFileWrite;
	string ArquivoChecagemSolucao = ""resultados/checagem-solucao.txt"";
	
	dataFileWrite.open(ArquivoChecagemSolucao.c_str(), std::ofstream::out | std::ofstream::app);

	if(!dataFileWrite.is_open()) {
	     cout<<""Não foi possivel abrir o arquivo dataFileWrite!: ""<<ArquivoChecagemSolucao<<endl;
	     dataFileWrite.clear();
	     exit(1);
	}

	// cout<<std::setprecision(21)<<fitness<<endl;

	dataFileWrite<<execucao+1<<""  ""<<std::setprecision(21)<<fitness<<"" ""<<theta1<<""  ""<<theta2<<""  ""<<Xi<<""  ""<<listaAliquotas[0]<<""  ""<<listaAliquotas[1]<<""  ""<<listaAliquotas[2]<<""  ""<<listaAliquotas[3]<<""  ""<<listaAliquotas[4]<<""  ""<<listaAliquotas[5]<<""  ""<<listaAliquotas[6]<<""  ""<<listaAliquotas[7]<<""  ""<<verificacao<<""\n"";
	
	dataFileWrite.clear();
	dataFileWrite.close();
}


// primeira sem penalidade - depois com penalidade
// Penalidade ",taxa
985,"/**
 * This file demonstrates the ability to command the control strategy.
 */

#include <stdio.h>
#include <math.h>

#include ""lookup.hpp""
#include ""group_command.hpp""
#include ""command.hpp""
#include ""mac_address.hpp""

int main(int argc, char* argv[])
{
  // Try and get the requested group.
  std::shared_ptr<hebi::Group> group;
  {
    hebi::Lookup lookup;
    group = lookup.getGroupFromNames({""X5-4""}, {""X5-0000""});
    if (!group)
    {
      std::cout << ""No group found!"" << std::endl;
      return -1;
    }
  }

  int num_modules = group->size();

  // Create a command object; this can be sent to the group
  hebi::GroupCommand command(num_modules);

  // Set the control strategy for all the modules
  hebi::Command::ControlStrategy  [MASK]  = hebi::Command::ControlStrategy::Strategy2;
  for (int module_index = 0; module_index < num_modules; module_index++)
  {
    command[module_index].settings().actuator().controlStrategy().set( [MASK] );
  }

  long timeout_ms = 100;
  if (group->sendCommandWithAcknowledgement(command, timeout_ms))
  {
    std::cout << ""Got acknowledgement."" << std::endl;
  }
  else
  {
    std::cout << ""Did not receive acknowledgement!"" << std::endl;
  }

  // NOTE: destructors automatically clean up group command and group
  return 0;
}
",new_strategy
986,"#include <MIDI.h>

const int HiHatPin = 8;
const int SnarePin = 9;
const int BassPin = 10;
const int HiTomPin = 11;
const int LowTomPin = 12;
const int CymbalPin = 13;

const int HiHatNum[] = {22,26,42,44,46};
const int SnareNum[] = {37,38,40};
const int BassNum[] = {35,36};
const int HiTomNum[] = {48,50};
const int LowTomNum[] = {41,43,45,47};
const int CymbalNum[] = {49,51,52,55,57,59};

const int Threshold = 10;

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

MIDI_CREATE_DEFAULT_INSTANCE(); 

void setup()
{
    MIDI.begin(MIDI_CHANNEL_OMNI); //all channel
    pinMode(HiHatPin, OUTPUT);
    pinMode(SnarePin, OUTPUT);
    pinMode(BassPin, OUTPUT);
    pinMode(HiTomPin, OUTPUT);
    pinMode(LowTomPin, OUTPUT);
    pinMode(CymbalPin, OUTPUT);
}

void loop()
{
    if (MIDI.read())
    {
        switch(MIDI.getType())
        {
                //--------Note--------------------
                //MIDI.getData1(): get note number
                //MIDI.getData2(): get velocity
                //--------------------------------
                case midi::NoteOn:
                    if(MIDI.getData2() > Threshold){
                        int hitPin = padPinCheack(MIDI.getData1());
                        hitPad(hitPin);
                    }
                    break;

                default:
                    break;
        }
    } 
}

int padPinCheack(int  [MASK] ){
    //HH
    for (int index = 0; index < SIZE_OF_ARRAY(HiHatNum); index++) {
      if ( [MASK]  == HiHatNum[index]) {
        return HiHatPin;
      }
    }

    //SN
    for (int index = 0; index < SIZE_OF_ARRAY(SnareNum); index++) {
      if ( [MASK]  == SnareNum[index]) {
        return SnarePin;
      }
    }

    //BD
    for (int index = 0; index < SIZE_OF_ARRAY(BassNum); index++) {
      if ( [MASK]  == BassNum[index]) {
        return BassPin;
      }
    }

     //HT
    for (int index = 0; index < SIZE_OF_ARRAY(HiTomNum); index++) {
      if ( [MASK]  == HiTomNum[index]) {
        return HiTomPin;
      }
    }

    //LT
    for (int index = 0; index < SIZE_OF_ARRAY(LowTomNum); index++) {
      if ( [MASK]  == LowTomNum[index]) {
        return LowTomPin;
      }
    }

    //CY
    for (int index = 0; index < SIZE_OF_ARRAY(CymbalNum); index++) {
      if ( [MASK]  == CymbalNum[index]) {
        return CymbalPin;
      }
    }
    
    return 0;
}

void hitPad(int pin){
    digitalWrite(pin, HIGH);
    delay(15);
    digitalWrite(pin, LOW);
}
",NoteNum
987,"#include <cstdlib>
#include <iostream>
#include <numeric>
#include <ostream>
#include <random>
#include <fstream>

#include ""hooke_jeeves.hpp""
#include ""NewMHJ.hpp""


constexpr double speed_of_light = 2.99792458e8;

template <typename T, typename Vec>
auto doppler_shift(T  [MASK] , Vec receiver_vel, Vec emitter_vel,
                   Vec receiver_pos, Vec emitter_pos) {
  Vec dpos = receiver_pos;

  for (auto i = 0; i < dpos.size(); ++i) {
    dpos[i] -= emitter_pos[i];
  }
  auto norm = (double)sqrt(
      std::inner_product(dpos.begin(), dpos.end(), dpos.begin(), 0.0));
  for (auto i = 0; i < dpos.size(); ++i) {
    dpos[i] /= norm;
  }

  double v_rec = std::inner_product(receiver_vel.begin(), receiver_vel.end(),
                                    dpos.begin(), 0.0);
  double v_emt = std::inner_product(emitter_vel.begin(), emitter_vel.end(),
                                    dpos.begin(), 0.0);

  return  [MASK]  * (1 + v_rec / speed_of_light) /
         (1 - v_emt / speed_of_light);
}

template <typename T> auto sqr(T a) { return a * a; }

auto functional(std::vector<double> pos, std::vector<double> &rec1_pos,
                std::vector<double> &rec2_pos, std::vector<double> &rec3_pos,
                std::vector<double> &rec4_pos, std::vector<double> &rec1_vel,
                std::vector<double> &rec2_vel, std::vector<double> &rec3_vel,
                std::vector<double> &rec4_vel, std::vector<double> dw,
                double w1) {
  auto &x = pos[0];
  auto &y = pos[1];
  auto &z = pos[2];

  auto &x1 = rec1_pos[0];
  auto &y1 = rec1_pos[1];
  auto &z1 = rec1_pos[2];

  auto &x2 = rec2_pos[0];
  auto &y2 = rec2_pos[1];
  auto &z2 = rec2_pos[2];

  auto &x3 = rec3_pos[0];
  auto &y3 = rec3_pos[1];
  auto &z3 = rec3_pos[2];

  auto &x4 = rec4_pos[0];
  auto &y4 = rec4_pos[1];
  auto &z4 = rec4_pos[2];

  auto &vx1 = rec1_vel[0];
  auto &vy1 = rec1_vel[1];
  auto &vz1 = rec1_vel[2];

  auto &vx2 = rec2_vel[0];
  auto &vy2 = rec2_vel[1];
  auto &vz2 = rec2_vel[2];

  auto &vx3 = rec3_vel[0];
  auto &vy3 = rec3_vel[1];
  auto &vz3 = rec3_vel[2];

  auto &vx4 = rec4_vel[0];
  auto &vy4 = rec4_vel[1];
  auto &vz4 = rec4_vel[2];

  auto dw12 = dw[0];
  auto dw13 = dw[1];
  auto dw14 = dw[2];

  auto r1_n = sqrt(sqr(x - x1) + sqr(y - y1) + sqr(z - z1));
  auto r2_n = sqrt(sqr(x - x2) + sqr(y - y2) + sqr(z - z2));
  auto r3_n = sqrt(sqr(x - x3) + sqr(y - y3) + sqr(z - z3));
  auto r4_n = sqrt(sqr(x - x4) + sqr(y - y4) + sqr(z - z4));

  auto v_r1 = (vx1 * (x - x1) + vy1 * (y - y1) + vz1 * (z - z1)) / r1_n;
  auto v_r2 = (vx2 * (x - x2) + vy2 * (y - y2) + vz2 * (z - z2)) / r2_n;
  auto v_r3 = (vx3 * (x - x3) + vy3 * (y - y3) + vz3 * (z - z3)) / r3_n;
  auto v_r4 = (vx4 * (x - x4) + vy4 * (y - y4) + vz4 * (z - z4)) / r4_n;

  auto f1 = (v_r1 - v_r2) / (speed_of_light + v_r1) - dw12 / w1;
  auto f2 = (v_r1 - v_r3) / (speed_of_light + v_r1) - dw13 / w1;
  auto f3 = (v_r1 - v_r4) / (speed_of_light + v_r1) - dw14 / w1;

  return sqr(f1) + sqr(f2) + sqr(f3);
}

struct mat_dot {
  // boost::numeric::ublas::vector<double> pos, vel;
  std::vector<double> pos, vel;

  mat_dot(double x = 0, double y = 0, double z = 0, double vx = 0,
          double vy = 0, double vz = 0)
      : pos(3), vel(3) {
    pos.at(0) = x;
    pos.at(1) = y;
    pos.at(2) = z;
    vel.at(0) = vx;
    vel.at(1) = vy;
    vel.at(2) = vz;
  };
};

std::random_device rd;

auto generate_receiver(double R, double v) {
  double angle =
      std::uniform_real_distribution<double>(0, 0.5 * 3.14159265358979323)(rd);
  double vel_angle =
      std::uniform_real_distribution<double>(0, 2 * 3.14159265358979323)(rd);

  double x = R * cos(angle);
  double y = R * sin(angle);
  double z = 0;
  double vx = v * sqrt(cos(vel_angle) * cos(vel_angle) / (1 + x * x / y / y));
  double vy = v * sqrt(cos(vel_angle) * cos(vel_angle) / (1 + y * y / x / x));
  double vz = v * sin(vel_angle);

  return mat_dot{x, y, z, vx, vy, vz};
}

auto generate_emitter(double R) {
  double angle =
      std::uniform_real_distribution<double>(0, 0.5 * 3.14159265358979323)(rd);
  return mat_dot{R * cos(angle), R * sin(angle), 0};
}

auto print(std::ostream &str, mat_dot &md) {

  str << ""pos:"" << md.pos.at(0) << '\t' << md.pos.at(1) << '\t' << md.pos.at(2)
      << std::endl;
  str << ""vel:"" << md.vel.at(0) << '\t' << md.vel.at(1) << '\t' << md.vel.at(2)
      << std::endl;
}

template <typename T>
auto print(std::ostream &str, std::vector<T> &v) {
  for (auto i = 0; i < v.size(); ++i)
  {
    str << v[i] << ' ';
  } str << std::endl;
}

int main() {
  mat_dot receiver[4];
  receiver[0] = generate_receiver(500, 1);
  receiver[1] = generate_receiver(550, 1);
  receiver[2] = generate_receiver(600, 1);
  receiver[3] = generate_receiver(650, 1);

  mat_dot emitter = generate_emitter(100);

  print(std::cout, receiver[0]);
  print(std::cout, receiver[1]);
  print(std::cout, receiver[2]);
  print(std::cout, receiver[3]);

  std::cout << std::endl << ""Emitter: "" << std::endl;
  print(std::cout, emitter);
  std::cout << std::endl;

  double f = 1e9;

  double f1 = doppler_shift(f, receiver[0].vel, emitter.vel, receiver[0].pos,
                            emitter.pos);
  double f2 = doppler_shift(f, receiver[1].vel, emitter.vel, receiver[1].pos,
                            emitter.pos);
  double f3 = doppler_shift(f, receiver[2].vel, emitter.vel, receiver[2].pos,
                            emitter.pos);
  double f4 = doppler_shift(f, receiver[3].vel, emitter.vel, receiver[3].pos,
                            emitter.pos);

  auto &r1 = receiver[0];
  auto &r2 = receiver[1];
  auto &r3 = receiver[2];
  auto &r4 = receiver[3];

  // auto p = hooke_jeeves_optimizer_simple(
  //     [&](std::vector<double> pos) {
  //       return functional(pos,
  //        r1.pos, r2.pos, r3.pos, r4.pos,
  //        r1.vel, r2.vel,r3.vel, r4.vel,
  //                         std::vector{f2 - f1, f3 - f1, f4 - f1}, f1);
  //     },
  //     /*r1.pos*/std::vector{0.0, 0.0, 0.0}, 3,1e-9);

  std::vector<float> p(3);

  NewMHJ(3,p.data(),[&](float pos[3]) {
               return functional(std::vector<double>(pos,pos+3),
                r1.pos, r2.pos, r3.pos, r4.pos,
                r1.vel, r2.vel,r3.vel, r4.vel,
                                 std::vector{f2 - f1, f3 - f1, f4 - f1}, f1);});


  std::cout << ""result:"" << p[0] << ' ' << p[1] << ' ' << p[2] << std::endl;


  std::ofstream str(""out.txt"");
  std::ofstream str2(""out_2.txt"");

  print(str2,emitter.pos);
  print(str2,p);
  print(str2,r1.pos);
  print(str2,r2.pos);
  print(str2,r3.pos);
  print(str2,r4.pos);

  for (auto j = -1000.; j < 1000.; j += 1)
  {
  for (auto i = -1000.; i < 1000.; i += 1)
  {
    std::vector pos{i,j,0.0};
    str << functional(pos,
                             r1.pos, r2.pos, r3.pos, r4.pos,
                             r1.vel, r2.vel,r3.vel, r4.vel,
                             std::vector{f2 - f1, f3 - f1, f4 - f1}, f1) << ' '/* << i << ' ' << j*/;
  } str << std::endl;
  }
}
",frequency
988,"#include <mutex>                // std::mutex
#include <queue>                // std::queue<>
#include <thread>               // std::thread
#include <atomic>               // std::atomic<>
#include <future>               // std::future<>
#include <csignal>              // sigal
#include <tuple>
#include <utility>              // std::move()
#include <cassert>              // assert         
#include <iostream>             // std::cout...
#include <functional>           // std::function<()>
#include <type_traits>          // std::result_of_t<()>
#include <condition_variable>   // std::condition_variable

class thread_pool{
public:
    ~thread_pool();
    thread_pool(int num_threads);

    thread_pool(const thread_pool&) = delete;
    thread_pool& operator=(const thread_pool&) = delete;

    void wait_jobs();
    void pause_threads();
    void resume_threads();
    static void thread_hold(int sig_id);
    template<typename F, typename... Args>
    decltype(auto) add_task(F&& f, Args&&... args);
    
    int get_num_threads_working(){
        return num_threads_working; 
    }

private:
    std::mutex task_mtx, count_mtx;
    std::condition_variable task_cv, idle_cv;
    
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> jobs;

    bool stop = {false};
    static int threads_on_hold;
    std::atomic_int num_threads_alive = {0};
    // The number of working threads which are performing tasks(not idle)
    std::atomic_int num_threads_working = {0};
};
int thread_pool::threads_on_hold = 0;

template<typename F, typename... Args>
decltype(auto) thread_pool::add_task(F&& f, Args&&... args){
    //using result_type = decltype(declval<F>(f)(args...));
    using result_type = std::result_of_t<F(Args...)>;

    //std::packaged_task<result_type()> task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
    auto task = std::make_shared<std::packaged_task<result_type()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...)
    );
    std::future<result_type>  [MASK]  = task->get_future();

    std::unique_lock<std::mutex> queue_lck(task_mtx);
    jobs.emplace([task](){(*task)();});
    queue_lck.unlock();

    task_cv.notify_one();
    return  [MASK] ;
}

// Will wait for all queued jobs to finish.
void thread_pool::wait_jobs(){
    std::unique_lock<std::mutex> count_lck(count_mtx);
    while(jobs.size() || num_threads_working){
       idle_cv.wait(count_lck); 
    } 
}

void thread_pool::thread_hold(int sig_id){
    threads_on_hold = 1;
    while(threads_on_hold){
        std::this_thread::yield(); 
    }
}

// All threads will be paused no matter if they are idle and working. While being paused, new job can be added.
void thread_pool::pause_threads(){
    for(int n = 0; n < num_threads_alive; n++){
        pthread_kill(threads[n].native_handle(), SIGUSR1);
    }
}

// All threads will return to their previous states continuing processing, if they are paused.
void thread_pool::resume_threads(){
    threads_on_hold = 0;
}

thread_pool::thread_pool(int num_threads){
    assert(num_threads > 0);
    for(int i = 0; i < num_threads; i++){
        // each thread in thread_pool is an endless loop callable object(lambda), waiting the condition_variable to notify when the job(task) added.
        threads.emplace_back([this](){
            struct sigaction act;
            act.sa_flags = 0;
            sigemptyset(&act.sa_mask);
            act.sa_handler = &thread_pool::thread_hold;
            if(sigaction(SIGUSR1, &act, NULL) == -1){
                fprintf(stderr, ""can't set handler SIGUSR1 for thread"");
            }
            num_threads_alive++; 
            while(true){ 
                std::unique_lock<std::mutex> queue_lck(task_mtx);
                task_cv.wait(queue_lck, [this](){
                    return stop || !jobs.empty(); 
                }); 
                if(stop && jobs.empty())
                    break;
                num_threads_working++;
                auto task = std::move(jobs.front());
                jobs.pop();
                queue_lck.unlock();
                task();
                num_threads_working--;
                if(!num_threads_working)
                    idle_cv.notify_one();
            }
            num_threads_alive--;
        });
        // threads[i].detach();
    } 
    while(num_threads_alive != num_threads){}
}

thread_pool::~thread_pool(){
    stop = true;

    while(num_threads_alive){
        task_cv.notify_all();
    }

    //std::cout << ""~thread_pool() clear all threads"" << std::endl;
    for(auto& thread: threads){
        thread.join(); 
    }
};

",fut_result
989,"#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <cmath>

using namespace std;

bool checkPList(string programListFile); //Validate program list file
bool checkPTrace(string programTraceFile); //Validate program trace file
bool checkPSize(long int pSize); //Validate page size
bool checkPAlgorithm(string pageAlgorithm); //Validate replacement algorithm
bool checkPStyle(string pageStyle); //Validate paging style
void checkArguments(int argc, char *argv[]); //Validate all arguments

int main(int argc, char *argv[])
{
  checkArguments(argc, argv);
  
  const int MAX_SIZE = 10; //Number of programs determined by the assignment
  const int memSize = 512; //Size of Memory
  long int pageSize = strtol(argv[3],NULL,10); //Page size determined by the user
  string programListFile = argv[1]; //List File determined by the user
  string programTraceFile = argv[2]; //Trace file determined by the user
  string pageAlgorithm = argv[4]; //Replacement algorithm determined by the user
  string pageStyle = argv[5]; //Paging style determined by the user
  vector<int> systemPageTable[MAX_SIZE]; //Page Table used by the simulation (virtual memory)
  vector<int> timeTracker; //Clock/LRU Tracker, adjusted depending on the algorithm chosen
  vector<int>  [MASK] ; //Memory used by the simulation
  int numPageFaults = 0; //The number of page faults
  int tracker; //Tracks the age of a page
  int clockTracker; //Tracks the clock bit
  bool foundInMemory = false; //Flag that tracks if a page is in memory
  int pageUniqueID; //Unique ID of a page
  int parseProgramID; //Program being read in
  int parseProgramSize; //Program size being read in
  int numPages; //Number of pages assigned to each program
  int memAllocated; //Memory allocated to each program
  int activeProgram; //Current program
  int requestedLocation; //Requested page location
  int pageLocation; //The actual page location
  int oldPage; //Page being examined
  
  ifstream fileIn; //open the list file and begin parsing
  fileIn.open(programListFile.c_str());
  if(fileIn.fail())
  {
    cerr << ""The file you wanted has disappeared!"" << endl;
    cerr << ""Exiting due to catastrophic failure..."" << endl;
    fileIn.close();
    exit(1);
  }
  else
  {
    pageUniqueID = 0;
    while(!fileIn.eof())
    {
      fileIn >> parseProgramID;
      fileIn >> parseProgramSize;
      numPages = static_cast<int>(ceil(static_cast<double>(parseProgramSize) / static_cast<double>(pageSize)));
      for(int i = 0; i < numPages; i++)
      {
        systemPageTable[parseProgramID].push_back(pageUniqueID); //assign each page a unique ID
        pageUniqueID++;
      }
    }
  }
  fileIn.close();
  
  memAllocated = static_cast<int>(ceil(static_cast<double>(memSize) / static_cast<double>(pageSize))); //determine the amount of memory for each program
  
  if(pageAlgorithm == ""lru"" || pageAlgorithm == ""fifo"")
  {
    for(int i = 0; i < memAllocated; i++)
    {
      timeTracker.push_back(0); //initialize the LRU page age tracker
    }
    for(int i = 0; i < MAX_SIZE; i++)
    {
      for(int j = 0; j < static_cast<int>(floor(static_cast<double>(memAllocated) / static_cast<double>(MAX_SIZE))); j++) //floor
      {
         [MASK] .push_back(systemPageTable[i][j]); //initialize the clock bit tracker
      }
    }
  }
  else
  {
    for(int i = 0; i < memAllocated; i++)
    {
      timeTracker.push_back(1);
    }
    for(int i = 0; i < MAX_SIZE; i++)
    {
      for(int j = 0; j < static_cast<int>(floor(static_cast<double>(memAllocated) / static_cast<double>(MAX_SIZE))); j++) //floor
      {
         [MASK] .push_back(systemPageTable[i][j]); //initial load of memory
      }
    }
  }
  
  if(pageAlgorithm == ""lru"")
  {
    fileIn.open(programTraceFile.c_str()); //open the trace file and begin parsing
    if(fileIn.fail())
    {
      cerr << ""The file you wanted has disappeared!"" << endl;
      cerr << ""Exiting due to catastrophic failure..."" << endl;
      fileIn.close();
      exit(1);
    }
    else
    {
      fileIn >> activeProgram;
      fileIn >> requestedLocation;
      pageLocation = static_cast<int>(ceil(static_cast<double>(requestedLocation) / pageSize)); //determine the actual location of the page
      int i;
      tracker = 0;
      while(!fileIn.eof())
      {
        foundInMemory = false;
        for(i = 0; i < static_cast<int>( [MASK] .size()); i++)
        {
          if( [MASK] [i] == systemPageTable[activeProgram][pageLocation])
          {
            foundInMemory = true; //if the page is found in memory, no page fault, no replacement
          }
          if(foundInMemory)
          {
            break; //prevent unnecessary loops
          }
        }
        if(!foundInMemory)
        {
          numPageFaults++; //page fault occured
          if(static_cast<int>( [MASK] .size()) < memAllocated)
          {
             [MASK] .push_back(systemPageTable[activeProgram][pageLocation]); //put into memory if there are empty spaces for the active program
          }
          else
          {
            oldPage = 0;
            for(int j = 1; j < static_cast<int>( [MASK] .size()); j++)
            {
              if(timeTracker[j] < timeTracker[oldPage])
              {
                oldPage = j;
              }
            }
             [MASK] [oldPage] = systemPageTable[activeProgram][pageLocation]; //the oldest page is swapped for a new one
            timeTracker[oldPage] = tracker;
            if(pageStyle == ""p"")
            {
              pageLocation++; oldPage++;
              if(oldPage == static_cast<int>( [MASK] .size()))
              {
                oldPage = 0;
              }
              if(pageLocation == static_cast<int>(systemPageTable[activeProgram].size()))
              {
                pageLocation = 0; //not using global page replacement, so bring in the first page of the active program
              }
               [MASK] [oldPage] = systemPageTable[activeProgram][pageLocation]; //next oldest page is swapped for a new one
              timeTracker[oldPage] = tracker;
            }
          }
        }
        else if(foundInMemory)
        {
          timeTracker[i] = tracker; //update the page age
        }
        tracker++;
        fileIn >> activeProgram;
        fileIn >> requestedLocation;
        pageLocation = static_cast<int>(ceil(static_cast<double>(requestedLocation) / pageSize));
      }
    }
  }
  else if(pageAlgorithm == ""fifo"")
  {
    fileIn.open(programTraceFile.c_str());
    if(fileIn.fail())
    {
      cerr << ""The file you wanted has disappeared!"" << endl;
      cerr << ""Exiting due to catastrophic failure..."" << endl;
      fileIn.close();
      exit(1);
    }
    else
    {
      fileIn >> activeProgram;
      fileIn >> requestedLocation;
      pageLocation = static_cast<int>(ceil(static_cast<double>(requestedLocation) / pageSize)); //determine the actual location of the page
      while(!fileIn.eof())
      {
        foundInMemory = false;
        for(int i = 0; i < static_cast<int>( [MASK] .size()); i++)
        {
          if( [MASK] [i] == systemPageTable[activeProgram][pageLocation])
          {
            foundInMemory = true; //no replacement if the page is found in memory
          }
          if(foundInMemory)
          {
            break; //prevent unnecessary loops
          }
        }
        if(!foundInMemory)
        {
          numPageFaults++; //page fault occured
          if(static_cast<int>( [MASK] .size()) < memAllocated)
          {
             [MASK] .push_back(systemPageTable[activeProgram][pageLocation]); //put page into memory if there is empty space in the active program's memory
          }
          else
          {
            oldPage = 0;
            for(int i = 1; i < static_cast<int>( [MASK] .size()); i++)
            {
              if(timeTracker[i] < timeTracker[oldPage])
              {
                oldPage = i;
              }
            }
             [MASK] [oldPage] = systemPageTable[activeProgram][pageLocation]; //swap occurs and the new page is put in
            timeTracker[oldPage] = tracker;
            if(pageStyle == ""p"")
            {
              pageLocation++; oldPage++;
              if(oldPage == static_cast<int>( [MASK] .size()))
              {
                oldPage = 0;
              }
              if(pageLocation == static_cast<int>(systemPageTable[activeProgram].size()))
              {
                pageLocation = 0; //prevent global page replacement
              }
               [MASK] [oldPage] = systemPageTable[activeProgram][pageLocation]; //another swap occurs and the new page is put in
              timeTracker[oldPage] = tracker;
            }
          }
        }
        tracker++;
        fileIn >> activeProgram;
        fileIn >> requestedLocation;
        pageLocation = static_cast<int>(ceil(static_cast<double>(requestedLocation) / pageSize));
      }
    }
  }
  else
  {
    fileIn.open(programTraceFile.c_str());
    if(fileIn.fail())
    {
      cerr << ""The file you wanted has disappeared!"" << endl;
      cerr << ""Exiting due to catastrophic failure..."" << endl;
      fileIn.close();
      exit(1);
    }
    else
    {
      fileIn >> activeProgram;
      fileIn >> requestedLocation;
      pageLocation = static_cast<int>(ceil(static_cast<double>(requestedLocation) / pageSize)); //determine the actual location of the page
      int i;
      clockTracker = 0;
      while(!fileIn.eof())
      {
        foundInMemory = false;
        for(i = 0; i < static_cast<int>( [MASK] .size()); i++)
        {
          if( [MASK] [i] == systemPageTable[activeProgram][pageLocation])
          {
            foundInMemory = true; //if the page is found in memory, no page fault, no swap occurs
          }
          if(foundInMemory)
          {
            break; //prevent unnecessary loops
          }
        }
        if(!foundInMemory)
        {
          numPageFaults++; //page fault occured
          if(static_cast<int>( [MASK] .size()) < memAllocated)
          {
             [MASK] .push_back(systemPageTable[activeProgram][pageLocation]); //if there is empty space in the active program's memory, put into memory
          }
          else
          {
            while(timeTracker[clockTracker] == 1)
            {
              timeTracker[clockTracker] = 0;
              clockTracker++;
              if(clockTracker == static_cast<int>(timeTracker.size()))
              {
                clockTracker = 0; //prevent seg fault
              }
            }
             [MASK] [clockTracker] = systemPageTable[activeProgram][pageLocation]; //swap occurs for the page with clock bit 0
            timeTracker[clockTracker] = 1;
            if(pageStyle == ""p"")
            {
              pageLocation++; clockTracker++;
              if(clockTracker == static_cast<int>( [MASK] .size()))
              {
                clockTracker = 0;
              }
              if(pageLocation == static_cast<int>(systemPageTable[activeProgram].size()))
              {
                pageLocation = 0;
              }
               [MASK] [clockTracker] = systemPageTable[activeProgram][pageLocation]; //swaps the next page with clock bit 0
              timeTracker[clockTracker] = 1; 
            }
          }
        }
        else if(foundInMemory)
        {
          timeTracker[i] = 1; //update the clock bit
        }
        fileIn >> activeProgram;
        fileIn >> requestedLocation;
        pageLocation = static_cast<int>(ceil(static_cast<double>(requestedLocation) / pageSize));
      }
    }
  }
  fileIn.close();
  
  cout << ""---------------------------------------------------"" << endl; //begin outputting the results
  cout << ""> Program List File: "" << programListFile << endl;
  cout << ""> Program Trace File: "" << programTraceFile << endl;
  cout << ""> Page Size: "" << pageSize << endl;
  cout << ""> Page Replacement Algorithm: "";
  if(pageAlgorithm == ""lru"")
  {
    cout << ""Least Recently Used"" << endl;
  }
  else if(pageAlgorithm == ""fifo"")
  {
    cout << ""First In-First Out"" << endl;
  }
  else
  {
    cout << ""Clock Based Policy"" << endl;
  }
  cout << ""> Paging Style: ""; 
  if(pageStyle == ""p"")
  {
    cout << ""Prepaging"" << endl;
  }
  else
  {
    cout << ""Demand"" << endl;
  }
  cout << ""> Number of Page Faults: "" << numPageFaults << endl;
  cout << ""---------------------------------------------------"" << endl;
    
  return 0;
}

bool checkPList(string programListFile) //check to make sure the file exists
{
  ifstream listFile;
  listFile.open(programListFile.c_str());
  if(listFile.fail())
  {
    cerr << ""Unable to open "" << programListFile << "" !"" << endl;
    cerr << ""Please make sure the file exists and re-execute the program."" << endl;
    listFile.close();
    return false;
  }
  else
  {
    listFile.close();
    return true;
  }
}

bool checkPTrace(string programTraceFile) //check to make sure the file exists
{
  ifstream traceFile;
  traceFile.open(programTraceFile.c_str());
  if(traceFile.fail())
  {
    cerr << ""Unable to open "" << programTraceFile << "" !"" << endl;
    cerr << ""Please make sure the file exists and re-execute the program."" << endl;
    traceFile.close();
    return false;
  }
  else
  {
    traceFile.close();
    return true;
  }
}

bool checkPSize(long int pSize) //check to make sure the user entered a valid page size
{
  bool isValid = false;
  switch (pSize) 
  {
    case 1:
      isValid = true;
      break;
    case 2:
      isValid = true;
      break;
    case 4:
      isValid = true;
      break;
    case 8:
      isValid = true;
      break;
    case 16:
      isValid = true;
      break;
    case 32:
      isValid = true;
      break;
    default:
      cerr << ""Invalid page size detected!"" << endl;
      cerr << ""Valid page sizes are: 1, 2, 4, 8, 16, & 32."" << endl;
      cerr << ""Please re-execute the program with a valid page size."" << endl;
      isValid = false;
  }
  return isValid;
}

bool checkPAlgorithm(string pageAlgorithm) //check to make sure the user entered a valid page replacement algorithm
{
  if(pageAlgorithm == ""clock"")
  {
    return true;
  }
  else if(pageAlgorithm == ""fifo"")
  {
    return true;
  }
  else if(pageAlgorithm == ""lru"")
  {
    return true;
  }
  else
  {
    cerr << ""No valid paging algorithm was detected!"" << endl;
    cerr << ""Valid algorithms are: clock, fifo, & lru."" << endl;
    cerr << ""Please re-execute the program with a valid paging algorthm."" << endl;
    return false;
  }
}

bool checkPStyle(string pageStyle) //check to make sure the user entered a valid paging style
{
  if(pageStyle == ""d"")
  {
    return true;
  }
  else if(pageStyle == ""p"")
  {
    return true;
  }
  else
  {
    cerr << ""No valid paging style was detected!"" << endl;
    cerr << ""Valid paging styles are: d or p."" << endl;
    cerr << ""Please re-execute the program with a valid paging algorithm."" << endl;
    return false;
  }
}

void checkArguments(int argc, char *argv[]) //check all the arguments passed into the program
{
  if(argc < 6)
  {
    cerr << ""Too few arguments have been passed to the program."" << endl;
    cerr << ""Arguments should be: programlist programtrace pagesize pagealgorithm pagingstyle"" << endl;
    cerr << ""Please re-execute the program with the correct number of arguments."" << endl;
    exit(1);
  }
  else if(argc > 6)
  {
    cerr << ""Too many arguments have been passed to the program."" << endl;
    cerr << ""Arguments should be: programlist programtrace pagesize pagealgorithm pagingstyle"" << endl;
    cerr << ""Please re-execute the program with the correct number of arguments."" << endl;
    exit(1);
  }
  else if(!checkPList(argv[1]))
  {
    exit(1);
  }
  else if(!checkPTrace(argv[2]))
  {
    exit(1);
  }
  else if(!checkPSize(strtol(argv[3],NULL,10)))
  {
    exit(1);
  }
  else if(!checkPAlgorithm(argv[4]))
  {
    exit(1);
  }
  else if(!checkPStyle(argv[5]))
  {
    exit(1);
  }
  return;
}
",systemMemory
990,"//  Copyright (c) 2021 <NAME>
//
//  SPDX-License-Identifier: BSL-1.0
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// This example demonstrates the use of the facility invoke_function_action that
// allows to wrap arbitrary global functions into an action. Please note: this
// facility will work as expected only if the function address of the wrapped
// function is the same on all localities.

#include <hpx/hpx.hpp>
#include <hpx/hpx_main.hpp>

#include <iostream>

int call_me(int  [MASK] )
{
    return  [MASK] ;
}

void void_call_me(int) {}

int main(int, char*[])
{
    // The function pointer is casted to a std::size_t to avoid compilation
    // problems complaining about raw pointers being used as action parameters.
    // The invoke_function facilities will cast this back to the correct
    // function pointer on the receiving end.
    {
        using action_type =
            hpx::components::server::invoke_function_action<decltype(&call_me),
                int>;

        hpx::future<int> result = hpx::async<action_type>(
            hpx::find_here(), reinterpret_cast<std::size_t>(&call_me), 42);

        std::cout << ""the action invocation returned: "" << result.get() << ""\n"";
    }

    {
        using action_type = hpx::components::server::invoke_function_action<
            decltype(&void_call_me), int>;

        hpx::future<void> result = hpx::async<action_type>(hpx::find_here(),
            reinterpret_cast<std::size_t>(&void_call_me), 42);

        result.get();
    }

    return 0;
}
",arg
991,"//
//   Copyright 2014 QuarksLab
//
//   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 BINMAP_GRAPH_HPP
#define BINMAP_GRAPH_HPP

#include ""binmap/hash.hpp""

#include <string>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>

#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphviz.hpp>

#include <boost/graph/adj_list_serialize.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/map.hpp>
#include ""boost_ex/filesystem/serialization.hpp""
#include ""boost_ex/serialization/unordered_map.hpp""
#include ""boost_ex/serialization/unordered_set.hpp""

/* define a new graph property to hold the hash of a node */
namespace boost {
enum vertex_hash_t {
  vertex_hash
};
BOOST_INSTALL_PROPERTY(vertex, hash);
}

class Graph {

  typedef boost::property<boost::vertex_name_t, boost::filesystem::path,
                          boost::property<boost::vertex_hash_t, Hash> >
  vertex_property;
  typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS,
                                vertex_property> graph_type;

  graph_type graph_;
  boost::unordered_map<boost::filesystem::path, graph_type::vertex_descriptor>
  mapping_;
  mutable std::vector<int> *distance_matrix_;

  boost::unordered_set<boost::filesystem::path> visited_path_;

public:
  Graph();
  ~Graph();

  typedef boost::unordered_set<boost::filesystem::path> successors_type;
  typedef boost::property_map<graph_type, boost::vertex_hash_t>::const_type
  const_hashes_t;
  typedef boost::graph_traits<graph_type>::vertex_iterator vertex_iterator;
  typedef vertex_iterator iterator;
  typedef graph_type::vertex_descriptor vertex_descriptor;
  typedef boost::graph_traits<graph_type>::out_edge_iterator edge_iterator;

  bool has_node(boost::filesystem::path const &path) const;

  bool has_path(boost::filesystem::path const &from,
                boost::filesystem::path const &to) const;

/**
*	if `input_file` is not found in the binary folder but has been parsed before
*		=> return path parsed before
*	if `input_file` is found but hasn't been found before
*		=> return `input_file` (and change the node's name)
**/
  boost::filesystem::path add_node(boost::filesystem::path const &input_file,
                Hash const &input_hash);

  graph_type const &graph() const;

  /** get the filename associated to a node descriptor */
  boost::filesystem::path const &key(graph_type::vertex_descriptor vd) const;

  /** get the hash associated to a node descriptor */
  Hash const &hash(graph_type::vertex_descriptor vd) const;

  /** get the hash associated to a filename */
  Hash const &hash(boost::filesystem::path const &key) const;

  /** collects all successors of a filename in succs */
  void successors(successors_type &succs,
                  boost::filesystem::path const &key) const;
  void predecessors(successors_type &preds,
                    boost::filesystem::path const &key) const;

  /** get internal filename to hash dict */
  const_hashes_t hashes() const;

  /** iterates over vertices */
  vertex_iterator begin() const;

  vertex_iterator end() const;

  /** iterates over successors of a node */
  edge_iterator edge_begin(boost::filesystem::path const &input_file) const;

  edge_iterator edge_end(boost::filesystem::path const &input_file) const;

  edge_iterator edge_begin(graph_type::vertex_descriptor input) const;

  edge_iterator edge_end(graph_type::vertex_descriptor input) const;

  /** add edge between from and to, pointing toward to*/
  void add_edge(boost::filesystem::path const &from,
                boost::filesystem::path const &to);

  /** dump the graph as a .dot file */
  void dot(boost::filesystem::path const &path) const;

  size_t size() const;

  template < class Archive >
  void serialize(Archive & ar, unsigned int) {
      ar& graph_ & mapping_;
  }

protected:
  void compute_distance_matrix() const;
};

/** Class resulting from the projection of a graph to a new dimension */

template <class T> class GraphProjection {

  typedef boost::property<boost::vertex_name_t, T> vertex_property;
  typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS,
                                vertex_property> graph_type;

  graph_type graph_;
  boost::unordered_map<T, typename graph_type::vertex_descriptor> mapping_;
  boost::unordered_set<boost::filesystem::path> visited_path_;

public:
  typedef typename boost::graph_traits<graph_type>::vertex_iterator
  vertex_iterator;
  bool has_node(T const &key) const {
    return mapping_.find(key) != mapping_.end();
  }

  boost::filesystem::path add_node(T const &key) {
    assert(not has_node(key));
    typename graph_type::vertex_descriptor v = boost::add_vertex(graph_);
    mapping_[key] = v;

    boost::put(boost::vertex_name_t(), graph_, v, key);
    return key;
  }

  vertex_iterator begin() const { return boost::vertices(graph_).first; }
  vertex_iterator end() const { return boost::vertices(graph_).second; }

  void add_edge(T const &from, T const &to) {
    assert(has_node(from));
    assert(has_node(to));
    boost::add_edge(mapping_[from], mapping_[to], graph_);
  }
  void dot(boost::filesystem::path const &path) const {
    std::ofstream  [MASK] (path.c_str());
    boost::write_graphviz(
         [MASK] , graph_,
        boost::make_label_writer(boost::get(boost::vertex_name_t(), graph_)));
  }
};

#endif
",dotfile
992,"#include <epoch_frame/dataframe.h>
#include <epoch_frame/series.h>
#include <epoch_frame/scalar.h>
#include <factory/array_factory.h>
#include <factory/index_factory.h>
#include <iostream>
#include <iomanip>
#include <random>
#include <chrono>
#include <vector>
#include <string>
#include <arrow/api.h>
#include <arrow/array/builder_primitive.h>
#include <cstdio>  // for popen, pclose

namespace efo = epoch_frame;

// Helper function to create random DataFrame with specified rows and columns
efo::DataFrame createRandomDataFrame(std::size_t rows, std::size_t cols) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(-100.0, 100.0);

    // Create columns
    std::vector<std::shared_ptr<arrow::ChunkedArray>> columns;
    std::vector<std::shared_ptr<arrow::Field>>  [MASK] ;

    for (std::size_t c = 0; c < cols; c++) {
        arrow::DoubleBuilder builder;
        auto status = builder.Reserve(rows);
        if (!status.ok()) {
            throw std::runtime_error(""Failed to reserve memory: "" + status.ToString());
        }

        for (std::size_t r = 0; r < rows; r++) {
            status = builder.Append(dis(gen));
            if (!status.ok()) {
                throw std::runtime_error(""Failed to append value: "" + status.ToString());
            }
        }

        std::shared_ptr<arrow::Array> array;
        status = builder.Finish(&array);
        if (!status.ok()) {
            throw std::runtime_error(""Failed to finish array: "" + status.ToString());
        }

        auto chunked = arrow::ChunkedArray::Make({array});
        columns.push_back(chunked.ValueOrDie());
         [MASK] .push_back(arrow::field(""col_"" + std::to_string(c), arrow::float64()));
    }

    auto schema = arrow::schema( [MASK] );
    auto table = arrow::Table::Make(schema, columns);
    auto index = efo::factory::index::from_range(0, rows);

    return efo::DataFrame(index, table);
}

// Setup Python environment for pandas benchmarks
bool setupPythonEnvironment() {
    std::string temp_dir = ""/tmp/epochframe_benchmark_env"";
    std::string python_path = temp_dir + ""/bin/python"";

    // Create temp directory if it doesn't exist
    std::string mkdir_cmd = ""mkdir -p "" + temp_dir;
    if (system(mkdir_cmd.c_str()) != 0) {
        std::cerr << ""Failed to create temp directory"" << std::endl;
        return false;
    }

    // Check if virtual environment already exists
    if (system((""test -f "" + python_path).c_str()) == 0) {
        return true;
    }

    std::cout << ""Setting up Python virtual environment with pandas..."" << std::endl;

    // Create virtual environment
    if (system((""python3 -m venv "" + temp_dir).c_str()) != 0) {
        std::cerr << ""Failed to create Python virtual environment"" << std::endl;
        return false;
    }

    // Install pandas and numpy
    std::string install_cmd = python_path + "" -m pip install pandas numpy"";
    std::cout << ""Running: "" << install_cmd << std::endl;
    if (system(install_cmd.c_str()) != 0) {
        std::cerr << ""Failed to install pandas and numpy"" << std::endl;
        return false;
    }

    std::cout << ""Python environment setup complete"" << std::endl;
    return true;
}

// Run a pandas benchmark and return execution time
double runPandasBenchmark(const std::string& operation, size_t rows, size_t cols) {
    // Create a Python script for the benchmark
    std::string script = ""#!/usr/bin/env python3\n""
                         ""import pandas as pd\n""
                         ""import numpy as np\n""
                         ""import time\n\n"";

    if (operation == ""creation"") {
        script += ""# Benchmark DataFrame creation\n""
                ""start_time = time.time()\n""
                ""df = pd.DataFrame(np.random.uniform(-100, 100, size=("" +
                std::to_string(rows) + "", "" + std::to_string(cols) + "")), \n""
                ""                  columns=['col_' + str(i) for i in range("" + std::to_string(cols) + "")])\n""
                ""elapsed_time = time.time() - start_time\n"";
    }
    else if (operation == ""addition"") {
        script += ""# Benchmark DF addition (without creation time)\n""
                ""df = pd.DataFrame(np.random.uniform(-100, 100, size=("" +
                std::to_string(rows) + "", "" + std::to_string(cols) + "")), \n""
                ""                  columns=['col_' + str(i) for i in range("" + std::to_string(cols) + "")])\n""
                ""# Start timing\n""
                ""start_time = time.time()\n""
                ""result = df + 1.0\n""
                ""elapsed_time = time.time() - start_time\n"";
    }
    else if (operation == ""subtraction"") {
        script += ""# Benchmark DF subtraction (without creation time)\n""
                ""df = pd.DataFrame(np.random.uniform(-100, 100, size=("" +
                std::to_string(rows) + "", "" + std::to_string(cols) + "")), \n""
                ""                  columns=['col_' + str(i) for i in range("" + std::to_string(cols) + "")])\n""
                ""# Start timing\n""
                ""start_time = time.time()\n""
                ""result = df - 1.0\n""
                ""elapsed_time = time.time() - start_time\n"";
    }
    else if (operation == ""multiplication"") {
        script += ""# Benchmark DF multiplication (without creation time)\n""
                ""df = pd.DataFrame(np.random.uniform(-100, 100, size=("" +
                std::to_string(rows) + "", "" + std::to_string(cols) + "")), \n""
                ""                  columns=['col_' + str(i) for i in range("" + std::to_string(cols) + "")])\n""
                ""# Start timing\n""
                ""start_time = time.time()\n""
                ""result = df * 2.0\n""
                ""elapsed_time = time.time() - start_time\n"";
    }
    else if (operation == ""division"") {
        script += ""# Benchmark DF division (without creation time)\n""
                ""df = pd.DataFrame(np.random.uniform(-100, 100, size=("" +
                std::to_string(rows) + "", "" + std::to_string(cols) + "")), \n""
                ""                  columns=['col_' + str(i) for i in range("" + std::to_string(cols) + "")])\n""
                ""# Start timing\n""
                ""start_time = time.time()\n""
                ""result = df / 2.0\n""
                ""elapsed_time = time.time() - start_time\n"";
    }
    else if (operation == ""df_addition"") {
        script += ""# Benchmark DataFrame + DataFrame (without creation time)\n""
                ""df1 = pd.DataFrame(np.random.uniform(-100, 100, size=("" +
                std::to_string(rows) + "", "" + std::to_string(cols) + "")), \n""
                ""                  columns=['col_' + str(i) for i in range("" + std::to_string(cols) + "")])\n""
                ""df2 = pd.DataFrame(np.random.uniform(-100, 100, size=("" +
                std::to_string(rows) + "", "" + std::to_string(cols) + "")), \n""
                ""                  columns=['col_' + str(i) for i in range("" + std::to_string(cols) + "")])\n""
                ""# Start timing\n""
                ""start_time = time.time()\n""
                ""result = df1 + df2\n""
                ""elapsed_time = time.time() - start_time\n"";
    }

    script += ""print(f'{elapsed_time:.6f}')\n"";

    // Write script to file
    std::string script_file = ""/tmp/simple_pandas_benchmark.py"";
    FILE* file = fopen(script_file.c_str(), ""w"");
    if (!file) {
        std::cerr << ""Failed to open file: "" << script_file << std::endl;
        return -1.0;
    }
    fputs(script.c_str(), file);
    fclose(file);

    // Make script executable
    std::string chmod_cmd = ""chmod +x "" + script_file;
    if (system(chmod_cmd.c_str()) != 0) {
        std::cerr << ""Failed to make script executable"" << std::endl;
        return -1.0;
    }

    // Run script
    std::string python_path = ""/tmp/epochframe_benchmark_env/bin/python"";
    std::string cmd = python_path + "" "" + script_file + "" 2>&1"";

    FILE* pipe = popen(cmd.c_str(), ""r"");
    if (!pipe) {
        std::cerr << ""Failed to run pandas benchmark script"" << std::endl;
        return -1.0;
    }

    // Read output
    char buffer[256];
    std::string result = """";
    while (!feof(pipe)) {
        if (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
            result += buffer;
        }
    }
    int status = pclose(pipe);

    if (status != 0) {
        std::cerr << ""Pandas benchmark failed with status: "" << status << std::endl;
        std::cerr << ""Output: "" << result << std::endl;
        return -1.0;
    }

    // Try to parse the execution time
    try {
        return std::stod(result);
    } catch (...) {
        std::cerr << ""Failed to parse pandas benchmark result: "" << result << std::endl;
        return -1.0;
    }
}

// Measure execution time of a function
template<typename Func>
double measureExecutionTime(Func&& func) {
    auto start = std::chrono::high_resolution_clock::now();
    func();
    auto end = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double> elapsed = end - start;
    return elapsed.count();
}

// Structure to hold test configuration
struct TestConfig {
    size_t rows;
    size_t cols;

    std::string toString() const {
        return std::to_string(rows) + "" rows × "" + std::to_string(cols) + "" columns"";
    }
};

int main(int argc, char* argv[]) {
    // Define test configurations (varying rows and columns)
    std::vector<TestConfig> testConfigs = {
        {1000, 5},    // Small dataset
        {10000, 5},   // Medium dataset with same columns
        {10000, 20},  // Medium dataset with more columns
        {100000, 5},  // Large dataset with few columns
        {100000, 20},  // Large dataset with more columns
        {10000000, 5},  // XLarge dataset with few columns
        {10000000, 20}  // XLarge dataset with more columns
    };

    // Parse command line arguments for custom configs
    if (argc > 1) {
        testConfigs.clear();

        // Each pair of arguments is a (rows, cols) pair
        for (int i = 1; i < argc - 1; i += 2) {
            if (i + 1 >= argc) break;

            try {
                size_t rows = std::stoul(argv[i]);
                size_t cols = std::stoul(argv[i + 1]);
                testConfigs.push_back({rows, cols});
            } catch (...) {
                std::cerr << ""Warning: Invalid size pair '"" << argv[i] << "", "" << argv[i + 1] << ""', skipping"" << std::endl;
            }
        }
    }

    // Set up Python environment
    bool hasPandas = setupPythonEnvironment();
    // bool hasPandas = false;

    std::cout << ""=== EpochFrame vs Pandas DataFrame Benchmark ==="" << std::endl << std::endl;

    // Run benchmarks for each test configuration
    for (const auto& config : testConfigs) {
        std::cout << ""Testing with "" << config.toString() << "":"" << std::endl;

        // DataFrame Creation
        double efCreateTime = measureExecutionTime([&]() {
            auto df = createRandomDataFrame(config.rows, config.cols);
        });

        double pdCreateTime = 0;
        if (hasPandas) {
            pdCreateTime = runPandasBenchmark(""creation"", config.rows, config.cols);
        }

        std::cout << ""  Creation: "" << std::fixed << std::setprecision(6)
                  << efCreateTime << ""s (EpochFrame)"";
        if (pdCreateTime > 0) {
            std::cout << "", "" << pdCreateTime << ""s (Pandas)"";
            double speedup = pdCreateTime / efCreateTime;
            std::cout << "", "" << std::setprecision(2) << speedup << ""x faster"";
        }
        std::cout << std::endl;

        // DataFrame Addition with scalar
        auto df_add = createRandomDataFrame(config.rows, config.cols);
        double efAddTime = measureExecutionTime([&]() {
            auto result = df_add + efo::Scalar(1.0);
        });

        double pdAddTime = 0;
        if (hasPandas) {
            pdAddTime = runPandasBenchmark(""addition"", config.rows, config.cols);
        }

        std::cout << ""  Addition (scalar): "" << std::fixed << std::setprecision(6)
                  << efAddTime << ""s (EpochFrame)"";
        if (pdAddTime > 0) {
            std::cout << "", "" << pdAddTime << ""s (Pandas)"";
            double speedup = pdAddTime / efAddTime;
            std::cout << "", "" << std::setprecision(2) << speedup << ""x faster"";
        }
        std::cout << std::endl;

        // DataFrame Subtraction with scalar
        auto df_sub = createRandomDataFrame(config.rows, config.cols);
        double efSubTime = measureExecutionTime([&]() {
            auto result = df_sub - efo::Scalar(1.0);
        });

        double pdSubTime = 0;
        if (hasPandas) {
            pdSubTime = runPandasBenchmark(""subtraction"", config.rows, config.cols);
        }

        std::cout << ""  Subtraction (scalar): "" << std::fixed << std::setprecision(6)
                  << efSubTime << ""s (EpochFrame)"";
        if (pdSubTime > 0) {
            std::cout << "", "" << pdSubTime << ""s (Pandas)"";
            double speedup = pdSubTime / efSubTime;
            std::cout << "", "" << std::setprecision(2) << speedup << ""x faster"";
        }
        std::cout << std::endl;

        // DataFrame Multiplication with scalar
        auto df_mul = createRandomDataFrame(config.rows, config.cols);
        double efMulTime = measureExecutionTime([&]() {
            auto result = df_mul * efo::Scalar(2.0);
        });

        double pdMulTime = 0;
        if (hasPandas) {
            pdMulTime = runPandasBenchmark(""multiplication"", config.rows, config.cols);
        }

        std::cout << ""  Multiplication (scalar): "" << std::fixed << std::setprecision(6)
                  << efMulTime << ""s (EpochFrame)"";
        if (pdMulTime > 0) {
            std::cout << "", "" << pdMulTime << ""s (Pandas)"";
            double speedup = pdMulTime / efMulTime;
            std::cout << "", "" << std::setprecision(2) << speedup << ""x faster"";
        }
        std::cout << std::endl;

        // DataFrame Division with scalar
        auto df_div = createRandomDataFrame(config.rows, config.cols);
        double efDivTime = measureExecutionTime([&]() {
            auto result = df_div / efo::Scalar(2.0);
        });

        double pdDivTime = 0;
        if (hasPandas) {
            pdDivTime = runPandasBenchmark(""division"", config.rows, config.cols);
        }

        std::cout << ""  Division (scalar): "" << std::fixed << std::setprecision(6)
                  << efDivTime << ""s (EpochFrame)"";
        if (pdDivTime > 0) {
            std::cout << "", "" << pdDivTime << ""s (Pandas)"";
            double speedup = pdDivTime / efDivTime;
            std::cout << "", "" << std::setprecision(2) << speedup << ""x faster"";
        }
        std::cout << std::endl;

        // DataFrame + DataFrame
        auto df1 = createRandomDataFrame(config.rows, config.cols);
        auto df2 = createRandomDataFrame(config.rows, config.cols);
        double efDfAddTime = measureExecutionTime([&]() {
            auto result = df1 + df2;
        });

        double pdDfAddTime = 0;
        if (hasPandas) {
            pdDfAddTime = runPandasBenchmark(""df_addition"", config.rows, config.cols);
        }

        std::cout << ""  DataFrame + DataFrame: "" << std::fixed << std::setprecision(6)
                  << efDfAddTime << ""s (EpochFrame)"";
        if (pdDfAddTime > 0) {
            std::cout << "", "" << pdDfAddTime << ""s (Pandas)"";
            double speedup = pdDfAddTime / efDfAddTime;
            std::cout << "", "" << std::setprecision(2) << speedup << ""x faster"";
        }
        std::cout << std::endl << std::endl;
    }

    return 0;
}
",fields
993,"#include <fstream>
#include <iostream>
#include <string.h>

#include ""Area.h""

using namespace std;

Area::Area() {
    int  [MASK]  = 0;
    int waterIndex = 0;
    int i;

    float x;
    float z = -100.0f;

    ifstream arch;
    arch.open(""resources/model/area.map"");
    string line;
    while (getline(arch, line)) {
        x = -100.0f;
        for (i = 0; i < 200; i++) {
            if (line[i] == '1') {
                waterVertices.push_back(glm::vec4(x - 0.2f, -1.90f, z - 0.2f, 1.0f));
                waterVertices.push_back(glm::vec4(x + 1.2f, -1.90f, z - 0.2f, 1.0f));
                waterVertices.push_back(glm::vec4(x + 1.2f, -1.90f, z + 1.2f, 1.0f));

                waterVertices.push_back(glm::vec4(x - 0.2f, -1.90f, z - 0.2f, 1.0f));
                waterVertices.push_back(glm::vec4(x + 1.2f, -1.90f, z + 1.2f, 1.0f));
                waterVertices.push_back(glm::vec4(x - 0.2f, -1.90f, z + 1.2f, 1.0f));

                for (int i = 0; i < 6; i++) {
                    waterNormals.push_back(glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
                }

                waterFaces.push_back(glm::uvec3(waterIndex++, waterIndex++, waterIndex++));
                waterFaces.push_back(glm::uvec3(waterIndex++, waterIndex++, waterIndex++));

                if (waterPoints.count(x) == 0) {
                    waterPoints[x] = set<float>();
                }
                
                waterPoints[x].insert(z);
            }
            else if (line[i] == '2') {
                parksVertices.push_back(glm::vec4(x - 0.2f, -1.90f, z - 0.2f, 1.0f));
                parksVertices.push_back(glm::vec4(x + 1.2f, -1.90f, z - 0.2f, 1.0f));
                parksVertices.push_back(glm::vec4(x + 1.2f, -1.90f, z + 1.2f, 1.0f));

                parksVertices.push_back(glm::vec4(x - 0.2f, -1.90f, z - 0.2f, 1.0f));
                parksVertices.push_back(glm::vec4(x + 1.2f, -1.90f, z + 1.2f, 1.0f));
                parksVertices.push_back(glm::vec4(x - 0.2f, -1.90f, z + 1.2f, 1.0f));

                for (int i = 0; i < 6; i++) {
                    parksNormals.push_back(glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
                }

                parksFaces.push_back(glm::uvec3( [MASK] ++,  [MASK] ++,  [MASK] ++));
                parksFaces.push_back(glm::uvec3( [MASK] ++,  [MASK] ++,  [MASK] ++));

                if (parksPoints.count(x) == 0) {
                    parksPoints[x] = set<float>();
                }
                
                parksPoints[x].insert(z);
            }

            x += 1.0f;
        }

        z += 1.0f;
    }
    arch.close();

    arch.open(""resources/model/population.map"");
    z = -100.0f;
    while (getline(arch, line)) {
        x = -100.0f;
        for (i = 0; i < 200; i++) {
            if (line[i] == '1' && waterPoints[x].count(z) == 0 && parksPoints[x].count(z) == 0) {
                populationCenters.push_back(glm::vec2(x, z));
            }
            x += 1.0f;
        }

        z += 1.0f;
    }
    arch.close();
}",parksIndex
994,"/*
 * SPDX-FileCopyrightText: Copyright (c) 2023-2024 NVIDIA CORPORATION &
 * AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0
 *
 * 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 ""utils.hpp""

namespace utils
{

std::string DBusHandler::getService(const char* path,
                                    const char* interface) const
{
    return getServiceMap(path, {interface}).begin()->first;
}

MapperServiceMap
    DBusHandler::getServiceMap(const char* path,
                               const dbus::Interfaces& ifaceList) const
{
    MapperServiceMap mapperResponse;
    auto& bus = DBusHandler::getBus();

    auto mapper = bus.new_method_call(mapperService, mapperPath,
                                      mapperInterface, ""GetObject"");
    mapper.append(path, ifaceList);

    auto  [MASK]  = bus.call(mapper);
     [MASK] .read(mapperResponse);
    return mapperResponse;
}

GetSubTreeResponse
    DBusHandler::getSubtree(const std::string& searchPath, int depth,
                            const dbus::Interfaces& ifaceList) const
{
    auto& bus = utils::DBusHandler::getBus();
    auto method = bus.new_method_call(mapperService, mapperPath,
                                      mapperInterface, ""GetSubTree"");
    method.append(searchPath, depth, ifaceList);
    auto reply = bus.call(method);
    GetSubTreeResponse response;
    reply.read(response);
    return response;
}

void DBusHandler::setDbusProperty(const DBusMapping& dBusMap,
                                  const PropertyValue& value) const
{
    auto setDbusValue = [&dBusMap, this](const auto& variant) {
        auto& bus = getBus();
        auto service = getService(dBusMap.objectPath.c_str(),
                                  dBusMap.interface.c_str());
        auto method = bus.new_method_call(
            service.c_str(), dBusMap.objectPath.c_str(), dbusProperties, ""Set"");
        method.append(dBusMap.interface.c_str(), dBusMap.propertyName.c_str(),
                      variant);
        bus.call_noreply(method);
    };

    if (dBusMap.propertyType == ""uint8_t"")
    {
        std::variant<uint8_t> v = std::get<uint8_t>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""bool"")
    {
        std::variant<bool> v = std::get<bool>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""int16_t"")
    {
        std::variant<int16_t> v = std::get<int16_t>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""uint16_t"")
    {
        std::variant<uint16_t> v = std::get<uint16_t>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""int32_t"")
    {
        std::variant<int32_t> v = std::get<int32_t>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""uint32_t"")
    {
        std::variant<uint32_t> v = std::get<uint32_t>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""int64_t"")
    {
        std::variant<int64_t> v = std::get<int64_t>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""uint64_t"")
    {
        std::variant<uint64_t> v = std::get<uint64_t>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""double"")
    {
        std::variant<double> v = std::get<double>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""string"")
    {
        std::variant<std::string> v = std::get<std::string>(value);
        setDbusValue(v);
    }
    else if (dBusMap.propertyType == ""array[object_path]"")
    {
        std::variant<std::vector<sdbusplus::message::object_path>> v =
            std::get<std::vector<sdbusplus::message::object_path>>(value);
        setDbusValue(v);
    }
    else
    {
        throw std::invalid_argument(""Unsupported Dbus Type"");
    }
}

PropertyValue DBusHandler::getDbusPropertyVariant(
    const char* objPath, const char* dbusProp, const char* dbusInterface) const
{
    auto& bus = DBusHandler::getBus();
    auto service = getService(objPath, dbusInterface);
    auto method = bus.new_method_call(service.c_str(), objPath, dbusProperties,
                                      ""Get"");
    method.append(dbusInterface, dbusProp);
    PropertyValue value{};
    auto reply = bus.call(method);
    reply.read(value);
    return value;
}

PropertyValuesCollection
    DBusHandler::getDbusProperties(const char* objPath,
                                   const char* dbusInterface) const
{
    PropertyValuesCollection properties;
    auto& bus = DBusHandler::getBus();
    auto service = getService(objPath, dbusInterface);
    auto method = bus.new_method_call(service.c_str(), objPath, dbusProperties,
                                      ""GetAll"");
    method.append(dbusInterface);
    auto reply = bus.call(method);
    reply.read(properties);
    return properties;
}

IDBusHandler& DBusHandler()
{
    return DBusHandler::instance();
}

GetAssociatedObjectsResponse
    DBusHandler::getAssociatedObjects(const std::string& path,
                                      const std::string& association) const
{
    auto& bus = utils::DBusHandler::getBus();
    const auto associationPath = path + ""/"" + association;
    auto method = bus.new_method_call(mapperService, associationPath.c_str(),
                                      dbusProperties, ""Get"");
    method.append(""xyz.openbmc_project.Association"", ""endpoints"");
    auto reply = bus.call(method);
    GetAssociatedObjectsResponse response;
    reply.read(response);
    return response;
}

} // namespace utils
",mapperResponseMsg
995,"#include ""Json.h""

static void skip_whitespace(const std::string &data,size_t &i){
    for(char c=data[i];i<data.size()&&((c=data[i]),(c==' '||c=='\t'||c=='\n'||c=='#'));i++){
        if(c=='#')while(i<data.size()&&data[i]!='\n')i++;//comment
    }
}

static inline constexpr char unescape(char c){
    switch(c) {
    case 'a':
        return '\a';
    case 'b':
        return '\b';
    case 't':
        return '\t';
    case 'n':
        return '\n';
    case 'v':
        return '\v';
    case 'f':
        return '\f';
    case 'r':
        return '\r';
    case '\\':
        return '\\';
    case '""':
        return '\""';
    default:
        return c;
    }
}

static std::string readString(const std::string &data,size_t &i){
    if(skip_whitespace(data,i),data[i]!='""'){
        throw std::runtime_error(""Trying to read non-string as string"");
    }
    i++;
    size_t start=i;
    for(;i<data.size()&&(data[i]!='""'||data[i-1]=='\\');i++);
    size_t end=i;
    std::string temp;
    bool reading_escape=false;
    for(size_t j=start;j<end;j++){
        if(reading_escape){
            temp+=unescape(data[j]);
            start=j+1;
            reading_escape=false;
        }else if(data[j]=='\\'){
            temp+=data.substr(start,j-start);
            reading_escape=true;
        }
    }
    if(start!=end){
        temp+=data.substr(start,end-start);
    }
    i++;
    return temp;
}

static std::shared_ptr<Json::JsonElement> getElement(const std::string &data,size_t &i);

static std::shared_ptr<Json::JsonObject> getObject(const std::string &data,size_t &i){
    if(skip_whitespace(data,i),data[i]!='{'){
        return nullptr;
    }
    std::map<std::string,std::shared_ptr<Json::JsonElement>> obj;
    i++;
    while(skip_whitespace(data,i),data[i]!='}'){
        std::string key=readString(data,i);
        skip_whitespace(data,i);
        char c=data[i];
        if(c!=':'){
            throw Json::JsonParseError(""Expected ':' got '""+std::string(1,data[i])+""'"");
        }
        i++;
        obj[key]=getElement(data,i);
        if(skip_whitespace(data,i),data[i]!=','){
            if(data[i]=='}')break;
            throw Json::JsonParseError(""Expected ',' got '""+std::string(1,data[i])+""'"");
        }
        i++;
    }
    i++;
    return std::make_shared<Json::JsonObject>(obj);
}

static std::shared_ptr<Json::JsonArray> getArray(const std::string &data,size_t &i){
    if(skip_whitespace(data,i),data[i]!='['){
        return nullptr;
    }
    std::vector<std::shared_ptr<Json::JsonElement>> arr;
    i++;
    while(skip_whitespace(data,i),data[i]!=']'){
        arr.push_back(getElement(data,i));
        if(skip_whitespace(data,i),data[i]!=','){
            if(data[i]==']')break;
            throw Json::JsonParseError(""Expected ',' got '""+std::string(1,data[i])+""'"");
        }
        i++;
    }
    i++;
    return std::make_shared<Json::JsonArray>(arr);
}

static inline unsigned int ipow(unsigned int  [MASK] ,unsigned int exp){
    unsigned int val=1;
    while(exp-->0){
        val*= [MASK] ;
    }
    return val;
}

static std::shared_ptr<Json::JsonElement> getLiteral(const std::string &data,size_t &i){
    if(skip_whitespace(data,i),data[i]=='""'){//read string
        return std::make_shared<Json::JsonString>(readString(data,i));
    }else{
        if((data[i]>='0'&&data[i]<='9')||data[i]=='.'||data[i]=='-'){
            int num=0;
            int dec=0;
            int dec_len=0;
            bool is_float=false;
            bool is_negative=false;
            if(data[i]=='-'){
                is_negative=true;
                i++;
            }
            while(i<data.size()){
                if(data[i]>='0'&&data[i]<='9'){
                    if(is_float){
                        dec_len++;
                        dec*=10;
                        dec+=data[i]-'0';
                    }else{
                        num*=10;
                        num+=data[i]-'0';
                    }
                }else if(!is_float&&data[i]=='.'){
                    is_float=true;
                }else{
                    break;
                }
                i++;
            }
            if(is_float){
                double d=num+(double(dec)/ipow(10,dec_len));
                return std::make_shared<Json::JsonFloat>(is_negative?-d:d);
            }else{
                return std::make_shared<Json::JsonInteger>(is_negative?-num:num);
            }
        }else if(data[i]=='n'&&data[i+1]=='u'&&data[i+2]=='l'&&data[i+3]=='l'){
            i+=4;
            return std::make_shared<Json::JsonNull>();
        }else if(data[i]=='t'&&data[i+1]=='r'&&data[i+2]=='u'&&data[i+3]=='e'){
            i+=4;
            return std::make_shared<Json::JsonTrue>();
        }else if(data[i]=='f'&&data[i+1]=='a'&&data[i+2]=='l'&&data[i+3]=='s'&&data[i+4]=='e'){
            i+=5;
            return std::make_shared<Json::JsonFalse>();
        }
    }
    return nullptr;
}

static std::shared_ptr<Json::JsonElement> getElement(const std::string &data,size_t &i){
    std::shared_ptr<Json::JsonElement> e=std::static_pointer_cast<Json::JsonElement>(getObject(data,i));
    if(!e){
        e=std::static_pointer_cast<Json::JsonElement>(getArray(data,i));
        if(!e){
            e=getLiteral(data,i);
            if(!e){
                throw Json::JsonParseError(""Invalid Json"");
            }
        }
    }
    return e;
}

Json::JsonParseError::JsonParseError(const std::string& error):runtime_error(""Error while parsing Json: ""+error){}

std::shared_ptr<Json::JsonElement> Json::parse(const std::string &data){
    size_t i=0;
    return getElement(data,i);
}

Json::JsonObject::JsonObject(const std::map<std::string,std::shared_ptr<JsonElement>> &obj):map(obj){
}

bool Json::JsonObject::has_key(std::string key){
    return find(key)!=end();
}

Json::JsonElementType Json::JsonObject::getType(){
    return JsonElementType::OBJECT;
}

Json::JsonArray::JsonArray(const std::vector<std::shared_ptr<JsonElement>> &arr):vector(arr){
}

Json::JsonElementType Json::JsonArray::getType(){
    return JsonElementType::ARRAY;
}

Json::JsonInteger::JsonInteger(int i2):i(i2){
}

Json::JsonElementType Json::JsonInteger::getType(){
    return JsonElementType::INTEGER;
}

Json::JsonFloat::JsonFloat(double f2):f(f2){
}

Json::JsonElementType Json::JsonFloat::getType(){
    return JsonElementType::FLOAT;
}

Json::JsonString::JsonString(const std::string &s2):s(s2){
}

Json::JsonElementType Json::JsonString::getType(){
    return JsonElementType::STRING;
}

Json::JsonElementType Json::JsonTrue::getType(){
    return JsonElementType::JSON_TRUE;
}

Json::JsonElementType Json::JsonFalse::getType(){
    return JsonElementType::JSON_FALSE;
}

Json::JsonElementType Json::JsonNull::getType(){
    return JsonElementType::JSON_NULL;
}



",base
996,"#include ""string""
#include ""ros/ros.h""
#include ""serial/serial.h""
#include ""oroca_ros_tutorials/MsgTutorial.h""
#include ""oroca_ros_tutorials/Header.h""
#include ""std_msgs/Float64.h""
#include ""std_msgs/String.h""
//#include <tf/transform_broadcaster.h>
//#include <tf/LinearMath/Quaternion.h>


// void poseCallback(tf::pose& msg)
// {   tf::Quaternion q;
//     tf::TransformBroadcaster broadcaster;
//     tf::Transform transform;
//     transform.setOrigin( tf::Vector3(msg->x, msg->y, msg->z) );
//     q.setRPY(3.1402, -1.5708, 1.5722);
//     transform.setRotation(q);

//     broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0,0,0.065406)), ros::Time::now(), ""base_link"",""Link1""));
//     //broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(q),tf::Vector3(0.029687, -0.022, 0.061593)), ros::Time::now(), ""Link1"",""Link2""));
//     ROS_INFO(""sendTransform"");

// }

int main(int argc, char **argv)
{
ros::init(argc, argv, ""topic_pub"");
ros::NodeHandle nh;
ros::Publisher ros_tutorial_pub = nh.advertise<oroca_ros_tutorials::MsgTutorial>(""topic_msg"", 100);
//ros::Subscriber sub = nh.subscribe(""pose"",100,&poseCallback);
//tf::Transform transform;

ros::Rate loop_rate(10);

double joint1=0, joint2=0, joint3=0, joint4=0, joint5=0, joint6=0, angle=0;


//geometry_msgs::TransformStamped odom_trans;
//geometry_msgs::Quaternion quaternion;
oroca_ros_tutorials::MsgTutorial topic_msg;

std::string robot_description_string;
nh.param(""robot_description"",robot_description_string, std::string());

std::vector<std::string>  [MASK]  = {""joint1"",""joint2"",""joint3"",""joint4"",""joint5"",""joint6""}; //각 joint의 이름
std::vector<double> joint = {joint1,joint2,joint3,joint4,joint5,joint6}; //각 joint의 position 값

int count = 0;

/* tf::Quaternion q;
tf::TransformBroadcaster broadcaster;
tf::Transform transform; */

//broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0,0,0.065406)), ros::Time::now(), ""base_link"",""Link1""));
//broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0.029687, -0.022, 0.061593)), ros::Time::now(), ""Link1"",""Link2""));


while (ros::ok())
{
    // broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0,0,0.065406)), ros::Time::now(), ""base_link"",""Link1""));
    // broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0.029687, -0.022, 0.061593)), ros::Time::now(), ""Link1"",""Link2""));
    //broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0.029687, -0.022, 0.061593)), ros::Time::now(), ""Link2"",""Link3""));
    //broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0.029687, -0.022, 0.061593)), ros::Time::now(), ""Link3"",""Link4""));
    //broadcaster.sendTransform(tf::StampedTransform(tf::Transform(tf::Quaternion(0,0,0,1),tf::Vector3(0.029687, -0.022, 0.061593)), ros::Time::now(), ""Link4"",""Link5""));

// // transform.rotation=quaternion.Euler(tf::Vector3(0,0,0.065406));
// // broadcaster.sendTransform(tf::StampedTransform(transform, ros::Time::now(), ""dummy"",""base_link""));


// // broadcaster.sendTransform(tf::StampedTransform(transform, ros::Time::now(), ""Link2"",""Link3""));
// // broadcaster.sendTransform(tf::StampedTransform(transform, ros::Time::now(), ""Link3"",""Link4""));
// // broadcaster.sendTransform(tf::StampedTransform(transform, ros::Time::now(), ""Link4"",""Link5""));
// // broadcaster.sendTransform(tf::StampedTransform(transform, ros::Time::now(), ""Link5"",""Link6""));

    count += 0.001;

topic_msg.stamp = ros::Time::now();
topic_msg.seq = count;
topic_msg.name.resize(6); //topic_msg의 name값 4개로 확장
topic_msg.position.resize(6); //topic_msg의 position값 6개로 확장

// odom_trans.header.stamp = ros::Time::now();
// odom_trans.transform.translation.x = cos(angle);
// odom_trans.transform.translation.y = sin(angle);
// odom_trans.transform.translation.z = .7;
// odom_trans.transform.rotation = tf::createQuaternionMsgFromYaw(angle+M_PI/2);

//angle+=5;

for (int k=0; k<6; k++)
{
    topic_msg.name[k] =  [MASK] [k];
    topic_msg.position[k]=joint[k];
}
ROS_INFO(""sec = %d"", topic_msg.stamp.sec);
ROS_INFO(""nsec = %d"", topic_msg.stamp.nsec);
ROS_INFO(""seq = %d"", topic_msg.seq);
ros_tutorial_pub.publish(topic_msg);
//broadcaster.sendTransform(odom_trans);
loop_rate.sleep();
++count;
}
//return 0;
}",joint_name
997,"/*
 * CascadeEvent.cpp
 *
 *  Created on: May 6, 2015
 *
 * Author: <EMAIL>
 *
 * Copyright 2014 IMDEA Materials Institute, Getafe, Madrid, Spain
 *
 * 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 ""CascadeEvent.h""
#include ""domains/MCClient.h""
#include ""io/Diagnostic.h""
#include ""io/ParameterManager.h""
#include ""kernel/Mesh.h""
#include ""kernel/SubDomain.h""
#include ""kernel/Analyzer.h""
#include <sstream>

using std::string;
using std::vector;
using std::stringstream;
using std::map;

namespace Cascade {

CascadeEvent::CascadeEvent(Kernel::Domain *pD, const std::vector<std::string> &f,
		bool bReact, bool periodic, bool voluminic, bool bDisplace, bool bCorrectX,
		const std::string &fileName, float rate)  :
				Event(pD), _format(f), _bReact(bReact), _periodic(periodic), _voluminic(voluminic),
				_bDisplace(bDisplace), _bCorrectX(bCorrectX), _rate(rate)
{
	_pist.open(fileName.c_str());
	if(_pist.fail())
		ERRORMSG(""cascade: file "" << fileName << "" not found"");

	//Algorithm to store the random positions within the file. It assumes that the first line of every cascade starts with a # New cascade
	//It works if there are some headers. The only condition is that every line which has only one number, n,
	//(no matter if it is surrounded by spaces or tabs) and the rest lines of that cascade are OK.

	bool bFormat = false;
	unsigned position = 0;
	string theLine;
	getline(_pist, theLine);
	if(theLine == ""# New cascade"")
	{
		_startPos.push_back(position);
		do
		{
			position = _pist.tellg();
			getline(_pist, theLine);
			if(theLine == ""# New cascade"")
				_startPos.push_back(position);
		} while(!_pist.eof());
	}
	else
		do
		{
			_startPos.push_back(position);
			stringstream ss;
			unsigned numberOf;
			ss << theLine;
			ss >> numberOf;
			while(numberOf--)
			{
				getline(_pist,theLine);
				if(_pist.eof())
					ERRORMSG(""Error in cascade file. Format 'Number of particles' seems to be wrong. Unexpected end of file"");
			}
			bFormat = true;
			do
			{
				position = _pist.tellg();
				getline(_pist, theLine);
			} while(theLine.empty() && _pist.eof() == false);
		} while(!_pist.eof());

	LOWMSG(_startPos.size() << "" cascades detected. Format detected is "" << (bFormat? ""Number of particles"":""'# New cascade' tag.""));
	if(_startPos.empty())
		ERRORMSG(""File "" << fileName << "" contains no cascades. Are the new cascades being started with '# New cascade' or the number of particles?"");
	_cPos = _startPos;
}

CascadeEvent::~CascadeEvent()
{
	_pist.close();
}

void CascadeEvent::perform(Kernel::SubDomain *p, unsigned)
{
	p->_evLog.performed(0, Kernel::Event::CASCADE, 0, 0, 0, 0);
	string firstLine;
	stringstream firstBuffer;

	Kernel::Mesh *pMesh = p->_pDomain->_pMesh;
	Kernel::Coordinates m,M;
	pMesh->getDomain(m,M);
	float x=0, y=0, z=0;
	unsigned  [MASK]  = p->_rng.rand()*_startPos.size();
	assert( [MASK]  < _startPos.size());
	if(_pist.eof())
		_pist.clear();

	_pist.seekg(_startPos[ [MASK] ],_pist.beg);
	getline(_pist,firstLine);
	firstBuffer << firstLine;
	unsigned numberOfParticles = 0;
	if(firstLine != ""# New cascade"")	//format number of particles
	{
		stringstream ss;
		ss << firstLine;
		ss >> numberOfParticles;
	}

	if(_voluminic)
		x = m._x + p->_rng.rand()*(M._x - m._x);
	if(_bDisplace)
	{
		y = m._y + p->_rng.rand()*(M._y - m._y);
		z = m._z + p->_rng.rand()*(M._z - m._z);
	}
	if(_bCorrectX)
	{
		Kernel::Coordinates cell, Cell;
		double minX = M._x;
		for(Kernel::Mesh::iterator mi =pMesh->begin(); mi != pMesh->end(); ++mi)
		{
			mi->getCorners(cell, Cell);
			if(cell._y < y && Cell._y > y && cell._z < z && Cell._z > z)
				if(!Domains::global()->PM()->isGasLike(mi->getMaterial()) && cell._x < minX)
					minX = cell._x;
		}
		x = minX;
	}

	//for each particle in the cascade
	unsigned howMany = 0;
	while(true)
	{
		string line;
		stringstream buffer;
		vector<string> fieldsInFile;
		getline(_pist, line);
		if(_pist.eof() ||
		    line == ""# New cascade"" ||
		    (firstLine != ""# New cascade"" && numberOfParticles == 0) ||
		    (numberOfParticles && numberOfParticles == howMany))
			break;
		howMany++;
		buffer << line;
		do
		{
			string token;
			buffer >> token;
			fieldsInFile.push_back(token);
		} while(!buffer.eof());
		if(buffer.fail())
			fieldsInFile.pop_back();
		if(fieldsInFile.size() == 0)
			ERRORMSG(""Wrong cascade number "" <<  [MASK]  << "". Header says "" << firstLine);
		create(pMesh, x, y, z, _format, fieldsInFile, m, M, _bReact, _periodic, _voluminic);
	}
	if(howMany == 0)
		WARNINGMSG(""Empty cascades are present."");
	//removing the cascade position, so it is not repeated.
	if(_startPos.size() > 1)
	{
		_startPos[ [MASK] ] = _startPos.back();
		_startPos.pop_back();
	}
	else
		_startPos = _cPos;
}

/* Format are 4 strings, each of them containing the format of:
 * 	1-> Point Defect
 * 	2, 3, 4 -> x,y,z
 * fileLine is an array of strings in one file line
 *
 * The function has to transform the first format in the particle type, generate variables for each column
 * in filename, and evaluate the 2nd, 3rd and 4th format
 */
void CascadeEvent::create(Kernel::Mesh *pMesh,
		float impactx, float impacty, float impactz,
		const vector<string> &format, const vector<string> &fileLine,
		const Kernel::Coordinates &m, const Kernel::Coordinates &M,
		bool bReact, bool periodic, bool voluminic)
{
	unsigned typeColumn = format[0][0] - 'A';
	//create variable map
	map<string, double> variableMap;
	for(unsigned column = 0; column < fileLine.size(); ++column)
	{
		string varName = ""A"";
		varName[0] += column;
		variableMap[varName] = atof(fileLine[column].c_str());
		HIGHMSG(varName << "" = "" << atof(fileLine[column].c_str()) << ""; "");
	}

	Kernel::Analyzer<double> xAnalyzer(format[1]);
	double x = xAnalyzer(variableMap);
	Kernel::Analyzer<double> yAnalyzer(format[2]);
	Kernel::Analyzer<double> zAnalyzer(format[3]);
	double y = yAnalyzer(variableMap);
	double z = zAnalyzer(variableMap);

	x += impactx;
	y += impacty;
	z += impactz;

	if(periodic)
	{
		float sizeY = M._y - m._y;
		float sizeZ = M._z - m._z;
		while(y >= M._y) y -= sizeY;
		while(y <  m._y) y += sizeY;
		while(z >= M._z) z -= sizeZ;
		while(z <  m._z) z += sizeZ;
		if(voluminic)
		{
			float sizeX = M._x - m._x;
			while(x >= M._x) x -= sizeX;
			while(x <  m._x) x += sizeX;
		}
	}

	Kernel::Coordinates c(x, y, z);
	if(c.isInto(m, M))
	{
		unsigned index = pMesh->getIndexFromCoordinates(c);
		Kernel::M_TYPE mt = pMesh->getElement(index)->getMaterial();
		if(Domains::global()->PM()->getMaterial(mt)._bAmorphous )
			if(fileLine[typeColumn] == ""I"" || fileLine[typeColumn] == ""V"" )
				pMesh->getElement(index)->incrAmorphParts();

		const string name = fileLine[typeColumn];
		Kernel::Event::E_TYPE et = Domains::global()->PM()->getDefectType(name, mt);
		switch(et)
		{
		case Kernel::Event::MOBILEPARTICLE:
			Domains::global()->client()->createMP(name, """", c, bReact);
			break;
		default:
		  {
			vector<string> tokens;
			IO::ParameterManager::getTokens(name, ':', tokens);
			if(tokens.size() != 2 || Domains::global()->PM()->getDefectType(tokens[1], mt) != Kernel::Event::CLUSTER)
			{
				WARNINGMSG(""Cannot recognize "" << name << "" as a cluster. ':' expected!"");
				return;
			}
			Domains::global()->client()->createMC(tokens[1], tokens[0], c);
		  }
		}
	}
	else //be sure it is out!
		Domains::global()->client()->createMP(fileLine[typeColumn],"""", Kernel::Coordinates(1e19,1e19,1e19), bReact);
}


} /* namespace Cascade */
",randomPos
998,"#include <array>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <random>
#include <limits>

#include ""transit_density.hpp""

static double eps = 1000.0*std::numeric_limits<double>::epsilon();

static std::mt19937_64 rng;
static std::uniform_int_distribution<uint64_t> uint_dist;
double urand() {
  return (double) uint_dist(rng)/UINT64_MAX;
}

int main() {

  constexpr auto nsamples = 1e9;

  constexpr auto L   = 2.0;
  constexpr auto lam = 1.0;
  constexpr auto mu  = 2.0;

  constexpr auto  [MASK]  = 2.0/3.0;

/*
  auto psi1 = []( const double x ){
    const auto z = 2.0*sqrt(lam*mu*x*(L-x));
    return exp(-lam*x - mu*(L-x))
         * ( lam*std::cyl_bessel_i(0,z) + sqrt(lam*mu*x/(L-x))*bessi1(z) );
  };
  auto psi2 = []( const double x ){
    const auto z = 2.0*sqrt(lam*mu*x*(L-x));
    return exp(-lam*x - mu*(L-x))
         * ( mu*bessi0(z) + sqrt(lam*mu*(L-x)/x)*bessi1(z) );
  };
*/

  constexpr std::array< double, 2 > r = { lam, mu };

  constexpr auto nbins = 100;
  std::array< double, nbins > t1;
  t1.fill( 0.0 );

  auto fA = 0.0;
  auto fB = 0.0;

  for ( auto sample = 0; sample < nsamples ; ++sample ) {
    auto t = 0.0;
    auto x = 0.0;
    auto k = urand() <  [MASK]  ? 0 : 1;
    auto m = 0;

    while ( x < L ) {
      auto s = -log(urand())/r[k];
      s = x + s < L ? s : L-x;
      x += s + eps;

      if ( k == 0 ) { t += s; }

      k = (k+1) % 2;
      ++m;
    }
    k = floor( t/L * nbins );
    if ( m == 1 ) {
      if ( k == 0 ) fA += 1.0;
      else          fB += 1.0;
    }
    if ( k < nbins && m > 1 ) { t1[k] += 1.0; }
  }

  constexpr auto dx = L/nbins;
  auto x = 0.5*dx;
  for ( auto i = 0 ; i < nbins ; ++i ) {
    const auto calc = t1[i]/nsamples;
    const auto ref = transit_density( x, L, lam, mu,  [MASK]  );
    std::cout << std::fixed << std::right << std::setw(5) << std::setprecision(2) << x << ""  ""
      << std::setw(10) << std::setprecision(6) << ref << ""   "" 
      << calc/dx << "" +/- "" << std::scientific << std::sqrt( calc * ( 1 - calc ) / nsamples )/dx << ""   "" 
      << std::scientific << ( calc/dx - ref ) << '\n';
    x += dx;
  }
  fA /= nsamples; fB /= nsamples;
  std::cout << '\n' << ( 1 -  [MASK]  ) * std::exp(-mu* L) << ""   "" << fA << "" +/- "" << std::scientific << std::sqrt( fA*(1-fA)/nsamples ) 
            << '\n' <<  [MASK]          * std::exp(-lam*L) << ""   "" << fB << "" +/- "" << std::scientific << std::sqrt( fB*(1-fB)/nsamples ) << '\n';
  return 0;
}
",omega
999,"//===-- ARMBaseInstrInfo.cpp - ARM Instruction Information ----------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the Base ARM implementation of the TargetInstrInfo class.
//
//===----------------------------------------------------------------------===//

#include ""ARM.h""
#include ""ARMBaseInstrInfo.h""
#include ""ARMBaseRegisterInfo.h""
#include ""ARMConstantPoolValue.h""
#include ""ARMFeatures.h""
#include ""ARMHazardRecognizer.h""
#include ""ARMMachineFunctionInfo.h""
#include ""MCTargetDesc/ARMAddressingModes.h""
#include ""llvm/ADT/STLExtras.h""
#include ""llvm/CodeGen/LiveVariables.h""
#include ""llvm/CodeGen/MachineConstantPool.h""
#include ""llvm/CodeGen/MachineFrameInfo.h""
#include ""llvm/CodeGen/MachineInstrBuilder.h""
#include ""llvm/CodeGen/MachineJumpTableInfo.h""
#include ""llvm/CodeGen/MachineMemOperand.h""
#include ""llvm/CodeGen/MachineRegisterInfo.h""
#include ""llvm/CodeGen/SelectionDAGNodes.h""
#include ""llvm/CodeGen/TargetSchedule.h""
#include ""llvm/IR/Constants.h""
#include ""llvm/IR/Function.h""
#include ""llvm/IR/GlobalValue.h""
#include ""llvm/MC/MCAsmInfo.h""
#include ""llvm/MC/MCExpr.h""
#include ""llvm/Support/BranchProbability.h""
#include ""llvm/Support/CommandLine.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/Support/ErrorHandling.h""
#include ""llvm/Support/raw_ostream.h""

using namespace llvm;

#define DEBUG_TYPE ""arm-instrinfo""

#define GET_INSTRINFO_CTOR_DTOR
#include ""ARMGenInstrInfo.inc""

static cl::opt<bool>
EnableARM3Addr(""enable-arm-3-addr-conv"", cl::Hidden,
               cl::desc(""Enable ARM 2-addr to 3-addr conv""));

static cl::opt<bool>
WidenVMOVS(""widen-vmovs"", cl::Hidden, cl::init(true),
           cl::desc(""Widen ARM vmovs to vmovd when possible""));

static cl::opt<unsigned>
SwiftPartialUpdateClearance(""swift-partial-update-clearance"",
     cl::Hidden, cl::init(12),
     cl::desc(""Clearance before partial register updates""));

/// ARM_MLxEntry - Record information about MLA / MLS instructions.
struct ARM_MLxEntry {
  uint16_t MLxOpc;     // MLA / MLS opcode
  uint16_t MulOpc;     // Expanded multiplication opcode
  uint16_t AddSubOpc;  // Expanded add / sub opcode
  bool NegAcc;         // True if the acc is negated before the add / sub.
  bool HasLane;        // True if instruction has an extra ""lane"" operand.
};

static const ARM_MLxEntry ARM_MLxTable[] = {
  // MLxOpc,          MulOpc,           AddSubOpc,       NegAcc, HasLane
  // fp scalar ops
  { ARM::VMLAS,       ARM::VMULS,       ARM::VADDS,      false,  false },
  { ARM::VMLSS,       ARM::VMULS,       ARM::VSUBS,      false,  false },
  { ARM::VMLAD,       ARM::VMULD,       ARM::VADDD,      false,  false },
  { ARM::VMLSD,       ARM::VMULD,       ARM::VSUBD,      false,  false },
  { ARM::VNMLAS,      ARM::VNMULS,      ARM::VSUBS,      true,   false },
  { ARM::VNMLSS,      ARM::VMULS,       ARM::VSUBS,      true,   false },
  { ARM::VNMLAD,      ARM::VNMULD,      ARM::VSUBD,      true,   false },
  { ARM::VNMLSD,      ARM::VMULD,       ARM::VSUBD,      true,   false },

  // fp SIMD ops
  { ARM::VMLAfd,      ARM::VMULfd,      ARM::VADDfd,     false,  false },
  { ARM::VMLSfd,      ARM::VMULfd,      ARM::VSUBfd,     false,  false },
  { ARM::VMLAfq,      ARM::VMULfq,      ARM::VADDfq,     false,  false },
  { ARM::VMLSfq,      ARM::VMULfq,      ARM::VSUBfq,     false,  false },
  { ARM::VMLAslfd,    ARM::VMULslfd,    ARM::VADDfd,     false,  true  },
  { ARM::VMLSslfd,    ARM::VMULslfd,    ARM::VSUBfd,     false,  true  },
  { ARM::VMLAslfq,    ARM::VMULslfq,    ARM::VADDfq,     false,  true  },
  { ARM::VMLSslfq,    ARM::VMULslfq,    ARM::VSUBfq,     false,  true  },
};

ARMBaseInstrInfo::ARMBaseInstrInfo(const ARMSubtarget& STI)
  : ARMGenInstrInfo(ARM::ADJCALLSTACKDOWN, ARM::ADJCALLSTACKUP),
    Subtarget(STI) {
  for (unsigned i = 0, e = array_lengthof(ARM_MLxTable); i != e; ++i) {
    if (!MLxEntryMap.insert(std::make_pair(ARM_MLxTable[i].MLxOpc, i)).second)
      llvm_unreachable(""Duplicated entries?"");
    MLxHazardOpcodes.insert(ARM_MLxTable[i].AddSubOpc);
    MLxHazardOpcodes.insert(ARM_MLxTable[i].MulOpc);
  }
}

// Use a ScoreboardHazardRecognizer for prepass ARM scheduling. TargetInstrImpl
// currently defaults to no prepass hazard recognizer.
ScheduleHazardRecognizer *
ARMBaseInstrInfo::CreateTargetHazardRecognizer(const TargetSubtargetInfo *STI,
                                               const ScheduleDAG *DAG) const {
  if (usePreRAHazardRecognizer()) {
    const InstrItineraryData *II =
        static_cast<const ARMSubtarget *>(STI)->getInstrItineraryData();
    return new ScoreboardHazardRecognizer(II, DAG, ""pre-RA-sched"");
  }
  return TargetInstrInfo::CreateTargetHazardRecognizer(STI, DAG);
}

ScheduleHazardRecognizer *ARMBaseInstrInfo::
CreateTargetPostRAHazardRecognizer(const InstrItineraryData *II,
                                   const ScheduleDAG *DAG) const {
  if (Subtarget.isThumb2() || Subtarget.hasVFP2())
    return (ScheduleHazardRecognizer *)new ARMHazardRecognizer(II, DAG);
  return TargetInstrInfo::CreateTargetPostRAHazardRecognizer(II, DAG);
}

MachineInstr *
ARMBaseInstrInfo::convertToThreeAddress(MachineFunction::iterator &MFI,
                                        MachineBasicBlock::iterator &MBBI,
                                        LiveVariables *LV) const {
  // FIXME: Thumb2 support.

  if (!EnableARM3Addr)
    return nullptr;

  MachineInstr *MI = MBBI;
  MachineFunction &MF = *MI->getParent()->getParent();
  uint64_t TSFlags = MI->getDesc().TSFlags;
  bool isPre = false;
  switch ((TSFlags & ARMII::IndexModeMask) >> ARMII::IndexModeShift) {
  default: return nullptr;
  case ARMII::IndexModePre:
    isPre = true;
    break;
  case ARMII::IndexModePost:
    break;
  }

  // Try splitting an indexed load/store to an un-indexed one plus an add/sub
  // operation.
  unsigned MemOpc = getUnindexedOpcode(MI->getOpcode());
  if (MemOpc == 0)
    return nullptr;

  MachineInstr *UpdateMI = nullptr;
  MachineInstr *MemMI = nullptr;
  unsigned AddrMode = (TSFlags & ARMII::AddrModeMask);
  const MCInstrDesc &MCID = MI->getDesc();
  unsigned NumOps = MCID.getNumOperands();
  bool isLoad = !MI->mayStore();
  const MachineOperand &WB = isLoad ? MI->getOperand(1) : MI->getOperand(0);
  const MachineOperand &Base = MI->getOperand(2);
  const MachineOperand &Offset = MI->getOperand(NumOps-3);
  unsigned WBReg = WB.getReg();
  unsigned BaseReg = Base.getReg();
  unsigned OffReg = Offset.getReg();
  unsigned OffImm = MI->getOperand(NumOps-2).getImm();
  ARMCC::CondCodes Pred = (ARMCC::CondCodes)MI->getOperand(NumOps-1).getImm();
  switch (AddrMode) {
  default: llvm_unreachable(""Unknown indexed op!"");
  case ARMII::AddrMode2: {
    bool isSub = ARM_AM::getAM2Op(OffImm) == ARM_AM::sub;
    unsigned Amt = ARM_AM::getAM2Offset(OffImm);
    if (OffReg == 0) {
      if (ARM_AM::getSOImmVal(Amt) == -1)
        // Can't encode it in a so_imm operand. This transformation will
        // add more than 1 instruction. Abandon!
        return nullptr;
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBri : ARM::ADDri), WBReg)
        .addReg(BaseReg).addImm(Amt)
        .addImm(Pred).addReg(0).addReg(0);
    } else if (Amt != 0) {
      ARM_AM::ShiftOpc ShOpc = ARM_AM::getAM2ShiftOpc(OffImm);
      unsigned SOOpc = ARM_AM::getSORegOpc(ShOpc, Amt);
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrsi : ARM::ADDrsi), WBReg)
        .addReg(BaseReg).addReg(OffReg).addReg(0).addImm(SOOpc)
        .addImm(Pred).addReg(0).addReg(0);
    } else
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrr : ARM::ADDrr), WBReg)
        .addReg(BaseReg).addReg(OffReg)
        .addImm(Pred).addReg(0).addReg(0);
    break;
  }
  case ARMII::AddrMode3 : {
    bool isSub = ARM_AM::getAM3Op(OffImm) == ARM_AM::sub;
    unsigned Amt = ARM_AM::getAM3Offset(OffImm);
    if (OffReg == 0)
      // Immediate is 8-bits. It's guaranteed to fit in a so_imm operand.
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBri : ARM::ADDri), WBReg)
        .addReg(BaseReg).addImm(Amt)
        .addImm(Pred).addReg(0).addReg(0);
    else
      UpdateMI = BuildMI(MF, MI->getDebugLoc(),
                         get(isSub ? ARM::SUBrr : ARM::ADDrr), WBReg)
        .addReg(BaseReg).addReg(OffReg)
        .addImm(Pred).addReg(0).addReg(0);
    break;
  }
  }

  std::vector<MachineInstr*> NewMIs;
  if (isPre) {
    if (isLoad)
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc), MI->getOperand(0).getReg())
        .addReg(WBReg).addImm(0).addImm(Pred);
    else
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc)).addReg(MI->getOperand(1).getReg())
        .addReg(WBReg).addReg(0).addImm(0).addImm(Pred);
    NewMIs.push_back(MemMI);
    NewMIs.push_back(UpdateMI);
  } else {
    if (isLoad)
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc), MI->getOperand(0).getReg())
        .addReg(BaseReg).addImm(0).addImm(Pred);
    else
      MemMI = BuildMI(MF, MI->getDebugLoc(),
                      get(MemOpc)).addReg(MI->getOperand(1).getReg())
        .addReg(BaseReg).addReg(0).addImm(0).addImm(Pred);
    if (WB.isDead())
      UpdateMI->getOperand(0).setIsDead();
    NewMIs.push_back(UpdateMI);
    NewMIs.push_back(MemMI);
  }

  // Transfer LiveVariables states, kill / dead info.
  if (LV) {
    for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
      MachineOperand &MO = MI->getOperand(i);
      if (MO.isReg() && TargetRegisterInfo::isVirtualRegister(MO.getReg())) {
        unsigned Reg = MO.getReg();

        LiveVariables::VarInfo &VI = LV->getVarInfo(Reg);
        if (MO.isDef()) {
          MachineInstr *NewMI = (Reg == WBReg) ? UpdateMI : MemMI;
          if (MO.isDead())
            LV->addVirtualRegisterDead(Reg, NewMI);
        }
        if (MO.isUse() && MO.isKill()) {
          for (unsigned j = 0; j < 2; ++j) {
            // Look at the two new MI's in reverse order.
            MachineInstr *NewMI = NewMIs[j];
            if (!NewMI->readsRegister(Reg))
              continue;
            LV->addVirtualRegisterKilled(Reg, NewMI);
            if (VI.removeKill(MI))
              VI.Kills.push_back(NewMI);
            break;
          }
        }
      }
    }
  }

  MFI->insert(MBBI, NewMIs[1]);
  MFI->insert(MBBI, NewMIs[0]);
  return NewMIs[0];
}

// Branch analysis.
bool
ARMBaseInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
                                MachineBasicBlock *&FBB,
                                SmallVectorImpl<MachineOperand> &Cond,
                                bool AllowModify) const {
  TBB = nullptr;
  FBB = nullptr;

  MachineBasicBlock::iterator I = MBB.end();
  if (I == MBB.begin())
    return false; // Empty blocks are easy.
  --I;

  // Walk backwards from the end of the basic block until the branch is
  // analyzed or we give up.
  while (isPredicated(I) || I->isTerminator() || I->isDebugValue()) {

    // Flag to be raised on unanalyzeable instructions. This is useful in cases
    // where we want to clean up on the end of the basic block before we bail
    // out.
    bool CantAnalyze = false;

    // Skip over DEBUG values and predicated nonterminators.
    while (I->isDebugValue() || !I->isTerminator()) {
      if (I == MBB.begin())
        return false;
      --I;
    }

    if (isIndirectBranchOpcode(I->getOpcode()) ||
        isJumpTableBranchOpcode(I->getOpcode())) {
      // Indirect branches and jump tables can't be analyzed, but we still want
      // to clean up any instructions at the tail of the basic block.
      CantAnalyze = true;
    } else if (isUncondBranchOpcode(I->getOpcode())) {
      TBB = I->getOperand(0).getMBB();
    } else if (isCondBranchOpcode(I->getOpcode())) {
      // Bail out if we encounter multiple conditional branches.
      if (!Cond.empty())
        return true;

      assert(!FBB && ""FBB should have been null."");
      FBB = TBB;
      TBB = I->getOperand(0).getMBB();
      Cond.push_back(I->getOperand(1));
      Cond.push_back(I->getOperand(2));
    } else if (I->isReturn()) {
      // Returns can't be analyzed, but we should run cleanup.
      CantAnalyze = !isPredicated(I);
    } else {
      // We encountered other unrecognized terminator. Bail out immediately.
      return true;
    }

    // Cleanup code - to be run for unpredicated unconditional branches and
    //                returns.
    if (!isPredicated(I) &&
          (isUncondBranchOpcode(I->getOpcode()) ||
           isIndirectBranchOpcode(I->getOpcode()) ||
           isJumpTableBranchOpcode(I->getOpcode()) ||
           I->isReturn())) {
      // Forget any previous condition branch information - it no longer applies.
      Cond.clear();
      FBB = nullptr;

      // If we can modify the function, delete everything below this
      // unconditional branch.
      if (AllowModify) {
        MachineBasicBlock::iterator DI = std::next(I);
        while (DI != MBB.end()) {
          MachineInstr *InstToDelete = DI;
          ++DI;
          InstToDelete->eraseFromParent();
        }
      }
    }

    if (CantAnalyze)
      return true;

    if (I == MBB.begin())
      return false;

    --I;
  }

  // We made it past the terminators without bailing out - we must have
  // analyzed this branch successfully.
  return false;
}


unsigned ARMBaseInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
  MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
  if (I == MBB.end())
    return 0;

  if (!isUncondBranchOpcode(I->getOpcode()) &&
      !isCondBranchOpcode(I->getOpcode()))
    return 0;

  // Remove the branch.
  I->eraseFromParent();

  I = MBB.end();

  if (I == MBB.begin()) return 1;
  --I;
  if (!isCondBranchOpcode(I->getOpcode()))
    return 1;

  // Remove the branch.
  I->eraseFromParent();
  return 2;
}

unsigned
ARMBaseInstrInfo::InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
                               MachineBasicBlock *FBB,
                               ArrayRef<MachineOperand> Cond,
                               DebugLoc DL) const {
  ARMFunctionInfo *AFI = MBB.getParent()->getInfo<ARMFunctionInfo>();
  int BOpc   = !AFI->isThumbFunction()
    ? ARM::B : (AFI->isThumb2Function() ? ARM::t2B : ARM::tB);
  int BccOpc = !AFI->isThumbFunction()
    ? ARM::Bcc : (AFI->isThumb2Function() ? ARM::t2Bcc : ARM::tBcc);
  bool isThumb = AFI->isThumbFunction() || AFI->isThumb2Function();

  // Shouldn't be a fall through.
  assert(TBB && ""InsertBranch must not be told to insert a fallthrough"");
  assert((Cond.size() == 2 || Cond.size() == 0) &&
         ""ARM branch conditions have two components!"");

  // For conditional branches, we use addOperand to preserve CPSR flags.

  if (!FBB) {
    if (Cond.empty()) { // Unconditional branch?
      if (isThumb)
        BuildMI(&MBB, DL, get(BOpc)).addMBB(TBB).addImm(ARMCC::AL).addReg(0);
      else
        BuildMI(&MBB, DL, get(BOpc)).addMBB(TBB);
    } else
      BuildMI(&MBB, DL, get(BccOpc)).addMBB(TBB)
        .addImm(Cond[0].getImm()).addOperand(Cond[1]);
    return 1;
  }

  // Two-way conditional branch.
  BuildMI(&MBB, DL, get(BccOpc)).addMBB(TBB)
    .addImm(Cond[0].getImm()).addOperand(Cond[1]);
  if (isThumb)
    BuildMI(&MBB, DL, get(BOpc)).addMBB(FBB).addImm(ARMCC::AL).addReg(0);
  else
    BuildMI(&MBB, DL, get(BOpc)).addMBB(FBB);
  return 2;
}

bool ARMBaseInstrInfo::
ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
  ARMCC::CondCodes CC = (ARMCC::CondCodes)(int)Cond[0].getImm();
  Cond[0].setImm(ARMCC::getOppositeCondition(CC));
  return false;
}

bool ARMBaseInstrInfo::isPredicated(const MachineInstr *MI) const {
  if (MI->isBundle()) {
    MachineBasicBlock::const_instr_iterator I = MI->getIterator();
    MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
    while (++I != E && I->isInsideBundle()) {
      int PIdx = I->findFirstPredOperandIdx();
      if (PIdx != -1 && I->getOperand(PIdx).getImm() != ARMCC::AL)
        return true;
    }
    return false;
  }

  int PIdx = MI->findFirstPredOperandIdx();
  return PIdx != -1 && MI->getOperand(PIdx).getImm() != ARMCC::AL;
}

bool ARMBaseInstrInfo::
PredicateInstruction(MachineInstr *MI, ArrayRef<MachineOperand> Pred) const {
  unsigned Opc = MI->getOpcode();
  if (isUncondBranchOpcode(Opc)) {
    MI->setDesc(get(getMatchingCondBranchOpcode(Opc)));
    MachineInstrBuilder(*MI->getParent()->getParent(), MI)
      .addImm(Pred[0].getImm())
      .addReg(Pred[1].getReg());
    return true;
  }

  int PIdx = MI->findFirstPredOperandIdx();
  if (PIdx != -1) {
    MachineOperand &PMO = MI->getOperand(PIdx);
    PMO.setImm(Pred[0].getImm());
    MI->getOperand(PIdx+1).setReg(Pred[1].getReg());
    return true;
  }
  return false;
}

bool ARMBaseInstrInfo::SubsumesPredicate(ArrayRef<MachineOperand> Pred1,
                                         ArrayRef<MachineOperand> Pred2) const {
  if (Pred1.size() > 2 || Pred2.size() > 2)
    return false;

  ARMCC::CondCodes CC1 = (ARMCC::CondCodes)Pred1[0].getImm();
  ARMCC::CondCodes CC2 = (ARMCC::CondCodes)Pred2[0].getImm();
  if (CC1 == CC2)
    return true;

  switch (CC1) {
  default:
    return false;
  case ARMCC::AL:
    return true;
  case ARMCC::HS:
    return CC2 == ARMCC::HI;
  case ARMCC::LS:
    return CC2 == ARMCC::LO || CC2 == ARMCC::EQ;
  case ARMCC::GE:
    return CC2 == ARMCC::GT;
  case ARMCC::LE:
    return CC2 == ARMCC::LT;
  }
}

bool ARMBaseInstrInfo::DefinesPredicate(MachineInstr *MI,
                                    std::vector<MachineOperand> &Pred) const {
  bool Found = false;
  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    if ((MO.isRegMask() && MO.clobbersPhysReg(ARM::CPSR)) ||
        (MO.isReg() && MO.isDef() && MO.getReg() == ARM::CPSR)) {
      Pred.push_back(MO);
      Found = true;
    }
  }

  return Found;
}

static bool isCPSRDefined(const MachineInstr *MI) {
  for (const auto &MO : MI->operands())
    if (MO.isReg() && MO.getReg() == ARM::CPSR && MO.isDef() && !MO.isDead())
      return true;
  return false;
}

static bool isEligibleForITBlock(const MachineInstr *MI) {
  switch (MI->getOpcode()) {
  default: return true;
  case ARM::tADC:   // ADC (register) T1
  case ARM::tADDi3: // ADD (immediate) T1
  case ARM::tADDi8: // ADD (immediate) T2
  case ARM::tADDrr: // ADD (register) T1
  case ARM::tAND:   // AND (register) T1
  case ARM::tASRri: // ASR (immediate) T1
  case ARM::tASRrr: // ASR (register) T1
  case ARM::tBIC:   // BIC (register) T1
  case ARM::tEOR:   // EOR (register) T1
  case ARM::tLSLri: // LSL (immediate) T1
  case ARM::tLSLrr: // LSL (register) T1
  case ARM::tLSRri: // LSR (immediate) T1
  case ARM::tLSRrr: // LSR (register) T1
  case ARM::tMUL:   // MUL T1
  case ARM::tMVN:   // MVN (register) T1
  case ARM::tORR:   // ORR (register) T1
  case ARM::tROR:   // ROR (register) T1
  case ARM::tRSB:   // RSB (immediate) T1
  case ARM::tSBC:   // SBC (register) T1
  case ARM::tSUBi3: // SUB (immediate) T1
  case ARM::tSUBi8: // SUB (immediate) T2
  case ARM::tSUBrr: // SUB (register) T1
    return !isCPSRDefined(MI);
  }
}

/// isPredicable - Return true if the specified instruction can be predicated.
/// By default, this returns true for every instruction with a
/// PredicateOperand.
bool ARMBaseInstrInfo::isPredicable(MachineInstr *MI) const {
  if (!MI->isPredicable())
    return false;

  if (!isEligibleForITBlock(MI))
    return false;

  ARMFunctionInfo *AFI =
    MI->getParent()->getParent()->getInfo<ARMFunctionInfo>();

  if (AFI->isThumb2Function()) {
    if (getSubtarget().restrictIT())
      return isV8EligibleForIT(MI);
  } else { // non-Thumb
    if ((MI->getDesc().TSFlags & ARMII::DomainMask) == ARMII::DomainNEON)
      return false;
  }

  return true;
}

namespace llvm {
template <> bool IsCPSRDead<MachineInstr>(MachineInstr *MI) {
  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    if (!MO.isReg() || MO.isUndef() || MO.isUse())
      continue;
    if (MO.getReg() != ARM::CPSR)
      continue;
    if (!MO.isDead())
      return false;
  }
  // all definitions of CPSR are dead
  return true;
}
}

/// GetInstSize - Return the size of the specified MachineInstr.
///
unsigned ARMBaseInstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
  const MachineBasicBlock &MBB = *MI->getParent();
  const MachineFunction *MF = MBB.getParent();
  const MCAsmInfo *MAI = MF->getTarget().getMCAsmInfo();

  const MCInstrDesc &MCID = MI->getDesc();
  if (MCID.getSize())
    return MCID.getSize();

  // If this machine instr is an inline asm, measure it.
  if (MI->getOpcode() == ARM::INLINEASM)
    return getInlineAsmLength(MI->getOperand(0).getSymbolName(), *MAI);
  unsigned Opc = MI->getOpcode();
  switch (Opc) {
  default:
    // pseudo-instruction sizes are zero.
    return 0;
  case TargetOpcode::BUNDLE:
    return getInstBundleLength(MI);
  case ARM::MOVi16_ga_pcrel:
  case ARM::MOVTi16_ga_pcrel:
  case ARM::t2MOVi16_ga_pcrel:
  case ARM::t2MOVTi16_ga_pcrel:
    return 4;
  case ARM::MOVi32imm:
  case ARM::t2MOVi32imm:
    return 8;
  case ARM::CONSTPOOL_ENTRY:
  case ARM::JUMPTABLE_INSTS:
  case ARM::JUMPTABLE_ADDRS:
  case ARM::JUMPTABLE_TBB:
  case ARM::JUMPTABLE_TBH:
    // If this machine instr is a constant pool entry, its size is recorded as
    // operand #2.
    return MI->getOperand(2).getImm();
  case ARM::Int_eh_sjlj_longjmp:
    return 16;
  case ARM::tInt_eh_sjlj_longjmp:
    return 10;
  case ARM::Int_eh_sjlj_setjmp:
  case ARM::Int_eh_sjlj_setjmp_nofp:
    return 20;
  case ARM::tInt_eh_sjlj_setjmp:
  case ARM::t2Int_eh_sjlj_setjmp:
  case ARM::t2Int_eh_sjlj_setjmp_nofp:
    return 12;
  case ARM::SPACE:
    return MI->getOperand(1).getImm();
  }
}

unsigned ARMBaseInstrInfo::getInstBundleLength(const MachineInstr *MI) const {
  unsigned Size = 0;
  MachineBasicBlock::const_instr_iterator I = MI->getIterator();
  MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
  while (++I != E && I->isInsideBundle()) {
    assert(!I->isBundle() && ""No nested bundle!"");
    Size += GetInstSizeInBytes(&*I);
  }
  return Size;
}

void ARMBaseInstrInfo::copyFromCPSR(MachineBasicBlock &MBB,
                                    MachineBasicBlock::iterator I,
                                    unsigned DestReg, bool KillSrc,
                                    const ARMSubtarget &Subtarget) const {
  unsigned Opc = Subtarget.isThumb()
                     ? (Subtarget.isMClass() ? ARM::t2MRS_M : ARM::t2MRS_AR)
                     : ARM::MRS;

  MachineInstrBuilder MIB =
      BuildMI(MBB, I, I->getDebugLoc(), get(Opc), DestReg);

  // There is only 1 A/R class MRS instruction, and it always refers to
  // APSR. However, there are lots of other possibilities on M-class cores.
  if (Subtarget.isMClass())
    MIB.addImm(0x800);

  AddDefaultPred(MIB);

  MIB.addReg(ARM::CPSR, RegState::Implicit | getKillRegState(KillSrc));
}

void ARMBaseInstrInfo::copyToCPSR(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator I,
                                  unsigned SrcReg, bool KillSrc,
                                  const ARMSubtarget &Subtarget) const {
  unsigned Opc = Subtarget.isThumb()
                     ? (Subtarget.isMClass() ? ARM::t2MSR_M : ARM::t2MSR_AR)
                     : ARM::MSR;

  MachineInstrBuilder MIB = BuildMI(MBB, I, I->getDebugLoc(), get(Opc));

  if (Subtarget.isMClass())
    MIB.addImm(0x800);
  else
    MIB.addImm(8);

  MIB.addReg(SrcReg, getKillRegState(KillSrc));

  AddDefaultPred(MIB);

  MIB.addReg(ARM::CPSR, RegState::Implicit | RegState::Define);
}

void ARMBaseInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator I, DebugLoc DL,
                                   unsigned DestReg, unsigned SrcReg,
                                   bool KillSrc) const {
  bool GPRDest = ARM::GPRRegClass.contains(DestReg);
  bool GPRSrc = ARM::GPRRegClass.contains(SrcReg);

  if (GPRDest && GPRSrc) {
    AddDefaultCC(AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::MOVr), DestReg)
                                    .addReg(SrcReg, getKillRegState(KillSrc))));
    return;
  }

  bool SPRDest = ARM::SPRRegClass.contains(DestReg);
  bool SPRSrc = ARM::SPRRegClass.contains(SrcReg);

  unsigned Opc = 0;
  if (SPRDest && SPRSrc)
    Opc = ARM::VMOVS;
  else if (GPRDest && SPRSrc)
    Opc = ARM::VMOVRS;
  else if (SPRDest && GPRSrc)
    Opc = ARM::VMOVSR;
  else if (ARM::DPRRegClass.contains(DestReg, SrcReg) && !Subtarget.isFPOnlySP())
    Opc = ARM::VMOVD;
  else if (ARM::QPRRegClass.contains(DestReg, SrcReg))
    Opc = ARM::VORRq;

  if (Opc) {
    MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(Opc), DestReg);
    MIB.addReg(SrcReg, getKillRegState(KillSrc));
    if (Opc == ARM::VORRq)
      MIB.addReg(SrcReg, getKillRegState(KillSrc));
    AddDefaultPred(MIB);
    return;
  }

  // Handle register classes that require multiple instructions.
  unsigned BeginIdx = 0;
  unsigned SubRegs = 0;
  int Spacing = 1;

  // Use VORRq when possible.
  if (ARM::QQPRRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VORRq;
    BeginIdx = ARM::qsub_0;
    SubRegs = 2;
  } else if (ARM::QQQQPRRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VORRq;
    BeginIdx = ARM::qsub_0;
    SubRegs = 4;
  // Fall back to VMOVD.
  } else if (ARM::DPairRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 2;
  } else if (ARM::DTripleRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 3;
  } else if (ARM::DQuadRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 4;
  } else if (ARM::GPRPairRegClass.contains(DestReg, SrcReg)) {
    Opc = Subtarget.isThumb2() ? ARM::tMOVr : ARM::MOVr;
    BeginIdx = ARM::gsub_0;
    SubRegs = 2;
  } else if (ARM::DPairSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 2;
    Spacing = 2;
  } else if (ARM::DTripleSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 3;
    Spacing = 2;
  } else if (ARM::DQuadSpcRegClass.contains(DestReg, SrcReg)) {
    Opc = ARM::VMOVD;
    BeginIdx = ARM::dsub_0;
    SubRegs = 4;
    Spacing = 2;
  } else if (ARM::DPRRegClass.contains(DestReg, SrcReg) && Subtarget.isFPOnlySP()) {
    Opc = ARM::VMOVS;
    BeginIdx = ARM::ssub_0;
    SubRegs = 2;
  } else if (SrcReg == ARM::CPSR) {
    copyFromCPSR(MBB, I, DestReg, KillSrc, Subtarget);
    return;
  } else if (DestReg == ARM::CPSR) {
    copyToCPSR(MBB, I, SrcReg, KillSrc, Subtarget);
    return;
  }

  assert(Opc && ""Impossible reg-to-reg copy"");

  const TargetRegisterInfo *TRI = &getRegisterInfo();
  MachineInstrBuilder Mov;

  // Copy register tuples backward when the first Dest reg overlaps with SrcReg.
  if (TRI->regsOverlap(SrcReg, TRI->getSubReg(DestReg, BeginIdx))) {
    BeginIdx = BeginIdx + ((SubRegs - 1) * Spacing);
    Spacing = -Spacing;
  }
#ifndef NDEBUG
  SmallSet<unsigned, 4> DstRegs;
#endif
  for (unsigned i = 0; i != SubRegs; ++i) {
    unsigned Dst = TRI->getSubReg(DestReg, BeginIdx + i * Spacing);
    unsigned Src = TRI->getSubReg(SrcReg, BeginIdx + i * Spacing);
    assert(Dst && Src && ""Bad sub-register"");
#ifndef NDEBUG
    assert(!DstRegs.count(Src) && ""destructive vector copy"");
    DstRegs.insert(Dst);
#endif
    Mov = BuildMI(MBB, I, I->getDebugLoc(), get(Opc), Dst).addReg(Src);
    // VORR takes two source operands.
    if (Opc == ARM::VORRq)
      Mov.addReg(Src);
    Mov = AddDefaultPred(Mov);
    // MOVr can set CC.
    if (Opc == ARM::MOVr)
      Mov = AddDefaultCC(Mov);
  }
  // Add implicit super-register defs and kills to the last instruction.
  Mov->addRegisterDefined(DestReg, TRI);
  if (KillSrc)
    Mov->addRegisterKilled(SrcReg, TRI);
}

const MachineInstrBuilder &
ARMBaseInstrInfo::AddDReg(MachineInstrBuilder &MIB, unsigned Reg,
                          unsigned SubIdx, unsigned State,
                          const TargetRegisterInfo *TRI) const {
  if (!SubIdx)
    return MIB.addReg(Reg, State);

  if (TargetRegisterInfo::isPhysicalRegister(Reg))
    return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
  return MIB.addReg(Reg, State, SubIdx);
}

void ARMBaseInstrInfo::
storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                    unsigned SrcReg, bool isKill, int FI,
                    const TargetRegisterClass *RC,
                    const TargetRegisterInfo *TRI) const {
  DebugLoc DL;
  if (I != MBB.end()) DL = I->getDebugLoc();
  MachineFunction &MF = *MBB.getParent();
  MachineFrameInfo &MFI = *MF.getFrameInfo();
  unsigned Align = MFI.getObjectAlignment(FI);

  MachineMemOperand *MMO = MF.getMachineMemOperand(
      MachinePointerInfo::getFixedStack(MF, FI), MachineMemOperand::MOStore,
      MFI.getObjectSize(FI), Align);

  switch (RC->getSize()) {
    case 4:
      if (ARM::GPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::STRi12))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else if (ARM::SPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTRS))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 8:
      if (ARM::DPRRegClass.hasSubClassEq(RC)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTRD))
                   .addReg(SrcReg, getKillRegState(isKill))
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
      } else if (ARM::GPRPairRegClass.hasSubClassEq(RC)) {
        if (Subtarget.hasV5TEOps()) {
          MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(ARM::STRD));
          AddDReg(MIB, SrcReg, ARM::gsub_0, getKillRegState(isKill), TRI);
          AddDReg(MIB, SrcReg, ARM::gsub_1, 0, TRI);
          MIB.addFrameIndex(FI).addReg(0).addImm(0).addMemOperand(MMO);

          AddDefaultPred(MIB);
        } else {
          // Fallback to STM instruction, which has existed since the dawn of
          // time.
          MachineInstrBuilder MIB =
            AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::STMIA))
                             .addFrameIndex(FI).addMemOperand(MMO));
          AddDReg(MIB, SrcReg, ARM::gsub_0, getKillRegState(isKill), TRI);
          AddDReg(MIB, SrcReg, ARM::gsub_1, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 16:
      if (ARM::DPairRegClass.hasSubClassEq(RC)) {
        // Use aligned spills if the stack can be realigned.
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1q64))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMQIA))
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addFrameIndex(FI)
                     .addMemOperand(MMO));
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 24:
      if (ARM::DTripleRegClass.hasSubClassEq(RC)) {
        // Use aligned spills if the stack can be realigned.
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1d64TPseudo))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
          AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 32:
      if (ARM::QQPRRegClass.hasSubClassEq(RC) || ARM::DQuadRegClass.hasSubClassEq(RC)) {
        if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
          // FIXME: It's possible to only store part of the QQ register if the
          // spilled def has a sub-register index.
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VST1d64QPseudo))
                     .addFrameIndex(FI).addImm(16)
                     .addReg(SrcReg, getKillRegState(isKill))
                     .addMemOperand(MMO));
        } else {
          MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
          MIB = AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
                AddDReg(MIB, SrcReg, ARM::dsub_3, 0, TRI);
        }
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    case 64:
      if (ARM::QQQQPRRegClass.hasSubClassEq(RC)) {
        MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VSTMDIA))
                         .addFrameIndex(FI))
                         .addMemOperand(MMO);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_0, getKillRegState(isKill), TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_1, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_2, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_3, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_4, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_5, 0, TRI);
        MIB = AddDReg(MIB, SrcReg, ARM::dsub_6, 0, TRI);
              AddDReg(MIB, SrcReg, ARM::dsub_7, 0, TRI);
      } else
        llvm_unreachable(""Unknown reg class!"");
      break;
    default:
      llvm_unreachable(""Unknown reg class!"");
  }
}

unsigned
ARMBaseInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
                                     int &FrameIndex) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::STRrs:
  case ARM::t2STRs: // FIXME: don't use t2STRs to access frame.
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isReg() &&
        MI->getOperand(3).isImm() &&
        MI->getOperand(2).getReg() == 0 &&
        MI->getOperand(3).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::STRi12:
  case ARM::t2STRi12:
  case ARM::tSTRspi:
  case ARM::VSTRD:
  case ARM::VSTRS:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isImm() &&
        MI->getOperand(2).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VST1q64:
  case ARM::VST1d64TPseudo:
  case ARM::VST1d64QPseudo:
    if (MI->getOperand(0).isFI() &&
        MI->getOperand(2).getSubReg() == 0) {
      FrameIndex = MI->getOperand(0).getIndex();
      return MI->getOperand(2).getReg();
    }
    break;
  case ARM::VSTMQIA:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  }

  return 0;
}

unsigned ARMBaseInstrInfo::isStoreToStackSlotPostFE(const MachineInstr *MI,
                                                    int &FrameIndex) const {
  const MachineMemOperand *Dummy;
  return MI->mayStore() && hasStoreToStackSlot(MI, Dummy, FrameIndex);
}

void ARMBaseInstrInfo::
loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                     unsigned DestReg, int FI,
                     const TargetRegisterClass *RC,
                     const TargetRegisterInfo *TRI) const {
  DebugLoc DL;
  if (I != MBB.end()) DL = I->getDebugLoc();
  MachineFunction &MF = *MBB.getParent();
  MachineFrameInfo &MFI = *MF.getFrameInfo();
  unsigned Align = MFI.getObjectAlignment(FI);
  MachineMemOperand *MMO = MF.getMachineMemOperand(
      MachinePointerInfo::getFixedStack(MF, FI), MachineMemOperand::MOLoad,
      MFI.getObjectSize(FI), Align);

  switch (RC->getSize()) {
  case 4:
    if (ARM::GPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::LDRi12), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));

    } else if (ARM::SPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDRS), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 8:
    if (ARM::DPRRegClass.hasSubClassEq(RC)) {
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDRD), DestReg)
                   .addFrameIndex(FI).addImm(0).addMemOperand(MMO));
    } else if (ARM::GPRPairRegClass.hasSubClassEq(RC)) {
      MachineInstrBuilder MIB;

      if (Subtarget.hasV5TEOps()) {
        MIB = BuildMI(MBB, I, DL, get(ARM::LDRD));
        AddDReg(MIB, DestReg, ARM::gsub_0, RegState::DefineNoRead, TRI);
        AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
        MIB.addFrameIndex(FI).addReg(0).addImm(0).addMemOperand(MMO);

        AddDefaultPred(MIB);
      } else {
        // Fallback to LDM instruction, which has existed since the dawn of
        // time.
        MIB = AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::LDMIA))
                                 .addFrameIndex(FI).addMemOperand(MMO));
        MIB = AddDReg(MIB, DestReg, ARM::gsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
      }

      if (TargetRegisterInfo::isPhysicalRegister(DestReg))
        MIB.addReg(DestReg, RegState::ImplicitDefine);
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 16:
    if (ARM::DPairRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1q64), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMQIA), DestReg)
                       .addFrameIndex(FI)
                       .addMemOperand(MMO));
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 24:
    if (ARM::DTripleRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1d64TPseudo), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        MachineInstrBuilder MIB =
          AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                         .addFrameIndex(FI)
                         .addMemOperand(MMO));
        MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
        if (TargetRegisterInfo::isPhysicalRegister(DestReg))
          MIB.addReg(DestReg, RegState::ImplicitDefine);
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
   case 32:
    if (ARM::QQPRRegClass.hasSubClassEq(RC) || ARM::DQuadRegClass.hasSubClassEq(RC)) {
      if (Align >= 16 && getRegisterInfo().canRealignStack(MF)) {
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLD1d64QPseudo), DestReg)
                     .addFrameIndex(FI).addImm(16)
                     .addMemOperand(MMO));
      } else {
        MachineInstrBuilder MIB =
        AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                       .addFrameIndex(FI))
                       .addMemOperand(MMO);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
        MIB = AddDReg(MIB, DestReg, ARM::dsub_3, RegState::DefineNoRead, TRI);
        if (TargetRegisterInfo::isPhysicalRegister(DestReg))
          MIB.addReg(DestReg, RegState::ImplicitDefine);
      }
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  case 64:
    if (ARM::QQQQPRRegClass.hasSubClassEq(RC)) {
      MachineInstrBuilder MIB =
      AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::VLDMDIA))
                     .addFrameIndex(FI))
                     .addMemOperand(MMO);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_3, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_4, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_5, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_6, RegState::DefineNoRead, TRI);
      MIB = AddDReg(MIB, DestReg, ARM::dsub_7, RegState::DefineNoRead, TRI);
      if (TargetRegisterInfo::isPhysicalRegister(DestReg))
        MIB.addReg(DestReg, RegState::ImplicitDefine);
    } else
      llvm_unreachable(""Unknown reg class!"");
    break;
  default:
    llvm_unreachable(""Unknown regclass!"");
  }
}

unsigned
ARMBaseInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
                                      int &FrameIndex) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::LDRrs:
  case ARM::t2LDRs:  // FIXME: don't use t2LDRs to access frame.
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isReg() &&
        MI->getOperand(3).isImm() &&
        MI->getOperand(2).getReg() == 0 &&
        MI->getOperand(3).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::LDRi12:
  case ARM::t2LDRi12:
  case ARM::tLDRspi:
  case ARM::VLDRD:
  case ARM::VLDRS:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(2).isImm() &&
        MI->getOperand(2).getImm() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VLD1q64:
  case ARM::VLD1d64TPseudo:
  case ARM::VLD1d64QPseudo:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  case ARM::VLDMQIA:
    if (MI->getOperand(1).isFI() &&
        MI->getOperand(0).getSubReg() == 0) {
      FrameIndex = MI->getOperand(1).getIndex();
      return MI->getOperand(0).getReg();
    }
    break;
  }

  return 0;
}

unsigned ARMBaseInstrInfo::isLoadFromStackSlotPostFE(const MachineInstr *MI,
                                             int &FrameIndex) const {
  const MachineMemOperand *Dummy;
  return MI->mayLoad() && hasLoadFromStackSlot(MI, Dummy, FrameIndex);
}

/// \brief Expands MEMCPY to either LDMIA/STMIA or LDMIA_UPD/STMID_UPD
/// depending on whether the result is used.
void ARMBaseInstrInfo::expandMEMCPY(MachineBasicBlock::iterator MBBI) const {
  bool isThumb1 = Subtarget.isThumb1Only();
  bool isThumb2 = Subtarget.isThumb2();
  const ARMBaseInstrInfo *TII = Subtarget.getInstrInfo();

  MachineInstr *MI = MBBI;
  DebugLoc dl = MI->getDebugLoc();
  MachineBasicBlock *BB = MI->getParent();

  MachineInstrBuilder LDM, STM;
  if (isThumb1 || !MI->getOperand(1).isDead()) {
    LDM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2LDMIA_UPD
                                                 : isThumb1 ? ARM::tLDMIA_UPD
                                                            : ARM::LDMIA_UPD))
             .addOperand(MI->getOperand(1));
  } else {
    LDM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2LDMIA : ARM::LDMIA));
  }

  if (isThumb1 || !MI->getOperand(0).isDead()) {
    STM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2STMIA_UPD
                                                 : isThumb1 ? ARM::tSTMIA_UPD
                                                            : ARM::STMIA_UPD))
             .addOperand(MI->getOperand(0));
  } else {
    STM = BuildMI(*BB, MI, dl, TII->get(isThumb2 ? ARM::t2STMIA : ARM::STMIA));
  }

  AddDefaultPred(LDM.addOperand(MI->getOperand(3)));
  AddDefaultPred(STM.addOperand(MI->getOperand(2)));

  // Sort the scratch registers into ascending order.
  const TargetRegisterInfo &TRI = getRegisterInfo();
  llvm::SmallVector<unsigned, 6> ScratchRegs;
  for(unsigned I = 5; I < MI->getNumOperands(); ++I)
    ScratchRegs.push_back(MI->getOperand(I).getReg());
  std::sort(ScratchRegs.begin(), ScratchRegs.end(),
            [&TRI](const unsigned &Reg1,
                   const unsigned &Reg2) -> bool {
              return TRI.getEncodingValue(Reg1) <
                     TRI.getEncodingValue(Reg2);
            });

  for (const auto &Reg : ScratchRegs) {
    LDM.addReg(Reg, RegState::Define);
    STM.addReg(Reg, RegState::Kill);
  }

  BB->erase(MBBI);
}


bool
ARMBaseInstrInfo::expandPostRAPseudo(MachineBasicBlock::iterator MI) const {
  MachineFunction &MF = *MI->getParent()->getParent();
  Reloc::Model RM = MF.getTarget().getRelocationModel();

  if (MI->getOpcode() == TargetOpcode::LOAD_STACK_GUARD) {
    assert(getSubtarget().getTargetTriple().isOSBinFormatMachO() &&
           ""LOAD_STACK_GUARD currently supported only for MachO."");
    expandLoadStackGuard(MI, RM);
    MI->getParent()->erase(MI);
    return true;
  }

  if (MI->getOpcode() == ARM::MEMCPY) {
    expandMEMCPY(MI);
    return true;
  }

  // This hook gets to expand COPY instructions before they become
  // copyPhysReg() calls.  Look for VMOVS instructions that can legally be
  // widened to VMOVD.  We prefer the VMOVD when possible because it may be
  // changed into a VORR that can go down the NEON pipeline.
  if (!WidenVMOVS || !MI->isCopy() || Subtarget.isCortexA15() ||
      Subtarget.isFPOnlySP())
    return false;

  // Look for a copy between even S-registers.  That is where we keep floats
  // when using NEON v2f32 instructions for f32 arithmetic.
  unsigned DstRegS = MI->getOperand(0).getReg();
  unsigned SrcRegS = MI->getOperand(1).getReg();
  if (!ARM::SPRRegClass.contains(DstRegS, SrcRegS))
    return false;

  const TargetRegisterInfo *TRI = &getRegisterInfo();
  unsigned DstRegD = TRI->getMatchingSuperReg(DstRegS, ARM::ssub_0,
                                              &ARM::DPRRegClass);
  unsigned SrcRegD = TRI->getMatchingSuperReg(SrcRegS, ARM::ssub_0,
                                              &ARM::DPRRegClass);
  if (!DstRegD || !SrcRegD)
    return false;

  // We want to widen this into a DstRegD = VMOVD SrcRegD copy.  This is only
  // legal if the COPY already defines the full DstRegD, and it isn't a
  // sub-register insertion.
  if (!MI->definesRegister(DstRegD, TRI) || MI->readsRegister(DstRegD, TRI))
    return false;

  // A dead copy shouldn't show up here, but reject it just in case.
  if (MI->getOperand(0).isDead())
    return false;

  // All clear, widen the COPY.
  DEBUG(dbgs() << ""widening:    "" << *MI);
  MachineInstrBuilder MIB(*MI->getParent()->getParent(), MI);

  // Get rid of the old <imp-def> of DstRegD.  Leave it if it defines a Q-reg
  // or some other super-register.
  int ImpDefIdx = MI->findRegisterDefOperandIdx(DstRegD);
  if (ImpDefIdx != -1)
    MI->RemoveOperand(ImpDefIdx);

  // Change the opcode and operands.
  MI->setDesc(get(ARM::VMOVD));
  MI->getOperand(0).setReg(DstRegD);
  MI->getOperand(1).setReg(SrcRegD);
  AddDefaultPred(MIB);

  // We are now reading SrcRegD instead of SrcRegS.  This may upset the
  // register scavenger and machine verifier, so we need to indicate that we
  // are reading an undefined value from SrcRegD, but a proper value from
  // SrcRegS.
  MI->getOperand(1).setIsUndef();
  MIB.addReg(SrcRegS, RegState::Implicit);

  // SrcRegD may actually contain an unrelated value in the ssub_1
  // sub-register.  Don't kill it.  Only kill the ssub_0 sub-register.
  if (MI->getOperand(1).isKill()) {
    MI->getOperand(1).setIsKill(false);
    MI->addRegisterKilled(SrcRegS, TRI, true);
  }

  DEBUG(dbgs() << ""replaced by: "" << *MI);
  return true;
}

/// Create a copy of a const pool value. Update CPI to the new index and return
/// the label UID.
static unsigned duplicateCPV(MachineFunction &MF, unsigned &CPI) {
  MachineConstantPool *MCP = MF.getConstantPool();
  ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();

  const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPI];
  assert(MCPE.isMachineConstantPoolEntry() &&
         ""Expecting a machine constantpool entry!"");
  ARMConstantPoolValue *ACPV =
    static_cast<ARMConstantPoolValue*>(MCPE.Val.MachineCPVal);

  unsigned PCLabelId = AFI->createPICLabelUId();
  ARMConstantPoolValue *NewCPV = nullptr;

  // FIXME: The below assumes PIC relocation model and that the function
  // is Thumb mode (t1 or t2). PCAdjustment would be 8 for ARM mode PIC, and
  // zero for non-PIC in ARM or Thumb. The callers are all of thumb LDR
  // instructions, so that's probably OK, but is PIC always correct when
  // we get here?
  if (ACPV->isGlobalValue())
    NewCPV = ARMConstantPoolConstant::Create(
        cast<ARMConstantPoolConstant>(ACPV)->getGV(), PCLabelId, ARMCP::CPValue,
        4, ACPV->getModifier(), ACPV->mustAddCurrentAddress());
  else if (ACPV->isExtSymbol())
    NewCPV = ARMConstantPoolSymbol::
      Create(MF.getFunction()->getContext(),
             cast<ARMConstantPoolSymbol>(ACPV)->getSymbol(), PCLabelId, 4);
  else if (ACPV->isBlockAddress())
    NewCPV = ARMConstantPoolConstant::
      Create(cast<ARMConstantPoolConstant>(ACPV)->getBlockAddress(), PCLabelId,
             ARMCP::CPBlockAddress, 4);
  else if (ACPV->isLSDA())
    NewCPV = ARMConstantPoolConstant::Create(MF.getFunction(), PCLabelId,
                                             ARMCP::CPLSDA, 4);
  else if (ACPV->isMachineBasicBlock())
    NewCPV = ARMConstantPoolMBB::
      Create(MF.getFunction()->getContext(),
             cast<ARMConstantPoolMBB>(ACPV)->getMBB(), PCLabelId, 4);
  else
    llvm_unreachable(""Unexpected ARM constantpool value type!!"");
  CPI = MCP->getConstantPoolIndex(NewCPV, MCPE.getAlignment());
  return PCLabelId;
}

void ARMBaseInstrInfo::
reMaterialize(MachineBasicBlock &MBB,
              MachineBasicBlock::iterator I,
              unsigned DestReg, unsigned SubIdx,
              const MachineInstr *Orig,
              const TargetRegisterInfo &TRI) const {
  unsigned Opcode = Orig->getOpcode();
  switch (Opcode) {
  default: {
    MachineInstr *MI = MBB.getParent()->CloneMachineInstr(Orig);
    MI->substituteRegister(Orig->getOperand(0).getReg(), DestReg, SubIdx, TRI);
    MBB.insert(I, MI);
    break;
  }
  case ARM::tLDRpci_pic:
  case ARM::t2LDRpci_pic: {
    MachineFunction &MF = *MBB.getParent();
    unsigned CPI = Orig->getOperand(1).getIndex();
    unsigned PCLabelId = duplicateCPV(MF, CPI);
    MachineInstrBuilder MIB = BuildMI(MBB, I, Orig->getDebugLoc(), get(Opcode),
                                      DestReg)
      .addConstantPoolIndex(CPI).addImm(PCLabelId);
    MIB->setMemRefs(Orig->memoperands_begin(), Orig->memoperands_end());
    break;
  }
  }
}

MachineInstr *
ARMBaseInstrInfo::duplicate(MachineInstr *Orig, MachineFunction &MF) const {
  MachineInstr *MI = TargetInstrInfo::duplicate(Orig, MF);
  switch(Orig->getOpcode()) {
  case ARM::tLDRpci_pic:
  case ARM::t2LDRpci_pic: {
    unsigned CPI = Orig->getOperand(1).getIndex();
    unsigned PCLabelId = duplicateCPV(MF, CPI);
    Orig->getOperand(1).setIndex(CPI);
    Orig->getOperand(2).setImm(PCLabelId);
    break;
  }
  }
  return MI;
}

bool ARMBaseInstrInfo::produceSameValue(const MachineInstr *MI0,
                                        const MachineInstr *MI1,
                                        const MachineRegisterInfo *MRI) const {
  unsigned Opcode = MI0->getOpcode();
  if (Opcode == ARM::t2LDRpci ||
      Opcode == ARM::t2LDRpci_pic ||
      Opcode == ARM::tLDRpci ||
      Opcode == ARM::tLDRpci_pic ||
      Opcode == ARM::LDRLIT_ga_pcrel ||
      Opcode == ARM::LDRLIT_ga_pcrel_ldr ||
      Opcode == ARM::tLDRLIT_ga_pcrel ||
      Opcode == ARM::MOV_ga_pcrel ||
      Opcode == ARM::MOV_ga_pcrel_ldr ||
      Opcode == ARM::t2MOV_ga_pcrel) {
    if (MI1->getOpcode() != Opcode)
      return false;
    if (MI0->getNumOperands() != MI1->getNumOperands())
      return false;

    const MachineOperand &MO0 = MI0->getOperand(1);
    const MachineOperand &MO1 = MI1->getOperand(1);
    if (MO0.getOffset() != MO1.getOffset())
      return false;

    if (Opcode == ARM::LDRLIT_ga_pcrel ||
        Opcode == ARM::LDRLIT_ga_pcrel_ldr ||
        Opcode == ARM::tLDRLIT_ga_pcrel ||
        Opcode == ARM::MOV_ga_pcrel ||
        Opcode == ARM::MOV_ga_pcrel_ldr ||
        Opcode == ARM::t2MOV_ga_pcrel)
      // Ignore the PC labels.
      return MO0.getGlobal() == MO1.getGlobal();

    const MachineFunction *MF = MI0->getParent()->getParent();
    const MachineConstantPool *MCP = MF->getConstantPool();
    int CPI0 = MO0.getIndex();
    int CPI1 = MO1.getIndex();
    const MachineConstantPoolEntry &MCPE0 = MCP->getConstants()[CPI0];
    const MachineConstantPoolEntry &MCPE1 = MCP->getConstants()[CPI1];
    bool isARMCP0 = MCPE0.isMachineConstantPoolEntry();
    bool isARMCP1 = MCPE1.isMachineConstantPoolEntry();
    if (isARMCP0 && isARMCP1) {
      ARMConstantPoolValue *ACPV0 =
        static_cast<ARMConstantPoolValue*>(MCPE0.Val.MachineCPVal);
      ARMConstantPoolValue *ACPV1 =
        static_cast<ARMConstantPoolValue*>(MCPE1.Val.MachineCPVal);
      return ACPV0->hasSameValue(ACPV1);
    } else if (!isARMCP0 && !isARMCP1) {
      return MCPE0.Val.ConstVal == MCPE1.Val.ConstVal;
    }
    return false;
  } else if (Opcode == ARM::PICLDR) {
    if (MI1->getOpcode() != Opcode)
      return false;
    if (MI0->getNumOperands() != MI1->getNumOperands())
      return false;

    unsigned Addr0 = MI0->getOperand(1).getReg();
    unsigned Addr1 = MI1->getOperand(1).getReg();
    if (Addr0 != Addr1) {
      if (!MRI ||
          !TargetRegisterInfo::isVirtualRegister(Addr0) ||
          !TargetRegisterInfo::isVirtualRegister(Addr1))
        return false;

      // This assumes SSA form.
      MachineInstr *Def0 = MRI->getVRegDef(Addr0);
      MachineInstr *Def1 = MRI->getVRegDef(Addr1);
      // Check if the loaded value, e.g. a constantpool of a global address, are
      // the same.
      if (!produceSameValue(Def0, Def1, MRI))
        return false;
    }

    for (unsigned i = 3, e = MI0->getNumOperands(); i != e; ++i) {
      // %vreg12<def> = PICLDR %vreg11, 0, pred:14, pred:%noreg
      const MachineOperand &MO0 = MI0->getOperand(i);
      const MachineOperand &MO1 = MI1->getOperand(i);
      if (!MO0.isIdenticalTo(MO1))
        return false;
    }
    return true;
  }

  return MI0->isIdenticalTo(MI1, MachineInstr::IgnoreVRegDefs);
}

/// areLoadsFromSameBasePtr - This is used by the pre-regalloc scheduler to
/// determine if two loads are loading from the same base address. It should
/// only return true if the base pointers are the same and the only differences
/// between the two addresses is the offset. It also returns the offsets by
/// reference.
///
/// FIXME: remove this in favor of the MachineInstr interface once pre-RA-sched
/// is permanently disabled.
bool ARMBaseInstrInfo::areLoadsFromSameBasePtr(SDNode *Load1, SDNode *Load2,
                                               int64_t &Offset1,
                                               int64_t &Offset2) const {
  // Don't worry about Thumb: just ARM and Thumb2.
  if (Subtarget.isThumb1Only()) return false;

  if (!Load1->isMachineOpcode() || !Load2->isMachineOpcode())
    return false;

  switch (Load1->getMachineOpcode()) {
  default:
    return false;
  case ARM::LDRi12:
  case ARM::LDRBi12:
  case ARM::LDRD:
  case ARM::LDRH:
  case ARM::LDRSB:
  case ARM::LDRSH:
  case ARM::VLDRD:
  case ARM::VLDRS:
  case ARM::t2LDRi8:
  case ARM::t2LDRBi8:
  case ARM::t2LDRDi8:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRi12:
  case ARM::t2LDRBi12:
  case ARM::t2LDRSHi12:
    break;
  }

  switch (Load2->getMachineOpcode()) {
  default:
    return false;
  case ARM::LDRi12:
  case ARM::LDRBi12:
  case ARM::LDRD:
  case ARM::LDRH:
  case ARM::LDRSB:
  case ARM::LDRSH:
  case ARM::VLDRD:
  case ARM::VLDRS:
  case ARM::t2LDRi8:
  case ARM::t2LDRBi8:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRi12:
  case ARM::t2LDRBi12:
  case ARM::t2LDRSHi12:
    break;
  }

  // Check if base addresses and chain operands match.
  if (Load1->getOperand(0) != Load2->getOperand(0) ||
      Load1->getOperand(4) != Load2->getOperand(4))
    return false;

  // Index should be Reg0.
  if (Load1->getOperand(3) != Load2->getOperand(3))
    return false;

  // Determine the offsets.
  if (isa<ConstantSDNode>(Load1->getOperand(1)) &&
      isa<ConstantSDNode>(Load2->getOperand(1))) {
    Offset1 = cast<ConstantSDNode>(Load1->getOperand(1))->getSExtValue();
    Offset2 = cast<ConstantSDNode>(Load2->getOperand(1))->getSExtValue();
    return true;
  }

  return false;
}

/// shouldScheduleLoadsNear - This is a used by the pre-regalloc scheduler to
/// determine (in conjunction with areLoadsFromSameBasePtr) if two loads should
/// be scheduled togther. On some targets if two loads are loading from
/// addresses in the same cache line, it's better if they are scheduled
/// together. This function takes two integers that represent the load offsets
/// from the common base address. It returns true if it decides it's desirable
/// to schedule the two loads together. ""NumLoads"" is the number of loads that
/// have already been scheduled after Load1.
///
/// FIXME: remove this in favor of the MachineInstr interface once pre-RA-sched
/// is permanently disabled.
bool ARMBaseInstrInfo::shouldScheduleLoadsNear(SDNode *Load1, SDNode *Load2,
                                               int64_t Offset1, int64_t Offset2,
                                               unsigned NumLoads) const {
  // Don't worry about Thumb: just ARM and Thumb2.
  if (Subtarget.isThumb1Only()) return false;

  assert(Offset2 > Offset1);

  if ((Offset2 - Offset1) / 8 > 64)
    return false;

  // Check if the machine opcodes are different. If they are different
  // then we consider them to not be of the same base address,
  // EXCEPT in the case of Thumb2 byte loads where one is LDRBi8 and the other LDRBi12.
  // In this case, they are considered to be the same because they are different
  // encoding forms of the same basic instruction.
  if ((Load1->getMachineOpcode() != Load2->getMachineOpcode()) &&
      !((Load1->getMachineOpcode() == ARM::t2LDRBi8 &&
         Load2->getMachineOpcode() == ARM::t2LDRBi12) ||
        (Load1->getMachineOpcode() == ARM::t2LDRBi12 &&
         Load2->getMachineOpcode() == ARM::t2LDRBi8)))
    return false;  // FIXME: overly conservative?

  // Four loads in a row should be sufficient.
  if (NumLoads >= 3)
    return false;

  return true;
}

bool ARMBaseInstrInfo::isSchedulingBoundary(const MachineInstr *MI,
                                            const MachineBasicBlock *MBB,
                                            const MachineFunction &MF) const {
  // Debug info is never a scheduling boundary. It's necessary to be explicit
  // due to the special treatment of IT instructions below, otherwise a
  // dbg_value followed by an IT will result in the IT instruction being
  // considered a scheduling hazard, which is wrong. It should be the actual
  // instruction preceding the dbg_value instruction(s), just like it is
  // when debug info is not present.
  if (MI->isDebugValue())
    return false;

  // Terminators and labels can't be scheduled around.
  if (MI->isTerminator() || MI->isPosition())
    return true;

  // Treat the start of the IT block as a scheduling boundary, but schedule
  // t2IT along with all instructions following it.
  // FIXME: This is a big hammer. But the alternative is to add all potential
  // true and anti dependencies to IT block instructions as implicit operands
  // to the t2IT instruction. The added compile time and complexity does not
  // seem worth it.
  MachineBasicBlock::const_iterator I = MI;
  // Make sure to skip any dbg_value instructions
  while (++I != MBB->end() && I->isDebugValue())
    ;
  if (I != MBB->end() && I->getOpcode() == ARM::t2IT)
    return true;

  // Don't attempt to schedule around any instruction that defines
  // a stack-oriented pointer, as it's unlikely to be profitable. This
  // saves compile time, because it doesn't require every single
  // stack slot reference to depend on the instruction that does the
  // modification.
  // Calls don't actually change the stack pointer, even if they have imp-defs.
  // No ARM calling conventions change the stack pointer. (X86 calling
  // conventions sometimes do).
  if (!MI->isCall() && MI->definesRegister(ARM::SP))
    return true;

  return false;
}

bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &MBB,
                    unsigned NumCycles, unsigned ExtraPredCycles,
                    BranchProbability Probability) const {
  if (!NumCycles)
    return false;

  // If we are optimizing for size, see if the branch in the predecessor can be
  // lowered to cbn?z by the constant island lowering pass, and return false if
  // so. This results in a shorter instruction sequence.
  if (MBB.getParent()->getFunction()->optForSize()) {
    MachineBasicBlock *Pred = *MBB.pred_begin();
    if (!Pred->empty()) {
      MachineInstr *LastMI = &*Pred->rbegin();
      if (LastMI->getOpcode() == ARM::t2Bcc) {
        MachineBasicBlock::iterator CmpMI = LastMI;
        if (CmpMI != Pred->begin()) {
          --CmpMI;
          if (CmpMI->getOpcode() == ARM::tCMPi8 ||
              CmpMI->getOpcode() == ARM::t2CMPri) {
            unsigned Reg = CmpMI->getOperand(0).getReg();
            unsigned PredReg = 0;
            ARMCC::CondCodes P = getInstrPredicate(CmpMI, PredReg);
            if (P == ARMCC::AL && CmpMI->getOperand(1).getImm() == 0 &&
                isARMLowRegister(Reg))
              return false;
          }
        }
      }
    }
  }

  // Attempt to estimate the relative costs of predication versus branching.
  // Here we scale up each component of UnpredCost to avoid precision issue when
  // scaling NumCycles by Probability.
  const unsigned ScalingUpFactor = 1024;
  unsigned UnpredCost = Probability.scale(NumCycles * ScalingUpFactor);
  UnpredCost += ScalingUpFactor; // The branch itself
  UnpredCost += Subtarget.getMispredictionPenalty() * ScalingUpFactor / 10;

  return (NumCycles + ExtraPredCycles) * ScalingUpFactor <= UnpredCost;
}

bool ARMBaseInstrInfo::
isProfitableToIfCvt(MachineBasicBlock &TMBB,
                    unsigned TCycles, unsigned TExtra,
                    MachineBasicBlock &FMBB,
                    unsigned FCycles, unsigned FExtra,
                    BranchProbability Probability) const {
  if (!TCycles || !FCycles)
    return false;

  // Attempt to estimate the relative costs of predication versus branching.
  // Here we scale up each component of UnpredCost to avoid precision issue when
  // scaling TCycles/FCycles by Probability.
  const unsigned ScalingUpFactor = 1024;
  unsigned TUnpredCost = Probability.scale(TCycles * ScalingUpFactor);
  unsigned FUnpredCost =
      Probability.getCompl().scale(FCycles * ScalingUpFactor);
  unsigned UnpredCost = TUnpredCost + FUnpredCost;
  UnpredCost += 1 * ScalingUpFactor; // The branch itself
  UnpredCost += Subtarget.getMispredictionPenalty() * ScalingUpFactor / 10;

  return (TCycles + FCycles + TExtra + FExtra) * ScalingUpFactor <= UnpredCost;
}

bool
ARMBaseInstrInfo::isProfitableToUnpredicate(MachineBasicBlock &TMBB,
                                            MachineBasicBlock &FMBB) const {
  // Reduce false anti-dependencies to let Swift's out-of-order execution
  // engine do its thing.
  return Subtarget.isSwift();
}

/// getInstrPredicate - If instruction is predicated, returns its predicate
/// condition, otherwise returns AL. It also returns the condition code
/// register by reference.
ARMCC::CondCodes
llvm::getInstrPredicate(const MachineInstr *MI, unsigned &PredReg) {
  int PIdx = MI->findFirstPredOperandIdx();
  if (PIdx == -1) {
    PredReg = 0;
    return ARMCC::AL;
  }

  PredReg = MI->getOperand(PIdx+1).getReg();
  return (ARMCC::CondCodes)MI->getOperand(PIdx).getImm();
}


unsigned llvm::getMatchingCondBranchOpcode(unsigned Opc) {
  if (Opc == ARM::B)
    return ARM::Bcc;
  if (Opc == ARM::tB)
    return ARM::tBcc;
  if (Opc == ARM::t2B)
    return ARM::t2Bcc;

  llvm_unreachable(""Unknown unconditional branch opcode!"");
}

MachineInstr *ARMBaseInstrInfo::commuteInstructionImpl(MachineInstr *MI,
                                                       bool NewMI,
                                                       unsigned OpIdx1,
                                                       unsigned OpIdx2) const {
  switch (MI->getOpcode()) {
  case ARM::MOVCCr:
  case ARM::t2MOVCCr: {
    // MOVCC can be commuted by inverting the condition.
    unsigned PredReg = 0;
    ARMCC::CondCodes CC = getInstrPredicate(MI, PredReg);
    // MOVCC AL can't be inverted. Shouldn't happen.
    if (CC == ARMCC::AL || PredReg != ARM::CPSR)
      return nullptr;
    MI = TargetInstrInfo::commuteInstructionImpl(MI, NewMI, OpIdx1, OpIdx2);
    if (!MI)
      return nullptr;
    // After swapping the MOVCC operands, also invert the condition.
    MI->getOperand(MI->findFirstPredOperandIdx())
      .setImm(ARMCC::getOppositeCondition(CC));
    return MI;
  }
  }
  return TargetInstrInfo::commuteInstructionImpl(MI, NewMI, OpIdx1, OpIdx2);
}

/// Identify instructions that can be folded into a MOVCC instruction, and
/// return the defining instruction.
static MachineInstr *canFoldIntoMOVCC(unsigned Reg,
                                      const MachineRegisterInfo &MRI,
                                      const TargetInstrInfo *TII) {
  if (!TargetRegisterInfo::isVirtualRegister(Reg))
    return nullptr;
  if (!MRI.hasOneNonDBGUse(Reg))
    return nullptr;
  MachineInstr *MI = MRI.getVRegDef(Reg);
  if (!MI)
    return nullptr;
  // MI is folded into the MOVCC by predicating it.
  if (!MI->isPredicable())
    return nullptr;
  // Check if MI has any non-dead defs or physreg uses. This also detects
  // predicated instructions which will be reading CPSR.
  for (unsigned i = 1, e = MI->getNumOperands(); i != e; ++i) {
    const MachineOperand &MO = MI->getOperand(i);
    // Reject frame index operands, PEI can't handle the predicated pseudos.
    if (MO.isFI() || MO.isCPI() || MO.isJTI())
      return nullptr;
    if (!MO.isReg())
      continue;
    // MI can't have any tied operands, that would conflict with predication.
    if (MO.isTied())
      return nullptr;
    if (TargetRegisterInfo::isPhysicalRegister(MO.getReg()))
      return nullptr;
    if (MO.isDef() && !MO.isDead())
      return nullptr;
  }
  bool DontMoveAcrossStores = true;
  if (!MI->isSafeToMove(/* AliasAnalysis = */ nullptr, DontMoveAcrossStores))
    return nullptr;
  return MI;
}

bool ARMBaseInstrInfo::analyzeSelect(const MachineInstr *MI,
                                     SmallVectorImpl<MachineOperand> &Cond,
                                     unsigned &TrueOp, unsigned &FalseOp,
                                     bool &Optimizable) const {
  assert((MI->getOpcode() == ARM::MOVCCr || MI->getOpcode() == ARM::t2MOVCCr) &&
         ""Unknown select instruction"");
  // MOVCC operands:
  // 0: Def.
  // 1: True use.
  // 2: False use.
  // 3: Condition code.
  // 4: CPSR use.
  TrueOp = 1;
  FalseOp = 2;
  Cond.push_back(MI->getOperand(3));
  Cond.push_back(MI->getOperand(4));
  // We can always fold a def.
  Optimizable = true;
  return false;
}

MachineInstr *
ARMBaseInstrInfo::optimizeSelect(MachineInstr *MI,
                                 SmallPtrSetImpl<MachineInstr *> &SeenMIs,
                                 bool PreferFalse) const {
  assert((MI->getOpcode() == ARM::MOVCCr || MI->getOpcode() == ARM::t2MOVCCr) &&
         ""Unknown select instruction"");
  MachineRegisterInfo &MRI = MI->getParent()->getParent()->getRegInfo();
  MachineInstr *DefMI = canFoldIntoMOVCC(MI->getOperand(2).getReg(), MRI, this);
  bool Invert = !DefMI;
  if (!DefMI)
    DefMI = canFoldIntoMOVCC(MI->getOperand(1).getReg(), MRI, this);
  if (!DefMI)
    return nullptr;

  // Find new register class to use.
  MachineOperand FalseReg = MI->getOperand(Invert ? 2 : 1);
  unsigned       DestReg  = MI->getOperand(0).getReg();
  const TargetRegisterClass *PreviousClass = MRI.getRegClass(FalseReg.getReg());
  if (!MRI.constrainRegClass(DestReg, PreviousClass))
    return nullptr;

  // Create a new predicated version of DefMI.
  // Rfalse is the first use.
  MachineInstrBuilder NewMI = BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                                      DefMI->getDesc(), DestReg);

  // Copy all the DefMI operands, excluding its (null) predicate.
  const MCInstrDesc &DefDesc = DefMI->getDesc();
  for (unsigned i = 1, e = DefDesc.getNumOperands();
       i != e && !DefDesc.OpInfo[i].isPredicate(); ++i)
    NewMI.addOperand(DefMI->getOperand(i));

  unsigned CondCode = MI->getOperand(3).getImm();
  if (Invert)
    NewMI.addImm(ARMCC::getOppositeCondition(ARMCC::CondCodes(CondCode)));
  else
    NewMI.addImm(CondCode);
  NewMI.addOperand(MI->getOperand(4));

  // DefMI is not the -S version that sets CPSR, so add an optional %noreg.
  if (NewMI->hasOptionalDef())
    AddDefaultCC(NewMI);

  // The output register value when the predicate is false is an implicit
  // register operand tied to the first def.
  // The tie makes the register allocator ensure the FalseReg is allocated the
  // same register as operand 0.
  FalseReg.setImplicit();
  NewMI.addOperand(FalseReg);
  NewMI->tieOperands(0, NewMI->getNumOperands() - 1);

  // Update SeenMIs set: register newly created MI and erase removed DefMI.
  SeenMIs.insert(NewMI);
  SeenMIs.erase(DefMI);

  // If MI is inside a loop, and DefMI is outside the loop, then kill flags on
  // DefMI would be invalid when tranferred inside the loop.  Checking for a
  // loop is expensive, but at least remove kill flags if they are in different
  // BBs.
  if (DefMI->getParent() != MI->getParent())
    NewMI->clearKillInfo();

  // The caller will erase MI, but not DefMI.
  DefMI->eraseFromParent();
  return NewMI;
}

/// Map pseudo instructions that imply an 'S' bit onto real opcodes. Whether the
/// instruction is encoded with an 'S' bit is determined by the optional CPSR
/// def operand.
///
/// This will go away once we can teach tblgen how to set the optional CPSR def
/// operand itself.
struct AddSubFlagsOpcodePair {
  uint16_t PseudoOpc;
  uint16_t MachineOpc;
};

static const AddSubFlagsOpcodePair AddSubFlagsOpcodeMap[] = {
  {ARM::ADDSri, ARM::ADDri},
  {ARM::ADDSrr, ARM::ADDrr},
  {ARM::ADDSrsi, ARM::ADDrsi},
  {ARM::ADDSrsr, ARM::ADDrsr},

  {ARM::SUBSri, ARM::SUBri},
  {ARM::SUBSrr, ARM::SUBrr},
  {ARM::SUBSrsi, ARM::SUBrsi},
  {ARM::SUBSrsr, ARM::SUBrsr},

  {ARM::RSBSri, ARM::RSBri},
  {ARM::RSBSrsi, ARM::RSBrsi},
  {ARM::RSBSrsr, ARM::RSBrsr},

  {ARM::t2ADDSri, ARM::t2ADDri},
  {ARM::t2ADDSrr, ARM::t2ADDrr},
  {ARM::t2ADDSrs, ARM::t2ADDrs},

  {ARM::t2SUBSri, ARM::t2SUBri},
  {ARM::t2SUBSrr, ARM::t2SUBrr},
  {ARM::t2SUBSrs, ARM::t2SUBrs},

  {ARM::t2RSBSri, ARM::t2RSBri},
  {ARM::t2RSBSrs, ARM::t2RSBrs},
};

unsigned llvm::convertAddSubFlagsOpcode(unsigned OldOpc) {
  for (unsigned i = 0, e = array_lengthof(AddSubFlagsOpcodeMap); i != e; ++i)
    if (OldOpc == AddSubFlagsOpcodeMap[i].PseudoOpc)
      return AddSubFlagsOpcodeMap[i].MachineOpc;
  return 0;
}

void llvm::emitARMRegPlusImmediate(MachineBasicBlock &MBB,
                               MachineBasicBlock::iterator &MBBI, DebugLoc dl,
                               unsigned DestReg, unsigned BaseReg, int NumBytes,
                               ARMCC::CondCodes Pred, unsigned PredReg,
                               const ARMBaseInstrInfo &TII, unsigned MIFlags) {
  if (NumBytes == 0 && DestReg != BaseReg) {
    BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), DestReg)
      .addReg(BaseReg, RegState::Kill)
      .addImm((unsigned)Pred).addReg(PredReg).addReg(0)
      .setMIFlags(MIFlags);
    return;
  }

  bool isSub = NumBytes < 0;
  if (isSub) NumBytes = -NumBytes;

  while (NumBytes) {
    unsigned RotAmt = ARM_AM::getSOImmValRotate(NumBytes);
    unsigned ThisVal = NumBytes & ARM_AM::rotr32(0xFF, RotAmt);
    assert(ThisVal && ""Didn't extract field correctly"");

    // We will handle these bits from offset, clear them.
    NumBytes &= ~ThisVal;

    assert(ARM_AM::getSOImmVal(ThisVal) != -1 && ""Bit extraction didn't work?"");

    // Build the new ADD / SUB.
    unsigned Opc = isSub ? ARM::SUBri : ARM::ADDri;
    BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg)
      .addReg(BaseReg, RegState::Kill).addImm(ThisVal)
      .addImm((unsigned)Pred).addReg(PredReg).addReg(0)
      .setMIFlags(MIFlags);
    BaseReg = DestReg;
  }
}

bool llvm::tryFoldSPUpdateIntoPushPop(const ARMSubtarget &Subtarget,
                                      MachineFunction &MF, MachineInstr *MI,
                                      unsigned NumBytes) {
  // This optimisation potentially adds lots of load and store
  // micro-operations, it's only really a great benefit to code-size.
  if (!MF.getFunction()->optForMinSize())
    return false;

  // If only one register is pushed/popped, LLVM can use an LDR/STR
  // instead. We can't modify those so make sure we're dealing with an
  // instruction we understand.
  bool IsPop = isPopOpcode(MI->getOpcode());
  bool IsPush = isPushOpcode(MI->getOpcode());
  if (!IsPush && !IsPop)
    return false;

  bool IsVFPPushPop = MI->getOpcode() == ARM::VSTMDDB_UPD ||
                      MI->getOpcode() == ARM::VLDMDIA_UPD;
  bool IsT1PushPop = MI->getOpcode() == ARM::tPUSH ||
                     MI->getOpcode() == ARM::tPOP ||
                     MI->getOpcode() == ARM::tPOP_RET;

  assert((IsT1PushPop || (MI->getOperand(0).getReg() == ARM::SP &&
                          MI->getOperand(1).getReg() == ARM::SP)) &&
         ""trying to fold sp update into non-sp-updating push/pop"");

  // The VFP push & pop act on D-registers, so we can only fold an adjustment
  // by a multiple of 8 bytes in correctly. Similarly rN is 4-bytes. Don't try
  // if this is violated.
  if (NumBytes % (IsVFPPushPop ? 8 : 4) != 0)
    return false;

  // ARM and Thumb2 push/pop insts have explicit ""sp, sp"" operands (+
  // pred) so the list starts at 4. Thumb1 starts after the predicate.
  int RegListIdx = IsT1PushPop ? 2 : 4;

  // Calculate the space we'll need in terms of registers.
  unsigned FirstReg = MI->getOperand(RegListIdx).getReg();
  unsigned RD0Reg, RegsNeeded;
  if (IsVFPPushPop) {
    RD0Reg = ARM::D0;
    RegsNeeded = NumBytes / 8;
  } else {
    RD0Reg = ARM::R0;
    RegsNeeded = NumBytes / 4;
  }

  // We're going to have to strip all list operands off before
  // re-adding them since the order matters, so save the existing ones
  // for later.
  SmallVector<MachineOperand, 4> RegList;
  for (int i = MI->getNumOperands() - 1; i >= RegListIdx; --i)
    RegList.push_back(MI->getOperand(i));

  const TargetRegisterInfo *TRI = MF.getRegInfo().getTargetRegisterInfo();
  const MCPhysReg *CSRegs = TRI->getCalleeSavedRegs(&MF);

  // Now try to find enough space in the reglist to allocate NumBytes.
  for (unsigned CurReg = FirstReg - 1; CurReg >= RD0Reg && RegsNeeded;
       --CurReg) {
    if (!IsPop) {
      // Pushing any register is completely harmless, mark the
      // register involved as undef since we don't care about it in
      // the slightest.
      RegList.push_back(MachineOperand::CreateReg(CurReg, false, false,
                                                  false, false, true));
      --RegsNeeded;
      continue;
    }

    // However, we can only pop an extra register if it's not live. For
    // registers live within the function we might clobber a return value
    // register; the other way a register can be live here is if it's
    // callee-saved.
    if (isCalleeSavedRegister(CurReg, CSRegs) ||
        MI->getParent()->computeRegisterLiveness(TRI, CurReg, MI) !=
        MachineBasicBlock::LQR_Dead) {
      // VFP pops don't allow holes in the register list, so any skip is fatal
      // for our transformation. GPR pops do, so we should just keep looking.
      if (IsVFPPushPop)
        return false;
      else
        continue;
    }

    // Mark the unimportant registers as <def,dead> in the POP.
    RegList.push_back(MachineOperand::CreateReg(CurReg, true, false, false,
                                                true));
    --RegsNeeded;
  }

  if (RegsNeeded > 0)
    return false;

  // Finally we know we can profitably perform the optimisation so go
  // ahead: strip all existing registers off and add them back again
  // in the right order.
  for (int i = MI->getNumOperands() - 1; i >= RegListIdx; --i)
    MI->RemoveOperand(i);

  // Add the complete list back in.
  MachineInstrBuilder MIB(MF, &*MI);
  for (int i = RegList.size() - 1; i >= 0; --i)
    MIB.addOperand(RegList[i]);

  return true;
}

bool llvm::rewriteARMFrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
                                unsigned FrameReg, int &Offset,
                                const ARMBaseInstrInfo &TII) {
  unsigned Opcode = MI.getOpcode();
  const MCInstrDesc &Desc = MI.getDesc();
  unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
  bool isSub = false;

  // Memory operands in inline assembly always use AddrMode2.
  if (Opcode == ARM::INLINEASM)
    AddrMode = ARMII::AddrMode2;

  if (Opcode == ARM::ADDri) {
    Offset += MI.getOperand(FrameRegIdx+1).getImm();
    if (Offset == 0) {
      // Turn it into a move.
      MI.setDesc(TII.get(ARM::MOVr));
      MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
      MI.RemoveOperand(FrameRegIdx+1);
      Offset = 0;
      return true;
    } else if (Offset < 0) {
      Offset = -Offset;
      isSub = true;
      MI.setDesc(TII.get(ARM::SUBri));
    }

    // Common case: small offset, fits into instruction.
    if (ARM_AM::getSOImmVal(Offset) != -1) {
      // Replace the FrameIndex with sp / fp
      MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
      MI.getOperand(FrameRegIdx+1).ChangeToImmediate(Offset);
      Offset = 0;
      return true;
    }

    // Otherwise, pull as much of the immedidate into this ADDri/SUBri
    // as possible.
    unsigned RotAmt = ARM_AM::getSOImmValRotate(Offset);
    unsigned ThisImmVal = Offset & ARM_AM::rotr32(0xFF, RotAmt);

    // We will handle these bits from offset, clear them.
    Offset &= ~ThisImmVal;

    // Get the properly encoded SOImmVal field.
    assert(ARM_AM::getSOImmVal(ThisImmVal) != -1 &&
           ""Bit extraction didn't work?"");
    MI.getOperand(FrameRegIdx+1).ChangeToImmediate(ThisImmVal);
 } else {
    unsigned ImmIdx = 0;
    int InstrOffs = 0;
    unsigned NumBits = 0;
    unsigned Scale = 1;
    switch (AddrMode) {
    case ARMII::AddrMode_i12: {
      ImmIdx = FrameRegIdx + 1;
      InstrOffs = MI.getOperand(ImmIdx).getImm();
      NumBits = 12;
      break;
    }
    case ARMII::AddrMode2: {
      ImmIdx = FrameRegIdx+2;
      InstrOffs = ARM_AM::getAM2Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM2Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 12;
      break;
    }
    case ARMII::AddrMode3: {
      ImmIdx = FrameRegIdx+2;
      InstrOffs = ARM_AM::getAM3Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM3Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 8;
      break;
    }
    case ARMII::AddrMode4:
    case ARMII::AddrMode6:
      // Can't fold any offset even if it's zero.
      return false;
    case ARMII::AddrMode5: {
      ImmIdx = FrameRegIdx+1;
      InstrOffs = ARM_AM::getAM5Offset(MI.getOperand(ImmIdx).getImm());
      if (ARM_AM::getAM5Op(MI.getOperand(ImmIdx).getImm()) == ARM_AM::sub)
        InstrOffs *= -1;
      NumBits = 8;
      Scale = 4;
      break;
    }
    default:
      llvm_unreachable(""Unsupported addressing mode!"");
    }

    Offset += InstrOffs * Scale;
    assert((Offset & (Scale-1)) == 0 && ""Can't encode this offset!"");
    if (Offset < 0) {
      Offset = -Offset;
      isSub = true;
    }

    // Attempt to fold address comp. if opcode has offset bits
    if (NumBits > 0) {
      // Common case: small offset, fits into instruction.
      MachineOperand &ImmOp = MI.getOperand(ImmIdx);
      int ImmedOffset = Offset / Scale;
      unsigned Mask = (1 << NumBits) - 1;
      if ((unsigned)Offset <= Mask * Scale) {
        // Replace the FrameIndex with sp
        MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
        // FIXME: When addrmode2 goes away, this will simplify (like the
        // T2 version), as the LDR.i12 versions don't need the encoding
        // tricks for the offset value.
        if (isSub) {
          if (AddrMode == ARMII::AddrMode_i12)
            ImmedOffset = -ImmedOffset;
          else
            ImmedOffset |= 1 << NumBits;
        }
        ImmOp.ChangeToImmediate(ImmedOffset);
        Offset = 0;
        return true;
      }

      // Otherwise, it didn't fit. Pull in what we can to simplify the immed.
      ImmedOffset = ImmedOffset & Mask;
      if (isSub) {
        if (AddrMode == ARMII::AddrMode_i12)
          ImmedOffset = -ImmedOffset;
        else
          ImmedOffset |= 1 << NumBits;
      }
      ImmOp.ChangeToImmediate(ImmedOffset);
      Offset &= ~(Mask*Scale);
    }
  }

  Offset = (isSub) ? -Offset : Offset;
  return Offset == 0;
}

/// analyzeCompare - For a comparison instruction, return the source registers
/// in SrcReg and SrcReg2 if having two register operands, and the value it
/// compares against in CmpValue. Return true if the comparison instruction
/// can be analyzed.
bool ARMBaseInstrInfo::
analyzeCompare(const MachineInstr *MI, unsigned &SrcReg, unsigned &SrcReg2,
               int &CmpMask, int &CmpValue) const {
  switch (MI->getOpcode()) {
  default: break;
  case ARM::CMPri:
  case ARM::t2CMPri:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = 0;
    CmpMask = ~0;
    CmpValue = MI->getOperand(1).getImm();
    return true;
  case ARM::CMPrr:
  case ARM::t2CMPrr:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = MI->getOperand(1).getReg();
    CmpMask = ~0;
    CmpValue = 0;
    return true;
  case ARM::TSTri:
  case ARM::t2TSTri:
    SrcReg = MI->getOperand(0).getReg();
    SrcReg2 = 0;
    CmpMask = MI->getOperand(1).getImm();
    CmpValue = 0;
    return true;
  }

  return false;
}

/// isSuitableForMask - Identify a suitable 'and' instruction that
/// operates on the given source register and applies the same mask
/// as a 'tst' instruction. Provide a limited look-through for copies.
/// When successful, MI will hold the found instruction.
static bool isSuitableForMask(MachineInstr *&MI, unsigned SrcReg,
                              int CmpMask, bool CommonUse) {
  switch (MI->getOpcode()) {
    case ARM::ANDri:
    case ARM::t2ANDri:
      if (CmpMask != MI->getOperand(2).getImm())
        return false;
      if (SrcReg == MI->getOperand(CommonUse ? 1 : 0).getReg())
        return true;
      break;
  }

  return false;
}

/// getSwappedCondition - assume the flags are set by MI(a,b), return
/// the condition code if we modify the instructions such that flags are
/// set by MI(b,a).
inline static ARMCC::CondCodes getSwappedCondition(ARMCC::CondCodes CC) {
  switch (CC) {
  default: return ARMCC::AL;
  case ARMCC::EQ: return ARMCC::EQ;
  case ARMCC::NE: return ARMCC::NE;
  case ARMCC::HS: return ARMCC::LS;
  case ARMCC::LO: return ARMCC::HI;
  case ARMCC::HI: return ARMCC::LO;
  case ARMCC::LS: return ARMCC::HS;
  case ARMCC::GE: return ARMCC::LE;
  case ARMCC::LT: return ARMCC::GT;
  case ARMCC::GT: return ARMCC::LT;
  case ARMCC::LE: return ARMCC::GE;
  }
}

/// isRedundantFlagInstr - check whether the first instruction, whose only
/// purpose is to update flags, can be made redundant.
/// CMPrr can be made redundant by SUBrr if the operands are the same.
/// CMPri can be made redundant by SUBri if the operands are the same.
/// This function can be extended later on.
inline static bool isRedundantFlagInstr(MachineInstr *CmpI, unsigned SrcReg,
                                        unsigned SrcReg2, int ImmValue,
                                        MachineInstr *OI) {
  if ((CmpI->getOpcode() == ARM::CMPrr ||
       CmpI->getOpcode() == ARM::t2CMPrr) &&
      (OI->getOpcode() == ARM::SUBrr ||
       OI->getOpcode() == ARM::t2SUBrr) &&
      ((OI->getOperand(1).getReg() == SrcReg &&
        OI->getOperand(2).getReg() == SrcReg2) ||
       (OI->getOperand(1).getReg() == SrcReg2 &&
        OI->getOperand(2).getReg() == SrcReg)))
    return true;

  if ((CmpI->getOpcode() == ARM::CMPri ||
       CmpI->getOpcode() == ARM::t2CMPri) &&
      (OI->getOpcode() == ARM::SUBri ||
       OI->getOpcode() == ARM::t2SUBri) &&
      OI->getOperand(1).getReg() == SrcReg &&
      OI->getOperand(2).getImm() == ImmValue)
    return true;
  return false;
}

/// optimizeCompareInstr - Convert the instruction supplying the argument to the
/// comparison into one that sets the zero bit in the flags register;
/// Remove a redundant Compare instruction if an earlier instruction can set the
/// flags in the same way as Compare.
/// E.g. SUBrr(r1,r2) and CMPrr(r1,r2). We also handle the case where two
/// operands are swapped: SUBrr(r1,r2) and CMPrr(r2,r1), by updating the
/// condition code of instructions which use the flags.
bool ARMBaseInstrInfo::
optimizeCompareInstr(MachineInstr *CmpInstr, unsigned SrcReg, unsigned SrcReg2,
                     int CmpMask, int CmpValue,
                     const MachineRegisterInfo *MRI) const {
  // Get the unique definition of SrcReg.
  MachineInstr *MI = MRI->getUniqueVRegDef(SrcReg);
  if (!MI) return false;

  // Masked compares sometimes use the same register as the corresponding 'and'.
  if (CmpMask != ~0) {
    if (!isSuitableForMask(MI, SrcReg, CmpMask, false) || isPredicated(MI)) {
      MI = nullptr;
      for (MachineRegisterInfo::use_instr_iterator
           UI = MRI->use_instr_begin(SrcReg), UE = MRI->use_instr_end();
           UI != UE; ++UI) {
        if (UI->getParent() != CmpInstr->getParent()) continue;
        MachineInstr *PotentialAND = &*UI;
        if (!isSuitableForMask(PotentialAND, SrcReg, CmpMask, true) ||
            isPredicated(PotentialAND))
          continue;
        MI = PotentialAND;
        break;
      }
      if (!MI) return false;
    }
  }

  // Get ready to iterate backward from CmpInstr.
  MachineBasicBlock::iterator I = CmpInstr, E = MI,
                              B = CmpInstr->getParent()->begin();

  // Early exit if CmpInstr is at the beginning of the BB.
  if (I == B) return false;

  // There are two possible candidates which can be changed to set CPSR:
  // One is MI, the other is a SUB instruction.
  // For CMPrr(r1,r2), we are looking for SUB(r1,r2) or SUB(r2,r1).
  // For CMPri(r1, CmpValue), we are looking for SUBri(r1, CmpValue).
  MachineInstr *Sub = nullptr;
  if (SrcReg2 != 0)
    // MI is not a candidate for CMPrr.
    MI = nullptr;
  else if (MI->getParent() != CmpInstr->getParent() || CmpValue != 0) {
    // Conservatively refuse to convert an instruction which isn't in the same
    // BB as the comparison.
    // For CMPri w/ CmpValue != 0, a Sub may still be a candidate.
    // Thus we cannot return here.
    if (CmpInstr->getOpcode() == ARM::CMPri ||
       CmpInstr->getOpcode() == ARM::t2CMPri)
      MI = nullptr;
    else
      return false;
  }

  // Check that CPSR isn't set between the comparison instruction and the one we
  // want to change. At the same time, search for Sub.
  const TargetRegisterInfo *TRI = &getRegisterInfo();
  --I;
  for (; I != E; --I) {
    const MachineInstr &Instr = *I;

    if (Instr.modifiesRegister(ARM::CPSR, TRI) ||
        Instr.readsRegister(ARM::CPSR, TRI))
      // This instruction modifies or uses CPSR after the one we want to
      // change. We can't do this transformation.
      return false;

    // Check whether CmpInstr can be made redundant by the current instruction.
    if (isRedundantFlagInstr(CmpInstr, SrcReg, SrcReg2, CmpValue, &*I)) {
      Sub = &*I;
      break;
    }

    if (I == B)
      // The 'and' is below the comparison instruction.
      return false;
  }

  // Return false if no candidates exist.
  if (!MI && !Sub)
    return false;

  // The single candidate is called MI.
  if (!MI) MI = Sub;

  // We can't use a predicated instruction - it doesn't always write the flags.
  if (isPredicated(MI))
    return false;

  switch (MI->getOpcode()) {
  default: break;
  case ARM::RSBrr:
  case ARM::RSBri:
  case ARM::RSCrr:
  case ARM::RSCri:
  case ARM::ADDrr:
  case ARM::ADDri:
  case ARM::ADCrr:
  case ARM::ADCri:
  case ARM::SUBrr:
  case ARM::SUBri:
  case ARM::SBCrr:
  case ARM::SBCri:
  case ARM::t2RSBri:
  case ARM::t2ADDrr:
  case ARM::t2ADDri:
  case ARM::t2ADCrr:
  case ARM::t2ADCri:
  case ARM::t2SUBrr:
  case ARM::t2SUBri:
  case ARM::t2SBCrr:
  case ARM::t2SBCri:
  case ARM::ANDrr:
  case ARM::ANDri:
  case ARM::t2ANDrr:
  case ARM::t2ANDri:
  case ARM::ORRrr:
  case ARM::ORRri:
  case ARM::t2ORRrr:
  case ARM::t2ORRri:
  case ARM::EORrr:
  case ARM::EORri:
  case ARM::t2EORrr:
  case ARM::t2EORri: {
    // Scan forward for the use of CPSR
    // When checking against MI: if it's a conditional code that requires
    // checking of the V bit or C bit, then this is not safe to do.
    // It is safe to remove CmpInstr if CPSR is redefined or killed.
    // If we are done with the basic block, we need to check whether CPSR is
    // live-out.
    SmallVector<std::pair<MachineOperand*, ARMCC::CondCodes>, 4>
        OperandsToUpdate;
    bool isSafe = false;
    I = CmpInstr;
    E = CmpInstr->getParent()->end();
    while (!isSafe && ++I != E) {
      const MachineInstr &Instr = *I;
      for (unsigned IO = 0, EO = Instr.getNumOperands();
           !isSafe && IO != EO; ++IO) {
        const MachineOperand &MO = Instr.getOperand(IO);
        if (MO.isRegMask() && MO.clobbersPhysReg(ARM::CPSR)) {
          isSafe = true;
          break;
        }
        if (!MO.isReg() || MO.getReg() != ARM::CPSR)
          continue;
        if (MO.isDef()) {
          isSafe = true;
          break;
        }
        // Condition code is after the operand before CPSR except for VSELs.
        ARMCC::CondCodes CC;
        bool IsInstrVSel = true;
        switch (Instr.getOpcode()) {
        default:
          IsInstrVSel = false;
          CC = (ARMCC::CondCodes)Instr.getOperand(IO - 1).getImm();
          break;
        case ARM::VSELEQD:
        case ARM::VSELEQS:
          CC = ARMCC::EQ;
          break;
        case ARM::VSELGTD:
        case ARM::VSELGTS:
          CC = ARMCC::GT;
          break;
        case ARM::VSELGED:
        case ARM::VSELGES:
          CC = ARMCC::GE;
          break;
        case ARM::VSELVSS:
        case ARM::VSELVSD:
          CC = ARMCC::VS;
          break;
        }

        if (Sub) {
          ARMCC::CondCodes NewCC = getSwappedCondition(CC);
          if (NewCC == ARMCC::AL)
            return false;
          // If we have SUB(r1, r2) and CMP(r2, r1), the condition code based
          // on CMP needs to be updated to be based on SUB.
          // Push the condition code operands to OperandsToUpdate.
          // If it is safe to remove CmpInstr, the condition code of these
          // operands will be modified.
          if (SrcReg2 != 0 && Sub->getOperand(1).getReg() == SrcReg2 &&
              Sub->getOperand(2).getReg() == SrcReg) {
            // VSel doesn't support condition code update.
            if (IsInstrVSel)
              return false;
            OperandsToUpdate.push_back(
                std::make_pair(&((*I).getOperand(IO - 1)), NewCC));
          }
        } else {
          // No Sub, so this is x = <op> y, z; cmp x, 0.
          switch (CC) {
          case ARMCC::EQ: // Z
          case ARMCC::NE: // Z
          case ARMCC::MI: // N
          case ARMCC::PL: // N
          case ARMCC::AL: // none
            // CPSR can be used multiple times, we should continue.
            break;
          case ARMCC::HS: // C
          case ARMCC::LO: // C
          case ARMCC::VS: // V
          case ARMCC::VC: // V
          case ARMCC::HI: // C Z
          case ARMCC::LS: // C Z
          case ARMCC::GE: // N V
          case ARMCC::LT: // N V
          case ARMCC::GT: // Z N V
          case ARMCC::LE: // Z N V
            // The instruction uses the V bit or C bit which is not safe.
            return false;
          }
        }
      }
    }

    // If CPSR is not killed nor re-defined, we should check whether it is
    // live-out. If it is live-out, do not optimize.
    if (!isSafe) {
      MachineBasicBlock *MBB = CmpInstr->getParent();
      for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
               SE = MBB->succ_end(); SI != SE; ++SI)
        if ((*SI)->isLiveIn(ARM::CPSR))
          return false;
    }

    // Toggle the optional operand to CPSR.
    MI->getOperand(5).setReg(ARM::CPSR);
    MI->getOperand(5).setIsDef(true);
    assert(!isPredicated(MI) && ""Can't use flags from predicated instruction"");
    CmpInstr->eraseFromParent();

    // Modify the condition code of operands in OperandsToUpdate.
    // Since we have SUB(r1, r2) and CMP(r2, r1), the condition code needs to
    // be changed from r2 > r1 to r1 < r2, from r2 < r1 to r1 > r2, etc.
    for (unsigned i = 0, e = OperandsToUpdate.size(); i < e; i++)
      OperandsToUpdate[i].first->setImm(OperandsToUpdate[i].second);
    return true;
  }
  }

  return false;
}

bool ARMBaseInstrInfo::FoldImmediate(MachineInstr *UseMI,
                                     MachineInstr *DefMI, unsigned Reg,
                                     MachineRegisterInfo *MRI) const {
  // Fold large immediates into add, sub, or, xor.
  unsigned DefOpc = DefMI->getOpcode();
  if (DefOpc != ARM::t2MOVi32imm && DefOpc != ARM::MOVi32imm)
    return false;
  if (!DefMI->getOperand(1).isImm())
    // Could be t2MOVi32imm <ga:xx>
    return false;

  if (!MRI->hasOneNonDBGUse(Reg))
    return false;

  const MCInstrDesc &DefMCID = DefMI->getDesc();
  if (DefMCID.hasOptionalDef()) {
    unsigned NumOps = DefMCID.getNumOperands();
    const MachineOperand &MO = DefMI->getOperand(NumOps-1);
    if (MO.getReg() == ARM::CPSR && !MO.isDead())
      // If DefMI defines CPSR and it is not dead, it's obviously not safe
      // to delete DefMI.
      return false;
  }

  const MCInstrDesc &UseMCID = UseMI->getDesc();
  if (UseMCID.hasOptionalDef()) {
    unsigned NumOps = UseMCID.getNumOperands();
    if (UseMI->getOperand(NumOps-1).getReg() == ARM::CPSR)
      // If the instruction sets the flag, do not attempt this optimization
      // since it may change the semantics of the code.
      return false;
  }

  unsigned UseOpc = UseMI->getOpcode();
  unsigned NewUseOpc = 0;
  uint32_t ImmVal = (uint32_t)DefMI->getOperand(1).getImm();
  uint32_t SOImmValV1 = 0, SOImmValV2 = 0;
  bool Commute = false;
  switch (UseOpc) {
  default: return false;
  case ARM::SUBrr:
  case ARM::ADDrr:
  case ARM::ORRrr:
  case ARM::EORrr:
  case ARM::t2SUBrr:
  case ARM::t2ADDrr:
  case ARM::t2ORRrr:
  case ARM::t2EORrr: {
    Commute = UseMI->getOperand(2).getReg() != Reg;
    switch (UseOpc) {
    default: break;
    case ARM::SUBrr: {
      if (Commute)
        return false;
      ImmVal = -ImmVal;
      NewUseOpc = ARM::SUBri;
      // Fallthrough
    }
    case ARM::ADDrr:
    case ARM::ORRrr:
    case ARM::EORrr: {
      if (!ARM_AM::isSOImmTwoPartVal(ImmVal))
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getSOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getSOImmTwoPartSecond(ImmVal);
      switch (UseOpc) {
      default: break;
      case ARM::ADDrr: NewUseOpc = ARM::ADDri; break;
      case ARM::ORRrr: NewUseOpc = ARM::ORRri; break;
      case ARM::EORrr: NewUseOpc = ARM::EORri; break;
      }
      break;
    }
    case ARM::t2SUBrr: {
      if (Commute)
        return false;
      ImmVal = -ImmVal;
      NewUseOpc = ARM::t2SUBri;
      // Fallthrough
    }
    case ARM::t2ADDrr:
    case ARM::t2ORRrr:
    case ARM::t2EORrr: {
      if (!ARM_AM::isT2SOImmTwoPartVal(ImmVal))
        return false;
      SOImmValV1 = (uint32_t)ARM_AM::getT2SOImmTwoPartFirst(ImmVal);
      SOImmValV2 = (uint32_t)ARM_AM::getT2SOImmTwoPartSecond(ImmVal);
      switch (UseOpc) {
      default: break;
      case ARM::t2ADDrr: NewUseOpc = ARM::t2ADDri; break;
      case ARM::t2ORRrr: NewUseOpc = ARM::t2ORRri; break;
      case ARM::t2EORrr: NewUseOpc = ARM::t2EORri; break;
      }
      break;
    }
    }
  }
  }

  unsigned OpIdx = Commute ? 2 : 1;
  unsigned Reg1 = UseMI->getOperand(OpIdx).getReg();
  bool isKill = UseMI->getOperand(OpIdx).isKill();
  unsigned NewReg = MRI->createVirtualRegister(MRI->getRegClass(Reg));
  AddDefaultCC(AddDefaultPred(BuildMI(*UseMI->getParent(),
                                      UseMI, UseMI->getDebugLoc(),
                                      get(NewUseOpc), NewReg)
                              .addReg(Reg1, getKillRegState(isKill))
                              .addImm(SOImmValV1)));
  UseMI->setDesc(get(NewUseOpc));
  UseMI->getOperand(1).setReg(NewReg);
  UseMI->getOperand(1).setIsKill();
  UseMI->getOperand(2).ChangeToImmediate(SOImmValV2);
  DefMI->eraseFromParent();
  return true;
}

static unsigned getNumMicroOpsSwiftLdSt(const InstrItineraryData *ItinData,
                                        const MachineInstr *MI) {
  switch (MI->getOpcode()) {
  default: {
    const MCInstrDesc &Desc = MI->getDesc();
    int UOps = ItinData->getNumMicroOps(Desc.getSchedClass());
    assert(UOps >= 0 && ""bad # UOps"");
    return UOps;
  }

  case ARM::LDRrs:
  case ARM::LDRBrs:
  case ARM::STRrs:
  case ARM::STRBrs: {
    unsigned ShOpVal = MI->getOperand(3).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 1;
    return 2;
  }

  case ARM::LDRH:
  case ARM::STRH: {
    if (!MI->getOperand(2).getReg())
      return 1;

    unsigned ShOpVal = MI->getOperand(3).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 1;
    return 2;
  }

  case ARM::LDRSB:
  case ARM::LDRSH:
    return (ARM_AM::getAM3Op(MI->getOperand(3).getImm()) == ARM_AM::sub) ? 3:2;

  case ARM::LDRSB_POST:
  case ARM::LDRSH_POST: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    return (Rt == Rm) ? 4 : 3;
  }

  case ARM::LDR_PRE_REG:
  case ARM::LDRB_PRE_REG: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rt == Rm)
      return 3;
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 2;
    return 3;
  }

  case ARM::STR_PRE_REG:
  case ARM::STRB_PRE_REG: {
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 2;
    return 3;
  }

  case ARM::LDRH_PRE:
  case ARM::STRH_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (!Rm)
      return 2;
    if (Rt == Rm)
      return 3;
    return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub)
      ? 3 : 2;
  }

  case ARM::LDR_POST_REG:
  case ARM::LDRB_POST_REG:
  case ARM::LDRH_POST: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    return (Rt == Rm) ? 3 : 2;
  }

  case ARM::LDR_PRE_IMM:
  case ARM::LDRB_PRE_IMM:
  case ARM::LDR_POST_IMM:
  case ARM::LDRB_POST_IMM:
  case ARM::STRB_POST_IMM:
  case ARM::STRB_POST_REG:
  case ARM::STRB_PRE_IMM:
  case ARM::STRH_POST:
  case ARM::STR_POST_IMM:
  case ARM::STR_POST_REG:
  case ARM::STR_PRE_IMM:
    return 2;

  case ARM::LDRSB_PRE:
  case ARM::LDRSH_PRE: {
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm == 0)
      return 3;
    unsigned Rt = MI->getOperand(0).getReg();
    if (Rt == Rm)
      return 4;
    unsigned ShOpVal = MI->getOperand(4).getImm();
    bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
    unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
    if (!isSub &&
        (ShImm == 0 ||
         ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
          ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
      return 3;
    return 4;
  }

  case ARM::LDRD: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(2).getReg();
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub) ?4:3;
    return (Rt == Rn) ? 3 : 2;
  }

  case ARM::STRD: {
    unsigned Rm = MI->getOperand(3).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(4).getImm()) == ARM_AM::sub) ?4:3;
    return 2;
  }

  case ARM::LDRD_POST:
  case ARM::t2LDRD_POST:
    return 3;

  case ARM::STRD_POST:
  case ARM::t2STRD_POST:
    return 4;

  case ARM::LDRD_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(3).getReg();
    unsigned Rm = MI->getOperand(4).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(5).getImm()) == ARM_AM::sub) ?5:4;
    return (Rt == Rn) ? 4 : 3;
  }

  case ARM::t2LDRD_PRE: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(3).getReg();
    return (Rt == Rn) ? 4 : 3;
  }

  case ARM::STRD_PRE: {
    unsigned Rm = MI->getOperand(4).getReg();
    if (Rm)
      return (ARM_AM::getAM3Op(MI->getOperand(5).getImm()) == ARM_AM::sub) ?5:4;
    return 3;
  }

  case ARM::t2STRD_PRE:
    return 3;

  case ARM::t2LDR_POST:
  case ARM::t2LDRB_POST:
  case ARM::t2LDRB_PRE:
  case ARM::t2LDRSBi12:
  case ARM::t2LDRSBi8:
  case ARM::t2LDRSBpci:
  case ARM::t2LDRSBs:
  case ARM::t2LDRH_POST:
  case ARM::t2LDRH_PRE:
  case ARM::t2LDRSBT:
  case ARM::t2LDRSB_POST:
  case ARM::t2LDRSB_PRE:
  case ARM::t2LDRSH_POST:
  case ARM::t2LDRSH_PRE:
  case ARM::t2LDRSHi12:
  case ARM::t2LDRSHi8:
  case ARM::t2LDRSHpci:
  case ARM::t2LDRSHs:
    return 2;

  case ARM::t2LDRDi8: {
    unsigned Rt = MI->getOperand(0).getReg();
    unsigned Rn = MI->getOperand(2).getReg();
    return (Rt == Rn) ? 3 : 2;
  }

  case ARM::t2STRB_POST:
  case ARM::t2STRB_PRE:
  case ARM::t2STRBs:
  case ARM::t2STRDi8:
  case ARM::t2STRH_POST:
  case ARM::t2STRH_PRE:
  case ARM::t2STRHs:
  case ARM::t2STR_POST:
  case ARM::t2STR_PRE:
  case ARM::t2STRs:
    return 2;
  }
}

// Return the number of 32-bit words loaded by LDM or stored by STM. If this
// can't be easily determined return 0 (missing MachineMemOperand).
//
// FIXME: The current MachineInstr design does not support relying on machine
// mem operands to determine the width of a memory access. Instead, we expect
// the target to provide this information based on the instruction opcode and
// operands. However, using MachineMemOperand is the best solution now for
// two reasons:
//
// 1) getNumMicroOps tries to infer LDM memory width from the total number of MI
// operands. This is much more dangerous than using the MachineMemOperand
// sizes because CodeGen passes can insert/remove optional machine operands. In
// fact, it's totally incorrect for preRA passes and appears to be wrong for
// postRA passes as well.
//
// 2) getNumLDMAddresses is only used by the scheduling machine model and any
// machine model that calls this should handle the unknown (zero size) case.
//
// Long term, we should require a target hook that verifies MachineMemOperand
// sizes during MC lowering. That target hook should be local to MC lowering
// because we can't ensure that it is aware of other MI forms. Doing this will
// ensure that MachineMemOperands are correctly propagated through all passes.
unsigned ARMBaseInstrInfo::getNumLDMAddresses(const MachineInstr *MI) const {
  unsigned Size = 0;
  for (MachineInstr::mmo_iterator I = MI->memoperands_begin(),
         E = MI->memoperands_end(); I != E; ++I) {
    Size += (*I)->getSize();
  }
  return Size / 4;
}

unsigned
ARMBaseInstrInfo::getNumMicroOps(const InstrItineraryData *ItinData,
                                 const MachineInstr *MI) const {
  if (!ItinData || ItinData->isEmpty())
    return 1;

  const MCInstrDesc &Desc = MI->getDesc();
  unsigned Class = Desc.getSchedClass();
  int ItinUOps = ItinData->getNumMicroOps(Class);
  if (ItinUOps >= 0) {
    if (Subtarget.isSwift() && (Desc.mayLoad() || Desc.mayStore()))
      return getNumMicroOpsSwiftLdSt(ItinData, MI);

    return ItinUOps;
  }

  unsigned Opc = MI->getOpcode();
  switch (Opc) {
  default:
    llvm_unreachable(""Unexpected multi-uops instruction!"");
  case ARM::VLDMQIA:
  case ARM::VSTMQIA:
    return 2;

  // The number of uOps for load / store multiple are determined by the number
  // registers.
  //
  // On Cortex-A8, each pair of register loads / stores can be scheduled on the
  // same cycle. The scheduling for the first load / store must be done
  // separately by assuming the address is not 64-bit aligned.
  //
  // On Cortex-A9, the formula is simply (#reg / 2) + (#reg % 2). If the address
  // is not 64-bit aligned, then AGU would take an extra cycle.  For VFP / NEON
  // load / store multiple, the formula is (#reg / 2) + (#reg % 2) + 1.
  case ARM::VLDMDIA:
  case ARM::VLDMDIA_UPD:
  case ARM::VLDMDDB_UPD:
  case ARM::VLDMSIA:
  case ARM::VLDMSIA_UPD:
  case ARM::VLDMSDB_UPD:
  case ARM::VSTMDIA:
  case ARM::VSTMDIA_UPD:
  case ARM::VSTMDDB_UPD:
  case ARM::VSTMSIA:
  case ARM::VSTMSIA_UPD:
  case ARM::VSTMSDB_UPD: {
    unsigned NumRegs = MI->getNumOperands() - Desc.getNumOperands();
    return (NumRegs / 2) + (NumRegs % 2) + 1;
  }

  case ARM::LDMIA_RET:
  case ARM::LDMIA:
  case ARM::LDMDA:
  case ARM::LDMDB:
  case ARM::LDMIB:
  case ARM::LDMIA_UPD:
  case ARM::LDMDA_UPD:
  case ARM::LDMDB_UPD:
  case ARM::LDMIB_UPD:
  case ARM::STMIA:
  case ARM::STMDA:
  case ARM::STMDB:
  case ARM::STMIB:
  case ARM::STMIA_UPD:
  case ARM::STMDA_UPD:
  case ARM::STMDB_UPD:
  case ARM::STMIB_UPD:
  case ARM::tLDMIA:
  case ARM::tLDMIA_UPD:
  case ARM::tSTMIA_UPD:
  case ARM::tPOP_RET:
  case ARM::tPOP:
  case ARM::tPUSH:
  case ARM::t2LDMIA_RET:
  case ARM::t2LDMIA:
  case ARM::t2LDMDB:
  case ARM::t2LDMIA_UPD:
  case ARM::t2LDMDB_UPD:
  case ARM::t2STMIA:
  case ARM::t2STMDB:
  case ARM::t2STMIA_UPD:
  case ARM::t2STMDB_UPD: {
    unsigned NumRegs = MI->getNumOperands() - Desc.getNumOperands() + 1;
    if (Subtarget.isSwift()) {
      int UOps = 1 + NumRegs;  // One for address computation, one for each ld / st.
      switch (Opc) {
      default: break;
      case ARM::VLDMDIA_UPD:
      case ARM::VLDMDDB_UPD:
      case ARM::VLDMSIA_UPD:
      case ARM::VLDMSDB_UPD:
      case ARM::VSTMDIA_UPD:
      case ARM::VSTMDDB_UPD:
      case ARM::VSTMSIA_UPD:
      case ARM::VSTMSDB_UPD:
      case ARM::LDMIA_UPD:
      case ARM::LDMDA_UPD:
      case ARM::LDMDB_UPD:
      case ARM::LDMIB_UPD:
      case ARM::STMIA_UPD:
      case ARM::STMDA_UPD:
      case ARM::STMDB_UPD:
      case ARM::STMIB_UPD:
      case ARM::tLDMIA_UPD:
      case ARM::tSTMIA_UPD:
      case ARM::t2LDMIA_UPD:
      case ARM::t2LDMDB_UPD:
      case ARM::t2STMIA_UPD:
      case ARM::t2STMDB_UPD:
        ++UOps; // One for base register writeback.
        break;
      case ARM::LDMIA_RET:
      case ARM::tPOP_RET:
      case ARM::t2LDMIA_RET:
        UOps += 2; // One for base reg wb, one for write to pc.
        break;
      }
      return UOps;
    } else if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
      if (NumRegs < 4)
        return 2;
      // 4 registers would be issued: 2, 2.
      // 5 registers would be issued: 2, 2, 1.
      int A8UOps = (NumRegs / 2);
      if (NumRegs % 2)
        ++A8UOps;
      return A8UOps;
    } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
      int A9UOps = (NumRegs / 2);
      // If there are odd number of registers or if it's not 64-bit aligned,
      // then it takes an extra AGU (Address Generation Unit) cycle.
      if ((NumRegs % 2) ||
          !MI->hasOneMemOperand() ||
          (*MI->memoperands_begin())->getAlignment() < 8)
        ++A9UOps;
      return A9UOps;
    } else {
      // Assume the worst.
      return NumRegs;
    }
  }
  }
}

int
ARMBaseInstrInfo::getVLDMDefCycle(const InstrItineraryData *ItinData,
                                  const MCInstrDesc &DefMCID,
                                  unsigned DefClass,
                                  unsigned DefIdx, unsigned DefAlign) const {
  int RegNo = (int)(DefIdx+1) - DefMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    // Def is the address writeback.
    return ItinData->getOperandCycle(DefClass, DefIdx);

  int DefCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // (regno / 2) + (regno % 2) + 1
    DefCycle = RegNo / 2 + 1;
    if (RegNo % 2)
      ++DefCycle;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    DefCycle = RegNo;
    bool isSLoad = false;

    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::VLDMSIA:
    case ARM::VLDMSIA_UPD:
    case ARM::VLDMSDB_UPD:
      isSLoad = true;
      break;
    }

    // If there are odd number of 'S' registers or if it's not 64-bit aligned,
    // then it takes an extra cycle.
    if ((isSLoad && (RegNo % 2)) || DefAlign < 8)
      ++DefCycle;
  } else {
    // Assume the worst.
    DefCycle = RegNo + 2;
  }

  return DefCycle;
}

int
ARMBaseInstrInfo::getLDMDefCycle(const InstrItineraryData *ItinData,
                                 const MCInstrDesc &DefMCID,
                                 unsigned DefClass,
                                 unsigned DefIdx, unsigned DefAlign) const {
  int RegNo = (int)(DefIdx+1) - DefMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    // Def is the address writeback.
    return ItinData->getOperandCycle(DefClass, DefIdx);

  int DefCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // 4 registers would be issued: 1, 2, 1.
    // 5 registers would be issued: 1, 2, 2.
    DefCycle = RegNo / 2;
    if (DefCycle < 1)
      DefCycle = 1;
    // Result latency is issue cycle + 2: E2.
    DefCycle += 2;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    DefCycle = (RegNo / 2);
    // If there are odd number of registers or if it's not 64-bit aligned,
    // then it takes an extra AGU (Address Generation Unit) cycle.
    if ((RegNo % 2) || DefAlign < 8)
      ++DefCycle;
    // Result latency is AGU cycles + 2.
    DefCycle += 2;
  } else {
    // Assume the worst.
    DefCycle = RegNo + 2;
  }

  return DefCycle;
}

int
ARMBaseInstrInfo::getVSTMUseCycle(const InstrItineraryData *ItinData,
                                  const MCInstrDesc &UseMCID,
                                  unsigned UseClass,
                                  unsigned UseIdx, unsigned UseAlign) const {
  int RegNo = (int)(UseIdx+1) - UseMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    return ItinData->getOperandCycle(UseClass, UseIdx);

  int UseCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    // (regno / 2) + (regno % 2) + 1
    UseCycle = RegNo / 2 + 1;
    if (RegNo % 2)
      ++UseCycle;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    UseCycle = RegNo;
    bool isSStore = false;

    switch (UseMCID.getOpcode()) {
    default: break;
    case ARM::VSTMSIA:
    case ARM::VSTMSIA_UPD:
    case ARM::VSTMSDB_UPD:
      isSStore = true;
      break;
    }

    // If there are odd number of 'S' registers or if it's not 64-bit aligned,
    // then it takes an extra cycle.
    if ((isSStore && (RegNo % 2)) || UseAlign < 8)
      ++UseCycle;
  } else {
    // Assume the worst.
    UseCycle = RegNo + 2;
  }

  return UseCycle;
}

int
ARMBaseInstrInfo::getSTMUseCycle(const InstrItineraryData *ItinData,
                                 const MCInstrDesc &UseMCID,
                                 unsigned UseClass,
                                 unsigned UseIdx, unsigned UseAlign) const {
  int RegNo = (int)(UseIdx+1) - UseMCID.getNumOperands() + 1;
  if (RegNo <= 0)
    return ItinData->getOperandCycle(UseClass, UseIdx);

  int UseCycle;
  if (Subtarget.isCortexA8() || Subtarget.isCortexA7()) {
    UseCycle = RegNo / 2;
    if (UseCycle < 2)
      UseCycle = 2;
    // Read in E3.
    UseCycle += 2;
  } else if (Subtarget.isLikeA9() || Subtarget.isSwift()) {
    UseCycle = (RegNo / 2);
    // If there are odd number of registers or if it's not 64-bit aligned,
    // then it takes an extra AGU (Address Generation Unit) cycle.
    if ((RegNo % 2) || UseAlign < 8)
      ++UseCycle;
  } else {
    // Assume the worst.
    UseCycle = 1;
  }
  return UseCycle;
}

int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    const MCInstrDesc &DefMCID,
                                    unsigned DefIdx, unsigned DefAlign,
                                    const MCInstrDesc &UseMCID,
                                    unsigned UseIdx, unsigned UseAlign) const {
  unsigned DefClass = DefMCID.getSchedClass();
  unsigned UseClass = UseMCID.getSchedClass();

  if (DefIdx < DefMCID.getNumDefs() && UseIdx < UseMCID.getNumOperands())
    return ItinData->getOperandLatency(DefClass, DefIdx, UseClass, UseIdx);

  // This may be a def / use of a variable_ops instruction, the operand
  // latency might be determinable dynamically. Let the target try to
  // figure it out.
  int DefCycle = -1;
  bool LdmBypass = false;
  switch (DefMCID.getOpcode()) {
  default:
    DefCycle = ItinData->getOperandCycle(DefClass, DefIdx);
    break;

  case ARM::VLDMDIA:
  case ARM::VLDMDIA_UPD:
  case ARM::VLDMDDB_UPD:
  case ARM::VLDMSIA:
  case ARM::VLDMSIA_UPD:
  case ARM::VLDMSDB_UPD:
    DefCycle = getVLDMDefCycle(ItinData, DefMCID, DefClass, DefIdx, DefAlign);
    break;

  case ARM::LDMIA_RET:
  case ARM::LDMIA:
  case ARM::LDMDA:
  case ARM::LDMDB:
  case ARM::LDMIB:
  case ARM::LDMIA_UPD:
  case ARM::LDMDA_UPD:
  case ARM::LDMDB_UPD:
  case ARM::LDMIB_UPD:
  case ARM::tLDMIA:
  case ARM::tLDMIA_UPD:
  case ARM::tPUSH:
  case ARM::t2LDMIA_RET:
  case ARM::t2LDMIA:
  case ARM::t2LDMDB:
  case ARM::t2LDMIA_UPD:
  case ARM::t2LDMDB_UPD:
    LdmBypass = 1;
    DefCycle = getLDMDefCycle(ItinData, DefMCID, DefClass, DefIdx, DefAlign);
    break;
  }

  if (DefCycle == -1)
    // We can't seem to determine the result latency of the def, assume it's 2.
    DefCycle = 2;

  int UseCycle = -1;
  switch (UseMCID.getOpcode()) {
  default:
    UseCycle = ItinData->getOperandCycle(UseClass, UseIdx);
    break;

  case ARM::VSTMDIA:
  case ARM::VSTMDIA_UPD:
  case ARM::VSTMDDB_UPD:
  case ARM::VSTMSIA:
  case ARM::VSTMSIA_UPD:
  case ARM::VSTMSDB_UPD:
    UseCycle = getVSTMUseCycle(ItinData, UseMCID, UseClass, UseIdx, UseAlign);
    break;

  case ARM::STMIA:
  case ARM::STMDA:
  case ARM::STMDB:
  case ARM::STMIB:
  case ARM::STMIA_UPD:
  case ARM::STMDA_UPD:
  case ARM::STMDB_UPD:
  case ARM::STMIB_UPD:
  case ARM::tSTMIA_UPD:
  case ARM::tPOP_RET:
  case ARM::tPOP:
  case ARM::t2STMIA:
  case ARM::t2STMDB:
  case ARM::t2STMIA_UPD:
  case ARM::t2STMDB_UPD:
    UseCycle = getSTMUseCycle(ItinData, UseMCID, UseClass, UseIdx, UseAlign);
    break;
  }

  if (UseCycle == -1)
    // Assume it's read in the first stage.
    UseCycle = 1;

  UseCycle = DefCycle - UseCycle + 1;
  if (UseCycle > 0) {
    if (LdmBypass) {
      // It's a variable_ops instruction so we can't use DefIdx here. Just use
      // first def operand.
      if (ItinData->hasPipelineForwarding(DefClass, DefMCID.getNumOperands()-1,
                                          UseClass, UseIdx))
        --UseCycle;
    } else if (ItinData->hasPipelineForwarding(DefClass, DefIdx,
                                               UseClass, UseIdx)) {
      --UseCycle;
    }
  }

  return UseCycle;
}

static const MachineInstr *getBundledDefMI(const TargetRegisterInfo *TRI,
                                           const MachineInstr *MI, unsigned Reg,
                                           unsigned &DefIdx, unsigned &Dist) {
  Dist = 0;

  MachineBasicBlock::const_iterator I = MI; ++I;
  MachineBasicBlock::const_instr_iterator II = std::prev(I.getInstrIterator());
  assert(II->isInsideBundle() && ""Empty bundle?"");

  int Idx = -1;
  while (II->isInsideBundle()) {
    Idx = II->findRegisterDefOperandIdx(Reg, false, true, TRI);
    if (Idx != -1)
      break;
    --II;
    ++Dist;
  }

  assert(Idx != -1 && ""Cannot find bundled definition!"");
  DefIdx = Idx;
  return &*II;
}

static const MachineInstr *getBundledUseMI(const TargetRegisterInfo *TRI,
                                           const MachineInstr *MI, unsigned Reg,
                                           unsigned &UseIdx, unsigned &Dist) {
  Dist = 0;

  MachineBasicBlock::const_instr_iterator II = ++MI->getIterator();
  assert(II->isInsideBundle() && ""Empty bundle?"");
  MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();

  // FIXME: This doesn't properly handle multiple uses.
  int Idx = -1;
  while (II != E && II->isInsideBundle()) {
    Idx = II->findRegisterUseOperandIdx(Reg, false, TRI);
    if (Idx != -1)
      break;
    if (II->getOpcode() != ARM::t2IT)
      ++Dist;
    ++II;
  }

  if (Idx == -1) {
    Dist = 0;
    return nullptr;
  }

  UseIdx = Idx;
  return &*II;
}

/// Return the number of cycles to add to (or subtract from) the static
/// itinerary based on the def opcode and alignment. The caller will ensure that
/// adjusted latency is at least one cycle.
static int adjustDefLatency(const ARMSubtarget &Subtarget,
                            const MachineInstr *DefMI,
                            const MCInstrDesc *DefMCID, unsigned DefAlign) {
  int Adjust = 0;
  if (Subtarget.isCortexA8() || Subtarget.isLikeA9() || Subtarget.isCortexA7()) {
    // FIXME: Shifter op hack: no shift (i.e. [r +/- r]) or [r + r << 2]
    // variants are one cycle cheaper.
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal = DefMI->getOperand(3).getImm();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          (ShImm == 2 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        --Adjust;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt = DefMI->getOperand(3).getImm();
      if (ShAmt == 0 || ShAmt == 2)
        --Adjust;
      break;
    }
    }
  } else if (Subtarget.isSwift()) {
    // FIXME: Properly handle all of the latency adjustments for address
    // writeback.
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal = DefMI->getOperand(3).getImm();
      bool isSub = ARM_AM::getAM2Op(ShOpVal) == ARM_AM::sub;
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (!isSub &&
          (ShImm == 0 ||
           ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
            ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl)))
        Adjust -= 2;
      else if (!isSub &&
               ShImm == 1 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsr)
        --Adjust;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt = DefMI->getOperand(3).getImm();
      if (ShAmt == 0 || ShAmt == 1 || ShAmt == 2 || ShAmt == 3)
        Adjust -= 2;
      break;
    }
    }
  }

  if (DefAlign < 8 && Subtarget.isLikeA9()) {
    switch (DefMCID->getOpcode()) {
    default: break;
    case ARM::VLD1q8:
    case ARM::VLD1q16:
    case ARM::VLD1q32:
    case ARM::VLD1q64:
    case ARM::VLD1q8wb_fixed:
    case ARM::VLD1q16wb_fixed:
    case ARM::VLD1q32wb_fixed:
    case ARM::VLD1q64wb_fixed:
    case ARM::VLD1q8wb_register:
    case ARM::VLD1q16wb_register:
    case ARM::VLD1q32wb_register:
    case ARM::VLD1q64wb_register:
    case ARM::VLD2d8:
    case ARM::VLD2d16:
    case ARM::VLD2d32:
    case ARM::VLD2q8:
    case ARM::VLD2q16:
    case ARM::VLD2q32:
    case ARM::VLD2d8wb_fixed:
    case ARM::VLD2d16wb_fixed:
    case ARM::VLD2d32wb_fixed:
    case ARM::VLD2q8wb_fixed:
    case ARM::VLD2q16wb_fixed:
    case ARM::VLD2q32wb_fixed:
    case ARM::VLD2d8wb_register:
    case ARM::VLD2d16wb_register:
    case ARM::VLD2d32wb_register:
    case ARM::VLD2q8wb_register:
    case ARM::VLD2q16wb_register:
    case ARM::VLD2q32wb_register:
    case ARM::VLD3d8:
    case ARM::VLD3d16:
    case ARM::VLD3d32:
    case ARM::VLD1d64T:
    case ARM::VLD3d8_UPD:
    case ARM::VLD3d16_UPD:
    case ARM::VLD3d32_UPD:
    case ARM::VLD1d64Twb_fixed:
    case ARM::VLD1d64Twb_register:
    case ARM::VLD3q8_UPD:
    case ARM::VLD3q16_UPD:
    case ARM::VLD3q32_UPD:
    case ARM::VLD4d8:
    case ARM::VLD4d16:
    case ARM::VLD4d32:
    case ARM::VLD1d64Q:
    case ARM::VLD4d8_UPD:
    case ARM::VLD4d16_UPD:
    case ARM::VLD4d32_UPD:
    case ARM::VLD1d64Qwb_fixed:
    case ARM::VLD1d64Qwb_register:
    case ARM::VLD4q8_UPD:
    case ARM::VLD4q16_UPD:
    case ARM::VLD4q32_UPD:
    case ARM::VLD1DUPq8:
    case ARM::VLD1DUPq16:
    case ARM::VLD1DUPq32:
    case ARM::VLD1DUPq8wb_fixed:
    case ARM::VLD1DUPq16wb_fixed:
    case ARM::VLD1DUPq32wb_fixed:
    case ARM::VLD1DUPq8wb_register:
    case ARM::VLD1DUPq16wb_register:
    case ARM::VLD1DUPq32wb_register:
    case ARM::VLD2DUPd8:
    case ARM::VLD2DUPd16:
    case ARM::VLD2DUPd32:
    case ARM::VLD2DUPd8wb_fixed:
    case ARM::VLD2DUPd16wb_fixed:
    case ARM::VLD2DUPd32wb_fixed:
    case ARM::VLD2DUPd8wb_register:
    case ARM::VLD2DUPd16wb_register:
    case ARM::VLD2DUPd32wb_register:
    case ARM::VLD4DUPd8:
    case ARM::VLD4DUPd16:
    case ARM::VLD4DUPd32:
    case ARM::VLD4DUPd8_UPD:
    case ARM::VLD4DUPd16_UPD:
    case ARM::VLD4DUPd32_UPD:
    case ARM::VLD1LNd8:
    case ARM::VLD1LNd16:
    case ARM::VLD1LNd32:
    case ARM::VLD1LNd8_UPD:
    case ARM::VLD1LNd16_UPD:
    case ARM::VLD1LNd32_UPD:
    case ARM::VLD2LNd8:
    case ARM::VLD2LNd16:
    case ARM::VLD2LNd32:
    case ARM::VLD2LNq16:
    case ARM::VLD2LNq32:
    case ARM::VLD2LNd8_UPD:
    case ARM::VLD2LNd16_UPD:
    case ARM::VLD2LNd32_UPD:
    case ARM::VLD2LNq16_UPD:
    case ARM::VLD2LNq32_UPD:
    case ARM::VLD4LNd8:
    case ARM::VLD4LNd16:
    case ARM::VLD4LNd32:
    case ARM::VLD4LNq16:
    case ARM::VLD4LNq32:
    case ARM::VLD4LNd8_UPD:
    case ARM::VLD4LNd16_UPD:
    case ARM::VLD4LNd32_UPD:
    case ARM::VLD4LNq16_UPD:
    case ARM::VLD4LNq32_UPD:
      // If the address is not 64-bit aligned, the latencies of these
      // instructions increases by one.
      ++Adjust;
      break;
    }
  }
  return Adjust;
}



int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    const MachineInstr *DefMI, unsigned DefIdx,
                                    const MachineInstr *UseMI,
                                    unsigned UseIdx) const {
  // No operand latency. The caller may fall back to getInstrLatency.
  if (!ItinData || ItinData->isEmpty())
    return -1;

  const MachineOperand &DefMO = DefMI->getOperand(DefIdx);
  unsigned Reg = DefMO.getReg();
  const MCInstrDesc *DefMCID = &DefMI->getDesc();
  const MCInstrDesc *UseMCID = &UseMI->getDesc();

  unsigned DefAdj = 0;
  if (DefMI->isBundle()) {
    DefMI = getBundledDefMI(&getRegisterInfo(), DefMI, Reg, DefIdx, DefAdj);
    DefMCID = &DefMI->getDesc();
  }
  if (DefMI->isCopyLike() || DefMI->isInsertSubreg() ||
      DefMI->isRegSequence() || DefMI->isImplicitDef()) {
    return 1;
  }

  unsigned  [MASK]  = 0;
  if (UseMI->isBundle()) {
    unsigned NewUseIdx;
    const MachineInstr *NewUseMI = getBundledUseMI(&getRegisterInfo(), UseMI,
                                                   Reg, NewUseIdx,  [MASK] );
    if (!NewUseMI)
      return -1;

    UseMI = NewUseMI;
    UseIdx = NewUseIdx;
    UseMCID = &UseMI->getDesc();
  }

  if (Reg == ARM::CPSR) {
    if (DefMI->getOpcode() == ARM::FMSTAT) {
      // fpscr -> cpsr stalls over 20 cycles on A8 (and earlier?)
      return Subtarget.isLikeA9() ? 1 : 20;
    }

    // CPSR set and branch can be paired in the same cycle.
    if (UseMI->isBranch())
      return 0;

    // Otherwise it takes the instruction latency (generally one).
    unsigned Latency = getInstrLatency(ItinData, DefMI);

    // For Thumb2 and -Os, prefer scheduling CPSR setting instruction close to
    // its uses. Instructions which are otherwise scheduled between them may
    // incur a code size penalty (not able to use the CPSR setting 16-bit
    // instructions).
    if (Latency > 0 && Subtarget.isThumb2()) {
      const MachineFunction *MF = DefMI->getParent()->getParent();
      // FIXME: Use Function::optForSize().
      if (MF->getFunction()->hasFnAttribute(Attribute::OptimizeForSize))
        --Latency;
    }
    return Latency;
  }

  if (DefMO.isImplicit() || UseMI->getOperand(UseIdx).isImplicit())
    return -1;

  unsigned DefAlign = DefMI->hasOneMemOperand()
    ? (*DefMI->memoperands_begin())->getAlignment() : 0;
  unsigned UseAlign = UseMI->hasOneMemOperand()
    ? (*UseMI->memoperands_begin())->getAlignment() : 0;

  // Get the itinerary's latency if possible, and handle variable_ops.
  int Latency = getOperandLatency(ItinData, *DefMCID, DefIdx, DefAlign,
                                  *UseMCID, UseIdx, UseAlign);
  // Unable to find operand latency. The caller may resort to getInstrLatency.
  if (Latency < 0)
    return Latency;

  // Adjust for IT block position.
  int Adj = DefAdj +  [MASK] ;

  // Adjust for dynamic def-side opcode variants not captured by the itinerary.
  Adj += adjustDefLatency(Subtarget, DefMI, DefMCID, DefAlign);
  if (Adj >= 0 || (int)Latency > -Adj) {
    return Latency + Adj;
  }
  // Return the itinerary latency, which may be zero but not less than zero.
  return Latency;
}

int
ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                    SDNode *DefNode, unsigned DefIdx,
                                    SDNode *UseNode, unsigned UseIdx) const {
  if (!DefNode->isMachineOpcode())
    return 1;

  const MCInstrDesc &DefMCID = get(DefNode->getMachineOpcode());

  if (isZeroCost(DefMCID.Opcode))
    return 0;

  if (!ItinData || ItinData->isEmpty())
    return DefMCID.mayLoad() ? 3 : 1;

  if (!UseNode->isMachineOpcode()) {
    int Latency = ItinData->getOperandCycle(DefMCID.getSchedClass(), DefIdx);
    if (Subtarget.isLikeA9() || Subtarget.isSwift())
      return Latency <= 2 ? 1 : Latency - 1;
    else
      return Latency <= 3 ? 1 : Latency - 2;
  }

  const MCInstrDesc &UseMCID = get(UseNode->getMachineOpcode());
  const MachineSDNode *DefMN = dyn_cast<MachineSDNode>(DefNode);
  unsigned DefAlign = !DefMN->memoperands_empty()
    ? (*DefMN->memoperands_begin())->getAlignment() : 0;
  const MachineSDNode *UseMN = dyn_cast<MachineSDNode>(UseNode);
  unsigned UseAlign = !UseMN->memoperands_empty()
    ? (*UseMN->memoperands_begin())->getAlignment() : 0;
  int Latency = getOperandLatency(ItinData, DefMCID, DefIdx, DefAlign,
                                  UseMCID, UseIdx, UseAlign);

  if (Latency > 1 &&
      (Subtarget.isCortexA8() || Subtarget.isLikeA9() ||
       Subtarget.isCortexA7())) {
    // FIXME: Shifter op hack: no shift (i.e. [r +/- r]) or [r + r << 2]
    // variants are one cycle cheaper.
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          (ShImm == 2 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        --Latency;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl only.
      unsigned ShAmt =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      if (ShAmt == 0 || ShAmt == 2)
        --Latency;
      break;
    }
    }
  } else if (DefIdx == 0 && Latency > 2 && Subtarget.isSwift()) {
    // FIXME: Properly handle all of the latency adjustments for address
    // writeback.
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::LDRrs:
    case ARM::LDRBrs: {
      unsigned ShOpVal =
        cast<ConstantSDNode>(DefNode->getOperand(2))->getZExtValue();
      unsigned ShImm = ARM_AM::getAM2Offset(ShOpVal);
      if (ShImm == 0 ||
          ((ShImm == 1 || ShImm == 2 || ShImm == 3) &&
           ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsl))
        Latency -= 2;
      else if (ShImm == 1 && ARM_AM::getAM2ShiftOpc(ShOpVal) == ARM_AM::lsr)
        --Latency;
      break;
    }
    case ARM::t2LDRs:
    case ARM::t2LDRBs:
    case ARM::t2LDRHs:
    case ARM::t2LDRSHs: {
      // Thumb2 mode: lsl 0-3 only.
      Latency -= 2;
      break;
    }
    }
  }

  if (DefAlign < 8 && Subtarget.isLikeA9())
    switch (DefMCID.getOpcode()) {
    default: break;
    case ARM::VLD1q8:
    case ARM::VLD1q16:
    case ARM::VLD1q32:
    case ARM::VLD1q64:
    case ARM::VLD1q8wb_register:
    case ARM::VLD1q16wb_register:
    case ARM::VLD1q32wb_register:
    case ARM::VLD1q64wb_register:
    case ARM::VLD1q8wb_fixed:
    case ARM::VLD1q16wb_fixed:
    case ARM::VLD1q32wb_fixed:
    case ARM::VLD1q64wb_fixed:
    case ARM::VLD2d8:
    case ARM::VLD2d16:
    case ARM::VLD2d32:
    case ARM::VLD2q8Pseudo:
    case ARM::VLD2q16Pseudo:
    case ARM::VLD2q32Pseudo:
    case ARM::VLD2d8wb_fixed:
    case ARM::VLD2d16wb_fixed:
    case ARM::VLD2d32wb_fixed:
    case ARM::VLD2q8PseudoWB_fixed:
    case ARM::VLD2q16PseudoWB_fixed:
    case ARM::VLD2q32PseudoWB_fixed:
    case ARM::VLD2d8wb_register:
    case ARM::VLD2d16wb_register:
    case ARM::VLD2d32wb_register:
    case ARM::VLD2q8PseudoWB_register:
    case ARM::VLD2q16PseudoWB_register:
    case ARM::VLD2q32PseudoWB_register:
    case ARM::VLD3d8Pseudo:
    case ARM::VLD3d16Pseudo:
    case ARM::VLD3d32Pseudo:
    case ARM::VLD1d64TPseudo:
    case ARM::VLD1d64TPseudoWB_fixed:
    case ARM::VLD3d8Pseudo_UPD:
    case ARM::VLD3d16Pseudo_UPD:
    case ARM::VLD3d32Pseudo_UPD:
    case ARM::VLD3q8Pseudo_UPD:
    case ARM::VLD3q16Pseudo_UPD:
    case ARM::VLD3q32Pseudo_UPD:
    case ARM::VLD3q8oddPseudo:
    case ARM::VLD3q16oddPseudo:
    case ARM::VLD3q32oddPseudo:
    case ARM::VLD3q8oddPseudo_UPD:
    case ARM::VLD3q16oddPseudo_UPD:
    case ARM::VLD3q32oddPseudo_UPD:
    case ARM::VLD4d8Pseudo:
    case ARM::VLD4d16Pseudo:
    case ARM::VLD4d32Pseudo:
    case ARM::VLD1d64QPseudo:
    case ARM::VLD1d64QPseudoWB_fixed:
    case ARM::VLD4d8Pseudo_UPD:
    case ARM::VLD4d16Pseudo_UPD:
    case ARM::VLD4d32Pseudo_UPD:
    case ARM::VLD4q8Pseudo_UPD:
    case ARM::VLD4q16Pseudo_UPD:
    case ARM::VLD4q32Pseudo_UPD:
    case ARM::VLD4q8oddPseudo:
    case ARM::VLD4q16oddPseudo:
    case ARM::VLD4q32oddPseudo:
    case ARM::VLD4q8oddPseudo_UPD:
    case ARM::VLD4q16oddPseudo_UPD:
    case ARM::VLD4q32oddPseudo_UPD:
    case ARM::VLD1DUPq8:
    case ARM::VLD1DUPq16:
    case ARM::VLD1DUPq32:
    case ARM::VLD1DUPq8wb_fixed:
    case ARM::VLD1DUPq16wb_fixed:
    case ARM::VLD1DUPq32wb_fixed:
    case ARM::VLD1DUPq8wb_register:
    case ARM::VLD1DUPq16wb_register:
    case ARM::VLD1DUPq32wb_register:
    case ARM::VLD2DUPd8:
    case ARM::VLD2DUPd16:
    case ARM::VLD2DUPd32:
    case ARM::VLD2DUPd8wb_fixed:
    case ARM::VLD2DUPd16wb_fixed:
    case ARM::VLD2DUPd32wb_fixed:
    case ARM::VLD2DUPd8wb_register:
    case ARM::VLD2DUPd16wb_register:
    case ARM::VLD2DUPd32wb_register:
    case ARM::VLD4DUPd8Pseudo:
    case ARM::VLD4DUPd16Pseudo:
    case ARM::VLD4DUPd32Pseudo:
    case ARM::VLD4DUPd8Pseudo_UPD:
    case ARM::VLD4DUPd16Pseudo_UPD:
    case ARM::VLD4DUPd32Pseudo_UPD:
    case ARM::VLD1LNq8Pseudo:
    case ARM::VLD1LNq16Pseudo:
    case ARM::VLD1LNq32Pseudo:
    case ARM::VLD1LNq8Pseudo_UPD:
    case ARM::VLD1LNq16Pseudo_UPD:
    case ARM::VLD1LNq32Pseudo_UPD:
    case ARM::VLD2LNd8Pseudo:
    case ARM::VLD2LNd16Pseudo:
    case ARM::VLD2LNd32Pseudo:
    case ARM::VLD2LNq16Pseudo:
    case ARM::VLD2LNq32Pseudo:
    case ARM::VLD2LNd8Pseudo_UPD:
    case ARM::VLD2LNd16Pseudo_UPD:
    case ARM::VLD2LNd32Pseudo_UPD:
    case ARM::VLD2LNq16Pseudo_UPD:
    case ARM::VLD2LNq32Pseudo_UPD:
    case ARM::VLD4LNd8Pseudo:
    case ARM::VLD4LNd16Pseudo:
    case ARM::VLD4LNd32Pseudo:
    case ARM::VLD4LNq16Pseudo:
    case ARM::VLD4LNq32Pseudo:
    case ARM::VLD4LNd8Pseudo_UPD:
    case ARM::VLD4LNd16Pseudo_UPD:
    case ARM::VLD4LNd32Pseudo_UPD:
    case ARM::VLD4LNq16Pseudo_UPD:
    case ARM::VLD4LNq32Pseudo_UPD:
      // If the address is not 64-bit aligned, the latencies of these
      // instructions increases by one.
      ++Latency;
      break;
    }

  return Latency;
}

unsigned ARMBaseInstrInfo::getPredicationCost(const MachineInstr *MI) const {
   if (MI->isCopyLike() || MI->isInsertSubreg() ||
      MI->isRegSequence() || MI->isImplicitDef())
    return 0;

  if (MI->isBundle())
    return 0;

  const MCInstrDesc &MCID = MI->getDesc();

  if (MCID.isCall() || MCID.hasImplicitDefOfPhysReg(ARM::CPSR)) {
    // When predicated, CPSR is an additional source operand for CPSR updating
    // instructions, this apparently increases their latencies.
    return 1;
  }
  return 0;
}

unsigned ARMBaseInstrInfo::getInstrLatency(const InstrItineraryData *ItinData,
                                           const MachineInstr *MI,
                                           unsigned *PredCost) const {
  if (MI->isCopyLike() || MI->isInsertSubreg() ||
      MI->isRegSequence() || MI->isImplicitDef())
    return 1;

  // An instruction scheduler typically runs on unbundled instructions, however
  // other passes may query the latency of a bundled instruction.
  if (MI->isBundle()) {
    unsigned Latency = 0;
    MachineBasicBlock::const_instr_iterator I = MI->getIterator();
    MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
    while (++I != E && I->isInsideBundle()) {
      if (I->getOpcode() != ARM::t2IT)
        Latency += getInstrLatency(ItinData, &*I, PredCost);
    }
    return Latency;
  }

  const MCInstrDesc &MCID = MI->getDesc();
  if (PredCost && (MCID.isCall() || MCID.hasImplicitDefOfPhysReg(ARM::CPSR))) {
    // When predicated, CPSR is an additional source operand for CPSR updating
    // instructions, this apparently increases their latencies.
    *PredCost = 1;
  }
  // Be sure to call getStageLatency for an empty itinerary in case it has a
  // valid MinLatency property.
  if (!ItinData)
    return MI->mayLoad() ? 3 : 1;

  unsigned Class = MCID.getSchedClass();

  // For instructions with variable uops, use uops as latency.
  if (!ItinData->isEmpty() && ItinData->getNumMicroOps(Class) < 0)
    return getNumMicroOps(ItinData, MI);

  // For the common case, fall back on the itinerary's latency.
  unsigned Latency = ItinData->getStageLatency(Class);

  // Adjust for dynamic def-side opcode variants not captured by the itinerary.
  unsigned DefAlign = MI->hasOneMemOperand()
    ? (*MI->memoperands_begin())->getAlignment() : 0;
  int Adj = adjustDefLatency(Subtarget, MI, &MCID, DefAlign);
  if (Adj >= 0 || (int)Latency > -Adj) {
    return Latency + Adj;
  }
  return Latency;
}

int ARMBaseInstrInfo::getInstrLatency(const InstrItineraryData *ItinData,
                                      SDNode *Node) const {
  if (!Node->isMachineOpcode())
    return 1;

  if (!ItinData || ItinData->isEmpty())
    return 1;

  unsigned Opcode = Node->getMachineOpcode();
  switch (Opcode) {
  default:
    return ItinData->getStageLatency(get(Opcode).getSchedClass());
  case ARM::VLDMQIA:
  case ARM::VSTMQIA:
    return 2;
  }
}

bool ARMBaseInstrInfo::
hasHighOperandLatency(const TargetSchedModel &SchedModel,
                      const MachineRegisterInfo *MRI,
                      const MachineInstr *DefMI, unsigned DefIdx,
                      const MachineInstr *UseMI, unsigned UseIdx) const {
  unsigned DDomain = DefMI->getDesc().TSFlags & ARMII::DomainMask;
  unsigned UDomain = UseMI->getDesc().TSFlags & ARMII::DomainMask;
  if (Subtarget.isCortexA8() &&
      (DDomain == ARMII::DomainVFP || UDomain == ARMII::DomainVFP))
    // CortexA8 VFP instructions are not pipelined.
    return true;

  // Hoist VFP / NEON instructions with 4 or higher latency.
  unsigned Latency
    = SchedModel.computeOperandLatency(DefMI, DefIdx, UseMI, UseIdx);
  if (Latency <= 3)
    return false;
  return DDomain == ARMII::DomainVFP || DDomain == ARMII::DomainNEON ||
         UDomain == ARMII::DomainVFP || UDomain == ARMII::DomainNEON;
}

bool ARMBaseInstrInfo::
hasLowDefLatency(const TargetSchedModel &SchedModel,
                 const MachineInstr *DefMI, unsigned DefIdx) const {
  const InstrItineraryData *ItinData = SchedModel.getInstrItineraries();
  if (!ItinData || ItinData->isEmpty())
    return false;

  unsigned DDomain = DefMI->getDesc().TSFlags & ARMII::DomainMask;
  if (DDomain == ARMII::DomainGeneral) {
    unsigned DefClass = DefMI->getDesc().getSchedClass();
    int DefCycle = ItinData->getOperandCycle(DefClass, DefIdx);
    return (DefCycle != -1 && DefCycle <= 2);
  }
  return false;
}

bool ARMBaseInstrInfo::verifyInstruction(const MachineInstr *MI,
                                         StringRef &ErrInfo) const {
  if (convertAddSubFlagsOpcode(MI->getOpcode())) {
    ErrInfo = ""Pseudo flag setting opcodes only exist in Selection DAG"";
    return false;
  }
  return true;
}

// LoadStackGuard has so far only been implemented for MachO. Different code
// sequence is needed for other targets.
void ARMBaseInstrInfo::expandLoadStackGuardBase(MachineBasicBlock::iterator MI,
                                                unsigned LoadImmOpc,
                                                unsigned LoadOpc,
                                                Reloc::Model RM) const {
  MachineBasicBlock &MBB = *MI->getParent();
  DebugLoc DL = MI->getDebugLoc();
  unsigned Reg = MI->getOperand(0).getReg();
  const GlobalValue *GV =
      cast<GlobalValue>((*MI->memoperands_begin())->getValue());
  MachineInstrBuilder MIB;

  BuildMI(MBB, MI, DL, get(LoadImmOpc), Reg)
      .addGlobalAddress(GV, 0, ARMII::MO_NONLAZY);

  if (Subtarget.GVIsIndirectSymbol(GV, RM)) {
    MIB = BuildMI(MBB, MI, DL, get(LoadOpc), Reg);
    MIB.addReg(Reg, RegState::Kill).addImm(0);
    unsigned Flag = MachineMemOperand::MOLoad | MachineMemOperand::MOInvariant;
    MachineMemOperand *MMO = MBB.getParent()->getMachineMemOperand(
        MachinePointerInfo::getGOT(*MBB.getParent()), Flag, 4, 4);
    MIB.addMemOperand(MMO);
    AddDefaultPred(MIB);
  }

  MIB = BuildMI(MBB, MI, DL, get(LoadOpc), Reg);
  MIB.addReg(Reg, RegState::Kill).addImm(0);
  MIB.setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
  AddDefaultPred(MIB);
}

bool
ARMBaseInstrInfo::isFpMLxInstruction(unsigned Opcode, unsigned &MulOpc,
                                     unsigned &AddSubOpc,
                                     bool &NegAcc, bool &HasLane) const {
  DenseMap<unsigned, unsigned>::const_iterator I = MLxEntryMap.find(Opcode);
  if (I == MLxEntryMap.end())
    return false;

  const ARM_MLxEntry &Entry = ARM_MLxTable[I->second];
  MulOpc = Entry.MulOpc;
  AddSubOpc = Entry.AddSubOpc;
  NegAcc = Entry.NegAcc;
  HasLane = Entry.HasLane;
  return true;
}

//===----------------------------------------------------------------------===//
// Execution domains.
//===----------------------------------------------------------------------===//
//
// Some instructions go down the NEON pipeline, some go down the VFP pipeline,
// and some can go down both.  The vmov instructions go down the VFP pipeline,
// but they can be changed to vorr equivalents that are executed by the NEON
// pipeline.
//
// We use the following execution domain numbering:
//
enum ARMExeDomain {
  ExeGeneric = 0,
  ExeVFP = 1,
  ExeNEON = 2
};
//
// Also see ARMInstrFormats.td and Domain* enums in ARMBaseInfo.h
//
std::pair<uint16_t, uint16_t>
ARMBaseInstrInfo::getExecutionDomain(const MachineInstr *MI) const {
  // If we don't have access to NEON instructions then we won't be able
  // to swizzle anything to the NEON domain. Check to make sure.
  if (Subtarget.hasNEON()) {
    // VMOVD, VMOVRS and VMOVSR are VFP instructions, but can be changed to NEON
    // if they are not predicated.
    if (MI->getOpcode() == ARM::VMOVD && !isPredicated(MI))
      return std::make_pair(ExeVFP, (1 << ExeVFP) | (1 << ExeNEON));

    // CortexA9 is particularly picky about mixing the two and wants these
    // converted.
    if (Subtarget.isCortexA9() && !isPredicated(MI) &&
        (MI->getOpcode() == ARM::VMOVRS || MI->getOpcode() == ARM::VMOVSR ||
         MI->getOpcode() == ARM::VMOVS))
      return std::make_pair(ExeVFP, (1 << ExeVFP) | (1 << ExeNEON));
  }
  // No other instructions can be swizzled, so just determine their domain.
  unsigned Domain = MI->getDesc().TSFlags & ARMII::DomainMask;

  if (Domain & ARMII::DomainNEON)
    return std::make_pair(ExeNEON, 0);

  // Certain instructions can go either way on Cortex-A8.
  // Treat them as NEON instructions.
  if ((Domain & ARMII::DomainNEONA8) && Subtarget.isCortexA8())
    return std::make_pair(ExeNEON, 0);

  if (Domain & ARMII::DomainVFP)
    return std::make_pair(ExeVFP, 0);

  return std::make_pair(ExeGeneric, 0);
}

static unsigned getCorrespondingDRegAndLane(const TargetRegisterInfo *TRI,
                                            unsigned SReg, unsigned &Lane) {
  unsigned DReg = TRI->getMatchingSuperReg(SReg, ARM::ssub_0, &ARM::DPRRegClass);
  Lane = 0;

  if (DReg != ARM::NoRegister)
   return DReg;

  Lane = 1;
  DReg = TRI->getMatchingSuperReg(SReg, ARM::ssub_1, &ARM::DPRRegClass);

  assert(DReg && ""S-register with no D super-register?"");
  return DReg;
}

/// getImplicitSPRUseForDPRUse - Given a use of a DPR register and lane,
/// set ImplicitSReg to a register number that must be marked as implicit-use or
/// zero if no register needs to be defined as implicit-use.
///
/// If the function cannot determine if an SPR should be marked implicit use or
/// not, it returns false.
///
/// This function handles cases where an instruction is being modified from taking
/// an SPR to a DPR[Lane]. A use of the DPR is being added, which may conflict
/// with an earlier def of an SPR corresponding to DPR[Lane^1] (i.e. the other
/// lane of the DPR).
///
/// If the other SPR is defined, an implicit-use of it should be added. Else,
/// (including the case where the DPR itself is defined), it should not.
///
static bool getImplicitSPRUseForDPRUse(const TargetRegisterInfo *TRI,
                                       MachineInstr *MI,
                                       unsigned DReg, unsigned Lane,
                                       unsigned &ImplicitSReg) {
  // If the DPR is defined or used already, the other SPR lane will be chained
  // correctly, so there is nothing to be done.
  if (MI->definesRegister(DReg, TRI) || MI->readsRegister(DReg, TRI)) {
    ImplicitSReg = 0;
    return true;
  }

  // Otherwise we need to go searching to see if the SPR is set explicitly.
  ImplicitSReg = TRI->getSubReg(DReg,
                                (Lane & 1) ? ARM::ssub_0 : ARM::ssub_1);
  MachineBasicBlock::LivenessQueryResult LQR =
    MI->getParent()->computeRegisterLiveness(TRI, ImplicitSReg, MI);

  if (LQR == MachineBasicBlock::LQR_Live)
    return true;
  else if (LQR == MachineBasicBlock::LQR_Unknown)
    return false;

  // If the register is known not to be live, there is no need to add an
  // implicit-use.
  ImplicitSReg = 0;
  return true;
}

void
ARMBaseInstrInfo::setExecutionDomain(MachineInstr *MI, unsigned Domain) const {
  unsigned DstReg, SrcReg, DReg;
  unsigned Lane;
  MachineInstrBuilder MIB(*MI->getParent()->getParent(), MI);
  const TargetRegisterInfo *TRI = &getRegisterInfo();
  switch (MI->getOpcode()) {
    default:
      llvm_unreachable(""cannot handle opcode!"");
      break;
    case ARM::VMOVD:
      if (Domain != ExeNEON)
        break;

      // Zap the predicate operands.
      assert(!isPredicated(MI) && ""Cannot predicate a VORRd"");

      // Make sure we've got NEON instructions.
      assert(Subtarget.hasNEON() && ""VORRd requires NEON"");

      // Source instruction is %DDst = VMOVD %DSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      // Change to a %DDst = VORRd %DSrc, %DSrc, 14, %noreg (; implicits)
      MI->setDesc(get(ARM::VORRd));
      AddDefaultPred(MIB.addReg(DstReg, RegState::Define)
                        .addReg(SrcReg)
                        .addReg(SrcReg));
      break;
    case ARM::VMOVRS:
      if (Domain != ExeNEON)
        break;
      assert(!isPredicated(MI) && ""Cannot predicate a VGETLN"");

      // Source instruction is %RDst = VMOVRS %SSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      DReg = getCorrespondingDRegAndLane(TRI, SrcReg, Lane);

      // Convert to %RDst = VGETLNi32 %DSrc, Lane, 14, %noreg (; imps)
      // Note that DSrc has been widened and the other lane may be undef, which
      // contaminates the entire register.
      MI->setDesc(get(ARM::VGETLNi32));
      AddDefaultPred(MIB.addReg(DstReg, RegState::Define)
                        .addReg(DReg, RegState::Undef)
                        .addImm(Lane));

      // The old source should be an implicit use, otherwise we might think it
      // was dead before here.
      MIB.addReg(SrcReg, RegState::Implicit);
      break;
    case ARM::VMOVSR: {
      if (Domain != ExeNEON)
        break;
      assert(!isPredicated(MI) && ""Cannot predicate a VSETLN"");

      // Source instruction is %SDst = VMOVSR %RSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      DReg = getCorrespondingDRegAndLane(TRI, DstReg, Lane);

      unsigned ImplicitSReg;
      if (!getImplicitSPRUseForDPRUse(TRI, MI, DReg, Lane, ImplicitSReg))
        break;

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      // Convert to %DDst = VSETLNi32 %DDst, %RSrc, Lane, 14, %noreg (; imps)
      // Again DDst may be undefined at the beginning of this instruction.
      MI->setDesc(get(ARM::VSETLNi32));
      MIB.addReg(DReg, RegState::Define)
         .addReg(DReg, getUndefRegState(!MI->readsRegister(DReg, TRI)))
         .addReg(SrcReg)
         .addImm(Lane);
      AddDefaultPred(MIB);

      // The narrower destination must be marked as set to keep previous chains
      // in place.
      MIB.addReg(DstReg, RegState::Define | RegState::Implicit);
      if (ImplicitSReg != 0)
        MIB.addReg(ImplicitSReg, RegState::Implicit);
      break;
    }
    case ARM::VMOVS: {
      if (Domain != ExeNEON)
        break;

      // Source instruction is %SDst = VMOVS %SSrc, 14, %noreg (; implicits)
      DstReg = MI->getOperand(0).getReg();
      SrcReg = MI->getOperand(1).getReg();

      unsigned DstLane = 0, SrcLane = 0, DDst, DSrc;
      DDst = getCorrespondingDRegAndLane(TRI, DstReg, DstLane);
      DSrc = getCorrespondingDRegAndLane(TRI, SrcReg, SrcLane);

      unsigned ImplicitSReg;
      if (!getImplicitSPRUseForDPRUse(TRI, MI, DSrc, SrcLane, ImplicitSReg))
        break;

      for (unsigned i = MI->getDesc().getNumOperands(); i; --i)
        MI->RemoveOperand(i-1);

      if (DSrc == DDst) {
        // Destination can be:
        //     %DDst = VDUPLN32d %DDst, Lane, 14, %noreg (; implicits)
        MI->setDesc(get(ARM::VDUPLN32d));
        MIB.addReg(DDst, RegState::Define)
           .addReg(DDst, getUndefRegState(!MI->readsRegister(DDst, TRI)))
           .addImm(SrcLane);
        AddDefaultPred(MIB);

        // Neither the source or the destination are naturally represented any
        // more, so add them in manually.
        MIB.addReg(DstReg, RegState::Implicit | RegState::Define);
        MIB.addReg(SrcReg, RegState::Implicit);
        if (ImplicitSReg != 0)
          MIB.addReg(ImplicitSReg, RegState::Implicit);
        break;
      }

      // In general there's no single instruction that can perform an S <-> S
      // move in NEON space, but a pair of VEXT instructions *can* do the
      // job. It turns out that the VEXTs needed will only use DSrc once, with
      // the position based purely on the combination of lane-0 and lane-1
      // involved. For example
      //     vmov s0, s2 -> vext.32 d0, d0, d1, #1  vext.32 d0, d0, d0, #1
      //     vmov s1, s3 -> vext.32 d0, d1, d0, #1  vext.32 d0, d0, d0, #1
      //     vmov s0, s3 -> vext.32 d0, d0, d0, #1  vext.32 d0, d1, d0, #1
      //     vmov s1, s2 -> vext.32 d0, d0, d0, #1  vext.32 d0, d0, d1, #1
      //
      // Pattern of the MachineInstrs is:
      //     %DDst = VEXTd32 %DSrc1, %DSrc2, Lane, 14, %noreg (;implicits)
      MachineInstrBuilder NewMIB;
      NewMIB = BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                       get(ARM::VEXTd32), DDst);

      // On the first instruction, both DSrc and DDst may be <undef> if present.
      // Specifically when the original instruction didn't have them as an
      // <imp-use>.
      unsigned CurReg = SrcLane == 1 && DstLane == 1 ? DSrc : DDst;
      bool CurUndef = !MI->readsRegister(CurReg, TRI);
      NewMIB.addReg(CurReg, getUndefRegState(CurUndef));

      CurReg = SrcLane == 0 && DstLane == 0 ? DSrc : DDst;
      CurUndef = !MI->readsRegister(CurReg, TRI);
      NewMIB.addReg(CurReg, getUndefRegState(CurUndef));

      NewMIB.addImm(1);
      AddDefaultPred(NewMIB);

      if (SrcLane == DstLane)
        NewMIB.addReg(SrcReg, RegState::Implicit);

      MI->setDesc(get(ARM::VEXTd32));
      MIB.addReg(DDst, RegState::Define);

      // On the second instruction, DDst has definitely been defined above, so
      // it is not <undef>. DSrc, if present, can be <undef> as above.
      CurReg = SrcLane == 1 && DstLane == 0 ? DSrc : DDst;
      CurUndef = CurReg == DSrc && !MI->readsRegister(CurReg, TRI);
      MIB.addReg(CurReg, getUndefRegState(CurUndef));

      CurReg = SrcLane == 0 && DstLane == 1 ? DSrc : DDst;
      CurUndef = CurReg == DSrc && !MI->readsRegister(CurReg, TRI);
      MIB.addReg(CurReg, getUndefRegState(CurUndef));

      MIB.addImm(1);
      AddDefaultPred(MIB);

      if (SrcLane != DstLane)
        MIB.addReg(SrcReg, RegState::Implicit);

      // As before, the original destination is no longer represented, add it
      // implicitly.
      MIB.addReg(DstReg, RegState::Define | RegState::Implicit);
      if (ImplicitSReg != 0)
        MIB.addReg(ImplicitSReg, RegState::Implicit);
      break;
    }
  }

}

//===----------------------------------------------------------------------===//
// Partial register updates
//===----------------------------------------------------------------------===//
//
// Swift renames NEON registers with 64-bit granularity.  That means any
// instruction writing an S-reg implicitly reads the containing D-reg.  The
// problem is mostly avoided by translating f32 operations to v2f32 operations
// on D-registers, but f32 loads are still a problem.
//
// These instructions can load an f32 into a NEON register:
//
// VLDRS - Only writes S, partial D update.
// VLD1LNd32 - Writes all D-regs, explicit partial D update, 2 uops.
// VLD1DUPd32 - Writes all D-regs, no partial reg update, 2 uops.
//
// FCONSTD can be used as a dependency-breaking instruction.
unsigned ARMBaseInstrInfo::
getPartialRegUpdateClearance(const MachineInstr *MI,
                             unsigned OpNum,
                             const TargetRegisterInfo *TRI) const {
  if (!SwiftPartialUpdateClearance ||
      !(Subtarget.isSwift() || Subtarget.isCortexA15()))
    return 0;

  assert(TRI && ""Need TRI instance"");

  const MachineOperand &MO = MI->getOperand(OpNum);
  if (MO.readsReg())
    return 0;
  unsigned Reg = MO.getReg();
  int UseOp = -1;

  switch(MI->getOpcode()) {
    // Normal instructions writing only an S-register.
  case ARM::VLDRS:
  case ARM::FCONSTS:
  case ARM::VMOVSR:
  case ARM::VMOVv8i8:
  case ARM::VMOVv4i16:
  case ARM::VMOVv2i32:
  case ARM::VMOVv2f32:
  case ARM::VMOVv1i64:
    UseOp = MI->findRegisterUseOperandIdx(Reg, false, TRI);
    break;

    // Explicitly reads the dependency.
  case ARM::VLD1LNd32:
    UseOp = 3;
    break;
  default:
    return 0;
  }

  // If this instruction actually reads a value from Reg, there is no unwanted
  // dependency.
  if (UseOp != -1 && MI->getOperand(UseOp).readsReg())
    return 0;

  // We must be able to clobber the whole D-reg.
  if (TargetRegisterInfo::isVirtualRegister(Reg)) {
    // Virtual register must be a foo:ssub_0<def,undef> operand.
    if (!MO.getSubReg() || MI->readsVirtualRegister(Reg))
      return 0;
  } else if (ARM::SPRRegClass.contains(Reg)) {
    // Physical register: MI must define the full D-reg.
    unsigned DReg = TRI->getMatchingSuperReg(Reg, ARM::ssub_0,
                                             &ARM::DPRRegClass);
    if (!DReg || !MI->definesRegister(DReg, TRI))
      return 0;
  }

  // MI has an unwanted D-register dependency.
  // Avoid defs in the previous N instructrions.
  return SwiftPartialUpdateClearance;
}

// Break a partial register dependency after getPartialRegUpdateClearance
// returned non-zero.
void ARMBaseInstrInfo::
breakPartialRegDependency(MachineBasicBlock::iterator MI,
                          unsigned OpNum,
                          const TargetRegisterInfo *TRI) const {
  assert(MI && OpNum < MI->getDesc().getNumDefs() && ""OpNum is not a def"");
  assert(TRI && ""Need TRI instance"");

  const MachineOperand &MO = MI->getOperand(OpNum);
  unsigned Reg = MO.getReg();
  assert(TargetRegisterInfo::isPhysicalRegister(Reg) &&
         ""Can't break virtual register dependencies."");
  unsigned DReg = Reg;

  // If MI defines an S-reg, find the corresponding D super-register.
  if (ARM::SPRRegClass.contains(Reg)) {
    DReg = ARM::D0 + (Reg - ARM::S0) / 2;
    assert(TRI->isSuperRegister(Reg, DReg) && ""Register enums broken"");
  }

  assert(ARM::DPRRegClass.contains(DReg) && ""Can only break D-reg deps"");
  assert(MI->definesRegister(DReg, TRI) && ""MI doesn't clobber full D-reg"");

  // FIXME: In some cases, VLDRS can be changed to a VLD1DUPd32 which defines
  // the full D-register by loading the same value to both lanes.  The
  // instruction is micro-coded with 2 uops, so don't do this until we can
  // properly schedule micro-coded instructions.  The dispatcher stalls cause
  // too big regressions.

  // Insert the dependency-breaking FCONSTD before MI.
  // 96 is the encoding of 0.5, but the actual value doesn't matter here.
  AddDefaultPred(BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
                         get(ARM::FCONSTD), DReg).addImm(96));
  MI->addRegisterKilled(DReg, TRI, true);
}

bool ARMBaseInstrInfo::hasNOP() const {
  return Subtarget.getFeatureBits()[ARM::HasV6KOps];
}

bool ARMBaseInstrInfo::isSwiftFastImmShift(const MachineInstr *MI) const {
  if (MI->getNumOperands() < 4)
    return true;
  unsigned ShOpVal = MI->getOperand(3).getImm();
  unsigned ShImm = ARM_AM::getSORegOffset(ShOpVal);
  // Swift supports faster shifts for: lsl 2, lsl 1, and lsr 1.
  if ((ShImm == 1 && ARM_AM::getSORegShOp(ShOpVal) == ARM_AM::lsr) ||
      ((ShImm == 1 || ShImm == 2) &&
       ARM_AM::getSORegShOp(ShOpVal) == ARM_AM::lsl))
    return true;

  return false;
}

bool ARMBaseInstrInfo::getRegSequenceLikeInputs(
    const MachineInstr &MI, unsigned DefIdx,
    SmallVectorImpl<RegSubRegPairAndIdx> &InputRegs) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isRegSequenceLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VMOVDRR:
    // dX = VMOVDRR rY, rZ
    // is the same as:
    // dX = REG_SEQUENCE rY, ssub_0, rZ, ssub_1
    // Populate the InputRegs accordingly.
    // rY
    const MachineOperand *MOReg = &MI.getOperand(1);
    InputRegs.push_back(
        RegSubRegPairAndIdx(MOReg->getReg(), MOReg->getSubReg(), ARM::ssub_0));
    // rZ
    MOReg = &MI.getOperand(2);
    InputRegs.push_back(
        RegSubRegPairAndIdx(MOReg->getReg(), MOReg->getSubReg(), ARM::ssub_1));
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}

bool ARMBaseInstrInfo::getExtractSubregLikeInputs(
    const MachineInstr &MI, unsigned DefIdx,
    RegSubRegPairAndIdx &InputReg) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isExtractSubregLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VMOVRRD:
    // rX, rY = VMOVRRD dZ
    // is the same as:
    // rX = EXTRACT_SUBREG dZ, ssub_0
    // rY = EXTRACT_SUBREG dZ, ssub_1
    const MachineOperand &MOReg = MI.getOperand(2);
    InputReg.Reg = MOReg.getReg();
    InputReg.SubReg = MOReg.getSubReg();
    InputReg.SubIdx = DefIdx == 0 ? ARM::ssub_0 : ARM::ssub_1;
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}

bool ARMBaseInstrInfo::getInsertSubregLikeInputs(
    const MachineInstr &MI, unsigned DefIdx, RegSubRegPair &BaseReg,
    RegSubRegPairAndIdx &InsertedReg) const {
  assert(DefIdx < MI.getDesc().getNumDefs() && ""Invalid definition index"");
  assert(MI.isInsertSubregLike() && ""Invalid kind of instruction"");

  switch (MI.getOpcode()) {
  case ARM::VSETLNi32:
    // dX = VSETLNi32 dY, rZ, imm
    const MachineOperand &MOBaseReg = MI.getOperand(1);
    const MachineOperand &MOInsertedReg = MI.getOperand(2);
    const MachineOperand &MOIndex = MI.getOperand(3);
    BaseReg.Reg = MOBaseReg.getReg();
    BaseReg.SubReg = MOBaseReg.getSubReg();

    InsertedReg.Reg = MOInsertedReg.getReg();
    InsertedReg.SubReg = MOInsertedReg.getSubReg();
    InsertedReg.SubIdx = MOIndex.getImm() == 0 ? ARM::ssub_0 : ARM::ssub_1;
    return true;
  }
  llvm_unreachable(""Target dependent opcode missing"");
}
",UseAdj