hexsha stringlengths 40 40 | size int64 7 1.05M | ext stringclasses 13
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 4 269 | max_stars_repo_name stringlengths 5 108 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 9 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 269 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 9 | max_issues_count int64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 269 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 9 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 7 1.05M | avg_line_length float64 1.21 330k | max_line_length int64 6 990k | alphanum_fraction float64 0.01 0.99 | author_id stringlengths 2 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9dcaf21f2b056bb30dd41f33926eda6d8d7ad3af | 1,753 | cpp | C++ | artoo/src/factorytest.cpp | meee1/OpenSolo | 6f299639adbad1e8d573c8ae1135832711b600e4 | [
"Apache-2.0"
] | 68 | 2019-09-23T03:27:05.000Z | 2022-03-12T03:00:41.000Z | artoo/src/factorytest.cpp | meee1/OpenSolo | 6f299639adbad1e8d573c8ae1135832711b600e4 | [
"Apache-2.0"
] | 22 | 2019-10-26T20:15:56.000Z | 2022-02-12T05:41:56.000Z | artoo/src/factorytest.cpp | meee1/OpenSolo | 6f299639adbad1e8d573c8ae1135832711b600e4 | [
"Apache-2.0"
] | 33 | 2019-09-29T19:52:19.000Z | 2022-03-12T03:00:43.000Z | #include "factorytest.h"
#include "buttonmanager.h"
#include "haptic.h"
#include "buzzer.h"
#include "ili9341parallel.h"
#include "board.h"
void FactoryTest::onOutputTest(const uint8_t *bytes, unsigned len)
{
/*
* Dispatched from hostprotocol.
*/
if (len < 5) {
return;
}
static const unsigned NUM_LEDS = 6;
const uint8_t whiteLedMask = bytes[0];
const uint8_t greenLedMask = bytes[1];
const uint16_t buzzerHz = (bytes[3] << 8) | bytes[2];
const uint8_t motorSeconds = bytes[4];
Buzzer::init(440); // only using buzzer for factory test
for (unsigned i = 0; i < NUM_LEDS; ++i) {
bool whiteOn = whiteLedMask & (1 << i);
bool greenOn = greenLedMask & (1 << i);
Button & b = ButtonManager::button(static_cast<Io::ButtonID>(Io::ButtonPower + i));
b.setWhiteLed(whiteOn);
b.setGreenLed(greenOn);
}
if (buzzerHz) {
Buzzer::setFrequency(buzzerHz);
Buzzer::play();
} else {
Buzzer::stop();
}
if (motorSeconds) {
// XXX: this is probably ok, but need to verify whether
// we need arbitrary durations for HW testing
Haptic::startPattern(Haptic::SingleMedium);
}
}
void FactoryTest::onGpioTest(const uint8_t *bytes, unsigned len)
{
/*
* Dispatched from hostprotocol to control i/o lines during factory test.
*/
if (len < 2) {
return;
}
switch (bytes[0]) {
case GpioLedBacklight:
ILI9341Parallel::lcd.setBacklight(bytes[1] ? 100 : 0);
break;
case GpioChargerEnable:
if (bytes[1]) {
CHG_ENABLE_GPIO.setHigh();
} else {
CHG_ENABLE_GPIO.setLow();
}
break;
}
}
| 23.689189 | 91 | 0.588705 | meee1 |
9dd244eabc31b4f9ed8df9741f05078fccc1b9a1 | 2,129 | cpp | C++ | src/examples/test_executor.cpp | woggle/mesos-old | 54b4894efb6c5645eb530d993355559d548f768d | [
"Apache-2.0"
] | null | null | null | src/examples/test_executor.cpp | woggle/mesos-old | 54b4894efb6c5645eb530d993355559d548f768d | [
"Apache-2.0"
] | null | null | null | src/examples/test_executor.cpp | woggle/mesos-old | 54b4894efb6c5645eb530d993355559d548f768d | [
"Apache-2.0"
] | 3 | 2017-03-29T04:57:55.000Z | 2020-07-25T20:10:54.000Z | /**
* 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 <cstdlib>
#include <iostream>
#include <mesos/executor.hpp>
using namespace mesos;
using namespace std;
class MyExecutor : public Executor
{
public:
virtual ~MyExecutor() {}
virtual void init(ExecutorDriver*, const ExecutorArgs& args)
{
cout << "Initalized executor on " << args.hostname() << endl;
}
virtual void launchTask(ExecutorDriver* driver, const TaskDescription& task)
{
cout << "Starting task " << task.task_id().value() << endl;
TaskStatus status;
status.mutable_task_id()->MergeFrom(task.task_id());
status.set_state(TASK_RUNNING);
driver->sendStatusUpdate(status);
sleep(1);
cout << "Finishing task " << task.task_id().value() << endl;
status.mutable_task_id()->MergeFrom(task.task_id());
status.set_state(TASK_FINISHED);
driver->sendStatusUpdate(status);
}
virtual void killTask(ExecutorDriver* driver, const TaskID& taskId) {}
virtual void frameworkMessage(ExecutorDriver* driver,
const string& data) {}
virtual void shutdown(ExecutorDriver* driver) {}
virtual void error(ExecutorDriver* driver, int code,
const std::string& message) {}
};
int main(int argc, char** argv)
{
MyExecutor exec;
MesosExecutorDriver driver(&exec);
driver.run();
return 0;
}
| 27.649351 | 78 | 0.700798 | woggle |
9dd509d3b1d33d66d013245fae5c7fb30442a6ed | 14,191 | cpp | C++ | Common/network/src/worker_thread.cpp | deeptexas-ai/test | f06b798d18f2d53c9206df41406d02647004ce84 | [
"MIT"
] | 4 | 2021-10-20T09:18:06.000Z | 2022-03-27T05:08:26.000Z | Common/network/src/worker_thread.cpp | deeptexas-ai/test | f06b798d18f2d53c9206df41406d02647004ce84 | [
"MIT"
] | 1 | 2021-11-05T03:28:41.000Z | 2021-11-06T07:48:05.000Z | Common/network/src/worker_thread.cpp | deeptexas-ai/test | f06b798d18f2d53c9206df41406d02647004ce84 | [
"MIT"
] | 1 | 2021-12-13T16:04:22.000Z | 2021-12-13T16:04:22.000Z | #include "worker_thread.h"
#include "socket_manager.h"
namespace network
{
CWorkerThread::CWorkerThread()
{
m_nNotifyReadFd = INVALID_SOCKET;
m_nNotifySendFd = INVALID_SOCKET;
m_base = NULL;
}
CWorkerThread::~CWorkerThread()
{
if(INVALID_SOCKET != m_nNotifyReadFd)
{
close(m_nNotifyReadFd);
m_nNotifyReadFd = INVALID_SOCKET;
}
if(INVALID_SOCKET != m_nNotifySendFd)
{
close(m_nNotifySendFd);
m_nNotifySendFd = INVALID_SOCKET;
}
if(NULL != m_base)
{
event_del(&m_oNotifyEvent);
event_base_free(m_base);
m_base = NULL;
}
}
bool CWorkerThread::Init()
{
int fds[2];
if (pipe(fds))
{
fprintf(stderr, "Worker thread init| Can't create notify pipe\n");
LOG(LT_ERROR, "Worker thread init| Can't create notify pipe");
exit(1);
}
m_nNotifyReadFd = fds[0];
m_nNotifySendFd = fds[1];
m_base = event_base_new();
if(NULL == m_base)
{
LOG(LT_ERROR, "Worker thread init| new base failed");
exit(2);
}
event_set(&m_oNotifyEvent, m_nNotifyReadFd, EV_READ | EV_PERSIST, NotifyCallback, (void*)this);
event_base_set(m_base, &m_oNotifyEvent);
if (-1 == event_add(&m_oNotifyEvent, 0))
{
fprintf(stderr, "Worker thread init| Can't monitor libevent notify pipe\n");
LOG(LT_ERROR, "Worker thread init| Can't monitor libevent notify pipe");
exit(3);
}
pthread_t tid = 0;
if(0 != pthread_create( &tid, NULL, &CWorkerThread::Run, (void*)this))
{
LOG(LT_ERROR, "Worker thread init| create failed");
return false;
}
return true;
}
void* CWorkerThread::Run(void *arg)
{
pthread_detach( pthread_self() );
LOG(LT_INFO, "Worker thread run ...| pid=%llu", pthread_self());
CWorkerThread *pThis = (CWorkerThread *)arg;
pThis->m_nThreadID = pthread_self();
event_base_dispatch(pThis->m_base);
LOG(LT_INFO, "Worker thread Exit ...| pid=%llu", pthread_self());
_exit(0);
return NULL;
}
bool CWorkerThread::PushNotifyFd(const CNotifyFd &oNotify)
{
{
Lock lock(&m_oLock);
m_lstNotifyFd.push_back(oNotify);
}
char buf[2] = {'c', '0'};
if (1 != write(m_nNotifySendFd, buf, 1))
{
LOG(LT_ERROR, "Worker thread| push notify fd failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort
);
_exit(0);
}
return true;
}
void CWorkerThread::NotifyCallback(evutil_socket_t fd, short events, void *arg)
{
char buf[2];
CWorkerThread *pThis = (CWorkerThread *)arg;
CNotifyFd oNotify;
//fd就是m_nNotifyReadFd
if (1 != read(fd, buf, 1))
{
LOG(LT_ERROR, "Worker notify callback| read pipe failed| thread_id=%llu| msg=%s", pThis->m_nThreadID, strerror(errno));
_exit(0);
}
//从队列取出通知消息
{
Lock lock(&pThis->m_oLock);
if(pThis->m_lstNotifyFd.empty())
{
LOG(LT_ERROR, "Worker notify callback| queue is empty| thread_id=%llu", pThis->m_nThreadID);
return;
}
oNotify = pThis->m_lstNotifyFd.front();
pThis->m_lstNotifyFd.pop_front();
}
switch (oNotify.m_nType)
{
case NOTIFY_TYPE_ACCEPT:
pThis->DoAccept(oNotify);
break;
case NOTIFY_TYPE_CONNECT:
pThis->DoConnect(oNotify);
break;
case NOTIFY_TYPE_LISTEN:
pThis->DoListen(oNotify);
break;
case NOTIFY_TYPE_CLOSE:
pThis->DoClose(oNotify);
break;
default:
LOG(LT_ERROR, "Worker notify callback| unknow type| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
pThis->m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort);
break;
}
}
//Connect的通知处理
void CWorkerThread::DoAccept(const CNotifyFd &oNotify)
{
TcpSocket *pSocket = CSocketManager::Instance()->GetTcpSocket(oNotify.m_nFd);
if(NULL == pSocket)
{
LOG(LT_ERROR,
"Worker thread| do accept notify get socket failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort
);
close(oNotify.m_nFd);
return;
}
if(Socket::SOCK_STATE_INIT != pSocket->GetState())
{
LOG(LT_WARN, "Worker thread| do accept socket not release| fd=%d| state=%d| unique_id=0x%x| addr_msg=%s",
oNotify.m_nFd, pSocket->GetState(), pSocket->GetUniqueID(), pSocket->GetAddrMsg().c_str()
);
pSocket->Release(false);
}
//设置参数
SERVERKEY sk(CSocketManager::Instance()->GetLocalServerID());
pSocket->SetUniqueID(CSocketManager::Instance()->GetSequence());
pSocket->SetTransID(sk.nType, sk.nInstID);
pSocket->SetIsAcceptFd(true);
pSocket->SetSocketHandler(NULL, oNotify.m_bBinaryMode);
std::string sMsg;
bool bSuccess = false;
if(!pSocket->Create(oNotify.m_nFd))
{
sMsg = "create failed";
}
else if (!pSocket->SetKeepAlive(true)) // 保持连接
{
sMsg = "keep alive failed";
}
else if (!pSocket->SetNoDelay(true))
{
sMsg = "no delay failed";
}
else if (!pSocket->SetNonBlock())
{
sMsg = "not block failed";
}
else if (!pSocket->SetLinger())
{
sMsg = "linger failed";
}
else if (!pSocket->SetReuse(true))
{
sMsg = "reuse failed";
}
else
{
pSocket->SetLocalAddr(oNotify.m_szLocalAddr, oNotify.m_nLocalPort);
pSocket->SetRemoteAddr(oNotify.m_szRemoteAddr, oNotify.m_nRemotePort);
pSocket->SetState(Socket::SOCK_STATE::SOCK_STATE_NORMAL);
if(!pSocket->RegisterEvent(m_base))
{
sMsg = "register failed";
}
else
{
bSuccess = true;
}
}
//注册事件
if(bSuccess)
{
LOG(LT_INFO_TRANS, pSocket->NextTransID().c_str(),
"Worker thread| do accept notify succ| thread_id=%llu| type=%d| fd=%d| unique_id=0x%x| local_addr=%s:%d| remote_addr=%s:%d| binary_mode=%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, pSocket->GetUniqueID(), oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort, oNotify.m_bBinaryMode
);
}
else
{
LOG(LT_ERROR,
"Worker thread| do accept failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d| msg=%s",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort, sMsg.c_str()
);
pSocket->Release(true);
}
}
//Connect的通知处理
void CWorkerThread::DoConnect(const CNotifyFd &oNotify)
{
TcpSocket *pSocket = CSocketManager::Instance()->GetTcpSocket(oNotify.m_nFd);
if(NULL == pSocket)
{
LOG(LT_ERROR,
"Worker thread| do connect notify get socket failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort
);
close(oNotify.m_nFd);
return;
}
if(Socket::SOCK_STATE_INIT != pSocket->GetState())
{
LOG(LT_WARN, "Worker thread| do connect socket not release| fd=%d| state=%d| unique_id=0x%x| addr_msg=%s",
oNotify.m_nFd, pSocket->GetState(), pSocket->GetUniqueID(), pSocket->GetAddrMsg().c_str()
);
pSocket->Release(false);
}
//设置参数
SERVERKEY sk(CSocketManager::Instance()->GetLocalServerID());
pSocket->SetUniqueID(CSocketManager::Instance()->GetSequence());
pSocket->SetTransID(sk.nType, sk.nInstID);
pSocket->SetIsAcceptFd(false);
pSocket->SetSocketHandler(oNotify.m_pHandler, oNotify.m_bBinaryMode);
std::string sMsg;
bool bSuccess = false;
if(!pSocket->Create(oNotify.m_nFd))
{
sMsg = "create failed";
}
else if (!pSocket->SetKeepAlive(true)) // 保持连接
{
sMsg = "keep alive failed";
}
else if (!pSocket->SetNoDelay(true))
{
sMsg = "no delay failed";
}
else if (!pSocket->SetNonBlock())
{
sMsg = "not block failed";
}
else if (!pSocket->SetLinger())
{
sMsg = "linger failed";
}
else if (!pSocket->SetReuse(true))
{
sMsg = "reuse failed";
}
else if (pSocket->Connect(oNotify.m_szRemoteAddr, oNotify.m_nRemotePort) < 0)
{
sMsg = "connect failed";
}
else if(!pSocket->RegisterEvent(m_base))
{
sMsg = "register failed";
}
else {
bSuccess = true;
}
//注册事件
if(bSuccess)
{
LOG(LT_INFO_TRANS, pSocket->NextTransID().c_str(),
"Worker thread| do connect notify succ| thread_id=%llu| type=%d| fd=%d| unique_id=0x%x| local_addr=%s:%d| remote_addr=%s:%d| binary_mode=%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, pSocket->GetUniqueID(), oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort, oNotify.m_bBinaryMode
);
}
else
{
LOG(LT_ERROR,
"Worker thread| do connect failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d| state=%d| msg=%s",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort, pSocket->GetState(), sMsg.c_str()
);
pSocket->Release(true);
if(NULL == oNotify.m_pHandler)
{
oNotify.m_pHandler->OnConnect(oNotify.m_nFd, false, 0, oNotify.m_bBinaryMode);
}
}
}
//Listen的通知处理
void CWorkerThread::DoListen(const CNotifyFd &oNotify)
{
TcpSocket *pSocket = CSocketManager::Instance()->GetTcpSocket(oNotify.m_nFd);
if(NULL == pSocket)
{
LOG(LT_ERROR,
"Worker thread| do listen notify get socket failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort
);
close(oNotify.m_nFd);
_exit(0);
}
pSocket->SetLocalAddr(oNotify.m_szLocalAddr, oNotify.m_nLocalPort);
//注册listen事件
if(!pSocket->RegisterListen(m_base))
{
LOG(LT_ERROR,
"Worker thread| do listen notify register failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort
);
pSocket->Release(true);
_exit(0);
}
LOG(LT_INFO, "Worker thread| do listen notify succ| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort
);
}
void CWorkerThread::DoClose(const CNotifyFd &oNotify)
{
TcpSocket *pSocket = CSocketManager::Instance()->GetTcpSocket(oNotify.m_nFd);
if(NULL == pSocket)
{
LOG(LT_ERROR,
"Worker thread| do connect notify get socket failed| thread_id=%llu| type=%d| fd=%d| local_addr=%s:%d| remote_addr=%s:%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort
);
close(oNotify.m_nFd);
return;
}
LOG(LT_INFO_TRANS, pSocket->NextTransID().c_str(),
"Worker thread| do close notify succ| thread_id=%llu| type=%d| fd=%d| unique_id=0x%x| local_addr=%s:%d| remote_addr=%s:%d| binary_mode=%d",
m_nThreadID, oNotify.m_nType, oNotify.m_nFd, pSocket->GetUniqueID(), oNotify.m_szLocalAddr, oNotify.m_nLocalPort, oNotify.m_szRemoteAddr, oNotify.m_nRemotePort, oNotify.m_bBinaryMode
);
pSocket->ActiveClose();
}
}
| 35.389027 | 198 | 0.549503 | deeptexas-ai |
9dd9cbda5f437b167f3828e590502a2766fe4e92 | 639 | cpp | C++ | source/Ch18/drill/chapter18.2.cpp | TangoPango2008/UDProg-Introduction | 3d98eb5c6fd9896e5c8bbd939bcf7061370b9a5c | [
"CC0-1.0"
] | null | null | null | source/Ch18/drill/chapter18.2.cpp | TangoPango2008/UDProg-Introduction | 3d98eb5c6fd9896e5c8bbd939bcf7061370b9a5c | [
"CC0-1.0"
] | null | null | null | source/Ch18/drill/chapter18.2.cpp | TangoPango2008/UDProg-Introduction | 3d98eb5c6fd9896e5c8bbd939bcf7061370b9a5c | [
"CC0-1.0"
] | null | null | null | #include "../std_lib_facilities.h"
vector<int> gv{1,2,4,8,16,31,64,128,256,512};
/*void initialize(vector<int> vr){
for(int i = 0; i < vr.size(); i ++)
vr[i] = pow(2,i);
}*/
void f(vector<int>& vr){
vector<int> lv(10);
for(int i = 0; i < lv.size(); i ++)
lv[i] = vr[i];
for(int i = 0; i < lv.size(); i ++)
cout << lv[i] << ' ' ;
cout << '\n';
vector<int> lv2(vr.size());
lv2 = vr;
for(int i = 0; i < lv2.size(); i ++)
cout << lv2[i] << ' ' ;
cout << '\n';
}
int main(){
f(gv);
vector<int> vv(10);
int factorial = 1;
for(int i = 1; i < vv.size()+1; i++){
factorial *= i;
vv[i-1] = factorial;
}
f(vv);
} | 16.384615 | 45 | 0.494523 | TangoPango2008 |
9ddcf2c3e4774ded9507ec9d5f69f9970bc02fb5 | 47,040 | cpp | C++ | Engine/Rogy.cpp | Yavuz1234567890/Rogy-Engine- | ccabed511be0a7d719d0e8793b91a11fe08024ea | [
"MIT"
] | 1 | 2021-01-07T03:10:21.000Z | 2021-01-07T03:10:21.000Z | Engine/Rogy.cpp | LigthWood/Rogy-Engine- | 9690d05a7cc99fffa492eef5303568ae227682b8 | [
"MIT"
] | null | null | null | Engine/Rogy.cpp | LigthWood/Rogy-Engine- | 9690d05a7cc99fffa492eef5303568ae227682b8 | [
"MIT"
] | null | null | null | #include "Rogy.h"
#include "gizmos\debug_gizmos.h"
#include "physics\GLDebugDrawer.h"
DDRenderInterfaceCoreGL* ddGizmos;
// Window weigh and height
int SCR_weight, SCR_height;
// ---------------------------------------------------------------
// ## Editor Camera Movment
// ---------------------------------------------------------------
bool poses_geted;
bool CamCanMove;
double l_xpos, l_ypos;
void FpsCamera(Camera *cam, float dt, GLFWwindow* wind)
{
if (CamCanMove)
{
if (!poses_geted)
{
glfwGetCursorPos(wind, &l_xpos, &l_ypos);
poses_geted = true;
}
if (!cam->MouseSeted)
{
glfwSetCursorPos(wind, SCR_weight / 2, SCR_height / 2);
cam->MouseSeted = true;
}
glfwSetInputMode(wind, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Get mouse position
double xpos, ypos;
glfwGetCursorPos(wind, &xpos, &ypos);
// Reset mouse position for next frame
glfwSetCursorPos(wind, SCR_weight / 2, SCR_height / 2);
// Compute new orientation
glm::vec3 rot = cam->transform.Rotation;
rot.y += cam->MouseSpeed * (float)(SCR_weight / 2 - xpos);
rot.x += cam->MouseSpeed * (float)(SCR_height / 2 - ypos);
cam->transform.SetRotation(rot);
if (glfwGetKey(wind, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
{
cam->Speed = 50;
}
else
{
cam->Speed = 15;
}
// Move forward
if (glfwGetKey(wind, GLFW_KEY_W) == GLFW_PRESS)
{
//cam.Position += cam.direction * Time::deltaTime * cam.Speed
cam->transform.Position += cam->transform.direction() * cam->Speed * dt;
}
// Move backward
if (glfwGetKey(wind, GLFW_KEY_S) == GLFW_PRESS)
{
cam->transform.Position -= cam->transform.direction() * cam->Speed * dt;
}
// Strafe right
if (glfwGetKey(wind, GLFW_KEY_D) == GLFW_PRESS)
{
cam->transform.Position += cam->transform.right() * cam->Speed * dt;
}
// Strafe left
if (glfwGetKey(wind, GLFW_KEY_A) == GLFW_PRESS)
{
cam->transform.Position -= cam->transform.right() * cam->Speed * dt;
}
}
else
{
cam->MouseSeted = false;
glfwSetInputMode(wind, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
if (poses_geted)
{
//Reset mouse position for next frame
glfwSetCursorPos(wind, l_xpos, l_ypos);
poses_geted = false;
}
}
}
// ---------------------------------------------------------------
// ## Engine
// ---------------------------------------------------------------
Rogy::Rogy() { }
Rogy::~Rogy() { }
void OnWindowResize(GLFWwindow* window, int weigth, int height)
{
glViewport(0, 0, weigth, height);
SCR_weight = weigth;
SCR_height = height;
}
bool Rogy::InitGraphics()
{
// Initialize the window
// ----------------------------
window.StartWindow(SCR_weight, SCR_height, 4, 0); // Initialize GLFW window with GL/GLSL version 4.0
#ifdef EDITOR_MODE // Set Window Title
window.SetWindowTitle("Rogy Editor");
#else
window.SetWindowTitle(mProjectSettings.GameName.c_str());
#endif
window.SetWindowSizeCallback(OnWindowResize); // Set Size callback function
window.GetFramebufferSize(SCR_weight, SCR_height); // Get Framebuffer size
window.SetWindowIcon("core/logo.png"); // Change window Icon
// Set the mouse at the center of the screen
glfwPollEvents();
glfwSwapInterval(0); // Vsync
// limit frame rate
frameRateLimit = 0.0f;
// Initialize Render Engine
// ----------------------------
renderer.Initialize(SCR_weight, SCR_height, window.window, &resManager);
return true;
}
bool Rogy::Init()
{
RGetCurrentPath();
Rogy::getIns(this);
LoadProjectSettings();
SCR_weight = mProjectSettings.ResolutionWeight;
SCR_height = mProjectSettings.ResolutionHeight;
// Initialize Resources
// ----------------------------
Init_succes = false;
resManager.Init();
resManager.scene = &mScene;
MainViewport.height = (float)SCR_height;
MainViewport.weight = (float)SCR_weight;
MainViewport.left_pos = 0.0f;
MainViewport.top_pos = 0.0f;
// Initialize Graphics
// ----------------------------
if (InitGraphics())
{
Init_succes = true;
}
else { return false; }
m_UI.Init();
#ifdef EDITOR_MODE
EditorMode = true;
#else
mScene.game_view = true;
BeginPlay();
if (mProjectSettings.DefaultFullScreen)
window.SetFullScreen(true);
#endif
mScene.Root.root = true;
DebugTool::GetInstance(&m_Debug);
// Initialize Physics
// ---------------------------
m_PhysicsWorld.Init();
// Initialize Scripting
// ---------------------------
m_ScriptManager.debug = &m_Debug;
RecompileScripts();
// Initialize Audio
// ---------------------------
m_Audio.Init();
// Initialize input
m_Input.Init(window.window);
//m_Input.AddAxis("Horizontal", RKey::KEY_D, RKey::KEY_A);
//m_Input.AddAxis("Vertical" , RKey::KEY_W, RKey::KEY_S);
// Initialize Editor
// ----------------------------
editor.SCR_height = SCR_height;
editor.SCR_weight = SCR_weight;
editor.MainViewport = &MainViewport;
if (editor.Init("#version 130", window.window))
{
Init_succes = true;
if (EditorMode)
{
editor.s_hierarchy.scene = &mScene;
editor.scn_settings.rndr = &renderer;
editor.prep_editor.res = &resManager;
editor.prep_editor.rndr = &renderer;
editor.prep_editor.phy_world = &m_PhysicsWorld;
editor.prep_editor.scrMnger = &m_ScriptManager;
editor.db_editor.debuger = &m_Debug;
editor.prg_settings.input = &m_Input;
editor.prg_settings.rndr = &renderer;
editor.prg_settings.prj = &mProjectSettings;
editor.prep_editor.audio_mnger = &m_Audio;
}
}
else return false;
return true;
}
// ---------------------------------------------------------------
// ## Play mode
// ---------------------------------------------------------------
bool Rogy::IsPlaying()
{
return isPlaying;
}
void Rogy::BeginPlay()
{
mScene.is_playing = true;
isPlaying = true;
SaveScene("core\\temp_scene", true);
m_ScriptManager.BeginGame();
}
void Rogy::StopPlay()
{
mScene.is_playing = false;
isPlaying = false;
LoadScene("core\\temp_scene", true);
}
// ---------------------------------------------------------------
// ## Grass editor
// ---------------------------------------------------------------
void Rogy::GrassEdit()
{
if (!mScene.edit_grass) return;
std::vector<GrassComponent*> allGrass = renderer.mGrass.GetComponents();
GrassComponent* grass = nullptr;
for (size_t i = 0; i < allGrass.size(); i++)
{
if (allGrass[i]->edit)
{
grass = allGrass[i];
break;
}
}
// Grass Edit
if (grass != nullptr)
{
if (m_Input.GetMouseButtonDown(0))
{
m_PhysicsWorld.updateAABBs();
if (m_Input.GetKey(RKey::KEY_LSHIFT))
{
glm::vec3 rayStart, rayDir, grassPos;
int mouseX = int(m_Input.GetMouseXPos() - MainViewport.left_pos);
int mouseY = int(m_Input.GetMouseYPos() - MainViewport.top_pos - 57);
m_PhysicsWorld.ScreenPosToWorldRay(mouseX, mouseY
, (int)MainViewport.weight, (int)MainViewport.height,
renderer.MainCam.GetViewMatrix(), renderer.MainCam.GetProjectionMatrix()
, rayStart, rayDir);
if (m_PhysicsWorld.RaycastHitPoint(renderer.MainCam.transform.Position, rayDir, 10000.0f, grassPos))
grass->RemoveBladesInRange(grassPos + glm::vec3(0.0f, grass->size.y, 0.0f));
}
else {
int aRaduis = grass->Edit_Raduis;
for (size_t i = 0; i < grass->Edit_amount; i++)
{
glm::vec3 rayStart, rayDir, grassPos;
int mouseX = int(m_Input.GetMouseXPos() - MainViewport.left_pos);
int mouseY = int(m_Input.GetMouseYPos() - MainViewport.top_pos - 57);
mouseX += Random::Range(-aRaduis, aRaduis);
mouseY += Random::Range(-aRaduis, aRaduis);
m_PhysicsWorld.ScreenPosToWorldRay(mouseX, mouseY
, (int)MainViewport.weight, (int)MainViewport.height,
renderer.MainCam.GetViewMatrix(), renderer.MainCam.GetProjectionMatrix()
, rayStart, rayDir);
if (m_PhysicsWorld.RaycastHitPoint(renderer.MainCam.transform.Position, rayDir, 10000.0f, grassPos))
grass->AddGrassBlade(grassPos + glm::vec3(0.0f, grass->size.y, 0.0f));
}
}
}
}
}
CDebugDraw* debugDrawer;
// ---------------------------------------------------------------
// ## Update
// ---------------------------------------------------------------
void Rogy::StartUp()
{
// Set a unique id for each component by registering it
// ----------------------------------------------
REGISTER_COMPONENT(BillboardComponent);
REGISTER_COMPONENT(SpotLight);
REGISTER_COMPONENT(DirectionalLight);
REGISTER_COMPONENT(PointLight);
REGISTER_COMPONENT(ReflectionProbe);
REGISTER_COMPONENT(CameraComponent);
REGISTER_COMPONENT(RendererComponent);
REGISTER_COMPONENT(RigidBody);
REGISTER_COMPONENT(NativeScriptComponent);
REGISTER_COMPONENT(ParticleSystem);
REGISTER_COMPONENT(RAudioSource);
REGISTER_COMPONENT(GrassComponent);
REGISTER_COMPONENT(UIText);
UIText* text = m_UI.texts.AddComponent(0);
text->Position = glm::vec2(10, 10);
text->Scale.x = 0.5f;
text->alpha = 0.7f;
text->text = "Rogy Game";
m_UI.img->texture = resManager.CreateTexture("res//Textures//backward-time.png", "res//Textures//crate.png");
m_UI.img->Position = glm::vec2(200, 200);
m_UI.img->Scale = glm::vec2(50, 50);
m_UI.Checked = resManager.CreateTexture("core//textures//checked.png", "core//textures//checked.png");
m_UI.Unchecked = resManager.CreateTexture("core//textures//unchecked.png", "core//textures//unchecked.png");
LoadScene(mProjectSettings.MainScenePath.c_str());
return;
Entity* r = mScene.AddEntity("TringleMesh");
RendererComponent* mesh = renderer.m_renderers.AddComponent(r->ID);
r->AddComponent<RendererComponent>(mesh);
mesh->material = renderer.CreateMaterial("");
mesh->mesh = resManager.mMeshs.CreateModel("res//models//teapot.obj")->GetFirstMesh();
m_PhysicsWorld.AddRigidBody(r);
RigidBody* rb = r->GetComponent<RigidBody>();
btTriangleMesh* tm = new btTriangleMesh();
for (size_t i = 0; i < mesh->mesh->indices.size(); i+= 3)
{
tm->addTriangle(btVector3(mesh->mesh->vertices[i].Position.x, mesh->mesh->vertices[i].Position.y, mesh->mesh->vertices[i].Position.z),
btVector3(mesh->mesh->vertices[i + 1].Position.x, mesh->mesh->vertices[i + 1].Position.y, mesh->mesh->vertices[i + 1].Position.z),
btVector3(mesh->mesh->vertices[i + 2].Position.x, mesh->mesh->vertices[i + 2].Position.y, mesh->mesh->vertices[i + 2].Position.z));
}
btCollisionShape* meshShape = new btBvhTriangleMeshShape(tm, true);
delete rb->collisionShape;
rb->collisionShape = meshShape;
rb->m_CollisionType = MESH_COLLIDER;
rb->GetRigidBody()->setCollisionShape(rb->collisionShape);
}
void Rogy::MainLoop()
{
if (!Init_succes) return;
StartUp();
debugDrawer = new CDebugDraw();
debugDrawer->setDebugMode(btIDebugDraw::DBG_DrawWireframe);
m_PhysicsWorld.dynamicsWorld->setDebugDrawer(debugDrawer);
// Set up the Debug Draw:
ddGizmos = new DDRenderInterfaceCoreGL();
dd::initialize(ddGizmos);
double lasttime = glfwGetTime();
while (window.active)
{
#ifdef EDITOR_MODE
if (EditorMode && !IsPlaying())
if (!editor.isMouseInEditor())
this_thread::sleep_for(std::chrono::duration<int>(1));
#endif // EDITOR_MODE
// Frame rate limiter.
// ----------------------------------------
if (frameRateLimit != 0.0f)
{
while (glfwGetTime() < lasttime + 1.0 / frameRateLimit)
{
continue;
}
lasttime += 1.0 / frameRateLimit;
}
// per-frame time logic
// ----------------------------------------
float currentFrame = (float)glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
FPS = (int)(1.0f / deltaTime);
renderer.fps = FPS;
m_Input.Update(deltaTime);
// Prepare for the new frame
// ----------------------------------------
#ifdef EDITOR_MODE
if (!mScene.game_view) {
CamCanMove = glfwGetMouseButton(window.window, GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS;
if (ImGui::IsAnyWindowHovered())
CamCanMove = false;
else GrassEdit();
FpsCamera(&renderer.MainCam, deltaTime, window.window);
}
else if (isPlaying && m_Input.GetKeyDown(RKey::KEY_ESCAPE))
m_Input.SetCursor(true);
renderer.OnViewportResize((int)MainViewport.left_pos, (int)MainViewport.top_pos, (int)MainViewport.weight, (int)MainViewport.height);
m_UI.SetScreenSize((int)MainViewport.left_pos, (int)MainViewport.top_pos, (int)MainViewport.weight, (int)MainViewport.height);
#else
renderer.OnViewportResize(0, 0, SCR_weight, SCR_height);
#endif // EDITOR_MODE
/* Serialization operations are unreliable, sometimes can cause errors
For example : corrupted files etc... */
try { QueueSpawnList(); }
catch (cereal::Exception ex) { std::cout << ex.what() << endl; }
m_PhysicsWorld.update();
if (IsPlaying())
m_PhysicsWorld.StepSimulation(deltaTime);
mScene.Root.Update(deltaTime);
UpdateEntity(&mScene.Root);
renderer.UpdateGameCamera();
PushAllRenders();
m_Audio.SetListenerPosition(renderer.MainCam.transform.Position);
m_Audio.SetListenerForward(renderer.MainCam.transform.forward());
m_Audio.SetListenerUp(renderer.MainCam.transform.up());
m_Audio.Update();
m_ScriptManager.Update();
if (IsPlaying())
m_ScriptManager.OnTick(deltaTime);
m_Input.ResetMouseDelta();
// Render Frame
// ----------------------------------------
if (renderer.BakeLighting)
lmBaked = true;
renderer.RenderFrame(deltaTime);
#ifdef EDITOR_MODE
// If the Lightmaps where baked last frame set the texture of every mesh to its lightmap texture.
if (renderer.isLightBakingSucceed() && lmBaked)
{
lmSetIndex = 0;
SetEntitiesLightmapPaths(mScene.GetRoot());
lmBaked = false;
}
if (EditorMode && !mScene.game_view)
{
ddGizmos->mvpMatrix = renderer.MainCam.GetProjectionMatrix() * renderer.MainCam.GetViewMatrix();
ddGizmos->scr_w = (int)MainViewport.weight;
ddGizmos->scr_h = (int)MainViewport.height;
if (EditorMode) {
if (mScene.show_grid)
dd::xzSquareGrid(-50.0f, 50.0f, -1.0f, 1.0f, dd::colors::Gray);
// Debug physics
//m_PhysicsWorld.dynamicsWorld->debugDrawWorld();
for (size_t i = 0; i < debugDrawer->LINES.size(); i++)
{
CDebugDraw::_LINE l = debugDrawer->LINES[i];
const ddVec3 mfrom = { l.from.getX(), l.from.getY(), l.from.getZ() };
const ddVec3 mto = { l.to.getX(), l.to.getY(), l.to.getZ() };
dd::line(mfrom, mto, dd::colors::Green);
}
debugDrawer->LINES.clear();
}
dd::flush();
}
#endif
renderer.EndFrame();
m_UI.Render(int(m_Input.GetMouseXPos() - MainViewport.left_pos), int(m_Input.GetMouseYPos() + MainViewport.top_pos), m_Input.GetMouseButton(0));
// Render UI
// ----------------------------------------
#ifdef EDITOR_MODE
RenderUI();
#endif
// Swap buffers
// ----------------------------------------
m_Input.Clear();
window.SwapBuffersAndPollEvents();
}
// Clear
// ----------------------------------------
editor.ShutDown();
delete debugDrawer;
delete ddGizmos;
m_ScriptManager.Close();
Clear();
SaveProjectSettings();
// Close OpenGL window and terminate GLFW
glfwTerminate();
}
// ---------------------------------------------------------------
// ## Billboards
// ---------------------------------------------------------------
void Rogy::PushAllRenders()
{
glm::vec3 camPos = renderer.MainCam.transform.Position;
for (size_t i = 0; i < renderer.r_billboards.size(); i++)
{
BillboardComponent* bb = renderer.r_billboards[i];
if (bb->depth_test)
renderer.AddBillbroadInfo(bb->pos, bb->size, bb->tex_path.c_str(), true, bb->color, bb->use_tex_as_mask);
else
{
if (bb->sun_source)
{
glm::vec3 lpos = bb->dir + camPos;
vec3 lightDir = glm::normalize(lpos - camPos);
if (!m_PhysicsWorld.RayTest(camPos, lightDir, 99999.9f))
renderer.AddBillbroadInfo(lpos, bb->size, bb->tex_path.c_str(), false, bb->color, bb->use_tex_as_mask);
}
else
{
float range = glm::distance(camPos, bb->pos);
vec3 lightDir = glm::normalize(bb->pos - camPos);
if (!m_PhysicsWorld.RayTest(camPos, lightDir, range))
renderer.AddBillbroadInfo(bb->pos, bb->size, bb->tex_path.c_str(), false, bb->color, bb->use_tex_as_mask);
}
}
}
}
// ---------------------------------------------------------------
// ## Update Entities
// ---------------------------------------------------------------
void Rogy::UpdateEntity(Entity* ent)
{
Transform& transform = ent->transform;
bool ChangedTransform = transform.transformation_changed;
transform.transformation_changed = false;
bool active = ent->Active;
for (size_t i = 0; i < ent->m_components.size(); i++)
{
// Push Renderer component to the renderer
if (Component::IsComponentType<RendererComponent>(ent->m_components[i]))
{
RendererComponent* rc = Component::QuickCast<RendererComponent>(ent->m_components[i]);
if (rc->mesh) {
rc->enabled = ent->Active;
rc->IsStatic = ent->Static;
if (ChangedTransform) {
rc->position = transform.GetWorldPosition();
rc->transform = transform.GetTransform();
glm::vec3 ws = transform.GetWorldScale();
rc->bbox.BoxMax = (rc->mesh->bbox.BoxMax * ws) + transform.GetWorldPosition();
rc->bbox.BoxMin = (rc->mesh->bbox.BoxMin * ws) + transform.GetWorldPosition();
rc->bbox.radius = (ws.x + ws.y + ws.z) / 3;
/*rc->bbox.radius = rc->mesh->bbox.radius + ws.x - 1;
rc->bbox.radius = rc->bbox.radius + ws.y - 1;
rc->bbox.radius = rc->bbox.radius + ws.z - 1;*/
if (transform.Angels != glm::vec3(0.0f, 0.0f, 0.0f))
rc->bbox.useRaduis = true;
else rc->bbox.useRaduis = false;
}
if (!mScene.game_view && ent->is_Selected && !rc->bbox.useRaduis) {
// Axis-aligned bounding box:
const ddVec3 bbMins = { rc->bbox.BoxMin.x
, rc->bbox.BoxMin.y
, rc->bbox.BoxMin.z };
const ddVec3 bbMaxs = { rc->bbox.BoxMax.x
, rc->bbox.BoxMax.y
, rc->bbox.BoxMax.z };
const ddVec3 bbCenter = {
(bbMins[0] + bbMaxs[0]) * 0.5f,
(bbMins[1] + bbMaxs[1]) * 0.5f,
(bbMins[2] + bbMaxs[2]) * 0.5f
};
dd::aabb(bbMins, bbMaxs, dd::colors::Gray);
}
renderer.PushRender(rc->mesh, rc->material, rc->transform, rc->bbox, rc->CastShadows, rc->position, rc->IsStatic, rc->lightmapPath);
}
continue;
}
if (Component::IsComponentType<RigidBody>(ent->m_components[i]))
{
RigidBody* rb = Component::QuickCast<RigidBody>(ent->m_components[i]);
if (transform.m_Last_Transform != transform.m_Transform)
rb->rigidBody->activate();
btTransform& tr = rb->GetTransform();
btVector3& ve = tr.getOrigin();
btQuaternion& qu = tr.getRotation();
quat q = quat(qu.getW(), qu.getX(), qu.getY(), qu.getZ());
transform.SetRotation(q);
//transform.SetPosition(ve.getX(), ve.getY(), ve.getZ());
transform.SetPosition(glm::vec3(ve.getX(), ve.getY(), ve.getZ()));
if(ent->is_Selected && !mScene.game_view)
m_PhysicsWorld.dynamicsWorld->debugDrawObject(rb->rigidBody->getWorldTransform(), rb->rigidBody->getCollisionShape(), btVector3(1, 1, 1));
continue;
}
// Update Light Position
if (Component::IsComponentType<PointLight>(ent->m_components[i]))
{
PointLight* point_light = Component::QuickCast<PointLight>(ent->m_components[i]);
point_light->Active = active;
point_light->Static = ent->Static;
point_light->Position = transform.GetWorldPosition();
if (!mScene.game_view && ent->is_Selected)
{
vec3 cen = transform.GetWorldPosition();
float rad = point_light->Raduis;
const ddVec3 bbCenter = { cen.x, cen.y, cen.z };
const ddVec3 xbbnorm = { 1, 0, 0 };
const ddVec3 ybbnorm = { 0, 1, 0 };
const ddVec3 zbbnorm = { 0, 0, 1 };
dd::circle(bbCenter, xbbnorm, dd::colors::Gray, rad, 40);
dd::circle(bbCenter, ybbnorm, dd::colors::Gray, rad, 40);
dd::circle(bbCenter, zbbnorm, dd::colors::Gray, rad, 40);
}
continue;
}
if (Component::IsComponentType<DirectionalLight>(ent->m_components[i]))
{
DirectionalLight* dir_light = Component::QuickCast<DirectionalLight>(ent->m_components[i]);
dir_light->Active = active;
dir_light->Direction = transform.forward();
continue;
}
if (Component::IsComponentType<SpotLight>(ent->m_components[i]))
{
SpotLight* spot_light = Component::QuickCast<SpotLight>(ent->m_components[i]);
spot_light->Active = active;
spot_light->Direction = transform.forward();
spot_light->Position = transform.GetWorldPosition();
continue;
}
if (Component::IsComponentType<ReflectionProbe>(ent->m_components[i]))
{
ReflectionProbe* ref_probe = Component::QuickCast<ReflectionProbe>(ent->m_components[i]);
ref_probe->Active = active;
ref_probe->Position = transform.GetWorldPosition();
if (!mScene.game_view && ent->is_Selected)
{
// Axis-aligned bounding box:
const ddVec3 bbMins = { ref_probe->GetBBox().BoxMin.x
, ref_probe->GetBBox().BoxMin.y
, ref_probe->GetBBox().BoxMin.z };
const ddVec3 bbMaxs = { ref_probe->GetBBox().BoxMax.x
, ref_probe->GetBBox().BoxMax.y
, ref_probe->GetBBox().BoxMax.z };
const ddVec3 bbCenter = {
(bbMins[0] + bbMaxs[0]) * 0.5f,
(bbMins[1] + bbMaxs[1]) * 0.5f,
(bbMins[2] + bbMaxs[2]) * 0.5f
};
dd::aabb(bbMins, bbMaxs, dd::colors::Gray);
}
continue;
}
// Update Billboard position
if (Component::IsComponentType<BillboardComponent>(ent->m_components[i]))
{
BillboardComponent* bb = Component::QuickCast<BillboardComponent>(ent->m_components[i]);
bb->pos = transform.GetWorldPosition();
bb->dir = transform.forward();
continue;
}
if (Component::IsComponentType<ParticleSystem>(ent->m_components[i]))
{
ParticleSystem* bb = Component::QuickCast<ParticleSystem>(ent->m_components[i]);
bb->TargetPos = transform.GetWorldPosition();
bb->Direction = transform.forward();
continue;
}
// Update Camera info
if (Component::IsComponentType<CameraComponent>(ent->m_components[i]))
{
CameraComponent* cam = Component::QuickCast<CameraComponent>(ent->m_components[i]);
cam->position = transform.GetWorldPosition();
cam->right = transform.right();
cam->direction = transform.forward();
cam->up = transform.up();
continue;
}
if (Component::IsComponentType<RAudioSource>(ent->m_components[i]))
{
RAudioSource* audio = Component::QuickCast<RAudioSource>(ent->m_components[i]);
audio->SetPosition(transform.GetWorldPosition());
continue;
}
if (Component::IsComponentType<NativeScriptComponent>(ent->m_components[i]))
{
NativeScriptComponent* nsc = Component::QuickCast<NativeScriptComponent>(ent->m_components[i]);
if (!nsc->Instance)
{
nsc->Instance = nsc->InstantiateScript();
nsc->Instance->m_entity = ent;
nsc->Instance->OnCreate();
}
nsc->Instance->OnUpdate(deltaTime);
continue;
}
}
for (size_t i = 0; i < ent->Children.size(); i++)
{
UpdateEntity(ent->Children[i]);
}
}
// ---------------------------------------------------------------
// ## Spawn entities, load/save/clear scene
// ---------------------------------------------------------------
void Rogy::QueueSpawnList()
{
renderer.use_GameView = mScene.game_view;
for (size_t i = 0; i < mScene.m_requests.size(); i++)
{
if (mScene.m_requests[i] == SR_RECOMPILE_SCRIPTS)
{
RecompileScripts();
break;
}
if (mScene.m_requests[i] == SR_PAST_COPY)
{
std::filebuf fb;
if (fb.open("savedCopy", std::ios::in))
{
std::istream is(&fb);
cereal::BinaryInputArchive ar(is);
Entity* ent = mScene.AddEntity("Entity (Load Failed)"); // this name is used if load fails
LoadEntityForSpawn(ar, ent, false);
fb.close();
}
break;
}
if (mScene.m_requests[i] == SR_PLAY_SCENE)
{
if (IsPlaying())
StopPlay();
else
BeginPlay();
break;
}
if (mScene.m_requests[i] == SR_QUIT_GAME)
{
window.CloseWindow();
break;
}
if (mScene.m_requests[i] == SR_NEW_SCENE)
{
ClearScene();
mScene.name = "";
mScene.path = "";
mScene.Root.name = "New Scene";
break;
}
if (mScene.m_requests[i] == SR_LOAD_SCENE)
{
LoadScene(mScene.path.c_str());
break;
}
if (mScene.m_requests[i] == SR_SAVE_SCENE)
{
SaveScene(mScene.path.c_str());
break;
}
}
for (size_t i = 0; i < mScene.spawn_requests.size(); i++)
{
SpawnEntity(mScene.spawn_requests[i]);
}
mScene.spawn_requests.clear();
mScene.m_requests.clear();
}
void Rogy::LoadEntityForSpawn(cereal::BinaryInputArchive &ar, Entity* ent, bool is_load_scene_root, bool LoadCustomTransformation)
{
std::string ser_ver;
ar(ser_ver);
//ar(ID);
ar(ent->is_prefab);
// If this entity is prefab then load it from its file
// Prefab is minimized version of scene and can be spawned inside a scene.
if (ent->is_prefab)
{
ar(ent->transform);
ar(ent->path);
//std::cout << "LOADING A PREFAB IN SCENE : " << ent->path << std::endl;
std::filebuf fb;
if (fb.open(ent->path, std::ios::in))
{
std::istream is(&fb);
cereal::BinaryInputArchive ar(is);
LoadEntityForSpawn(ar, ent, false, true);
fb.close();
}
}
else
{
ar(ent->name);
ar(ent->tag);
ar(ent->Active);
ar(ent->Static);
if (LoadCustomTransformation)
{
// Do not apply the loaded transformation from the prefab when loading
// Just use the last applied trasformation
ent->transform.noApply = true;
}
ar(ent->transform);
// Load entity's components one by one
int num_comp = 0; ar(num_comp);
int comp_id = -1;
for (int i = 0; i < num_comp; i++)
{
ar(comp_id);
if (comp_id == RendererComponent::TYPE_ID)
{
RendererComponent* rc = renderer.m_renderers.AddComponent(ent->ID);
ent->AddComponent<RendererComponent>(rc);
ar(rc->enabled);
ar(rc->CastShadows);
ar(rc->lightmapPath);
bool hasMesh = false;
ar(hasMesh);
if (hasMesh)
{
string dir;
int indx = 0;
ar(dir);
ar(indx);
rc->mesh = &resManager.mMeshs.CreateModel(dir)->meshes[indx];
}
string mat_dir, mat_name;
ar(mat_dir);
ar(mat_name);
rc->material = renderer.LoadMaterial(mat_dir.c_str());
if (!rc->material->isDefault)
rc->material->path = mat_name;
}
else if (comp_id == PointLight::TYPE_ID)
{
ent->AddComponent<PointLight>(renderer.CreatePointLight(ent->ID));
ent->GetComponent<PointLight>()->SerializeLoad<cereal::BinaryInputArchive>(ar);
}
else if (comp_id == SpotLight::TYPE_ID)
{
ent->AddComponent<SpotLight>(renderer.CreatePointLight(ent->ID));
ent->GetComponent<SpotLight>()->SerializeLoad<cereal::BinaryInputArchive>(ar);
}
else if (comp_id == DirectionalLight::TYPE_ID) {
ent->AddComponent<DirectionalLight>(renderer.CreateDirectionalLight());
ent->GetComponent<DirectionalLight>()->SerializeLoad<cereal::BinaryInputArchive>(ar);
}
else if (comp_id == ReflectionProbe::TYPE_ID)
{
ent->AddComponent<ReflectionProbe>(renderer.CreateReflectionProbe(ent->ID));
ent->GetComponent<ReflectionProbe>()->SerializeSave<cereal::BinaryInputArchive>(ar);
}
else if (comp_id == RigidBody::TYPE_ID)
{
m_PhysicsWorld.AddRigidBody(ent);
ent->GetComponent<RigidBody>()->SerializeLoad<cereal::BinaryInputArchive>(ar);
ent->SetScale(ent->transform.GetLocalScale());
}
else if (comp_id == BillboardComponent::TYPE_ID)
{
BillboardComponent* bb = renderer.CreateBillboard(ent->ID);
ent->AddComponent<BillboardComponent>(bb);
bb->SerializeLoad<cereal::BinaryInputArchive>(ar);
}
else if (comp_id == CameraComponent::TYPE_ID)
{
ent->AddComponent<CameraComponent>(renderer.m_cameras.AddComponent(ent->ID));
ent->GetComponent<CameraComponent>()->SerializeLoad<cereal::BinaryInputArchive>(ar);
}
else if (comp_id == ParticleSystem::TYPE_ID)
{
ParticleSystem* ps = renderer.mParticals.AddComponent(ent->ID);
ent->AddComponent<ParticleSystem>(ps);
ps->serializeLoad<cereal::BinaryInputArchive>(ar);
ps->mTexture = resManager.CreateTexture(ps->tex_path, ps->tex_path.c_str());
}
else if (comp_id == RAudioSource::TYPE_ID)
{
RAudioSource* ras = m_Audio.AddComponent(ent->ID);
ent->AddComponent<RAudioSource>(ras);
ras->SerializeLoad<cereal::BinaryInputArchive>(ar);
ras->mClip = m_Audio.LoadClip(ras->clip_path);
}
else if (comp_id == GrassComponent::TYPE_ID)
{
GrassComponent* rc = renderer.mGrass.AddComponent(ent->ID);
rc->SerializeLoad<cereal::BinaryInputArchive>(ar);
rc->mTexture = resManager.CreateTexture(rc->texPath, rc->texPath.c_str());
ent->AddComponent<GrassComponent>(rc);
}
}
size_t script_count; ar(script_count);
for (size_t i = 0; i < script_count; i++)
{
std::string className; ar(className);
ScriptInstance* scr = m_ScriptManager.InstanceComponentClass(ent->ID, className.c_str());
ent->AddScript(scr);
ScriptSerializer::LoadScriptObject(ar, scr);
}
int child_count; ar(child_count);
for (int i = 0; i < child_count; i++)
{
Entity* child_ent = mScene.AddEntity("Entity (Load Failed)");
child_ent->SetParent(ent);
LoadEntityForSpawn(ar, child_ent, false);
}
}
}
void Rogy::ClearScene()
{
renderer.postProc.Use = false;
renderer.SceneName = "";
mScene.Root.RemoveAllChilds();
renderer.RemoveAllLights();
renderer.Clear_Lightmaps();
m_ScriptManager.ClearInstances();
}
void Rogy::SaveScene(const char* path, bool temp)
{
std::ofstream os(path, std::ios::binary);
cereal::BinaryOutputArchive ar(os);
// scene properties (skybox, post effects, fog)
// ----------------------------------
ar(renderer);
// Save the Scene
// ----------------------------------
try { mScene.SaveBP(ar); }
catch (cereal::Exception ex) { cout << ex.what() << endl; }
os.close();
}
void Rogy::LoadScene(const char* path, bool temp)
{
ClearScene();
if (!temp) {
mScene.name = "";
mScene.Root.name = "New Scene";
}
std::filebuf fb;
if (fb.open(path, std::ios::in))
{
std::istream is(&fb);
cereal::BinaryInputArchive ar(is);
ar(renderer);
string ser_ver;
ar(ser_ver);
if (temp) {
string str;
ar(str);
}
else
{
ar(mScene.name);
eraseSubStr(mScene.name, std::string("\\"));
eraseAllSubStr(mScene.name, std::string(".rscn")); // remove extension
renderer.SceneName = mScene.name;
}
LoadEntityForSpawn(ar, &mScene.Root, true);
mScene.Root.name = mScene.name;
fb.close();
}
// New Scene Loaded
if(IsPlaying())
m_ScriptManager.BeginGame();
}
Entity* Rogy::SpawnEntity(std::string& path)
{
std::filebuf fb;
if (fb.open(path, std::ios::in))
{
std::istream is(&fb);
cereal::BinaryInputArchive ar(is);
Entity* ent = mScene.AddEntity("Entity (Load Failed)"); // this name is used if load fails
ent->is_prefab = true;
ent->path = path;
LoadEntityForSpawn(ar, ent, false);
if (IsPlaying())
ent->StartScripts();
fb.close();
return ent;
}
#ifdef EDITOR_MODE
else
m_Debug.Error("Failed To load prefab at : " + path);
#endif
return nullptr;
}
void LoadModelToEntity(Model* model, Entity* ent, RModelNode* node, SceneManager& scene)
{
ent->name = node->name;
//ent->mesh = &model->meshes[node->idx];
for (size_t i = 0; i < node->children.size(); i++)
{
Entity* ent_c = scene.AddEntity("model");
ent_c->SetParent(ent);
LoadModelToEntity(model, ent_c, node->children[i], scene);
}
}
Entity* Rogy::SpawnModel(std::string& path)
{
Model* model = resManager.mMeshs.CreateModel(path);
if (model == nullptr)
{
m_Debug.Error("failed to load model at : " + path);
return nullptr;
}
Entity* ent = mScene.AddEntity("Model");
LoadModelToEntity(model, ent, model->model_scene, mScene);
return ent;
}
void Rogy::SetEntitiesLightmapPaths(Entity* ent)
{
if (ent->Static && ent->HasComponent<RendererComponent>())
{
ent->GetComponent<RendererComponent>()->lightmapPath = renderer.mlightmaps[lmSetIndex]->getTexPath();
lmSetIndex++;
}
for (size_t i = 0; i < ent->Children.size(); i++)
{
if (!ent->Children[i]->Active)
continue;
SetEntitiesLightmapPaths(ent->Children[i]);
}
}
void Rogy::Clear()
{
mScene.Root.RemoveAllChilds();
window.Clear();
renderer.Clear();
resManager.Clear();
m_Audio.Clear();
}
SceneManager* Rogy::GetScene()
{
return &mScene;
}
// ---------------------------------------------------------------
// ## Play mode
// ---------------------------------------------------------------
void Rogy::RenderUI()
{
editor.SCR_height = SCR_height;
editor.SCR_weight = SCR_weight;
editor.start();
ImGuizmo::BeginFrame();
if (!editor.s_hierarchy.sel_entt.empty()) {
Entity* ent = mScene.FindEntity(editor.s_hierarchy.sel_entt[0]);
if (ent->is_Selected == true)
{
// Entity transform
glm::mat4 transform = ent->transform.GetTransform();
ImGuizmo::Manipulate(glm::value_ptr(renderer.MainCam.GetViewMatrix()), glm::value_ptr(renderer.MainCam.GetProjectionMatrix()),
editor.mCurrentGizmoOperation, editor.mCurrentGizmoMode, glm::value_ptr(transform),nullptr, nullptr);
// Translate only -- other things were buggy
if (ImGuizmo::IsUsing())
ent->SetTranslation(glm::vec3(transform[3]));
}
}
ImGuiIO& io = ImGui::GetIO();
ImGuiViewport *viewport = ImGui::GetMainViewport();
ImGuizmo::SetRect(viewport->Pos.x + MainViewport.left_pos, viewport->Pos.y + 57, MainViewport.weight, MainViewport.height);
editor.render();
}
// ---------------------------------------------------------------
// ## Save game info
// ---------------------------------------------------------------
void Rogy::SaveProjectSettings()
{
mProjectSettings.CascadedShadowMapsResolution = renderer.m_ShadowMapper.TEXEL_SIZE;
mProjectSettings.CascadesCount = renderer.m_ShadowMapper.SHADOW_MAP_CASCADE_COUNT;
mProjectSettings.ShadowDistance = (float)renderer.m_ShadowMapper.Shadow_Distance;
mProjectSettings.PointShadowResolution = renderer.m_PointShadowMapper.TEXEL_SIZE;
mProjectSettings.SpotShadowsResolution = renderer.m_SpotShadowMapper.TEXEL_SIZE;
mProjectSettings.CascadeSplits[0] = renderer.m_ShadowMapper.CascadeSplits[0];
mProjectSettings.CascadeSplits[1] = renderer.m_ShadowMapper.CascadeSplits[1];
mProjectSettings.CascadeSplits[2] = renderer.m_ShadowMapper.CascadeSplits[2];
std::ofstream os("core\\ProjectSettings", std::ios::binary);
cereal::BinaryOutputArchive ar(os);
ar(mProjectSettings);
os.close();
os.open("core\\InputSettings", std::ios::binary);
cereal::BinaryOutputArchive ar2(os);
m_Input.serializeSave<cereal::BinaryOutputArchive>(ar2);
os.close();
}
void Rogy::LoadProjectSettings()
{
std::filebuf fb;
if (fb.open("core\\ProjectSettings", std::ios::in))
{
std::istream is(&fb);
cereal::BinaryInputArchive ar(is);
ar(mProjectSettings);
fb.close();
}
if (fb.open("core\\InputSettings", std::ios::in))
{
std::istream is(&fb);
cereal::BinaryInputArchive ar(is);
m_Input.serializeLoad<cereal::BinaryInputArchive>(ar);
fb.close();
}
renderer.m_ShadowMapper.TEXEL_SIZE = mProjectSettings.CascadedShadowMapsResolution;
renderer.m_ShadowMapper.SHADOW_MAP_CASCADE_COUNT = mProjectSettings.CascadesCount;
renderer.m_ShadowMapper.Shadow_Distance = (size_t)mProjectSettings.ShadowDistance;
renderer.m_PointShadowMapper.TEXEL_SIZE = mProjectSettings.PointShadowResolution;
renderer.m_SpotShadowMapper.TEXEL_SIZE = mProjectSettings.SpotShadowsResolution;
renderer.m_ShadowMapper.CascadeSplits[0] = mProjectSettings.CascadeSplits[0];
renderer.m_ShadowMapper.CascadeSplits[1] = mProjectSettings.CascadeSplits[1];
renderer.m_ShadowMapper.CascadeSplits[2] = mProjectSettings.CascadeSplits[2];
}
// ---------------------------------------------------------------
// Lua Scripting
// ---------------------------------------------
void Rogy::RecompileScripts()
{
// Reload lua state
m_ScriptManager.ReloadLuaInterpreter();
BindEngineForScript();
// Compile scripts in resources folder
m_ScriptManager.RecompileScripts(false);
// Send engine systems to scripting side
LuaRef Func = getGlobal(m_ScriptManager.L, "Prepare_ScriptSide");
Func(&mScene, &m_Input, &m_PhysicsWorld, &m_Debug, &m_Audio);
// Re instance objects
m_ScriptManager.ReInstanceObjects();
}
void Rogy::BindEngineForScript()
{
// Bind all the input keys to Lua in namespace "RKey"
RKey::BindKeyToNamespace(m_ScriptManager.L, "RKey");
luabridge::getGlobalNamespace(m_ScriptManager.L)
//SceneManager
.beginClass<SceneManager>("SceneManager")
.addFunction("SpawnEntity", &SceneManager::SpawnEntity)
.addFunction("LoadScene", &SceneManager::LoadScene)
.addFunction("QuitGame", &SceneManager::QuitGame)
.addProperty("IsPlaying", &SceneManager::is_playing)
.addFunction("GetEntity", &SceneManager::FindEntity)
.addFunction("DestroyEntity", &SceneManager::DestroyEntity)
.addFunction("GetRoot", &SceneManager::GetRoot)
.addFunction("CreateEntity", &SceneManager::CreateEntity<Rogy>)
.endClass()
//Debug
.beginClass<DebugTool>("DebugTool")
.addFunction("Log", &DebugTool::Log)
.addFunction("Warning", &DebugTool::Warning)
.addFunction("Error", &DebugTool::Error)
.addFunction("Clear", &DebugTool::Clear)
.endClass()
.beginClass<AudioClip>("AudioClip")
.addProperty("Path", &AudioClip::mPath)
.endClass()
.beginClass<AudioManager>("AudioManager")
.addFunction("LoadClip", &AudioManager::LoadClip)
.addFunction("Play2D", &AudioManager::Play2D)
.addFunction("Play3D", &AudioManager::Play3D)
.endClass()
.beginNamespace("Mathf")
.addFunction("Clamp", &LMath::Clamp)
.addFunction("Abs", &LMath::Abs)
.addFunction("Sin", &LMath::Sin)
.addFunction("PI", &LMath::PI)
.endNamespace()
// Vector3
.beginClass<glm::vec3>("Vector3")
.addConstructor<void(*) (float, float, float)>()
.addProperty("x", &Vec3Helper::get<0>, &Vec3Helper::set<0>)
.addProperty("y", &Vec3Helper::get<1>, &Vec3Helper::set<1>)
.addProperty("z", &Vec3Helper::get<2>, &Vec3Helper::set<2>)
.addFunction("__add", &Vec3Helper::ADD)
.addFunction("__mul", &Vec3Helper::MUL)
.addFunction("__div", &Vec3Helper::DIV)
.addFunction("__sub", &Vec3Helper::SUB)
.addFunction("__lt", &Vec3Helper::lessThen)
.addFunction("__le", &Vec3Helper::LessOrEq)
.addFunction("__eq", &Vec3Helper::Equale)
.addStaticFunction("Up", &Vec3Helper::VecUp)
.addStaticFunction("Right", &Vec3Helper::VecRight)
.addStaticFunction("Forward", &Vec3Helper::VecForward)
.addStaticFunction("Vec3F", &Vec3Helper::Vec3F)
.addStaticFunction("Lerp", &Vec3Helper::Lerp)
.endClass()
// Vector2
.beginClass<glm::vec2>("Vector2")
.addConstructor<void(*) (float, float)>()
.addProperty("x", &Vec2Helper::get<0>, &Vec2Helper::set<0>)
.addProperty("y", &Vec2Helper::get<1>, &Vec2Helper::set<1>)
.addFunction("__add", &Vec2Helper::ADD)
.addFunction("__mul", &Vec2Helper::MUL)
.addFunction("__div", &Vec2Helper::DIV)
.addFunction("__sub", &Vec2Helper::SUB)
.addFunction("__lt", &Vec2Helper::lessThen)
.addFunction("__le", &Vec2Helper::LessOrEq)
.addFunction("__eq", &Vec2Helper::Equale)
.addStaticFunction("Up", &Vec2Helper::VecUp)
.addStaticFunction("Right", &Vec2Helper::VecRight)
.addStaticFunction("Vec2F", &Vec2Helper::Vec2F)
.addStaticFunction("Lerp", &Vec2Helper::Lerp)
.endClass()
// --------------------------------------------------------------------------
// Binding components
// --------------------------------------------------------------------------
.beginClass<Transform>("Transform")
.addFunction("GetPosition", &Transform::GetLocalPosition)
.addFunction("SetPosition", &Transform::SetPosition)
.addFunction("GetWorldPosition", &Transform::GetWorldPosition)
.addFunction("SetWorldPosition", &Transform::SetWorldPosition)
.addFunction("GetScale", &Transform::GetLocalScale)
.addFunction("SetScale", &Transform::GetLocalScale)
.addFunction("GetAngels", &Transform::GetEurlerAngels)
.addFunction("SetAngels", &Transform::SetAngels)
.addFunction("Forward", &Transform::forward)
.addFunction("Right", &Transform::right)
.addFunction("Up", &Transform::up)
.addFunction("LookAt", &Transform::LookAt)
.addFunction("Translate", &Transform::Translate)
.endClass()
// RigidBody
.beginClass<RigidBody>("RigidBody")
.addFunction("Move", &RigidBody::Move)
.addFunction("GetVelocity", &RigidBody::GetVelocity)
.addFunction("SetVelocity", &RigidBody::SetVelocity)
.addFunction("SetAngels", &RigidBody::SetAngels)
.addFunction("AddForce", &RigidBody::AddForce)
.addFunction("AddCentralForce", &RigidBody::AddCentralForce)
.endClass()
.beginClass<PointLight>("PointLight")
.addProperty("Intensity", &PointLight::Intensity)
.addProperty("Color", &PointLight::Color)
.addProperty("Raduis", &PointLight::Raduis)
.addProperty("CastShadows", &PointLight::CastShadows)
.addProperty("Bias", &PointLight::Bias)
.endClass()
.beginClass<SpotLight>("SpotLight")
.addProperty("Intensity", &SpotLight::Intensity)
.addProperty("Color", &SpotLight::Color)
.addProperty("Raduis", &SpotLight::Raduis)
.addProperty("CastShadows", &SpotLight::CastShadows)
.addProperty("Bias", &SpotLight::Bias)
.addProperty("OuterCutOff", &SpotLight::OuterCutOff)
.addProperty("CutOff", &SpotLight::CutOff)
.endClass()
.beginClass<DirectionalLight>("DirectionalLight")
.addProperty("Intensity", &DirectionalLight::Intensity)
.addProperty("Color", &DirectionalLight::Color)
.addProperty("CastShadows", &DirectionalLight::CastShadows)
.addProperty("Soft", &DirectionalLight::Soft)
.addProperty("Bias", &DirectionalLight::Bias)
.endClass()
.beginClass<CameraComponent>("CameraComponent")
.addProperty("FOV", &CameraComponent::FOV)
.addProperty("Primary", &CameraComponent::Primary)
.addProperty("FarView", &CameraComponent::FarView)
.addProperty("NearView", &CameraComponent::NearView)
.endClass()
.beginClass<BillboardComponent>("BillboardComponent")
.addProperty("enabled", &BillboardComponent::enabled)
.addProperty("depth_test", &BillboardComponent::depth_test)
.addProperty("color", &BillboardComponent::color)
//.addProperty("size", &BillboardComponent::size)
.addProperty("tex_path", &BillboardComponent::tex_path)
.addProperty("sun_source", &BillboardComponent::sun_source)
.endClass()
.beginClass<ReflectionProbe>("ReflectionProbe")
.addProperty("BoxProjection", &ReflectionProbe::BoxProjection)
.addProperty("Intensity", &ReflectionProbe::Intensity)
.addProperty("static_only", &ReflectionProbe::static_only)
.addProperty("Resolution", &ReflectionProbe::Resolution)
.addFunction("BakeReflections", &ReflectionProbe::BakeReflections)
.endClass()
.beginClass<ParticleSystem>("ParticleSystem")
.addProperty("StartSize", &ParticleSystem::StartSize)
.addProperty("StartColor", &ParticleSystem::StartColor)
.addProperty("StartSpeed", &ParticleSystem::StartSpeed)
.addProperty("StartLifeTime", &ParticleSystem::StartLifeTime)
.addProperty("FadeOut", &ParticleSystem::FadeOut)
.addProperty("PlayOnStart", &ParticleSystem::PlayOnStart)
.addProperty("AddSizeOverTime", &ParticleSystem::AddSizeOverTime)
.addProperty("EmitteCount", &ParticleSystem::EmitteCount)
.addFunction("GetMaxParticleCount", &ParticleSystem::GetMaxParticleCount)
.addFunction("SetMaxParticleCount", &ParticleSystem::SetMaxParticleCount)
.addFunction("Emitte", &ParticleSystem::Emitte)
.addFunction("Stop", &ParticleSystem::Stop)
.addProperty("GravityModifier", &ParticleSystem::GravityModifier)
.addProperty("OneDirection", &ParticleSystem::OneDirection)
.addProperty("Spread", &ParticleSystem::Spread)
.addProperty("Looping", &ParticleSystem::Looping)
.addProperty("Emitting", &ParticleSystem::Emitting)
.endClass()
.beginClass<RAudioSource>("RAudioSource")
.addFunction("Play", &RAudioSource::Play)
.addFunction("Stop", &RAudioSource::Stop)
.addProperty("PlayOnStart", &RAudioSource::PlayOnStart)
.addFunction("SetLooping", &RAudioSource::SetLooping)
.addFunction("GetLooping", &RAudioSource::GetLooping)
.addFunction("SetMaxDistance", &RAudioSource::SetMaxDistance)
.addFunction("GetMaxDistance", &RAudioSource::GetMaxDistance)
.addFunction("SetMinDistance", &RAudioSource::SetMinDistance)
.addFunction("GetMinDistance", &RAudioSource::GetMinDistance)
.addFunction("SetVolume", &RAudioSource::SetVolume)
.addFunction("GetVolume", &RAudioSource::GetVolume)
.endClass()
// --------------------------------------------------------------------------
// End binding components
// --------------------------------------------------------------------------
// Entity
.beginClass<Entity>("Entity")
.addData("ID", &Entity::ID, false)
.addProperty("Active", &Entity::Active)
.addProperty("parent", &Entity::parent)
.addProperty("name", &Entity::name)
.addProperty("tag", &Entity::tag)
.addProperty("transform", &Entity::transform)
.addFunction("DestroySelf", &Entity::DestroySelf)
.addFunction("DestroySelfIn", &Entity::DestroySelfIn)
.addFunction("SetParent", &Entity::SetParent)
.addFunction("GetChild", &Entity::GetChild)
.addFunction("SetRotation", &Entity::SetRotation)
.addFunction("SetTranslation", &Entity::SetTranslation)
.addFunction("RotateY", &Entity::RotateY)
.addFunction("GetScriptIndex", &Entity::GetScriptInstance)
.addFunction("GetParticleSystem", &Entity::GetComponent<ParticleSystem>)
.addFunction("GetAudioSource", &Entity::GetComponent<RAudioSource>)
.addFunction("GetRigidBody", &Entity::GetComponent<RigidBody>)
.addFunction("GetPointLight", &Entity::GetComponent<PointLight>)
.addFunction("GetSpotLight", &Entity::GetComponent<SpotLight>)
.addFunction("GetDirectionalLight", &Entity::GetComponent<DirectionalLight>)
.addFunction("GetCameraComponent", &Entity::GetComponent<CameraComponent>)
.addFunction("GetBillboardComponent", &Entity::GetComponent<BillboardComponent>)
.addFunction("GetReflectionProbe", &Entity::GetComponent<ReflectionProbe>)
.endClass()
// InputManager
.beginClass<InputManager>("InputManager")
.addFunction("GetKey", &InputManager::GetKey)
.addFunction("GetKeyDown", &InputManager::GetKeyDown)
.addFunction("GetKeyUp", &InputManager::GetKeyUp)
.addFunction("GetAxis", &InputManager::GetAxis)
.addFunction("GetMouseXPos", &InputManager::GetMouseXPos)
.addFunction("GetMouseYPos", &InputManager::GetMouseYPos)
.addFunction("GetMouseXDelta", &InputManager::GetMouseXDelta)
.addFunction("GetMouseYDelta", &InputManager::GetMouseYDelta)
.addFunction("GetMouseButton", &InputManager::GetMouseButton)
.addFunction("GetMouseButtonDown", &InputManager::GetMouseButtonDown)
.addFunction("GetMouseButtonUp", &InputManager::GetMouseButtonUp)
.addFunction("SetCursor", &InputManager::SetCursor)
.endClass()
// Physics
.beginClass<RayHitInfo>("RayHitInfo")
.addConstructor<void(*) ()>()
.addProperty("hasHit", &RayHitInfo::hasHit)
.addProperty("distance", &RayHitInfo::distance)
.addProperty("body", &RayHitInfo::body)
.addProperty("point", &RayHitInfo::point)
.addProperty("normal", &RayHitInfo::normal)
.endClass()
.beginClass<PhysicsWorld>("PhysicsWorld")
.addFunction("Raycast", &PhysicsWorld::Raycast)
.addFunction("RayTest", &PhysicsWorld::RayTest)
.endClass();
} | 31.826793 | 146 | 0.665859 | Yavuz1234567890 |
9ddf8608c4c60af12c876f221d5734553df3a7ed | 394 | cpp | C++ | source/Highscore.cpp | JROB774/block-fever | 9977ac6725e1adf5f86706e04da725e3df8a9c69 | [
"MIT"
] | 1 | 2022-01-14T01:10:02.000Z | 2022-01-14T01:10:02.000Z | source/Highscore.cpp | JROB774/block-fever | 9977ac6725e1adf5f86706e04da725e3df8a9c69 | [
"MIT"
] | null | null | null | source/Highscore.cpp | JROB774/block-fever | 9977ac6725e1adf5f86706e04da725e3df8a9c69 | [
"MIT"
] | null | null | null | int Highscore::highscore;
void Highscore::setScore (const int arg_highscore) {
highscore = arg_highscore;
}
int Highscore::getScore (void) {
return highscore;
}
bool Highscore::addScore (const int arg_score) {
bool newBest = (arg_score > highscore);
if (newBest) { highscore = arg_score; }
return newBest;
}
void Highscore::reset (void) {
highscore = 0;
}
| 13.133333 | 52 | 0.667513 | JROB774 |
9de029d03df9d6015c2060a20fd98321b2cadb2e | 299 | cpp | C++ | vlr-util/util.AutoCleanupBase.cpp | nick42/vlr-util | 937f53dd4d3e15b23d615b085f5bf4a8e6b9cd91 | [
"Artistic-2.0"
] | null | null | null | vlr-util/util.AutoCleanupBase.cpp | nick42/vlr-util | 937f53dd4d3e15b23d615b085f5bf4a8e6b9cd91 | [
"Artistic-2.0"
] | null | null | null | vlr-util/util.AutoCleanupBase.cpp | nick42/vlr-util | 937f53dd4d3e15b23d615b085f5bf4a8e6b9cd91 | [
"Artistic-2.0"
] | null | null | null | #include "pch.h"
#include "util.AutoCleanupBase.h"
NAMESPACE_BEGIN( vlr )
NAMESPACE_BEGIN( util )
HRESULT CAutoCleanupBase::OnDestroy_DoCleanup()
{
m_bDoCleanupCalled = true;
if (!m_bDoCleanup)
{
return S_FALSE;
}
return DoCleanup();
}
NAMESPACE_END //( util )
NAMESPACE_END //( vlr )
| 13 | 47 | 0.715719 | nick42 |
9de2a95465c9ad9226b95005fbb33e37e059feaa | 146 | cxx | C++ | Modules/ThirdParty/VNL/src/vxl/core/vnl/Templates/vnl_file_matrix+vnl_rational-.cxx | eile/ITK | 2f09e6e2f9e0a4a7269ac83c597f97b04f915dc1 | [
"Apache-2.0"
] | 4 | 2015-05-22T03:47:43.000Z | 2016-06-16T20:57:21.000Z | Modules/ThirdParty/VNL/src/vxl/core/vnl/Templates/vnl_file_matrix+vnl_rational-.cxx | GEHC-Surgery/ITK | f5df62749e56c9036e5888cfed904032ba5fdfb7 | [
"Apache-2.0"
] | null | null | null | Modules/ThirdParty/VNL/src/vxl/core/vnl/Templates/vnl_file_matrix+vnl_rational-.cxx | GEHC-Surgery/ITK | f5df62749e56c9036e5888cfed904032ba5fdfb7 | [
"Apache-2.0"
] | 9 | 2016-06-23T16:03:12.000Z | 2022-03-31T09:25:08.000Z | #include <vnl/vnl_file_matrix.txx>
#include <vnl/vnl_rational.h>
#include <vnl/vnl_rational_traits.h>
VNL_FILE_MATRIX_INSTANTIATE(vnl_rational);
| 24.333333 | 42 | 0.821918 | eile |
9de5202d1d5bde83729ab91a78fad9f1ca7d1902 | 13,578 | cpp | C++ | libs/hwdrivers/src/aria/src/ArSocket_LIN.cpp | yhexie/mrpt | 0bece2883aa51ad3dc88cb8bb84df571034ed261 | [
"OLDAP-2.3"
] | null | null | null | libs/hwdrivers/src/aria/src/ArSocket_LIN.cpp | yhexie/mrpt | 0bece2883aa51ad3dc88cb8bb84df571034ed261 | [
"OLDAP-2.3"
] | null | null | null | libs/hwdrivers/src/aria/src/ArSocket_LIN.cpp | yhexie/mrpt | 0bece2883aa51ad3dc88cb8bb84df571034ed261 | [
"OLDAP-2.3"
] | 1 | 2021-08-16T11:50:47.000Z | 2021-08-16T11:50:47.000Z | /* +---------------------------------------------------------------------------+
| Mobile Robot Programming Toolkit (MRPT) |
| http://www.mrpt.org/ |
| |
| Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |
| See: http://www.mrpt.org/Authors - All rights reserved. |
| Released under BSD License. See details in http://www.mrpt.org/License |
+---------------------------------------------------------------------------+ */
#include "ArExport.h"
#include "ariaOSDef.h"
#include "ArSocket.h"
#include "ArLog.h"
#include <errno.h>
#include <stdio.h>
#include <netdb.h>
#include <arpa/inet.h>
#include "ArFunctor.h"
#include <sys/socket.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
/// We're always initialized in Linux
bool ArSocket::ourInitialized=true;
/**
In Windows, the networking subsystem needs to be initialized and shutdown
individyaly by each program. So when a program starts they will need to
call the static function ArSocket::init() and call ArSocket::shutdown()
when it exits. For programs that use Aria::init() and Aria::uninit()
calling the ArSocket::init() and ArSocket::shutdown() is unnecessary. The
Aria initialization functions take care of this. These functions do nothing
in Linux.
*/
bool ArSocket::init()
{
return(true);
}
/**
In Windows, the networking subsystem needs to be initialized and shutdown
individyaly by each program. So when a program starts they will need to
call the static function ArSocket::init() and call ArSocket::shutdown()
when it exits. For programs that use Aria::init() and Aria::uninit()
calling the ArSocket::init() and ArSocket::shutdown() is unnecessary. The
Aria initialization functions take care of this. These functions do nothing
in Linux.
*/
void ArSocket::shutdown()
{
}
ArSocket::ArSocket() :
myType(Unknown),
myError(NoErr),
myErrorStr(),
myDoClose(true),
myFD(-1),
myNonBlocking(false),
mySin()
{
internalInit();
}
/**
Constructs the socket and connects it to the given host.
@param host hostname of the server to connect to
@param port port number of the server to connect to
@param type protocol type to use
*/
ArSocket::ArSocket(const char *host, int port, Type type) :
myType(type),
myError(NoErr),
myErrorStr(),
myDoClose(true),
myFD(-1),
myNonBlocking(false),
mySin()
{
internalInit();
connect(host, port, type);
}
/**
Constructs the socket and opens it as a server port.
@param port port number to bind the socket to
@param doClose automaticaly close the port if the socket is destructed
@param type protocol type to use
*/
ArSocket::ArSocket(int port, bool doClose, Type type) :
myType(type),
myError(NoErr),
myErrorStr(),
myDoClose(doClose),
myFD(-1),
myNonBlocking(false),
mySin()
{
internalInit();
open(port, type);
}
ArSocket::~ArSocket()
{
close();
}
bool ArSocket::hostAddr(const char *host, struct in_addr &addr)
{
struct hostent *hp;
if (!(hp=gethostbyname(host)))
{
perror("gethostbyname");
memset(&addr, 0, sizeof(in_addr));
return(false);
}
else
{
bcopy(hp->h_addr, &addr, hp->h_length);
return(true);
}
}
bool ArSocket::addrHost(struct in_addr &addr, char *host)
{
struct hostent *hp;
hp=gethostbyaddr((char*)&addr.s_addr, sizeof(addr.s_addr), AF_INET);
if (hp)
strcpy(host, hp->h_name);
else
strcpy(host, inet_ntoa(addr));
return(true);
}
std::string ArSocket::getHostName()
{
char localhost[100]; // maxHostNameLen()];
if (gethostname(localhost, sizeof(localhost)) == 1)
return("");
else
return(localhost);
}
bool ArSocket::connect(const char *host, int port, Type type)
{
char localhost[100]; // maxHostNameLen()];
if (!host)
{
if (gethostname(localhost, sizeof(localhost)) == 1)
{
myError=ConBadHost;
myErrorStr="Failure to locate host '";
myErrorStr+=localhost;
myErrorStr+="'";
perror("gethostname");
return(false);
}
host=localhost;
}
bzero(&mySin, sizeof(mySin));
// MPL taking out this next code line from the if since it makes
// everything we can't resolve try to connect to localhost
// && !hostAddr("localhost", mySin.sin_addr))
if (!hostAddr(host, mySin.sin_addr))
return(false);
setIPString();
mySin.sin_family=AF_INET;
mySin.sin_port=hostToNetOrder(port);
if ((type == TCP) && ((myFD=socket(AF_INET, SOCK_STREAM, 0)) < 0))
{
myError=NetFail;
myErrorStr="Failure to make TCP socket";
perror("socket");
return(false);
}
else if ((type == UDP) && ((myFD=socket(AF_INET, SOCK_DGRAM, 0)) < 0))
{
myError=NetFail;
myErrorStr="Failure to make UDP socket";
perror("socket");
return(false);
}
myType=type;
if (::connect(myFD, (struct sockaddr *)&mySin,
sizeof(struct sockaddr_in)) < 0)
{
myErrorStr="Failure to connect socket";
switch (errno)
{
case ECONNREFUSED:
myError=ConRefused;
myErrorStr+="; Connection refused";
break;
case ENETUNREACH:
myError=ConNoRoute;
myErrorStr+="; No route to host";
break;
default:
myError=NetFail;
break;
}
//perror("connect");
::close(myFD);
myFD = -1;
return(false);
}
return(true);
}
bool ArSocket::open(int port, Type type, const char *openOnIP)
{
int ret;
char localhost[100]; // maxHostNameLen()];
if ((type == TCP) && ((myFD=socket(AF_INET, SOCK_STREAM, 0)) < 0))
{
myErrorStr="Failure to make TCP socket";
perror("socket");
return(false);
}
else if ((type == UDP) && ((myFD=socket(AF_INET, SOCK_DGRAM, 0)) < 0))
{
myErrorStr="Failure to make UDP socket";
perror("socket");
return(false);
}
myType=type;
/* MPL removed this since with what I Took out down below months ago
if (gethostname(localhost, sizeof(localhost)) == 1)
{
myErrorStr="Failure to locate localhost";
perror("gethostname");
return(false);
}
*/
bzero(&mySin, sizeof(mySin));
/* MPL took this out since it was just overriding it with the
INADDR_ANY anyways and it could cause slowdowns if a machine wasn't
configured so lookups are quick
if (!hostAddr(localhost, mySin.sin_addr) &&
!hostAddr("localhost", mySin.sin_addr))
return(false); */
if (openOnIP != NULL)
{
if (!hostAddr(openOnIP, mySin.sin_addr))
{
ArLog::log(ArLog::Normal, "Couldn't find ip of %s to open on", openOnIP);
return(false);
}
else
{
//printf("Opening on %s\n", openOnIP);
}
}
else
{
mySin.sin_addr.s_addr=htonl(INADDR_ANY);
}
setIPString();
mySin.sin_family=AF_INET;
mySin.sin_port=hostToNetOrder(port);
if ((ret=bind(myFD, (struct sockaddr *)&mySin, sizeof(mySin))) < 0)
{
myErrorStr="Failure to bind socket to port ";
sprintf(localhost, "%d", port);
myErrorStr+=localhost;
perror("socket");
return(false);
}
if ((type == TCP) && (listen(myFD, 5) < 0))
{
myErrorStr="Failure to listen on socket";
perror("listen");
return(false);
}
return(true);
}
bool ArSocket::create(Type type)
{
if ((type == TCP) && ((myFD=socket(AF_INET, SOCK_STREAM, 0)) < 0))
{
myErrorStr="Failure to make TCP socket";
perror("socket");
return(false);
}
else if ((type == UDP) && ((myFD=socket(AF_INET, SOCK_DGRAM, 0)) < 0))
{
myErrorStr="Failure to make UDP socket";
perror("socket");
return(false);
}
myType=type;
if (getSockName())
return(true);
else
return(false);
}
bool ArSocket::findValidPort(int startPort, const char *openOnIP)
{
// char localhost[100]; // maxHostNameLen()];
/*
if (gethostname(localhost, sizeof(localhost)) == 1)
{
myErrorStr="Failure to locate localhost";
perror("gethostname");
return(false);
}
*/
for (int i=0; i+startPort < 65000; ++i)
{
bzero(&mySin, sizeof(mySin));
/*
if (!hostAddr(localhost, mySin.sin_addr) &&
!hostAddr("localhost", mySin.sin_addr))
return(false);
*/
setIPString();
if (openOnIP != NULL)
{
if (!hostAddr(openOnIP, mySin.sin_addr))
{
ArLog::log(ArLog::Normal, "Couldn't find ip of %s to open udp on", openOnIP);
return(false);
}
else
{
//printf("Opening on %s\n", openOnIP);
}
}
else
{
mySin.sin_addr.s_addr=htonl(INADDR_ANY);
}
mySin.sin_family=AF_INET;
mySin.sin_port=hostToNetOrder(startPort+i);
if (bind(myFD, (struct sockaddr *)&mySin, sizeof(mySin)) == 0)
break;
}
return(true);
}
bool ArSocket::connectTo(const char *host, int port)
{
char localhost[100]; // maxHostNameLen()];
if (myFD < 0)
return(false);
if (!host)
{
if (gethostname(localhost, sizeof(localhost)) == 1)
{
myErrorStr="Failure to locate host '";
myErrorStr+=localhost;
myErrorStr+="'";
perror("gethostname");
return(false);
}
host=localhost;
}
bzero(&mySin, sizeof(mySin));
if (!hostAddr(host, mySin.sin_addr))
return(false);
setIPString();
mySin.sin_family=AF_INET;
mySin.sin_port=hostToNetOrder(port);
return(connectTo(&mySin));
}
bool ArSocket::connectTo(struct sockaddr_in *sin)
{
if (::connect(myFD, (struct sockaddr *)sin,
sizeof(struct sockaddr_in)) < 0)
{
myErrorStr="Failure to connect socket";
perror("connect");
return(0);
}
return(1);
}
bool ArSocket::close()
{
if (myFD != -1)
ArLog::log(ArLog::Verbose, "Closing socket");
if (myCloseFunctor != NULL)
myCloseFunctor->invoke();
if (myDoClose && ::close(myFD))
{
myFD=-1;
return(false);
}
else
{
myFD=-1;
return(true);
}
}
bool ArSocket::setLinger(int time)
{
struct linger lin;
if (time)
{
lin.l_onoff=1;
lin.l_linger=time;
}
else
{
lin.l_onoff=0;
lin.l_linger=time;
}
if (setsockopt(myFD, SOL_SOCKET, SO_LINGER, &lin, sizeof(lin)) != 0)
{
myErrorStr="Failure to setsockopt LINGER";
perror("setsockopt");
return(false);
}
else
return(true);
}
bool ArSocket::setBroadcast()
{
if (setsockopt(myFD, SOL_SOCKET, SO_BROADCAST, NULL, 0) != 0)
{
myErrorStr="Failure to setsockopt BROADCAST";
perror("setsockopt");
return(false);
}
else
return(true);
}
bool ArSocket::setReuseAddress()
{
int opt=1;
if (setsockopt(myFD, SOL_SOCKET, SO_REUSEADDR,
(char*)&opt, sizeof(opt)) != 0)
{
myErrorStr="Failure to setsockopt REUSEADDR";
perror("setsockopt");
return(false);
}
else
return(true);
}
bool ArSocket::setNonBlock()
{
if (fcntl(myFD, F_SETFL, O_NONBLOCK) != 0)
{
myErrorStr="Failure to fcntl O_NONBLOCK";
perror("fcntl");
return(false);
}
else
{
myNonBlocking = true;
return(true);
}
}
/**
Copy socket structures. Copy from one Socket to another will still have
the first socket close the file descripter when it is destructed.
*/
bool ArSocket::copy(int fd, bool doclose)
{
socklen_t len;
myFD=fd;
myDoClose=doclose;
myType=Unknown;
len=sizeof(struct sockaddr_in);
if (getsockname(myFD, (struct sockaddr*)&mySin, &len))
{
myErrorStr="Failed to getsockname on fd ";
perror("setsockopt");
return(false);
}
else
return(true);
}
/**
@return true if there are no errors, false if there are
errors... not that if you're in non-blocking mode and there is no
socket to connect that is NOT an error, you'll want to check the
getFD on the sock you pass in to see if it is actually a valid
socket.
**/
bool ArSocket::accept(ArSocket *sock)
{
socklen_t len;
unsigned char *bytes;
len=sizeof(struct sockaddr_in);
sock->myFD=::accept(myFD, (struct sockaddr*)&(sock->mySin), &len);
sock->myType=myType;
bytes = (unsigned char *)sock->inAddr();
sprintf(sock->myIPString, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2],
bytes[3]);
if ((sock->myFD < 0 && !myNonBlocking) ||
(sock->myFD < 0 && errno != EWOULDBLOCK && myNonBlocking))
{
myErrorStr="Failed to accept on socket";
perror("accept");
return(false);
}
return(true);
}
void ArSocket::inToA(struct in_addr *addr, char *buff)
{
strcpy(buff, inet_ntoa(*addr));
}
bool ArSocket::getSockName()
{
socklen_t size;
if (myFD < 0)
{
myErrorStr="Trying to get socket name on an unopened socket";
printf("%s",myErrorStr.c_str());
return(false);
}
size=sizeof(mySin);
if (getsockname(myFD, (struct sockaddr *)&mySin, &size) != 0)
{
myErrorStr="Error getting socket name";
perror(myErrorStr.c_str());
return(false);
}
return(true);
}
unsigned int ArSocket::hostToNetOrder(int i)
{
return(htons(i));
}
unsigned int ArSocket::netToHostOrder(int i)
{
return(ntohs(i));
}
/** If this socket is a TCP socket, then set the TCP_NODELAY flag,
* to disable the use of the Nagle algorithm (which waits until enough
* data is ready to send to fill a TCP frame, rather then sending the
* packet immediately).
* @param flag true to turn on NoDelay, false to turn it off.
* @return true of the flag was successfully set, false if there was an
* error or this socket is not a TCP socket.
*/
bool ArSocket::setNoDelay(bool flag)
{
if(myType != TCP) return false;
int f = flag?1:0;
int r = setsockopt(myFD, IPPROTO_TCP, TCP_NODELAY, (char*)&f, sizeof(f));
return (r != -1);
}
| 22.442975 | 83 | 0.625423 | yhexie |
9de941dbce1feace4f6f6f220917ac3b755808d0 | 752 | cpp | C++ | src/gameLoopDriver.cpp | jacobrs/risk-game | 29ed2a58a9d5cf2fd28881876e1fabe4ed0e8ee5 | [
"MIT"
] | null | null | null | src/gameLoopDriver.cpp | jacobrs/risk-game | 29ed2a58a9d5cf2fd28881876e1fabe4ed0e8ee5 | [
"MIT"
] | null | null | null | src/gameLoopDriver.cpp | jacobrs/risk-game | 29ed2a58a9d5cf2fd28881876e1fabe4ed0e8ee5 | [
"MIT"
] | null | null | null | #include <iostream>
#include "./headers/Game.h"
#include "./headers/GameMap.h"
#include "./headers/MapLoader.h"
using namespace std;
int main(int args, char** argv){
// Initialize a new game with a valid map
MapLoader* loader = new MapLoader("./src/map/World.map");
loader->importMap();
GameMap* map = loader->exportToGameMap();
// verify that the map was loaded in properly
printf("Checking integrity of game map\n\n");
map->isValidMap();
vector<Player*> initPlayers;
initPlayers.push_back(new Player(0, "Tester1", "red"));
initPlayers.push_back(new Player(1, "Tester2", "blue"));
printf("Starting main game loop\n");
Game *game = new Game(map, 2, initPlayers);
game->startGame();
delete loader;
delete game;
}
| 25.931034 | 59 | 0.68484 | jacobrs |
9df3872b428bbb1a548e4547d54e1a4ea7b3d499 | 1,581 | cpp | C++ | details/pbkdf2.cpp | VlinderSoftware/securitylayer | 0daef0efe08af2649b164affcbdd30845a7806cd | [
"Apache-2.0"
] | 1 | 2020-07-16T01:34:06.000Z | 2020-07-16T01:34:06.000Z | details/pbkdf2.cpp | blytkerchan/securitylayer | 0daef0efe08af2649b164affcbdd30845a7806cd | [
"Apache-2.0"
] | 1 | 2020-07-23T02:55:31.000Z | 2020-07-23T02:55:31.000Z | details/pbkdf2.cpp | blytkerchan/securitylayer | 0daef0efe08af2649b164affcbdd30845a7806cd | [
"Apache-2.0"
] | 1 | 2020-07-03T00:06:20.000Z | 2020-07-03T00:06:20.000Z | /* Copyright 2020 Ronald Landheer-Cieslak
*
* 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 "pbkdf2.hpp"
#include <openssl/evp.h>
#include <stdexcept>
#include "../exceptions/contract.hpp"
using namespace std;
namespace DNP3SAv6 { namespace Details {
PBKDF2::PBKDF2(std::string const &password, std::vector< unsigned char > const &salt, unsigned int iteration_count/* = 1000*/)
{
EVP_MD const *md(EVP_sha256());
if (!md) throw bad_alloc();
vector< unsigned char > key(32);
if (!PKCS5_PBKDF2_HMAC(password.c_str(), password.size(), salt.empty() ? nullptr : &salt[0], salt.size(), iteration_count, md, key.size(), &key[0]))
{
throw runtime_error("failed to derive key");
}
else
{ /* no-op */ }
key_.insert(key_.end(), key.begin(), key.end());
}
PBKDF2::~PBKDF2()
{
}
vector< unsigned char > PBKDF2::operator()(size_t n)
{
pre_condition(n <= key_.size());
auto end(key_.begin()); advance(end, n);
vector< unsigned char > retval(key_.begin(), end);
key_.erase(key_.begin(), end);
return retval;
}
}}
| 32.9375 | 152 | 0.683112 | VlinderSoftware |
9df43eb3a77ee94dfb0d61a5da7fcf9890aa3f42 | 4,933 | cpp | C++ | src/brokerlib/message/handler/src/ServiceRegistryRegisterRequestHandler.cpp | chrissmith-mcafee/opendxl-broker | a3f985fc19699ab8fcff726bbd1974290eb6e044 | [
"Apache-2.0",
"MIT"
] | 13 | 2017-10-15T14:32:34.000Z | 2022-02-17T08:25:26.000Z | src/brokerlib/message/handler/src/ServiceRegistryRegisterRequestHandler.cpp | vkrish-mcafee/opendxl-broker | 39c5d06c233dbe01146f0db781eccfd67bbaafbf | [
"Apache-2.0",
"MIT"
] | 14 | 2017-10-17T18:23:50.000Z | 2021-12-10T22:05:25.000Z | src/brokerlib/message/handler/src/ServiceRegistryRegisterRequestHandler.cpp | vkrish-mcafee/opendxl-broker | 39c5d06c233dbe01146f0db781eccfd67bbaafbf | [
"Apache-2.0",
"MIT"
] | 26 | 2017-10-27T00:27:29.000Z | 2021-09-02T16:57:55.000Z | /******************************************************************************
* Copyright (c) 2018 McAfee, LLC - All Rights Reserved.
*****************************************************************************/
#include "include/BrokerSettings.h"
#include "include/SimpleLog.h"
#include "json/include/JsonService.h"
#include "message/include/DxlEvent.h"
#include "message/include/DxlMessageService.h"
#include "message/include/DxlMessageConstants.h"
#include "message/include/dxl_error_message.h"
#include "message/handler/include/ServiceRegistryRegisterRequestHandler.h"
#include "message/payload/include/ServiceRegistryRegisterEventPayload.h"
#include "serviceregistry/include/ServiceRegistry.h"
#include "DxlFlags.h"
#include "metrics/include/TenantMetricsService.h"
using namespace std;
using namespace dxl::broker::json;
using namespace dxl::broker::message::handler;
using namespace dxl::broker::message::payload;
using namespace dxl::broker::core;
using namespace dxl::broker::service;
using namespace dxl::broker::metrics;
/** {@inheritDoc} */
bool ServiceRegistryRegisterRequestHandler::onStoreMessage(
CoreMessageContext* context, struct cert_hashes* certHashes ) const
{
if( SL_LOG.isDebugEnabled() )
{
SL_START << "ServiceRegistryRegisterRequestHandler::onStoreMessage" << SL_DEBUG_END;
}
// Get the DXL request
DxlRequest* request = context->getDxlRequest();
// Get the payload
ServiceRegistryRegisterEventPayload registerPayload;
JsonService::getInstance().fromJson( request->getPayloadStr(), registerPayload );
// Update the payload with information from the local broker, current connection
registerPayload.setBrokerGuid( BrokerSettings::getGuid() );
registerPayload.setClientGuid(
( ( context->getContextFlags() & DXL_FLAG_LOCAL ) ?
BrokerSettings::getGuid() : context->getCanonicalSourceId() ) );
registerPayload.setClientInstanceGuid(
( ( context->getContextFlags() & DXL_FLAG_LOCAL ) ?
BrokerSettings::getInstanceGuid() : context->getSourceId() ) );
bool isManaged = (context->getContextFlags() & DXL_FLAG_MANAGED) != 0;
registerPayload.setManagedClient( isManaged );
if( !isManaged )
{
unordered_set<std::string> certs;
struct cert_hashes *current, *tmp;
HASH_ITER( hh, certHashes, current, tmp )
{
certs.insert( current->cert_sha1 );
}
registerPayload.setCertificates( certs );
}
if( BrokerSettings::isMultiTenantModeEnabled() )
{
const std::string& clientTenantGuid = request->getSourceTenantGuid();
const unordered_set<std::string>* destTenantGuids = request->getDestinationTenantGuids();
unordered_set<std::string> targetTenantGuids;
// If the client is not OPs
if( !context->isSourceOps() )
{
// Service registration from a regular client only available for its tenants
targetTenantGuids.insert( clientTenantGuid );
}
// If the client is OPs and the destination tenants are not NULL, the destinations are allowed
else if( destTenantGuids != NULL )
{
targetTenantGuids = *destTenantGuids;
}
// Set the service tenant GUID to that of the client that registered the service.
registerPayload.setClientTenantGuid( clientTenantGuid );
// Set the target tenant GUIDs for this service.
registerPayload.setTargetTenantGuids( targetTenantGuids );
}
// Create the registration
shared_ptr<ServiceRegistration> reg(
new ServiceRegistration( registerPayload.getServiceRegistration() ) );
reg->setBrokerService( context->getContextFlags() & DXL_FLAG_LOCAL );
DxlMessageService& messageService = DxlMessageService::getInstance();
shared_ptr<DxlResponse> response;
// Check if the service limit has been exceeded in multi-tenant
if( !BrokerSettings::isMultiTenantModeEnabled() ||
context->isSourceOps() ||
TenantMetricsService::getInstance().isServiceRegistrationAllowed( reg->getClientTenantGuid().c_str() ) )
{
// Register the service
ServiceRegistry::getInstance().registerService( reg );
// Send a response to the invoking client
response = messageService.createResponse( request );
}
else
{
// Send an error response to the invoking client as its tenant limit is exceeded
int isFabricError;
response = messageService.createErrorResponse(
request,
FABRICSERVICELIMITEXCEEDED,
getMessage( FABRICSERVICELIMITEXCEEDED, &isFabricError )
);
}
messageService.sendMessage( request->getReplyToTopic(), *response );
// Do not propagate the request, we send an event to the other brokers
return false;
}
| 40.105691 | 120 | 0.668964 | chrissmith-mcafee |
9df533f023df50f4bdb15435aa666002deabc746 | 7,660 | cpp | C++ | slave_driver/slave_uwb(Deprecated)/src/uwb_node.cpp | hanruihua/multirobot_slave | 7264efc29d9572db4ff4165d4374b1e8ddb39c26 | [
"MIT"
] | 1 | 2020-06-04T13:00:27.000Z | 2020-06-04T13:00:27.000Z | slave_driver/slave_uwb(Deprecated)/src/uwb_node.cpp | hanruihua/multirobot_slave | 7264efc29d9572db4ff4165d4374b1e8ddb39c26 | [
"MIT"
] | null | null | null | slave_driver/slave_uwb(Deprecated)/src/uwb_node.cpp | hanruihua/multirobot_slave | 7264efc29d9572db4ff4165d4374b1e8ddb39c26 | [
"MIT"
] | 3 | 2019-06-10T03:56:33.000Z | 2021-07-29T03:52:30.000Z | #include <serial/serial.h>
#include <std_msgs/String.h>
#include <std_msgs/Empty.h>
#include <ros/ros.h>
#include <iostream>
#include "data_typedef.h"
#include <geometry_msgs/Point.h>
#include <slave_msgs/uwb_position.h>
#include <string.h>
std::string id;
template<typename T> std::string toString(const T& t){
std::ostringstream oss; //创建一个格式化输出流
oss<<t; //把值传递如流中
return oss.str();
}
int main (int argc, char** argv){
ros::init(argc, argv, "uwb_node");
ros::NodeHandle n;
// ros::Subscriber ground_truth = n.subscribe("robot01", 1000, callback); //subscribe to mocap
ros::Publisher uwb_pub = n.advertise<slave_msgs::uwb_position>("uwb_position", 1000);
//initialize
slave_msgs::uwb_position uwb_out;
serial::Serial ros_ser;
uint8 data_frame[128];
try
{
ros_ser.setPort("/dev/ttyUSB0");
ros_ser.setBaudrate(921600);
serial::Timeout to = serial::Timeout::simpleTimeout(1000);
ros_ser.setStopbits (serial::stopbits_one);
ros_ser.setTimeout(to);
ros_ser.open();
}
catch (serial::IOException& e)
{
//ros_ser.setPort("/dev/ttyUSB1");
ROS_ERROR_STREAM("Unable to open port ");
ROS_ERROR_STREAM(e.getErrorNumber());
return -1;
}
if(ros_ser.isOpen()){
ROS_INFO_STREAM("Serial Port opened");
}else{
return -1;
}
ros::Rate loop_rate(50); // Attention!! Make sure this value is according with serial rate
while(ros::ok())
{
uint8 data_frame_sum = 0;
if(ros_ser.available())
{
ros_ser.read(data_frame, 128);
}
//ROS_INFO_STREAM("Reading from serial port");
if((data_frame[0] == 0x55) && (data_frame[1] == 0x01))
{
//ROS_INFO_STREAM("Read successfully");
for (int i = 0; i < (128 - 1); i++)
{
data_frame_sum += data_frame[i];
}
if (data_frame_sum == data_frame[128 - 1])
{
ROS_INFO_STREAM("valid frame");
//ROS_INFO_STREAM("id:" + data_frame[2]);
uwb_out.id = toString(data_frame[2]);
uwb_out.position.x = (float) Byte32(sint32, data_frame[6], data_frame[5], data_frame[4], 0) / 256000.0f;
uwb_out.position.y = (float) Byte32(sint32, data_frame[9], data_frame[8], data_frame[7], 0) / 256000.0f;
uwb_out.position.z = (float) Byte32(sint32, data_frame[12], data_frame[11], data_frame[10], 0) / 256000.0f;
uwb_pub.publish(uwb_out);
//ros::spinOnce();
//ROS_INFO_STREAM("position x:" pos.x "position y:" pos.y "position z:" pos.z);
// std::cout << "position x: " << uwb_out.position << " ";
// std::cout << "position y: " << pos.y << " ";
// std::cout << "position z: " << pos.z << " ";
// std::cout << std::endl;
// i_uwb_lps_tag.id = data_frame[2];
// i_uwb_lps_tag.position.x = (float)Byte32(sint32 ,data_frame[6],data_frame[5],data_frame[4], 0) / 256000.0f;
// i_uwb_lps_tag.position.y = (float)Byte32(sint32 ,data_frame[9],data_frame[8],data_frame[7], 0) / 256000.0f;
// i_uwb_lps_tag.position.z = (float)Byte32(sint32 ,data_frame[12],data_frame[11],data_frame[10], 0) / 256000.0f;
// i_uwb_lps_tag.velocity.x = (float)Byte32(sint32 ,data_frame[15],data_frame[14],data_frame[13], 0) / 2560000.0f;
// i_uwb_lps_tag.velocity.y = (float)Byte32(sint32 ,data_frame[18],data_frame[17],data_frame[16], 0) / 2560000.0f;
// i_uwb_lps_tag.velocity.z = (float)Byte32(sint32 ,data_frame[21],data_frame[20],data_frame[19], 0) / 2560000.0f;
// i_uwb_lps_tag.dis_buf[0] = (float)Byte32(sint32 ,data_frame[24],data_frame[23],data_frame[22], 0) / 256000.0f;
// i_uwb_lps_tag.dis_buf[1] = (float)Byte32(sint32 ,data_frame[27],data_frame[26],data_frame[25], 0) / 256000.0f;
// i_uwb_lps_tag.dis_buf[2] = (float)Byte32(sint32 ,data_frame[30],data_frame[29],data_frame[28], 0) / 256000.0f;
// i_uwb_lps_tag.dis_buf[3] = (float)Byte32(sint32 ,data_frame[33],data_frame[32],data_frame[31], 0) / 256000.0f;
// i_uwb_lps_tag.dis_buf[4] = (float)Byte32(sint32 ,data_frame[36],data_frame[35],data_frame[34], 0) / 256000.0f;
// i_uwb_lps_tag.dis_buf[5] = (float)Byte32(sint32 ,data_frame[39],data_frame[38],data_frame[37], 0) / 256000.0f;
// i_uwb_lps_tag.dis_buf[6] = (float)Byte32(sint32 ,data_frame[42],data_frame[41],data_frame[40], 0) / 256000.0f;
// i_uwb_lps_tag.dis_buf[7] = (float)Byte32(sint32 ,data_frame[45],data_frame[44],data_frame[43], 0) / 256000.0f;
// buf[0] = data_frame[46];buf[1] = data_frame[47];buf[2] = data_frame[48];buf[3] = data_frame[49];
// Byte_to_Float(&i_uwb_lps_tag.gyro.x,buf);
// buf[0] = data_frame[50];buf[1] = data_frame[51];buf[2] = data_frame[52];buf[3] = data_frame[53];
// Byte_to_Float(&i_uwb_lps_tag.gyro.y,buf);
// buf[0] = data_frame[54];buf[1] = data_frame[55];buf[2] = data_frame[56];buf[3] = data_frame[57];
// Byte_to_Float(&i_uwb_lps_tag.gyro.z,buf);
// buf[0] = data_frame[58];buf[1] = data_frame[59];buf[2] = data_frame[60];buf[3] = data_frame[61];
// Byte_to_Float(&i_uwb_lps_tag.acc.x,buf);
// buf[0] = data_frame[62];buf[1] = data_frame[63];buf[2] = data_frame[64];buf[3] = data_frame[65];
// Byte_to_Float(&i_uwb_lps_tag.acc.y,buf);
// buf[0] = data_frame[66];buf[1] = data_frame[67];buf[2] = data_frame[68];buf[3] = data_frame[69];
// Byte_to_Float(&i_uwb_lps_tag.acc.z,buf);
// i_uwb_lps_tag.angle.x = (float) (Byte16(sint16, data_frame[83], data_frame[82])) / 100.0f;
// i_uwb_lps_tag.angle.y = (float) (Byte16(sint16, data_frame[85], data_frame[84])) / 100.0f;
// i_uwb_lps_tag.angle.z = (float) (Byte16(sint16, data_frame[87], data_frame[86])) / 100.0f;
// buf[0] = data_frame[88];buf[1] = data_frame[89];buf[2] = data_frame[90];buf[3] = data_frame[91];
// Byte_to_Float(&i_uwb_lps_tag.Q.q0,buf);
// buf[0] = data_frame[92];buf[1] = data_frame[93];buf[2] = data_frame[94];buf[3] = data_frame[95];
// Byte_to_Float(&i_uwb_lps_tag.Q.q1,buf);
// buf[0] = data_frame[96];buf[1] = data_frame[97];buf[2] = data_frame[98];buf[3] = data_frame[99];
// Byte_to_Float(&i_uwb_lps_tag.Q.q2,buf);
// buf[0] = data_frame[100];buf[1] = data_frame[101];buf[2] = data_frame[102];buf[3] = data_frame[103];
// Byte_to_Float(&i_uwb_lps_tag.Q.q3,buf);
// i_uwb_lps_tag.system_time = Byte32(uint32,data_frame[115], data_frame[114], data_frame[113], data_frame[112]);
// i_uwb_lps_tag.sensor_status = data_frame[116];
}
// for(int i=0; i<n; i++)
// {
// //16进制的方式打印到屏幕
// std::cout << std::hex << (buffer[i] & 0xff) << " ";
// }
// std::cout << std::endl;
//std_msgs::String serial_data;
// //获取串口数据
// serial_data.data = ros_ser.read(n);
// ROS_INFO_STREAM("Read: " << serial_data.data);
//将串口数据发布到主题sensor
}
loop_rate.sleep();
}
}
| 45.868263 | 130 | 0.568146 | hanruihua |
9df61e9e192f873c21543dd272661bfb11d3dd01 | 6,890 | cpp | C++ | CSGOSimple/features/skins.cpp | lukizel/baluware | 5d76d5616537d9812ee38bbb41b3abf596cb8830 | [
"Unlicense"
] | null | null | null | CSGOSimple/features/skins.cpp | lukizel/baluware | 5d76d5616537d9812ee38bbb41b3abf596cb8830 | [
"Unlicense"
] | null | null | null | CSGOSimple/features/skins.cpp | lukizel/baluware | 5d76d5616537d9812ee38bbb41b3abf596cb8830 | [
"Unlicense"
] | 1 | 2020-12-04T20:36:19.000Z | 2020-12-04T20:36:19.000Z | #include "skins.hpp"
static auto erase_override_if_exists_by_index( const int definition_index ) -> void {
if( k_weapon_info.count( definition_index ) ) {
auto& icon_override_map = g_Options.skins.m_icon_overrides;
const auto& original_item = k_weapon_info.at( definition_index );
if( original_item.icon && icon_override_map.count( original_item.icon ) )
icon_override_map.erase( icon_override_map.at( original_item.icon ) ); // Remove the leftover override
}
}
static auto apply_config_on_attributable_item( C_BaseAttributableItem* item, const item_setting* config,
const unsigned xuid_low ) -> void {
if( !config->enabled ) {
return;
}
item->m_Item( ).m_iItemIDHigh( ) = -1;
item->m_Item( ).m_iAccountID( ) = xuid_low;
//if( config->custom_name[0] )
// strcpy_s( item->m_Item( ).m_iCustomName( ), config->custom_name );
if( config->paint_kit_index )
item->m_nFallbackPaintKit( ) = config->paint_kit_index;
if( config->seed )
item->m_nFallbackSeed( ) = config->seed;
if( config->stat_trak ) {
item->m_nFallbackStatTrak( ) = config->stat_trak;
item->m_Item( ).m_iEntityQuality( ) = 9;
} else {
item->m_Item( ).m_iEntityQuality( ) = is_knife( config->definition_index ) ? 3 : 0;
}
item->m_flFallbackWear( ) = config->wear;
auto& definition_index = item->m_Item( ).m_iItemDefinitionIndex( );
auto& icon_override_map = g_Options.skins.m_icon_overrides;
if( config->definition_override_index && config->definition_override_index != definition_index && k_weapon_info.count( config->definition_override_index ) ) {
const auto old_definition_index = definition_index;
definition_index = config->definition_override_index;
const auto& replacement_item = k_weapon_info.at( config->definition_override_index );
item->m_nModelIndex( ) = g_MdlInfo->GetModelIndex( replacement_item.model );
item->SetModelIndex( g_MdlInfo->GetModelIndex( replacement_item.model ) );
item->GetClientNetworkable( )->PreDataUpdate( 0 );
if( old_definition_index && k_weapon_info.count( old_definition_index ) ) {
const auto& original_item = k_weapon_info.at( old_definition_index );
if( original_item.icon && replacement_item.icon ) {
icon_override_map[original_item.icon] = replacement_item.icon;
}
}
} else {
erase_override_if_exists_by_index( definition_index );
}
}
static auto get_wearable_create_fn( ) -> CreateClientClassFn {
auto clazz = g_CHLClient->GetAllClasses( );
// Please, if you gonna paste it into a cheat use classids here. I use names because they
// won't change in the foreseeable future and i dont need high speed, but chances are
// you already have classids, so use them instead, they are faster.
while( strcmp( clazz->m_pNetworkName, "CEconWearable" ) )
clazz = clazz->m_pNext;
return clazz->m_pCreateFn;
}
void Skins::OnFrameStageNotify( bool frame_end ) {
const auto local_index = g_EngineClient->GetLocalPlayer( );
const auto local = static_cast< C_BasePlayer* >( g_EntityList->GetClientEntity( local_index ) );
if( !local )
return;
player_info_t player_info;
if( !g_EngineClient->GetPlayerInfo( local_index, &player_info ) )
return;
if( frame_end ) {
const auto wearables = local->m_hMyWearables( );
const auto glove_config = &g_Options.skins.m_items[GLOVE_T_SIDE];
static auto glove_handle = CBaseHandle( 0 );
auto glove = reinterpret_cast< C_BaseAttributableItem* >( g_EntityList->GetClientEntityFromHandle( wearables[0] ) );
if( !glove ) {
const auto our_glove = reinterpret_cast< C_BaseAttributableItem* >( g_EntityList->GetClientEntityFromHandle( glove_handle ) );
if( our_glove ) // Our glove still exists
{
wearables[0] = glove_handle;
glove = our_glove;
}
}
if( !local->IsAlive( ) ) {
if( glove ) {
glove->GetClientNetworkable( )->SetDestroyedOnRecreateEntities( );
glove->GetClientNetworkable( )->Release( );
}
return;
}
if( glove_config && glove_config->definition_override_index ) {
if( !glove ) {
static auto create_wearable_fn = get_wearable_create_fn( );
const auto entry = g_EntityList->GetHighestEntityIndex( ) + 1;
const auto serial = rand( ) % 0x1000;
//glove = static_cast<C_BaseAttributableItem*>(create_wearable_fn(entry, serial));
create_wearable_fn( entry, serial );
glove = reinterpret_cast< C_BaseAttributableItem* >( g_EntityList->GetClientEntity( entry ) );
assert( glove );
{
static auto set_abs_origin_addr = Utils::PatternScan( GetModuleHandle( L"client.dll" ), "55 8B EC 83 E4 F8 51 53 56 57 8B F1" );
const auto set_abs_origin_fn = reinterpret_cast< void( __thiscall* )( void*, const std::array<float, 3>& ) >( set_abs_origin_addr );
static constexpr std::array<float, 3> new_pos = { 10000.f, 10000.f, 10000.f };
set_abs_origin_fn( glove, new_pos );
}
const auto wearable_handle = reinterpret_cast< CBaseHandle* >( &wearables[0] );
*wearable_handle = entry | serial << 16;
glove_handle = wearables[0];
}
// Thanks, Beakers
glove->SetGloveModelIndex( -1 );
apply_config_on_attributable_item( glove, glove_config, player_info.xuid_low );
}
} else {
auto weapons = local->m_hMyWeapons( );
for( int i = 0; weapons[i].IsValid( ); i++ ) {
C_BaseAttributableItem *weapon = ( C_BaseAttributableItem* )g_EntityList->GetClientEntityFromHandle( weapons[i] );
if( !weapon )
continue;
auto& definition_index = weapon->m_Item( ).m_iItemDefinitionIndex( );
const auto active_conf = &g_Options.skins.m_items[is_knife( definition_index ) ? WEAPON_KNIFE : definition_index];
apply_config_on_attributable_item( weapon, active_conf, player_info.xuid_low );
}
const auto view_model_handle = local->m_hViewModel( );
if( !view_model_handle.IsValid( ) )
return;
const auto view_model = static_cast< C_BaseViewModel* >( g_EntityList->GetClientEntityFromHandle( view_model_handle ) );
if( !view_model )
return;
const auto view_model_weapon_handle = view_model->m_hWeapon( );
if( !view_model_weapon_handle.IsValid( ) )
return;
const auto view_model_weapon = static_cast< C_BaseCombatWeapon* >( g_EntityList->GetClientEntityFromHandle( view_model_weapon_handle ) );
if( !view_model_weapon )
return;
if( k_weapon_info.count( view_model_weapon->m_Item( ).m_iItemDefinitionIndex( ) ) ) {
const auto override_model = k_weapon_info.at( view_model_weapon->m_Item( ).m_iItemDefinitionIndex( ) ).model;
auto override_model_index = g_MdlInfo->GetModelIndex( override_model );
view_model->m_nModelIndex( ) = override_model_index;
auto world_model_handle = view_model_weapon->m_hWeaponWorldModel( );
if( !world_model_handle.IsValid( ) )
return;
const auto world_model = static_cast< C_BaseWeaponWorldModel* >( g_EntityList->GetClientEntityFromHandle( world_model_handle ) );
if( !world_model )
return;
world_model->m_nModelIndex( ) = override_model_index + 1;
}
}
}
| 43.333333 | 159 | 0.730914 | lukizel |
9df94a3925d8d6c6bf4f6423dd18cbcdac719f3c | 2,427 | cpp | C++ | AIO/tennis robot/tennis.cpp | eddiegz/Personal-C | f7869826216e5c665f8f646502141f0dc680e545 | [
"MIT"
] | 3 | 2021-05-15T08:18:09.000Z | 2021-05-17T04:41:57.000Z | AIO/tennis robot/tennis.cpp | eddiegz/Personal-C | f7869826216e5c665f8f646502141f0dc680e545 | [
"MIT"
] | null | null | null | AIO/tennis robot/tennis.cpp | eddiegz/Personal-C | f7869826216e5c665f8f646502141f0dc680e545 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
using pii=pair<int,int>;
#define ff first
#define ss second
//#define DEBUG
const int MAXN=1e5+5;
bool done[MAXN];
priority_queue<pii,vector<pii>,greater<pii>> order;
ll ans=0;ll ind=1;
ll b,n;
void solve();
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);cout.tie(nullptr);
#ifndef DEBUG
freopen("tennisin.txt","r",stdin);
freopen("tennisout.txt","w",stdout);
#endif
int t=1;
while(t--){
solve();
}
}
void solve(){
cin>>b>>n;
for(int i=1;i<=b;++i){
int a;cin>>a;
order.push({a,i});
}
ll length=b,available=b,initial=0;
while(1){
if(n<=0)break;
auto ch=order.top().ff,ind=order.top().ss;
vector<int> to_go;
to_go.push_back(ind);
ll level=1;
order.pop();
while(true){
if(!order.empty()&&order.top().ff==ch){
to_go.push_back(order.top().ss);
order.pop();
level++;
}
else{
break;
}
}
length-=level;
if((ch-initial)*available<n){
n-=(ch-initial)*available;
available-=level;
initial=ch;
for(int ele:to_go){
done[ele]=true;
}
}
else{
ll time=n/available;
if(time>0){
if(n%available>0){
n-=time*available;
for(int i=1;i<=b;++i){
if(!done[i]){
n--;
}
if(n==0){
ans=i;
break;
}
}
}
else{
for(int i=b;i>=1;--i){
if(!done[i]){
ans=i;
n=0;
break;
}
}
}
}
else{
for(int i=1;i<=b;++i){
if(!done[i]){
n--;
}
if(n==0){
ans=i;
break;
}
}
}
}
}
cout<<ans<<endl;
} | 23.563107 | 51 | 0.347342 | eddiegz |
9dfacc1cd005107d4b7276d9c934bada29f75f44 | 252 | cpp | C++ | test/TestEnvironment.cpp | Gaoadt/heaps | 83e03b4ef3af32dbebdfb29c1461d2f7d8a9cbaa | [
"MIT"
] | null | null | null | test/TestEnvironment.cpp | Gaoadt/heaps | 83e03b4ef3af32dbebdfb29c1461d2f7d8a9cbaa | [
"MIT"
] | null | null | null | test/TestEnvironment.cpp | Gaoadt/heaps | 83e03b4ef3af32dbebdfb29c1461d2f7d8a9cbaa | [
"MIT"
] | null | null | null | #include "TestEnvironment.h"
std::string Heaps::Testing::heapParamName(const testing::TestParamInfo<HeapBehaviourTest::ParamType>& info)
{
IHeapTestingEnvironment* env = dynamic_cast<IHeapTestingEnvironment *>(info.param);
return env->ToString();
}
| 31.5 | 107 | 0.789683 | Gaoadt |
9dfcfe0cde70b39c4f35a71c91688fa83f9c78f1 | 797 | hpp | C++ | include/Pomdog/Input/GamepadButtons.hpp | bis83/pomdog | 133a9262958d539ae6d93664e6cb2207b5b6c7ff | [
"MIT"
] | null | null | null | include/Pomdog/Input/GamepadButtons.hpp | bis83/pomdog | 133a9262958d539ae6d93664e6cb2207b5b6c7ff | [
"MIT"
] | null | null | null | include/Pomdog/Input/GamepadButtons.hpp | bis83/pomdog | 133a9262958d539ae6d93664e6cb2207b5b6c7ff | [
"MIT"
] | null | null | null | // Copyright (c) 2013-2015 mogemimi.
// Distributed under the MIT license. See LICENSE.md file for details.
#ifndef POMDOG_GAMEPADBUTTONS_7EF60FA0_HPP
#define POMDOG_GAMEPADBUTTONS_7EF60FA0_HPP
#include "ButtonState.hpp"
#include <cstdint>
namespace Pomdog {
class GamepadButtons {
public:
ButtonState A = ButtonState::Released;
ButtonState B = ButtonState::Released;
ButtonState X = ButtonState::Released;
ButtonState Y = ButtonState::Released;
ButtonState LeftShoulder = ButtonState::Released;
ButtonState RightShoulder = ButtonState::Released;
ButtonState Start = ButtonState::Released;
ButtonState LeftStick = ButtonState::Released;
ButtonState RightStick = ButtonState::Released;
};
} // namespace Pomdog
#endif // POMDOG_GAMEPADBUTTONS_7EF60FA0_HPP
| 28.464286 | 70 | 0.769134 | bis83 |
9dfe4bbf5abf8a747614274f7bed7a27280f9299 | 1,863 | hpp | C++ | ModSource/breakingpoint_ui/LoadingScreenBase.hpp | nrailuj/breakingpointmod | e102e106b849ca78deb3cb299f3ae18c91c3bfe9 | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | 70 | 2017-06-23T21:25:05.000Z | 2022-03-27T02:39:33.000Z | ModSource/breakingpoint_ui/LoadingScreenBase.hpp | nrailuj/breakingpointmod | e102e106b849ca78deb3cb299f3ae18c91c3bfe9 | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | 84 | 2017-08-26T22:06:28.000Z | 2021-09-09T15:32:56.000Z | ModSource/breakingpoint_ui/LoadingScreenBase.hpp | nrailuj/breakingpointmod | e102e106b849ca78deb3cb299f3ae18c91c3bfe9 | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | 71 | 2017-06-24T01:10:42.000Z | 2022-03-18T23:02:00.000Z | /*
Breaking Point Mod for Arma 3
Released under Arma Public Share Like Licence (APL-SA)
https://www.bistudio.com/community/licenses/arma-public-license-share-alike
Alderon Games Pty Ltd
*/
idd = 101;
onLoad = "[""onLoad"",_this,""RscDisplayLoading""] call compile preprocessfilelinenumbers ""breakingpoint_ui\scripts\Loading\RscDisplayLoading.sqf""";
onUnload = "[""onUnload"",_this,""RscDisplayLoading""] call compile preprocessfilelinenumbers ""breakingpoint_ui\scripts\Loading\RscDisplayLoading.sqf""";
class controlsBackground {
delete CA_Vignette;
delete Noise;
class Black : RscText {
colorBackground[] = {0, 0, 0, 1};
x = "safezoneXAbs";
y = "safezoneY";
w = "safezoneWAbs";
h = "safezoneH";
};
class Map : RscPicture {
idc = 999;
text = "\breakingpoint_ui\loading\main_title_01.jpg";
colorText[] = {1, 1, 1, 1};
x = "safezoneX";
y = "safezoneY";
w = "safezoneW";
h = "safezoneH";
};
};
class controls {
delete Title;
delete Name;
delete Briefing;
delete Progress;
delete Progress2;
delete Date; //
delete MapBackTop;
delete MapName;
delete MapAuthor;
delete MapBackBottom;
delete MapDescription;
delete Mission;
delete ProgressMap;
delete ProgressMission;
delete Disclaimer;
class LoadingStart : RscControlsGroup {
idc = 2310;
x = "0 * safezoneW + safezoneX";
y = "0 * safezoneH + safezoneY";
w = "1 * safezoneW";
h = "1 * safezoneH";
class controls {
class Black : RscText {
colorBackground[] = {0, 0, 0, 1};
x = "safezoneXAbs";
y = "safezoneY";
w = "safezoneWAbs";
h = "safezoneH";
};
delete Noise;
class Logo : RscPicture {
idc = 1200;
text = "\breakingpoint_ui\loading\main_title_01.jpg";
colorText[] = {1, 1, 1, 1};
x = "0 * safezoneW";
y = "0 * safezoneH";
w = "1 * safezoneW";
h = "1 * safezoneH";
};
};
};
};
| 22.445783 | 154 | 0.656468 | nrailuj |
3b044568e4bab00c1c92c7ab908b910c6b3f9536 | 4,786 | cpp | C++ | src/bind/file/explorer_util.cpp | e-ntro-py/win-vind | 1ec805420732c82a46e2c79720db728ded792814 | [
"MIT"
] | null | null | null | src/bind/file/explorer_util.cpp | e-ntro-py/win-vind | 1ec805420732c82a46e2c79720db728ded792814 | [
"MIT"
] | null | null | null | src/bind/file/explorer_util.cpp | e-ntro-py/win-vind | 1ec805420732c82a46e2c79720db728ded792814 | [
"MIT"
] | null | null | null | #include "explorer_util.hpp"
#include <filesystem>
#include <memory>
#include <exdisp.h>
#include <shlobj.h>
#include "core/errlogger.hpp"
#include "util/def.hpp"
#include "util/smartcom.hpp"
#include "util/string.hpp"
#include "util/winwrap.hpp"
namespace vind
{
namespace bind {
//This is based on https://devblogs.microsoft.com/oldnewthing/?p=38393 .
std::filesystem::path get_current_explorer_path() {
auto hwnd = util::get_foreground_window() ;
if(util::is_failed(CoInitialize(NULL))) {
throw RUNTIME_EXCEPT("initialization failed") ;
}
auto co_uninit = [] (char* ptr) {
if(ptr) {
delete ptr ;
ptr = nullptr ;
}
CoUninitialize() ;
} ;
std::unique_ptr<char, decltype(co_uninit)> smart_uninit{new char(), co_uninit} ;
//we can get explorer handle from IShellWindows.
util::SmartCom<IShellWindows> psw{} ;
if(util::is_failed(CoCreateInstance(
CLSID_ShellWindows,
NULL,
CLSCTX_ALL,
IID_IShellWindows,
reinterpret_cast<void**>(&psw)
))) {
throw RUNTIME_EXCEPT("cannot create IShellWindows.") ;
}
long win_num = 0 ;
if(util::is_failed(psw->get_Count(&win_num))) {
throw RUNTIME_EXCEPT("No explorer is opened.") ;
}
for(long i = 0 ; i < win_num ; i ++) {
VARIANT v ;
v.vt = VT_I4 ;
V_I4(&v) = i ;
//IDispatch is an interface to object, method or property
util::SmartCom<IDispatch> pdisp{} ;
if(util::is_failed(psw->Item(v, &pdisp))) {
continue ;
}
//Is this shell foreground window??
util::SmartCom<IWebBrowserApp> pwba{} ;
if(util::is_failed(pdisp->QueryInterface(IID_IWebBrowserApp, reinterpret_cast<void**>(&pwba)))) {
continue ;
}
HWND shell_hwnd = NULL ;
if(util::is_failed(pwba->get_HWND(reinterpret_cast<LONG_PTR*>(&shell_hwnd)))) {
continue ;
}
if(shell_hwnd != hwnd) {
continue ; //it is not foreground window
}
//access to shell window
util::SmartCom<IServiceProvider> psp{} ;
if(util::is_failed(pwba->QueryInterface(IID_IServiceProvider, reinterpret_cast<void**>(&psp)))) {
throw RUNTIME_EXCEPT("cannot access a top service provider.") ;
}
//access to shell browser
util::SmartCom<IShellBrowser> psb{} ;
if(util::is_failed(psp->QueryService(SID_STopLevelBrowser, IID_IShellBrowser, reinterpret_cast<void**>(&psb)))) {
throw RUNTIME_EXCEPT("cannot access a shell browser.") ;
}
//access to shell view
util::SmartCom<IShellView> psv{} ;
if(util::is_failed(psb->QueryActiveShellView(&psv))) {
throw RUNTIME_EXCEPT("cannot access a shell view.") ;
}
//get IFolerView Interface
util::SmartCom<IFolderView> pfv{} ;
if(util::is_failed(psv->QueryInterface(IID_IFolderView, reinterpret_cast<void**>(&pfv)))) {
throw RUNTIME_EXCEPT("cannot access a foler view.") ;
}
//get IPersistantFolder2 in order to use GetCurFolder method
util::SmartCom<IPersistFolder2> ppf2{} ;
if(util::is_failed(pfv->GetFolder(IID_IPersistFolder2, reinterpret_cast<void**>(&ppf2)))) {
throw RUNTIME_EXCEPT("cannot access a persist folder 2.") ;
}
ITEMIDLIST* raw_pidl = nullptr ;
if(util::is_failed(ppf2->GetCurFolder(&raw_pidl))) {
throw RUNTIME_EXCEPT("cannot get current folder.") ;
}
auto idl_deleter = [](ITEMIDLIST* ptr) {CoTaskMemFree(ptr) ;} ;
std::unique_ptr<ITEMIDLIST, decltype(idl_deleter)> pidl(raw_pidl, idl_deleter) ;
//convert to path
WCHAR path[MAX_PATH] = {0} ;
if(!SHGetPathFromIDListW(pidl.get(), path)) {
throw RUNTIME_EXCEPT("cannot convert an item ID to a file system path.") ;
}
return std::filesystem::path(path) ;
}
return std::filesystem::path() ;
}
}
}
| 37.390625 | 129 | 0.516924 | e-ntro-py |
3b0764534c0184331705ea13e0cbacbefdc3ba0e | 989 | hpp | C++ | include/gui/Button.hpp | Kihau/GoGame | db6b2dfcf373b3cc07d76d6551d83e0e9a73d6c5 | [
"MIT"
] | null | null | null | include/gui/Button.hpp | Kihau/GoGame | db6b2dfcf373b3cc07d76d6551d83e0e9a73d6c5 | [
"MIT"
] | null | null | null | include/gui/Button.hpp | Kihau/GoGame | db6b2dfcf373b3cc07d76d6551d83e0e9a73d6c5 | [
"MIT"
] | null | null | null | #ifndef BUTTON_H
#define BUTTON_H
#include "gui/GuiComponent.hpp"
// TODO: To implement either of the systems
// 1. Add c#-like callback event system (and use lamba expression to add callbacks)
// 2. Create fields for all button events, return their reault via callback methods (if callback method return true - execute some code)
// 3. Create sfml like event handling method (button.pollEvents())
class Button : public GuiComponent {
private:
sf::Text caption;
sf::RectangleShape base;
bool clicked = false;
public:
Button();
Button(sf::Font font, const sf::Vector2f& size = sf::Vector2f(0.0f, 0.0f));
~Button();
void draw(sf::RenderTarget& target, const sf::RenderStates& states) const;
void update(sf::Vector2f);
void update();
bool clickCallback();
void setText(std::string);
void setBackground(sf::Color);
void setOutlineThickness(f32);
void setOutlineColor(sf::Color);
void setPosition(const sf::Vector2f&);
};
#endif | 29.969697 | 136 | 0.703741 | Kihau |
3b08228e5c654d05653c5e65890400cd6a33fbac | 16,056 | cc | C++ | RAVL2/GUI/2D/MarkupPolygon2d.cc | isuhao/ravl2 | 317e0ae1cb51e320b877c3bad6a362447b5e52ec | [
"BSD-Source-Code"
] | null | null | null | RAVL2/GUI/2D/MarkupPolygon2d.cc | isuhao/ravl2 | 317e0ae1cb51e320b877c3bad6a362447b5e52ec | [
"BSD-Source-Code"
] | null | null | null | RAVL2/GUI/2D/MarkupPolygon2d.cc | isuhao/ravl2 | 317e0ae1cb51e320b877c3bad6a362447b5e52ec | [
"BSD-Source-Code"
] | null | null | null | // This file is part of RAVL, Recognition And Vision Library
// Copyright (C) 2006, Omniperception Ltd.
// This code may be redistributed under the terms of the GNU Lesser
// General Public License (LGPL). See the lgpl.licence file for details or
// see http://www.gnu.org/copyleft/lesser.html
// file-header-ends-here
//! rcsid="$Id: fixSource.cfg 5642 2006-06-23 10:51:11Z craftit $"
//! lib=RavlGUI2D
#include "Ravl/GUI/MarkupPolygon2d.hh"
#include "Ravl/GUI/GUIMarkupCanvas.hh"
#include "Ravl/Projection2d.hh"
#include "Ravl/Affine2d.hh"
#include "Ravl/OS/SysLog.hh"
#include "Ravl/RCWrap.hh"
#include "Ravl/GUI/MarkupLayerInfo.hh"
#include <gdk/gdk.h>
#define DODEBUG 0
#if DODEBUG
#define ONDEBUG(x) x
#else
#define ONDEBUG(x)
#endif
namespace RavlGUIN {
//: Constructor.
MarkupPolygon2dBodyC::MarkupPolygon2dBodyC(Int64T id,IntT zOrder,const Polygon2dC &_poly,bool openPoly,bool isFixed)
: MarkupInfoBodyC(id,zOrder),
poly(_poly),
orgPoly(_poly.Copy()),
useCustomColour(false),
colour(255,255,0),
m_fixed(isFixed),
m_openPoly(openPoly)
{}
//: Constructor.
MarkupPolygon2dBodyC::MarkupPolygon2dBodyC(Int64T id,IntT zOrder,const Polygon2dC &_poly,const ByteRGBValueC &_colour,bool openPoly,bool isFixed)
: MarkupInfoBodyC(id,zOrder),
poly(_poly),
orgPoly(_poly.Copy()),
useCustomColour(true),
colour(_colour),
m_fixed(isFixed),
m_openPoly(openPoly)
{}
//: Extent of object.
RealRange2dC MarkupPolygon2dBodyC::Extent(GUIMarkupCanvasBodyC &mv) const {
RealRange2dC rextent;
bool polyOk = true;
bool isFirst = true;
// Work out extent of this polygon allowing for dodgy points.
for(DLIterC<Point2dC> it(poly);it;it++) {
Point2dC &dir = *it;
if(IsNan(dir[0]) || IsNan(dir[1]) || IsInf(dir[0]) || IsInf(dir[1])) {
//SysLog(SYSLOG_ERR) << "MarkupPolygon2dBodyC::Extent, Illegal polygon : " << poly;
polyOk = false;
continue;
}
if(isFirst) {
rextent = RealRange2dC(*it,0.0);
isFirst = false;
continue;
}
rextent.Involve(dir);
}
if(!isFirst)
rextent = rextent.Expand(2);
// Involve extent of children
for(DLIterC<MarkupPolygon2dC> it(children);it;it++) {
if(isFirst) {
rextent = it->Extent(mv);
isFirst = false;
} else
rextent.Involve(it->Extent(mv));
}
// If 'isFirst' is true then we haven't found a single usefull point.
if((rextent.Range1().Min() > rextent.Range1().Max()) || (rextent.Range2().Min() > rextent.Range2().Max()) || isFirst) {
SysLog(SYSLOG_WARNING) << "MarkupPolygon2dBodyC::Extent, Negative or invalid extent=" << rextent << " ";
return RealRange2dC(0,0);
}
return rextent;
}
//: Set colour for polygon.
void MarkupPolygon2dBodyC::SetColour(const ByteRGBValueC &_colour) {
colour = _colour;
useCustomColour = true;
}
void MarkupPolygon2dBodyC::UnsetColour()
{
useCustomColour = false;
}
//: Add child markup.
bool MarkupPolygon2dBodyC::Insert(const MarkupPolygon2dC &markupPoly) {
children.InsLast(markupPoly);
return true;
}
//: Call when some part of the polygon has been updated.
// This will update the position of any child polygons appropriatly.
bool MarkupPolygon2dBodyC::MovePoly() {
Projection2dC proj;
try {
proj = FitProjection(orgPoly,poly);
} catch(ExceptionC &) { // Catch numerical problems.
return false; // Couldn't fit projection so ignore.
}
for(DLIterC<MarkupPolygon2dC> it(children);it;it++)
it->ApplyTransform(proj);
return true;
}
//: Apply transform to this polygon
// This replaces poly with orgPoly transformed by the given projection.
bool MarkupPolygon2dBodyC::ApplyTransform(const Projection2dC &proj) {
poly = proj * orgPoly;
for(DLIterC<MarkupPolygon2dC> it(children);it;it++)
it->ApplyTransform(proj);
return true;
}
//: Update database with changes to this polygon
bool MarkupPolygon2dBodyC::UpdateDb() {
orgPoly = poly.Copy();
if(trigUpdate.IsValid()) {
if(!trigUpdate.Call(poly,id))
SysLog(SYSLOG_WARNING) << "MarkupPolygon2dBodyC::UpdateDb, Update failed.... ";
}
for(DLIterC<MarkupPolygon2dC> it(children);it;it++)
it->UpdateDb();
return true;
}
//: Method for rendering frame.
bool MarkupPolygon2dBodyC::Render(GUIMarkupCanvasBodyC &mv,const RealRange2dC &area,bool selected) {
if(poly.IsEmpty())
return true;
// Set up the gc
if (!SetDrawStyle(mv))
return true;
GdkGC *dc = mv.GcDrawContext();
// Use an overrding colour
if (useCustomColour)
{
GdkColor gcolour;
gcolour.red = (IntT) colour.Red() * 256;
gcolour.green = (IntT) colour.Green() * 256;
gcolour.blue = (IntT) colour.Blue() * 256;
gdk_gc_set_rgb_fg_color(dc, &gcolour);
}
// Draw the polygon
int n = 0;
Point2dC last = poly.Last();
for(DLIterC<Point2dC> it(poly);it;it++,n++) {
if(n == 1) {
Vector2dC dir = (*it) - last;
if(IsNan(dir[0]) || IsNan(dir[1]) || IsInf(dir[0]) || IsInf(dir[1])) {
SysLog(SYSLOG_ERR) << "MarkupPolygon2dBodyC::Render, Illegal polygon : " << poly;
break;
}
// Draw the arrow
RealT len = dir.Magnitude();
if(len == 0) len = 1; // Look out for zero's
dir *= 3/len;
Vector2dC perp = dir.Perpendicular()/2;
Point2dC p1 = last + dir;
Point2dC p2 = last + perp + (dir/3);
Point2dC p3 = last - perp + (dir/3);
mv.GUIDrawLine(dc,p2,p1);
mv.GUIDrawLine(dc,p3,p1);
mv.GUIDrawLine(dc,last,p2);
mv.GUIDrawLine(dc,last,p3);
// Draw the line
mv.GUIDrawLine(dc,p1,*it);
} else {
// Draw the line
if(n != 0 || !m_openPoly)
mv.GUIDrawLine(dc,last,*it);
}
if (selected)
{
const IntT boxSize = 2;
mv.GUIDrawLine(dc, Point2dC(*it - Point2dC(-boxSize, -boxSize)), Point2dC(*it - Point2dC(-boxSize, boxSize)));
mv.GUIDrawLine(dc, Point2dC(*it - Point2dC( boxSize, -boxSize)), Point2dC(*it - Point2dC( boxSize, boxSize)));
mv.GUIDrawLine(dc, Point2dC(*it - Point2dC( boxSize, -boxSize)), Point2dC(*it - Point2dC(-boxSize, -boxSize)));
mv.GUIDrawLine(dc, Point2dC(*it - Point2dC( boxSize, boxSize)), Point2dC(*it - Point2dC(-boxSize, boxSize)));
}
last = *it;
}
return true;
}
//: Find a point on the polygon
// Returns the number of the point.
bool MarkupPolygon2dBodyC::FindClosestPoint(const Point2dC &pnt,RealT &score,IntT &pntNo) {
IntT c = 0;
IntT best = -1;
RealT bestDist = Sqr(6);
for(DLIterC<Point2dC> it(poly);it;it++,c++) {
RealT dist = pnt.SqrEuclidDistance(*it);
if(IsNan(dist) || IsInf(dist) || dist >= bestDist) // Be paranoid about corrupted data.
continue;
bestDist = dist;
best = c;
}
if(best < 0)
return false;
score = Sqrt(bestDist);
pntNo = best;
return true;
}
//: Check if we've selected something in this object.
RealT MarkupPolygon2dBodyC::SelectTest(GUIMarkupCanvasBodyC &mv,const Point2dC &at,const MouseEventC &me) {
RealT score = -1;
IntT pn;
if(FindClosestPoint(at,score,pn)) {
if(mv.GUIIsSelected(Id()) && score < 6) // Only show bias within a circle.
score /= 20; // Give it a strong bias towards selected polygons
return score;
}
//SysLog(SYSLOG_DEBUG) << "MarkupPolygon2dBodyC::SelectTest, Contains=" << poly.Contains(at) << " Area=" << poly.Area() << "\n";
if(poly.Contains(at)) {
score = Abs(poly.Area());
return score;
}
return -1;
}
//: Handle mouse event.
// Returns true if even has been handled.
// States:
// -2 = Select event, no op.
// -1 = Whole rectangle drag.
// 0 n = Drag single corner
// 100 n+100 = Mark each corner.
bool MarkupPolygon2dBodyC::MouseEventPress(GUIMarkupCanvasBodyC &mv,const Point2dC &at,const MouseEventC &me,IntT &state,bool &refresh) {
ONDEBUG(SysLog(SYSLOG_DEBUG) << "MarkupPolygon2dBodyC::MouseEventPress() At=" << at << " State=" << state << " " << " ");
ONDEBUG(SysLog(SYSLOG_DEBUG) << " Press " << me.HasChanged(0) << " " << me.HasChanged(1) << " " << me.HasChanged(2) << " " << me.HasChanged(3) << " " << " " << me.HasChanged(4) << " ");
ONDEBUG(SysLog(SYSLOG_DEBUG)
<< " Press Ctrl=" << me.IsCntrl()
<< " Lock=" << me.IsLock()
<< " Shift=" << me.IsShift()
<< " Alt=" << me.IsAlt()
<< " Mod5=" << me.IsMod5()
<< " Mod6=" << me.IsMod6()
<< " Mod7=" << me.IsMod7() // 'Special Key'
<< " Mod8=" << me.IsMod8() // 'Atl Gr'
<< " ");
if(m_fixed)
return false;
if(state >= 100) {
IntT size = (IntT) poly.Size();
IntT pat = state - 100;
if(pat >= size) return false;
poly.Nth(pat) = at;
MovePoly();
refresh = true;
return true;
}
if(me.HasChanged(0)) { // Button 0 press ?
IntT newState = -1;
RealT score = -1;
if(FindClosestPoint(at,score,newState)) {
state = newState;
if((me.IsMod7() || me.IsMod8() || me.IsAlt())) {// newState == 0 &&
//cerr << "NewState=" << newState << "\n";
state = 100 + newState; // Put it into markup mode.
}
return true;
}
}
//SysLog(SYSLOG_DEBUG) << "MarkupPolygon2dBodyC::MouseEventPress, Contains=" << poly.Contains(at) << " Area=" << poly.Area() << "\n";
if(poly.Contains(at)) { // Click inside the rect ?
if(me.HasChanged(1) && (me.IsShift() || me.IsCntrl())) { // Is it inside the polygon ?
mv.SetMouseInfo(RCWrapC<Polygon2dC>(poly.Copy()).Abstract());
state = -1;
return true;
}
if(me.HasChanged(0)) { // Attempting a select operation ?
ONDEBUG(SysLog(SYSLOG_DEBUG) << " Select... Id=" << Id() );
if(Id() >= 0) {
state = -2;
if(me.IsCntrl()) { // *** Cntrl select. ***
if(!mv.GUIIsSelected(Id()))
mv.GUIAddSelect(Id());
else
mv.GUIDelSelect(Id());
refresh = true;
return true;
} else if(me.IsShift()) {// *** Shift select ***
if(!mv.GUIIsSelected(Id())) {
mv.GUIAddSelect(Id());
refresh = true;
return true;
}
return false;
} else { // *** Plain ***
mv.GUIClearSelect(false);
mv.GUIAddSelect(Id());
refresh = true;
return true;
}
}
}
}
return false;
}
//: Handle mouse event.
// Returns true if even has been handled.
bool MarkupPolygon2dBodyC::MouseEventMove(GUIMarkupCanvasBodyC &mv,const Point2dC &at,const MouseEventC &me,IntT &state,bool &refresh) {
ONDEBUG(SysLog(SYSLOG_DEBUG) << "MarkupPolygon2dBodyC::MouseEventMove() At=" << at << " State=" << state << " " << " ");
ONDEBUG(SysLog(SYSLOG_DEBUG) << " Press " << me.HasChanged(0) << " " << me.HasChanged(1) << " " << me.HasChanged(2) << " " << me.HasChanged(3) << " " << " " << me.HasChanged(4) << " ");
if(m_fixed)
return false;
if(state == -2)
return false;
if(state == -1) { // Move whole polygon ?
RCWrapC<Polygon2dC> oldPoly(mv.MouseInfo(),true);
RavlAssert(oldPoly.IsValid());
poly = oldPoly.Data().Copy();
Point2dC offset = (at - mv.MousePressAt());
for(DLIterC<Point2dC> oit(poly);oit;oit++)
*oit += offset;
if(!me.IsCntrl())
MovePoly();
refresh = true;
return true;
}
// Normal move.
if(state < 100) {
if(state < (IntT) poly.Size())
poly.Nth(state) = at;
else
SysLog(SYSLOG_WARNING) << "MarkupPolygon2dBodyC::MouseEvent, Odd state=" << state << " Size=" << poly.Size() << " ";
if(!me.IsCntrl())
MovePoly();
refresh = true;
return true;
}
// Markup mode.
if(state >= 100) {
IntT pat = state - 100;
if(pat >= (IntT) poly.Size())
return false;
QuickMarkPoint(pat,at,me.IsMod8());
if(!me.IsCntrl())
MovePoly();
refresh = true;
return true;
}
return false;
}
//: Move a point with quick markup.
bool MarkupPolygon2dBodyC::QuickMarkPoint(int pnt,Point2dC pos,bool markVert) {
// 0. Move whole thing
// 1. Change horz angle and scale.
// 2. Change vert angle and scale.
// 3. Change perspective
DLIterC<Point2dC> oit(orgPoly);
DLIterC<Point2dC> pit(poly);
switch(pnt) {
case 0: { // Move whole thing
Vector2dC offset = pos - *oit;
for(;pit && oit;pit++,oit++)
*pit = *oit + offset;
if(markVert) {
// Make the last point directly below this one.
poly.Nth(-1).Col() = pos.Col();
// Make the other side the average of the two offsets.
Point2dC &p1 = poly.Nth(1);
Point2dC p2 = poly.Nth(2);
p1.Col() = (p1.Col() + p2.Col())/2.0;
}
} break;
case 1: { // Move horzontal angle and scale.
SArray1dC<Point2dC> op(3);
SArray1dC<Point2dC> np(3);
op[0] = *oit; oit++;
op[1] = *oit; oit++;
op[2] = *oit;
np[0] = *pit;
np[1] = pos;
RealT d2 = op[0].EuclidDistance(op[1]);
if(d2 <= 0) d2 = 0.1; // Avoid potential division by zero.
RealT scale = np[0].EuclidDistance(pos) / d2;
if(markVert) {
// Make sure np[2] is directly below np[1]
np[2] = pos + Vector2dC((op[2].Row() - op[1].Row()) * scale,0);
} else {
np[2] = pos + (op[2] - op[1]) * scale;
}
Affine2dC trans = FitAffine(op,np);
poly = trans * orgPoly;
if(markVert) { // Need to do vertical correction on final point?
poly.Nth(-1).Col() = poly.First().Col();
}
} break;
case 2: { // Affine change.
SArray1dC<Point2dC> op(3);
SArray1dC<Point2dC> np(3);
op[0] = *oit; oit++;
op[1] = *oit; oit++;
op[2] = *oit;
np[0] = *pit; pit++;
np[1] = *pit; pit++;
np[2] = pos;
if(markVert) {
// Make sure it stays vertical.
np[2].Col() = np[1].Col();
}
Affine2dC trans = FitAffine(op,np);
poly = trans * orgPoly;
if(markVert) { // Need to do vertical correction on final point?
poly.Nth(-1).Col() = poly.First().Col();
}
} break;
case 3: {
if(markVert)
pos.Col() = poly.First().Col();
poly.Nth(pnt) = pos;
} break;
default:
poly.Nth(pnt) = pos;
break;
}
return true;
}
//: Handle mouse event.
// Returns true if even has been handled.
bool MarkupPolygon2dBodyC::MouseEventRelease(GUIMarkupCanvasBodyC &mv,const Point2dC &at,const MouseEventC &me,IntT &state,bool &refresh) {
ONDEBUG(SysLog(SYSLOG_DEBUG) << "MarkupPolygon2dBodyC::MouseEventRelease() At=" << at << " State=" << state << " " << " ");
ONDEBUG(SysLog(SYSLOG_DEBUG) << " Press " << me.HasChanged(0) << " " << me.HasChanged(1) << " " << me.HasChanged(2) << " " << me.HasChanged(3) << " " << " " << me.HasChanged(4) << " ");
if(m_fixed)
return false;
if(state == -2)
return false;
if(state < 100 && state >= -1) {
UpdateDb();
} else { // State >= 0, initial create mode.
IntT size = poly.Size();
state++;
if((state - 100) == size || !(me.IsMod7() || me.IsMod8() || me.IsAlt())) {
UpdateDb();
return false;
}
return true;
}
return false;
}
//: Does polygon have child with given id ?
bool MarkupPolygon2dBodyC::HasChild(Int64T anId) const {
for(DLIterC<MarkupPolygon2dC> it(children);it;it++) {
if(it->Id() == anId) return true;
if(it->HasChild(anId)) return true;
}
return false;
}
}
| 31.116279 | 189 | 0.572496 | isuhao |
3b0b6bec179e47c47b2c521e79ffde4856c4ebc3 | 3,687 | cpp | C++ | libyul/optimiser/CommonSubexpressionEliminator.cpp | step21/solidity | 2a0d701f709673162e8417d2f388b8171a34e892 | [
"MIT"
] | null | null | null | libyul/optimiser/CommonSubexpressionEliminator.cpp | step21/solidity | 2a0d701f709673162e8417d2f388b8171a34e892 | [
"MIT"
] | 1 | 2020-06-17T14:24:49.000Z | 2020-06-17T14:24:49.000Z | libyul/optimiser/CommonSubexpressionEliminator.cpp | step21/solidity | 2a0d701f709673162e8417d2f388b8171a34e892 | [
"MIT"
] | null | null | null | /*(
This file is part of solidity.
solidity 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.
solidity 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 solidity. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* Optimisation stage that replaces expressions known to be the current value of a variable
* in scope by a reference to that variable.
*/
#include <libyul/optimiser/CommonSubexpressionEliminator.h>
#include <libyul/optimiser/Metrics.h>
#include <libyul/optimiser/SyntacticalEquality.h>
#include <libyul/optimiser/CallGraphGenerator.h>
#include <libyul/optimiser/Semantics.h>
#include <libyul/SideEffects.h>
#include <libyul/Exceptions.h>
#include <libyul/AsmData.h>
#include <libyul/Dialect.h>
using namespace std;
using namespace solidity;
using namespace solidity::yul;
using namespace solidity::util;
void CommonSubexpressionEliminator::run(OptimiserStepContext& _context, Block& _ast)
{
CommonSubexpressionEliminator cse{
_context.dialect,
SideEffectsPropagator::sideEffects(_context.dialect, CallGraphGenerator::callGraph(_ast))
};
cse(_ast);
}
CommonSubexpressionEliminator::CommonSubexpressionEliminator(
Dialect const& _dialect,
map<YulString, SideEffects> _functionSideEffects
):
DataFlowAnalyzer(_dialect, std::move(_functionSideEffects))
{
}
void CommonSubexpressionEliminator::visit(Expression& _e)
{
bool descend = true;
// If this is a function call to a function that requires literal arguments,
// do not try to simplify there.
if (holds_alternative<FunctionCall>(_e))
{
FunctionCall& funCall = std::get<FunctionCall>(_e);
if (BuiltinFunction const* builtin = m_dialect.builtin(funCall.functionName.name))
{
for (size_t i = funCall.arguments.size(); i > 0; i--)
// We should not modify function arguments that have to be literals
// Note that replacing the function call entirely is fine,
// if the function call is movable.
if (!builtin->literalArguments || !builtin->literalArguments.value()[i - 1])
visit(funCall.arguments[i - 1]);
descend = false;
}
}
// We visit the inner expression first to first simplify inner expressions,
// which hopefully allows more matches.
// Note that the DataFlowAnalyzer itself only has code for visiting Statements,
// so this basically invokes the AST walker directly and thus post-visiting
// is also fine with regards to data flow analysis.
if (descend)
DataFlowAnalyzer::visit(_e);
if (holds_alternative<Identifier>(_e))
{
Identifier& identifier = std::get<Identifier>(_e);
YulString name = identifier.name;
if (m_value.count(name))
{
assertThrow(m_value.at(name).value, OptimizerException, "");
if (holds_alternative<Identifier>(*m_value.at(name).value))
{
YulString value = std::get<Identifier>(*m_value.at(name).value).name;
assertThrow(inScope(value), OptimizerException, "");
_e = Identifier{locationOf(_e), value};
}
}
}
else
{
// TODO this search is rather inefficient.
for (auto const& [variable, value]: m_value)
{
assertThrow(value.value, OptimizerException, "");
assertThrow(inScope(variable), OptimizerException, "");
if (SyntacticallyEqual{}(_e, *value.value))
{
_e = Identifier{locationOf(_e), variable};
break;
}
}
}
}
| 32.06087 | 91 | 0.743423 | step21 |
3b0edc5dbfb4cbcfc3e15b030794300154e55356 | 337 | cpp | C++ | Olamundo/for/main.cpp | tosantos1/LIP | 7dbc045afa02729f4e2f2f1d3b29baebf5be72ad | [
"MIT"
] | null | null | null | Olamundo/for/main.cpp | tosantos1/LIP | 7dbc045afa02729f4e2f2f1d3b29baebf5be72ad | [
"MIT"
] | null | null | null | Olamundo/for/main.cpp | tosantos1/LIP | 7dbc045afa02729f4e2f2f1d3b29baebf5be72ad | [
"MIT"
] | null | null | null | #include <iostream>
using namespace std;
int main()
{
int x, n, resultado = 1;
cout << "Informe a base: ";
cin >> x;
cout << "Informe o expoente: ";
cin >> n;
for(int cont = 0;cont < n ; cont ++){
resultado = resultado * x;
}
cout << "Resultado: " << resultado << endl;
return 0;
}
| 12.481481 | 47 | 0.504451 | tosantos1 |
3b16176f55073f6c49713121e4807033f10f1bd4 | 969 | cpp | C++ | Contests/Codeforces/CF1011/C.cpp | SYCstudio/OI | 6e9bfc17dbd4b43467af9b19aa2aed41e28972fa | [
"MIT"
] | 4 | 2017-10-31T14:25:18.000Z | 2018-06-10T16:10:17.000Z | Contests/Codeforces/CF1011/C.cpp | SYCstudio/OI | 6e9bfc17dbd4b43467af9b19aa2aed41e28972fa | [
"MIT"
] | null | null | null | Contests/Codeforces/CF1011/C.cpp | SYCstudio/OI | 6e9bfc17dbd4b43467af9b19aa2aed41e28972fa | [
"MIT"
] | null | null | null | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define ld long double
#define mem(Arr,x) memset(Arr,x,sizeof(Arr))
const int maxN=1010;
const ld eps=1e-6;
const int inf=2147483647;
int n,m;
int A[maxN],B[maxN];
bool Check(ld fuel);
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) scanf("%d",&A[i]);
for (int i=1;i<=n;i++) scanf("%d",&B[i]);
ld L=0,R=2e9,Ans=-1;
do{
ld mid=(L+R)/(ld)2.0;
if (Check(mid)) Ans=mid,R=mid-eps;
else L=mid+eps;
}
while (L+eps<R);
if ((Ans==-1)||(Ans>1e9+1)) printf("-1\n");
else printf("%.10LF\n",Ans);
return 0;
}
bool Check(ld fuel){
//printf("%.10LF\n",fuel);
fuel=fuel-(fuel+m)/(ld)A[1];
if (fuel<0) return 0;
for (int i=2;i<=n;i++){
fuel=fuel-(fuel+m)/(ld)B[i];
if (fuel<0) return 0;
fuel=fuel-(fuel+m)/(ld)A[i];
if (fuel<0) return 0;
}
fuel=fuel-(fuel+m)/(ld)B[1];
if (fuel<0) return 0;
return 1;
}
| 17.944444 | 44 | 0.597523 | SYCstudio |
3b1832611024fb775e8dbaf17e7a8171b5ac5884 | 9,162 | cc | C++ | cpp/src/arrow/ipc/file.cc | DonaldFoss/ApacheArrow | 4226adfbc6b3dff10b3fe7a6691b30bcc94140bd | [
"Apache-2.0"
] | 1 | 2020-04-23T01:11:36.000Z | 2020-04-23T01:11:36.000Z | cpp/src/arrow/ipc/file.cc | DonaldFoss/ApacheArrow | 4226adfbc6b3dff10b3fe7a6691b30bcc94140bd | [
"Apache-2.0"
] | 1 | 2021-12-09T23:06:13.000Z | 2021-12-09T23:06:14.000Z | cpp/src/arrow/ipc/file.cc | DonaldFoss/ApacheArrow | 4226adfbc6b3dff10b3fe7a6691b30bcc94140bd | [
"Apache-2.0"
] | null | null | null | // 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 "arrow/ipc/file.h"
#include <cstdint>
#include <cstring>
#include <sstream>
#include <vector>
#include "arrow/buffer.h"
#include "arrow/io/interfaces.h"
#include "arrow/io/memory.h"
#include "arrow/ipc/adapter.h"
#include "arrow/ipc/metadata-internal.h"
#include "arrow/ipc/metadata.h"
#include "arrow/ipc/util.h"
#include "arrow/status.h"
#include "arrow/util/logging.h"
namespace arrow {
namespace ipc {
static constexpr const char* kArrowMagicBytes = "ARROW1";
// ----------------------------------------------------------------------
// File footer
static flatbuffers::Offset<flatbuffers::Vector<const flatbuf::Block*>>
FileBlocksToFlatbuffer(FBB& fbb, const std::vector<FileBlock>& blocks) {
std::vector<flatbuf::Block> fb_blocks;
for (const FileBlock& block : blocks) {
fb_blocks.emplace_back(block.offset, block.metadata_length, block.body_length);
}
return fbb.CreateVectorOfStructs(fb_blocks);
}
Status WriteFileFooter(const Schema& schema, const std::vector<FileBlock>& dictionaries,
const std::vector<FileBlock>& record_batches, io::OutputStream* out) {
FBB fbb;
flatbuffers::Offset<flatbuf::Schema> fb_schema;
RETURN_NOT_OK(SchemaToFlatbuffer(fbb, schema, &fb_schema));
auto fb_dictionaries = FileBlocksToFlatbuffer(fbb, dictionaries);
auto fb_record_batches = FileBlocksToFlatbuffer(fbb, record_batches);
auto footer = flatbuf::CreateFooter(
fbb, kMetadataVersion, fb_schema, fb_dictionaries, fb_record_batches);
fbb.Finish(footer);
int32_t size = fbb.GetSize();
return out->Write(fbb.GetBufferPointer(), size);
}
static inline FileBlock FileBlockFromFlatbuffer(const flatbuf::Block* block) {
return FileBlock(block->offset(), block->metaDataLength(), block->bodyLength());
}
class FileFooter::FileFooterImpl {
public:
FileFooterImpl(const std::shared_ptr<Buffer>& buffer, const flatbuf::Footer* footer)
: buffer_(buffer), footer_(footer) {}
int num_dictionaries() const { return footer_->dictionaries()->size(); }
int num_record_batches() const { return footer_->recordBatches()->size(); }
MetadataVersion::type version() const {
switch (footer_->version()) {
case flatbuf::MetadataVersion_V1:
return MetadataVersion::V1;
case flatbuf::MetadataVersion_V2:
return MetadataVersion::V2;
// Add cases as other versions become available
default:
return MetadataVersion::V2;
}
}
FileBlock record_batch(int i) const {
return FileBlockFromFlatbuffer(footer_->recordBatches()->Get(i));
}
FileBlock dictionary(int i) const {
return FileBlockFromFlatbuffer(footer_->dictionaries()->Get(i));
}
Status GetSchema(std::shared_ptr<Schema>* out) const {
auto schema_msg = std::make_shared<SchemaMetadata>(nullptr, footer_->schema());
return schema_msg->GetSchema(out);
}
private:
// Retain reference to memory
std::shared_ptr<Buffer> buffer_;
const flatbuf::Footer* footer_;
};
FileFooter::FileFooter() {}
FileFooter::~FileFooter() {}
Status FileFooter::Open(
const std::shared_ptr<Buffer>& buffer, std::unique_ptr<FileFooter>* out) {
const flatbuf::Footer* footer = flatbuf::GetFooter(buffer->data());
*out = std::unique_ptr<FileFooter>(new FileFooter());
// TODO(wesm): Verify the footer
(*out)->impl_.reset(new FileFooterImpl(buffer, footer));
return Status::OK();
}
int FileFooter::num_dictionaries() const {
return impl_->num_dictionaries();
}
int FileFooter::num_record_batches() const {
return impl_->num_record_batches();
}
MetadataVersion::type FileFooter::version() const {
return impl_->version();
}
FileBlock FileFooter::record_batch(int i) const {
return impl_->record_batch(i);
}
FileBlock FileFooter::dictionary(int i) const {
return impl_->dictionary(i);
}
Status FileFooter::GetSchema(std::shared_ptr<Schema>* out) const {
return impl_->GetSchema(out);
}
// ----------------------------------------------------------------------
// File writer implementation
FileWriter::FileWriter(io::OutputStream* sink, const std::shared_ptr<Schema>& schema)
: StreamWriter(sink, schema) {}
Status FileWriter::Open(io::OutputStream* sink, const std::shared_ptr<Schema>& schema,
std::shared_ptr<FileWriter>* out) {
*out = std::shared_ptr<FileWriter>(new FileWriter(sink, schema)); // ctor is private
RETURN_NOT_OK((*out)->UpdatePosition());
return Status::OK();
}
Status FileWriter::Start() {
RETURN_NOT_OK(WriteAligned(
reinterpret_cast<const uint8_t*>(kArrowMagicBytes), strlen(kArrowMagicBytes)));
started_ = true;
return Status::OK();
}
Status FileWriter::WriteRecordBatch(const RecordBatch& batch) {
// Push an empty FileBlock
// Append metadata, to be written in the footer later
record_batches_.emplace_back(0, 0, 0);
return StreamWriter::WriteRecordBatch(
batch, &record_batches_[record_batches_.size() - 1]);
}
Status FileWriter::Close() {
// Write metadata
int64_t initial_position = position_;
RETURN_NOT_OK(WriteFileFooter(*schema_, dictionaries_, record_batches_, sink_));
RETURN_NOT_OK(UpdatePosition());
// Write footer length
int32_t footer_length = position_ - initial_position;
if (footer_length <= 0) { return Status::Invalid("Invalid file footer"); }
RETURN_NOT_OK(Write(reinterpret_cast<const uint8_t*>(&footer_length), sizeof(int32_t)));
// Write magic bytes to end file
return Write(
reinterpret_cast<const uint8_t*>(kArrowMagicBytes), strlen(kArrowMagicBytes));
}
// ----------------------------------------------------------------------
// Reader implementation
FileReader::FileReader(
const std::shared_ptr<io::ReadableFileInterface>& file, int64_t footer_offset)
: file_(file), footer_offset_(footer_offset) {}
FileReader::~FileReader() {}
Status FileReader::Open(const std::shared_ptr<io::ReadableFileInterface>& file,
std::shared_ptr<FileReader>* reader) {
int64_t footer_offset;
RETURN_NOT_OK(file->GetSize(&footer_offset));
return Open(file, footer_offset, reader);
}
Status FileReader::Open(const std::shared_ptr<io::ReadableFileInterface>& file,
int64_t footer_offset, std::shared_ptr<FileReader>* reader) {
*reader = std::shared_ptr<FileReader>(new FileReader(file, footer_offset));
return (*reader)->ReadFooter();
}
Status FileReader::ReadFooter() {
int magic_size = static_cast<int>(strlen(kArrowMagicBytes));
if (footer_offset_ <= magic_size * 2 + 4) {
std::stringstream ss;
ss << "File is too small: " << footer_offset_;
return Status::Invalid(ss.str());
}
std::shared_ptr<Buffer> buffer;
int file_end_size = magic_size + sizeof(int32_t);
RETURN_NOT_OK(file_->ReadAt(footer_offset_ - file_end_size, file_end_size, &buffer));
if (memcmp(buffer->data() + sizeof(int32_t), kArrowMagicBytes, magic_size)) {
return Status::Invalid("Not an Arrow file");
}
int32_t footer_length = *reinterpret_cast<const int32_t*>(buffer->data());
if (footer_length <= 0 || footer_length + magic_size * 2 + 4 > footer_offset_) {
return Status::Invalid("File is smaller than indicated metadata size");
}
// Now read the footer
RETURN_NOT_OK(file_->ReadAt(
footer_offset_ - footer_length - file_end_size, footer_length, &buffer));
RETURN_NOT_OK(FileFooter::Open(buffer, &footer_));
// Get the schema
return footer_->GetSchema(&schema_);
}
std::shared_ptr<Schema> FileReader::schema() const {
return schema_;
}
int FileReader::num_dictionaries() const {
return footer_->num_dictionaries();
}
int FileReader::num_record_batches() const {
return footer_->num_record_batches();
}
MetadataVersion::type FileReader::version() const {
return footer_->version();
}
Status FileReader::GetRecordBatch(int i, std::shared_ptr<RecordBatch>* batch) {
DCHECK_GE(i, 0);
DCHECK_LT(i, num_record_batches());
FileBlock block = footer_->record_batch(i);
std::shared_ptr<RecordBatchMetadata> metadata;
RETURN_NOT_OK(ReadRecordBatchMetadata(
block.offset, block.metadata_length, file_.get(), &metadata));
// TODO(wesm): ARROW-388 -- the buffer frame of reference is 0 (see
// ARROW-384).
std::shared_ptr<Buffer> buffer_block;
RETURN_NOT_OK(file_->Read(block.body_length, &buffer_block));
io::BufferReader reader(buffer_block);
return ReadRecordBatch(metadata, schema_, &reader, batch);
}
} // namespace ipc
} // namespace arrow
| 31.163265 | 90 | 0.712726 | DonaldFoss |
3b18d006cb1a4aecc50530df0653ab4a48f9fd60 | 421 | cpp | C++ | components/xtl/tests/stl/ptrunf1.cpp | untgames/funner | c91614cda55fd00f5631d2bd11c4ab91f53573a3 | [
"MIT"
] | 7 | 2016-03-30T17:00:39.000Z | 2017-03-27T16:04:04.000Z | components/xtl/tests/stl/ptrunf1.cpp | untgames/Funner | c91614cda55fd00f5631d2bd11c4ab91f53573a3 | [
"MIT"
] | 4 | 2017-11-21T11:25:49.000Z | 2018-09-20T17:59:27.000Z | components/xtl/tests/stl/ptrunf1.cpp | untgames/Funner | c91614cda55fd00f5631d2bd11c4ab91f53573a3 | [
"MIT"
] | 4 | 2016-11-29T15:18:40.000Z | 2017-03-27T16:04:08.000Z | #include <stl/algorithm>
#include <stl/functional>
#include <stdio.h>
using namespace stl;
inline bool even (int n)
{
return (n % 2) == 0;
}
int main ()
{
printf ("Results of ptrunf1_test:\n");
int array [3] = {1,2,3};
int* p = find_if ((int*)array,(int*)array+3,pointer_to_unary_function<int,bool> (even));
if (p != array + 3)
printf ("%d is even\n",*p);
return 0;
}
| 16.84 | 91 | 0.565321 | untgames |
3b1a2072dde5c79af4b33b31479b7aed692d8418 | 473 | cpp | C++ | Unrest-iOS/Line.cpp | arvindrajayadav/unrest | d89f20e95fbcdef37a47ab1454b2479522a0e43f | [
"MIT"
] | 11 | 2020-08-04T08:37:46.000Z | 2022-03-31T22:35:15.000Z | CRAB/Line.cpp | arvindrajayadav/unrest | d89f20e95fbcdef37a47ab1454b2479522a0e43f | [
"MIT"
] | 1 | 2020-12-16T16:51:52.000Z | 2020-12-18T06:35:38.000Z | Unrest-iOS/Line.cpp | arvindrajayadav/unrest | d89f20e95fbcdef37a47ab1454b2479522a0e43f | [
"MIT"
] | 7 | 2020-08-04T09:34:20.000Z | 2021-09-11T03:00:16.000Z | #include "stdafx.h"
#include "Line.h"
//------------------------------------------------------------------------
// Purpose: Draw a line from start to end
//------------------------------------------------------------------------
void DrawLine(const int &x1, const int &y1, const int &x2, const int &y2,
const Uint8 &r, const Uint8 &g, const Uint8 &b, const Uint8 &a)
{
SDL_SetRenderDrawColor(gRenderer, r, g, b, a);
SDL_RenderDrawLine(gRenderer, x1, y1, x2, y2);
} | 39.416667 | 74 | 0.469345 | arvindrajayadav |
3b1ac9dda4777a3a580d8f60463a3e14f5405b78 | 7,881 | cc | C++ | src/xqp/interact.cc | DouglasRMiles/QuProlog | 798d86f87fb4372b8918ef582ef2f0fc0181af2d | [
"Apache-2.0"
] | 5 | 2019-11-20T02:05:31.000Z | 2022-01-06T18:59:16.000Z | src/xqp/interact.cc | logicmoo/QuProlog | 798d86f87fb4372b8918ef582ef2f0fc0181af2d | [
"Apache-2.0"
] | null | null | null | src/xqp/interact.cc | logicmoo/QuProlog | 798d86f87fb4372b8918ef582ef2f0fc0181af2d | [
"Apache-2.0"
] | 2 | 2022-01-08T13:52:24.000Z | 2022-03-07T17:41:37.000Z | /***************************************************************************
interact.cc - QP interaction widget
-------------------
begin : April 2004
copyright : (C) 2004 by Peter Robinson
email : pjr@itee.uq.edu.au
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
// $Id: interact.cc,v 1.3 2004/05/25 04:31:33 qp Exp $
#include <signal.h>
#include <unistd.h>
#include <string>
#include <iostream>
#include "interact.h"
#include "term.h"
#include "xqpqueries.h"
#include <qmessagebox.h>
#include <qfiledialog.h>
#include <qfile.h>
#include <qtextstream.h>
#include <QKeyEvent>
using namespace std;
Interact::Interact( QWidget *box )
: QTextEdit(box)
{
parent = box;
setFont( QFont( "Lucidatypewriter", 12, QFont::Normal ) );
indent = 0;
readonly = false;
connect(this, SIGNAL(send_cmd(QString)), box, SLOT(send_cmd_to_qp(QString)));
in_history = false;
hist_pos = 0;
}
void Interact::insert_at_end(QString s)
{
insertPlainText(s);
QTextCursor cursor(textCursor());
cursor.movePosition(QTextCursor::End);
setTextCursor(cursor);
setTextColor(Qt::blue);
in_query = (s.contains(QRegExp("'| \\?- $")));
//if (in_query)
indent = cursor.position();
}
void Interact::processF5(QString s)
{
QTextCursor cursor(textCursor());
cursor.movePosition(QTextCursor::End);
cursor.insertText(s);
setTextCursor(cursor);
}
void Interact::processReturn()
{
QTextCursor cursor(textCursor());
cursor.setPosition(indent);
cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
in_history = false;
QString cmd = cursor.selectedText();
cmd.replace(QChar::ParagraphSeparator, QString("\n"));
if (!in_query || end_of_term(cmd, 0))
{
cmd.append("\n");
send_cmd(cmd);
cmd.truncate(cmd.length()-1);
if (in_query)
{
addHistoryItem(new QString(cmd));
hist_pos = 0;
}
in_query = false;
}
}
Interact::~Interact()
{
}
void Interact::mouseReleaseEvent(QMouseEvent* e)
{
QTextCursor cursor(textCursor());
int p = cursor.position();
if (p < indent)
{
if (e->button() != Qt::MidButton)
QTextEdit::mouseReleaseEvent(e);
cursor.movePosition(QTextCursor::End);
setTextCursor(cursor);
readonly = true;
}
else
{
QTextEdit::mouseReleaseEvent(e);
readonly = false;
}
}
void Interact::mousePressEvent(QMouseEvent* e)
{
if (e->button() == Qt::MidButton)
{
QMouseEvent lbe(QEvent::MouseButtonPress, e->pos(),
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QTextEdit::mousePressEvent(&lbe);
QTextEdit::mouseReleaseEvent(&lbe);
}
QTextEdit::mousePressEvent(e);
}
void Interact::cut()
{
if (readonly) QTextEdit::copy();
else QTextEdit::cut();
}
void Interact::paste()
{
if (!readonly) QTextEdit::paste();
}
void Interact::keyPressEvent(QKeyEvent *k)
{
int key_pressed = k->key();
if (key_pressed == Qt::Key_Control)
{
QTextEdit::keyPressEvent(k);
return;
}
if (k->modifiers() == Qt::ControlModifier)
{
in_history = false;
if (key_pressed == 'D')
{
emit ctrl_D_sig();
return;
}
if (key_pressed == 'C')
{
QTextEdit::keyPressEvent(k);
return;
}
}
if (readonly)
{
in_history = false;
QTextCursor cursor(textCursor());
cursor.movePosition(QTextCursor::End);
setTextCursor(cursor);
}
if (key_pressed == Qt::Key_Return)
{
processReturn();
}
if ((key_pressed == Qt::Key_Backspace)
|| (key_pressed == Qt::Key_Left))
{
int p;
in_history = false;
QTextCursor cursor(textCursor());
p = cursor.position();
if (p <= indent)
{
return;
}
}
if (key_pressed == Qt::Key_Up)
{
QString* item;
if (!in_history)
{
item = firstHistoryItem();
}
else
{
item = nextHistoryItem();
}
in_history = true;
if (item != NULL)
{
QTextCursor cursor(textCursor());
cursor.setPosition(indent);
cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
cursor.removeSelectedText();
setTextColor(Qt::blue);
insertPlainText(*item);
}
return;
}
if (key_pressed == Qt::Key_Down)
{
QString* item = previousHistoryItem();
QTextCursor cursor(textCursor());
cursor.setPosition(indent);
cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
cursor.removeSelectedText();
setTextColor(Qt::blue);
if ( item != NULL)
{
insertPlainText(*item);
}
else
{
in_history = false;
insertPlainText("");
}
return;
}
if (key_pressed == Qt::Key_Home)
{
in_history = false;
if (k->modifiers() == Qt::ControlModifier)
{
QTextCursor cursor(textCursor());
cursor.setPosition(indent);
setTextCursor(cursor);
return;
}
else
{
int p;
QTextCursor cursor(textCursor());
cursor.movePosition(QTextCursor::StartOfBlock);
p = cursor.position();
if (p > indent)
{
setTextCursor(cursor);
}
return;
}
}
if (key_pressed == Qt::Key_PageUp)
{
in_history = false;
QTextCursor cursor(textCursor());
cursor.setPosition(indent);
setTextCursor(cursor);
return;
}
in_history = false;
QTextEdit::keyPressEvent(k);
}
void Interact::addHistoryItem(QString* s)
{
history.prepend(s);
}
QString* Interact::firstHistoryItem(void)
{
if (history.size() == 0) return NULL;
return history.first();
}
QString* Interact::nextHistoryItem(void)
{
if (history.size() <= hist_pos+1) return NULL;
return history[++hist_pos];
}
QString* Interact::previousHistoryItem(void)
{
if (hist_pos == 0) return NULL;
return history[--hist_pos];
}
void Interact::openQueryFile()
{
QString fileName = QFileDialog::getOpenFileName(this, QString::null, QString::null, "*");
if (fileName != QString::null)
{
QFile f(fileName);
if (f.open(QIODevice::ReadOnly))
{
QTextStream t(&f);
XQPQueries* xqp_queries = new XQPQueries(parent, fileName, t.readAll());
xqp_queries->setFont(font());
connect(xqp_queries, SIGNAL(process_text(QString)), this, SLOT(processF5(QString)));
connect(xqp_queries, SIGNAL(process_return()), this, SLOT(processReturn()));
f.close();
}
}
}
void Interact::saveHistory()
{
QString fileName = QFileDialog::getSaveFileName(this, QString::null, QString::null, "*");
if (fileName != QString::null)
{
QFile f(fileName);
if (f.open(QIODevice::WriteOnly))
{
QString* item = firstHistoryItem();
QTextStream out(&f);
while (item != NULL)
{
out << *item << "\n";
item = nextHistoryItem();
}
f.close();
}
}
}
void Interact::saveSession()
{
QString fileName = QFileDialog::getSaveFileName(this, QString::null, QString::null, "*");
if (fileName != QString::null)
{
QFile f(fileName);
if (f.open(QIODevice::WriteOnly))
{
QString s = toPlainText();
QTextStream out(&f);
out << s;
f.close();
}
}
}
| 23.455357 | 91 | 0.572643 | DouglasRMiles |
3b203d53e5a024e99f1e865213bfbfed82c12618 | 820 | cpp | C++ | sieveOfEratosthenes.cpp | akashsharma99/2ndSemPractise | ba854e8ef5089ad627cee6f7c8828b711437affa | [
"MIT"
] | null | null | null | sieveOfEratosthenes.cpp | akashsharma99/2ndSemPractise | ba854e8ef5089ad627cee6f7c8828b711437affa | [
"MIT"
] | null | null | null | sieveOfEratosthenes.cpp | akashsharma99/2ndSemPractise | ba854e8ef5089ad627cee6f7c8828b711437affa | [
"MIT"
] | null | null | null | // C++ program to print all primes smaller than or equal to n using Sieve of Eratosthenes
#include <iostream>
#include<string.h>//for memset function to set memory to a particular value
using namespace std;
void SieveOfEratosthenes(int n)
{
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for (int p=2; p<=n; p++)
if (prime[p])
cout << p << " ";
}
// Driver Program to test above function
int main()
{
int n;
cout<<"Enter limit: ";
cin>>n;
cout << "Following are the prime numbers smaller than or equal to " << n << endl;
SieveOfEratosthenes(n);
return 0;
}
| 22.777778 | 89 | 0.562195 | akashsharma99 |
3b235ca287c4678c50d4b36cf5e7fb6bea1c368b | 1,828 | cpp | C++ | doubly-linked-list/tests/unit/ConstructorTest.cpp | JMazurkiewicz/PROI-projects | d135f8c170a584ef56399a6f7818cc221047d40c | [
"MIT"
] | null | null | null | doubly-linked-list/tests/unit/ConstructorTest.cpp | JMazurkiewicz/PROI-projects | d135f8c170a584ef56399a6f7818cc221047d40c | [
"MIT"
] | null | null | null | doubly-linked-list/tests/unit/ConstructorTest.cpp | JMazurkiewicz/PROI-projects | d135f8c170a584ef56399a6f7818cc221047d40c | [
"MIT"
] | null | null | null | #include "DoublyLinkedList.h"
#include "Test.h"
#include <vector>
namespace {
void defaultConstructorTest() {
DoublyLinkedList<int> list;
TEST(list.getSize() == 0);
TEST(list.isEmpty());
TEST(list.begin() == list.end());
}
void listConstructorTest() {
DoublyLinkedList<float> list{1.2F, 2, 4, 6, 8, 1, 4, 6};
TEST(list.getSize() == 8);
TEST(list[4] == 8);
TEST(list[1] == 2);
}
void valueConstructorTest() {
DoublyLinkedList<char> list(26, 'A');
TEST(list.getSize() == 26);
TEST(list[0] == 'A');
}
void copyConstructorTest() {
DoublyLinkedList<double> one{0.0, 1, 2, 3, 4, 5, 6, 7};
DoublyLinkedList<double> two(one);
const auto& refone = one;
const auto& reftwo = two;
TEST(one.getSize() == two.getSize());
TEST(refone[0] == reftwo[0]);
TEST(refone[6] == reftwo[6]);
TEST(refone.begin().getNode() == reftwo.begin().getNode());
}
void moveConstructorTest() {
DoublyLinkedList<void*> one(3, nullptr);
void* firstNode = one.begin().getNode();
DoublyLinkedList<void*> two = std::move(one);
TEST(one.getSize() == 0);
TEST(two.getSize() == 3);
TEST(firstNode == two.begin().getNode());
}
void iteratorConstructorTest() {
std::vector<int> vector = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
DoublyLinkedList<long> list(vector.begin(), vector.end());
TEST(list.getSize() == 10);
TEST(list.front() == 0);
TEST(list.back() == 9);
}
} // namespace
void constructorTest() {
defaultConstructorTest();
listConstructorTest();
valueConstructorTest();
copyConstructorTest();
moveConstructorTest();
iteratorConstructorTest();
}
| 25.388889 | 67 | 0.556346 | JMazurkiewicz |
3b238c796f289e927cbc5cd078f6372d39ea3cc8 | 1,294 | hh | C++ | include/netpoll.hh | henglinli/runtime | 2ec1981113f35dee1ea793dad2fab197152d5e08 | [
"BSD-3-Clause"
] | 1 | 2016-08-24T16:57:21.000Z | 2016-08-24T16:57:21.000Z | include/netpoll.hh | henglinli/runtime | 2ec1981113f35dee1ea793dad2fab197152d5e08 | [
"BSD-3-Clause"
] | null | null | null | include/netpoll.hh | henglinli/runtime | 2ec1981113f35dee1ea793dad2fab197152d5e08 | [
"BSD-3-Clause"
] | null | null | null | // -*-coding:utf-8-unix;-*-
//
#pragma once
//
#include "macros.hh"
//
namespace NAMESPACE {
//
template<typename Impl>
class NetPoll {
public:
//
NetPoll() = default;
~NetPoll() = default;
//
auto Init() -> int {
return static_cast<Impl*>(this)->init();
}
//
auto Open(int fd, void *ptr) -> int {
return static_cast<Impl*>(this)->open(fd, ptr);
}
//
auto Close(int fd) -> int {
return static_cast<Impl*>(this)->close(fd);
}
//
auto Poll(bool block) -> int {
return static_cast<Impl*>(this)->poll(block);
}
//
private:
friend class NetPoller;
//
DISALLOW_COPY_AND_ASSIGN(NetPoll);
};
//
class NetPoller final {
public:
NetPoller() = default;
~NetPoller() = default;
//
template<typename Impl>
static auto Init(NetPoll<Impl>& poll) -> int {
return poll.Init();
}
//
template<typename Impl>
static auto Open(NetPoll<Impl>& poll, int fd, void *ptr) -> int {
return poll.Open(fd, ptr);
}
//
template<typename Impl>
static auto Close(NetPoll<Impl>& poll, int fd) -> int {
return poll.Close(fd);
}
//
template<typename Impl>
static auto Poll(NetPoll<Impl>& poll, bool block) -> int {
return poll.Poll(block);
}
//
private:
DISALLOW_COPY_AND_ASSIGN(NetPoller);
};
} // namespace NAMESPACE
| 19.313433 | 67 | 0.618238 | henglinli |
3b2420953d8544cfa292505e8536ffda0ffe47e1 | 1,085 | cc | C++ | example/udp_example.cc | jiejieTop/doralib | bf587aab93860a84e6d3cedf1dad206a44834f2e | [
"Apache-2.0"
] | 4 | 2020-11-04T04:44:08.000Z | 2021-12-16T08:38:05.000Z | example/udp_example.cc | jiejieTop/doralib | bf587aab93860a84e6d3cedf1dad206a44834f2e | [
"Apache-2.0"
] | 1 | 2020-11-04T14:29:43.000Z | 2020-11-05T04:51:33.000Z | example/udp_example.cc | jiejieTop/doralib | bf587aab93860a84e6d3cedf1dad206a44834f2e | [
"Apache-2.0"
] | 2 | 2020-11-25T17:27:33.000Z | 2021-02-24T09:31:00.000Z | /*
* @Author: jiejie
* @GitHub: https://github.com/jiejieTop
* @Date: 2020-10-27 18:34:01
* @LastEditors: jiejie
* @LastEditTime: 2020-11-15 11:46:20
* @Description: the code belongs to jiejie, please keep the author information and source code according to the license.
*/
#include "dora_socket.h"
#include "dora_log.h"
#define DGRAM_DATA "this is a udp test ..."
int main(void)
{
char recv_buf[1024];
int len = 0;
memset(recv_buf, 0, sizeof(recv_buf));
DORA_LOG_INFO("========================= udp =========================");
auto udp1 = new doralib::sock("127.0.0.4", "8001");
auto udp2 = new doralib::sock("127.0.0.4", "8002");
udp1->sock_bind("8002");
udp2->sock_bind("8001");
udp1->sock_write(DGRAM_DATA, strlen(DGRAM_DATA), "127.0.0.4", "8002");
len = udp1->sock_read(recv_buf, sizeof(recv_buf), NULL, NULL, 1000);
DORA_LOG_INFO("len is {} : {}", len, recv_buf);
udp1->sock_close();
udp2->sock_close();
DORA_LOG_INFO("========================= success =========================");
return 0;
}
| 25.232558 | 121 | 0.576037 | jiejieTop |
3b2541469df1539733a74e9a7850caedac2e44a1 | 6,500 | cpp | C++ | ClockWork_Engine/GameObject.cpp | xsiro/NewClockWork_Engine | 8da27311b179c6812e52d62cacbdd8ba7b538d9a | [
"MIT"
] | null | null | null | ClockWork_Engine/GameObject.cpp | xsiro/NewClockWork_Engine | 8da27311b179c6812e52d62cacbdd8ba7b538d9a | [
"MIT"
] | null | null | null | ClockWork_Engine/GameObject.cpp | xsiro/NewClockWork_Engine | 8da27311b179c6812e52d62cacbdd8ba7b538d9a | [
"MIT"
] | null | null | null | #include "GameObject.h"
#include "ModuleComponent.h"
#include "ModuleTransform.h"
#include "ModuleMesh.h"
#include "ModuleMaterial.h"
#include "imgui.h"
#include "Application.h"
#include "Cam.h"
#include "JSON.h"
#include "MathGeoLib/include/MathGeoLib.h"
#include <vector>
GameObject::GameObject() : enabled(true), name("Game Object"), _parent(nullptr), to_delete(false), transform(nullptr), _visible(false)
{
transform = (ModuleTransform*)AddComponent(TRANSFORM);
UUID = LCG().Int();
}
GameObject::GameObject(GnMesh* mesh) : GameObject()
{
SetName(mesh->name);
AddComponent((ModuleComponent*)mesh);
}
GameObject::~GameObject()
{
_parent = nullptr;
for (size_t i = 0; i < components.size(); i++)
{
delete components[i];
components[i] = nullptr;
}
transform = nullptr;
components.clear();
children.clear();
name.clear();
UUID = 0;
}
void GameObject::Update()
{
if (enabled)
{
for (size_t i = 0; i < components.size(); i++)
{
//Update Components
if (components[i]->IsEnabled())
{
if (components[i]->GetType() == ComponentType::MESH)
{
GnMesh* mesh = (GnMesh*)components[i];
GenerateAABB(mesh);
if (App->renderer3D->IsInsideCameraView(_AABB))
mesh->Update();
}
else
{
components[i]->Update();
}
}
}
//Update Children
for (size_t i = 0; i < children.size(); i++)
{
children[i]->Update();
}
}
}
void GameObject::OnEditor()
{
ImGui::Checkbox("Enabled", &enabled);
ImGui::SameLine();
static char buf[64] = "Name";
strcpy(buf, name.c_str());
if (ImGui::InputText("", &buf[0], IM_ARRAYSIZE(buf))) {}
for (size_t i = 0; i < components.size(); i++)
{
components[i]->OnEditor();
}
if (ImGui::CollapsingHeader("Debugging Information"))
{
if (_parent != nullptr)
ImGui::Text("Parent: %s", _parent->GetName());
else
ImGui::Text("No parent");
ImGui::Text("UUID: %d", UUID);
}
}
void GameObject::Save(GnJSONArray& save_array)
{
JSON save_object;
save_object.AddInt("UUID", UUID);
if (_parent != nullptr)
save_object.AddInt("Parent UUID", _parent->UUID);
else
save_object.AddInt("Parent UUID", 0);
save_object.AddString("Name", name.c_str());
GnJSONArray componentsSave = save_object.AddArray("Components");
for (size_t i = 0; i < components.size(); i++)
{
components[i]->Save(componentsSave);
}
save_array.AddObject(save_object);
for (size_t i = 0; i < children.size(); i++)
{
children[i]->Save(save_array);
}
}
uint GameObject::Load(JSON* object)
{
UUID = object->GetInt("UUID");
name = object->GetString("Name", "No Name");
uint parentUUID = object->GetInt("Parent UUID");
GnJSONArray componentsArray = object->GetArray("Components");
for (size_t i = 0; i < componentsArray.Size(); i++)
{
JSON componentObject = componentsArray.GetObjectAt(i);
ModuleComponent* component = AddComponent((ComponentType)componentObject.GetInt("Type"));
component->Load(componentObject);
}
return parentUUID;
}
ModuleComponent* GameObject::GetComponent(ComponentType component)
{
for (size_t i = 0; i < components.size(); i++)
{
if (components[i]->GetType() == component)
{
return components[i];
}
}
return nullptr;
}
std::vector<ModuleComponent*> GameObject::GetComponents()
{
return components;
}
ModuleComponent* GameObject::AddComponent(ComponentType type)
{
ModuleComponent* ModuleComponent = nullptr;
switch (type)
{
case TRANSFORM:
if (transform != nullptr)
{
RemoveComponent(transform);
}
transform = new ModuleTransform();
ModuleComponent = transform;
break;
case MESH:
ModuleComponent = new GnMesh();
break;
case MATERIAL:
ModuleComponent = new ModuleMaterial(this);
break;
case CAMERA:
ModuleComponent = new Camera(this);
break;
case LIGHT:
ModuleComponent = new Light(this);
break;
default:
break;
}
ModuleComponent->SetGameObject(this);
components.push_back(ModuleComponent);
return ModuleComponent;
}
void GameObject::AddComponent(ModuleComponent* component)
{
components.push_back(component);
component->SetGameObject(this);
}
bool GameObject::RemoveComponent(ModuleComponent* component)
{
bool ret = false;
for (size_t i = 0; i < components.size(); i++)
{
if (components[i] == component) {
delete components[i];
components.erase(components.begin() + i);
component = nullptr;
ret = true;
}
}
return ret;
}
const char* GameObject::GetName() { return name.c_str(); }
void GameObject::SetName(const char* g_name)
{
name = g_name;
}
void GameObject::SetTransform(ModuleTransform g_transform)
{
//localTransform->Set(g_transform.GetLocalTransform());
//localTransform->UpdateLocalTransform();
memcpy(transform, &g_transform, sizeof(g_transform));
}
ModuleTransform* GameObject::GetTransform()
{
return transform;
}
AABB GameObject::GetAABB()
{
return _AABB;
}
bool GameObject::IsVisible()
{
return _visible;
}
void GameObject::AddChild(GameObject* child)
{
if (child != nullptr)
children.push_back(child);
child->SetParent(this);
}
int GameObject::GetChildrenAmount()
{
return children.size();
}
GameObject* GameObject::GetChildAt(int index)
{
return children[index];
}
GameObject* GameObject::GetParent()
{
return _parent;
}
void GameObject::SetParent(GameObject* g_parent)
{
_parent = g_parent;
}
void GameObject::Reparent(GameObject* newParent)
{
if (newParent != nullptr)
{
_parent->RemoveChild(this);
_parent = newParent;
newParent->AddChild(this);
transform->ChangeParentTransform(newParent->GetTransform()->GetGlobalTransform());
}
}
bool GameObject::RemoveChild(GameObject* gameObject)
{
bool ret = false;
for (size_t i = 0; i < children.size(); i++)
{
if (children[i] == gameObject)
{
children.erase(children.begin() + i);
ret = true;
}
}
return ret;
}
void GameObject::DeleteChildren()
{
for (size_t i = 0; i < children.size(); i++)
{
children[i]->DeleteChildren();
children[i] = nullptr;
}
this->~GameObject();
}
void GameObject::UpdateChildrenTransforms()
{
transform->UpdateGlobalTransform();
for (size_t i = 0; i < children.size(); i++)
{
children[i]->GetTransform()->UpdateGlobalTransform(transform->GetGlobalTransform());
children[i]->UpdateChildrenTransforms();
}
}
void GameObject::GenerateAABB(GnMesh* mesh)
{
_OBB = mesh->GetAABB();
_OBB.Transform(transform->GetGlobalTransform());
_AABB.SetNegativeInfinity();
_AABB.Enclose(_OBB);
float3 cornerPoints[8];
_AABB.GetCornerPoints(cornerPoints);
App->renderer3D->DrawAABB(cornerPoints);
}
| 19.061584 | 134 | 0.687692 | xsiro |
3b255d7d62fc90118f6999020039bb50710658ab | 31,837 | cpp | C++ | libgambatte/src/memory.cpp | Gorialis/BizHawk | 096277122553d38d87fa11c0cfe4d45e2682b939 | [
"MIT"
] | null | null | null | libgambatte/src/memory.cpp | Gorialis/BizHawk | 096277122553d38d87fa11c0cfe4d45e2682b939 | [
"MIT"
] | null | null | null | libgambatte/src/memory.cpp | Gorialis/BizHawk | 096277122553d38d87fa11c0cfe4d45e2682b939 | [
"MIT"
] | null | null | null | //
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "memory.h"
#include "gambatte.h"
#include "savestate.h"
#include "sound.h"
#include "video.h"
#include <algorithm>
#include <cstring>
using namespace gambatte;
namespace {
int const oam_size = 4 * lcd_num_oam_entries;
void decCycles(unsigned long& counter, unsigned long dec) {
if (counter != disabled_time)
counter -= dec;
}
int serialCntFrom(unsigned long cyclesUntilDone, bool cgbFast) {
return cgbFast ? (cyclesUntilDone + 0xF) >> 4 : (cyclesUntilDone + 0x1FF) >> 9;
}
} // unnamed namespace.
Memory::Memory(Interrupter const& interrupter)
: readCallback_(0)
, writeCallback_(0)
, execCallback_(0)
, cdCallback_(0)
, linkCallback_(0)
, bios_(0)
, getInput_(0)
, divLastUpdate_(0)
, lastOamDmaUpdate_(disabled_time)
, lcd_(ioamhram_, 0, VideoInterruptRequester(intreq_))
, interrupter_(interrupter)
, dmaSource_(0)
, dmaDestination_(0)
, oamDmaPos_(-2u & 0xFF)
, oamDmaStartPos_(0)
, serialCnt_(0)
, blanklcd_(false)
, LINKCABLE_(false)
, linkClockTrigger_(false)
, haltHdmaState_(hdma_low)
{
intreq_.setEventTime<intevent_blit>(1l * lcd_vres * lcd_cycles_per_line);
intreq_.setEventTime<intevent_end>(0);
}
Memory::~Memory() {
delete []bios_;
}
void Memory::setStatePtrs(SaveState &state) {
state.mem.ioamhram.set(ioamhram_, sizeof ioamhram_);
cart_.setStatePtrs(state);
lcd_.setStatePtrs(state);
psg_.setStatePtrs(state);
}
void Memory::loadState(SaveState const &state) {
biosMode_ = state.mem.biosMode;
stopped_ = state.mem.stopped;
psg_.loadState(state);
lcd_.loadState(state, state.mem.oamDmaPos < oam_size ? cart_.rdisabledRam() : ioamhram_);
tima_.loadState(state, TimaInterruptRequester(intreq_));
cart_.loadState(state);
intreq_.loadState(state);
intreq_.setEventTime<intevent_serial>(state.mem.nextSerialtime > state.cpu.cycleCounter
? state.mem.nextSerialtime
: state.cpu.cycleCounter);
intreq_.setEventTime<intevent_unhalt>(state.mem.unhaltTime);
lastOamDmaUpdate_ = state.mem.lastOamDmaUpdate;
dmaSource_ = state.mem.dmaSource;
dmaDestination_ = state.mem.dmaDestination;
oamDmaPos_ = state.mem.oamDmaPos;
oamDmaStartPos_ = 0;
haltHdmaState_ = static_cast<HdmaState>(std::min(1u * state.mem.haltHdmaState, 1u * hdma_requested));
serialCnt_ = intreq_.eventTime(intevent_serial) != disabled_time
? serialCntFrom(intreq_.eventTime(intevent_serial) - state.cpu.cycleCounter,
ioamhram_[0x102] & isCgb() * 2)
: 8;
cart_.setVrambank(ioamhram_[0x14F] & isCgb());
cart_.setOamDmaSrc(oam_dma_src_off);
cart_.setWrambank(isCgb() && (ioamhram_[0x170] & 0x07) ? ioamhram_[0x170] & 0x07 : 1);
if (lastOamDmaUpdate_ != disabled_time) {
if (lastOamDmaUpdate_ > state.cpu.cycleCounter) {
oamDmaStartPos_ = (oamDmaPos_ + (lastOamDmaUpdate_ - state.cpu.cycleCounter) / 4) & 0xFF;
lastOamDmaUpdate_ = state.cpu.cycleCounter;
}
oamDmaInitSetup();
unsigned oamEventPos = oamDmaPos_ < oam_size ? oam_size : oamDmaStartPos_;
intreq_.setEventTime<intevent_oam>(
lastOamDmaUpdate_ + ((oamEventPos - oamDmaPos_) & 0xFF) * 4);
}
intreq_.setEventTime<intevent_blit>(ioamhram_[0x140] & lcdc_en
? lcd_.nextMode1IrqTime()
: state.cpu.cycleCounter);
blanklcd_ = false;
if (!isCgb())
std::fill_n(cart_.vramdata() + vrambank_size(), vrambank_size(), 0);
}
void Memory::setEndtime(unsigned long cc, unsigned long inc) {
if (intreq_.eventTime(intevent_blit) <= cc) {
intreq_.setEventTime<intevent_blit>(intreq_.eventTime(intevent_blit)
+ (lcd_cycles_per_frame << isDoubleSpeed()));
}
intreq_.setEventTime<intevent_end>(cc + (inc << isDoubleSpeed()));
}
void Memory::updateSerial(unsigned long const cc) {
if (!LINKCABLE_) {
if (intreq_.eventTime(intevent_serial) != disabled_time) {
if (intreq_.eventTime(intevent_serial) <= cc) {
ioamhram_[0x101] = (((ioamhram_[0x101] + 1) << serialCnt_) - 1) & 0xFF;
ioamhram_[0x102] &= 0x7F;
intreq_.flagIrq(8, intreq_.eventTime(intevent_serial));
intreq_.setEventTime<intevent_serial>(disabled_time);
} else {
int const targetCnt = serialCntFrom(intreq_.eventTime(intevent_serial) - cc,
ioamhram_[0x102] & isCgb() * 2);
ioamhram_[0x101] = (((ioamhram_[0x101] + 1) << (serialCnt_ - targetCnt)) - 1) & 0xFF;
serialCnt_ = targetCnt;
}
}
} else {
if (intreq_.eventTime(intevent_serial) != disabled_time) {
if (intreq_.eventTime(intevent_serial) <= cc) {
linkClockTrigger_ = true;
intreq_.setEventTime<intevent_serial>(disabled_time);
if (linkCallback_)
linkCallback_();
}
}
}
}
void Memory::updateTimaIrq(unsigned long cc) {
while (intreq_.eventTime(intevent_tima) <= cc)
tima_.doIrqEvent(TimaInterruptRequester(intreq_));
}
void Memory::updateIrqs(unsigned long cc) {
updateSerial(cc);
updateTimaIrq(cc);
lcd_.update(cc);
}
unsigned long Memory::event(unsigned long cc) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
switch (intreq_.minEventId()) {
case intevent_unhalt:
if ((lcd_.hdmaIsEnabled() && lcd_.isHdmaPeriod(cc) && haltHdmaState_ == hdma_low)
|| haltHdmaState_ == hdma_requested) {
flagHdmaReq(intreq_);
}
intreq_.unhalt();
intreq_.setEventTime<intevent_unhalt>(disabled_time);
stopped_ = false;
break;
case intevent_end:
intreq_.setEventTime<intevent_end>(disabled_time - 1);
while (cc >= intreq_.minEventTime()
&& intreq_.eventTime(intevent_end) != disabled_time) {
cc = event(cc);
}
intreq_.setEventTime<intevent_end>(disabled_time);
break;
case intevent_blit:
{
bool const lcden = ioamhram_[0x140] & lcdc_en;
unsigned long blitTime = intreq_.eventTime(intevent_blit);
if (lcden | blanklcd_) {
lcd_.updateScreen(blanklcd_, cc);
intreq_.setEventTime<intevent_blit>(disabled_time);
intreq_.setEventTime<intevent_end>(disabled_time);
while (cc >= intreq_.minEventTime())
cc = event(cc);
} else
blitTime += lcd_cycles_per_frame << isDoubleSpeed();
blanklcd_ = lcden ^ 1;
intreq_.setEventTime<intevent_blit>(blitTime);
}
break;
case intevent_serial:
updateSerial(cc);
break;
case intevent_oam:
if (lastOamDmaUpdate_ != disabled_time) {
unsigned const oamEventPos = oamDmaPos_ < oam_size ? oam_size : oamDmaStartPos_;
intreq_.setEventTime<intevent_oam>(
lastOamDmaUpdate_ + ((oamEventPos - oamDmaPos_) & 0xFF) * 4);
}
else
intreq_.setEventTime<intevent_oam>(disabled_time);
break;
case intevent_dma:
interrupter_.prefetch(cc, *this);
cc = dma(cc);
if (haltHdmaState_ == hdma_requested) {
haltHdmaState_ = hdma_low;
intreq_.setMinIntTime(cc);
cc -= 4;
}
break;
case intevent_tima:
tima_.doIrqEvent(TimaInterruptRequester(intreq_));
break;
case intevent_video:
lcd_.update(cc);
break;
case intevent_interrupts:
if (stopped_) {
intreq_.setEventTime<intevent_interrupts>(disabled_time);
break;
}
if (halted()) {
cc += 4 * (isCgb() || cc - intreq_.eventTime(intevent_interrupts) < 2);
if (cc > lastOamDmaUpdate_)
updateOamDma(cc);
if ((lcd_.hdmaIsEnabled() && lcd_.isHdmaPeriod(cc) && haltHdmaState_ == hdma_low)
|| haltHdmaState_ == hdma_requested) {
flagHdmaReq(intreq_);
}
intreq_.unhalt();
intreq_.setEventTime<intevent_unhalt>(disabled_time);
}
if (ime()) {
di();
cc = interrupter_.interrupt(cc, *this);
}
break;
}
return cc;
}
unsigned long Memory::dma(unsigned long cc) {
bool const doubleSpeed = isDoubleSpeed();
unsigned dmaSrc = dmaSource_;
unsigned dmaDest = dmaDestination_;
unsigned dmaLength = ((ioamhram_[0x155] & 0x7F) + 1) * 0x10;
unsigned length = hdmaReqFlagged(intreq_) ? 0x10 : dmaLength;
if (1ul * dmaDest + length >= 0x10000) {
length = 0x10000 - dmaDest;
ioamhram_[0x155] |= 0x80;
}
dmaLength -= length;
if (!(ioamhram_[0x140] & lcdc_en))
dmaLength = 0;
unsigned long lOamDmaUpdate = lastOamDmaUpdate_;
lastOamDmaUpdate_ = disabled_time;
while (length--) {
unsigned const src = dmaSrc++ & 0xFFFF;
unsigned const data = (src & -vrambank_size()) == mm_vram_begin || src >= mm_oam_begin
? 0xFF
: read(src, cc);
cc += 2 + 2 * doubleSpeed;
if (cc - 3 > lOamDmaUpdate && !halted()) {
oamDmaPos_ = (oamDmaPos_ + 1) & 0xFF;
lOamDmaUpdate += 4;
if (oamDmaPos_ == oamDmaStartPos_)
startOamDma(lOamDmaUpdate);
if (oamDmaPos_ < oam_size) {
ioamhram_[src & 0xFF] = data;
}
else if (oamDmaPos_ == oam_size) {
endOamDma(lOamDmaUpdate);
if (oamDmaStartPos_ == 0)
lOamDmaUpdate = disabled_time;
}
}
nontrivial_write(mm_vram_begin | dmaDest++ % vrambank_size(), data, cc);
}
lastOamDmaUpdate_ = lOamDmaUpdate;
ackDmaReq(intreq_);
cc += 4;
dmaSource_ = dmaSrc;
dmaDestination_ = dmaDest;
ioamhram_[0x155] = halted()
? ioamhram_[0x155] | 0x80
: ((dmaLength / 0x10 - 1) & 0xFF) | (ioamhram_[0x155] & 0x80);
if ((ioamhram_[0x155] & 0x80) && lcd_.hdmaIsEnabled()) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
lcd_.disableHdma(cc);
}
return cc;
}
void Memory::freeze(unsigned long cc) {
// permanently halt CPU.
// simply halt and clear IE to avoid unhalt from occuring,
// which avoids additional state to represent a "frozen" state.
nontrivial_ff_write(0xFF, 0, cc);
ackDmaReq(intreq_);
intreq_.halt();
}
bool Memory::halt(unsigned long cc) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
haltHdmaState_ = lcd_.hdmaIsEnabled() && lcd_.isHdmaPeriod(cc)
? hdma_high : hdma_low;
bool const hdmaReq = hdmaReqFlagged(intreq_);
if (hdmaReq)
haltHdmaState_ = hdma_requested;
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc + 4);
ackDmaReq(intreq_);
intreq_.halt();
return hdmaReq;
}
unsigned Memory::pendingIrqs(unsigned long cc) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
updateIrqs(cc);
return intreq_.pendingIrqs();
}
void Memory::ackIrq(unsigned bit, unsigned long cc) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
// TODO: adjust/extend IRQ assertion time rather than use the odd cc offsets?
// NOTE: a minimum offset of 2 is required for the LCD due to implementation assumptions w.r.t. cc headroom.
updateSerial(cc + 3 + isCgb());
updateTimaIrq(cc + 2 + isCgb());
lcd_.update(cc + 2);
intreq_.ackIrq(bit);
}
unsigned long Memory::stop(unsigned long cc, bool &skip) {
// FIXME: this is incomplete.
intreq_.setEventTime<intevent_unhalt>(cc + 0x20000 + 4);
// speed change.
if (ioamhram_[0x14D] & isCgb()) {
tima_.speedChange(TimaInterruptRequester(intreq_));
// DIV reset.
nontrivial_ff_write(0x04, 0, cc);
haltHdmaState_ = lcd_.hdmaIsEnabled() && lcd_.isHdmaPeriod(cc)
? hdma_high : hdma_low;
skip = hdmaReqFlagged(intreq_);
if (skip && isDoubleSpeed())
haltHdmaState_ = hdma_requested;
unsigned long const cc_ = cc + 8 * !isDoubleSpeed();
if (cc_ >= cc + 4) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc + 4);
if (!skip || isDoubleSpeed())
ackDmaReq(intreq_);
intreq_.halt();
}
psg_.speedChange(cc_, isDoubleSpeed());
lcd_.speedChange(cc_);
cart_.speedChange(cc_);
ioamhram_[0x14D] ^= 0x81;
// TODO: perhaps make this a bit nicer?
intreq_.setEventTime<intevent_blit>(ioamhram_[0x140] & lcdc_en
? lcd_.nextMode1IrqTime()
: cc + (lcd_cycles_per_frame << isDoubleSpeed()));
if (intreq_.eventTime(intevent_end) > cc_) {
intreq_.setEventTime<intevent_end>(cc_
+ (isDoubleSpeed()
? (intreq_.eventTime(intevent_end) - cc_) * 2
: (intreq_.eventTime(intevent_end) - cc_) / 2));
}
if (cc_ < cc + 4) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc + 4);
if (!skip || !isDoubleSpeed())
ackDmaReq(intreq_);
intreq_.halt();
}
// ensure that no updates with a previous cc occur.
cc += 8;
}
else {
// FIXME: test and implement stop correctly.
skip = halt(cc);
cc += 4;
stopped_ = true;
intreq_.setEventTime<intevent_unhalt>(disabled_time);
}
return cc;
}
void Memory::decEventCycles(IntEventId eventId, unsigned long dec) {
if (intreq_.eventTime(eventId) != disabled_time)
intreq_.setEventTime(eventId, intreq_.eventTime(eventId) - dec);
}
unsigned long Memory::resetCounters(unsigned long cc) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
updateIrqs(cc);
unsigned long const dec = cc < 0x20000
? 0
: (cc & -0x10000l) - 0x10000;
decCycles(divLastUpdate_, dec);
decCycles(lastOamDmaUpdate_, dec);
decEventCycles(intevent_serial, dec);
decEventCycles(intevent_oam, dec);
decEventCycles(intevent_blit, dec);
decEventCycles(intevent_end, dec);
decEventCycles(intevent_unhalt, dec);
unsigned long const oldCC = cc;
cc -= dec;
intreq_.resetCc(oldCC, cc);
cart_.resetCc(oldCC, cc);
tima_.resetCc(oldCC, cc, TimaInterruptRequester(intreq_));
lcd_.resetCc(oldCC, cc);
psg_.resetCounter(cc, oldCC, isDoubleSpeed());
return cc;
}
void Memory::updateInput() {
unsigned state = 0xF;
if ((ioamhram_[0x100] & 0x30) != 0x30 && getInput_) {
unsigned input = (*getInput_)();
unsigned dpad_state = ~input >> 4;
unsigned button_state = ~input;
if (!(ioamhram_[0x100] & 0x10))
state &= dpad_state;
if (!(ioamhram_[0x100] & 0x20))
state &= button_state;
if (state != 0xF && (ioamhram_[0x100] & 0xF) == 0xF)
intreq_.flagIrq(0x10);
}
ioamhram_[0x100] = (ioamhram_[0x100] & -0x10u) | state;
}
void Memory::updateOamDma(unsigned long const cc) {
unsigned char const *const oamDmaSrc = oamDmaSrcPtr();
unsigned cycles = (cc - lastOamDmaUpdate_) >> 2;
if (halted()) {
lastOamDmaUpdate_ += 4 * cycles;
}
else while (cycles--) {
oamDmaPos_ = (oamDmaPos_ + 1) & 0xFF;
lastOamDmaUpdate_ += 4;
if (oamDmaPos_ == oamDmaStartPos_)
startOamDma(lastOamDmaUpdate_);
if (oamDmaPos_ < oam_size) {
ioamhram_[oamDmaPos_] = ((oamDmaSrc) ? oamDmaSrc[oamDmaPos_] : cart_.rtcRead());
}
else if (oamDmaPos_ == oam_size) {
endOamDma(lastOamDmaUpdate_);
if (oamDmaStartPos_ == 0) {
lastOamDmaUpdate_ = disabled_time;
break;
}
}
}
}
void Memory::oamDmaInitSetup() {
if (ioamhram_[0x146] < mm_sram_begin / 0x100) {
cart_.setOamDmaSrc(ioamhram_[0x146] < mm_vram_begin / 0x100 ? oam_dma_src_rom : oam_dma_src_vram);
}
else if (ioamhram_[0x146] < 0x100 - isCgb() * 0x20) {
cart_.setOamDmaSrc(ioamhram_[0x146] < mm_wram_begin / 0x100 ? oam_dma_src_sram : oam_dma_src_wram);
}
else
cart_.setOamDmaSrc(oam_dma_src_invalid);
}
unsigned char const* Memory::oamDmaSrcPtr() const {
switch (cart_.oamDmaSrc()) {
case oam_dma_src_rom:
return cart_.romdata(ioamhram_[0x146] >> 6) + ioamhram_[0x146] * 0x100l;
case oam_dma_src_sram:
return cart_.rsrambankptr() ? cart_.rsrambankptr() + ioamhram_[0x146] * 0x100l : 0;
case oam_dma_src_vram:
return cart_.vrambankptr() + ioamhram_[0x146] * 0x100l;
case oam_dma_src_wram:
return cart_.wramdata(ioamhram_[0x146] >> 4 & 1) + (ioamhram_[0x146] * 0x100l & 0xFFF);
case oam_dma_src_invalid:
case oam_dma_src_off:
break;
}
return cart_.rdisabledRam();
}
void Memory::startOamDma(unsigned long cc) {
oamDmaPos_ = 0;
oamDmaStartPos_ = 0;
lcd_.oamChange(cart_.rdisabledRam(), cc);
}
void Memory::endOamDma(unsigned long cc) {
if (oamDmaStartPos_ == 0) {
oamDmaPos_ = -2u & 0xFF;
cart_.setOamDmaSrc(oam_dma_src_off);
}
lcd_.oamChange(ioamhram_, cc);
}
unsigned Memory::nontrivial_ff_read(unsigned const p, unsigned long const cc) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
switch (p) {
case 0x00:
updateInput();
break;
case 0x01:
case 0x02:
updateSerial(cc);
break;
case 0x04:
return (cc - tima_.divLastUpdate()) >> 8 & 0xFF;
case 0x05:
ioamhram_[0x105] = tima_.tima(cc);
break;
case 0x0F:
updateIrqs(cc);
ioamhram_[0x10F] = intreq_.ifreg();
break;
case 0x26:
if (ioamhram_[0x126] & 0x80) {
psg_.generateSamples(cc, isDoubleSpeed());
ioamhram_[0x126] = 0xF0 | psg_.getStatus();
} else
ioamhram_[0x126] = 0x70;
break;
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
psg_.generateSamples(cc, isDoubleSpeed());
return psg_.waveRamRead(p & 0xF);
case 0x41:
return ioamhram_[0x141] | lcd_.getStat(ioamhram_[0x145], cc);
case 0x44:
return lcd_.getLyReg(cc);
case 0x69:
return lcd_.cgbBgColorRead(ioamhram_[0x168] & 0x3F, cc);
case 0x6B:
return lcd_.cgbSpColorRead(ioamhram_[0x16A] & 0x3F, cc);
default:
break;
}
return ioamhram_[p + 0x100];
}
unsigned Memory::nontrivial_read(unsigned const p, unsigned long const cc) {
if (p < mm_hram_begin) {
if (lastOamDmaUpdate_ != disabled_time) {
updateOamDma(cc);
if (cart_.isInOamDmaConflictArea(p) && oamDmaPos_ < oam_size) {
int const r = isCgb() && cart_.oamDmaSrc() != oam_dma_src_wram && p >= mm_wram_begin
? cart_.wramdata(ioamhram_[0x146] >> 4 & 1)[p & 0xFFF]
: ioamhram_[oamDmaPos_];
if (isCgb() && cart_.oamDmaSrc() == oam_dma_src_vram)
ioamhram_[oamDmaPos_] = 0;
return r;
}
}
if (p < mm_wram_begin) {
if (p < mm_vram_begin)
return cart_.romdata(p >> 14)[p];
if (p < mm_sram_begin) {
if (!lcd_.vramReadable(cc))
return 0xFF;
return cart_.vrambankptr()[p];
}
if (cart_.rsrambankptr())
return cart_.rsrambankptr()[p];
return cart_.rtcRead();
}
if (p < mm_oam_begin)
return cart_.wramdata(p >> 12 & 1)[p & 0xFFF];
long const ffp = static_cast<long>(p) - mm_io_begin;
if (ffp >= 0)
return nontrivial_ff_read(ffp, cc);
if (!lcd_.oamReadable(cc) || oamDmaPos_ < oam_size)
return 0xFF;
}
return ioamhram_[p - mm_oam_begin];
}
unsigned Memory::nontrivial_peek(unsigned const p) {
if (p < 0xC000) {
if (p < 0x8000)
return cart_.romdata(p >> 14)[p];
if (p < 0xA000) {
return cart_.vrambankptr()[p];
}
if (cart_.rsrambankptr())
return cart_.rsrambankptr()[p];
return cart_.rtcRead(); // verified side-effect free
}
if (p < 0xFE00)
return cart_.wramdata(p >> 12 & 1)[p & 0xFFF];
if (p >= 0xFF00 && p < 0xFF80)
return nontrivial_ff_peek(p);
return ioamhram_[p - 0xFE00];
}
unsigned Memory::nontrivial_ff_peek(unsigned const p) {
// some regs may be somewhat wrong with this
return ioamhram_[p - 0xFE00];
}
void Memory::nontrivial_ff_write(unsigned const p, unsigned data, unsigned long const cc) {
if (lastOamDmaUpdate_ != disabled_time)
updateOamDma(cc);
switch (p & 0xFF) {
case 0x00:
if ((data ^ ioamhram_[0x100]) & 0x30) {
ioamhram_[0x100] = (ioamhram_[0x100] & ~0x30u) | (data & 0x30);
updateInput();
}
return;
case 0x01:
updateSerial(cc);
break;
case 0x02:
updateSerial(cc);
serialCnt_ = 8;
if ((data & 0x81) == 0x81) {
intreq_.setEventTime<intevent_serial>(data & isCgb() * 2
? cc - (cc - tima_.divLastUpdate()) % 8 + 0x10 * serialCnt_
: cc - (cc - tima_.divLastUpdate()) % 0x100 + 0x200 * serialCnt_);
} else
intreq_.setEventTime<intevent_serial>(disabled_time);
data |= 0x7E - isCgb() * 2;
break;
case 0x04:
if (intreq_.eventTime(intevent_serial) != disabled_time
&& intreq_.eventTime(intevent_serial) > cc) {
unsigned long const t = intreq_.eventTime(intevent_serial);
unsigned long const n = ioamhram_[0x102] & isCgb() * 2
? t + (cc - t) % 8 - 2 * ((cc - t) & 4)
: t + (cc - t) % 0x100 - 2 * ((cc - t) & 0x80);
intreq_.setEventTime<intevent_serial>(std::max(cc, n));
}
psg_.generateSamples(cc, isDoubleSpeed());
psg_.divReset(isDoubleSpeed());
tima_.divReset(cc, TimaInterruptRequester(intreq_));
return;
case 0x05:
tima_.setTima(data, cc, TimaInterruptRequester(intreq_));
break;
case 0x06:
tima_.setTma(data, cc, TimaInterruptRequester(intreq_));
break;
case 0x07:
data |= 0xF8;
tima_.setTac(data, cc, TimaInterruptRequester(intreq_), agbMode_);
break;
case 0x0F:
updateIrqs(cc + 1 + isDoubleSpeed());
intreq_.setIfreg(0xE0 | data);
return;
case 0x10:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr10(data);
data |= 0x80;
break;
case 0x11:
if (!psg_.isEnabled()) {
if (isCgb())
return;
data &= 0x3F;
}
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr11(data);
data |= 0x3F;
break;
case 0x12:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr12(data);
break;
case 0x13:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr13(data);
return;
case 0x14:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr14(data, isDoubleSpeed());
data |= 0xBF;
break;
case 0x16:
if (!psg_.isEnabled()) {
if (isCgb())
return;
data &= 0x3F;
}
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr21(data);
data |= 0x3F;
break;
case 0x17:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr22(data);
break;
case 0x18:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr23(data);
return;
case 0x19:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr24(data, isDoubleSpeed());
data |= 0xBF;
break;
case 0x1A:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr30(data);
data |= 0x7F;
break;
case 0x1B:
if (!psg_.isEnabled() && isCgb())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr31(data);
return;
case 0x1C:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr32(data);
data |= 0x9F;
break;
case 0x1D:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr33(data);
return;
case 0x1E:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr34(data);
data |= 0xBF;
break;
case 0x20:
if (!psg_.isEnabled() && isCgb())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr41(data);
return;
case 0x21:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr42(data);
break;
case 0x22:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr43(data);
break;
case 0x23:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setNr44(data);
data |= 0xBF;
break;
case 0x24:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.setSoVolume(data);
break;
case 0x25:
if (!psg_.isEnabled())
return;
psg_.generateSamples(cc, isDoubleSpeed());
psg_.mapSo(data);
break;
case 0x26:
if ((ioamhram_[0x126] ^ data) & 0x80) {
psg_.generateSamples(cc, isDoubleSpeed());
if (!(data & 0x80)) {
for (unsigned i = 0x10; i < 0x26; ++i)
ff_write(i, 0, cc);
psg_.setEnabled(false);
}
else {
psg_.reset(isDoubleSpeed());
psg_.setEnabled(true);
}
}
data = (data & 0x80) | (ioamhram_[0x126] & 0x7F);
break;
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
psg_.generateSamples(cc, isDoubleSpeed());
psg_.waveRamWrite(p & 0xF, data);
break;
case 0x40:
if (ioamhram_[0x140] != data) {
if ((ioamhram_[0x140] ^ data) & lcdc_en) {
unsigned const stat = data & lcdc_en ? ioamhram_[0x141] : lcd_.getStat(ioamhram_[0x145], cc);
bool const hdmaEnabled = lcd_.hdmaIsEnabled();
lcd_.lcdcChange(data, cc);
ioamhram_[0x144] = 0;
ioamhram_[0x141] &= 0xF8;
if (data & lcdc_en) {
if (ioamhram_[0x141] & lcdstat_lycirqen && ioamhram_[0x145] == 0 && !(stat & lcdstat_lycflag))
intreq_.flagIrq(2);
intreq_.setEventTime<intevent_blit>(blanklcd_
? lcd_.nextMode1IrqTime()
: lcd_.nextMode1IrqTime() + (lcd_cycles_per_frame << isDoubleSpeed()));
}
else {
ioamhram_[0x141] |= stat & lcdstat_lycflag;
intreq_.setEventTime<intevent_blit>(
cc + (lcd_cycles_per_line * 4 << isDoubleSpeed()));
if (hdmaEnabled)
flagHdmaReq(intreq_);
}
}
else
lcd_.lcdcChange(data, cc);
ioamhram_[0x140] = data;
}
return;
case 0x41:
lcd_.lcdstatChange(data, cc);
if (!(ioamhram_[0x140] & lcdc_en) && (ioamhram_[0x141] & lcdstat_lycflag)
&& (~ioamhram_[0x141] & lcdstat_lycirqen & (isCgb() ? data : -1))) {
intreq_.flagIrq(2);
}
data = (ioamhram_[0x141] & 0x87) | (data & 0x78);
break;
case 0x42:
lcd_.scyChange(data, cc);
break;
case 0x43:
lcd_.scxChange(data, cc);
break;
case 0x45:
lcd_.lycRegChange(data, cc);
break;
case 0x46:
lastOamDmaUpdate_ = cc;
oamDmaStartPos_ = (oamDmaPos_ + 2) & 0xFF;
intreq_.setEventTime<intevent_oam>(std::min(intreq_.eventTime(intevent_oam), cc + 8));
ioamhram_[0x146] = data;
oamDmaInitSetup();
return;
case 0x47:
if (!isCgb() || isCgbDmg())
lcd_.dmgBgPaletteChange(data, cc);
break;
case 0x48:
if (!isCgb() || isCgbDmg())
lcd_.dmgSpPalette1Change(data, cc);
break;
case 0x49:
if (!isCgb() || isCgbDmg())
lcd_.dmgSpPalette2Change(data, cc);
break;
case 0x4A:
lcd_.wyChange(data, cc);
break;
case 0x4B:
lcd_.wxChange(data, cc);
break;
case 0x4C:
if (!biosMode_)
return;
break;
case 0x4D:
if (isCgb() && !isCgbDmg())
ioamhram_[0x14D] = (ioamhram_[0x14D] & ~1u) | (data & 1);
return;
case 0x4F:
if (isCgb() && !isCgbDmg()) {
cart_.setVrambank(data & 1);
ioamhram_[0x14F] = 0xFE | data;
}
return;
case 0x50:
if (!biosMode_)
return;
if (isCgb() && (ioamhram_[0x14C] & 0x04)) {
lcd_.copyCgbPalettesToDmg();
lcd_.setCgbDmg(true);
}
biosMode_ = false;
return;
case 0x51:
dmaSource_ = data << 8 | (dmaSource_ & 0xFF);
return;
case 0x52:
dmaSource_ = (dmaSource_ & 0xFF00) | (data & 0xF0);
return;
case 0x53:
dmaDestination_ = data << 8 | (dmaDestination_ & 0xFF);
return;
case 0x54:
dmaDestination_ = (dmaDestination_ & 0xFF00) | (data & 0xF0);
return;
case 0x55:
if (isCgb()) {
ioamhram_[0x155] = data & 0x7F;
if (lcd_.hdmaIsEnabled()) {
if (!(data & 0x80)) {
ioamhram_[0x155] |= 0x80;
lcd_.disableHdma(cc);
}
} else {
if (data & 0x80) {
if (ioamhram_[0x140] & lcdc_en) {
lcd_.enableHdma(cc);
} else
flagHdmaReq(intreq_);
} else
flagGdmaReq(intreq_);
}
}
return;
case 0x56:
if (isCgb())
ioamhram_[0x156] = data | 0x3E;
return;
case 0x68:
if (isCgb())
ioamhram_[0x168] = data | 0x40;
return;
case 0x69:
if (isCgb()) {
unsigned index = ioamhram_[0x168] & 0x3F;
lcd_.cgbBgColorChange(index, data, cc);
ioamhram_[0x168] = (ioamhram_[0x168] & ~0x3Fu)
| ((index + (ioamhram_[0x168] >> 7)) & 0x3F);
}
return;
case 0x6A:
if (isCgb())
ioamhram_[0x16A] = data | 0x40;
return;
case 0x6B:
if (isCgb()) {
unsigned index = ioamhram_[0x16A] & 0x3F;
lcd_.cgbSpColorChange(index, data, cc);
ioamhram_[0x16A] = (ioamhram_[0x16A] & ~0x3Fu)
| ((index + (ioamhram_[0x16A] >> 7)) & 0x3F);
}
return;
case 0x6C:
if (isCgb())
ioamhram_[0x16C] = data | 0xFE;
return;
case 0x70:
if (isCgb() && !isCgbDmg()) {
cart_.setWrambank(data & 0x07 ? data & 0x07 : 1);
ioamhram_[0x170] = data | 0xF8;
}
return;
case 0x72:
case 0x73:
case 0x74:
if (isCgb())
break;
return;
case 0x75:
if (isCgb())
ioamhram_[0x175] = data | 0x8F;
return;
case 0xFF:
intreq_.setIereg(data);
break;
default:
return;
}
ioamhram_[p + 0x100] = data;
}
void Memory::nontrivial_write(unsigned const p, unsigned const data, unsigned long const cc) {
if (lastOamDmaUpdate_ != disabled_time) {
updateOamDma(cc);
if (cart_.isInOamDmaConflictArea(p) && oamDmaPos_ < oam_size) {
if (isCgb()) {
if (p < mm_wram_begin)
ioamhram_[oamDmaPos_] = cart_.oamDmaSrc() != oam_dma_src_vram ? data : 0;
else if (cart_.oamDmaSrc() != oam_dma_src_wram)
cart_.wramdata(ioamhram_[0x146] >> 4 & 1)[p & 0xFFF] = data;
}
else {
ioamhram_[oamDmaPos_] = cart_.oamDmaSrc() == oam_dma_src_wram
? ioamhram_[oamDmaPos_] & data
: data;
}
return;
}
}
if (p < mm_oam_begin) {
if (p < mm_sram_begin) {
if (p < mm_vram_begin) {
cart_.mbcWrite(p, data, cc);
}
else if (lcd_.vramWritable(cc)) {
lcd_.vramChange(cc);
cart_.vrambankptr()[p] = data;
}
}
else if (p < mm_wram_begin) {
if (cart_.wsrambankptr())
cart_.wsrambankptr()[p] = data;
else
cart_.rtcWrite(data, cc);
}
else
cart_.wramdata(p >> 12 & 1)[p & 0xFFF] = data;
}
else if (p - mm_hram_begin >= 0x7Fu) {
long const ffp = static_cast<long>(p) - mm_io_begin;
if (ffp < 0) {
if (lcd_.oamWritable(cc) && oamDmaPos_ >= oam_size
&& (p < mm_oam_begin + oam_size || isCgb())) {
lcd_.oamChange(cc);
ioamhram_[p - mm_oam_begin] = data;
}
}
else
nontrivial_ff_write(ffp, data, cc);
}
else
ioamhram_[p - mm_oam_begin] = data;
}
LoadRes Memory::loadROM(char const *romfiledata, unsigned romfilelength, unsigned const flags) {
bool const forceDmg = flags & GB::LoadFlag::FORCE_DMG;
bool const multicartCompat = flags & GB::LoadFlag::MULTICART_COMPAT;
if (LoadRes const fail = cart_.loadROM(romfiledata, romfilelength, forceDmg, multicartCompat))
return fail;
psg_.init(cart_.isCgb());
lcd_.reset(ioamhram_, cart_.vramdata(), cart_.isCgb());
agbMode_ = flags & GB::LoadFlag::GBA_CGB;
return LOADRES_OK;
}
std::size_t Memory::fillSoundBuffer(unsigned long cc) {
psg_.generateSamples(cc, isDoubleSpeed());
return psg_.fillBuffer();
}
void Memory::setCgbPalette(unsigned *lut) {
lcd_.setCgbPalette(lut);
}
bool Memory::getMemoryArea(int which, unsigned char **data, int *length) {
if (!data || !length)
return false;
switch (which)
{
case 4: // oam
*data = &ioamhram_[0];
*length = 160;
return true;
case 5: // hram
*data = &ioamhram_[384];
*length = 128;
return true;
case 6: // bgpal
*data = (unsigned char *)lcd_.bgPalette();
*length = 32;
return true;
case 7: // sppal
*data = (unsigned char *)lcd_.spPalette();
*length = 32;
return true;
default: // pass to cartridge
return cart_.getMemoryArea(which, data, length);
}
}
int Memory::linkStatus(int which)
{
switch (which)
{
case 256: // ClockSignaled
return linkClockTrigger_;
case 257: // AckClockSignal
linkClockTrigger_ = false;
return 0;
case 258: // GetOut
return ioamhram_[0x101] & 0xff;
case 259: // connect link cable
LINKCABLE_ = true;
return 0;
default: // ShiftIn
if (ioamhram_[0x102] & 0x80) // was enabled
{
ioamhram_[0x101] = which;
ioamhram_[0x102] &= 0x7F;
intreq_.flagIrq(8);
}
return 0;
}
return -1;
}
SYNCFUNC(Memory)
{
SSS(cart_);
NSS(ioamhram_);
NSS(divLastUpdate_);
NSS(lastOamDmaUpdate_);
SSS(intreq_);
SSS(tima_);
SSS(lcd_);
SSS(psg_);
NSS(dmaSource_);
NSS(dmaDestination_);
NSS(oamDmaPos_);
NSS(serialCnt_);
NSS(blanklcd_);
NSS(biosMode_);
NSS(stopped_);
NSS(LINKCABLE_);
NSS(linkClockTrigger_);
}
| 24.17388 | 109 | 0.675001 | Gorialis |
3b26ff012400f88317639b9e2c1da2dba5c24d62 | 1,931 | cpp | C++ | euler/tasks/11/main.cpp | pg83/zm | ef9027bd9ee260118fdf80e8b53361da1b7892f3 | [
"MIT"
] | null | null | null | euler/tasks/11/main.cpp | pg83/zm | ef9027bd9ee260118fdf80e8b53361da1b7892f3 | [
"MIT"
] | null | null | null | euler/tasks/11/main.cpp | pg83/zm | ef9027bd9ee260118fdf80e8b53361da1b7892f3 | [
"MIT"
] | null | null | null | #include <euler/lib/euler.h>
static const unsigned data[] = {
#include "data.h"
};
static unsigned xy(size_t x, size_t y) noexcept {
return data[x + y * 20];
}
int main() {
unsigned max = 0;
for (size_t i = 0; i <= 16; ++i) {
for (size_t j = 0; j <= 16; ++j) {
const auto a1 = xy(i, j);
const auto a2 = xy(i + 1, j);
const auto a3 = xy(i + 2, j);
const auto a4 = xy(i + 3, j);
const auto b1 = xy(i, j);
const auto b2 = xy(i, j + 1);
const auto b3 = xy(i, j + 2);
const auto b4 = xy(i, j + 3);
const auto c1 = xy(i, j);
const auto c2 = xy(i + 1, j + 1);
const auto c3 = xy(i + 2, j + 2);
const auto c4 = xy(i + 3, j + 3);
const auto d1 = xy(i + 3, j);
const auto d2 = xy(i + 2, j + 1);
const auto d3 = xy(i + 1, j + 2);
const auto d4 = xy(i, j + 3);
const auto v1 = a1 * a2 * a3 * a4;
const auto v2 = b1 * b2 * b3 * b4;
const auto v3 = c1 * c2 * c3 * c4;
const auto v4 = d1 * d2 * d3 * d4;
if (v1 > max) {
max = v1;
std::cout << i << " " << j << " " << a1 << " " << a2 << " " << a3 << " " << a4 << std::endl;
}
if (v2 > max) {
max = v2;
std::cout << i << " " << j << " " << b1 << " " << b2 << " " << b3 << " " << b4 << std::endl;
}
if (v3 > max) {
max = v3;
std::cout << i << " " << j << " " << c1 << " " << c2 << " " << c3 << " " << c4 << std::endl;
}
if (v4 > max) {
max = v4;
std::cout << i << " " << j << " " << d1 << " " << d2 << " " << d3 << " " << d4 << std::endl;
}
}
}
std::cout << max << std::endl;
}
| 29.707692 | 109 | 0.337649 | pg83 |
3b2abbdc675cc379208cf0ac240f906852675bfe | 1,713 | cpp | C++ | third_party/libigl/include/igl/orient_halfedges.cpp | chefmramos85/monster-mash | 239a41f6f178ca83c4be638331e32f23606b0381 | [
"Apache-2.0"
] | 1,125 | 2021-02-01T09:51:56.000Z | 2022-03-31T01:50:40.000Z | third_party/libigl/include/igl/orient_halfedges.cpp | ryan-cranfill/monster-mash | c1b906d996885f8a4011bdf7558e62e968e1e914 | [
"Apache-2.0"
] | 19 | 2021-02-01T12:36:30.000Z | 2022-03-19T14:02:50.000Z | third_party/libigl/include/igl/orient_halfedges.cpp | ryan-cranfill/monster-mash | c1b906d996885f8a4011bdf7558e62e968e1e914 | [
"Apache-2.0"
] | 148 | 2021-02-13T10:54:31.000Z | 2022-03-28T11:55:20.000Z | // This file is part of libigl, a simple c++ geometry processing library.
//
// Copyright (C) 2020 Oded Stein <oded.stein@columbia.edu>
//
// 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 http://mozilla.org/MPL/2.0/.
#include "orient_halfedges.h"
#include "oriented_facets.h"
#include "unique_simplices.h"
template <typename DerivedF, typename DerivedE, typename DerivedOE>
IGL_INLINE void
igl::orient_halfedges(
const Eigen::MatrixBase<DerivedF>& F,
Eigen::PlainObjectBase<DerivedE>& E,
Eigen::PlainObjectBase<DerivedOE>& oE)
{
assert(F.cols()==3 && "This only works for triangle meshes.");
using Int = typename DerivedF::Scalar;
const Eigen::Index m = F.rows();
DerivedE allE, EE;
oriented_facets(F, allE);
Eigen::Matrix<Int, Eigen::Dynamic, 1> IA, IC;
unique_simplices(allE, EE, IA, IC);
E.resize(m, 3);
oE.resize(m, 3);
for(Eigen::Index f=0; f<m; ++f) {
for(int e=0; e<3; ++e) {
const Int ind = f + m*e;
E(f,e) = IC(ind);
assert((EE(E(f,e),0)==allE(ind,0) || EE(E(f,e),0)==allE(ind,1)) &&
"Something is wrong in the edge matrix.");
oE(f,e) = EE(E(f,e),0)==allE(ind,0) ? 1 : -1;
}
}
}
#ifdef IGL_STATIC_LIBRARY
// Explicit template instantiation
template void igl::orient_halfedges<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
#endif
| 34.959184 | 350 | 0.638646 | chefmramos85 |
3b2d2515bc65e7317ef6348de67ea288b25eade0 | 1,082 | cpp | C++ | sandbox/ardupilot/libraries/AP_HAL_AVR_SITL/utility/print_vprintf.cpp | prabhu-dev/LineDetectorLengthFix | 2450bae17eb8bfbf0e3b942d765c5c4954715bde | [
"MIT"
] | null | null | null | sandbox/ardupilot/libraries/AP_HAL_AVR_SITL/utility/print_vprintf.cpp | prabhu-dev/LineDetectorLengthFix | 2450bae17eb8bfbf0e3b942d765c5c4954715bde | [
"MIT"
] | null | null | null | sandbox/ardupilot/libraries/AP_HAL_AVR_SITL/utility/print_vprintf.cpp | prabhu-dev/LineDetectorLengthFix | 2450bae17eb8bfbf0e3b942d765c5c4954715bde | [
"MIT"
] | null | null | null | // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
/*
* vprintf for SITL
*
* This firmware 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.
*/
#include <AP_HAL.h>
#if CONFIG_HAL_BOARD == HAL_BOARD_AVR_SITL
#include <AP_Progmem.h>
#include <stdarg.h>
#include <string.h>
#include "print_vprintf.h"
#include <stdio.h>
#include <stdlib.h>
void print_vprintf(AP_HAL::Print *s, unsigned char in_progmem, const char *fmt, va_list ap)
{
char *str = NULL;
int i;
char *fmt2 = strdup(fmt);
for (i=0; fmt2[i]; i++) {
// cope with %S
if (fmt2[i] == '%' && fmt2[i+1] == 'S') {
fmt2[i+1] = 's';
}
}
(void)vasprintf(&str, fmt2, ap);
for (i=0; str[i]; i++) {
s->write(str[i]);
}
free(str);
free(fmt2);
}
#endif
| 27.05 | 91 | 0.554529 | prabhu-dev |
3b2e518527a3f0b45f97e73a0bea9f5f94ce10d0 | 944 | cpp | C++ | Chapter01/unique_ptr_3/unique_ptr_3.cpp | Vaibhav-Kashyap/-Learning-CPP-Functional-Programming-packt | 3c7ef5fcfb161870b644595c69fdb3a3522d8411 | [
"MIT"
] | 41 | 2017-08-25T07:13:57.000Z | 2022-01-06T12:28:33.000Z | Chapter01/unique_ptr_3/unique_ptr_3.cpp | Vaibhav-Kashyap/-Learning-CPP-Functional-Programming-packt | 3c7ef5fcfb161870b644595c69fdb3a3522d8411 | [
"MIT"
] | null | null | null | Chapter01/unique_ptr_3/unique_ptr_3.cpp | Vaibhav-Kashyap/-Learning-CPP-Functional-Programming-packt | 3c7ef5fcfb161870b644595c69fdb3a3522d8411 | [
"MIT"
] | 26 | 2017-08-10T21:12:25.000Z | 2021-11-17T07:25:04.000Z | /* unique_ptr_3.cpp */
#include <memory>
#include <iostream>
using namespace std;
struct BodyMass
{
int Id;
float Weight;
BodyMass(int id, float weight) :
Id(id),
Weight(weight)
{
cout << "BodyMass is constructed!" << endl;
cout << "Id = " << Id << endl;
cout << "Weight = " << Weight << endl;
}
~BodyMass()
{
cout << "BodyMass is destructed!" << endl;
}
};
unique_ptr<BodyMass> GetBodyMass()
{
return make_unique<BodyMass>(1, 165.3f);
}
unique_ptr<BodyMass> UpdateBodyMass(
unique_ptr<BodyMass> bodyMass)
{
bodyMass->Weight += 1.0f;
return bodyMass;
}
auto main() -> int
{
cout << "[unique_ptr_3.cpp]" << endl;
auto myWeight = GetBodyMass();
cout << "Current weight = " << myWeight->Weight << endl;
myWeight = UpdateBodyMass(move(myWeight));
cout << "Updated weight = " << myWeight->Weight << endl;
return 0;
}
| 17.811321 | 60 | 0.576271 | Vaibhav-Kashyap |
3b2ee455cae2e0886c62e163dada2132d3255fc6 | 11,549 | cc | C++ | src/Publisher_TEST.cc | amtj/ign-transport | 3b386bf46efd2fc0b847aa7fd3911b1d9d27546c | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | src/Publisher_TEST.cc | amtj/ign-transport | 3b386bf46efd2fc0b847aa7fd3911b1d9d27546c | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | src/Publisher_TEST.cc | amtj/ign-transport | 3b386bf46efd2fc0b847aa7fd3911b1d9d27546c | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | /*
* Copyright (C) 2015 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 <string>
#include "ignition/transport/AdvertiseOptions.hh"
#include "ignition/transport/Publisher.hh"
#include "gtest/gtest.h"
using namespace ignition;
using namespace transport;
// Global constants.
static const std::string Topic = "/topic";
static const std::string Addr = "tcp://myAddress";
static const std::string PUuid = "processUUID";
static const std::string NUuid = "nodeUUID";
static const Scope_t Scope = Scope_t::ALL;
static const std::string Ctrl = "controlAddress";
static const std::string SocketId = "socketId";
static const std::string MsgTypeName = "MessageType";
static const std::string ReqTypeName = "RequestType";
static const std::string RepTypeName = "ResponseType";
static const std::string NewTopic = "/newTopic";
static const std::string NewAddr = "tcp://anotherAddress";
static const std::string NewPUuid = "processUUID2";
static const std::string NewNUuid = "nodeUUID2";
static const Scope_t NewScope = Scope_t::HOST;
static const std::string NewCtrl = "controlAddress2";
static const std::string NewSocketId = "socketId2";
static const std::string NewMsgTypeName = "MessageType2";
static const std::string NewReqTypeName = "RequestType2";
static const std::string NewRepTypeName = "ResponseType2";
//////////////////////////////////////////////////
/// \brief Check the Publisher accessors.
TEST(PublisherTest, Publisher)
{
Publisher publisher(Topic, Addr, PUuid, NUuid, Scope);
EXPECT_EQ(publisher.Topic(), Topic);
EXPECT_EQ(publisher.Addr(), Addr);
EXPECT_EQ(publisher.PUuid(), PUuid);
EXPECT_EQ(publisher.NUuid(), NUuid);
EXPECT_EQ(publisher.Scope(), Scope);
size_t msgLength = sizeof(uint16_t) + publisher.Topic().size() +
sizeof(uint16_t) + publisher.Addr().size() +
sizeof(uint16_t) + publisher.PUuid().size() +
sizeof(uint16_t) + publisher.NUuid().size() +
sizeof(uint8_t);
EXPECT_EQ(publisher.MsgLength(), msgLength);
Publisher pub2(publisher);
EXPECT_TRUE(publisher == pub2);
EXPECT_FALSE(publisher != pub2);
msgLength = sizeof(uint16_t) + pub2.Topic().size() +
sizeof(uint16_t) + pub2.Addr().size() +
sizeof(uint16_t) + pub2.PUuid().size() +
sizeof(uint16_t) + pub2.NUuid().size() +
sizeof(uint8_t);
EXPECT_EQ(pub2.MsgLength(), msgLength);
// Modify the publisher's member variables.
publisher.SetTopic(NewTopic);
publisher.SetAddr(NewAddr);
publisher.SetPUuid(NewPUuid);
publisher.SetNUuid(NewNUuid);
publisher.SetScope(NewScope);
EXPECT_EQ(publisher.Topic(), NewTopic);
EXPECT_EQ(publisher.Addr(), NewAddr);
EXPECT_EQ(publisher.PUuid(), NewPUuid);
EXPECT_EQ(publisher.NUuid(), NewNUuid);
EXPECT_EQ(publisher.Scope(), NewScope);
msgLength = sizeof(uint16_t) + publisher.Topic().size() +
sizeof(uint16_t) + publisher.Addr().size() +
sizeof(uint16_t) + publisher.PUuid().size() +
sizeof(uint16_t) + publisher.NUuid().size() +
sizeof(uint8_t);
EXPECT_EQ(publisher.MsgLength(), msgLength);
}
//////////////////////////////////////////////////
/// \brief Check the Publisher Pack()/Unpack().
TEST(PublisherTest, PublisherIO)
{
// Try to pack an empty publisher.
Publisher emptyPublisher;
std::vector<char> buffer(emptyPublisher.MsgLength());
EXPECT_EQ(emptyPublisher.Pack(&buffer[0]), 0u);
// Pack a Publisher.
Publisher publisher(Topic, Addr, PUuid, NUuid, Scope);
buffer.resize(publisher.MsgLength());
size_t bytes = publisher.Pack(&buffer[0]);
EXPECT_EQ(bytes, publisher.MsgLength());
// Unpack the Publisher.
Publisher otherPublisher;
otherPublisher.Unpack(&buffer[0]);
// Check that after Pack() and Unpack() the Publisher remains the same.
EXPECT_EQ(publisher.Topic(), otherPublisher.Topic());
EXPECT_EQ(publisher.Addr(), otherPublisher.Addr());
EXPECT_EQ(publisher.PUuid(), otherPublisher.PUuid());
EXPECT_EQ(publisher.NUuid(), otherPublisher.NUuid());
EXPECT_EQ(publisher.Scope(), otherPublisher.Scope());
// Try to pack a header passing a NULL buffer.
EXPECT_EQ(otherPublisher.Pack(nullptr), 0u);
// Try to unpack a header passing a NULL buffer.
EXPECT_EQ(otherPublisher.Unpack(nullptr), 0u);
}
//////////////////////////////////////////////////
/// \brief Check the MessagePublisher accessors.
TEST(PublisherTest, MessagePublisher)
{
MessagePublisher publisher(Topic, Addr, Ctrl, PUuid, NUuid, Scope,
MsgTypeName);
EXPECT_EQ(publisher.Topic(), Topic);
EXPECT_EQ(publisher.Addr(), Addr);
EXPECT_EQ(publisher.Ctrl(), Ctrl);
EXPECT_EQ(publisher.PUuid(), PUuid);
EXPECT_EQ(publisher.NUuid(), NUuid);
EXPECT_EQ(publisher.Scope(), Scope);
EXPECT_EQ(publisher.MsgTypeName(), MsgTypeName);
size_t msgLength = publisher.Publisher::MsgLength() +
sizeof(uint16_t) + publisher.Ctrl().size() +
sizeof(uint16_t) + publisher.MsgTypeName().size();
EXPECT_EQ(publisher.MsgLength(), msgLength);
MessagePublisher pub2(publisher);
EXPECT_TRUE(publisher == pub2);
EXPECT_FALSE(publisher != pub2);
msgLength = pub2.Publisher::MsgLength() +
sizeof(uint16_t) + pub2.Ctrl().size() +
sizeof(uint16_t) + pub2.MsgTypeName().size();
EXPECT_EQ(pub2.MsgLength(), msgLength);
// Modify the publisher's member variables.
publisher.SetTopic(NewTopic);
publisher.SetAddr(NewAddr);
publisher.SetCtrl(NewCtrl);
publisher.SetPUuid(NewPUuid);
publisher.SetNUuid(NewNUuid);
publisher.SetScope(NewScope);
publisher.SetMsgTypeName(NewMsgTypeName);
EXPECT_EQ(publisher.Topic(), NewTopic);
EXPECT_EQ(publisher.Addr(), NewAddr);
EXPECT_EQ(publisher.Ctrl(), NewCtrl);
EXPECT_EQ(publisher.PUuid(), NewPUuid);
EXPECT_EQ(publisher.NUuid(), NewNUuid);
EXPECT_EQ(publisher.Scope(), NewScope);
EXPECT_EQ(publisher.MsgTypeName(), NewMsgTypeName);
msgLength = publisher.Publisher::MsgLength() +
sizeof(uint16_t) + publisher.Ctrl().size() +
sizeof(uint16_t) + publisher.MsgTypeName().size();
EXPECT_EQ(publisher.MsgLength(), msgLength);
}
//////////////////////////////////////////////////
/// \brief Check the MessagePublisher Pack()/Unpack().
TEST(PublisherTest, MessagePublisherIO)
{
// Try to pack an empty publisher.
MessagePublisher emptyPublisher;
std::vector<char> buffer(emptyPublisher.MsgLength());
EXPECT_EQ(emptyPublisher.Pack(&buffer[0]), 0u);
// Pack a Publisher.
MessagePublisher publisher(Topic, Addr, Ctrl, PUuid, NUuid, Scope,
MsgTypeName);
buffer.resize(publisher.MsgLength());
size_t bytes = publisher.Pack(&buffer[0]);
EXPECT_EQ(bytes, publisher.MsgLength());
// Unpack the Publisher.
MessagePublisher otherPublisher;
otherPublisher.Unpack(&buffer[0]);
// Check that after Pack() and Unpack() the Publisher remains the same.
EXPECT_EQ(publisher.Topic(), otherPublisher.Topic());
EXPECT_EQ(publisher.Addr(), otherPublisher.Addr());
EXPECT_EQ(publisher.Ctrl(), otherPublisher.Ctrl());
EXPECT_EQ(publisher.PUuid(), otherPublisher.PUuid());
EXPECT_EQ(publisher.NUuid(), otherPublisher.NUuid());
EXPECT_EQ(publisher.Scope(), otherPublisher.Scope());
EXPECT_EQ(publisher.MsgTypeName(), otherPublisher.MsgTypeName());
// Try to pack a header passing a NULL buffer.
EXPECT_EQ(otherPublisher.Pack(nullptr), 0u);
// Try to unpack a header passing a NULL buffer.
EXPECT_EQ(otherPublisher.Unpack(nullptr), 0u);
}
//////////////////////////////////////////////////
/// \brief Check the ServicePublisher accessors.
TEST(PublisherTest, ServicePublisher)
{
ServicePublisher publisher(Topic, Addr, SocketId, PUuid, NUuid, Scope,
ReqTypeName, RepTypeName);
EXPECT_EQ(publisher.Topic(), Topic);
EXPECT_EQ(publisher.Addr(), Addr);
EXPECT_EQ(publisher.SocketId(), SocketId);
EXPECT_EQ(publisher.PUuid(), PUuid);
EXPECT_EQ(publisher.NUuid(), NUuid);
EXPECT_EQ(publisher.Scope(), Scope);
EXPECT_EQ(publisher.ReqTypeName(), ReqTypeName);
EXPECT_EQ(publisher.RepTypeName(), RepTypeName);
size_t msgLength = publisher.Publisher::MsgLength() +
sizeof(uint16_t) + publisher.SocketId().size() +
sizeof(uint16_t) + publisher.ReqTypeName().size() +
sizeof(uint16_t) + publisher.RepTypeName().size();
EXPECT_EQ(publisher.MsgLength(), msgLength);
ServicePublisher pub2(publisher);
EXPECT_TRUE(publisher == pub2);
EXPECT_FALSE(publisher != pub2);
msgLength = pub2.Publisher::MsgLength() +
sizeof(uint16_t) + pub2.SocketId().size() +
sizeof(uint16_t) + pub2.ReqTypeName().size() +
sizeof(uint16_t) + pub2.RepTypeName().size();
EXPECT_EQ(pub2.MsgLength(), msgLength);
// Modify the publisher's member variables.
publisher.SetTopic(NewTopic);
publisher.SetAddr(NewAddr);
publisher.SetSocketId(NewSocketId);
publisher.SetPUuid(NewPUuid);
publisher.SetNUuid(NewNUuid);
publisher.SetScope(NewScope);
publisher.SetReqTypeName(NewReqTypeName);
publisher.SetRepTypeName(NewRepTypeName);
EXPECT_EQ(publisher.Topic(), NewTopic);
EXPECT_EQ(publisher.Addr(), NewAddr);
EXPECT_EQ(publisher.SocketId(), NewSocketId);
EXPECT_EQ(publisher.PUuid(), NewPUuid);
EXPECT_EQ(publisher.NUuid(), NewNUuid);
EXPECT_EQ(publisher.Scope(), NewScope);
EXPECT_EQ(publisher.ReqTypeName(), NewReqTypeName);
EXPECT_EQ(publisher.RepTypeName(), NewRepTypeName);
msgLength = publisher.Publisher::MsgLength() +
sizeof(uint16_t) + publisher.SocketId().size() +
sizeof(uint16_t) + publisher.ReqTypeName().size() +
sizeof(uint16_t) + publisher.RepTypeName().size();
EXPECT_EQ(publisher.MsgLength(), msgLength);
}
//////////////////////////////////////////////////
/// \brief Check the ServicePublisher Pack()/Unpack().
TEST(PublisherTest, ServicePublisherIO)
{
// Try to pack an empty publisher.
ServicePublisher emptyPublisher;
std::vector<char> buffer(emptyPublisher.MsgLength());
EXPECT_EQ(emptyPublisher.Pack(&buffer[0]), 0u);
// Pack a Publisher.
ServicePublisher publisher(Topic, Addr, SocketId, PUuid, NUuid, Scope,
ReqTypeName, RepTypeName);
buffer.resize(publisher.MsgLength());
size_t bytes = publisher.Pack(&buffer[0]);
EXPECT_EQ(bytes, publisher.MsgLength());
// Unpack the Publisher.
ServicePublisher otherPublisher;
otherPublisher.Unpack(&buffer[0]);
// Check that after Pack() and Unpack() the Publisher remains the same.
EXPECT_EQ(publisher.Topic(), otherPublisher.Topic());
EXPECT_EQ(publisher.Addr(), otherPublisher.Addr());
EXPECT_EQ(publisher.SocketId(), otherPublisher.SocketId());
EXPECT_EQ(publisher.PUuid(), otherPublisher.PUuid());
EXPECT_EQ(publisher.NUuid(), otherPublisher.NUuid());
EXPECT_EQ(publisher.Scope(), otherPublisher.Scope());
EXPECT_EQ(publisher.ReqTypeName(), otherPublisher.ReqTypeName());
EXPECT_EQ(publisher.RepTypeName(), otherPublisher.RepTypeName());
// Try to pack a header passing a NULL buffer.
EXPECT_EQ(otherPublisher.Pack(nullptr), 0u);
// Try to unpack a header passing a NULL buffer.
EXPECT_EQ(otherPublisher.Unpack(nullptr), 0u);
}
| 37.618893 | 75 | 0.707334 | amtj |
3b320c221eb4a7ead447225e0a7a17c50466a9ce | 8,123 | cpp | C++ | wbsTools/MatchStations/MatchStationView.cpp | RNCan/WeatherBasedSimulationFramework | 19df207d11b1dddf414d78e52bece77f31d45df8 | [
"MIT"
] | 6 | 2017-05-26T21:19:41.000Z | 2021-09-03T14:17:29.000Z | wbsTools/MatchStations/MatchStationView.cpp | RNCan/WeatherBasedSimulationFramework | 19df207d11b1dddf414d78e52bece77f31d45df8 | [
"MIT"
] | 5 | 2016-02-18T12:39:58.000Z | 2016-03-13T12:57:45.000Z | wbsTools/MatchStations/MatchStationView.cpp | RNCan/WeatherBasedSimulationFramework | 19df207d11b1dddf414d78e52bece77f31d45df8 | [
"MIT"
] | 1 | 2019-06-16T02:49:20.000Z | 2019-06-16T02:49:20.000Z |
// BioSIMView.cpp : implementation of the CDPTView class
//
#include "stdafx.h"
#include "MatchStationDoc.h"
#include "MatchStationView.h"
#include "resource.h"
#include "CommonRes.h"
//#include "StudiesDefinitionsDlg.h"
#include "MainFrm.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
using namespace UtilWin;
using namespace CFL;
using namespace std;
// CDPTView
IMPLEMENT_DYNCREATE(CDPTView, CView)
const int IDC_STATISTIC_ID = 1001;
const int IDC_VALIDITY_ID = 1002;
const int IDC_GRID_ID = 1003;
BEGIN_MESSAGE_MAP(CDPTView, CView)
ON_WM_CREATE()
ON_WM_SIZE()
ON_WM_WINDOWPOSCHANGED()
ON_CBN_SELCHANGE(IDC_STATISTIC_ID, OnStatisticChange )
ON_COMMAND_RANGE(ID_STUDIES_LIST, ID_MODE_EDIT, &CDPTView::OnCommandUI)
ON_UPDATE_COMMAND_UI_RANGE(ID_STUDIES_LIST, ID_MODE_EDIT, &CDPTView::OnUpdateUI)
ON_COMMAND(ID_EDIT_COPY, OnCopy)
ON_COMMAND(ID_EDIT_PASTE, OnPaste)
END_MESSAGE_MAP()
// CDPTView construction/destruction
CDPTView::CDPTView()
{
// m_bMustBeUpdated=false;
//m_bEnable=false;
}
CDPTView::~CDPTView()
{
}
BOOL CDPTView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
// CDPTView drawing
void CDPTView::OnDraw(CDC* pDC)
{
//CBioSIMDoc* pDoc = GetDocument();
//ASSERT_VALID(pDoc);
//if (!pDoc)
//return;
}
//void CDPTView::OnRButtonUp(UINT nFlags, CPoint point)
//{
// ClientToScreen(&point);
// OnContextMenu(this, point);
//}
//void CDPTView::OnContextMenu(CWnd* pWnd, CPoint point)
//{
//theApp.GetContextMenuManager()->ShowPopupMenu(IDR_POPUP_EDIT, point.x, point.y, this, TRUE);
//}
// CDPTView diagnostics
// CDPTView message handlers
//CBCGPGridCtrl* CDPTView::CreateGrid ()
CUGCtrl* CDPTView::CreateGrid ()
{
return (CUGCtrl*) new CResultCtrl();
}
int CDPTView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CView::OnCreate(lpCreateStruct) == -1)
return -1;
//m_font.CreateStockObject(DEFAULT_GUI_FONT);
//m_statisticCtrl.Create(WS_GROUP|WS_CHILD|WS_VISIBLE|WS_TABSTOP|WS_BORDER|CBS_DROPDOWNLIST , CRect(0,0,0,0), this, IDC_STATISTIC_ID );
//m_statisticCtrl.SetCurSel(MEAN);
//
//m_wndToolBar.Create(this, AFX_DEFAULT_TOOLBAR_STYLE|CBRS_SIZE_DYNAMIC, IDR_RESULT_TOOLBAR);
//m_wndToolBar.LoadToolBar(IDR_RESULT_TOOLBAR, 0, 0, TRUE /* Is locked */);
//m_wndToolBar.SetPaneStyle(m_wndToolBar.GetPaneStyle() | CBRS_TOOLTIPS | CBRS_FLYBY);
//m_wndToolBar.SetPaneStyle(m_wndToolBar.GetPaneStyle() & ~(CBRS_GRIPPER | CBRS_SIZE_DYNAMIC | CBRS_BORDER_TOP | CBRS_BORDER_BOTTOM | CBRS_BORDER_LEFT | CBRS_BORDER_RIGHT));
//m_wndToolBar.SetOwner(this);
//m_wndToolBar.SetRouteCommandsViaFrame(FALSE);
//
// CMatchStationDoc* pDoc = GetDocument();
m_grid.CreateGrid( WS_CHILD|WS_VISIBLE, CRect(0,0,0,0), this, IDC_GRID_ID );
AdjustLayout();
return 0;
}
void CDPTView::OnSize(UINT nType, int cx, int cy)
{
CView::OnSize(nType, cx, cy);
AdjustLayout();
}
void CDPTView::AdjustLayout()
{
if (GetSafeHwnd() == NULL || !IsWindow(GetSafeHwnd()))
{
return;
}
CRect rectClient;
GetClientRect(rectClient);
//int cxTlb = m_wndToolBar.CalcFixedLayout(FALSE, TRUE).cx+10;
//int cyTlb = m_wndToolBar.CalcFixedLayout(FALSE, TRUE).cy;
//m_wndToolBar.SetWindowPos(NULL, rectClient.left, rectClient.top, rectClient.Width(), cyTlb, SWP_NOACTIVATE | SWP_NOZORDER);
//m_statisticCtrl.SetWindowPos(NULL, rectClient.Width()-200, rectClient.top+2, 200, cyTlb, SWP_NOACTIVATE | SWP_NOZORDER);
//m_grid.SetWindowPos(NULL, rectClient.left, rectClient.top + cyTlb, rectClient.Width(), rectClient.Height() -(cyTlb), SWP_NOACTIVATE | SWP_NOZORDER);
m_grid.SetWindowPos(NULL, rectClient.left, rectClient.top, rectClient.Width(), rectClient.Height(), SWP_NOACTIVATE | SWP_NOZORDER);
}
void CDPTView::OnStatisticChange()
{
//m_grid.SetStatType( m_statisticCtrl.GetCurSel() );
}
void CDPTView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
{
//CMatchStationDoc* pDoc = (CMatchStationDoc*)GetDocument();
//CMainFrame* pMainFrm = (CMainFrame*)AfxGetMainWnd();
//if (lHint == CMatchStationDoc::INIT)
//{
//pMainFrm->SetDocument(pDoc);
//}
m_grid.OnUpdate(pSender, lHint, pHint);
//pMainFrm->OnUpdate(pSender, lHint, pHint);
}
//void CDPTView::UpdateResult()
//{
//}
void CDPTView::OnWindowPosChanged(WINDOWPOS* lpwndpos)
{
CView::OnWindowPosChanged(lpwndpos);
if( lpwndpos->flags & SWP_SHOWWINDOW )
{
//if( m_bMustBeUpdated )
//{
// //UpdateResult();
// //m_bMustBeUpdated=false;
//}
}
}
#ifdef _DEBUG
void CDPTView::AssertValid() const
{
CView::AssertValid();
}
void CDPTView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CMatchStationDoc* CDPTView::GetDocument() const // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMatchStationDoc)));
return (CMatchStationDoc*)m_pDocument;
}
#endif //_DEBUG
void CDPTView::OnCommandUI(UINT nID)
{
//CMatchStationDoc* pDocument = pDocument = GetDocument(); ASSERT(pDocument);
//CWeatherDatabasePtr& pProject = pDocument->m_pProject; ASSERT(pProject);
//
//if (nID == ID_STUDIES_LIST)
//{
// CStudiesDefinitionsDlg dlg(AfxGetMainWnd());
// dlg.m_studiesDefinitions = pProject->m_studiesDefinitions;
// dlg.m_properties = pProject->m_properties;
// if (dlg.DoModal() == IDOK)
// {
// if (pProject->m_studiesDefinitions != dlg.m_studiesDefinitions)
// {
// pProject->m_studiesDefinitions = dlg.m_studiesDefinitions;
//
// for (CStudiesDefinitions::iterator it = pProject->m_studiesDefinitions.begin(); it != pProject->m_studiesDefinitions.end(); it++)
// {
// CStudyData& data = pProject->m_studiesData[it->first];
// CStudyDefinition& study = it->second;
// if (data.size_y() != study.GetNbVials() || data.size_x() != study.m_fields.size())
// {
// data.resize(study.GetNbVials(), study.m_fields.size());
// }
// ASSERT(data.size_y() == study.GetNbVials() && data.size_x() == study.m_fields.size());
// }
// if (pProject->m_studiesDefinitions.find(pProject->m_properties.m_studyName) == pProject->m_studiesDefinitions.end())
// {
// //current study have chnaged name
// pProject->m_properties.m_studyName.clear();
// }
//
// //remove old data
//
// pDocument->UpdateAllViews(NULL, CMatchStationDoc::DEFINITION_CHANGE, NULL);
// }
//
// }
//}
////else if (nID == ID_SHOW_ALL || nID == ID_SHOW_EMPTY || nID == ID_SHOW_NON_EMPTY)
////{
//// //pDocument->m_showType = nID - ID_SHOW_ALL;
////}
//else if (nID == ID_READ_ONLY || nID == ID_MODE_EDIT)
//{
// pProject->m_properties.m_bEditable = nID == ID_MODE_EDIT;
// GetDocument()->UpdateAllViews(NULL, CMatchStationDoc::PROPERTIES_CHANGE, NULL);
//}
}
void CDPTView::OnUpdateUI(CCmdUI *pCmdUI)
{
//bool bEnable = false;
//CMatchStationDoc* pDocument = pDocument = GetDocument(); ASSERT(pDocument);
//CWeatherDatabasePtr pProject = pDocument->m_pProject;
//if (pProject)
//{
// const CDPTProjectProperties& properties = pProject->m_properties;
// switch (pCmdUI->m_nID)
// {
// case ID_STUDIES_LIST: break;
// //case ID_SHOW_ALL: pCmdUI->SetRadio(); break;
// //case ID_SHOW_EMPTY: pCmdUI->SetRadio(); break;
// //case ID_SHOW_NON_EMPTY: pCmdUI->SetRadio(); break;
// case ID_READ_ONLY: pCmdUI->SetRadio(!properties.m_bEditable); break;
// case ID_MODE_EDIT: pCmdUI->SetRadio(properties.m_bEditable); break;
// default: ASSERT(FALSE);
// }
//
// bEnable = true;
//}
//
//pCmdUI->Enable(bEnable);
}
void CDPTView::OnInitialUpdate()
{
CMatchStationDoc* pDoc = (CMatchStationDoc*)GetDocument();
pDoc->UpdateAllViews(NULL, 0, NULL);
//CMainFrame* pMainFrm = (CMainFrame*)AfxGetMainWnd();
//pMainFrm->OnUpdate(NULL, 0, NULL);
}
void CDPTView::OnCopy()
{
m_grid.CopySelected();
}
void CDPTView::OnPaste()
{
m_grid.Paste();
}
| 26.118971 | 175 | 0.688416 | RNCan |
3b328a615d674927e3346252a3a0993be5362697 | 240 | inl | C++ | include/AKLib/Math/Math.inl | xXAKShredder8Xx/AKLib | b85d116203f6670e1f7a80c9d5396d4dc1a71f2c | [
"Apache-2.0",
"MIT"
] | null | null | null | include/AKLib/Math/Math.inl | xXAKShredder8Xx/AKLib | b85d116203f6670e1f7a80c9d5396d4dc1a71f2c | [
"Apache-2.0",
"MIT"
] | null | null | null | include/AKLib/Math/Math.inl | xXAKShredder8Xx/AKLib | b85d116203f6670e1f7a80c9d5396d4dc1a71f2c | [
"Apache-2.0",
"MIT"
] | null | null | null |
NSB(AKLib)
NSB(Math)
template <typename T>
AKL_INLINE T Interpolate(T goal, T current, T dt)
{
T diff = goal - current;
if (diff > dt)
return current + dt;
else if (diff < -dt)
return current - dt;
return goal;
}
NSE()
NSE() | 11.428571 | 50 | 0.633333 | xXAKShredder8Xx |
3b379f14f51d5b4d3c2e1c6c6f7111629aa4f1a6 | 374 | cpp | C++ | TitaniumRose/src/TitaniumRose/ImGui/ImGuiLayer.cpp | Zinadore/Hazel-D3D12 | 084cf9a473b6c66a2890f107667f687d6c7ed0a0 | [
"Apache-2.0"
] | null | null | null | TitaniumRose/src/TitaniumRose/ImGui/ImGuiLayer.cpp | Zinadore/Hazel-D3D12 | 084cf9a473b6c66a2890f107667f687d6c7ed0a0 | [
"Apache-2.0"
] | null | null | null | TitaniumRose/src/TitaniumRose/ImGui/ImGuiLayer.cpp | Zinadore/Hazel-D3D12 | 084cf9a473b6c66a2890f107667f687d6c7ed0a0 | [
"Apache-2.0"
] | null | null | null | #include "trpch.h"
#include "TitaniumRose/Core/Application.h"
#include "TitaniumRose/ImGui/ImGuiLayer.h"
#include "Platform/D3D12/ImGui/D3D12ImGuiLayer.h"
#include "Platform/D3D12/D3D12Renderer.h"
namespace Roses {
ImGuiLayer::ImGuiLayer()
: Layer("ImGuiLayer")
{
}
ImGuiLayer* ImGuiLayer::Initialize()
{
return new D3D12ImGuiLayer(D3D12Renderer::Context);
}
} | 19.684211 | 53 | 0.751337 | Zinadore |
3b37e0b30f21af95462d0a795b0951952a41f91a | 905 | cpp | C++ | widgets/demos/ex-pixmap-puzzle/main.cpp | sfaure-witekio/qt-training-material | d166e4ed9cc5f5faab85b0337c5844c4cdcb206e | [
"BSD-3-Clause"
] | 16 | 2017-01-11T17:28:03.000Z | 2021-09-27T16:12:01.000Z | widgets/demos/ex-pixmap-puzzle/main.cpp | sfaure-witekio/qt-training-material | d166e4ed9cc5f5faab85b0337c5844c4cdcb206e | [
"BSD-3-Clause"
] | null | null | null | widgets/demos/ex-pixmap-puzzle/main.cpp | sfaure-witekio/qt-training-material | d166e4ed9cc5f5faab85b0337c5844c4cdcb206e | [
"BSD-3-Clause"
] | 4 | 2017-03-17T02:44:32.000Z | 2021-01-22T07:57:34.000Z | /*************************************************************************
*
* Copyright (c) 2016 The Qt Company
* All rights reserved.
*
* See the LICENSE.txt file shipped along with this file for the license.
*
*************************************************************************/
#include <QApplication>
#include <QPushButton>
#include <QHBoxLayout>
#include "puzzle.h"
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Puzzle *puzzle = new Puzzle;
QPushButton *next = new QPushButton("Next");
QObject::connect(next, &QPushButton::clicked, puzzle, &Puzzle::showNext);
QHBoxLayout *hlay = new QHBoxLayout;
// hlay->addStretch(1);
hlay->addWidget(next);
QVBoxLayout *vlay = new QVBoxLayout;
vlay->addLayout(hlay);
vlay->addWidget(puzzle);
QWidget widget;
widget.setLayout(vlay);
widget.show();
return app.exec();
}
| 24.459459 | 77 | 0.558011 | sfaure-witekio |
3b3a7df34b79fb8dcc536cd44ff18ae03bc28e00 | 2,729 | cpp | C++ | cpe-2015-projects/DragonCommon/libsrc/common/vectorDataReader.cpp | patinyanudklin/git_testing | 81aa72dd211e8931df5d8a3f7852bb4ea09ad3f1 | [
"Unlicense"
] | null | null | null | cpe-2015-projects/DragonCommon/libsrc/common/vectorDataReader.cpp | patinyanudklin/git_testing | 81aa72dd211e8931df5d8a3f7852bb4ea09ad3f1 | [
"Unlicense"
] | null | null | null | cpe-2015-projects/DragonCommon/libsrc/common/vectorDataReader.cpp | patinyanudklin/git_testing | 81aa72dd211e8931df5d8a3f7852bb4ea09ad3f1 | [
"Unlicense"
] | null | null | null | extern "C"
{
#include "drelease.h"
char VECTORDATAREADER_CPP_ID[]=
"\0@(#) " __FILE__ " $Revision: 1.5 $$Date: 2014/12/05 14:24:30 $";
D_REL_IDSTR;
}
/*
* filename vectorDataReader.cpp
* $Revision: 1.5 $ $Date: 2014/12/05 14:24:30 $
*
* ~~ Copyright 2006-2014 Kurt Rudahl and Sally Goldin
*
* All rights are reserved. Copying or other reproduction of
* this program except for archival purposes is prohibited
* without the prior written consent of Goldin-Rudahl Associates.
*
* RESTRICTED RIGHTS LEGEND
*
* Use, duplication, or disclosure by the U.S. Government
* is subject to restrictions as set forth in
* paragraph (b) (3) (B) of the Rights in Technical
* Data and Computer Software clause in DAR 7-104.9(a).
*
* The moral right of the copyright holder is hereby asserted
* ~~ EndC
***************************************************
* $Id: vectorDataReader.cpp,v 1.5 2014/12/05 14:24:30 rudahl Exp $
* $Log: vectorDataReader.cpp,v $
* Revision 1.5 2014/12/05 14:24:30 rudahl
* reconciled DragonProfessional with OpenDragon
*
* Revision 1.4 2008/04/26 10:55:55 rudahl
* improved notices
*
* Revision 1.3 2007/05/27 06:06:03 rudahl
* removed unneeded headers
*
* Revision 1.2 2006/08/14 07:20:17 goldin
* Debugging new vector framework
*
* Revision 1.1 2006/08/04 11:06:41 goldin
* Create class hierarchy similar to that for image classes
*
*
*
*******************************************************************
* This is the VectorDataReader base class. This is an
* abstract base class for concrete classes that handling
* the reading of reading vector files of various format.
* This class is roughly analagous to the the ImageReader class.
*
* Created by Sally Goldin, 4 August 2006
*
****************************************************************
*/
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stddef.h> /* for offsetof() */
#include "dtypes.h"
#include "dlimits.h"
#include "dragon-errors.h"
//#include "files.h"
#include "ob.h"
#include "dhead.h"
#include "dragonHd.h"
#include "imageHdr.h"
#include "img.h"
#include "imageReader.h"
#include "imageWriter.h"
#include "vectorData.h"
#include "vectorDataReader.h"
//#include "i18n.h"
#include "dragonOb.h"
#include "logger.h"
//#include "dp.h"
Class VectorDataReader::s_class_Base("VectorDataReader","Class for reading vector files");
VectorDataReader::VectorDataReader(int iDebug,int iTrace)
{
m_pVectorData = NULL;
m_pClass = &s_class_Base; m_pClass->setSubClass(OB::getObjectClass());
}
void VectorDataReader_END() { puts(FIL_ID); }
| 28.427083 | 90 | 0.649322 | patinyanudklin |
3b3f3b6e8b2c8150e6f24ea3e59292c18ba96f26 | 1,695 | cpp | C++ | Codeforces/MartianClock.cpp | aajjbb/contest-files | b8842681b96017063a7baeac52ae1318bf59d74d | [
"Apache-2.0"
] | 1 | 2018-08-28T19:58:40.000Z | 2018-08-28T19:58:40.000Z | Codeforces/MartianClock.cpp | aajjbb/contest-files | b8842681b96017063a7baeac52ae1318bf59d74d | [
"Apache-2.0"
] | 2 | 2017-04-16T00:48:05.000Z | 2017-08-03T20:12:26.000Z | Codeforces/MartianClock.cpp | aajjbb/contest-files | b8842681b96017063a7baeac52ae1318bf59d74d | [
"Apache-2.0"
] | 4 | 2016-03-04T19:42:00.000Z | 2018-01-08T11:42:00.000Z | #include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <memory>
#include <iomanip>
#include <functional>
#include <new>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <climits>
#include <cctype>
#include <ctime>
#define REP(i, n) for((i) = 0; i < n; i++)
#define FOR(i, a, n) for((i) = a; i < n; i++)
#define FORR(i, a, n) for((i) = a; i <= n; i++)
#define sz(n) n.size()
#define pb(n) push_back(n)
#define all(n) n.begin(), n.end()
using namespace std;
typedef long long int64;
int parse(string s, int base) {
int i,ans=0;
REP(i,s.length()){
int x = ((s[i] >= 'A' && s[i] <= 'Z') ? (s[i] - 'A' + 10) : (s[i] - '0'));
if(x >= base) return -1;
ans = ans * base + x;
}
return ans;
}
int main(void) {
string s;
vector<int> v;
cin >> s;
int i = 0;
for(;i < sz(s); i++) {
if(s[i] == ':') break;
}
string h = s.substr(0, i);
string m = s.substr(i + 1);
for(int i = 2; i <= 80; i++) {
int th = parse(h, i);
int tm = parse(m, i);
if(th >= 0 && th <= 23 && tm >= 0 && tm <= 59) {
v.push_back(i);
}
}
if(v.size() == 0) {
v.push_back(0);
} else if(v[sz(v) - 1] > 60) {
v.clear();
v.push_back(-1);
}
for(int i = 0; i < sz(v); i++) {
if(i == sz(v) - 1) {
cout << v[i] << endl;
} else {
cout << v[i] << " ";
}
}
return 0;
}
| 20.670732 | 83 | 0.448378 | aajjbb |
3b4322c6f705b67ed97afeb8531cfa7f6b73476f | 1,499 | cpp | C++ | YorozuyaGSLib/source/CNationCodeStrTable.cpp | lemkova/Yorozuya | f445d800078d9aba5de28f122cedfa03f26a38e4 | [
"MIT"
] | 29 | 2017-07-01T23:08:31.000Z | 2022-02-19T10:22:45.000Z | YorozuyaGSLib/source/CNationCodeStrTable.cpp | kotopes/Yorozuya | 605c97d3a627a8f6545cc09f2a1b0a8afdedd33a | [
"MIT"
] | 90 | 2017-10-18T21:24:51.000Z | 2019-06-06T02:30:33.000Z | YorozuyaGSLib/source/CNationCodeStrTable.cpp | kotopes/Yorozuya | 605c97d3a627a8f6545cc09f2a1b0a8afdedd33a | [
"MIT"
] | 44 | 2017-12-19T08:02:59.000Z | 2022-02-24T23:15:01.000Z | #include <CNationCodeStrTable.hpp>
START_ATF_NAMESPACE
CNationCodeStrTable::CNationCodeStrTable()
{
using org_ptr = void (WINAPIV*)(struct CNationCodeStrTable*);
(org_ptr(0x140204ad0L))(this);
};
void CNationCodeStrTable::ctor_CNationCodeStrTable()
{
using org_ptr = void (WINAPIV*)(struct CNationCodeStrTable*);
(org_ptr(0x140204ad0L))(this);
};
int CNationCodeStrTable::GetCode(char* szCodeStr)
{
using org_ptr = int (WINAPIV*)(struct CNationCodeStrTable*, char*);
return (org_ptr(0x14020aca0L))(this, szCodeStr);
};
char* CNationCodeStrTable::GetStr(int iType)
{
using org_ptr = char* (WINAPIV*)(struct CNationCodeStrTable*, int);
return (org_ptr(0x14020adb0L))(this, iType);
};
bool CNationCodeStrTable::Init()
{
using org_ptr = bool (WINAPIV*)(struct CNationCodeStrTable*);
return (org_ptr(0x14020ac40L))(this);
};
int CNationCodeStrTable::RegistCode()
{
using org_ptr = int (WINAPIV*)(struct CNationCodeStrTable*);
return (org_ptr(0x14020ae30L))(this);
};
CNationCodeStrTable::~CNationCodeStrTable()
{
using org_ptr = void (WINAPIV*)(struct CNationCodeStrTable*);
(org_ptr(0x140204b20L))(this);
};
void CNationCodeStrTable::dtor_CNationCodeStrTable()
{
using org_ptr = void (WINAPIV*)(struct CNationCodeStrTable*);
(org_ptr(0x140204b20L))(this);
};
END_ATF_NAMESPACE
| 32.586957 | 75 | 0.656438 | lemkova |
3b43cc073be6bca95c262d235393cab10753d940 | 5,868 | cpp | C++ | tests/PreProcessingModules/LowPassFilterUnitTest.cpp | torydebra/grt | 6c3fe9e5ab470d840b1c3e613ee0356d209eef7b | [
"MIT",
"Unlicense"
] | 818 | 2015-01-03T05:21:04.000Z | 2022-03-30T00:43:09.000Z | tests/PreProcessingModules/LowPassFilterUnitTest.cpp | torydebra/grt | 6c3fe9e5ab470d840b1c3e613ee0356d209eef7b | [
"MIT",
"Unlicense"
] | 131 | 2015-01-26T08:50:57.000Z | 2022-01-12T07:51:53.000Z | tests/PreProcessingModules/LowPassFilterUnitTest.cpp | torydebra/grt | 6c3fe9e5ab470d840b1c3e613ee0356d209eef7b | [
"MIT",
"Unlicense"
] | 301 | 2015-01-15T12:36:54.000Z | 2022-03-14T20:12:10.000Z | #include <GRT.h>
#include "gtest/gtest.h"
using namespace GRT;
//Unit tests for the GRT LowPassFilter module
const std::string modelFilename = "lpf_model.grt";
Float ROUND( const Float x ){ return roundf(x*100.0)/100.0; } //Round the value to 3 decimal places
Float GET_FILTER_FACTOR( const Float freq, const Float delta ){ return delta / ((ONE_OVER_TWO_PI/freq) + delta); }
// Tests the default constructor
TEST(LowPassFilter, TestDefaultConstructor) {
LowPassFilter lpf;
//Check the id's matches
EXPECT_TRUE( lpf.getId() == LowPassFilter::getId() );
//Check the lpf is not trained
EXPECT_TRUE( !lpf.getTrained() );
}
// Tests the copy constructor
TEST(LowPassFilter, TestCopyConstructor) {
LowPassFilter lpf;
//Check the id's matches
EXPECT_TRUE( lpf.getId() == LowPassFilter::getId() );
//Check the lpf is not trained
EXPECT_TRUE( !lpf.getTrained() );
LowPassFilter lpf2( lpf );
//Check the id's matches
EXPECT_TRUE( lpf2.getId() == LowPassFilter::getId() );
//Check the lpf is not trained
EXPECT_TRUE( !lpf2.getTrained() );
}
// Tests the equals operator
TEST(LowPassFilter, TestEqualsOperator) {
LowPassFilter lpf;
//Check the id's matches
EXPECT_TRUE( lpf.getId() == LowPassFilter::getId() );
//Check the lpf is not trained
EXPECT_TRUE( !lpf.getTrained() );
LowPassFilter lpf2 = lpf;
//Check the id's matches
EXPECT_TRUE( lpf2.getId() == LowPassFilter::getId() );
//Check the lpf is not trained
EXPECT_TRUE( !lpf2.getTrained() );
}
// Tests the gain getter/setter
TEST(LowPassFilter, TestGainGetSet) {
LowPassFilter lpf;
//Check the id's matches
EXPECT_TRUE( lpf.getId() == LowPassFilter::getId() );
//Set the gain with a valid value
EXPECT_TRUE( lpf.setGain( 0.9 ) );
EXPECT_EQ( lpf.getGain(), 0.9 );
//Set the gain with a non valid value
EXPECT_FALSE( lpf.setGain( -1 ) );
EXPECT_EQ( lpf.getGain(), 0.9 ); //The gain should not have changed
//Set the gain with a valid value
EXPECT_TRUE( lpf.setGain( 1.1 ) );
EXPECT_EQ( lpf.getGain(), 1.1 ); //The gain should now have changed
}
// Tests the filter factor getter/setter
TEST(LowPassFilter, TestFilterFactorGetSet) {
LowPassFilter lpf;
//Check the id's matches
EXPECT_TRUE( lpf.getId() == LowPassFilter::getId() );
//Set the gain with a valid value
EXPECT_TRUE( lpf.setFilterFactor( 0.9 ) );
EXPECT_EQ( lpf.getFilterFactor(), 0.9 );
//Set the gain with a non valid value
EXPECT_FALSE( lpf.setFilterFactor( -1 ) );
EXPECT_EQ( lpf.getFilterFactor(), 0.9 ); //The gain should not have changed
//Set the gain with a non valid value
EXPECT_FALSE( lpf.setFilterFactor( 1.1 ) );
EXPECT_EQ( lpf.getFilterFactor(), 0.9 ); //The gain should not have changed
}
// Tests the filter factor setter
TEST(LowPassFilter, TestCutoffFrequencySet) {
LowPassFilter lpf;
//Check the id's matches
EXPECT_TRUE( lpf.getId() == LowPassFilter::getId() );
const Float delta = 1.0 / 500.0f; //Set a delta for 500Hz
const Float expectedFilterFactor = delta / ((ONE_OVER_TWO_PI/10.0) + delta);
//Set the gain with a valid value
EXPECT_TRUE( lpf.setCutoffFrequency( 10, delta ) );
EXPECT_EQ( lpf.getFilterFactor(), expectedFilterFactor );
//Set the gain with a non valid value
EXPECT_FALSE( lpf.setCutoffFrequency( -1, delta ) );
EXPECT_EQ( lpf.getFilterFactor(), expectedFilterFactor ); //The gain should not have changed
//Set the gain with a non valid value
EXPECT_FALSE( lpf.setCutoffFrequency( 0, delta ) );
EXPECT_EQ( lpf.getFilterFactor(), expectedFilterFactor ); //The gain should not have changed
//Set the gain with a non valid value
EXPECT_FALSE( lpf.setCutoffFrequency( 10, 0 ) );
EXPECT_EQ( lpf.getFilterFactor(), expectedFilterFactor ); //The gain should not have changed
}
// Tests the save/load functions
TEST(LowPassFilter, TestSaveLoad) {
LowPassFilter lpf;
//Check the id's matches
EXPECT_TRUE( lpf.getId() == LowPassFilter::getId() );
const Float delta = 1.0 / 500.0f; //Set a delta for 500Hz
const Float expectedFilterFactor = delta / ((ONE_OVER_TWO_PI/10.0) + delta);
//Set the gain with a valid value
EXPECT_TRUE( lpf.setCutoffFrequency( 10, delta ) );
EXPECT_EQ( lpf.getFilterFactor(), expectedFilterFactor );
EXPECT_TRUE( lpf.save("lpf_unit_test_model.grt") );
EXPECT_TRUE( lpf.clear() );
EXPECT_TRUE( lpf.load("lpf_unit_test_model.grt") );
EXPECT_EQ( ROUND( lpf.getFilterFactor() ), ROUND( expectedFilterFactor ) ); //Due to differences in how things are load from the file, we need to round the expected value
}
// Tests the filter functions
TEST(LowPassFilter, TestFilter) {
LowPassFilter lpf_1( 0.9 );
LowPassFilter lpf_2( 0.999 );
const UINT numSeconds = 5; //The number of seconds of data we want to generate
const Float sampleRate = 1000.0f;
const Float delta = 1.0 / sampleRate; //Set a delta for 1000Hz smaple rate
const Float freq = 1.0; //Stores the frequency
Float t = 0; //This keeps track of the time
Float sum_1 = 0;
Float sum_2 = 0;
Random random;
for(UINT i=0; i<numSeconds*1000; i++){
//Generate the signal
Float signal = sin( t * TWO_PI * freq ) + random.getRandomNumberGauss( 0, 0.1 );
//Filter the signal using the two filters
Float filteredValue_1 = lpf_1.filter( signal );
Float filteredValue_2 = lpf_2.filter( signal );
//Update the t
t += delta;
sum_1 += fabs( filteredValue_1 );
sum_2 += fabs( filteredValue_2 );
}
EXPECT_GT( sum_1, sum_2 ); //The gain for lpf 1 should be larger than that for 2 (as lpf 2 has a more aggressive filter)
}
int main(int argc, char **argv) {
::testing::InitGoogleTest( &argc, argv );
return RUN_ALL_TESTS();
}
| 30.247423 | 172 | 0.680641 | torydebra |
3b45bf22611ddbfab35ceb9a29144266fef5de08 | 3,240 | cpp | C++ | Plugins/UPIDController/Source/UPIDController/Private/PIDController.cpp | yukilikespie/RobCoG_FleX-4.16 | a6d1e8c0abb8ac1e36c5967cb886de8c154b2948 | [
"BSD-3-Clause"
] | null | null | null | Plugins/UPIDController/Source/UPIDController/Private/PIDController.cpp | yukilikespie/RobCoG_FleX-4.16 | a6d1e8c0abb8ac1e36c5967cb886de8c154b2948 | [
"BSD-3-Clause"
] | null | null | null | Plugins/UPIDController/Source/UPIDController/Private/PIDController.cpp | yukilikespie/RobCoG_FleX-4.16 | a6d1e8c0abb8ac1e36c5967cb886de8c154b2948 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2017, Institute for Artificial Intelligence - University of Bremen
// Author: Andrei Haidu (http://haidu.eu)
#include "PIDController.h"
// Default constructor
PIDController::PIDController()
{
}
// Constructor
PIDController::PIDController(float ProportionalVal, float IntegralVal, float DerivativeVal,
float OutMaxVal, float OutMinVal) :
P(ProportionalVal),
I(IntegralVal),
D(DerivativeVal),
OutMax(OutMaxVal),
OutMin(OutMinVal)
{
IErr = 0.f;
PrevErr = 0.f;
}
// Destructor
PIDController::~PIDController()
{
}
// Set all PID values
void PIDController::SetValues(float ProportionalVal, float IntegralVal, float DerivativeVal,
float OutMaxVal, float OutMinVal)
{
P = ProportionalVal;
I = IntegralVal;
D = DerivativeVal;
OutMax = OutMaxVal;
OutMin = OutMinVal;
PIDController::Reset();
};
// Update the PID loop
float PIDController::Update(const float Error, const float DeltaTime)
{
if (DeltaTime == 0.0f || FMath::IsNaN(Error))
{
return 0.0f;
}
// Calculate proportional output
const float POut = P * Error;
// Calculate integral error / output
IErr += DeltaTime * Error;
const float IOut = I * IErr;
// Calculate the derivative error / output
const float DErr = (Error - PrevErr) / DeltaTime;
const float DOut = D * DErr;
// Set previous error
PrevErr = Error;
// Calculate the output
const float Out = POut + IOut + DOut;
// Clamp output to max/min values
if (OutMax > 0.f || OutMin < 0.f)
{
if (Out > OutMax)
return OutMax;
else if (Out < OutMin)
return OutMin;
}
return Out;
};
// Update only P
float PIDController::UpdateAsP(const float Error, const float DeltaTime)
{
if (DeltaTime == 0.0f || FMath::IsNaN(Error))
{
return 0.0f;
}
// Calculate proportional output
const float Out = P * Error;
// Clamp output to max/min values
if (OutMax > 0.f || OutMin < 0.f)
{
if (Out > OutMax)
return OutMax;
else if (Out < OutMin)
return OutMin;
}
return Out;
};
// Update only PD
float PIDController::UpdateAsPD(const float Error, const float DeltaTime)
{
if (DeltaTime == 0.0f || FMath::IsNaN(Error))
{
return 0.0f;
}
// Calculate proportional output
const float POut = P * Error;
// Calculate the derivative error / output
const float DErr = (Error - PrevErr) / DeltaTime;
const float DOut = D * DErr;
// Set previous error
PrevErr = Error;
// Calculate the output
const float Out = POut + DOut;
// Clamp output to max/min values
if (OutMax > 0.f || OutMin < 0.f)
{
if (Out > OutMax)
return OutMax;
else if (Out < OutMin)
return OutMin;
}
return Out;
};
// Update only PI
float PIDController::UpdateAsPI(const float Error, const float DeltaTime)
{
if (DeltaTime == 0.0f || FMath::IsNaN(Error))
{
return 0.0f;
}
// Calculate proportional output
const float POut = P * Error;
// Calculate integral error / output
IErr += DeltaTime * Error;
const float IOut = I * IErr;
// Calculate the output
const float Out = POut + IOut;
// Clamp output to max/min values
if (OutMax > 0.f || OutMin < 0.f)
{
if (Out > OutMax)
return OutMax;
else if (Out < OutMin)
return OutMin;
}
return Out;
};
// Reset error values of the PID
void PIDController::Reset()
{
PrevErr = 0.0f;
IErr = 0.0f;
}; | 19.171598 | 92 | 0.678395 | yukilikespie |
8dc733651fdb8c8b76d1b8b6948c7f664ef06090 | 2,493 | cpp | C++ | timus/task1003_b.cpp | greendwin/puzzles | 5df1175f178d0c3e1ffa765160057d90e9da37cd | [
"MIT"
] | null | null | null | timus/task1003_b.cpp | greendwin/puzzles | 5df1175f178d0c3e1ffa765160057d90e9da37cd | [
"MIT"
] | null | null | null | timus/task1003_b.cpp | greendwin/puzzles | 5df1175f178d0c3e1ffa765160057d90e9da37cd | [
"MIT"
] | null | null | null |
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <algorithm>
#include <iterator>
#include <cassert>
#pragma warning(disable : 4018)
#ifdef ONLINE_JUDGE
typedef long long INT64;
typedef unsigned long long UINT64;
#else
typedef __int64 INT64;
typedef unsigned __int64 UINT64;
#endif
using namespace std;
struct PART {
int first;
int last;
int odd;
bool operator < (const PART & p) const {
return first < p.first || first == p.first && last < p.last;
}
};
enum {
STATE_UNKNOWN,
STATE_ODD,
STATE_EVEN,
};
bool check(vector<PART> & parts)
{
sort(parts.begin(), parts.end());
map<int, int> states;
typedef map<int, int>::iterator state_iterator;
for (int k = 0; k < parts.size(); ++k) {
const PART & cur = parts[k];
state_iterator iter = states.find(cur.first - 1);
if (iter != states.end()) {
int odd = iter->second ^ cur.odd;
iter = states.find(cur.last);
if (iter == states.end()) {
states.insert(make_pair(cur.last, odd));
} else if (iter->second != odd) {
return false;
}
continue;
}
if (k > 0 && parts[k - 1].first == cur.first || k + 1 < parts.size() && parts[k + 1].first == cur.first) {
states.insert(make_pair(cur.first - 1, 0));
--k;
}
}
return true;
}
int main(void)
{
bool stop = false;
PART p;
string res;
vector<PART> parts;
parts.reserve(5000);
vector<PART> tmp;
tmp.reserve(5000);
for (;;) {
parts.clear();
int bitsCount = 0;
cin >> bitsCount;
if (bitsCount == -1) {
break;
}
int count = 0;
cin >> count;
for (int k = 0; k < count; ++k) {
cin >> p.first >> p.last >> res;
p.odd = (res == "odd");
parts.push_back(p);
}
int lo = 1;
int hi = count;
tmp.clear();
copy(parts.begin(), parts.end(), back_inserter(tmp));
if (check(tmp)) {
cout << count << endl;
continue;
}
while (hi - lo > 1) {
int mid = (hi + lo) / 2;
tmp.clear();
copy(parts.begin(), parts.begin() + mid, back_inserter(tmp));
if (check(tmp)) {
lo = mid;
} else {
hi = mid;
}
}
cout << lo << endl;
}
return 0;
}
| 18.744361 | 112 | 0.503811 | greendwin |
8dc88f5b26149aaab6708a59350ed317f96aeabb | 5,657 | cpp | C++ | src/TestXE/XETInput/WindowState.cpp | devxkh/FrankE | 72faca02759b54aaec842831f3c7a051e7cf5335 | [
"MIT"
] | 11 | 2017-01-17T15:02:25.000Z | 2020-11-27T16:54:42.000Z | src/TestXE/XETInput/WindowState.cpp | devxkh/FrankE | 72faca02759b54aaec842831f3c7a051e7cf5335 | [
"MIT"
] | 9 | 2016-10-23T20:15:38.000Z | 2018-02-06T11:23:17.000Z | src/TestXE/XETInput/WindowState.cpp | devxkh/FrankE | 72faca02759b54aaec842831f3c7a051e7cf5335 | [
"MIT"
] | 2 | 2019-08-29T10:23:51.000Z | 2020-04-03T06:08:34.000Z | #include "WindowState.hpp"
#include <memory>
#include <iostream>
void WindowState::createFrameListener(void)
{
}
WindowState::WindowState(XE::XEngine& engine, bool replace)
: XE::XEState(engine, replace)
{
XE::LogManager::getSingleton().logMessage("InitState - Initialization");
//SetResource();
//--------------------------------------------------------
//------------------ Controller -------------------------------
//--------------------------------------------------------
//one controller is always needed
//std::unique_ptr<XE::Controller> controller = std::unique_ptr<XE::Controller>(new XE::Controller(0, &engine)); //creates camera
//engine.getCtrlMgr().addController(std::move(controller));
//mStateData->mUIStateManager.addUIState(mStateData->mUIStateManager.build <UI::UIInitGame>(UI::UISI_InitGame, controller, true));
//Select Char
//XE::CharEntity mChara(1, controller->getStateData()->mScene);
//controller->getStateData()->mScene->addGameEntity(mChara);
//controller->setCharEntity(mChara);
//controller->getView().mCamera->setStyle(CA_CHARACTER);
//### controller->getActionMap()[InputCmd::NavEnter] = XE::Action(XE::Keyboard::Return, XE::Action::PressOnce);
//### controller->getCallBackSystem().connect(InputCmd::CamRotate, std::bind(&Controller::updateCameraGoal, this));
//lNameOfResourceGroup = "Init";
//{
// XE::Entity* test = mStateData->mScene->getSceneMgr()->createEntity("test", "Geoset_0_1_tex_1.mesh", lNameOfResourceGroup);
// XE::SceneNode* lNode = mStateData->mScene->getSceneMgr()->getRootSceneNode()->createChildSceneNode();
// //
// lNode->attachObject(test);
// lNode->scale(0.5, 0.5, 0.5);
// lNode->rotate(XE::Quaternion(XE::Degree(90), Ogre::Vector3::UNIT_X));
// // create a floor mesh resource
// XE::MeshManager::getSingleton().createPlane("floor", lNameOfResourceGroup,
// XE::Plane(Ogre::Vector3::UNIT_Y, -1), 250, 250, 25, 25, true, 1, 15, 15, Ogre::Vector3::UNIT_Z);
// // create a floor entity, give it a material, and place it at the origin
// XE::Entity* floor = mStateData->mScene->getSceneMgr()->createEntity("Floor", "floor", lNameOfResourceGroup);
// floor->setMaterialName("Examples/Rockwall", lNameOfResourceGroup);
// floor->setCastShadows(false);
// mStateData->mScene->getSceneMgr()->getRootSceneNode()->attachObject(floor);
//}
// controller->getView().mCamera->setPivotPosition(XE::Vector3f(0, 1, 0)); //fixed camera
XE::LogManager::getSingleton().logMessage("InitState - Initialized");
}
WindowState::~WindowState()
{
}
void WindowState::SetResource(){
XE::ConfigFile cf;
cf.load("E:/Projekte/Src Game/_Engine/XEngine/build/VS2010/XEngine/XEALL/Debug/resources.cfg", "\t:=", true);
XE::ConfigFile::SectionIterator seci = cf.getSectionIterator();
Ogre::String secName, typeName, archName;
Ogre::String sec, type, arch;
// go through all specified resource groups
while (seci.hasMoreElements())
{
sec = seci.peekNextKey();
XE::ConfigFile::SettingsMultiMap* settings = seci.getNext();
XE::ConfigFile::SettingsMultiMap::iterator i;
// go through all resource paths
for (i = settings->begin(); i != settings->end(); i++)
{
type = i->first;
arch = i->second;
//#if XE_PLATFORM == XE_PLATFORM_APPLE || XE_PLATFORM == XE_PLATFORM_APPLE_IOS
// // OS X does not set the working directory relative to the app,
// // In order to make things portable on OS X we need to provide
// // the loading with it's own bundle path location
// if (!Ogre::StringUtil::startsWith(arch, "/", false)) // only adjust relative dirs
// arch = Ogre::String(Ogre::macBundlePath() + "/" + arch);
//#endif
XE::ResourceGroupManager::getSingleton().addResourceLocation(arch, type, sec);
}
}
lNameOfResourceGroup = "General";
{
XE::ResourceGroupManager& lRgMgr = XE::ResourceGroupManager::getSingleton();
lRgMgr.initialiseResourceGroup(lNameOfResourceGroup);
lRgMgr.loadResourceGroup(lNameOfResourceGroup);
// Create XE_NEW factory
//XE::AL::SoundFactory* mOgreOggSoundFactory = XE_NEW_T(XE::AL::SoundFactory, MEMCATEGORY_GENERAL)();
//mStateData->mRoot->addMovableObjectFactory(mOgreOggSoundFactory, true);
//XE::AL::SoundManager* mOgreOggSoundManager = XE_NEW_T(XE::AL::SoundManager, MEMCATEGORY_GENERAL)();
//if (XE::AL::SoundManager::getSingletonPtr()->init("",100,100,mStateData->mScene->getSceneMgr()))
//{
// // Create a streamed sound, no looping, no prebuffering
// if (XE::AL::SoundManager::getSingletonPtr()->createSound("Sound1", "electricspark.ogg", false, false, false,mStateData->mScene->getSceneMgr()) )
// {
//
// }
//}
//geladene Materialien abfragen
/*XE::ResourceManager::ResourceMapIterator materialIterator = XE::MaterialManager::getSingleton().getResourceIterator();
while (materialIterator.hasMoreElements())
{
std::cout << "MaterialLoaded:" << (static_cast<XE::MaterialPtr>(materialIterator.peekNextValue()))->getName() << std::endl;
materialIterator.moveNext();
} */
}
//do this after long loading Times!
//KH m_engine->getRoot()->clearEventTimes();
}
void WindowState::update(float deltaTime)
{
//window.setMouseCursorVisible(false); // Hide cursor
if (!m_breaked)
{
// if(mStateData->mUIStateMgr->running())
// mStateData->mUIStateMgr->update();//update UI States
// XE::WindowEventUtilities::messagePump(); //dont use it or .net wrapper crash!
}
}
void WindowState::cleanup()
{
// Let's cleanup!
{
//mStateData->mUIManager.destroyScreen("WorldState");
XE::ResourceGroupManager& lRgMgr = XE::ResourceGroupManager::getSingleton();
lRgMgr.destroyResourceGroup(lNameOfResourceGroup);
}
}
| 35.136646 | 149 | 0.688704 | devxkh |
8dca289b3ce427d887e1719af626f72e11d5a62d | 522 | cpp | C++ | src/render/src/sge_render/backend/dx11/Render_DX11_Common.cpp | SimpleTalkCpp/SimpleGameEngine | 755c989995d07768bdc77175404fdcb2eb69c2e6 | [
"MIT"
] | null | null | null | src/render/src/sge_render/backend/dx11/Render_DX11_Common.cpp | SimpleTalkCpp/SimpleGameEngine | 755c989995d07768bdc77175404fdcb2eb69c2e6 | [
"MIT"
] | null | null | null | src/render/src/sge_render/backend/dx11/Render_DX11_Common.cpp | SimpleTalkCpp/SimpleGameEngine | 755c989995d07768bdc77175404fdcb2eb69c2e6 | [
"MIT"
] | null | null | null | #include "Render_DX11_Common.h"
namespace sge {
VertexSemanticType DX11Util::parseDxSemanticName(StrView s) {
VertexSemanticType v;
if (s == "SV_POSITION") {
return VertexSemanticType::POSITION;
}
if (!enumTryParse(v, s)) {
throw SGE_ERROR("unknown VertexLayout_SemanticType {}", s);
}
return v;
}
const char* DX11Util::getDxSemanticName(VertexSemanticType v) {
const char* s = enumStr(v);
if (!s) {
throw SGE_ERROR("unknown VertexLayout_SemanticType {}", v);
}
return s;
}
} | 20.076923 | 64 | 0.678161 | SimpleTalkCpp |
8dd093bfb7016552fb0124648615203ed8bf11e9 | 1,948 | cpp | C++ | source/tests/cpp_tests/destructors_errors_test.cpp | Panzerschrek/U-00DC-Sprache | eb677a66d178985433a62eb6b8a50ce2cdb14b1a | [
"BSD-3-Clause"
] | 45 | 2016-06-21T22:28:43.000Z | 2022-03-26T12:21:46.000Z | source/tests/cpp_tests/destructors_errors_test.cpp | Panzerschrek/U-00DC-Sprache | eb677a66d178985433a62eb6b8a50ce2cdb14b1a | [
"BSD-3-Clause"
] | 6 | 2020-07-12T18:00:10.000Z | 2021-11-30T11:20:14.000Z | source/tests/cpp_tests/destructors_errors_test.cpp | Panzerschrek/U-00DC-Sprache | eb677a66d178985433a62eb6b8a50ce2cdb14b1a | [
"BSD-3-Clause"
] | 5 | 2019-09-03T17:20:34.000Z | 2022-01-30T15:10:21.000Z | #include "tests.hpp"
namespace U
{
U_TEST( FunctionBodyDuplication_ForDestructors_Test0 )
{
static const char c_program_text[]=
R"(
class S
{
fn destructor(){}
fn destructor(){}
}
)";
const ErrorTestBuildResult build_result= BuildProgramWithErrors( c_program_text );
U_TEST_ASSERT( !build_result.errors.empty() );
const CodeBuilderError& error= build_result.errors.front();
U_TEST_ASSERT( error.code == CodeBuilderErrorCode::FunctionBodyDuplication );
U_TEST_ASSERT( error.src_loc.GetLine() == 5u );
}
U_TEST( DestructorOutsideClassTest0 )
{
static const char c_program_text[]=
R"(
fn destructor();
)";
const ErrorTestBuildResult build_result= BuildProgramWithErrors( c_program_text );
U_TEST_ASSERT( !build_result.errors.empty() );
const CodeBuilderError& error= build_result.errors.front();
U_TEST_ASSERT( error.code == CodeBuilderErrorCode::ConstructorOrDestructorOutsideClass );
U_TEST_ASSERT( error.src_loc.GetLine() == 2u );
}
U_TEST( DestructorMustReturnVoidTest0 )
{
static const char c_program_text[]=
R"(
class S
{
fn destructor() : i32 { return 0; }
}
)";
const ErrorTestBuildResult build_result= BuildProgramWithErrors( c_program_text );
U_TEST_ASSERT( !build_result.errors.empty() );
const CodeBuilderError& error= build_result.errors.front();
U_TEST_ASSERT( error.code == CodeBuilderErrorCode::ConstructorAndDestructorMustReturnVoid );
U_TEST_ASSERT( error.src_loc.GetLine() == 4u );
}
U_TEST( ExplicitArgumentsInDestructorTest1 )
{
static const char c_program_text[]=
R"(
class S
{
fn destructor( i32 a ) {}
}
)";
const ErrorTestBuildResult build_result= BuildProgramWithErrors( c_program_text );
U_TEST_ASSERT( !build_result.errors.empty() );
const CodeBuilderError& error= build_result.errors.front();
U_TEST_ASSERT( error.code == CodeBuilderErrorCode::ExplicitArgumentsInDestructor );
U_TEST_ASSERT( error.src_loc.GetLine() == 4u );
}
} // namespace U
| 25.298701 | 93 | 0.752567 | Panzerschrek |
8dd193192e7f4983194d254cd907dc06a61b57fc | 375 | cpp | C++ | belts/yellow/week_3/sum_reverse_sort/sum_reverse_sort.cpp | vlasenckov/cpp_garbage_collector | 6c10dad0f780c608336ef107e9a3b6a2d4bf3909 | [
"MIT"
] | null | null | null | belts/yellow/week_3/sum_reverse_sort/sum_reverse_sort.cpp | vlasenckov/cpp_garbage_collector | 6c10dad0f780c608336ef107e9a3b6a2d4bf3909 | [
"MIT"
] | null | null | null | belts/yellow/week_3/sum_reverse_sort/sum_reverse_sort.cpp | vlasenckov/cpp_garbage_collector | 6c10dad0f780c608336ef107e9a3b6a2d4bf3909 | [
"MIT"
] | null | null | null | #include "sum_reverse_sort.h"
#include <algorithm>
int Sum(int x, int y) {
return x + y;
}
std::string Reverse(std::string s)
{
int size = s.size(), temp;
for (int i = 0; i < size/2; i++) {
temp = s[i];
s[i] = s[size-1-i];
s[size-1-i] = temp;
}
return s;
};
void Sort(std::vector<int> &v) {
std::sort(v.begin(), v.end());
}
| 17.045455 | 38 | 0.506667 | vlasenckov |
8dd53f5cea3bfb2dd5bdd4e104227a105c762b90 | 3,185 | cpp | C++ | src/rendering/engine/engine/resource_factory.cpp | Bargor/tempest | 94837c6dcfef036827076446101e59afb7792f5d | [
"Apache-2.0",
"MIT"
] | null | null | null | src/rendering/engine/engine/resource_factory.cpp | Bargor/tempest | 94837c6dcfef036827076446101e59afb7792f5d | [
"Apache-2.0",
"MIT"
] | 1 | 2019-12-02T20:17:52.000Z | 2019-12-02T20:17:52.000Z | src/rendering/engine/engine/resource_factory.cpp | Bargor/tempest | 94837c6dcfef036827076446101e59afb7792f5d | [
"Apache-2.0",
"MIT"
] | null | null | null | // This file is part of Tempest-engine project
// Author: Karol Kontny
#include "resource_factory.h"
#include "engine/device.h"
namespace tst {
namespace engine {
resource_factory::resource_factory(device& device, application::data_loader& dataLoader)
: api::resource_factory(device.create_resource_factory(dataLoader)) {
}
resource_factory::~resource_factory() {
}
resources::index_buffer resource_factory::create_index_buffer(std::vector<std::uint16_t>&& indices) {
return resources::index_buffer(create_buffer_creation_info(), std::move(indices));
}
resources::index_buffer resource_factory::create_index_buffer(std::vector<std::uint32_t>&& indices) {
return resources::index_buffer(create_buffer_creation_info(), std::move(indices));
}
std::size_t resource_factory::create_pipeline(const std::string& techniqueName,
std::string_view pipelineName,
const std::string& shadersName,
const resources::vertex_buffer& vertexBuffer) {
return super::create_pipeline(techniqueName, pipelineName, shadersName, vertexBuffer.to_super());
}
void resource_factory::create_technique(std::string name) {
super::create_technique(std::move(name));
}
resources::vertex_buffer resource_factory::create_vertex_buffer(const engine::vertex_format& format,
std::vector<vertex>&& vertices) {
return resources::vertex_buffer(create_buffer_creation_info(), format, std::move(vertices));
}
resources::texture resource_factory::create_texture(const std::string& textureName) {
return resources::texture(create_texture_creation_info(textureName));
}
api::buffer::creation_info resource_factory::create_buffer_creation_info() const noexcept {
return super::create_buffer_creation_info();
}
api::uniform_buffer::creation_info resource_factory::create_uniform_creation_info(const std::string& shaderName,
bind_point bindPoint) const noexcept {
return super::create_uniform_creation_info(shaderName, bindPoint);
}
api::texture::creation_info resource_factory::create_texture_creation_info(const std::string& textureName) const {
return super::create_texture_creation_info(textureName);
}
api::material::creation_info resource_factory::create_material_creation_info(const std::string& shaderName,
const std::vector<std::string>& textureNames,
std::uint32_t staticStorageSize,
std::uint32_t dynamicStorageSize) const {
return super::create_material_creation_info(shaderName, textureNames, staticStorageSize, dynamicStorageSize);
}
} // namespace engine
} // namespace tst
| 47.537313 | 126 | 0.626688 | Bargor |
8dd548333ae9aff260b3e589ec34099e4e565801 | 12,122 | cpp | C++ | lib/commonAPI/barcode/ext/platform/wm/src/Barcode_impl.cpp | mensfeld/rhodes | 2962610a314ed563a0b7c83fcae6136913a1b033 | [
"MIT"
] | 173 | 2015-01-02T11:14:08.000Z | 2022-03-05T09:54:54.000Z | lib/commonAPI/barcode/ext/platform/wm/src/Barcode_impl.cpp | mensfeld/rhodes | 2962610a314ed563a0b7c83fcae6136913a1b033 | [
"MIT"
] | 263 | 2015-01-05T04:35:22.000Z | 2021-09-07T06:00:02.000Z | lib/commonAPI/barcode/ext/platform/wm/src/Barcode_impl.cpp | watusi/rhodes | 07161cca58ff6a960bbd1b79b36447b819bfa0eb | [
"MIT"
] | 77 | 2015-01-12T20:57:18.000Z | 2022-02-17T15:15:14.000Z | #include <common/RhodesApp.h>
#include "../../../shared/generated/cpp/BarcodeBase.h"
#include "Scanner.h"
namespace rho {
using namespace apiGenerator;
using namespace common;
#undef DEFAULT_LOGCATEGORY
#define DEFAULT_LOGCATEGORY "Barcode"
enum deviceManufacturer_T {SCANNER_SYMBOL, SCANNER_INTERMEC, SCANNER_HONEYWELL, SCANNER_OTHER};
deviceManufacturer_T g_deviceManufacturer;
class CBarcodeImpl: public IRhoExtension, public CBarcodeBase
{
public:
CScanner *m_pScanner;
CBarcodeImpl(const rho::String& strID): CBarcodeBase()
{
m_hashProps.put( "ID", strID);
if (g_deviceManufacturer == SCANNER_SYMBOL)
{
// For Symbol Scanners the ID will be in the form "SCNX" where
// X is a number
int iInstance = 0;
if (strID.length() > 3)
iInstance = atoi(strID.c_str() + 3);
LOG(INFO) + "Initialising Scanner Interface for Scanner " + strID;
RHODESAPP().getExtManager().registerExtension(/*convertToStringA*/(strID), this );
m_pScanner = new CScanner(iInstance);
if (m_pScanner){
m_pScanner->Initialise(true, rho::common::convertToStringW(strID).c_str());
// Modified by Abhineet Agarwal
// Invoking the below method to check whether battery is low or critical
// and whether or not, the scanner should be disabled.
m_pScanner->StartOrDisableCheckingLowBattery();
}
}
else
{
// Unsupported Scanner implementation
m_pScanner = NULL;
}
}
~CBarcodeImpl()
{
DEBUGMSG(true, (L"\nShutting down Scanner\n"));
if (m_pScanner)
{
delete m_pScanner;
m_pScanner = NULL;
}
DEBUGMSG(true, (L"\nScanner is shut down\n"));
}
virtual void setProperty( const rho::String& propertyName, const rho::String& propertyValue, CMethodResult& oResult)
{
if (!m_pScanner) {return;}
DEBUGMSG(TRUE, (L"Setting Property %s to %s", convertToStringW(propertyName).c_str(), convertToStringW(propertyValue).c_str()));
BOOL bRet = m_pScanner->SetPropertyOrMethod(convertToStringW(propertyName).c_str(), convertToStringW(propertyValue).c_str());
oResult.set(bRet == TRUE);
}
virtual void setProperties( const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult)
{
// Set multiple properties
if (!m_pScanner) {return;}
typedef std::map<rho::String, rho::String>::const_iterator it_type;
for (it_type iterator = propertyMap.begin(); iterator != propertyMap.end(); iterator++)
{
DEBUGMSG(TRUE, (L"Setting Property %s value %s", convertToStringW(iterator->first).c_str(), convertToStringW(iterator->second).c_str()));
m_pScanner->SetPropertyOrMethod(convertToStringW(iterator->first).c_str(), convertToStringW(iterator->second).c_str());
}
oResult.set(true);
}
virtual void clearAllProperties(rho::apiGenerator::CMethodResult& oResult)
{
if (!m_pScanner) {return;}
// Clearing all Scanner properties will disable the Scanner
m_pScanner->DisableScannerAndResetToDefault();
}
virtual void getProperty( const rho::String& propertyName, rho::apiGenerator::CMethodResult& oResult)
{
if (!m_pScanner) {return;}
if (m_hashProps.containsKey(propertyName))
oResult.set(m_hashProps.get(propertyName));
else
{
int iLen = m_pScanner->RetrieveProperty(convertToStringW(propertyName).c_str(), NULL);
if (iLen > -1)
{
WCHAR szValue[MAX_PATH];
if (szValue)
{
m_pScanner->RetrieveProperty(convertToStringW(propertyName).c_str(), szValue);
rho::StringW szStringValue;
szStringValue.insert(0, szValue);
oResult.set(szStringValue);
}
}
else
oResult.set(L"Unavailable");
}
}
virtual void getProperties( const rho::Vector<rho::String>& arrayofNames, rho::apiGenerator::CMethodResult& oResult)
{
if (!m_pScanner) {return;}
rho::Hashtable<rho::String, rho::String> propsHash;
rho::StringW szProperty;
typedef std::vector<rho::String>::const_iterator it_type;
for (it_type iterator = arrayofNames.begin(); iterator != arrayofNames.end(); iterator++)
{
szProperty = L"";
if (m_hashProps.containsKey(*iterator))
szProperty = convertToStringW(m_hashProps.get(*iterator));
else
{
int iLen = m_pScanner->RetrieveProperty(convertToStringW(*iterator).c_str(), NULL);
if (iLen > -1)
{
WCHAR szValue[MAX_PATH];
if (szValue)
{
m_pScanner->RetrieveProperty(convertToStringW(*iterator).c_str(), szValue);
szProperty.insert(0, szValue);
}
}
else
szProperty = L"Unavailable";
}
propsHash.put(*iterator, convertToStringA(szProperty));
}
oResult.set(propsHash);
}
virtual void getAllProperties(rho::apiGenerator::CMethodResult& oResult)
{
if (!m_pScanner) {return;}
m_pScanner->RetrieveAllProperties(&oResult);
}
virtual void enable( const rho::Hashtable<rho::String, rho::String>& propertyMap, CMethodResult& oResult)
{
if (!m_pScanner) {return;}
if (!oResult.hasCallback())
{
m_pScanner->SetCallback(0, NULL);
DEBUGMSG(true, (L"No Callback"));
}
else
{
DEBUGMSG(true, (L"Callback"));
m_pScanner->SetCallback(0, oResult);
}
CMethodResult oRes;
setProperties(propertyMap, oRes);
m_pScanner->SetPropertyOrMethod(L"enable", L"");
}
virtual void disable(CMethodResult& oResult)
{
if (!m_pScanner) {return;}
m_pScanner->SetPropertyOrMethod(L"disable", L"");
}
virtual void start(CMethodResult& oResult)
{
if (!m_pScanner) {return;}
m_pScanner->SetPropertyOrMethod(L"start", L"");
}
virtual void stop(CMethodResult& oResult)
{
if (!m_pScanner) {return;}
m_pScanner->SetPropertyOrMethod(L"stop", L"");
}
virtual void take( const rho::Hashtable<rho::String, rho::String>& propertyMap, CMethodResult& oResult)
{
// For Symbol Scanners Take will enable the Scanner and perform a soft start.
// If a barcode is scanned then the data will be returned, if no barcode is scanned
// then 'cancel' is returned. The time we wait for is defined by scanTimeout
if (!m_pScanner) {return;}
ResetEvent(m_pScanner->getEnableForTakeComplete());
CMethodResult oRes;
setProperties(propertyMap, oRes);
m_pScanner->SetPropertyOrMethod(L"enable", L"");
DWORD dwWaitForEnable = WaitForSingleObject(
m_pScanner->getEnableForTakeComplete(), 45000);
if (dwWaitForEnable == WAIT_TIMEOUT)
{
LOG(WARNING) + "Scanner did not enable in time for Take Method";
rho::Hashtable<rho::String, rho::String> scannedData;
scannedData.put( convertToStringA(L"barcode"), convertToStringA(L"") );
scannedData.put( convertToStringA(L"status"), convertToStringA(L"cancel") );
oResult.set(scannedData);
return;
}
else if (dwWaitForEnable == WAIT_FAILED)
LOG(WARNING) + "Error waiting for Take Barcode ";
m_pScanner->SetCallback(4, oResult);
WCHAR szTimeout[10]; // Something's gone terribly wrong if the scan timeout is more than a milliard!
m_pScanner->RetrieveProperty(L"scanTimeout", szTimeout);
DWORD dwTimeout = _wtoi(szTimeout);
m_pScanner->SetPropertyOrMethod(L"start", L"");
// Wait for the Scan Timeout duration
DWORD dwWaitRes = WaitForSingleObject(m_pScanner->getReadComplete(), dwTimeout);
if (dwWaitRes == WAIT_TIMEOUT)
{
// Scanner has timed out trying to scan a barcode, return cancelled to user
LOG(INFO) + "Barcode Take method did not detect a barcode";
rho::Hashtable<rho::String, rho::String> scannedData;
scannedData.put( convertToStringA(L"barcode"), convertToStringA(L"") );
scannedData.put( convertToStringA(L"status"), convertToStringA(L"cancel") );
oResult.set(scannedData);
}
else if (dwWaitRes == WAIT_FAILED)
LOG(WARNING) + "Error waiting for Take Barcode ";
m_pScanner->SetPropertyOrMethod(L"stop", L"");
m_pScanner->SetPropertyOrMethod(L"disable", L"");
m_pScanner->SetCallback(4, NULL);
}
virtual void registerBluetoothStatus(rho::apiGenerator::CMethodResult& oResult)
{
if (!m_pScanner) {return;}
m_pScanner->SetCallback(1, oResult);
}
virtual void commandRemoteScanner( const rho::String& command, rho::apiGenerator::CMethodResult& oResult)
{
if (!m_pScanner) {return;}
m_pScanner->CommandRemoteScanner(convertToStringW(command).c_str());
}
virtual void take_barcode( const rho::String& rubyCallbackURL, const rho::Hashtable<rho::String, rho::String>& propertyMap, rho::apiGenerator::CMethodResult& oResult)
{
oResult.setError("Not Supported on Windows Mobile / CE / Embedded");
}
virtual void barcode_recognize( const rho::String& imageFilePath, rho::apiGenerator::CMethodResult& oResult)
{
oResult.setError("Not Supported on Windows Mobile / CE / Embedded");
}
virtual void getSupportedProperties(rho::apiGenerator::CMethodResult& oResult)
{
if(!m_pScanner) {return;}
m_pScanner->GetSupportedProperties(&oResult);
}
// Virtual Methods overridden from IRhoExtension
virtual void OnAppActivate(bool bActivate, const CRhoExtData& oExtData)
{
if (!m_pScanner) {return;}
m_pScanner->ApplicationFocusChange(bActivate);
}
};
//CBarcodeSingletonBase::CBarcodeSingletonBase() {}
class CBarcodeSingleton: public CBarcodeSingletonBase
{
public:
CBarcodeSingleton(): CBarcodeSingletonBase(){}
~CBarcodeSingleton()
{
if (m_hEMDKLibrary)
FreeLibrary(m_hEMDKLibrary);
}
virtual rho::String getInitialDefaultID();
virtual void enumerate(CMethodResult& oResult);
HMODULE m_hEMDKLibrary;
LPFN_SCAN_FINDFIRST_T lpfn_SCAN_FindFirst;
LPFN_SCAN_FINDNEXT_T lpfn_SCAN_FindNext;
LPFN_SCAN_FINDCLOSE_T lpfn_SCAN_FindClose;
void initialise();
};
class CBarcodeFactory: public CBarcodeFactoryBase
{
~CBarcodeFactory(){}
virtual IBarcodeSingleton* createModuleSingleton();
virtual IBarcode* createModuleByID(const rho::String& strID);
};
extern "C" void Init_Barcode_extension()
{
CBarcodeFactory::setInstance( new CBarcodeFactory() );
Init_Barcode_API();
}
IBarcode* CBarcodeFactory::createModuleByID(const rho::String& strID)
{
return new CBarcodeImpl(strID);
}
IBarcodeSingleton* CBarcodeFactory::createModuleSingleton()
{
CBarcodeSingleton* pBarcodeSingleton = new CBarcodeSingleton();
pBarcodeSingleton->initialise();
return pBarcodeSingleton;
}
void CBarcodeSingleton::initialise()
{
// Determine the type of device we are running on and therefore which
// Scanner API to load
m_hEMDKLibrary = LoadLibrary(L"SCNAPI32.DLL");
if (m_hEMDKLibrary)
{
g_deviceManufacturer = SCANNER_SYMBOL;
// To enumerate scanners we just need find first, find next and find close
lpfn_SCAN_FindFirst = (LPFN_SCAN_FINDFIRST_T)GetProcAddress
(m_hEMDKLibrary, _T(SCAN_FindFirst_EXPORT));
lpfn_SCAN_FindNext = (LPFN_SCAN_FINDNEXT_T)GetProcAddress
(m_hEMDKLibrary, _T(SCAN_FindNext_EXPORT));
lpfn_SCAN_FindClose = (LPFN_SCAN_FINDCLOSE_T)GetProcAddress
(m_hEMDKLibrary, _T(SCAN_FindClose_EXPORT));
}
else
{
// EMDK Library failed to load, logically we are not on a Symbol Device
g_deviceManufacturer = SCANNER_OTHER;
}
}
void CBarcodeSingleton::enumerate(CMethodResult& oResult)
{
rho::Vector<rho::String> arIDs;
if (g_deviceManufacturer == SCANNER_SYMBOL)
{
SCAN_FINDINFO scanFindInfo;
memset(&scanFindInfo, 0, sizeof(scanFindInfo));
scanFindInfo.StructInfo.dwAllocated = sizeof(scanFindInfo);
HANDLE scanFindHandle = NULL;
DWORD dwResult =
lpfn_SCAN_FindFirst(&scanFindInfo, &scanFindHandle);
while(dwResult == E_SCN_SUCCESS)
{
// Remove Comma from end of Device Name
TCHAR szModifiedDeviceName[MAX_DEVICE_NAME + 1];
wcscpy(szModifiedDeviceName, scanFindInfo.szDeviceName);
if (wcslen(szModifiedDeviceName) > 0 &&
szModifiedDeviceName[wcslen(szModifiedDeviceName) - 1] == L':')
szModifiedDeviceName[wcslen(szModifiedDeviceName) - 1] = L'\0';
arIDs.addElement(convertToStringA(szModifiedDeviceName));
dwResult = lpfn_SCAN_FindNext(&scanFindInfo, scanFindHandle);
}
lpfn_SCAN_FindClose(scanFindHandle);
}
//oResult.setParamName("scannerArray");
oResult.set(arIDs);
}
rho::String CBarcodeSingleton::getInitialDefaultID()
{
CMethodResult oRes;
enumerate(oRes);
rho::Vector<rho::String>& arIDs = oRes.getStringArray();
return arIDs[0];
}
} | 32.239362 | 171 | 0.727768 | mensfeld |
8dd6dbb768f2c7d1b386b02a36a54164ea54a748 | 2,869 | cc | C++ | chrome/browser/ui/views/find_bar_host_uitest.cc | SlimKatLegacy/android_external_chromium | bc611cda58cc18d0dbaa8a7aee05eb3c0742e573 | [
"BSD-3-Clause"
] | 2 | 2017-09-02T19:08:28.000Z | 2021-11-15T15:15:14.000Z | chrome/browser/ui/views/find_bar_host_uitest.cc | SlimKatLegacy/android_external_chromium | bc611cda58cc18d0dbaa8a7aee05eb3c0742e573 | [
"BSD-3-Clause"
] | 2 | 2017-07-25T09:37:22.000Z | 2017-08-04T07:18:56.000Z | chrome/browser/ui/views/find_bar_host_uitest.cc | SlimKatLegacy/android_external_chromium | bc611cda58cc18d0dbaa8a7aee05eb3c0742e573 | [
"BSD-3-Clause"
] | 2 | 2020-01-12T00:55:53.000Z | 2020-11-04T06:36:41.000Z | // Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/app/chrome_command_ids.h"
#include "chrome/test/automation/browser_proxy.h"
#include "chrome/test/automation/tab_proxy.h"
#include "chrome/test/ui/ui_test.h"
#include "net/test/test_server.h"
class FindInPageControllerTest : public UITest {
public:
FindInPageControllerTest() {
show_window_ = true;
}
};
const std::string kSimplePage = "404_is_enough_for_us.html";
#if !defined(OS_WIN)
// Has never been enabled on other platforms http://crbug.com/45753
#define FindMovesOnTabClose_Issue1343052 \
DISABLED_FindMovesOnTabClose_Issue1343052
#endif
// The find window should not change its location just because we open and close
// a new tab.
TEST_F(FindInPageControllerTest, FindMovesOnTabClose_Issue1343052) {
net::TestServer test_server(net::TestServer::TYPE_HTTP,
FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(test_server.Start());
GURL url = test_server.GetURL(kSimplePage);
scoped_refptr<TabProxy> tabA(GetActiveTab());
ASSERT_TRUE(tabA.get());
ASSERT_TRUE(tabA->NavigateToURL(url));
WaitUntilTabCount(1);
scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
ASSERT_TRUE(browser.get() != NULL);
// Toggle the bookmark bar state.
EXPECT_TRUE(browser->ApplyAccelerator(IDC_SHOW_BOOKMARK_BAR));
EXPECT_TRUE(WaitForBookmarkBarVisibilityChange(browser.get(), true));
// Open the Find window and wait for it to animate.
EXPECT_TRUE(browser->OpenFindInPage());
EXPECT_TRUE(WaitForFindWindowVisibilityChange(browser.get(), true));
// Find its location.
int x = -1, y = -1;
EXPECT_TRUE(browser->GetFindWindowLocation(&x, &y));
// Open another tab (tab B).
EXPECT_TRUE(browser->AppendTab(url));
scoped_refptr<TabProxy> tabB(GetActiveTab());
ASSERT_TRUE(tabB.get());
// Close tab B.
EXPECT_TRUE(tabB->Close(true));
// See if the Find window has moved.
int new_x = -1, new_y = -1;
EXPECT_TRUE(browser->GetFindWindowLocation(&new_x, &new_y));
EXPECT_EQ(x, new_x);
EXPECT_EQ(y, new_y);
// Now reset the bookmark bar state and try the same again.
EXPECT_TRUE(browser->ApplyAccelerator(IDC_SHOW_BOOKMARK_BAR));
EXPECT_TRUE(WaitForBookmarkBarVisibilityChange(browser.get(), false));
// Bookmark bar has moved, reset our coordinates.
EXPECT_TRUE(browser->GetFindWindowLocation(&x, &y));
// Open another tab (tab C).
EXPECT_TRUE(browser->AppendTab(url));
scoped_refptr<TabProxy> tabC(GetActiveTab());
ASSERT_TRUE(tabC.get());
// Close it.
EXPECT_TRUE(tabC->Close(true));
// See if the Find window has moved.
EXPECT_TRUE(browser->GetFindWindowLocation(&new_x, &new_y));
EXPECT_EQ(x, new_x);
EXPECT_EQ(y, new_y);
}
| 32.235955 | 80 | 0.735796 | SlimKatLegacy |
8dd833372205c02c079c9cf4db195727d59d5110 | 3,024 | cpp | C++ | src/DTC/parallelStorageFreqDTC.cpp | Seideman-Group/chiML | 9ace5dccdbc6c173e8383f6a31ff421b4fefffdf | [
"MIT"
] | 1 | 2019-04-27T05:25:27.000Z | 2019-04-27T05:25:27.000Z | src/DTC/parallelStorageFreqDTC.cpp | Seideman-Group/chiML | 9ace5dccdbc6c173e8383f6a31ff421b4fefffdf | [
"MIT"
] | null | null | null | src/DTC/parallelStorageFreqDTC.cpp | Seideman-Group/chiML | 9ace5dccdbc6c173e8383f6a31ff421b4fefffdf | [
"MIT"
] | 2 | 2019-04-03T10:08:21.000Z | 2019-09-30T22:40:28.000Z | /** @file DTC/parallelStorageFreqDTC.cpp
* @brief A class that collects the FDTD field information across all processes to one process to Fourier transform and place it in a Grid for outputting
*
* Collects FDTD filed information from all processes, Fourier transforms it and transfers
* it into one place to be outputted by a detector
*
* @author Thomas A. Purcell (tpurcell90)
* @bug No known bugs.
*/
#include <DTC/parallelStorageFreqDTC.hpp>
parallelStorageFreqDTCReal::parallelStorageFreqDTCReal(int dtcNum, real_pgrid_ptr grid, DIRECTION propDir, std::array<int,3> loc, std::array<int,3> sz, std::vector<double> freqList) :
parallelStorageFreqDTC(dtcNum, grid, propDir, loc, sz, freqList)
{}
parallelStorageFreqDTCReal::parallelStorageFreqDTCReal(int dtcNum, std::pair< real_pgrid_ptr, std::array<int,3> > gridOff, DIRECTION propDir, std::array<int,3> loc, std::array<int,3> sz, std::vector<double> freqList) :
parallelStorageFreqDTC(dtcNum, gridOff, propDir, loc, sz, freqList)
{}
void parallelStorageFreqDTCReal::fieldIn(cplx* fftFact)
{
if(!fieldInFreq_)
return;
for(int ii = 0; ii < fieldInFreq_->fInGridInds_.size(); ii+=2)
{
dger_(nfreq_, fieldInFreq_->sz_[0], 1.0, reinterpret_cast<double*>(fftFact) , 2, &grid_->point(fieldInFreq_->fInGridInds_[ii]), fieldInFreq_->stride_, &fInReal_[ fieldInFreq_->fInGridInds_[ii+1] ], nfreq_);
dger_(nfreq_, fieldInFreq_->sz_[0], 1.0, reinterpret_cast<double*>(fftFact)+1, 2, &grid_->point(fieldInFreq_->fInGridInds_[ii]), fieldInFreq_->stride_, &fInCplx_[ fieldInFreq_->fInGridInds_[ii+1] ], nfreq_);
}
}
parallelStorageFreqDTCCplx::parallelStorageFreqDTCCplx(int dtcNum, cplx_pgrid_ptr grid, DIRECTION propDir, std::array<int,3> loc, std::array<int,3> sz, std::vector<double> freqList) :
parallelStorageFreqDTC(dtcNum, grid, propDir, loc, sz, freqList)
{}
parallelStorageFreqDTCCplx::parallelStorageFreqDTCCplx(int dtcNum, std::pair< cplx_pgrid_ptr, std::array<int,3> > gridOff, DIRECTION propDir, std::array<int,3> loc, std::array<int,3> sz, std::vector<double> freqList) :
parallelStorageFreqDTC(dtcNum, gridOff, propDir, loc, sz, freqList)
{}
void parallelStorageFreqDTCCplx::fieldIn(cplx* fftFact)
{
if(!fieldInFreq_)
return;
// Take an outer product of the prefactor vector and the field vectors to get the discrete Fourier Transform at all points
for(int ii = 0; ii < fieldInFreq_->fInGridInds_.size(); ii+=2)
zgerc_(nfreq_, fieldInFreq_->sz_[0], 1.0, fftFact, 1, &grid_->point(fieldInFreq_->fInGridInds_[ii]), fieldInFreq_->stride_, &outGrid_->point(fieldInFreq_->fInGridInds_[ii+1]), nfreq_);
}
void parallelStorageFreqDTCReal::toOutGrid()
{
if(outGrid_)
{
dcopy_(outGrid_->size(), fInReal_.data(), 1, reinterpret_cast<double*>( outGrid_->data() ) , 2);
dcopy_(outGrid_->size(), fInCplx_.data(), 1, reinterpret_cast<double*>( outGrid_->data() )+1, 2);
}
return;
}
void parallelStorageFreqDTCCplx::toOutGrid()
{
return;
} | 48.774194 | 218 | 0.72619 | Seideman-Group |
8dd8cb72589c86c64dfb5d0a7a1367447f695af2 | 2,433 | cpp | C++ | sample/TestLibWin32/ParticleBufferObject.cpp | CYBORUS/SDL2TK | 22ea239b57f9a6409ec8fea70c5497554df8069f | [
"Unlicense"
] | 1 | 2015-06-06T12:19:14.000Z | 2015-06-06T12:19:14.000Z | sample/TestLibWin32/ParticleBufferObject.cpp | CYBORUS/SDL2TK | 22ea239b57f9a6409ec8fea70c5497554df8069f | [
"Unlicense"
] | null | null | null | sample/TestLibWin32/ParticleBufferObject.cpp | CYBORUS/SDL2TK | 22ea239b57f9a6409ec8fea70c5497554df8069f | [
"Unlicense"
] | null | null | null | #include "ParticleBufferObject.hpp"
#include "ParticleBuilder.hpp"
#include "ParticleProgram.hpp"
#include <iostream>
static constexpr GLvoid* Offset(size_t offset)
{
return (GLfloat*)0 + offset;
}
ParticleBufferObject::ParticleBufferObject()
: _buffer(0)
, _count(0)
{
}
ParticleBufferObject::ParticleBufferObject(const ParticleBuilder& builder)
: _buffer(0)
{
std::size_t size = builder._array.size();
_count = size / 12;
std::cerr << "particle count -- " << _count << '\n';
if (_count > 0)
{
glGenBuffers(1, &_buffer);
glBindBuffer(GL_ARRAY_BUFFER, _buffer);
glBufferData(
GL_ARRAY_BUFFER,
size * sizeof(GLfloat),
builder._array.data(),
GL_STATIC_DRAW);
}
}
ParticleBufferObject::ParticleBufferObject(ParticleBufferObject&& other)
: _buffer(other._buffer)
, _count(other._count)
{
other._buffer = 0;
other._count = 0;
}
ParticleBufferObject::~ParticleBufferObject()
{
glDeleteBuffers(1, &_buffer);
}
ParticleBufferObject& ParticleBufferObject::operator=(
ParticleBufferObject&& other)
{
if (this != &other)
{
glDeleteBuffers(1, &_buffer);
_buffer = other._buffer;
_count = other._count;
other._buffer = 0;
other._count = 0;
}
return *this;
}
void ParticleBufferObject::Draw(const ParticleProgram& program) const
{
const GLsizei stride = sizeof(GLfloat) * 12;
glBindBuffer(GL_ARRAY_BUFFER, _buffer);
glVertexAttribPointer(program._vertexAttribute, 4, GL_FLOAT, GL_FALSE,
stride, Offset(0));
glEnableVertexAttribArray(program._vertexAttribute);
glVertexAttribPointer(program._colorAttribute, 4, GL_FLOAT, GL_FALSE,
stride, Offset(4));
glEnableVertexAttribArray(program._colorAttribute);
glVertexAttribPointer(program._velocityAttribute, 3, GL_FLOAT, GL_FALSE,
stride, Offset(8));
glEnableVertexAttribArray(program._velocityAttribute);
glVertexAttribPointer(program._startAttribute, 1, GL_FLOAT, GL_FALSE,
stride, Offset(11));
glEnableVertexAttribArray(program._startAttribute);
glDrawArrays(GL_POINTS, 0, _count);
glDisableVertexAttribArray(program._startAttribute);
glDisableVertexAttribArray(program._velocityAttribute);
glDisableVertexAttribArray(program._colorAttribute);
glDisableVertexAttribArray(program._vertexAttribute);
}
| 26.16129 | 76 | 0.697904 | CYBORUS |
8dda695908687e8f064f72f4c8f08ffb7dae66d3 | 2,196 | cc | C++ | template/micro_project/tensor_server.cc | delldu/Create | c3ad50200e5abe5b2d52623d3f95e0ffb11b9ab7 | [
"Apache-2.0"
] | 2 | 2019-09-19T10:57:00.000Z | 2022-01-17T20:22:07.000Z | template/micro_project/tensor_server.cc | delldu/Create | c3ad50200e5abe5b2d52623d3f95e0ffb11b9ab7 | [
"Apache-2.0"
] | null | null | null | template/micro_project/tensor_server.cc | delldu/Create | c3ad50200e5abe5b2d52623d3f95e0ffb11b9ab7 | [
"Apache-2.0"
] | null | null | null | #include "tensor_server.h"
Status TensorServiceImpl::Hello(ServerContext* context, const HelloRequest* request, HelloReply* response)
{
std::string prefix("Hello ");
response->set_message(prefix + request->name());
return Status::OK;
}
Status TensorServiceImpl::GetTensor(ServerContext* context, const GetTensorRequest* request, GetTensorReply* response)
{
TensorBuffer::iterator it = m_buffer.find(request->id());
if (it == m_buffer.end()) {
response->clear_tensor();
return Status(StatusCode::NOT_FOUND, "Tensor not found.");
}
response->mutable_tensor()->CopyFrom(it->second);
return Status::OK;
}
Status TensorServiceImpl::SetTensor(ServerContext* context, const SetTensorRequest* request, SetTensorReply* response)
{
m_buffer[request->id()] = request->tensor();
return Status::OK;
}
Status TensorServiceImpl::DelTensor(ServerContext* context, const DelTensorRequest* request, DelTensorReply* response)
{
m_buffer.erase(request->id());
return Status::OK;
}
Status TensorServiceImpl::CheckID(ServerContext* context, const CheckIDRequest* request, CheckIDReply* response)
{
TensorBuffer::iterator it = m_buffer.find(request->id());
return (it == m_buffer.end()) ? (Status(StatusCode::NOT_FOUND, "Tensor not found.")) : (Status::OK);
}
Status ImageCleanServiceImpl::ImageClean(ServerContext* context, const ImageCleanRequest* request, ImageCleanReply* response)
{
return Status::OK;
}
void StartImageCleanServer(std::string endpoint)
{
TensorServiceImpl tensor_service;
ImageCleanServiceImpl image_clean_service(tensor_service.BufferAddress());
ServerBuilder builder;
builder.SetMaxReceiveMessageSize(32 * 1024 * 1024);
builder.SetMaxSendMessageSize(32 * 1024 * 1024);
builder.AddListeningPort(endpoint, grpc::InsecureServerCredentials());
builder.RegisterService(&tensor_service);
builder.RegisterService(&image_clean_service);
std::unique_ptr<Server> server(builder.BuildAndStart());
std::cout << "Server listening on " << endpoint << std::endl;
server->Wait();
}
int main(int argc, char** argv)
{
StartImageCleanServer("0.0.0.0:50051");
return 0;
}
| 30.929577 | 125 | 0.728142 | delldu |
8de06bf141bd7a9ac0cff678fcc40221307028d4 | 289 | cpp | C++ | 191.cpp | nitin-maharana/LeetCode | d5e99fa313df3fda65bf385f46f8a62b6d061306 | [
"MIT"
] | 4 | 2016-02-28T17:09:14.000Z | 2017-04-15T15:56:08.000Z | 191.cpp | nitin-maharana/LeetCode | d5e99fa313df3fda65bf385f46f8a62b6d061306 | [
"MIT"
] | null | null | null | 191.cpp | nitin-maharana/LeetCode | d5e99fa313df3fda65bf385f46f8a62b6d061306 | [
"MIT"
] | null | null | null | /*
* Written by Nitin Kumar Maharana
* nitin.maharana@gmail.com
*/
class Solution {
public:
int hammingWeight(uint32_t n) {
int count = 0;
while(n)
{
count++;
n = n & (n-1);
}
return count;
}
};
| 14.45 | 35 | 0.439446 | nitin-maharana |
8de327d1313d53d56138416aec6145c5e6f94dfb | 702 | cpp | C++ | NoExceptAuto/NoExceptAuto.cpp | jbcoe/CppSandbox | 574dc31bbd3640a8cf1b7642c4a449bee687cce5 | [
"MIT"
] | 7 | 2015-01-18T13:30:09.000Z | 2021-08-21T19:50:26.000Z | NoExceptAuto/NoExceptAuto.cpp | jbcoe/CppSandbox | 574dc31bbd3640a8cf1b7642c4a449bee687cce5 | [
"MIT"
] | 1 | 2016-03-13T21:26:37.000Z | 2016-03-13T21:26:37.000Z | NoExceptAuto/NoExceptAuto.cpp | jbcoe/CppSandbox | 574dc31bbd3640a8cf1b7642c4a449bee687cce5 | [
"MIT"
] | 1 | 2016-02-16T04:56:25.000Z | 2016-02-16T04:56:25.000Z | #include <iostream>
int f()
{
return 1;
}
int noexcept_f() noexcept
{
return 1;
}
auto g()
{
return noexcept_f();
}
auto conditional_noexcept_g() noexcept(noexcept(noexcept_f()))
{
return noexcept_f();
}
int main(int argc, char* argv[])
{
std::cout << std::boolalpha << "f is noexcept: " << noexcept(f())
<< std::endl;
std::cout << std::boolalpha
<< "noexcept_f is noexcept: " << noexcept(noexcept_f())
<< std::endl;
std::cout << std::boolalpha << "g is noexcept: " << noexcept(g())
<< std::endl;
std::cout << std::boolalpha << "conditional_noexcept_g is noexcept: "
<< noexcept(conditional_noexcept_g()) << std::endl;
}
| 20.057143 | 71 | 0.582621 | jbcoe |
8de3df29716d3e64c625ae2493b60263efab1b73 | 261,446 | hpp | C++ | flite/lang/us_rms/us_rms_cg_f0_trees.hpp | Barath-Kannan/flite | 236f91a9a1e60fd25f1deed6d48022567cd7100f | [
"Apache-2.0"
] | 7 | 2017-12-10T23:02:22.000Z | 2021-08-05T21:12:11.000Z | flite/lang/us_rms/us_rms_cg_f0_trees.hpp | Barath-Kannan/flite | 236f91a9a1e60fd25f1deed6d48022567cd7100f | [
"Apache-2.0"
] | null | null | null | flite/lang/us_rms/us_rms_cg_f0_trees.hpp | Barath-Kannan/flite | 236f91a9a1e60fd25f1deed6d48022567cd7100f | [
"Apache-2.0"
] | 3 | 2018-10-28T03:47:09.000Z | 2020-06-04T08:54:23.000Z | #pragma once
#include "flite/utils/val_const.hpp"
DEF_STATIC_CONST_VAL_FLOAT(val_0000, 0.556047);
DEF_STATIC_CONST_VAL_FLOAT(val_0001, 110.412003);
#define CTNODE_cmu_us_rms_f0_zh_204_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_0002, 97.185600);
DEF_STATIC_CONST_VAL_FLOAT(val_0003, 100.119003);
DEF_STATIC_CONST_VAL_FLOAT(val_0004, 100.661003);
DEF_STATIC_CONST_VAL_FLOAT(val_0005, 0.495560);
DEF_STATIC_CONST_VAL_FLOAT(val_0006, 0.128000);
DEF_STATIC_CONST_VAL_FLOAT(val_0007, 112.811996);
#define CTNODE_cmu_us_rms_f0_oy_131_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0008, 51.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0009, 100.893997);
#define CTNODE_cmu_us_rms_f0_oy_131_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0010, 106.808998);
#define CTNODE_cmu_us_rms_f0_oy_131_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_0011, 0.766811);
DEF_STATIC_CONST_VAL_STRING(val_0012, "content");
DEF_STATIC_CONST_VAL_FLOAT(val_0013, 102.051003);
#define CTNODE_cmu_us_rms_f0_oy_131_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0014, 94.275597);
#define CTNODE_cmu_us_rms_f0_oy_131_NO_0006 10
DEF_STATIC_CONST_VAL_FLOAT(val_0015, 89.268501);
DEF_STATIC_CONST_VAL_FLOAT(val_0016, 0.793674);
DEF_STATIC_CONST_VAL_STRING(val_0017, "-");
DEF_STATIC_CONST_VAL_FLOAT(val_0018, 96.056000);
#define CTNODE_cmu_us_rms_f0_oy_132_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0019, 106.685997);
#define CTNODE_cmu_us_rms_f0_oy_132_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0020, 84.912498);
DEF_STATIC_CONST_VAL_FLOAT(val_0021, 35.200001);
DEF_STATIC_CONST_VAL_FLOAT(val_0022, 104.902000);
#define CTNODE_cmu_us_rms_f0_oy_133_NO_0000 2
DEF_STATIC_CONST_VAL_STRING(val_0023, "b");
DEF_STATIC_CONST_VAL_FLOAT(val_0024, 82.202599);
#define CTNODE_cmu_us_rms_f0_oy_133_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0025, 89.678001);
#define CTNODE_cmu_us_rms_f0_oy_133_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0026, 102.782997);
DEF_STATIC_CONST_VAL_FLOAT(val_0027, 0.190115);
DEF_STATIC_CONST_VAL_FLOAT(val_0028, 123.052002);
#define CTNODE_cmu_us_rms_f0_ch_41_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_0029, 111.883003);
#define CTNODE_cmu_us_rms_f0_ch_41_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0030, 26.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0031, 0.486837);
DEF_STATIC_CONST_VAL_FLOAT(val_0032, 109.185997);
#define CTNODE_cmu_us_rms_f0_ch_41_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0033, 0.056000);
DEF_STATIC_CONST_VAL_FLOAT(val_0034, 100.605003);
#define CTNODE_cmu_us_rms_f0_ch_41_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0035, 93.922302);
#define CTNODE_cmu_us_rms_f0_ch_41_NO_0004 10
DEF_STATIC_CONST_VAL_FLOAT(val_0036, 89.520302);
DEF_STATIC_CONST_VAL_FLOAT(val_0037, 0.201523);
DEF_STATIC_CONST_VAL_FLOAT(val_0038, 13.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0039, 135.069000);
#define CTNODE_cmu_us_rms_f0_ch_42_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0040, 123.934998);
#define CTNODE_cmu_us_rms_f0_ch_42_NO_0000 4
DEF_STATIC_CONST_VAL_STRING(val_0041, "0");
DEF_STATIC_CONST_VAL_STRING(val_0042, "a");
DEF_STATIC_CONST_VAL_FLOAT(val_0043, 103.030998);
#define CTNODE_cmu_us_rms_f0_ch_42_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0044, 122.855003);
#define CTNODE_cmu_us_rms_f0_ch_42_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0045, 0.742564);
DEF_STATIC_CONST_VAL_FLOAT(val_0046, 0.601250);
DEF_STATIC_CONST_VAL_FLOAT(val_0047, 110.195000);
#define CTNODE_cmu_us_rms_f0_ch_42_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0048, 118.990997);
#define CTNODE_cmu_us_rms_f0_ch_42_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_0049, 102.987000);
#define CTNODE_cmu_us_rms_f0_ch_42_NO_0004 14
DEF_STATIC_CONST_VAL_FLOAT(val_0050, 94.425301);
DEF_STATIC_CONST_VAL_FLOAT(val_0051, 1.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0052, 126.111000);
#define CTNODE_cmu_us_rms_f0_ch_43_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0053, 113.815002);
#define CTNODE_cmu_us_rms_f0_ch_43_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0054, 105.318001);
DEF_STATIC_CONST_VAL_STRING(val_0055, "f");
DEF_STATIC_CONST_VAL_FLOAT(val_0056, 0.297878);
DEF_STATIC_CONST_VAL_FLOAT(val_0057, 116.084999);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0058, 102.650002);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0059, 0.110000);
DEF_STATIC_CONST_VAL_FLOAT(val_0060, 91.957100);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0061, 14.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0062, 85.733200);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0063, 87.349800);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0004 10
DEF_STATIC_CONST_VAL_FLOAT(val_0064, 0.181057);
DEF_STATIC_CONST_VAL_FLOAT(val_0065, 101.349998);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0011 13
DEF_STATIC_CONST_VAL_STRING(val_0066, "in");
DEF_STATIC_CONST_VAL_FLOAT(val_0067, 83.487999);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0068, 91.102997);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0010 16
DEF_STATIC_CONST_VAL_FLOAT(val_0069, 107.222000);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0070, 104.516998);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_0071, 0.124000);
DEF_STATIC_CONST_VAL_FLOAT(val_0072, 95.762299);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0073, 90.788399);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_0074, 99.149597);
#define CTNODE_cmu_us_rms_f0_aw_21_NO_0020 26
DEF_STATIC_CONST_VAL_FLOAT(val_0075, 106.454002);
DEF_STATIC_CONST_VAL_FLOAT(val_0076, 1.194000);
DEF_STATIC_CONST_VAL_FLOAT(val_0077, 0.052000);
DEF_STATIC_CONST_VAL_FLOAT(val_0078, 106.306000);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0079, 15.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0080, 109.782997);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0081, 116.206001);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_0082, 0.707500);
DEF_STATIC_CONST_VAL_FLOAT(val_0083, 103.750999);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0084, 98.533897);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0000 10
DEF_STATIC_CONST_VAL_STRING(val_0085, "3");
DEF_STATIC_CONST_VAL_FLOAT(val_0086, 81.110298);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0087, 1.619500);
DEF_STATIC_CONST_VAL_FLOAT(val_0088, 7.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0089, 96.322701);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0090, 100.746002);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0012 16
DEF_STATIC_CONST_VAL_FLOAT(val_0091, 91.610603);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0092, 97.831497);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_0093, 0.091000);
DEF_STATIC_CONST_VAL_FLOAT(val_0094, 88.987198);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0095, 12.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_0096, 93.922699);
#define CTNODE_cmu_us_rms_f0_aw_22_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0097, 92.086197);
DEF_STATIC_CONST_VAL_STRING(val_0098, "n");
DEF_STATIC_CONST_VAL_FLOAT(val_0099, 90.851501);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0100, 82.106598);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_0101, 0.083000);
DEF_STATIC_CONST_VAL_STRING(val_0102, "s");
DEF_STATIC_CONST_VAL_FLOAT(val_0103, 106.176003);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0104, 0.057500);
DEF_STATIC_CONST_VAL_FLOAT(val_0105, 99.655197);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0106, 93.230400);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0005 11
DEF_STATIC_CONST_VAL_FLOAT(val_0107, 0.340656);
DEF_STATIC_CONST_VAL_FLOAT(val_0108, 0.053500);
DEF_STATIC_CONST_VAL_FLOAT(val_0109, 94.941200);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0110, 107.067001);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0011 15
DEF_STATIC_CONST_VAL_STRING(val_0111, "2");
DEF_STATIC_CONST_VAL_FLOAT(val_0112, 92.366096);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0113, 81.174797);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0000 18
DEF_STATIC_CONST_VAL_FLOAT(val_0114, 0.629253);
DEF_STATIC_CONST_VAL_FLOAT(val_0115, 81.871803);
#define CTNODE_cmu_us_rms_f0_aw_23_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_0116, 75.684998);
DEF_STATIC_CONST_VAL_FLOAT(val_0117, 0.062000);
DEF_STATIC_CONST_VAL_FLOAT(val_0118, 79.334198);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0119, 90.116501);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0120, 3.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0121, 120.265999);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0122, 0.387074);
DEF_STATIC_CONST_VAL_FLOAT(val_0123, 103.396004);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0124, 113.748001);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_0125, 102.021004);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0004 12
DEF_STATIC_CONST_VAL_STRING(val_0126, "final");
DEF_STATIC_CONST_VAL_FLOAT(val_0127, 0.053000);
DEF_STATIC_CONST_VAL_FLOAT(val_0128, 99.763702);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0129, 87.343803);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0012 16
DEF_STATIC_CONST_VAL_STRING(val_0130, "pau_161");
DEF_STATIC_CONST_VAL_FLOAT(val_0131, 93.563202);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_0132, 12.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0133, 107.767998);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0018 20
DEF_STATIC_CONST_VAL_STRING(val_0134, "initial");
DEF_STATIC_CONST_VAL_FLOAT(val_0135, 0.185711);
DEF_STATIC_CONST_VAL_FLOAT(val_0136, 113.249001);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_0137, 100.709999);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_0138, 0.068000);
DEF_STATIC_CONST_VAL_FLOAT(val_0139, 6.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0140, 101.274002);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_0141, 105.323997);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_0142, 106.478996);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0025 31
DEF_STATIC_CONST_VAL_FLOAT(val_0143, 99.647102);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0024 32
DEF_STATIC_CONST_VAL_FLOAT(val_0144, 0.281055);
DEF_STATIC_CONST_VAL_FLOAT(val_0145, 103.306000);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_0146, 0.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_0147, 97.450897);
#define CTNODE_cmu_us_rms_f0_ow_126_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_0148, 92.747704);
DEF_STATIC_CONST_VAL_FLOAT(val_0149, 1.091000);
DEF_STATIC_CONST_VAL_FLOAT(val_0150, 91.225899);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0151, 108.320000);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0152, 99.957497);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0001 7
DEF_STATIC_CONST_VAL_STRING(val_0153, "coda");
DEF_STATIC_CONST_VAL_FLOAT(val_0154, 112.358002);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0155, 101.995003);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_0156, 0.092500);
DEF_STATIC_CONST_VAL_FLOAT(val_0157, 119.670998);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0158, 114.464996);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0159, 107.113998);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0000 16
DEF_STATIC_CONST_VAL_FLOAT(val_0160, 19.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0161, 1.875000);
DEF_STATIC_CONST_VAL_FLOAT(val_0162, 100.263000);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_0163, 106.605003);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_0164, 0.391447);
DEF_STATIC_CONST_VAL_FLOAT(val_0165, 94.037903);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_0166, 90.817703);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_0167, 95.300499);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_0168, 100.113998);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0017 29
DEF_STATIC_CONST_VAL_FLOAT(val_0169, 0.115000);
DEF_STATIC_CONST_VAL_FLOAT(val_0170, 2.249000);
DEF_STATIC_CONST_VAL_FLOAT(val_0171, 99.092300);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_0172, 90.178703);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0029 33
DEF_STATIC_CONST_VAL_FLOAT(val_0173, 0.164500);
DEF_STATIC_CONST_VAL_FLOAT(val_0174, 90.829498);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_0175, 82.671898);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0016 36
DEF_STATIC_CONST_VAL_FLOAT(val_0176, 80.801903);
#define CTNODE_cmu_us_rms_f0_ow_127_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_0177, 88.541298);
DEF_STATIC_CONST_VAL_FLOAT(val_0178, 78.571899);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0179, 86.015198);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0180, 112.628998);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0181, 39.599998);
DEF_STATIC_CONST_VAL_FLOAT(val_0182, 91.845703);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0007 9
DEF_STATIC_CONST_VAL_STRING(val_0183, "l");
DEF_STATIC_CONST_VAL_FLOAT(val_0184, 112.364998);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0185, 109.672997);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0186, 0.490626);
DEF_STATIC_CONST_VAL_FLOAT(val_0187, 108.889999);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0188, 98.365402);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0013 17
DEF_STATIC_CONST_VAL_FLOAT(val_0189, 0.022500);
DEF_STATIC_CONST_VAL_FLOAT(val_0190, 101.191002);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0191, 93.643600);
#define CTNODE_cmu_us_rms_f0_ow_128_NO_0006 20
DEF_STATIC_CONST_VAL_FLOAT(val_0192, 84.819099);
DEF_STATIC_CONST_VAL_FLOAT(val_0193, 0.038000);
DEF_STATIC_CONST_VAL_FLOAT(val_0194, 112.082001);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0195, 0.462985);
DEF_STATIC_CONST_VAL_FLOAT(val_0196, 16.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0197, 97.938499);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0198, 92.744202);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_0199, 107.223999);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0003 9
DEF_STATIC_CONST_VAL_FLOAT(val_0200, 94.200996);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0201, 87.863297);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0000 12
DEF_STATIC_CONST_VAL_FLOAT(val_0202, 82.108597);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0203, 79.447098);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0012 16
DEF_STATIC_CONST_VAL_STRING(val_0204, "ax_28");
DEF_STATIC_CONST_VAL_FLOAT(val_0205, 90.434502);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0206, 0.489271);
DEF_STATIC_CONST_VAL_FLOAT(val_0207, 88.211800);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_0208, 82.175903);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0016 22
DEF_STATIC_CONST_VAL_FLOAT(val_0209, 0.115872);
DEF_STATIC_CONST_VAL_FLOAT(val_0210, 99.746300);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0211, 0.411363);
DEF_STATIC_CONST_VAL_STRING(val_0212, "1");
DEF_STATIC_CONST_VAL_FLOAT(val_0213, 94.720398);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_0214, 98.545898);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_0215, 90.020500);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0024 30
DEF_STATIC_CONST_VAL_FLOAT(val_0216, 91.610703);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_0217, 86.251900);
#define CTNODE_cmu_us_rms_f0_b_36_NO_0030 34
DEF_STATIC_CONST_VAL_FLOAT(val_0218, 82.448502);
DEF_STATIC_CONST_VAL_FLOAT(val_0219, 105.348000);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0220, 0.532570);
DEF_STATIC_CONST_VAL_FLOAT(val_0221, 105.745003);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0222, 111.995003);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_0223, 0.415637);
DEF_STATIC_CONST_VAL_FLOAT(val_0224, 126.660004);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0225, 111.691002);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_0226, 110.616997);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0000 12
DEF_STATIC_CONST_VAL_FLOAT(val_0227, 2.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_0228, 2.284000);
DEF_STATIC_CONST_VAL_FLOAT(val_0229, 96.357903);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0230, 88.632500);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0012 16
DEF_STATIC_CONST_VAL_FLOAT(val_0231, 2.362500);
DEF_STATIC_CONST_VAL_FLOAT(val_0232, 103.565002);
#define CTNODE_cmu_us_rms_f0_b_37_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_0233, 96.094002);
DEF_STATIC_CONST_VAL_FLOAT(val_0234, 17.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0235, 0.027500);
DEF_STATIC_CONST_VAL_FLOAT(val_0236, 111.337997);
#define CTNODE_cmu_us_rms_f0_b_38_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0237, 116.870003);
#define CTNODE_cmu_us_rms_f0_b_38_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_0238, 103.301003);
#define CTNODE_cmu_us_rms_f0_b_38_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_0239, 0.018500);
DEF_STATIC_CONST_VAL_FLOAT(val_0240, 98.172203);
#define CTNODE_cmu_us_rms_f0_b_38_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0241, 94.497803);
#define CTNODE_cmu_us_rms_f0_b_38_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_0242, 87.666199);
#define CTNODE_cmu_us_rms_f0_b_38_NO_0006 12
DEF_STATIC_CONST_VAL_FLOAT(val_0243, 105.417999);
DEF_STATIC_CONST_VAL_FLOAT(val_0244, 85.469101);
#define CTNODE_cmu_us_rms_f0_g_76_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_0245, 89.214203);
#define CTNODE_cmu_us_rms_f0_g_76_NO_0002 4
DEF_STATIC_CONST_VAL_STRING(val_0246, "+");
DEF_STATIC_CONST_VAL_FLOAT(val_0247, 88.426399);
#define CTNODE_cmu_us_rms_f0_g_76_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0248, 95.366402);
#define CTNODE_cmu_us_rms_f0_g_76_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_0249, 0.512908);
DEF_STATIC_CONST_VAL_FLOAT(val_0250, 103.683998);
#define CTNODE_cmu_us_rms_f0_g_76_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0251, 90.327301);
DEF_STATIC_CONST_VAL_STRING(val_0252, "pau");
DEF_STATIC_CONST_VAL_FLOAT(val_0253, 119.968002);
#define CTNODE_cmu_us_rms_f0_g_77_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_0254, 103.091003);
#define CTNODE_cmu_us_rms_f0_g_77_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0255, 2.345000);
DEF_STATIC_CONST_VAL_FLOAT(val_0256, 90.024300);
#define CTNODE_cmu_us_rms_f0_g_77_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0257, 97.058098);
#define CTNODE_cmu_us_rms_f0_g_77_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_0258, 86.722900);
DEF_STATIC_CONST_VAL_FLOAT(val_0259, 11.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0260, 118.584000);
#define CTNODE_cmu_us_rms_f0_g_78_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0261, 111.521004);
#define CTNODE_cmu_us_rms_f0_g_78_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0262, 0.018000);
DEF_STATIC_CONST_VAL_FLOAT(val_0263, 0.233708);
DEF_STATIC_CONST_VAL_FLOAT(val_0264, 102.003998);
#define CTNODE_cmu_us_rms_f0_g_78_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0265, 0.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0266, 90.612396);
#define CTNODE_cmu_us_rms_f0_g_78_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0267, 95.824097);
#define CTNODE_cmu_us_rms_f0_g_78_NO_0005 11
DEF_STATIC_CONST_VAL_FLOAT(val_0268, 101.393997);
#define CTNODE_cmu_us_rms_f0_g_78_NO_0004 12
DEF_STATIC_CONST_VAL_FLOAT(val_0269, 110.636002);
#define CTNODE_cmu_us_rms_f0_g_78_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0270, 100.689003);
DEF_STATIC_CONST_VAL_FLOAT(val_0271, 0.047000);
DEF_STATIC_CONST_VAL_FLOAT(val_0272, 0.360444);
DEF_STATIC_CONST_VAL_FLOAT(val_0273, 112.453003);
#define CTNODE_cmu_us_rms_f0_ng_121_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0274, 93.301804);
#define CTNODE_cmu_us_rms_f0_ng_121_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0275, 101.432999);
#define CTNODE_cmu_us_rms_f0_ng_121_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_0276, 0.069000);
DEF_STATIC_CONST_VAL_FLOAT(val_0277, 96.741096);
#define CTNODE_cmu_us_rms_f0_ng_121_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0278, 26.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0279, 92.096901);
#define CTNODE_cmu_us_rms_f0_ng_121_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0280, 85.361397);
#define CTNODE_cmu_us_rms_f0_ng_121_NO_0006 12
DEF_STATIC_CONST_VAL_FLOAT(val_0281, 79.210403);
DEF_STATIC_CONST_VAL_FLOAT(val_0282, 0.837000);
DEF_STATIC_CONST_VAL_FLOAT(val_0283, 0.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0284, 110.042000);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0285, 107.598999);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0286, 2.703000);
DEF_STATIC_CONST_VAL_FLOAT(val_0287, 69.457100);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0288, 79.233597);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_0289, 0.075000);
DEF_STATIC_CONST_VAL_FLOAT(val_0290, 0.422361);
DEF_STATIC_CONST_VAL_FLOAT(val_0291, 97.480003);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0292, 0.024000);
DEF_STATIC_CONST_VAL_FLOAT(val_0293, 0.732303);
DEF_STATIC_CONST_VAL_FLOAT(val_0294, 93.354301);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0295, 88.117599);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0012 16
DEF_STATIC_CONST_VAL_FLOAT(val_0296, 85.993896);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0009 17
DEF_STATIC_CONST_VAL_FLOAT(val_0297, 0.013500);
DEF_STATIC_CONST_VAL_FLOAT(val_0298, 104.508003);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_0299, 100.998001);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_0300, 94.007301);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0008 22
DEF_STATIC_CONST_VAL_FLOAT(val_0301, 24.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0302, 84.278099);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_0303, 80.863701);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_0304, 88.878799);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0022 28
DEF_STATIC_CONST_VAL_FLOAT(val_0305, 11.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0306, 94.306801);
#define CTNODE_cmu_us_rms_f0_ng_122_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_0307, 87.638603);
DEF_STATIC_CONST_VAL_FLOAT(val_0308, 0.061000);
DEF_STATIC_CONST_VAL_FLOAT(val_0309, 103.919998);
#define CTNODE_cmu_us_rms_f0_ng_123_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0310, 0.021500);
DEF_STATIC_CONST_VAL_FLOAT(val_0311, 93.502998);
#define CTNODE_cmu_us_rms_f0_ng_123_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0312, 87.065804);
#define CTNODE_cmu_us_rms_f0_ng_123_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0313, 83.382202);
#define CTNODE_cmu_us_rms_f0_ng_123_NO_0000 8
DEF_STATIC_CONST_VAL_FLOAT(val_0314, 0.726168);
DEF_STATIC_CONST_VAL_FLOAT(val_0315, 87.667801);
#define CTNODE_cmu_us_rms_f0_ng_123_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0316, 81.154800);
#define CTNODE_cmu_us_rms_f0_ng_123_NO_0008 12
DEF_STATIC_CONST_VAL_FLOAT(val_0317, 78.613800);
DEF_STATIC_CONST_VAL_FLOAT(val_0318, 0.398913);
DEF_STATIC_CONST_VAL_FLOAT(val_0319, 125.345001);
#define CTNODE_cmu_us_rms_f0_uw_179_NO_0001 3
DEF_STATIC_CONST_VAL_STRING(val_0320, "y_196");
DEF_STATIC_CONST_VAL_FLOAT(val_0321, 103.985001);
#define CTNODE_cmu_us_rms_f0_uw_179_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0322, 112.973999);
#define CTNODE_cmu_us_rms_f0_uw_179_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_0323, 89.602898);
#define CTNODE_cmu_us_rms_f0_uw_179_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0324, 95.579697);
#define CTNODE_cmu_us_rms_f0_uw_179_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0325, 115.186996);
#define CTNODE_cmu_us_rms_f0_uw_179_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0326, 103.429001);
#define CTNODE_cmu_us_rms_f0_uw_179_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0327, 103.216003);
DEF_STATIC_CONST_VAL_FLOAT(val_0328, 0.201403);
DEF_STATIC_CONST_VAL_STRING(val_0329, "p");
DEF_STATIC_CONST_VAL_FLOAT(val_0330, 110.976997);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0331, 125.470001);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0332, 132.214005);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_0333, 0.504772);
DEF_STATIC_CONST_VAL_FLOAT(val_0334, 114.580002);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0335, 107.309998);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0336, 102.028999);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0007 13
DEF_STATIC_CONST_VAL_FLOAT(val_0337, 107.686996);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0338, 94.069504);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0339, 98.024803);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0340, 104.556000);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0006 20
DEF_STATIC_CONST_VAL_FLOAT(val_0341, 86.103798);
#define CTNODE_cmu_us_rms_f0_uw_180_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0342, 96.714401);
DEF_STATIC_CONST_VAL_FLOAT(val_0343, 0.205044);
DEF_STATIC_CONST_VAL_FLOAT(val_0344, 118.056000);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0000 2
DEF_STATIC_CONST_VAL_STRING(val_0345, "pau_141");
DEF_STATIC_CONST_VAL_STRING(val_0346, "y");
DEF_STATIC_CONST_VAL_FLOAT(val_0347, 82.100304);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0348, 75.252701);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_0349, 0.812665);
DEF_STATIC_CONST_VAL_FLOAT(val_0350, 89.559700);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0351, 95.095596);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_0352, 106.833000);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0353, 95.875198);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0012 16
DEF_STATIC_CONST_VAL_FLOAT(val_0354, 112.982002);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0011 17
DEF_STATIC_CONST_VAL_FLOAT(val_0355, 93.802902);
#define CTNODE_cmu_us_rms_f0_uw_181_NO_0006 18
DEF_STATIC_CONST_VAL_FLOAT(val_0356, 89.791801);
DEF_STATIC_CONST_VAL_FLOAT(val_0357, 0.372903);
DEF_STATIC_CONST_VAL_FLOAT(val_0358, 130.764999);
#define CTNODE_cmu_us_rms_f0_sh_156_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0359, 111.002998);
#define CTNODE_cmu_us_rms_f0_sh_156_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0360, 0.496583);
DEF_STATIC_CONST_VAL_FLOAT(val_0361, 105.417000);
#define CTNODE_cmu_us_rms_f0_sh_156_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0362, 95.190498);
DEF_STATIC_CONST_VAL_FLOAT(val_0363, 0.136000);
DEF_STATIC_CONST_VAL_FLOAT(val_0364, 145.809006);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0365, 137.531006);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_0366, 0.505351);
DEF_STATIC_CONST_VAL_FLOAT(val_0367, 129.531006);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0368, 111.544998);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_0369, 130.802994);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_0370, 11.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0371, 0.409401);
DEF_STATIC_CONST_VAL_FLOAT(val_0372, 0.183377);
DEF_STATIC_CONST_VAL_FLOAT(val_0373, 118.457001);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0374, 112.843002);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0375, 100.348999);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0011 17
DEF_STATIC_CONST_VAL_FLOAT(val_0376, 7.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0377, 91.441704);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_0378, 96.801399);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_0379, 0.020000);
DEF_STATIC_CONST_VAL_FLOAT(val_0380, 101.512001);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0381, 108.133003);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_0382, 98.277702);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0010 26
DEF_STATIC_CONST_VAL_FLOAT(val_0383, 0.624947);
DEF_STATIC_CONST_VAL_FLOAT(val_0384, 119.844002);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_0385, 108.080002);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_0386, 20.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0387, 0.352171);
DEF_STATIC_CONST_VAL_FLOAT(val_0388, 124.288002);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_0389, 114.953003);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0031 35
DEF_STATIC_CONST_VAL_FLOAT(val_0390, 132.572998);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0026 36
DEF_STATIC_CONST_VAL_FLOAT(val_0391, 99.801003);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_0392, 103.441002);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_0393, 111.809998);
#define CTNODE_cmu_us_rms_f0_sh_157_NO_0038 42
DEF_STATIC_CONST_VAL_FLOAT(val_0394, 118.605003);
DEF_STATIC_CONST_VAL_FLOAT(val_0395, 0.062000);
DEF_STATIC_CONST_VAL_FLOAT(val_0396, 0.424309);
DEF_STATIC_CONST_VAL_FLOAT(val_0397, 120.375000);
#define CTNODE_cmu_us_rms_f0_sh_158_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0398, 99.450104);
#define CTNODE_cmu_us_rms_f0_sh_158_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0399, 112.852997);
#define CTNODE_cmu_us_rms_f0_sh_158_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_0400, 112.115997);
#define CTNODE_cmu_us_rms_f0_sh_158_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0401, 26.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_0402, 124.806000);
#define CTNODE_cmu_us_rms_f0_sh_158_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0403, 133.751999);
DEF_STATIC_CONST_VAL_FLOAT(val_0404, 0.775756);
DEF_STATIC_CONST_VAL_FLOAT(val_0405, 107.029999);
#define CTNODE_cmu_us_rms_f0_uh_174_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0406, 123.116997);
#define CTNODE_cmu_us_rms_f0_uh_174_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0407, 93.253998);
DEF_STATIC_CONST_VAL_FLOAT(val_0408, 0.210787);
DEF_STATIC_CONST_VAL_FLOAT(val_0409, 119.434998);
#define CTNODE_cmu_us_rms_f0_uh_175_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_0410, 9.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0411, 106.973999);
#define CTNODE_cmu_us_rms_f0_uh_175_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0412, 96.044998);
DEF_STATIC_CONST_VAL_FLOAT(val_0413, 0.225207);
DEF_STATIC_CONST_VAL_FLOAT(val_0414, 119.119003);
#define CTNODE_cmu_us_rms_f0_uh_176_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_0415, 95.050697);
#define CTNODE_cmu_us_rms_f0_uh_176_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0416, 109.110001);
DEF_STATIC_CONST_VAL_FLOAT(val_0417, 0.047000);
DEF_STATIC_CONST_VAL_FLOAT(val_0418, 0.268421);
DEF_STATIC_CONST_VAL_FLOAT(val_0419, 129.727997);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0420, 128.529999);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_0421, 123.850998);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_0422, 135.570007);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0000 8
DEF_STATIC_CONST_VAL_STRING(val_0423, "pau_142");
DEF_STATIC_CONST_VAL_FLOAT(val_0424, 109.113998);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0425, 8.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0426, 0.303952);
DEF_STATIC_CONST_VAL_FLOAT(val_0427, 5.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0428, 107.030998);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0429, 102.801003);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_0430, 98.216202);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0431, 92.405602);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0010 18
DEF_STATIC_CONST_VAL_FLOAT(val_0432, 0.482399);
DEF_STATIC_CONST_VAL_FLOAT(val_0433, 96.009499);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_0434, 88.744904);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_0435, 0.067500);
DEF_STATIC_CONST_VAL_FLOAT(val_0436, 81.314796);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_0437, 85.297798);
#define CTNODE_cmu_us_rms_f0_hh_81_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_0438, 90.661598);
DEF_STATIC_CONST_VAL_FLOAT(val_0439, 0.012000);
DEF_STATIC_CONST_VAL_FLOAT(val_0440, 131.423996);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0441, 135.602997);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_0442, 139.953003);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_0443, 118.932999);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0000 8
DEF_STATIC_CONST_VAL_FLOAT(val_0444, 11.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0445, 0.069000);
DEF_STATIC_CONST_VAL_FLOAT(val_0446, 97.236099);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0447, 107.133003);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_0448, 114.774002);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0008 14
DEF_STATIC_CONST_VAL_FLOAT(val_0449, 15.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0450, 3.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0451, 0.484999);
DEF_STATIC_CONST_VAL_FLOAT(val_0452, 102.042999);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_0453, 92.933403);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0015 19
DEF_STATIC_CONST_VAL_FLOAT(val_0454, 83.014297);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0455, 0.072500);
DEF_STATIC_CONST_VAL_FLOAT(val_0456, 89.728897);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0457, 99.911797);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0019 25
DEF_STATIC_CONST_VAL_FLOAT(val_0458, 88.652298);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_0459, 0.474889);
DEF_STATIC_CONST_VAL_FLOAT(val_0460, 80.567001);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_0461, 77.612198);
#define CTNODE_cmu_us_rms_f0_hh_82_NO_0014 30
DEF_STATIC_CONST_VAL_FLOAT(val_0462, 106.289001);
DEF_STATIC_CONST_VAL_FLOAT(val_0463, 132.485001);
#define CTNODE_cmu_us_rms_f0_hh_83_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_0464, 15.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0465, 2.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0466, 0.219471);
DEF_STATIC_CONST_VAL_FLOAT(val_0467, 108.734001);
#define CTNODE_cmu_us_rms_f0_hh_83_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0468, 0.734588);
DEF_STATIC_CONST_VAL_FLOAT(val_0469, 102.223000);
#define CTNODE_cmu_us_rms_f0_hh_83_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0470, 96.788803);
#define CTNODE_cmu_us_rms_f0_hh_83_NO_0006 10
DEF_STATIC_CONST_VAL_FLOAT(val_0471, 92.873596);
#define CTNODE_cmu_us_rms_f0_hh_83_NO_0003 11
DEF_STATIC_CONST_VAL_FLOAT(val_0472, 0.582813);
DEF_STATIC_CONST_VAL_FLOAT(val_0473, 93.184097);
#define CTNODE_cmu_us_rms_f0_hh_83_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0474, 85.354897);
#define CTNODE_cmu_us_rms_f0_hh_83_NO_0002 14
DEF_STATIC_CONST_VAL_FLOAT(val_0475, 109.477997);
DEF_STATIC_CONST_VAL_FLOAT(val_0476, 0.276786);
DEF_STATIC_CONST_VAL_FLOAT(val_0477, 0.194007);
DEF_STATIC_CONST_VAL_FLOAT(val_0478, 0.116729);
DEF_STATIC_CONST_VAL_FLOAT(val_0479, 102.825996);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0480, 111.200996);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_0481, 98.200104);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_0482, 105.433998);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0483, 109.961998);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0484, 122.007004);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0000 12
DEF_STATIC_CONST_VAL_STRING(val_0485, "k_103");
DEF_STATIC_CONST_VAL_FLOAT(val_0486, 110.486000);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0487, 0.099000);
DEF_STATIC_CONST_VAL_FLOAT(val_0488, 0.104000);
DEF_STATIC_CONST_VAL_FLOAT(val_0489, 0.611920);
DEF_STATIC_CONST_VAL_FLOAT(val_0490, 0.073000);
DEF_STATIC_CONST_VAL_FLOAT(val_0491, 0.057000);
DEF_STATIC_CONST_VAL_FLOAT(val_0492, 0.040000);
DEF_STATIC_CONST_VAL_FLOAT(val_0493, 97.190399);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_0494, 102.070000);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_0495, 93.288803);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0019 25
DEF_STATIC_CONST_VAL_FLOAT(val_0496, 103.982002);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0018 26
DEF_STATIC_CONST_VAL_FLOAT(val_0497, 93.398697);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0017 27
DEF_STATIC_CONST_VAL_FLOAT(val_0498, 89.217201);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_0499, 95.474197);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_0500, 86.761002);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0016 32
DEF_STATIC_CONST_VAL_FLOAT(val_0501, 0.124500);
DEF_STATIC_CONST_VAL_FLOAT(val_0502, 0.255556);
DEF_STATIC_CONST_VAL_FLOAT(val_0503, 79.302101);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_0504, 89.852699);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_0505, 93.564697);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0015 37
DEF_STATIC_CONST_VAL_FLOAT(val_0506, 0.609322);
DEF_STATIC_CONST_VAL_FLOAT(val_0507, 96.348900);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_0508, 90.770103);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0037 41
DEF_STATIC_CONST_VAL_STRING(val_0509, "hh_83");
DEF_STATIC_CONST_VAL_FLOAT(val_0510, 0.605562);
DEF_STATIC_CONST_VAL_FLOAT(val_0511, 104.855003);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_0512, 98.660301);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0041 45
DEF_STATIC_CONST_VAL_FLOAT(val_0513, 111.644997);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0014 46
DEF_STATIC_CONST_VAL_FLOAT(val_0514, 0.083721);
DEF_STATIC_CONST_VAL_FLOAT(val_0515, 101.450996);
#define CTNODE_cmu_us_rms_f0_ae_6_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_0516, 108.280998);
DEF_STATIC_CONST_VAL_FLOAT(val_0517, 0.431552);
DEF_STATIC_CONST_VAL_FLOAT(val_0518, 1.125000);
DEF_STATIC_CONST_VAL_STRING(val_0519, "cc");
DEF_STATIC_CONST_VAL_FLOAT(val_0520, 0.020000);
DEF_STATIC_CONST_VAL_FLOAT(val_0521, 0.191000);
DEF_STATIC_CONST_VAL_FLOAT(val_0522, 0.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_0523, 101.721001);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0524, 0.172500);
DEF_STATIC_CONST_VAL_FLOAT(val_0525, 98.432297);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0526, 100.254997);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0005 11
DEF_STATIC_CONST_VAL_FLOAT(val_0527, 103.016998);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0004 12
DEF_STATIC_CONST_VAL_FLOAT(val_0528, 96.755302);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0003 13
DEF_STATIC_CONST_VAL_FLOAT(val_0529, 10.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0530, 101.667999);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0531, 104.772003);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0002 16
DEF_STATIC_CONST_VAL_FLOAT(val_0532, 0.395161);
DEF_STATIC_CONST_VAL_FLOAT(val_0533, 94.851799);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_0534, 90.110901);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0001 19
DEF_STATIC_CONST_VAL_FLOAT(val_0535, 0.656000);
DEF_STATIC_CONST_VAL_FLOAT(val_0536, 16.299999);
DEF_STATIC_CONST_VAL_FLOAT(val_0537, 107.419998);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_0538, 102.870003);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_0539, 102.072998);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_0540, 95.931000);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0019 27
DEF_STATIC_CONST_VAL_FLOAT(val_0541, 0.442500);
DEF_STATIC_CONST_VAL_FLOAT(val_0542, 0.500769);
DEF_STATIC_CONST_VAL_FLOAT(val_0543, 115.102997);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_0544, 107.081001);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0028 32
DEF_STATIC_CONST_VAL_FLOAT(val_0545, 0.396000);
DEF_STATIC_CONST_VAL_FLOAT(val_0546, 106.959999);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_0547, 98.571701);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0027 35
DEF_STATIC_CONST_VAL_FLOAT(val_0548, 0.308101);
DEF_STATIC_CONST_VAL_FLOAT(val_0549, 117.459999);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_0550, 110.862999);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0000 38
DEF_STATIC_CONST_VAL_FLOAT(val_0551, 0.793576);
DEF_STATIC_CONST_VAL_FLOAT(val_0552, 101.289001);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_0553, 107.319000);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0040 44
DEF_STATIC_CONST_VAL_FLOAT(val_0554, 98.249298);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0039 45
DEF_STATIC_CONST_VAL_FLOAT(val_0555, 95.975800);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_0556, 89.795700);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0038 48
DEF_STATIC_CONST_VAL_FLOAT(val_0557, 9.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0558, 0.637107);
DEF_STATIC_CONST_VAL_FLOAT(val_0559, 99.381401);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_0560, 0.536574);
DEF_STATIC_CONST_VAL_FLOAT(val_0561, 94.842003);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_0562, 94.392502);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0052 56
DEF_STATIC_CONST_VAL_FLOAT(val_0563, 5.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0564, 92.384003);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0056 58
DEF_STATIC_CONST_VAL_FLOAT(val_0565, 90.986000);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0049 59
DEF_STATIC_CONST_VAL_FLOAT(val_0566, 0.400124);
DEF_STATIC_CONST_VAL_FLOAT(val_0567, 95.181999);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_0568, 2.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0569, 92.765900);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_0570, 88.808296);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0059 65
DEF_STATIC_CONST_VAL_FLOAT(val_0571, 9.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_0572, 87.453102);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_0573, 91.014801);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0048 68
DEF_STATIC_CONST_VAL_FLOAT(val_0574, 0.851287);
DEF_STATIC_CONST_VAL_FLOAT(val_0575, 0.641399);
DEF_STATIC_CONST_VAL_FLOAT(val_0576, 89.119003);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0070 72
DEF_STATIC_CONST_VAL_FLOAT(val_0577, 92.095100);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0069 73
DEF_STATIC_CONST_VAL_FLOAT(val_0578, 87.561501);
#define CTNODE_cmu_us_rms_f0_ae_7_NO_0068 74
DEF_STATIC_CONST_VAL_FLOAT(val_0579, 82.413498);
DEF_STATIC_CONST_VAL_FLOAT(val_0580, 0.277460);
DEF_STATIC_CONST_VAL_FLOAT(val_0581, 36.799999);
DEF_STATIC_CONST_VAL_FLOAT(val_0582, 103.794998);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0583, 109.689003);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_0584, 114.557999);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0585, 124.429001);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0002 10
DEF_STATIC_CONST_VAL_STRING(val_0586, "t_164");
DEF_STATIC_CONST_VAL_FLOAT(val_0587, 107.116997);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0588, 116.412003);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_0589, 95.283401);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0590, 0.173000);
DEF_STATIC_CONST_VAL_FLOAT(val_0591, 0.054500);
DEF_STATIC_CONST_VAL_FLOAT(val_0592, 100.955002);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0593, 0.195446);
DEF_STATIC_CONST_VAL_STRING(val_0594, "hh");
DEF_STATIC_CONST_VAL_FLOAT(val_0595, 114.688004);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0596, 107.393997);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0019 23
DEF_STATIC_CONST_VAL_FLOAT(val_0597, 104.065002);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0016 24
DEF_STATIC_CONST_VAL_FLOAT(val_0598, 95.623001);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0001 25
DEF_STATIC_CONST_VAL_FLOAT(val_0599, 91.653603);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0000 26
DEF_STATIC_CONST_VAL_FLOAT(val_0600, 79.746002);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_0601, 74.637001);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_0602, 32.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0603, 83.435402);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_0604, 78.430099);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0026 34
DEF_STATIC_CONST_VAL_FLOAT(val_0605, 0.487121);
DEF_STATIC_CONST_VAL_FLOAT(val_0606, 0.180000);
DEF_STATIC_CONST_VAL_FLOAT(val_0607, 110.738998);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_0608, 103.209999);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0036 40
DEF_STATIC_CONST_VAL_FLOAT(val_0609, 94.013100);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0035 41
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_0610, 99.615402);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0041 45
DEF_STATIC_CONST_VAL_FLOAT(val_0611, 93.799599);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_0612, 100.942001);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0045 49
DEF_STATIC_CONST_VAL_FLOAT(val_0613, 87.715500);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_0614, 92.078796);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_0615, 92.845802);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0034 54
DEF_STATIC_CONST_VAL_STRING(val_0616, "l_106");
DEF_STATIC_CONST_VAL_FLOAT(val_0617, 94.892502);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0056 58
DEF_STATIC_CONST_VAL_FLOAT(val_0618, 0.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_0619, 0.847909);
DEF_STATIC_CONST_VAL_FLOAT(val_0620, 91.833504);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0059 61
DEF_STATIC_CONST_VAL_FLOAT(val_0621, 89.761703);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0058 62
DEF_STATIC_CONST_VAL_FLOAT(val_0622, 87.312103);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0055 63
DEF_STATIC_CONST_VAL_FLOAT(val_0623, 91.540298);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0063 65
DEF_STATIC_CONST_VAL_FLOAT(val_0624, 94.652397);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0065 67
DEF_STATIC_CONST_VAL_STRING(val_0625, "det");
DEF_STATIC_CONST_VAL_FLOAT(val_0626, 98.457298);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0067 69
DEF_STATIC_CONST_VAL_FLOAT(val_0627, 107.497002);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0054 70
DEF_STATIC_CONST_VAL_FLOAT(val_0628, 0.075500);
DEF_STATIC_CONST_VAL_FLOAT(val_0629, 0.584893);
DEF_STATIC_CONST_VAL_FLOAT(val_0630, 96.016502);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0073 75
DEF_STATIC_CONST_VAL_FLOAT(val_0631, 0.026000);
DEF_STATIC_CONST_VAL_FLOAT(val_0632, 93.358002);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0075 77
DEF_STATIC_CONST_VAL_FLOAT(val_0633, 87.880501);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0072 78
DEF_STATIC_CONST_VAL_FLOAT(val_0634, 0.702291);
DEF_STATIC_CONST_VAL_FLOAT(val_0635, 90.609497);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0079 81
DEF_STATIC_CONST_VAL_FLOAT(val_0636, 87.384804);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0078 82
DEF_STATIC_CONST_VAL_FLOAT(val_0637, 29.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0638, 88.623299);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0083 85
DEF_STATIC_CONST_VAL_FLOAT(val_0639, 83.879501);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0085 87
DEF_STATIC_CONST_VAL_FLOAT(val_0640, 86.521103);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0082 88
DEF_STATIC_CONST_VAL_FLOAT(val_0641, 82.678200);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0071 89
DEF_STATIC_CONST_VAL_FLOAT(val_0642, 97.159500);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0089 91
DEF_STATIC_CONST_VAL_FLOAT(val_0643, 88.318901);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0091 93
DEF_STATIC_CONST_VAL_FLOAT(val_0644, 93.438301);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0070 94
DEF_STATIC_CONST_VAL_FLOAT(val_0645, 31.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0646, 84.503502);
#define CTNODE_cmu_us_rms_f0_ae_8_NO_0094 96
DEF_STATIC_CONST_VAL_FLOAT(val_0647, 81.751099);
DEF_STATIC_CONST_VAL_FLOAT(val_0648, 0.074000);
DEF_STATIC_CONST_VAL_STRING(val_0649, "pau_143");
DEF_STATIC_CONST_VAL_FLOAT(val_0650, 127.857002);
#define CTNODE_cmu_us_rms_f0_y_194_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0651, 120.811996);
#define CTNODE_cmu_us_rms_f0_y_194_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_0652, 0.019500);
DEF_STATIC_CONST_VAL_FLOAT(val_0653, 118.030998);
#define CTNODE_cmu_us_rms_f0_y_194_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0654, 101.132004);
#define CTNODE_cmu_us_rms_f0_y_194_NO_0000 8
DEF_STATIC_CONST_VAL_FLOAT(val_0655, 0.605382);
DEF_STATIC_CONST_VAL_FLOAT(val_0656, 106.610001);
#define CTNODE_cmu_us_rms_f0_y_194_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0657, 102.002998);
#define CTNODE_cmu_us_rms_f0_y_194_NO_0008 12
DEF_STATIC_CONST_VAL_FLOAT(val_0658, 93.614601);
DEF_STATIC_CONST_VAL_FLOAT(val_0659, 0.392890);
DEF_STATIC_CONST_VAL_FLOAT(val_0660, 0.030000);
DEF_STATIC_CONST_VAL_FLOAT(val_0661, 114.864998);
#define CTNODE_cmu_us_rms_f0_y_195_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0662, 108.343002);
#define CTNODE_cmu_us_rms_f0_y_195_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0663, 0.203530);
DEF_STATIC_CONST_VAL_FLOAT(val_0664, 103.026001);
#define CTNODE_cmu_us_rms_f0_y_195_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0665, 96.296303);
#define CTNODE_cmu_us_rms_f0_y_195_NO_0000 8
DEF_STATIC_CONST_VAL_STRING(val_0666, "m");
DEF_STATIC_CONST_VAL_FLOAT(val_0667, 96.265800);
#define CTNODE_cmu_us_rms_f0_y_195_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0668, 0.475000);
DEF_STATIC_CONST_VAL_FLOAT(val_0669, 89.907402);
#define CTNODE_cmu_us_rms_f0_y_195_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0670, 92.733299);
#define CTNODE_cmu_us_rms_f0_y_195_NO_0008 14
DEF_STATIC_CONST_VAL_FLOAT(val_0671, 100.889999);
DEF_STATIC_CONST_VAL_FLOAT(val_0672, 0.299808);
DEF_STATIC_CONST_VAL_FLOAT(val_0673, 117.194000);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0674, 107.042999);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0675, 112.348999);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_0676, 5.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_0677, 102.370003);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0678, 106.694000);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_0679, 88.133797);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0680, 107.627998);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0681, 92.219803);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0682, 5.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0683, 95.959602);
#define CTNODE_cmu_us_rms_f0_y_196_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_0684, 101.088997);
DEF_STATIC_CONST_VAL_FLOAT(val_0685, 3.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0686, 95.297600);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0687, 90.884201);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_0688, 0.406105);
DEF_STATIC_CONST_VAL_FLOAT(val_0689, 106.578003);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0690, 99.418900);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0691, 90.987198);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0001 11
DEF_STATIC_CONST_VAL_FLOAT(val_0692, 87.522400);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0693, 95.696297);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0694, 88.658997);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0000 16
DEF_STATIC_CONST_VAL_FLOAT(val_0695, 101.248001);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0696, 94.523804);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_0697, 0.525524);
DEF_STATIC_CONST_VAL_FLOAT(val_0698, 0.029000);
DEF_STATIC_CONST_VAL_FLOAT(val_0699, 114.802002);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_0700, 106.587997);
#define CTNODE_cmu_us_rms_f0_k_101_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_0701, 99.891701);
DEF_STATIC_CONST_VAL_FLOAT(val_0702, 0.898000);
DEF_STATIC_CONST_VAL_FLOAT(val_0703, 123.628998);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0704, 117.765999);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0705, 0.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0706, 103.000000);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0707, 115.028000);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0000 8
DEF_STATIC_CONST_VAL_FLOAT(val_0708, 0.057500);
DEF_STATIC_CONST_VAL_FLOAT(val_0709, 92.229301);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0710, 80.990997);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0008 12
DEF_STATIC_CONST_VAL_FLOAT(val_0711, 4.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0712, 96.655296);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0713, 90.232399);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0012 16
DEF_STATIC_CONST_VAL_FLOAT(val_0714, 1.086000);
DEF_STATIC_CONST_VAL_FLOAT(val_0715, 1.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0716, 107.436996);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_0717, 115.735001);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_0718, 17.799999);
DEF_STATIC_CONST_VAL_FLOAT(val_0719, 110.817001);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0720, 0.589949);
DEF_STATIC_CONST_VAL_FLOAT(val_0721, 106.305000);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0024 26
#define CTNODE_cmu_us_rms_f0_k_102_NO_0021 27
DEF_STATIC_CONST_VAL_FLOAT(val_0722, 101.952003);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_0723, 96.497597);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0020 30
DEF_STATIC_CONST_VAL_FLOAT(val_0724, 93.360603);
#define CTNODE_cmu_us_rms_f0_k_102_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_0725, 102.089996);
DEF_STATIC_CONST_VAL_FLOAT(val_0726, 0.085000);
DEF_STATIC_CONST_VAL_FLOAT(val_0727, 0.057500);
DEF_STATIC_CONST_VAL_FLOAT(val_0728, 95.451797);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0729, 83.811897);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_0730, 77.749496);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0000 6
DEF_STATIC_CONST_VAL_STRING(val_0731, "r");
DEF_STATIC_CONST_VAL_FLOAT(val_0732, 128.432007);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0733, 10.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0734, 113.134003);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0735, 120.780998);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_0736, 107.066002);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0737, 113.389000);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0010 18
DEF_STATIC_CONST_VAL_FLOAT(val_0738, 121.263000);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0009 19
DEF_STATIC_CONST_VAL_FLOAT(val_0739, 127.971001);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0006 20
DEF_STATIC_CONST_VAL_FLOAT(val_0740, 0.432524);
DEF_STATIC_CONST_VAL_FLOAT(val_0741, 119.785004);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0742, 108.025002);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_0743, 0.013000);
DEF_STATIC_CONST_VAL_FLOAT(val_0744, 0.499130);
DEF_STATIC_CONST_VAL_FLOAT(val_0745, 110.107002);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_0746, 102.477997);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_0747, 0.089000);
DEF_STATIC_CONST_VAL_FLOAT(val_0748, 0.045000);
DEF_STATIC_CONST_VAL_FLOAT(val_0749, 92.101097);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_0750, 97.271202);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0031 35
DEF_STATIC_CONST_VAL_FLOAT(val_0751, 99.958298);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0030 36
DEF_STATIC_CONST_VAL_FLOAT(val_0752, 103.822998);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0025 37
DEF_STATIC_CONST_VAL_FLOAT(val_0753, 3.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_0754, 99.153702);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_0755, 103.305000);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0037 41
DEF_STATIC_CONST_VAL_FLOAT(val_0756, 103.080002);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_0757, 0.065000);
DEF_STATIC_CONST_VAL_FLOAT(val_0758, 115.810997);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_0759, 107.304001);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0044 48
DEF_STATIC_CONST_VAL_FLOAT(val_0760, 102.536003);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0043 49
DEF_STATIC_CONST_VAL_FLOAT(val_0761, 108.431999);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_0762, 115.609001);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0052 54
DEF_STATIC_CONST_VAL_FLOAT(val_0763, 120.245003);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0051 55
#define CTNODE_cmu_us_rms_f0_k_103_NO_0020 56
DEF_STATIC_CONST_VAL_FLOAT(val_0764, 25.200001);
DEF_STATIC_CONST_VAL_FLOAT(val_0765, 0.511077);
DEF_STATIC_CONST_VAL_FLOAT(val_0766, 0.282568);
DEF_STATIC_CONST_VAL_FLOAT(val_0767, 118.796997);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0059 61
DEF_STATIC_CONST_VAL_FLOAT(val_0768, 115.014999);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0058 62
DEF_STATIC_CONST_VAL_FLOAT(val_0769, 104.620003);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_0770, 111.181999);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0057 65
DEF_STATIC_CONST_VAL_FLOAT(val_0771, 117.385002);
#define CTNODE_cmu_us_rms_f0_k_103_NO_0056 66
DEF_STATIC_CONST_VAL_FLOAT(val_0772, 120.990997);
DEF_STATIC_CONST_VAL_FLOAT(val_0773, 0.101000);
DEF_STATIC_CONST_VAL_FLOAT(val_0774, 116.246002);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0775, 113.650002);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0776, 0.470676);
DEF_STATIC_CONST_VAL_FLOAT(val_0777, 0.282605);
DEF_STATIC_CONST_VAL_FLOAT(val_0778, 11.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_0779, 101.325996);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_0780, 104.447998);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_0781, 108.029999);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0006 12
DEF_STATIC_CONST_VAL_FLOAT(val_0782, 101.805000);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0783, 96.158203);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0005 15
DEF_STATIC_CONST_VAL_FLOAT(val_0784, 100.714996);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0785, 83.362602);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_0786, 91.930603);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0787, 90.519402);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0017 23
DEF_STATIC_CONST_VAL_FLOAT(val_0788, 95.092003);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0000 24
DEF_STATIC_CONST_VAL_FLOAT(val_0789, 41.599998);
DEF_STATIC_CONST_VAL_FLOAT(val_0790, 0.882684);
DEF_STATIC_CONST_VAL_FLOAT(val_0791, 82.196098);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_0792, 90.899696);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_0793, 81.007797);
#define CTNODE_cmu_us_rms_f0_aa_1_NO_0024 30
DEF_STATIC_CONST_VAL_FLOAT(val_0794, 97.040001);
DEF_STATIC_CONST_VAL_FLOAT(val_0795, 1.692500);
DEF_STATIC_CONST_VAL_FLOAT(val_0796, 1.052000);
DEF_STATIC_CONST_VAL_FLOAT(val_0797, 0.236000);
DEF_STATIC_CONST_VAL_FLOAT(val_0798, 12.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_0799, 116.385002);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0800, 110.275002);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0801, 116.450996);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_0802, 14.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0803, 109.017998);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0804, 105.315002);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0004 14
DEF_STATIC_CONST_VAL_FLOAT(val_0805, 110.320999);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0806, 101.374001);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0016 18
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0003 19
DEF_STATIC_CONST_VAL_STRING(val_0807, "w");
DEF_STATIC_CONST_VAL_FLOAT(val_0808, 101.666000);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_0809, 99.480400);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0002 22
DEF_STATIC_CONST_VAL_FLOAT(val_0810, 95.235603);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0001 23
DEF_STATIC_CONST_VAL_FLOAT(val_0811, 0.547301);
DEF_STATIC_CONST_VAL_FLOAT(val_0812, 1.494000);
DEF_STATIC_CONST_VAL_FLOAT(val_0813, 0.122000);
DEF_STATIC_CONST_VAL_FLOAT(val_0814, 11.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0815, 103.914001);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_0816, 100.088997);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_0817, 98.186600);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0025 31
DEF_STATIC_CONST_VAL_FLOAT(val_0818, 103.183998);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_0819, 110.931000);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0024 34
DEF_STATIC_CONST_VAL_FLOAT(val_0820, 98.039497);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0023 35
DEF_STATIC_CONST_VAL_FLOAT(val_0821, 92.795601);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0000 36
DEF_STATIC_CONST_VAL_FLOAT(val_0822, 83.511803);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_0823, 105.722000);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_0824, 2.349000);
DEF_STATIC_CONST_VAL_FLOAT(val_0825, 103.625000);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_0826, 95.434502);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0039 45
DEF_STATIC_CONST_VAL_FLOAT(val_0827, 0.755917);
DEF_STATIC_CONST_VAL_FLOAT(val_0828, 92.084900);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_0829, 95.937897);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0048 50
DEF_STATIC_CONST_VAL_STRING(val_0830, "single");
DEF_STATIC_CONST_VAL_FLOAT(val_0831, 101.436996);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_0832, 99.757004);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0045 53
DEF_STATIC_CONST_VAL_FLOAT(val_0833, 0.850856);
DEF_STATIC_CONST_VAL_FLOAT(val_0834, 91.718399);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_0835, 88.792297);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0038 56
DEF_STATIC_CONST_VAL_FLOAT(val_0836, 0.072500);
DEF_STATIC_CONST_VAL_FLOAT(val_0837, 87.538803);
#define CTNODE_cmu_us_rms_f0_aa_2_NO_0056 58
DEF_STATIC_CONST_VAL_FLOAT(val_0838, 91.383202);
DEF_STATIC_CONST_VAL_FLOAT(val_0839, 0.503155);
DEF_STATIC_CONST_VAL_FLOAT(val_0840, 100.988998);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_0841, 0.322505);
DEF_STATIC_CONST_VAL_FLOAT(val_0842, 115.266998);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0843, 106.834000);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_0844, 0.224159);
DEF_STATIC_CONST_VAL_FLOAT(val_0845, 0.740000);
DEF_STATIC_CONST_VAL_FLOAT(val_0846, 103.139999);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0847, 97.162903);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_0848, 0.830000);
DEF_STATIC_CONST_VAL_FLOAT(val_0849, 91.933701);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0850, 87.785004);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0000 14
DEF_STATIC_CONST_VAL_FLOAT(val_0851, 79.220802);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0852, 101.323997);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_0853, 92.688103);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_0854, 90.359001);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0016 22
DEF_STATIC_CONST_VAL_FLOAT(val_0855, 0.621525);
DEF_STATIC_CONST_VAL_FLOAT(val_0856, 86.150101);
#define CTNODE_cmu_us_rms_f0_aa_3_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0857, 88.376701);
DEF_STATIC_CONST_VAL_FLOAT(val_0858, 0.331034);
DEF_STATIC_CONST_VAL_FLOAT(val_0859, 86.043999);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_0860, 91.201401);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_0861, 0.131579);
DEF_STATIC_CONST_VAL_FLOAT(val_0862, 100.593002);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0863, 91.597198);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0001 9
DEF_STATIC_CONST_VAL_FLOAT(val_0864, 81.461800);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_0865, 0.029500);
DEF_STATIC_CONST_VAL_FLOAT(val_0866, 0.011000);
DEF_STATIC_CONST_VAL_FLOAT(val_0867, 87.847702);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_0868, 96.485703);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_0869, 103.510002);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0870, 96.708504);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0871, 0.427068);
DEF_STATIC_CONST_VAL_FLOAT(val_0872, 96.597801);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_0873, 90.495300);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0019 25
DEF_STATIC_CONST_VAL_FLOAT(val_0874, 0.276139);
DEF_STATIC_CONST_VAL_FLOAT(val_0875, 103.443001);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_0876, 0.549413);
DEF_STATIC_CONST_VAL_FLOAT(val_0877, 97.653099);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_0878, 92.969803);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0018 30
DEF_STATIC_CONST_VAL_FLOAT(val_0879, 92.375801);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0017 31
DEF_STATIC_CONST_VAL_FLOAT(val_0880, 101.408997);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0010 32
DEF_STATIC_CONST_VAL_FLOAT(val_0881, 0.409922);
DEF_STATIC_CONST_VAL_FLOAT(val_0882, 0.123150);
DEF_STATIC_CONST_VAL_FLOAT(val_0883, 97.905899);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_0884, 101.025002);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_0885, 104.736000);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0033 39
DEF_STATIC_CONST_VAL_FLOAT(val_0886, 93.261002);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_0887, 87.660400);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0032 42
DEF_STATIC_CONST_VAL_FLOAT(val_0888, 0.236538);
DEF_STATIC_CONST_VAL_FLOAT(val_0889, 0.296631);
DEF_STATIC_CONST_VAL_FLOAT(val_0890, 119.300003);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0043 45
DEF_STATIC_CONST_VAL_FLOAT(val_0891, 109.353996);
#define CTNODE_cmu_us_rms_f0_ay_31_NO_0042 46
DEF_STATIC_CONST_VAL_FLOAT(val_0892, 95.395798);
DEF_STATIC_CONST_VAL_FLOAT(val_0893, 1.024000);
DEF_STATIC_CONST_VAL_FLOAT(val_0894, 109.129997);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0895, 0.320629);
DEF_STATIC_CONST_VAL_FLOAT(val_0896, 19.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0897, 106.169998);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_0898, 0.443000);
DEF_STATIC_CONST_VAL_FLOAT(val_0899, 108.661003);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_0900, 0.237500);
DEF_STATIC_CONST_VAL_FLOAT(val_0901, 100.148003);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0011 13
DEF_STATIC_CONST_VAL_STRING(val_0902, "aux");
DEF_STATIC_CONST_VAL_FLOAT(val_0903, 99.493599);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0904, 97.460197);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0905, 98.101097);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0010 18
DEF_STATIC_CONST_VAL_FLOAT(val_0906, 103.051003);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0007 19
DEF_STATIC_CONST_VAL_FLOAT(val_0907, 0.102500);
DEF_STATIC_CONST_VAL_FLOAT(val_0908, 92.934700);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0909, 97.359398);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0019 23
DEF_STATIC_CONST_VAL_FLOAT(val_0910, 100.135002);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0004 24
DEF_STATIC_CONST_VAL_FLOAT(val_0911, 107.237000);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0003 25
DEF_STATIC_CONST_VAL_FLOAT(val_0912, 94.484100);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0000 26
DEF_STATIC_CONST_VAL_FLOAT(val_0913, 2.950000);
DEF_STATIC_CONST_VAL_FLOAT(val_0914, 82.054901);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_0915, 87.931503);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0028 32
DEF_STATIC_CONST_VAL_FLOAT(val_0916, 78.199898);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0027 33
DEF_STATIC_CONST_VAL_FLOAT(val_0917, 95.376198);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_0918, 85.895897);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0026 36
DEF_STATIC_CONST_VAL_FLOAT(val_0919, 96.724800);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_0920, 104.121002);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0037 41
DEF_STATIC_CONST_VAL_FLOAT(val_0921, 93.956001);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_0922, 97.402496);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0036 44
DEF_STATIC_CONST_VAL_FLOAT(val_0923, 19.200001);
DEF_STATIC_CONST_VAL_FLOAT(val_0924, 2.044000);
DEF_STATIC_CONST_VAL_FLOAT(val_0925, 89.453697);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_0926, 0.053000);
DEF_STATIC_CONST_VAL_FLOAT(val_0927, 91.880699);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0048 50
DEF_STATIC_CONST_VAL_FLOAT(val_0928, 19.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0929, 98.365799);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_0930, 95.057701);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0050 54
DEF_STATIC_CONST_VAL_FLOAT(val_0931, 92.459099);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0045 55
DEF_STATIC_CONST_VAL_FLOAT(val_0932, 92.510902);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_0933, 86.809799);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0058 60
DEF_STATIC_CONST_VAL_FLOAT(val_0934, 84.117798);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0057 61
DEF_STATIC_CONST_VAL_FLOAT(val_0935, 90.674500);
#define CTNODE_cmu_us_rms_f0_ay_32_NO_0044 62
DEF_STATIC_CONST_VAL_FLOAT(val_0936, 98.566498);
DEF_STATIC_CONST_VAL_FLOAT(val_0937, 0.884979);
DEF_STATIC_CONST_VAL_FLOAT(val_0938, 87.473801);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0939, 42.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0940, 77.693802);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_0941, 83.034599);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_0942, 74.275597);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0000 8
DEF_STATIC_CONST_VAL_FLOAT(val_0943, 101.332001);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_0944, 0.036000);
DEF_STATIC_CONST_VAL_FLOAT(val_0945, 0.008000);
DEF_STATIC_CONST_VAL_FLOAT(val_0946, 85.078201);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_0947, 0.506847);
DEF_STATIC_CONST_VAL_FLOAT(val_0948, 91.712303);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_0949, 88.217499);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0012 18
DEF_STATIC_CONST_VAL_FLOAT(val_0950, 0.093000);
DEF_STATIC_CONST_VAL_FLOAT(val_0951, 0.056000);
DEF_STATIC_CONST_VAL_FLOAT(val_0952, 0.536570);
DEF_STATIC_CONST_VAL_FLOAT(val_0953, 92.673401);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_0954, 86.831398);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0019 23
DEF_STATIC_CONST_VAL_FLOAT(val_0955, 27.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0956, 96.915100);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_0957, 93.533096);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0018 26
DEF_STATIC_CONST_VAL_FLOAT(val_0958, 98.194504);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0009 27
DEF_STATIC_CONST_VAL_FLOAT(val_0959, 0.350255);
DEF_STATIC_CONST_VAL_FLOAT(val_0960, 0.077000);
DEF_STATIC_CONST_VAL_FLOAT(val_0961, 98.216103);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_0962, 95.114700);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0030 34
DEF_STATIC_CONST_VAL_FLOAT(val_0963, 100.833000);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0029 35
DEF_STATIC_CONST_VAL_FLOAT(val_0964, 101.522003);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0028 36
DEF_STATIC_CONST_VAL_FLOAT(val_0965, 0.226637);
DEF_STATIC_CONST_VAL_FLOAT(val_0966, 0.096907);
DEF_STATIC_CONST_VAL_FLOAT(val_0967, 116.411003);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_0968, 100.552002);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_0969, 108.221001);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_0970, 115.334999);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0036 44
DEF_STATIC_CONST_VAL_FLOAT(val_0971, 98.533699);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0027 45
DEF_STATIC_CONST_VAL_FLOAT(val_0972, 100.821999);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_0973, 96.015999);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_0974, 85.349503);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_0975, 87.850403);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_0976, 93.654198);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0008 54
DEF_STATIC_CONST_VAL_FLOAT(val_0977, 0.325840);
DEF_STATIC_CONST_VAL_FLOAT(val_0978, 90.019699);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_0979, 79.022003);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_0980, 84.621902);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0054 60
DEF_STATIC_CONST_VAL_FLOAT(val_0981, 0.077000);
DEF_STATIC_CONST_VAL_FLOAT(val_0982, 48.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0983, 90.907303);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_0984, 83.881897);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0060 64
DEF_STATIC_CONST_VAL_FLOAT(val_0985, 0.262170);
DEF_STATIC_CONST_VAL_FLOAT(val_0986, 102.962997);
#define CTNODE_cmu_us_rms_f0_ay_33_NO_0064 66
DEF_STATIC_CONST_VAL_FLOAT(val_0987, 93.810501);
DEF_STATIC_CONST_VAL_FLOAT(val_0988, 127.137001);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0989, 131.205994);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0990, 15.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0991, 118.231003);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_0992, 112.564003);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_0993, 0.059000);
DEF_STATIC_CONST_VAL_FLOAT(val_0994, 0.190040);
DEF_STATIC_CONST_VAL_FLOAT(val_0995, 108.192001);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_0996, 102.713997);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_0997, 105.376999);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0998, 86.720100);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_0999, 0.063500);
DEF_STATIC_CONST_VAL_FLOAT(val_1000, 106.158997);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1001, 99.174500);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_1002, 0.486908);
DEF_STATIC_CONST_VAL_FLOAT(val_1003, 95.507004);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1004, 89.762299);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0009 25
DEF_STATIC_CONST_VAL_FLOAT(val_1005, 8.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_1006, 111.385002);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_1007, 115.516998);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_1008, 0.273529);
DEF_STATIC_CONST_VAL_FLOAT(val_1009, 96.995499);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1010, 103.878998);
#define CTNODE_cmu_us_rms_f0_w_189_NO_0004 32
DEF_STATIC_CONST_VAL_FLOAT(val_1011, 122.613998);
DEF_STATIC_CONST_VAL_FLOAT(val_1012, 0.645500);
DEF_STATIC_CONST_VAL_FLOAT(val_1013, 0.020208);
DEF_STATIC_CONST_VAL_FLOAT(val_1014, 125.364998);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1015, 115.486000);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_1016, 114.192001);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1017, 103.530998);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0001 9
DEF_STATIC_CONST_VAL_FLOAT(val_1018, 106.982002);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1019, 97.229202);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0000 12
DEF_STATIC_CONST_VAL_FLOAT(val_1020, 107.014999);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_1021, 0.715686);
DEF_STATIC_CONST_VAL_FLOAT(val_1022, 21.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1023, 0.266334);
DEF_STATIC_CONST_VAL_FLOAT(val_1024, 103.665001);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1025, 0.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1026, 7.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_1027, 95.087196);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_1028, 0.015000);
DEF_STATIC_CONST_VAL_FLOAT(val_1029, 95.964897);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1030, 1.778000);
DEF_STATIC_CONST_VAL_FLOAT(val_1031, 97.534897);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_1032, 105.610001);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0020 28
DEF_STATIC_CONST_VAL_FLOAT(val_1033, 0.445815);
DEF_STATIC_CONST_VAL_FLOAT(val_1034, 96.803497);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_1035, 92.950699);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_1036, 94.360603);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0017 33
DEF_STATIC_CONST_VAL_FLOAT(val_1037, 106.661003);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0016 34
DEF_STATIC_CONST_VAL_FLOAT(val_1038, 0.066500);
DEF_STATIC_CONST_VAL_FLOAT(val_1039, 95.827301);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_1040, 16.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1041, 0.084000);
DEF_STATIC_CONST_VAL_FLOAT(val_1042, 90.294701);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_1043, 87.801003);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1044, 85.880997);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0037 43
DEF_STATIC_CONST_VAL_FLOAT(val_1045, 91.572403);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0034 44
DEF_STATIC_CONST_VAL_FLOAT(val_1046, 0.023000);
DEF_STATIC_CONST_VAL_FLOAT(val_1047, 100.278999);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_1048, 94.407600);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0044 48
DEF_STATIC_CONST_VAL_FLOAT(val_1049, 92.622902);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0015 49
DEF_STATIC_CONST_VAL_FLOAT(val_1050, 83.267601);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_1051, 87.486702);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0049 53
DEF_STATIC_CONST_VAL_FLOAT(val_1052, 95.866699);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0054 56
DEF_STATIC_CONST_VAL_FLOAT(val_1053, 91.156799);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0053 57
DEF_STATIC_CONST_VAL_FLOAT(val_1054, 85.601196);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_1055, 93.716499);
#define CTNODE_cmu_us_rms_f0_w_190_NO_0012 60
DEF_STATIC_CONST_VAL_FLOAT(val_1056, 119.586998);
DEF_STATIC_CONST_VAL_FLOAT(val_1057, 0.297560);
DEF_STATIC_CONST_VAL_FLOAT(val_1058, 112.538002);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1059, 109.422997);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1060, 0.041000);
DEF_STATIC_CONST_VAL_FLOAT(val_1061, 109.789001);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1062, 102.892998);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1063, 97.542999);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1064, 104.365997);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0000 12
DEF_STATIC_CONST_VAL_FLOAT(val_1065, 0.705201);
DEF_STATIC_CONST_VAL_FLOAT(val_1066, 0.420552);
DEF_STATIC_CONST_VAL_FLOAT(val_1067, 94.514702);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1068, 91.596100);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_1069, 97.819504);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1070, 100.225998);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_1071, 0.501046);
DEF_STATIC_CONST_VAL_FLOAT(val_1072, 96.829399);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1073, 92.887497);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0013 25
DEF_STATIC_CONST_VAL_FLOAT(val_1074, 88.411697);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_1075, 91.954399);
#define CTNODE_cmu_us_rms_f0_w_191_NO_0012 28
DEF_STATIC_CONST_VAL_FLOAT(val_1076, 109.793999);
DEF_STATIC_CONST_VAL_FLOAT(val_1077, 0.907817);
DEF_STATIC_CONST_VAL_FLOAT(val_1078, 0.014000);
DEF_STATIC_CONST_VAL_FLOAT(val_1079, 88.440300);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1080, 94.474800);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_1081, 81.805801);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_1082, 115.557999);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0007 9
DEF_STATIC_CONST_VAL_STRING(val_1083, "ey_68");
DEF_STATIC_CONST_VAL_FLOAT(val_1084, 109.827003);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1085, 0.272754);
DEF_STATIC_CONST_VAL_FLOAT(val_1086, 115.258003);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1087, 100.164001);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_1088, 105.207001);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0015 17
DEF_STATIC_CONST_VAL_STRING(val_1089, "d");
DEF_STATIC_CONST_VAL_FLOAT(val_1090, 0.522851);
DEF_STATIC_CONST_VAL_FLOAT(val_1091, 92.787003);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1092, 86.762802);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_1093, 99.847198);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0017 23
DEF_STATIC_CONST_VAL_FLOAT(val_1094, 0.228040);
DEF_STATIC_CONST_VAL_FLOAT(val_1095, 103.609001);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_1096, 110.607002);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_1097, 90.183701);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1098, 0.428645);
DEF_STATIC_CONST_VAL_FLOAT(val_1099, 101.262001);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_1100, 95.966103);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0029 33
DEF_STATIC_CONST_VAL_FLOAT(val_1101, 99.256599);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1102, 97.492302);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_1103, 92.697701);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_1104, 89.274498);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0037 41
DEF_STATIC_CONST_VAL_FLOAT(val_1105, 95.281601);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0000 42
DEF_STATIC_CONST_VAL_FLOAT(val_1106, 0.811030);
DEF_STATIC_CONST_VAL_FLOAT(val_1107, 0.080000);
DEF_STATIC_CONST_VAL_FLOAT(val_1108, 0.012000);
DEF_STATIC_CONST_VAL_FLOAT(val_1109, 96.809700);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_1110, 90.268402);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0044 48
DEF_STATIC_CONST_VAL_FLOAT(val_1111, 86.476700);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0043 49
DEF_STATIC_CONST_VAL_FLOAT(val_1112, 81.668999);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0042 50
DEF_STATIC_CONST_VAL_STRING(val_1113, "ih_88");
DEF_STATIC_CONST_VAL_FLOAT(val_1114, 82.470901);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_1115, 86.642700);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0050 54
DEF_STATIC_CONST_VAL_FLOAT(val_1116, 18.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_1117, 81.864098);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_1118, 77.823402);
#define CTNODE_cmu_us_rms_f0_m_111_NO_0054 58
DEF_STATIC_CONST_VAL_FLOAT(val_1119, 74.160896);
DEF_STATIC_CONST_VAL_FLOAT(val_1120, 1.176000);
DEF_STATIC_CONST_VAL_FLOAT(val_1121, 91.695900);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1122, 95.160599);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1123, 110.763000);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1124, 97.664703);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_1125, 0.050000);
DEF_STATIC_CONST_VAL_FLOAT(val_1126, 108.086998);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1127, 103.714996);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1128, 101.052002);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0000 14
DEF_STATIC_CONST_VAL_FLOAT(val_1129, 81.187202);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1130, 94.176804);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1131, 89.018700);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_1132, 85.211502);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0015 23
DEF_STATIC_CONST_VAL_FLOAT(val_1133, 2.276000);
DEF_STATIC_CONST_VAL_FLOAT(val_1134, 91.048500);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_1135, 86.780701);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_1136, 99.032097);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1137, 0.070000);
DEF_STATIC_CONST_VAL_FLOAT(val_1138, 89.423698);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_1139, 0.641381);
DEF_STATIC_CONST_VAL_FLOAT(val_1140, 98.419098);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1141, 92.575699);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0030 36
DEF_STATIC_CONST_VAL_FLOAT(val_1142, 88.218002);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0029 37
DEF_STATIC_CONST_VAL_FLOAT(val_1143, 92.737999);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_1144, 98.425003);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0014 40
DEF_STATIC_CONST_VAL_FLOAT(val_1145, 2.483500);
DEF_STATIC_CONST_VAL_FLOAT(val_1146, 86.806396);
#define CTNODE_cmu_us_rms_f0_m_112_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1147, 76.772301);
DEF_STATIC_CONST_VAL_FLOAT(val_1148, 0.041000);
DEF_STATIC_CONST_VAL_FLOAT(val_1149, 79.577400);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1150, 94.085800);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_1151, 103.725998);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1152, 91.734200);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_1153, 0.413689);
DEF_STATIC_CONST_VAL_FLOAT(val_1154, 100.210999);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1155, 92.349701);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_1156, 0.039500);
DEF_STATIC_CONST_VAL_FLOAT(val_1157, 102.569000);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_1158, 95.576103);
#define CTNODE_cmu_us_rms_f0_m_113_NO_0004 16
DEF_STATIC_CONST_VAL_FLOAT(val_1159, 87.310799);
DEF_STATIC_CONST_VAL_FLOAT(val_1160, 0.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1161, 5.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1162, 126.351997);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1163, 122.039001);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_1164, 110.948997);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1165, 99.466499);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0000 8
DEF_STATIC_CONST_VAL_FLOAT(val_1166, 0.051500);
DEF_STATIC_CONST_VAL_FLOAT(val_1167, 108.349998);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1168, 101.917000);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0008 12
DEF_STATIC_CONST_VAL_FLOAT(val_1169, 0.193340);
DEF_STATIC_CONST_VAL_FLOAT(val_1170, 102.757004);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1171, 84.949898);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_1172, 0.098000);
DEF_STATIC_CONST_VAL_FLOAT(val_1173, 0.614537);
DEF_STATIC_CONST_VAL_FLOAT(val_1174, 100.184998);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1175, 95.186897);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_1176, 90.503502);
#define CTNODE_cmu_us_rms_f0_ao_16_NO_0016 22
DEF_STATIC_CONST_VAL_FLOAT(val_1177, 88.718803);
DEF_STATIC_CONST_VAL_FLOAT(val_1178, 1.058000);
DEF_STATIC_CONST_VAL_FLOAT(val_1179, 117.424004);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1180, 109.893997);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1181, 0.178951);
DEF_STATIC_CONST_VAL_FLOAT(val_1182, 0.038122);
DEF_STATIC_CONST_VAL_FLOAT(val_1183, 100.621002);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1184, 0.080342);
DEF_STATIC_CONST_VAL_FLOAT(val_1185, 107.252998);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1186, 112.096001);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0005 11
DEF_STATIC_CONST_VAL_FLOAT(val_1187, 103.309998);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1188, 98.188599);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0000 14
DEF_STATIC_CONST_VAL_FLOAT(val_1189, 12.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_1190, 90.886398);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1191, 0.926659);
DEF_STATIC_CONST_VAL_FLOAT(val_1192, 83.242500);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_1193, 77.482803);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0014 20
DEF_STATIC_CONST_VAL_FLOAT(val_1194, 111.218002);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_1195, 98.742401);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_1196, 0.237000);
DEF_STATIC_CONST_VAL_FLOAT(val_1197, 0.582796);
DEF_STATIC_CONST_VAL_FLOAT(val_1198, 0.143000);
DEF_STATIC_CONST_VAL_FLOAT(val_1199, 95.047897);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_1200, 89.063698);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_1201, 99.438797);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0026 32
DEF_STATIC_CONST_VAL_FLOAT(val_1202, 99.631897);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0025 33
DEF_STATIC_CONST_VAL_FLOAT(val_1203, 0.761994);
DEF_STATIC_CONST_VAL_FLOAT(val_1204, 0.022000);
DEF_STATIC_CONST_VAL_FLOAT(val_1205, 90.853996);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_1206, 94.542603);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_1207, 95.607597);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0033 39
DEF_STATIC_CONST_VAL_FLOAT(val_1208, 0.797965);
DEF_STATIC_CONST_VAL_FLOAT(val_1209, 88.173500);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_1210, 93.130798);
#define CTNODE_cmu_us_rms_f0_ao_17_NO_0024 42
DEF_STATIC_CONST_VAL_FLOAT(val_1211, 85.563301);
DEF_STATIC_CONST_VAL_FLOAT(val_1212, 10.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_1213, 91.854401);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1214, 82.630096);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_1215, 96.796898);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0000 6
DEF_STATIC_CONST_VAL_STRING(val_1216, "g_76");
DEF_STATIC_CONST_VAL_FLOAT(val_1217, 86.432503);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1218, 0.517241);
DEF_STATIC_CONST_VAL_FLOAT(val_1219, 0.380908);
DEF_STATIC_CONST_VAL_FLOAT(val_1220, 118.496002);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1221, 109.012001);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_1222, 32.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_1223, 17.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1224, 103.124001);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1225, 97.763298);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_1226, 0.385638);
DEF_STATIC_CONST_VAL_FLOAT(val_1227, 115.958000);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1228, 102.736000);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0013 21
DEF_STATIC_CONST_VAL_FLOAT(val_1229, 96.759201);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0008 22
DEF_STATIC_CONST_VAL_FLOAT(val_1230, 0.291047);
DEF_STATIC_CONST_VAL_FLOAT(val_1231, 0.206375);
DEF_STATIC_CONST_VAL_FLOAT(val_1232, 112.321999);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_1233, 110.609001);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_1234, 105.375000);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0022 28
DEF_STATIC_CONST_VAL_FLOAT(val_1235, 0.422869);
DEF_STATIC_CONST_VAL_FLOAT(val_1236, 102.234001);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1237, 97.469002);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0028 32
DEF_STATIC_CONST_VAL_FLOAT(val_1238, 89.821602);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1239, 94.783897);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_1240, 0.632975);
DEF_STATIC_CONST_VAL_FLOAT(val_1241, 0.526531);
DEF_STATIC_CONST_VAL_FLOAT(val_1242, 97.258499);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_1243, 99.501801);
#define CTNODE_cmu_us_rms_f0_ao_18_NO_0036 40
DEF_STATIC_CONST_VAL_FLOAT(val_1244, 94.027298);
DEF_STATIC_CONST_VAL_FLOAT(val_1245, 119.614998);
#define CTNODE_cmu_us_rms_f0_th_169_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_1246, 109.475998);
#define CTNODE_cmu_us_rms_f0_th_169_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1247, 0.413033);
DEF_STATIC_CONST_VAL_FLOAT(val_1248, 104.292000);
#define CTNODE_cmu_us_rms_f0_th_169_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_1249, 83.330597);
#define CTNODE_cmu_us_rms_f0_th_169_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1250, 94.898697);
DEF_STATIC_CONST_VAL_FLOAT(val_1251, 12.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_1252, 1.253000);
DEF_STATIC_CONST_VAL_FLOAT(val_1253, 108.140999);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1254, 97.500900);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_1255, 0.376299);
DEF_STATIC_CONST_VAL_FLOAT(val_1256, 122.607002);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1257, 0.097500);
DEF_STATIC_CONST_VAL_FLOAT(val_1258, 112.671997);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1259, 104.147003);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0001 11
DEF_STATIC_CONST_VAL_FLOAT(val_1260, 1.107000);
DEF_STATIC_CONST_VAL_FLOAT(val_1261, 121.119003);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1262, 129.845001);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_1263, 122.269997);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1264, 0.712195);
DEF_STATIC_CONST_VAL_FLOAT(val_1265, 109.192001);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_1266, 119.116997);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0000 20
DEF_STATIC_CONST_VAL_FLOAT(val_1267, 0.016000);
DEF_STATIC_CONST_VAL_FLOAT(val_1268, 0.095000);
DEF_STATIC_CONST_VAL_FLOAT(val_1269, 93.795303);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_1270, 106.483002);
#define CTNODE_cmu_us_rms_f0_th_170_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_1271, 73.656502);
DEF_STATIC_CONST_VAL_FLOAT(val_1272, 98.396797);
#define CTNODE_cmu_us_rms_f0_th_171_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_1273, 129.251007);
#define CTNODE_cmu_us_rms_f0_th_171_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1274, 116.261002);
DEF_STATIC_CONST_VAL_FLOAT(val_1275, 0.291039);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1276, 113.445999);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_1277, 110.329002);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_1278, 118.833000);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0000 8
DEF_STATIC_CONST_VAL_FLOAT(val_1279, 111.857002);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1280, 104.633003);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1281, 0.832620);
DEF_STATIC_CONST_VAL_FLOAT(val_1282, 0.508031);
DEF_STATIC_CONST_VAL_FLOAT(val_1283, 102.167000);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1284, 96.330299);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_1285, 89.154999);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0013 19
DEF_STATIC_CONST_VAL_FLOAT(val_1286, 94.026604);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1287, 0.036500);
DEF_STATIC_CONST_VAL_FLOAT(val_1288, 0.767361);
DEF_STATIC_CONST_VAL_FLOAT(val_1289, 86.457497);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1290, 92.011803);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_1291, 94.265900);
#define CTNODE_cmu_us_rms_f0_ah_11_NO_0012 26
DEF_STATIC_CONST_VAL_FLOAT(val_1292, 84.113098);
DEF_STATIC_CONST_VAL_FLOAT(val_1293, 1.223000);
DEF_STATIC_CONST_VAL_FLOAT(val_1294, 0.182312);
DEF_STATIC_CONST_VAL_FLOAT(val_1295, 126.600998);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1296, 112.870003);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_1297, 0.186160);
DEF_STATIC_CONST_VAL_FLOAT(val_1298, 107.463997);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1299, 97.328796);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1300, 114.804001);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1301, 0.234000);
DEF_STATIC_CONST_VAL_FLOAT(val_1302, 9.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1303, 106.711998);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1304, 108.571999);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_1305, 106.222000);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1306, 111.412003);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0015 19
DEF_STATIC_CONST_VAL_FLOAT(val_1307, 113.681999);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0000 20
DEF_STATIC_CONST_VAL_FLOAT(val_1308, 86.068703);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_1309, 10.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1310, 108.125999);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1311, 100.584999);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_1312, 0.525978);
DEF_STATIC_CONST_VAL_FLOAT(val_1313, 13.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_1314, 100.938004);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_1315, 97.934998);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_1316, 94.083397);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0026 32
DEF_STATIC_CONST_VAL_FLOAT(val_1317, 98.396896);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_1318, 17.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_1319, 0.825710);
DEF_STATIC_CONST_VAL_FLOAT(val_1320, 92.863503);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_1321, 96.088097);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0036 40
DEF_STATIC_CONST_VAL_FLOAT(val_1322, 0.010500);
DEF_STATIC_CONST_VAL_FLOAT(val_1323, 91.089600);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1324, 93.708099);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0035 43
DEF_STATIC_CONST_VAL_FLOAT(val_1325, 90.110802);
#define CTNODE_cmu_us_rms_f0_ah_12_NO_0034 44
DEF_STATIC_CONST_VAL_FLOAT(val_1326, 89.339699);
DEF_STATIC_CONST_VAL_FLOAT(val_1327, 0.211300);
DEF_STATIC_CONST_VAL_FLOAT(val_1328, 108.082001);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1329, 114.138000);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_1330, 20.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_1331, 0.439599);
DEF_STATIC_CONST_VAL_FLOAT(val_1332, 0.325276);
DEF_STATIC_CONST_VAL_FLOAT(val_1333, 105.407997);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1334, 96.482803);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1335, 0.799005);
DEF_STATIC_CONST_VAL_FLOAT(val_1336, 93.285103);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1337, 89.775299);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_1338, 87.709801);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0009 15
DEF_STATIC_CONST_VAL_FLOAT(val_1339, 98.505600);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0004 16
DEF_STATIC_CONST_VAL_FLOAT(val_1340, 26.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_1341, 89.263702);
#define CTNODE_cmu_us_rms_f0_ah_13_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1342, 82.799301);
DEF_STATIC_CONST_VAL_FLOAT(val_1343, 0.291984);
DEF_STATIC_CONST_VAL_FLOAT(val_1344, 0.175314);
DEF_STATIC_CONST_VAL_FLOAT(val_1345, 105.264999);
#define CTNODE_cmu_us_rms_f0_v_184_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1346, 96.201698);
#define CTNODE_cmu_us_rms_f0_v_184_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_1347, 0.835253);
DEF_STATIC_CONST_VAL_FLOAT(val_1348, 94.918503);
#define CTNODE_cmu_us_rms_f0_v_184_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1349, 89.164398);
#define CTNODE_cmu_us_rms_f0_v_184_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1350, 0.453937);
DEF_STATIC_CONST_VAL_FLOAT(val_1351, 90.730797);
#define CTNODE_cmu_us_rms_f0_v_184_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1352, 84.653099);
#define CTNODE_cmu_us_rms_f0_v_184_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1353, 86.755699);
#define CTNODE_cmu_us_rms_f0_v_184_NO_0004 14
DEF_STATIC_CONST_VAL_FLOAT(val_1354, 81.907204);
DEF_STATIC_CONST_VAL_FLOAT(val_1355, 1.269000);
DEF_STATIC_CONST_VAL_FLOAT(val_1356, 102.441002);
#define CTNODE_cmu_us_rms_f0_v_185_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1357, 92.848000);
#define CTNODE_cmu_us_rms_f0_v_185_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_1358, 2.177000);
DEF_STATIC_CONST_VAL_FLOAT(val_1359, 89.617401);
#define CTNODE_cmu_us_rms_f0_v_185_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1360, 86.611900);
#define CTNODE_cmu_us_rms_f0_v_185_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_1361, 87.053497);
#define CTNODE_cmu_us_rms_f0_v_185_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1362, 0.020500);
DEF_STATIC_CONST_VAL_FLOAT(val_1363, 82.056000);
#define CTNODE_cmu_us_rms_f0_v_185_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1364, 85.585403);
DEF_STATIC_CONST_VAL_FLOAT(val_1365, 6.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_1366, 0.306925);
DEF_STATIC_CONST_VAL_FLOAT(val_1367, 93.270599);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1368, 0.189630);
DEF_STATIC_CONST_VAL_FLOAT(val_1369, 106.497002);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_1370, 99.949303);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_1371, 0.778606);
DEF_STATIC_CONST_VAL_FLOAT(val_1372, 93.834297);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1373, 0.012000);
DEF_STATIC_CONST_VAL_FLOAT(val_1374, 0.043000);
DEF_STATIC_CONST_VAL_FLOAT(val_1375, 87.748901);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1376, 92.632698);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_1377, 86.184700);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0008 16
DEF_STATIC_CONST_VAL_FLOAT(val_1378, 98.098198);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0007 17
DEF_STATIC_CONST_VAL_FLOAT(val_1379, 82.237297);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_1380, 88.925201);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0000 20
DEF_STATIC_CONST_VAL_FLOAT(val_1381, 0.074500);
DEF_STATIC_CONST_VAL_FLOAT(val_1382, 107.277000);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1383, 99.543602);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_1384, 114.850998);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0020 26
DEF_STATIC_CONST_VAL_FLOAT(val_1385, 0.709244);
DEF_STATIC_CONST_VAL_FLOAT(val_1386, 0.436534);
DEF_STATIC_CONST_VAL_FLOAT(val_1387, 102.989998);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1388, 97.100098);
#define CTNODE_cmu_us_rms_f0_v_186_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_1389, 91.397697);
DEF_STATIC_CONST_VAL_FLOAT(val_1390, 0.165651);
DEF_STATIC_CONST_VAL_FLOAT(val_1391, 117.901001);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1392, 0.090000);
DEF_STATIC_CONST_VAL_FLOAT(val_1393, 0.074000);
DEF_STATIC_CONST_VAL_FLOAT(val_1394, 17.200001);
DEF_STATIC_CONST_VAL_FLOAT(val_1395, 102.690002);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1396, 110.882004);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1397, 93.961403);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0004 10
DEF_STATIC_CONST_VAL_FLOAT(val_1398, 113.584000);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0001 11
DEF_STATIC_CONST_VAL_FLOAT(val_1399, 0.065000);
DEF_STATIC_CONST_VAL_FLOAT(val_1400, 114.952003);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1401, 133.820007);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0000 14
DEF_STATIC_CONST_VAL_FLOAT(val_1402, 0.751860);
DEF_STATIC_CONST_VAL_FLOAT(val_1403, 0.033000);
DEF_STATIC_CONST_VAL_FLOAT(val_1404, 89.061996);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1405, 93.668198);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0015 19
DEF_STATIC_CONST_VAL_FLOAT(val_1406, 80.820099);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0014 20
DEF_STATIC_CONST_VAL_FLOAT(val_1407, 0.479223);
DEF_STATIC_CONST_VAL_FLOAT(val_1408, 0.062500);
DEF_STATIC_CONST_VAL_FLOAT(val_1409, 103.296997);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1410, 94.967598);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_1411, 97.810699);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_1412, 112.378998);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_1413, 116.755997);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0020 30
DEF_STATIC_CONST_VAL_FLOAT(val_1414, 0.043000);
DEF_STATIC_CONST_VAL_FLOAT(val_1415, 85.337402);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_1416, 93.175598);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0030 34
DEF_STATIC_CONST_VAL_FLOAT(val_1417, 0.088889);
DEF_STATIC_CONST_VAL_FLOAT(val_1418, 94.733498);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_1419, 96.765900);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_1420, 98.437500);
#define CTNODE_cmu_us_rms_f0_dh_51_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_1421, 105.057999);
DEF_STATIC_CONST_VAL_FLOAT(val_1422, 13.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1423, 0.441673);
DEF_STATIC_CONST_VAL_FLOAT(val_1424, 6.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_1425, 0.868000);
DEF_STATIC_CONST_VAL_FLOAT(val_1426, 15.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_1427, 102.943001);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1428, 100.139000);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1429, 106.278000);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0004 10
DEF_STATIC_CONST_VAL_FLOAT(val_1430, 111.222000);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0003 11
DEF_STATIC_CONST_VAL_FLOAT(val_1431, 0.499288);
DEF_STATIC_CONST_VAL_FLOAT(val_1432, 93.442200);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1433, 100.417000);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0002 14
DEF_STATIC_CONST_VAL_FLOAT(val_1434, 9.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_1435, 14.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1436, 97.138802);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1437, 98.937698);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_1438, 0.711250);
DEF_STATIC_CONST_VAL_FLOAT(val_1439, 93.558899);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_1440, 94.800400);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0019 23
DEF_STATIC_CONST_VAL_FLOAT(val_1441, 14.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_1442, 93.356598);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1443, 92.087097);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0018 26
DEF_STATIC_CONST_VAL_FLOAT(val_1444, 96.496300);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0001 27
DEF_STATIC_CONST_VAL_FLOAT(val_1445, 0.688667);
DEF_STATIC_CONST_VAL_FLOAT(val_1446, 0.650901);
DEF_STATIC_CONST_VAL_FLOAT(val_1447, 94.886200);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1448, 90.490700);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0028 32
DEF_STATIC_CONST_VAL_FLOAT(val_1449, 92.360901);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_1450, 0.027500);
DEF_STATIC_CONST_VAL_FLOAT(val_1451, 87.017303);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_1452, 89.401901);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0027 37
DEF_STATIC_CONST_VAL_FLOAT(val_1453, 0.042500);
DEF_STATIC_CONST_VAL_FLOAT(val_1454, 97.092201);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_1455, 91.285301);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0000 40
DEF_STATIC_CONST_VAL_FLOAT(val_1456, 105.231003);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1457, 18.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1458, 109.568001);
#define CTNODE_cmu_us_rms_f0_dh_52_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_1459, 113.834000);
DEF_STATIC_CONST_VAL_FLOAT(val_1460, 0.342857);
DEF_STATIC_CONST_VAL_FLOAT(val_1461, 0.189047);
DEF_STATIC_CONST_VAL_FLOAT(val_1462, 0.057134);
DEF_STATIC_CONST_VAL_FLOAT(val_1463, 102.088997);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1464, 97.466904);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_1465, 105.249001);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0003 9
DEF_STATIC_CONST_VAL_FLOAT(val_1466, 93.802002);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1467, 3.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_1468, 97.675301);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1469, 101.161003);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0002 14
DEF_STATIC_CONST_VAL_FLOAT(val_1470, 94.663803);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0001 15
DEF_STATIC_CONST_VAL_FLOAT(val_1471, 108.720001);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1472, 101.039001);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0000 18
DEF_STATIC_CONST_VAL_FLOAT(val_1473, 0.039500);
DEF_STATIC_CONST_VAL_FLOAT(val_1474, 99.319901);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1475, 92.149399);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_1476, 0.057000);
DEF_STATIC_CONST_VAL_FLOAT(val_1477, 9.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1478, 88.274300);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_1479, 92.030998);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_1480, 0.025000);
DEF_STATIC_CONST_VAL_FLOAT(val_1481, 97.561798);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1482, 92.169403);
#define CTNODE_cmu_us_rms_f0_dh_53_NO_0022 30
DEF_STATIC_CONST_VAL_FLOAT(val_1483, 86.693604);
DEF_STATIC_CONST_VAL_FLOAT(val_1484, 0.060000);
DEF_STATIC_CONST_VAL_FLOAT(val_1485, 111.065002);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1486, 93.455704);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_1487, 0.042500);
DEF_STATIC_CONST_VAL_FLOAT(val_1488, 0.910396);
DEF_STATIC_CONST_VAL_FLOAT(val_1489, 85.416000);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1490, 78.533401);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1491, 75.952904);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0005 11
DEF_STATIC_CONST_VAL_FLOAT(val_1492, 90.890900);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0004 12
DEF_STATIC_CONST_VAL_FLOAT(val_1493, 0.483720);
DEF_STATIC_CONST_VAL_FLOAT(val_1494, 86.677399);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_1495, 81.284103);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0012 16
DEF_STATIC_CONST_VAL_FLOAT(val_1496, 0.209252);
DEF_STATIC_CONST_VAL_FLOAT(val_1497, 0.036500);
DEF_STATIC_CONST_VAL_FLOAT(val_1498, 100.351997);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1499, 91.029999);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_1500, 0.644892);
DEF_STATIC_CONST_VAL_FLOAT(val_1501, 12.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_1502, 0.026000);
DEF_STATIC_CONST_VAL_FLOAT(val_1503, 93.172401);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1504, 86.340500);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_1505, 89.704102);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0022 28
DEF_STATIC_CONST_VAL_FLOAT(val_1506, 85.622200);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0021 29
DEF_STATIC_CONST_VAL_FLOAT(val_1507, 81.613899);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1508, 86.574997);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0016 32
DEF_STATIC_CONST_VAL_STRING(val_1509, "n_118");
DEF_STATIC_CONST_VAL_FLOAT(val_1510, 0.030500);
DEF_STATIC_CONST_VAL_FLOAT(val_1511, 91.804199);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1512, 84.724701);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0032 36
DEF_STATIC_CONST_VAL_STRING(val_1513, "l_108");
DEF_STATIC_CONST_VAL_FLOAT(val_1514, 91.076797);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_1515, 94.421600);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_1516, 97.931297);
#define CTNODE_cmu_us_rms_f0_d_46_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1517, 107.492996);
DEF_STATIC_CONST_VAL_FLOAT(val_1518, 1.243000);
DEF_STATIC_CONST_VAL_FLOAT(val_1519, 107.156998);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1520, 0.321653);
DEF_STATIC_CONST_VAL_FLOAT(val_1521, 0.179936);
DEF_STATIC_CONST_VAL_FLOAT(val_1522, 100.987000);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1523, 95.829697);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_1524, 92.974098);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0003 9
DEF_STATIC_CONST_VAL_FLOAT(val_1525, 90.404701);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_1526, 103.146004);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1527, 0.919556);
DEF_STATIC_CONST_VAL_FLOAT(val_1528, 0.063500);
DEF_STATIC_CONST_VAL_FLOAT(val_1529, 0.043500);
DEF_STATIC_CONST_VAL_FLOAT(val_1530, 0.711444);
DEF_STATIC_CONST_VAL_FLOAT(val_1531, 88.238899);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1532, 90.991699);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_1533, 83.263702);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0016 22
DEF_STATIC_CONST_VAL_FLOAT(val_1534, 0.023000);
DEF_STATIC_CONST_VAL_FLOAT(val_1535, 90.068199);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1536, 95.166603);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0015 25
DEF_STATIC_CONST_VAL_FLOAT(val_1537, 0.392584);
DEF_STATIC_CONST_VAL_FLOAT(val_1538, 80.638000);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_1539, 85.948303);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0014 28
DEF_STATIC_CONST_VAL_FLOAT(val_1540, 82.322502);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0013 29
DEF_STATIC_CONST_VAL_FLOAT(val_1541, 95.753601);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0012 30
DEF_STATIC_CONST_VAL_FLOAT(val_1542, 3.555000);
DEF_STATIC_CONST_VAL_FLOAT(val_1543, 78.869499);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_1544, 72.591797);
#define CTNODE_cmu_us_rms_f0_d_47_NO_0030 34
DEF_STATIC_CONST_VAL_FLOAT(val_1545, 85.571503);
DEF_STATIC_CONST_VAL_FLOAT(val_1546, 106.707001);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1547, 0.905837);
DEF_STATIC_CONST_VAL_FLOAT(val_1548, 4.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_1549, 81.454803);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1550, 86.674400);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_1551, 97.608597);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1552, 82.057198);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1553, 0.226987);
DEF_STATIC_CONST_VAL_FLOAT(val_1554, 97.657997);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1555, 84.164497);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1556, 89.757797);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_1557, 97.525101);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1558, 89.814499);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0003 21
DEF_STATIC_CONST_VAL_FLOAT(val_1559, 79.385201);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1560, 74.341499);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_1561, 84.211998);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0000 26
DEF_STATIC_CONST_VAL_FLOAT(val_1562, 85.062599);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_1563, 111.216003);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_1564, 0.490348);
DEF_STATIC_CONST_VAL_FLOAT(val_1565, 0.198561);
DEF_STATIC_CONST_VAL_FLOAT(val_1566, 109.308998);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1567, 100.723000);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_1568, 112.452003);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0031 37
DEF_STATIC_CONST_VAL_FLOAT(val_1569, 95.086197);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_1570, 99.334396);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0037 41
DEF_STATIC_CONST_VAL_FLOAT(val_1571, 107.122002);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_1572, 99.284103);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0030 44
DEF_STATIC_CONST_VAL_FLOAT(val_1573, 0.024500);
DEF_STATIC_CONST_VAL_FLOAT(val_1574, 0.047500);
DEF_STATIC_CONST_VAL_FLOAT(val_1575, 0.828093);
DEF_STATIC_CONST_VAL_FLOAT(val_1576, 94.163101);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_1577, 88.876503);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0046 50
DEF_STATIC_CONST_VAL_FLOAT(val_1578, 85.409698);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0045 51
DEF_STATIC_CONST_VAL_FLOAT(val_1579, 97.482903);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0044 52
DEF_STATIC_CONST_VAL_FLOAT(val_1580, 92.054703);
#define CTNODE_cmu_us_rms_f0_d_48_NO_0052 54
DEF_STATIC_CONST_VAL_FLOAT(val_1581, 99.199501);
DEF_STATIC_CONST_VAL_FLOAT(val_1582, 0.398911);
DEF_STATIC_CONST_VAL_FLOAT(val_1583, 0.160169);
DEF_STATIC_CONST_VAL_FLOAT(val_1584, 114.647003);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1585, 102.497002);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1586, 106.967003);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1587, 100.311996);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0002 10
DEF_STATIC_CONST_VAL_FLOAT(val_1588, 0.122573);
DEF_STATIC_CONST_VAL_FLOAT(val_1589, 123.084999);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1590, 116.425003);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_1591, 112.278000);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0001 15
DEF_STATIC_CONST_VAL_FLOAT(val_1592, 94.602898);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1593, 100.348000);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_1594, 0.025000);
DEF_STATIC_CONST_VAL_FLOAT(val_1595, 0.231938);
DEF_STATIC_CONST_VAL_FLOAT(val_1596, 117.445000);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1597, 110.758003);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_1598, 0.332167);
DEF_STATIC_CONST_VAL_FLOAT(val_1599, 103.699997);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1600, 109.226997);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_1601, 102.575996);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0021 31
DEF_STATIC_CONST_VAL_FLOAT(val_1602, 99.723503);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0016 32
DEF_STATIC_CONST_VAL_STRING(val_1603, "ae_8");
DEF_STATIC_CONST_VAL_FLOAT(val_1604, 92.701500);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_1605, 97.921501);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0015 35
DEF_STATIC_CONST_VAL_FLOAT(val_1606, 92.188797);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0000 36
DEF_STATIC_CONST_VAL_FLOAT(val_1607, 0.922117);
DEF_STATIC_CONST_VAL_FLOAT(val_1608, 97.146797);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1609, 86.515800);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_1610, 92.156097);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0039 45
DEF_STATIC_CONST_VAL_FLOAT(val_1611, 0.018000);
DEF_STATIC_CONST_VAL_FLOAT(val_1612, 94.405800);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_1613, 0.011500);
DEF_STATIC_CONST_VAL_FLOAT(val_1614, 95.923599);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_1615, 101.547997);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0049 53
DEF_STATIC_CONST_VAL_FLOAT(val_1616, 103.533997);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0048 54
DEF_STATIC_CONST_VAL_FLOAT(val_1617, 99.724899);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0054 56
DEF_STATIC_CONST_VAL_FLOAT(val_1618, 92.369499);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0047 57
DEF_STATIC_CONST_VAL_FLOAT(val_1619, 106.026001);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_1620, 97.615898);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0059 61
DEF_STATIC_CONST_VAL_FLOAT(val_1621, 102.558998);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0038 62
DEF_STATIC_CONST_VAL_FLOAT(val_1622, 84.709198);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0037 63
DEF_STATIC_CONST_VAL_FLOAT(val_1623, 0.706481);
DEF_STATIC_CONST_VAL_FLOAT(val_1624, 0.554751);
DEF_STATIC_CONST_VAL_FLOAT(val_1625, 87.254601);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_1626, 87.653702);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0064 68
DEF_STATIC_CONST_VAL_FLOAT(val_1627, 85.266098);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0063 69
DEF_STATIC_CONST_VAL_FLOAT(val_1628, 0.719369);
DEF_STATIC_CONST_VAL_FLOAT(val_1629, 93.846298);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0069 71
DEF_STATIC_CONST_VAL_FLOAT(val_1630, 90.203300);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0036 72
DEF_STATIC_CONST_VAL_FLOAT(val_1631, 82.626404);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0072 74
DEF_STATIC_CONST_VAL_FLOAT(val_1632, 0.092000);
DEF_STATIC_CONST_VAL_FLOAT(val_1633, 0.069000);
DEF_STATIC_CONST_VAL_FLOAT(val_1634, 92.241203);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0075 77
DEF_STATIC_CONST_VAL_FLOAT(val_1635, 83.378601);
#define CTNODE_cmu_us_rms_f0_n_116_NO_0074 78
DEF_STATIC_CONST_VAL_FLOAT(val_1636, 93.100899);
DEF_STATIC_CONST_VAL_FLOAT(val_1637, 0.395921);
DEF_STATIC_CONST_VAL_FLOAT(val_1638, 0.717000);
DEF_STATIC_CONST_VAL_FLOAT(val_1639, 0.038000);
DEF_STATIC_CONST_VAL_FLOAT(val_1640, 101.434998);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_1641, 112.568001);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_1642, 94.556297);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1643, 99.622597);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_1644, 97.912903);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_1645, 0.491774);
DEF_STATIC_CONST_VAL_FLOAT(val_1646, 106.283997);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_1647, 101.056000);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0002 16
DEF_STATIC_CONST_VAL_FLOAT(val_1648, 100.780998);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1649, 0.038000);
DEF_STATIC_CONST_VAL_FLOAT(val_1650, 94.362396);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1651, 100.582001);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_1652, 8.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_1653, 95.416100);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1654, 90.976898);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_1655, 89.384102);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0001 27
DEF_STATIC_CONST_VAL_FLOAT(val_1656, 0.616257);
DEF_STATIC_CONST_VAL_FLOAT(val_1657, 97.744499);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_1658, 88.710701);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_1659, 94.191200);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0027 33
DEF_STATIC_CONST_VAL_FLOAT(val_1660, 3.630000);
DEF_STATIC_CONST_VAL_FLOAT(val_1661, 2.367500);
DEF_STATIC_CONST_VAL_FLOAT(val_1662, 86.128403);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_1663, 83.797997);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_1664, 90.333504);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1665, 86.448799);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0039 43
DEF_STATIC_CONST_VAL_FLOAT(val_1666, 81.647301);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0038 44
DEF_STATIC_CONST_VAL_FLOAT(val_1667, 0.571179);
DEF_STATIC_CONST_VAL_FLOAT(val_1668, 89.730103);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_1669, 95.114197);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0045 49
DEF_STATIC_CONST_VAL_FLOAT(val_1670, 2.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_1671, 90.356499);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_1672, 92.252502);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0049 53
DEF_STATIC_CONST_VAL_FLOAT(val_1673, 90.758400);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_1674, 88.693298);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_1675, 84.302200);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0044 58
DEF_STATIC_CONST_VAL_FLOAT(val_1676, 92.037003);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0059 61
DEF_STATIC_CONST_VAL_FLOAT(val_1677, 85.260803);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0058 62
DEF_STATIC_CONST_VAL_FLOAT(val_1678, 94.696198);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0063 65
DEF_STATIC_CONST_VAL_FLOAT(val_1679, 91.349297);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0062 66
DEF_STATIC_CONST_VAL_FLOAT(val_1680, 98.645302);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0033 67
DEF_STATIC_CONST_VAL_FLOAT(val_1681, 0.914189);
DEF_STATIC_CONST_VAL_FLOAT(val_1682, 85.442802);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0067 69
DEF_STATIC_CONST_VAL_FLOAT(val_1683, 80.947800);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0000 70
DEF_STATIC_CONST_VAL_FLOAT(val_1684, 1.775500);
DEF_STATIC_CONST_VAL_FLOAT(val_1685, 0.067000);
DEF_STATIC_CONST_VAL_FLOAT(val_1686, 93.103699);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0071 73
DEF_STATIC_CONST_VAL_FLOAT(val_1687, 0.014000);
DEF_STATIC_CONST_VAL_FLOAT(val_1688, 81.082001);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0073 75
DEF_STATIC_CONST_VAL_FLOAT(val_1689, 88.008400);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0075 77
DEF_STATIC_CONST_VAL_FLOAT(val_1690, 85.099899);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0070 78
DEF_STATIC_CONST_VAL_FLOAT(val_1691, 72.992104);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0078 80
DEF_STATIC_CONST_VAL_FLOAT(val_1692, 7.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_1693, 2.836000);
DEF_STATIC_CONST_VAL_FLOAT(val_1694, 77.954201);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0082 84
DEF_STATIC_CONST_VAL_FLOAT(val_1695, 84.172600);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0081 85
DEF_STATIC_CONST_VAL_FLOAT(val_1696, 3.836000);
DEF_STATIC_CONST_VAL_FLOAT(val_1697, 90.504997);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0086 88
DEF_STATIC_CONST_VAL_FLOAT(val_1698, 85.961899);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0085 89
DEF_STATIC_CONST_VAL_FLOAT(val_1699, 83.528397);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0080 90
DEF_STATIC_CONST_VAL_FLOAT(val_1700, 83.545097);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0090 92
DEF_STATIC_CONST_VAL_FLOAT(val_1701, 0.017000);
DEF_STATIC_CONST_VAL_FLOAT(val_1702, 78.270699);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0094 96
DEF_STATIC_CONST_VAL_FLOAT(val_1703, 82.764603);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0093 97
DEF_STATIC_CONST_VAL_FLOAT(val_1704, 76.175301);
#define CTNODE_cmu_us_rms_f0_n_117_NO_0092 98
DEF_STATIC_CONST_VAL_FLOAT(val_1705, 73.613403);
DEF_STATIC_CONST_VAL_FLOAT(val_1706, 0.403789);
DEF_STATIC_CONST_VAL_FLOAT(val_1707, 0.244790);
DEF_STATIC_CONST_VAL_FLOAT(val_1708, 104.913002);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1709, 99.057297);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1710, 90.376801);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0002 8
DEF_STATIC_CONST_VAL_FLOAT(val_1711, 0.016000);
DEF_STATIC_CONST_VAL_FLOAT(val_1712, 113.112000);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1713, 101.841003);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0001 11
DEF_STATIC_CONST_VAL_FLOAT(val_1714, 93.899803);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1715, 87.316200);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_1716, 91.424400);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0011 17
DEF_STATIC_CONST_VAL_FLOAT(val_1717, 102.254997);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0000 18
DEF_STATIC_CONST_VAL_FLOAT(val_1718, 0.940383);
DEF_STATIC_CONST_VAL_FLOAT(val_1719, 0.779165);
DEF_STATIC_CONST_VAL_FLOAT(val_1720, 94.237396);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_1721, 97.926804);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_1722, 88.061501);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0019 25
DEF_STATIC_CONST_VAL_FLOAT(val_1723, 7.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1724, 77.732101);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_1725, 88.400002);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1726, 92.537697);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0028 32
DEF_STATIC_CONST_VAL_STRING(val_1727, "ax");
DEF_STATIC_CONST_VAL_FLOAT(val_1728, 0.726237);
DEF_STATIC_CONST_VAL_FLOAT(val_1729, 85.017502);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1730, 80.515099);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_1731, 92.597504);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_1732, 86.965401);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0036 40
DEF_STATIC_CONST_VAL_FLOAT(val_1733, 0.663146);
DEF_STATIC_CONST_VAL_FLOAT(val_1734, 84.424896);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_1735, 82.241699);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0040 44
DEF_STATIC_CONST_VAL_FLOAT(val_1736, 86.905998);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0025 45
DEF_STATIC_CONST_VAL_FLOAT(val_1737, 94.324097);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0018 46
DEF_STATIC_CONST_VAL_FLOAT(val_1738, 0.059000);
DEF_STATIC_CONST_VAL_FLOAT(val_1739, 0.976176);
DEF_STATIC_CONST_VAL_FLOAT(val_1740, 78.452202);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_1741, 74.984100);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0046 50
DEF_STATIC_CONST_VAL_FLOAT(val_1742, 81.316299);
#define CTNODE_cmu_us_rms_f0_n_118_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_1743, 87.994904);
DEF_STATIC_CONST_VAL_FLOAT(val_1744, 0.480306);
DEF_STATIC_CONST_VAL_FLOAT(val_1745, 98.030602);
#define CTNODE_cmu_us_rms_f0_jh_96_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1746, 93.850403);
#define CTNODE_cmu_us_rms_f0_jh_96_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_1747, 93.315804);
#define CTNODE_cmu_us_rms_f0_jh_96_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_1748, 89.267197);
#define CTNODE_cmu_us_rms_f0_jh_96_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_1749, 85.468399);
#define CTNODE_cmu_us_rms_f0_jh_96_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_1750, 79.647102);
DEF_STATIC_CONST_VAL_FLOAT(val_1751, 0.484907);
DEF_STATIC_CONST_VAL_FLOAT(val_1752, 100.928001);
#define CTNODE_cmu_us_rms_f0_jh_97_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1753, 110.700996);
#define CTNODE_cmu_us_rms_f0_jh_97_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_1754, 2.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_1755, 94.704597);
#define CTNODE_cmu_us_rms_f0_jh_97_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1756, 100.297997);
#define CTNODE_cmu_us_rms_f0_jh_97_NO_0001 9
DEF_STATIC_CONST_VAL_FLOAT(val_1757, 2.019000);
DEF_STATIC_CONST_VAL_FLOAT(val_1758, 108.671997);
#define CTNODE_cmu_us_rms_f0_jh_97_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1759, 119.745003);
#define CTNODE_cmu_us_rms_f0_jh_97_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_1760, 106.174004);
#define CTNODE_cmu_us_rms_f0_jh_97_NO_0000 14
DEF_STATIC_CONST_VAL_FLOAT(val_1761, 84.789803);
DEF_STATIC_CONST_VAL_FLOAT(val_1762, 0.901423);
DEF_STATIC_CONST_VAL_FLOAT(val_1763, 0.030000);
DEF_STATIC_CONST_VAL_FLOAT(val_1764, 112.950996);
#define CTNODE_cmu_us_rms_f0_jh_98_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1765, 0.457663);
DEF_STATIC_CONST_VAL_FLOAT(val_1766, 0.070000);
DEF_STATIC_CONST_VAL_FLOAT(val_1767, 110.487000);
#define CTNODE_cmu_us_rms_f0_jh_98_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_1768, 102.849998);
#define CTNODE_cmu_us_rms_f0_jh_98_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_1769, 95.809097);
#define CTNODE_cmu_us_rms_f0_jh_98_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_1770, 102.027000);
#define CTNODE_cmu_us_rms_f0_jh_98_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_1771, 81.902397);
DEF_STATIC_CONST_VAL_FLOAT(val_1772, 111.226997);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1773, 106.152000);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_1774, 0.063500);
DEF_STATIC_CONST_VAL_FLOAT(val_1775, 88.736504);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1776, 0.328766);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1777, 111.195999);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_1778, 0.643002);
DEF_STATIC_CONST_VAL_FLOAT(val_1779, 98.871498);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_1780, 102.945999);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0013 17
DEF_STATIC_CONST_VAL_FLOAT(val_1781, 93.463600);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_1782, 0.043500);
DEF_STATIC_CONST_VAL_FLOAT(val_1783, 96.019402);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1784, 100.154999);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0008 22
DEF_STATIC_CONST_VAL_FLOAT(val_1785, 0.025000);
DEF_STATIC_CONST_VAL_FLOAT(val_1786, 90.970299);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1787, 94.965797);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0005 25
DEF_STATIC_CONST_VAL_FLOAT(val_1788, 0.308548);
DEF_STATIC_CONST_VAL_FLOAT(val_1789, 92.866302);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1790, 96.886398);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_1791, 105.985001);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0025 31
DEF_STATIC_CONST_VAL_FLOAT(val_1792, 0.751849);
DEF_STATIC_CONST_VAL_FLOAT(val_1793, 0.105500);
DEF_STATIC_CONST_VAL_FLOAT(val_1794, 91.572998);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1795, 103.286003);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_1796, 89.805603);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0031 37
DEF_STATIC_CONST_VAL_FLOAT(val_1797, 94.604797);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_1798, 83.519699);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_1799, 0.635343);
DEF_STATIC_CONST_VAL_FLOAT(val_1800, 93.649803);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0043 45
DEF_STATIC_CONST_VAL_FLOAT(val_1801, 91.982697);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_1802, 86.714996);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0042 48
DEF_STATIC_CONST_VAL_FLOAT(val_1803, 96.986000);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0041 49
DEF_STATIC_CONST_VAL_FLOAT(val_1804, 0.794494);
DEF_STATIC_CONST_VAL_FLOAT(val_1805, 88.741699);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_1806, 84.869598);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0049 53
DEF_STATIC_CONST_VAL_FLOAT(val_1807, 88.051102);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_1808, 90.219200);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0000 56
DEF_STATIC_CONST_VAL_FLOAT(val_1809, 0.568821);
DEF_STATIC_CONST_VAL_STRING(val_1810, "g_78");
DEF_STATIC_CONST_VAL_FLOAT(val_1811, 105.275002);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0058 60
DEF_STATIC_CONST_VAL_FLOAT(val_1812, 100.059998);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0057 61
DEF_STATIC_CONST_VAL_FLOAT(val_1813, 0.176471);
DEF_STATIC_CONST_VAL_FLOAT(val_1814, 98.096001);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_1815, 90.107697);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0056 64
DEF_STATIC_CONST_VAL_FLOAT(val_1816, 0.275000);
DEF_STATIC_CONST_VAL_FLOAT(val_1817, 127.059998);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_1818, 0.466327);
DEF_STATIC_CONST_VAL_FLOAT(val_1819, 123.504997);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0067 69
DEF_STATIC_CONST_VAL_FLOAT(val_1820, 111.230003);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0069 71
DEF_STATIC_CONST_VAL_FLOAT(val_1821, 116.568001);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0064 72
DEF_STATIC_CONST_VAL_FLOAT(val_1822, 0.062500);
DEF_STATIC_CONST_VAL_FLOAT(val_1823, 112.834999);
#define CTNODE_cmu_us_rms_f0_r_146_NO_0072 74
DEF_STATIC_CONST_VAL_FLOAT(val_1824, 98.093201);
DEF_STATIC_CONST_VAL_FLOAT(val_1825, 0.704500);
DEF_STATIC_CONST_VAL_FLOAT(val_1826, 121.446999);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1827, 114.815002);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1828, 0.456000);
DEF_STATIC_CONST_VAL_FLOAT(val_1829, 105.793999);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1830, 112.223000);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1831, 102.725998);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_1832, 79.872498);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0012 14
DEF_STATIC_CONST_VAL_STRING(val_1833, "aa");
DEF_STATIC_CONST_VAL_FLOAT(val_1834, 80.884697);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_1835, 88.430496);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_1836, 13.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_1837, 99.023003);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1838, 89.223701);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0011 21
DEF_STATIC_CONST_VAL_FLOAT(val_1839, 99.241600);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_1840, 94.009499);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_1841, 101.903999);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0022 28
DEF_STATIC_CONST_VAL_FLOAT(val_1842, 0.105000);
DEF_STATIC_CONST_VAL_FLOAT(val_1843, 92.563004);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_1844, 87.288101);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0029 33
DEF_STATIC_CONST_VAL_FLOAT(val_1845, 96.328102);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0028 34
DEF_STATIC_CONST_VAL_FLOAT(val_1846, 85.235397);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0021 35
#define CTNODE_cmu_us_rms_f0_r_147_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_1847, 1.542000);
DEF_STATIC_CONST_VAL_FLOAT(val_1848, 105.794998);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_1849, 100.781998);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0038 42
DEF_STATIC_CONST_VAL_FLOAT(val_1850, 98.051003);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0037 43
DEF_STATIC_CONST_VAL_FLOAT(val_1851, 97.345200);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_1852, 93.768303);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0044 48
DEF_STATIC_CONST_VAL_FLOAT(val_1853, 87.305603);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0043 49
DEF_STATIC_CONST_VAL_FLOAT(val_1854, 100.130997);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0010 50
DEF_STATIC_CONST_VAL_FLOAT(val_1855, 0.458049);
DEF_STATIC_CONST_VAL_FLOAT(val_1856, 102.397003);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_1857, 0.749621);
DEF_STATIC_CONST_VAL_FLOAT(val_1858, 96.100998);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_1859, 92.047501);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0050 56
DEF_STATIC_CONST_VAL_FLOAT(val_1860, 0.547672);
DEF_STATIC_CONST_VAL_FLOAT(val_1861, 0.417949);
DEF_STATIC_CONST_VAL_FLOAT(val_1862, 120.387001);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_1863, 111.828003);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0056 60
DEF_STATIC_CONST_VAL_FLOAT(val_1864, 0.399668);
DEF_STATIC_CONST_VAL_FLOAT(val_1865, 112.032997);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_1866, 103.730003);
#define CTNODE_cmu_us_rms_f0_r_147_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_1867, 97.780701);
DEF_STATIC_CONST_VAL_FLOAT(val_1868, 84.413597);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1869, 0.145000);
DEF_STATIC_CONST_VAL_FLOAT(val_1870, 78.522202);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_1871, 72.517403);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_1872, 19.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1873, 93.178001);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_1874, 85.121696);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_1875, 94.713303);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0008 14
DEF_STATIC_CONST_VAL_FLOAT(val_1876, 110.963997);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_1877, 0.304107);
DEF_STATIC_CONST_VAL_FLOAT(val_1878, 100.573997);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1879, 93.365898);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0007 19
DEF_STATIC_CONST_VAL_FLOAT(val_1880, 0.518440);
DEF_STATIC_CONST_VAL_FLOAT(val_1881, 0.049000);
DEF_STATIC_CONST_VAL_FLOAT(val_1882, 94.924896);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_1883, 90.045601);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0019 23
DEF_STATIC_CONST_VAL_FLOAT(val_1884, 88.588699);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1885, 81.278702);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0000 26
DEF_STATIC_CONST_VAL_FLOAT(val_1886, 0.310997);
DEF_STATIC_CONST_VAL_FLOAT(val_1887, 0.035000);
DEF_STATIC_CONST_VAL_FLOAT(val_1888, 115.553001);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_1889, 127.833000);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_1890, 0.169188);
DEF_STATIC_CONST_VAL_FLOAT(val_1891, 110.220001);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_1892, 103.110001);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0026 34
DEF_STATIC_CONST_VAL_FLOAT(val_1893, 84.974098);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_1894, 93.167198);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_1895, 91.727898);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_1896, 95.852997);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0038 42
DEF_STATIC_CONST_VAL_FLOAT(val_1897, 111.379997);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_1898, 0.024000);
DEF_STATIC_CONST_VAL_FLOAT(val_1899, 98.600197);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_1900, 106.555000);
#define CTNODE_cmu_us_rms_f0_r_148_NO_0044 48
DEF_STATIC_CONST_VAL_FLOAT(val_1901, 96.515503);
DEF_STATIC_CONST_VAL_FLOAT(val_1902, 101.990997);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_1903, 87.084503);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_1904, 0.907040);
DEF_STATIC_CONST_VAL_FLOAT(val_1905, 0.870791);
DEF_STATIC_CONST_VAL_FLOAT(val_1906, 91.703201);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1907, 88.377098);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_1908, 0.934209);
DEF_STATIC_CONST_VAL_FLOAT(val_1909, 85.936203);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1910, 78.523697);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0000 12
DEF_STATIC_CONST_VAL_FLOAT(val_1911, 0.185714);
DEF_STATIC_CONST_VAL_FLOAT(val_1912, 121.727997);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0014 16
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0013 17
DEF_STATIC_CONST_VAL_FLOAT(val_1913, 0.443370);
DEF_STATIC_CONST_VAL_FLOAT(val_1914, 113.775002);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0017 19
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0012 20
DEF_STATIC_CONST_VAL_FLOAT(val_1915, 0.185360);
DEF_STATIC_CONST_VAL_FLOAT(val_1916, 100.877998);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0021 23
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_1917, 14.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_1918, 0.594138);
DEF_STATIC_CONST_VAL_FLOAT(val_1919, 93.572701);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1920, 0.349212);
DEF_STATIC_CONST_VAL_FLOAT(val_1921, 102.129997);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1922, 97.499100);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_1923, 95.490303);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0026 34
DEF_STATIC_CONST_VAL_FLOAT(val_1924, 102.109001);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0025 35
DEF_STATIC_CONST_VAL_FLOAT(val_1925, 95.523804);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_1926, 90.482201);
#define CTNODE_cmu_us_rms_f0_ey_66_NO_0024 38
DEF_STATIC_CONST_VAL_FLOAT(val_1927, 88.614403);
DEF_STATIC_CONST_VAL_STRING(val_1928, "dh");
DEF_STATIC_CONST_VAL_FLOAT(val_1929, 96.934196);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1930, 108.623001);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_1931, 0.139771);
DEF_STATIC_CONST_VAL_FLOAT(val_1932, 114.976997);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_1933, 111.510002);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_1934, 122.720001);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0006 12
DEF_STATIC_CONST_VAL_FLOAT(val_1935, 0.103000);
DEF_STATIC_CONST_VAL_FLOAT(val_1936, 107.648003);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_1937, 98.747597);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0012 16
DEF_STATIC_CONST_VAL_FLOAT(val_1938, 0.756000);
DEF_STATIC_CONST_VAL_FLOAT(val_1939, 113.817001);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1940, 107.792000);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0001 19
DEF_STATIC_CONST_VAL_FLOAT(val_1941, 90.286598);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0000 20
DEF_STATIC_CONST_VAL_FLOAT(val_1942, 0.881202);
DEF_STATIC_CONST_VAL_FLOAT(val_1943, 94.011002);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_1944, 90.795197);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_1945, 80.781898);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_1946, 86.638802);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0020 28
DEF_STATIC_CONST_VAL_FLOAT(val_1947, 96.442299);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1948, 1.862000);
DEF_STATIC_CONST_VAL_FLOAT(val_1949, 109.950996);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_1950, 102.417000);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0028 34
DEF_STATIC_CONST_VAL_FLOAT(val_1951, 2.129000);
DEF_STATIC_CONST_VAL_FLOAT(val_1952, 99.688400);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_1953, 93.861702);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0035 39
DEF_STATIC_CONST_VAL_FLOAT(val_1954, 92.127296);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_1955, 89.071297);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0039 43
DEF_STATIC_CONST_VAL_FLOAT(val_1956, 83.370697);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0034 44
DEF_STATIC_CONST_VAL_FLOAT(val_1957, 95.273102);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_1958, 2.180000);
DEF_STATIC_CONST_VAL_FLOAT(val_1959, 105.274002);
#define CTNODE_cmu_us_rms_f0_ey_67_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_1960, 98.192101);
DEF_STATIC_CONST_VAL_FLOAT(val_1961, 72.609901);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1962, 0.080000);
DEF_STATIC_CONST_VAL_FLOAT(val_1963, 86.546700);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_1964, 78.838898);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_1965, 30.400000);
DEF_STATIC_CONST_VAL_STRING(val_1966, "m_111");
DEF_STATIC_CONST_VAL_FLOAT(val_1967, 108.452003);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_1968, 105.220001);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_1969, 0.318296);
DEF_STATIC_CONST_VAL_FLOAT(val_1970, 0.180474);
DEF_STATIC_CONST_VAL_FLOAT(val_1971, 110.917999);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1972, 101.192001);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_1973, 93.975098);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_1974, 0.589471);
DEF_STATIC_CONST_VAL_FLOAT(val_1975, 104.106003);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_1976, 96.557999);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0015 21
DEF_STATIC_CONST_VAL_FLOAT(val_1977, 95.587402);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_1978, 90.589699);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_1979, 87.404800);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0006 26
DEF_STATIC_CONST_VAL_FLOAT(val_1980, 0.412036);
DEF_STATIC_CONST_VAL_FLOAT(val_1981, 85.859901);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_1982, 95.150803);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_1983, 102.453003);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0026 32
DEF_STATIC_CONST_VAL_FLOAT(val_1984, 0.141500);
DEF_STATIC_CONST_VAL_FLOAT(val_1985, 85.774200);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_1986, 92.999199);
#define CTNODE_cmu_us_rms_f0_ey_68_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_1987, 81.458397);
DEF_STATIC_CONST_VAL_FLOAT(val_1988, 135.276993);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_1989, 0.071000);
DEF_STATIC_CONST_VAL_FLOAT(val_1990, 124.307999);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_1991, 113.232002);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_1992, 120.538002);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0003 9
DEF_STATIC_CONST_VAL_FLOAT(val_1993, 107.246002);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_1994, 87.600502);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_1995, 96.789703);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_1996, 101.317001);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0011 17
DEF_STATIC_CONST_VAL_FLOAT(val_1997, 74.284203);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0010 18
DEF_STATIC_CONST_VAL_FLOAT(val_1998, 113.279999);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_1999, 0.469196);
DEF_STATIC_CONST_VAL_FLOAT(val_2000, 108.207001);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_2001, 100.900002);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0018 24
DEF_STATIC_CONST_VAL_FLOAT(val_2002, 88.426903);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2003, 22.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_2004, 100.755997);
#define CTNODE_cmu_us_rms_f0_f_71_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_2005, 93.697800);
DEF_STATIC_CONST_VAL_FLOAT(val_2006, 0.499603);
DEF_STATIC_CONST_VAL_FLOAT(val_2007, 123.431999);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2008, 115.710999);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_2009, 0.304762);
DEF_STATIC_CONST_VAL_FLOAT(val_2010, 100.737000);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2011, 111.556999);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0001 9
DEF_STATIC_CONST_VAL_FLOAT(val_2012, 96.618599);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2013, 2.397500);
DEF_STATIC_CONST_VAL_FLOAT(val_2014, 100.125000);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_2015, 104.274002);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0013 17
DEF_STATIC_CONST_VAL_FLOAT(val_2016, 1.066000);
DEF_STATIC_CONST_VAL_FLOAT(val_2017, 106.077003);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2018, 105.389999);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_2019, 112.277000);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0012 22
DEF_STATIC_CONST_VAL_FLOAT(val_2020, 0.305556);
DEF_STATIC_CONST_VAL_FLOAT(val_2021, 98.532303);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_2022, 101.542999);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0009 25
DEF_STATIC_CONST_VAL_FLOAT(val_2023, 2.160000);
DEF_STATIC_CONST_VAL_FLOAT(val_2024, 100.545998);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_2025, 94.688499);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_2026, 89.145302);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_2027, 95.424301);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0000 32
DEF_STATIC_CONST_VAL_FLOAT(val_2028, 90.709602);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_2029, 107.351997);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_2030, 99.458504);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0032 38
DEF_STATIC_CONST_VAL_FLOAT(val_2031, 137.141998);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2032, 127.003998);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0038 42
DEF_STATIC_CONST_VAL_FLOAT(val_2033, 0.688571);
DEF_STATIC_CONST_VAL_FLOAT(val_2034, 121.216003);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_2035, 116.898003);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0043 47
DEF_STATIC_CONST_VAL_FLOAT(val_2036, 2.412500);
DEF_STATIC_CONST_VAL_FLOAT(val_2037, 108.563004);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_2038, 114.299004);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0048 52
DEF_STATIC_CONST_VAL_FLOAT(val_2039, 112.875000);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0052 54
DEF_STATIC_CONST_VAL_FLOAT(val_2040, 118.933998);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0047 55
DEF_STATIC_CONST_VAL_FLOAT(val_2041, 107.623001);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0042 56
DEF_STATIC_CONST_VAL_FLOAT(val_2042, 21.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_2043, 125.902000);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_2044, 132.113007);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0056 60
DEF_STATIC_CONST_VAL_FLOAT(val_2045, 1.585000);
DEF_STATIC_CONST_VAL_FLOAT(val_2046, 120.348999);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_2047, 0.907500);
DEF_STATIC_CONST_VAL_FLOAT(val_2048, 127.524002);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0063 65
DEF_STATIC_CONST_VAL_FLOAT(val_2049, 122.814003);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0060 66
DEF_STATIC_CONST_VAL_FLOAT(val_2050, 121.088997);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0066 68
DEF_STATIC_CONST_VAL_FLOAT(val_2051, 0.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_2052, 111.116997);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0068 70
DEF_STATIC_CONST_VAL_FLOAT(val_2053, 0.704311);
DEF_STATIC_CONST_VAL_FLOAT(val_2054, 119.097000);
#define CTNODE_cmu_us_rms_f0_f_72_NO_0070 72
DEF_STATIC_CONST_VAL_FLOAT(val_2055, 115.074997);
DEF_STATIC_CONST_VAL_FLOAT(val_2056, 94.416603);
#define CTNODE_cmu_us_rms_f0_f_73_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_2057, 0.087500);
DEF_STATIC_CONST_VAL_FLOAT(val_2058, 125.691002);
#define CTNODE_cmu_us_rms_f0_f_73_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2059, 118.500000);
#define CTNODE_cmu_us_rms_f0_f_73_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_2060, 124.389000);
#define CTNODE_cmu_us_rms_f0_f_73_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2061, 129.061996);
DEF_STATIC_CONST_VAL_FLOAT(val_2062, 0.291852);
DEF_STATIC_CONST_VAL_FLOAT(val_2063, 101.625000);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2064, 111.624001);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_2065, 0.075000);
DEF_STATIC_CONST_VAL_FLOAT(val_2066, 94.205200);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2067, 106.455002);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_2068, 101.529999);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_2069, 0.043000);
DEF_STATIC_CONST_VAL_FLOAT(val_2070, 0.563886);
DEF_STATIC_CONST_VAL_FLOAT(val_2071, 99.253601);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_2072, 95.957001);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2073, 90.637802);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0012 18
DEF_STATIC_CONST_VAL_FLOAT(val_2074, 85.715103);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2075, 92.376701);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0011 21
DEF_STATIC_CONST_VAL_FLOAT(val_2076, 97.651497);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0000 22
DEF_STATIC_CONST_VAL_FLOAT(val_2077, 0.372344);
DEF_STATIC_CONST_VAL_FLOAT(val_2078, 96.621300);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2079, 109.668999);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2080, 102.646004);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_2081, 110.113998);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_2082, 117.498001);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0023 33
DEF_STATIC_CONST_VAL_FLOAT(val_2083, 0.854602);
DEF_STATIC_CONST_VAL_FLOAT(val_2084, 109.176003);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_2085, 101.702003);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_2086, 100.598999);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_2087, 97.929001);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_2088, 0.016000);
DEF_STATIC_CONST_VAL_FLOAT(val_2089, 90.538696);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_2090, 87.182098);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0033 45
DEF_STATIC_CONST_VAL_FLOAT(val_2091, 88.111504);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0022 46
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_2092, 127.628998);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0048 50
DEF_STATIC_CONST_VAL_FLOAT(val_2093, 109.806999);
#define CTNODE_cmu_us_rms_f0_ih_86_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_2094, 118.495003);
DEF_STATIC_CONST_VAL_FLOAT(val_2095, 1.276000);
DEF_STATIC_CONST_VAL_FLOAT(val_2096, 119.014999);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2097, 115.453003);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_2098, 1.060000);
DEF_STATIC_CONST_VAL_FLOAT(val_2099, 104.991997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_2100, 111.904999);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_2101, 99.124802);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0004 12
DEF_STATIC_CONST_VAL_FLOAT(val_2102, 0.697500);
DEF_STATIC_CONST_VAL_FLOAT(val_2103, 108.929001);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_2104, 103.033997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2105, 99.357101);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0012 18
DEF_STATIC_CONST_VAL_FLOAT(val_2106, 95.922798);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2107, 100.571999);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0001 21
DEF_STATIC_CONST_VAL_FLOAT(val_2108, 113.685997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_2109, 132.082001);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_2110, 0.466500);
DEF_STATIC_CONST_VAL_FLOAT(val_2111, 116.241997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2112, 109.304001);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_2113, 120.919998);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0025 31
DEF_STATIC_CONST_VAL_FLOAT(val_2114, 103.637001);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2115, 110.685997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0031 35
DEF_STATIC_CONST_VAL_FLOAT(val_2116, 0.010000);
DEF_STATIC_CONST_VAL_FLOAT(val_2117, 112.487000);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_2118, 114.611000);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0035 39
DEF_STATIC_CONST_VAL_FLOAT(val_2119, 112.967003);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2120, 108.445999);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0000 42
DEF_STATIC_CONST_VAL_FLOAT(val_2121, 87.585403);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_2122, 83.635101);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0043 47
DEF_STATIC_CONST_VAL_FLOAT(val_2123, 93.623703);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0042 48
DEF_STATIC_CONST_VAL_FLOAT(val_2124, 119.764999);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0048 50
DEF_STATIC_CONST_VAL_STRING(val_2125, "t");
DEF_STATIC_CONST_VAL_FLOAT(val_2126, 92.421204);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_2127, 95.248199);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_2128, 102.853996);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0052 58
DEF_STATIC_CONST_VAL_FLOAT(val_2129, 2.058000);
DEF_STATIC_CONST_VAL_FLOAT(val_2130, 94.844803);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0058 60
DEF_STATIC_CONST_VAL_FLOAT(val_2131, 0.761228);
DEF_STATIC_CONST_VAL_FLOAT(val_2132, 92.755997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_2133, 88.872101);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0060 64
DEF_STATIC_CONST_VAL_FLOAT(val_2134, 85.300903);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0051 65
DEF_STATIC_CONST_VAL_FLOAT(val_2135, 99.451302);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0066 68
DEF_STATIC_CONST_VAL_FLOAT(val_2136, 114.542999);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0068 70
DEF_STATIC_CONST_VAL_FLOAT(val_2137, 106.245003);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0065 71
DEF_STATIC_CONST_VAL_FLOAT(val_2138, 87.931000);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0071 73
DEF_STATIC_CONST_VAL_FLOAT(val_2139, 91.239899);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_2140, 100.727997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0076 78
DEF_STATIC_CONST_VAL_FLOAT(val_2141, 0.413131);
DEF_STATIC_CONST_VAL_FLOAT(val_2142, 99.161201);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0078 80
DEF_STATIC_CONST_VAL_FLOAT(val_2143, 2.380000);
DEF_STATIC_CONST_VAL_FLOAT(val_2144, 95.053001);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0080 82
DEF_STATIC_CONST_VAL_FLOAT(val_2145, 91.875603);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0073 83
DEF_STATIC_CONST_VAL_FLOAT(val_2146, 103.157997);
#define CTNODE_cmu_us_rms_f0_ih_87_NO_0050 84
DEF_STATIC_CONST_VAL_FLOAT(val_2147, 112.346001);
DEF_STATIC_CONST_VAL_FLOAT(val_2148, 106.995003);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0001 3
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_2149, 84.561699);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2150, 96.408699);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0005 9
DEF_STATIC_CONST_VAL_STRING(val_2151, "v");
DEF_STATIC_CONST_VAL_FLOAT(val_2152, 89.503502);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_2153, 76.906403);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2154, 79.349800);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_2155, 84.681702);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0004 16
DEF_STATIC_CONST_VAL_FLOAT(val_2156, 0.409932);
DEF_STATIC_CONST_VAL_FLOAT(val_2157, 102.820000);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_2158, 93.110603);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_2159, 89.554398);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_2160, 86.577499);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0017 25
DEF_STATIC_CONST_VAL_FLOAT(val_2161, 98.333397);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_2162, 121.196999);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2163, 0.384553);
DEF_STATIC_CONST_VAL_FLOAT(val_2164, 112.217003);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_2165, 102.199997);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0016 32
DEF_STATIC_CONST_VAL_FLOAT(val_2166, 0.322691);
DEF_STATIC_CONST_VAL_FLOAT(val_2167, 5.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_2168, 111.417000);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_2169, 102.478996);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_2170, 92.711098);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0035 39
DEF_STATIC_CONST_VAL_FLOAT(val_2171, 97.670502);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2172, 108.855003);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0032 42
DEF_STATIC_CONST_VAL_FLOAT(val_2173, 99.868698);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0043 45
DEF_STATIC_CONST_VAL_FLOAT(val_2174, 86.155998);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_2175, 0.505661);
DEF_STATIC_CONST_VAL_FLOAT(val_2176, 0.019500);
DEF_STATIC_CONST_VAL_FLOAT(val_2177, 8.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_2178, 98.208397);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_2179, 95.443398);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0048 52
DEF_STATIC_CONST_VAL_FLOAT(val_2180, 94.229401);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0052 54
DEF_STATIC_CONST_VAL_FLOAT(val_2181, 91.611504);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0047 55
DEF_STATIC_CONST_VAL_FLOAT(val_2182, 96.211197);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0056 58
DEF_STATIC_CONST_VAL_FLOAT(val_2183, 90.898003);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0055 59
DEF_STATIC_CONST_VAL_FLOAT(val_2184, 90.036697);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_2185, 87.041199);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0059 63
DEF_STATIC_CONST_VAL_FLOAT(val_2186, 95.702499);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0063 65
DEF_STATIC_CONST_VAL_FLOAT(val_2187, 91.359596);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0066 68
DEF_STATIC_CONST_VAL_FLOAT(val_2188, 86.504799);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0065 69
DEF_STATIC_CONST_VAL_FLOAT(val_2189, 93.080704);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0042 70
DEF_STATIC_CONST_VAL_FLOAT(val_2190, 87.700203);
#define CTNODE_cmu_us_rms_f0_ih_88_NO_0070 72
DEF_STATIC_CONST_VAL_FLOAT(val_2191, 83.912697);
DEF_STATIC_CONST_VAL_FLOAT(val_2192, 94.604103);
#define CTNODE_cmu_us_rms_f0_p_136_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_2193, 86.633202);
#define CTNODE_cmu_us_rms_f0_p_136_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_2194, 0.591566);
DEF_STATIC_CONST_VAL_FLOAT(val_2195, 98.849602);
#define CTNODE_cmu_us_rms_f0_p_136_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2196, 104.246002);
#define CTNODE_cmu_us_rms_f0_p_136_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_2197, 111.811996);
#define CTNODE_cmu_us_rms_f0_p_136_NO_0004 10
DEF_STATIC_CONST_VAL_FLOAT(val_2198, 0.019000);
DEF_STATIC_CONST_VAL_FLOAT(val_2199, 97.488602);
#define CTNODE_cmu_us_rms_f0_p_136_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2200, 88.698303);
DEF_STATIC_CONST_VAL_FLOAT(val_2201, 0.655500);
DEF_STATIC_CONST_VAL_FLOAT(val_2202, 124.567001);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2203, 0.473000);
DEF_STATIC_CONST_VAL_FLOAT(val_2204, 114.608002);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_2205, 106.989998);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_2206, 82.871696);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_2207, 91.118401);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2208, 101.112999);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0007 13
DEF_STATIC_CONST_VAL_FLOAT(val_2209, 107.677002);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_2210, 105.834999);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_2211, 98.493401);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2212, 97.899498);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_2213, 1.966000);
DEF_STATIC_CONST_VAL_FLOAT(val_2214, 94.615196);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_2215, 84.630203);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0013 25
DEF_STATIC_CONST_VAL_FLOAT(val_2216, 0.640548);
DEF_STATIC_CONST_VAL_FLOAT(val_2217, 116.589996);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_2218, 106.050003);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_2219, 103.857002);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_2220, 93.030998);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0000 32
DEF_STATIC_CONST_VAL_FLOAT(val_2221, 0.582982);
DEF_STATIC_CONST_VAL_FLOAT(val_2222, 128.848999);
#define CTNODE_cmu_us_rms_f0_p_137_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2223, 121.233002);
DEF_STATIC_CONST_VAL_FLOAT(val_2224, 128.328995);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_2225, 0.189246);
DEF_STATIC_CONST_VAL_FLOAT(val_2226, 122.757004);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2227, 122.943001);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_2228, 109.337997);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_2229, 95.813797);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0000 10
DEF_STATIC_CONST_VAL_STRING(val_2230, "ae_6");
DEF_STATIC_CONST_VAL_FLOAT(val_2231, 87.325302);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2232, 0.022000);
DEF_STATIC_CONST_VAL_FLOAT(val_2233, 91.107803);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_2234, 111.671997);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_2235, 103.460999);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0015 19
DEF_STATIC_CONST_VAL_FLOAT(val_2236, 104.967003);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_2237, 6.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_2238, 99.372803);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_2239, 91.006401);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0010 24
DEF_STATIC_CONST_VAL_FLOAT(val_2240, 100.004997);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2241, 0.617149);
DEF_STATIC_CONST_VAL_FLOAT(val_2242, 101.153999);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2243, 107.550003);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_2244, 116.252998);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0029 33
DEF_STATIC_CONST_VAL_FLOAT(val_2245, 120.407997);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0026 34
DEF_STATIC_CONST_VAL_FLOAT(val_2246, 106.572998);
#define CTNODE_cmu_us_rms_f0_p_138_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_2247, 96.029800);
DEF_STATIC_CONST_VAL_FLOAT(val_2248, 122.988998);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2249, 133.858994);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_2250, 95.548897);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_2251, 0.184615);
DEF_STATIC_CONST_VAL_FLOAT(val_2252, 110.445999);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_2253, 126.875999);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2254, 120.379997);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0007 13
DEF_STATIC_CONST_VAL_FLOAT(val_2255, 0.406553);
DEF_STATIC_CONST_VAL_FLOAT(val_2256, 105.279999);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_2257, 98.591003);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0013 17
DEF_STATIC_CONST_VAL_FLOAT(val_2258, 0.683333);
DEF_STATIC_CONST_VAL_FLOAT(val_2259, 116.972000);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_2260, 109.766998);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0000 20
DEF_STATIC_CONST_VAL_FLOAT(val_2261, 97.940300);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_2262, 88.684998);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2263, 93.937103);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0021 27
DEF_STATIC_CONST_VAL_FLOAT(val_2264, 0.280000);
DEF_STATIC_CONST_VAL_FLOAT(val_2265, 119.680000);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_2266, 104.233002);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_2267, 109.438004);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_2268, 106.500999);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_2269, 107.940002);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_2270, 103.710999);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0036 40
DEF_STATIC_CONST_VAL_FLOAT(val_2271, 99.737396);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_2272, 94.428001);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0043 45
DEF_STATIC_CONST_VAL_FLOAT(val_2273, 91.359901);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0040 46
DEF_STATIC_CONST_VAL_FLOAT(val_2274, 0.380311);
DEF_STATIC_CONST_VAL_FLOAT(val_2275, 105.223000);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0048 50
DEF_STATIC_CONST_VAL_FLOAT(val_2276, 112.744003);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0047 51
DEF_STATIC_CONST_VAL_FLOAT(val_2277, 0.680593);
DEF_STATIC_CONST_VAL_FLOAT(val_2278, 97.206100);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0052 54
DEF_STATIC_CONST_VAL_FLOAT(val_2279, 90.881203);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0051 55
DEF_STATIC_CONST_VAL_FLOAT(val_2280, 99.455704);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0046 56
DEF_STATIC_CONST_VAL_FLOAT(val_2281, 106.945999);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0031 57
DEF_STATIC_CONST_VAL_FLOAT(val_2282, 100.167000);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0057 59
DEF_STATIC_CONST_VAL_STRING(val_2283, "r_148");
DEF_STATIC_CONST_VAL_FLOAT(val_2284, 105.513000);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0059 61
DEF_STATIC_CONST_VAL_FLOAT(val_2285, 126.860001);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0020 62
DEF_STATIC_CONST_VAL_FLOAT(val_2286, 0.322921);
DEF_STATIC_CONST_VAL_FLOAT(val_2287, 99.651199);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_2288, 96.872398);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0064 66
DEF_STATIC_CONST_VAL_FLOAT(val_2289, 13.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_2290, 3.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_2291, 89.870003);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0068 70
DEF_STATIC_CONST_VAL_FLOAT(val_2292, 0.097500);
DEF_STATIC_CONST_VAL_FLOAT(val_2293, 81.960701);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0070 72
DEF_STATIC_CONST_VAL_FLOAT(val_2294, 87.686897);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0067 73
DEF_STATIC_CONST_VAL_FLOAT(val_2295, 92.753700);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0066 74
DEF_STATIC_CONST_VAL_FLOAT(val_2296, 88.253601);
#define CTNODE_cmu_us_rms_f0_iy_91_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_2297, 97.915703);
DEF_STATIC_CONST_VAL_FLOAT(val_2298, 0.734000);
DEF_STATIC_CONST_VAL_FLOAT(val_2299, 26.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_2300, 122.533997);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_2301, 117.572998);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_2302, 5.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2303, 0.090163);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_2304, 102.513000);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_2305, 119.961998);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_2306, 115.796997);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_2307, 110.391998);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0002 16
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0001 17
DEF_STATIC_CONST_VAL_FLOAT(val_2308, 0.556000);
DEF_STATIC_CONST_VAL_STRING(val_2309, "g");
DEF_STATIC_CONST_VAL_FLOAT(val_2310, 136.658997);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2311, 129.403000);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_2312, 123.558998);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0017 23
DEF_STATIC_CONST_VAL_FLOAT(val_2313, 112.483002);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0000 24
DEF_STATIC_CONST_VAL_FLOAT(val_2314, 0.409667);
DEF_STATIC_CONST_VAL_FLOAT(val_2315, 120.975998);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_2316, 110.619003);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_2317, 0.611866);
DEF_STATIC_CONST_VAL_FLOAT(val_2318, 110.192001);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_2319, 103.219002);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0026 34
DEF_STATIC_CONST_VAL_FLOAT(val_2320, 22.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_2321, 110.140999);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_2322, 2.080500);
DEF_STATIC_CONST_VAL_FLOAT(val_2323, 110.593002);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_2324, 101.419998);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0037 41
DEF_STATIC_CONST_VAL_FLOAT(val_2325, 0.557715);
DEF_STATIC_CONST_VAL_FLOAT(val_2326, 98.657402);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_2327, 91.617500);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0041 45
DEF_STATIC_CONST_VAL_FLOAT(val_2328, 102.869003);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0034 46
DEF_STATIC_CONST_VAL_FLOAT(val_2329, 93.666100);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_2330, 99.423500);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0025 49
DEF_STATIC_CONST_VAL_FLOAT(val_2331, 1.867000);
DEF_STATIC_CONST_VAL_FLOAT(val_2332, 23.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_2333, 109.629997);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_2334, 105.735001);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_2335, 102.014000);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_2336, 98.673203);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_2337, 95.104797);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0050 60
DEF_STATIC_CONST_VAL_FLOAT(val_2338, 0.021000);
DEF_STATIC_CONST_VAL_FLOAT(val_2339, 97.518402);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_2340, 89.317596);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0049 63
DEF_STATIC_CONST_VAL_FLOAT(val_2341, 0.818319);
DEF_STATIC_CONST_VAL_FLOAT(val_2342, 92.355301);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0064 66
DEF_STATIC_CONST_VAL_FLOAT(val_2343, 85.447197);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0063 67
DEF_STATIC_CONST_VAL_FLOAT(val_2344, 101.625999);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0067 69
DEF_STATIC_CONST_VAL_FLOAT(val_2345, 95.498802);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0070 72
DEF_STATIC_CONST_VAL_FLOAT(val_2346, 102.443001);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0069 73
DEF_STATIC_CONST_VAL_FLOAT(val_2347, 0.925065);
DEF_STATIC_CONST_VAL_FLOAT(val_2348, 2.505500);
DEF_STATIC_CONST_VAL_FLOAT(val_2349, 90.472198);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_2350, 97.112000);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0073 77
DEF_STATIC_CONST_VAL_FLOAT(val_2351, 85.672302);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0024 78
DEF_STATIC_CONST_VAL_FLOAT(val_2352, 0.028000);
DEF_STATIC_CONST_VAL_FLOAT(val_2353, 11.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_2354, 84.429298);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0080 82
DEF_STATIC_CONST_VAL_FLOAT(val_2355, 93.948196);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0079 83
DEF_STATIC_CONST_VAL_FLOAT(val_2356, 101.615997);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0078 84
DEF_STATIC_CONST_VAL_FLOAT(val_2357, 0.071000);
DEF_STATIC_CONST_VAL_FLOAT(val_2358, 0.908896);
DEF_STATIC_CONST_VAL_FLOAT(val_2359, 82.903099);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0086 88
DEF_STATIC_CONST_VAL_FLOAT(val_2360, 87.816597);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0085 89
DEF_STATIC_CONST_VAL_FLOAT(val_2361, 80.072502);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0084 90
DEF_STATIC_CONST_VAL_FLOAT(val_2362, 81.298500);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0091 93
DEF_STATIC_CONST_VAL_FLOAT(val_2363, 81.278297);
#define CTNODE_cmu_us_rms_f0_iy_92_NO_0090 94
DEF_STATIC_CONST_VAL_FLOAT(val_2364, 76.339600);
DEF_STATIC_CONST_VAL_FLOAT(val_2365, 0.077000);
DEF_STATIC_CONST_VAL_FLOAT(val_2366, 22.200001);
DEF_STATIC_CONST_VAL_FLOAT(val_2367, 80.100800);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2368, 83.985199);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_2369, 93.202103);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_2370, 0.975000);
DEF_STATIC_CONST_VAL_FLOAT(val_2371, 71.097801);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_2372, 79.293999);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_2373, 105.363998);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2374, 116.875999);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_2375, 26.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2376, 93.516502);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_2377, 83.444702);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_2378, 98.737602);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_2379, 92.522202);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_2380, 88.885597);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0021 27
DEF_STATIC_CONST_VAL_FLOAT(val_2381, 85.582603);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0020 28
DEF_STATIC_CONST_VAL_FLOAT(val_2382, 98.547203);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0015 29
DEF_STATIC_CONST_VAL_FLOAT(val_2383, 0.645187);
DEF_STATIC_CONST_VAL_FLOAT(val_2384, 95.814697);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_2385, 85.612701);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0029 33
DEF_STATIC_CONST_VAL_FLOAT(val_2386, 92.167000);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_2387, 102.818001);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0033 37
DEF_STATIC_CONST_VAL_FLOAT(val_2388, 22.700001);
DEF_STATIC_CONST_VAL_FLOAT(val_2389, 105.383003);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_2390, 98.787598);
#define CTNODE_cmu_us_rms_f0_iy_93_NO_0014 40
DEF_STATIC_CONST_VAL_FLOAT(val_2391, 111.573997);
DEF_STATIC_CONST_VAL_FLOAT(val_2392, 0.076000);
DEF_STATIC_CONST_VAL_FLOAT(val_2393, 91.577301);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2394, 80.707901);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_2395, 87.409302);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0002 8
DEF_STATIC_CONST_VAL_FLOAT(val_2396, 111.357002);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_2397, 0.061000);
DEF_STATIC_CONST_VAL_FLOAT(val_2398, 0.480964);
DEF_STATIC_CONST_VAL_FLOAT(val_2399, 113.731003);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_2400, 97.127998);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0011 15
DEF_STATIC_CONST_VAL_FLOAT(val_2401, 92.768600);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2402, 94.105301);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0018 20
#define CTNODE_cmu_us_rms_f0_l_106_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_2403, 0.364383);
DEF_STATIC_CONST_VAL_FLOAT(val_2404, 108.477997);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_2405, 93.125999);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_2406, 97.730103);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0010 26
DEF_STATIC_CONST_VAL_FLOAT(val_2407, 0.607314);
DEF_STATIC_CONST_VAL_FLOAT(val_2408, 93.135201);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2409, 100.025002);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_2410, 90.132896);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0001 31
DEF_STATIC_CONST_VAL_FLOAT(val_2411, 0.031500);
DEF_STATIC_CONST_VAL_FLOAT(val_2412, 110.630997);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2413, 95.963600);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0031 35
DEF_STATIC_CONST_VAL_FLOAT(val_2414, 113.161003);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_2415, 122.511002);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0000 38
DEF_STATIC_CONST_VAL_FLOAT(val_2416, 86.924202);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2417, 0.242000);
DEF_STATIC_CONST_VAL_FLOAT(val_2418, 0.973708);
DEF_STATIC_CONST_VAL_FLOAT(val_2419, 83.056702);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_2420, 76.186699);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0043 47
DEF_STATIC_CONST_VAL_FLOAT(val_2421, 71.909599);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0042 48
DEF_STATIC_CONST_VAL_FLOAT(val_2422, 72.507698);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0041 49
DEF_STATIC_CONST_VAL_FLOAT(val_2423, 84.708801);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0038 50
DEF_STATIC_CONST_VAL_FLOAT(val_2424, 86.672401);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0054 56
DEF_STATIC_CONST_VAL_FLOAT(val_2425, 81.991096);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0053 57
DEF_STATIC_CONST_VAL_FLOAT(val_2426, 94.849297);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0052 58
DEF_STATIC_CONST_VAL_FLOAT(val_2427, 101.738998);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0051 59
DEF_STATIC_CONST_VAL_FLOAT(val_2428, 93.159599);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0059 61
DEF_STATIC_CONST_VAL_FLOAT(val_2429, 0.574010);
DEF_STATIC_CONST_VAL_FLOAT(val_2430, 92.197701);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_2431, 86.583397);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0061 65
DEF_STATIC_CONST_VAL_FLOAT(val_2432, 86.571800);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_2433, 0.188235);
DEF_STATIC_CONST_VAL_FLOAT(val_2434, 82.645599);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0067 69
DEF_STATIC_CONST_VAL_FLOAT(val_2435, 81.153503);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0069 71
DEF_STATIC_CONST_VAL_FLOAT(val_2436, 77.909302);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0050 72
DEF_STATIC_CONST_VAL_FLOAT(val_2437, 103.350998);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0072 74
DEF_STATIC_CONST_VAL_FLOAT(val_2438, 100.196999);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_2439, 93.176598);
#define CTNODE_cmu_us_rms_f0_l_106_NO_0076 78
DEF_STATIC_CONST_VAL_FLOAT(val_2440, 86.075897);
DEF_STATIC_CONST_VAL_FLOAT(val_2441, 1.094000);
DEF_STATIC_CONST_VAL_FLOAT(val_2442, 0.344000);
DEF_STATIC_CONST_VAL_FLOAT(val_2443, 132.462997);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2444, 0.117000);
DEF_STATIC_CONST_VAL_FLOAT(val_2445, 105.574997);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_2446, 114.669998);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_2447, 0.224278);
DEF_STATIC_CONST_VAL_FLOAT(val_2448, 117.346001);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_2449, 97.114998);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2450, 99.777397);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_2451, 112.764999);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2452, 102.527000);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0008 18
DEF_STATIC_CONST_VAL_FLOAT(val_2453, 104.004997);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2454, 93.729797);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0007 21
DEF_STATIC_CONST_VAL_FLOAT(val_2455, 117.679001);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0000 22
DEF_STATIC_CONST_VAL_FLOAT(val_2456, 74.584099);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2457, 0.076000);
DEF_STATIC_CONST_VAL_FLOAT(val_2458, 81.623299);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_2459, 86.014297);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0023 29
DEF_STATIC_CONST_VAL_STRING(val_2460, "ih");
DEF_STATIC_CONST_VAL_FLOAT(val_2461, 95.729500);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_2462, 0.493611);
DEF_STATIC_CONST_VAL_FLOAT(val_2463, 93.944801);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_2464, 87.975502);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0033 37
DEF_STATIC_CONST_VAL_FLOAT(val_2465, 98.535896);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0032 38
DEF_STATIC_CONST_VAL_FLOAT(val_2466, 2.940000);
DEF_STATIC_CONST_VAL_FLOAT(val_2467, 93.084801);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2468, 87.922096);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0038 42
DEF_STATIC_CONST_VAL_FLOAT(val_2469, 89.564301);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_2470, 0.017500);
DEF_STATIC_CONST_VAL_FLOAT(val_2471, 86.126404);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_2472, 87.757896);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0029 47
DEF_STATIC_CONST_VAL_FLOAT(val_2473, 84.384697);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0022 48
DEF_STATIC_CONST_VAL_FLOAT(val_2474, 1.522500);
DEF_STATIC_CONST_VAL_FLOAT(val_2475, 95.612198);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_2476, 83.997498);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_2477, 92.321999);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_2478, 87.376602);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0048 56
DEF_STATIC_CONST_VAL_FLOAT(val_2479, 0.848074);
DEF_STATIC_CONST_VAL_STRING(val_2480, "uw");
DEF_STATIC_CONST_VAL_FLOAT(val_2481, 108.815002);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0058 60
DEF_STATIC_CONST_VAL_STRING(val_2482, "ow");
DEF_STATIC_CONST_VAL_FLOAT(val_2483, 105.691002);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_2484, 0.109000);
DEF_STATIC_CONST_VAL_FLOAT(val_2485, 0.425388);
DEF_STATIC_CONST_VAL_FLOAT(val_2486, 100.801003);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0063 65
DEF_STATIC_CONST_VAL_FLOAT(val_2487, 97.763000);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_2488, 93.880600);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0062 68
DEF_STATIC_CONST_VAL_FLOAT(val_2489, 0.008500);
DEF_STATIC_CONST_VAL_FLOAT(val_2490, 89.713997);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0068 70
DEF_STATIC_CONST_VAL_FLOAT(val_2491, 95.028801);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0057 71
DEF_STATIC_CONST_VAL_FLOAT(val_2492, 84.620598);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0056 72
DEF_STATIC_CONST_VAL_FLOAT(val_2493, 2.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_2494, 115.929001);
#define CTNODE_cmu_us_rms_f0_l_107_NO_0072 74
DEF_STATIC_CONST_VAL_FLOAT(val_2495, 102.758003);
DEF_STATIC_CONST_VAL_FLOAT(val_2496, 78.587097);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_2497, 85.088402);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_2498, 91.693901);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_2499, 90.250900);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_2500, 94.173698);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0000 10
DEF_STATIC_CONST_VAL_FLOAT(val_2501, 122.126999);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2502, 0.087337);
DEF_STATIC_CONST_VAL_FLOAT(val_2503, 112.073997);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_2504, 102.544998);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0010 16
DEF_STATIC_CONST_VAL_FLOAT(val_2505, 0.202761);
DEF_STATIC_CONST_VAL_FLOAT(val_2506, 118.633003);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_2507, 107.212997);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_2508, 0.538756);
DEF_STATIC_CONST_VAL_FLOAT(val_2509, 102.561996);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_2510, 94.202003);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0016 24
DEF_STATIC_CONST_VAL_FLOAT(val_2511, 0.033000);
DEF_STATIC_CONST_VAL_FLOAT(val_2512, 0.297166);
DEF_STATIC_CONST_VAL_FLOAT(val_2513, 110.069000);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2514, 96.275703);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_2515, 93.362099);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0026 32
DEF_STATIC_CONST_VAL_FLOAT(val_2516, 105.560997);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2517, 112.335999);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0025 35
DEF_STATIC_CONST_VAL_FLOAT(val_2518, 96.374199);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_2519, 86.685898);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0035 39
DEF_STATIC_CONST_VAL_FLOAT(val_2520, 94.557999);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2521, 97.803299);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_2522, 102.523003);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0024 44
DEF_STATIC_CONST_VAL_FLOAT(val_2523, 85.599098);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_2524, 0.584304);
DEF_STATIC_CONST_VAL_FLOAT(val_2525, 0.330802);
DEF_STATIC_CONST_VAL_FLOAT(val_2526, 105.925003);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_2527, 97.894096);
#define CTNODE_cmu_us_rms_f0_l_108_NO_0046 50
DEF_STATIC_CONST_VAL_FLOAT(val_2528, 84.782799);
DEF_STATIC_CONST_VAL_FLOAT(val_2529, 101.707001);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0000 2
DEF_STATIC_CONST_VAL_FLOAT(val_2530, 83.769600);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2531, 96.685997);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_2532, 0.045500);
DEF_STATIC_CONST_VAL_FLOAT(val_2533, 0.487175);
DEF_STATIC_CONST_VAL_FLOAT(val_2534, 91.704002);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_2535, 86.549103);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0008 12
DEF_STATIC_CONST_VAL_STRING(val_2536, "pps");
DEF_STATIC_CONST_VAL_FLOAT(val_2537, 90.224098);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_2538, 94.468002);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0007 15
DEF_STATIC_CONST_VAL_FLOAT(val_2539, 89.640297);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_2540, 88.301300);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_2541, 86.116302);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0015 21
DEF_STATIC_CONST_VAL_FLOAT(val_2542, 90.702003);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0006 22
DEF_STATIC_CONST_VAL_FLOAT(val_2543, 97.679199);
#define CTNODE_cmu_us_rms_f0_z_199_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_2544, 89.755699);
DEF_STATIC_CONST_VAL_FLOAT(val_2545, 3.197000);
DEF_STATIC_CONST_VAL_FLOAT(val_2546, 0.138000);
DEF_STATIC_CONST_VAL_FLOAT(val_2547, 79.677696);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2548, 73.569298);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_2549, 86.397400);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0001 7
DEF_STATIC_CONST_VAL_FLOAT(val_2550, 3.751000);
DEF_STATIC_CONST_VAL_FLOAT(val_2551, 98.411301);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0007 9
DEF_STATIC_CONST_VAL_FLOAT(val_2552, 4.191000);
DEF_STATIC_CONST_VAL_FLOAT(val_2553, 79.192101);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_2554, 89.115097);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2555, 99.115196);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0000 14
DEF_STATIC_CONST_VAL_FLOAT(val_2556, 1.167000);
DEF_STATIC_CONST_VAL_FLOAT(val_2557, 95.882797);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2558, 101.796997);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_2559, 110.780998);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0016 22
DEF_STATIC_CONST_VAL_FLOAT(val_2560, 92.261398);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_2561, 95.359802);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_2562, 94.915298);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2563, 98.134399);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0026 30
DEF_STATIC_CONST_VAL_FLOAT(val_2564, 99.758003);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0015 31
DEF_STATIC_CONST_VAL_FLOAT(val_2565, 102.721001);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_2566, 89.398903);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_2567, 86.444298);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_2568, 88.631599);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_2569, 95.984001);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_2570, 91.709999);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0033 43
DEF_STATIC_CONST_VAL_FLOAT(val_2571, 0.063000);
DEF_STATIC_CONST_VAL_FLOAT(val_2572, 89.428596);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_2573, 91.520401);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_2574, 97.190102);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0043 49
DEF_STATIC_CONST_VAL_FLOAT(val_2575, 93.898102);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_2576, 96.856003);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0049 53
DEF_STATIC_CONST_VAL_FLOAT(val_2577, 100.448997);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0014 54
DEF_STATIC_CONST_VAL_FLOAT(val_2578, 91.929497);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_2579, 99.310204);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0059 61
DEF_STATIC_CONST_VAL_FLOAT(val_2580, 12.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_2581, 104.143997);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_2582, 109.684998);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0058 64
DEF_STATIC_CONST_VAL_FLOAT(val_2583, 114.089996);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0057 65
DEF_STATIC_CONST_VAL_FLOAT(val_2584, 0.059000);
DEF_STATIC_CONST_VAL_FLOAT(val_2585, 93.755997);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_2586, 0.715915);
DEF_STATIC_CONST_VAL_FLOAT(val_2587, 109.606003);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0069 71
DEF_STATIC_CONST_VAL_FLOAT(val_2588, 102.557999);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0068 72
DEF_STATIC_CONST_VAL_FLOAT(val_2589, 100.015999);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0067 73
DEF_STATIC_CONST_VAL_FLOAT(val_2590, 95.457497);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_2591, 92.666100);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0073 77
DEF_STATIC_CONST_VAL_FLOAT(val_2592, 104.153000);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0054 78
DEF_STATIC_CONST_VAL_FLOAT(val_2593, 1.566500);
DEF_STATIC_CONST_VAL_FLOAT(val_2594, 105.990997);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0080 82
DEF_STATIC_CONST_VAL_FLOAT(val_2595, 112.776001);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0079 83
DEF_STATIC_CONST_VAL_FLOAT(val_2596, 101.078003);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0083 85
DEF_STATIC_CONST_VAL_FLOAT(val_2597, 101.555000);
#define CTNODE_cmu_us_rms_f0_z_200_NO_0078 86
DEF_STATIC_CONST_VAL_FLOAT(val_2598, 115.359001);
DEF_STATIC_CONST_VAL_FLOAT(val_2599, 80.784599);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_2600, 87.984596);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_2601, 87.801804);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2602, 95.407997);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_2603, 0.027000);
DEF_STATIC_CONST_VAL_FLOAT(val_2604, 101.564003);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2605, 94.616203);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_2606, 0.481773);
DEF_STATIC_CONST_VAL_FLOAT(val_2607, 110.137001);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_2608, 98.979599);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0004 16
DEF_STATIC_CONST_VAL_FLOAT(val_2609, 1.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_2610, 108.110001);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_2611, 117.617996);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0017 21
DEF_STATIC_CONST_VAL_FLOAT(val_2612, 98.768700);
#define CTNODE_cmu_us_rms_f0_z_201_NO_0016 22
DEF_STATIC_CONST_VAL_FLOAT(val_2613, 118.751999);
DEF_STATIC_CONST_VAL_FLOAT(val_2614, 92.269798);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2615, 0.075500);
DEF_STATIC_CONST_VAL_FLOAT(val_2616, 81.032303);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2617, 74.671600);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_2618, 92.022797);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0004 10
DEF_STATIC_CONST_VAL_FLOAT(val_2619, 78.546303);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2620, 63.872601);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0001 13
DEF_STATIC_CONST_VAL_FLOAT(val_2621, 6.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_2622, 90.389503);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2623, 94.507599);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_2624, 98.102699);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0013 19
#define CTNODE_cmu_us_rms_f0_s_151_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_2625, 111.620003);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0000 22
DEF_STATIC_CONST_VAL_FLOAT(val_2626, 0.077272);
DEF_STATIC_CONST_VAL_FLOAT(val_2627, 136.380005);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2628, 140.091995);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_2629, 124.011002);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0022 28
DEF_STATIC_CONST_VAL_FLOAT(val_2630, 0.376000);
DEF_STATIC_CONST_VAL_FLOAT(val_2631, 121.877998);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2632, 107.303001);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0031 35
DEF_STATIC_CONST_VAL_FLOAT(val_2633, 24.200001);
DEF_STATIC_CONST_VAL_FLOAT(val_2634, 112.019997);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_2635, 106.206001);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0035 39
DEF_STATIC_CONST_VAL_FLOAT(val_2636, 99.585503);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0030 40
DEF_STATIC_CONST_VAL_FLOAT(val_2637, 99.403297);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0029 41
DEF_STATIC_CONST_VAL_FLOAT(val_2638, 115.485001);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_2639, 104.885002);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0041 45
DEF_STATIC_CONST_VAL_FLOAT(val_2640, 0.187500);
DEF_STATIC_CONST_VAL_FLOAT(val_2641, 0.374644);
DEF_STATIC_CONST_VAL_FLOAT(val_2642, 95.003098);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_2643, 86.620201);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_2644, 89.653999);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0046 52
DEF_STATIC_CONST_VAL_FLOAT(val_2645, 25.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_2646, 0.302423);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_2647, 96.989601);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0054 58
DEF_STATIC_CONST_VAL_FLOAT(val_2648, 109.072998);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0053 59
DEF_STATIC_CONST_VAL_FLOAT(val_2649, 0.051000);
DEF_STATIC_CONST_VAL_FLOAT(val_2650, 97.855797);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_2651, 102.542000);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0060 64
DEF_STATIC_CONST_VAL_FLOAT(val_2652, 97.072304);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0064 66
DEF_STATIC_CONST_VAL_FLOAT(val_2653, 93.355301);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0059 67
DEF_STATIC_CONST_VAL_FLOAT(val_2654, 92.505096);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0052 68
DEF_STATIC_CONST_VAL_FLOAT(val_2655, 97.453499);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0068 70
DEF_STATIC_CONST_VAL_FLOAT(val_2656, 28.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2657, 95.463303);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0070 72
DEF_STATIC_CONST_VAL_FLOAT(val_2658, 90.387497);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0045 73
DEF_STATIC_CONST_VAL_FLOAT(val_2659, 0.417534);
DEF_STATIC_CONST_VAL_FLOAT(val_2660, 107.335999);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0075 77
DEF_STATIC_CONST_VAL_FLOAT(val_2661, 99.259003);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0074 78
DEF_STATIC_CONST_VAL_FLOAT(val_2662, 93.488503);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0078 80
DEF_STATIC_CONST_VAL_FLOAT(val_2663, 99.386398);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0073 81
DEF_STATIC_CONST_VAL_FLOAT(val_2664, 100.432999);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0081 83
DEF_STATIC_CONST_VAL_FLOAT(val_2665, 0.450000);
DEF_STATIC_CONST_VAL_FLOAT(val_2666, 101.820000);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0084 86
DEF_STATIC_CONST_VAL_FLOAT(val_2667, 106.896004);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0083 87
DEF_STATIC_CONST_VAL_FLOAT(val_2668, 109.443001);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0028 88
DEF_STATIC_CONST_VAL_FLOAT(val_2669, 0.603027);
DEF_STATIC_CONST_VAL_FLOAT(val_2670, 120.478996);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0090 92
DEF_STATIC_CONST_VAL_FLOAT(val_2671, 0.511724);
DEF_STATIC_CONST_VAL_FLOAT(val_2672, 110.761002);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0094 96
DEF_STATIC_CONST_VAL_FLOAT(val_2673, 108.499001);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0093 97
DEF_STATIC_CONST_VAL_FLOAT(val_2674, 113.072998);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0092 98
DEF_STATIC_CONST_VAL_FLOAT(val_2675, 113.667000);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0098 100
DEF_STATIC_CONST_VAL_FLOAT(val_2676, 117.425003);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0089 101
DEF_STATIC_CONST_VAL_FLOAT(val_2677, 0.739158);
DEF_STATIC_CONST_VAL_FLOAT(val_2678, 124.575996);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0102 104
DEF_STATIC_CONST_VAL_FLOAT(val_2679, 0.401306);
DEF_STATIC_CONST_VAL_FLOAT(val_2680, 122.400002);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0104 106
DEF_STATIC_CONST_VAL_FLOAT(val_2681, 117.731003);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0101 107
DEF_STATIC_CONST_VAL_FLOAT(val_2682, 21.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2683, 125.200996);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0107 109
DEF_STATIC_CONST_VAL_FLOAT(val_2684, 130.835007);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0088 110
DEF_STATIC_CONST_VAL_FLOAT(val_2685, 0.475574);
DEF_STATIC_CONST_VAL_FLOAT(val_2686, 0.251147);
DEF_STATIC_CONST_VAL_FLOAT(val_2687, 109.581001);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0112 114
DEF_STATIC_CONST_VAL_FLOAT(val_2688, 98.148003);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0111 115
DEF_STATIC_CONST_VAL_FLOAT(val_2689, 110.623001);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0116 118
DEF_STATIC_CONST_VAL_FLOAT(val_2690, 116.019997);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0118 120
DEF_STATIC_CONST_VAL_FLOAT(val_2691, 121.875000);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0115 121
DEF_STATIC_CONST_VAL_FLOAT(val_2692, 107.458000);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0110 122
DEF_STATIC_CONST_VAL_FLOAT(val_2693, 104.203003);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0123 125
DEF_STATIC_CONST_VAL_FLOAT(val_2694, 92.493698);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0122 126
DEF_STATIC_CONST_VAL_FLOAT(val_2695, 99.546204);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0126 128
DEF_STATIC_CONST_VAL_FLOAT(val_2696, 104.794998);
#define CTNODE_cmu_us_rms_f0_s_151_NO_0128 130
DEF_STATIC_CONST_VAL_FLOAT(val_2697, 112.599998);
DEF_STATIC_CONST_VAL_FLOAT(val_2698, 15.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2699, 0.633000);
DEF_STATIC_CONST_VAL_FLOAT(val_2700, 126.194000);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2701, 0.091000);
DEF_STATIC_CONST_VAL_FLOAT(val_2702, 119.444000);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_2703, 106.690002);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0002 8
DEF_STATIC_CONST_VAL_FLOAT(val_2704, 111.209999);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0011 13
#define CTNODE_cmu_us_rms_f0_s_152_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_2705, 100.386002);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0009 15
DEF_STATIC_CONST_VAL_FLOAT(val_2706, 11.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_2707, 117.106003);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_2708, 121.026001);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_2709, 112.625000);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0015 21
DEF_STATIC_CONST_VAL_FLOAT(val_2710, 109.114998);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0008 22
DEF_STATIC_CONST_VAL_FLOAT(val_2711, 0.390789);
DEF_STATIC_CONST_VAL_FLOAT(val_2712, 83.133102);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2713, 91.379700);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_2714, 95.035103);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_2715, 89.323997);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0027 31
DEF_STATIC_CONST_VAL_FLOAT(val_2716, 1.424000);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2717, 101.057999);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0031 35
DEF_STATIC_CONST_VAL_FLOAT(val_2718, 0.021000);
DEF_STATIC_CONST_VAL_FLOAT(val_2719, 0.210069);
DEF_STATIC_CONST_VAL_FLOAT(val_2720, 92.893402);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_2721, 99.126900);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0035 39
DEF_STATIC_CONST_VAL_FLOAT(val_2722, 102.992996);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0022 40
DEF_STATIC_CONST_VAL_FLOAT(val_2723, 0.799232);
DEF_STATIC_CONST_VAL_FLOAT(val_2724, 97.429604);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_2725, 101.357002);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_2726, 105.624001);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0046 48
#define CTNODE_cmu_us_rms_f0_s_152_NO_0041 49
DEF_STATIC_CONST_VAL_FLOAT(val_2727, 93.393700);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0040 50
DEF_STATIC_CONST_VAL_FLOAT(val_2728, 0.698163);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_2729, 109.105003);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0050 54
DEF_STATIC_CONST_VAL_FLOAT(val_2730, 103.626999);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0001 55
DEF_STATIC_CONST_VAL_FLOAT(val_2731, 93.831200);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0056 58
DEF_STATIC_CONST_VAL_FLOAT(val_2732, 123.636002);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0058 60
DEF_STATIC_CONST_VAL_FLOAT(val_2733, 0.307741);
DEF_STATIC_CONST_VAL_FLOAT(val_2734, 116.695000);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_2735, 109.278000);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_2736, 104.589996);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0055 65
DEF_STATIC_CONST_VAL_FLOAT(val_2737, 0.675500);
DEF_STATIC_CONST_VAL_FLOAT(val_2738, 131.843002);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0067 69
DEF_STATIC_CONST_VAL_FLOAT(val_2739, 125.082001);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0066 70
DEF_STATIC_CONST_VAL_FLOAT(val_2740, 135.031006);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0065 71
DEF_STATIC_CONST_VAL_FLOAT(val_2741, 0.797841);
DEF_STATIC_CONST_VAL_FLOAT(val_2742, 0.474956);
DEF_STATIC_CONST_VAL_FLOAT(val_2743, 126.360001);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_2744, 120.948997);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0073 77
DEF_STATIC_CONST_VAL_FLOAT(val_2745, 118.376999);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0078 80
DEF_STATIC_CONST_VAL_FLOAT(val_2746, 115.647003);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0077 81
DEF_STATIC_CONST_VAL_FLOAT(val_2747, 119.875999);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0081 83
DEF_STATIC_CONST_VAL_FLOAT(val_2748, 122.287003);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0072 84
DEF_STATIC_CONST_VAL_FLOAT(val_2749, 110.365997);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0071 85
DEF_STATIC_CONST_VAL_FLOAT(val_2750, 131.570999);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0085 87
DEF_STATIC_CONST_VAL_FLOAT(val_2751, 1.507000);
DEF_STATIC_CONST_VAL_FLOAT(val_2752, 127.172997);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0087 89
DEF_STATIC_CONST_VAL_FLOAT(val_2753, 122.501999);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0000 90
DEF_STATIC_CONST_VAL_FLOAT(val_2754, 0.068000);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0092 94
DEF_STATIC_CONST_VAL_FLOAT(val_2755, 93.924301);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0091 95
DEF_STATIC_CONST_VAL_FLOAT(val_2756, 83.486702);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0095 97
DEF_STATIC_CONST_VAL_FLOAT(val_2757, 0.013000);
DEF_STATIC_CONST_VAL_FLOAT(val_2758, 88.239601);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0097 99
DEF_STATIC_CONST_VAL_FLOAT(val_2759, 99.235703);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0090 100
DEF_STATIC_CONST_VAL_FLOAT(val_2760, 0.113000);
DEF_STATIC_CONST_VAL_FLOAT(val_2761, 3.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2762, 2.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_2763, 78.851303);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0103 105
DEF_STATIC_CONST_VAL_FLOAT(val_2764, 88.236298);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0102 106
DEF_STATIC_CONST_VAL_FLOAT(val_2765, 73.817802);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0101 107
DEF_STATIC_CONST_VAL_FLOAT(val_2766, 0.019000);
DEF_STATIC_CONST_VAL_FLOAT(val_2767, 84.222900);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0107 109
DEF_STATIC_CONST_VAL_FLOAT(val_2768, 68.280197);
#define CTNODE_cmu_us_rms_f0_s_152_NO_0100 110
DEF_STATIC_CONST_VAL_FLOAT(val_2769, 100.109001);
DEF_STATIC_CONST_VAL_FLOAT(val_2770, 94.688904);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_2771, 0.997207);
DEF_STATIC_CONST_VAL_FLOAT(val_2772, 78.677498);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2773, 79.788803);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_2774, 0.801075);
DEF_STATIC_CONST_VAL_FLOAT(val_2775, 0.050000);
DEF_STATIC_CONST_VAL_FLOAT(val_2776, 0.352383);
DEF_STATIC_CONST_VAL_FLOAT(val_2777, 118.606003);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2778, 105.344002);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_2779, 126.458000);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0008 14
DEF_STATIC_CONST_VAL_FLOAT(val_2780, 102.813004);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_2781, 110.309998);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0007 17
DEF_STATIC_CONST_VAL_FLOAT(val_2782, 89.778603);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0006 18
DEF_STATIC_CONST_VAL_FLOAT(val_2783, 110.850998);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_2784, 114.746002);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_2785, 122.083000);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_2786, 0.062500);
DEF_STATIC_CONST_VAL_FLOAT(val_2787, 127.264999);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_2788, 123.433998);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_2789, 120.494003);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0018 30
DEF_STATIC_CONST_VAL_FLOAT(val_2790, 118.748001);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_2791, 28.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_2792, 129.807999);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_2793, 126.721001);
#define CTNODE_cmu_us_rms_f0_s_153_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_2794, 134.125000);
DEF_STATIC_CONST_VAL_FLOAT(val_2795, 0.676451);
DEF_STATIC_CONST_VAL_FLOAT(val_2796, 100.888000);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_2797, 108.873001);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_2798, 0.283770);
DEF_STATIC_CONST_VAL_FLOAT(val_2799, 125.139000);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2800, 0.190909);
DEF_STATIC_CONST_VAL_FLOAT(val_2801, 120.663002);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_2802, 107.348000);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0001 11
DEF_STATIC_CONST_VAL_FLOAT(val_2803, 0.343879);
DEF_STATIC_CONST_VAL_FLOAT(val_2804, 113.355003);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_2805, 101.918999);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2806, 103.538002);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_2807, 0.177591);
DEF_STATIC_CONST_VAL_FLOAT(val_2808, 110.315002);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_2809, 106.550003);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_2810, 102.335999);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0011 23
DEF_STATIC_CONST_VAL_FLOAT(val_2811, 0.443675);
DEF_STATIC_CONST_VAL_FLOAT(val_2812, 103.491997);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2813, 98.220299);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_2814, 91.749199);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_2815, 97.789497);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0000 30
DEF_STATIC_CONST_VAL_FLOAT(val_2816, 0.879213);
DEF_STATIC_CONST_VAL_FLOAT(val_2817, 104.980003);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2818, 95.799004);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0031 35
DEF_STATIC_CONST_VAL_FLOAT(val_2819, 95.801697);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_2820, 93.374901);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0030 38
DEF_STATIC_CONST_VAL_FLOAT(val_2821, 8.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2822, 88.321198);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2823, 97.842300);
#define CTNODE_cmu_us_rms_f0_eh_56_NO_0038 42
DEF_STATIC_CONST_VAL_FLOAT(val_2824, 83.574997);
DEF_STATIC_CONST_VAL_FLOAT(val_2825, 0.682438);
DEF_STATIC_CONST_VAL_FLOAT(val_2826, 0.341084);
DEF_STATIC_CONST_VAL_FLOAT(val_2827, 0.013000);
DEF_STATIC_CONST_VAL_FLOAT(val_2828, 118.966003);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_2829, 114.065002);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0003 7
DEF_STATIC_CONST_VAL_FLOAT(val_2830, 0.087500);
DEF_STATIC_CONST_VAL_FLOAT(val_2831, 113.918999);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_2832, 108.974998);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_2833, 105.389000);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0007 13
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0002 14
DEF_STATIC_CONST_VAL_FLOAT(val_2834, 0.157086);
DEF_STATIC_CONST_VAL_FLOAT(val_2835, 113.974998);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_2836, 110.005997);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0015 19
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0014 20
DEF_STATIC_CONST_VAL_FLOAT(val_2837, 90.200798);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_2838, 0.419438);
DEF_STATIC_CONST_VAL_FLOAT(val_2839, 100.924004);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0023 25
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_2840, 107.538002);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0022 28
DEF_STATIC_CONST_VAL_FLOAT(val_2841, 95.487297);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_2842, 100.369003);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0001 31
DEF_STATIC_CONST_VAL_FLOAT(val_2843, 98.735703);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_2844, 21.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_2845, 94.541801);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_2846, 87.884102);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0000 36
DEF_STATIC_CONST_VAL_FLOAT(val_2847, 89.296303);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_2848, 0.028000);
DEF_STATIC_CONST_VAL_FLOAT(val_2849, 83.643097);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_2850, 79.025803);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0036 42
DEF_STATIC_CONST_VAL_FLOAT(val_2851, 3.059500);
DEF_STATIC_CONST_VAL_FLOAT(val_2852, 95.549896);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0043 45
DEF_STATIC_CONST_VAL_FLOAT(val_2853, 104.966003);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0042 46
DEF_STATIC_CONST_VAL_FLOAT(val_2854, 0.868714);
DEF_STATIC_CONST_VAL_FLOAT(val_2855, 91.692802);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_2856, 95.304901);
#define CTNODE_cmu_us_rms_f0_eh_57_NO_0046 50
DEF_STATIC_CONST_VAL_FLOAT(val_2857, 90.394203);
DEF_STATIC_CONST_VAL_FLOAT(val_2858, 83.357399);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_2859, 76.803398);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_2860, 0.201836);
DEF_STATIC_CONST_VAL_FLOAT(val_2861, 104.125999);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_2862, 113.820999);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_2863, 23.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_2864, 0.729007);
DEF_STATIC_CONST_VAL_FLOAT(val_2865, 107.752998);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2866, 99.535896);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_2867, 0.413037);
DEF_STATIC_CONST_VAL_FLOAT(val_2868, 94.769501);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2869, 90.712799);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_2870, 98.541100);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0009 19
DEF_STATIC_CONST_VAL_FLOAT(val_2871, 88.740303);
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0019 21
#define CTNODE_cmu_us_rms_f0_eh_58_NO_0008 22
DEF_STATIC_CONST_VAL_FLOAT(val_2872, 87.739799);
DEF_STATIC_CONST_VAL_FLOAT(val_2873, 91.815804);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_2874, 0.635069);
DEF_STATIC_CONST_VAL_FLOAT(val_2875, 0.316686);
DEF_STATIC_CONST_VAL_FLOAT(val_2876, 112.577003);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2877, 106.286003);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_2878, 110.392998);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_2879, 116.862999);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2880, 123.532997);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0004 14
DEF_STATIC_CONST_VAL_FLOAT(val_2881, 0.825516);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2882, 0.730617);
DEF_STATIC_CONST_VAL_FLOAT(val_2883, 107.100998);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_2884, 111.541000);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0014 20
DEF_STATIC_CONST_VAL_FLOAT(val_2885, 99.403000);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0003 21
DEF_STATIC_CONST_VAL_FLOAT(val_2886, 125.830002);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_2887, 118.328003);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0000 24
DEF_STATIC_CONST_VAL_FLOAT(val_2888, 0.029000);
DEF_STATIC_CONST_VAL_FLOAT(val_2889, 83.290901);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_2890, 86.006699);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_2891, 94.573303);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0025 31
DEF_STATIC_CONST_VAL_FLOAT(val_2892, 74.893600);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0024 32
DEF_STATIC_CONST_VAL_FLOAT(val_2893, 115.112999);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0033 35
DEF_STATIC_CONST_VAL_FLOAT(val_2894, 104.921997);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0032 36
DEF_STATIC_CONST_VAL_FLOAT(val_2895, 0.085000);
DEF_STATIC_CONST_VAL_FLOAT(val_2896, 102.091003);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_2897, 101.595001);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_2898, 0.012500);
DEF_STATIC_CONST_VAL_FLOAT(val_2899, 97.185204);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_2900, 0.320334);
DEF_STATIC_CONST_VAL_FLOAT(val_2901, 97.676903);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_2902, 91.266998);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0044 48
DEF_STATIC_CONST_VAL_FLOAT(val_2903, 0.381820);
DEF_STATIC_CONST_VAL_FLOAT(val_2904, 85.200699);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0048 50
DEF_STATIC_CONST_VAL_FLOAT(val_2905, 85.556602);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_2906, 91.412697);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0050 54
DEF_STATIC_CONST_VAL_FLOAT(val_2907, 0.601286);
DEF_STATIC_CONST_VAL_FLOAT(val_2908, 96.719498);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_2909, 90.660500);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0054 58
DEF_STATIC_CONST_VAL_FLOAT(val_2910, 92.439102);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0058 60
DEF_STATIC_CONST_VAL_FLOAT(val_2911, 85.435898);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0037 61
DEF_STATIC_CONST_VAL_FLOAT(val_2912, 0.310592);
DEF_STATIC_CONST_VAL_FLOAT(val_2913, 114.101997);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_2914, 103.933998);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0061 65
DEF_STATIC_CONST_VAL_FLOAT(val_2915, 0.665411);
DEF_STATIC_CONST_VAL_FLOAT(val_2916, 97.864403);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0066 68
DEF_STATIC_CONST_VAL_FLOAT(val_2917, 93.129799);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0065 69
DEF_STATIC_CONST_VAL_FLOAT(val_2918, 0.609412);
DEF_STATIC_CONST_VAL_FLOAT(val_2919, 101.956001);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0069 71
DEF_STATIC_CONST_VAL_FLOAT(val_2920, 98.379303);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0036 72
DEF_STATIC_CONST_VAL_FLOAT(val_2921, 100.224998);
#define CTNODE_cmu_us_rms_f0_t_164_NO_0072 74
DEF_STATIC_CONST_VAL_FLOAT(val_2922, 111.764000);
DEF_STATIC_CONST_VAL_FLOAT(val_2923, 0.795433);
DEF_STATIC_CONST_VAL_FLOAT(val_2924, 0.399061);
DEF_STATIC_CONST_VAL_FLOAT(val_2925, 114.130997);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2926, 109.834999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0005 9
DEF_STATIC_CONST_VAL_FLOAT(val_2927, 118.508003);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0004 10
DEF_STATIC_CONST_VAL_FLOAT(val_2928, 108.794998);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2929, 115.327003);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_2930, 105.255997);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0003 15
DEF_STATIC_CONST_VAL_FLOAT(val_2931, 107.157997);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_2932, 89.040001);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0002 18
DEF_STATIC_CONST_VAL_FLOAT(val_2933, 0.197078);
DEF_STATIC_CONST_VAL_FLOAT(val_2934, 125.806999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_2935, 131.089005);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0018 22
DEF_STATIC_CONST_VAL_FLOAT(val_2936, 0.334421);
DEF_STATIC_CONST_VAL_FLOAT(val_2937, 108.258003);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_2938, 0.664263);
DEF_STATIC_CONST_VAL_FLOAT(val_2939, 117.280998);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_2940, 111.877998);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0022 28
DEF_STATIC_CONST_VAL_FLOAT(val_2941, 125.233002);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0001 29
DEF_STATIC_CONST_VAL_FLOAT(val_2942, 2.025000);
DEF_STATIC_CONST_VAL_FLOAT(val_2943, 130.184998);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_2944, 122.195999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0000 32
DEF_STATIC_CONST_VAL_FLOAT(val_2945, 0.838000);
DEF_STATIC_CONST_VAL_FLOAT(val_2946, 0.059000);
DEF_STATIC_CONST_VAL_FLOAT(val_2947, 117.418999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_2948, 125.842003);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_2949, 109.857002);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0033 39
DEF_STATIC_CONST_VAL_FLOAT(val_2950, 0.243934);
DEF_STATIC_CONST_VAL_FLOAT(val_2951, 102.577003);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_2952, 93.852501);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0039 43
DEF_STATIC_CONST_VAL_FLOAT(val_2953, 5.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_2954, 98.350502);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_2955, 103.042999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0044 48
DEF_STATIC_CONST_VAL_FLOAT(val_2956, 109.583000);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0048 50
DEF_STATIC_CONST_VAL_FLOAT(val_2957, 102.862999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0043 51
DEF_STATIC_CONST_VAL_FLOAT(val_2958, 115.554001);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0032 52
DEF_STATIC_CONST_VAL_FLOAT(val_2959, 0.035000);
DEF_STATIC_CONST_VAL_FLOAT(val_2960, 81.887001);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_2961, 100.161003);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_2962, 1.987000);
DEF_STATIC_CONST_VAL_FLOAT(val_2963, 95.293098);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0058 60
DEF_STATIC_CONST_VAL_FLOAT(val_2964, 98.045403);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0057 61
DEF_STATIC_CONST_VAL_FLOAT(val_2965, 88.673302);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_2966, 94.084702);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0052 64
DEF_STATIC_CONST_VAL_FLOAT(val_2967, 99.710503);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0066 68
DEF_STATIC_CONST_VAL_FLOAT(val_2968, 102.362999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0068 70
DEF_STATIC_CONST_VAL_FLOAT(val_2969, 111.359001);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0065 71
DEF_STATIC_CONST_VAL_FLOAT(val_2970, 0.035000);
DEF_STATIC_CONST_VAL_FLOAT(val_2971, 103.513000);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_2972, 98.337700);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0073 77
DEF_STATIC_CONST_VAL_FLOAT(val_2973, 91.672600);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0077 79
DEF_STATIC_CONST_VAL_FLOAT(val_2974, 100.219002);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0072 80
DEF_STATIC_CONST_VAL_FLOAT(val_2975, 107.556999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0080 82
#define CTNODE_cmu_us_rms_f0_t_165_NO_0071 83
DEF_STATIC_CONST_VAL_FLOAT(val_2976, 91.652901);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0064 84
DEF_STATIC_CONST_VAL_FLOAT(val_2977, 0.060500);
DEF_STATIC_CONST_VAL_FLOAT(val_2978, 105.807999);
#define CTNODE_cmu_us_rms_f0_t_165_NO_0084 86
DEF_STATIC_CONST_VAL_FLOAT(val_2979, 112.834000);
DEF_STATIC_CONST_VAL_FLOAT(val_2980, 94.414200);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_2981, 0.020000);
DEF_STATIC_CONST_VAL_FLOAT(val_2982, 72.304703);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0004 6
DEF_STATIC_CONST_VAL_FLOAT(val_2983, 78.151901);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0006 8
DEF_STATIC_CONST_VAL_FLOAT(val_2984, 84.305702);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0001 9
DEF_STATIC_CONST_VAL_FLOAT(val_2985, 109.924004);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0009 11
#define CTNODE_cmu_us_rms_f0_t_166_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_2986, 91.815903);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_2987, 88.708000);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0015 19
DEF_STATIC_CONST_VAL_FLOAT(val_2988, 95.134697);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0014 20
DEF_STATIC_CONST_VAL_FLOAT(val_2989, 100.917999);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0013 21
DEF_STATIC_CONST_VAL_FLOAT(val_2990, 107.703003);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0000 22
DEF_STATIC_CONST_VAL_STRING(val_2991, "r_146");
DEF_STATIC_CONST_VAL_FLOAT(val_2992, 131.695007);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_2993, 123.469002);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0023 27
DEF_STATIC_CONST_VAL_FLOAT(val_2994, 0.037500);
DEF_STATIC_CONST_VAL_FLOAT(val_2995, 0.684204);
DEF_STATIC_CONST_VAL_FLOAT(val_2996, 118.612999);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_2997, 111.307999);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0028 32
DEF_STATIC_CONST_VAL_FLOAT(val_2998, 127.927002);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_2999, 123.767998);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0027 35
DEF_STATIC_CONST_VAL_FLOAT(val_3000, 108.706001);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0022 36
DEF_STATIC_CONST_VAL_FLOAT(val_3001, 0.311952);
DEF_STATIC_CONST_VAL_FLOAT(val_3002, 103.558998);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0038 40
DEF_STATIC_CONST_VAL_FLOAT(val_3003, 116.990997);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0037 41
DEF_STATIC_CONST_VAL_FLOAT(val_3004, 0.041000);
DEF_STATIC_CONST_VAL_FLOAT(val_3005, 8.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_3006, 93.037102);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_3007, 100.672997);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0041 45
DEF_STATIC_CONST_VAL_FLOAT(val_3008, 105.426003);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0036 46
DEF_STATIC_CONST_VAL_FLOAT(val_3009, 0.688772);
DEF_STATIC_CONST_VAL_FLOAT(val_3010, 107.695999);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_3011, 112.582001);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0048 52
DEF_STATIC_CONST_VAL_FLOAT(val_3012, 119.629997);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0047 53
DEF_STATIC_CONST_VAL_FLOAT(val_3013, 20.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_3014, 119.197998);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_3015, 125.815002);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0046 56
DEF_STATIC_CONST_VAL_FLOAT(val_3016, 104.543999);
#define CTNODE_cmu_us_rms_f0_t_166_NO_0056 58
DEF_STATIC_CONST_VAL_FLOAT(val_3017, 111.848999);
DEF_STATIC_CONST_VAL_FLOAT(val_3018, 0.295762);
DEF_STATIC_CONST_VAL_FLOAT(val_3019, 113.955002);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_3020, 103.943001);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_3021, 97.265800);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0002 8
DEF_STATIC_CONST_VAL_FLOAT(val_3022, 0.512957);
DEF_STATIC_CONST_VAL_FLOAT(val_3023, 109.378998);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0010 12
DEF_STATIC_CONST_VAL_FLOAT(val_3024, 94.563599);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0009 13
DEF_STATIC_CONST_VAL_FLOAT(val_3025, 91.123100);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_3026, 93.562103);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_3027, 20.299999);
DEF_STATIC_CONST_VAL_FLOAT(val_3028, 96.207100);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_3029, 100.036003);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0008 20
DEF_STATIC_CONST_VAL_FLOAT(val_3030, 86.689301);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0001 21
DEF_STATIC_CONST_VAL_FLOAT(val_3031, 0.886716);
DEF_STATIC_CONST_VAL_FLOAT(val_3032, 89.115997);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_3033, 83.282600);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0022 26
DEF_STATIC_CONST_VAL_STRING(val_3034, "v_186");
DEF_STATIC_CONST_VAL_FLOAT(val_3035, 97.633301);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_3036, 87.417099);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_3037, 92.772697);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0031 33
DEF_STATIC_CONST_VAL_FLOAT(val_3038, 89.649597);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0026 34
DEF_STATIC_CONST_VAL_FLOAT(val_3039, 0.271913);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_3040, 104.731003);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_3041, 0.694485);
DEF_STATIC_CONST_VAL_FLOAT(val_3042, 93.266296);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_3043, 87.195602);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0038 42
DEF_STATIC_CONST_VAL_FLOAT(val_3044, 0.642857);
DEF_STATIC_CONST_VAL_FLOAT(val_3045, 101.203003);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_3046, 93.669800);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0021 45
DEF_STATIC_CONST_VAL_FLOAT(val_3047, 90.792999);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_3048, 81.295502);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0000 48
DEF_STATIC_CONST_VAL_FLOAT(val_3049, 0.694630);
DEF_STATIC_CONST_VAL_FLOAT(val_3050, 0.417135);
DEF_STATIC_CONST_VAL_FLOAT(val_3051, 126.037003);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0050 52
DEF_STATIC_CONST_VAL_FLOAT(val_3052, 113.783997);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0052 54
DEF_STATIC_CONST_VAL_FLOAT(val_3053, 111.277000);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0049 55
DEF_STATIC_CONST_VAL_FLOAT(val_3054, 0.294402);
DEF_STATIC_CONST_VAL_FLOAT(val_3055, 110.785004);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0055 57
DEF_STATIC_CONST_VAL_FLOAT(val_3056, 0.574186);
DEF_STATIC_CONST_VAL_FLOAT(val_3057, 101.355003);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_3058, 94.652802);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0048 60
DEF_STATIC_CONST_VAL_FLOAT(val_3059, 93.440300);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_3060, 85.193100);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0060 64
DEF_STATIC_CONST_VAL_FLOAT(val_3061, 94.311996);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0064 66
DEF_STATIC_CONST_VAL_FLOAT(val_3062, 0.359184);
DEF_STATIC_CONST_VAL_FLOAT(val_3063, 106.264999);
#define CTNODE_cmu_us_rms_f0_er_61_NO_0066 68
DEF_STATIC_CONST_VAL_FLOAT(val_3064, 98.062103);
DEF_STATIC_CONST_VAL_FLOAT(val_3065, 1.225000);
DEF_STATIC_CONST_VAL_FLOAT(val_3066, 0.112701);
DEF_STATIC_CONST_VAL_FLOAT(val_3067, 114.264999);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_3068, 105.779999);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0004 8
DEF_STATIC_CONST_VAL_FLOAT(val_3069, 99.108200);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0003 9
DEF_STATIC_CONST_VAL_FLOAT(val_3070, 100.831001);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_3071, 97.252296);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_3072, 88.388298);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0002 14
DEF_STATIC_CONST_VAL_FLOAT(val_3073, 124.637001);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_3074, 119.309998);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0014 18
DEF_STATIC_CONST_VAL_FLOAT(val_3075, 105.179001);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0018 20
DEF_STATIC_CONST_VAL_FLOAT(val_3076, 113.704002);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0001 21
DEF_STATIC_CONST_VAL_FLOAT(val_3077, 0.502520);
DEF_STATIC_CONST_VAL_FLOAT(val_3078, 0.673919);
DEF_STATIC_CONST_VAL_FLOAT(val_3079, 90.350502);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0024 26
DEF_STATIC_CONST_VAL_FLOAT(val_3080, 0.311765);
DEF_STATIC_CONST_VAL_FLOAT(val_3081, 102.633003);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_3082, 97.783600);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0023 29
DEF_STATIC_CONST_VAL_FLOAT(val_3083, 96.625900);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0029 31
DEF_STATIC_CONST_VAL_FLOAT(val_3084, 85.076797);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0022 32
DEF_STATIC_CONST_VAL_FLOAT(val_3085, 1.642500);
DEF_STATIC_CONST_VAL_FLOAT(val_3086, 91.806099);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_3087, 81.451500);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_3088, 89.053200);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_3089, 93.249199);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0036 40
DEF_STATIC_CONST_VAL_FLOAT(val_3090, 82.332497);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_3091, 88.687698);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0021 43
DEF_STATIC_CONST_VAL_FLOAT(val_3092, 19.299999);
DEF_STATIC_CONST_VAL_FLOAT(val_3093, 113.859001);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0045 47
DEF_STATIC_CONST_VAL_FLOAT(val_3094, 107.403999);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_3095, 102.412003);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0044 50
DEF_STATIC_CONST_VAL_FLOAT(val_3096, 98.835098);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0043 51
DEF_STATIC_CONST_VAL_FLOAT(val_3097, 0.176000);
DEF_STATIC_CONST_VAL_FLOAT(val_3098, 0.073000);
DEF_STATIC_CONST_VAL_FLOAT(val_3099, 91.685997);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0052 54
DEF_STATIC_CONST_VAL_FLOAT(val_3100, 103.142998);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0051 55
DEF_STATIC_CONST_VAL_FLOAT(val_3101, 87.971802);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0000 56
DEF_STATIC_CONST_VAL_FLOAT(val_3102, 0.890000);
DEF_STATIC_CONST_VAL_FLOAT(val_3103, 95.523598);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_3104, 94.927597);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_3105, 88.594101);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_3106, 83.061600);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0059 65
DEF_STATIC_CONST_VAL_FLOAT(val_3107, 76.514503);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_3108, 84.418098);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0056 68
DEF_STATIC_CONST_VAL_FLOAT(val_3109, 84.462402);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0068 70
DEF_STATIC_CONST_VAL_FLOAT(val_3110, 0.146000);
DEF_STATIC_CONST_VAL_FLOAT(val_3111, 72.450104);
#define CTNODE_cmu_us_rms_f0_er_62_NO_0070 72
DEF_STATIC_CONST_VAL_FLOAT(val_3112, 83.878899);
DEF_STATIC_CONST_VAL_FLOAT(val_3113, 0.611320);
DEF_STATIC_CONST_VAL_FLOAT(val_3114, 97.729897);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_3115, 88.583603);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_3116, 23.299999);
DEF_STATIC_CONST_VAL_FLOAT(val_3117, 0.039000);
DEF_STATIC_CONST_VAL_FLOAT(val_3118, 85.820503);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_3119, 88.073799);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_3120, 90.917999);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0006 12
DEF_STATIC_CONST_VAL_FLOAT(val_3121, 0.603812);
DEF_STATIC_CONST_VAL_FLOAT(val_3122, 86.015404);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0012 14
DEF_STATIC_CONST_VAL_FLOAT(val_3123, 80.053497);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0001 15
DEF_STATIC_CONST_VAL_FLOAT(val_3124, 0.414789);
DEF_STATIC_CONST_VAL_FLOAT(val_3125, 110.191002);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_3126, 30.799999);
DEF_STATIC_CONST_VAL_FLOAT(val_3127, 95.805496);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_3128, 87.529198);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0000 20
DEF_STATIC_CONST_VAL_FLOAT(val_3129, 0.086000);
DEF_STATIC_CONST_VAL_FLOAT(val_3130, 0.820565);
DEF_STATIC_CONST_VAL_FLOAT(val_3131, 79.557297);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0022 24
DEF_STATIC_CONST_VAL_FLOAT(val_3132, 74.748398);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0021 25
DEF_STATIC_CONST_VAL_FLOAT(val_3133, 71.593597);
#define CTNODE_cmu_us_rms_f0_er_63_NO_0020 26
DEF_STATIC_CONST_VAL_FLOAT(val_3134, 93.002899);
DEF_STATIC_CONST_VAL_FLOAT(val_3135, 92.393204);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_3136, 100.609001);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0002 6
DEF_STATIC_CONST_VAL_FLOAT(val_3137, 117.442001);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0007 9
DEF_STATIC_CONST_VAL_STRING(val_3138, "to");
DEF_STATIC_CONST_VAL_FLOAT(val_3139, 112.122002);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0009 11
DEF_STATIC_CONST_VAL_FLOAT(val_3140, 110.116997);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_3141, 108.016998);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0013 15
DEF_STATIC_CONST_VAL_FLOAT(val_3142, 104.370003);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0006 16
DEF_STATIC_CONST_VAL_FLOAT(val_3143, 5.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_3144, 102.640999);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_3145, 105.992996);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0016 20
DEF_STATIC_CONST_VAL_FLOAT(val_3146, 0.842857);
DEF_STATIC_CONST_VAL_FLOAT(val_3147, 99.863899);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0020 22
DEF_STATIC_CONST_VAL_FLOAT(val_3148, 96.582397);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0001 23
DEF_STATIC_CONST_VAL_STRING(val_3149, "z_201");
DEF_STATIC_CONST_VAL_FLOAT(val_3150, 106.051003);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_3151, 98.858803);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_3152, 103.747002);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0025 29
DEF_STATIC_CONST_VAL_FLOAT(val_3153, 92.928802);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_3154, 93.915298);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_3155, 0.599685);
DEF_STATIC_CONST_VAL_FLOAT(val_3156, 0.331154);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0035 37
DEF_STATIC_CONST_VAL_FLOAT(val_3157, 98.809601);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0034 38
DEF_STATIC_CONST_VAL_FLOAT(val_3158, 90.932503);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0029 39
DEF_STATIC_CONST_VAL_FLOAT(val_3159, 0.499326);
DEF_STATIC_CONST_VAL_FLOAT(val_3160, 0.229493);
DEF_STATIC_CONST_VAL_FLOAT(val_3161, 100.038002);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0040 42
DEF_STATIC_CONST_VAL_FLOAT(val_3162, 95.340103);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0039 43
DEF_STATIC_CONST_VAL_FLOAT(val_3163, 0.724190);
DEF_STATIC_CONST_VAL_FLOAT(val_3164, 90.796303);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0043 45
DEF_STATIC_CONST_VAL_FLOAT(val_3165, 86.082001);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0000 46
DEF_STATIC_CONST_VAL_FLOAT(val_3166, 103.342003);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_3167, 84.563400);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_3168, 92.239998);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0046 52
DEF_STATIC_CONST_VAL_FLOAT(val_3169, 14.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_3170, 85.790802);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_3171, 91.098900);
#define CTNODE_cmu_us_rms_f0_ax_26_NO_0052 56
DEF_STATIC_CONST_VAL_FLOAT(val_3172, 82.932899);
DEF_STATIC_CONST_VAL_FLOAT(val_3173, 0.733500);
DEF_STATIC_CONST_VAL_FLOAT(val_3174, 0.404000);
DEF_STATIC_CONST_VAL_FLOAT(val_3175, 0.343000);
DEF_STATIC_CONST_VAL_FLOAT(val_3176, 104.860001);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0002 4
DEF_STATIC_CONST_VAL_FLOAT(val_3177, 110.285004);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0001 5
DEF_STATIC_CONST_VAL_FLOAT(val_3178, 106.164001);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0005 7
DEF_STATIC_CONST_VAL_FLOAT(val_3179, 100.384003);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_3180, 104.206001);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0007 11
DEF_STATIC_CONST_VAL_FLOAT(val_3181, 97.820000);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0000 12
DEF_STATIC_CONST_VAL_FLOAT(val_3182, 91.414101);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0015 17
DEF_STATIC_CONST_VAL_FLOAT(val_3183, 108.902000);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0017 19
DEF_STATIC_CONST_VAL_FLOAT(val_3184, 97.670799);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0019 21
DEF_STATIC_CONST_VAL_FLOAT(val_3185, 102.235001);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0014 22
DEF_STATIC_CONST_VAL_FLOAT(val_3186, 1.602000);
DEF_STATIC_CONST_VAL_FLOAT(val_3187, 99.187698);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0023 25
DEF_STATIC_CONST_VAL_FLOAT(val_3188, 95.093697);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0022 26
DEF_STATIC_CONST_VAL_FLOAT(val_3189, 88.407501);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0026 28
DEF_STATIC_CONST_VAL_FLOAT(val_3190, 93.920601);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0028 30
DEF_STATIC_CONST_VAL_FLOAT(val_3191, 90.167000);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0013 31
DEF_STATIC_CONST_VAL_FLOAT(val_3192, 90.612000);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_3193, 0.668246);
DEF_STATIC_CONST_VAL_FLOAT(val_3194, 87.535202);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_3195, 84.661598);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0033 39
DEF_STATIC_CONST_VAL_FLOAT(val_3196, 93.196800);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0032 40
DEF_STATIC_CONST_VAL_FLOAT(val_3197, 84.366798);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0031 41
DEF_STATIC_CONST_VAL_FLOAT(val_3198, 0.633073);
DEF_STATIC_CONST_VAL_FLOAT(val_3199, 98.877502);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0042 44
DEF_STATIC_CONST_VAL_FLOAT(val_3200, 3.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_3201, 95.436996);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_3202, 90.328598);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0041 47
DEF_STATIC_CONST_VAL_FLOAT(val_3203, 2.813000);
DEF_STATIC_CONST_VAL_FLOAT(val_3204, 91.584099);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0047 49
DEF_STATIC_CONST_VAL_FLOAT(val_3205, 85.611702);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_3206, 90.260803);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0012 52
DEF_STATIC_CONST_VAL_FLOAT(val_3207, 4.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_3208, 84.495697);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0054 56
DEF_STATIC_CONST_VAL_FLOAT(val_3209, 92.619202);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0053 57
DEF_STATIC_CONST_VAL_FLOAT(val_3210, 87.391296);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0057 59
DEF_STATIC_CONST_VAL_FLOAT(val_3211, 82.215599);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0052 60
DEF_STATIC_CONST_VAL_FLOAT(val_3212, 87.246597);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0060 62
DEF_STATIC_CONST_VAL_FLOAT(val_3213, 81.886803);
#define CTNODE_cmu_us_rms_f0_ax_27_NO_0062 64
DEF_STATIC_CONST_VAL_FLOAT(val_3214, 76.452499);
DEF_STATIC_CONST_VAL_FLOAT(val_3215, 0.042000);
DEF_STATIC_CONST_VAL_FLOAT(val_3216, 98.536499);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_3217, 107.777000);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0003 5
DEF_STATIC_CONST_VAL_FLOAT(val_3218, 103.865997);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0000 6
DEF_STATIC_CONST_VAL_FLOAT(val_3219, 0.622222);
DEF_STATIC_CONST_VAL_FLOAT(val_3220, 0.241534);
DEF_STATIC_CONST_VAL_FLOAT(val_3221, 107.210999);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0008 10
DEF_STATIC_CONST_VAL_FLOAT(val_3222, 1.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_3223, 99.978302);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0011 13
DEF_STATIC_CONST_VAL_FLOAT(val_3224, 95.122200);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0010 14
DEF_STATIC_CONST_VAL_FLOAT(val_3225, 0.523655);
DEF_STATIC_CONST_VAL_FLOAT(val_3226, 95.084000);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_3227, 87.554398);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0016 18
DEF_STATIC_CONST_VAL_FLOAT(val_3228, 91.083397);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0007 19
DEF_STATIC_CONST_VAL_FLOAT(val_3229, 0.426052);
DEF_STATIC_CONST_VAL_FLOAT(val_3230, 101.764999);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_3231, 94.051598);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0020 24
DEF_STATIC_CONST_VAL_FLOAT(val_3232, 95.691597);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_3233, 0.586188);
DEF_STATIC_CONST_VAL_FLOAT(val_3234, 95.059402);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_3235, 88.979797);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0024 30
DEF_STATIC_CONST_VAL_FLOAT(val_3236, 0.612183);
DEF_STATIC_CONST_VAL_FLOAT(val_3237, 92.604401);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_3238, 87.821701);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0019 33
DEF_STATIC_CONST_VAL_FLOAT(val_3239, 0.056000);
DEF_STATIC_CONST_VAL_FLOAT(val_3240, 85.595100);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0034 36
DEF_STATIC_CONST_VAL_FLOAT(val_3241, 82.076103);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0033 37
DEF_STATIC_CONST_VAL_FLOAT(val_3242, 0.242569);
DEF_STATIC_CONST_VAL_FLOAT(val_3243, 95.935600);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0037 39
DEF_STATIC_CONST_VAL_FLOAT(val_3244, 0.850000);
DEF_STATIC_CONST_VAL_FLOAT(val_3245, 92.031898);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0041 43
DEF_STATIC_CONST_VAL_FLOAT(val_3246, 88.864403);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0040 44
DEF_STATIC_CONST_VAL_FLOAT(val_3247, 0.533808);
DEF_STATIC_CONST_VAL_FLOAT(val_3248, 89.059402);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0044 46
DEF_STATIC_CONST_VAL_FLOAT(val_3249, 84.070000);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0039 47
DEF_STATIC_CONST_VAL_FLOAT(val_3250, 84.228203);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0006 48
DEF_STATIC_CONST_VAL_FLOAT(val_3251, 87.274002);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0049 51
DEF_STATIC_CONST_VAL_FLOAT(val_3252, 83.078796);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0051 53
DEF_STATIC_CONST_VAL_FLOAT(val_3253, 79.658997);
#define CTNODE_cmu_us_rms_f0_ax_28_NO_0048 54
DEF_STATIC_CONST_VAL_FLOAT(val_3254, 78.215797);
| 47.656945 | 49 | 0.878495 | Barath-Kannan |
8de64671d2bc37f66f39d995b2b346c029f9b9e3 | 846 | cpp | C++ | src/Application/Resource/RouteNotFound.cpp | edson-a-soares/poco_module_didactic | 1557c8eaa573ba88de2feafe5fcb6c08ea8631d8 | [
"Apache-2.0"
] | 2 | 2020-03-30T08:04:03.000Z | 2020-05-21T23:10:05.000Z | src/Application/Resource/RouteNotFound.cpp | edson-a-soares/poco_module_didactic | 1557c8eaa573ba88de2feafe5fcb6c08ea8631d8 | [
"Apache-2.0"
] | null | null | null | src/Application/Resource/RouteNotFound.cpp | edson-a-soares/poco_module_didactic | 1557c8eaa573ba88de2feafe5fcb6c08ea8631d8 | [
"Apache-2.0"
] | null | null | null | #include "Application/Resource/RouteNotFound.h"
#include "Application/Handling/ErrorJSONParser.h"
namespace Application {
namespace Resource {
void RouteNotFound::handleRequest(Poco::Net::HTTPServerRequest & request, Poco::Net::HTTPServerResponse & response)
{
configureCORS(response);
response.setContentType("application/json; charset=utf-8");
response.setStatus(Poco::Net::HTTPResponse::HTTP_NOT_FOUND);
response.setReason(Poco::Net::HTTPResponse::HTTP_REASON_NOT_FOUND);
Handling::ErrorJSONParser error = Handling::ErrorJSONParser(request.getHost());
std::ostream & outputStream = response.send();
outputStream << error.toJson("404", request.getURI(),
Poco::Net::HTTPResponse::HTTP_REASON_NOT_FOUND, "This route does not exist.");
outputStream.flush();
}
} }
| 30.214286 | 119 | 0.71513 | edson-a-soares |
8de6b8f2da582c498765deac51c0c290866ece8f | 1,530 | cpp | C++ | g.cpp | llwwns/atcoder-past-3 | a022382cacd5a726909ca844ce885d7ae598cf1c | [
"MIT"
] | null | null | null | g.cpp | llwwns/atcoder-past-3 | a022382cacd5a726909ca844ce885d7ae598cf1c | [
"MIT"
] | null | null | null | g.cpp | llwwns/atcoder-past-3 | a022382cacd5a726909ca844ce885d7ae598cf1c | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
#include <queue>
#include <tuple>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
vector<vector<bool>> p(405, vector<bool>(405, false));
for (int i = 0; i < n; i++) {
int px, py;
cin >> px >> py;
p[px + 202][py + 202] = true;
}
priority_queue<tuple<int, int, int, int>,
std::vector<tuple<int, int, int, int>>,
std::greater<tuple<int, int, int, int>>
> q;
auto h = [&](int i, int j) {
int dx = x - i >= 0 ? x - i : i - x;
int dy = y - j >= 0 ? y - j : j - y;
return max(dx, dy);
};
q.push(make_tuple(h(0, 0), 0, 0, 0));
auto check = [&](int nx, int ny, int b) {
if (nx < -202 || nx > 202 || ny < -202 || ny > 202 || p[nx + 202][ny + 202]) {
return false;
}
if (nx == x && ny == y) {
return true;
}
q.push(make_tuple(h(nx, ny) + b + 1, b + 1, nx, ny));
p[nx + 202][ny + 202] = true;
return false;
};
while (!q.empty()) {
int a, cx, cy, b;
tie(a, b, cx, cy) = q.top();
q.pop();
if (
check(cx + 1, cy + 1, b) ||
check(cx, cy + 1,b) ||
check(cx - 1, cy + 1,b) ||
check(cx + 1, cy,b) ||
check(cx - 1, cy,b) ||
check(cx, cy - 1,b)
) {
cout << b + 1 << endl;
return 0;
}
}
cout << -1 << endl;
}
| 27.321429 | 86 | 0.388235 | llwwns |
8de8c619615594f648376d9bad5c87a6a4d7dc39 | 274 | cpp | C++ | src/pola/gui/View.cpp | lij0511/pandora | 5988618f29d2f1ba418ef54a02e227903c1e7108 | [
"Apache-2.0"
] | null | null | null | src/pola/gui/View.cpp | lij0511/pandora | 5988618f29d2f1ba418ef54a02e227903c1e7108 | [
"Apache-2.0"
] | null | null | null | src/pola/gui/View.cpp | lij0511/pandora | 5988618f29d2f1ba418ef54a02e227903c1e7108 | [
"Apache-2.0"
] | null | null | null | /*
* View.cpp
*
* Created on: 2016年5月25日
* Author: lijing
*/
#include "pola/gui/View.h"
namespace pola {
namespace gui {
View::View() {
}
View::~View() {
}
void View::onDraw(graphic::GraphicContext* graphic) {
}
} /* namespace gui */
} /* namespace pola */
| 11.416667 | 53 | 0.60219 | lij0511 |
8de9997c29678c8fe4c5ceea3a82a3cbe7ce0c6d | 1,774 | cc | C++ | CommonTools/Statistics/src/PartitionGenerator.cc | nistefan/cmssw | ea13af97f7f2117a4f590a5e654e06ecd9825a5b | [
"Apache-2.0"
] | 3 | 2018-08-24T19:10:26.000Z | 2019-02-19T11:45:32.000Z | CommonTools/Statistics/src/PartitionGenerator.cc | nistefan/cmssw | ea13af97f7f2117a4f590a5e654e06ecd9825a5b | [
"Apache-2.0"
] | 3 | 2018-08-23T13:40:24.000Z | 2019-12-05T21:16:03.000Z | CommonTools/Statistics/src/PartitionGenerator.cc | nistefan/cmssw | ea13af97f7f2117a4f590a5e654e06ecd9825a5b | [
"Apache-2.0"
] | 5 | 2018-08-21T16:37:52.000Z | 2020-01-09T13:33:17.000Z | #include "CommonTools/Statistics/interface/PartitionGenerator.h"
#include <algorithm>
using namespace std;
vector<PartitionGenerator::Partition>
PartitionGenerator::partitions(int collectionSize, int minCollectionSize)
const {
std::vector<Partition> partitions;
// at the very least, we have a single bag of size 'collectionSize'
partitions.push_back( Partition(1, collectionSize) );
int first = collectionSize - minCollectionSize, second = minCollectionSize;
while( first >= second ) {
// try to further divide the first
std::vector<Partition> subPartitions = this->partitions(first, second);
std::vector<Partition>::iterator isub;
for( isub = subPartitions.begin(); isub != subPartitions.end(); isub++ ) {
const Partition& sub = *isub;
// reject subPartitions of first with a last element smaller than second
if( sub.back() < second ) continue;
Partition partition( sub.size()+1 );
copy( sub.begin(), sub.end(), partition.begin() );
partition[ partition.size()-1 ] = second;
partitions.push_back( partition );
}
first--; second++;
}
return partitions;
}
vector< std::vector<PartitionGenerator::Partition> >
PartitionGenerator::sortedPartitions(int collectionSize,
int minCollectionSize) const {
std::vector<Partition> partitions
= this->partitions(collectionSize, minCollectionSize);
sort (partitions.begin(), partitions.end(), LessCollections());
std::vector< std::vector<Partition> > sortedPartitions;
sortedPartitions.resize(partitions.rbegin()->size());
for (std::vector<Partition>::const_iterator i = partitions.begin();
i != partitions.end(); i++) {
sortedPartitions[(*i).size() - 1].push_back(*i);
}
return sortedPartitions;
}
| 32.254545 | 78 | 0.698985 | nistefan |
8df61ce703f6b4cc70ed365bb85048e83a4f4feb | 3,152 | hpp | C++ | src/seed_tracker.hpp | skovaka/nanopore_aligner | 0ebd606d941db0bb82f14c17b453f27269a38716 | [
"MIT"
] | 489 | 2018-11-02T14:04:10.000Z | 2022-03-25T07:31:59.000Z | src/seed_tracker.hpp | skovaka/nanopore_aligner | 0ebd606d941db0bb82f14c17b453f27269a38716 | [
"MIT"
] | 39 | 2019-11-11T00:49:51.000Z | 2022-03-22T18:04:01.000Z | src/seed_tracker.hpp | skovaka/nanopore_aligner | 0ebd606d941db0bb82f14c17b453f27269a38716 | [
"MIT"
] | 45 | 2018-11-08T20:41:21.000Z | 2022-03-15T00:53:28.000Z | /* MIT License
*
* Copyright (c) 2018 Sam Kovaka <skovaka@gmail.com>
*
* 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 _INCL_READ_SEED_TRACKER
#define _INCL_READ_SEED_TRACKER
#include <set>
#include <vector>
#include <iostream>
#include <algorithm>
#include "util.hpp"
#include "range.hpp"
//typedef struct {
// float min_mean_conf = 6.00;
// float min_top_conf = 1.85;
//} TrackerParams;
class SeedCluster {
//TODO: privatize
public:
u64 ref_st_;
Range ref_en_;
u32 evt_st_,
evt_en_,
total_len_;
#ifdef DEBUG_SEEDS
u32 id_;
#endif
SeedCluster(Range ref_st, u32 evt_st);
//SeedCluster(const SeedCluster &r);
SeedCluster();
u64 ref_start_base() const;
u8 update(SeedCluster &new_seed);
void print(std::ostream &out, bool newline, bool print_all) const;
Range ref_range() const;
bool is_valid();
friend bool operator< (const SeedCluster &q1, const SeedCluster &q2);
friend std::ostream &operator<< (std::ostream &out, const SeedCluster &a);
};
const SeedCluster NULL_ALN = SeedCluster();
bool operator< (const SeedCluster &q1, const SeedCluster &q2);
std::ostream &operator<< (std::ostream &out, const SeedCluster &a);
class SeedTracker {
public:
typedef struct {
u32 min_map_len;
float min_mean_conf;
float min_top_conf;
} Params;
static const Params PRMS_DEF;
Params PRMS;
std::set<SeedCluster> seed_clusters_;
std::multiset<u32> all_lens_;
SeedCluster max_map_;
float len_sum_;
SeedTracker();
SeedTracker(Params params);
//SeedCluster add_seed(SeedCluster sg);
const SeedCluster &add_seed(u64 ref_en, u32 ref_len, u32 evt_st);
SeedCluster get_final();
SeedCluster get_best();
float get_top_conf();
float get_mean_conf();
bool empty();
void reset();
std::vector<SeedCluster> get_alignments(u8 min_len);
bool check_ratio(const SeedCluster &s, float ratio);
bool check_map_conf(u32 seed_len, float mean_len, float second_len);
void print(std::ostream &out, u16 max_out);
};
#endif
| 27.893805 | 81 | 0.708439 | skovaka |
8df794657ea1e8fd0e2b6a33f6c7ce1c0ce1cd09 | 671 | hh | C++ | hefur/scrape-response.hh | sot-tech/hefur | 6307015793ef4b24f0124c393c0e6f3a573a3590 | [
"MIT"
] | 126 | 2015-02-16T13:14:03.000Z | 2022-03-27T14:46:19.000Z | hefur/scrape-response.hh | sot-tech/hefur | 6307015793ef4b24f0124c393c0e6f3a573a3590 | [
"MIT"
] | 35 | 2015-03-31T20:20:34.000Z | 2022-02-02T13:55:36.000Z | hefur/scrape-response.hh | sot-tech/hefur | 6307015793ef4b24f0124c393c0e6f3a573a3590 | [
"MIT"
] | 31 | 2015-05-28T02:04:48.000Z | 2022-02-02T13:48:03.000Z | #pragma once
#include <string>
#include <vector>
#include <mimosa/ref-countable.hh>
#include "info-hash.hh"
#include "namespace-helper.hh"
namespace hefur {
/**
* This class represents a scrape response.
* It is used by both http(s) server and upd server.
*/
struct ScrapeResponse : public m::RefCountable<ScrapeResponse> {
MIMOSA_DEF_PTR(ScrapeResponse);
bool error_;
std::string error_msg_;
struct Item {
InfoHash info_hash_;
uint32_t nleechers_;
uint32_t nseeders_;
uint32_t ndownloaded_;
};
uint32_t interval_;
std::vector<Item> items_;
};
} // namespace hefur
| 20.333333 | 67 | 0.643815 | sot-tech |
8dfaf13cc05e1dfeded6c3df3248b9cf8d9854cb | 6,139 | hpp | C++ | Controllers/UART/stm32f1_UART.hpp | 7bnx/Embedded | afb83151500b27066b571336c32aaddd9fa97fd7 | [
"MIT"
] | null | null | null | Controllers/UART/stm32f1_UART.hpp | 7bnx/Embedded | afb83151500b27066b571336c32aaddd9fa97fd7 | [
"MIT"
] | null | null | null | Controllers/UART/stm32f1_UART.hpp | 7bnx/Embedded | afb83151500b27066b571336c32aaddd9fa97fd7 | [
"MIT"
] | null | null | null | //----------------------------------------------------------------------------------
// Author: Semyon Ivanov
// e-mail: agreement90@mail.ru
// github: https://github.com/7bnx/Embedded
// Description: Driver for UART. STM32F1-series
// TODO:
//----------------------------------------------------------------------------------
#ifndef _STM32F1_UART_HPP
#define _STM32F1_UART_HPP
#include "stm32f1_UART_Helper.hpp"
/*!
@brief Controller's peripherals devices
*/
namespace controller{
/*!
@brief UART1 interface
@tparam <txBufferSize> size of tx buffer
@tparam <txBufferSize> size of rx buffer
@tparam <comm> communication type - via DMA or ISR. Default TX and RX via DMA
@tparam <mode> default mode is none parity, 8 data-bits, 1 stop-bit
@tparam <remap> remap pins of UART
*/
template<size_t txBufferSize, size_t rxBufferSize,
configuration::uart::communication comm = configuration::uart::communication::txDMA_rxDMA,
configuration::uart::mode mode = configuration::uart::mode::E_8_1,
configuration::uart::remap remap = configuration::uart::remap::None>
class UART1 : public helper::uart::Helper<UART1<txBufferSize, rxBufferSize, comm, mode, remap>,
1, txBufferSize, rxBufferSize, comm, mode, remap>{
protected:
using base = helper::uart::Helper<UART1<txBufferSize, rxBufferSize, comm, mode, remap>,
1, txBufferSize, rxBufferSize, comm, mode, remap>;
static constexpr uint32_t remapValue = remap == configuration::uart::remap::None ? 0 : 0x211;
static constexpr uint32_t dmaID = 1;
static constexpr uint32_t channelDMATX = 4;
static constexpr uint32_t channelDMARX = 5;
static constexpr uint32_t baseAddress = 0x40013800;
friend base;
struct pins{
using TX = std::conditional_t<remap == configuration::uart::remap::None, Pin::PA_9, Pin::PB_6>;
using RX = std::conditional_t<remap == configuration::uart::remap::None, Pin::PA_10, Pin::PB_7>;
};
struct power{
static constexpr uint32_t
UART1EN = 1 << 14,
UARTEN = 0,
DMAEN = 1;
};
struct irq{
static constexpr uint32_t
UART = 37,
DMATX = 14,
DMARX = 15;
};
static_assert(remap != configuration::uart::remap::Full, "UART1 has no full remap");
};
/*!
@brief UART2 interface
@tparam <txBufferSize> size of tx buffer
@tparam <txBufferSize> size of rx buffer
@tparam <comm> communication type - via DMA or ISR. Default TX and RX via DMA
@tparam <mode> default mode is none parity, 8 data-bits, 1 stop-bit
@tparam <remap> remap pins of UART
*/
template<size_t txBufferSize, size_t rxBufferSize,
configuration::uart::communication comm = configuration::uart::communication::txDMA_rxDMA,
configuration::uart::mode mode = configuration::uart::mode::N_8_1,
configuration::uart::remap remap = configuration::uart::remap::None>
class UART2 : public helper::uart::Helper<UART2<txBufferSize, rxBufferSize, comm, mode, remap>,
2, txBufferSize, rxBufferSize, comm, mode, remap>{
protected:
using base = helper::uart::Helper<UART2<txBufferSize, rxBufferSize, comm, mode, remap>,
2, txBufferSize, rxBufferSize, comm, mode, remap>;
static constexpr uint32_t remapValue = remap == configuration::uart::remap::None ? 0 : 0x311;
static constexpr uint32_t dmaID = 1;
static constexpr uint32_t channelDMATX = 7;
static constexpr uint32_t channelDMARX = 6;
static constexpr uint32_t baseAddress = 0x40004400;
struct pins{
using TX = std::conditional_t<remap == configuration::uart::remap::None, Pin::PA_2, Pin::PD_5>;
using RX = std::conditional_t<remap == configuration::uart::remap::None, Pin::PA_3, Pin::PD_6>;
};
struct power{
static constexpr uint32_t
UART1EN = 0,
UARTEN = 0x20000,
DMAEN = 1;
};
struct irq{
static constexpr uint32_t
UART = 38,
DMATX = 17,
DMARX = 16;
};
friend base;
static_assert(remap != configuration::uart::remap::Full, "UART2 has no full remap");
};
/*!
@brief UART3 interface
@tparam <txBufferSize> size of tx buffer
@tparam <txBufferSize> size of rx buffer
@tparam <comm> communication type - via DMA or ISR. Default TX and RX via DMA
@tparam <mode> default mode is none parity, 8 data-bits, 1 stop-bit
@tparam <remap> remap pins of UART
*/
template<size_t txBufferSize, size_t rxBufferSize,
configuration::uart::communication comm = configuration::uart::communication::txDMA_rxDMA,
configuration::uart::mode mode = configuration::uart::mode::N_8_1,
configuration::uart::remap remap = configuration::uart::remap::None>
class UART3 : public helper::uart::Helper<UART3<txBufferSize, rxBufferSize, comm, mode, remap>,
3, txBufferSize, rxBufferSize, comm, mode, remap>{
protected:
using base = helper::uart::Helper<UART3<txBufferSize, rxBufferSize, comm, mode, remap>,
3, txBufferSize, rxBufferSize, comm, mode, remap>;
static constexpr uint32_t remapValue = remap == configuration::uart::remap::None ? 0 :
remap == configuration::uart::remap::Partial ? 0x411 : 0x412;
static constexpr uint32_t dmaID = 1;
static constexpr uint32_t channelDMATX = 2;
static constexpr uint32_t channelDMARX = 3;
static constexpr uint32_t baseAddress = 0x40004800;
struct pins{
using TX = std::conditional_t<remap == configuration::uart::remap::None, Pin::PB_10,
std::conditional_t<remap == configuration::uart::remap::Partial, Pin::PC_10, Pin::PD_8>>;
using RX = std::conditional_t<remap == configuration::uart::remap::None, Pin::PB_11,
std::conditional_t<remap == configuration::uart::remap::Partial, Pin::PC_11, Pin::PD_9>>;
};
struct power{
static constexpr uint32_t
UART1EN = 0,
UARTEN = 0x40000,
DMAEN = 1;
};
struct irq{
static constexpr uint32_t
UART = 39,
DMATX = 12,
DMARX = 13;
};
friend base;
};
} // !namspace controller
#endif //!_STM32F1_UART_HPP | 34.488764 | 104 | 0.653364 | 7bnx |
8dfb853f14d950344cfe17a994815eb3fb5015d6 | 1,997 | cpp | C++ | Engine/sdk/src/lwDirectoryBrowser.cpp | ruuuubi/corsairs-client | ddbcd293d6ef3f58ff02290c02382cbb7e0939a2 | [
"Apache-2.0"
] | 1 | 2021-06-14T09:34:08.000Z | 2021-06-14T09:34:08.000Z | Engine/sdk/src/lwDirectoryBrowser.cpp | ruuuubi/corsairs-client | ddbcd293d6ef3f58ff02290c02382cbb7e0939a2 | [
"Apache-2.0"
] | null | null | null | Engine/sdk/src/lwDirectoryBrowser.cpp | ruuuubi/corsairs-client | ddbcd293d6ef3f58ff02290c02382cbb7e0939a2 | [
"Apache-2.0"
] | null | null | null | //
#include "lwDirectoryBrowser.h"
LW_BEGIN
// lwDirectoryBrowser
LW_STD_IMPLEMENTATION(lwDirectoryBrowser)
lwDirectoryBrowser::lwDirectoryBrowser()
: _proc(0), _param(0)
{
}
LW_RESULT lwDirectoryBrowser::_Go(const char* file, DWORD flag)
{
LW_RESULT ret = LW_RET_OK;
WIN32_FIND_DATA wfd;
HANDLE handle = ::FindFirstFile(file, &wfd);
if(handle == INVALID_HANDLE_VALUE)
goto __ret;
char file_path[260];
char file_spec[64];
strcpy(file_path, file);
char* p = strrchr(file_path, '\\');
if(p == 0)
goto __ret;
strcpy(file_spec, &p[1]);
p[1] = '\0';
do
{
if(wfd.cFileName[0] == '.')
{
if((wfd.cFileName[1] == '\0')
|| (wfd.cFileName[1] == '.' && wfd.cFileName[2] == '\0'))
{
continue;
}
}
if((!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) && (flag & DIR_BROWSE_FILE))
{
if(LW_FAILED((*_proc)(file_path, &wfd, _param)))
{
ret = LW_RET_OK_1;
goto __ret;
}
}
else if((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && (flag & DIR_BROWSE_DIRECTORY))
{
if(LW_FAILED((*_proc)(file_path, &wfd, _param)))
{
ret = LW_RET_OK_1;
goto __ret;
}
char sub_file[260];
sprintf(sub_file, "%s%s\\%s", file_path, wfd.cFileName, file_spec);
if((ret = _Go(sub_file, flag)) == LW_RET_OK_1)
goto __ret;
}
} while(::FindNextFile(handle, &wfd));
__ret:
::FindClose(handle);
return ret;
}
LW_RESULT lwDirectoryBrowser::Browse(const char *file, DWORD flag)
{
LW_RESULT ret = LW_RET_FAILED;
if(_proc == 0)
goto __ret;
//char* p = strrchr(file, '\\');
//if((p == 0) || (p[1] == '\0'))
// goto __ret;
ret = _Go(file, flag);
__ret:
return ret;
}
LW_END
| 20.377551 | 99 | 0.522784 | ruuuubi |
5c03011bc9dfc923634572952542be6a6434e68b | 4,381 | hh | C++ | trex/utils/TREXversion.hh | miatauro/trex2-agent | d896f8335f3194237a8bba49949e86f5488feddb | [
"BSD-3-Clause"
] | null | null | null | trex/utils/TREXversion.hh | miatauro/trex2-agent | d896f8335f3194237a8bba49949e86f5488feddb | [
"BSD-3-Clause"
] | null | null | null | trex/utils/TREXversion.hh | miatauro/trex2-agent | d896f8335f3194237a8bba49949e86f5488feddb | [
"BSD-3-Clause"
] | null | null | null | /*********************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, MBARI.
* All rights reserved.
*
* 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 name of the TREX Project 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.
*/
#ifndef H_TREXversion
# define H_TREXversion
# include <string>
namespace TREX {
/** @brief Core libraries version information
*
* This simple class lows to access to information about the current TREX
* version of TREX core libararies
*
* @ingroup utils
* @author Frederic Py <fpy@mbari.org>
*/
class version {
public:
version() {}
~version() {}
/** @brief version number
*
* Indicates the version number of this library. This version number follows
* the same nomenclature as th boost versionning and is guaranteed to
* increase as we have new versions.
*
* @return 100*(100*major()+minor())+release()
* @sa major()
* @sa minor()
* @sa release()
* @sa is_release_candidate()
* @sa str()
*
* @note For backward compatibility reasons -- along with the fact
* that sorting versions numbers encoded as int with RC is not trivial
* -- this number @e do @e not include the rc number. RC number should
* be tested aside knowing that 0.4.0-rc1 < 0.4.0-rc2 < ... < 0.4.0
*/
static unsigned long number();
/** @brief Major version number
* @return the major version number
*/
static unsigned short major_number();
/** @brief Minor version number
* @return the minor version number
*/
static unsigned short minor_number();
/** @brief Patch version number
* @return the patch version number
*/
static unsigned short release_number();
/** @brief Check if reelase candidate
*
* Checks if this version is a release cnadidate or not
* @sa rc_number()
*/
static bool is_release_candidate();
/** @brief release cancdidate version
*
* @return The release candidate version number for this version or 0
* if this version is not an RC
* @sa is_release_candidate()
*/
static unsigned rc_number();
/** @brief Human readable version
*
* Indicates the version number as a human readable string
* the string is formatted the usual way :
* @<major@>.@<minor@>.@<patch@>[-rc@<rc@>]
*
* @return The string value for this version
* @sa major()
* @sa minor()
* @sa release()
* @sa rc_number()
* @sa number()
*/
static std::string str();
static std::string full_str();
static bool svn_info();
static std::string svn_root();
static std::string svn_revision();
static bool git_info();
static std::string git_branch();
static std::string git_revision();
}; // TREX::version
} // TREX
#endif // H_TREXversion
| 33.7 | 81 | 0.654645 | miatauro |
5c03a0afcb3da8116e6961d6dfe22c7715c5c4ab | 2,845 | cc | C++ | mojo/services/native_viewport/native_viewport_android.cc | cvsuser-chromium/chromium | acb8e8e4a7157005f527905b48dd48ddaa3b863a | [
"BSD-3-Clause"
] | 4 | 2017-04-05T01:51:34.000Z | 2018-02-15T03:11:54.000Z | mojo/services/native_viewport/native_viewport_android.cc | cvsuser-chromium/chromium | acb8e8e4a7157005f527905b48dd48ddaa3b863a | [
"BSD-3-Clause"
] | 1 | 2021-12-13T19:44:12.000Z | 2021-12-13T19:44:12.000Z | mojo/services/native_viewport/native_viewport_android.cc | cvsuser-chromium/chromium | acb8e8e4a7157005f527905b48dd48ddaa3b863a | [
"BSD-3-Clause"
] | 4 | 2017-04-05T01:52:03.000Z | 2022-02-13T17:58:45.000Z | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "mojo/services/native_viewport/native_viewport_android.h"
#include <android/native_window_jni.h>
#include "mojo/services/native_viewport/android/mojo_viewport.h"
#include "mojo/shell/context.h"
#include "ui/events/event.h"
#include "ui/gfx/point.h"
namespace mojo {
namespace services {
NativeViewportAndroid::NativeViewportAndroid(shell::Context* context,
NativeViewportDelegate* delegate)
: delegate_(delegate),
context_(context),
window_(NULL),
id_generator_(0),
weak_factory_(this) {
}
NativeViewportAndroid::~NativeViewportAndroid() {
if (window_)
ReleaseWindow();
}
void NativeViewportAndroid::OnNativeWindowCreated(ANativeWindow* window) {
DCHECK(!window_);
window_ = window;
delegate_->OnAcceleratedWidgetAvailable(window_);
}
void NativeViewportAndroid::OnNativeWindowDestroyed() {
DCHECK(window_);
ReleaseWindow();
}
void NativeViewportAndroid::OnResized(const gfx::Size& size) {
size_ = size;
delegate_->OnResized(size);
}
void NativeViewportAndroid::OnTouchEvent(int pointer_id,
ui::EventType action,
float x, float y,
int64 time_ms) {
gfx::Point location(static_cast<int>(x), static_cast<int>(y));
ui::TouchEvent event(action, location,
id_generator_.GetGeneratedID(pointer_id),
base::TimeDelta::FromMilliseconds(time_ms));
// TODO(beng): handle multiple touch-points.
delegate_->OnEvent(&event);
if (action == ui::ET_TOUCH_RELEASED)
id_generator_.ReleaseNumber(pointer_id);
}
void NativeViewportAndroid::ReleaseWindow() {
ANativeWindow_release(window_);
window_ = NULL;
}
gfx::Size NativeViewportAndroid::GetSize() {
return size_;
}
void NativeViewportAndroid::Init() {
MojoViewportInit* init = new MojoViewportInit();
init->ui_runner = context_->task_runners()->ui_runner();
init->native_viewport = GetWeakPtr();
context_->task_runners()->java_runner()->PostTask(FROM_HERE,
base::Bind(MojoViewport::CreateForActivity,
context_->activity(),
init));
}
void NativeViewportAndroid::Close() {
// TODO(beng): close activity containing MojoView?
// TODO(beng): perform this in response to view destruction.
delegate_->OnDestroyed();
}
// static
scoped_ptr<NativeViewport> NativeViewport::Create(
shell::Context* context,
NativeViewportDelegate* delegate) {
return scoped_ptr<NativeViewport>(
new NativeViewportAndroid(context, delegate)).Pass();
}
} // namespace services
} // namespace mojo
| 29.329897 | 78 | 0.683304 | cvsuser-chromium |
5c05bda0a11c0cbacefed0d2d310cb395808b744 | 6,900 | hxx | C++ | opencascade/IGESDraw_ConnectPoint.hxx | mgreminger/OCP | 92eacb99497cd52b419c8a4a8ab0abab2330ed42 | [
"Apache-2.0"
] | null | null | null | opencascade/IGESDraw_ConnectPoint.hxx | mgreminger/OCP | 92eacb99497cd52b419c8a4a8ab0abab2330ed42 | [
"Apache-2.0"
] | null | null | null | opencascade/IGESDraw_ConnectPoint.hxx | mgreminger/OCP | 92eacb99497cd52b419c8a4a8ab0abab2330ed42 | [
"Apache-2.0"
] | null | null | null | // Created on: 1993-01-11
// Created by: CKY / Contract Toubro-Larsen ( Niraj RANGWALA )
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IGESDraw_ConnectPoint_HeaderFile
#define _IGESDraw_ConnectPoint_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_XYZ.hxx>
#include <Standard_Integer.hxx>
#include <IGESData_IGESEntity.hxx>
#include <Standard_Boolean.hxx>
class TCollection_HAsciiString;
class IGESGraph_TextDisplayTemplate;
class gp_Pnt;
class IGESDraw_ConnectPoint;
DEFINE_STANDARD_HANDLE(IGESDraw_ConnectPoint, IGESData_IGESEntity)
//! defines IGESConnectPoint, Type <132> Form Number <0>
//! in package IGESDraw
//!
//! Connect Point Entity describes a point of connection for
//! zero, one or more entities. Its referenced from Composite
//! curve, or Network Subfigure Definition/Instance, or Flow
//! Associative Instance, or it may stand alone.
class IGESDraw_ConnectPoint : public IGESData_IGESEntity
{
public:
Standard_EXPORT IGESDraw_ConnectPoint();
//! This method is used to set the fields of the class
//! ConnectPoint
//! - aPoint : A Coordinate point
//! - aDisplaySymbol : Display symbol Geometry
//! - aTypeFlag : Type of the connection
//! - aFunctionFlag : Function flag for the connection
//! - aFunctionIdentifier : Connection Point Function Identifier
//! - anIdentifierTemplate : Connection Point Function Template
//! - aFunctionName : Connection Point Function Name
//! - aFunctionTemplate : Connection Point Function Template
//! - aPointIdentifier : Unique Connect Point Identifier
//! - aFunctionCode : Connect Point Function Code
//! - aSwapFlag : Connect Point Swap Flag
//! - anOwnerSubfigure : Pointer to the "Owner" Entity
Standard_EXPORT void Init (const gp_XYZ& aPoint, const Handle(IGESData_IGESEntity)& aDisplaySymbol, const Standard_Integer aTypeFlag, const Standard_Integer aFunctionFlag, const Handle(TCollection_HAsciiString)& aFunctionIdentifier, const Handle(IGESGraph_TextDisplayTemplate)& anIdentifierTemplate, const Handle(TCollection_HAsciiString)& aFunctionName, const Handle(IGESGraph_TextDisplayTemplate)& aFunctionTemplate, const Standard_Integer aPointIdentifier, const Standard_Integer aFunctionCode, const Standard_Integer aSwapFlag, const Handle(IGESData_IGESEntity)& anOwnerSubfigure);
//! returns the coordinate of the connection point
Standard_EXPORT gp_Pnt Point() const;
//! returns the Transformed coordinate of the connection point
Standard_EXPORT gp_Pnt TransformedPoint() const;
//! returns True if Display symbol is specified
//! else returns False
Standard_EXPORT Standard_Boolean HasDisplaySymbol() const;
//! if display symbol specified returns display symbol geometric entity
//! else returns NULL Handle
Standard_EXPORT Handle(IGESData_IGESEntity) DisplaySymbol() const;
//! return value specifies a particular type of connection :
//! Type Flag = 0 : Not Specified(default)
//! 1 : Nonspecific logical point of connection
//! 2 : Nonspecific physical point of connection
//! 101 : Logical component pin
//! 102 : Logical part connector
//! 103 : Logical offpage connector
//! 104 : Logical global signal connector
//! 201 : Physical PWA surface mount pin
//! 202 : Physical PWA blind pin
//! 203 : Physical PWA thru-pin
//! 5001-9999 : Implementor defined.
Standard_EXPORT Standard_Integer TypeFlag() const;
//! returns Function Code that specifies a particular function for the
//! ECO576 connection :
//! e.g., Function Flag = 0 : Unspecified(default)
//! = 1 : Electrical Signal
//! = 2 : Fluid flow Signal
Standard_EXPORT Standard_Integer FunctionFlag() const;
//! return HAsciiString identifying Pin Number or Nozzle Label etc.
Standard_EXPORT Handle(TCollection_HAsciiString) FunctionIdentifier() const;
//! returns True if Text Display Template is specified for Identifier
//! else returns False
Standard_EXPORT Standard_Boolean HasIdentifierTemplate() const;
//! if Text Display Template for the Function Identifier is defined,
//! returns TestDisplayTemplate
//! else returns NULL Handle
Standard_EXPORT Handle(IGESGraph_TextDisplayTemplate) IdentifierTemplate() const;
//! returns Connection Point Function Name
Standard_EXPORT Handle(TCollection_HAsciiString) FunctionName() const;
//! returns True if Text Display Template is specified for Function Name
//! else returns False
Standard_EXPORT Standard_Boolean HasFunctionTemplate() const;
//! if Text Display Template for the Function Name is defined,
//! returns TestDisplayTemplate
//! else returns NULL Handle
Standard_EXPORT Handle(IGESGraph_TextDisplayTemplate) FunctionTemplate() const;
//! returns the Unique Connect Point Identifier
Standard_EXPORT Standard_Integer PointIdentifier() const;
//! returns the Connect Point Function Code
Standard_EXPORT Standard_Integer FunctionCode() const;
//! return value = 0 : Connect point may be swapped(default)
//! = 1 : Connect point may not be swapped
Standard_EXPORT Standard_Boolean SwapFlag() const;
//! returns True if Network Subfigure Instance/Definition Entity
//! is specified
//! else returns False
Standard_EXPORT Standard_Boolean HasOwnerSubfigure() const;
//! returns "owner" Network Subfigure Instance Entity,
//! or Network Subfigure Definition Entity, or NULL Handle.
Standard_EXPORT Handle(IGESData_IGESEntity) OwnerSubfigure() const;
DEFINE_STANDARD_RTTIEXT(IGESDraw_ConnectPoint,IGESData_IGESEntity)
protected:
private:
gp_XYZ thePoint;
Handle(IGESData_IGESEntity) theDisplaySymbol;
Standard_Integer theTypeFlag;
Standard_Integer theFunctionFlag;
Handle(TCollection_HAsciiString) theFunctionIdentifier;
Handle(IGESGraph_TextDisplayTemplate) theIdentifierTemplate;
Handle(TCollection_HAsciiString) theFunctionName;
Handle(IGESGraph_TextDisplayTemplate) theFunctionTemplate;
Standard_Integer thePointIdentifier;
Standard_Integer theFunctionCode;
Standard_Boolean theSwapFlag;
Handle(IGESData_IGESEntity) theOwnerSubfigure;
};
#endif // _IGESDraw_ConnectPoint_HeaderFile
| 38.333333 | 587 | 0.764058 | mgreminger |
5c067dd63fa6130932813091b35e04c5de4f95da | 1,163 | cpp | C++ | src/operator/detectors/opencv_face_detector.cpp | ccanel/saf | 5bc296e352419ae3688eb51dded72154f732127e | [
"Apache-2.0"
] | 28 | 2018-09-06T19:18:27.000Z | 2022-02-10T05:56:08.000Z | src/operator/detectors/opencv_face_detector.cpp | ccanel/saf | 5bc296e352419ae3688eb51dded72154f732127e | [
"Apache-2.0"
] | 13 | 2018-09-13T13:41:53.000Z | 2021-05-12T01:18:36.000Z | src/operator/detectors/opencv_face_detector.cpp | ccanel/saf | 5bc296e352419ae3688eb51dded72154f732127e | [
"Apache-2.0"
] | 14 | 2018-09-06T14:33:37.000Z | 2021-05-22T20:07:45.000Z | // Copyright 2018 The SAF 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 "operator/detectors/opencv_face_detector.h"
bool OpenCVFaceDetector::Init() {
return classifier_.load(model_desc_.GetModelParamsPath());
}
std::vector<ObjectInfo> OpenCVFaceDetector::Detect(const cv::Mat& image) {
std::vector<ObjectInfo> result;
std::vector<cv::Rect> rects;
classifier_.detectMultiScale(image, rects);
for (const auto& m : rects) {
ObjectInfo object_info;
object_info.tag = "face";
object_info.bbox = m;
object_info.confidence = 1.0;
result.push_back(object_info);
}
return result;
}
| 32.305556 | 75 | 0.734308 | ccanel |
5c08ce28e508537c679695090e5706aa0ba58a56 | 1,950 | hpp | C++ | xxhr/session.hpp | jamesgrantham/xxhr | 0d33abce7e87bb8b78141fcf6f918158a436660c | [
"MIT"
] | 15 | 2017-03-13T08:19:27.000Z | 2022-02-02T21:18:57.000Z | xxhr/session.hpp | jamesgrantham/xxhr | 0d33abce7e87bb8b78141fcf6f918158a436660c | [
"MIT"
] | 6 | 2018-06-29T12:00:12.000Z | 2021-12-17T19:45:47.000Z | xxhr/session.hpp | jamesgrantham/xxhr | 0d33abce7e87bb8b78141fcf6f918158a436660c | [
"MIT"
] | 3 | 2018-09-28T00:37:29.000Z | 2020-12-04T09:05:23.000Z | #ifndef XXHR_SESSION_H
#define XXHR_SESSION_H
#include <cstdint>
#include <memory>
#include "auth.hpp"
#include "body.hpp"
#include "cookies.hpp"
#include "xxhrtypes.hpp"
#include "digest.hpp"
#include "max_redirects.hpp"
#include "multipart.hpp"
#include "parameters.hpp"
#include "response.hpp"
#include "timeout.hpp"
#include "handler.hpp"
namespace xxhr {
class Session {
public:
Session();
~Session();
void SetUrl(const Url& url);
void SetParameters(const Parameters& parameters);
void SetParameters(Parameters&& parameters);
void SetHeader(const Header& header);
void SetTimeout(const Timeout& timeout);
void SetAuth(const Authentication& auth);
void SetDigest(const Digest& auth);
void SetMultipart(Multipart&& multipart);
void SetMultipart(const Multipart& multipart);
void SetRedirect(const bool& redirect);
void SetMaxRedirects(const MaxRedirects& max_redirects);
void SetCookies(const Cookies& cookies);
void SetBody(Body&& body);
void SetBody(const Body& body);
// Used in templated functions
void SetOption(const Url& url);
void SetOption(const Parameters& parameters);
void SetOption(Parameters&& parameters);
void SetOption(const Header& header);
void SetOption(const Timeout& timeout);
void SetOption(const Authentication& auth);
void SetOption(const Digest& auth);
void SetOption(Multipart&& multipart);
void SetOption(const Multipart& multipart);
void SetOption(const bool& redirect);
void SetOption(const MaxRedirects& max_redirects);
void SetOption(const Cookies& cookies);
void SetOption(Body&& body);
void SetOption(const Body& body);
template<class Handler>
void SetOption(const on_response_<Handler>&& on_response);
void DELETE_();
void GET();
void HEAD();
void OPTIONS();
void PATCH();
void POST();
void PUT();
class Impl;
private:
std::shared_ptr<Impl> pimpl_;
};
} // namespace xxhr
#include <xxhr/impl/session.hpp>
#endif
| 25 | 60 | 0.73641 | jamesgrantham |
5c099ecdff969eb49657fa26055ec0e53a52cc6f | 3,865 | hpp | C++ | src/parsers/parser_blat.hpp | danielnavarrogomez/Anaquin | 563dbeb25aff15a55e4309432a967812cbfa0c98 | [
"BSD-3-Clause"
] | null | null | null | src/parsers/parser_blat.hpp | danielnavarrogomez/Anaquin | 563dbeb25aff15a55e4309432a967812cbfa0c98 | [
"BSD-3-Clause"
] | null | null | null | src/parsers/parser_blat.hpp | danielnavarrogomez/Anaquin | 563dbeb25aff15a55e4309432a967812cbfa0c98 | [
"BSD-3-Clause"
] | null | null | null | #ifndef PARSER_BLAT_HPP
#define PARSER_BLAT_HPP
#include <functional>
#include "data/data.hpp"
#include "data/reader.hpp"
#include "data/tokens.hpp"
#include "parsers/parser.hpp"
#include <boost/algorithm/string.hpp>
#include <iostream>
namespace Anaquin
{
struct ParserBlat
{
enum Field
{
PSL_Matches,
PSL_MisMatches,
PSL_RepMatches,
PSL_NCount,
PSL_QGap_Count,
PSL_QGap_Bases,
PSL_TGap_Count,
PSL_TGap_Bases,
PSL_Strand,
PSL_QName,
PSL_QSize,
PSL_QStart,
PSL_QEnd,
PSL_TName,
PSL_TSize,
PSL_TStart,
PSL_TEnd,
PSL_Block_Count,
PSL_Block_Sizes,
PSL_Q_Starts,
PSL_T_Starts
};
struct Data
{
// Target sequence name
std::string tName;
// Query sequence name
std::string qName;
// Alignment start position in target
Base tStart;
// Alignment end position in target
Base tEnd;
// Target sequence size
Base tSize;
// Alignment start position in query
Base qStart;
// Alignment end position in query
Base qEnd;
// Query sequence size
Base qSize;
// Number of inserts in query
Counts qGapCount;
// Number of bases inserted into query
Base qGap;
// Number of inserts in target
Counts tGapCount;
// Number of bases inserted into target
Base tGap;
// Number of matching bases
Base match;
// Number of mismatching bases
Base mismatch;
};
template <typename F> static void parse(const Reader &r, F f)
{
protectParse("PSL format", [&]()
{
ParserProgress p;
std::string line;
std::vector<std::string> toks;
Data l;
while (r.nextLine(line))
{
if (p.i++ <= 3)
{
continue;
}
Tokens::split(line, "\t", toks);
if (toks.size() != 21)
{
throw std::runtime_error("Invalid line: " + line);
}
l.qName = toks[PSL_QName];
l.tName = toks[PSL_TName];
l.tStart = stoi(toks[PSL_TStart]);
l.tEnd = stoi(toks[PSL_TEnd]);
l.tSize = stoi(toks[PSL_TSize]);
l.qStart = stoi(toks[PSL_QStart]);
l.qEnd = stoi(toks[PSL_QEnd]);
l.qSize = stoi(toks[PSL_QSize]);
l.match = stoi(toks[PSL_Matches]);
l.mismatch = stoi(toks[PSL_MisMatches]);
l.qGap = stoi(toks[PSL_QGap_Bases]);
l.tGap = stoi(toks[PSL_TGap_Bases]);
l.qGapCount = stoi(toks[PSL_QGap_Count]);
l.tGapCount = stoi(toks[PSL_TGap_Count]);
f(l);
}
});
}
};
}
#endif
| 27.805755 | 74 | 0.398189 | danielnavarrogomez |
5c0ae9e77e1f600db070b10913a9ef27abb15c09 | 843 | cpp | C++ | runtime/src/aderite/scripting/InternalCalls.cpp | nfwGytautas/aderite | 87a6a5c24a6dcaca80088cb7a4fca1f846a7f22c | [
"MIT"
] | null | null | null | runtime/src/aderite/scripting/InternalCalls.cpp | nfwGytautas/aderite | 87a6a5c24a6dcaca80088cb7a4fca1f846a7f22c | [
"MIT"
] | null | null | null | runtime/src/aderite/scripting/InternalCalls.cpp | nfwGytautas/aderite | 87a6a5c24a6dcaca80088cb7a4fca1f846a7f22c | [
"MIT"
] | null | null | null | #include "InternalCalls.hpp"
#include "aderite/scripting/internals/ScriptAudio.hpp"
#include "aderite/scripting/internals/ScriptComponents.hpp"
#include "aderite/scripting/internals/ScriptDebug.hpp"
#include "aderite/scripting/internals/ScriptEntity.hpp"
#include "aderite/scripting/internals/ScriptInput.hpp"
#include "aderite/scripting/internals/ScriptPhysics.hpp"
#include "aderite/scripting/internals/ScriptSystemInternals.hpp"
#include "aderite/utility/Log.hpp"
namespace aderite {
namespace scripting {
void linkInternals() {
LOG_TRACE("[Scripting] Linking internals");
logInternals();
componentInternals();
entityInternals();
inputInternals();
physicsInternals();
audioInternals();
systemInternals();
LOG_TRACE("[Scripting] Internals linked");
}
} // namespace scripting
} // namespace aderite
| 27.193548 | 64 | 0.766311 | nfwGytautas |
5c0f1d6b70455ebc9f373d60620e9c2911c86c1e | 1,054 | cc | C++ | game/src/gui/app/layout_helper.cc | chunseoklee/mengde | 7261e45dab9e02d4bf18b4542767f4b50a5616a0 | [
"MIT"
] | 1 | 2018-03-02T03:36:59.000Z | 2018-03-02T03:36:59.000Z | game/src/gui/app/layout_helper.cc | chunseoklee/mengde | 7261e45dab9e02d4bf18b4542767f4b50a5616a0 | [
"MIT"
] | 1 | 2018-04-17T01:43:02.000Z | 2018-04-17T01:43:02.000Z | game/src/gui/app/layout_helper.cc | chunseoklee/mengde | 7261e45dab9e02d4bf18b4542767f4b50a5616a0 | [
"MIT"
] | null | null | null | #include "layout_helper.h"
#include "gui/foundation/rect.h"
#include "util/common.h"
namespace mengde {
namespace gui {
namespace app {
namespace layout {
Vec2D CalcPositionNearUnit(Vec2D element_size, Vec2D frame_size, Vec2D camera_coords, Vec2D unit_cell) {
const int kCellSize = 48; // FIXME hardcoded cell size
Vec2D cands[] = {(unit_cell * kCellSize - Vec2D(element_size.x, 0)),
(unit_cell * kCellSize - Vec2D(element_size.x - kCellSize, element_size.y)),
(unit_cell * kCellSize + Vec2D(kCellSize, kCellSize - element_size.y)),
(unit_cell * kCellSize + Vec2D(0, kCellSize))};
Rect frame({0, 0}, frame_size);
for (auto e : cands) {
Vec2D calc_lt = e - camera_coords;
Vec2D calc_rb = calc_lt + element_size;
if (frame.Contains(calc_lt) && frame.Contains(calc_rb)) {
return calc_lt;
}
}
UNREACHABLE("Cannot arrange with given criteria");
return {0, 0};
}
} // namespace layout
} // namespace app
} // namespace gui
} // namespace mengde
| 30.114286 | 104 | 0.6537 | chunseoklee |
5c0f1e53b302c68dd3a853036f21bd30a77002de | 7,503 | cc | C++ | content/browser/gpu/gpu_data_manager_impl_unittest.cc | junmin-zhu/chromium-rivertrail | eb1a57aca71fe68d96e48af8998dcfbe45171ee1 | [
"BSD-3-Clause"
] | 5 | 2018-03-10T13:08:42.000Z | 2021-07-26T15:02:11.000Z | content/browser/gpu/gpu_data_manager_impl_unittest.cc | sanyaade-mobiledev/chromium.src | d496dfeebb0f282468827654c2b3769b3378c087 | [
"BSD-3-Clause"
] | 1 | 2015-07-21T08:02:01.000Z | 2015-07-21T08:02:01.000Z | content/browser/gpu/gpu_data_manager_impl_unittest.cc | jianglong0156/chromium.src | d496dfeebb0f282468827654c2b3769b3378c087 | [
"BSD-3-Clause"
] | 6 | 2016-11-14T10:13:35.000Z | 2021-01-23T15:29:53.000Z | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/message_loop.h"
#include "base/run_loop.h"
#include "content/browser/gpu/gpu_data_manager_impl.h"
#include "content/public/browser/gpu_data_manager_observer.h"
#include "content/public/common/gpu_info.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace content {
namespace {
class TestObserver : public GpuDataManagerObserver {
public:
TestObserver()
: gpu_info_updated_(false),
video_memory_usage_stats_updated_(false) {
}
virtual ~TestObserver() { }
bool gpu_info_updated() const { return gpu_info_updated_; }
bool video_memory_usage_stats_updated() const {
return video_memory_usage_stats_updated_;
}
virtual void OnGpuInfoUpdate() OVERRIDE {
gpu_info_updated_ = true;
}
virtual void OnVideoMemoryUsageStatsUpdate(
const GPUVideoMemoryUsageStats& stats) OVERRIDE {
video_memory_usage_stats_updated_ = true;
}
private:
bool gpu_info_updated_;
bool video_memory_usage_stats_updated_;
};
} // namespace anonymous
class GpuDataManagerImplTest : public testing::Test {
public:
GpuDataManagerImplTest() { }
virtual ~GpuDataManagerImplTest() { }
protected:
void SetUp() {
}
void TearDown() {
}
MessageLoop message_loop_;
};
// We use new method instead of GetInstance() method because we want
// each test to be independent of each other.
TEST_F(GpuDataManagerImplTest, GpuSideBlacklisting) {
// If a feature is allowed in preliminary step (browser side), but
// disabled when GPU process launches and collects full GPU info,
// it's too late to let renderer know, so we basically block all GPU
// access, to be on the safe side.
GpuDataManagerImpl* manager = new GpuDataManagerImpl();
ASSERT_TRUE(manager);
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
EXPECT_TRUE(manager->GpuAccessAllowed());
const std::string blacklist_json =
"{\n"
" \"name\": \"gpu blacklist\",\n"
" \"version\": \"0.1\",\n"
" \"entries\": [\n"
" {\n"
" \"id\": 1,\n"
" \"blacklist\": [\n"
" \"webgl\"\n"
" ]\n"
" },\n"
" {\n"
" \"id\": 2,\n"
" \"gl_renderer\": {\n"
" \"op\": \"contains\",\n"
" \"value\": \"GeForce\"\n"
" },\n"
" \"blacklist\": [\n"
" \"accelerated_2d_canvas\"\n"
" ]\n"
" }\n"
" ]\n"
"}";
GPUInfo gpu_info;
gpu_info.gpu.vendor_id = 0x10de;
gpu_info.gpu.device_id = 0x0640;
manager->InitializeForTesting(blacklist_json, gpu_info);
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_EQ(GPU_FEATURE_TYPE_WEBGL, manager->GetBlacklistedFeatures());
gpu_info.gl_renderer = "NVIDIA GeForce GT 120";
manager->UpdateGpuInfo(gpu_info);
EXPECT_FALSE(manager->GpuAccessAllowed());
EXPECT_EQ(GPU_FEATURE_TYPE_WEBGL |
GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
manager->GetBlacklistedFeatures());
delete manager;
}
TEST_F(GpuDataManagerImplTest, GpuSideExceptions) {
GpuDataManagerImpl* manager = new GpuDataManagerImpl();
ASSERT_TRUE(manager);
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
EXPECT_TRUE(manager->GpuAccessAllowed());
const std::string blacklist_json =
"{\n"
" \"name\": \"gpu blacklist\",\n"
" \"version\": \"0.1\",\n"
" \"entries\": [\n"
" {\n"
" \"id\": 1,\n"
" \"exceptions\": [\n"
" {\n"
" \"gl_renderer\": {\n"
" \"op\": \"contains\",\n"
" \"value\": \"GeForce\"\n"
" }\n"
" }\n"
" ],\n"
" \"blacklist\": [\n"
" \"webgl\"\n"
" ]\n"
" }\n"
" ]\n"
"}";
GPUInfo gpu_info;
gpu_info.gpu.vendor_id = 0x10de;
gpu_info.gpu.device_id = 0x0640;
manager->InitializeForTesting(blacklist_json, gpu_info);
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
// Now assue gpu process launches and full GPU info is collected.
gpu_info.gl_renderer = "NVIDIA GeForce GT 120";
manager->UpdateGpuInfo(gpu_info);
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
delete manager;
}
TEST_F(GpuDataManagerImplTest, BlacklistCard) {
GpuDataManagerImpl* manager = new GpuDataManagerImpl();
ASSERT_TRUE(manager);
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
EXPECT_TRUE(manager->GpuAccessAllowed());
manager->BlacklistCard();
EXPECT_FALSE(manager->GpuAccessAllowed());
EXPECT_EQ(GPU_FEATURE_TYPE_ALL, manager->GetBlacklistedFeatures());
delete manager;
}
TEST_F(GpuDataManagerImplTest, SoftwareRendering) {
// Blacklist, then register SwiftShader.
GpuDataManagerImpl* manager = new GpuDataManagerImpl();
ASSERT_TRUE(manager);
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
manager->BlacklistCard();
EXPECT_FALSE(manager->GpuAccessAllowed());
EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
// If software rendering is enabled, even if we blacklist GPU,
// GPU process is still allowed.
const FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
manager->RegisterSwiftShaderPath(test_path);
EXPECT_TRUE(manager->ShouldUseSoftwareRendering());
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_EQ(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
manager->GetBlacklistedFeatures());
delete manager;
}
TEST_F(GpuDataManagerImplTest, SoftwareRendering2) {
// Register SwiftShader, then blacklist.
GpuDataManagerImpl* manager = new GpuDataManagerImpl();
ASSERT_TRUE(manager);
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
const FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
manager->RegisterSwiftShaderPath(test_path);
EXPECT_EQ(0, manager->GetBlacklistedFeatures());
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
manager->BlacklistCard();
EXPECT_TRUE(manager->GpuAccessAllowed());
EXPECT_TRUE(manager->ShouldUseSoftwareRendering());
EXPECT_EQ(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
manager->GetBlacklistedFeatures());
delete manager;
}
TEST_F(GpuDataManagerImplTest, GpuInfoUpdate) {
GpuDataManagerImpl* manager = new GpuDataManagerImpl();
ASSERT_TRUE(manager);
TestObserver observer;
manager->AddObserver(&observer);
EXPECT_FALSE(observer.gpu_info_updated());
GPUInfo gpu_info;
manager->UpdateGpuInfo(gpu_info);
base::RunLoop run_loop;
run_loop.RunUntilIdle();
EXPECT_TRUE(observer.gpu_info_updated());
delete manager;
}
TEST_F(GpuDataManagerImplTest, GPUVideoMemoryUsageStatsUpdate) {
GpuDataManagerImpl* manager = new GpuDataManagerImpl();
ASSERT_TRUE(manager);
TestObserver observer;
manager->AddObserver(&observer);
EXPECT_FALSE(observer.video_memory_usage_stats_updated());
GPUVideoMemoryUsageStats vram_stats;
manager->UpdateVideoMemoryUsageStats(vram_stats);
base::RunLoop run_loop;
run_loop.RunUntilIdle();
EXPECT_TRUE(observer.video_memory_usage_stats_updated());
delete manager;
}
} // namespace content
| 28.969112 | 73 | 0.688125 | junmin-zhu |
5c10b75a791fbc11ec0d10e91a4afe139f7b5414 | 14,017 | cc | C++ | mindspore/ccsrc/cxx_api/graph/acl/model_process.cc | GuoSuiming/mindspore | 48afc4cfa53d970c0b20eedfb46e039db2a133d5 | [
"Apache-2.0"
] | 55 | 2020-12-17T10:26:06.000Z | 2022-03-28T07:18:26.000Z | mindspore/ccsrc/cxx_api/graph/acl/model_process.cc | forwhat461/mindspore | 59a277756eb4faad9ac9afcc7fd526e8277d4994 | [
"Apache-2.0"
] | null | null | null | mindspore/ccsrc/cxx_api/graph/acl/model_process.cc | forwhat461/mindspore | 59a277756eb4faad9ac9afcc7fd526e8277d4994 | [
"Apache-2.0"
] | 14 | 2021-01-29T02:39:47.000Z | 2022-03-23T05:00:26.000Z | /**
* Copyright 2020 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 "cxx_api/graph/acl/model_process.h"
#include <sys/time.h>
#include <algorithm>
#include <map>
#include "utils/utils.h"
namespace mindspore::api {
static DataType TransToApiType(aclDataType data_type) {
static const std::map<aclDataType, api::DataType> data_type_map = {
{ACL_FLOAT16, api::kMsFloat16}, {ACL_FLOAT, api::kMsFloat32}, {ACL_DOUBLE, api::kMsFloat64},
{ACL_INT8, api::kMsInt8}, {ACL_INT16, api::kMsInt16}, {ACL_INT32, api::kMsInt32},
{ACL_INT64, api::kMsInt64}, {ACL_UINT8, api::kMsUint8}, {ACL_UINT16, api::kMsUint16},
{ACL_UINT32, api::kMsUint32}, {ACL_UINT64, api::kMsUint64}, {ACL_BOOL, api::kMsBool},
};
auto it = data_type_map.find(data_type);
if (it == data_type_map.end()) {
return api::kInvalidDataType;
} else {
return it->second;
}
}
template <class T>
inline static void ClearIfNotNull(T *vec) {
if (vec != nullptr) {
vec->clear();
}
}
template <class T, class U = std::vector<T>>
inline static void PushbackIfNotNull(U *vec, T &&item) {
if (vec != nullptr) {
vec->emplace_back(item);
}
}
static void ConstructTensorDesc(const std::vector<AclTensorInfo> &acl_tensor_list, std::vector<std::string> *names,
std::vector<std::vector<int64_t>> *shapes, std::vector<DataType> *data_types,
std::vector<size_t> *mem_sizes) {
ClearIfNotNull(names);
ClearIfNotNull(shapes);
ClearIfNotNull(data_types);
ClearIfNotNull(mem_sizes);
for (size_t i = 0; i < acl_tensor_list.size(); ++i) {
const auto &info = acl_tensor_list[i];
PushbackIfNotNull(names, info.name);
PushbackIfNotNull(shapes, info.dims);
PushbackIfNotNull(data_types, TransToApiType(info.data_type));
PushbackIfNotNull(mem_sizes, info.buffer_size);
}
}
Status ModelProcess::PreInitModelResource() {
model_desc_ = aclmdlCreateDesc();
aclError acl_ret = aclmdlGetDesc(model_desc_, model_id_);
if (acl_ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Read model desc failed";
return FAILED;
}
Status ret = InitInputsBuffer();
if (ret != SUCCESS) {
MS_LOG(ERROR) << "Create input buffer failed";
return FAILED;
}
ret = InitOutputsBuffer();
if (ret != SUCCESS) {
MS_LOG(ERROR) << "Create output buffer failed";
return FAILED;
}
return SUCCESS;
}
Status ModelProcess::LoadModelFromFile(const std::string &file_name, uint32_t *model_id) {
MS_EXCEPTION_IF_NULL(model_id);
aclError acl_ret = aclmdlLoadFromFile(file_name.c_str(), model_id);
if (acl_ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Read model file failed, file name is " << file_name;
return FAILED;
}
MS_LOG(INFO) << "Load model success " << file_name;
model_id_ = *model_id;
if (PreInitModelResource() != SUCCESS) {
aclmdlUnload(model_id_);
MS_LOG(ERROR) << "Pre init model resource failed, file name is " << file_name;
return FAILED;
}
return SUCCESS;
}
Status ModelProcess::InitInputsBuffer() {
aclError ret;
size_t input_size = aclmdlGetNumInputs(model_desc_);
MS_LOG(INFO) << "input_size = " << input_size;
for (size_t i = 0; i < input_size; ++i) {
auto buffer_size = aclmdlGetInputSizeByIndex(model_desc_, i);
void *data_mem_buffer = nullptr;
if (!is_run_on_device_) { // need to copy input/output to/from device
ret = aclrtMalloc(&data_mem_buffer, buffer_size, ACL_MEM_MALLOC_NORMAL_ONLY);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Malloc device input buffer faild , input size " << buffer_size;
return FAILED;
}
}
aclmdlIODims dims;
ret = aclmdlGetInputDims(model_desc_, i, &dims);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Get input shape failed";
if (!is_run_on_device_) {
aclrtFree(data_mem_buffer);
}
return FAILED;
}
aclDataType data_type = aclmdlGetInputDataType(model_desc_, i);
std::vector<int64_t> shape(dims.dims, dims.dims + dims.dimCount);
std::string input_name = aclmdlGetInputNameByIndex(model_desc_, i);
if (input_name.empty()) {
MS_LOG(WARNING) << "Get name of input " << i << " failed.";
}
MS_LOG(INFO) << "Name of input " << i << " is " << input_name;
input_infos_.emplace_back(AclTensorInfo{data_mem_buffer, buffer_size, data_type, shape, input_name});
}
MS_LOG(INFO) << "Create model inputs success";
return SUCCESS;
}
Status ModelProcess::CreateDataBuffer(void **data_mem_buffer, size_t buffer_size, aclmdlDataset *dataset) {
MS_EXCEPTION_IF_NULL(data_mem_buffer);
aclError ret;
auto free_data_buffer = [this](void *dataMemBuffer) {
if (!is_run_on_device_) {
aclrtFree(dataMemBuffer);
} else {
aclrtFreeHost(dataMemBuffer);
}
};
if (!is_run_on_device_) {
ret = aclrtMalloc(data_mem_buffer, buffer_size, ACL_MEM_MALLOC_NORMAL_ONLY);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Malloc device buffer faild , buffer size " << buffer_size;
return FAILED;
}
} else {
ret = aclrtMallocHost(data_mem_buffer, buffer_size);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Malloc device buffer faild , buffer size " << buffer_size;
return FAILED;
}
}
auto data_buffer = aclCreateDataBuffer(*data_mem_buffer, buffer_size);
if (data_buffer == nullptr) {
MS_LOG(ERROR) << "Create Data Buffer failed";
free_data_buffer(*data_mem_buffer);
return FAILED;
}
ret = aclmdlAddDatasetBuffer(dataset, data_buffer);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "add data buffer failed";
free_data_buffer(*data_mem_buffer);
aclDestroyDataBuffer(data_buffer);
return FAILED;
}
return SUCCESS;
}
Status ModelProcess::InitOutputsBuffer() {
aclError ret;
outputs_ = aclmdlCreateDataset();
if (outputs_ == nullptr) {
MS_LOG(ERROR) << "Create input dataset failed";
return FAILED;
}
size_t output_size = aclmdlGetNumOutputs(model_desc_);
MS_LOG(INFO) << "output_size = " << output_size;
for (size_t i = 0; i < output_size; ++i) {
auto buffer_size = aclmdlGetOutputSizeByIndex(model_desc_, i);
void *data_mem_buffer = nullptr;
if (CreateDataBuffer(&data_mem_buffer, buffer_size, outputs_) != SUCCESS) {
MS_LOG(ERROR) << "add output data buffer failed, buffer size " << buffer_size;
return FAILED;
}
aclmdlIODims dims;
ret = aclmdlGetOutputDims(model_desc_, i, &dims);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Get input shape failed";
if (!is_run_on_device_) {
aclrtFree(data_mem_buffer);
} else {
aclrtFreeHost(data_mem_buffer);
}
return FAILED;
}
aclDataType data_type = aclmdlGetOutputDataType(model_desc_, i);
std::vector<int64_t> shape(dims.dims, dims.dims + dims.dimCount);
std::string output_name = aclmdlGetOutputNameByIndex(model_desc_, i);
if (output_name.empty()) {
MS_LOG(WARNING) << "Get name of output " << i << " failed.";
}
MS_LOG(INFO) << "Name of input " << i << " is " << output_name;
output_infos_.emplace_back(AclTensorInfo{data_mem_buffer, buffer_size, data_type, shape, output_name});
}
MS_LOG(INFO) << "Create model output success";
return SUCCESS;
}
void ModelProcess::DestroyInputsDataset() {
if (inputs_ == nullptr) {
return;
}
for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(inputs_); i++) {
auto dataBuffer = aclmdlGetDatasetBuffer(inputs_, i);
aclDestroyDataBuffer(dataBuffer);
}
aclmdlDestroyDataset(inputs_);
inputs_ = nullptr;
}
void ModelProcess::DestroyInputsDataMem() {
if (!is_run_on_device_) {
for (const auto &item : input_infos_) {
aclrtFree(item.device_data);
}
}
input_infos_.clear();
}
void ModelProcess::DestroyInputsBuffer() {
DestroyInputsDataMem();
DestroyInputsDataset();
}
void ModelProcess::DestroyOutputsBuffer() {
for (const auto &item : output_infos_) {
if (!is_run_on_device_) {
aclrtFree(item.device_data);
} else {
aclrtFreeHost(item.device_data);
}
}
output_infos_.clear();
if (outputs_ == nullptr) {
return;
}
for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(outputs_); i++) {
auto dataBuffer = aclmdlGetDatasetBuffer(outputs_, i);
aclDestroyDataBuffer(dataBuffer);
}
aclmdlDestroyDataset(outputs_);
outputs_ = nullptr;
}
Status ModelProcess::UnLoad() {
auto ret = aclmdlUnload(model_id_);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Unload model failed";
return FAILED;
}
if (model_desc_ != nullptr) {
ret = aclmdlDestroyDesc(model_desc_);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Unload model failed";
return FAILED;
}
model_desc_ = nullptr;
}
DestroyInputsBuffer();
DestroyOutputsBuffer();
MS_LOG(INFO) << "End unload model " << model_id_;
return SUCCESS;
}
Status ModelProcess::CheckAndInitInput(const std::vector<Buffer> &inputs) {
aclError ret;
inputs_ = aclmdlCreateDataset();
// check inputs
if (inputs.size() != input_infos_.size()) {
MS_LOG(ERROR) << "inputs count not match, required count " << input_infos_.size() << ", given count "
<< inputs.size();
return INVALID_INPUTS;
}
for (size_t i = 0; i < input_infos_.size(); ++i) {
if (inputs[i].DataSize() != input_infos_[i].buffer_size) {
MS_LOG(ERROR) << "input " << i << " data size not match, required size " << input_infos_[i].buffer_size
<< ", given count " << inputs[i].DataSize();
return INVALID_INPUTS;
}
}
// copy inputs
for (size_t i = 0; i < input_infos_.size(); ++i) {
const auto &info = input_infos_[i];
const auto &input = inputs[i];
const void *data = input.Data();
void *input_buffer = nullptr;
if (!is_run_on_device_) {
ret = aclrtMemcpy(info.device_data, info.buffer_size, data, input.DataSize(), ACL_MEMCPY_HOST_TO_DEVICE);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Acl memcpy input " << i << " data to device failed, buffer size " << input.DataSize();
return FAILED;
}
input_buffer = info.device_data;
} else {
input_buffer = const_cast<void *>(data);
}
auto data_buffer = aclCreateDataBuffer(input_buffer, info.buffer_size);
if (data_buffer == nullptr) {
MS_LOG(ERROR) << "Create Data Buffer failed";
return FAILED;
}
ret = aclmdlAddDatasetBuffer(inputs_, data_buffer);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "add data buffer failed";
aclDestroyDataBuffer(data_buffer);
return FAILED;
}
}
return SUCCESS;
}
Status ModelProcess::PredictFromHost(const std::vector<Buffer> &inputs, std::vector<Buffer> *outputs) {
MS_EXCEPTION_IF_NULL(outputs);
aclError acl_ret;
Status ret = CheckAndInitInput(inputs);
if (ret != SUCCESS) {
MS_LOG(ERROR) << "check or init input failed";
DestroyInputsDataset();
return ret; // forward status error
}
struct timeval start_time;
struct timeval end_time;
(void)gettimeofday(&start_time, nullptr);
acl_ret = aclmdlExecute(model_id_, inputs_, outputs_);
(void)gettimeofday(&end_time, nullptr);
constexpr uint64_t kUSecondInSecond = 1000000;
uint64_t cost =
(kUSecondInSecond * static_cast<uint64_t>(end_time.tv_sec) + static_cast<uint64_t>(end_time.tv_usec)) -
(kUSecondInSecond * static_cast<uint64_t>(start_time.tv_sec) + static_cast<uint64_t>(start_time.tv_usec));
MS_LOG(INFO) << "Model execute in " << cost << " us";
DestroyInputsDataset();
if (acl_ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Execute Model Failed";
return FAILED;
}
ret = BuildOutputs(outputs);
if (ret != SUCCESS) {
MS_LOG(ERROR) << "Build outputs faield";
return FAILED;
}
MS_LOG(INFO) << "excute model success";
return SUCCESS;
}
Status ModelProcess::BuildOutputs(std::vector<Buffer> *outputs) {
MS_EXCEPTION_IF_NULL(outputs);
aclError ret;
// copy outputs
outputs->clear();
aclrtMemcpyKind kind = is_run_on_device_ ? ACL_MEMCPY_HOST_TO_HOST : ACL_MEMCPY_DEVICE_TO_HOST;
for (size_t i = 0; i < output_infos_.size(); ++i) {
const auto &info = output_infos_[i];
outputs->emplace_back(Buffer());
auto output = outputs->rbegin();
if (!output->ResizeData(info.buffer_size)) {
MS_LOG(ERROR) << "new output data buffer failed, data size " << info.buffer_size;
return FAILED;
}
ret = aclrtMemcpy(output->MutableData(), output->DataSize(), info.device_data, info.buffer_size, kind);
if (ret != ACL_ERROR_NONE) {
MS_LOG(ERROR) << "Memcpy output " << i << " from " << (is_run_on_device_ ? "host" : "device")
<< " to host failed, memory size " << info.buffer_size;
return FAILED;
}
}
return SUCCESS;
}
Status ModelProcess::GetInputsInfo(std::vector<std::string> *names, std::vector<std::vector<int64_t>> *shapes,
std::vector<DataType> *data_types, std::vector<size_t> *mem_sizes) const {
ConstructTensorDesc(input_infos_, names, shapes, data_types, mem_sizes);
return SUCCESS;
}
Status ModelProcess::GetOutputsInfo(std::vector<std::string> *names, std::vector<std::vector<int64_t>> *shapes,
std::vector<DataType> *data_types, std::vector<size_t> *mem_sizes) const {
ConstructTensorDesc(output_infos_, names, shapes, data_types, mem_sizes);
return SUCCESS;
}
} // namespace mindspore::api
| 34.104623 | 115 | 0.671898 | GuoSuiming |
5c13b4d69ab0a1ec8e6a637640c2537439399fee | 5,383 | cpp | C++ | src/lightmetrica-test/test_fp.cpp | jammm/lightmetrica-v2 | 6864942ec48d37f2c35dc30a38a26d7cc4bb527e | [
"MIT"
] | 150 | 2015-12-28T10:26:02.000Z | 2021-03-17T14:36:16.000Z | src/lightmetrica-test/test_fp.cpp | jammm/lightmetrica-v2 | 6864942ec48d37f2c35dc30a38a26d7cc4bb527e | [
"MIT"
] | null | null | null | src/lightmetrica-test/test_fp.cpp | jammm/lightmetrica-v2 | 6864942ec48d37f2c35dc30a38a26d7cc4bb527e | [
"MIT"
] | 17 | 2016-02-08T10:57:55.000Z | 2020-09-04T03:57:33.000Z | /*
Lightmetrica - A modern, research-oriented renderer
Copyright (c) 2015 Hisanari Otsu
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 <pch_test.h>
#include <lightmetrica/exception.h>
#include <lightmetrica/fp.h>
#include <lightmetrica-test/utils.h>
#if LM_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable:4723) // C4723: potential divide by 0
#endif
#if LM_COMPILER_CLANG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wliteral-range"
#endif
LM_TEST_NAMESPACE_BEGIN
#if LM_COMPILER_MSVC
TEST(FPTest, SupportedExceptions)
{
const auto Trial = [&](const std::string& desc, const std::function<void()>& func) -> void
{
SEHUtils::EnableStructuralException();
FPUtils::EnableFPControl();
bool exception = false;
try
{
func();
}
catch (const std::runtime_error& e)
{
exception = true;
EXPECT_EQ(desc, std::string(e.what()));
}
EXPECT_TRUE(exception);
FPUtils::DisableFPControl();
SEHUtils::DisableStructuralException();
};
// --------------------------------------------------------------------------------
SCOPED_TRACE("T0");
Trial("FLT_INVALID_OPERATION", [&]()
{
const volatile double t = std::numeric_limits<double>::infinity() * 0;
LM_UNUSED(t);
});
SCOPED_TRACE("T1");
Trial("FLT_INVALID_OPERATION", [&]()
{
double z = 0;
const volatile double t = 0 / z;
LM_UNUSED(t);
});
SCOPED_TRACE("T2");
Trial("FLT_INVALID_OPERATION", [&]()
{
const volatile double t = std::sqrt(-1);
LM_UNUSED(t);
});
//SCOPED_TRACE("T3");
//Trial("FLT_INVALID_OPERATION", [&]()
//{
// const volatile double one = 1.0;
// const volatile double nan = std::numeric_limits<double>::signaling_NaN();
// const volatile double t = one * nan;
// LM_UNUSED(t);
//});
SCOPED_TRACE("T4");
Trial("FLT_DIVIDE_BY_ZERO", [&]()
{
double z = 0;
const volatile double t = 1.0 / z;
LM_UNUSED(t);
});
}
TEST(FPTest, UnsupportedExceptions)
{
// _EM_DENORMAL
EXPECT_NO_THROW(
{
{
// 4.940656e-324 : denormal
const double t = 4.940656e-324;
EXPECT_EQ(FP_SUBNORMAL, std::fpclassify(t));
}
{
// 4.940656e-325 : below representable number by denormal -> clamped to zero
const double t = 4.940656e-325;
EXPECT_EQ(FP_ZERO, std::fpclassify(t));
}
});
// Overflow
EXPECT_NO_THROW(
{
const double max = std::numeric_limits<double>::max();
const double t = max + 1.0;
// Default rouding mode is `round to nearest`.
EXPECT_EQ(max, t);
});
// Underflow
EXPECT_NO_THROW(
{
double t = std::nextafter(std::numeric_limits<double>::min(), -std::numeric_limits<double>::infinity());
EXPECT_EQ(FP_SUBNORMAL, std::fpclassify(t));
});
EXPECT_NO_THROW(
{
double t = std::nextafter(std::numeric_limits<double>::denorm_min(), -std::numeric_limits<double>::infinity());
EXPECT_EQ(FP_ZERO, std::fpclassify(t));
});
// Inexact
EXPECT_NO_THROW(
{
const volatile double t = 2.0 / 3.0;
LM_UNUSED(t);
});
EXPECT_NO_THROW(
{
const volatile double t = std::log(1.1);
LM_UNUSED(t);
});
}
TEST(FPTest, DisabledBehavior)
{
EXPECT_NO_THROW(
{
const double t = std::numeric_limits<double>::infinity() * 0;
EXPECT_TRUE(std::isnan(t));
});
EXPECT_NO_THROW(
{
double z = 0;
const double t = 0 / z;
EXPECT_TRUE(std::isnan(t));
});
EXPECT_NO_THROW(
{
const double t = std::sqrt(-1);
EXPECT_TRUE(std::isnan(t));
});
EXPECT_NO_THROW(
{
const double t = 1.0 * std::numeric_limits<double>::signaling_NaN();
EXPECT_TRUE(std::isnan(t));
});
EXPECT_NO_THROW(
{
double z = 0;
const double t = 1.0 / z;
EXPECT_TRUE(std::isinf(t));
});
}
#endif
LM_TEST_NAMESPACE_END
#if LM_COMPILER_MSVC
#pragma warning(pop)
#endif
#if LM_COMPILER_CLANG
#pragma clang diagnostic pop
#endif
| 25.633333 | 119 | 0.601152 | jammm |
5c163e50bccbec1038ab871b5f9619b276afa183 | 2,089 | cpp | C++ | Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraSystemEditorData.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | 1 | 2022-01-29T18:36:12.000Z | 2022-01-29T18:36:12.000Z | Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraSystemEditorData.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraSystemEditorData.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#include "NiagaraSystemEditorData.h"
#include "NiagaraStackEditorData.h"
const FName UNiagaraSystemEditorFolder::GetFolderName() const
{
return FolderName;
}
void UNiagaraSystemEditorFolder::SetFolderName(FName InFolderName)
{
FolderName = InFolderName;
}
const TArray<UNiagaraSystemEditorFolder*>& UNiagaraSystemEditorFolder::GetChildFolders() const
{
return ChildFolders;
}
void UNiagaraSystemEditorFolder::AddChildFolder(UNiagaraSystemEditorFolder* ChildFolder)
{
Modify();
ChildFolders.Add(ChildFolder);
}
void UNiagaraSystemEditorFolder::RemoveChildFolder(UNiagaraSystemEditorFolder* ChildFolder)
{
Modify();
ChildFolders.Remove(ChildFolder);
}
const TArray<FGuid>& UNiagaraSystemEditorFolder::GetChildEmitterHandleIds() const
{
return ChildEmitterHandleIds;
}
void UNiagaraSystemEditorFolder::AddChildEmitterHandleId(FGuid ChildEmitterHandleId)
{
Modify();
ChildEmitterHandleIds.Add(ChildEmitterHandleId);
}
void UNiagaraSystemEditorFolder::RemoveChildEmitterHandleId(FGuid ChildEmitterHandleId)
{
Modify();
ChildEmitterHandleIds.Remove(ChildEmitterHandleId);
}
UNiagaraSystemEditorData::UNiagaraSystemEditorData(const FObjectInitializer& ObjectInitializer)
{
RootFolder = ObjectInitializer.CreateDefaultSubobject<UNiagaraSystemEditorFolder>(this, TEXT("RootFolder"));
StackEditorData = ObjectInitializer.CreateDefaultSubobject<UNiagaraStackEditorData>(this, TEXT("StackEditorData"));
OwnerTransform.SetLocation(FVector(0.0f, 0.0f, 100.0f));
}
void UNiagaraSystemEditorData::PostLoad()
{
Super::PostLoad();
if (RootFolder == nullptr)
{
RootFolder = NewObject<UNiagaraSystemEditorFolder>(this, TEXT("RootFolder"), RF_Transactional);
}
if (StackEditorData == nullptr)
{
StackEditorData = NewObject<UNiagaraStackEditorData>(this, TEXT("StackEditorData"), RF_Transactional);
}
}
UNiagaraSystemEditorFolder& UNiagaraSystemEditorData::GetRootFolder() const
{
return *RootFolder;
}
UNiagaraStackEditorData& UNiagaraSystemEditorData::GetStackEditorData() const
{
return *StackEditorData;
} | 26.782051 | 116 | 0.817616 | windystrife |
5c164135be53b45a0b8dd74ce9176453fbcd18c7 | 639 | cpp | C++ | ch16/exer16_51.cpp | imshenzhuo/CppPrimer | 87c74c0a36223e86571c2aedd9da428c06b04f4d | [
"CC0-1.0"
] | 3 | 2019-09-21T13:03:57.000Z | 2020-04-05T02:42:53.000Z | ch16/exer16_51.cpp | imshenzhuo/CppPrimer | 87c74c0a36223e86571c2aedd9da428c06b04f4d | [
"CC0-1.0"
] | null | null | null | ch16/exer16_51.cpp | imshenzhuo/CppPrimer | 87c74c0a36223e86571c2aedd9da428c06b04f4d | [
"CC0-1.0"
] | null | null | null | /*************************************************************************
> File Name: exer16_51.cpp
> Author: shenzhuo
> Mail: im.shenzhuo@gmail.com
> Created Time: 2019年09月26日 星期四 09时40分28秒
************************************************************************/
#include<iostream>
#include<string>
using namespace std;
template <typename T, typename... Args>
void foo(const T&t, const Args& ... rest) {
cout << sizeof...(Args) << endl;
cout << sizeof...(rest) << endl;
}
int main() {
int i = 0;
double d = 3.14;
string s = "how now brown cow";
foo(i, s, 42, d);
foo(s, 42, "hi");
foo(d, s);
foo("hi");
}
| 23.666667 | 74 | 0.463224 | imshenzhuo |
5c165832900814b7f32eb8a118646ce859f71254 | 396 | hpp | C++ | Game/test/include/titlescreen.hpp | eliseuegewarth/seven-keys | 7afcd9d9af6d99117bf949e328099ad5f07acef8 | [
"MIT"
] | null | null | null | Game/test/include/titlescreen.hpp | eliseuegewarth/seven-keys | 7afcd9d9af6d99117bf949e328099ad5f07acef8 | [
"MIT"
] | null | null | null | Game/test/include/titlescreen.hpp | eliseuegewarth/seven-keys | 7afcd9d9af6d99117bf949e328099ad5f07acef8 | [
"MIT"
] | 1 | 2017-08-25T14:37:52.000Z | 2017-08-25T14:37:52.000Z | /*
* Exemplo de uma tela de apresentação.
*
* Autor: Edson Alves
* Data: 29/04/2015
* Licença: LGPL. Sem copyright.
*/
#ifndef TITLE_SCREEN_H
#define TITLE_SCREEN_H
class Image;
class TitleScreen : public Level
{
public:
TitleScreen();
virtual ~TitleScreen();
bool on_message(Object *sender, MessageID id, Parameters parameters);
private:
void draw_self();
};
#endif
| 14.142857 | 73 | 0.691919 | eliseuegewarth |
5c18321bbb8047f6cb8d3a4654341f424e6b97ef | 4,306 | cpp | C++ | openrave/cpp-gen-md5/cpp-gen-md5.cpp | jdsika/TUM_HOly | a2ac55fa1751a3a8038cf61d29b95005f36d6264 | [
"MIT"
] | 2 | 2015-11-13T16:40:57.000Z | 2017-09-15T15:37:19.000Z | openrave/cpp-gen-md5/cpp-gen-md5.cpp | jdsika/holy | a2ac55fa1751a3a8038cf61d29b95005f36d6264 | [
"MIT"
] | 1 | 2016-06-13T01:29:51.000Z | 2016-06-14T00:38:27.000Z | openrave/cpp-gen-md5/cpp-gen-md5.cpp | jdsika/holy | a2ac55fa1751a3a8038cf61d29b95005f36d6264 | [
"MIT"
] | null | null | null | /** \file cpp-gen-md5.cpp
\brief Generates a md5 hash from the lexical tokens of a C++ ignoring directives and whitespace.
\author Rosen Diankov
\anchor cpp-gen-md5
Usage:
\verbatim
cpp-gen-md5 [filename1 define1] [filename2 define2] ...
\endverbatim
If only a filename is given, will output a 16 byte string. If both filename and define are given
will output a file consisting of the hashes:
\verbatim
#define @define2@ "@md5hash@"
\endverbatim
*/
#include "cpp_lexer.hpp"
#include <iostream>
#include <vector>
#include <sstream>
#include <cstdio>
#include <cstring>
#include "md5.h"
using namespace std;
void getTokenData(const char* fname, vector<char>& vdata);
string getmd5hash(const char* fname, const vector<char>& vbasedata);
int main(int argc, char* argv[])
{
if( argc < 2 ) {
cerr << "No filename given" << endl
<< "cpp-gen-md5 [common-string] [shared-filename] [filename1 define1] [filename2 define2]* ..." << endl
<< "Generates a md5 sum from the lexical tokens of a C++ ignoring directives and whitespace." << endl
<< "If only a filename is given, will output a 16 byte string" << endl
<< "If both filename and define are given will output #define @define2@ \"@md5hash@\"" << endl;
return 2;
}
vector<char> vbasedata;
vbasedata.resize(strlen(argv[1]));
if( vbasedata.size() > 0 ) {
memcpy(&vbasedata[0],argv[1],vbasedata.size());
}
if( strlen(argv[2]) > 0 ) {
getTokenData(argv[2],vbasedata);
}
for(int i = 3; i < argc; i += 2) {
vector<char> vdata=vbasedata;
string md5hash = getmd5hash(argv[i],vdata);
if( md5hash == "" ) {
return 1;
}
if( i+1 < argc ) {
cout << "#define " << argv[i+1] << " \"" << md5hash << "\"" << endl;
}
else {
cout << md5hash << endl;
}
}
return 0;
}
void getTokenData(const char* fname,vector<char>& vdata)
{
// Read the input file into a buffer.
FILE* f = fopen(fname, "rb");
if (!f) {
cerr << "Cannot open input file: " << fname << endl;
return;
}
fseek(f, 0, SEEK_END);
int const size = ftell(f);
fseek(f, 0, SEEK_SET);
vector<char> buf(size);
size_t read = fread(&buf[0], 1, size, f);
fclose(f);
if( read == 0 || read != size ) {
return;
}
cpp::clearstate();
cpp::lexer_iterator first(cpp::NewLexer(&buf[0], &buf[0]+buf.size(), fname));
cpp::lexer_iterator last;
while (first != last) {
cpp::Token const& token = *first;
switch(token.id) {
case cpp::Unknown_token:
case cpp::Directive_token:
case cpp::EOL_token:
case cpp::EOF_token:
case cpp::Comment_token:
break;
default:
vdata.push_back(token.id&0xff);
if( token.id&0xffff00) {
vdata.push_back((token.id>>8)&0xff);
vdata.push_back((token.id>>16)&0xff);
}
vdata.push_back((token.id>>24)&0xff);
//cpp::PrintToken(token);
if( (token.id&cpp::TokenTypeMask) == cpp::OperatorTokenType ) {
break;
}
if( (token.id&cpp::TokenTypeMask) == cpp::IdentifierTokenType ) {
if (token.id < cpp::Kwd_last) {
break;
}
}
for(size_t i = 0; i < token.text.size(); ++i) {
vdata.push_back(token.text[i]);
}
}
++first;
}
}
string getmd5hash(const char* fname, const vector<char>& vbasedata)
{
vector<char> vdata = vbasedata;
vdata.reserve(vdata.capacity()+10000);
getTokenData(fname,vdata);
md5_state_t state;
md5_byte_t digest[16];
md5_init(&state);
md5_append(&state, (const md5_byte_t *)&vdata[0], vdata.size());
md5_finish(&state, digest);
char hex_output[16*2+1];
for (int di = 0; di < 16; ++di) {
sprintf(hex_output + di * 2, "%02x", digest[di]);
}
return string(hex_output);
}
| 30.111888 | 117 | 0.533442 | jdsika |
5c21de73201313ec1b80293568b94fe22b358a62 | 612 | hpp | C++ | src/NetWidgets/ProgressBar.hpp | frc3512/DriverStationDisplay | c6b5eb263ec1d1701a3d48a915b7b106c982323d | [
"BSD-3-Clause"
] | null | null | null | src/NetWidgets/ProgressBar.hpp | frc3512/DriverStationDisplay | c6b5eb263ec1d1701a3d48a915b7b106c982323d | [
"BSD-3-Clause"
] | null | null | null | src/NetWidgets/ProgressBar.hpp | frc3512/DriverStationDisplay | c6b5eb263ec1d1701a3d48a915b7b106c982323d | [
"BSD-3-Clause"
] | 1 | 2017-03-14T02:13:29.000Z | 2017-03-14T02:13:29.000Z | // Copyright (c) 2012-2018 FRC Team 3512. All Rights Reserved.
#pragma once
#include <string>
#include <QProgressBar>
#include <QVBoxLayout>
#include "NetWidget.hpp"
#include "Text.hpp"
/**
* Provides an interface to a progress bar
*/
class ProgressBar : public QWidget, public NetWidget {
Q_OBJECT
public:
explicit ProgressBar(bool netUpdate, QWidget* parent = nullptr);
void setPercent(int percent);
int getPercent();
void setString(const std::wstring& text);
std::wstring getString();
void updateEntry() override;
private:
QProgressBar* m_bar;
Text* m_text;
};
| 18 | 68 | 0.697712 | frc3512 |
5c21e6f13de9912235666e55e22abcf74401ac26 | 1,955 | cpp | C++ | gui/src/models/dialogs-list/dialoginfo.cpp | sqglobe/SecureDialogues | bde56c7a62fb72b1cdfba8cebc0a770157b5f751 | [
"MIT"
] | 3 | 2019-07-05T12:01:36.000Z | 2021-03-19T22:48:48.000Z | gui/src/models/dialogs-list/dialoginfo.cpp | sqglobe/SecureDialogues | bde56c7a62fb72b1cdfba8cebc0a770157b5f751 | [
"MIT"
] | 41 | 2019-11-26T18:59:54.000Z | 2020-05-01T10:52:47.000Z | gui/src/models/dialogs-list/dialoginfo.cpp | sqglobe/SecureDialogues | bde56c7a62fb72b1cdfba8cebc0a770157b5f751 | [
"MIT"
] | 3 | 2019-05-21T17:48:16.000Z | 2021-03-19T22:48:49.000Z | #include "dialoginfo.h"
#include "primitives/contact.h"
std::string DialogInfo::name() const {
return mName;
}
std::string DialogInfo::address() const {
return mAddress;
}
std::string DialogInfo::moniker() const {
return mMoniker;
}
std::string DialogInfo::dialogId() const {
return mDialogId;
}
std::string DialogInfo::contactId() const {
return mContactId;
}
Dialog::Status DialogInfo::status() const {
return mStatus;
}
std::size_t DialogInfo::unreadMessages() const {
return mUnreadMessages;
}
std::chrono::system_clock::time_point DialogInfo::lastUpdated() const {
return mLastUpdated;
}
DialogInfo::DialogInfo(const Dialog& elem, const Contact& contact) :
mName(contact.name()), mAddress(contact.adress()),
mMoniker(contact.channelMoniker()), mDialogId(elem.getDialogId()),
mContactId(contact.id()), mStatus(elem.getStatus()),
mLastUpdated(std::chrono::system_clock::now()) {}
DialogInfo& DialogInfo::operator=(const DialogInfo& info) {
this->mAddress = info.mAddress;
this->mDialogId = info.mDialogId;
this->mMoniker = info.mMoniker;
this->mName = info.mName;
this->mStatus = info.mStatus;
this->mUnreadMessages = info.mUnreadMessages;
this->mContactId = info.mContactId;
this->mLastUpdated = std::chrono::system_clock::now();
return *this;
}
DialogInfo& DialogInfo::operator=(const Dialog& info) {
this->mStatus = info.getStatus();
this->mDialogId = info.getDialogId();
this->mContactId = info.getContactId();
this->mLastUpdated = std::chrono::system_clock::now();
return *this;
}
DialogInfo& DialogInfo::operator=(const Contact& info) {
this->mAddress = info.adress();
this->mMoniker = info.channelMoniker();
this->mName = info.name();
this->mContactId = info.id();
return *this;
}
void DialogInfo::messagesReaded() {
mUnreadMessages = 0;
}
void DialogInfo::addUnreadMessage() {
mUnreadMessages++;
this->mLastUpdated = std::chrono::system_clock::now();
}
| 24.746835 | 71 | 0.711509 | sqglobe |
5c22fa378f173f59a63dd2dab03fd04b1fabdbf1 | 1,332 | cpp | C++ | crypto_sign/bls/ref/usehash.cpp | iadgov/simon-speck-supercop | 5bba85c3094029eb73b7077441e5c6ea2f2cb1c6 | [
"CC0-1.0"
] | 21 | 2016-12-03T14:19:01.000Z | 2018-03-09T14:52:25.000Z | crypto_sign/bls/ref/usehash.cpp | iadgov/simon-speck-supercop | 5bba85c3094029eb73b7077441e5c6ea2f2cb1c6 | [
"CC0-1.0"
] | null | null | null | crypto_sign/bls/ref/usehash.cpp | iadgov/simon-speck-supercop | 5bba85c3094029eb73b7077441e5c6ea2f2cb1c6 | [
"CC0-1.0"
] | 11 | 2017-03-06T17:21:42.000Z | 2018-03-18T03:52:58.000Z | #include "crypto_hash_sha256.h"
#include "crypto_sign.h"
#include "sizes.h"
extern int signatureofshorthash(unsigned char *,unsigned long long *,
const unsigned char *,unsigned long long,
const unsigned char *,unsigned long long);
extern int verification(const unsigned char *,unsigned long long,
const unsigned char *,unsigned long long,
const unsigned char *,unsigned long long);
int crypto_sign(
unsigned char *sm,unsigned long long *smlen,
const unsigned char *m,unsigned long long mlen,
const unsigned char *sk
)
{
unsigned char h[32];
int i;
crypto_hash_sha256(h,m,mlen);
if (SHORTHASH_BYTES < 32) return -1;
i = signatureofshorthash(sm,smlen,h,32,sk,SECRETKEY_BYTES);
if (i < 0) return i;
if (*smlen != SIGNATURE_BYTES) return -1;
for (i = 0;i < mlen;++i) {
sm[*smlen] = m[i];
++*smlen;
}
return 0;
}
int crypto_sign_open(
unsigned char *m,unsigned long long *mlen,
const unsigned char *sm,unsigned long long smlen,
const unsigned char *pk
)
{
unsigned char h[32];
int i;
if (smlen < SIGNATURE_BYTES) return -100;
for (i = SIGNATURE_BYTES;i < smlen;++i) m[i - SIGNATURE_BYTES] = sm[i];
*mlen = smlen - SIGNATURE_BYTES;
crypto_hash_sha256(h,m,*mlen);
if (SHORTHASH_BYTES < 32) return -1;
return verification(h,32,sm,SIGNATURE_BYTES,pk,PUBLICKEY_BYTES);
}
| 26.117647 | 73 | 0.6997 | iadgov |
5c298102243dec2849eb61a190ac353c5315f5e6 | 272 | hpp | C++ | include/output/Mixer.hpp | medium-endian/multipid | 41ab0c810de04fc48923edf31e3c971826abbaf3 | [
"MIT"
] | 15 | 2018-06-25T23:06:57.000Z | 2022-03-31T06:00:35.000Z | include/output/Mixer.hpp | medium-endian/multipid | 41ab0c810de04fc48923edf31e3c971826abbaf3 | [
"MIT"
] | 3 | 2017-11-20T23:00:03.000Z | 2018-01-19T16:22:39.000Z | include/output/Mixer.hpp | medium-endian/multipid | 41ab0c810de04fc48923edf31e3c971826abbaf3 | [
"MIT"
] | 1 | 2020-08-24T13:24:39.000Z | 2020-08-24T13:24:39.000Z | #ifndef MIXER_H
#define MIXER_H
class Mixer {
public:
float throttle_volume;
float roll_volume;
float pitch_volume;
float yaw_volume;
Mixer(float thr_vol, float roll_vol, float pitch_vol, float yaw_vol);
};
#endif //MIXER_H
| 17 | 77 | 0.654412 | medium-endian |
5c29a808253871ca99b310f086ed57c1e5f65751 | 7,426 | cpp | C++ | Source/main.cpp | fakhirsh/EventManager | 5a92d1035d01308e12ba84e56fc63df40768562c | [
"MIT"
] | null | null | null | Source/main.cpp | fakhirsh/EventManager | 5a92d1035d01308e12ba84e56fc63df40768562c | [
"MIT"
] | null | null | null | Source/main.cpp | fakhirsh/EventManager | 5a92d1035d01308e12ba84e56fc63df40768562c | [
"MIT"
] | null | null | null |
#include <iostream>
#include <vector>
#include "FastDelegate/FastDelegate.h"
#include "CppDelegates/Delegate.h"
#include "Event.hpp"
#include "EventManager.hpp"
#include <map>
#include <string>
#include <chrono>
#include <memory>
using namespace std;
using namespace std::chrono;
using namespace CppDelegates;
using namespace fastdelegate;
using namespace FEngine;
//typedef CppDelegates::delegate<void (float)> EventDelegate;
class GameObj{
public:
void OnEvent(EventPtr e){
cout << this << " GameObj::OnEvent --> " << e->GetArg("health") << endl;
double d = e->GetArg("health");
}
};
/*
*class EventManager{
* public:
* EventManager(){}
* ~EventManager(){}
*
* void AddListener(EventDelegate ed){
* _list.push_back(ed);
* }
*
* void Call(){
* float f = 1.29f;
* for(int i = 0; i < _list.size(); i++){
* _list[i](f);
* f += 0.23342;
* }
* }
*
* private:
* vector<EventDelegate> _list;
*};
*/
/*
*void Benchmark1(unsigned int iterations);
*void Benchmark2(unsigned int iterations);
*void Benchmark3(unsigned int iterations);
*/
void Benchmark4(unsigned int iterations);
int main( void )
{
//GameObj obj1, obj2, obj3;
/*
typedef FastDelegate1<float> MyDelegate;
MyDelegate newdeleg;
newdeleg = MakeDelegate(&obj1, &GameObj::OnEvent);
newdeleg(6.3334443);
delegate<void (float)> d;
auto dInstance = decltype(d)::create<GameObj, &GameObj::OnEvent>(&obj2);
dInstance(3.1415);
auto d1 = delegate<void(float)>::create<GameObj, &GameObj::OnEvent>(&obj3);
d1(1.41);
*/
/*
* auto d1 = delegate<void(float)>::create<GameObj, &GameObj::OnEvent>(&obj1);
* auto d2 = delegate<void(float)>::create<GameObj, &GameObj::OnEvent>(&obj2);
* auto d3 = delegate<void(float)>::create<GameObj, &GameObj::OnEvent>(&obj3);
*
* EventManager emgr;
* emgr.AddListener(d1);
* emgr.AddListener(d2);
* emgr.AddListener(d3);
*
* emgr.Call();
*
* FEngine::Event e;
* e.SetEventId(5545);
* e.SetEventType("Hit");
* e.SetArg("damage", 20.0);
* e.SetArg("speed", 30.0);
* e.SetArg("happy", 100.0);
*
*
* map<string, double> args;
* args["damage"] = 20.0;
*
* cout << e.GetArg("speed") << endl;
*/
unsigned int iterations = 20;
//Benchmark1(iterations);
//Benchmark2(iterations);
//Benchmark3(iterations);
Benchmark4(iterations);
return 0;
}
/*
*
*void Benchmark1(unsigned int iterations){
*
* cout << "Benchmark 1" << endl;
* cout << "Creating " << iterations << " events" << endl;
*
* long int time = 0;
* long int newtime = 0;
*
* const long int num = high_resolution_clock::period::num;
* const long int den = high_resolution_clock::period::den;
* time = high_resolution_clock::now().time_since_epoch().count();
*
* unsigned int count = 0;
* do{
* FEngine::Event e;
* e.SetEventName("Game Started");
* e.SetEventType("Hit");
* e.SetArg("damage", 20.0);
* e.SetArg("speed", 30.0);
* e.SetArg("happy", 100.0);
*
* double temp = e.GetArg("damage");
* temp = e.GetArg("speed");
* temp = e.GetArg("happy");
* // HUGE panelty time wise:
* temp = e.GetArg("unknown");
*
* count++;
* }while(count < iterations);
*
* newtime = high_resolution_clock::now().time_since_epoch().count();
* double dt = (newtime - time) * 1.0 * num / den;
*
* cout << "Elapsed time: " << dt*1000 << " (msec)" << endl;
*}
*
*void Benchmark2(unsigned int iterations){
* cout << "Benchmark 2" << endl;
* cout << "Creating " << iterations << " events" << endl;
*
* long int time = 0;
* long int newtime = 0;
*
* const long int num = high_resolution_clock::period::num;
* const long int den = high_resolution_clock::period::den;
* time = high_resolution_clock::now().time_since_epoch().count();
*
*
* unsigned int count = 0;
* do{
* map<string, double> args;
*
* args["damage"] = 20.0;
* args["speed"] = 30.0;
* args["happy"] = 100.0;
*
* double temp = args["damage"];
* temp = args["speed"];
* temp = args["happy"];
* // HUGE panelty time wise:
* temp = args["unknown"];
*
* count++;
* }while(count < iterations);
*
* newtime = high_resolution_clock::now().time_since_epoch().count();
* double dt = (newtime - time) * 1.0 * num / den;
*
* cout << "Elapsed time: " << dt*1000 << " (msec)" << endl;
*
*}
*
*void Benchmark3(unsigned int iterations){
* cout << "Benchmark 3" << endl;
* cout << "Creating " << iterations << " events" << endl;
*
* EventManager mgr;
* GameObj obj1, obj2, obj3;
* auto d1 = EventDelegate::create<GameObj, &GameObj::OnEvent>(&obj1);
* auto d2 = EventDelegate::create<GameObj, &GameObj::OnEvent>(&obj2);
* auto d3 = EventDelegate::create<GameObj, &GameObj::OnEvent>(&obj3);
*
* mgr.AddListener("gamestart", d1);
* mgr.AddListener("gamestart", d2);
* mgr.AddListener("gamestart", d3);
*
*
* for(int i = 0; i < iterations; i++){
* Event e;
* e.SetEventType("gamestart");
* e.SetEventName("Random Event");
* e.SetArg("health", 100+i);
* mgr.EnQueue(e);
* }
*
* long int time = 0;
* long int newtime = 0;
*
* const long int num = high_resolution_clock::period::num;
* const long int den = high_resolution_clock::period::den;
* time = high_resolution_clock::now().time_since_epoch().count();
*
*
* unsigned int count = 0;
* do{
*
* mgr.Update(0.0f);
*
* count++;
* }while(count < iterations);
*
* newtime = high_resolution_clock::now().time_since_epoch().count();
* double dt = (newtime - time) * 1.0 * num / den;
*
* cout << "Elapsed time: " << dt*1000 << " (msec)" << endl;
*
*}
*
*/
void Benchmark4(unsigned int iterations){
cout << "Benchmark 3" << endl;
cout << "Creating " << iterations << " events" << endl;
EventManager mgr;
GameObj obj1, obj2, obj3;
auto d1 = EventDelegate::create<GameObj, &GameObj::OnEvent>(&obj1);
auto d2 = EventDelegate::create<GameObj, &GameObj::OnEvent>(&obj2);
auto d3 = EventDelegate::create<GameObj, &GameObj::OnEvent>(&obj3);
mgr.AddListener("gamestart", d1);
mgr.AddListener("gamestart", d2);
mgr.AddListener("gamestart", d3);
for(int i = 0; i < iterations; i++){
EventPtr e = make_shared<Event>();
e->SetEventType("gamestart");
e->SetEventName("Random Event");
e->SetArg("health", 100+i);
mgr.EnQueue(e);
}
long int time = 0;
long int newtime = 0;
const long int num = high_resolution_clock::period::num;
const long int den = high_resolution_clock::period::den;
time = high_resolution_clock::now().time_since_epoch().count();
unsigned int count = 0;
do{
mgr.Update(0.0f);
count++;
}while(count < iterations);
newtime = high_resolution_clock::now().time_since_epoch().count();
double dt = (newtime - time) * 1.0 * num / den;
cout << "Elapsed time: " << dt*1000 << " (msec)" << endl;
}
| 26.240283 | 85 | 0.568408 | fakhirsh |
5c29e44aff1e4903ec5714907aa7d61f8cf0283d | 1,352 | cpp | C++ | Source/Fabric/Private/MoPubFunctions.cpp | getsetgames/Fabric | c57937511ecd700a28ba088e26e1a61d794c8a66 | [
"MIT"
] | 13 | 2015-06-17T14:39:37.000Z | 2021-12-02T15:21:19.000Z | Source/Fabric/Private/MoPubFunctions.cpp | denfrost/Fabric | c57937511ecd700a28ba088e26e1a61d794c8a66 | [
"MIT"
] | 2 | 2015-06-17T12:13:17.000Z | 2016-11-03T02:40:23.000Z | Source/Fabric/Private/MoPubFunctions.cpp | denfrost/Fabric | c57937511ecd700a28ba088e26e1a61d794c8a66 | [
"MIT"
] | 10 | 2015-06-17T14:43:56.000Z | 2020-07-01T02:11:07.000Z | //
// Created by Derek van Vliet on 2014-12-10.
// Copyright (c) 2015 Get Set Games Inc. All rights reserved.
//
#include "MoPubFunctions.h"
#include "FabricPrivatePCH.h"
#if PLATFORM_IOS
static NSMutableDictionary* AdCache = [NSMutableDictionary dictionary];
#endif
bool UMoPubFunctions::MoPubHasInterstitial(FString AdUnitId)
{
#if PLATFORM_IOS
MPInterstitialAdController* Interstitial = [AdCache objectForKey:AdUnitId.GetNSString()];
if (Interstitial && Interstitial.ready)
{
return true;
}
#endif
return false;
}
void UMoPubFunctions::MoPubShowInterstitial(FString AdUnitId)
{
#if PLATFORM_IOS
dispatch_async(dispatch_get_main_queue(), ^{
MPInterstitialAdController* Interstitial = [AdCache objectForKey:AdUnitId.GetNSString()];
if (Interstitial && Interstitial.ready)
{
IOSAppDelegate* AppDelegate = (IOSAppDelegate*)[[UIApplication sharedApplication] delegate];
[Interstitial showFromViewController:AppDelegate.IOSController];
}
});
#endif
}
void UMoPubFunctions::MoPubCacheInterstitial(FString AdUnitId)
{
#if PLATFORM_IOS
dispatch_async(dispatch_get_main_queue(), ^{
MPInterstitialAdController* Interstitial = [MPInterstitialAdController interstitialAdControllerForAdUnitId:AdUnitId.GetNSString()];
[Interstitial loadAd];
[AdCache setObject:Interstitial forKey:AdUnitId.GetNSString()];
});
#endif
}
| 26 | 133 | 0.782544 | getsetgames |
5c2a6986d4bf9e84ec93445c5176a83d4a8b7450 | 10,794 | cpp | C++ | 16_1_Tree/main.cpp | Yu-Zhuang/Data-Structure-C | d0c563af93e44420899f547541a8d044f09bcbf0 | [
"MIT"
] | 2 | 2020-06-16T10:02:03.000Z | 2020-06-30T13:22:19.000Z | 16_1_Tree/main.cpp | mild-guy/Data-Structure-C | d0c563af93e44420899f547541a8d044f09bcbf0 | [
"MIT"
] | null | null | null | 16_1_Tree/main.cpp | mild-guy/Data-Structure-C | d0c563af93e44420899f547541a8d044f09bcbf0 | [
"MIT"
] | null | null | null | # include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <time.h>
# include "subFunc.h"
void ARRAY_CREATE(void *nums, int N, int element){
int *array = (int*)nums;
int i = 0, tmp = 0;
static int cp = 0, mv = 0;
// find the site to insert
for(i=0;i<N;i++,cp+=2)
if(element < array[i]) break;
// insert element
cp++;
if(i == N)
{ mv++; array[i-1] = element; }
else{
for(int j=i;j<N;j++,mv++,cp++){
tmp = array[j];
array[j] = element;
element = tmp;
}
}
// output comparison and movement times
for(int k=0;k<N;k++)
{ printf("%5d,", array[k]); if((k+1)%10 IS 0 AND k IS_NOT 0) printf("\n"); }
printf("\n=============== \tcp:%d\tmv:%d\t=====================\n\n", cp, mv);
}
void BST_CREATE(void *root, int N, int element){
BST_NODE *tree = (BST_NODE*)root;
static int cp = 0, mv = 0;
cp+=1; // 判斷
if(N IS 1)
tree->val = element;
else{
while(true){
cp+=3;
if(element < tree->val){
if(tree->left IS NULL){
tree->left = BST_NODE_CREATE(element);
break;
}
else
tree = tree->left;
}
else{
if(tree->right IS NULL){
tree->right = BST_NODE_CREATE(element);
break;
}
else
tree = tree->right;
}
}
}
mv++;
BST_IN_ORDER((BST_NODE*)root);
printf("\n=============== \tcp:%d\tmv:%d\t=====================\n\n", cp, mv);
}
void M_TREE_CREATE(void *root, int N, int element){
printf("\n=====\tM_TREE_CREATE: %d| target: %d\t=====\n", N, element);
M_TREE_NODE *tree = (M_TREE_NODE*)root;
static int cp = 0, mv = 0;
cp++;
if(N IS_NOT 1){
while(true){
cp+=2;
// print node
M_TREE_NODE_PRINT(tree);
if(tree->val[0] < 2){
cp++;
if(tree->val[0] IS 1){
tree->val[2] = element;
cp++;
if(tree->val[1] > element)
{ SWAP(&tree->val[1], &tree->val[2]); mv++; }
}
else
tree->val[1] = element;
tree->val[0]++;
M_TREE_NODE_PRINT(tree);
break;
}
else{ // if(root->val[0] IS 2)
cp++;
if(tree->val[1] > element){
printf("\t: go to left\n");
cp++;
if(tree->left IS NULL){
tree->left = M_TREE_NODE_CREATE(element);
M_TREE_NODE_PRINT(tree->left);
break;
}
else
tree = tree->left;
}
else if(tree->val[1] <= element AND tree->val[2] > element){
cp+=2;
printf("\t: go to mid\n");
cp++;
if(tree->mid IS NULL){
tree->mid = M_TREE_NODE_CREATE(element);
M_TREE_NODE_PRINT(tree->mid);
break;
}
else
tree = tree->mid;
}
else{
cp+=2;
printf("\t: go to right\n");
cp++;
if(tree->right IS NULL){
tree->right = M_TREE_NODE_CREATE(element);
M_TREE_NODE_PRINT(tree->right);
break;
}
else
tree = tree->right;
}
}
}
}
else
{ tree->val[0] += 1; tree->val[1] = element; M_TREE_NODE_PRINT(tree); mv++; return; }
mv++;
printf("\n=============== \tcp:%d\tmv:%d\t=====================\n\n", cp, mv);
}
void INSERT(void *ret, int chose, int N, int element){
switch(chose){
case 1: ARRAY_CREATE(ret, N, element); break;
case 2: BST_CREATE(ret, N, element); break;
case 3: M_TREE_CREATE(ret, N, element); break;
default: printf("\t[ warning : 404 ]\n"); break;
}
}
void* FILE_GET(char *file, int N, int chose){
FILE *fptr = fopen(file, "r");
void *ret = HEAD_CREATE(chose, N);
int take = 0;
if(fptr)
for(int i=0;i<N;i++){
fscanf(fptr,"%d", &take);
INSERT(ret, chose, i+1, take);
}
else
printf("\t[ warning : can't open the file ]\n");
fclose(fptr);
return ret;
}
bool ARRAY_BI_SEARCH(void *nums, int start, int end, int target){
int cp = 0, ret = 0;
int *array = (int*)nums;
while(start IS_NOT (start+end)/2){
cp++;
if(array[(start+end)/2] IS target)
{ ret = 1; break; }
else if(array[(start+end)/2] < target)
{cp++; start = (start+end)/2;}
else
end = (start+end)/2;
}
printf("\t# Comparison times of biSearchArray: %d\n", cp);
return ret;
}
bool BST_BI_SEARCH(void *root, int target){
BST_NODE *tree = (BST_NODE*)root;
int cp = 0;
int ret = 0;
while(tree IS_NOT NULL){
cp++;
if(tree->val IS target)
{ ret = 1; break; }
else if(tree->val > target)
{cp++; tree = tree->left;}
else
tree = tree->right;
}
printf("\t# Comparison times of biSearchBST: %d\n", cp);
return ret;
}
void M_TREE_PRINT(void *tree){
if(tree){
M_TREE_NODE *root = (M_TREE_NODE*)tree;
M_TREE_PRINT(root->left);
for(int i=0;i<root->val[0];i++)
printf("%d,", root->val[i+1]);
M_TREE_PRINT(root->mid);
M_TREE_PRINT(root->right);
}
}
void M_TREE_DELETE(M_TREE_NODE *node, int target){
if(node->val[0] IS 0 OR node IS NULL) {printf("err\n");return;}
printf("Before delete: "); M_TREE_NODE_PRINT(node);
// if node is not leaf
if(node->mid IS_NOT NULL AND node->mid->val[0] IS_NOT 0){
M_TREE_NODE *mxnNode;
if(node->val[1] IS target){ // target is small one
mxnNode = M_TREE_MIN(node->mid);
for(int i=0;i<node->val[0];i++)
if(node->val[i+1] IS target)
node->val[i+1] = mxnNode->val[1];
}
else{
mxnNode = M_TREE_MAX(node->mid);
for(int i=0;i<node->val[0];i++)
if(node->val[i+1] IS target)
node->val[i+1] = mxnNode->val[mxnNode->val[0]];
}
if(node->val[1] > node->val[2])
SWAP(&node->val[1], &node->val[2]);
if(node->val[1] IS target)
M_TREE_DELETE(mxnNode, mxnNode->val[1]);
else
M_TREE_DELETE(mxnNode, mxnNode->val[mxnNode->val[0]]);
}
else if(node->left IS_NOT NULL AND node->left->val[0] IS_NOT 0){
M_TREE_NODE *maxNode = M_TREE_MAX(node->left);
for(int i=0;i<node->val[0];i++)
if(node->val[i+1] IS target)
node->val[i+1] = maxNode->val[maxNode->val[0]];
if(node->val[1] > node->val[2])
SWAP(&node->val[1], &node->val[2]);
M_TREE_DELETE(maxNode, maxNode->val[maxNode->val[0]]);
}
else if(node->right IS_NOT NULL AND node->right->val[0] IS_NOT 0){
M_TREE_NODE *minNode = M_TREE_MIN(node->right);
for(int i=0;i<node->val[0];i++)
if(node->val[i+1] IS target)
node->val[i+1] = minNode->val[1];
if(node->val[1] > node->val[2])
SWAP(&node->val[1], &node->val[2]);
M_TREE_DELETE(minNode, minNode->val[1]);
}
// if node is leaf
else{
if(node->val[0] IS 1){
M_TREE_NODE *tmp = node;
node->val[0] -= 1;
TO_NULL(&node);
//free(tmp);
}
else{
node->val[0] -= 1;
if(node->val[1] IS target)
node->val[1] = node->val[2];
}
}
printf("After delete: "); M_TREE_NODE_PRINT(node);
}
bool M_TREE_SEARCH(void *root, int target){
M_TREE_NODE *tree = (M_TREE_NODE*)root;
int cp = 0;
int ret = 0;
while(tree IS_NOT NULL){
for(int i=0;i<tree->val[0];i++, cp++)
if(tree->val[i+1] IS target)
{ ret = 1; M_TREE_DELETE(tree, target); break; }
cp++;
if(tree->val[1] > target)
tree = tree->left;
else if(tree->val[1] <= target AND tree->val[2] > target)
{cp+=2; tree = tree->mid;}
else
{cp+=2; tree = tree->right;}
}
printf("\t# Comparison times of serch_M_Tree: %d| target: %d\n", cp, target);
return ret;
}
bool SEARCH(void *data, int intergerNum, int target, int chose){
printf("\t# target: %d\n", target);
switch(chose){
case 1: return ARRAY_BI_SEARCH(data, 0, intergerNum-1, target); break;
case 2: return BST_BI_SEARCH(data, target);
case 3: return M_TREE_SEARCH(data, target);
default: printf("err\n"); break;
}
return false;
}
int main(void){
srand(time(NULL));
char file[] = "DB.cpp";
int chose = 3; // 1: array, 2: BST, 3: m-way tree
int target = 500;
int intergerNum = 500;
void *data = NULL;
//FILE_CREATE(file, intergerNum);
data = FILE_GET(file, intergerNum, chose);
if(SEARCH(data, intergerNum, target, chose))
printf("\t# result: find\n");
else
printf("\t# result: not fount\n");
free(data);
return 0;
}
/*
data = FILE_GET(file, intergerNum, chose);
//int ary[500] = { -9983,-9927,-9882,-9881,-9863,-9863,-9829,-9800,-9784,-9732,-9679,-9663,-9646,-9599,-9584,-9499,-9478,-9367,-9318,-9292,-9227,-9224,-9208,-9204,-9200,-9146,-9137,-9018,-9013,-8930,-8890,-8841,-8836,-8759,-8680,-8635,-8584,-8496,-8420,-8408,-8405,-8386,-8367,-8341,-8298,-8284,-8167,-8165,-8153,-8144,-8130,-8119,-8076,-8065,-8055,-8049,-8040,-7957,-7947,-7764,-7732,-7731,-7727,-7698,-7637,-7633,-7602,-7582,-7577,-7575,-7565,-7544,-7521,-7491,-7436,-7421,-7364,-7299,-7298,-7298,-7264,-7198,-7181,-7028,-7018,-6990,-6912,-6888,-6856,-6818,-6806,-6802,-6800,-6786,-6783,-6731,-6689,-6673,-6637,-6611,-6608,-6569,-6532,-6512,-6491,-6428,-6388,-6375,-6320,-6308,-6255,-6240,-6155,-6109,-6065,-6043,-5992,-5987,-5983,-5973,-5874,-5832,-5808,-5769,-5728,-5610,-5575,-5500,-5486,-5485,-5479,-5434,-5431,-5388,-5374,-5216,-5183,-5147,-5134,-5091,-5083,-5034,-5031,-4856,-4847,-4826,-4814,-4799,-4798,-4789,-4696,-4656,-4641,-4627,-4597,-4555,-4540,-4537,-4536,-4467,-4437,-4431,-4388,-4373,-4365,-4358,-4303,-4160,-4127,-3993,-3990,-3969,-3946,-3853,-3831,-3703,-3641,-3326,-3301,-3296,-3264,-3243,-3228,-3115,-3111,-2817,-2751,-2717,-2698,-2660,-2657,-2657,-2596,-2513,-2499,-2279,-2260,-2257,-2242,-2152,-2116,-2032,-2025,-2001,-1875,-1855,-1839,-1799,-1778,-1777,-1761,-1741,-1724,-1644,-1610,-1592,-1564,-1377,-1358,-1297,-1163,-1068,-1017,-964,-941,-926,-919,-891,-883,-819,-797,-795,-678,-654,-636,-616,-592,-570,-551,-473,-466,-393,-383,-379,-377,-372,-335,-314,-285,-222,-118,-58,-30,2,35,51,83,84,91,105,138,150,154,203,227,251,433,443,470,532,546,568,648,650,687,765,779,782,790,832,842,878,887,896,943,971,977,985,1023,1109,1167,1265,1328,1340,1382,1407,1489,1504,1569,1672,1767,1799,1870,1927,1944,1969,1994,2025,2037,2211,2258,2342,2346,2347,2355,2416,2430,2487,2498,2574,2659,2692,2722,2731,2753,2867,2876,3023,3132,3173,3175,3178,3276,3288,3289,3340,3372,3443,3444,3449,3449,3487,3525,3530,3532,3547,3552,3603,3684,3769,3801,3817,3877,3999,4056,4304,4353,4464,4495,4509,4517,4591,4666,4711,4766,4807,4836,4841,4865,4897,4933,4947,4971,5075,5208,5254,5335,5358,5413,5459,5513,5517,5588,5600,5615,5656,5859,5874,5906,5929,5934,5944,5988,6026,6081,6085,6086,6087,6121,6165,6188,6227,6243,6326,6345,6360,6399,6400,6446,6517,6543,6580,6627,6639,6656,6698,6745,6893,6960,6998,7023,7032,7053,7181,7265,7279,7435,7437,7477,7542,7585,7603,7664,7679,7702,7743,7762,7898,7939,7940,7942,8206,8295,8346,8384,8420,8482,8511,8561,8561,8616,8632,8713,8715,8844,8875,8884,8887,8893,8927,8938,8955,8961,8968,9008,9079,9087,9144,9156,9192,9206,9225,9263,9267,9273,9315,9317,9339,9347,9360,9368,9407,9426,9455,9467,9509,9539,9590,9747,9779,9823,9824,9841,9845,9853,9863,9907,9979,9984,9991 };
printf("\n\tbefore: "); M_TREE_PRINT(data); printf("|\n");
FILE *fptr = fopen("DB.cpp", "r");
int take = 0;
for(int i=0;i<intergerNum;i++){
fscanf(fptr, "%d", &take);
if(M_TREE_SEARCH(data, take))
printf("find\n");
else
printf("not found\n");
}
printf("\n\tafter: "); M_TREE_PRINT(data); printf("|\n");
return 0;
}
*/
| 32.808511 | 2,701 | 0.613582 | Yu-Zhuang |
5c2b35a48d00c4d1bf0246880fdfa7ec1bf57e52 | 1,688 | cpp | C++ | @DOC by DIPTA/dipta007_final/Number Theory/divisors-from-factorization(Iterative).cpp | dipta007/Competitive-Programming | 998d47f08984703c5b415b98365ddbc84ad289c4 | [
"MIT"
] | 6 | 2018-10-15T18:45:05.000Z | 2022-03-29T04:30:10.000Z | @DOC by DIPTA/dipta007_final/Number Theory/divisors-from-factorization(Iterative).cpp | dipta007/Competitive-Programming | 998d47f08984703c5b415b98365ddbc84ad289c4 | [
"MIT"
] | null | null | null | @DOC by DIPTA/dipta007_final/Number Theory/divisors-from-factorization(Iterative).cpp | dipta007/Competitive-Programming | 998d47f08984703c5b415b98365ddbc84ad289c4 | [
"MIT"
] | 4 | 2018-01-07T06:20:07.000Z | 2019-08-21T15:45:59.000Z | #include <stdio.h>
#include <string.h>
#include <stdbool.h>
#define LEN 78777
#define MAX 1000010
#define clr(ar) memset(ar, 0, sizeof(ar))
#define read() freopen("lol.txt", "r", stdin)
#define chkbit(ar, i) (((ar[(i) >> 6]) & (1 << (((i) >> 1) & 31))))
#define setbit(ar, i) (((ar[(i) >> 6]) |= (1 << (((i) >> 1) & 31))))
#define isprime(x) (( (x) && ((x)&1) && (!chkbit(ar, (x)))) || ((x) == 2))
int p, prime[LEN];
long long div[7001];
unsigned int ar[(MAX >> 6) + 5] = {0};
int compare(const void* a, const void* b){
long long x = (*(long long*)a);
long long y = (*(long long*)b);
if (x == y) return 0;
return ((x < y) ? -1 : 1);
}
void Sieve(){
int i, j, k;
setbit(ar, 0), setbit(ar, 1);
for (i = 3; (i * i) < MAX; i++, i++){
if (!chkbit(ar, i)){
for (j = (i * i), k = i << 1; j < MAX; j += k) setbit(ar, j);
}
}
for (i = 3, prime[0] = 2, p = 1; i < MAX; i++, i++){
if (isprime(i)) prime[p++] = i;
}
}
int divisors(long long x){
int i, j, l, k, c, len = 0;
for (i = 0, div[len++] = 1; i < p; i++){
if ((long long)prime[i] * prime[i] > x) break;
c = 0, k = len;
while (!(x % prime[i])) c++, x /= prime[i];
long long y = prime[i];
for (j = 0; j < c; j++, y *= prime[i]){
for (l = 0; l < k; l++) div[len++] = y * div[l];
}
}
for (j = 0, k = len; j < k && x > 1; j++) div[len++] = div[j] * x;
qsort(div, len, sizeof(long long), compare);
return len;
}
int main(){
Sieve();
int i, j, k, x = divisors(2 * 3 * 5 * 21);
printf("%d\n", x);
for (i = 0; i < x; i++) printf("%lld\n", div[i]);
return 0;
}
| 25.969231 | 74 | 0.438981 | dipta007 |
5c2b656adc28b905c8d41693ec76a04dd3f6b74e | 384 | cpp | C++ | Way_Too_Long_Words.cpp | amit9amarwanshi/The_Quiet_Revolution | 7713787ef27c0c144e4c2d852d826ee1c4176a95 | [
"MIT"
] | null | null | null | Way_Too_Long_Words.cpp | amit9amarwanshi/The_Quiet_Revolution | 7713787ef27c0c144e4c2d852d826ee1c4176a95 | [
"MIT"
] | null | null | null | Way_Too_Long_Words.cpp | amit9amarwanshi/The_Quiet_Revolution | 7713787ef27c0c144e4c2d852d826ee1c4176a95 | [
"MIT"
] | null | null | null | #include <iostream>
#include<string>
using namespace std;
int main()
{
unsigned int n,x;
cin>>n;
if(n<101)
{
while(n--)
{
string s;
cin>>s;
x=s.length();
if(x<101)
{ if(x>10)
{
cout<<s[0]<<x-2<<s[x-1];
}
else
{
cout<<s;
}
}
cout<<"\n";
}
}
return 0;
}
| 11.636364 | 35 | 0.372396 | amit9amarwanshi |
5c2e494f3b64838cca4aa1da5583aaf9eaab496b | 2,543 | cc | C++ | src/count_bits_set.cc | OpenEye-Contrib/Flush | 71fc76cdf3348006d13d53a26fd0a6e1bc55addd | [
"BSD-3-Clause"
] | 5 | 2016-05-11T09:09:29.000Z | 2022-03-30T11:06:19.000Z | src/count_bits_set.cc | OpenEye-Contrib/Flush | 71fc76cdf3348006d13d53a26fd0a6e1bc55addd | [
"BSD-3-Clause"
] | null | null | null | src/count_bits_set.cc | OpenEye-Contrib/Flush | 71fc76cdf3348006d13d53a26fd0a6e1bc55addd | [
"BSD-3-Clause"
] | 2 | 2018-03-19T21:59:43.000Z | 2019-01-31T03:10:50.000Z | // take a flush fp file and write out the number of bits set in each cpd.
// takes 1 command line argument, the name of the fp file.
#include <fstream>
#include <iostream>
#include <stdio.h>
#include "ByteSwapper.H"
#include "Fingerprint.H"
using namespace std;
#include "AbstractPoint.H"
int AbstractPoint::next_seq_num = 0;
// on a bigendian machine, spells Dave.
static const int MAGIC_INT = 0x65766144;
// as it appears on a littleendian machine
static const int BUGGERED_MAGIC_INT = 0x44617665;
// ***************************************************************************
int main( int argc , char **argv ) {
if( argc < 2 ) {
cerr << " Error : need the name of a fingerprints file" << endl;
exit( 1 );
}
FILE *infile = fopen( argv[1] , "rb" );
if( !infile ) {
cerr << "Failed to open " << argv[1] << " for reading" << endl;
return false;
}
// take the integer off the top to get things set up correctly.
// in a new fp file, the very first integer will be either MAGIC_INT
// or BUGGERED_MAGIC_INT and indicates whether the machine reading and the
// machine writing were both in the same bigendian/littleendian format.
// if the first integer is neither of these, indicates that the file is in
// the old format - we'll assume no byteswapping.
bool byte_swapping;
int i , num_chars;
fread( &i , sizeof( int ) , 1 , infile );
if( i == MAGIC_INT ) {
fread( &num_chars , sizeof( int ) , 1 , infile );
byte_swapping = false;
} else if( i == BUGGERED_MAGIC_INT ) {
fread( &num_chars , sizeof( int ) , 1 , infile );
dac_byte_swapper<int>( num_chars );
byte_swapping = true;
} else {
byte_swapping = false;
num_chars = i;
}
fread( &i , sizeof( int ) , 1 , infile );
int max_mol_name_len = 0 , len;
char *mol_name = 0;
unsigned char *finger_chars = 0;
while( 1 ) {
if( !finger_chars )
finger_chars = new unsigned char[num_chars];
if( !fread( &len , sizeof( int ) , 1 , infile ) )
return false;
if( byte_swapping )
dac_byte_swapper<int>( len );
if( len > max_mol_name_len ) {
delete [] mol_name;
mol_name = new char[len + 1];
max_mol_name_len = len + 1;
}
if( !fread( mol_name , sizeof( char ) , len + 1 , infile ) )
break;
if( !fread( finger_chars , sizeof( unsigned char ) ,
num_chars , infile ) )
break;
Fingerprint finger( mol_name , num_chars , finger_chars );
cout << mol_name << " " << finger.get_num_bits_set() << endl;
}
}
| 28.897727 | 78 | 0.613055 | OpenEye-Contrib |
5c2fce3d13ef2186b75ed462e3bedaf1617f1827 | 2,151 | cpp | C++ | ExternalCode/copasi/UI/CQFittingResultTab1.cpp | dhlee4/Tinkercell_new | c4d1848bbb905f0e1f9e011837268ac80aff8711 | [
"BSD-3-Clause"
] | 1 | 2021-01-07T13:12:51.000Z | 2021-01-07T13:12:51.000Z | ExternalCode/copasi/UI/CQFittingResultTab1.cpp | dhlee4/Tinkercell_new | c4d1848bbb905f0e1f9e011837268ac80aff8711 | [
"BSD-3-Clause"
] | 7 | 2020-04-12T22:25:46.000Z | 2020-04-13T07:50:40.000Z | ExternalCode/copasi/UI/CQFittingResultTab1.cpp | daniel-anavaino/tinkercell | 7896a7f809a0373ab3c848d25e3691d10a648437 | [
"BSD-3-Clause"
] | 2 | 2020-04-12T21:57:01.000Z | 2020-04-12T21:59:29.000Z | // Begin CVS Header
// $Source: /fs/turing/cvs/copasi_dev/copasi/UI/CQFittingResultTab1.cpp,v $
// $Revision: 1.6 $
// $Name: Build-33 $
// $Author: aekamal $
// $Date: 2010/06/07 14:01:52 $
// End CVS Header
// Copyright (C) 2010 by Pedro Mendes, Virginia Tech Intellectual
// Properties, Inc., University of Heidelberg, and The University
// of Manchester.
// All rights reserved.
#include "CQFittingResultTab1.h"
#include "copasi.h"
#include "parameterFitting/CFitProblem.h"
#include "parameterFitting/CFitItem.h"
#include "parameterFitting/CExperimentSet.h"
#include "parameterFitting/CExperiment.h"
#include "UI/qtUtilities.h"
/*
* Constructs a CQFittingResultTab1 which is a child of 'parent', with the
* name 'name'.'
*/
CQFittingResultTab1::CQFittingResultTab1(QWidget* parent, const char* name, Qt::WindowFlags fl)
: QWidget(parent, name, fl)
{
setupUi(this);
init();
}
/*
* Destroys the object and frees any allocated resources
*/
CQFittingResultTab1::~CQFittingResultTab1()
{
// no need to delete child widgets, Qt does it all for us
}
/*
* Sets the strings of the subwidgets using the current
* language.
*/
void CQFittingResultTab1::languageChange()
{
retranslateUi(this);
}
void CQFittingResultTab1::load(const CFitProblem * pProblem)
{
mpEditObjectiveValue->setText(QString::number(pProblem->getSolutionValue()));
mpEditRMS->setText(QString::number(pProblem->getRMS()));
mpEditStdDeviation->setText(QString::number(pProblem->getStdDeviation()));
#ifndef COPASI_CROSSVALIDATION
mpLblCVObjectiveValue->hide();
mpEditCVObjectiveValue->hide();
mpLblCVRMS->hide();
mpEditCVRMS->hide();
mpLblCVStdDeviation->hide();
mpEditCVStdDeviation->hide();
#endif // not COPASI_CROSSVALIDATION
const unsigned C_INT32 & FunctionEvaluations = pProblem->getFunctionEvaluations();
mpEditEvaluations->setText(QString::number(FunctionEvaluations));
const C_FLOAT64 & ExecutionTime = pProblem->getExecutionTime();
mpEditCPUTime->setText(QString::number(ExecutionTime));
mpEditSpeed->setText(QString::number(FunctionEvaluations / ExecutionTime));
}
void CQFittingResultTab1::init()
{}
| 27.576923 | 95 | 0.74198 | dhlee4 |
5c32c4a33031552d792c472253b2bc82610af017 | 33,992 | cpp | C++ | src/RTL/Component/ModifierChain/IFXModifierChainState.cpp | alemuntoni/u3d | 7907b907464a2db53dac03fdc137dcb46d447513 | [
"Apache-2.0"
] | 44 | 2016-05-06T00:47:11.000Z | 2022-02-11T06:51:37.000Z | src/RTL/Component/ModifierChain/IFXModifierChainState.cpp | alemuntoni/u3d | 7907b907464a2db53dac03fdc137dcb46d447513 | [
"Apache-2.0"
] | 3 | 2016-06-27T12:37:31.000Z | 2021-03-24T12:39:48.000Z | src/RTL/Component/ModifierChain/IFXModifierChainState.cpp | alemuntoni/u3d | 7907b907464a2db53dac03fdc137dcb46d447513 | [
"Apache-2.0"
] | 15 | 2016-02-28T11:08:30.000Z | 2021-06-01T03:32:01.000Z | //***************************************************************************
//
// Copyright (c) 1999 - 2006 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.
//
//***************************************************************************
/*
@file IFXModifierChainState.cpp
The implementation file of the CIFXModifierChain component.
*/
#include "IFXModifierChainState.h"
#include "IFXModifierChain.h"
#include "IFXModifierChainInternal.h"
#include "IFXModifierDataPacketInternal.h"
#include "IFXModifier.h"
#include "IFXCoreCIDs.h"
#include <memory.h>
IFXDataPacketState::IFXDataPacketState()
{
m_NumDataElements = 0;
m_Enabled = FALSE;
m_LockedDataElement = INVALID_DATAELEMENT_INDEX;
m_pDids = NULL;
m_pDataElements = NULL;
m_pDataPacket = NULL;
m_pModifier = NULL;
}
IFXDataPacketState::~IFXDataPacketState()
{
IFXDELETE_ARRAY(m_pDataElements);
IFXRELEASE(m_pDataPacket);
IFXRELEASE(m_pModifier);
}
IFXDataElementState::IFXDataElementState()
{
State = IFXDATAELEMENTSTATE_INVALID;
AspectBit = 0;
Pad = 0;
pValue = NULL;
bNeedRelease = FALSE;
ChangeCount = 0;
Generator = INVALID_DATAPACKET_INDEX;
m_uInvCount = 0;
m_uInvAllocated = 0;
m_pInvSeq = 0;
}
IFXDataElementState::~IFXDataElementState()
{
if (bNeedRelease)
((IFXUnknown*)pValue)->Release();
IFXDELETE_ARRAY(m_pInvSeq);
}
IFXRESULT IFXDataElementState::AddInv(U32 in_ModIdx, U32 in_ElIdx)
{
// Check For Duplicate
if( m_pInvSeq )
{
U32 i;
for( i = 0; i < m_uInvCount; ++i)
{
if(m_pInvSeq[i].uEIndex == in_ElIdx && m_pInvSeq[i].uMIndex == in_ModIdx)
{
return IFX_OK;
}
}
}
// Grow if Needed
if( m_uInvCount == m_uInvAllocated )
{
IFXDidInvElement* pTmpInvs = new IFXDidInvElement[m_uInvAllocated + IFXDIDINVSEQGROWSIZE];
if(!pTmpInvs)
{
return IFX_E_OUT_OF_MEMORY;
}
if(m_pInvSeq)
{
memcpy(pTmpInvs, m_pInvSeq, sizeof(IFXDidInvElement) * (m_uInvAllocated));
IFXDELETE_ARRAY(m_pInvSeq);
}
m_pInvSeq = pTmpInvs;
m_uInvAllocated += IFXDIDINVSEQGROWSIZE;
}
m_pInvSeq[m_uInvCount].uEIndex = in_ElIdx;
m_pInvSeq[m_uInvCount].uMIndex = in_ModIdx;
++m_uInvCount;
return IFX_OK;
}
IFXIntraDependencies::IFXIntraDependencies()
{
Size = 0;
AllocatedSize = 0;
pDepElementsList = NULL;
}
IFXIntraDependencies::~IFXIntraDependencies()
{
IFXDELETE_ARRAY( pDepElementsList );
}
IFXRESULT IFXIntraDependencies::AddDependentElement(U32 in_DepEl, U32 in_Attr)
{
// Check For Duplicate
U32 i;
for( i = 0; i < Size; ++i)
{
if(pDepElementsList[i].uEIndex == in_DepEl)
{
pDepElementsList[i].uDepAttr |= in_Attr;
return IFX_OK;
}
}
// Grow if Needed
if( AllocatedSize == Size )
{
sElementDependency* pTmpDepElementsList = new sElementDependency[AllocatedSize + IFXDIDDEPSEQGROWSIZE];
if(!pTmpDepElementsList)
{
return IFX_E_OUT_OF_MEMORY;
}
if(pDepElementsList)
{
memcpy(pTmpDepElementsList, pDepElementsList,
sizeof(sElementDependency) * (Size));
IFXDELETE_ARRAY(pDepElementsList);
}
pDepElementsList = pTmpDepElementsList;
AllocatedSize += IFXDIDDEPSEQGROWSIZE;
}
pDepElementsList[Size].uEIndex = in_DepEl;
pDepElementsList[Size].uDepAttr = in_Attr;
++Size;
return IFX_OK;
}
IFXRESULT IFXIntraDependencies::CopyFrom(IFXIntraDependencies* in_pSrc)
{
Size = in_pSrc->Size;
AllocatedSize = in_pSrc->AllocatedSize;
if(AllocatedSize)
{
IFXASSERT( NULL == pDepElementsList );
pDepElementsList = new sElementDependency[AllocatedSize];
if(!pDepElementsList)
{
return IFX_E_OUT_OF_MEMORY;
}
if(in_pSrc->pDepElementsList)
{
memcpy(pDepElementsList, in_pSrc->pDepElementsList,
sizeof(sElementDependency) * (Size));
}
}
return IFX_OK;
}
void IFXIntraDependencies::CopyTo(IFXIntraDependencies* in_pSrc)
{
Size = in_pSrc->Size;
AllocatedSize = in_pSrc->AllocatedSize;
IFXASSERT( !pDepElementsList || ( in_pSrc->pDepElementsList != pDepElementsList ) );
IFXDELETE_ARRAY( pDepElementsList );
pDepElementsList = in_pSrc->pDepElementsList;
in_pSrc->Size = 0;
in_pSrc->AllocatedSize = 0;
in_pSrc->pDepElementsList = NULL;
}
IFXModifierChainState::IFXModifierChainState()
{
m_bNeedTime = FALSE;
m_NumModifiers = 0;
m_NumDataElements = 0;
m_NumAllocatedDataElements = 0;
m_pDids = NULL;
m_pDepSeq = NULL;
m_pDidRegistry = NULL;
m_pDataPacketState = NULL;
m_pBaseDataPacket = NULL;
m_pTime = NULL;
m_pPreviousModifierChain= NULL;
m_pModChain = NULL;
m_pTransform = NULL;
}
IFXModifierChainState::~IFXModifierChainState()
{
Destruct();
}
IFXRESULT IFXModifierChainState::Destruct()
{
IFXRELEASE(m_pBaseDataPacket);
m_pDidRegistry = NULL;
IFXDELETE_ARRAY(m_pDids);
IFXDELETE_ARRAY(m_pDepSeq);
IFXDELETE_ARRAY(m_pDataPacketState); // this cleans up the references and allocated data on each state.
m_NumModifiers = 0;
m_NumAllocatedDataElements = 0;
m_bNeedTime = FALSE;
m_NumDataElements = 0;
IFXRELEASE(m_pPreviousModifierChain);
m_pModChain = NULL;
IFXDELETE(m_pTransform);
return IFX_OK;
}
IFXRESULT IFXModifierChainState::Initialize(IFXModifierChainInternal* in_pModChain,
IFXModifierChainInternal* in_pBaseChain,
IFXModifierDataPacketInternal *in_pOverrideDP,
U32 in_Size,
IFXDidRegistry* in_pDidRegistry)
{
IFXRESULT result = IFX_OK;
m_pModChain = in_pModChain;
m_pPreviousModifierChain = in_pBaseChain;
IFXADDREF(m_pPreviousModifierChain);
if( m_pPreviousModifierChain && !in_pOverrideDP )
{
IFXASSERT( !m_pBaseDataPacket );
IFXModifierDataPacket* pDp = NULL;
m_pPreviousModifierChain->GetDataPacket(pDp);
pDp->QueryInterface(IID_IFXModifierDataPacketInternal, (void**)&m_pBaseDataPacket);
IFXRELEASE(pDp);
}
else if( in_pOverrideDP )
{
m_pBaseDataPacket = in_pOverrideDP;
m_pBaseDataPacket->AddRef();
}
m_pDidRegistry = in_pDidRegistry;
if( IFXSUCCESS(result) )
{
m_NumModifiers = in_Size+1;
// Allocate the DataPacket States
IFXASSERT(!m_pDataPacketState);
m_pDataPacketState = new IFXDataPacketState[m_NumModifiers];
if(!m_pDataPacketState)
{
result = IFX_E_OUT_OF_MEMORY;
}
}
// Do Partial initialization of the states.
if( IFXSUCCESS(result) )
{
U32 i;
for( i = 0; i < m_NumModifiers; ++i)
{
IFXModifierDataPacketInternal* pDataPacket = NULL;
result = IFXCreateComponent( CID_IFXModifierDataPacket,
IID_IFXModifierDataPacketInternal,
(void**) &(pDataPacket) );
if(IFXSUCCESS(result))
{
// set up the proxy data packet
result = pDataPacket->SetModifierChain( in_pModChain,
i - 1,
m_pDataPacketState + i);
}
if(IFXSUCCESS(result))
{
m_pDataPacketState[i].m_pDataPacket = pDataPacket;
}
else
{
IFXRELEASE(pDataPacket);
}
}
}
if(IFXFAILURE(result))
{
Destruct();
}
return result;
}
IFXRESULT IFXModifierChainState::SetModifier(U32 in_Idx, IFXModifier* in_pMod,
BOOL in_bEnabled)
{
IFXRESULT result = IFX_OK;
IFXASSERT(in_Idx < m_NumModifiers);
if(IFXSUCCESS(result) && in_pMod)
{
m_pDataPacketState[in_Idx].m_pModifier = in_pMod;
m_pDataPacketState[in_Idx].m_Enabled = in_bEnabled;
if(in_pMod)
in_pMod->AddRef();
}
return result;
}
IFXRESULT IFXModifierChainState::GetModifier(U32 in_Idx,
IFXModifier** out_ppMod)
{
IFXRESULT result = IFX_OK;
IFXASSERT(in_Idx < m_NumModifiers);
if(IFXSUCCESS(result))
{
*out_ppMod = m_pDataPacketState[in_Idx].m_pModifier;
(*out_ppMod)->AddRef();
}
return result;
}
IFXRESULT IFXModifierChainState::GetModifierDataPacket(U32 in_Idx,
IFXModifierDataPacket** out_ppModDP)
{
IFXRESULT result = IFX_OK;
if(in_Idx > (m_NumModifiers - 1))
{
result = IFX_E_INVALID_RANGE;
}
if(IFXSUCCESS(result))
{
result = m_pDataPacketState[in_Idx].m_pDataPacket->QueryInterface(
IID_IFXModifierDataPacket,
(void**)out_ppModDP);
}
return result;
}
IFXRESULT IFXModifierChainState::SetActive()
{
IFXRESULT result = IFX_OK;
IFXASSERT(m_pDataPacketState);
IFXModifier* pMod = NULL;
if(m_NumModifiers > 1)
{
pMod = m_pDataPacketState[1].m_pModifier;
if(pMod)
{
if(m_pDataPacketState[1].m_Enabled )
{
pMod->SetModifierChain( m_pModChain, 0 );
result = pMod->SetDataPacket( GetBaseDataPacketNR(),
m_pDataPacketState[1].m_pDataPacket);
}
else
{
pMod->SetModifierChain( NULL, (U32)-1 );
pMod->SetDataPacket( NULL, NULL );
}
}
}
U32 stage;
for( stage=2; stage<m_NumModifiers && IFXSUCCESS(result); stage++ )
{
pMod = m_pDataPacketState[stage].m_pModifier;
if( pMod )
{
if(m_pDataPacketState[stage].m_Enabled )
{
pMod->SetModifierChain( m_pModChain, stage-1 );
result = pMod->SetDataPacket( m_pDataPacketState[stage-1].m_pDataPacket, // lod setdp failing
m_pDataPacketState[stage].m_pDataPacket);
}
else
{
pMod->SetModifierChain( NULL, (U32)-1 );
pMod->SetDataPacket( NULL, NULL );
}
}
}
return result;
}
IFXRESULT IFXModifierChainState::NotifyActive()
{
IFXRESULT result = IFX_OK;
IFXASSERT(m_pDataPacketState);
U32 stage;
for ( stage=1; stage<m_NumModifiers && IFXSUCCESS(result)
; stage++ )
{
if(m_pDataPacketState[stage].m_Enabled )
{
m_pDataPacketState[stage].m_pModifier->Notify(IFXModifier::NEW_MODCHAIN_STATE, NULL);
}
}
return result;
}
IFXRESULT IFXModifierChainState::Build(BOOL in_bReqValidation)
{
IFXRESULT result = IFX_OK;
IFXASSERT(m_pDataPacketState);
// 1. Set up the proxy data packet
if(IFXSUCCESS(result))
{
result = BuildProxyDataPacket();
}
IFXASSERT(IFXSUCCESS(result));
// 2. Iterate the Modifiers and attempt to build them
if(IFXSUCCESS(result))
{
U32 i;
for( i = 1; i < m_NumModifiers; ++i)
{
result = BuildModifierDataPacket(i, in_bReqValidation);
IFXASSERT(IFXSUCCESS(result));
}
}
// 3. Add the invalidation sequence to make the last
// data packet trigger forwarding invalidations to the
// appended chains.
if(IFXSUCCESS(result))
{
result = AddAppendedChainInvSeq();
}
return result;
}
IFXRESULT IFXModifierChainState::BuildProxyDataPacket()
{
IFXRESULT result = IFX_OK;
// "external copy"
// if we have an m_pBaseDataPacket (prepended mod chain) -- Add all the elements from that
// else just add time;
if( m_pBaseDataPacket )
{
U32 NumDids = 0;
IFXDataPacketState* pState = NULL;
IFXDidEntry* pDids = NULL;
IFXIntraDependencies* pDepSeq = NULL;
// Copy All of the Dids Forward
result = m_pBaseDataPacket->GetDataPacketState( &pState, &pDepSeq );
if(IFXSUCCESS(result))
{
NumDids = pState->m_NumDataElements;
pDids = pState->m_pDids;
// cause dids array & outputs to be set to specific size...
if(!GrowDids(NumDids))
{
result = IFX_E_OUT_OF_MEMORY;
}
}
// Iteration & set important state
if(IFXSUCCESS(result))
{
memcpy(m_pDids, pDids, sizeof(IFXDidEntry) * NumDids);
m_NumDataElements = NumDids;
m_pDataPacketState[0].m_NumDataElements = NumDids;
m_pDataPacketState[0].m_Enabled = TRUE;
// Copy Consumed State
IFXDataElementState* pDEState = new IFXDataElementState[NumDids];
IFXASSERT( NULL == m_pDataPacketState[0].m_pDataElements );
m_pDataPacketState[0].m_pDataElements = pDEState;
IFXDataElementState* pSrcDEState = pState->m_pDataElements;
U32 i;
for( i = 0; i < NumDids; ++i)
{
pDEState[i].State = IFXDATAELEMENTSTATE_INVALID;
if (pDEState[i].bNeedRelease && pDEState[i].pValue)
((IFXUnknown*)pDEState[i].pValue)->Release();
pDEState[i].bNeedRelease = pSrcDEState[i].bNeedRelease;
pDEState[i].pValue = pSrcDEState[i].pValue;
if (pDEState[i].bNeedRelease)
((IFXUnknown*)pDEState[i].pValue)->AddRef();
pDEState[i].ChangeCount = pSrcDEState[i].ChangeCount;
pDEState[i].Generator = PROXY_DATAPACKET_INDEX;
// Copy the DepSeq
m_pDepSeq[i].CopyFrom(pDepSeq+i);
}
}
}
else
{
// Hardcode 1st elements: 0 = simtime, 1 = xform
IFXASSERT( 0 == TIME_ELEMENT_INDEX );
IFXASSERT( 1 == TRANSFORM_ELEMENT_INDEX );
if(INVALID_DATAELEMENT_INDEX == AppendDid(DID_IFXSimulationTime, 0))
{
result = IFX_E_OUT_OF_MEMORY;
}
if(INVALID_DATAELEMENT_INDEX == AppendDid(DID_IFXTransform, 0))
{
result = IFX_E_OUT_OF_MEMORY;
}
IFXDataElementState* pDEState = new IFXDataElementState[2];
IFXASSERT( NULL == m_pDataPacketState[0].m_pDataElements );
m_pDataPacketState[0].m_pDataElements = pDEState;
pDEState[0].State = IFXDATAELEMENTSTATE_INVALID;
pDEState[0].pValue = NULL;
pDEState[0].bNeedRelease = FALSE;
pDEState[0].ChangeCount = 0;
pDEState[0].Generator = 0;
IFXDELETE( m_pTransform );
m_pTransform = new IFXArray<IFXMatrix4x4>;
IFXASSERT( NULL != m_pTransform );
m_pTransform->CreateNewElement();
m_pTransform->GetElement(0).MakeIdentity();
pDEState[1].State = IFXDATAELEMENTSTATE_VALID;
pDEState[1].pValue = m_pTransform;
pDEState[1].bNeedRelease = FALSE;
pDEState[1].ChangeCount = 0;
pDEState[1].Generator = 0;
}
return IFX_OK;
}
// Add Invalidation Sequence to the Appended Chain
IFXRESULT IFXModifierChainState::AddAppendedChainInvSeq()
{
IFXRESULT result = IFX_OK;
IFXDataElementState* pDEState = NULL;
U32 NumDE = 0;
if( IFXSUCCESS(result) )
{
pDEState = m_pDataPacketState[m_NumModifiers-1].m_pDataElements;
NumDE = m_pDataPacketState[m_NumModifiers-1].m_NumDataElements;
}
if( IFXSUCCESS(result) )
{ // tell the generators of every data element that exists at the end of
// the Data packet that they need to invalidate appended chains.
U32 i;
for( i = 0; i < NumDE; i++ )
{
if( pDEState->State != IFXDATAELEMENTSTATE_CONSUMED )
{
U32 GenIdx = (pDEState->Generator == PROXY_DATAPACKET_INDEX) ? 0 : pDEState->Generator;
IFXASSERT(GenIdx < m_NumModifiers);
m_pDataPacketState[GenIdx].m_pDataElements[i].AddInv( APPENDED_DATAPACKET_INDEX, i );
}
pDEState++;
}
}
return result;
}
IFXRESULT IFXModifierChainState::BuildModifierDataPacket(U32 in_ModIdx,
BOOL in_bReqValidation)
{
IFXRESULT result = IFX_OK;
IFXGUID** pOutputs = NULL;
U32* upOutputUnchangedAttrs = NULL;
U32 uOutputCount = 0;
IFXGUID** pInputs = NULL;
U32 uInputCount = 0;
IFXGUID** pOutputDependencies = NULL;
U32* upOutputDependencyAttrs = NULL;
U32 uOutputDependencyCount = 0;
U32 o = 0;
//U32 uOutputIdx = (U32)INVALID_DATAPACKET_INDEX;
IFXDataPacketState* pDPState = &(m_pDataPacketState[in_ModIdx]);
IFXModifier* pMod = m_pDataPacketState[in_ModIdx].m_pModifier;
// Temp data for the duration of this function
U32* pOutputIndexes = NULL;
if( !pMod )
{ // if the modifier is NULL then we just populate the datapacket and escape.
// this may be the case during loads.
pDPState->m_NumDataElements = m_pDataPacketState[in_ModIdx-1].m_NumDataElements;
result = BMDPPopulateDataElements(in_ModIdx);
return result;
}
// 1. Get the output list from the Modifier
if( IFXSUCCESS(result) )
{
result = pMod->GetOutputs( pOutputs, uOutputCount,
upOutputUnchangedAttrs );
}
// 2. verify all of the inputs are satisfied
if( IFXSUCCESS(result) )
{
result = BMDPVerifyInputs( in_ModIdx, pMod, pOutputs, uOutputCount );
if( IFXFAILURE(result) )
{
// if Req Validation -- pass on failure
// else not req Validation Mark this as disabled
// and move along.
// the logic is as follows: in validation is not required,
// no problem, if validation is required and a modifier
// that was previously enabled becomes disabled, then
// it is and error. However if a previously disabled
// modifier becomes enabled then all is good.
if( !in_bReqValidation || pDPState->m_Enabled == FALSE )
{
pDPState->m_NumDataElements = m_pDataPacketState[in_ModIdx-1].m_NumDataElements;
result = BMDPPopulateDataElements(in_ModIdx);
// make sure we're set to disabled
pDPState->m_Enabled = FALSE;
return result;
}
return IFX_E_MODIFIERCHAIN_VALIDATION_FAILED;
}
else
{
pDPState->m_Enabled = TRUE;
}
}
if( IFXSUCCESS(result) )
{
pOutputIndexes = new U32[uOutputCount];
if( pOutputIndexes )
{
memset( pOutputIndexes, 0, sizeof(U32) * uOutputCount );
}
else
{
result = IFX_E_OUT_OF_MEMORY;
}
}
// 3. Initialize the DataPacket
// - Get all of the current Items in to the new Data Packet
// - Add the Modifier's Output DataElements to the new DataPacket
// pOutputs and uOutputCount retreived on previous call
// - Has Side effect of building the output index array
if( IFXSUCCESS(result) )
{
pDPState->m_NumDataElements = m_pDataPacketState[in_ModIdx-1].m_NumDataElements;
result = BMDPAddOutputs( in_ModIdx, pOutputs, uOutputCount, pOutputIndexes );
}
/// @todo: for all intra dependent outputs,
/// call XYXY() = BMDPCollapseDependencies Purge/Cleanse will never
// 4. Allocate and Copy the DataElementStates
if( IFXSUCCESS(result) )
{
result = BMDPPopulateDataElements( in_ModIdx );
}
// 4.5 Configure all of the Outputs
if( IFXSUCCESS(result) )
{
result = BMDPConfigureOutputs( in_ModIdx, uOutputCount,
pOutputIndexes );
}
// 5. Iterate over the Outputs to build up the inv sequence and the
// dep seq.
// 5.1 consume any consumed data elements
o = uOutputCount;
while( o-- && IFXSUCCESS(result) )
{
if ((*(pOutputs[o]) == DTS_IFXRenderable) || (*(pOutputs[o]) == DTS_IFXBound))
{
/// @todo: what we probably should do is iterate all out puts and do
/// the call below for each renderable output.
}
else
{
// 5.1.1 now check to see if the generation of this data element
// causes invalidation of a previously generated dependent data
// element.
if( IFXSUCCESS(result) )
{
result = BMDPConsumeElements( in_ModIdx, pOutputIndexes[o],
upOutputUnchangedAttrs ? upOutputUnchangedAttrs[o] : 0 );
}
}
}
// 5.2 Build up all the validation/invalidation seqs
o = uOutputCount;
while( o-- && IFXSUCCESS(result) )
{
// 5.2.1 Get the input dependencies and the output dependencies
if( IFXSUCCESS(result) )
{
result = pMod->GetDependencies( pOutputs[o],
pInputs,
uInputCount,
pOutputDependencies,
uOutputDependencyCount,
upOutputDependencyAttrs );
}
// 5.2.3 for each input dep of output o, add the input dependencies
// to the list
if( IFXSUCCESS(result) )
{
result = BMDPScheduleInvalidations( in_ModIdx,
pOutputIndexes[o], pOutputs[o], pInputs, uInputCount );
}
// 5.2.4 foreach output dependency dep of output o,
// add the input dependencies to the list
if( IFXSUCCESS(result) )
{
result = BMDPSetOutputDeps( in_ModIdx,
pOutputIndexes[o],
pOutputs[o],
pOutputDependencies,
uOutputDependencyCount,
upOutputDependencyAttrs);
}
}
// 6. for each element not generated by this modifier set it as a dependendent on
// the last modifier that generated it.
if( IFXSUCCESS(result) )
{
result = BMDPScheduleDefaultInvalidations(in_ModIdx);
}
IFXDELETE_ARRAY(pOutputIndexes);
return result;
}
IFXRESULT IFXModifierChainState::BMDPVerifyInputs(U32 in_ModIdx,
IFXModifier* pMod,
IFXDID** ppOutputs,
U32 NumOutputs)
{
IFXRESULT result = IFX_OK;
IFXGUID** pInputs = NULL;
U32 uInputCount = 0;
IFXGUID** pOutputDependencies = NULL;
U32* upOutputDependencyAttrs = NULL;
U32 uOutputDependencyCount = 0;
U32 i;
for( i = 0; i < NumOutputs && IFXSUCCESS(result); ++i)
{
result = pMod->GetDependencies( ppOutputs[i],
pInputs,
uInputCount,
pOutputDependencies,
uOutputDependencyCount,
upOutputDependencyAttrs );
if( IFXSUCCESS(result) )
{
U32 j;
for( j = 0; j < uInputCount; ++j )
{
U32 uDidIndex = GetDidIndex(*(pInputs[j]), in_ModIdx-1);
if( INVALID_DATAPACKET_INDEX == uDidIndex )
{
result = IFX_E_DATAPACKET_ELEMENT_NOT_FOUND;
break;
}
// need to check if this is consumed
else if( m_pDataPacketState[in_ModIdx-1].m_pDataElements[uDidIndex].State == IFXDATAELEMENTSTATE_CONSUMED )
{
/// @todo: clean up these err codes - change to IFX_E_DATAPACKET...
result = IFX_E_MODIFIER_DATAPACKET_ENTRY_CONSUMED;
break;
}
}
}
}
return result;
}
IFXRESULT IFXModifierChainState::BMDPAddOutputs( U32 in_ModIdx,
IFXDID** in_ppOutputs,
U32 in_uNumOutputs,
U32* pOutputIndices )
{
IFXRESULT result = IFX_OK;
U32 o = in_uNumOutputs;
while( o-- && IFXSUCCESS(result) )
{
if ( (DTS_IFXRenderable == *(in_ppOutputs[o])) || (DTS_IFXBound == *(in_ppOutputs[o])) )
{
pOutputIndices[o] = INVALID_DATAELEMENT_INDEX;
}
else
{
pOutputIndices[o] = GetDidIndex( *(in_ppOutputs[o]), in_ModIdx );
if( pOutputIndices[o] == INVALID_DATAELEMENT_INDEX )
{
pOutputIndices[o] = AppendDid(*(in_ppOutputs[o]), in_ModIdx);
if( INVALID_DATAELEMENT_INDEX == pOutputIndices[o] )
{
result = IFX_E_OUT_OF_MEMORY;
}
}
}
}
return result;
}
// Create a New Array of Data Element States for the DataPacket State of this modifier
IFXRESULT IFXModifierChainState::BMDPPopulateDataElements(U32 in_ModIdx)
{
IFXDataPacketState* pDPState = &(m_pDataPacketState[in_ModIdx]);
IFXDataElementState* pDE = new IFXDataElementState[pDPState->m_NumDataElements];
if( !pDE )
{
return IFX_E_OUT_OF_MEMORY;
}
IFXDELETE_ARRAY( pDPState->m_pDataElements );
pDPState->m_pDataElements = pDE;
U32 NumSrcDE = m_pDataPacketState[in_ModIdx-1].m_NumDataElements;
IFXDataElementState* pSrcDE = m_pDataPacketState[in_ModIdx-1].m_pDataElements;
U32 i;
for( i = 0; i < NumSrcDE; i++ )
{
pDE[i].Generator = pSrcDE[i].Generator;
pDE[i].ChangeCount = pSrcDE[i].ChangeCount;
pDE[i].State = pSrcDE[i].State;
if (pDE[i].bNeedRelease && pDE[i].pValue)
((IFXUnknown*)pDE[i].pValue)->Release();
pDE[i].bNeedRelease = pSrcDE[i].bNeedRelease;
pDE[i].pValue = pSrcDE[i].pValue;
if (pDE[i].bNeedRelease)
((IFXUnknown*)pDE[i].pValue)->AddRef();
}
return IFX_OK;
}
IFXRESULT IFXModifierChainState::BMDPConfigureOutputs( U32 in_ModIdx,
U32 in_uNumOutputs,
U32* pOutputIndices)
{
IFXRESULT result = IFX_OK;
U32 o = in_uNumOutputs;
IFXDataElementState* pDEStates = m_pDataPacketState[in_ModIdx].m_pDataElements;
while( o-- && IFXSUCCESS(result) )
{
// if not all renderables
if( pOutputIndices[o] != INVALID_DATAELEMENT_INDEX)
// this is a performance Hack See in BMDPAddOutputs
// where only DID_RENDERABLE are set to this value
{
// Iterate over all of the outputs one more time and up date
// the generating Modifier and validation state - additionally
// mark any dataelements that are possibly consumed.
pDEStates[pOutputIndices[o]].State = IFXDATAELEMENTSTATE_INVALID;
pDEStates[pOutputIndices[o]].Generator = in_ModIdx;
}
else
{ // if all renderables
U32 NumElements = m_pDataPacketState[in_ModIdx-1].m_NumDataElements;
IFXDataElementState* pSrcDEStates =
m_pDataPacketState[in_ModIdx-1].m_pDataElements;
// iter all of the date elements and make the renderables outputs of this
// modifier chain
U32 i;
for( i = 0; i < NumElements; ++i)
{
if(((m_pDids[i].Flags & IFX_DID_RENDERABLE) || ((m_pDids[i].Flags & IFX_DID_BOUND)))
&& pSrcDEStates[i].State != IFXDATAELEMENTSTATE_CONSUMED)
{
pDEStates[i].State = IFXDATAELEMENTSTATE_INVALID;
pSrcDEStates[i].AddInv(in_ModIdx, i);
pDEStates[i].Generator = in_ModIdx;
}
}
}
}
return result;
}
IFXRESULT IFXModifierChainState::BMDPConsumeElements(U32 in_ModIdx,
U32 in_OutputIdx,
U32 in_UnChangedAttrs)
{
IFXRESULT result = IFX_OK;
// walk thru dependencies that are defined for this element.
if(IFXSUCCESS(result))
{
U32 idx = 0;
IFXDataElementState* pDEState =
m_pDataPacketState[in_ModIdx].m_pDataElements;
// transverse intra dependencies for this output (parallel array)
IFXIntraDependencies* pOutElDeps = &(m_pDepSeq[in_OutputIdx]);
// this is the list of "arrows" that contain element index & attributes
sElementDependency* pElDepsList = pOutElDeps->pDepElementsList;
U32 i;
for( i = 0; i < pOutElDeps->Size; i++ )
{
idx = pElDepsList[i].uEIndex;
// test if any of the dependent sub attributes are being changed
if( (pElDepsList[i].uDepAttr & in_UnChangedAttrs) != pElDepsList[i].uDepAttr )
{
// the Generator is the last modifier to generate this element
// essentially an optmization to short circuit intermediate
// modifiers
// UPD: in case of partial loading of a file - when node with its chain is
// decoded prior its resource and node has some modifiers that request some
// data which are contained in resource MC - output of such modifier can be
// messed up and it can wrongly consume some elements of data packet. This causes failure
// Of following modifiers. Example: Shading Modifier in Node MC and CLOD Modifier
// following it. To prevent such behavior the second condition check
// was added: pDEState[idx].Generator != PROXY_DATAPACKET_INDEX
if( pDEState[idx].Generator != in_ModIdx && pDEState[idx].Generator != PROXY_DATAPACKET_INDEX )
{
// we need to remove all dependencies of a previously generated output
// of a currently generated output in TB written function XYXY(), and then this case should
// always
// this dependency has now been violated remove it
pDEState[idx].State = IFXDATAELEMENTSTATE_CONSUMED;
}
// if not last elements,
// remove this entry from the list.
if( i != (pOutElDeps->Size - 1) )
{
// copy last entry over current entry.
pOutElDeps->pDepElementsList[i]
= pElDepsList[pOutElDeps->Size-1];
// set i to repeat this iteration
i--;
}
pOutElDeps->Size--; // decrement the number
// of dependent elements
}
}
}
return result;
}
IFXRESULT IFXModifierChainState::BMDPScheduleInvalidations( U32 in_ModIdx,
U32 uOutputIdx,
IFXDID* pOutputDid,
IFXDID** in_ppInputs,
U32 uInputCount )
{
IFXRESULT result = IFX_OK;
U32 e = uInputCount, uTmpIndex;
IFXDataPacketState* pPrevState = &(m_pDataPacketState[in_ModIdx-1]);
IFXDataElementState* pPrevDE = pPrevState->m_pDataElements;
while ( e-- && IFXSUCCESS(result) )
{
if ( *(in_ppInputs[e]) == DTS_IFXRenderable )
{ // When a DataTypeSpecifier(DTS) is an input, all dataElements of that type are implied inputs.
IFXASSERT(!(*pOutputDid == *(in_ppInputs[e])));
U32 cnt = pPrevState->m_NumDataElements;
while( cnt-- )
{
if ( m_pDids[cnt].Flags & IFX_DID_RENDERABLE
&& pPrevDE[cnt].State != IFXDATAELEMENTSTATE_CONSUMED )
{
// Add the Invalidation link to the input data element.
IFXASSERT(pPrevDE[cnt].Generator != INVALID_DATAPACKET_INDEX);
m_pDataPacketState[pPrevDE[cnt].Generator].m_pDataElements[cnt]
.AddInv(in_ModIdx, uOutputIdx);
}
}
}
if ( *(in_ppInputs[e]) == DTS_IFXBound )
{ // When a DataTypeSpecifier(DTS) is an input, all dataElements of that type are implied inputs.
IFXASSERT(!(*pOutputDid == *(in_ppInputs[e])));
U32 cnt = pPrevState->m_NumDataElements;
while( cnt-- )
{
if( m_pDids[cnt].Flags & IFX_DID_BOUND
&& pPrevDE[cnt].State != IFXDATAELEMENTSTATE_CONSUMED )
{
// Add the Invalidation link to the input data element.
IFXASSERT(pPrevDE[cnt].Generator != INVALID_DATAPACKET_INDEX);
m_pDataPacketState[pPrevDE[cnt].Generator].m_pDataElements[cnt]
.AddInv(in_ModIdx, uOutputIdx);
}
}
}
else
{
uTmpIndex = GetDidIndex( *(in_ppInputs[e]), in_ModIdx-1 );
IFXDataElementState* pDEState = &(pPrevDE[uTmpIndex]);
IFXASSERT(pDEState->Generator != INVALID_DATAPACKET_INDEX);
// Add the Invalidation link to the input data element.
U32 GenIdx = pDEState->Generator == PROXY_DATAPACKET_INDEX ? 0 : pDEState->Generator;
IFXDataElementState* pGenDE =
&(m_pDataPacketState[GenIdx].m_pDataElements[uTmpIndex]);
pGenDE->AddInv(in_ModIdx, uOutputIdx);
if( *(in_ppInputs[e]) == DID_IFXSimulationTime )
{
m_bNeedTime = TRUE;
}
}
}
return result;
}
IFXRESULT IFXModifierChainState::BMDPSetOutputDeps(
U32 in_ModIdx,
U32 uOutputIdx,
IFXDID* pOutputDid,
IFXDID** ppOutputDependencies,
U32 uNumOutputDeps,
U32* upOutputDependencyAttrs)
{
IFXRESULT result = IFX_OK;
U32 uTmpIndex = 0;
U32 e = uNumOutputDeps;
while( e-- && IFXSUCCESS(result) )
{
// Output cannot be dependent on it's self
IFXASSERT(!(*pOutputDid == *(ppOutputDependencies[e])));
if( *(ppOutputDependencies[e]) == DTS_IFXRenderable)
{ // When a DataTypeSpecifier(DTS) is provided, all dataElements of that type are implied output dependencies.
IFXASSERT(!(*pOutputDid == *(ppOutputDependencies[e])));
U32 cnt = m_pDataPacketState[in_ModIdx].m_NumDataElements;
IFXDataElementState* pDEState = m_pDataPacketState[in_ModIdx].m_pDataElements;
while(cnt--)
{
if( m_pDids[cnt].Flags & IFX_DID_RENDERABLE
&& uOutputIdx != cnt)
{
// say that if the Output dependency is invalidated, or changed
// the dependent output should have the same happen
m_pDepSeq[cnt].AddDependentElement(uOutputIdx,
upOutputDependencyAttrs?upOutputDependencyAttrs[e]:0xFFFFFFFF);
// also add a default invalidation
pDEState[cnt].AddInv(in_ModIdx, uOutputIdx);
}
}
}
if( *(ppOutputDependencies[e]) == DTS_IFXBound)
{ // When a DataTypeSpecifier(DTS) is provided, all dataElements of that type are implied output dependencies.
IFXASSERT(!(*pOutputDid == *(ppOutputDependencies[e])));
U32 cnt = m_pDataPacketState[in_ModIdx].m_NumDataElements;
IFXDataElementState* pDEState = m_pDataPacketState[in_ModIdx].m_pDataElements;
while(cnt--)
{
if( m_pDids[cnt].Flags & IFX_DID_BOUND
&& uOutputIdx != cnt)
{
// say that if the Output dependency is invalidated, or changed
// the dependent output should have the same happen
m_pDepSeq[cnt].AddDependentElement(uOutputIdx,
upOutputDependencyAttrs?upOutputDependencyAttrs[e]:0xFFFFFFFF);
// also add a default invalidation
pDEState[cnt].AddInv(in_ModIdx, uOutputIdx);
}
}
}
else
{
uTmpIndex = GetDidIndex(*(ppOutputDependencies[e]), in_ModIdx);
IFXASSERT(uTmpIndex != INVALID_DATAELEMENT_INDEX);
IFXDataElementState* pDEState =
&(m_pDataPacketState[in_ModIdx].m_pDataElements[uTmpIndex]);
if (IFXSUCCESS(result))
{ // "reversing the order of the link: element x invalidates y, if y depends on x...
// say that if the Output dependency is invalidated, or changed
// the dependent output should have the same happen
m_pDepSeq[uTmpIndex].AddDependentElement(uOutputIdx,
upOutputDependencyAttrs?upOutputDependencyAttrs[e]:0xFFFFFFFF);
// also add a default invalidation
pDEState->AddInv(in_ModIdx, uOutputIdx);
}
}
}
return result;
}
IFXRESULT IFXModifierChainState::BMDPScheduleDefaultInvalidations(U32 in_ModIdx)
{
IFXRESULT result = IFX_OK;
U32 DataElementCount = m_pDataPacketState[in_ModIdx].m_NumDataElements;
IFXDataElementState* pDEState = m_pDataPacketState[in_ModIdx].m_pDataElements;
U32 i;
for( i = 0; i < DataElementCount; i++ )
{
// add this item as an invalidation dep for the last generator of it
U32 GenIdx = pDEState[i].Generator == PROXY_DATAPACKET_INDEX ? 0 : pDEState[i].Generator;
IFXASSERT(GenIdx != INVALID_DATAPACKET_INDEX);
if( GenIdx != in_ModIdx )
{
m_pDataPacketState[GenIdx].m_pDataElements[i].AddInv( in_ModIdx, i );
}
}
return result;
}
U32 IFXModifierChainState::GetDidIndex(const IFXDID& in_Did, U32 in_ModIdx)
{
U32 NumDids = m_pDataPacketState[in_ModIdx].m_NumDataElements;
U32 i;
for( i = 0; i < NumDids; i++ )
{
if( m_pDids[i].Did == in_Did )
{
return i;
}
}
return INVALID_DATAELEMENT_INDEX;
}
U32 IFXModifierChainState::AppendDid(const IFXDID& in_Did , U32 in_ModIdx)
{
if(m_NumDataElements == m_NumAllocatedDataElements)
{
if(!GrowDids(m_NumAllocatedDataElements+16))
{
return INVALID_DATAELEMENT_INDEX;
}
}
m_pDids[m_NumDataElements].Did = in_Did;
m_pDids[m_NumDataElements].Flags = m_pDidRegistry->GetDidFlags(in_Did);
m_NumDataElements++;
m_pDataPacketState[in_ModIdx].m_NumDataElements++;
return m_NumDataElements-1;
}
BOOL IFXModifierChainState::GrowDids(U32 in_Size)
{
IFXDidEntry* pNewDids = new IFXDidEntry[in_Size];
if(!pNewDids)
{
return FALSE;
}
IFXIntraDependencies* pDepSeq = new IFXIntraDependencies[in_Size];
if(!pDepSeq)
{
IFXDELETE_ARRAY(pNewDids);
return FALSE;
}
if(m_pDids)
{
memcpy(pNewDids, m_pDids, sizeof(IFXDidEntry) * m_NumDataElements);
delete[] m_pDids;
}
if(m_pDepSeq)
{
U32 i;
for( i = 0; i < m_NumDataElements; ++i)
{
//m_pDepSeq[i].CopyTo(pDepSeq+i);
pDepSeq[i].CopyTo(&m_pDepSeq[i]);
}
delete[] m_pDepSeq;
}
m_pDids = pNewDids;
m_pDepSeq = pDepSeq;
m_NumAllocatedDataElements = in_Size;
U32 i;
for( i = 0; i < m_NumModifiers; ++i)
{
m_pDataPacketState[i].m_pDids = m_pDids;
}
return TRUE;
}
void IFXModifierChainState::AttachToPrevChain()
{
if(m_pPreviousModifierChain)
{
m_pPreviousModifierChain->AddAppendedModifierChain(m_pModChain);
}
}
void IFXModifierChainState::DetachFromPrevChain()
{
if(m_pPreviousModifierChain)
{
m_pPreviousModifierChain->RemoveAppendedModifierChain(m_pModChain);
}
}
| 25.829787 | 112 | 0.705695 | alemuntoni |
5c35f842d4ad23e42a263ef4847d0ab15c609749 | 293 | cpp | C++ | C++Basics/functions.cpp | gustavoLuuD/theLearinigC | af1eb154585769d31a48268848dae0c67585fe27 | [
"MIT"
] | 1 | 2020-10-22T12:35:42.000Z | 2020-10-22T12:35:42.000Z | C++Basics/functions.cpp | gustavoLuuD/theLearinigC | af1eb154585769d31a48268848dae0c67585fe27 | [
"MIT"
] | null | null | null | C++Basics/functions.cpp | gustavoLuuD/theLearinigC | af1eb154585769d31a48268848dae0c67585fe27 | [
"MIT"
] | null | null | null | #include <iostream>
using namespace std;
string getDefault(){
return "Jhon Doe";
}
void printName(string name = getDefault()){
cout << name << endl;
}
int main(){
string name;
printName();
cout << "What's your name man? ";
getline(cin, name);
printName(name);
return 0;
}
| 14.65 | 43 | 0.634812 | gustavoLuuD |
5c38eff397e9d736350245c0a6dc407b7e6e4ace | 469 | cpp | C++ | sjoonb/0130/10814.cpp | Kwak-JunYoung/154Algoritm-5weeks | fa18ae5f68a1ee722a30a05309214247f7fbfda4 | [
"MIT"
] | 3 | 2022-01-24T03:06:32.000Z | 2022-01-30T08:43:58.000Z | sjoonb/0130/10814.cpp | Kwak-JunYoung/154Algoritm-5weeks | fa18ae5f68a1ee722a30a05309214247f7fbfda4 | [
"MIT"
] | null | null | null | sjoonb/0130/10814.cpp | Kwak-JunYoung/154Algoritm-5weeks | fa18ae5f68a1ee722a30a05309214247f7fbfda4 | [
"MIT"
] | 2 | 2022-01-24T02:27:40.000Z | 2022-01-30T08:57:03.000Z | #include <iostream>
#include <algorithm>
using namespace std;
int N;
pair<int, string> members[100000];
bool cmp(pair<int,string> a, pair<int,string> b)
{
return a.first < b.first;
}
int main() {
cin >> N;
for(int i=0; i<N; ++i) {
int age;
string name;
cin >> age >> name;
members[i] = make_pair(age, name);
}
stable_sort(members, members+N, cmp);
for(int i=0; i<N; ++i)
cout << members[i].first << " " << members[i].second << "\n";
return 0;
}
| 18.038462 | 63 | 0.601279 | Kwak-JunYoung |
5c3a73e5ff4a44e8f7b3bd6e6dd97cd5a8b61e98 | 1,927 | cc | C++ | src/connectivity/wlan/drivers/third_party/intel/iwlwifi/test/sim-mcc-update.cc | fabio-d/fuchsia-stardock | e57f5d1cf015fe2294fc2a5aea704842294318d2 | [
"BSD-2-Clause"
] | 5 | 2022-01-10T20:22:17.000Z | 2022-01-21T20:14:17.000Z | src/connectivity/wlan/drivers/third_party/intel/iwlwifi/test/sim-mcc-update.cc | fabio-d/fuchsia-stardock | e57f5d1cf015fe2294fc2a5aea704842294318d2 | [
"BSD-2-Clause"
] | null | null | null | src/connectivity/wlan/drivers/third_party/intel/iwlwifi/test/sim-mcc-update.cc | fabio-d/fuchsia-stardock | e57f5d1cf015fe2294fc2a5aea704842294318d2 | [
"BSD-2-Clause"
] | null | null | null | // Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/connectivity/wlan/drivers/third_party/intel/iwlwifi/test/sim-mcc-update.h"
#include <string.h>
#include <zircon/assert.h>
#include <iterator>
extern "C" {
#include "src/connectivity/wlan/drivers/third_party/intel/iwlwifi/mvm/mvm.h"
}
#include "src/connectivity/wlan/drivers/third_party/intel/iwlwifi/platform/compiler.h"
namespace wlan::testing {
zx_status_t HandleMccUpdate(struct iwl_host_cmd* cmd, SimMvmResponse* resp) {
auto mcc_cmd = reinterpret_cast<const struct iwl_mcc_update_cmd*>(cmd->data[0]);
__le32 channels[] = {
// actually the channel flags.
0x034b, // Ch1: VALID IBSS ACTIVE GO_CONCURRENT 20MHZ 40MHZ
0x0f4a, // Ch2: BSS ACTIVE GO_CONCURRENT 20MHZ 40MHZ 80MHZ 160MHZ
0x0f43, // Ch3: VALID BSS GO_CONCURRENT 20MHZ 40MHZ 80MHZ 160MHZ
0x0f4b, // Ch4: VALID IBSS ACTIVE GO_CONCURRENT 20MHZ 40MHZ 80MHZ 160MHZ
};
static constexpr size_t n_chan = std::size(channels);
size_t resp_size =
sizeof(struct iwl_mcc_update_resp_v3) + n_chan * sizeof(__le32); // mcc_resp->channels[0]
resp->resize(resp_size);
auto mcc_resp = reinterpret_cast<struct iwl_mcc_update_resp_v3*>(resp->data());
memset(mcc_resp, 0, resp_size);
mcc_resp->status = le32_to_cpu(MCC_RESP_NEW_CHAN_PROFILE);
mcc_resp->mcc = mcc_cmd->mcc;
mcc_resp->source_id = mcc_cmd->source_id;
// The channel list that this country supports. Currently we always return the same one.
// Note that this doesn't match the list in iwl_ext_nvm_channels / iwl_nvm_channels.
// We just return it for easy unit testing.
mcc_resp->n_channels = n_chan; // See enum iwl_nvm_channel_flags below:
memcpy(mcc_resp->channels, channels, sizeof(channels));
return ZX_OK;
}
} // namespace wlan::testing
| 40.145833 | 96 | 0.737935 | fabio-d |